chapter-2/chapter-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "16ef4aae-e71b-4940-8c47-76d1426f3c7c",
   "metadata": {},
   "source": [
    "# Chapter 2: Hidden Threads - Mastering the Art of Steganography in Rust\n",
    "\n",
    "## Introduction\n",
    "\n",
    "At the core of this fascinating chapter lies the perplexing art of [**steganography**](https://en.wikipedia.org/wiki/Steganography), a term derived from the fusion of two ancient Greek words - \"steganos\", meaning \"to cover or protect,\" and \"graphien\", signifying \"to write.\" In the vast domain of [**cybersecurity**](https://en.wikipedia.org/wiki/Computer_security), steganography serves as a captivating technique, like a digital cover, hiding valuable data within the seemingly innocent façade of images. This practice has become routine within the security community, a skill where practitioners adeptly navigate the delicate balance between hiding and disclosure. In essence, steganography empowers security professionals to embed payloads secretly, patiently awaiting the opportune moment for extraction once the data reaches its intended destination.\n",
    "\n",
    "As we kick off this chapter through the complexities of steganography, our focus sharpens on the security landscape, where the art of hiding and revealing data takes center stage. The essence of this practice lies in the ingenious hiding of information within the very fabric of images. Like a hidden message within a painting, steganography allows security practitioners to obscure critical payloads within the pixels of images, laying the groundwork for secret communication. This chapter, which is like a roadmap through the hidden passages of digital secrecy, reveals the techniques and procedures employed in this confidential art, offering insights into the methods that security professionals employ to navigate this delicate dance of data manipulation.\n",
    "\n",
    "The chapter, like a guidebook for digital spies, delves into the practical aspects of this obscuring art, particularly focusing on the embedding of data within [**Portable Network Graphics (PNG)**](https://en.wikipedia.org/wiki/PNG) images. The PNG format, known for its ubiquity and versatility, becomes the canvas upon which the steganographer paints hidden messages. The journey through this chapter promises a deep dive into the complexities of PNG files, exploring their byte structure, decoding headers, and cracking the sequence of chunks that define the anatomy of these digital canvases. In essence, the chapter stands as a beacon for those navigating the maze of steganography, offering both theoretical insights and practical wisdom for concealing and unveiling secrets within the digital realm."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec4ed77-fddd-4358-85b8-401115926814",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "* [**Exploring the PNG Format**](#1.-Exploring-the-PNG-Format)\n",
    "* [**Reading a PNG File**](#2.-Reading-a-PNG-File)\n",
    "* [**Hiding a secret in a PNG File**](#3.-Hiding-a-secret-in-a-PNG-File)\n",
    "    * [**Locating an offset**](#3.1-Locating-an-offset)\n",
    "    * [**Writing the payload**](#3.2-Writing-the-payload)\n",
    "    * [**Encoding a payload using a simple XOR operation**](#3.3-Encoding-a-payload-using-a-simple-XOR-operation)\n",
    "    * [**Encode and Inject a payload program**](#3.4-Encode-and-Inject-a-payload-program)\n",
    "* [**Revealing a secret from a PNG Film**](#4.-Revealing-a-secret-from-a-PNG-File)\n",
    "* [**Test Cases**](#5.-Test-Cases)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccc15f26-08eb-425e-8875-c6265b6de47c",
   "metadata": {},
   "source": [
    "## 1. Exploring the PNG Format\n",
    "\n",
    "To kick off our journey of embedding data within the PNG format, we must first understand the complex byte curtain that constitutes a binary PNG image file. The PNG specification, accessible at [**libpng.org**](http://www.libpng.org/pub/png/spec/1.2/PNG-Structure.html#PNG-file-signature), becomes our compass in navigating this digital landscape. Within this knowledge, byte chunks incorporate the fabric of PNG images, creating a canvas where our steganographic secrets will find their hiding places. These chunks, repetitive in nature, lay the groundwork for our exploration into the hidden domains of data manipulation.\n",
    "\n",
    "**The Enigmatic Header:**\n",
    "\n",
    "![ScreenShot taken from the Bless hex editor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m9y570ydqf6j6f882lwf.png)\n",
    "\n",
    "In the realm of PNG files, our journey begins with the opening eight bytes, forming the magical sequence \"**89 50 4E 47 0D 0A 1A 0A**\". This sequence acts as a secret code, the key that unlocks the PNG world. Picture it like the first musical notes of our steganographic symphony. Now, onto the scene comes the `Header` struct, a kind of container designed to catch these magical bytes.\n",
    "\n",
    "```rust\n",
    "// Header holds the first UINT64 (Magic Bytes)\n",
    "struct Header {\n",
    "    header: u64,\n",
    "}\n",
    "```\n",
    "\n",
    "The `Header` structure is like an artist's canvas waiting for a masterpiece. It holds an unsigned 64-bit integer, a perfect fit for the magical bytes. When we perform a magical act called [**transmutation**](https://doc.rust-lang.org/std/mem/fn.transmute.html), the hidden message \"PNG\" is revealed, almost like a secret handshake granting us access to the **PNG** world. This Header is our guardian, making sure our PNG image is the real deal and giving us the green light to start our work of steganography. It's like the keeper of secrets, ensuring the symphony begins without any interference.\n",
    "\n",
    "**Decoding the Chunk Sequence:**\n",
    "\n",
    "As we venture beyond the surface of the PNG image, we encounter something known as the chunk sequence. This sequence follows structured data of **SIZE** (4 bytes), **TYPE** (4 bytes), **DATA** (variable bytes), and **CRC** (4 bytes). Each chunk is like a puzzle piece in the steganographic mosaic and contributes its unique narrative to the overall story painted within the **PNG** image. The **SIZE** chunk sets the stage, dictating the length of the upcoming **DATA**, while the **TYPE** chunk acts as a sign, revealing the purpose of the data that follows. Our mission is to decode this sequence, uncovering the hidden messages that lie beneath.\n",
    "\n",
    "```rust\n",
    "// Chunk represents a data byte chunk segment\n",
    "struct Chunk {\n",
    "    size: u32,\n",
    "    r#type: u32,\n",
    "    data: Vec<u8>,\n",
    "    crc: u32,\n",
    "}\n",
    "```\n",
    "\n",
    "As we embark on the complexities of steganography within the PNG image, the `MetaChunk` structure emerges as our reliable companion, illuminating the path through the concealed landscape of digital storytelling. Picture the `MetaChunk` as our guide, equipped with the tools to decode the complexities hidden within each segment of our steganographic work.\n",
    "\n",
    "```rust\n",
    "// MetaChunk structure orchestrating the steganographic journey\n",
    "struct MetaChunk {\n",
    "    header: Header,\n",
    "    chk: Chunk,\n",
    "    offset: u64,\n",
    "}\n",
    "```\n",
    "\n",
    "The `MetaChunk` will navigate us through the hidden landscapes of binary complexities. Its fields, such as the `header` and `chk` (representing the Header and Chunk structures, respectively), are our compass and map, ensuring we stay on course through this steganographic work. The `offset`, is like a GPS coordinate, pinpoints our location within the byte landscape, marking the starting point of each chunk segment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89748640-055c-4673-8d80-e9e71e886eb8",
   "metadata": {},
   "source": [
    "## 2. Reading a PNG File\n",
    "\n",
    "**Preprocessing the Image:**\n",
    "The `pre_process_image` function, our initiation into the PNG world, transforms the PNG image into a readable script. It's the first step in turning a PNG image, which seems like a puzzle, into something we can read and work with. This function does some important things to make that happen.\n",
    "\n",
    "```rust\n",
    "// Implementation of MetaChunk, defining a function `pre_process_image` that processes a PNG image file\n",
    "impl MetaChunk {\n",
    "    fn pre_process_image(file: &mut File) -> Result<MetaChunk, std::io::Error> {\n",
    "        // Creating a Header struct to hold the first 8 bytes of the PNG image\n",
    "        let mut header = Header { header: 0 };\n",
    "        // Reading exactly 8 bytes from the file into the header using unsafe operations\n",
    "        file.read_exact(unsafe { mem::transmute::<_, &mut [u8; 8]>(&mut header.header) })?;\n",
    "\n",
    "        // Converting the header bytes from u64 to u8 array\n",
    "        let b_arr = u64_to_u8_array(header.header);\n",
    "\n",
    "        // Checking if the PNG magic bytes are present in the file\n",
    "        if &b_arr[1..4] != b\"PNG\" {\n",
    "            // If not, panicking and terminating the program with an error message\n",
    "            panic!(\"Provided file is not a valid PNG format\");\n",
    "        } else {\n",
    "            // If yes, printing a confirmation message\n",
    "            println!(\"It is a valid PNG file. Let's process it!\");\n",
    "        }\n",
    "\n",
    "        // Getting the current position (offset) in the file and storing it\n",
    "        let offset = file.seek(SeekFrom::Current(0))?;\n",
    "\n",
    "        // Returning a `MetaChunk` struct instance with the obtained header, an initial Chunk, and the offset\n",
    "        Ok(MetaChunk {\n",
    "            header,\n",
    "            chk: Chunk {\n",
    "                size: 0,\n",
    "                r#type: 0,\n",
    "                data: Vec::new(),\n",
    "                crc: 0,\n",
    "            },\n",
    "            offset,\n",
    "        })\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "Once initiated, validation becomes crucial. This method inspect the first eight bytes, ensuring their adherence to the PNG format. The magic bytes unfold, and if the decoded message aligns with \"PNG\", the gateway to our steganographic exploration swings open.\n",
    "\n",
    "**Reading through Chunk Sequences:**\n",
    "\n",
    "![ScreenShot taken from the Bless hex editor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/33kasxf4cstfnq5ak2l8.png)\n",
    "\n",
    "Our journey into the PNG landscape is marked by the `process_image` function, a blend of code orchestrating the navigation through chunks. A loop, a recurring motif, guides the traversal through each chunk. The `count` becomes our companion, marking each chunk's unveiling in this steganographic manuscript.\n",
    "\n",
    "```rust\n",
    "fn process_image(&mut self, file: &mut File) {\n",
    "    let mut count = 1;\n",
    "    let mut chunk_type = String::new();\n",
    "    let end_chunk_type = \"IEND\";\n",
    "    \n",
    "    while chunk_type != end_chunk_type {\n",
    "        println!(\"---- Chunk # {} ----\", count);\n",
    "        let offset = self.get_offset(file);\n",
    "        println!(\"Chunk Offset: {:x}\", offset);\n",
    "        self.read_chunk(file);\n",
    "        chunk_type = self.chunk_type_to_string();\n",
    "        count += 1;\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Charting Coordinates with Offset:**\n",
    "\n",
    "In this exploration, awareness of our position within the PNG image becomes imperative. The `get_offset` method, a virtual compass, captures the coordinates of each chunk. The [**`seek`**](https://doc.rust-lang.org/std/io/trait.Seek.html#tymethod.seek) function, a navigator's tool, unfolds the map of offsets, guiding our steganographic ship through the PNG terrain. It moves to an offset, in bytes, in the file stream.\n",
    "\n",
    "```rust\n",
    "fn get_offset(&mut self, data: &mut File) -> u64 {\n",
    "    let offset = data.seek(SeekFrom::Current(0)).unwrap();\n",
    "    self.offset = offset;\n",
    "    offset\n",
    "}\n",
    "```\n",
    "\n",
    "**Deciphering Chunk by Chunk:**\n",
    "\n",
    "The heart of our steganographic novel lies in the `read_chunk` method—a meticulous deciphering of each chunk's data. The synchronization of `read_chunk_size`, `read_chunk_type`, `read_chunk_bytes`, and `read_chunk_crc` becomes a choreography of bytes, each revealing a distinct aspect of the hidden bytes.\n",
    "\n",
    "```rust\n",
    "fn read_chunk(&mut self, data: &mut File) {\n",
    "    self.read_chunk_size(data);\n",
    "    self.read_chunk_type(data);\n",
    "    self.read_chunk_bytes(data, self.chk.size);\n",
    "    self.read_chunk_crc(data);\n",
    "}\n",
    "```\n",
    "\n",
    "**Transcribing the Size Chunk:**\n",
    "\n",
    "The `read_chunk_size` method reads the size of each chunk. The `size_bytes` variable holds the essence of the chunk size on the paper of our steganographic manuscript.\n",
    "\n",
    "```rust\n",
    "fn read_chunk_size(&mut self, data: &mut File) {\n",
    "    let mut size_bytes = [0; 4];\n",
    "\n",
    "    match data.read_exact(&mut size_bytes) {\n",
    "        Ok(_) => {\n",
    "            self.chk.size = u32::from_be_bytes(size_bytes);\n",
    "        }\n",
    "        Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "            eprintln!(\"Warning: Reached end of file prematurely while reading chunk size\");\n",
    "        }\n",
    "        Err(err) => {\n",
    "            eprintln!(\"Error reading chunk size bytes: {}\", err);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Decoding the Chunk Type:**\n",
    "The `read_chunk_type` method deciphers the type of each chunk.\n",
    "\n",
    "```rust\n",
    "fn read_chunk_type(&mut self, data: &mut File) {\n",
    "    let mut type_bytes = [0; 4];\n",
    "\n",
    "    match data.read_exact(&mut type_bytes) {\n",
    "        Ok(_) => {\n",
    "            self.chk.r#type = u32::from_be_bytes(type_bytes);\n",
    "        }\n",
    "        Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "            eprintln!(\"Warning: Reached end of file prematurely while reading chunk type\");\n",
    "        }\n",
    "        Err(err) => {\n",
    "            eprintln!(\"Error reading chunk type bytes: {}\", err);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Reading the Chunk's Bytes:**\n",
    "The `read_chunk_bytes` method reads each chunk of the image file given a number of bytes.\n",
    "\n",
    "```rust\n",
    "fn read_chunk_bytes(&mut self, data: &mut File, len: u32) {\n",
    "    self.chk.data = vec![0; len as usize];\n",
    "\n",
    "    match data.read_exact(&mut self.chk.data) {\n",
    "        Ok(_) => {\n",
    "            // Successfully read the expected number of bytes\n",
    "        }\n",
    "        Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "            eprintln!(\"Error reading chunk bytes: Reached end of file prematurely\");\n",
    "            self.chk\n",
    "                .data\n",
    "                .truncate(data.seek(SeekFrom::Current(0)).unwrap() as usize);\n",
    "        }\n",
    "        Err(err) => {\n",
    "            eprintln!(\"Error reading chunk bytes: {}\", err);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "**Decoding the Chunk's CRC:**\n",
    "The `read_chunk_crc` method takes on the role of the guardian, deciphering the script's integrity. The CRC bytes ensure that the essence of the chunk remains unaltered.\n",
    "\n",
    "```rust\n",
    "fn read_chunk_crc(&mut self, data: &mut File) {\n",
    "    let mut crc_bytes = [0; 4];\n",
    "\n",
    "    match data.read_exact(&mut crc_bytes) {\n",
    "        Ok(_) => {\n",
    "            self.chk.crc = u32::from_be_bytes(crc_bytes);\n",
    "        }\n",
    "        Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "            eprintln!(\"Warning: Reached end of file prematurely while reading chunk CRC\");\n",
    "        }\n",
    "        Err(err) => {\n",
    "            eprintln!(\"Error reading chunk CRC bytes: {}\", err);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "As the stenographic odyssey unfolds, each line of code becomes a step in deciphering the hidden canvas of PNG images. The orchestration of structs, functions, and bytes creates a symphony that resonates with the heartbeat of steganography. With every offset, chunk, and byte, the cover over PNG's secrets slowly lifts, revealing a digital narrative waiting to be explored.\n",
    "\n",
    "Now, let's put it all together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c4c5e390-3536-418e-a82e-71a6c6a5bed8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n",
      "---- Chunk # 1 ----\n",
      "Chunk Offset: 8\n",
      "---- Chunk # 2 ----\n",
      "Chunk Offset: 21\n",
      "---- Chunk # 3 ----\n",
      "Chunk Offset: 2e\n",
      "---- Chunk # 4 ----\n",
      "Chunk Offset: 203a\n",
      "---- Chunk # 5 ----\n",
      "Chunk Offset: 4046\n",
      "---- Chunk # 6 ----\n",
      "Chunk Offset: 6052\n",
      "---- Chunk # 7 ----\n",
      "Chunk Offset: 805e\n",
      "---- Chunk # 8 ----\n",
      "Chunk Offset: a06a\n",
      "---- Chunk # 9 ----\n",
      "Chunk Offset: c076\n",
      "---- Chunk # 10 ----\n",
      "Chunk Offset: e082\n",
      "---- Chunk # 11 ----\n",
      "Chunk Offset: 1008e\n",
      "---- Chunk # 12 ----\n",
      "Chunk Offset: 1209a\n",
      "---- Chunk # 13 ----\n",
      "Chunk Offset: 140a6\n",
      "---- Chunk # 14 ----\n",
      "Chunk Offset: 160b2\n",
      "---- Chunk # 15 ----\n",
      "Chunk Offset: 180be\n",
      "---- Chunk # 16 ----\n",
      "Chunk Offset: 1a0ca\n",
      "---- Chunk # 17 ----\n",
      "Chunk Offset: 1c0d6\n",
      "---- Chunk # 18 ----\n",
      "Chunk Offset: 1e0e2\n",
      "---- Chunk # 19 ----\n",
      "Chunk Offset: 200ee\n",
      "---- Chunk # 20 ----\n",
      "Chunk Offset: 220fa\n",
      "---- Chunk # 21 ----\n",
      "Chunk Offset: 24106\n",
      "---- Chunk # 22 ----\n",
      "Chunk Offset: 26112\n",
      "---- Chunk # 23 ----\n",
      "Chunk Offset: 26d33\n"
     ]
    }
   ],
   "source": [
    "use std::fs::File;\n",
    "use std::io::ErrorKind;\n",
    "use std::io::{Read, Seek, SeekFrom};\n",
    "use std::mem;\n",
    "use std::str;\n",
    "\n",
    "#[derive(Debug)]\n",
    "struct Header {\n",
    "    header: u64,\n",
    "}\n",
    "\n",
    "#[derive(Debug)]\n",
    "struct Chunk {\n",
    "    size: u32,\n",
    "    r#type: u32,\n",
    "    data: Vec<u8>,\n",
    "    crc: u32,\n",
    "}\n",
    "\n",
    "struct MetaChunk {\n",
    "    header: Header,\n",
    "    chk: Chunk,\n",
    "    offset: u64,\n",
    "}\n",
    "\n",
    "fn u64_to_u8_array(value: u64) -> [u8; 8] {\n",
    "    let bytes = value.to_ne_bytes();\n",
    "    let mut result = [0; 8];\n",
    "\n",
    "    unsafe {\n",
    "        result = mem::transmute_copy(&bytes);\n",
    "    }\n",
    "\n",
    "    result\n",
    "}\n",
    "\n",
    "impl MetaChunk {\n",
    "    fn pre_process_image(file: &mut File) -> Result<MetaChunk, std::io::Error> {\n",
    "        let mut header = Header { header: 0 };\n",
    "        file.read_exact(unsafe { mem::transmute::<_, &mut [u8; 8]>(&mut header.header) })?;\n",
    "\n",
    "        let b_arr = u64_to_u8_array(header.header);\n",
    "        if &b_arr[1..4] != b\"PNG\" {\n",
    "            panic!(\"Not a valid PNG format\");\n",
    "        } else {\n",
    "            println!(\"It is a valid PNG file. Let's process it!\");\n",
    "        }\n",
    "\n",
    "        let offset = file.seek(SeekFrom::Current(0))?;\n",
    "        Ok(MetaChunk {\n",
    "            header,\n",
    "            chk: Chunk {\n",
    "                size: 0,\n",
    "                r#type: 0,\n",
    "                data: Vec::new(),\n",
    "                crc: 0,\n",
    "            },\n",
    "            offset,\n",
    "        })\n",
    "    }\n",
    "\n",
    "    fn process_image(&mut self, file: &mut File) {\n",
    "        let mut count = 1;\n",
    "        let mut chunk_type = String::new();\n",
    "        let end_chunk_type = \"IEND\";\n",
    "        \n",
    "        while chunk_type != end_chunk_type {\n",
    "            println!(\"---- Chunk # {} ----\", count);\n",
    "            let offset = self.get_offset(file);\n",
    "            println!(\"Chunk Offset: {:x}\", offset);\n",
    "            self.read_chunk(file);\n",
    "            chunk_type = self.chunk_type_to_string();\n",
    "            count += 1;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn get_offset(&mut self, file: &mut File) -> u64 {\n",
    "        let offset = file.seek(SeekFrom::Current(0)).unwrap();\n",
    "        self.offset = offset;\n",
    "        offset\n",
    "    }\n",
    "\n",
    "    fn read_chunk(&mut self, file: &mut File) {\n",
    "        self.read_chunk_size(file);\n",
    "        self.read_chunk_type(file);\n",
    "        self.read_chunk_bytes(file, self.chk.size);\n",
    "        self.read_chunk_crc(file);\n",
    "    }\n",
    "\n",
    "    fn read_chunk_size(&mut self, file: &mut File) {\n",
    "        let mut size_bytes = [0; 4];\n",
    "\n",
    "        match file.read_exact(&mut size_bytes) {\n",
    "            Ok(_) => {\n",
    "                // Successfully read the expected number of bytes\n",
    "                self.chk.size = u32::from_be_bytes(size_bytes);\n",
    "            }\n",
    "            Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "                // Handle the situation where the file ends before reading the expected bytes\n",
    "                eprintln!(\"Warning: Reached end of file prematurely while reading chunk size\");\n",
    "            }\n",
    "            Err(err) => {\n",
    "                eprintln!(\"Error reading chunk size bytes: {}\", err);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn read_chunk_type(&mut self, file: &mut File) {\n",
    "        let mut type_bytes = [0; 4];\n",
    "\n",
    "        match file.read_exact(&mut type_bytes) {\n",
    "            Ok(_) => {\n",
    "                // Successfully read the expected number of bytes\n",
    "                self.chk.r#type = u32::from_be_bytes(type_bytes);\n",
    "            }\n",
    "            Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "                // Handle the situation where the file ends before reading the expected bytes\n",
    "                eprintln!(\"Warning: Reached end of file prematurely while reading chunk type\");\n",
    "            }\n",
    "            Err(err) => {\n",
    "                eprintln!(\"Error reading chunk type bytes: {}\", err);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn read_chunk_bytes(&mut self, file: &mut File, len: u32) {\n",
    "        self.chk.data = vec![0; len as usize];\n",
    "\n",
    "        match file.read_exact(&mut self.chk.data) {\n",
    "            Ok(_) => {\n",
    "                // Successfully read the expected number of bytes\n",
    "            }\n",
    "            Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "                eprintln!(\"Error reading chunk bytes: Reached end of file prematurely\");\n",
    "                // Update the length of the Chunk based on the actual number of bytes read\n",
    "                self.chk\n",
    "                    .data\n",
    "                    .truncate(file.seek(SeekFrom::Current(0)).unwrap() as usize);\n",
    "            }\n",
    "            Err(err) => {\n",
    "                eprintln!(\"Error reading chunk bytes: {}\", err);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn read_chunk_crc(&mut self, file: &mut File) {\n",
    "        let mut crc_bytes = [0; 4];\n",
    "\n",
    "        match file.read_exact(&mut crc_bytes) {\n",
    "            Ok(_) => {\n",
    "                // Successfully read the expected number of bytes\n",
    "                self.chk.crc = u32::from_be_bytes(crc_bytes);\n",
    "            }\n",
    "            Err(err) if err.kind() == ErrorKind::UnexpectedEof => {\n",
    "                // Handle the situation where the file ends before reading the expected bytes\n",
    "                eprintln!(\"Warning: Reached end of file prematurely while reading CRC\");\n",
    "            }\n",
    "            Err(err) => {\n",
    "                eprintln!(\"Error reading CRC bytes: {}\", err);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    fn chunk_type_to_string(&self) -> String {\n",
    "        String::from_utf8_lossy(&self.chk.r#type.to_be_bytes()).to_string()\n",
    "    }\n",
    "}\n",
    "\n",
    "let mut file = File::open(\"stegano/prj.png\").expect(\"Error opening file\");\n",
    "\n",
    "let mut meta_chunk = MetaChunk::pre_process_image(&mut file).expect(\"Error processing image\");\n",
    "\n",
    "meta_chunk.process_image(&mut file);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "39bae1c1-79da-4671-900f-fba5af7f5a36",
   "metadata": {},
   "source": [
    "![ScreenShot taken from the Bless hex editor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ns2mwc5fe14k677iq0ws.png)\n",
    "\n",
    "The output signifies the successful validation of the PNG file as indicated by the confirmation message, \"It is a valid PNG file. Let's process it!\" This message is printed after checking if the magic bytes \"PNG\" are present in the file.\n",
    "\n",
    "Following this confirmation, the program proceeds to process the PNG file in a chunk-wise manner. Each line in the output corresponds to a different chunk within the PNG file, and the offset value indicates the position of each chunk in hexadecimal format. The term \"Chunk Offset\" is essentially revealing the starting point of each chunk within the file.\n",
    "\n",
    "For instance, the first chunk (Chunk #1) starts at an offset of 8, the second chunk (Chunk #2) at an offset of 21, and so forth. These offsets provide a crucial reference point for navigating and manipulating the image file. In the context of steganography, understanding the position of each chunk becomes essential for hiding and extracting hidden data without corrupting the file structure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a793b7-c652-47c5-a691-46711efe2829",
   "metadata": {},
   "source": [
    "Having meticulously traversed the header of the PNG image and comprehensively processed it in a chunk-wise fashion, we have gained invaluable insights into the complex structure of the image file. The journey has developed as a meticulous exploration of the PNG format, unraveling the magic bytes and delving into the sequential chunks that compose the image.\n",
    "\n",
    "Now armed with the knowledge of how to navigate through the chunks and decipher their offsets, our next work is to embark on the hiding of a message within these layers of data. This entails the artful insertion of our payload into the file, ensuring its secret existence within the seemingly innocent image structure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c04d6c09-a797-4133-8a04-c90a99248a81",
   "metadata": {},
   "source": [
    "## 3. Hiding a secret in a PNG File\n",
    "In the domain of steganography, where plenty of sophisticated techniques exist for embedding payloads, our focus within this particular section will sharpen on the meticulous method of manipulating byte offsets. The PNG file format, our chosen format for this exploration, introduces a structured canvas outlined by additional chunk segments, each carefully defined within its specification. These critical chunks form the ground upon which the image decoder relies for seamless image processing. On the other hand, the additional chunks, while optional, contribute essential metadata that extends beyond the core encoding or decoding processes, including timestamps and textual information.\n",
    "\n",
    "Within this complex framework, the additional chunk type emerges as an opportune target for the strategic injection of payloads. Its non-essential role in the image processing pipeline makes it an ideal candidate for manipulation. Whether through overwriting an existing chunk or delicately introducing an entirely new one, the potential for impactful alteration is vast. This sets the stage for a detailed exploration into the technique of seamlessly inserting new byte slices into the carefully delineated boundaries of an additional chunk segment.\n",
    "\n",
    "To truly grasp the complexities of this method, we must delve deep into the anatomy of the PNG file format, which was already discussed in the previous sections. The critical chunks, acting as the digital scaffolding of the image, house critical data for the image decoder's effective functioning. Contrariwise, the additional chunks, characterized by their optional nature, impart an additional layer of functionality to the file by contributing supplementary metadata. This metadata, while not necessary to the decoding process, adds intrinsic value by encapsulating timestamps and textual details.\n",
    "\n",
    "The deliberate selection of the additional chunk type as the focal point for payload injection derives from its non-critical identification. By opting to overwrite an existing ancillary chunk or introduce a completely new one, the image can be manipulated without compromising its core decoding functionality. In the subsequent sections, we will guide you through a meticulously detailed, step-by-step process, shedding light on the sophisticated art of seamlessly integrating new byte slices into the carefully chosen chunk segment. This journey aims to unravel the complexities of steganographic payload embedding, offering a comprehensive understanding of the interplay between manipulation and the complex landscape of PNG file structures."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35696ba0-13e2-457d-aa01-f7fe3199f056",
   "metadata": {},
   "source": [
    "### 3.1 Locating an offset\n",
    "\n",
    "To pinpoint an appropriate chunk offset, the initial step entails determining an appropriate location within the image data. Revisiting the hex editor, we proceed to walk through the original PNG file while moving toward the end of the image file.\n",
    "\n",
    "Within any valid `PNG` image, an `IEND` chunk type serves as an indicator for the terminal section of the file, signifying the end-of-file (`EOF`) chunk. Precision in this process involves advancing to the 4 bytes immediately preceding the final `SIZE` chunk, strategically situating yourself at the initiation offset of the IEND chunk. This marks the beginning of the arbitrary chunks - whether they be critical or not - encompassed within the overarching PNG file. It's essential to acknowledge that these chunks are optional, making it plausible that the file under examination may not exhibit the same chunks or might lack them altogether. In our illustrative scenario, the offset leading to the IEND chunk originates at an integer offset **159020**, as shown in the following image.\n",
    "\n",
    "![ScreenShot taken from the Bless hex editor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2qjp5mbcym1t7dnzih7l.png)\n",
    "\n",
    "This image visually encapsulates the process of determining a chunk offset in relation to the `IEND` position. The complex interplay of the file's structure unfolds as you navigate through the hex representation, unraveling the spatial arrangement of critical chunks within the `PNG` file. This meticulous exploration ensures a comprehensive understanding of the file's composition, particularly when dealing with optional chunks that contribute to the overall complexity of the `PNG` format. In essence, this methodological approach establishes a foundation for precise offset identification, allowing for an examination of `PNG` files and facilitating informed analysis of their structural complexities."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ac26330-6291-4367-9593-7096667d4fe6",
   "metadata": {},
   "source": [
    "### 3.2 Writing the payload\n",
    "Navigating the complexities of encoding ordered bytes into a byte stream often involves utilizing a Rust struct as a standard approach. The following code snippet orchestrates a sequence of functions that are progressively developed throughout this section.\n",
    "\n",
    "```rust\n",
    "struct CmdArgs {\n",
    "    input: String,\n",
    "    output: String,\n",
    "    meta: bool,\n",
    "    suppress: bool,\n",
    "    offset: String,\n",
    "    inject: bool,\n",
    "    payload: String,\n",
    "    r#type: String,\n",
    "    encode: bool,\n",
    "    decode: bool,\n",
    "    key: String,\n",
    "}\n",
    "\n",
    "impl CmdArgs {\n",
    "    fn new(args: &[String]) -> Result<Self, &'static str> {\n",
    "        if args.len() < 5 {\n",
    "            return Err(\"Not enough arguments. Usage: program input output offset payload\");\n",
    "        }\n",
    "\n",
    "        Ok(CmdArgs {\n",
    "            input: args[1].clone(),\n",
    "            output: args[2].clone(),\n",
    "            meta: false,\n",
    "            suppress: false,\n",
    "            offset: args[3].clone(),\n",
    "            inject: false,\n",
    "            payload: args[4].clone(),\n",
    "            r#type: String::from(\"PNG\"),\n",
    "            encode: args.contains(&String::from(\"encode\")),\n",
    "            decode: args.contains(&String::from(\"decode\")),\n",
    "            key: args[5].clone(),\n",
    "        })\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "The `CmdArgs` struct, as outlined in the above code snippet, encapsulates flag values obtained from command line inputs. These flags play a pivotal role in determining the payload to be utilized and the specific location within the image data for insertion. The struct employs these flags to create a new `MetaChunk` struct instance `meta_chunk`, aligning with the structured format of bytes to be written, mirroring those read from existing chunk segments.\n",
    "\n",
    "```rust\n",
    "fn main() {\n",
    "    let args: Vec<String> = env::args().collect();\n",
    "\n",
    "    let cmd_line_opts = match CmdArgs::new(&args) {\n",
    "        Ok(opts) => opts,\n",
    "        Err(err) => {\n",
    "            eprintln!(\"Error: {}\", err);\n",
    "            return;\n",
    "        }\n",
    "    };\n",
    "\n",
    "    let mut file = File::open(&cmd_line_opts.input).expect(\"Error opening file\");\n",
    "\n",
    "    let mut meta_chunk = MetaChunk::pre_process_image(&mut file).expect(\"Error processing image\");\n",
    "\n",
    "    if cmd_line_opts.encode {\n",
    "        let mut file_writer = File::create(&cmd_line_opts.output).unwrap();\n",
    "\n",
    "        // Calculate CRC for the payload\n",
    "        let mut bytes_msb = Vec::new();\n",
    "        bytes_msb.write_all(&meta_chunk.chk.r#type.to_be_bytes()).unwrap();\n",
    "        bytes_msb.write_all(&cmd_line_opts.payload.as_bytes()).unwrap();\n",
    "        let crc = crc32_little(meta_chunk.chk.crc, &bytes_msb);\n",
    "\n",
    "        // Update the MetaChunk with the encoded data and CRC\n",
    "        meta_chunk.chk.data = encoded_data;\n",
    "        meta_chunk.chk.crc = crc;\n",
    "\n",
    "        // Create a new mutable reference to file_reader\n",
    "        let mut file_reader = &file;\n",
    "\n",
    "        meta_chunk.write_data(&mut file_reader, &cmd_line_opts, &mut file_writer);\n",
    "\n",
    "        println!(\"Image encoded and written successfully!\");\n",
    "    } else if cmd_line_opts.decode {\n",
    "        // TODO: Find and decode the payload\n",
    "        meta_chunk.process_image(&mut file);\n",
    "    }\n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "Upon initializing the `MetaChunk` struct, the next procedural step involves reading the payload into a byte slice `file_writer`. However, this necessitates additional functionality to convert the literal flag values into a practical byte array. The following sections meticulously unravel the complexities of functions such as `marshal_data`, `write_data` contributing to the overall functionality.\n",
    "\n",
    "The difficulties involved in computing the [**CRC32**](https://en.wikipedia.org/wiki/Computation_of_cyclic_redundancy_checks#CRC-32_algorithm) of the chunk mandate the innovative development of a new crate known as [**`crc32-v2`**](https://github.com/wiseaidev/crc32-v2). This remarkable creation stands as the evolutionary successor to the pre-existing [**`crc32`**](https://crates.io/crates/crc32) crate, showing a new era of enhanced functionality and performance in the domain of [**cyclic redundancy checks**](https://en.wikipedia.org/wiki/Cyclic_redundancy_check). The birth of `crc32-v2` signifies a quantum leap in crate evolution, meticulously tailored to address the specific demands and challenges posed by the slightly complex task of CRC32 computation for the chunk. This crate, not only builds upon the foundation laid by its predecessor but also introduces novel methodologies and optimizations (TODO), marking a paradigm shift in the landscape of CRC32 computation in the domain of chunk processing. The crafting of `crc32-v2` is a testament to the relentless pursuit of excellence, where every line of code reflects a synthesis of brilliance and precision, elevating the standards of crate development to unprecedented heights.\n",
    "\n",
    "```rust\n",
    "impl MetaChunk {\n",
    "    fn marshal_data(&self) -> Vec<u8> {\n",
    "        let mut bytes_msb = Vec::new();\n",
    "        bytes_msb.push(self.chk.data.len() as u8);\n",
    "        bytes_msb.write_all(&self.chk.r#type.to_be_bytes()).unwrap();\n",
    "        bytes_msb.write_all(&self.chk.data).unwrap();\n",
    "        bytes_msb.write_all(&self.chk.crc.to_be_bytes()).unwrap();\n",
    "        println!(\"Encoded Payload: {:?}\", bytes_msb);\n",
    "        bytes_msb\n",
    "    }\n",
    "\n",
    "    fn write_data<R: Read + Seek, W: Write>(&self, r: &mut R, c: &CmdArgs, mut w: W) {\n",
    "        // write header at position 0\n",
    "        let b_arr = u64_to_u8_array(self.header.header);\n",
    "        w.write_all(&b_arr).unwrap();\n",
    "        // write from 0 to offset\n",
    "        let offset = i64::from_str(&c.offset).unwrap();\n",
    "        let mut buff = vec![0; offset as usize];\n",
    "        r.read_exact(&mut buff).unwrap();\n",
    "        w.write_all(&buff).unwrap();\n",
    "        // write payload at offset\n",
    "        let data: Vec<u8> = self.marshal_data();\n",
    "        w.write_all(&data).unwrap();\n",
    "        // write from offset to end\n",
    "        // uncomment the following line to preserve the length of the image after manipulation\n",
    "        // r.seek(SeekFrom::Current(data.len().try_into().unwrap())).expect(\"Error seeking to offset\");\n",
    "        copy(r, &mut w).unwrap();\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "Starting with the `marshal_data` method, as shown in the above code snippet, orchestrates the consolidation of all essential chunk information into a bytes buffer, incorporating size, type, data, and checksum. This method plays a pivotal role in preparing the raw bytes of the custom chunk for insertion into the new image file.\n",
    "\n",
    "The final piece of the puzzle lies in the `write_data` function, the struct method as in the previous section. This function accepts a buffer reader `r`, `CmdArgs` struct `c`, and a buffer writer `w` facilitates the creation of a new PNG image by strategically writing the new chunk segment bytes into the specified offset location. The function adeptly handles nuances such as preserving the PNG header bytes, ensuring consistency between the original and modified images.\n",
    "\n",
    "In essence, this complex sequence of methods and functions forms the backbone of a steganography program, seamlessly integrating ordered bytes into a byte stream and topping in the successful injection of a payload as a new chunk. Through careful execution of the command line program, as exemplified in the next section, a new PNG file, namely \"output.png\" is generated, preserving identical leading and trailing chunks while secretly hiding the injected payload.\n",
    "\n",
    "This meticulous exploration is a sense of accomplishment, marking the successful creation of a steganography program that seamlessly integrates ordered bytes into a PNG file, displaying a robust foundation for further exploration and refinement in the realm of data hiding and security."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "469ed0b7-26b0-4ce1-b898-f8244f603241",
   "metadata": {},
   "source": [
    "### 3.3 Encoding a payload using a simple XOR operation\n",
    "\n",
    "In the realm of steganography, where various techniques are employed to obscure data within binary files, an [**obfuscation**](https://en.wikipedia.org/wiki/Obfuscation) method plays a pivotal role. Building upon the groundwork laid in the previous sections, our focus now extends to enhancing the program with the incorporation of obfuscation techniques, thereby hiding the true value of the payload.\n",
    "\n",
    "The utility of obfuscation becomes particularly pronounced in scenarios where concealing the payload from vigilant network-monitoring devices and robust endpoint security solutions is imperative. Consider a scenario where a raw [**shellcode**](https://en.wikipedia.org/wiki/Shellcode), designed for spawning a new [**Metasploit shell**](https://en.wikipedia.org/wiki/Metasploit), is being embedded. In such cases, evasion of detection becomes critical. To achieve this, the utilization of [**Exclusive OR (XOR)**](https://en.wikipedia.org/wiki/Exclusive_or) bitwise operations for both encryption and decryption of data emerges as a strategic choice.\n",
    "\n",
    "XOR, a conditional operation between two binary values, yields a Boolean true outcome only when the two values differ. Contrariwise, a Boolean false result is produced if the values are identical. The XOR truth table, as outlined in the following table, briefly captures this logic, where the output is true when either x or y is true, but not when both are true.\n",
    "\n",
    "| x | y | x XOR y |\n",
    "|---|---|---------|\n",
    "| 0 | 0 |    0    |\n",
    "| 0 | 1 |    1    |\n",
    "| 1 | 0 |    1    |\n",
    "| 1 | 1 |    0    |\n",
    "\n",
    "This XOR logic forms the crux of data obfuscation, wherein the bits in the data are compared to the bits of a secret key. The subsequent manipulation involves altering the payload bit to 0 when the two values match and to 1 when they differ. To implement this concept, the code from the previous section is expanded to accommodate an `xor_encode_decode` function.\n",
    "\n",
    "```rust\n",
    "fn xor_encode_decode(input: &[u8], key: &str) -> Vec<u8> {\n",
    "    let mut b_arr = Vec::with_capacity(input.len());\n",
    "    for (i, &byte) in input.iter().enumerate() {\n",
    "        b_arr.push(byte.wrapping_add(key.as_bytes()[i % key.len()]));\n",
    "    }\n",
    "    b_arr\n",
    "}\n",
    "```\n",
    "\n",
    "The `xor_encode_decode` function, at its core, takes a byte slice representing the payload (`input`) and a secret key (`key`) as inputs. Within its scope, a new byte vector (`b_arr`) is initialized with a length equivalent to that of the input payload. Subsequently, a conditional loop iterates over each index position of the input byte array. During each iteration, XOR operations are performed by taking the current index's binary value and XORing it with a binary value derived from the modulo of the current index and the length of the secret key (`key`). This cleverly enables the use of a key shorter than the payload, as the modulo ensures that when the end of the key is reached, the next iteration reverts to the first byte of the key. The resulting XOR operation outputs are then written to the new `b_arr` bytes vector, which is ultimately returned.\n",
    "\n",
    "Practical integration of these XOR functions into the existing program entails modifying the `main` function logic. The modifications, illustrated in the following code snippet, assume the use of command line arguments to dynamically pass values for conditional encoding and decoding logic.\n",
    "\n",
    "```rust\n",
    "fn main() {\n",
    "    // ..\n",
    "    if cmd_line_opts.encode {\n",
    "        let mut file_writer = File::create(&cmd_line_opts.output).unwrap();\n",
    "        // Assuming encoding is requested\n",
    "        let encoded_data = xor_encode_decode(cmd_line_opts.payload.as_bytes(), &cmd_line_opts.key);\n",
    "\n",
    "        // Calculate CRC for the encoded data\n",
    "        let mut bytes_msb = Vec::new();\n",
    "        bytes_msb.write_all(&meta_chunk.chk.r#type.to_be_bytes()).unwrap();\n",
    "        bytes_msb.write_all(&encoded_data).unwrap();\n",
    "        let crc = crc32_little(meta_chunk.chk.crc, &bytes_msb);\n",
    "\n",
    "        // Update the MetaChunk with the encoded data and CRC\n",
    "        meta_chunk.chk.data = encoded_data;\n",
    "        meta_chunk.chk.crc = crc;\n",
    "\n",
    "        // Create a new mutable reference to file_reader\n",
    "        let mut file_reader = &file;\n",
    "\n",
    "        meta_chunk.write_data(&mut file_reader, &cmd_line_opts, &mut file_writer);\n",
    "\n",
    "        println!(\"Image encoded and written successfully!\");\n",
    "    } else if cmd_line_opts.decode {\n",
    "        // ..\n",
    "    }\n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "Now, let's put it all together. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dcdc083-03fa-4166-bd62-8a96e8ea6963",
   "metadata": {},
   "source": [
    "### 3.4 Encode and Inject a payload program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6d85503f-5a53-4044-b9e0-fddb715ffa22",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::process::{Command, Output, Stdio};\n",
    "\n",
    "// A helper function to execute a shell command from a Rust script\n",
    "fn execute_command(command: &str) -> Result<(), std::io::Error> {\n",
    "    let status = Command::new(\"bash\")\n",
    "        .arg(\"-c\")\n",
    "        .arg(command)\n",
    "        .stderr(Stdio::inherit())\n",
    "        .status()?;\n",
    "\n",
    "    if status.success() {\n",
    "        Ok(())\n",
    "    } else {\n",
    "        Err(std::io::Error::from_raw_os_error(status.code().unwrap_or(1)))\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dcad4d2d-8138-44fa-a566-b641ea65bf46",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.03s\n",
      "     Running `target/debug/stegano prj.png output.png 159028 hello pass encode`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n",
      "original bytes [104, 101, 108, 108, 111]\n",
      "Encoded Payload: [5, 0, 0, 0, 0, 24, 4, 31, 31, 31, 109, 44, 172, 118]\n",
      "Image encoded and written successfully!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run prj.png output.png 159028 'hello' 'pass' encode\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d68b5c2-d6cc-4194-87f6-c2c373988e39",
   "metadata": {},
   "source": [
    "![ScreenShot taken from the Bless hex editor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3aaos20elhhprhznd49d.png)\n",
    "\n",
    "In essence, the integration of XOR-based obfuscation techniques into the program provides a robust layer of security, enabling the obscuring and protection of sensitive payloads within binary files. This strategic utilization of XOR operations serves as a powerful tool in the arsenal of data protection and steganographic practices, contributing to the multifaceted landscape of information security.\n",
    "\n",
    "In the next sections, we are going to explore how to reverse these steps and extract the original payload."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45159de8-cae3-4452-9a7d-22760d301e82",
   "metadata": {},
   "outputs": [],
   "source": [
    "let command = \"cd stegano && cargo run output.png decoded.png 159020 'pass' decode\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad444a83-a8d8-402a-87e4-f07c72fae408",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9199ca24-c934-4ea4-ae07-6c3de3fc1963",
   "metadata": {},
   "source": [
    "## 4. Revealing a secret from a PNG File"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c77410c4-c0bc-4754-93e9-b7fe458c6db1",
   "metadata": {},
   "source": [
    "Now that we were successfully able to encode and inject a secret inside a PNG file by pinpointing an offset and embedding information at that specific location, the subsequent phase involves the extraction of the secret information and the revelation of the hidden secrets encoded within, which is achieved through the decoding process utilizing the XOR operator. To do so, the user is required to specify not only the key employed in the XOR operation but also the image containing the concealed information and the precise offset where the secret was injected.\n",
    "\n",
    "```rust\n",
    "    fn write_data<R: Read + Seek, W: Write>(&mut self, r: &mut R, c: &CmdArgs, mut w: W) {\n",
    "        // Common encoding and decoding process\n",
    "        let b_arr = u64_to_u8_array(self.header.header);\n",
    "        w.write_all(&b_arr).unwrap();\n",
    "        let offset = i64::from_str(&c.offset).unwrap();\n",
    "        let mut buff = vec![0; (offset - 8) as usize];\n",
    "\n",
    "        if c.encode {\n",
    "            // Encoding specific operations\n",
    "            buff.resize((offset - 8) as usize, 0);\n",
    "            r.read_exact(&mut buff).unwrap();\n",
    "            w.write_all(&buff).unwrap();\n",
    "            let data: Vec<u8> = self.marshal_data();\n",
    "            w.write_all(&data).unwrap();\n",
    "            // Uncomment the following line to preserve the length of the image after manipulation\n",
    "            // r.seek(SeekFrom::Current(data.len().try_into().unwrap())).expect(\"Error seeking to offset\");\n",
    "            copy(r, &mut w).unwrap();\n",
    "        } else if c.decode {\n",
    "            // Decoding specific operations\n",
    "            buff.resize((offset - 16) as usize, 0);\n",
    "            r.read_exact(&mut buff).unwrap();\n",
    "            w.write_all(&buff).unwrap();\n",
    "            let offset = self.get_offset(r);\n",
    "            self.read_chunk(r);\n",
    "            println!(\"Encoded Payload: {:?}\", self.chk);\n",
    "            let decoded_data = xor_encode_decode(&self.chk.data, &c.key);\n",
    "            let decoded_string = String::from_utf8_lossy(&decoded_data);\n",
    "            println!(\"Decoded Payload: {:?}\", decoded_data);\n",
    "            println!(\"Original Data: {:?}\", decoded_string);\n",
    "            r.seek(SeekFrom::Current(self.chk.data.len().try_into().unwrap()))\n",
    "                .expect(\"Error seeking to offset\");\n",
    "            copy(r, &mut w).unwrap();\n",
    "        }\n",
    "    }\n",
    "```\n",
    "\n",
    "Now, let's break down the method responsible for this cryptographic work - the `write_data` method. This method is used to handle the dual responsibilities of injecting and encoding, as well as extracting and decoding the hidden information.\n",
    "\n",
    "```rust\n",
    "fn write_data<R: Read + Seek, W: Write>(&mut self, r: &mut R, c: &CmdArgs, mut w: W) {\n",
    "    // ... (omitted for brevity)\n",
    "```\n",
    "\n",
    "At the method's entry point, we encounter generic parameters `R` and `W`, which represent types that can be read from (`Read`) and written to (`Write`). These generics make the method adaptable to various input and output sources.\n",
    "\n",
    "```rust\n",
    "if c.encode {\n",
    "    // Encoding process\n",
    "    let b_arr = u64_to_u8_array(self.header.header);\n",
    "    w.write_all(&b_arr).unwrap();\n",
    "```\n",
    "\n",
    "The conditional statement checks if encoding is the goal. If so, the method initiates the encoding process by converting the header's 64-bit value into a byte array and writing it to the output stream (`w`).\n",
    "\n",
    "```rust\n",
    "let offset = i64::from_str(&c.offset).unwrap();\n",
    "let mut buff = vec![0; (offset - 8) as usize];\n",
    "r.read_exact(&mut buff).unwrap();\n",
    "w.write_all(&buff).unwrap();\n",
    "```\n",
    "\n",
    "Here, the method reads data from the input stream (`r`) up to the specified offset, preparing the canvas for the payload insertion. It's like making space for the hidden message within the image.\n",
    "\n",
    "```rust\n",
    "let data: Vec<u8> = self.marshal_data();\n",
    "w.write_all(&data).unwrap();\n",
    "```\n",
    "\n",
    "The payload, encapsulated as a vector of unsigned 8-bit integers, is then written to the output stream (`w`). Think of this step as the act of placing the secret message at the designated location within the image.\n",
    "\n",
    "```rust\n",
    "// Uncomment the following line to preserve the length of the image after manipulation\n",
    "// r.seek(SeekFrom::Current(data.len().try_into().unwrap())).expect(\"Error seeking to offset\");\n",
    "```\n",
    "\n",
    "This commented line when uncommented, ensures that the length of the image remains intact after manipulation. It's like tidying up after the secret has been securely placed.\n",
    "\n",
    "```rust\n",
    "copy(r, &mut w).unwrap();\n",
    "```\n",
    "\n",
    "Finally, the method completes the encoding process by copying the remaining data from the input stream (`r`) to the output stream (`w`). This step ensures that the image remains coherent even after the injection operation.\n",
    "\n",
    "```rust\n",
    "} else if c.decode {\n",
    "    // Decoding process\n",
    "    let b_arr = u64_to_u8_array(self.header.header);\n",
    "    w.write_all(&b_arr).unwrap();\n",
    "```\n",
    "\n",
    "The method then delves into the decoding process if the user specifies the `decode` flag. Like before, the header is written to the output stream (`w`), setting the stage for the revelation of hidden information.\n",
    "\n",
    "```rust\n",
    "let offset = i64::from_str(&c.offset).unwrap();\n",
    "let mut buff = vec![0; (offset - 16) as usize];\n",
    "r.read_exact(&mut buff).unwrap();\n",
    "w.write_all(&buff).unwrap();\n",
    "```\n",
    "\n",
    "Similarly to the encoding process, data up to the specified offset is read from the input stream (`r`). The buffer (`buff`) ensures that the canvas is prepared for decoding.\n",
    "\n",
    "```rust\n",
    "let offset = self.get_offset(r);\n",
    "self.read_chunk(r);\n",
    "println!(\"Encoded Payload: {:?}\", self.chk);\n",
    "```\n",
    "\n",
    "The method then fetches the actual offset of the hidden payload, reads the payload chunk, and prints the encoded payload for the user to witness the encoded information.\n",
    "\n",
    "```rust\n",
    "let decoded_data = xor_encode_decode(&self.chk.data, &c.key);\n",
    "let decoded_string = String::from_utf8_lossy(&decoded_data);\n",
    "println!(\"Decoded Payload: {:?}\", decoded_data);\n",
    "println!(\"Original Data: {:?}\", decoded_string);\n",
    "```\n",
    "\n",
    "Using the XOR operator and the provided key, the encoded payload is decoded. The resulting decoded data is printed for the user, revealing the hidden secret within the image.\n",
    "\n",
    "```rust\n",
    "r.seek(SeekFrom::Current(self.chk.data.len().try_into().unwrap())).expect(\"Error seeking to offset\");\n",
    "copy(r, &mut w).unwrap();\n",
    "```\n",
    "\n",
    "To conclude the decoding process, the method seeks to the position following the decoded payload's length within the input stream (`r`). The remaining data is then copied to the output stream (`w`), ensuring the image's integrity is maintained."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73bac091-0ba5-42d4-a4fb-d45cd5130f59",
   "metadata": {},
   "source": [
    "### 4.1 Extract and Decode the secret program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "89abc600-585a-4260-bccf-f6125cf68c65",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.04s\n",
      "     Running `target/debug/stegano output.png decoded.png 159028 decode pass`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n",
      "Encoded Payload: Chunk { size: 5, type: 0, data: [24, 4, 31, 31, 31], crc: 1831644278 }\n",
      "Decoded Payload: [104, 101, 108, 108, 111]\n",
      "Original Data: \"hello\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run output.png decoded.png 159028 decode 'pass'\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1e9a104-9cb1-4102-9e1a-1b7870e0f9d5",
   "metadata": {},
   "source": [
    "As you can see, we've effectively managed to extract and decode the hidden message embedded within the picture. In simpler terms, we've revealed and translated the secret content that was previously hidden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9cbec55-231a-425f-a2cb-e4b77b35c730",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6573a4fe-0781-4e55-af14-9b2195719b11",
   "metadata": {},
   "source": [
    "## 5. Test Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8cc34a-a639-4ce1-a7e0-05ba15443b80",
   "metadata": {},
   "source": [
    "### 5.1 Exact Key, Exact Offset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "867604d2-2ce6-43a8-a4a6-05ba041f14d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.03s\n",
      "     Running `target/debug/stegano prj.png output.png 159028 'hello there 121321412 12312942' pass encode`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n",
      "original bytes [104, 101, 108, 108, 111, 32, 116, 104, 101, 114, 101, 32, 49, 50, 49, 51, 50, 49, 52, 49, 50, 32, 49, 50, 51, 49, 50, 57, 52, 50]\n",
      "Encoded Payload: [30, 0, 0, 0, 0, 24, 4, 31, 31, 31, 65, 7, 27, 21, 19, 22, 83, 65, 83, 66, 64, 66, 80, 71, 66, 66, 65, 66, 65, 67, 80, 65, 74, 68, 83, 31, 145, 123, 52]\n",
      "Image encoded and written successfully!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run prj.png output.png 159028 'hello there 121321412 12312942' 'pass' encode\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8f0fa88e-f94b-46a0-b3c9-968fe467a799",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.05s\n",
      "     Running `target/debug/stegano output.png decoded.png 159028 decode pass`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n",
      "Encoded Payload: Chunk { size: 30, type: 0, data: [24, 4, 31, 31, 31, 65, 7, 27, 21, 19, 22, 83, 65, 83, 66, 64, 66, 80, 71, 66, 66, 65, 66, 65, 67, 80, 65, 74, 68, 83], crc: 529627956 }\n",
      "Decoded Payload: [104, 101, 108, 108, 111, 32, 116, 104, 101, 114, 101, 32, 49, 50, 49, 51, 50, 49, 52, 49, 50, 32, 49, 50, 51, 49, 50, 57, 52, 50]\n",
      "Original Data: \"hello there 121321412 12312942\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run output.png decoded.png 159028 decode 'pass'\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63ad1c83-c6a3-4845-a87f-9f3677a55f8f",
   "metadata": {},
   "source": [
    "### 5.2 Wrong Key, Exact Offset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3824524c-cf19-4e3d-9ec4-691c25e7796d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.05s\n",
      "     Running `target/debug/stegano output.png decoded.png 159028 decode invalid-password`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n",
      "Encoded Payload: Chunk { size: 30, type: 0, data: [24, 4, 31, 31, 31, 65, 7, 27, 21, 19, 22, 83, 65, 83, 66, 64, 66, 80, 71, 66, 66, 65, 66, 65, 67, 80, 65, 74, 68, 83], crc: 529627956 }\n",
      "Decoded Payload: [113, 106, 105, 126, 115, 40, 99, 54, 101, 114, 101, 32, 54, 60, 48, 36, 43, 62, 49, 35, 46, 40, 38, 108, 51, 49, 50, 57, 51, 60]\n",
      "Original Data: \"qji~s(c6ere 6<0$+>1#.(&l31293<\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run output.png decoded.png 159028 decode 'invalid-password'\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6c6a165-9905-47be-be6c-d654fa574252",
   "metadata": {},
   "source": [
    "### 5.3 Exact Key, Wrong Offset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "18e2855c-f497-4bc3-99c7-c0182c4638ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.03s\n",
      "     Running `target/debug/stegano output.png decoded.png 159000 decode pass`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Error reading chunk bytes: Reached end of file prematurely\n",
      "Warning: Reached end of file prematurely while reading CRC\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoded Payload: Chunk { size: 89, type: 221593541, data: [218, 90, 165, 243, 175, 218, 199, 174, 7, 167, 188, 81, 255, 63, 17, 225, 164, 44, 36, 53, 182, 112, 0, 30, 0, 0, 0, 0, 24, 4, 31, 31, 31, 65, 7, 27, 21, 19, 22, 83, 65, 83, 66, 64, 66, 80, 71, 66, 66, 65, 66, 65, 67, 80, 65, 74, 68, 83, 31, 145, 123, 52, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], crc: 0 }\n",
      "Decoded Payload: [170, 59, 214, 128, 223, 187, 180, 221, 119, 198, 207, 34, 143, 94, 98, 146, 212, 77, 87, 70, 198, 17, 115, 109, 112, 97, 115, 115, 104, 101, 108, 108, 111, 32, 116, 104, 101, 114, 101, 32, 49, 50, 49, 51, 50, 49, 52, 49, 50, 32, 49, 50, 51, 49, 50, 57, 52, 50, 108, 226, 11, 85, 115, 115, 112, 40, 54, 61, 52, 207, 49, 19, 242, 97, 115, 115, 112, 97, 115, 115, 112, 97, 115, 115, 112, 97, 115, 115, 112]\n",
      "Original Data: \"�;ր\\u{7fb}��w��\\\"�^b��MWF�\\u{11}smpasshello there 121321412 12312942l�\\u{b}Ussp(6=4�1\\u{13}�asspasspasspassp\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run output.png decoded.png 159000 decode 'pass'\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b454f73-815d-4a67-a092-eedb2bb63093",
   "metadata": {},
   "source": [
    "### 5.4 Wrong Key, Wrong Offset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "90b3a110-63c3-49cb-8238-fee33391d362",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished dev [unoptimized + debuginfo] target(s) in 0.05s\n",
      "     Running `target/debug/stegano output.png decoded.png 159000 decode invalid`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a valid PNG file. Let's process it!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Error reading chunk bytes: Reached end of file prematurely\n",
      "Warning: Reached end of file prematurely while reading CRC\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encoded Payload: Chunk { size: 89, type: 221593541, data: [218, 90, 165, 243, 175, 218, 199, 174, 7, 167, 188, 81, 255, 63, 17, 225, 164, 44, 36, 53, 182, 112, 0, 30, 0, 0, 0, 0, 24, 4, 31, 31, 31, 65, 7, 27, 21, 19, 22, 83, 65, 83, 66, 64, 66, 80, 71, 66, 66, 65, 66, 65, 67, 80, 65, 74, 68, 83, 31, 145, 123, 52, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], crc: 0 }\n",
      "Decoded Payload: [179, 52, 211, 146, 195, 179, 163, 199, 105, 209, 221, 61, 150, 91, 120, 143, 210, 77, 72, 92, 210, 25, 110, 104, 97, 108, 105, 100, 113, 106, 105, 126, 115, 40, 99, 114, 123, 101, 119, 63, 40, 55, 43, 46, 52, 49, 43, 43, 38, 40, 44, 55, 34, 60, 40, 46, 45, 61, 105, 240, 23, 93, 100, 105, 110, 63, 36, 34, 45, 202, 43, 14, 244, 97, 108, 105, 100, 105, 110, 118, 97, 108, 105, 100, 105, 110, 118, 97, 108]\n",
      "Original Data: \"�4Ӓó��i��=�[x��MH\\\\�\\u{19}nhalidqji~s(cr{ew?(7+.41++&(,7\\\"<(.-=i�\\u{17}]din?$\\\"-�+\\u{e}�alidinvalidinval\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd stegano && cargo run output.png decoded.png 159000 decode 'invalid'\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da11bb09-1611-4bbf-8b3b-45c08a0118a6",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}