/* ブロックを確保する */ 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); }