eapsim.c

linux 下通过802.1认证的安装包

  retval = sim_build_start(simdata, simdata->response_data, &outptr);
  if (retval != XENONE)
    {
      FREE(simdata->response_data);
      eap_type_common_fail(eapdata);
      return;
    }

  offset = sizeof(struct eap_header)+3;

  eaphdr = (struct eap_header *)eapdata->eapReqData;

  size = ntohs(eaphdr->eap_length) - sizeof(struct eap_header);

  while (offset < size)
    {
      switch (eapdata->eapReqData[offset])
	{
	case AT_MAC:
	  debug_printf(DEBUG_NORMAL, "You cannot have an AT_MAC in a Start "
		       "packet!\n");
	  eap_type_common_fail(eapdata);
	  return;

	case AT_ANY_ID_REQ:
	case AT_FULLAUTH_ID_REQ:
	case AT_PERMANENT_ID_REQ:
	  retval = sim_build_fullauth(username, eapdata->eapReqData, &offset,
				      simdata->response_data,
				      &simdata->response_size);
	  if (retval != XENONE)
	    {
	      eap_type_common_fail(eapdata);
	      FREE(simdata->response_data);
	      return;
	    }
	  break;

	case AT_VERSION_LIST:
	  retval = sim_at_version_list(username, simdata, eapdata->eapReqData,
				       &offset, simdata->response_data,
				       &simdata->response_size);
	  if (retval != XENONE)
	    {
	      eap_type_common_fail(eapdata);
	      FREE(simdata->response_data);
	      return;
	    }
	  break;

	default:
	  debug_printf(DEBUG_NORMAL, "Unknown SIM type! (%02X)\n",
		       eapdata->eapReqData[offset]);
	  break;
	}
    }

  value16 = htons(simdata->response_size);
  memcpy(&simdata->response_data[1], &value16, 2);  
}

/***********************************************************************
 *
 * Process an EAP-SIM challenge message.
 *
 ***********************************************************************/
void eapsim_do_challenge(eap_type_data *eapdata)
{
  struct eaptypedata *simdata = NULL;
  int retval = 0;   //, outptr = 0;
  uint16_t offset = 0, size = 0, value16 = 0;
  struct eap_header *eaphdr = NULL;
  struct config_eap_sim *simconf = NULL;
  char *username = NULL;
  uint8_t nsres[16], mac_calc[16], K_int[16];
  struct typelength *typelen = NULL;

  if (!xsup_assert((eapdata != NULL), "eapdata != NULL", FALSE))
    return;

  if (!xsup_assert((eapdata->eap_data != NULL), "eapdata->eap_data != NULL",
                   FALSE))
    {
      eap_type_common_fail(eapdata);
      return;
    }

  if (!xsup_assert((eapdata->eap_conf_data != NULL),
                   "eapdata->eap_conf_data != NULL", FALSE))
    {
      eap_type_common_fail(eapdata);
      return;
    }

  simdata = (struct eaptypedata *)eapdata->eap_data;
  simconf = (struct config_eap_sim *)eapdata->eap_conf_data;

  if (simdata->response_data != NULL)
    {
      debug_printf(DEBUG_NORMAL, "SIM response data was not properly "
		   "deallocated!  Please check the code!\n");
      FREE(simdata->response_data);
    }

  // Allocate some memory for the request.
  simdata->response_data = Malloc(1500);
  if (simdata->response_data == NULL)
    {
      debug_printf(DEBUG_NORMAL, "Couldn't allocate memory to store response "
                   "data!\n");
      eap_type_common_fail(eapdata);
      return;
    }

  if (simconf->username == NULL)
    {
      username = eapdata->ident;
    }
  else
    {
      username = simconf->username;
    }

  offset = sizeof(struct eap_header)+3;

  eaphdr = eapdata->eapReqData;

  size = ntohs(eaphdr->eap_length) - sizeof(struct eap_header);

  typelen = (struct typelength *)simdata->response_data;
  typelen->type = SIM_CHALLENGE;
  typelen->length = 3;

  while (offset < size)
    {
      switch (eapdata->eapReqData[offset])
	{
	case AT_RAND:
	  retval = sim_do_at_rand(simdata, username, &nsres, 
				  eapdata->eapReqData, &offset,
				  simdata->response_data, 
				  &simdata->response_size, &K_int);
	  if (retval != XENONE)
	    {
	      eap_type_common_fail(eapdata);
	      FREE(simdata->response_data);
	      return;
	    }

	case AT_IV:
	  debug_printf(DEBUG_AUTHTYPES, "Got an IV (Not supported)\n");
	  sim_skip_not_implemented(eapdata->eapReqData, &offset);
	  break;

	case AT_ENCR_DATA:
	  debug_printf(DEBUG_AUTHTYPES, "Got an AT_ENCR_DATA (Not supported)"
		       "\n");
	  sim_skip_not_implemented(eapdata->eapReqData, &offset);
	  break;

	case AT_MAC:
	  retval = sim_do_at_mac(eapdata, simdata, 
				 &eapdata->eapReqData[sizeof(struct eap_header)],
				 size, &offset,
				 simdata->response_data, 
				 &simdata->response_size, &K_int);
	  if (retval != XENONE)
	    {
	      eap_type_common_fail(eapdata);
	      FREE(simdata->response_data);
	      return;
	    }
	  break;
	}
    }

  if (simdata->workingversion == 1)
    {
      debug_printf(DEBUG_AUTHTYPES, "nsres = ");
      debug_hex_printf(DEBUG_AUTHTYPES, nsres, 12);
      
      retval = sim_do_v1_response(eapdata, simdata->response_data,
				  &simdata->response_size, &nsres,
				  &K_int);
      if (retval != XENONE)
	{
	  eap_type_common_fail(eapdata);
	  FREE(simdata->response_data);
	  return;
	}
    }

  value16 = htons(simdata->response_size);
  memcpy(&simdata->response_data, &value16, 2);

  eapdata->methodState = DONE;
  eapdata->decision = COND_SUCC;
  eapdata->ignore = FALSE;
}

