Header Working but bugs with file returning EOF

.gitignore

@@ -1,2 +1,4 @@
 
 Builds/
+
+.vs/

SteganoTest/SteganoTest.vcxproj

@@ -32,6 +32,7 @@
     <ClInclude Include="src\header.h" />
     <ClInclude Include="src\image.h" />
     <ClInclude Include="src\verbose.h" />
+    <ClInclude Include="src\version.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\bitmask.c" />
@@ -40,9 +41,11 @@
     <ClCompile Include="src\encoder.c" />
     <ClCompile Include="src\external\argtable3.c" />
     <ClCompile Include="src\file.c" />
+    <ClCompile Include="src\header.c" />
     <ClCompile Include="src\image.c" />
     <ClCompile Include="src\launcher.c" />
     <ClCompile Include="src\verbose.c" />
+    <ClCompile Include="src\version.c" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>

SteganoTest/SteganoTest.vcxproj.filters

@@ -57,6 +57,9 @@
     <ClInclude Include="src\external\stb_image_write.h">
       <Filter>Source Files\external</Filter>
     </ClInclude>
+    <ClInclude Include="src\version.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\bitmask.c">
@@ -86,5 +89,11 @@
     <ClCompile Include="src\external\argtable3.c">
       <Filter>Source Files\external</Filter>
     </ClCompile>
+    <ClCompile Include="src\header.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\version.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SteganoTest/SteganoTest.vcxproj.user

@@ -11,13 +11,13 @@
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LocalDebuggerCommandArguments>
-    </LocalDebuggerCommandArguments>
+    <LocalDebuggerCommandArguments>-v -e -i stegacito_forest.png</LocalDebuggerCommandArguments>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <RemoteDebuggerCommandArguments>-v -e -i stegacito_forest.png</RemoteDebuggerCommandArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LocalDebuggerCommandArguments>
-    </LocalDebuggerCommandArguments>
+    <LocalDebuggerCommandArguments>-v res/test.xlsx -i res/forest.png</LocalDebuggerCommandArguments>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+    <RemoteDebuggerCommandArguments>-v res/test.xlsx -i res/forest.png</RemoteDebuggerCommandArguments>
   </PropertyGroup>
 </Project>

SteganoTest/extracted_hello.txt

@@ -0,0 +1 @@
+Un fichier secret de test !

SteganoTest/src/decoder.c

@@ -13,7 +13,10 @@ int decoder_main(struct arg_file* image, struct arg_file* output)
 	// --------------------------------- //
 	// Load Image
 	Image* my_image = ImageLoad(image->filename[0]);
-	VERBOSE_ON printf("Loaded image with a width of %dpx, a height of %dpx and %d channels\n", my_image->width, my_image->height, my_image->channels);
+	VERBOSE_ON printf("Loaded image with a width of %d px, a height of %d px and %d channels\n", my_image->width, my_image->height, my_image->channels);
+
+	Header my_header = HeaderExtract(my_image);
+	const int filesize = *(HEADER_FILE_SIZE_CONTAINER_TYPE_32*)(&my_header.header[6]);
 
 	// --------------------------------- //
 	// File Opening
@@ -24,17 +27,17 @@ int decoder_main(struct arg_file* image, struct arg_file* output)
 	}
 	else
 	{
-		char buf[256];
-		snprintf(buf, sizeof buf, "%s%s%s", image->filename[0], "_extracted", ".txt");
+		char buf[512];
+		snprintf(buf, sizeof buf, "%s%s", "extracted_", &my_header.header[10]);
 		my_file = FileLoad(buf, "w+");
 	}
-	
-	for (int i = 0; i < my_image->height * my_image->width; i += my_image->channels)
+
+	for (int i = HEADER_SIZE_IN_BYTES_32*my_image->channels; i < (HEADER_SIZE_IN_BYTES_32 * my_image->channels)+(filesize*my_image->channels); i += my_image->channels)
 	{
 		const RGB pixel = { my_image->pixel_array[i], my_image->pixel_array[i + 1], my_image->pixel_array[i + 2] };
 		Byte data_extracted = Decode(pixel);
 		fwrite(&data_extracted, sizeof(Byte), 1, my_file->file_handler);
-		VERBOSE_ON printf("Pixel %d (%d,%d,%d) : %d \n", i / 4, my_image->pixel_array[i], my_image->pixel_array[i + 1], my_image->pixel_array[i + 2], data_extracted);
+		VERBOSE_ON printf("Pixel %d (%d,%d,%d) : %d \n", (i - HEADER_SIZE_IN_BYTES_32/my_image->channels) / my_image->channels, my_image->pixel_array[i], my_image->pixel_array[i + 1], my_image->pixel_array[i + 2], data_extracted);
 	}
 
 	//Clean

SteganoTest/src/encoder.c

