Skip to main content

graphrt_bundle/
sign.rs

1//! Ed25519 signatures over the bundle manifest.
2//!
3//! The manifest records the SHA-256 of every file, so signing the exact
4//! `bundle.json` bytes covers the whole bundle.
5
6use std::fmt;
7
8use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};
9use serde::{Deserialize, Serialize};
10
11use crate::error::BundleError;
12use crate::{hex, unhex};
13
14/// Contents of `bundle.sig`.
15#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
16pub struct BundleSignature {
17    /// Always `ed25519`.
18    pub algorithm: String,
19    /// Hex-encoded 32-byte public key.
20    pub public_key: String,
21    /// Hex-encoded 64-byte signature over the exact `bundle.json` bytes.
22    pub signature: String,
23}
24
25/// A generated signing key pair, hex encoded.
26#[derive(Clone)]
27pub struct KeyPair {
28    /// 32-byte secret seed. Keep it out of source control.
29    pub secret_key: String,
30    pub public_key: String,
31}
32
33impl fmt::Debug for KeyPair {
34    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
35        f.debug_struct("KeyPair").field("secret_key", &"<redacted>").field("public_key", &self.public_key).finish()
36    }
37}
38
39/// Generate a new Ed25519 key pair from the operating system's random source.
40pub fn generate_keypair() -> Result<KeyPair, BundleError> {
41    let mut seed = [0u8; 32];
42    getrandom::fill(&mut seed).map_err(|e| BundleError::Signature(format!("no random source: {e}")))?;
43    let signing = SigningKey::from_bytes(&seed);
44    Ok(KeyPair { secret_key: hex(&seed), public_key: hex(signing.verifying_key().as_bytes()) })
45}
46
47/// Parse a hex public key.
48pub fn parse_public_key(text: &str) -> Result<VerifyingKey, BundleError> {
49    let bytes = unhex(text).ok_or_else(|| BundleError::Signature("public key is not hex".into()))?;
50    let array: [u8; 32] = bytes.try_into().map_err(|_| BundleError::Signature("public key must be 32 bytes".into()))?;
51    VerifyingKey::from_bytes(&array).map_err(|e| BundleError::Signature(format!("invalid public key: {e}")))
52}
53
54pub(crate) fn parse_secret_key(text: &str) -> Result<SigningKey, BundleError> {
55    let bytes = unhex(text).ok_or_else(|| BundleError::Signature("secret key is not hex".into()))?;
56    let array: [u8; 32] = bytes.try_into().map_err(|_| BundleError::Signature("secret key must be 32 bytes".into()))?;
57    Ok(SigningKey::from_bytes(&array))
58}
59
60/// Sign manifest bytes.
61pub(crate) fn sign_manifest(manifest: &[u8], secret_key: &str) -> Result<BundleSignature, BundleError> {
62    let key = parse_secret_key(secret_key)?;
63    let signature = key.sign(manifest);
64    Ok(BundleSignature {
65        algorithm: "ed25519".into(),
66        public_key: hex(key.verifying_key().as_bytes()),
67        signature: hex(&signature.to_bytes()),
68    })
69}
70
71/// Verify `sig` over manifest bytes; returns the signer's public key (hex).
72pub(crate) fn verify_manifest(manifest: &[u8], sig: &BundleSignature) -> Result<String, BundleError> {
73    if sig.algorithm != "ed25519" {
74        return Err(BundleError::Signature(format!("unsupported algorithm `{}`", sig.algorithm)));
75    }
76    let key = parse_public_key(&sig.public_key)?;
77    let bytes = unhex(&sig.signature).ok_or_else(|| BundleError::Signature("signature is not hex".into()))?;
78    let array: [u8; 64] = bytes.try_into().map_err(|_| BundleError::Signature("signature must be 64 bytes".into()))?;
79    key.verify(manifest, &Signature::from_bytes(&array))
80        .map_err(|_| BundleError::Signature("signature does not match the manifest".into()))?;
81    Ok(hex(key.as_bytes()))
82}
83
84/// Return a copy of `bundle` (archive bytes) signed with `secret_key` (hex seed).
85/// Any previous signature is replaced. The bundle is fully verified first.
86pub fn sign_bundle(bundle: &[u8], secret_key: &str) -> Result<Vec<u8>, BundleError> {
87    let opened = crate::Bundle::open(bundle, &crate::OpenOptions::default())?;
88    let signature = sign_manifest(opened.manifest_bytes(), secret_key)?;
89    let sig_json = serde_json::to_vec_pretty(&signature).map_err(|e| BundleError::Signature(e.to_string()))?;
90    let first: [(&str, &[u8]); 2] =
91        [(crate::MANIFEST_PATH, opened.manifest_bytes()), (crate::SIGNATURE_PATH, sig_json.as_slice())];
92    crate::archive::write_zip(&first, opened.raw_files())
93}
94
95#[cfg(test)]
96mod tests {
97    use super::*;
98
99    #[test]
100    fn sign_and_verify() {
101        let pair = generate_keypair().unwrap();
102        let sig = sign_manifest(b"manifest", &pair.secret_key).unwrap();
103        assert_eq!(verify_manifest(b"manifest", &sig).unwrap(), pair.public_key);
104        assert!(verify_manifest(b"tampered", &sig).is_err());
105        assert!(!format!("{pair:?}").contains(&pair.secret_key));
106    }
107}