enc_rust 0.2.2

A pure rust implementation of the Module-Lattice-based standards ML-KEM and (soon) ML-DSA, also known as the PQC scheme Crystals Kyber and Dilithium.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::params::{SecurityLevel, K};
use core::{
    array::TryFromSliceError,
    fmt::{Display, Formatter},
    num::TryFromIntError,
};
use num_enum::TryFromPrimitiveError;

#[derive(Debug, PartialEq, Eq)]
pub enum CrystalsError {
    MismatchedSecurityLevels(SecurityLevel, SecurityLevel),
    IncorrectBufferLength(usize, usize),
    InvalidSeedLength(usize, usize),
    InternalError(),
    InvalidK(usize),
    InvalidCiphertextLength(usize),
}

impl Display for CrystalsError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match *self {
            Self::MismatchedSecurityLevels(sec_level_1, sec_level_2) => write!(f, "Mismatched security levels when attempting operation: {sec_level_1:#?} and {sec_level_2:#?}"),
            Self::IncorrectBufferLength(buf_len, expected_buf_len) => write!(f, "Incorrect buffer length for (un)packing. Expected buffer length {expected_buf_len}, got length {buf_len}"),
            Self::InvalidSeedLength(seed_len, expected_seed_len) => write!(f, "Invalid seed length, expected {expected_seed_len}, got {seed_len}"),
            Self::InternalError() => write!(f, "Unexpected internal error"),
            Self::InvalidK(k) => write!(f, "Recieved invalid k value, {k}, expected 2, 3, or 4"),
            Self::InvalidCiphertextLength(ciphertext_len) => write!(f, "Invalid ciphertext length, expected 768, 1088, or 1568, got {ciphertext_len}"),
        }
    }
}

#[derive(Debug)]
pub enum PackingError {
    Crystals(CrystalsError),
    TryFromPrimitive(TryFromPrimitiveError<K>),
    TryFromInt(TryFromIntError),
    TryFromSlice(TryFromSliceError),
}

impl From<CrystalsError> for PackingError {
    fn from(error: CrystalsError) -> Self {
        Self::Crystals(error)
    }
}

impl From<TryFromPrimitiveError<K>> for PackingError {
    fn from(error: TryFromPrimitiveError<K>) -> Self {
        Self::TryFromPrimitive(error)
    }
}

impl From<TryFromIntError> for PackingError {
    fn from(error: TryFromIntError) -> Self {
        Self::TryFromInt(error)
    }
}

impl From<TryFromSliceError> for PackingError {
    fn from(error: TryFromSliceError) -> Self {
        Self::TryFromSlice(error)
    }
}

#[derive(Debug)]
pub enum KeyGenerationError {
    Crystals(CrystalsError),
    TryFromSlice(TryFromSliceError),
    Packing(PackingError),
    Rand(rand_core::Error),
}

impl From<CrystalsError> for KeyGenerationError {
    fn from(error: CrystalsError) -> Self {
        Self::Crystals(error)
    }
}

impl From<TryFromSliceError> for KeyGenerationError {
    fn from(error: TryFromSliceError) -> Self {
        Self::TryFromSlice(error)
    }
}

impl From<PackingError> for KeyGenerationError {
    fn from(error: PackingError) -> Self {
        Self::Packing(error)
    }
}

impl From<rand_core::Error> for KeyGenerationError {
    fn from(error: rand_core::Error) -> Self {
        Self::Rand(error)
    }
}

#[derive(Debug)]
pub enum EncryptionDecryptionError {
    Crystals(CrystalsError),
    KeyGenerationError(KeyGenerationError),
    TryFromInt(TryFromIntError),
    Packing(PackingError),
    Rand(rand_core::Error),
}

impl From<CrystalsError> for EncryptionDecryptionError {
    fn from(error: CrystalsError) -> Self {
        Self::Crystals(error)
    }
}

impl From<KeyGenerationError> for EncryptionDecryptionError {
    fn from(error: KeyGenerationError) -> Self {
        Self::KeyGenerationError(error)
    }
}

impl From<TryFromIntError> for EncryptionDecryptionError {
    fn from(error: TryFromIntError) -> Self {
        Self::TryFromInt(error)
    }
}

impl From<PackingError> for EncryptionDecryptionError {
    fn from(error: PackingError) -> Self {
        Self::Packing(error)
    }
}

impl From<rand_core::Error> for EncryptionDecryptionError {
    fn from(error: rand_core::Error) -> Self {
        Self::Rand(error)
    }
}