mirror of
https://github.com/BitskiCo/jwk-rs
synced 2025-05-03 12:59:41 +00:00
264 lines
8.9 KiB
Rust
264 lines
8.9 KiB
Rust
use super::*;
|
|
|
|
use std::str::FromStr;
|
|
|
|
#[test]
|
|
fn deserialize_es256() {
|
|
// Generated using https://mkjwk.org
|
|
let jwk_str = r#"{
|
|
"kty": "EC",
|
|
"d": "ZoKQ9j4dhIBlMRVrv-QG8P_T9sutv3_95eio9MtpgKg",
|
|
"use": "enc",
|
|
"crv": "P-256",
|
|
"kid": "a key",
|
|
"x": "QOMHmv96tVlJv-uNqprnDSKIj5AiLTXKRomXYnav0N0",
|
|
"y": "TjYZoHnctatEE6NCrKmXQdJJPnNzZEX8nBmZde3AY4k",
|
|
"alg": "ES256"
|
|
}"#;
|
|
let jwk = JsonWebKey::from_str(jwk_str).unwrap();
|
|
assert_eq!(
|
|
jwk,
|
|
JsonWebKey {
|
|
key_type: box KeyType::EC {
|
|
// The parameters were decoded using a 10-liner Rust script.
|
|
params: Curve::P256 {
|
|
d: Some(
|
|
[
|
|
102, 130, 144, 246, 62, 29, 132, 128, 101, 49, 21, 107, 191, 228, 6,
|
|
240, 255, 211, 246, 203, 173, 191, 127, 253, 229, 232, 168, 244, 203,
|
|
105, 128, 168
|
|
]
|
|
.into()
|
|
),
|
|
x: [
|
|
64, 227, 7, 154, 255, 122, 181, 89, 73, 191, 235, 141, 170, 154, 231, 13,
|
|
34, 136, 143, 144, 34, 45, 53, 202, 70, 137, 151, 98, 118, 175, 208, 221
|
|
]
|
|
.into(),
|
|
y: [
|
|
78, 54, 25, 160, 121, 220, 181, 171, 68, 19, 163, 66, 172, 169, 151, 65,
|
|
210, 73, 62, 115, 115, 100, 69, 252, 156, 25, 153, 117, 237, 192, 99, 137
|
|
]
|
|
.into(),
|
|
},
|
|
},
|
|
algorithm: Some(JsonWebAlgorithm::ES256),
|
|
key_id: Some("a key".into()),
|
|
key_ops: KeyOps::empty(),
|
|
key_use: Some(KeyUse::Encryption),
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_es256() {
|
|
let jwk = JsonWebKey {
|
|
key_type: box KeyType::EC {
|
|
params: Curve::P256 {
|
|
d: None,
|
|
x: [1u8; 32].into(),
|
|
y: [2u8; 32].into(),
|
|
},
|
|
},
|
|
key_id: None,
|
|
algorithm: None,
|
|
key_ops: KeyOps::empty(),
|
|
key_use: None,
|
|
};
|
|
assert_eq!(
|
|
jwk.to_string(),
|
|
r#"{"kty":"EC","crv":"P-256","x":"AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=","y":"AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI="}"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn deserialize_hs256() {
|
|
let jwk_str = r#"{
|
|
"kty": "oct",
|
|
"k": "tAON6Q",
|
|
"alg": "HS256",
|
|
"key_ops": ["verify", "sign"]
|
|
}"#;
|
|
let jwk = JsonWebKey::from_str(jwk_str).unwrap();
|
|
assert_eq!(
|
|
jwk,
|
|
JsonWebKey {
|
|
key_type: box KeyType::Symmetric {
|
|
// The parameters were decoded using a 10-liner Rust script.
|
|
key: vec![180, 3, 141, 233].into(),
|
|
},
|
|
algorithm: Some(JsonWebAlgorithm::HS256),
|
|
key_id: None,
|
|
key_ops: KeyOps::SIGN | KeyOps::VERIFY,
|
|
key_use: None,
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_hs256() {
|
|
let jwk = JsonWebKey {
|
|
key_type: box KeyType::Symmetric {
|
|
key: vec![42; 16].into(),
|
|
},
|
|
key_id: None,
|
|
algorithm: None,
|
|
key_ops: KeyOps::empty(),
|
|
key_use: None,
|
|
};
|
|
assert_eq!(
|
|
jwk.to_string(),
|
|
r#"{"kty":"oct","k":"KioqKioqKioqKioqKioqKg=="}"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn deserialize_rs256() {
|
|
let jwk_str = r#"{
|
|
"p": "_LSip5o4eaGf25uvwyUq9ubRtKemrCaoCxumoj63Au0",
|
|
"kty": "RSA",
|
|
"q": "l20iLpicEW3uja0Zg2xP6DjZa86bD4IQ3wFXCcKCf1c",
|
|
"d": "Xo0VAHtfV38HwJbAI6X-Fu7vuyoQjnuiSlQhcSjxn0BZfLP_DKxdJ2ANgTGVE0x243YHqhWRHLobbmDcnUuMOQ",
|
|
"e": "AQAB",
|
|
"qi": "2mzAaSr7I1D3vDtOhbWKS9-9ELRHKbAHz4dhn4DSCBo",
|
|
"dp": "-kyswxeVEpyM6wdU2xRobu-HDMn145PSZFY6AX_e460",
|
|
"alg": "RS256",
|
|
"dq": "OqMWE3khJlatg8s-D_hHUSOCfg65WN4C7ng0XiEmK20",
|
|
"n": "lXpGmBoIxj56TpptApaac6V19_7WWbq0a14a5UHBBlkc54NwIUa2X4p9OeK2sy6rLQ_1g1AcSwfsVUy8MP-Riw"
|
|
}"#;
|
|
let jwk = JsonWebKey::from_str(jwk_str).unwrap();
|
|
assert_eq!(
|
|
jwk,
|
|
JsonWebKey {
|
|
key_type: box KeyType::RSA {
|
|
public: RsaPublic {
|
|
e: PublicExponent,
|
|
n: vec![
|
|
149, 122, 70, 152, 26, 8, 198, 62, 122, 78, 154, 109, 2, 150, 154, 115,
|
|
165, 117, 247, 254, 214, 89, 186, 180, 107, 94, 26, 229, 65, 193, 6, 89,
|
|
28, 231, 131, 112, 33, 70, 182, 95, 138, 125, 57, 226, 182, 179, 46, 171,
|
|
45, 15, 245, 131, 80, 28, 75, 7, 236, 85, 76, 188, 48, 255, 145, 139
|
|
]
|
|
.into()
|
|
},
|
|
private: Some(RsaPrivate {
|
|
d: vec![
|
|
94, 141, 21, 0, 123, 95, 87, 127, 7, 192, 150, 192, 35, 165, 254, 22, 238,
|
|
239, 187, 42, 16, 142, 123, 162, 74, 84, 33, 113, 40, 241, 159, 64, 89,
|
|
124, 179, 255, 12, 172, 93, 39, 96, 13, 129, 49, 149, 19, 76, 118, 227,
|
|
118, 7, 170, 21, 145, 28, 186, 27, 110, 96, 220, 157, 75, 140, 57
|
|
]
|
|
.into(),
|
|
p: Some(
|
|
vec![
|
|
252, 180, 162, 167, 154, 56, 121, 161, 159, 219, 155, 175, 195, 37, 42,
|
|
246, 230, 209, 180, 167, 166, 172, 38, 168, 11, 27, 166, 162, 62, 183,
|
|
2, 237
|
|
]
|
|
.into()
|
|
),
|
|
q: Some(
|
|
vec![
|
|
151, 109, 34, 46, 152, 156, 17, 109, 238, 141, 173, 25, 131, 108, 79,
|
|
232, 56, 217, 107, 206, 155, 15, 130, 16, 223, 1, 87, 9, 194, 130, 127,
|
|
87
|
|
]
|
|
.into()
|
|
),
|
|
dp: Some(
|
|
vec![
|
|
250, 76, 172, 195, 23, 149, 18, 156, 140, 235, 7, 84, 219, 20, 104,
|
|
110, 239, 135, 12, 201, 245, 227, 147, 210, 100, 86, 58, 1, 127, 222,
|
|
227, 173
|
|
]
|
|
.into()
|
|
),
|
|
dq: Some(
|
|
vec![
|
|
58, 163, 22, 19, 121, 33, 38, 86, 173, 131, 203, 62, 15, 248, 71, 81,
|
|
35, 130, 126, 14, 185, 88, 222, 2, 238, 120, 52, 94, 33, 38, 43, 109
|
|
]
|
|
.into()
|
|
),
|
|
qi: Some(
|
|
vec![
|
|
218, 108, 192, 105, 42, 251, 35, 80, 247, 188, 59, 78, 133, 181, 138,
|
|
75, 223, 189, 16, 180, 71, 41, 176, 7, 207, 135, 97, 159, 128, 210, 8,
|
|
26
|
|
]
|
|
.into()
|
|
)
|
|
})
|
|
},
|
|
algorithm: Some(JsonWebAlgorithm::RS256),
|
|
key_id: None,
|
|
key_ops: KeyOps::empty(),
|
|
key_use: None,
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_rs256() {
|
|
let jwk = JsonWebKey {
|
|
key_type: box KeyType::RSA {
|
|
public: RsaPublic {
|
|
e: PublicExponent,
|
|
n: vec![105, 183, 62].into(),
|
|
},
|
|
private: Some(RsaPrivate {
|
|
d: vec![105, 183, 63].into(),
|
|
p: None,
|
|
q: None,
|
|
dp: None,
|
|
dq: None,
|
|
qi: None,
|
|
}),
|
|
},
|
|
key_id: None,
|
|
algorithm: None,
|
|
key_ops: KeyOps::empty(),
|
|
key_use: None,
|
|
};
|
|
assert_eq!(
|
|
jwk.to_string(),
|
|
r#"{"kty":"RSA","e":"AQAB","n":"abc-","d":"abc_"}"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn mismatched_algorithm() {
|
|
macro_rules! assert_mismatched_alg {
|
|
($jwk_str:literal) => {
|
|
match JsonWebKey::from_str($jwk_str) {
|
|
Err(Error::MismatchedAlgorithm) => {}
|
|
v => panic!("expected MismatchedAlgorithm, got {:?}", v),
|
|
}
|
|
};
|
|
}
|
|
|
|
assert_mismatched_alg!(r#"{ "kty": "oct", "k": "tAON6Q", "alg": "ES256" }"#);
|
|
assert_mismatched_alg!(r#"{ "kty": "oct", "k": "tAON6Q", "alg": "RS256" }"#);
|
|
|
|
assert_mismatched_alg!(
|
|
r#"{
|
|
"kty": "EC",
|
|
"d": "ZoKQ9j4dhIBlMRVrv-QG8P_T9sutv3_95eio9MtpgKg",
|
|
"crv": "P-256",
|
|
"x": "QOMHmv96tVlJv-uNqprnDSKIj5AiLTXKRomXYnav0N0",
|
|
"y": "TjYZoHnctatEE6NCrKmXQdJJPnNzZEX8nBmZde3AY4k",
|
|
"alg": "RS256"
|
|
}"#
|
|
);
|
|
assert_mismatched_alg!(
|
|
r#"{
|
|
"kty": "EC",
|
|
"d": "ZoKQ9j4dhIBlMRVrv-QG8P_T9sutv3_95eio9MtpgKg",
|
|
"crv": "P-256",
|
|
"x": "QOMHmv96tVlJv-uNqprnDSKIj5AiLTXKRomXYnav0N0",
|
|
"y": "TjYZoHnctatEE6NCrKmXQdJJPnNzZEX8nBmZde3AY4k",
|
|
"alg": "HS256"
|
|
}"#
|
|
);
|
|
}
|