Function ghost_encode 

pub fn ghost_encode(
    image_bytes: &[u8],
    message: &str,
    passphrase: &str,
) -> Result<Vec<u8>, StegoError>

Encode a text message into a cover JPEG using Ghost mode.

Arguments

• image_bytes: Raw bytes of the cover JPEG image.
• message: The plaintext message to embed (must fit within capacity).
• passphrase: Used for both structural key derivation and encryption.

Returns

The stego JPEG image as bytes, or an error if the image is too small or the message exceeds the embedding capacity.

Errors

• StegoError::InvalidJpeg if image_bytes is not a valid baseline JPEG.
• StegoError::NoLuminanceChannel if the image has no Y component.
• StegoError::ImageTooSmall if the cover has too few usable coefficients.
• StegoError::MessageTooLarge if the message exceeds STC capacity.

Examples found in repository

examples/test_encode.rs (line 32)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 4 {
        eprintln!("Usage: test_encode <input.jpg> <message> <passphrase>");
        eprintln!("       test_encode --decode <stego.jpg> <passphrase>");
        std::process::exit(1);
    }

    if args[1] == "--decode" {
        let stego = fs::read(&args[2]).expect("Could not read stego image");
        match phasm_core::ghost_decode(&stego, &args[3]) {
            Ok(payload) => {
                println!("Decoded message: {}", payload.text);
                for f in &payload.files {
                    println!("  File: {} ({} bytes)", f.filename, f.content.len());
                }
            }
            Err(e) => eprintln!("Decode failed: {:?}", e),
        }
    } else {
        let cover = fs::read(&args[1]).expect("Could not read cover image");
        let message = &args[2];
        let passphrase = &args[3];

        let stego = phasm_core::ghost_encode(&cover, message, passphrase)
            .expect("Encode failed");

        let out_path = args[1].replace(".jpg", "_stego.jpg").replace(".JPG", "_stego.jpg");
        fs::write(&out_path, &stego).expect("Could not write output");
        println!("Stego image written to: {}", out_path);
        println!("Original: {} bytes, Stego: {} bytes", cover.len(), stego.len());
    }
}