crypto-bigint 0.7.2

Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations of modern formulas using const generics.
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
134
135
136
137

use crate::{Choice, CtEq};
use core::ops::Neg;

/// Possible return values for Jacobi symbol calculations.
#[derive(Debug, Copy, Clone)]
#[repr(i8)]
pub enum JacobiSymbol {
    /// The two arguments are not coprime, they have a common divisor apart from 1.
    Zero = 0,

    /// The two arguments are coprime. If the lower argument is prime, then the upper argument
    /// is quadratic residue modulo the lower argument. Otherwise, the upper argument is known to
    /// be quadratic nonresidue for an even number of prime factors of the lower argument.
    One = 1,

    /// The two terms are coprime, and the upper argument is a quadratic nonresidue modulo the
    /// lower argument.
    MinusOne = -1,
}

impl JacobiSymbol {
    /// Determine if the symbol is zero.
    #[must_use]
    pub const fn is_zero(&self) -> Choice {
        Choice::from_i64_eq(*self as i8 as i64, 0)
    }

    /// Determine if the symbol is one.
    #[must_use]
    pub const fn is_one(&self) -> Choice {
        Choice::from_i64_eq(*self as i8 as i64, 1)
    }

    /// Determine if the symbol is minus one.
    #[must_use]
    pub const fn is_minus_one(&self) -> Choice {
        Choice::from_i64_eq(*self as i8 as i64, -1)
    }

    /// Negate the symbol.
    #[must_use]
    pub const fn neg(self) -> Self {
        match self {
            Self::Zero => Self::Zero,
            Self::One => Self::MinusOne,
            Self::MinusOne => Self::One,
        }
    }

    pub(crate) const fn from_i8(value: i8) -> Self {
        match value {
            0 => Self::Zero,
            1 => Self::One,
            -1 => Self::MinusOne,
            _ => panic!("invalid value for Jacobi symbol"),
        }
    }
}

impl CtEq for JacobiSymbol {
    fn ct_eq(&self, other: &Self) -> Choice {
        (*self as i8).ct_eq(&(*other as i8))
    }
}

impl Eq for JacobiSymbol {}

impl PartialEq for JacobiSymbol {
    fn eq(&self, other: &Self) -> bool {
        self.ct_eq(other).to_bool()
    }
}

impl From<JacobiSymbol> for i8 {
    fn from(symbol: JacobiSymbol) -> i8 {
        symbol as i8
    }
}

impl Neg for JacobiSymbol {
    type Output = Self;

    fn neg(self) -> Self {
        Self::neg(self)
    }
}

#[cfg(feature = "subtle")]
impl subtle::ConstantTimeEq for JacobiSymbol {
    fn ct_eq(&self, other: &Self) -> subtle::Choice {
        CtEq::ct_eq(self, other).into()
    }
}

#[cfg(test)]
mod tests {
    use super::JacobiSymbol;

    #[test]
    fn jacobi_eq() {
        assert_eq!(JacobiSymbol::Zero, JacobiSymbol::Zero);
        assert_ne!(JacobiSymbol::Zero, JacobiSymbol::One);
        assert_ne!(JacobiSymbol::Zero, JacobiSymbol::MinusOne);
        assert!(JacobiSymbol::Zero.is_zero().to_bool());
        assert!(!JacobiSymbol::One.is_zero().to_bool());
        assert!(JacobiSymbol::One.is_one().to_bool());
        assert!(!JacobiSymbol::MinusOne.is_one().to_bool());
        assert!(JacobiSymbol::MinusOne.is_minus_one().to_bool());
        #[cfg(feature = "subtle")]
        assert!(bool::from(subtle::ConstantTimeEq::ct_eq(
            &JacobiSymbol::Zero,
            &JacobiSymbol::Zero
        )));
        #[cfg(feature = "subtle")]
        assert!(!bool::from(subtle::ConstantTimeEq::ct_eq(
            &JacobiSymbol::Zero,
            &JacobiSymbol::One
        )));
    }

    #[test]
    fn jacobi_from() {
        assert_eq!(i8::from(JacobiSymbol::Zero), 0i8);
        assert_eq!(i8::from(JacobiSymbol::One), 1i8);
        assert_eq!(i8::from(JacobiSymbol::MinusOne), -1i8);
        assert_eq!(JacobiSymbol::from_i8(0i8), JacobiSymbol::Zero);
        assert_eq!(JacobiSymbol::from_i8(1i8), JacobiSymbol::One);
        assert_eq!(JacobiSymbol::from_i8(-1i8), JacobiSymbol::MinusOne);
    }

    #[test]
    fn jacobi_neg() {
        assert_eq!(JacobiSymbol::Zero.neg(), JacobiSymbol::Zero);
        assert_eq!(-JacobiSymbol::One, JacobiSymbol::MinusOne);
        assert_eq!(-JacobiSymbol::MinusOne, JacobiSymbol::One);
    }
}