spodes_rs/security/
signature.rs1use ecdsa::signature::{Signer, Verifier};
14
15use super::SecuritySuite;
16
17#[derive(Debug, PartialEq, Eq)]
19pub enum SignError {
20 InvalidPrivateKey,
22 InvalidPublicKey,
24 InvalidSignature,
26 VerificationFailed,
28 UnsupportedSuite,
30}
31
32impl std::fmt::Display for SignError {
33 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34 write!(f, "{self:?}")
35 }
36}
37
38impl std::error::Error for SignError {}
39
40fn coord_len(suite: SecuritySuite) -> Option<usize> {
43 match suite {
44 SecuritySuite::Suite1 => Some(32), SecuritySuite::Suite2 => Some(48), SecuritySuite::Suite0 => None,
47 }
48}
49
50fn to_sec1(point: &[u8], coord: usize) -> Vec<u8> {
52 if point.len() == 2 * coord {
53 let mut v = Vec::with_capacity(1 + point.len());
54 v.push(0x04);
55 v.extend_from_slice(point);
56 v
57 } else {
58 point.to_vec()
59 }
60}
61
62pub fn ecdsa_sign(suite: SecuritySuite, private_key: &[u8], message: &[u8]) -> Result<Vec<u8>, SignError> {
66 match suite {
67 SecuritySuite::Suite1 => {
68 use p256::ecdsa::{Signature, SigningKey};
69 let sk = SigningKey::from_slice(private_key).map_err(|_| SignError::InvalidPrivateKey)?;
70 let sig: Signature = sk.sign(message);
71 Ok(sig.to_bytes().to_vec())
72 }
73 SecuritySuite::Suite2 => {
74 use p384::ecdsa::{Signature, SigningKey};
75 let sk = SigningKey::from_slice(private_key).map_err(|_| SignError::InvalidPrivateKey)?;
76 let sig: Signature = sk.sign(message);
77 Ok(sig.to_bytes().to_vec())
78 }
79 SecuritySuite::Suite0 => Err(SignError::UnsupportedSuite),
80 }
81}
82
83pub fn ecdsa_verify(
86 suite: SecuritySuite,
87 public_key: &[u8],
88 message: &[u8],
89 signature: &[u8],
90) -> Result<(), SignError> {
91 let coord = coord_len(suite).ok_or(SignError::UnsupportedSuite)?;
92 let sec1 = to_sec1(public_key, coord);
93 match suite {
94 SecuritySuite::Suite1 => {
95 use p256::ecdsa::{Signature, VerifyingKey};
96 let vk = VerifyingKey::from_sec1_bytes(&sec1).map_err(|_| SignError::InvalidPublicKey)?;
97 let sig = Signature::from_slice(signature).map_err(|_| SignError::InvalidSignature)?;
98 vk.verify(message, &sig).map_err(|_| SignError::VerificationFailed)
99 }
100 SecuritySuite::Suite2 => {
101 use p384::ecdsa::{Signature, VerifyingKey};
102 let vk = VerifyingKey::from_sec1_bytes(&sec1).map_err(|_| SignError::InvalidPublicKey)?;
103 let sig = Signature::from_slice(signature).map_err(|_| SignError::InvalidSignature)?;
104 vk.verify(message, &sig).map_err(|_| SignError::VerificationFailed)
105 }
106 SecuritySuite::Suite0 => Err(SignError::UnsupportedSuite),
107 }
108}
109
110#[cfg(test)]
111mod tests {
112 use super::*;
113
114 #[test]
115 fn p256_sign_verify_round_trip() {
116 let sk = hex(b"418073C239FA6125011DE4D6CD2E645780289F761BB21BFB0835CB5585E8B373");
118 let signing = p256::ecdsa::SigningKey::from_slice(&sk).unwrap();
119 let vk = signing.verifying_key();
120 let pk = vk.to_sec1_point(false).as_bytes().to_vec(); let msg = b"SystemTitle-C||SystemTitle-S||StoC||CtoS";
122 let sig = ecdsa_sign(SecuritySuite::Suite1, &sk, msg).unwrap();
123 assert_eq!(sig.len(), 64);
124 ecdsa_verify(SecuritySuite::Suite1, &pk, msg, &sig).unwrap();
125 ecdsa_verify(SecuritySuite::Suite1, &pk[1..], msg, &sig).unwrap();
127 assert_eq!(ecdsa_verify(SecuritySuite::Suite1, &pk, b"other", &sig), Err(SignError::VerificationFailed));
129 }
130
131 #[test]
132 fn p384_sign_verify_round_trip() {
133 let sk = [0x11u8; 48];
134 let signing = p384::ecdsa::SigningKey::from_slice(&sk).unwrap();
135 let pk = signing.verifying_key().to_sec1_point(false).as_bytes().to_vec();
136 let msg = b"message";
137 let sig = ecdsa_sign(SecuritySuite::Suite2, &sk, msg).unwrap();
138 assert_eq!(sig.len(), 96);
139 ecdsa_verify(SecuritySuite::Suite2, &pk, msg, &sig).unwrap();
140 }
141
142 #[test]
143 fn suite0_has_no_ecdsa() {
144 assert_eq!(ecdsa_sign(SecuritySuite::Suite0, &[0u8; 32], b"x"), Err(SignError::UnsupportedSuite));
145 }
146
147 fn hex(s: &[u8]) -> Vec<u8> {
148 fn nib(c: u8) -> u8 {
149 match c {
150 b'0'..=b'9' => c - b'0',
151 b'a'..=b'f' => c - b'a' + 10,
152 b'A'..=b'F' => c - b'A' + 10,
153 _ => panic!("bad hex"),
154 }
155 }
156 s.chunks(2).map(|p| (nib(p[0]) << 4) | nib(p[1])).collect()
157 }
158}