MatasanoCrypto/tst/utils.cpp

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

#include "src/base64.h"
#include "src/hamming.h"
#include "src/xor.h"
#include "src/common.h"
#include "src/xor_char_finder.h"

void hex_to_base64_test() {
    const char test_buff1[]     ="49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d";
    const char expected_buff1[] ="SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t";

    const char test_buff2[]     ="4927";
    const char expected_buff2[] ="SSH";

    const char test_buff3[]     ="49";
    const char expected_buff3[] ="SB";

    const char test_buff4[]     ="33";
    const char expected_buff4[] ="z";

    const char test_buff5[]     = "616e79";
    const char expected_buff5[] = "YW55";

    char output[256];

    memset (output,'\0', 256);
    hex_to_base64(test_buff1, output, strlen(test_buff1) );
    CHECK( memcmp(expected_buff1, output, strlen(expected_buff1)) == 0 );
    CHECK( strlen(expected_buff1) == strlen(output));

    // test case  when there are 2 hex'es
    memset (output,'\0', 256);
    hex_to_base64(test_buff2, output, strlen(test_buff2) );
    CHECK( memcmp(expected_buff2, output, strlen(expected_buff2)) == 0 );
    CHECK( strlen(expected_buff2) == strlen(output));

    // test case  when there is 1 hex
    memset (output,'\0', 256);
    hex_to_base64(test_buff3, output, strlen(test_buff3) );
    CHECK( memcmp(expected_buff3, output, strlen(expected_buff3)) == 0 );
    CHECK( strlen(expected_buff3) == strlen(output));

    // test case  when there is 1 char
    memset (output,'\0', 256);
    hex_to_base64(test_buff4, output, strlen(test_buff4) );
    CHECK( memcmp(expected_buff4, output, strlen(expected_buff4)) == 0 );
    CHECK( strlen(expected_buff4) == strlen(output));

    memset (output,'\0', 256);
    hex_to_base64(test_buff5, output, strlen(test_buff5) );
    CHECK( memcmp(expected_buff5, output, strlen(expected_buff5)) == 0 );
    CHECK( strlen(expected_buff5) == strlen(output));
}

void convert_string_to_hex_test()
{
    const char test_buff1[] = "49276d";
    unsigned char out_buff[3];
    convert_string_to_hex(test_buff1, strlen(test_buff1), out_buff);
    CHECK(  out_buff[0] == 0x49
            &&  out_buff[1] == 0x27
            &&  out_buff[2] == 0x6d);

    // and back
    char out_buf[6];
    convert_hex_to_string(out_buff, 3, out_buf);
    CHECK( memcmp(out_buf, test_buff1, 6) == 0 );

}

void xor_strings_test()
{
    const char i_buf_1[] = "1c0111001f010100061a024b53535009181c";
    const char i_buf_2[] = "686974207468652062756c6c277320657965";
    char out_buf[36];
    unsigned char buf[36/2];

    xor_strings(i_buf_1, i_buf_2, buf);

    convert_hex_to_string(buf, 36/2, out_buf);
    CHECK( memcmp(out_buf, "746865206b696420646f6e277420706c6179", 36) == 0);
}

void hamming_test()
{
    unsigned char msg[256];
    const unsigned char ch1[]="this is a test";
    const unsigned char ch2[]="wokka wokka!!!";
    sprintf((char*)msg, "GOT: %d", block_distance(ch1, ch2,14));
    CHECK(block_distance(ch1,ch2, 14) == 37, msg);

    const unsigned char ch3[]="test1";
    const unsigned char ch4[]="test3";

    sprintf((char*)msg, "GOT: %d", block_distance(ch3, ch4,5));
    CHECK(block_distance(ch3,ch4,5)==1, msg);


    const unsigned char ch5[]={0x01, 0x03};
    const unsigned char ch6[]={0x02, 0x02};

    sprintf((char*)msg, "GOT: %d", block_distance(ch5, ch6,2));
    CHECK(block_distance(ch5,ch6,2)==3, msg);

}

uint8_t b64_vec_1_hex = 0x66;
uint8_t b64_vec_1_base64[] = "Zg==";

uint8_t b64_vec_2_hex[] = {0x66, 0x6F};
uint8_t b64_vec_2_base64[] = "Zm8=";

uint8_t b64_vec_3_hex[] = {0x66, 0x6F, 0x6F};
uint8_t b64_vec_3_base64[] = "Zm9v";

uint8_t b64_vec_4_hex[] = {0x66, 0x6F, 0x6F, 0x62};
uint8_t b64_vec_4_base64[] = "Zm9vYg==";

