C++ (Cpp) _mcrypt_block_encrypt示例

示例#1

文件： ofb.c 项目： dbalagansky/libmcrypt-gyp

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;
}

示例#2

文件： ecb.c 项目： erelh/gpac

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;
}

示例#3

文件： nofb.c 项目： erelh/gpac

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;
}

示例#4

文件： ncfb.c 项目： Bromvlieg/libmcrypt

__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;
}

示例#5

文件： ctr.c 项目： Bromvlieg/libmcrypt

__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;
}

示例#6

文件： ctr.c 项目： erelh/gpac

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;
}