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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
use std::cmp::Ordering;
use image::{ColorType, DynamicImage, GenericImageView, Pixel};
use thiserror::Error;
use crate::codec::Codec;
/// Least-significant bit (LSB) steganography encodes data in the least-significant bits of colors
/// in an image. This implementation reduces the colors in the carrier (irreversibly) in order to
/// allow a byte of data to fit in each pixel of the image. 3 bits of data are encoded per pixel,
/// and the 9th bit is used to signal the end of data.
#[derive(Debug)]
pub struct LsbCodec;
impl Codec for LsbCodec {
type Carrier = DynamicImage;
type Payload = Vec<u8>;
type Output = Self::Carrier;
type Error = LsbError;
fn encode<C, P>(&self, carrier: C, payload: P) -> Result<Self::Output, Self::Error>
where
C: Into<Self::Carrier>,
P: Into<Self::Payload>,
{
let mut image: DynamicImage = carrier.into();
let payload: Vec<u8> = payload.into();
if image.pixels().count() < payload.len() {
return Err(LsbError::PayloadTooBig);
}
let mut payload_iter = payload.iter();
match image {
DynamicImage::ImageRgba8(ref mut image) => {
for pixel in image.pixels_mut() {
if let Some(payload_byte) = payload_iter.next() {
encode_pixel(pixel, *payload_byte, false);
} else {
encode_pixel(pixel, 0, true);
}
}
},
DynamicImage::ImageRgb8(ref mut image) => {
for pixel in image.pixels_mut() {
if let Some(payload_byte) = payload_iter.next() {
encode_pixel(pixel, *payload_byte, false);
} else {
encode_pixel(pixel, 0, true);
}
}
},
_ => return Err(LsbError::UnsupportedFormat { format: image.color() })
}
Ok(image)
}
fn decode<E>(&self, carrier: E) -> Result<(Self::Carrier, Self::Payload), LsbError>
where
E: Into<Self::Output>,
{
let mut image: DynamicImage = carrier.into();
let mut payload: Vec<u8> = Vec::new();
match image {
DynamicImage::ImageRgba8(ref mut image) => {
for pixel in image.pixels_mut() {
if let Some(payload_byte) = decode_pixel(pixel) {
payload.push(payload_byte);
} else {
break;
}
}
},
DynamicImage::ImageRgb8(ref mut image) => {
for pixel in image.pixels_mut() {
if let Some(payload_byte) = decode_pixel(pixel) {
payload.push(payload_byte);
} else {
break;
}
}
},
_ => return Err(LsbError::UnsupportedFormat { format: image.color() })
}
Ok((image, payload))
}
}
fn encode_pixel<P: Pixel<Subpixel = u8>>(pixel: &mut P, payload_byte: u8, end_of_data: bool) {
let mut bits_remaining: i32 = 8;
for channel in pixel.channels_mut() {
*channel &= 0b11111000;
bits_remaining -= 3;
if bits_remaining <= -3 {
break;
}
let mask = match bits_remaining.cmp(&0) {
Ordering::Less => payload_byte << -bits_remaining,
_ => payload_byte >> bits_remaining,
} & 0b00000111;
*channel |= mask;
}
// Add end-of-data marker to final bit if necessary
if end_of_data {
*pixel.channels_mut().last_mut().unwrap() |= 1;
}
}
fn decode_pixel<P: Pixel<Subpixel = u8>>(pixel: &mut P) -> Option<u8> {
// Final bit as end-of-data marker
if pixel.channels().last().unwrap() & 1 == 1 {
return None;
}
let mut bits_remaining: i32 = 8;
let mut payload_byte: u8 = 0;
for channel in pixel.channels_mut() {
bits_remaining -= 3;
if bits_remaining <= -3 {
break;
}
let channel_bits = *channel & 0b00000111;
*channel &= 0b11111000;
let mask = match bits_remaining.cmp(&0) {
Ordering::Less => channel_bits >> -bits_remaining,
_ => channel_bits << bits_remaining,
};
payload_byte |= mask;
}
Some(payload_byte)
}
/// Errors thrown by the LSB Codec.
#[derive(Error, Debug)]
pub enum LsbError {
/// Error thrown when payload is too big for the carrier.
#[error("Payload is too big for the carrier. Choose a smaller payload or an image with greater pixel dimensions.")]
PayloadTooBig,
/// Error thrown when pixel format is unsupported.
#[error("Specified image format ({format:?}) is unsupported.")]
UnsupportedFormat {
/// Provided (invalid) format.
format: ColorType
},
}
|
