Authentication with Mifare Classic using libnfc (Page 1 of 2)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libnfc.h>
#include "crapto1.h"

bool mifare_test(dev_info* pdi, byte_t* pbtUid, uint64_t ui64Key, uint32_t uiBlock)
{
  uint32_t pos, nt;
  struct Crypto1State* pcs;
  byte_t abtAuth[4]        = { 0x60,0x00,0x00,0x00 };
  byte_t abtArEnc[8]       = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
  byte_t abtArEncPar[8]    = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
  byte_t abtRx[MAX_FRAME_LEN];
  byte_t abtRxPar[MAX_FRAME_LEN];
  uint32_t uiRxLen;
  
  // Configure the authentication frame using the supplied block 
  abtAuth[1] = uiBlock;
  append_iso14443a_crc(abtAuth,2);

  // Now we take over, first we need full control over the CRC
  nfc_configure(pdi,DCO_HANDLE_CRC,false);

  // Request plain tag-nonce
  printf(" Nt: ");
  if (!nfc_initiator_transceive_bytes(pdi,abtAuth,4,abtRx,&uiRxLen)) return false;
  print_hex(abtRx,4);
  
  // Save the tag nonce (nt)
  nt = swap_endian32(abtRx);

  // Init cipher with key
  pcs = crypto1_create(ui64Key);

  // Load (plain) uid^nt into the cipher
  for (pos=0; pos<4; pos++)
  {
    // Update the cipher with the tag-initialization 
    crypto1_byte(pcs,pbtUid[pos]^abtRx[pos],0);
  }

  // Generate (encrypted) nr+parity by loading it into the cipher
  for (pos=0; pos<4; pos++)
  {
    // Load in, and encrypt, the reader nonce (plain nr=0x00000000)
    abtArEnc[pos] = crypto1_byte(pcs,0x00,0) ^ 0x00;
    // Encrypt the parity bits for the 4 plaintext bytes of nr
    abtArEncPar[pos] = filter(pcs->odd) ^ oddparity(0x00);
  }
  
  // Skip 32 bits in pseudo random generator
  nt = prng_successor(nt,32);
  
  // Generate reader-answer from tag-nonce
  for (pos=4; pos<8; pos++)
  {
    // Get the next random byte for verify the reader to the tag 
    nt = prng_successor(nt,8);

    // Encrypt the reader-answer (nt' = suc2(nt))
    abtArEnc[pos] = crypto1_byte(pcs,0x00,0) ^ (nt&0xff);
    // Encrypt the parity bits for the 4 plaintext bytes of nt'
    abtArEncPar[pos] = filter(pcs->odd) ^ oddparity(nt&0xff);
  }

  // Finally we want to send arbitrary parity bits
  nfc_configure(pdi,DCO_HANDLE_PARITY,false);

  // Transmit reader-answer
  printf(" Ar: ");
  print_hex_par(abtArEnc,64,abtArEncPar);
  if (!nfc_initiator_transceive_bits(pdi,abtArEnc,64,abtArEncPar,abtRx,&uiRxLen,abtRxPar)) return false;
  printf(" At: "); 
  print_hex_par(abtRx,uiRxLen,abtRxPar);
  
  crypto1_destroy(pcs);

  return true;
}


