Skip to main content

spodes_rs/security/
signature.rs

1//! Digital-signature HLS mechanisms.
2//!
3//! Mechanism 7 (ECDSA) is provided here over the security-suite curves — P-256
4//! for suite 1 and P-384 for suite 2 — hashing with SHA-256 / SHA-384 as the
5//! suites specify (IEC 62056-5-3 Table 32). Mechanism 10 (GOST 34.10-2018-256)
6//! is in [`super::gost3410`].
7//!
8//! During the HLS handshake the message is `SystemTitle-a ‖ SystemTitle-b ‖
9//! challenge_a ‖ challenge_b`; the signer uses its private key and the verifier
10//! the peer's public key. Public keys may be given either as a raw `x ‖ y`
11//! point or in SEC1 form (with the `0x04` prefix).
12
13use ecdsa::signature::{Signer, Verifier};
14
15use super::SecuritySuite;
16
17/// Errors from signing or verifying.
18#[derive(Debug, PartialEq, Eq)]
19pub enum SignError {
20    /// The private key was malformed for the curve.
21    InvalidPrivateKey,
22    /// The public key was malformed for the curve.
23    InvalidPublicKey,
24    /// The signature was malformed for the curve.
25    InvalidSignature,
26    /// The signature did not verify.
27    VerificationFailed,
28    /// The mechanism/suite combination is not a signature scheme handled here.
29    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
40/// Coordinate length (octets) of the suite's curve, or `None` if the suite has
41/// no ECDSA curve.
42fn coord_len(suite: SecuritySuite) -> Option<usize> {
43    match suite {
44        SecuritySuite::Suite1 => Some(32), // P-256
45        SecuritySuite::Suite2 => Some(48), // P-384
46        SecuritySuite::Suite0 => None,
47    }
48}
49
50/// Normalizes a public key to SEC1 uncompressed form (`0x04 ‖ x ‖ y`).
51fn 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
62/// Signs `message` with an ECDSA private key (raw scalar) on the suite's curve,
63/// returning the fixed-size `r ‖ s` signature (64 octets for P-256, 96 for
64/// P-384). Signing is deterministic (RFC 6979).
65pub 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
83/// Verifies an ECDSA `r ‖ s` signature over `message` with a public key
84/// (raw `x ‖ y` or SEC1) on the suite's curve.
85pub 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        // Green Book Annex C client signing key.
117        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(); // 0x04 ‖ x ‖ y
121        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        // A raw x‖y key (no 0x04) also verifies.
126        ecdsa_verify(SecuritySuite::Suite1, &pk[1..], msg, &sig).unwrap();
127        // Tampered message fails.
128        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}