sm_handler.c

来自「可以用作很多客户端的XSUPPLICANT的源代码。比如用在802.1x或者无线」· C语言 代码 · 共 695 行 · 第 1/2 页

  if ((!challenge) || (!response) || (!ckey))
    {
      debug_printf(DEBUG_NORMAL, "Invalid data passed to do_gsm()!\n");
      return XEMALLOC;
    }

  strcpy(buff2, RUN_GSM);
  bzero(&buff3, MAXBUFF);

  for (i = 0; i < 16; i++)
    {
      sprintf(buff3,"%02X",challenge[i]);
      strcat(buff2, buff3);
    }

  //  printf("(in do_gsm) Sending in : %s\n",buff2);
  len = MAXBUFF;
  card_io(buff2, buf, &len);

  /*printf("Response : ");
  
  for (i=0; i<4; i++)
    printf("%02X ",buf[i]);
  */
  memcpy(response, &buf[0], 4);
  /*
  printf("\nCipher Key : ");

  for (i=4; i<12; i++)
    printf("%02X ",buf[i]);
  */
  memcpy(ckey, &buf[4], 8);

  //  printf("\n");
  return 0;
}


int sc_need_init()
{
  return need_init;
}

int init_get_imsi(struct generic_eap_data *thisint, char *rimsi)
{
  LPSTR mszReaders;
  long ret;
  DWORD size, dwState, dwProtocol, dwAtrLen;
  DWORD len;
  unsigned char *buf; 
  unsigned char buff2[MAXBUFF], buff3[MAXBUFF];
  unsigned char imsi[20];
  int i;
  char *s, *dbuf, *pin;
  BYTE pbAtr[MAX_ATR_SIZE];
  struct config_eap_sim *mydata;

  if ((!thisint) || (!thisint->eap_conf_data))
    {
      debug_printf(DEBUG_NORMAL, "Invalid data passed to init_get_imsi()!\n");
      return XEMALLOC;
    }

  mydata = (struct config_eap_sim *)thisint->eap_conf_data;

  if (need_init == 0) return 0;

  buf = (unsigned char *)malloc(MAXBUFF);
  if (buf == NULL) return XEMALLOC;

  g_sc_context = 0;
  g_card_hdl = 0;
  o_stdprotocol = 0;

  pin = mydata->password;

  // First, get a context for us to work with the card.
  ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &g_sc_context);
  if (ret != SCARD_S_SUCCESS)
    {
      printf("Error!  Couldn't establish Smart Card Context!  (Is pcscd loaded?)\n");
      free(buf);
      buf = NULL;
      return -1;
    }

  // Find out the size of the buffer that we need in order to get our
  // reader information back.
  ret = SCardListReaders(g_sc_context, NULL, NULL, &readerstrlen);
  if (ret != SCARD_S_SUCCESS)
    {
      print_sc_error(ret);
      free(buf);
      buf = NULL;
      return -1;
    }

  o_readername = (char *)malloc(readerstrlen);
  if (o_readername == NULL)
    {
      printf("Couldn't allocate memory for reader info string!\n");
    }

  ret = SCardListReaders(g_sc_context, NULL, o_readername, &readerstrlen);
  if (ret != SCARD_S_SUCCESS)
    {
      printf("Couldn't list smart card readers!\n");
      print_sc_error(ret);
      free(buf);
      buf = NULL;
      return -1;
    }

  // We may have found more than one reader, but we are only going to use 
  // the first one we found.  This could be changed in the future if a
  // situation presents itself that needs more than one reader.  In that
  // case, the string that is returned contains the names of all of the readers
  // with the last name being terminated with a double NULL. \0\0.
  debug_printf(DEBUG_AUTHTYPES, "Found reader : %s\n",o_readername);

  while (1)
    {
      ret = SCardConnect(g_sc_context, o_readername,
			 SCARD_SHARE_SHARED,
			 SCARD_PROTOCOL_T0, 
			 &g_card_hdl, &o_stdprotocol);
      
      if (ret == SCARD_S_SUCCESS) break;

      if (ret == SCARD_E_NO_SMARTCARD)
	{
	  printf("Please insert a smart card!\n");
	  sleep(2);
	  continue;
	} else {
	  printf("An unchecked error happened!\n");
	  print_sc_error(ret);
	  break;
	}
    }

  dwState = 0;
  dwProtocol = 0;
  dwAtrLen = MAX_ATR_SIZE;
  size = 50;
  mszReaders= (LPSTR) malloc(size);
  bzero(mszReaders, 50);
  bzero(&pbAtr, MAX_ATR_SIZE);
  ret = SCardStatus(g_card_hdl, mszReaders, &size, &dwState, &dwProtocol, pbAtr, &dwAtrLen);
  if (ret != SCARD_S_SUCCESS)
    {
      print_sc_error(ret);
      free(mszReaders);
      free(buf);
      buf = NULL;
      exit(1);                /* Need to fix this! */
    }

  switch (dwState)
    {
    case SCARD_ABSENT:
      debug_printf(DEBUG_NORMAL, "There is no card in the reader.\n");
      break;
    case SCARD_PRESENT:
      debug_printf(DEBUG_NORMAL, "The card needs to be moved to a position that the reader can use!\n");
      break;
    case SCARD_SWALLOWED:
      debug_printf(DEBUG_NORMAL, "Card is ready, but not powered.\n");
      break;
    case SCARD_POWERED:
      debug_printf(DEBUG_NORMAL, "Card is powered, but we aren't sure of the mode of the card!\n");
      break;
    }

  /* select the Master File */                
  len=MAXBUFF;
  card_io(SELECT_MF, buf, &len);

  /* select DF_GSM */
  len=MAXBUFF;
  card_io(SELECT_DF_GSM, buf, &len); 

  if (!(buf[13] & 0x80))
    {
      if (pin == NULL) return -1;   /* We don't have a pin, but we need one. */

      strcpy(buff2, "A020000108");
      for (i = 0;i<strlen(pin); i++)
	{
	  sprintf(buff3, "%02X",pin[i]);
	  strcat(buff2, buff3);
	}
      for (i = strlen(pin); i < 8; i++)
	{
	  strcat(buff2, "FF");             /* Pad it to 8 bytes */
	}
      len=MAXBUFF;
      card_io(buff2, buf, &len);

      if (len == 2 && buf[0] == 0x98)
	{
	  if (buf[1] == 0x04)
	    {
	      printf("Incorrect PIN, at least one attempt left\n");
	      exit (1);               /* Need to fix this! */
	    }
	  else if (buf[1] == 0x40)
	    {
	      printf("Incorrect PIN, no attempts left\n");
	      exit (1);               /* Need to fix this! */
	    }
	}
    }
  len=MAXBUFF;
  dbuf = (char *)malloc(MAXBUFF);
  card_io(SELECT_EF_IMSI,dbuf,&len);

  len=MAXBUFF;
  bzero(dbuf,MAXBUFF);
  card_io(GET_IMSI,dbuf,&len);
  
  s = imsi;
  *s++ = hinibble(dbuf[1]);
  
  for (i = 2; i<9; i++)
    {
      *s++ = lonibble(dbuf[i]);
      *s++ = hinibble(dbuf[i]);
    }
  *s = '\0';

  if (rimsi != NULL)
    {
      memcpy(rimsi, imsi, 18);
    }
  
  free(buf);
  buf = NULL;
  free(dbuf);
  dbuf = NULL;

  free(mszReaders);
  mszReaders = NULL;

  return XENONE;
}

