clawdstrike 0.2.5

Security guards and policy engine for AI agent execution
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Package signing and verification using Ed25519 + SHA-256.

use std::fs;
use std::path::Path;

use hush_core::{Hash, Keypair, PublicKey, Signature};
use serde::{Deserialize, Serialize};

use crate::error::{Error, Result};

/// A cryptographic signature over a package archive.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PackageSignature {
    /// SHA-256 hash of the archive bytes.
    pub hash: Hash,
    /// Ed25519 signature over the hash bytes.
    pub signature: Signature,
    /// Optional embedded public key (for distribution).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub public_key: Option<PublicKey>,
}

/// Sign a `.cpkg` archive file.
///
/// Computes the SHA-256 hash of the file bytes, signs the hash with
/// the provided keypair, and returns a [`PackageSignature`].
pub fn sign_package(archive_path: &Path, keypair: &Keypair) -> Result<PackageSignature> {
    let bytes = fs::read(archive_path)?;
    let hash = hush_core::sha256(&bytes);
    let signature = keypair.sign(hash.as_bytes());

    Ok(PackageSignature {
        hash,
        signature,
        public_key: Some(keypair.public_key()),
    })
}

/// Verify a `.cpkg` archive against a [`PackageSignature`] and a public key.
///
/// Returns `true` if the archive hash matches and the signature is valid.
pub fn verify_package(
    archive_path: &Path,
    signature: &PackageSignature,
    public_key: &PublicKey,
) -> Result<bool> {
    let bytes = fs::read(archive_path)?;
    let hash = hush_core::sha256(&bytes);

    if hash != signature.hash {
        return Ok(false);
    }

    Ok(public_key.verify(hash.as_bytes(), &signature.signature))
}

/// Verify using the embedded public key inside the signature.
pub fn verify_package_embedded(archive_path: &Path, signature: &PackageSignature) -> Result<bool> {
    match &signature.public_key {
        Some(pk) => verify_package(archive_path, signature, pk),
        None => Err(Error::PkgError(
            "no public key embedded in signature".to_string(),
        )),
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    fn create_test_archive(tmp: &Path) -> PathBuf {
        let archive = tmp.join("test.cpkg");
        fs::write(&archive, b"fake archive content for signing").unwrap();
        archive
    }

    #[test]
    fn sign_and_verify_roundtrip() {
        let tmp = tempfile::tempdir().unwrap();
        let archive = create_test_archive(tmp.path());
        let keypair = Keypair::generate();

        let sig = sign_package(&archive, &keypair).unwrap();
        assert!(verify_package(&archive, &sig, &keypair.public_key()).unwrap());
    }

    #[test]
    fn verify_embedded_roundtrip() {
        let tmp = tempfile::tempdir().unwrap();
        let archive = create_test_archive(tmp.path());
        let keypair = Keypair::generate();

        let sig = sign_package(&archive, &keypair).unwrap();
        assert!(verify_package_embedded(&archive, &sig).unwrap());
    }

    #[test]
    fn tamper_detection() {
        let tmp = tempfile::tempdir().unwrap();
        let archive = create_test_archive(tmp.path());
        let keypair = Keypair::generate();

        let sig = sign_package(&archive, &keypair).unwrap();

        // Tamper with the archive.
        fs::write(&archive, b"tampered content!!!").unwrap();
        assert!(!verify_package(&archive, &sig, &keypair.public_key()).unwrap());
    }

    #[test]
    fn wrong_key_fails() {
        let tmp = tempfile::tempdir().unwrap();
        let archive = create_test_archive(tmp.path());
        let keypair = Keypair::generate();
        let other_keypair = Keypair::generate();

        let sig = sign_package(&archive, &keypair).unwrap();
        assert!(!verify_package(&archive, &sig, &other_keypair.public_key()).unwrap());
    }

    #[test]
    fn signature_serde_roundtrip() {
        let tmp = tempfile::tempdir().unwrap();
        let archive = create_test_archive(tmp.path());
        let keypair = Keypair::generate();

        let sig = sign_package(&archive, &keypair).unwrap();
        let json = serde_json::to_string(&sig).unwrap();
        let restored: PackageSignature = serde_json::from_str(&json).unwrap();

        assert!(verify_package(&archive, &restored, &keypair.public_key()).unwrap());
    }
}