Struct Obfuscator 

pub struct Obfuscator { /* private fields */ }

The main obfuscator struct that provides text obfuscation functionality

Implementations

impl Obfuscator

pub fn new(passphrase: &[u8]) -> Self

Creates a new Obfuscator with the given passphrase

Arguments

• passphrase - The passphrase used for encryption/decryption

Panics

Panics if the passphrase is empty

Examples

use rustfuscator::Obfuscator;

let obfuscator = Obfuscator::new("my-secure-passphrase".as_bytes());

Examples found in repository

examples/obfuscate.rs (line 5)

fn main() {
    let original_text = "simple text or password";
    let o = Obfuscator::new("randompassphrase".as_bytes())
        .with_salt_length(6)
        .with_separator(rustfuscator::DEFAULT_SEPARATOR_STR);

    // obfuscate
    match o.obfuscate(original_text) {
        Ok(obfuscated_text) => {
            println!("Obfuscated text: {}", obfuscated_text);

            // unobfuscate
            match o.unobfuscate(&obfuscated_text) {
                Ok(unobfuscated_text) => {
                    println!("Unobfuscated text: {}", unobfuscated_text);
                }
                Err(err) => {
                    println!("Error: {}", err);
                }
            }
        }
        Err(err) => {
            println!("Error: {}", err);
        }
    }
}

pub fn with_salt_length(self, length: u8) -> Self

Sets a custom salt length

Arguments

• length - The salt length in bytes

Panics

Panics if the salt length is 0

Examples

use rustfuscator::Obfuscator;

let obfuscator = Obfuscator::new("passphrase".as_bytes())
    .with_salt_length(16);

Examples found in repository

examples/obfuscate.rs (line 6)

fn main() {
    let original_text = "simple text or password";
    let o = Obfuscator::new("randompassphrase".as_bytes())
        .with_salt_length(6)
        .with_separator(rustfuscator::DEFAULT_SEPARATOR_STR);

    // obfuscate
    match o.obfuscate(original_text) {
        Ok(obfuscated_text) => {
            println!("Obfuscated text: {}", obfuscated_text);

            // unobfuscate
            match o.unobfuscate(&obfuscated_text) {
                Ok(unobfuscated_text) => {
                    println!("Unobfuscated text: {}", unobfuscated_text);
                }
                Err(err) => {
                    println!("Error: {}", err);
                }
            }
        }
        Err(err) => {
            println!("Error: {}", err);
        }
    }
}

pub fn with_separator(self, separator: &str) -> Self

Sets a custom separator for the obfuscated string parts

Arguments

• separator - The separator string

Examples

use rustfuscator::Obfuscator;

let obfuscator = Obfuscator::new("passphrase".as_bytes())
    .with_separator("#");

Examples found in repository

examples/obfuscate.rs (line 7)

fn main() {
    let original_text = "simple text or password";
    let o = Obfuscator::new("randompassphrase".as_bytes())
        .with_salt_length(6)
        .with_separator(rustfuscator::DEFAULT_SEPARATOR_STR);

    // obfuscate
    match o.obfuscate(original_text) {
        Ok(obfuscated_text) => {
            println!("Obfuscated text: {}", obfuscated_text);

            // unobfuscate
            match o.unobfuscate(&obfuscated_text) {
                Ok(unobfuscated_text) => {
                    println!("Unobfuscated text: {}", unobfuscated_text);
                }
                Err(err) => {
                    println!("Error: {}", err);
                }
            }
        }
        Err(err) => {
            println!("Error: {}", err);
        }
    }
}

pub fn obfuscate(&self, text: &str) -> Result<String, ObfuscatorError>

Obfuscates the given text using the configured passphrase

Arguments

• text - The text to obfuscate

Returns

• Result<String, ObfuscatorError> - The obfuscated string or an error

Examples

use rustfuscator::Obfuscator;

let obfuscator = Obfuscator::new("passphrase".as_bytes());
let obfuscated = obfuscator.obfuscate("Hello, World!").unwrap();
println!("Obfuscated: {}", obfuscated);

Examples found in repository

examples/obfuscate.rs (line 10)

fn main() {
    let original_text = "simple text or password";
    let o = Obfuscator::new("randompassphrase".as_bytes())
        .with_salt_length(6)
        .with_separator(rustfuscator::DEFAULT_SEPARATOR_STR);

    // obfuscate
    match o.obfuscate(original_text) {
        Ok(obfuscated_text) => {
            println!("Obfuscated text: {}", obfuscated_text);

            // unobfuscate
            match o.unobfuscate(&obfuscated_text) {
                Ok(unobfuscated_text) => {
                    println!("Unobfuscated text: {}", unobfuscated_text);
                }
                Err(err) => {
                    println!("Error: {}", err);
                }
            }
        }
        Err(err) => {
            println!("Error: {}", err);
        }
    }
}

pub fn unobfuscate( &self, obfuscated_text: &str, ) -> Result<String, ObfuscatorError>

Unobfuscates the given obfuscated text using the configured passphrase

Arguments

• obfuscated_text - The obfuscated text to unobfuscate

Returns

• Result<String, ObfuscatorError> - The original text or an error

Examples

use rustfuscator::Obfuscator;

let obfuscator = Obfuscator::new("passphrase".as_bytes());
let obfuscated = obfuscator.obfuscate("Hello, World!").unwrap();
let unobfuscated = obfuscator.unobfuscate(&obfuscated).unwrap();
assert_eq!(unobfuscated, "Hello, World!");

Examples found in repository

examples/obfuscate.rs (line 15)

fn main() {
    let original_text = "simple text or password";
    let o = Obfuscator::new("randompassphrase".as_bytes())
        .with_salt_length(6)
        .with_separator(rustfuscator::DEFAULT_SEPARATOR_STR);

    // obfuscate
    match o.obfuscate(original_text) {
        Ok(obfuscated_text) => {
            println!("Obfuscated text: {}", obfuscated_text);

            // unobfuscate
            match o.unobfuscate(&obfuscated_text) {
                Ok(unobfuscated_text) => {
                    println!("Unobfuscated text: {}", unobfuscated_text);
                }
                Err(err) => {
                    println!("Error: {}", err);
                }
            }
        }
        Err(err) => {
            println!("Error: {}", err);
        }
    }
}