clean up errors, constrain context

keks · keks · commit 1c6523122b42 · 2025-10-02T15:51:59.000+02:00
diff --git a/ecdsa/src/impl_signature_trait.rs b/ecdsa/src/impl_signature_trait.rs
@@ -48,7 +48,7 @@ pub mod signers {
                 ) -> Result<(), arrayref::SignError> {
                     let result = libcrux_p256::$sign_fn(
                         signature,
-                        payload.len().try_into().map_err(|_| arrayref::SignError::InvalidPayloadLength)?,
+                        payload.len().try_into().map_err(|_| arrayref::SignError::InvalidArgument)?,
                         payload,
                         signing_key.declassify_ref(),
                         &nonce.0,
@@ -58,8 +58,9 @@ pub mod signers {
                     }
                     Ok(())
                 }
-                #[inline(always)]
+
                 /// Verify a signature using a provided verification key.
+                #[inline(always)]
                 fn verify(
                     payload: &[u8],
                     verification_key: &[u8; VERIFICATION_KEY_LEN],
@@ -77,6 +78,7 @@ pub mod signers {
                     }
                     Ok(())
                 }
+
                 fn keygen_derand(
                     signing_key: &mut [U8; SIGNING_KEY_LEN],
                     verification_key: &mut [u8; VERIFICATION_KEY_LEN],
@@ -94,6 +96,7 @@ pub mod signers {
 
                 }
             }
+
             libcrux_traits::impl_signature_slice_trait!(
                 Signer<$name> => SIGNING_KEY_LEN, VERIFICATION_KEY_LEN, SIG_LEN, RAND_KEYGEN_LEN, &Nonce, nonce);
 
@@ -106,13 +109,11 @@ pub mod signers {
                 RAND_KEYGEN_LEN,
                 &'a Nonce
             );
-
         };
     }
 
