#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "libs/ciphers.h"

#include "libs/exploits.h"

#include "libs/macs.h"

#include "libs/utils.h"

int source_25(unsigned char *ct)

{

FILE *fp = fopen("files/25.txt", "r");

unsigned char ecb[4096] = {0}, pt[4096] = {0};

unsigned char key[] = "YELLOW SUBMARINE", nonce[8] = {0};

char b64[60];

int i;

for (i = 0; fscanf(fp, "%s", b64) == 1; i += 45) {

base64_str_to_binary(b64, ecb + i);

}

// no padding on the plaintext, so we ignore

// the following return value

decrypt_AES_ECB(ecb, pt, i - 45, key);

return AES_CTR(pt, ct, i - 45, get_static_key(), nonce);

}

int edit_25(unsigned char *ct, unsigned char *key, int length, int offset,

char *newtext)

{

// too lazy to do this efficiently, just

// bulk decrypt, replace, encrypt

unsigned char pt[4096], nonce[8] = {0};

length = AES_CTR(ct, pt, length, key, nonce);

memcpy(pt + offset, newtext, strlen(newtext));

AES_CTR(pt, ct, length, key, nonce);

return strlen(newtext);

}

void challenge_25()

{

unsigned char ct[4096] = {0}, pt[4096];

int length = source_25(ct);

char newtext[2] = {0};

newtext[0] = 0x01;

unsigned char c;

int i;

for (i = 0; i < length; ++i) {

c = ct[i];

edit_25(ct, get_static_key(), length, i, newtext);

pt[i] = c ^ ct[i] ^ 0x01;

}

print_str((char *)pt);

}

int source_26(unsigned char *in, size_t length, unsigned char *out)

{

char prepend[] = "comment1=cooking%20MCs;userdata=";

char append[] = ";comment2=%20like%20a%20pound%20of%20bacon";

int pre_length = strlen(prepend), ap_length = strlen(append);

char *encoding = malloc((pre_length + 3 * length + ap_length) * sizeof(char));

memcpy(encoding, prepend, pre_length);

int i, j;

for (i = 0, j = pre_length; i < length; ++i, ++j) {

if (in[i] == ';' || in[i] == '=') {

encoding[j++] = '"';

encoding[j++] = in[i];

encoding[j] = '"';

} else {

encoding[j] = in[i];

}

}

memcpy(encoding + j, append, ap_length);

unsigned char nonce[8] = {0};

int encrypted_length = AES_CTR((unsigned char *)encoding, out,

j + ap_length, get_static_key(), nonce);

free(encoding);

return encrypted_length;

}

int receiver_26(unsigned char *in, size_t length)

{

unsigned char *out = malloc(length * sizeof(unsigned char));

unsigned char nonce[8] = {0};

int str_length = AES_CTR(in, out, length, get_static_key(), nonce);

unsigned char target[13] = ";admin=true;";

int i, j;

for (i = 0, j = 0; i < str_length; ++i) {

if (out[i] == target[j]) {

++j;

if (j > 11) {

free(out);

return 1;

}

} else {

j = 0;

}

}

free(out);

return 0;

}

void challenge_26()

{

unsigned char input[11] = ":admin<true";

unsigned char output[512] = {0};

int len = source_26(input, 11, output);

output[32] ^= 0x01;

output[38] ^= 0x01;

int result = receiver_26(output, len);

if (result) {

print_str("admin priveleges");

} else {

print_str("stay back, plebeian");

}

}

int source_27(unsigned char *in, size_t length, unsigned char *out)

{

char prepend[] = "comment1=cooking%20MCs;userdata=";

char append[] = ";comment2=%20like%20a%20pound%20of%20bacon";

int pre_length = strlen(prepend), ap_length = strlen(append);

char *encoding = malloc((pre_length + 3 * length + ap_length) * sizeof(char));

memcpy(encoding, prepend, pre_length);

int i, j;

for (i = 0, j = pre_length; i < length; ++i, ++j) {

if (in[i] == ';' || in[i] == '=') {

encoding[j++] = '"';

encoding[j++] = in[i];

encoding[j] = '"';

} else {

encoding[j] = in[i];

}

}

memcpy(encoding + j, append, ap_length);

int encrypted_length = encrypt_AES_CBC((unsigned char *)encoding, out,

j + ap_length, get_static_key(), get_static_key());

free(encoding);

return encrypted_length;

}

int receiver_27(unsigned char *in, size_t length, unsigned char *out)

{

int str_length = decrypt_AES_CBC(in, out, length, get_static_key(), get_static_key());

int i, high_ascii = 0;

for (i = 0; i < str_length; ++i) {

if (out[i] > 0x7f) {

++high_ascii;

break;

}

}

if (!high_ascii) {

memset(out, 0, str_length);

return 0;

}

return 1;

}

void challenge_27()

{

unsigned char ct[128] = {0}, pt[128] = {0};

int length = source_27(NULL, 0, ct);

int i;

for (i = 0; i < 16; ++i) {

ct[i + 16] = 0;

ct[i + 32] = ct[i];

}

int result = receiver_27(ct, length, pt);

unsigned char key[16] = {0};

if (result) {

fixed_xor(pt, pt + 32, 16, key);

if (memcmp(get_static_key(), key, 16) == 0) {

print_str("Key recovered.");

} else {

print_str("Key incorrect.");

}

} else {

print_str("No high-ASCII error received.");

}

}

void challenge_28()

{

unsigned char message[] = "message", key[] = "key";

unsigned char mac[20];

sha1_keyed_mac(message, 7, key, 3, mac);

print_hex(mac, 20);

}

