Example solving homework by LLM (https://old.reddit.com/r/C_Programming/comments/1h2qd4m/_/lzll2oz/)

baboon.pgm.gz

bugfix.patch

--- solve.c.orig
+++ solve.c
@@ -78,3 +78,3 @@
             unsigned char cover_msb = (coverPixels[i * width + j] & 0xF0);
-            unsigned char secret_lsb = (secretPixels[i * width + j] & 0x0F);
+            unsigned char secret_lsb = (secretPixels[i * width + j]>>4 & 0x0F);
 

farm.pgm.gz

Lab4_Q3.txt

Question 2: Steganography using 4-bit LSB algorithm
Scope: File Processing, Pointers, Dynamic Memory Allocation (No arrays)
File to use: stego_lsb.c

Preliminary:

This question should be solved using dynamic memory  allocation  along  with
pointers.  Any  submitted  work  which  includes  an  array  will  be  given
automatically a zero mark. To view pgm files, you can use the  “Irfan  View”
software (https://www.irfanview.com/). To read  the  content  of  ASCII  PGM
file, open the file using Notepad or a similar text editor.

The format of ASCII (text format) PGM image file is:
P2
# comment
Width  Height
Maximum Gray value
Pixel values


The format of a Binary PGM image file is:
P5
# comment
Width  Height
Maximum Gray value
Pixel values



Task Description:

Steganography is  the  art  and  discipline  of  embedding  hidden  messages
(secret message) into signals (cover signal) in  such  a  way  that  no  one
suspects the existence of the message and only the sender and recipient  can
extract it.

In 8-bit images (256 Gray levels), each image pixel value is represented  in
8 bits. Humans can’t notice a minor difference in the values  of  the  image
pixels. Research has shown that altering up to the  four  Least  Significant
Bits (LSBs) of the  original  image  pixel  values  does  not  significantly
distort the original image.

Based on this principle, the steganography LSB  algorithm  when  applied  on
images generates a stego image whereby the binary  representation  of  every
pixel value has two fields:

   1. The upper field includes a number (N) of the most significant bits  of
      the corresponding pixel in the cover image

   2. The lower field includes “8-N” of the most  significant  bits  of  the
      corresponding pixel in the secret image

Figure 1 gives an example of the LSB steganography encoding with N=4.
                         Cover Image Pixel: 10110001

                        Secret Image Pixel: 00111111

                         Stego Image Pixel: 10110011

      Figure 1. Steganography encoding using LSB algorithm with order 4

When this procedure is completed, an entire image (the secret image) can  be
hidden within another (cover image) without  much  noticeable  deterioration
of either image; allowing a secret message to be passed.

At the recipient, each 8-bit stego image pixel  is  processed  as  shown  in
Figure .2 to extract the corresponding pixel value in the  cover  image  and
the secret image.
Each pixel of the stego image is split into two 4-bit nibbles, where:
    • The most significant 4-bit nibble corresponds to the most  significant
      4-bit nibble of the decoded Cover image
    • The least significant 4-bit nibble corresponds to the most significant
      4-bit nibble of the extracted Secret image.
The least significant 4-bit nibbles in both the Secret and Cover images  are
set to zero.


//                                                            Stego Image
Pixel: 10110011



                                                           10110000
                                             00110000

                     Reconstructed:          Cover Image
                           Secret Image

  Figure 2.  Steganography decoding using LSB algorithm with order 4: the 4
                          LSBs are all set to zero



Requirements

Complete the attached  program:  stego_lsb.c  to  implement  the  4-bit  LSB
Steganography encoding and decoding algorithms in C as explained above.  The
cover  image  file  is  “baboon.pgm”,  while  the  secret  image   file   is
“farm.jpg”, both are in ASCII format. The structure of the attached  program
should not be altered. Comments  in  the  provided  program  indicate  where
additional code needs to be written, as  broadly  explained  below.  Further
requirements and constraints are detailed bellow:
    • The provided images and those to be generated are all  512x512  pixels
      in size.
    • Using malloc function, dynamic memory space  should  be  requested  to
      store the pixels of the cover, secret,  stego,  and  extracted  secret
      images.
    • The dynamically allocated memory should be  accessed  and  manipulated
      using pointer with offset addressing, not arrays:
         o The pointer ‘coverPixels’ should point to the cover image memory
           space, then to the ‘stego’ image’s.
         o The pointer ‘secretPixels’ should  point  to  the  secret  image
           memory space.
         o The pointer ‘outputPixels’ should point to the extracted  secret
           image memory space.
    • The ‘stego’ image should be  stored  in  binary  format  to  the  file
      ‘stego_image_bin.pgm’
    • The extracted ‘secret’ image should be stored in text  format  to  the
      file ‘extracted_secret.pgm’
    • The function ‘embedLSB’ should be implemented and called  to  generate
      the ‘stego’ image.
    • The function ‘extractLSB’ should be implemented and called to  extract
      the ‘secret’ image from the ‘stego’ image.
    • The  functions  ‘readPGMText’,  ‘writePGMText’,  and  ‘writePGMBinary’
      should be completed and used to read the  provided  ASCII  images  and
      generate the binary format ‘stego’ image and the text format  ‘secret’
      image.
    • Your code should handle all  possible  errors  that  can  occur  while
      processing  files  and  pointers,  printing  relevant   messages   and
      returning different values from each function in each case.
    •  For  file  processing,  include  C  statements  to  verify   if   the
      corresponding operations were successful.


Hint: you can use C  bitwise  and  shift  operators  to  implement  the  LSB
steganography algorithms.

What to submit

  • A description (flowchart or pseudo code) of your design solution to,

    • generate the ‘stego’ image pixel value from the ‘cover’ and ‘secret’
      images

    • Extract the ‘secret’ image pixel from the ‘stego’ image

 • Full code concisely commented.

 • The original ‘cover’ and ‘secret’ image files, along with the ‘stego’
   image and ‘extracted secret’ image files.

solve.illume.txt

!note Mistral Nemo 2407 (llama.cpp, Q4_K_M)
!:temperature 0
!:max_tokens 10000
!context Lab4_Q3.txt
!context stego_lsb.c
!user
Please complete this assignment.

!assistant

Here's a completed version of the `stego_lsb.c` program with the required functions implemented. I've added comments to explain each step and used bitwise operations to manipulate the pixel values for LSB steganography.

```c
#include <stdio.h>
#include <stdlib.h>

#define WIDTH 512
#define HEIGHT 512

// Function to read a PGM image in text format.
int readPGMText(const char *filename, unsigned char *pixels, int width, int height) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("Error opening file");
        return 1;
    }

    char line[1024];
    fgets(line, sizeof(line), file); // Skip the first line (P2)
    fgets(line, sizeof(line), file); // Skip the second line (comment)

    int w, h, max_val;
    fscanf(file, "%d %d\n%d\n", &w, &h, &max_val);
    if (w != width || h != height) {
        printf("Error: Image dimensions do not match\n");
        return 1;
    }

    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            fscanf(file, "%hhu", &pixels[i * width + j]);
        }
    }

    fclose(file);
    return 0;
}

// Function to write a PGM image in text format.
int writePGMText(const char *filename, unsigned char *pixels, int width, int height) {
    FILE *file = fopen(filename, "w");
    if (!file) {
        perror("Error opening file");
        return 1;
    }

    fprintf(file, "P2\n# Created by stego_lsb.c\n%d %d\n255\n", width, height);

    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            fprintf(file, "%hhu ", pixels[i * width + j]);
        }
        fprintf(file, "\n");
    }

    fclose(file);
    return 0;
}

// Function to write a PGM image in binary format.
int writePGMBinary(const char *filename, unsigned char *pixels, int width, int height) {
    FILE *file = fopen(filename, "wb");
    if (!file) {
        perror("Error opening file");
        return 1;
    }

    fprintf(file, "P5\n# Created by stego_lsb.c\n%d %d\n255\n", width, height);

    fwrite(pixels, sizeof(unsigned char), width * height, file);

    fclose(file);
    return 0;
}

// Function to hide a secret image using the 4-bit LSB steganography algorithm.
void embedLSB(unsigned char *coverPixels, unsigned char *secretPixels, int width, int height) {
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            // Get the 4 MSBs of the cover pixel and the 4 LSBs of the secret pixel
            unsigned char cover_msb = (coverPixels[i * width + j] & 0xF0);
            unsigned char secret_lsb = (secretPixels[i * width + j] & 0x0F);

            // Combine them to create the stego pixel
            coverPixels[i * width + j] = (cover_msb | secret_lsb);
        }
    }
}

// Function to extract the secret image using 4-LSB steganography algorithm.
void extractLSB(unsigned char *coverPixels, unsigned char *outputPixels, int width, int height) {
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            // Get the 4 LSBs of the stego pixel (which are the 4 MSBs of the secret pixel)
            unsigned char secret_msb = (coverPixels[i * width + j] & 0x0F);

            // Set the 4 LSBs of the secret pixel to 0
            outputPixels[i * width + j] = (secret_msb << 4);
        }
    }
}

int main() {
    char cover_image[] = "baboon.pgm";
    char secret_image[] = "farm.pgm";
    char stego_image[] = "stego_image_bin.pgm";
    char extracted_secret[] = "extracted_secret.pgm";

    unsigned char *coverPixels, *secretPixels, *outputPixels;
    int coverWidth = WIDTH, coverHeight = HEIGHT, secretWidth = WIDTH, secretHeight = HEIGHT;

    // Using malloc, dynamically request exact memory space, referenced by coverPixels, to store the cover image pixel values.
    coverPixels = malloc(coverWidth * coverHeight);
    if (!coverPixels) {
        perror("Error allocating memory for coverPixels");
        return 1;
    }

    // Read the cover image file (text PGM) and store its pixels in 'coverPixels' referenced memory space.
    if (readPGMText(cover_image, coverPixels, coverWidth, coverHeight)) {
        return 1;
    }

    // Using malloc, dynamically request exact memory space, referenced by 'secretPixels', to store the secret image pixel values.
    secretPixels = malloc(secretWidth * secretHeight);
    if (!secretPixels) {
        perror("Error allocating memory for secretPixels");
        free(coverPixels);
        return 1;
    }

    // Read the secret image file (text PGM) and store its pixels in 'secretPixels' referenced memory space.
    if (readPGMText(secret_image, secretPixels, secretWidth, secretHeight)) {
        free(coverPixels);
        free(secretPixels);
        return 1;
    }

    // Check if the dimensions of both images match, exit if they don't.
    if (coverWidth != secretWidth || coverHeight != secretHeight) {
        printf("Error: Image dimensions do not match\n");
        free(coverPixels);
        free(secretPixels);
        return 1;
    }

    // Call the function embedLSB to embed the secret image into the cover image.
    embedLSB(coverPixels, secretPixels, coverWidth, coverHeight);

    // The stego image pixels are stored in 'coverPixels' referenced memory space.

    // Save the stego image into binary format to stego_image_bin.pgm
    if (writePGMBinary(stego_image, coverPixels, coverWidth, coverHeight)) {
        free(coverPixels);
        free(secretPixels);
        return 1;
    }

    // Using malloc, dynamically request exact memory space, referenced by 'outputPixels', to store the extracted secret image
    outputPixels = malloc(secretWidth * secretHeight);
    if (!outputPixels) {
        perror("Error allocating memory for outputPixels");
        free(coverPixels);
        free(secretPixels);
        return 1;
    }

    // Call the function extractLSB to extract the secret image from the stego image
    extractLSB(coverPixels, outputPixels, coverWidth, coverHeight);

    // Save the extracted secret image in a text format to extracted_secret.pgm
    if (writePGMText(extracted_secret, outputPixels, secretWidth, secretHeight)) {
        free(coverPixels);
        free(secretPixels);
        free(outputPixels);
        return 1;
    }

    free(coverPixels);
    free(secretPixels);
    free(outputPixels);

    return 0;
}
```

To compile and run the program, use the following commands:

```sh
gcc -o stego_lsb stego_lsb.c
./stego_lsb
```

This will generate the `stego_image_bin.pgm` and `extracted_secret.pgm` files in the same directory as the executable.

stego_lsb.c

#include <stdio.h>
#include <stdlib.h>

#define WIDTH 512
#define HEIGHT 512

// Function to read a PGM image in text format.
// 'pixels' stores the pixel values of the image specified by 'filename'.
int readPGMText(const char *filename, unsigned char *pixels, int width, int height) {
}

// Function to write a PGM image in text format.
// The dereferenced values of 'pixels' are stored in the PGM image specified by 'filename'.
int writePGMText(const char *filename, unsigned char *pixels, int width, int height) {
}


// Function to write a PGM image in binary format.
// The dereferenced values of 'pixels' are stored in the PGM image specified by 'filename' in binary format.

int writePGMBinary(const char *filename, unsigned char *pixels, int width, int height) {
}

// Function to hide a secret image using the 4-bit LSB steganography algorithm.
// The dereferenced values of 'coverPixels' (cover image) are updated with the dereferenced values of 
// 'secretPixels' (secret image) based on the 4-bit LSB steganography algorithm

void embedLSB(unsigned char *coverPixels, unsigned char *secretPixels, int width, int height) {

}

// Function to extract the secret image using 4-LSB steganography algorithm.
// The extracted pixel values, derived from the stego image referenced by 'coverPixels',
// are stored in the memory space pointed to by 'outputPixels' 
void extractLSB(unsigned char *coverPixels, unsigned char *outputPixels, int width, int height) {

}

int main() {
    char cover_image[]="baboon.pgm";
    char secret_image[]="farm.pgm";
    char stego_image[]="stego_image_bin.pgm";
    char extracted_secret[]="extracted_secret.pgm";
    

    unsigned char *coverPixels, *secretPixels, *outputPixels;
    int coverWidth=WIDTH, coverHeight=HEIGHT, secretWidth=WIDTH, secretHeight=HEIGHT;

    // Using malloc, dynnamically request extact memory space,referenced by coverPixels, to store the cover image pixel values. 
	
    // Read the cover image file (text PGM) and store its pixels in 'coverPixels' referenced memory space.

    //  Using malloc, dynamically request extact memory space, referenced by 'secretPixels', to store the secret image pixel values.
    
    // Read the secret image file (text PGM) and store its pixels in 'secretPixels' referenced memory space.

    // Check if the dimensions of both images match, exit if they don't.
 
    // Call the function embedLSB to embed the secret image into the cover image.
    
    // The stego image pixels are stored in 'coverPixels' referenced memory space.
        
    // Save the stego image into binary format to stego_image_bin.pgm
  
    //  Using malloc, dynamically request exact memory space, referenced by 'outputPixels', to store the extracted secret image    

    // Call the function extractLSB to extract the secret image from the stego image
    
    // Save the extracted secret image in a text format to extracted_secret.pgm

   
    return 0;
}