uint8_t b64_vec_5_hex[] = {0x66, 0x6F, 0x6F, 0x62, 0x61};
uint8_t b64_vec_5_base64[] = "Zm9vYmE=";

uint8_t b64_vec_6_hex[] = {0x66, 0x6F, 0x6F, 0x62, 0x61, 0x72};
uint8_t b64_vec_6_base64[] = "Zm9vYmFy";

uint8_t b64_vec_7_hex[] = {0x4D, 0x61, 0x6E, 0x4D, 0x61, 0x6E};
uint8_t b64_vec_7_base64[]= "TWFuTWFu"; // 0x41 0x61 0x6E 0x41 0x61 0x6E

uint8_t b64_vec_8_hex[] = { 0x61, 0x6e, 0x79, 0x20, 0x63, 0x61, 0x72, 0x6e, 0x61,
                            0x6c, 0x20, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x75};
uint8_t b64_vec_8_base64[]= "YW55IGNhcm5hbCBwbGVhc3U="; // 0x41 0x61 0x6E 0x41 0x61 0x6E

struct Base64_Vector {
    const uint8_t* hex;
    const uint32_t hex_len;
    const uint8_t* base64;
    const uint32_t base64_len;

} b64_vectors[]={
    {
        &b64_vec_1_hex,     1,
        b64_vec_1_base64,   sizeof(b64_vec_1_base64)
    },
    {
        b64_vec_2_hex,      sizeof(b64_vec_2_hex),
        b64_vec_2_base64,   sizeof(b64_vec_2_base64)
    },
    {
        b64_vec_3_hex,      sizeof(b64_vec_3_hex),
        b64_vec_3_base64,   sizeof(b64_vec_3_base64)
    },
    {
        b64_vec_4_hex,      sizeof(b64_vec_4_hex),
        b64_vec_4_base64,   sizeof(b64_vec_4_base64)
    },
    {
        b64_vec_5_hex,      sizeof(b64_vec_5_hex),
        b64_vec_5_base64,   sizeof(b64_vec_5_base64)
    },
    {
        b64_vec_6_hex,      sizeof(b64_vec_6_hex),
        b64_vec_6_base64,   sizeof(b64_vec_6_base64)
    },
    {
        b64_vec_7_hex,      sizeof(b64_vec_7_hex),
        b64_vec_7_base64,   sizeof(b64_vec_7_base64)
    },
    {
        b64_vec_8_hex,      sizeof(b64_vec_8_hex),
        b64_vec_8_base64,   sizeof(b64_vec_8_base64)
    },
};

void base64_test()
{
    uint8_t tmpbuf[256];

    // BASE64->HEX

    // empty string
    uint32_t ret = 256;
    b64_to_hex((const uint8_t*)"", 0, tmpbuf, &ret);
    CHECK(ret == 0);

    // vectors
    for(size_t i=0; i<sizeof(b64_vectors)/sizeof(Base64_Vector); i++) {
        Base64_Vector* vec = &b64_vectors[i];
        ret = 256;
        b64_to_hex(vec->base64, vec->base64_len, tmpbuf, &ret);

        char log_buf[256];
        sprintf(log_buf, "Counter %u. Expected %u but got %d\n", i, vec->base64_len-1, ret);
        CHECK( memcmp(vec->hex, tmpbuf, ret) == 0, (uint8_t*)log_buf );
    }

    // HEX->BASE64
    /* OZAPTF: hex_to_base64 dosn't work
    for(size_t i=0; i<sizeof(b64_vectors)/sizeof(Base64_Vector); i++) {
        Base64_Vector* vec = &b64_vectors[i];
        ret = hex_to_base64((char*)vec->hex, (char*)tmpbuf, vec->hex_len);

        printf("%u %u\n", ret, vec->base64_len);
        CHECK(ret == vec->base64_len);
        CHECK( memcmp(tmpbuf, vec->base64, ret) == 0);
    }
    */
}


void c2b_test()
{
    CHECK( c2b('A') ==  0 );
    CHECK( c2b('L') == 11 );
    CHECK( c2b('Z') == 25 );
    CHECK( c2b('a') == 26 );
    CHECK( c2b('z') == 51 );
    CHECK( c2b('0') == 52 );
    CHECK( c2b('5') == 57 );
    CHECK( c2b('9') == 61 );
    CHECK( c2b('+') == 62 );
    CHECK( c2b('/') == 63 );
    CHECK( c2b('=') == 64 );
    CHECK( c2b('*') == 0xFF );
}