Skip to main content

ghost_decode

phasm_core::stego

Function ghost_decode 

Source 
pub fn ghost_decode(
    stego_bytes: &[u8],
    passphrase: &str,
) -> Result<PayloadData, StegoError>
Expand description

Decode a payload from a stego JPEG using Ghost mode.

Returns the decoded text and any embedded files.

§Errors

Examples found in repository?
examples/test_timing.rs (line 30)
12fn main() {
13    let args: Vec<String> = std::env::args().collect();
14    let path = args.get(1).map_or("/tmp/phasm_shared.jpg", |s| s.as_str());
15    let img = std::fs::read(path).unwrap_or_else(|e| {
16        eprintln!("Error reading {path}: {e}");
17        std::process::exit(1);
18    });
19    eprintln!("Image: {} bytes", img.len());
20
21    let start = Instant::now();
22    eprintln!("Trying Armor decode...");
23    match armor_decode(&img, "") {
24        Ok((p, q)) => eprintln!("ARMOR SUCCESS: text='{}' integrity={:.1}% [{:.1}s]", p.text, q.integrity_percent, start.elapsed().as_secs_f64()),
25        Err(e) => eprintln!("ARMOR FAILED: {:?} [{:.1}s]", e, start.elapsed().as_secs_f64()),
26    }
27
28    let start2 = Instant::now();
29    eprintln!("Trying Ghost decode...");
30    match ghost_decode(&img, "") {
31        Ok(p) => eprintln!("GHOST SUCCESS: text='{}' [{:.1}s]", p.text, start2.elapsed().as_secs_f64()),
32        Err(e) => eprintln!("GHOST FAILED: {:?} [{:.1}s]", e, start2.elapsed().as_secs_f64()),
33    }
34}
More examples
Hide additional examples
examples/test_encode.rs (line 18)
8fn main() {
9    let args: Vec<String> = std::env::args().collect();
10    if args.len() < 4 {
11        eprintln!("Usage: test_encode <input.jpg> <message> <passphrase>");
12        eprintln!("       test_encode --decode <stego.jpg> <passphrase>");
13        std::process::exit(1);
14    }
15
16    if args[1] == "--decode" {
17        let stego = fs::read(&args[2]).expect("Could not read stego image");
18        match phasm_core::ghost_decode(&stego, &args[3]) {
19            Ok(payload) => {
20                println!("Decoded message: {}", payload.text);
21                for f in &payload.files {
22                    println!("  File: {} ({} bytes)", f.filename, f.content.len());
23                }
24            }
25            Err(e) => eprintln!("Decode failed: {:?}", e),
26        }
27    } else {
28        let cover = fs::read(&args[1]).expect("Could not read cover image");
29        let message = &args[2];
30        let passphrase = &args[3];
31
32        let stego = phasm_core::ghost_encode(&cover, message, passphrase)
33            .expect("Encode failed");
34
35        let out_path = args[1].replace(".jpg", "_stego.jpg").replace(".JPG", "_stego.jpg");
36        fs::write(&out_path, &stego).expect("Could not write output");
37        println!("Stego image written to: {}", out_path);
38        println!("Original: {} bytes, Stego: {} bytes", cover.len(), stego.len());
39    }
40}