@@ -20,9 +20,11 @@ int encoder_main(struct arg_file * file, struct arg_file * image, struct arg_fil
 	// Load File
 	File* my_file = FileLoad(file->filename[0], "r");
 
+	Header my_header = HeaderCreate(my_file->size, file->basename[0]);
+
 	// --------------------------------- //
 	// Check if it can be added in Image
-	if (my_file->size <= (HEADER_FILE_SIZE_CONTAINER_TYPE_64)((HEADER_FILE_SIZE_CONTAINER_TYPE_64)my_image->width * (HEADER_FILE_SIZE_CONTAINER_TYPE_64)my_image->height - (HEADER_FILE_SIZE_CONTAINER_TYPE_64)HEADER_SIZE_IN_BYTES_64))
+	if (my_file->size <= my_image->width*my_image->height - HEADER_SIZE_IN_BYTES_32)
 	{
 		VERBOSE_ON printf("The file can be hidden in the image\n");
 	}
@@ -31,17 +33,30 @@ int encoder_main(struct arg_file * file, struct arg_file * image, struct arg_fil
 		printf("Error, the file can't be hidden in the image, it is too heavy\n");
 		exit(3);
 	}
+	// --------------------------------- //
+	// Insert Header
+	VERBOSE_ON printf("Header Encoding ...\n");
+	for(HEADER_FILE_SIZE_CONTAINER_TYPE_32 i = 0; i < HEADER_SIZE_IN_BYTES_32; i++)
+	{
+		// Get Pixel
+		const RGB pixel_original = ImageGetPixelRGB(my_image, i);
+		VERBOSE_ON printf("Original Pixel = (%d,%d,%d)\n", pixel_original.r, pixel_original.g, pixel_original.b);
+
+		// Encode Pixel
+		const RGB pixel_encoded = Encode(pixel_original, my_header.header[i]);
 
-
+		// Insert in Image Array
+		ImageSetPixelRGB(my_image, i, pixel_encoded);
+	}
+	fseek(my_file->file_handler, 0L, SEEK_SET);
 	// --------------------------------- //
 	// Pixel Encoding
 	VERBOSE_ON printf("Pixel Encoding ...\n");
 	int error_counter = 0;
-	for (int i = 0; i < my_file->size; i++)
+	for (HEADER_FILE_SIZE_CONTAINER_TYPE_32 i = HEADER_SIZE_IN_BYTES_32; i < my_file->size + HEADER_SIZE_IN_BYTES_32; i++)
 	{
-
 		VERBOSE_ON printf("-------------------\n");
-		VERBOSE_ON printf("Pixel Number : %d\n", i);
+		VERBOSE_ON printf("Pixel Number : %d\n", i - HEADER_SIZE_IN_BYTES_32);
 
 		// ------------------------------------- //
 		// Get Values

SteganoTest/src/errorcode.h

@@ -7,5 +7,6 @@
 #define ERRORCODE_CANNOT_MALLOC_IMAGE 4 // file is too big for that image
 #define ERRORCODE_ARGSERROR 5
 #define ERRORCODE_ERROR_IN_ENCODING 6
+#define ERRORCODE_HEADER_IS_NOT_A_STEGACITO_ONE 7
 
 #endif // ERRORCODE_H

SteganoTest/src/file.c

@@ -5,11 +5,11 @@
 #include "file.h"
 #include "verbose.h"
 
-HEADER_FILE_SIZE_CONTAINER_TYPE_64 GetSizeFileInBytes(FILE* file)
+HEADER_FILE_SIZE_CONTAINER_TYPE_32 GetSizeFileInBytes(FILE* file)
 {
-	const HEADER_FILE_SIZE_CONTAINER_TYPE_64 save_cursor_pos = ftell(file);
+	const HEADER_FILE_SIZE_CONTAINER_TYPE_32 save_cursor_pos = ftell(file);
 	fseek(file, 0L, SEEK_END);
-	const HEADER_FILE_SIZE_CONTAINER_TYPE_64 size = ftell(file);
+	const HEADER_FILE_SIZE_CONTAINER_TYPE_32 size = ftell(file);
 	fseek(file, 0, save_cursor_pos);
 	return size;
 }

SteganoTest/src/file.h

@@ -7,11 +7,11 @@
 struct File
 {
 	FILE* file_handler;
-	HEADER_FILE_SIZE_CONTAINER_TYPE_64 size;
+	HEADER_FILE_SIZE_CONTAINER_TYPE_32 size;
 
 }; typedef struct File File;
 
-HEADER_FILE_SIZE_CONTAINER_TYPE_64 GetSizeFileInBytes(FILE* file);
+HEADER_FILE_SIZE_CONTAINER_TYPE_32 GetSizeFileInBytes(FILE* file);
 File* FileLoad(const char* path, char* mode);
 void FileUnload(File** file_to_delete);
 

SteganoTest/src/header.c

@@ -0,0 +1,65 @@
+#include "header.h"
+#include <stdio.h>
+#include <string.h>
+#include "image.h"
+#include "common.h"
+#include "verbose.h"
+#include <stdlib.h>
+#include "errorcode.h"
+
+Header HeaderCreate(HEADER_FILE_SIZE_CONTAINER_TYPE_32 file_size, const char* filename)
+{
+	Header header_contrainer = { 0 };
+	// Control Key // THE KEY SHOULD NEVER CHANGE !!
+	header_contrainer.header[0] = HEADER_CONTROL_KEY_1;
+	header_contrainer.header[1] = HEADER_CONTROL_KEY_2;
+	header_contrainer.header[2] = HEADER_CONTROL_KEY_3;
+	header_contrainer.header[3] = HEADER_CONTROL_KEY_4;
+	header_contrainer.header[4] = HEADER_CONTROL_KEY_5;
+
+	// Version
+	header_contrainer.header[5] = GetVersionNumber();
+
+	// Size
+	HEADER_FILE_SIZE_CONTAINER_TYPE_32 * file_size_in_header = (HEADER_FILE_SIZE_CONTAINER_TYPE_32*)&header_contrainer.header[6];
+	*file_size_in_header = file_size;
+
+	// Name
+	strncpy((char *)&header_contrainer.header[10], filename, HEADER_FILE_NAME_CHAR_MAX);
+
+	// Data
+	// Data should start at [10]
+
+	return header_contrainer;
+}
+
+Header HeaderExtract(Image * my_image)
+{
+	Header my_header = { 0 };
+	for(HEADER_FILE_SIZE_CONTAINER_TYPE_32 i = 0; i < HEADER_SIZE_IN_BYTES_32; i++)
+	{
+		const RGB pixel = ImageGetPixelRGB(my_image, i);
+		my_header.header[i] = Decode(pixel);
+	}
+
+	// Check Control Key
+	if
+	(
+		my_header.header[0] == HEADER_CONTROL_KEY_1 && 
+		my_header.header[1] == HEADER_CONTROL_KEY_2 && 
+		my_header.header[2] == HEADER_CONTROL_KEY_3 && 
+		my_header.header[3] == HEADER_CONTROL_KEY_4 && 
+		my_header.header[4] == HEADER_CONTROL_KEY_5
+	)
+	{
+		VERBOSE_ON printf("Header extracted is a good header\n");
+	}
+	else
+	{
+		printf("Error ! The Image is probably not steganographied !\n");
+		exit(ERRORCODE_HEADER_IS_NOT_A_STEGACITO_ONE);
+	}
+
+	return my_header;
+}
+

SteganoTest/src/header.h

@@ -3,39 +3,50 @@
 
 #include <stdint.h>
 #include <limits.h>
+#include "basictype.h"
+#include "version.h"
+#include "image.h"
 
 // ------------------------------- //
 // Header Constants & Types
 // ------------------------------- //
 
 // ----- File Size Container ----- //
-#if defined(UINT64_MAX)
-typedef uint64_t HEADER_FILE_SIZE_CONTAINER_TYPE_64;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
-#elif UINT_MAX == 0xFFFFFFFFFFFFFFFF
-typedef unsigned int HEADER_FILE_SIZE_CONTAINER_TYPE_64;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
-#elif LONG_MAX = 0xFFFFFFFFFFFFFFFF
-typedef unsigned long HEADER_FILE_SIZE_CONTAINER_TYPE_64;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
-#elif LLONG_MAX = 0xFFFFFFFFFFFFFFFF
-typedef unsigned long long HEADER_FILE_SIZE_CONTAINER_TYPE_64;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
-#elif
-typedef unsigned long HEADER_FILE_SIZE_CONTAINER_TYPE_64;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 4
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64_NOT_AVAIABLE;
-#endif
+//#if defined(UINT64_MAX)
+//typedef uint64_t HEADER_FILE_SIZE_CONTAINER_TYPE_64;
+//#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
+//#elif UINT_MAX == 0xFFFFFFFFFFFFFFFF
+//typedef unsigned int HEADER_FILE_SIZE_CONTAINER_TYPE_64;
+//#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
+//#elif LONG_MAX = 0xFFFFFFFFFFFFFFFF
+//typedef unsigned long HEADER_FILE_SIZE_CONTAINER_TYPE_64;
+//#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
+//#elif LLONG_MAX = 0xFFFFFFFFFFFFFFFF
+//typedef unsigned long long HEADER_FILE_SIZE_CONTAINER_TYPE_64;
+//#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 8
+//#elif
+//typedef unsigned long HEADER_FILE_SIZE_CONTAINER_TYPE_64;
+//#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 4
+//#define HEADER_FILE_SIZE_CONTAINER_SIZE_64_NOT_AVAIABLE;
+//#endif
 
 
 #if defined(UINT32_MAX)
 typedef uint32_t HEADER_FILE_SIZE_CONTAINER_TYPE_32;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 4
+#define HEADER_FILE_SIZE_CONTAINER_SIZE_32 4
 #elif UINT_MAX == 0xFFFFFFFF
 typedef INT HEADER_FILE_SIZE_CONTAINER_TYPE_32;
-#define HEADER_FILE_SIZE_CONTAINER_SIZE_64 4
+#define HEADER_FILE_SIZE_CONTAINER_SIZE_32 4
 #endif
 
+// --------- Control Key --------- //
+#define HEADER_CONTROL_KEY_NB_BYTES 5
+#define HEADER_CONTROL_KEY_1 0b10111011
+#define HEADER_CONTROL_KEY_2 0b10110101
+#define HEADER_CONTROL_KEY_3 0b01100101
+#define HEADER_CONTROL_KEY_4 0b10111000
+#define HEADER_CONTROL_KEY_5 0b10111011
+
 // ----- File Name Container ---- //
 #define HEADER_FILE_NAME_CHAR_MAX 255
 #define HEADER_FILE_NAME_CHAR_TYPE unsigned char
@@ -45,14 +56,15 @@ typedef INT HEADER_FILE_SIZE_CONTAINER_TYPE_32;
 #define HEADER_VERSION_TYPE unsigned char
 #define HEADER_VERSION_SIZE 1
 
-// ----- Flag Container --------- //
-#define HEADER_FLAGS_TYPE unsigned char
-#define HEADER_FLAGS_SIZE 1
+#define HEADER_SIZE_IN_BYTES_32 (HEADER_FILE_SIZE_CONTAINER_SIZE_32+(HEADER_FILE_NAME_CHAR_MAX*HEADER_FILE_NAME_CHAR_SIZE_IN_BYTE)+HEADER_VERSION_SIZE+HEADER_CONTROL_KEY_NB_BYTES)
+
+struct Header
+{
+	Byte header[HEADER_SIZE_IN_BYTES_32];
 
-#define HEADER_SIZE_IN_BYTES_64 (HEADER_FILE_SIZE_CONTAINER_SIZE_64+(HEADER_FILE_NAME_CHAR_MAX*HEADER_FILE_NAME_CHAR_SIZE_IN_BYTE)+HEADER_VERSION_SIZE+HEADER_FLAGS_SIZE)
-#define HEADER_SIZE_IN_BYTES_32 (HEADER_FILE_SIZE_CONTAINER_SIZE_64+(HEADER_FILE_NAME_CHAR_MAX*HEADER_FILE_NAME_CHAR_SIZE_IN_BYTE)+HEADER_VERSION_SIZE+HEADER_FLAGS_SIZE)
+}; typedef struct Header Header;
 
-// Should be 327 if a 64 bit container is used
-// Should be 291 if a 32 bit container is used
+Header HeaderCreate(HEADER_FILE_SIZE_CONTAINER_TYPE_32 file_size, const char * filename);
+Header HeaderExtract(Image* my_image);
 
 #endif // HEADER_H

SteganoTest/src/image.c

@@ -23,7 +23,7 @@ Image* ImageLoad(const char* path_to_file)
 	}
 
 	VERBOSE_ON printf("Loaded image with a width of %dpx, a height of %dpx and %d channels\n", my_image->width, my_image->height, my_image->channels);
-	VERBOSE_ON printf("You can load a file with a maximum size of %d bytes\n", my_image->width * my_image->height - HEADER_SIZE_IN_BYTES_64);
+	VERBOSE_ON printf("You can load a file with a maximum size of %d bytes\n", my_image->width * my_image->height - HEADER_SIZE_IN_BYTES_32);
 	return my_image;
 }
 

SteganoTest/src/launcher.c

@@ -8,6 +8,7 @@
 #include "encoder.h"
 #include "verbose.h"
 #include "external/argtable3.h"
+#include "version.h"
 
 // Argument	Type On, Off, Multiple On
 struct arg_lit* verbose, * help, * version, * extract;
@@ -16,13 +17,7 @@ struct arg_file* output, * file, * image;
 struct arg_end* end;
 char ProgExecName[] = "stegacito.exe";
 char ProgTitle[] = "Stegacito";
-unsigned char version_number = 1;
-char * version_name[] =
-{
-	"PREDEV",
-	"0.0.1",
-	"0.0.2"
-};
+
 int main(int argc, char* argv[])
 {
 	void* argtable[] =
@@ -42,7 +37,7 @@ int main(int argc, char* argv[])
 
 	if (version->count > 0)
 	{
-		printf("Version : %s\n", version_name[version_number]);
+		printf("Version : %s\n", GetVersionName());
 	}
 
 	// Show Help if needed