/* ブロックを確保する */
static struct block *block_malloc (unsigned short hash) {
int i;
struct block *p;
if (hash_unfill[0] != NULL) {
/* ブロック用の領域は確保済み */
p = hash_unfill[0];
hash_unfill[0] = hash_unfill[0]->unfill_next;
} else {
/* ブロック用の領域を新たに確保する */
p = (struct block *) MALLOC (sizeof (struct block) * (BLOCK_ALLOC), __FILE__, __LINE__, __func__);
if (p == NULL) {
ShowFatalError ("Memory manager::block_alloc failed.\n");
exit (EXIT_FAILURE);
}
if (block_first == NULL) {
/* 初回確保 */
block_first = p;
} else {
block_last->block_next = p;
}
block_last = &p[BLOCK_ALLOC - 1];
block_last->block_next = NULL;
/* ブロックを連結させる */
for (i = 0; i < BLOCK_ALLOC; i++) {
if (i != 0) {
// p[0] はこれから使うのでリンクには加えない
p[i].unfill_next = hash_unfill[0];
hash_unfill[0] = &p[i];
p[i].unfill_prev = NULL;
p[i].unit_used = 0;
}
if (i != BLOCK_ALLOC - 1) {
p[i].block_next = &p[i + 1];
}
}
}
// unfill に追加
memmgr_assert (hash_unfill[ hash ] == NULL);
hash_unfill[ hash ] = p;
p->unfill_prev = &block_head;
p->unfill_next = NULL;
p->unit_size = (unsigned short) (hash2size (hash) + sizeof (struct unit_head));
p->unit_hash = hash;
p->unit_count = BLOCK_DATA_SIZE / p->unit_size;
p->unit_used = 0;
p->unit_unfill = 0xFFFF;
p->unit_maxused = 0;
#ifdef DEBUG_MEMMGR
memset (p->data, 0xfd, sizeof (p->data));
#endif
return p;
}
/* Allocating blocks */
static struct block* block_malloc(unsigned short hash)
{
int i;
struct block *p;
if(hash_unfill[0] != NULL) {
/* Space for the block has already been secured */
p = hash_unfill[0];
hash_unfill[0] = hash_unfill[0]->unfill_next;
} else {
/* Newly allocated space for the block */
p = (struct block*)MALLOC(sizeof(struct block) * (BLOCK_ALLOC), __FILE__, __LINE__, __func__ );
if(p == NULL) {
ShowFatalError("Memory manager::block_alloc failed.\n");
exit(EXIT_FAILURE);
}
if(block_first == NULL) {
/* First ensure */
block_first = p;
} else {
block_last->block_next = p;
}
block_last = &p[BLOCK_ALLOC - 1];
block_last->block_next = NULL;
/* Linking the block */
for(i=0;i<BLOCK_ALLOC;i++) {
if(i != 0) {
// I do not add the link p [0], so we will use
p[i].unfill_next = hash_unfill[0];
hash_unfill[0] = &p[i];
p[i].unfill_prev = NULL;
p[i].unit_used = 0;
}
if(i != BLOCK_ALLOC -1) {
p[i].block_next = &p[i+1];
}
}
}
// Add to unfill
memmgr_assert(hash_unfill[ hash ] == NULL);
hash_unfill[ hash ] = p;
p->unfill_prev = &block_head;
p->unfill_next = NULL;
p->unit_size = (unsigned short)(hash2size( hash ) + sizeof(struct unit_head));
p->unit_hash = hash;
p->unit_count = BLOCK_DATA_SIZE / p->unit_size;
p->unit_used = 0;
p->unit_unfill = 0xFFFF;
p->unit_maxused = 0;
#ifdef DEBUG_MEMMGR
memset( p->data, 0xfd, sizeof(p->data) );
#endif
return p;
}
/* �u���b�N���m�ۂ��� */
static struct block* block_malloc(unsigned short hash)
{
int i;
struct block *p;
if(hash_unfill[0] != NULL) {
/* �u���b�N�p�̗̈�͊m�ۍς� */
p = hash_unfill[0];
hash_unfill[0] = hash_unfill[0]->unfill_next;
} else {
/* �u���b�N�p�̗̈��V���Ɋm�ۂ��� */
p = (struct block*)MALLOC(sizeof(struct block) * (BLOCK_ALLOC), __FILE__, __LINE__, __func__ );
if(p == NULL) {
printf("Memory manager::block_alloc failed.\n");
exit(EXIT_FAILURE);
}
if(block_first == NULL) {
/* ����m�� */
block_first = p;
} else {
block_last->block_next = p;
}
block_last = &p[BLOCK_ALLOC - 1];
block_last->block_next = NULL;
/* �u���b�N��A�������� */
for(i=0;i<BLOCK_ALLOC;i++) {
if(i != 0) {
// p[0] �͂��ꂩ��g���̂Ń����N�ɂ͉����Ȃ�
p[i].unfill_next = hash_unfill[0];
hash_unfill[0] = &p[i];
p[i].unfill_prev = NULL;
p[i].unit_used = 0;
}
if(i != BLOCK_ALLOC -1) {
p[i].block_next = &p[i+1];
}
}
}
// unfill �ɒlj�
memmgr_assert(hash_unfill[ hash ] == NULL);
hash_unfill[ hash ] = p;
p->unfill_prev = &block_head;
p->unfill_next = NULL;
p->unit_size = (unsigned short)(hash2size( hash ) + sizeof(struct unit_head));
p->unit_hash = hash;
p->unit_count = BLOCK_DATA_SIZE / p->unit_size;
p->unit_used = 0;
p->unit_unfill = 0xFFFF;
p->unit_maxused = 0;
#ifdef DEBUG_MEMMGR
memset( p->data, 0xfd, sizeof(p->data) );
#endif
return p;
}
static ssize_t
make_intro_from_plaintext(
void *buf, size_t len, crypto_pk_t *key, void **cell_out)
{
char *cell = NULL;
ssize_t cell_len = -1, r;
/* Assemble key digest and ciphertext, then construct the cell */
ssize_t ciphertext_size;
if (!(buf && key && len > 0 && cell_out)) goto done;
/*
* Figure out an upper bound on how big the ciphertext will be
* (see crypto_pk_public_hybrid_encrypt())
*/
ciphertext_size = PKCS1_OAEP_PADDING_OVERHEAD;
ciphertext_size += crypto_pk_keysize(key);
ciphertext_size += CIPHER_KEY_LEN;
ciphertext_size += len;
/*
* Allocate space for the cell
*/
memmgr_init_check_shared_mem(SHARED_SIZE, UIO_DEVICE, BASE_ADDRESS);
// cell = tor_malloc(DIGEST_LEN + ciphertext_size);
cell = memmgr_alloc(DIGEST_LEN + ciphertext_size);
memmgr_assert(buf);
/* Compute key digest (will be first DIGEST_LEN octets of cell) */
r = crypto_pk_get_digest(key, cell);
tt_assert(r >= 0);
/* Do encryption */
r = crypto_pk_public_hybrid_encrypt(
key, cell + DIGEST_LEN, ciphertext_size,
buf, len,
PK_PKCS1_OAEP_PADDING, 0);
tt_assert(r >= 0);
/* Figure out cell length */
cell_len = DIGEST_LEN + r;
/* Output the cell */
*cell_out = cell;
done:
// memmgr_free(cell);
return cell_len;
}
/** Parse a CREATED, CREATED_FAST, or CREATED2 cell from <b>cell_in</b> into
* <b>cell_out</b>. Return 0 on success, -1 on failure. */
int
created_cell_parse(created_cell_t *cell_out, const cell_t *cell_in)
{
// printf("\nAsserting in created_cell_parse");
memmgr_assert((void*)cell_in);
memset(cell_out, 0, sizeof(cell_t));
int i;
switch (cell_in->command) {
case CELL_CREATED:
// printf("\ncreated cell t case 1");
cell_out->cell_type = CELL_CREATED;
cell_out->handshake_len = TAP_ONIONSKIN_REPLY_LEN;
for(i=0; i<TAP_ONIONSKIN_REPLY_LEN; i++){
cell_out->reply[i] = cell_in->payload[i];
}
// memcpy(cell_out->reply, cell_in->payload, TAP_ONIONSKIN_REPLY_LEN);
// printf("\ncreated cell t case 1 done");
break;
case CELL_CREATED_FAST:
// printf("\ncreated cell t case 2");
cell_out->cell_type = CELL_CREATED_FAST;
cell_out->handshake_len = CREATED_FAST_LEN;
for(i=0; i<CREATED_FAST_LEN; i++){
cell_out->reply[i] = cell_in->payload[i];
}
// memcpy(cell_out->reply, cell_in->payload, CREATED_FAST_LEN);
// printf("\ncreated cell t case 2 done");
break;
case CELL_CREATED2:
{
// printf("\ncreated cell t case 3");
const uint8_t *p = cell_in->payload;
cell_out->cell_type = CELL_CREATED2;
cell_out->handshake_len = ntohs(get_uint16(p));
if (cell_out->handshake_len > CELL_PAYLOAD_SIZE - 2)
return -1;
for(i=0; i<cell_out->handshake_len; i++){
cell_out->reply[i] = p[i+2];
}
// memcpy(cell_out->reply, p+2, cell_out->handshake_len);
// printf("\ncreated cell t case 3 done");
break;
}
}
return check_created_cell(cell_out);
}
void _mfree(void *ptr, const char *file, int line, const char *func )
{
struct unit_head *head;
if (ptr == NULL)
return;
head = (struct unit_head *)((char *)ptr - sizeof(struct unit_head) + sizeof(long));
if(head->size == 0) {
/* area that is directly secured by malloc () */
struct unit_head_large *head_large = (struct unit_head_large *)((char *)ptr - sizeof(struct unit_head_large) + sizeof(long));
if(
*(long*)((char*)head_large + sizeof(struct unit_head_large) - sizeof(long) + head_large->size)
!= 0xdeadbeaf)
{
ShowError("Memory manager: args of aFree 0x%p is overflowed pointer %s line %d\n", ptr, file, line);
} else {
head->size = 0xFFFF;
if(head_large->prev) {
head_large->prev->next = head_large->next;
} else {
unit_head_large_first = head_large->next;
}
if(head_large->next) {
head_large->next->prev = head_large->prev;
}
memmgr_usage_bytes -= head_large->size;
#ifdef DEBUG_MEMMGR
// set freed memory to 0xfd
memset(ptr, 0xfd, head_large->size);
#endif
FREE(head_large,file,line,func);
}
} else {
/* Release unit */
struct block *block = head->block;
if( (char*)head - (char*)block > sizeof(struct block) ) {
ShowError("Memory manager: args of aFree 0x%p is invalid pointer %s line %d\n", ptr, file, line);
} else if(head->block == NULL) {
ShowError("Memory manager: args of aFree 0x%p is freed pointer %s:%d@%s\n", ptr, file, line, func);
} else if(*(long*)((char*)head + sizeof(struct unit_head) - sizeof(long) + head->size) != 0xdeadbeaf) {
ShowError("Memory manager: args of aFree 0x%p is overflowed pointer %s line %d\n", ptr, file, line);
} else {
memmgr_usage_bytes -= head->size;
head->block = NULL;
#ifdef DEBUG_MEMMGR
memset(ptr, 0xfd, block->unit_size - sizeof(struct unit_head) + sizeof(long) );
head->file = file;
head->line = line;
#endif
memmgr_assert( block->unit_used > 0 );
if(--block->unit_used == 0) {
/* Release of the block */
block_free(block);
} else {
if( block->unfill_prev == NULL) {
// add to unfill list
if( hash_unfill[ block->unit_hash ] ) {
hash_unfill[ block->unit_hash ]->unfill_prev = block;
}
block->unfill_prev = &block_head;
block->unfill_next = hash_unfill[ block->unit_hash ];
hash_unfill[ block->unit_hash ] = block;
}
head->size = block->unit_unfill;
block->unit_unfill = (unsigned short)(((uintptr_t)head - (uintptr_t)block->data) / block->unit_size);
}
}
}
}
void* _mmalloc(size_t size, const char *file, int line, const char *func )
{
struct block *block;
short size_hash = size2hash( size );
struct unit_head *head;
if (((long) size) < 0) {
ShowError("_mmalloc: %d\n", size);
return NULL;
}
if(size == 0) {
return NULL;
}
memmgr_usage_bytes += size;
/* To ensure the area that exceeds the length of the block, using malloc () to */
/* At that time, the distinction by assigning NULL to unit_head.block */
if(hash2size(size_hash) > BLOCK_DATA_SIZE - sizeof(struct unit_head)) {
struct unit_head_large* p = (struct unit_head_large*)MALLOC(sizeof(struct unit_head_large)+size,file,line,func);
if(p != NULL) {
p->size = size;
p->unit_head.block = NULL;
p->unit_head.size = 0;
p->unit_head.file = file;
p->unit_head.line = line;
p->prev = NULL;
if (unit_head_large_first == NULL)
p->next = NULL;
else {
unit_head_large_first->prev = p;
p->next = unit_head_large_first;
}
unit_head_large_first = p;
*(long*)((char*)p + sizeof(struct unit_head_large) - sizeof(long) + size) = 0xdeadbeaf;
return (char *)p + sizeof(struct unit_head_large) - sizeof(long);
} else {
ShowFatalError("Memory manager::memmgr_alloc failed (allocating %d+%d bytes at %s:%d).\n", sizeof(struct unit_head_large), size, file, line);
exit(EXIT_FAILURE);
}
}
/* When a block of the same size is not ensured, to ensure a new */
if(hash_unfill[size_hash]) {
block = hash_unfill[size_hash];
} else {
block = block_malloc(size_hash);
}
if( block->unit_unfill == 0xFFFF ) {
// there are no more free space that
memmgr_assert(block->unit_used < block->unit_count);
memmgr_assert(block->unit_used == block->unit_maxused);
head = block2unit(block, block->unit_maxused);
block->unit_used++;
block->unit_maxused++;
} else {
head = block2unit(block, block->unit_unfill);
block->unit_unfill = head->size;
block->unit_used++;
}
if( block->unit_unfill == 0xFFFF && block->unit_maxused >= block->unit_count) {
// Since I ran out of the unit, removed from the list unfill
if( block->unfill_prev == &block_head) {
hash_unfill[ size_hash ] = block->unfill_next;
} else {
block->unfill_prev->unfill_next = block->unfill_next;
}
if( block->unfill_next ) {
block->unfill_next->unfill_prev = block->unfill_prev;
}
block->unfill_prev = NULL;
}
#ifdef DEBUG_MEMMGR
{
size_t i, sz = hash2size( size_hash );
for( i=0; i<sz; i++ )
{
if( ((unsigned char*)head)[ sizeof(struct unit_head) - sizeof(long) + i] != 0xfd )
{
if( head->line != 0xfdfd )
{
ShowError("Memory manager: freed-data is changed. (freed in %s line %d)\n", head->file,head->line);
}
else
{
ShowError("Memory manager: not-allocated-data is changed.\n");
}
break;
}
}
memset( (char *)head + sizeof(struct unit_head) - sizeof(long), 0xcd, sz );
}
#endif
head->block = block;
head->file = file;
head->line = line;
head->size = (unsigned short)size;
*(long*)((char*)head + sizeof(struct unit_head) - sizeof(long) + size) = 0xdeadbeaf;
return (char *)head + sizeof(struct unit_head) - sizeof(long);
}
void* _mmalloc(size_t size, const char *file, int line, const char *func )
{
struct block *block;
short size_hash = size2hash( size );
struct unit_head *head;
if (((long) size) < 0) {
ShowError("_mmalloc: %d\n", size);
return NULL;
}
if(size == 0) {
return NULL;
}
memmgr_usage_bytes += size;
/* ブロック長を超える領域の確保には、malloc() を用いる */
/* その際、unit_head.block に NULL を代入して区別する */
if(hash2size(size_hash) > BLOCK_DATA_SIZE - sizeof(struct unit_head)) {
struct unit_head_large* p = (struct unit_head_large*)MALLOC(sizeof(struct unit_head_large)+size,file,line,func);
if(p != NULL) {
p->size = size;
p->unit_head.block = NULL;
p->unit_head.size = 0;
p->unit_head.file = file;
p->unit_head.line = line;
p->prev = NULL;
if (unit_head_large_first == NULL)
p->next = NULL;
else {
unit_head_large_first->prev = p;
p->next = unit_head_large_first;
}
unit_head_large_first = p;
*(long*)((char*)p + sizeof(struct unit_head_large) - sizeof(long) + size) = 0xdeadbeaf;
return (char *)p + sizeof(struct unit_head_large) - sizeof(long);
} else {
ShowFatalError("Memory manager::memmgr_alloc failed (allocating %d+%d bytes at %s:%d).\n", sizeof(struct unit_head_large), size, file, line);
exit(EXIT_FAILURE);
}
}
/* 同一サイズのブロックが確保されていない時、新たに確保する */
if(hash_unfill[size_hash]) {
block = hash_unfill[size_hash];
} else {
block = block_malloc(size_hash);
}
if( block->unit_unfill == 0xFFFF ) {
// free済み領域が残っていない
memmgr_assert(block->unit_used < block->unit_count);
memmgr_assert(block->unit_used == block->unit_maxused);
head = block2unit(block, block->unit_maxused);
block->unit_used++;
block->unit_maxused++;
} else {
head = block2unit(block, block->unit_unfill);
block->unit_unfill = head->size;
block->unit_used++;
}
if( block->unit_unfill == 0xFFFF && block->unit_maxused >= block->unit_count) {
// ユニットを使い果たしたので、unfillリストから削除
if( block->unfill_prev == &block_head) {
hash_unfill[ size_hash ] = block->unfill_next;
} else {
block->unfill_prev->unfill_next = block->unfill_next;
}
if( block->unfill_next ) {
block->unfill_next->unfill_prev = block->unfill_prev;
}
block->unfill_prev = NULL;
}
#ifdef DEBUG_MEMMGR
{
size_t i, sz = hash2size( size_hash );
for( i=0; i<sz; i++ )
{
if( ((unsigned char*)head)[ sizeof(struct unit_head) - sizeof(long) + i] != 0xfd )
{
if( head->line != 0xfdfd )
{
ShowError("Memory manager: freed-data is changed. (freed in %s line %d)\n", head->file,head->line);
}
else
{
ShowError("Memory manager: not-allocated-data is changed.\n");
}
break;
}
}
memset( (char *)head + sizeof(struct unit_head) - sizeof(long), 0xcd, sz );
}
#endif
head->block = block;
head->file = file;
head->line = line;
head->size = (unsigned short)size;
*(long*)((char*)head + sizeof(struct unit_head) - sizeof(long) + size) = 0xdeadbeaf;
return (char *)head + sizeof(struct unit_head) - sizeof(long);
};
/** Test utility function: checks that the <b>plaintext_len</b>-byte string at
* <b>plaintext</b> is at least superficially parseable.
*/
static void
do_parse_test(uint8_t *plaintext, size_t plaintext_len, int phase)
{
crypto_pk_t *k = NULL;
ssize_t r;
uint8_t *cell = NULL;
size_t cell_len;
rend_intro_cell_t *parsed_req = NULL;
char *err_msg = NULL;
char digest[DIGEST_LEN];
/* Get a key */
k = crypto_pk_new();
tt_assert(k);
r = crypto_pk_read_private_key_from_string(k, AUTHORITY_SIGNKEY_1, -1);
tt_assert(!r);
/* Get digest for future comparison */
r = crypto_pk_get_digest(k, digest);
tt_assert(r >= 0);
/* Make a cell out of it */
memmgr_init_check_shared_mem(SHARED_SIZE, UIO_DEVICE, BASE_ADDRESS);
char* plaintext_buf = memmgr_alloc(plaintext_len);
memcpy(plaintext_buf, plaintext, plaintext_len);
r = make_intro_from_plaintext(
plaintext_buf, plaintext_len,
k, (void **)(&cell));
tt_assert(r > 0);
tt_assert(cell);
cell_len = r;
memmgr_free(plaintext_buf);
/* Do early parsing */
parsed_req = rend_service_begin_parse_intro(cell, cell_len, 2, &err_msg);
tt_assert(parsed_req);
tt_assert(!err_msg);
tt_mem_op(parsed_req->pk,OP_EQ, digest, DIGEST_LEN);
tt_assert(parsed_req->ciphertext);
tt_assert(parsed_req->ciphertext_len > 0);
if (phase == EARLY_PARSE_ONLY)
goto done;
printf("\nHere");
/* Do decryption */
r = rend_service_decrypt_intro(parsed_req, k, &err_msg);
tt_assert(!r);
tt_assert(!err_msg);
tt_assert(parsed_req->plaintext);
tt_assert(parsed_req->plaintext_len > 0);
if (phase == DECRYPT_ONLY)
goto done;
/* Do late parsing */
r = rend_service_parse_intro_plaintext(parsed_req, &err_msg);
tt_assert(!r);
tt_assert(!err_msg);
tt_assert(parsed_req->parsed);
done:
// tor_free(cell);
memmgr_assert(cell);
memmgr_free(cell);
crypto_pk_free(k);
rend_service_free_intro(parsed_req);
tor_free(err_msg);
}
void AdrenoMM_Free(void *ptr, const char *file, int line, const char *func )
{
struct unit_head *head;
if (ptr == NULL)
return;
head = (struct unit_head *)((char *)ptr - sizeof(struct unit_head) + sizeof(long));
if(head->size == 0) {
/* malloc() �Œ��Ɋm�ۂ��ꂽ�̈� */
struct unit_head_large *head_large = (struct unit_head_large *)((char *)ptr - sizeof(struct unit_head_large) + sizeof(long));
if(
*(long*)((char*)head_large + sizeof(struct unit_head_large) - sizeof(long) + head_large->size)
!= 0xdeadbeaf)
{
printf("Memory manager: args of aFree 0x%p is overflowed pointer %s line %d\n", ptr, file, line);
} else {
head->size = 0xFFFF;
if(head_large->prev) {
head_large->prev->next = head_large->next;
} else {
unit_head_large_first = head_large->next;
}
if(head_large->next) {
head_large->next->prev = head_large->prev;
}
memmgr_usage_bytes -= head_large->size;
#ifdef DEBUG_MEMMGR
// set freed memory to 0xfd
memset(ptr, 0xfd, head_large->size);
#endif
FREE(head_large,file,line,func);
}
} else {
/* ���j�b�g��� */
struct block *block = head->block;
if( (char*)head - (char*)block > (long)sizeof(struct block) ) {
printf("Memory manager: args of aFree 0x%p is invalid pointer %s line %d\n", ptr, file, line);
} else if(head->block == NULL) {
printf("Memory manager: args of aFree 0x%p is freed pointer %s:%d@%s\n", ptr, file, line, func);
} else if(*(long*)((char*)head + sizeof(struct unit_head) - sizeof(long) + head->size) != 0xdeadbeaf) {
printf("Memory manager: args of aFree 0x%p is overflowed pointer %s line %d\n", ptr, file, line);
} else {
memmgr_usage_bytes -= head->size;
head->block = NULL;
#ifdef DEBUG_MEMMGR
memset(ptr, 0xfd, block->unit_size - sizeof(struct unit_head) + sizeof(long) );
head->file = file;
head->line = line;
#endif
memmgr_assert( block->unit_used > 0 );
if(--block->unit_used == 0) {
/* �u���b�N�̉�� */
block_free(block);
} else {
if( block->unfill_prev == NULL) {
// unfill ���X�g�ɒlj�
if( hash_unfill[ block->unit_hash ] ) {
hash_unfill[ block->unit_hash ]->unfill_prev = block;
}
block->unfill_prev = &block_head;
block->unfill_next = hash_unfill[ block->unit_hash ];
hash_unfill[ block->unit_hash ] = block;
}
head->size = block->unit_unfill;
block->unit_unfill = (unsigned short)(((uintptr_t)head - (uintptr_t)block->data) / block->unit_size);
}
}
}
}
void* AdrenoMM_Alloc(unsigned int size, const char *file, int line, const char *func )
{
struct block *block;
short size_hash = size2hash( size );
struct unit_head *head;
if(size == 0) {
return NULL;
}
memmgr_usage_bytes += size;
if (memmgr_usage_bytes > memmgr_max_used_bytes)
memmgr_max_used_bytes = memmgr_usage_bytes;
/* �u���b�N������̈�̊m�ۂɂ́Amalloc() ��p���� */
/* ���̍ہAunit_head.block �� NULL �������ċ�ʂ��� */
if(hash2size(size_hash) > BLOCK_DATA_SIZE - sizeof(struct unit_head)) {
struct unit_head_large* p = (struct unit_head_large*)MALLOC(sizeof(struct unit_head_large)+size,file,line,func);
if(p != NULL) {
p->size = size;
p->unit_head.block = NULL;
p->unit_head.size = 0;
p->unit_head.file = file;
p->unit_head.line = line;
p->prev = NULL;
if (unit_head_large_first == NULL)
p->next = NULL;
else {
unit_head_large_first->prev = p;
p->next = unit_head_large_first;
}
unit_head_large_first = p;
*(long*)((char*)p + sizeof(struct unit_head_large) - sizeof(long) + size) = 0xdeadbeaf;
return (char *)p + sizeof(struct unit_head_large) - sizeof(long);
} else {
printf("Memory manager::memmgr_alloc failed (allocating %ld+%d bytes at %s:%d).\n", sizeof(struct unit_head_large), size, file, line);
exit(EXIT_FAILURE);
}
}
/* ����T�C�Y�̃u���b�N���m�ۂ���Ă��Ȃ����A�V���Ɋm�ۂ��� */
if(hash_unfill[size_hash]) {
block = hash_unfill[size_hash];
} else {
block = block_malloc(size_hash);
}
if( block->unit_unfill == 0xFFFF ) {
// free�ςݗ̈悪�c���Ă��Ȃ�
memmgr_assert(block->unit_used < block->unit_count);
memmgr_assert(block->unit_used == block->unit_maxused);
head = block2unit(block, block->unit_maxused);
block->unit_used++;
block->unit_maxused++;
} else {
head = block2unit(block, block->unit_unfill);
block->unit_unfill = head->size;
block->unit_used++;
}
if( block->unit_unfill == 0xFFFF && block->unit_maxused >= block->unit_count) {
// ���j�b�g���g���ʂ������̂ŁAunfill���X�g����폜
if( block->unfill_prev == &block_head) {
hash_unfill[ size_hash ] = block->unfill_next;
} else {
block->unfill_prev->unfill_next = block->unfill_next;
}
if( block->unfill_next ) {
block->unfill_next->unfill_prev = block->unfill_prev;
}
block->unfill_prev = NULL;
}
#ifdef DEBUG_MEMMGR
{
unsigned int i, sz = hash2size( size_hash );
for( i=0; i<sz; i++ )
{
if( ((unsigned char*)head)[ sizeof(struct unit_head) - sizeof(long) + i] != 0xfd )
{
if( head->line != 0xfdfd )
{
printf("Memory manager: freed-data is changed. (freed in %s line %d)\n", head->file,head->line);
}
else
{
printf("Memory manager: not-allocated-data is changed.\n");
}
break;
}
}
memset( (char *)head + sizeof(struct unit_head) - sizeof(long), 0xcd, sz );
}
#endif
head->block = block;
head->file = file;
head->line = line;
head->size = (unsigned short)size;
*(long*)((char*)head + sizeof(struct unit_head) - sizeof(long) + size) = 0xdeadbeaf;
return (char *)head + sizeof(struct unit_head) - sizeof(long);
};
int triple_encrypt_fpga_ecb(unsigned char *plaintext, int plaintext_len,
unsigned char *key, unsigned char *key1, unsigned char *key2,
unsigned char *ciphertext){
clock_t begin, end;
memmgr_assert(plaintext);
memmgr_assert(ciphertext);
unsigned src = lookupBufferPhysicalAddress(plaintext);
unsigned dest = lookupBufferPhysicalAddress(ciphertext);
XTriple_aes_Key_in_v key_in;
key_in.word_0 = packU32(key[0], key[1], key[2], key[3]);
key_in.word_1 = packU32(key[4], key[5], key[6], key[7]);
key_in.word_2 = packU32(key[8], key[9], key[10], key[11]);
key_in.word_3 = packU32(key[12], key[13], key[14], key[15]);
XTriple_aes_Key_in1_v key_in1;
key_in1.word_0 = packU32(key1[0], key1[1], key1[2], key1[3]);
key_in1.word_1 = packU32(key1[4], key1[5], key1[6], key1[7]);
key_in1.word_2 = packU32(key1[8], key1[9], key1[10], key1[11]);
key_in1.word_3 = packU32(key1[12], key1[13], key1[14], key1[15]);
XTriple_aes_Key_in2_v key_in2;
key_in2.word_0 = packU32(key2[0], key2[1], key2[2], key2[3]);
key_in2.word_1 = packU32(key2[4], key2[5], key2[6], key2[7]);
key_in2.word_2 = packU32(key2[8], key2[9], key2[10], key2[11]);
key_in2.word_3 = packU32(key2[12], key2[13], key2[14], key2[15]);
XTriple_aes_Iv_v iv_in;
iv_in.word_0 = 0;
iv_in.word_1 = 0;
iv_in.word_2 = 0;
iv_in.word_3 = 0;
XTriple_aes_Iv1_v iv_in1;
iv_in1.word_0 = 0;
iv_in1.word_1 = 0;
iv_in1.word_2 = 0;
iv_in1.word_3 = 0;
XTriple_aes_Iv2_v iv_in2;
iv_in2.word_0 = 0;
iv_in2.word_1 = 0;
iv_in2.word_2 = 0;
iv_in2.word_3 = 0;
XTriple_aes triple_aes;
XTriple_aes_Initialize(&triple_aes, "triple-aes");
XTriple_aes_Start(&triple_aes);
XTriple_aes_Set_sourceAddress(&triple_aes, src);
XTriple_aes_Set_key_in_V(&triple_aes, key_in);
XTriple_aes_Set_key_in1_V(&triple_aes, key_in1);
XTriple_aes_Set_key_in2_V(&triple_aes, key_in2);
XTriple_aes_Set_iv_V(&triple_aes, iv_in);
XTriple_aes_Set_iv1_V(&triple_aes, iv_in1);
XTriple_aes_Set_iv2_V(&triple_aes, iv_in2);
XTriple_aes_Set_destinationAddress(&triple_aes, dest);
XTriple_aes_Set_numBytes(&triple_aes, plaintext_len);
XTriple_aes_Set_mode(&triple_aes, 0);
XTriple_aes_Set_sourceAddress_vld(&triple_aes);
XTriple_aes_Set_key_in_V_vld(&triple_aes);
XTriple_aes_Set_key_in1_V_vld(&triple_aes);
XTriple_aes_Set_key_in2_V_vld(&triple_aes);
XTriple_aes_Set_iv_V_vld(&triple_aes);
XTriple_aes_Set_iv1_V_vld(&triple_aes);
XTriple_aes_Set_iv2_V_vld(&triple_aes);
XTriple_aes_Set_destinationAddress_vld(&triple_aes);
XTriple_aes_Set_numBytes_vld(&triple_aes);
XTriple_aes_Set_mode_vld(&triple_aes);
begin = clock();
printf("\nWaiting for FPGA");
while(XTriple_aes_IsDone(&triple_aes) != 1){}
end = clock();
double ticks = (double)(end-begin);
double seconds = ticks/CLOCKS_PER_SEC;
printf("It took %f clicks (%f seconds) in FPGA.\n", ticks, seconds);
XTriple_aes_Release(&triple_aes);
}