cryptoy 0.4.0

Toy implementations of cryptographic protocols for educational purposes
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

use cryptoy::rsa::codec::Pkcs1V1_5;
use cryptoy::rsa::traits::Codec;
use cryptoy::rsa::{codec, KeyPair, Rsa};
use rand::{thread_rng, RngCore};

pub fn main() {
    // we are using insecure parameters here for the sake of a demo and making
    // the bytes output smaller and easier to read.
    let prime_bits = 64;
    let min_padding: usize = 2;

    let mut rng = thread_rng();
    let seed = rng.next_u64();

    let key_pair = KeyPair::generate(prime_bits, seed).unwrap();

    let modulus_bytes = key_pair.private_key.modulus.bits() / 8;
    let codec = Pkcs1V1_5::new(
        codec::BlockType::Type02,
        modulus_bytes,
        modulus_bytes - min_padding - 3,
        seed,
    );

    let mut rsa = Rsa::<Pkcs1V1_5> { codec, key_pair };

    let plaintext = b"hello, RSA PKCS!";

    let ciphertext = rsa.encrypt(plaintext).unwrap();
    let decrypted_text = rsa.decrypt(&ciphertext).unwrap();

    // this is done internally, but we're doing it again to print it for demo
    // purposes.
    let encoded_plaintext = rsa.codec.encode(plaintext).unwrap();
    let encoded_bytes: Vec<u8> = encoded_plaintext.to_bytes_be();

    let ciphertext_bytes: Vec<u8> = ciphertext.to_bytes_be();

    println!("plaintext:      {:?}", plaintext);
    println!(" ({:?})", String::from_utf8_lossy(plaintext));
    println!("decrypted_text: {:?}", decrypted_text);
    println!(" ({:?})", String::from_utf8_lossy(&decrypted_text));
    println!("encoded:        {:?}", encoded_bytes);
    println!("ciphertext:     {:?}", ciphertext_bytes);

    assert_eq!(plaintext, decrypted_text.as_slice());
}