[dcdev] Encrypting ADC

/* 
 * Copyright (C) 2005 Gustaf Räntilä, gustaf ta gempond tod com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

// Standard c-library stuff
#include <stdlib.h>
#include <time.h>

// Crypto
#include <openssl/aes.h>
#include <openssl/rand.h>

// STL
#include <string>

// Changable values
/* Key sizes are in bytes, so 128, 192 and 256 bits refer to 16, 24 and 32 bytes. */
#define KEY_SIZE 16
/* User count */
#define MAX_USERS 2500
/* Message pool */
#define MAX_MESSAGES 10000
/* Time of simulation */
#define SECONDS 30

#define MIN(x, y) (((x) < (y)) ? (x) : (y))

using namespace std;

typedef unsigned char u8;
typedef const u8 cu8;

struct AESKey {
	AES_KEY enc;
	AES_KEY dec;
};

class AES {
public:
	static AESKey* makeKey(const char* str, size_t len) {
		AESKey* aes = new AESKey;
		cu8* key = (cu8*)str;
		size_t keysize = len;
		u8 tmpkey[32];
		if (len != 16 && len != 24 && len != 32) {
			// Algorithmly not necessary, but for libcrypto it is
			// Note; key is now NOT of size <len> as requested!
			// Try to stick to using AES specified key-sizes.
			// Pad "too small" keys with blankspace, and truncate too large ones
			len = MIN(len, 32);
			memcpy(&tmpkey[0], key, len);
			if (len < 16)
				keysize = 16;
			else if (len < 24)
				keysize = 24;
			else
				keysize = 32;
			for (size_t i = len; i < keysize; ++i)
				tmpkey[i] = ' ';
			key = &tmpkey[0];
		}
		if (0 != AES_set_encrypt_key(key, keysize * 8, &aes->enc)) {
			delete aes;
			return NULL;
		}
		if (0 != AES_set_decrypt_key(key, keysize * 8, &aes->dec)) {
			delete aes;
			return NULL;
		}
		return aes;
	}
	static void encrypt(const char* in, char* out, size_t len, AESKey* key) {
		// if (len % 16) exit(1); // not block size multiple
		for (size_t i = 0; i < len; i += 16)
			AES_encrypt((cu8*)in + i, (u8*)out + i, &key->enc);
	}
	static void decrypt(const char* in, char* out, size_t len, AESKey* key) {
		// if (len % 16) exit(1); // not block size multiple
		for (size_t i = 0; i < len; i += 16)
			AES_decrypt((cu8*)in + i, (u8*)out + i, &key->dec);
	}
};

struct UserStruct {
	char pad[100]; // In hubsofts, user structures contains a lot of stuff ignored here
	AESKey* aeskey;
};

struct Message {
	UserStruct* user;
	char* message;
	int message_len;
};

static inline int simpleRand(int max) {
	return rand() % max;
}

int main(int argc, void** argv) {
	srand(time(0));

	UserStruct* users = new UserStruct[MAX_USERS];
	Message* messages = new Message[MAX_MESSAGES];

	// Create user objects
	printf("Generating %i users (keys, of size %i bits)...\n", MAX_USERS, KEY_SIZE*8);
	fflush(stdout);
	char randkey[KEY_SIZE];
	for (int i = 0; i < MAX_USERS; ++i) {
		RAND_bytes((u8*)&randkey[0], KEY_SIZE);
		users[i].aeskey = AES::makeKey(&randkey[0], KEY_SIZE);
	}

	// Create messages
	printf("Generating %i messages, and encrypt them (to simulate incoming encrypted message)...\n", MAX_MESSAGES);
	fflush(stdout);
	for (int i = 0; i < MAX_MESSAGES; ++i) {
		messages[i].user = &users[i % MAX_USERS];
		messages[i].message_len = 16;
		messages[i].message_len += 	simpleRand(200); // Message sizes are between 16 and 216 bytes...
		if (messages[i].message_len % 16)
			// ...make message multiple of 16 bytes, AES is 16-size block cipher
			messages[i].message_len += 16 - (messages[i].message_len % 16);
		messages[i].message = new char[messages[i].message_len];
		RAND_bytes((u8*)messages[i].message, messages[i].message_len - 1);
		// Ensure readable ASCII characters... No reason for this really.
		for (string::size_type j = 0; j < messages[i].message_len - 1; ++j)
			if ((u8)messages[i].message[j] < 32 || (u8)messages[i].message[j] > 192)
				static_cast<u8>(messages[i].message[j]) += 128;
		messages[i].message[messages[i].message_len - 1] = 0;
		// Encrypt this message
		AES::encrypt(messages[i].message, messages[i].message, messages[i].message_len, messages[i].user->aeskey);
	}

	// Benchmarking message encryption/decryption
	printf("Decrypting random message, encrypting to all %i users for %i seconds...\n", MAX_USERS, SECONDS);
	fflush(stdout);

	clock_t c_start, c_end;
	c_start = clock();
	c_end = c_start + CLOCKS_PER_SEC * SECONDS;
	size_t bytes = 0, num_messages = 0;
	do {
		Message* msg = &messages[simpleRand(MAX_MESSAGES)];
		// if (msg->message_len % 16) exit(1);
		// Decrypt message
		char* dec_msg = new char[msg->message_len];
		AES::decrypt(msg->message, dec_msg, msg->message_len, msg->user->aeskey);
		bytes += msg->message_len;
		num_messages += 1;
		// Encrypt to each and every user (including the sender, whatever... doesn't really affect ordo.)
		for (int i = 0; i < MAX_USERS; ++i) {
			char* sendbuf = new char[msg->message_len];
			AES::encrypt(dec_msg, sendbuf, msg->message_len, users[i].aeskey);
			delete[] sendbuf;
			bytes += msg->message_len;
		}
		delete[] dec_msg;
	} while (clock() < c_end);
	printf("Done. Throughput: %i kbytes/s, %i and messages passed hub per second.\n", (bytes/SECONDS) >> 10, num_messages / SECONDS);
	fflush(stdout);

}