/***********************************************************************
 *
 * Process an EAP-SIM request message.
 *
 ***********************************************************************/
void eapsim_process(eap_type_data *eapdata)
{
  if (!xsup_assert((eapdata != NULL), "eapdata != NULL", FALSE))
    return;

  if (!xsup_assert((eapdata->eap_data != NULL), "eapdata->eap_data != NULL",
		   FALSE))
    {
      eap_type_common_fail(eapdata);
      return;
    }

  if (!xsup_assert((eapdata->eap_conf_data != NULL),
		   "eapdata->eap_conf_data != NULL", FALSE))
    {
      eap_type_common_fail(eapdata);
      return;
    }

  if (eapdata->methodState == INIT)
    {
      if (eapsim_init(eapdata) == FALSE)
	{
	  eap_type_common_fail(eapdata);
	  return;
	}
    }

  switch (eapdata->eapReqData[sizeof(struct eap_header)])
    {
    case SIM_START:
      eapsim_do_sim_start(eapdata);
      break;

    case SIM_CHALLENGE:
      eapsim_do_sim_challenge(eapdata);
      break;

    case SIM_NOTIFICATION:
      debug_printf(DEBUG_NORMAL, "Got SIM_NOTIFICATION! (Unsupported)\n");
      break;

    case SIM_REAUTHENTICATION:
      debug_printf(DEBUG_NORMAL, "Got SIM_REAUTHENTICATION! (Unsupported)\n");
      break;

    default:
      debug_printf(DEBUG_NORMAL, "Unknown Sub-Type value! (%d)\n",
		   eapdata->eapReqData[sizeof(struct eap_header)]);
      break;
    }
}

/***********************************************************************
 *
 * Build an EAP-SIM response message.
 *
 ***********************************************************************/
uint8_t *eapsim_buildResp(eap_type_data *eapdata)
{
  struct eaptypedata *simdata = NULL;
  uint8_t *resp_pkt = NULL;
  struct eap_header *eaphdr = NULL;

  if (!xsup_assert((eapdata != NULL), "eapdata != NULL", FALSE))
    return NULL;

  if (!xsup_assert((eapdata->eap_data != NULL), "eapdata->eap_data != NULL",
		   FALSE))
    {
      eap_type_common_fail(eapdata);
      return NULL;
    }

  simdata = (struct eaptypedata *)eapdata->eap_data;

  resp_pkt = Malloc(sizeof(struct eap_header) + simdata->response_size);
  if (resp_pkt == NULL)
    {
      debug_printf(DEBUG_NORMAL, "Couldn't allocate memory for response "
		   "packet!\n");
      FREE(simdata->response_data);
      return NULL;
    }

  eaphdr = (struct eap_header *)resp_pkt;
  
  eaphdr->eap_code = EAP_RESPONSE_PKT;
  eaphdr->eap_identifier = eap_type_common_get_eap_reqid(eapdata->eapReqData);
  eaphdr->eap_length = htons((sizeof(struct eap_header) + simdata->response_size));
  eaphdr->eap_type = EAP_TYPE_SIM;

  memcpy(&resp_pkt[sizeof(struct eap_header)], simdata->response_data,
	 simdata->response_size);

  FREE(simdata->response_data);
  
  return resp_pkt;
}

/***********************************************************************
 *
 * Determine if keying material is available.
 *
 ***********************************************************************/
uint8_t eapsim_isKeyAvailable(eap_type_data *eapdata)
{
  struct eaptypedata *simdata;

  if (!xsup_assert((eapdata != NULL), "eapdata != NULL", FALSE))
    return FALSE;

  if (!xsup_assert((eapdata->eap_data != NULL), "eapdata->eap_data != NULL",
		   FALSE)) 
    return FALSE;

  simdata = (struct eaptypedata *)eapdata->eap_data;

  if (simdata->keyingMaterial != NULL) return TRUE;

  return FALSE;
}

/***********************************************************************
 *
 * Return the keying material.
 *
 ***********************************************************************/
uint8_t *eapsim_getKey(eap_type_data *eapdata)
{
  struct eaptypedata *simdata;
  uint8_t *keydata;

  if (!xsup_assert((eapdata != NULL), "eapdata != NULL", FALSE))
    return FALSE;

  if (!xsup_assert((eapdata->eap_data != NULL), "eapdata->eap_data != NULL",
                   FALSE))
    return FALSE;

  simdata = (struct eaptypedata *)eapdata->eap_data;

  keydata = Malloc(64);
  if (keydata == NULL)
    {
      debug_printf(DEBUG_NORMAL, "Couldn't allocate memory to store key "
		   "data!\n");
      return NULL;
    }

  memcpy(keydata, simdata->keyingMaterial, 64);

  return simdata->keyingMaterial;
}

/***********************************************************************
 *
 * Clean up after ourselves.
 *
 ***********************************************************************/
void eapsim_deinit(eap_type_data *eapdata)
{
  FREE(eapdata->eap_data);

  debug_printf(DEBUG_AUTHTYPES, "(EAP-SIM) Deinit.\n");
}

#endif