path: root/task1_hex_to_base64.c

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

static const unsigned char base64_encode[] =
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz"
	"0123456789+/";

static const unsigned char hex_encode[] =
	"0123456789abcdef";

/*
 * This functions accepts a string and returns it base64 encoded
*/
void three_bytes_to_base64(char * encode, int bytes_to_print, char *result)
{
	unsigned char one, two, three, four;
	unsigned char tmp;
	char ret[4];
	
	// first six bits
	one = encode[0] >> 2;
	ret[0] = base64_encode[one];
	if(bytes_to_print-- > 0)
		result[0] = ret[0];
	// second six bits
	// two last bits of first byte
	tmp = encode[0] & 0x03;
	two = encode[1] >> 4;
	tmp = tmp << 4;
	two = tmp | two;
	ret[1] = base64_encode[two];
	if(bytes_to_print-- > 0)
		result[1] = ret[1];
	// second six bits
	// two last bits of first byte
	// third six bits
	tmp = encode[1] & 0x0F;
	tmp = tmp << 2;
	three = encode[2] & 0xC0;
	three = three >> 6;
	three = tmp | three;
	ret[2] = base64_encode[three];
	if(bytes_to_print-- > 0)
		result[2] = ret[2];
	// last six bit11s
	four = encode[2] & 0x3F;
	ret[3] = base64_encode[four];
	ret[4] = '\0';
	if(bytes_to_print-- > 0)
		result[3] = ret[3];
	}




static char string_to_hex_map[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
				   0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
				   0x0E, 0x0F};
/*
 * This function converts the first char of a string into its corresponding 
 * hex value
 *
 * @return On Sucess return 0, if char is no valid hex value returns -1
 */
int hex_char_to_bit(char toEncode)
{
	char encode;
	switch(toEncode) {
		case '0':
			encode = string_to_hex_map[0];
			break;
		case '1':
			encode = string_to_hex_map[1];
			break;
		case '2':
			encode = string_to_hex_map[2];
			break;
		case '3':
			encode = string_to_hex_map[3];
			break;
		case '4':
			encode = string_to_hex_map[4];
			break;
		case '5':
			encode = string_to_hex_map[5];
			break;
		case '6':
			encode = string_to_hex_map[6];
			break;
		case '7':
			encode = string_to_hex_map[7];
			break;
		case '8':
			encode = string_to_hex_map[8];
			break;
		case '9':
			encode = string_to_hex_map[9];
			break;
		case 'a':
			encode = string_to_hex_map[10];
			break;
		case 'b':
			encode = string_to_hex_map[11];
			break;
		case 'c':
			encode = string_to_hex_map[12];
			break;
		case 'd':
			encode = string_to_hex_map[13];
			break;
		case 'e':
			encode = string_to_hex_map[14];
			break;
		case 'f':
			encode = string_to_hex_map[15];
			break;
		default:
			return -1;
	}

	return encode;

}


void two_char_hex(char *start, char *result)
{
	char first = hex_char_to_bit(start[0]);
	char second = hex_char_to_bit(start[1]);
	
	*result = first;
	*result = *result << 4;
	*result = *result | second;
}

int convert_hex_string_to_character_string(char *encode, char* result)
{
	int i;
	int length = strlen(encode);

	for(i = 0;i< length/2;i++)
		two_char_hex(&encode[i*2], &result[i]);

	return i;
}

int convert_to_base64(char *encode, char *result)
{
	int length = strlen(encode);
	
	int rounds = length / 3;
	int bytes_last_round = length % 3;
	int i;

	for (i=0;i<rounds;i++) {
		three_bytes_to_base64(encode + i*3,4, &result[i*4]);
	}
	// in der letzen runde nicht mehr alle ausgeben
	// nur noch 3-leftover
	if (bytes_last_round > 0) {
		three_bytes_to_base64(encode + i*3, 1+bytes_last_round, &result[i*4]);

		for(i=0;i<(3-bytes_last_round);i++)
			result[i*4+(1+bytes_last_round)] = '=';
	}

}

