S1T6 not finished

Makefile

@@ -4,5 +4,6 @@ all:
 	g++ -g -I${INC} -c utils/utils_tester.cpp -o obj/utils_tester.o
 	g++ -g -I${INC} -c utils/xor.c -o obj/xor.o
 	g++ -g -I${INC} -c set1/xor_char_finder.cpp -o obj/xor_char_finder.o
-	g++ -g -lpthread -o utils_tester obj/hex_to_base64.o obj/utils_tester.o obj/xor_char_finder.o obj/xor.o
+	g++ -g -I${INC} -c utils/hamming.c -o obj/hamming.o
+	g++ -g -lpthread -o utils_tester obj/hex_to_base64.o obj/utils_tester.o obj/xor_char_finder.o obj/xor.o obj/hamming.o
 	

etc/set1_t6.txt

@@ -0,0 +1,64 @@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utils/hamming.c

@@ -0,0 +1,63 @@
+#include <string.h>
+#include <stdlib.h>
+#include "utils/hex_to_base64.h"
+
+static unsigned calculate_nb_of_bits_set(unsigned char i_char)
+{
+	static const unsigned len = 8;
+	unsigned char tmp_char = i_char;
+	unsigned idx = 0;
+	unsigned ret = 0;
+	for(;idx<len; idx++)
+	{
+		ret += (tmp_char & 0x01);
+		tmp_char = tmp_char >> 1;
+	}
+	return ret;
+}
+
+// calculate distance between s1 and s2
+// -1 : failure (different sizes of the strings)
+int block_distance(const char* const s1, const char* const s2, const unsigned i_size)
+{
+	int ret = 0;
+	int counter = 0;
+
+	for(counter=0; counter<i_size; ++counter)
+	{
+		ret += calculate_nb_of_bits_set(s1[counter]^s2[counter]);
+	}
+
+	return ret;
+}
+
+int choose_min_block_size(const char* i_string, const unsigned i_size)
+{
+	unsigned block_size = 2;
+	double min_dist=40; // max block is 40 => max dist is 40
+	double tmp_dist1, tmp_dist2;
+	int min_block_size=2;
+
+	tmp_dist1 = tmp_dist2 = 0;
+
+	for(; block_size<=40; block_size++)
+	{
+		// take 4 blocks, calc distance, normalize and get min
+
+		tmp_dist1 = block_distance(i_string, i_string+block_size, block_size);
+		tmp_dist1 = tmp_dist1/block_size;
+		tmp_dist2 = block_distance(i_string+(block_size*2), i_string+(block_size*3), block_size);
+		tmp_dist2 = tmp_dist2/block_size;
+
+		if(tmp_dist2<tmp_dist1)
+			tmp_dist1 = tmp_dist2;
+		if(tmp_dist1<min_dist) {
+			min_dist = tmp_dist1;
+			min_block_size = block_size;
+		}
+	}
+	return min_block_size;
+}
+
+// break  in blocks
+// 

utils/hamming.h

@@ -0,0 +1,2 @@
+int block_distance(const char* const s1, const char* const s2, const unsigned i_size);
+int choose_min_block_size(const char* i_string, const unsigned i_size);

utils/hex_to_base64.cpp

@@ -1,10 +1,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include "utils/hex_to_base64.h"
 
 #define MIN(a,b) a<b ? a : b
 
