Ejemplo n.º 1
0
CompareResult CmpCacheFind(CmpCache_p *cache, Term_p t1, DerefType d1,
			   Term_p t2, DerefType d2)
{
   QuadKey key;
   QuadTree_p handle;
   CompareResult res = to_unknown;
   bool nat_order;
   
   if(TermIsVar(t1)||TermIsVar(t2))
   {
      return to_unknown;
   }
   nat_order = prepare_key(t1,d1,t2,d2,&key);
   handle = QuadTreeFind(cache, &key);

   if(nat_order)
   {
      if(handle)
      {
	 res = handle->val.i_val;
      }
   }
   else
   {
      if(handle)
      {
	 res = POInverseRelation(handle->val.i_val);
      }
   }
   return res;
}
Ejemplo n.º 2
0
void main(void){
	char key[26]="ilovexingxing";
	int rst=prepare_key(key);
	printf("rst=%i, key=%s\n",rst,key );
	char message[]="i love xingxing";
	encrypt(message,key);
	printf("encrypted message : %s\n",message );
	decrypt(message,key);
	printf("decrypted message : %s\n",message );	
}
void main(int argc, char* argv[])
{	struct block key;
	FILE *fp1,*fp2;
	fp1=fopen(argv[1],"rb");
	fp2=fopen(argv[3],"wb");
	// Converting the key provided as string into key object.
	key=prepare_key(argv[2]);
	decrypt_file(fp1,key,fp2);
	fclose(fp1);
	fclose(fp2);
}
Ejemplo n.º 4
0
int main(int argc, char *argv[]) {
	char keys[27] = "TRAILBLAZERS";
	char data[] = "abcdefg";
	prepare_key(keys);
	puts(keys);
	
	encrypt(data, keys);
	puts(data);
	
	decrypt(data, keys);
	puts(data);	
	return 0;	
}
Ejemplo n.º 5
0
static void ffi_open_fn(VMState *state, CallInfo *info) {
  VM_ASSERT(info->args_len == 1, "wrong arity: expected 1, got %i", info->args_len);
  Object *root = state->root;
  Object *string_base = state->shared->vcache.string_base;
  Object *array_base = state->shared->vcache.array_base;
  Object *ffi = AS_OBJ(OBJECT_LOOKUP(root, ffi));
  Object *handle_base = AS_OBJ(OBJECT_LOOKUP(ffi, handle));

  StringObject *sarg = (StringObject*) obj_instance_of(OBJ_OR_NULL(load_arg(state->frame, INFO_ARGS_PTR(info)[0])), string_base);
  VM_ASSERT(sarg, "argument to ffi.open must be string!");

  Object *libmap = AS_OBJ(OBJECT_LOOKUP(ffi, library_map));

  char *file = sarg->value;

  bool file_found = false;
  FastKey file_key = prepare_key(file, strlen(file));
  Value mapping = object_lookup_p(libmap, &file_key, &file_found);
  const char **file_list_ptr = NULL;
  int file_list_len = 0;
  if (file_found) {
    ArrayObject *aobj = (ArrayObject*) obj_instance_of(OBJ_OR_NULL(mapping), array_base);
    StringObject *sobj = (StringObject*) obj_instance_of(OBJ_OR_NULL(mapping), string_base);
    if (aobj) {
      file_list_len = aobj->length;
      file_list_ptr = malloc(sizeof(char*) * file_list_len);
      for (int i = 0; i < file_list_len; i++) {
        StringObject *file = (StringObject*) obj_instance_of(OBJ_OR_NULL(aobj->ptr[i]), string_base);
        VM_ASSERT(file, "library_map sub-entries must be string");
        file_list_ptr[i] = my_asprintf("%s", file->value); // outside gc, make copy
      }
    } else if (sobj) {
      file_list_len = 1;
      file_list_ptr = malloc(sizeof(char*) * 1);
      file_list_ptr[0] = my_asprintf("%s", sobj->value);
    } else VM_ASSERT(false, "library_map entries must be string or array");
  } else {
    file_list_len = 1;
    file_list_ptr = malloc(sizeof(char*) * 1);
    file_list_ptr[0] = file;
  }

  void *dlptr = my_dlopen(file_list_len, file_list_ptr);

  Object *handle_obj = AS_OBJ(make_object(state, handle_base, false));
  handle_obj->flags |= OBJ_FROZEN;
  OBJECT_SET(state, handle_obj, pointer, make_ptr(state, dlptr));
  vm_return(state, info, OBJ2VAL(handle_obj));
}
Ejemplo n.º 6
0
CString GetLink(int nIndex)
{
    CString str = "";
    rc4_key key;
    sPassword[16] = (unsigned char)(nIndex * 5);
    prepare_key(sPassword, 17, &key);

    char *sBuf = (char*)malloc(option.link_length);
    memcpy(sBuf, sLinksBuf + nIndex * option.link_length, option.link_length);
    rc4((unsigned char *)sBuf, option.link_length, &key);
    memset(&key, 0, sizeof(rc4_key ));
    str = sBuf;
    free(sBuf);
    return str;
}
Ejemplo n.º 7
0
bool
wpa_encr_key_data(eapol_wpa_key_header_t *body, uint16 key_info, uint8 *ekey,
	uint8 *gtk,	uint8 *data, uint8 *encrkey, rc4_ks_t *rc4key)
{
	uint16 len;

	switch (key_info & (WPA_KEY_DESC_V1 | WPA_KEY_DESC_V2)) {
	case WPA_KEY_DESC_V1:
		if (gtk)
			len = ntoh16_ua((uint8 *)&body->key_len);
		else
			len = ntoh16_ua((uint8 *)&body->data_len);

		/* create the iv/ptk key */
		bcopy(body->iv, encrkey, 16);
		bcopy(ekey, &encrkey[16], 16);
		/* encrypt the key data */
		prepare_key(encrkey, 32, rc4key);
		rc4(data, WPA_KEY_DATA_LEN_256, rc4key); /* dump 256 bytes */
		rc4(body->data, len, rc4key);
		break;
	case WPA_KEY_DESC_V2:
	case WPA_KEY_DESC_V3:
		len = ntoh16_ua((uint8 *)&body->data_len);
		/* pad if needed - min. 16 bytes, 8 byte aligned */
		/* padding is 0xdd followed by 0's */
		if (len < 2*AKW_BLOCK_LEN) {
			body->data[len] = WPA2_KEY_DATA_PAD;
			bzero(&body->data[len+1], 2*AKW_BLOCK_LEN - (len+1));
			len = 2*AKW_BLOCK_LEN;
		} else if (len % AKW_BLOCK_LEN) {
			body->data[len] = WPA2_KEY_DATA_PAD;
			bzero(&body->data[len+1], AKW_BLOCK_LEN - ((len+1) % AKW_BLOCK_LEN));
			len += AKW_BLOCK_LEN - (len % AKW_BLOCK_LEN);
		}
		if (aes_wrap(WPA_MIC_KEY_LEN, ekey, len, body->data, body->data)) {
			return FALSE;
		}
		len += 8;
		hton16_ua_store(len, (uint8 *)&body->data_len);
		break;
	default:
		return FALSE;
	}

	return TRUE;
}
Ejemplo n.º 8
0
/* Decrypt a key data from a WPA key message */
bool
BCMROMFN(wpa_decr_key_data)(eapol_wpa_key_header_t *body, uint16 key_info, uint8 *ekey,
                            uint8 *gtk, uint8 *data, uint8 *encrkey, rc4_ks_t *rc4key)
{
	uint16 len;

	switch (key_info & (WPA_KEY_DESC_V1 | WPA_KEY_DESC_V2)) {
	case WPA_KEY_DESC_V1:
		bcopy(body->iv, encrkey, WPA_MIC_KEY_LEN);
		bcopy(ekey, &encrkey[WPA_MIC_KEY_LEN], WPA_MIC_KEY_LEN);
		/* decrypt the key data */
		prepare_key(encrkey, WPA_MIC_KEY_LEN*2, rc4key);
		rc4(data, WPA_KEY_DATA_LEN_256, rc4key); /* dump 256 bytes */
		if (gtk)
			len = ntoh16_ua((uint8 *)&body->key_len);
		else
			len = ntoh16_ua((uint8 *)&body->data_len);
		rc4(body->data, len, rc4key);
		if (gtk)
			bcopy(body->data, gtk, len);
		break;

	case WPA_KEY_DESC_V2:
	case WPA_KEY_DESC_V3:
		len = ntoh16_ua((uint8 *)&body->data_len);
		if (aes_unwrap(WPA_MIC_KEY_LEN, ekey, len, body->data,
		               gtk ? gtk : body->data)) {
			return FALSE;
		}
		break;

	default:
		return FALSE;
	}
	return TRUE;
}
Ejemplo n.º 9
0
int
main (int argc, char **argv)
{
	Elf32_Phdr	* phdr;
	Elf32_Ehdr	* ehdr;
	rc4_key		  key;
	int		  fd,
			  i = 0,
			  off;
	char		* file = NULL,
			* passw = NULL,
			  pass[256],
			* ptr,
			* buf;
	struct stat	  st;

	if (argc == 2)
		file = argv[1];
	else
		usage(argv[0]);

	do {
		if (i)
			printf("Passphrases don't match.\n");

		if ((passw = getpass("Passphrase: ")) == NULL) 
			fatal("Bad pass");

		memcpy(pass, passw, strlen(passw));

		if ((passw = getpass("Confirm phrase: ")) == NULL)
			fatal("Bad pass");
		i = 1;

	} while (STRCMP(passw, !=, pass));

	memset(pass, 0x00, sizeof(pass));

	if ((fd = open(file, O_RDWR, 0)) == -1)
		fatal("open host file");

	if (fstat(fd, &st) < 0)
		fatal("stat host file");

	if ((ptr = mmap(NULL, st.st_size, (PROT_READ|PROT_WRITE),
					MAP_SHARED, fd, 0)) == (void *)(-1))
		fatal("mmap failed");

	ehdr = (Elf32_Ehdr *)ptr;
	phdr = (Elf32_Phdr *)(ptr + ehdr->e_phoff);

	for (i = 0; i < ehdr->e_phnum; i++, phdr++)
		if (phdr->p_type == PT_LOAD)
			break;

	off = ehdr->e_entry - phdr->p_vaddr;

	buf = (char *)(ptr + off);

	prepare_key(passw, strlen(passw), &key);
	rc4(buf, phdr->p_filesz - off, &key);

	return 0;
}
Ejemplo n.º 10
0
bool CmpCacheInsert(CmpCache_p *cache, Term_p t1, DerefType d1, Term_p
		    t2, DerefType d2, CompareResult insert)
{
   QuadKey key;
   IntOrP val;
   bool nat_order, res;
   QuadTree_p handle;

   assert(insert!=to_unknown);
   /* printf("%p:%d:%p:%d:%d\n", t1,d1,t2,d2,insert); */

   if(TermIsVar(t1)||TermIsVar(t2))
   {
      return false;
   }

   nat_order = prepare_key(t1,d1,t2,d2,&key);
   if(nat_order)
   {
      val.i_val = insert;
   }
   else
   {
      val.i_val = POInverseRelation(insert);
   }
   handle = QuadTreeFind(cache, &key);
   if(handle)
   {
      switch(handle->val.i_val)
      {
      case to_notgteq:
	    /* printf("notgteq=%ld\n", val.i_val); */
	    if(val.i_val==to_notleeq)
	    {
	       handle->val.i_val = to_uncomparable;
	    }
	    else
	    {
	       assert((val.i_val==to_notgteq)||
		      (val.i_val==to_lesser)||
		      (val.i_val==to_uncomparable));
	       handle->val.i_val = val.i_val;
	    }
	    break;
      case to_notleeq:
	    /* printf("notleeq=%ld\n", val.i_val); */
	    if(val.i_val==to_notgteq)
	    {
	       handle->val.i_val = to_uncomparable;
	    }
	    else
	    {
	       assert((val.i_val==to_notleeq)||
		      (val.i_val==to_greater)||
		      (val.i_val==to_uncomparable));
	       handle->val.i_val = val.i_val;
	    }
	    break;
      default:
	    assert((handle->val.i_val==val.i_val)
		   ||((val.i_val==to_notgteq)
		      &&(handle->val.i_val==to_lesser))
		   ||((val.i_val==to_notleeq)
		      &&(handle->val.i_val==to_greater)));
	    break;
      }
      return false;
   }
   else
   {
      res =  QuadTreeStore(cache, &key, val);
      return res;
   }
}
Ejemplo n.º 11
0
int main(int argc, char* argv[])
{
  UCHAR seed[256];
  UCHAR line[MAX_LINE+1];
  UCHAR plain_text[MAX_TEXT+1];
  UCHAR cipher_text[MAX_TEXT+1];
  UCHAR comment[MAX_LINE+1];
  UCHAR xored_text[MAX_TEXT+1];
  int i, num;
  ULONG sweep, done = 0, iter;
  rc4_key key;
  FILE *fp;
  char** args = argv;
  int acount = argc;
  double time_taken;

  USHORT plain_text_len, cipher_text_len, text_len;
  USHORT cmd_line_project_id, file_check_sum = 0;
  USHORT completed_check_sum = 0;
  USHORT comment_len = 0;
  USHORT segments, start_segment;
  UCHAR* tag;
  UCHAR* value;

  int done_plain_text = 0;
  int done_cipher_text = 0;

#if !defined(_MSDOS) && !defined(__OS2__)
  struct timeval tv_start,tv_end;
#endif
  double keys_sec, run_time, start_time;
  int first = 1;
#ifdef __OS2__
  APIRET rc;
#endif

  big_endian = ((char*)&test_endian)[0];
  prog = argv[0];

#ifdef __OS2__
  /* set priority class to IDLETIME */
  rc = DosSetPriority(PRTYS_PROCESS, PRTYC_IDLETIME, 0, 0);
  if (rc != 0)
  {
    fprintf(stderr, "%s: unable to set priority, rc = %ld\n", prog, rc);
    exit(1);
  }
#endif /* __OS2__ */

  if (argc < 2)
  {
    usage();
    exit(1);
  }
  if (args[1][0]=='-')
  {
    switch(args[1][1])
    {
    case 'q':
      verbose = 0; break;
    case '\0':  /* stdin = '-' */
      acount++; args--;  /* doesn't count as a flag */
      break;
    default:
      fprintf(stderr,"invalid flag %s\n",args[1]);
      usage();
      exit(1);
    }
    args++; acount--;
  }

  if (acount < 5)
  {
    usage();
    exit(1);
  }

  if (!strcmp(args[1],"-"))
  {
    fp = stdin;
  }
  else
  {
    fp = fopen(args[1],"rb");
    if (!fp) 
    {
      fprintf(stderr,"error cannot open config file %s\n",args[1]);
      exit(2);
    }
  }

  num = sscanf(args[2],"%hx",&cmd_line_project_id);
  if (num < 1)
  {
    fprintf(stderr,"error: project-id should be a hexadecimal number\n\n");
    usage();
    exit(1);
  }

  if (strlen(args[3]) > 4)
  {
    fprintf(stderr,"error: start-key should be a 4 digit hexadecimal number\n\n");
    usage();
    exit(1);
  }
  i = byte_pack(seed, (UCHAR*) args[3], 2);
  if (i != 2)
  {
    fprintf(stderr,"error: start-key should be a 4 digit hexadecimal number\n\n");
    usage();
    exit(1);
  }
  
  seed[2] = seed[3] = seed[4] = 0;
  start_segment = (USHORT)seed[0]*256 + (USHORT)seed[1];

  num = sscanf(args[4],"%hu",&segments);
  if (num < 1)
  {
    fprintf(stderr,"error: segments should be a decimal number\n\n");
    usage();
    exit(1);
  }
  
  sweep = (ULONG)segments << 8;

  while (!feof(fp))
  {
    line[0] = '\0';
    fgets(line, MAX_LINE, fp);
    strip_crlf(line);
    strip_comments(line);
    file_check_sum = checksum(file_check_sum, line);
    parse_line(line,&tag,&value);
    if (!tag || !*tag)
    {
      continue;
    }
    if (!strcasecmp(tag,"PLAIN-TEXT"))
    {
      if (done_plain_text)
      {
	fprintf(stderr,
	  "config file error: should only have one PLAIN-TEXT field\n");
	exit(2);
      }
      if (strlen(value) & 0x1 != 0)
      {
	fprintf(stderr,
"config file error: PLAIN-TEXT field must be an even number of hex digits\n");
	exit(2);
      }
      plain_text_len = byte_pack(plain_text, value, MAX_TEXT);
      if (plain_text_len == 0)
      {
	fprintf(stderr,
	  "config file error: PLAIN-TEXT field must be hex digits\n");
	exit(2);
      }
      done_plain_text = 1;
    }
    else if (!strcasecmp(tag,"CIPHER-TEXT"))
    {
      if (done_cipher_text)
      {
	fprintf(stderr,
	  "config file error: should only have one CIPHER-TEXT field\n");
	exit(2);
      }
      if (strlen(value) & 0x1 != 0)
      {
	fprintf(stderr,
"config file error: CIPHER-TEXT field must be an even number of hex digits\n");
	exit(2);
      }
      cipher_text_len = byte_pack(cipher_text, value, MAX_TEXT);
      if (cipher_text_len == 0)
      {
	fprintf(stderr,
	  "config file error: CIPHER-TEXT field must be hex digits\n");
	exit(2);
      }
      done_cipher_text = 1;
    }
    else if (!strcasecmp(tag,"COMMENT"))
    { 
      char *rest = strtok(0, "\n"); /* ie to the end of string as there */
      if (comment_len != 0)	    /* won't be a \n due to strip_crlf */
      {
	fprintf(stderr,
	  "config file error: should only have one COMMENT field\n");
	exit(2);
      }
      strncpy(comment, value, MAX_LINE);
      if (rest)
      {
	comment_len = strlen(comment);
	strncat(comment," ", MAX_LINE - comment_len);
	comment_len++;
	strncat(comment, rest, MAX_LINE - comment_len);
	comment[MAX_LINE] = '\0';
      }
      comment_len = strlen(comment);
    }
    else
    {
      fprintf(stderr,"config file error: unknown tag: %s\n",tag);
      exit(2);
    }
  }
  if (!done_plain_text)
  {
    fprintf(stderr,"config file error: no PLAIN-TEXT field\n");
    exit(2);
  }
  if (!done_cipher_text)
  {
    fprintf(stderr,"config file error: no CIPHER-TEXT field\n");
    exit(2);
  }

  if (plain_text_len != cipher_text_len)
  {
    fprintf(stderr,"config file warning: PLAIN-TEXT and CIPHER-TEXT are not the same length\n");
  }
  text_len = plain_text_len < cipher_text_len ? 
                                    plain_text_len : cipher_text_len;

  if (cmd_line_project_id != file_check_sum)
  {
    fprintf(stderr,"error: you have the wrong config file for project %04x (%04x)\n",
	    cmd_line_project_id, file_check_sum);
    exit(1);
  }

  completed_check_sum = (( (ULONG)file_check_sum + (ULONG)start_segment + 
                            (ULONG)segments ) & 0xFFFFL);

  if (verbose)
  {
    fprintf(stderr,"PROJECT-ID\t%04x\n",file_check_sum);
    if (comment_len) fprintf(stderr,"COMMENT \t%s\n",comment);
    fprintf(stderr,"START-KEY\t%s\n",print_hex(seed,KEY_SIZE));
    fprintf(stderr,"SEGMENTS\t%u (16M keys/segment)\n",segments);
    fprintf(stderr,"PLAIN-TEXT\t%s\n",print_hex(plain_text,text_len));
    fprintf(stderr,"CIPHER-TEXT\t%s\n",print_hex(cipher_text,text_len));
    fprintf(stderr,"TEXT-SIZE\t%d\n",text_len);

    fprintf(stderr,"256k keys per '.' printed, 1 segment per line, a segment = 16M keys\n");
    fprintf(stderr,"LINES-TO-DO\t%d\n",segments);
  }

/* pre-compute plain_text XOR cipher_text */ 

  for (i=0; i<text_len; i++)
  {
    xored_text[i] = plain_text[i] ^ cipher_text[i];
  }

  for (done=0; done<sweep; done++)
  {
    if (verbose)
    {
      if (first)
      {
#if defined(_MSDOS) || defined(__OS2__)
	start_time = (double) clock()/CLOCKS_PER_SEC;
#else
	gettimeofday(&tv_start,0);
#endif
      }
    }
    for (iter=0; iter < 65536; iter++)
    {
      prepare_key(seed,KEY_SIZE,&key);
      if (rc4_eq(xored_text, text_len, &key))
      {
	if (verbose)
	{
	  fprintf(stderr,"\nFOUND-IT\t%s\n", print_hex(seed,KEY_SIZE));
	  instructions();
	}
	printf("%04x %04x %04x %u %s\n",file_check_sum,completed_check_sum,
	       start_segment,segments,print_hex(seed,KEY_SIZE));
	exit(0);
      }
      inc_key(seed);
    }
    if (verbose) 
    {
      if (first)
      {
#if defined(_MSDOS) || defined(__OS2__)
	time_taken = ((double) clock()/CLOCKS_PER_SEC) - start_time;
#else
	gettimeofday(&tv_end,0);
	time_taken = (double)(tv_end.tv_sec - tv_start.tv_sec);
	time_taken += ((double)(tv_end.tv_usec - tv_start.tv_usec)/1000000.0);
#endif
	keys_sec = 65536.0 / time_taken;
	fprintf(stderr,"KEYS-PER-SEC\t%0.1lf keys/sec\n",keys_sec);
	fprintf(stderr,"EXPECTED-RUNNING-TIME\t");
	run_time = sweep * time_taken;
	if (run_time < 60)
	{
	  fprintf(stderr,"%0.1lf secs\n",run_time);
	}
	else if (run_time < 3600)
	{
	  fprintf(stderr,"%0.1lf mins\n",run_time / 60);
	}
	else 
	{
	  fprintf(stderr,"%0.1lf hours\n",run_time / 3600);
	  if (run_time > 180000)
	  {
	    fprintf(stderr,"in days: %0.1lf days\n",run_time / 86400);
	  }
	}
	first = 0;
      }
      if ((done & 255L) == 0)
      {
	if (done > 0) fprintf(stderr,"]\n");
	fprintf(stderr,"%sxxxxxx:[",print_hex(seed,2));
      }
      if ((done & 3L) == 0)
      {
	fputc('.',stderr);
      }
#ifdef __OS2__
      fflush(stderr);	/* needed to prevent buffering of stderr */
#endif
    }
  }
  if (verbose)
  {
    fprintf(stderr,"]\n");
    instructions();
  }
  printf("%04x %04x %04x %u no\n",file_check_sum,completed_check_sum,
	 start_segment,segments);
  return 0;
}
Ejemplo n.º 12
0
/* Send a EAPOL-Key packet */
void
eapol_key(nas_t *nas, nas_sta_t *sta,
          unsigned char *send_key, int send_key_len,
          unsigned char *recv_key, int recv_key_len,
          unsigned char *key, int key_len, int index, int unicast)
{
	struct iovec packet;
	eapol_header_t *eapol;
	eapol_key_header_t *body;

	struct timeval tv;
	struct timezone tz;
	unsigned short length;
	unsigned int replay[2];
	unsigned char rc4_seed[48] = { 0 };
	rc4_ks_t rc4_key;

	/* Allocate packet */
	packet.iov_len = EAPOL_HEADER_LEN + EAPOL_KEY_HEADER_LEN;
	if (key)
		packet.iov_len += key_len;
	if (!(packet.iov_base = (caddr_t) malloc(packet.iov_len))) {
		perror("malloc");
		return;
	}

	/* Fill EAPOL header */
	eapol = (eapol_header_t *) packet.iov_base;
	memcpy(&eapol->eth.ether_dhost, &sta->ea, ETHER_ADDR_LEN);
	memcpy(&eapol->eth.ether_shost, &nas->ea, ETHER_ADDR_LEN);
	if (sta->flags & STA_FLAG_PRE_AUTH)
		eapol->eth.ether_type = htons(ETHER_TYPE_802_1X_PREAUTH);
	else
		eapol->eth.ether_type = htons(ETHER_TYPE_802_1X);
	eapol->version = sta->eapol_version;
	eapol->type = EAPOL_KEY;
	eapol->length = htons(packet.iov_len - EAPOL_HEADER_LEN);

	/* Fill EAPOL-Key header */
	body = (eapol_key_header_t *) eapol->body;
	body->type = EAPOL_RC4_KEY;

	/* Length field is unaligned */
	length = htons(key_len);
	memcpy(&body->length, &length, sizeof(body->length));

	/* Replay Counter field is unaligned */
	gettimeofday(&tv, &tz);
	/*
	* keep track timestamp locally in case gettimeofday() does not return
	* correct usec value, for example, on vx. It is ok to not adjust
	* tv.tv_sec since tv.tv_usec is not going to overflow anyway.
	*/
	if (tv.tv_usec == sta->rc4keyusec && tv.tv_sec == sta->rc4keysec) {
		tv.tv_usec += sta->rc4keycntr;
		sta->rc4keycntr ++;
	}
	else {
		sta->rc4keysec = tv.tv_sec;
		sta->rc4keyusec = tv.tv_usec;
		sta->rc4keycntr = 1;
	}
	replay[0] = htonl(tv.tv_sec + JAN_1970);
	replay[1] = htonl(NTPFRAC(tv.tv_usec));
	memcpy(body->replay, replay, sizeof(body->replay));

	/* Fill Key IV */
	nas_rand128(body->iv);

	/* Fill Key Index */
	body->index = index;
	if (unicast)
		body->index |= EAPOL_KEY_UNICAST;

	/* Encrypt Key */
	if (key) {
		memcpy(rc4_seed, body->iv, 16);
		memcpy(&rc4_seed[16], recv_key, recv_key_len);
		prepare_key(rc4_seed, 16 + recv_key_len, &rc4_key);
		memcpy(body->key, key, key_len);
		rc4(body->key, key_len, &rc4_key);
	}

	/* Calculate HMAC-MD5 checksum with null signature */
	if (send_key) {
		memset(body->signature, 0, 16);
		hmac_md5(&eapol->version, packet.iov_len - OFFSETOF(eapol_header_t, version),
		         send_key, send_key_len, body->signature);
	}

	if (sta->flags & STA_FLAG_PRE_AUTH)
		nas_preauth_send_packet(nas, &packet, 1);
	else
		nas_eapol_send_packet(nas, &packet, 1);
	free(packet.iov_base);
}