1use 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#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
16pub struct BundleSignature {
17 pub algorithm: String,
19 pub public_key: String,
21 pub signature: String,
23}
24
25#[derive(Clone)]
27pub struct KeyPair {
28 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
39pub 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
47pub 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
60pub(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
71pub(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
84pub 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}