sarkara 0.8.0

A Post-Quantum cryptography library.
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

//! Nonce Generater.

use std::mem::size_of_val;
use rand::Rng;
use byteorder::{ BigEndian, ByteOrder };


/// Nonce Generater trait.
pub trait GenNonce {
    /// fill nonce.
    fn fill(&mut self, nonce: &mut [u8]);

    /// generate nonce.
    fn gen(&mut self, len: usize) -> Vec<u8> {
        let mut output = vec![0; len];
        self.fill(&mut output);
        output
    }
}

impl<T: Rng> GenNonce for T {
    #[inline]
    fn fill(&mut self, nonce: &mut [u8]) {
        self.fill_bytes(nonce)
    }
}


/// u64 Counter Nonce Generater.
///
/// ```
/// # extern crate rand;
/// # extern crate sarkara;
/// # fn main() {
/// # use rand::{ OsRng, ChaChaRng, Rng };
/// # use sarkara::aead::{ General, AeadCipher };
/// # use sarkara::stream::HC256;
/// # use sarkara::auth::HMAC;
/// # use sarkara::hash::Blake2b;
/// # use sarkara::utils::nonce::{ GenNonce, Counter };
/// #
/// # type HHBB = General<HC256, HMAC<Blake2b>, Blake2b>;
/// #
/// # let mut rng = OsRng::new().unwrap();
/// # let mut key = vec![0; HHBB::KEY_LENGTH];
/// # let mut plaintext = vec![0; 1024];
/// # rng.fill_bytes(&mut key);
/// # rng.fill_bytes(&mut plaintext);
/// #
/// let mut ctr1 = Counter::default();
/// let mut ctr2 = Counter::default();
///
/// let mut nonce = vec![0; HHBB::NONCE_LENGTH];
/// ctr1.fill(&mut nonce);
/// let ciphertext = HHBB::new(&key)
///     .with_aad(&nonce)
///     .encrypt(&mut nonce, &plaintext);
///
/// let mut nonce = vec![0; HHBB::NONCE_LENGTH];
/// ctr2.fill(&mut nonce);
/// let decrypttext = HHBB::new(&key)
///     .with_aad(&nonce)
///     .decrypt(&nonce, &ciphertext).unwrap();
/// # assert_eq!(decrypttext, plaintext);
/// # }
/// ```
///
/// ## Panic When:
/// - Counter overflow.
/// - nonce length < `size_of::<u64>()`.
#[derive(Debug, Clone)]
pub struct Counter(pub u64);

impl Default for Counter {
    fn default() -> Counter {
        Counter(0)
    }
}

impl GenNonce for Counter {
    fn fill(&mut self, nonce: &mut [u8]) {
        let nonce_len = nonce.len();
        let ctr_len = size_of_val(&self.0);
        assert!(nonce_len >= ctr_len);

        let (_, ctr) = nonce.split_at_mut(nonce_len - ctr_len);
        BigEndian::write_u64(ctr, self.0);
        self.0 = self.0.checked_add(1).expect("Counter overflow.");
    }
}


#[test]
fn test_counter() {
    let mut output = [0; 12];
    let mut ctr = Counter::default();

    ctr.fill(&mut output);
    assert_eq!(BigEndian::read_u64(&output[4..]), 0);

    ctr.fill(&mut output);
    assert_eq!(BigEndian::read_u64(&output[4..]), 1);
}