C++ (Cpp) ECRYPT_process_bytes Examples

Example #1

File: trivium-wrapper.c Project: angzy/cube-attack-like

static int rounds(const u8 *iv, const u8 *key, u16 num_rounds) {
	ECRYPT_ctx ctx = {0};
	u16 rounds_32bits = num_rounds / 32;
	u8 state[4] = {0};
	u16 i, j;

	ECRYPT_keysetup(&ctx, key, 80, 80);
	ECRYPT_ivsetup(&ctx, iv, rounds_32bits);
	ECRYPT_process_bytes(&ctx, state, state, 4);

	i = 3 - ((num_rounds - 32 * rounds_32bits) / 8);
	j = 7 - ((num_rounds - 32 * rounds_32bits) % 8);

	if (state[i] & (1 << j))
		return 1;
	else
		return 0;
}

Example #2

File: ecrypt-sync.c Project: alweber/cacheaudit

void ECRYPT_process_packet(
  int action,
  ECRYPT_ctx* ctx,
  const u8* iv,
  const u8* input,
  u8* output,
  u32 msglen)
{
  ECRYPT_ivsetup(ctx, iv);

#ifdef ECRYPT_HAS_SINGLE_BYTE_FUNCTION
  ECRYPT_process_bytes(action, ctx, input, output, msglen);
#else
  if (action == 0)
    ECRYPT_encrypt_bytes(ctx, input, output, msglen);
  else
    ECRYPT_decrypt_bytes(ctx, input, output, msglen);
#endif
}

Example #3

File: trivium-api.c Project: angzy/cube-attack-like

int rounds(const u8* iv, const u8* key, const int rounds)
{
	ECRYPT_ctx ctx = {0};
	int rounds_32bits = rounds / 32;
	u8 state[4] = {0};
	int i;
	int j;

	ECRYPT_keysetup(&ctx, key, 80, 80);
	ECRYPT_ivsetup(&ctx, iv, rounds_32bits);
	ECRYPT_process_bytes(&ctx, state, state, 4);

	i = 3 - (rounds - 32 * rounds_32bits) / 8;
	j = 7 - ((rounds - 32 * rounds_32bits) % 8);

//	return reverse(state[i]);

	if (state[i] & (1 << j))
		return 1;
	else
		return 0;
}

Example #4

File: test.c Project: deian/CUDA-CubeAttack

int main()
{
  ECRYPT_ctx ctx;
  int i,t;
  u8 key[10];
  u8 iv[10];
  u8 in[NR_PROC_BYTES],out[NR_PROC_BYTES];
  u32 dkey[3],div[3];

  xs_rng rng;

  xs_seed(&rng,time(0));
//  xs_seed(&rng,1337);

  memset(in,0x00,sizeof(in)); memset(out,0x00,sizeof(out));

  memset(dkey,0,3*sizeof(u32));
  memset(div,0,3*sizeof(u32));

  printf("%d\n",NR_TESTS);

  for(t=0;t<NR_TESTS;t++) {

     /*
        memset(key,0xff,sizeof(key));
        memset(iv,0xff,sizeof(iv));
      */
     for(i=0;i<sizeof(key);i++) {
        int tmp=xs_rand(&rng);
        key[i]=tmp&0xff;
        iv[i]=(tmp>>8)&0xff;
     }
     //  memcpy(dkey,key,sizeof(key));
     //  memcpy(div,iv,sizeof(iv));

     //  printf("key:\n"); print_bin_array_u8(key,10); printf("\n");
     //  printf("iv:\n"); print_bin_array_u8(iv,10); printf("\n");

     ECRYPT_init();
     ECRYPT_keysetup(&ctx,key,80,80);
     ECRYPT_ivsetup(&ctx,iv);


     //  printf("state:\n"); print_bin_array_u8(ctx.s,40); printf("\n");
     ECRYPT_process_bytes(0,&ctx,in,out,sizeof(in));
     print_x32_array(key,3);
     print_x32_array(iv,3);
     print_x32_rev_bits(out);
     printf("\n");
     //  printf("state:\n"); print_bin_array_u8(ctx.s,40); printf("\n");

     //  printf("output:\n"); print_bin_array_u8(out,NR_PROC_BYTES); printf("\n");

     //  printf("\n-----------------------\n");
     //  printf("dkey:\n"); print_bin_array_u32(dkey,3); printf("\n");
     //  printf("div:\n"); print_bin_array_u32(div,3); printf("\n");

#if 0
     {
        int term[12]={3,13,18,26,38,40,47,49,55,57,66,79};
        int nr_terms=12;
        u32 const_term=0;
        int tm;
        int k;
        for(tm=-1;tm<80;tm++) {
           int sum=0,output=0;
           memset(dkey,0,3*sizeof(u32));
           if(tm!=-1) {
              black_box_key_set_bitpos(dkey,tm);
           }
           //        printf("dkey:\n"); print_bin_array_u32(dkey,3); printf("\n");
           for(k=0;k<(1<<nr_terms);k++)
           {
              memset(div,0,3*sizeof(u32));
              black_box_id2iv(div,term,12,k);
              //        printf("div[%3d]:\n",k); print_bin_array_u32(div,3); printf("\n");
              output=d_trivium(dkey,div,32);
              sum^=output;
           }
           if(tm==-1) {
              const_term=sum;
           } else {
              printf("x_%02d=%08x\n",tm,(sum^const_term)&1);
           }
        }
     }
#endif
  }


  return 0;

}