secbox 0.1.1

Sensitive data container.
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

use SecBox;

#[test]
fn test_new() {
    let a = SecBox::new(b'a');
    let b = SecBox::new(b'b');
    let c = SecBox::new(b'c');

    assert_eq!(*a, b'a');
    assert_eq!(*b, b'b');
    assert_eq!(*c, b'c');
}

#[test]
fn test_unsized() {
    let string = String::from("abcs").into_boxed_str();

    let bx = SecBox::from(string);

    assert_eq!(&*bx, "abcs");
}

#[test]
fn test_zeroed() {
    let bx = SecBox::new(44);

    let ptr = &*bx as *const i32;

    drop(bx);

    unsafe {
        assert_eq!(*ptr, 0);
    }
}

#[test]
fn test_into_inner() {
    let a = SecBox::new(b'a');
    let b = SecBox::new(b'b');
    let c = SecBox::new(b'c');

    assert_eq!(a.into_inner(), b'a');
    assert_eq!(b.into_inner(), b'b');
    assert_eq!(c.into_inner(), b'c');
}

#[test]
fn test_mut() {
    let mut n = SecBox::new(0);

    assert_eq!(*n, 0);

    *n += 1;

    assert_eq!(*n, 1);

    *n = 55;

    assert_eq!(*n, 55);
}

#[test]
fn test_clone() {
    let bx = SecBox::new(0);
    let mut bx2 = bx.clone();

    *bx2 = 3;

    assert_eq!(*bx, 0);
    assert_eq!(*bx2, 3);
}

#[test]
fn test_clone_from() {
    let bx = SecBox::new(0);
    let mut bx2 = SecBox::new(44);

    bx2.clone_from(&bx);

    assert_eq!(*bx, 0);
    assert_eq!(*bx2, 0);
}

#[test]
fn test_dtor() {
    use std::rc::Rc;
    use std::cell::Cell;

    struct Dropper {
        dropped: Rc<Cell<bool>>,
    }

    impl Drop for Dropper {
        fn drop(&mut self) {
            // No double-drops.
            assert!(!self.dropped.get());
            self.dropped.set(true);
        }
    }

    let d = Rc::new(Cell::new(false));
    let d2 = d.clone();

    let dropster = Dropper { dropped: d };

    let bx = SecBox::new(dropster);

    drop(bx);

    assert!(d2.get());
}