An implementation of the Bacon's cipher.
The crate offers codecs that encode / decode and steganographers that hide / reveal encoded messages.
Available codecs:
CharCodec: A codec that encodes data of type char.
The encoding is done by substituting with two given elements (elem_a and elem_b) of type T.
The substitution is done using the first version of the Bacon's cipher.
CharCodecV2: A codec that encodes data of type char.
The encoding is done by substituting with two given elements (elem_a and elem_b) of type T.
The substitution is done using the second version of the Bacon's cipher.
Available steganographers:
LetterCaseSteganographer: Applies steganography based on the case of the characters.
E.g. Lowercase for Bacon's element A, capital for Bacon's element B.
MarkdownSteganographer: Applies steganography based on Markdown tags that surround elements.
E.g. Sourround an element with ** for Bacon's element A and the rest of the elements are considered as Bacon's element B.
SimpleTagSteganographer: Applies steganography based on HTML or XML tags that surround elements. (needs the feature extended-steganography)
E.g. Sourround an element with <b> and </b> for Bacon's element A and with <i> and </i> for Bacon's element B.
```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
// Get the encoded chars let encodedchars = codec.encode(&secret); let encodedstring = String::fromiter(encodedchars.iter());
asserteq!("ABABBBABBABAAABAABAAAAABABAAAAAABAABAABA", encodedstring); ```
```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
// Retrieve the decoded chars let decoded = codec.decode(&encodedchars); let string = String::fromiter(decoded.iter());
assert_eq!("MYSECRET", string); ```
```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 the message that we want to hide.
let secret_chars: Vec
// 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"); ```
```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 the hidden message let output = s.reveal(&publicchars, &codec); let hiddenmessage = String::fromiter(output.unwrap().iter()); assert!(hiddenmessage.starts_with("MYSECRET"));
```
```rust use baconcipher::codecs::charcodec::CharCodec; use baconcipher::stega::markdown::{MarkdownSteganographer, Marker}; use baconcipher::{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 Markdown markers let s = MarkdownSteganographer::new( Marker::empty(), Marker::new( Some(""), Some(""))).unwrap();
// This is the public message in which we want to hide the secret one. let public = "This is a public message that contains a secret one";
// This is the message that we want to hide.
let secret_chars: Vec
let output = s.disguise( &secretchars, &Vec::fromiter(public.chars()), &codec); let string = String::from_iter(output.unwrap().iter()); assert!(string == "This is a public message that contains a secret one"); ```
```rust use baconcipher::codecs::charcodec::CharCodec; use baconcipher::stega::markdown::{MarkdownSteganographer, Marker}; use baconcipher::{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 Markdown markers let s = MarkdownSteganographer::new( Marker::empty(), Marker::new( Some(""), Some(""))).unwrap();
// This is the public message that contains a hidden message let public = "This is a public message that contains a secret one";
// This is the hidden message let output = s.reveal( &Vec::fromiter(public.chars()), &codec); assert!(output.isok()); let string = String::fromiter(output.unwrap().iter()); assert!(string.startswith("MYSECRET")); ```
At your option, under: