1use flate2::{Compression, read::DeflateDecoder, write::DeflateEncoder};
9use std::io::{Read, Write};
10
11use crate::error;
12
13pub fn hide_encrypt<T>(info: T, carrier_template: &str) -> Result<String, error::HideSomethingError>
36where
37 T: ToString,
38{
39 let compressed = flate2_compress(info)?;
41
42 let mut payload = Vec::new();
44 payload.extend_from_slice(&(compressed.len() as u32).to_be_bytes());
45 payload.extend_from_slice(&compressed);
46
47 let bits: Vec<u8> = bytes_to_bits(&payload).collect();
49 let needed_bits = bits.len();
50
51 let mut carrier = String::new();
53 let template_letters: Vec<char> = carrier_template
54 .chars()
55 .filter(|c| c.is_alphabetic())
56 .collect();
57 if template_letters.is_empty() {
58 return Err(error::HideSomethingError::CarrierTemplateEmpty);
59 }
60
61 while carrier.chars().filter(|c| c.is_alphabetic()).count() < needed_bits {
62 carrier.push_str(carrier_template);
63 }
64
65 let chars: Vec<char> = carrier.chars().collect();
66
67 let mut bit_iter = bits.into_iter();
69 let mut result = String::with_capacity(chars.len());
70 for ch in chars {
71 if ch.is_alphabetic() {
72 if let Some(bit) = bit_iter.next() {
73 if bit == 1 {
74 result.push(ch.to_ascii_uppercase());
75 } else {
76 result.push(ch.to_ascii_lowercase());
77 }
78 } else {
79 result.push(ch);
81 }
82 } else {
83 result.push(ch);
84 }
85 }
86
87 Ok(result)
88}
89
90pub fn hide_decrypt<T>(info: T) -> Result<String, error::HideSomethingError>
111where
112 T: ToString,
113{
114 let bits: Vec<u8> = info
116 .to_string()
117 .chars()
118 .filter(|c| c.is_alphabetic())
119 .map(|c| if c.is_uppercase() { 1 } else { 0 })
120 .collect();
121
122 let raw_bytes = bits_to_bytes(&bits);
124 if raw_bytes.len() < 4 {
125 return Err(error::HideSomethingError::TooShortData);
126 }
127
128 let len_bytes: [u8; 4] = [raw_bytes[0], raw_bytes[1], raw_bytes[2], raw_bytes[3]];
130 let data_len = u32::from_be_bytes(len_bytes) as usize;
131 let compressed = &raw_bytes[4..4 + data_len];
132
133 let decompressed = flate2_decompress(compressed)?;
135
136 Ok(String::from_utf8(decompressed)?)
138}
139
140fn flate2_compress<T>(info: T) -> Result<Vec<u8>, error::HideSomethingError>
144where
145 T: ToString,
146{
147 let mut e = DeflateEncoder::new(Vec::new(), Compression::fast());
148 e.write_all(&info.to_string().into_bytes())?;
149 Ok(e.finish()?)
150}
151
152fn flate2_decompress(data: &[u8]) -> Result<Vec<u8>, error::HideSomethingError> {
154 let mut decoder = DeflateDecoder::new(data);
155 let mut out = Vec::new();
156 decoder.read_to_end(&mut out)?;
157 Ok(out)
158}
159
160fn bytes_to_bits(data: &[u8]) -> impl Iterator<Item = u8> + '_ {
162 data.iter()
163 .flat_map(|&b| (0..8).rev().map(move |i| (b >> i) & 1))
164}
165
166fn bits_to_bytes(bits: &[u8]) -> Vec<u8> {
169 bits.chunks(8)
170 .filter(|chunk| chunk.len() == 8)
171 .map(|chunk| {
172 let mut byte = 0u8;
173 for (i, &bit) in chunk.iter().enumerate() {
174 byte |= bit << (7 - i);
175 }
176 byte
177 })
178 .collect()
179}
180
181#[cfg(test)]
183mod tests {
184 use super::*;
185
186 fn round_trip(original: &str, template: &str) {
188 let hidden = hide_encrypt(original, template).unwrap();
189 let recovered = hide_decrypt(&hidden).unwrap();
190 assert_eq!(recovered, original);
191 }
192
193 #[test]
194 fn test_hide_encrypt_basic() {
195 let info = "123";
198 let template = "Happy Everyday!";
199 let result = hide_encrypt(info, template).unwrap();
200 assert_eq!(
201 result,
202 "happy everyday!happy everyday!hapPy EveRYdaY!HapPY eVerydAY!haPpy everYDay!happy everyday!"
203 );
204 }
205
206 #[test]
207 fn test_hide_decrypt_basic() {
208 let hidden = "happy everyday!happy everyday!hapPy EveRYdaY!HapPY eVerydAY!haPpy everYDay!happy everyday!";
209 let recovered = hide_decrypt(hidden).unwrap();
210 assert_eq!(recovered, "123");
211 }
212
213 #[test]
214 fn test_round_trip_simple() {
215 round_trip("Hello", "abc");
216 round_trip("Rust", "Programming Language");
217 round_trip("123456", "Template");
218 }
219
220 #[test]
221 fn test_round_trip_with_special_chars() {
222 round_trip("Hello, World!", "This is a template.");
224 round_trip("data: 42", "Carrier with spaces and punctuation!");
225 }
226
227 #[test]
228 fn test_round_trip_empty_string() {
229 round_trip("", "Any template");
231 }
232
233 #[test]
234 fn test_round_trip_long_data() {
235 let long = "a".repeat(1000);
236 round_trip(&long, "Short");
237 }
238
239 #[test]
240 fn test_error_carrier_empty() {
241 let result = hide_encrypt("test", "123!@#");
243 assert!(matches!(
244 result,
245 Err(error::HideSomethingError::CarrierTemplateEmpty)
246 ));
247 }
248
249 #[test]
250 fn test_error_too_short_data() {
251 let result = hide_decrypt("abc");
253 assert!(matches!(
254 result,
255 Err(error::HideSomethingError::TooShortData)
256 ));
257 }
258
259 #[test]
262 fn test_hide_encrypt_known_expected() {
263 let info = "hello";
265 let template = "Test";
266 let hidden = hide_encrypt(info, template).unwrap();
267 let recovered = hide_decrypt(&hidden).unwrap();
269 assert_eq!(recovered, "hello");
270 }
271}