1use crate::errors::SigningMethodError;
2use crate::key::Key;
3use ed25519_dalek::{Signer as EdSigner, Verifier as EdVerifier};
4use hmac::{Hmac, Mac};
5use rsa::pkcs1::{DecodeRsaPrivateKey, DecodeRsaPublicKey};
6use rsa::pkcs1v15::{SigningKey, VerifyingKey};
7use rsa::pkcs8::{DecodePrivateKey, DecodePublicKey};
8use rsa::signature::SignatureEncoding;
9use rsa::{RsaPrivateKey, RsaPublicKey};
10use sha2::Sha256;
11use std::collections::HashMap;
12use std::sync::{Arc, OnceLock, RwLock};
13
14pub trait SigningMethod: Send + Sync {
16 fn alg(&self) -> &'static str;
17 fn sign(&self, data: &[u8], key: &Key) -> Result<Vec<u8>, SigningMethodError>;
18 fn verify(&self, data: &[u8], signature: &[u8], key: &Key) -> Result<(), SigningMethodError>;
19}
20
21#[derive(Debug, Default)]
23pub struct SigningMethodHS256;
24
25impl SigningMethodHS256 {
26 pub fn new() -> Self {
27 Self
28 }
29}
30
31impl SigningMethod for SigningMethodHS256 {
32 fn alg(&self) -> &'static str {
33 "HS256"
34 }
35
36 fn sign(&self, data: &[u8], key: &Key) -> Result<Vec<u8>, SigningMethodError> {
37 let secret = match key {
38 Key::Bytes(bytes) => bytes.as_slice(),
39 _ => return Err(SigningMethodError::InvalidKeyType),
40 };
41
42 let mut mac = Hmac::<Sha256>::new_from_slice(secret)
43 .map_err(|err| SigningMethodError::CryptoError(err.to_string()))?;
44 mac.update(data);
45 Ok(mac.finalize().into_bytes().to_vec())
46 }
47
48 fn verify(&self, data: &[u8], signature: &[u8], key: &Key) -> Result<(), SigningMethodError> {
49 let expected = self.sign(data, key)?;
50 if expected.as_slice() == signature {
51 Ok(())
52 } else {
53 Err(SigningMethodError::InvalidSignature)
54 }
55 }
56}
57
58#[derive(Debug, Default)]
60pub struct SigningMethodEdDSA;
61
62impl SigningMethodEdDSA {
63 pub fn new() -> Self {
64 Self
65 }
66}
67
68impl SigningMethod for SigningMethodEdDSA {
69 fn alg(&self) -> &'static str {
70 "EdDSA"
71 }
72
73 fn sign(&self, data: &[u8], key: &Key) -> Result<Vec<u8>, SigningMethodError> {
74 let signing_key = match key {
75 Key::Ed25519Private(key) => key.clone(),
76 Key::Bytes(bytes) => parse_ed25519_private(bytes)?,
77 _ => return Err(SigningMethodError::InvalidKeyType),
78 };
79
80 let signature = signing_key.sign(data);
81 Ok(signature.to_bytes().to_vec())
82 }
83
84 fn verify(&self, data: &[u8], signature: &[u8], key: &Key) -> Result<(), SigningMethodError> {
85 let verifying_key = match key {
86 Key::Ed25519Public(key) => *key,
87 Key::Bytes(bytes) => parse_ed25519_public(bytes)?,
88 _ => return Err(SigningMethodError::InvalidKeyType),
89 };
90
91 let signature = ed25519_dalek::Signature::from_slice(signature)
92 .map_err(|err| SigningMethodError::CryptoError(err.to_string()))?;
93 verifying_key
94 .verify(data, &signature)
95 .map_err(|_| SigningMethodError::InvalidSignature)
96 }
97}
98
99#[derive(Debug, Default)]
101pub struct SigningMethodRS256;
102
103impl SigningMethodRS256 {
104 pub fn new() -> Self {
105 Self
106 }
107}
108
109impl SigningMethod for SigningMethodRS256 {
110 fn alg(&self) -> &'static str {
111 "RS256"
112 }
113
114 fn sign(&self, data: &[u8], key: &Key) -> Result<Vec<u8>, SigningMethodError> {
115 let private_key = match key {
116 Key::RsaPrivate(key) => key.clone(),
117 Key::Bytes(bytes) => parse_rsa_private(bytes)?,
118 _ => return Err(SigningMethodError::InvalidKeyType),
119 };
120
121 let signing_key = SigningKey::<Sha256>::new(private_key);
122 let signature = signing_key.sign(data);
123 Ok(signature.to_vec())
124 }
125
126 fn verify(&self, data: &[u8], signature: &[u8], key: &Key) -> Result<(), SigningMethodError> {
127 let public_key = match key {
128 Key::RsaPublic(key) => key.clone(),
129 Key::Bytes(bytes) => parse_rsa_public(bytes)?,
130 _ => return Err(SigningMethodError::InvalidKeyType),
131 };
132
133 let verifying_key = VerifyingKey::<Sha256>::new(public_key);
134 let signature = rsa::pkcs1v15::Signature::try_from(signature)
135 .map_err(|err| SigningMethodError::CryptoError(err.to_string()))?;
136
137 verifying_key
138 .verify(data, &signature)
139 .map_err(|_| SigningMethodError::InvalidSignature)
140 }
141}
142
143#[derive(Debug)]
145pub struct SigningMethodRegistry;
146
147impl SigningMethodRegistry {
148 pub fn register(method: Arc<dyn SigningMethod>) {
149 let store = registry();
150 let mut guard = store.write().expect("signing method registry lock");
151 guard.insert(method.alg().to_string(), method);
152 }
153
154 pub fn method(alg: &str) -> Option<Arc<dyn SigningMethod>> {
155 let store = registry();
156 let guard = store.read().expect("signing method registry lock");
157 guard.get(alg).cloned()
158 }
159}
160
161fn registry() -> &'static RwLock<HashMap<String, Arc<dyn SigningMethod>>> {
162 static REGISTRY: OnceLock<RwLock<HashMap<String, Arc<dyn SigningMethod>>>> = OnceLock::new();
163 REGISTRY.get_or_init(|| {
164 let mut methods: HashMap<String, Arc<dyn SigningMethod>> = HashMap::new();
165 methods.insert("HS256".to_string(), Arc::new(SigningMethodHS256::new()));
166 methods.insert("EdDSA".to_string(), Arc::new(SigningMethodEdDSA::new()));
167 methods.insert("RS256".to_string(), Arc::new(SigningMethodRS256::new()));
168 RwLock::new(methods)
169 })
170}
171
172fn parse_ed25519_private(bytes: &[u8]) -> Result<ed25519_dalek::SigningKey, SigningMethodError> {
173 match bytes.len() {
174 32 => {
175 let key_bytes: [u8; 32] = bytes.try_into().map_err(|_| {
176 SigningMethodError::KeyParseError("invalid ed25519 key".to_string())
177 })?;
178 Ok(ed25519_dalek::SigningKey::from_bytes(&key_bytes))
179 }
180 64 => {
181 let key_bytes: [u8; 64] = bytes.try_into().map_err(|_| {
182 SigningMethodError::KeyParseError("invalid ed25519 key".to_string())
183 })?;
184 ed25519_dalek::SigningKey::from_keypair_bytes(&key_bytes)
185 .map_err(|err| SigningMethodError::KeyParseError(err.to_string()))
186 }
187 _ => Err(SigningMethodError::KeyParseError(
188 "ed25519 private key must be 32 or 64 bytes".to_string(),
189 )),
190 }
191}
192
193fn parse_ed25519_public(bytes: &[u8]) -> Result<ed25519_dalek::VerifyingKey, SigningMethodError> {
194 match bytes.len() {
195 32 => {
196 let key_bytes: [u8; 32] = bytes.try_into().map_err(|_| {
197 SigningMethodError::KeyParseError("invalid ed25519 key".to_string())
198 })?;
199 ed25519_dalek::VerifyingKey::from_bytes(&key_bytes)
200 .map_err(|err| SigningMethodError::KeyParseError(err.to_string()))
201 }
202 64 => {
203 let key_bytes: [u8; 64] = bytes.try_into().map_err(|_| {
204 SigningMethodError::KeyParseError("invalid ed25519 key".to_string())
205 })?;
206 let signing_key = ed25519_dalek::SigningKey::from_keypair_bytes(&key_bytes)
207 .map_err(|err| SigningMethodError::KeyParseError(err.to_string()))?;
208 Ok(signing_key.verifying_key())
209 }
210 _ => Err(SigningMethodError::KeyParseError(
211 "ed25519 public key must be 32 or 64 bytes".to_string(),
212 )),
213 }
214}
215
216fn parse_rsa_private(bytes: &[u8]) -> Result<RsaPrivateKey, SigningMethodError> {
217 if let Ok(key) = RsaPrivateKey::from_pkcs1_der(bytes) {
218 return Ok(key);
219 }
220
221 if let Ok(key) = RsaPrivateKey::from_pkcs8_der(bytes) {
222 return Ok(key);
223 }
224
225 Err(SigningMethodError::KeyParseError(
226 "failed to parse rsa private key".to_string(),
227 ))
228}
229
230fn parse_rsa_public(bytes: &[u8]) -> Result<RsaPublicKey, SigningMethodError> {
231 if let Ok(key) = RsaPublicKey::from_pkcs1_der(bytes) {
232 return Ok(key);
233 }
234
235 if let Ok(key) = RsaPublicKey::from_public_key_der(bytes) {
236 return Ok(key);
237 }
238
239 Err(SigningMethodError::KeyParseError(
240 "failed to parse rsa public key".to_string(),
241 ))
242}