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

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