crates.io Build Status codecov

bacon-cipher

An implementation of the Bacon's cipher.

The crate offers codecs that encode / decode and steganographers that hide / reveal encoded messages

Encoding - Decoding

Encode a message to Bacon codes

```rust use baconcipher::codecs::charcodec::CharCodec; use bacon_cipher::BaconCodec; use std::iter::FromIterator;

// Define a Bacon Codec that encodes using the characters 'A' and 'B' let codec = CharCodec::new('A', 'B');

// This is the secret to encode let secret: Vec = "My secret".chars().collect();

// Get the encoded chars let encodedchars = codec.encode(&secret); let encodedstring = String::fromiter(encodedchars.iter());

asserteq!("ABABBBABBABAAABAABAAAAABABAAAAAABAABAABA", encodedstring); ```

Decode Bacon codes

```rust use baconcipher::codecs::charcodec::CharCodec; use bacon_cipher::BaconCodec; use std::iter::FromIterator;

// Define a Bacon Codec that encodes using the characters 'A' and 'B' let codec = CharCodec::new('A', 'B');

// These are the encoded characters let encoded_chars: Vec = "ABABBBABBABAAABAABAAAAABABAAAAAABAABAABA".chars().collect();

// Retrieve the decoded chars let decoded = codec.decode(&encodedchars); let string = String::fromiter(decoded.iter());

assert_eq!("MYSECRET", string); ```

Steganography

Disguise a hidden message into a public one

```rust use baconcipher::codecs::charcodec::CharCodec; use baconcipher::stega::lettercase::LetterCaseSteganographer; use bacon_cipher::{BaconCodec, Steganographer}; use std::iter::FromIterator;

// Define a Bacon Codec that encodes using the characters 'A' and 'B' let codec = CharCodec::new('a', 'b');

// Apply steganography based on the case of the characters let s = LetterCaseSteganographer::new();

// This is the public message in which we want to hide the secret one. let public_chars: Vec = "This is a public message that contains a secret one".chars().collect();

// This is the message that we want to hide. let secret_chars: Vec = "My secret".chars().collect();

// This is the public message that contains the secret one let disguisedpublic = s.disguise(&secretchars, &publicchars, &codec); let string = String::fromiter(disguised_public.unwrap().iter());

assert!(string == "tHiS IS a PUbLic mEssAge thaT cOntains A seCreT one"); ```

Reveal a hidden message from a public one

```rust use baconcipher::codecs::charcodec::CharCodec; use baconcipher::stega::lettercase::LetterCaseSteganographer; use bacon_cipher::{BaconCodec, Steganographer}; use std::iter::FromIterator;

// Define a Bacon Codec that encodes using the characters 'A' and 'B' let codec = CharCodec::new('a', 'b');

// Apply steganography based on the case of the characters let s = LetterCaseSteganographer::new();

// This is the public message that contains a hidden message let public_chars: Vec = "tHiS IS a PUbLic mEssAge thaT cOntains A seCreT one".chars().collect();

// This is the hidden message let output = s.reveal(&publicchars, &codec); let hiddenmessage = String::fromiter(output.unwrap().iter()); assert!(hiddenmessage.starts_with("MYSECRET"));

```

Licence

At your option, under: