dryoc 1.0.0

Don't Roll Your Own Crypto: pure-Rust, hard to misuse cryptography library
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

#![cfg(all(target_arch = "wasm32", target_os = "unknown"))]

use dryoc::classic::crypto_generichash::crypto_generichash;
use dryoc::dryocbox::{DryocBox, KeyPair, NewByteArray, Nonce};
use dryoc::dryocsecretbox::{DryocSecretBox, Key};
use dryoc::dryocstream::{DryocStream, Header, Key as StreamKey, Tag};
use dryoc::precalc::PrecalcSecretKey;
use wasm_bindgen_test::wasm_bindgen_test;

#[wasm_bindgen_test]
fn dryocbox_roundtrip() {
    let sender_keypair = KeyPair::generate();
    let recipient_keypair = KeyPair::generate();
    let nonce = Nonce::generate();
    let message = b"wasm dryocbox";

    let dryocbox = DryocBox::encrypt_to_vecbox(
        message,
        &nonce,
        &recipient_keypair.public_key,
        &sender_keypair.secret_key,
    )
    .expect("unable to encrypt");

    let decrypted = dryocbox
        .decrypt_to_vec(
            &nonce,
            &sender_keypair.public_key,
            &recipient_keypair.secret_key,
        )
        .expect("unable to decrypt");

    assert_eq!(message, decrypted.as_slice());
}

#[wasm_bindgen_test]
fn dryocbox_precalc_roundtrip() {
    let sender_keypair = KeyPair::generate();
    let recipient_keypair = KeyPair::generate();
    let nonce = Nonce::generate();
    let message = b"wasm dryocbox precalc";
    let shared_key =
        PrecalcSecretKey::precalculate(&recipient_keypair.public_key, &sender_keypair.secret_key)
            .expect("precalculation failed");

    let dryocbox =
        DryocBox::precalc_encrypt_to_vecbox(message, &nonce, &shared_key).expect("encrypt failed");
    let decrypted = dryocbox
        .decrypt_to_vec(
            &nonce,
            &sender_keypair.public_key,
            &recipient_keypair.secret_key,
        )
        .expect("decrypt failed");

    assert_eq!(message, decrypted.as_slice());
}

#[wasm_bindgen_test]
fn dryocsecretbox_roundtrip() {
    let secret_key = Key::generate();
    let nonce = dryoc::dryocsecretbox::Nonce::generate();
    let message = b"wasm dryocsecretbox";

    let dryocsecretbox: dryoc::dryocsecretbox::VecBox =
        DryocSecretBox::encrypt(message, &nonce, &secret_key);
    let decrypted: Vec<u8> = dryocsecretbox
        .decrypt(&nonce, &secret_key)
        .expect("unable to decrypt");

    assert_eq!(message, decrypted.as_slice());
}

#[wasm_bindgen_test]
fn dryocstream_roundtrip() {
    let key = StreamKey::generate();
    let (mut push_stream, header): (_, Header) = DryocStream::init_push(&key);
    let message = b"wasm secretstream".to_vec();
    let associated_data = b"fixed-width lengths".to_vec();
    let ciphertext = push_stream
        .push_to_vec(&message, Some(&associated_data), Tag::FINAL)
        .expect("secretstream push failed");

    let mut pull_stream = DryocStream::init_pull(&key, &header);
    let (decrypted, tag) = pull_stream
        .pull_to_vec(&ciphertext, Some(&associated_data))
        .expect("secretstream pull failed");

    assert_eq!(decrypted, message);
    assert_eq!(tag, Tag::FINAL);
}

#[wasm_bindgen_test]
fn generichash_known_answer() {
    let mut hash = [0u8; 32];
    crypto_generichash(&mut hash, b"abc", None).expect("hash failed");

    assert_eq!(
        &hash,
        &[
            0xbd, 0xdd, 0x81, 0x3c, 0x63, 0x42, 0x39, 0x72, 0x31, 0x71, 0xef, 0x3f, 0xee, 0x98,
            0x57, 0x9b, 0x94, 0x96, 0x4e, 0x3b, 0xb1, 0xcb, 0x3e, 0x42, 0x72, 0x62, 0xc8, 0xc0,
            0x68, 0xd5, 0x23, 0x19,
        ]
    );
}