reallyme-crypto-dispatch 0.1.6

Algorithm dispatch, codec binding, and structural validation for cryptographic primitives.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
//
// SPDX-License-Identifier: Apache-2.0

#![allow(clippy::needless_return)]
use crate::AlgorithmError;
use crypto_core::Algorithm;
use zeroize::Zeroizing;

/// ML-KEM-768 algorithm adapter.
///
/// This adapter provides key generation and KEM operations.
/// It does NOT implement SignatureAlgorithm.
pub struct MlKem768Algo;

impl MlKem768Algo {
    /// The algorithm selector this adapter implements.
    pub const ALG: Algorithm = Algorithm::MlKem768;

    /// Generate an ML-KEM-768 keypair.
    pub fn generate_keypair() -> Result<(Vec<u8>, Zeroizing<Vec<u8>>), AlgorithmError> {
        #[cfg(any(feature = "native", all(feature = "wasm", target_arch = "wasm32")))]
        {
            return crate::algorithms::KeypairResultExt::into_algorithm_keypair(
                crypto_ml_kem_768::generate_ml_kem_768_keypair(),
                Self::ALG,
            );
        }

        #[cfg(not(any(feature = "native", all(feature = "wasm", target_arch = "wasm32"))))]
        {
            Err(AlgorithmError::UnsupportedAlgorithm(Self::ALG))
        }
    }

    /// Encapsulate using the public key.
    ///
    /// Returns (shared_secret, ciphertext); the shared secret zeroizes on
    /// drop.
    pub fn encapsulate(public_key: &[u8]) -> Result<(Zeroizing<Vec<u8>>, Vec<u8>), AlgorithmError> {
        #[cfg(any(feature = "native", all(feature = "wasm", target_arch = "wasm32")))]
        {
            let (ct, ss) = crypto_ml_kem_768::ml_kem_768_encapsulate(public_key)
                .map_err(AlgorithmError::from)?;

            return Ok((ss, ct));
        }

        #[cfg(not(any(feature = "native", all(feature = "wasm", target_arch = "wasm32"))))]
        {
            let _ = public_key;
            Err(AlgorithmError::UnsupportedAlgorithm(Self::ALG))
        }
    }

    /// Decapsulate using the secret key.
    ///
    /// Returns shared_secret; it zeroizes on drop.
    pub fn decapsulate(
        ciphertext: &[u8],
        secret_key: &[u8],
    ) -> Result<Zeroizing<Vec<u8>>, AlgorithmError> {
        #[cfg(any(feature = "native", all(feature = "wasm", target_arch = "wasm32")))]
        {
            return crypto_ml_kem_768::ml_kem_768_decapsulate(ciphertext, secret_key)
                .map_err(AlgorithmError::from);
        }

        #[cfg(not(any(feature = "native", all(feature = "wasm", target_arch = "wasm32"))))]
        {
            let _ = (ciphertext, secret_key);
            Err(AlgorithmError::UnsupportedAlgorithm(Self::ALG))
        }
    }
}