avoid panic (#54)

Author: raphaelrobert

benches/public.rs

@@ -167,7 +167,7 @@ pub fn criterion_public_benchmark(c: &mut Criterion) {
                         .unwrap();
                     origin_key_store
                         .insert(
-                            public_key_to_truncated_token_key_id(&public_key),
+                            public_key_to_truncated_token_key_id(&public_key).unwrap(),
                             public_key.clone(),
                         )
                         .await;

src/auth/authenticate.rs

@@ -77,7 +77,7 @@ impl TokenChallenge {
         if self.redemption_context.is_empty() {
             None
         } else {
-            Some(self.redemption_context.as_slice().try_into().unwrap())
+            self.redemption_context.as_slice().try_into().ok()
         }
     }
 

src/common/errors.rs

@@ -38,6 +38,13 @@ pub enum CreateKeypairError {
         #[source]
         source: BlindRsaError,
     },
+    #[error("Key serialization failed")]
+    /// Error when serializing the public key fails.
+    KeySerializationFailed {
+        /// Underlying RSA error that triggered the failure.
+        #[source]
+        source: BlindRsaError,
+    },
     #[error("Collision exhausted")]
     /// Error when collision attempts are exhausted
     CollisionExhausted,

src/common/private.rs

@@ -16,23 +16,19 @@ pub trait PrivateCipherSuite:
     + Sync
 {
     /// Returns the token type for the cipher suite.
+    fn token_type() -> TokenType;
+}
+
+impl PrivateCipherSuite for p384::NistP384 {
     fn token_type() -> TokenType {
-        match Self::ID {
-            "P384-SHA384" => TokenType::PrivateP384,
-            "ristretto255-SHA512" => TokenType::PrivateRistretto255,
-            _ => panic!("Unsupported token type"),
-        }
+        TokenType::PrivateP384
     }
 }
 
-impl<C> PrivateCipherSuite for C where
-    C: CipherSuite<Group: Group<Elem: Send + Sync, Scalar: Send + Sync>>
-        + PartialEq
-        + Debug
-        + Clone
-        + Send
-        + Sync
-{
+impl PrivateCipherSuite for voprf::Ristretto255 {
+    fn token_type() -> TokenType {
+        TokenType::PrivateRistretto255
+    }
 }
 
 /// Public key alias

src/generic_tokens/response.rs

@@ -131,8 +131,12 @@ impl GenericBatchTokenResponse {
                     ) => response
                         .issue_token(state)
                         .map(GenericToken::from_private_ristretto)?,
-                    // The mismatch case is handled above.
-                    _ => unreachable!("token type mismatch checked earlier"),
+                    _ => {
+                        return Err(IssueTokenError::UnexpectedTokenResponseType {
+                            expected,
+                            found,
+                        });
+                    }
                 };
                 tokens.push(token);
             }

src/public_tokens/det_rng.rs

@@ -76,11 +76,15 @@ impl TryRng for DeterministicRng {
     type Error = Infallible;
 
     fn try_next_u32(&mut self) -> Result<u32, Infallible> {
-        unimplemented!()
+        let mut buf = [0u8; 4];
+        self.fill_with_data(&mut buf)?;
+        Ok(u32::from_le_bytes(buf))
     }
 
     fn try_next_u64(&mut self) -> Result<u64, Infallible> {
-        unimplemented!()
+        let mut buf = [0u8; 8];
+        self.fill_with_data(&mut buf)?;
+        Ok(u64::from_le_bytes(buf))
     }
 
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Infallible> {

src/public_tokens/mod.rs

@@ -4,6 +4,8 @@ use blind_rsa_signatures::{Deterministic, PSS, Sha384};
 use sha2::{Digest, Sha256};
 use typenum::U256;
 
+use blind_rsa_signatures::Error as BlindRsaError;
+
 use crate::{TokenKeyId, TruncatedTokenKeyId, auth::authorize::Token, truncate_token_key_id};
 
 pub mod request;
@@ -26,13 +28,20 @@ use self::server::serialize_public_key;
 /// Size of the authenticator
 pub const NK: usize = 256;
 
-/// Converts a public key to a token key ID
-pub fn public_key_to_truncated_token_key_id(public_key: &PublicKey) -> TruncatedTokenKeyId {
-    truncate_token_key_id(&public_key_to_token_key_id(public_key))
+/// Converts a public key to a truncated token key ID.
+///
+/// # Errors
+/// Returns an error if the public key cannot be serialized.
+pub fn public_key_to_truncated_token_key_id(
+    public_key: &PublicKey,
+) -> Result<TruncatedTokenKeyId, BlindRsaError> {
+    Ok(truncate_token_key_id(&public_key_to_token_key_id(
+        public_key,
+    )?))
 }
 
-fn public_key_to_token_key_id(public_key: &PublicKey) -> TokenKeyId {
-    let public_key = serialize_public_key(public_key);
+fn public_key_to_token_key_id(public_key: &PublicKey) -> Result<TokenKeyId, BlindRsaError> {
+    let public_key = serialize_public_key(public_key)?;
 
-    Sha256::digest(public_key).into()
+    Ok(Sha256::digest(public_key).into())
 }

src/public_tokens/request.rs

@@ -57,7 +57,11 @@ impl TokenRequest {
             .inspect_err(|e| warn!(error:% = e; "Failed to create challenge digest"))
             .map_err(|source| IssueTokenRequestError::InvalidTokenChallenge { source })?;
 
-        let token_key_id = public_key_to_token_key_id(&public_key);
+        let token_key_id = public_key_to_token_key_id(&public_key).map_err(|source| {
+            IssueTokenRequestError::BlindingError {
+                source: source.into(),
+            }
+        })?;
 
         // nonce = random(32)
         // challenge_digest = SHA256(challenge)

src/public_tokens/server.rs

@@ -85,10 +85,14 @@ pub trait OriginKeyStore {
     async fn remove(&self, truncated_token_key_id: &TruncatedTokenKeyId) -> bool;
 }
 
-/// Serializes a keypair into a DER-encoded PKCS#8 document.
-#[must_use]
-pub fn serialize_public_key(public_key: &PublicKey) -> Vec<u8> {
-    public_key.to_spki().unwrap()
+/// Serializes a public key into a DER-encoded SPKI document.
+///
+/// # Errors
+/// Returns an error if the public key cannot be serialized.
+pub fn serialize_public_key(
+    public_key: &PublicKey,
+) -> Result<Vec<u8>, blind_rsa_signatures::Error> {
+    public_key.to_spki()
 }
 
 const KEYSIZE_IN_BITS: usize = 2048;
@@ -119,8 +123,10 @@ impl IssuerServer {
             let key_pair = KeyPair::generate(rng, KEYSIZE_IN_BITS)
                 .inspect_err(|e| debug!(error:% = e; "Failed to generate RSA keypair"))
                 .map_err(|source| CreateKeypairError::KeyGenerationFailed { source })?;
-            let truncated_token_key_id =
-                truncate_token_key_id(&public_key_to_token_key_id(&key_pair.pk));
+            let truncated_token_key_id = truncate_token_key_id(
+                &public_key_to_token_key_id(&key_pair.pk)
+                    .map_err(|source| CreateKeypairError::KeySerializationFailed { source })?,
+            );
 
             if key_store.get(&truncated_token_key_id).await.is_some() {
                 continue;
@@ -170,11 +176,21 @@ impl IssuerServer {
     }
 
     /// Sets the given keypair.
+    ///
+    /// # Errors
+    /// Returns an error if the public key cannot be serialized.
     #[cfg(feature = "kat")]
-    pub async fn set_keypair<IKS: IssuerKeyStore>(&self, key_store: &IKS, key_pair: KeyPair) {
-        let truncated_token_key_id =
-            truncate_token_key_id(&public_key_to_token_key_id(&key_pair.pk));
+    pub async fn set_keypair<IKS: IssuerKeyStore>(
+        &self,
+        key_store: &IKS,
+        key_pair: KeyPair,
+    ) -> Result<(), CreateKeypairError> {
+        let truncated_token_key_id = truncate_token_key_id(
+            &public_key_to_token_key_id(&key_pair.pk)
+                .map_err(|source| CreateKeypairError::KeySerializationFailed { source })?,
+        );
         key_store.insert(truncated_token_key_id, key_pair).await;
+        Ok(())
     }
 }
 

tests/generic_tokens.rs

@@ -67,7 +67,8 @@ async fn generic_tokens_cycle() {
         .insert(
             privacypass::public_tokens::public_key_to_truncated_token_key_id(
                 &public_token_public_key,
-            ),
+            )
+            .unwrap(),
             public_token_public_key.clone(),
         )
         .await;