cvs.zerfleddert.de Git - proxmark3-svn/blob - common/protocols.c

   1 #include <string.h>
   2 #include <stdint.h>
   3 #include <stdarg.h>
   4 #include "protocols.h"
   5
   6 // ATA55xx shared presets & routines
   7 uint32_t GetT55xxClockBit(uint32_t clock) {
   8         switch (clock) {
   9                 case 128: return T55x7_BITRATE_RF_128;
  10                 case 100: return T55x7_BITRATE_RF_100;
  11                 case  64: return T55x7_BITRATE_RF_64;
  12                 case  50: return T55x7_BITRATE_RF_50;
  13                 case  40: return T55x7_BITRATE_RF_40;
  14                 case  32: return T55x7_BITRATE_RF_32;
  15                 case  16: return T55x7_BITRATE_RF_16;
  16                 case   8: return T55x7_BITRATE_RF_8;
  17                 default : return 0;
  18         }
  19 }
  20
  21 #ifndef ON_DEVICE
  22 #include "ui.h"
  23 #define prnt PrintAndLog
  24
  25 // iclass / picopass chip config structures and shared routines
  26 typedef struct {
  27         uint8_t app_limit;      //[8]
  28         uint8_t otp[2];         //[9-10]
  29         uint8_t block_writelock;//[11]
  30         uint8_t chip_config;    //[12]
  31         uint8_t mem_config;     //[13]
  32         uint8_t eas;            //[14]
  33         uint8_t fuses;          //[15]
  34 } picopass_conf_block;
  35
  36
  37 typedef struct {
  38         uint8_t csn[8];
  39         picopass_conf_block conf;
  40         uint8_t epurse[8];
  41         uint8_t key_d[8];
  42         uint8_t key_c[8];
  43         uint8_t app_issuer_area[8];
  44 } picopass_hdr;
  45
  46 uint8_t isset(uint8_t val, uint8_t mask) {
  47         return (val & mask);
  48 }
  49
  50 uint8_t notset(uint8_t val, uint8_t mask){
  51         return !(val & mask);
  52 }
  53
  54 void fuse_config(const picopass_hdr *hdr) {
  55         uint8_t fuses = hdr->conf.fuses;
  56
  57         if (isset(fuses,FUSE_FPERS))
  58                 prnt("  Mode: Personalization [Programmable]");
  59         else
  60                 prnt("  Mode: Application [Locked]");
  61
  62         if (isset(fuses, FUSE_CODING1)) {
  63                 prnt("  Coding: RFU");
  64         } else {
  65                 if( isset( fuses , FUSE_CODING0))
  66                         prnt("  Coding: ISO 14443-2 B/ISO 15693");
  67                 else
  68                         prnt("  Coding: ISO 14443B only");
  69         }
  70         if( isset (fuses,FUSE_CRYPT1 | FUSE_CRYPT0 )) prnt("    Crypt: Secured page, keys not locked");
  71         if( isset (fuses,FUSE_CRYPT1) && notset( fuses, FUSE_CRYPT0 )) prnt("   Crypt: Secured page, keys not locked");
  72         if( notset (fuses,FUSE_CRYPT1) && isset( fuses, FUSE_CRYPT0 )) prnt("   Crypt: Non secured page");
  73         if( notset (fuses,FUSE_CRYPT1) && notset( fuses, FUSE_CRYPT0 )) prnt("  Crypt: No auth possible. Read only if RA is enabled");
  74
  75         if( isset( fuses, FUSE_RA))
  76                 prnt("  RA: Read access enabled");
  77         else
  78                 prnt("  RA: Read access not enabled");
  79 }
  80
  81 void getMemConfig(uint8_t mem_cfg, uint8_t chip_cfg, uint8_t *max_blk, uint8_t *app_areas, uint8_t *kb) {
  82         // mem-bit 5, mem-bit 7, chip-bit 4: defines chip type
  83         if(isset(chip_cfg, 0x10) && notset(mem_cfg, 0x80) && notset(mem_cfg, 0x20)) {
  84                 *kb = 2;
  85                 *app_areas = 2;
  86                 *max_blk = 31;
  87         } else if(isset(chip_cfg, 0x10) && isset(mem_cfg, 0x80) && notset(mem_cfg, 0x20)) {
  88                 *kb = 16;
  89                 *app_areas = 2;
  90                 *max_blk = 255; //16kb
  91         } else if(notset(chip_cfg, 0x10) && notset(mem_cfg, 0x80) && notset(mem_cfg, 0x20)) {
  92                 *kb = 16;
  93                 *app_areas = 16;
  94                 *max_blk = 255; //16kb
  95         } else if(isset(chip_cfg, 0x10) && isset(mem_cfg, 0x80) && isset(mem_cfg, 0x20)) {
  96                 *kb = 32;
  97                 *app_areas = 3;
  98                 *max_blk = 255; //16kb
  99         } else if(notset(chip_cfg, 0x10) && notset(mem_cfg, 0x80) && isset(mem_cfg, 0x20)) {
 100                 *kb = 32;
 101                 *app_areas = 17;
 102                 *max_blk = 255; //16kb
 103         } else {
 104                 *kb = 32;
 105                 *app_areas = 2;
 106                 *max_blk = 255;
 107         }
 108 }
 109
 110 void mem_app_config(const picopass_hdr *hdr) {
 111         uint8_t mem = hdr->conf.mem_config;
 112         uint8_t chip = hdr->conf.chip_config;
 113         uint8_t applimit = hdr->conf.app_limit;
 114         if (applimit < 6) applimit = 26;
 115         uint8_t kb = 2;
 116         uint8_t app_areas = 2;
 117         uint8_t max_blk = 31;
 118         getMemConfig(mem, chip, &max_blk, &app_areas, &kb);
 119         prnt("  Mem: %u KBits/%u App Areas (%u * 8 bytes) [%02X]", kb, app_areas, max_blk, mem);
 120         prnt("  AA1: blocks 06-%02X", applimit);
 121         prnt("  AA2: blocks %02X-%02X", applimit+1, max_blk);
 122 }
 123 void print_picopass_info(const picopass_hdr *hdr) {
 124         fuse_config(hdr);
 125         mem_app_config(hdr);
 126 }
 127 void printIclassDumpInfo(uint8_t* iclass_dump) {
 128         print_picopass_info((picopass_hdr *) iclass_dump);
 129 }
 130
 131 /*
 132 void test() {
 133         picopass_hdr hdr = {0x27,0xaf,0x48,0x01,0xf9,0xff,0x12,0xe0,0x12,0xff,0xff,0xff,0x7f,0x1f,0xff,0x3c};
 134         prnt("Picopass configuration:");
 135         print_picopass_info(&hdr);
 136 }
 137 int main(int argc, char *argv[]) {
 138         test();
 139         return 0;
 140 }
 141 */
 142
 143 #endif
 144 //ON_DEVICE