pixelveil 1.0.1

A performant steganography and steganalysis library for hiding data in images, audio files, and videos
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
123
124
125
126
127
128
129
130
131
132

use crate::{
    image::lossless::bpcs::bit_plane::{BYTES_PER_PLANE, BitPlane},
    utils::bit_operations_utils::unsigned_int_to_bits,
};
use rand::{Rng, rng};

pub(crate) fn get_bytes_per_plane_u8s<'a, T>(iter: &'a mut T) -> Option<Vec<u8>>
where
    T: Iterator<Item = u8>,
{
    let mut u8s: Vec<u8> = Vec::with_capacity(BYTES_PER_PLANE);

    for _ in 0..BYTES_PER_PLANE {
        // if the next item is found, push it.
        // if not, check if the u8s vec contains any data, if it does, fill it with random data
        // if not, return None
        if let Some(next) = iter.next() {
            u8s.push(next);
        } else {
            if u8s.is_empty() {
                return None;
            } else {
                u8s.push(rng().random_range(0u8..0b11111111u8));
            }
        }
    }

    Some(u8s)
}

pub(crate) struct MessagePlanesIter<'a, T>
where
    T: Iterator<Item = u8>,
{
    pub(crate) message_byte_iter: &'a mut T,
    pub(crate) conjugation_map: &'a mut Vec<bool>,
}

impl<'a, T> MessagePlanesIter<'a, T>
where
    T: Iterator<Item = u8>,
{
    pub(crate) fn new(message_byte_iter: &'a mut T, conjugation_map: &'a mut Vec<bool>) -> Self {
        MessagePlanesIter {
            message_byte_iter,
            conjugation_map,
        }
    }
}

impl<'a, T> Iterator for MessagePlanesIter<'a, T>
where
    T: Iterator<Item = u8>,
{
    type Item = BitPlane;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(plane_u8s) = get_bytes_per_plane_u8s(self.message_byte_iter) {
            // get bits
            let mut data_bits: Vec<bool> = Vec::with_capacity(plane_u8s.len() * 8);
            for byte in plane_u8s {
                data_bits.extend(unsigned_int_to_bits(byte));
            }

            let mut plane = BitPlane::from_bits(data_bits.try_into().unwrap());

            if plane.alpha() < 0.5 {
                plane.conjugate();
                self.conjugation_map.push(true);
            } else {
                self.conjugation_map.push(false);
            }

            Some(plane)
        } else {
            None
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_message_plane_iter_consistency() {
        let mut conj_map: Vec<bool> = Vec::with_capacity(8 * 9);

        let mut bytes = vec![
            0b00000000u8,
            0b00100000u8,
            0b11111111u8,
            0b10100101u8,
            0b00101011u8,
            0b11011001u8,
            0b11110111u8,
            0b00001101u8,
            0b00111101u8,
        ]
        .into_iter();

        let mut plane_iter = MessagePlanesIter::new(&mut bytes, &mut conj_map);

        let mut next = plane_iter.next().unwrap();
        next.conjugate(); // next is supposed to be automatically conjugated on the .next(), so we conjugate it again to get the original data
        assert_eq!(
            next.bits,
            [
                [false, false, false, false, false, false, false, false],
                [false, false, true, false, false, false, false, false],
                [true, true, true, true, true, true, true, true],
                [true, false, true, false, false, true, false, true],
                [false, false, true, false, true, false, true, true],
                [true, true, false, true, true, false, false, true],
                [true, true, true, true, false, true, true, true],
                [false, false, false, false, true, true, false, true],
            ]
        );

        let next = plane_iter.next().unwrap();
        // the 2nd bit plane might have been conjugated, depending on how the bits were filled to fit a plane, so we need the
        //  first row (the data bits) to be equal to either the regular or conjugated version of itself
        assert!(
            (next.bits[0] == [false, false, true, true, true, true, false, true])
                ^ (next.bits[0] == [false, true, true, false, true, false, false, false])
        );

        let next = plane_iter.next();
        assert!(next.is_none());

        assert_eq!(conj_map[0], true);
    }
}