void challenge_29()

{

unsigned char message[128] = "comment1=cooking%20MCs;userdata=foo;"

"comment2=%20like%20a%20pound%20of%20bacon";

int mlen = 77, plen;

unsigned char padded_message[256] = {0};

memcpy(padded_message, message, 128);

unsigned char append[16] = ";admin=true";

int alen = 11;

unsigned char mac[20], forged_mac[20], test_mac[20];

print_str("Base MAC");

sha1_keyed_mac(message, strlen((char *) message),

(unsigned char *) get_static_word(),

strlen(get_static_word()), mac);

print_hex(mac, 20);

print_str("\nForged MAC");

// Assumes secret length 8, but will be the same for any

// secret length that doesn't increase or decrease the

// number of 64 byte blocks in the hash input + padding

sha1_length_extension(mac, mlen + 8 + sha1_pad_length(mlen + 8), append, alen, forged_mac);

print_hex(forged_mac, 20);

print_str("\nPlaintext verified by server: ");

int i;

for (i = 0; i < 16; ++i) {

plen = sha1_pad(padded_message, mlen, i);

memcpy(padded_message + plen, append, alen);

plen += alen;

sha1_keyed_mac(padded_message, plen,

(unsigned char *) get_static_word(),

strlen(get_static_word()), test_mac);

if (memcmp(forged_mac, test_mac, 20) == 0) {

print_hex(test_mac, 20);

print_binary(padded_message, plen);

}

}

}

void challenge_30()

{

unsigned char message[128] = "comment1=cooking%20MCs;userdata=foo;"

"comment2=%20like%20a%20pound%20of%20bacon";

int mlen = 77, plen;

unsigned char padded_message[256] = {0};

memcpy(padded_message, message, 128);

unsigned char append[16] = ";admin=true";

int alen = 11;

unsigned char mac[16], forged_mac[16], test_mac[16];

print_str("Base MAC");

md4_keyed_mac(message, strlen((char *) message),

(unsigned char *) get_static_word(),

strlen(get_static_word()), mac);

print_hex(mac, 16);

print_str("\nForged MAC");

// Assumes secret length 8, but will be the same for any

// secret length that doesn't increase or decrease the

// number of 64 byte blocks in the hash input + padding

md4_length_extension(mac, mlen + 8 + sha1_pad_length(mlen + 8), append, alen, forged_mac);

print_hex(forged_mac, 16);

print_str("\nPlaintext verified by server: ");

int i;

for (i = 0; i < 16; ++i) {

plen = md4_pad(padded_message, mlen, i);

memcpy(padded_message + plen, append, alen);

plen += alen;

md4_keyed_mac(padded_message, plen,

(unsigned char *) get_static_word(),

strlen(get_static_word()), test_mac);

//print_hex(test_mac, 16);

//print_binary(padded_message, plen);

if (memcmp(forged_mac, test_mac, 16) == 0) {

print_hex(test_mac, 16);

print_binary(padded_message, plen);

}

}

}

int insecure_compare_31(unsigned char *a, unsigned char *b, int n)

{

int i;

for (i = 0; i < n; ++i) {

if (a[i] != b[i]) {

return b[i] - a[i];

}

sleepms(50);

}

return 0;

}

int server_31(unsigned char *file, int flen, unsigned char *signature)

{

unsigned char hmac[20];

sha1_hmac(get_static_key(), 16, file, flen, hmac);

if (insecure_compare_31(signature, hmac, 20) == 0) {

return 200;

}

return 500;

}

void challenge_31()

{

unsigned char file[128] = "file";

unsigned char vector[20] = {0};

int i, j;

for (i = 0; i < 20; ++i) {

for (j = 0; j < 256; ++j) {

vector[i] = j;

stopwatch_ms();

server_31(file, 4, vector);

int ms = stopwatch_ms();

if (ms >= 50 * (i + 1)) {

break;

}

}

}

if (server_31(file, 4, vector) == 200) {

print_str("Verified MAC for \"file\":");

print_hex(vector, 20);

}

}

int insecure_compare_32(unsigned char *a, unsigned char *b, int n)

{

int i;

for (i = 0; i < n; ++i) {

if (a[i] != b[i]) {

return b[i] - a[i];

}

sleepms(1);

}

return 0;

}

int server_32(unsigned char *file, int flen, unsigned char *signature)

{

unsigned char hmac[20];

sha1_hmac(get_static_key(), 16, file, flen, hmac);

if (insecure_compare_32(signature, hmac, 20) == 0) {

return 200;

}

return 500;

}

void challenge_32()

{

setbuf(stdout, NULL);

unsigned char file[128] = "file";

unsigned char vector[20] = {0};

print_str("Cracked HMAC:");

int i, j, k, best_time;

int times[256];

for (i = 0; i < 20; ++i) {

for (j = 0; j < 256; ++j) {

times[j] = 0;

}

for (k = 0; k < 5; ++k) {

for (j = 0; j < 256; ++j) {

vector[i] = j;

stopwatch_us();

server_32(file, 4, vector);

times[j] += stopwatch_us();

}

}

best_time = 0;

for (j = 0; j < 256; ++j) {

if (times[j] > best_time) {

best_time = times[j];

vector[i] = j;

}

}

printf("%02x", vector[i]);

}

if (server_32(file, 4, vector) == 200) {

print_str("\nHMAC verified as correct.");

} else {

print_str("\nHMAC incorrect.");

}

}

int main(int argc, char *argv[])

{

srand(time(NULL));

challenge_32();

}