int eapsim_get_username(struct interface_data *thisint)
{
  char imsi[18];   // An IMSI should always be 18 digits.
  char realm[25];
  char *username;
  struct config_eap_sim *userdata;
  struct generic_eap_data mydata;

  if ((!thisint) || (!thisint->userdata) || (!thisint->userdata->methods) ||
      (!thisint->userdata->methods->method_data))
    {
      debug_printf(DEBUG_NORMAL, "Invalid interface structure passed to eapsim_get_username()!\n");
      return XEMALLOC;
    }

  userdata = (struct config_eap_sim *)thisint->userdata->methods->method_data;

  mydata.eap_conf_data = userdata;

  bzero(&imsi, 18);
  init_get_imsi(&mydata, (char *)&imsi);

  debug_printf(DEBUG_AUTHTYPES, "SIM IMSI : %s\n",imsi);

  if (thisint->userdata->identity != NULL)
    {
      free(thisint->userdata->identity);
    }

  thisint->userdata->identity = (char *)malloc(50);  // 50 should be plenty!
  if (thisint->userdata->identity == NULL) return XEMALLOC;

  username = thisint->userdata->identity;
  userdata->username = username;
  bzero(username, 50);

  username[0] = '1';  // An IMSI should always start with a 1.
  strncpy(&username[1], (char *)&imsi, 18);

  if (userdata->auto_realm == TRUE)
    {
      bzero(&realm, 25);
      sprintf((char *)&realm, "@mnc%c%c%c.mcc%c%c%c.owlan.org",
	      username[4], username[5], username[6], username[1], username[2],
	      username[3]);

      debug_printf(DEBUG_AUTHTYPES, "Realm Portion : %s\n",realm);
      strcat(username, realm);
    }

  // Close the smartcard, so that we know what state we are in.
  close_smartcard();

  debug_printf(DEBUG_AUTHTYPES, "Username is now : %s\n", username);

  return XENONE;
}

int init_smartcard(struct generic_eap_data *thisint)
{

  if (!thisint)
    {
      debug_printf(DEBUG_NORMAL, "Invalid interface structure passed to init_smartcard()!\n");
      return XEMALLOC;
    }

  init_get_imsi(thisint, NULL);

  return XENONE;
}


int close_smartcard()
{
  long ret;

  if (g_card_hdl) 
    {
      ret = SCardDisconnect(g_card_hdl, SCARD_UNPOWER_CARD);
      if (ret != SCARD_S_SUCCESS) 
	debug_printf(DEBUG_NORMAL, "Couldn't disconnect from Smart Card!\n");
      g_card_hdl = 0;
    }

  if (g_sc_context)
    {
      ret = SCardReleaseContext(g_sc_context);
      if (ret != SCARD_S_SUCCESS) 
	debug_printf(DEBUG_NORMAL, "Couldn't release smart card context!\n");
      g_sc_context = 0;
    }

  return XENONE;
}


#endif