From 67682300773b063176cf46a79095559a54e9118e Mon Sep 17 00:00:00 2001 From: Jasper Bryant-Greene Date: Wed, 9 Jan 2019 09:18:49 +0800 Subject: [PATCH 1/5] Added ES256/ES384/ES512 Algorithm stubs --- src/crypto.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/src/crypto.rs b/src/crypto.rs index 207897b..edc63a9 100644 --- a/src/crypto.rs +++ b/src/crypto.rs @@ -18,6 +18,15 @@ pub enum Algorithm { /// HMAC using SHA-512 HS512, + /// ECDSA using SHA-256 + ES256, + + /// ECDSA using SHA-384 + ES384, + + /// ECDSA using SHA-512 + ES512, + /// RSASSA-PKCS1-v1_5 using SHA-256 RS256, /// RSASSA-PKCS1-v1_5 using SHA-384 @@ -39,6 +48,9 @@ impl FromStr for Algorithm { "HS256" => Ok(Algorithm::HS256), "HS384" => Ok(Algorithm::HS384), "HS512" => Ok(Algorithm::HS512), + "ES256" => Ok(Algorithm::ES256), + "ES384" => Ok(Algorithm::ES384), + "ES512" => Ok(Algorithm::ES512), "RS256" => Ok(Algorithm::HS256), "RS384" => Ok(Algorithm::HS384), "RS512" => Ok(Algorithm::HS512), @@ -55,6 +67,11 @@ fn sign_hmac(alg: &'static digest::Algorithm, key: &[u8], signing_input: &str) - Ok(base64::encode_config::(&digest, base64::URL_SAFE_NO_PAD)) } +/// The actual ECDSA signing + encoding +fn sign_ecdsa(alg: Algorithm, key: &[u8], signing_input: &str) -> Result { + unimplemented!() +} + /// The actual RSA signing + encoding /// Taken from Ring doc https://briansmith.org/rustdoc/ring/signature/index.html fn sign_rsa(alg: Algorithm, key: &[u8], signing_input: &str) -> Result { @@ -90,6 +107,10 @@ pub fn sign(signing_input: &str, key: &[u8], algorithm: Algorithm) -> Result sign_hmac(&digest::SHA384, key, signing_input), Algorithm::HS512 => sign_hmac(&digest::SHA512, key, signing_input), + Algorithm::ES256 | Algorithm::ES384 | Algorithm::ES512 => { + sign_ecdsa(algorithm, key, signing_input) + } + Algorithm::RS256 | Algorithm::RS384 | Algorithm::RS512 => { sign_rsa(algorithm, key, signing_input) } @@ -133,6 +154,9 @@ pub fn verify( let signed = sign(signing_input, key, algorithm)?; Ok(verify_slices_are_equal(signature.as_ref(), signed.as_ref()).is_ok()) } + Algorithm::ES256 | Algorithm::ES384 | Algorithm::ES512 => { + unimplemented!() + } Algorithm::RS256 => { verify_rsa(&signature::RSA_PKCS1_2048_8192_SHA256, signature, signing_input, key) } From 9883fab729635c924e441217309f43412c4c87fc Mon Sep 17 00:00:00 2001 From: Jasper Bryant-Greene Date: Wed, 9 Jan 2019 09:46:06 +0800 Subject: [PATCH 2/5] implemented ECDSA signing, updated ring to 0.14 alpha --- Cargo.toml | 2 +- src/crypto.rs | 28 ++++++++++++---------------- src/errors.rs | 22 ++++++++++++++++++++++ 3 files changed, 35 insertions(+), 17 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c9c2e31..4321e56 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ keywords = ["jwt", "web", "api", "token", "json"] serde_json = "1.0" serde_derive = "1.0" serde = "1.0" -ring = { version = "0.13", features = ["rsa_signing", "dev_urandom_fallback"] } +ring = "0.14.0-alpha4" base64 = "0.9" untrusted = "0.6" chrono = "0.4" diff --git a/src/crypto.rs b/src/crypto.rs index edc63a9..bfbd2f4 100644 --- a/src/crypto.rs +++ b/src/crypto.rs @@ -24,9 +24,6 @@ pub enum Algorithm { /// ECDSA using SHA-384 ES384, - /// ECDSA using SHA-512 - ES512, - /// RSASSA-PKCS1-v1_5 using SHA-256 RS256, /// RSASSA-PKCS1-v1_5 using SHA-384 @@ -50,7 +47,6 @@ impl FromStr for Algorithm { "HS512" => Ok(Algorithm::HS512), "ES256" => Ok(Algorithm::ES256), "ES384" => Ok(Algorithm::ES384), - "ES512" => Ok(Algorithm::ES512), "RS256" => Ok(Algorithm::HS256), "RS384" => Ok(Algorithm::HS384), "RS512" => Ok(Algorithm::HS512), @@ -68,8 +64,11 @@ fn sign_hmac(alg: &'static digest::Algorithm, key: &[u8], signing_input: &str) - } /// The actual ECDSA signing + encoding -fn sign_ecdsa(alg: Algorithm, key: &[u8], signing_input: &str) -> Result { - unimplemented!() +fn sign_ecdsa(alg: &'static signature::EcdsaSigningAlgorithm, key: &[u8], signing_input: &str) -> Result { + let signing_key = signature::EcdsaKeyPair::from_pkcs8(alg, untrusted::Input::from(key))?; + let rng = rand::SystemRandom::new(); + let sig = signing_key.sign(&rng, untrusted::Input::from(signing_input.as_bytes()))?; + Ok(base64::encode_config(&sig, base64::URL_SAFE_NO_PAD)) } /// The actual RSA signing + encoding @@ -83,14 +82,12 @@ fn sign_rsa(alg: Algorithm, key: &[u8], signing_input: &str) -> Result { }; let key_pair = Arc::new( - signature::RSAKeyPair::from_der(untrusted::Input::from(key)) + signature::RsaKeyPair::from_der(untrusted::Input::from(key)) .map_err(|_| ErrorKind::InvalidRsaKey)?, ); - let mut signing_state = - signature::RSASigningState::new(key_pair).map_err(|_| ErrorKind::InvalidRsaKey)?; - let mut signature = vec![0; signing_state.key_pair().public_modulus_len()]; + let mut signature = vec![0; key_pair.public_modulus_len()]; let rng = rand::SystemRandom::new(); - signing_state + key_pair .sign(ring_alg, &rng, signing_input.as_bytes(), &mut signature) .map_err(|_| ErrorKind::InvalidRsaKey)?; @@ -107,9 +104,8 @@ pub fn sign(signing_input: &str, key: &[u8], algorithm: Algorithm) -> Result sign_hmac(&digest::SHA384, key, signing_input), Algorithm::HS512 => sign_hmac(&digest::SHA512, key, signing_input), - Algorithm::ES256 | Algorithm::ES384 | Algorithm::ES512 => { - sign_ecdsa(algorithm, key, signing_input) - } + Algorithm::ES256 => sign_ecdsa(&signature::ECDSA_P256_SHA256_FIXED_SIGNING, key, signing_input), + Algorithm::ES384 => sign_ecdsa(&signature::ECDSA_P384_SHA384_FIXED_SIGNING, key, signing_input), Algorithm::RS256 | Algorithm::RS384 | Algorithm::RS512 => { sign_rsa(algorithm, key, signing_input) @@ -119,7 +115,7 @@ pub fn sign(signing_input: &str, key: &[u8], algorithm: Algorithm) -> Result { + Algorithm::ES256 | Algorithm::ES384 => { unimplemented!() } Algorithm::RS256 => { diff --git a/src/errors.rs b/src/errors.rs index d450b9a..5147548 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -36,6 +36,8 @@ pub enum ErrorKind { InvalidToken, /// When the signature doesn't match InvalidSignature, + /// When the secret given is not a valid ECDSA key + InvalidEcdsaKey, /// When the secret given is not a valid RSA key InvalidRsaKey, /// When the algorithm from string doesn't match the one passed to `from_str` @@ -64,6 +66,8 @@ pub enum ErrorKind { Json(serde_json::Error), /// Some of the text was invalid UTF-8 Utf8(::std::string::FromUtf8Error), + /// Something unspecified went wrong with crypto + Crypto(::ring::error::Unspecified), /// Hints that destructuring should not be exhaustive. /// @@ -79,6 +83,7 @@ impl StdError for Error { match *self.0 { ErrorKind::InvalidToken => "invalid token", ErrorKind::InvalidSignature => "invalid signature", + ErrorKind::InvalidEcdsaKey => "invalid ECDSA key", ErrorKind::InvalidRsaKey => "invalid RSA key", ErrorKind::ExpiredSignature => "expired signature", ErrorKind::InvalidIssuer => "invalid issuer", @@ -90,6 +95,7 @@ impl StdError for Error { ErrorKind::Base64(ref err) => err.description(), ErrorKind::Json(ref err) => err.description(), ErrorKind::Utf8(ref err) => err.description(), + ErrorKind::Crypto(ref err) => err.description(), _ => unreachable!(), } } @@ -98,6 +104,7 @@ impl StdError for Error { match *self.0 { ErrorKind::InvalidToken => None, ErrorKind::InvalidSignature => None, + ErrorKind::InvalidEcdsaKey => None, ErrorKind::InvalidRsaKey => None, ErrorKind::ExpiredSignature => None, ErrorKind::InvalidIssuer => None, @@ -109,6 +116,7 @@ impl StdError for Error { ErrorKind::Base64(ref err) => Some(err), ErrorKind::Json(ref err) => Some(err), ErrorKind::Utf8(ref err) => Some(err), + ErrorKind::Crypto(ref err) => Some(err), _ => unreachable!(), } } @@ -119,6 +127,7 @@ impl fmt::Display for Error { match *self.0 { ErrorKind::InvalidToken => write!(f, "invalid token"), ErrorKind::InvalidSignature => write!(f, "invalid signature"), + ErrorKind::InvalidEcdsaKey => write!(f, "invalid ECDSA key"), ErrorKind::InvalidRsaKey => write!(f, "invalid RSA key"), ErrorKind::ExpiredSignature => write!(f, "expired signature"), ErrorKind::InvalidIssuer => write!(f, "invalid issuer"), @@ -130,6 +139,7 @@ impl fmt::Display for Error { ErrorKind::Base64(ref err) => write!(f, "base64 error: {}", err), ErrorKind::Json(ref err) => write!(f, "JSON error: {}", err), ErrorKind::Utf8(ref err) => write!(f, "UTF-8 error: {}", err), + ErrorKind::Crypto(ref err) => write!(f, "Crypto error: {}", err), _ => unreachable!(), } } @@ -153,6 +163,18 @@ impl From<::std::string::FromUtf8Error> for Error { } } +impl From<::ring::error::Unspecified> for Error { + fn from(err: ::ring::error::Unspecified) -> Error { + new_error(ErrorKind::Crypto(err)) + } +} + +impl From<::ring::error::KeyRejected> for Error { + fn from(_err: ::ring::error::KeyRejected) -> Error { + new_error(ErrorKind::InvalidEcdsaKey) + } +} + impl From for Error { fn from(kind: ErrorKind) -> Error { new_error(kind) From 1f6ae28566c09a8e595740182446979004255803 Mon Sep 17 00:00:00 2001 From: Jasper Bryant-Greene Date: Fri, 18 Jan 2019 10:34:12 +0800 Subject: [PATCH 3/5] ring -> 0.14.1, updated other deps --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 4321e56..142f489 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ keywords = ["jwt", "web", "api", "token", "json"] serde_json = "1.0" serde_derive = "1.0" serde = "1.0" -ring = "0.14.0-alpha4" +ring = "0.14.1" base64 = "0.9" untrusted = "0.6" chrono = "0.4" From e10b049d9a6f10cf7070346c5940a0f65239d8fe Mon Sep 17 00:00:00 2001 From: Jasper Bryant-Greene Date: Fri, 1 Feb 2019 12:11:20 +0800 Subject: [PATCH 4/5] implemented verification of ECDSA signatures and added tests --- src/crypto.rs | 36 +++++++++++++++------------------- tests/ecdsa.rs | 38 ++++++++++++++++++++++++++++++++++++ tests/private_ecdsa_key.pk8 | Bin 0 -> 138 bytes tests/public_ecdsa_key.pk8 | 1 + 4 files changed, 55 insertions(+), 20 deletions(-) create mode 100644 tests/ecdsa.rs create mode 100644 tests/private_ecdsa_key.pk8 create mode 100644 tests/public_ecdsa_key.pk8 diff --git a/src/crypto.rs b/src/crypto.rs index bfbd2f4..96f2774 100644 --- a/src/crypto.rs +++ b/src/crypto.rs @@ -73,14 +73,7 @@ fn sign_ecdsa(alg: &'static signature::EcdsaSigningAlgorithm, key: &[u8], signin /// The actual RSA signing + encoding /// Taken from Ring doc https://briansmith.org/rustdoc/ring/signature/index.html -fn sign_rsa(alg: Algorithm, key: &[u8], signing_input: &str) -> Result { - let ring_alg = match alg { - Algorithm::RS256 => &signature::RSA_PKCS1_SHA256, - Algorithm::RS384 => &signature::RSA_PKCS1_SHA384, - Algorithm::RS512 => &signature::RSA_PKCS1_SHA512, - _ => unreachable!(), - }; - +fn sign_rsa(alg: &'static signature::RsaEncoding, key: &[u8], signing_input: &str) -> Result { let key_pair = Arc::new( signature::RsaKeyPair::from_der(untrusted::Input::from(key)) .map_err(|_| ErrorKind::InvalidRsaKey)?, @@ -88,7 +81,7 @@ fn sign_rsa(alg: Algorithm, key: &[u8], signing_input: &str) -> Result { let mut signature = vec![0; key_pair.public_modulus_len()]; let rng = rand::SystemRandom::new(); key_pair - .sign(ring_alg, &rng, signing_input.as_bytes(), &mut signature) + .sign(alg, &rng, signing_input.as_bytes(), &mut signature) .map_err(|_| ErrorKind::InvalidRsaKey)?; Ok(base64::encode_config::<[u8]>(&signature, base64::URL_SAFE_NO_PAD)) @@ -107,15 +100,15 @@ pub fn sign(signing_input: &str, key: &[u8], algorithm: Algorithm) -> Result sign_ecdsa(&signature::ECDSA_P256_SHA256_FIXED_SIGNING, key, signing_input), Algorithm::ES384 => sign_ecdsa(&signature::ECDSA_P384_SHA384_FIXED_SIGNING, key, signing_input), - Algorithm::RS256 | Algorithm::RS384 | Algorithm::RS512 => { - sign_rsa(algorithm, key, signing_input) - } + Algorithm::RS256 => sign_rsa(&signature::RSA_PKCS1_SHA256, key, signing_input), + Algorithm::RS384 => sign_rsa(&signature::RSA_PKCS1_SHA384, key, signing_input), + Algorithm::RS512 => sign_rsa(&signature::RSA_PKCS1_SHA512, key, signing_input), } } -/// See Ring RSA docs for more details -fn verify_rsa( - alg: &signature::RsaParameters, +/// See Ring docs for more details +fn verify_ring( + alg: &dyn signature::VerificationAlgorithm, signature: &str, signing_input: &str, key: &[u8], @@ -150,17 +143,20 @@ pub fn verify( let signed = sign(signing_input, key, algorithm)?; Ok(verify_slices_are_equal(signature.as_ref(), signed.as_ref()).is_ok()) } - Algorithm::ES256 | Algorithm::ES384 => { - unimplemented!() + Algorithm::ES256 => { + verify_ring(&signature::ECDSA_P256_SHA256_FIXED, signature, signing_input, key) + } + Algorithm::ES384 => { + verify_ring(&signature::ECDSA_P384_SHA384_FIXED, signature, signing_input, key) } Algorithm::RS256 => { - verify_rsa(&signature::RSA_PKCS1_2048_8192_SHA256, signature, signing_input, key) + verify_ring(&signature::RSA_PKCS1_2048_8192_SHA256, signature, signing_input, key) } Algorithm::RS384 => { - verify_rsa(&signature::RSA_PKCS1_2048_8192_SHA384, signature, signing_input, key) + verify_ring(&signature::RSA_PKCS1_2048_8192_SHA384, signature, signing_input, key) } Algorithm::RS512 => { - verify_rsa(&signature::RSA_PKCS1_2048_8192_SHA512, signature, signing_input, key) + verify_ring(&signature::RSA_PKCS1_2048_8192_SHA512, signature, signing_input, key) } } } diff --git a/tests/ecdsa.rs b/tests/ecdsa.rs new file mode 100644 index 0000000..72f13df --- /dev/null +++ b/tests/ecdsa.rs @@ -0,0 +1,38 @@ +extern crate jsonwebtoken; +#[macro_use] +extern crate serde_derive; +extern crate chrono; + +use chrono::Utc; +use jsonwebtoken::{decode, encode, sign, verify, Algorithm, Header, Validation}; + +#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)] +struct Claims { + sub: String, + company: String, + exp: i64, +} + +#[test] +fn round_trip_sign_verification() { + let privkey = include_bytes!("private_ecdsa_key.pk8"); + let encrypted = sign("hello world", privkey, Algorithm::ES256).unwrap(); + let pubkey = include_bytes!("public_ecdsa_key.pk8"); + let is_valid = verify(&encrypted, "hello world", pubkey, Algorithm::ES256).unwrap(); + assert!(is_valid); +} + +#[test] +fn round_trip_claim() { + let my_claims = Claims { + sub: "b@b.com".to_string(), + company: "ACME".to_string(), + exp: Utc::now().timestamp() + 10000, + }; + let privkey = include_bytes!("private_ecdsa_key.pk8"); + let token = encode(&Header::new(Algorithm::ES256), &my_claims, privkey).unwrap(); + let pubkey = include_bytes!("public_ecdsa_key.pk8"); + let token_data = decode::(&token, pubkey, &Validation::new(Algorithm::ES256)).unwrap(); + assert_eq!(my_claims, token_data.claims); + assert!(token_data.header.kid.is_none()); +} diff --git a/tests/private_ecdsa_key.pk8 b/tests/private_ecdsa_key.pk8 new file mode 100644 index 0000000000000000000000000000000000000000..f838b0488205eedcefee26544541bd2d28bcf577 GIT binary patch literal 138 zcmV;50CoQ`frkPC05B5<2P%e0&OHJF1_&yKNX|V20S5$aFlzz<0R$jfF<%I2V`HYU z+NrtS>^clW)qFbm9wP6XJ)T?+$GRa3(zTyfu9smFU literal 0 HcmV?d00001 diff --git a/tests/public_ecdsa_key.pk8 b/tests/public_ecdsa_key.pk8 new file mode 100644 index 0000000..188c9d8 --- /dev/null +++ b/tests/public_ecdsa_key.pk8 @@ -0,0 +1 @@ +ò@O%I_!IAM Ly5+\Iw[ a ԫxG2GU \ No newline at end of file From 8a495d3a4e9feeec648b8c532238eb2015428fab Mon Sep 17 00:00:00 2001 From: Jasper Bryant-Greene Date: Fri, 1 Feb 2019 12:12:29 +0800 Subject: [PATCH 5/5] updated ring dependency --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 142f489..6ec7278 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ keywords = ["jwt", "web", "api", "token", "json"] serde_json = "1.0" serde_derive = "1.0" serde = "1.0" -ring = "0.14.1" +ring = "0.14.4" base64 = "0.9" untrusted = "0.6" chrono = "0.4"