+    /// [`libcrux_traits::signature`] APIs for p256.
     pub mod p256 {
-        //! [`libcrux_traits::signature`] APIs for p256.
-
         use super::*;
 
         pub use crate::p256::Nonce;
diff --git a/ed25519/src/impl_signature_trait.rs b/ed25519/src/impl_signature_trait.rs
@@ -26,7 +26,7 @@ pub mod signers {
                 payload
                     .len()
                     .try_into()
-                    .map_err(|_| SignError::InvalidPayloadLength)?,
+                    .map_err(|_| SignError::InvalidArgument)?,
                 payload,
             );
 
diff --git a/libcrux-ml-dsa/src/impl_signature_trait.rs b/libcrux-ml-dsa/src/impl_signature_trait.rs
@@ -10,36 +10,93 @@ pub mod signers {
     ///
     /// Can be implemented using the convenience macro [`impl_context`].
     pub trait Context {
+        /// This is a buffer of valid size. The validity trait is private, so the users can't
+        /// flag more sizes as valid and circumvent the type safety we established here.
+        #[allow(private_bounds)]
+        type Buf: ValidContextBuf;
+
         /// Return the context.
-        fn context() -> &'static [u8];
+        fn context() -> &'static Self::Buf;
     }
 
+    trait ValidContextBuf {}
+
+    // Implement ValidContextBuf for all sizes 0..=255
+    macro_rules! define_valid_buf {
+        () => {
+            define_valid_buf!(0);
+            define_valid_buf!(1);
+            define_valid_buf!(2, 0);
+            define_valid_buf!(2, 1);
+            define_valid_buf!(2, 2);
+            define_valid_buf!(2, 3);
+            define_valid_buf!(2, 4);
+            define_valid_buf!(2, 5, 0);
+            define_valid_buf!(2, 5, 1);
+            define_valid_buf!(2, 5, 2);
+            define_valid_buf!(2, 5, 3);
+            define_valid_buf!(2, 5, 4);
+            define_valid_buf!(2, 5, 5);
+        };
+        ($num:expr) => {
+            define_valid_buf!($num, 0);
+            define_valid_buf!($num, 1);
+            define_valid_buf!($num, 2);
+            define_valid_buf!($num, 3);
+            define_valid_buf!($num, 4);
+            define_valid_buf!($num, 5);
+            define_valid_buf!($num, 6);
+            define_valid_buf!($num, 7);
+            define_valid_buf!($num, 8);
+            define_valid_buf!($num, 9);
+        };
+        ($num1:expr,$num2:expr) => {
+            define_valid_buf!($num1, $num2, 0);
+            define_valid_buf!($num1, $num2, 1);
+            define_valid_buf!($num1, $num2, 2);
+            define_valid_buf!($num1, $num2, 3);
+            define_valid_buf!($num1, $num2, 4);
+            define_valid_buf!($num1, $num2, 5);
+            define_valid_buf!($num1, $num2, 6);
+            define_valid_buf!($num1, $num2, 7);
+            define_valid_buf!($num1, $num2, 8);
+            define_valid_buf!($num1, $num2, 9);
+        };
+        ($num1:expr,$num2:expr,$num3:expr) => {
+            impl ValidContextBuf for [u8; $num1 * 100 + $num2 * 10 + $num3] {}
+        };
+    }
+
+    define_valid_buf!();
+
     #[macro_export]
     /// A convenience macro for implementing the [`Context`] trait.
-    /// The `$context` must be provided as a `&'static [u8]`.
+    /// The `$context` must be provided as a `&'static [u8; $len]`.
     ///
     /// Usage:
     /// ```rust
     /// use libcrux_ml_dsa::signers::{Context, impl_context};
-    /// impl_context!(AppContext, b"context");
+    /// impl_context!(AppContext, b"context", 7);
     /// ```
     macro_rules! impl_context {
-        ($name:ident, $context:literal) => {
+        ($name:ident, $context:literal,$len:expr) => {
             impl_context!(
                 $name,
                 $context,
+                $len,
                 concat!(
                     "An ML-DSA signing context that contains \"",
                     stringify!($context),
                     "\"."
                 )
             )
         };
-        ($name:ident, $context:literal, $doc:expr) => {
+        ($name:ident, $context:literal, $len:expr, $doc:expr) => {
             #[doc = $doc]
             pub struct $name;
             impl Context for $name {
-                fn context() -> &'static [u8] {
+                type Buf = [u8; $len];
+                fn context() -> &'static [u8; $len] {
                     $context
                 }
             }
@@ -68,7 +125,7 @@ pub mod signers {
                 ///
                 /// It is the responsibility of the caller to ensure  that the `randomness` argument is actually
                 /// random.
-                impl<T: Context>
+                impl<const N: usize, T: Context<Buf= [u8;N]>>
                     arrayref::Sign<
                         SIGNING_KEY_LEN,
                         VERIFICATION_KEY_LEN,
@@ -91,7 +148,11 @@ pub mod signers {
                             randomness.declassify(),
                             signature
                         )
-                        .map_err(|_| arrayref::SignError::LibraryError)
+                        .map_err(|err| match err {
+                            crate::types::SigningError::RejectionSamplingError=> arrayref::SignError::InvalidRandomness,
+                            crate::types::SigningError::ContextTooLongError=> arrayref::SignError::InvalidArgument,
+
+                        })
                     }
                     /// Verify a signature using a provided verification key and context.
                     fn verify(
@@ -105,7 +166,13 @@ pub mod signers {
                             T::context(),
                             signature,
                         )
-                        .map_err(|_| arrayref::VerifyError::LibraryError)
+                        .map_err(|err| match err {
+                            crate::types::VerificationError::MalformedHintError=>arrayref::VerifyError::InvalidSignature,
+                            crate::types::VerificationError::SignerResponseExceedsBoundError=>arrayref::VerifyError::InvalidSignature,
+                            crate::types::VerificationError::CommitmentHashesDontMatchError=>arrayref::VerifyError::InvalidSignature,
+                            crate::types::VerificationError::VerificationContextTooLongError=>arrayref::VerifyError::LibraryError,
+
+                        })
                     }
 
                     fn keygen_derand(
diff --git a/traits/src/signature/arrayref.rs b/traits/src/signature/arrayref.rs
@@ -118,16 +118,21 @@ pub trait Sign<
 /// input parameters to internal library errors.
 #[derive(Debug, PartialEq, Eq)]
 pub enum SignError {
-    /// The length of the provided payload is invalid for this signature algorithm.
-    InvalidPayloadLength,
+    /// The the provided argument is invalid for this signature algorithm.
+    /// It could be that the payload is too long.
+    InvalidArgument,
+    /// The random value provided is not suitable. For rejection sampling, try again with new
+    /// randomness.
+    InvalidRandomness,
     /// An internal library error occurred during the signing operation.
     LibraryError,
 }
 
 impl core::fmt::Display for SignError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let text = match self {
-            SignError::InvalidPayloadLength => "the length of the provided payload is invalid",
+            SignError::InvalidArgument => "a provided argument is invalid",
+            SignError::InvalidRandomness => "the provided randomness is unsuitable",
             SignError::LibraryError => "indicates a library error",
         };
 
@@ -143,8 +148,6 @@ impl core::fmt::Display for SignError {
 pub enum VerifyError {
     /// The provided signature is cryptographically invalid or does not match the payload.
     InvalidSignature,
-    /// The length of the provided signature buffer is invalid for this algorithm.
-    InvalidSignatureBufferLength,
     /// The length of the provided payload is invalid for this signature algorithm.
     InvalidPayloadLength,
     /// An internal library error occurred during verification.
@@ -155,9 +158,6 @@ impl core::fmt::Display for VerifyError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let text = match self {
             VerifyError::InvalidSignature => "the provided signature is invalid",
-            VerifyError::InvalidSignatureBufferLength => {
-                "the length of the provided signature buffer is invalid"
-            }
             VerifyError::InvalidPayloadLength => "the length of the provided payload is invalid",
             VerifyError::LibraryError => "indicates a library error",
         };
diff --git a/traits/src/signature/slice.rs b/traits/src/signature/slice.rs
@@ -103,8 +103,12 @@ pub enum SignError {
     InvalidSigningKeyLength,
     /// The length of the provided signature output buffer is invalid.
     InvalidSignatureBufferLength,
-    /// The length of the provided payload is invalid for this signature algorithm.
-    InvalidPayloadLength,
+    /// The the provided argument is invalid for this signature algorithm.
+    /// It could be that the payload is too long.
+    InvalidArgument,
+    /// The random value provided is not suitable. For rejection sampling, try again with new
+    /// randomness.
+    InvalidRandomness,
     /// An internal library error occurred during the signing operation.
     LibraryError,
 }
@@ -118,7 +122,8 @@ impl core::fmt::Display for SignError {
             SignError::InvalidSignatureBufferLength => {
                 "the length of the provided signature buffer is invalid"
             }
-            SignError::InvalidPayloadLength => "the length of the provided payload is invalid",
+            SignError::InvalidArgument => "a provided argument is invalid",
+            SignError::InvalidRandomness => "the provided randomness is unsuitable",
             SignError::LibraryError => "indicates a library error",
         };
 
@@ -206,7 +211,8 @@ mod error_in_core {
 impl From<super::arrayref::SignError> for SignError {
     fn from(e: super::arrayref::SignError) -> Self {
         match e {
-            super::arrayref::SignError::InvalidPayloadLength => Self::InvalidPayloadLength,
+            super::arrayref::SignError::InvalidArgument => Self::InvalidArgument,
+            super::arrayref::SignError::InvalidRandomness => Self::InvalidRandomness,
             super::arrayref::SignError::LibraryError => Self::LibraryError,
         }
     }
@@ -215,9 +221,6 @@ impl From<super::arrayref::VerifyError> for VerifyError {
     fn from(e: super::arrayref::VerifyError) -> Self {
         match e {
             super::arrayref::VerifyError::InvalidSignature => Self::InvalidSignature,
-            super::arrayref::VerifyError::InvalidSignatureBufferLength => {
-                Self::InvalidSignatureBufferLength
-            }
             super::arrayref::VerifyError::InvalidPayloadLength => Self::InvalidPayloadLength,
             super::arrayref::VerifyError::LibraryError => Self::LibraryError,
         }