int main(int argc, const char* argv[])
{
  dev_info* pdi;
  tag_info ti;
  uint32_t uiBlock;
  uint64_t ui64Key;

  if (argc < 3)
  {
    printf("syntax: %s <key> <block>\n",argv[0]);
    return 1;
  }
  
  sscanf(argv[1],"%012llx",&ui64Key);
  sscanf(argv[2],"%02x",&uiBlock);
  
  // Try to open the NFC reader
  pdi = nfc_connect(NULL);
  
  if (pdi == INVALID_DEVICE_INFO)
  {
    printf("Error connecting NFC reader\n");
    return 1;
  }
  nfc_initiator_init(pdi);

  // Drop the field for a while, so the card can reset
  nfc_configure(pdi,DCO_ACTIVATE_FIELD,false);

  // Let the reader only try once to find a tag
  nfc_configure(pdi,DCO_INFINITE_SELECT,false);

  // Configure the CRC and Parity settings
  nfc_configure(pdi,DCO_HANDLE_CRC,true);
  nfc_configure(pdi,DCO_HANDLE_PARITY,true);

  // Enable field so more power consuming cards can power themselves up
  nfc_configure(pdi,DCO_ACTIVATE_FIELD,true);

  printf("\nConnected to NFC reader: %s\n\n",pdi->acName);
  
  // Poll for a ISO14443A (MIFARE) tag
  if (!nfc_initiator_select_tag(pdi,IM_ISO14443A_106,NULL,0,&ti))
  {
    printf("Error connecting to MIFARE Classic tag\n");
    nfc_disconnect(pdi);
    return 1;
  }
  
  // Print the uid to the screen 
  printf("   uid: %08x\n",swap_endian32(ti.tia.abtUid));
  printf("   key: %012llx\n",ui64Key);
  printf(" block: %02x\n",uiBlock);
  printf("\n");
  
  // Run the MIFARE Classic test
  if (mifare_test(pdi,ti.tia.abtUid,ui64Key,uiBlock))
  {
    printf("\nAuthentication Succesful\n\n");
  } else {
    printf("\nAuthentication failed\n");
  }

  // Reset the "advanced" configuration to normal
  nfc_configure(pdi,DCO_HANDLE_CRC,true);
  nfc_configure(pdi,DCO_HANDLE_PARITY,true);

  // Clean up and release device
  nfc_disconnect(pdi);
  return 0;
}

gcc -o crypto1test crypto1test.c crypto1.c crapto1.h -I/usr/local/include/libnfc -L/usr/local/lib/ -lnfc

./crypto1test ffffffffffff 14

Connected to NFC reader: ACR122U101 - PN532 v1.4 (0x07)

   uid: 6c14df2a
   key: ffffffffffff
 block: 14

 Nt: 65  25  bb  51  
 Ar: 8c! ca  16  f9! c8! 2d  2a! 54  
 At: 9e  cf! 75! 77  

Authentication Succesful

  abtAuth[1] = uiBlock;
  append_iso14443a_crc(abtAuth,2);

  //do encrypted second auth
  abtAuth2[0] = 0x60;

  // Configure the authentication frame using the supplied block 
  abtAuth2[1] = uiBlock;
  append_iso14443a_crc(abtAuth2,2);

  // Generate (encrypted) abtAuth2by loading it into the cipher
  for (pos=0; pos<4; pos++)
  {
    // Encrypt the abtAuth2
    abtArEnc2[pos] = crypto1_byte(pcs,0x00,0) ^ abtAuth2[pos];
    // Encrypt the parity bits for the 4 plaintext bytes of abtAuth2
    abtArEncPar2[pos] = filter(pcs->odd) ^ oddparity(abtAuth2[pos]);
  }

  // Finally we want to send arbitrary parity bits
  nfc_configure(pdi,DCO_HANDLE_PARITY,false);

  // Transmit second auth
  printf(" Auth2: ");
  print_hex_par(abtArEnc2,32,abtArEncPar2);
  if (!nfc_initiator_transceive_bits(pdi,abtArEnc2,32,abtArEncPar2,abtRx,&uiRxLen,abtRxPar)) return false;
  printf(" Nt': "); 
  print_hex_par(abtRx,uiRxLen,abtRxPar);

  // Generate (encrypted) nr+parity by loading it into the cipher
  for (pos=0; pos<4; pos++)
  {
    // Load in, and encrypt, the reader nonce (plain nr=0x00000000)
    abtArEnc[pos] = crypto1_byte(pcs,0x00,0) ^ 0x00;
    // Encrypt the parity bits for the 4 plaintext bytes of nr
    abtArEncPar[pos] = filter(pcs->odd) ^ oddparity(0x00);
  }