use flate2::{Compression, read::DeflateDecoder, write::DeflateEncoder};
use std::io::{Read, Write};
use crate::error;
pub fn hide_encrypt<T>(info: T, carrier_template: &str) -> Result<String, error::HideSomethingError>
where
T: ToString,
{
let compressed = flate2_compress(info)?;
let mut payload = Vec::new();
payload.extend_from_slice(&(compressed.len() as u32).to_be_bytes());
payload.extend_from_slice(&compressed);
let bits: Vec<u8> = bytes_to_bits(&payload).collect();
let needed_bits = bits.len();
let mut carrier = String::new();
let template_letters: Vec<char> = carrier_template
.chars()
.filter(|c| c.is_alphabetic())
.collect();
if template_letters.is_empty() {
return Err(error::HideSomethingError::CarrierTemplateEmpty);
}
while carrier.chars().filter(|c| c.is_alphabetic()).count() < needed_bits {
carrier.push_str(carrier_template);
}
let chars: Vec<char> = carrier.chars().collect();
let mut bit_iter = bits.into_iter();
let mut result = String::with_capacity(chars.len());
for ch in chars {
if ch.is_alphabetic() {
if let Some(bit) = bit_iter.next() {
if bit == 1 {
result.push(ch.to_ascii_uppercase());
} else {
result.push(ch.to_ascii_lowercase());
}
} else {
result.push(ch);
}
} else {
result.push(ch);
}
}
Ok(result)
}
pub fn hide_decrypt<T>(info: T) -> Result<String, error::HideSomethingError>
where
T: ToString,
{
let bits: Vec<u8> = info
.to_string()
.chars()
.filter(|c| c.is_alphabetic())
.map(|c| if c.is_uppercase() { 1 } else { 0 })
.collect();
let raw_bytes = bits_to_bytes(&bits);
if raw_bytes.len() < 4 {
return Err(error::HideSomethingError::TooShortData);
}
let len_bytes: [u8; 4] = [raw_bytes[0], raw_bytes[1], raw_bytes[2], raw_bytes[3]];
let data_len = u32::from_be_bytes(len_bytes) as usize;
let compressed = &raw_bytes[4..4 + data_len];
let decompressed = flate2_decompress(compressed)?;
Ok(String::from_utf8(decompressed)?)
}
fn flate2_compress<T>(info: T) -> Result<Vec<u8>, error::HideSomethingError>
where
T: ToString,
{
let mut e = DeflateEncoder::new(Vec::new(), Compression::fast());
e.write_all(&info.to_string().into_bytes())?;
Ok(e.finish()?)
}
fn flate2_decompress(data: &[u8]) -> Result<Vec<u8>, error::HideSomethingError> {
let mut decoder = DeflateDecoder::new(data);
let mut out = Vec::new();
decoder.read_to_end(&mut out)?;
Ok(out)
}
fn bytes_to_bits(data: &[u8]) -> impl Iterator<Item = u8> + '_ {
data.iter()
.flat_map(|&b| (0..8).rev().map(move |i| (b >> i) & 1))
}
fn bits_to_bytes(bits: &[u8]) -> Vec<u8> {
bits.chunks(8)
.filter(|chunk| chunk.len() == 8)
.map(|chunk| {
let mut byte = 0u8;
for (i, &bit) in chunk.iter().enumerate() {
byte |= bit << (7 - i);
}
byte
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn round_trip(original: &str, template: &str) {
let hidden = hide_encrypt(original, template).unwrap();
let recovered = hide_decrypt(&hidden).unwrap();
assert_eq!(recovered, original);
}
#[test]
fn test_hide_encrypt_basic() {
let info = "123";
let template = "Happy Everyday!";
let result = hide_encrypt(info, template).unwrap();
assert_eq!(
result,
"happy everyday!happy everyday!hapPy EveRYdaY!HapPY eVerydAY!haPpy everYDay!happy everyday!"
);
}
#[test]
fn test_hide_decrypt_basic() {
let hidden = "happy everyday!happy everyday!hapPy EveRYdaY!HapPY eVerydAY!haPpy everYDay!happy everyday!";
let recovered = hide_decrypt(hidden).unwrap();
assert_eq!(recovered, "123");
}
#[test]
fn test_round_trip_simple() {
round_trip("Hello", "abc");
round_trip("Rust", "Programming Language");
round_trip("123456", "Template");
}
#[test]
fn test_round_trip_with_special_chars() {
round_trip("Hello, World!", "This is a template.");
round_trip("data: 42", "Carrier with spaces and punctuation!");
}
#[test]
fn test_round_trip_empty_string() {
round_trip("", "Any template");
}
#[test]
fn test_round_trip_long_data() {
let long = "a".repeat(1000);
round_trip(&long, "Short");
}
#[test]
fn test_error_carrier_empty() {
let result = hide_encrypt("test", "123!@#");
assert!(matches!(result, Err(error::HideSomethingError::CarrierTemplateEmpty)));
}
#[test]
fn test_error_too_short_data() {
let result = hide_decrypt("abc");
assert!(matches!(result, Err(error::HideSomethingError::TooShortData)));
}
#[test]
fn test_hide_encrypt_known_expected() {
let info = "hello";
let template = "Test";
let hidden = hide_encrypt(info, template).unwrap();
let recovered = hide_decrypt(&hidden).unwrap();
assert_eq!(recovered, "hello");
}
}