From 45fb43c1f776d227304c72b96e44f3413da0a699 Mon Sep 17 00:00:00 2001 From: Saber Haj Rabiee Date: Fri, 5 Mar 2021 00:10:03 -0800 Subject: [PATCH] removed unnecessary conversions (#180) * removed unnecessary conversions --- src/crypto/ecdsa.rs | 2 +- src/crypto/eddsa.rs | 2 +- src/crypto/mod.rs | 2 +- src/crypto/rsa.rs | 2 +- src/encoding.rs | 8 ++++---- src/header.rs | 6 ++---- src/serialization.rs | 18 +++++++++--------- 7 files changed, 19 insertions(+), 21 deletions(-) diff --git a/src/crypto/ecdsa.rs b/src/crypto/ecdsa.rs index 5425a8b..f1c3626 100644 --- a/src/crypto/ecdsa.rs +++ b/src/crypto/ecdsa.rs @@ -34,5 +34,5 @@ pub fn sign( let signing_key = signature::EcdsaKeyPair::from_pkcs8(alg, key)?; let rng = rand::SystemRandom::new(); let out = signing_key.sign(&rng, message)?; - Ok(b64_encode(out.as_ref())) + Ok(b64_encode(out)) } diff --git a/src/crypto/eddsa.rs b/src/crypto/eddsa.rs index d0b6f9d..7c18534 100644 --- a/src/crypto/eddsa.rs +++ b/src/crypto/eddsa.rs @@ -19,5 +19,5 @@ pub(crate) fn alg_to_ec_verification(alg: Algorithm) -> &'static signature::EdDS pub fn sign(key: &[u8], message: &[u8]) -> Result { let signing_key = signature::Ed25519KeyPair::from_pkcs8_maybe_unchecked(key)?; let out = signing_key.sign(message); - Ok(b64_encode(out.as_ref())) + Ok(b64_encode(out)) } diff --git a/src/crypto/mod.rs b/src/crypto/mod.rs index b30e4de..c2957dc 100644 --- a/src/crypto/mod.rs +++ b/src/crypto/mod.rs @@ -15,7 +15,7 @@ pub(crate) mod rsa; /// Could be in its own file to match RSA/EC but it's 2 lines... pub(crate) fn sign_hmac(alg: hmac::Algorithm, key: &[u8], message: &[u8]) -> String { let digest = hmac::sign(&hmac::Key::new(alg, key), message); - b64_encode(digest.as_ref()) + b64_encode(digest) } /// Take the payload of a JWT, sign it using the algorithm given and return diff --git a/src/crypto/rsa.rs b/src/crypto/rsa.rs index 687ca97..dfdbb25 100644 --- a/src/crypto/rsa.rs +++ b/src/crypto/rsa.rs @@ -45,7 +45,7 @@ pub(crate) fn sign( let rng = rand::SystemRandom::new(); key_pair.sign(alg, &rng, message, &mut signature).map_err(|_| ErrorKind::RsaFailedSigning)?; - Ok(b64_encode(&signature)) + Ok(b64_encode(signature)) } /// Checks that a signature is valid based on the (n, e) RSA pubkey components diff --git a/src/encoding.rs b/src/encoding.rs index 9a4b62c..05df8f1 100644 --- a/src/encoding.rs +++ b/src/encoding.rs @@ -114,10 +114,10 @@ pub fn encode(header: &Header, claims: &T, key: &EncodingKey) -> R if key.family != header.alg.family() { return Err(new_error(ErrorKind::InvalidAlgorithm)); } - let encoded_header = b64_encode_part(&header)?; - let encoded_claims = b64_encode_part(&claims)?; - let message = [encoded_header.as_ref(), encoded_claims.as_ref()].join("."); - let signature = crypto::sign(&*message.as_bytes(), key, header.alg)?; + let encoded_header = b64_encode_part(header)?; + let encoded_claims = b64_encode_part(claims)?; + let message = [encoded_header, encoded_claims].join("."); + let signature = crypto::sign(message.as_bytes(), key, header.alg)?; Ok([message, signature].join(".")) } diff --git a/src/header.rs b/src/header.rs index b45c191..15e93f3 100644 --- a/src/header.rs +++ b/src/header.rs @@ -65,11 +65,9 @@ impl Header { } /// Converts an encoded part into the Header struct if possible - pub(crate) fn from_encoded(encoded_part: &str) -> Result { + pub(crate) fn from_encoded>(encoded_part: T) -> Result { let decoded = b64_decode(encoded_part)?; - let s = String::from_utf8(decoded)?; - - Ok(serde_json::from_str(&s)?) + Ok(serde_json::from_slice(&decoded)?) } } diff --git a/src/serialization.rs b/src/serialization.rs index 23d0883..5d09312 100644 --- a/src/serialization.rs +++ b/src/serialization.rs @@ -1,32 +1,32 @@ use serde::de::DeserializeOwned; use serde::ser::Serialize; use serde_json::map::Map; -use serde_json::{from_str, to_string, Value}; +use serde_json::{from_slice, to_vec, Value}; use crate::errors::Result; -pub(crate) fn b64_encode(input: &[u8]) -> String { +pub(crate) fn b64_encode>(input: T) -> String { base64::encode_config(input, base64::URL_SAFE_NO_PAD) } -pub(crate) fn b64_decode(input: &str) -> Result> { +pub(crate) fn b64_decode>(input: T) -> Result> { base64::decode_config(input, base64::URL_SAFE_NO_PAD).map_err(|e| e.into()) } /// Serializes a struct to JSON and encodes it in base64 pub(crate) fn b64_encode_part(input: &T) -> Result { - let json = to_string(input)?; - Ok(b64_encode(json.as_bytes())) + let json = to_vec(input)?; + Ok(b64_encode(json)) } /// Decodes from base64 and deserializes from JSON to a struct AND a hashmap of Value so we can /// run validation on it -pub(crate) fn from_jwt_part_claims, T: DeserializeOwned>( +pub(crate) fn from_jwt_part_claims, T: DeserializeOwned>( encoded: B, ) -> Result<(T, Map)> { - let s = String::from_utf8(b64_decode(encoded.as_ref())?)?; + let s = b64_decode(encoded)?; - let claims: T = from_str(&s)?; - let validation_map: Map<_, _> = from_str(&s)?; + let claims: T = from_slice(&s)?; + let validation_map: Map<_, _> = from_slice(&s)?; Ok((claims, validation_map)) }