rottenwheel/monero
1
0
Fork 0
mirror of https://codeberg.org/anoncontributorxmr/monero.git synced 2024-11-30 06:43:28 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update slow-hash.c

Browse Source 
1. Various optimizations for faster hashing performance.
This commit is contained in:
NoodleDoodleNoodleDoodleNoodleDoodleNoo 2014-05-17 16:25:00 -07:00
parent e4f7b92ff9
commit 49d55d3c30
1 changed files with 18 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/crypto/slow-hash.c
View File

@ -22,6 +22,9 @@ static void (*const extra_hashes[4])(const void *, size_t, char *) = {
#define INIT_SIZE_BLK 8 #define INIT_SIZE_BLK 8
#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE) #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
extern int aesb_single_round(const uint8_t *in, uint8_t*out, const uint8_t *expandedKey);
extern int aesb_pseudo_round(const uint8_t *in, uint8_t *out, const uint8_t *expandedKey);
static size_t e2i(const uint8_t* a, size_t count) { return (*((uint64_t*)a) / AES_BLOCK_SIZE) & (count - 1); } static size_t e2i(const uint8_t* a, size_t count) { return (*((uint64_t*)a) / AES_BLOCK_SIZE) & (count - 1); }
static void mul(const uint8_t* a, const uint8_t* b, uint8_t* res) { static void mul(const uint8_t* a, const uint8_t* b, uint8_t* res) {
@ -47,19 +50,20 @@ static void sum_half_blocks(uint8_t* a, const uint8_t* b) {
((uint64_t*)a)[0] = SWAP64LE(a0); ((uint64_t*)a)[0] = SWAP64LE(a0);
((uint64_t*)a)[1] = SWAP64LE(a1); ((uint64_t*)a)[1] = SWAP64LE(a1);
} }
#define U64(x) ((uint64_t *) (x))
static void copy_block(uint8_t* dst, const uint8_t* src) { static void copy_block(uint8_t* dst, const uint8_t* src) {
memcpy(dst, src, AES_BLOCK_SIZE); memcpy(dst, src, AES_BLOCK_SIZE);
} }
static void swap_blocks(uint8_t* a, uint8_t* b) { static void swap_blocks(uint8_t *a, uint8_t *b){
size_t i; uint64_t t[2];
uint8_t t; U64(t)[0] = U64(a)[0];
for (i = 0; i < AES_BLOCK_SIZE; i++) { U64(t)[1] = U64(a)[1];
t = a[i]; U64(a)[0] = U64(b)[0];
a[i] = b[i]; U64(a)[1] = U64(b)[1];
b[i] = t; U64(b)[0] = U64(t)[0];
} U64(b)[1] = U64(t)[1];
} }
static void xor_blocks(uint8_t* a, const uint8_t* b) { static void xor_blocks(uint8_t* a, const uint8_t* b) {
@ -89,17 +93,17 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
uint8_t d[AES_BLOCK_SIZE]; uint8_t d[AES_BLOCK_SIZE];
size_t i, j; size_t i, j;
uint8_t aes_key[AES_KEY_SIZE]; uint8_t aes_key[AES_KEY_SIZE];
OAES_CTX* aes_ctx; oaes_ctx *aes_ctx;
hash_process(&state.hs, data, length); hash_process(&state.hs, data, length);
memcpy(text, state.init, INIT_SIZE_BYTE); memcpy(text, state.init, INIT_SIZE_BYTE);
memcpy(aes_key, state.hs.b, AES_KEY_SIZE); memcpy(aes_key, state.hs.b, AES_KEY_SIZE);
aes_ctx = oaes_alloc(); aes_ctx = (oaes_ctx *) oaes_alloc();
oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE); oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE);
for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) { for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
for (j = 0; j < INIT_SIZE_BLK; j++) { for (j = 0; j < INIT_SIZE_BLK; j++) {
oaes_pseudo_encrypt_ecb(aes_ctx, &text[AES_BLOCK_SIZE * j]); aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
} }
memcpy(&long_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE); memcpy(&long_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
} }
@ -117,7 +121,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
/* Iteration 1 */ /* Iteration 1 */
j = e2i(a, MEMORY / AES_BLOCK_SIZE); j = e2i(a, MEMORY / AES_BLOCK_SIZE);
copy_block(c, &long_state[j * AES_BLOCK_SIZE]); copy_block(c, &long_state[j * AES_BLOCK_SIZE]);
oaes_encryption_round(a, c); aesb_single_round(c, c, a);
xor_blocks(b, c); xor_blocks(b, c);
swap_blocks(b, c); swap_blocks(b, c);
copy_block(&long_state[j * AES_BLOCK_SIZE], c); copy_block(&long_state[j * AES_BLOCK_SIZE], c);
@ -140,12 +144,12 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) { for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
for (j = 0; j < INIT_SIZE_BLK; j++) { for (j = 0; j < INIT_SIZE_BLK; j++) {
xor_blocks(&text[j * AES_BLOCK_SIZE], &long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]); xor_blocks(&text[j * AES_BLOCK_SIZE], &long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
oaes_pseudo_encrypt_ecb(aes_ctx, &text[j * AES_BLOCK_SIZE]); aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
} }
} }
memcpy(state.init, text, INIT_SIZE_BYTE); memcpy(state.init, text, INIT_SIZE_BYTE);
hash_permutation(&state.hs); hash_permutation(&state.hs);
/*memcpy(hash, &state, 32);*/ /*memcpy(hash, &state, 32);*/
extra_hashes[state.hs.b[0] & 3](&state, 200, hash); extra_hashes[state.hs.b[0] & 3](&state, 200, hash);
oaes_free(&aes_ctx); oaes_free((OAES_CTX **) &aes_ctx);
} }