asbs 1.2.3

A generic steganography 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
107
108
109
110
111
112
113
114

use asbs::{binary, Conceal, Reveal};
use std::{fs::File, io};

#[test]
fn it_conceals_and_reveals_with_known_length() -> io::Result<()> {
    let pattern = |i| Some(((1u8 << (i % 3)) - 1) << 1);

    let cover = File::open("tests/resources/cover")?;
    let cover_len = cover.metadata()?.len() as usize;

    let payload = b"a very very secret message";
    let payload_len = payload.len();

    let mut package = Vec::with_capacity(cover_len);

    assert_eq!(
        cover_len,
        binary::Carrier::new(pattern, &mut package).conceal(payload.as_slice(), cover)?,
    );

    let mut revealed_payload = Vec::with_capacity(payload_len);

    binary::Package::with_len(payload_len, pattern, package.as_slice())
        .reveal(&mut revealed_payload)?;

    assert_eq!(*payload, *revealed_payload);

    Ok(())
}

#[test]
fn it_conceals_and_reveals_with_embedded_length() -> io::Result<()> {
    let pattern = |i| Some(1u8 << (i % 3));

    let cover = File::open("tests/resources/cover")?;
    let cover_len = cover.metadata()?.len() as usize;

    let payload = b"a very very secret message";

    let mut package = Vec::with_capacity(cover_len);

    assert_eq!(
        cover_len,
        binary::Carrier::with_embedded_len(payload.len(), pattern, &mut package)
            .conceal(payload.as_slice(), cover)?,
    );

    let mut revealed_payload = Vec::new();

    binary::Package::with_embedded_len(pattern, package.as_slice())
        .reveal(&mut revealed_payload)?;

    assert_eq!(*payload, *revealed_payload);

    Ok(())
}

#[test]
fn it_handles_zero_length_payload() -> io::Result<()> {
    let pattern = |_| Some(1);

    let mut package = Vec::new();

    binary::Carrier::with_embedded_len(0, pattern, &mut package)
        .conceal([].as_slice(), File::open("tests/resources/cover")?)?;

    let mut revealed_payload = Vec::new();

    binary::Package::with_embedded_len(pattern, package.as_slice())
        .reveal(&mut revealed_payload)?;

    assert!(revealed_payload.is_empty());

    Ok(())
}

#[test]
fn it_handles_partial_conceal() -> io::Result<()> {
    let pattern = |_| Some(1);

    let mut package = Vec::with_capacity(0);

    assert_eq!(
        io::ErrorKind::WriteZero,
        binary::Carrier::new(pattern, &mut package)
        .conceal(b"this message won't be written".as_slice(), [].as_slice())
            .unwrap_err()
            .kind()
    );

    Ok(())
}

#[test]
fn it_handles_partial_reveal() -> io::Result<()> {
    let pattern = |_| Some(1);

    let mut package = Vec::new();

    binary::Carrier::new(pattern, &mut package).conceal(
        b"this message won't fit".as_slice(),
        File::open("tests/resources/cover")?,
    )?;

    assert_eq!(
        io::ErrorKind::WriteZero,
        binary::Package::with_embedded_len(pattern, package.as_slice())
            .reveal([].as_mut_slice())
            .unwrap_err()
            .kind()
    );

    Ok(())
}