int _mdecrypt( OFB_BUFFER* buf, void *plaintext, int len, int blocksize, void* akey, void (*func)(void*,void*), void (*func2)(void*,void*)) { /* plaintext is 1 byte (8bit ofb) */ char *plain = plaintext; int i, j; void (*_mcrypt_block_encrypt) (void *, void *); _mcrypt_block_encrypt = func; for (j = 0; j < len; j++) { memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); /* Shift the register */ for (i = 0; i < (blocksize - 1); i++) buf->s_register[i] = buf->s_register[i + 1]; buf->s_register[blocksize - 1] = buf->enc_s_register[0]; plain[j] ^= buf->enc_s_register[0]; } return 0; }
static GF_Err _mcrypt( void* ign, void *plaintext, int len, int blocksize, void* akey, void (*func)(void*,void*), void (*func2)(void*,void*)) { int j; char *plain = plaintext; void (*_mcrypt_block_encrypt) (void *, void *); _mcrypt_block_encrypt = func; for (j = 0; j < len / blocksize; j++) { _mcrypt_block_encrypt(akey, &plain[j * blocksize]); } if (j==0 && len!=0) return GF_BAD_PARAM; /* no blocks were encrypted */ return GF_OK; }
GFINLINE static void xor_stuff( nOFB_BUFFER *buf, void* akey, void (*func)(void*,void*), u8* plain, int blocksize, int xor_size) { void (*_mcrypt_block_encrypt) (void *, void *); _mcrypt_block_encrypt = func; if (xor_size == blocksize) { if (buf->s_register_pos == 0) { memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy(buf->s_register, buf->enc_s_register, blocksize); memxor( plain, buf->enc_s_register, blocksize); } else { int size = blocksize - buf->s_register_pos; memxor( plain, &buf->enc_s_register[buf->s_register_pos], size); memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy( buf->s_register, buf->enc_s_register, blocksize); memxor( &plain[size], buf->enc_s_register, buf->s_register_pos); /* buf->s_register_pos remains the same */ } } else { /* xor_size != blocksize */ if (buf->s_register_pos == 0) { memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy(buf->s_register, buf->enc_s_register, blocksize); memxor( plain, buf->enc_s_register, xor_size); buf->s_register_pos = xor_size; } else { int size = blocksize - buf->s_register_pos; int min_size = size < xor_size ? size: xor_size; memxor( plain, &buf->enc_s_register[buf->s_register_pos], min_size); buf->s_register_pos += min_size; if (min_size >= xor_size) return; memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy(buf->s_register, buf->enc_s_register, blocksize); memxor( &plain[min_size], buf->s_register, xor_size - min_size); buf->s_register_pos = xor_size - min_size; } } return; }
__inline static #else inline static #endif void xor_stuff_de( nCFB_BUFFER *buf, void* akey, void (*func)(void*,void*), byte* cipher, int blocksize, int xor_size) { void (*_mcrypt_block_encrypt) (void *, void *); _mcrypt_block_encrypt = func; if (xor_size == blocksize) { if (buf->s_register_pos == 0) { memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy(buf->s_register, cipher, blocksize); memxor( cipher, buf->enc_s_register, blocksize); } else { int size = blocksize - buf->s_register_pos; memxor( cipher, &buf->enc_s_register[buf->s_register_pos], size); memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy( &buf->s_register[size], cipher, buf->s_register_pos); memxor( &cipher[size], buf->enc_s_register, buf->s_register_pos); /* buf->s_register_pos remains the same */ } } else { /* xor_size != blocksize */ if (buf->s_register_pos == 0) { memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy(buf->s_register, cipher, xor_size); memxor( cipher, buf->enc_s_register, xor_size); buf->s_register_pos = xor_size; } else { int size = blocksize - buf->s_register_pos; int min_size = size < xor_size ? size: xor_size; memxor( cipher, &buf->enc_s_register[buf->s_register_pos], min_size); memcpy( &buf->s_register[buf->s_register_pos], cipher, min_size); buf->s_register_pos += min_size; if (min_size >= xor_size) return; memcpy(buf->enc_s_register, buf->s_register, blocksize); _mcrypt_block_encrypt(akey, buf->enc_s_register); memcpy(buf->s_register, cipher, xor_size - min_size); memxor( &cipher[min_size], buf->s_register, xor_size - min_size); buf->s_register_pos = xor_size - min_size; } } return; }
__inline static #else inline static #endif void xor_stuff( CTR_BUFFER *buf, void* akey, void (*func)(void*,void*), byte* plain, int blocksize, int xor_size) { void (*_mcrypt_block_encrypt) (void *, void *); _mcrypt_block_encrypt = func; if (xor_size == blocksize) { if (buf->c_counter_pos == 0) { memcpy( buf->enc_counter, buf->c_counter, blocksize); _mcrypt_block_encrypt(akey, buf->enc_counter); memxor( plain, buf->enc_counter, blocksize); increase_counter( buf->c_counter, blocksize); } else { int size = blocksize - buf->c_counter_pos; memxor( plain, &buf->enc_counter[buf->c_counter_pos], size); increase_counter( buf->c_counter, blocksize); memcpy( buf->enc_counter, buf->c_counter, blocksize); _mcrypt_block_encrypt(akey, buf->enc_counter); memxor( &plain[size], buf->enc_counter, buf->c_counter_pos); /* buf->c_counter_pos remains the same */ } } else { /* xor_size != blocksize */ if (buf->c_counter_pos == 0) { memcpy( buf->enc_counter, buf->c_counter, blocksize); _mcrypt_block_encrypt(akey, buf->enc_counter); memxor( plain, buf->enc_counter, xor_size); buf->c_counter_pos = xor_size; } else { int size = blocksize - buf->c_counter_pos; int min_size = size < xor_size ? size: xor_size; memxor( plain, &buf->enc_counter[buf->c_counter_pos], min_size); buf->c_counter_pos += min_size; if (min_size >= xor_size) return; increase_counter( buf->c_counter, blocksize); memcpy( buf->enc_counter, buf->c_counter, blocksize); _mcrypt_block_encrypt(akey, buf->enc_counter); memxor( &plain[min_size], buf->enc_counter, xor_size - min_size); buf->c_counter_pos = xor_size - min_size; } } return; }
static GFINLINE void xor_stuff( CTR_BUFFER *buf, void* akey, void (*func)(void*,void*), u8* plain, int blocksize, int xor_size) { void (*_mcrypt_block_encrypt) (void *, void *); _mcrypt_block_encrypt = func; if (xor_size == blocksize) { if (((CTR_BUFFER* )buf)->c_counter_pos == 0) { memcpy( ((CTR_BUFFER* )buf)->enc_counter, ((CTR_BUFFER* )buf)->c_counter, blocksize); _mcrypt_block_encrypt(akey, ((CTR_BUFFER* )buf)->enc_counter); memxor( plain, ((CTR_BUFFER* )buf)->enc_counter, blocksize); increase_counter( ((CTR_BUFFER* )buf)->c_counter, blocksize); } else { int size = blocksize - ((CTR_BUFFER* )buf)->c_counter_pos; memxor( plain, &((CTR_BUFFER* )buf)->enc_counter[((CTR_BUFFER* )buf)->c_counter_pos], size); increase_counter( ((CTR_BUFFER* )buf)->c_counter, blocksize); memcpy( ((CTR_BUFFER* )buf)->enc_counter, ((CTR_BUFFER* )buf)->c_counter, blocksize); _mcrypt_block_encrypt(akey, ((CTR_BUFFER* )buf)->enc_counter); memxor( &plain[size], ((CTR_BUFFER* )buf)->enc_counter, ((CTR_BUFFER* )buf)->c_counter_pos); /* ((CTR_BUFFER* )buf)->c_counter_pos remains the same */ } } else { /* xor_size != blocksize */ if (((CTR_BUFFER* )buf)->c_counter_pos == 0) { memcpy( ((CTR_BUFFER* )buf)->enc_counter, ((CTR_BUFFER* )buf)->c_counter, blocksize); _mcrypt_block_encrypt(akey, ((CTR_BUFFER* )buf)->enc_counter); memxor( plain, ((CTR_BUFFER* )buf)->enc_counter, xor_size); ((CTR_BUFFER* )buf)->c_counter_pos = xor_size; } else { int size = blocksize - ((CTR_BUFFER* )buf)->c_counter_pos; int min_size = size < xor_size ? size: xor_size; memxor( plain, &((CTR_BUFFER* )buf)->enc_counter[((CTR_BUFFER* )buf)->c_counter_pos], min_size); ((CTR_BUFFER* )buf)->c_counter_pos += min_size; if (min_size >= xor_size) return; increase_counter( ((CTR_BUFFER* )buf)->c_counter, blocksize); memcpy( ((CTR_BUFFER* )buf)->enc_counter, ((CTR_BUFFER* )buf)->c_counter, blocksize); _mcrypt_block_encrypt(akey, ((CTR_BUFFER* )buf)->enc_counter); memxor( &plain[min_size], ((CTR_BUFFER* )buf)->enc_counter, xor_size - min_size); ((CTR_BUFFER* )buf)->c_counter_pos = xor_size - min_size; } } return; }