hoike_sign/
ecdsa_bridge.rs1pub const ECDSA_WITH_SHA256_OID: &str = "1.2.840.10045.4.3.2";
17
18#[derive(Clone)]
21pub struct EcdsaP256Signer {
22 inner: p256::ecdsa::SigningKey,
23}
24
25impl EcdsaP256Signer {
26 pub fn new(inner: p256::ecdsa::SigningKey) -> Self {
27 Self { inner }
28 }
29
30 pub fn verifying_key(&self) -> p256::ecdsa::VerifyingKey {
31 *self.inner.verifying_key()
32 }
33}
34
35impl From<p256::ecdsa::SigningKey> for EcdsaP256Signer {
36 fn from(inner: p256::ecdsa::SigningKey) -> Self {
37 Self::new(inner)
38 }
39}
40
41#[derive(Clone)]
44pub struct EcdsaSignatureBytes {
45 der_bytes: Vec<u8>,
46}
47
48impl From<EcdsaSignatureBytes> for Vec<u8> {
49 fn from(sig: EcdsaSignatureBytes) -> Vec<u8> {
50 sig.der_bytes
51 }
52}
53
54impl TryFrom<&[u8]> for EcdsaSignatureBytes {
55 type Error = signature::Error;
56
57 fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
58 p256::ecdsa::DerSignature::from_bytes(bytes).map_err(|_| signature::Error::new())?;
60 Ok(EcdsaSignatureBytes {
61 der_bytes: bytes.to_vec(),
62 })
63 }
64}
65
66impl AsRef<[u8]> for EcdsaSignatureBytes {
67 fn as_ref(&self) -> &[u8] {
68 &self.der_bytes
69 }
70}
71
72impl signature::Signer<EcdsaSignatureBytes> for EcdsaP256Signer {
75 fn try_sign(&self, msg: &[u8]) -> Result<EcdsaSignatureBytes, signature::Error> {
76 use p256::ecdsa::signature::Signer as SignerV3;
78 let sig: p256::ecdsa::Signature =
79 SignerV3::try_sign(&self.inner, msg).map_err(|_| signature::Error::new())?;
80 let der = sig.to_der();
81 Ok(EcdsaSignatureBytes {
82 der_bytes: der.as_bytes().to_vec(),
83 })
84 }
85}
86
87impl signature::SignatureEncoding for EcdsaSignatureBytes {
90 type Repr = Vec<u8>;
91}
92
93impl spki::SignatureBitStringEncoding for EcdsaSignatureBytes {
96 fn to_bitstring(&self) -> der::Result<der::asn1::BitString> {
97 der::asn1::BitString::from_bytes(&self.der_bytes)
98 }
99}
100
101impl spki::DynSignatureAlgorithmIdentifier for EcdsaP256Signer {
104 fn signature_algorithm_identifier(&self) -> spki::Result<spki::AlgorithmIdentifierOwned> {
105 Ok(spki::AlgorithmIdentifierOwned {
106 oid: const_oid::ObjectIdentifier::new_unwrap(ECDSA_WITH_SHA256_OID),
107 parameters: None,
108 })
109 }
110}
111
112#[cfg(test)]
113mod tests {
114 use super::*;
115 use p256::ecdsa::signature::Verifier;
116 use signature::Signer as SignerV2;
117
118 #[test]
119 fn signs_and_verifies_with_p256_key() {
120 let key = p256::ecdsa::SigningKey::from_bytes((&[7u8; 32]).into()).unwrap();
121 let signer = EcdsaP256Signer::new(key.clone());
122 let sig = SignerV2::sign(&signer, b"bridge message");
123 key.verifying_key()
124 .verify(
125 b"bridge message",
126 &p256::ecdsa::DerSignature::from_bytes(sig.as_ref()).unwrap(),
127 )
128 .unwrap();
129 }
130
131 #[test]
132 fn algorithm_identifier_is_ecdsa_with_sha256() {
133 use spki::DynSignatureAlgorithmIdentifier;
134 let signer =
135 EcdsaP256Signer::new(p256::ecdsa::SigningKey::from_bytes((&[1u8; 32]).into()).unwrap());
136 let alg = signer.signature_algorithm_identifier().unwrap();
137 assert_eq!(alg.oid.to_string(), ECDSA_WITH_SHA256_OID);
138 assert!(alg.parameters.is_none());
139 }
140
141 #[test]
142 fn bitstring_wraps_der_bytes() {
143 use signature::Signer;
144 use spki::SignatureBitStringEncoding;
145 let signer =
146 EcdsaP256Signer::new(p256::ecdsa::SigningKey::from_bytes((&[2u8; 32]).into()).unwrap());
147 let sig = signer.sign(b"test");
148 let bits = sig.to_bitstring().unwrap();
149 assert_eq!(bits.raw_bytes(), sig.as_ref());
150 assert_eq!(sig.as_ref()[0], 0x30);
152 }
153
154 #[test]
155 fn rejects_non_der_input() {
156 assert!(EcdsaSignatureBytes::try_from(b"not der".as_slice()).is_err());
157 }
158}