Skip to main content

pwt/
signing.rs

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
14/// SigningMethod signs and verifies PWT payloads.
15pub 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/// SigningMethodHS256 implements HMAC-SHA256 signing.
22#[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/// SigningMethodEdDSA implements Ed25519 signing.
59#[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/// SigningMethodRS256 implements RSA SHA-256 signing.
100#[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/// SigningMethodRegistry stores available signing methods.
144#[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}