oboron 0.8.0

Encryption and encoding library for developer ergonomics: prefix entropy, compact outputs, high performance
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

#[cfg(feature = "zrbcx")]
use oboron::ztier::ZrbcxC32;
#[cfg(feature = "aags")]
use oboron::AagsC32;
use oboron::Omnib;
#[cfg(feature = "upbc")]
use oboron::UpbcC32;

#[test]
#[cfg(feature = "zrbcx")]
fn test_zrbcx_basic() {
    let original = "hello world";
    let ob = ZrbcxC32::new_keyless().unwrap();
    let ot = ob.enc(original).unwrap();
    let pt2 = ob.dec(&ot).unwrap();

    assert_eq!(original, pt2);
    assert!(ot.len() > 0);
}

#[test]
#[cfg(feature = "zrbcx")]
fn test_empty_string() {
    let original = "";
    let ob = ZrbcxC32::new_keyless().unwrap();
    assert!(ob.enc(original).is_err());
}

#[test]
#[cfg(feature = "zrbcx")]
fn test_zrbcx_all_printable_ascii() {
    let original = (32..127).map(|c| c as u8 as char).collect::<String>();
    let ob = ZrbcxC32::new_keyless().unwrap();
    let ot = ob.enc(&original).unwrap();
    let pt2 = ob.dec(&ot).unwrap();

    assert_eq!(original, pt2);
}

#[test]
#[cfg(feature = "zrbcx")]
fn test_convenience_functions() {
    let original = "convenience test";

    let ot = oboron::enc_keyless(original, "aasv.c32").unwrap();
    let pt2 = oboron::dec_keyless(&ot, "aasv.c32").unwrap();
    assert_eq!(original, pt2);

    let pt3 = oboron::autodec_keyless(&ot).unwrap();
    assert_eq!(original, pt3);
}

#[test]
#[cfg(feature = "aags")]
fn test_aags_deterministic() {
    let original = "deterministic test";
    let ob = AagsC32::new_keyless().unwrap();

    let ot1 = ob.enc(original).unwrap();
    let ot2 = ob.enc(original).unwrap();

    // aags is deterministic - same input produces same output
    assert_eq!(ot1, ot2);

    let pt2 = ob.dec(&ot1).unwrap();
    assert_eq!(original, pt2);
}

#[test]
#[cfg(feature = "upbc")]
fn test_upbc_probabilistic() {
    let original = "probabilistic test";
    let ob = UpbcC32::new_keyless().unwrap();

    let ot1 = ob.enc(original).unwrap();
    let ot2 = ob.enc(original).unwrap();

    // upbc is probabilistic - same input produces different output
    assert_ne!(ot1, ot2);

    let pt21 = ob.dec(&ot1).unwrap();
    let pt22 = ob.dec(&ot2).unwrap();
    assert_eq!(original, pt21);
    assert_eq!(original, pt22);
}

#[test]
fn test_autodetect_all_formats() {
    let original = "autodetect all";
    let omb = Omnib::new_keyless().unwrap();

    #[cfg(feature = "aags")]
    {
        let ot = omb.enc(original, "aags.c32").unwrap();
        let pt2 = omb.autodec(&ot).unwrap();
        assert_eq!(original, pt2, "Failed for format aags");
    }
    #[cfg(feature = "apgs")]
    {
        let ot = omb.enc(original, "apgs.c32").unwrap();
        let pt2 = omb.autodec(&ot).unwrap();
        assert_eq!(original, pt2, "Failed for format apgs");
    }
    #[cfg(feature = "aasv")]
    {
        let ot = omb.enc(original, "aasv.c32").unwrap();
        let pt2 = omb.autodec(&ot).unwrap();
        assert_eq!(original, pt2, "Failed for format aasv");
    }
    #[cfg(feature = "apsv")]
    {
        let ot = omb.enc(original, "apsv.c32").unwrap();
        let pt2 = omb.autodec(&ot).unwrap();
        assert_eq!(original, pt2, "Failed for format apsv");
    }
    #[cfg(feature = "upbc")]
    {
        let ot = omb.enc(original, "upbc.c32").unwrap();
        let pt2 = omb.autodec(&ot).unwrap();
        assert_eq!(original, pt2, "Failed for format upbc");
    }
}