void xor_string(char *str1, char* str2, char *result, int length) {
	int i;
	
	for(i=0;i<length;i++)
		result[i] = str1[i] ^ str2[i];
	
	return;
		
}


void xor_string_single_byte(char byte, char* string, char *result, int length) {
	int i;

	for(i=0;i<length;i++)
		result[i] = string[i] ^ byte;

	result[i] = '\0';

	return;
}

/**
 * results must be to times bigger than str1
 */
void hex_binary_to_string(char *str1, char *result, int length)
{
	int i;
	int tmp = 0;

	for(i=0;i<length/2;i++) {
		tmp = str1[i] & 0xF0;
		tmp = tmp >> 4;
		result[i*2] = hex_encode[tmp];
		tmp = str1[i] & 0x0F;
		result[(i*2)+1] = hex_encode[tmp];
	}

	result[i*2] = '\0';
}



int score_based_on_frequent_characters(char *string, int length)
{
	int number = 0;
	int i;
	char tmp;

	for(i=0;i<length;i++) {
		tmp = tolower(string[i]);	
		if( tmp == 'e' || tmp == 'a' || tmp == 'i' || tmp == 'o'
			|| tmp == 'u' )
			number++;
	}

	return ((number*100)/length);
}

int isprintable(char *string, int length)
{
	int i;

	for(i=0;i<length;i++) {
		if(!(isprint(string[i]) || isspace(string[i]))) {
			return 0;
		}
	}

	return 1;
}

void string_looks_like_it_is_english(char *string, int length)
{
	char *xor_tmp = malloc(strlen(string));
	int i;

	for(i= 0; i< 255; i++) {
		xor_string_single_byte((char) i, string, xor_tmp, length);
		if (!isprintable(xor_tmp, length))
			continue;
		int score = score_based_on_frequent_characters(xor_tmp, length);
		if(score > 20)
			printf("char: %c, score: %i, string: %s\n", (char) i, score, xor_tmp);
	}

	//free(xor_tmp);
}

void task4() {
	/** read the file */
	FILE *fp;
	int bytes_read;
	int malloc_size = 62;
	int line_number = 0;
	int j;
	char *string = malloc(malloc_size);
	char *string2 = malloc(malloc_size);

	fp = fopen("4.txt", "r");

	if (fp == NULL) {
		printf("Error open file\n");
		exit(1);
	}
	
	while (fscanf(fp, "%61c", string) != EOF) {
		j = convert_hex_string_to_character_string(string, string2);
		printf("line number: %i, length: %i,\n",  line_number, j);
		string_looks_like_it_is_english(string2, j);
		line_number++;
	}

	fclose(fp);

}


int main(int argc, char **argv)
{
	if (argc == 3 ) {
		int length = strlen(argv[1]);
		char *tmp = malloc(length);
		char *tmp2 = malloc(length);
		char *base64= malloc(length);
		char *__xor_string = malloc(length);
		char *back_hex = malloc(length);
		int i = convert_hex_string_to_character_string(argv[1], tmp);
		int j = convert_hex_string_to_character_string(argv[2], tmp2);
		xor_string(tmp, tmp2, __xor_string, strlen(argv[2]));
		// convert the __xor_string to printable charaters
		hex_binary_to_string(tmp2, back_hex, strlen(argv[2]));
		printf("***************************\n");
		printf("set 1, challelnge 1:\n");
		printf("input string 1:\n");
		printf("%s\n", argv[1]);
		printf("input string 2:\n");
		printf("%s\n", argv[2]);

		printf("char string of arg 1:\n");
		printf("%s\n", tmp);
		printf("char string of arg 2:\n");
		printf("%s\n", tmp2);

		printf("string 2 from hex back to printable charaters:\n");	
		printf("%s\n", back_hex);
		printf("***************************\n");
		printf("set 1, challenge 2\n");
		printf("xor string:\n");
		hex_binary_to_string(__xor_string, back_hex, strlen(argv[2]));
		printf("%s\n", back_hex);

		printf("***************************\n");
		printf("set 1, challenge 3\n");
		//string_looks_

		}

	printf("***************************\n");
	printf("set 1, challenge 4\n");
	task4();


}