-unsigned short char_to_hex[256] = { 
+static const unsigned short char_to_hex[256] = { 
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -36,7 +37,21 @@ unsigned short char_to_hex[256] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
-unsigned char int_to_base64[65] = {
+int c2b(char T)
+{
+	if(T>96)      // a...
+		return T-71; 	//// 26=97-71
+	else if(T>64) // A...
+		return T-65; 	//// 0=65-65 
+	else if(T>47) // 0...
+		return T+5;  	//// 52=47+5
+	else if(T==47) // /
+		return T+16;	//// 63=47+16
+	else if(T==43) // +
+		return T+21;	//// 64=43+21
+}
+
+static const unsigned char int_to_base64[65] = {
 	'A','B','C','D','E','F','G','H','I','J',
 	'K','L','M','N','O','P','Q','R','S','T',
 	'U','V','W','X','Y','Z','a','b','c','d',
@@ -46,10 +61,6 @@ unsigned char int_to_base64[65] = {
 	'8','9','+','/','='
 };
 
-// data stores 24 bits
-struct int24 {
-	unsigned int data:24;
-};
 
 void convert_string_to_hex(const char* const iArray, const unsigned iArrayLen, unsigned char*& oHexArray)
 {
@@ -71,7 +82,7 @@ void convert_hex_to_string(const unsigned char* const iHexArray, unsigned iHexAr
 	}
 }
 
-void read_bytes(const char* hex_buff, int24& o_data, unsigned len=3)
+void read_bytes(const char* hex_buff, struct int24& o_data, unsigned len=3)
 {
 	unsigned char* tmp = (unsigned char*)malloc(len);
 	convert_string_to_hex(hex_buff, len*2, tmp);
@@ -153,7 +164,6 @@ unsigned hex_to_base64(const char* hex_buff, char*& base64_buff, unsigned hex_bu
 	return j;
 }
 
-
 /* -----------------------------------------------------------------------------
  * @brief   xor_strings      
  *          
@@ -187,4 +197,53 @@ void xor_strings(const char* const iLeftString, const char* const iRightString,
 
 	free(xor_array1);
 	free(xor_array2);
-}
+}
+
+struct int24 base64_3char_to_hex(const char (&T)[4])
+{
+	unsigned char a = ( c2b(T[0]) << 2 )        | (c2b(T[1]) >> 4 );
+	unsigned char b = ((c2b(T[1]) & 0xF ) << 4) | (c2b(T[2]) >> 2);
+	unsigned char c = ((c2b(T[2]) & 3 ) << 6 )  | (c2b(T[3]) & 0x3F);
+	struct int24 t;
+	t.data = (a<<16) | (b<<8) | c;
+	return t;
+}
+
+/* -----------------------------------------------------------------------------
+ * @brief   Converts string encoded in base64 to HEX      
+ *          
+ * @param   i_string: Base64 encoded string.  
+ * @param	i_string_len: % 4 must == 0 
+ * @param	o_hex_array: array to be populated with HEX's. Caller must ensure 
+ * 				that array has required size. Method doesn't do any checks 
+ *
+ * @returns -1 on failure, 0 on success
+ *          
+-------------------------------------------------------------------------------- */
+int base64_to_hex(const char* const i_string, int i_string_len, unsigned char*& o_hex_array )
+{
+	int pointer = 0;
+	int hex_pointer = 0;
+	char array[4];
+
+	struct int24 tmp;
+	while(pointer<i_string_len)
+	{
+		array[pointer] = *(i_string+pointer);
+		pointer++;
+		array[pointer] = *(i_string+pointer);
+		pointer++;
+		array[pointer] = *(i_string+pointer);
+		pointer++;
+		array[pointer] = *(i_string+pointer);
+		pointer++;
+
+		tmp = base64_3char_to_hex(array);
+		o_hex_array[hex_pointer++] = tmp.data >> 16;
+		o_hex_array[hex_pointer++] = tmp.data >> 8;
+		o_hex_array[hex_pointer++] = tmp.data;
+	}
+
+	return 0;
+}
+

utils/hex_to_base64.h

@@ -1,4 +1,11 @@
+// data stores 24 bits
+struct int24 {
+	unsigned int data:24;
+};
+
 unsigned hex_to_base64(const char* hex_buff, char*& base64_buff, unsigned hex_buff_len );
+int base64_to_hex(const char* const i_string, int i_string_len, unsigned char*& o_hex_array );
 void convert_string_to_hex(const char* const iArray, const unsigned iArrayLen, unsigned char*& oHexArray);
 void convert_hex_to_string(const unsigned char* const iHexArray, unsigned iHexArrayLen, char*& oStringBuf );
 void xor_strings(const char* const iLeftString, const char* const iRightString, unsigned char*& oXorArray);
+int c2b(char T);

utils/utils_tester.cpp

@@ -1,5 +1,6 @@
 #include "hex_to_base64.h"
 #include "set1/xor_char_finder.h"
+#include "hamming.h"
 #include <string.h>
 #include <assert.h>
 #include <stdio.h>
@@ -46,6 +47,33 @@ void hex_to_base64_text() {
 	assert( strlen(expected_buff4) == strlen(output));
 }
 
+unsigned long read_file_to_buffer(const char* const filepath, char*& obuff, int remove_new_line_chr = 1)
+{
+	FILE* fh=0;
+	size_t len=0;
+	char* line=NULL;
+	unsigned long total_len=0;
+
+	if( (fh=fopen(filepath, "rb")) == 0 )
+	{
+		fprintf(stderr, "File %s doesn't exist. Exiting...\n", filepath);
+		exit(1);
+	}
+
+	while( getline(&line, &len, fh) != -1 )
+	{
+		len = strlen(line);
+		if(remove_new_line_chr)
+			len--;
+
+		strncpy(obuff+total_len, line, len);
+		total_len+=len;
+		free(line);
+		line=NULL;
+	}
+	return total_len;
+}
+
 void convert_string_to_hex_test()
 {
 	const char test_buff1[] = "49276d";
@@ -118,14 +146,14 @@ void set2_challange4_test()
 		xor_char_finder(line, max_score);
 		if(max_score.letter != 0x00)
 		{
-			printf("%d -> %c\n", line_nb, max_score.letter);
+			// printf("%d -> %c\n", line_nb, max_score.letter);
 
 			convert_string_to_hex(line, 60, p_hexdump);
 			for(int i=0; i<30;++i)
 			{				
-				printf("%c", hexdump[i]^max_score.letter);
+				// printf("%c", hexdump[i]^max_score.letter);
 			}
-			printf("\n");
+			// printf("\n");
 		}
 		free(line); line=0; len=0;
 
@@ -154,6 +182,23 @@ void set2_challenge_5_test()
 			assert( expected[i] == po_ch1[i] );
 }
 
+void hamming_test()
+{
+	static const char ch1[]="this is a test";
+	static const char ch2[]="wokka wokka!!!";
+	assert(block_distance(ch1,ch2,strlen(ch1)) == 37);
+}
+
+void base64_to_hex_test()
+{
+	static const char ch2[]="TWFuTWFu"; // 0x41 0x61 0x6E 0x41 0x61 0x6E
+	unsigned char out[6];
+	unsigned char *p=out;
+	unsigned char expected[6] = {0x4D, 0x61, 0x6E, 0x4D, 0x61, 0x6E};
+	base64_to_hex(ch2, 8, p);	
+	assert( memcmp(expected, out, 6) == 0 );
+}
+
 int main() {
 	hex_to_base64_text();
 	convert_string_to_hex_test();
@@ -161,5 +206,13 @@ int main() {
 	//set1_challenge3_test();
 	set2_challange4_test();
 	set2_challenge_5_test();
+	hamming_test(); 
+	base64_to_hex_test();
+
+	char buf[1024*1024]; // 1 MB
+	char* pbuf=buf;
+	unsigned long l=read_file_to_buffer("etc/set1_t6.txt", pbuf);
+	buf[l]='\0';
+	printf("%s\n", buf);
 }