cry 0.1.5

Advance cryptography based on ECC and permutation cryptography.
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

use super::BarePublicKey;
use super::Keypair;
use crate::primitive::bytes::{self, Bytes};
use crate::primitive::point::{DisLogPoint, Point};
use crate::primitive::scalar::{Scalar, ScalarNumber};
use digest::Digest;
use generic_array::GenericArray;

pub struct PublicKey<P: DisLogPoint, S: ScalarNumber> {
    pub code: bytes::Output<S>,
    pub public: Point<P>,
}

impl<P: DisLogPoint, S: ScalarNumber> PublicKey<P, S> {
    pub fn from_keypair(keypair: &Keypair<P, S>) -> Self {
        PublicKey {
            code: keypair.code.clone(),
            public: keypair.public.clone(),
        }
    }

    pub fn derive<D: Digest>(&self, id: bytes::Output<S>) -> Self {
        let mut hasher = D::new();
        hasher.update(self.public.to_bytes());
        hasher.update(&id);
        hasher.update(&self.code);

        let result = hasher.finalize();
        let (c, s) = result.split_at(result.len() / 2);
        // here will clone, but it seems ok.
        let part = Scalar::from_bytes(GenericArray::clone_from_slice(s));
        let public_part = part * Point::basepoint();
        let public = &self.public + public_part;
        Self {
            code: bytes::Output::<S>::clone_from_slice(c),
            public,
        }
    }

    pub fn to_bare_public(&self) -> BarePublicKey<P> {
        BarePublicKey {
            public: self.public.clone(),
        }
    }
}

#[cfg(all(test, feature = "ristretto255"))]
mod tests {
    use super::*;
    use crate::ristretto255;
    use rand::RngCore;
    use sha3::Sha3_512;

    #[test]
    fn test_key_derive() {
        let mut rng = rand::thread_rng();
        let mut seed = [0u8; 32];
        rng.fill_bytes(&mut seed);
        let keypair =
            Keypair::<ristretto255::Point, ristretto255::Scalar>::new::<Sha3_512>(seed.into());

        let root_public_key = keypair.to_public();

        let mut rng = rand::thread_rng();
        let mut id_array = [0u8; 32];
        rng.fill_bytes(&mut id_array);

        let sub_public_key = root_public_key.derive::<Sha3_512>(id_array.into());

        let sub_keypair = keypair.derive::<Sha3_512>(id_array.into());

        assert_eq!(sub_keypair.public, sub_public_key.public);
    }
}