X-Git-Url: http://git.rot13.org/?a=blobdiff_plain;f=utils%2Flibrfid-tool.c;h=3651e5d642ab39c729ab48c9ef864a9aa935ca24;hb=72e21ac4f2e8c9352797d32dd5d19d0d3c2736c7;hp=e1270f1cf77f7a8f0ea914455785a817d981dee7;hpb=6ae1ffc4f537eb4748c801f6d42ed08ee7221c6f;p=librfid diff --git a/utils/librfid-tool.c b/utils/librfid-tool.c index e1270f1..3651e5d 100644 --- a/utils/librfid-tool.c +++ b/utils/librfid-tool.c @@ -1,9 +1,9 @@ /* librfid-tool - a small command-line tool for librfid testing * - * (C) 2005-2006 by Harald Welte + * (C) 2005-2008 by Harald Welte * * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 + * it under the terms of the GNU General Public License version 2 * as published by the Free Software Foundation * * This program is distributed in the hope that it will be useful, @@ -13,7 +13,7 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ #include @@ -22,6 +22,10 @@ #include #include +#ifndef __MINGW32__ +#include +#endif + #define _GNU_SOURCE #include @@ -31,87 +35,17 @@ #include #include +#include +#include + #include #include +#include +#include +#include -#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) - -static const char * -hexdump(const void *data, unsigned int len) -{ - static char string[1024]; - unsigned char *d = (unsigned char *) data; - unsigned int i, left; - - string[0] = '\0'; - left = sizeof(string); - for (i = 0; len--; i += 3) { - if (i >= sizeof(string) -4) - break; - snprintf(string+i, 4, " %02x", *d++); - } - return string; -} - -static struct rfid_reader_handle *rh; -static struct rfid_layer2_handle *l2h; -static struct rfid_protocol_handle *ph; - -static int reader() { - printf("opening reader handle\n"); - rh = rfid_reader_open(NULL, RFID_READER_CM5121); - if (!rh) { - fprintf(stderr, "No Omnikey Cardman 5121 found\n"); - rh = rfid_reader_open(NULL, RFID_READER_OPENPCD); - if (!rh) { - fprintf(stderr, "No OpenPCD found either\n"); - return -1; - } - } - return 0; -} -static int init(int layer2) -{ - unsigned char buf[0x3f]; - int rc; - - - printf("opening layer2 handle\n"); - l2h = rfid_layer2_init(rh, layer2); - if (!l2h) { - fprintf(stderr, "error during iso14443a_init\n"); - return -1; - } - - //rc632_register_dump(rh->ah, buf); - - printf("running layer2 anticol\n"); - rc = rfid_layer2_open(l2h); - if (rc < 0) { - fprintf(stderr, "error during layer2_open\n"); - return rc; - } +#include "librfid-tool.h" - return 0; -} - -static int l3(int protocol) -{ - printf("running layer3 (ats)\n"); - ph = rfid_protocol_init(l2h, protocol); - if (!ph) { - fprintf(stderr, "error during protocol_init\n"); - return -1; - } - if (rfid_protocol_open(ph) < 0) { - fprintf(stderr, "error during protocol_open\n"); - return -1; - } - - printf("we now have layer3 up and running\n"); - - return 0; -} static int select_mf(void) { @@ -198,7 +132,7 @@ iso7816_read_binary(unsigned char *buf, unsigned int *len) unsigned char cmd[] = { 0x00, 0xb0, 0x00, 0x00, 0x00 }; unsigned char resp[256]; unsigned int rlen = sizeof(resp); - + int rv; rv = rfid_protocol_transceive(ph, cmd, sizeof(cmd), resp, &rlen, 0, 0); @@ -274,28 +208,174 @@ mifare_classic_read_sector(struct rfid_protocol_handle *ph, int sector) unsigned char buf[20]; unsigned int len = sizeof(buf); int ret; - int block; + int block, blocks_per_sector, first_block; + + printf("Reading sector %u\n", sector); - /* FIXME: make this work for sectors > 31 */ - printf("reading sector %u\n", sector); + first_block = mfcl_sector2block(sector); + blocks_per_sector = mfcl_sector_blocks(sector); - for (block = sector*4; block < sector*4+4; block++) { - printf("reading block %u\n", block); + if (first_block < 0 || blocks_per_sector < 0) + return -EINVAL; + + for (block = first_block; block < first_block + blocks_per_sector; + block++) { + printf("Reading block %u: ", block); ret = rfid_protocol_read(ph, block, buf, &len); - if(ret == -ETIMEDOUT) + if (ret == -ETIMEDOUT) fprintf(stderr, "TIMEOUT\n"); - if (ret < 0) + if (ret < 0) { + printf("Error %d reading\n", ret); return ret; + } printf("Page 0x%x: %s\n", block, hexdump(buf, len)); } return 0; } +static int +mifare_classic_dump(struct rfid_protocol_handle *ph) +{ + unsigned int size; + unsigned int size_len = sizeof(size); + int sector, num_sectors; + + if (rfid_protocol_getopt(ph, RFID_OPT_PROTO_SIZE, + &size, &size_len) == 0) { + printf("Size: %u bytes\n", size); + } else { + printf("Size: unknown ?!?\n"); + return -EINVAL; + } + + switch (size) { + case 320: + num_sectors = 5; + break; + case 1024: + num_sectors = 16; + break; + case 4096: + num_sectors = 40; + break; + default: + return -EINVAL; + } + + for (sector = 0; sector < num_sectors; sector++) { + int rc; + + printf("Authenticating sector %u: ", sector); + fflush(stdout); + + rc = mfcl_set_key(ph, MIFARE_CL_KEYA_DEFAULT_INFINEON); + if (rc < 0) { + printf("key format error\n"); + exit(1); + } + + rc = mfcl_auth(ph, RFID_CMD_MIFARE_AUTH1A, + mfcl_sector2block(sector)); + if (rc < 0) { + printf("mifare auth error\n"); + exit(1); + } else + printf("mifare auth succeeded!\n"); + + mifare_classic_read_sector(ph, sector); + } +} + +void +iso15693_write(struct rfid_reader_handle *rh,int layer2,int sector, + unsigned char *data, unsigned int len) +{ + int rc; + unsigned char uid_buf[16]; + unsigned int uid_len = sizeof(uid_buf); + + if (rh->reader->l2_supported & (1 << layer2)) { + l2h = rfid_layer2_init(rh, layer2); + if (!l2h) { + printf("error during layer2(%d)_init (0=14a,1=14b,3=15)\n",layer2); + return; + } + printf("Layer2 init ok\n"); + rc = rfid_layer2_open(l2h); + if (rc>0){ + rfid_layer2_getopt(l2h, RFID_OPT_LAYER2_UID, &uid_buf, &uid_len); + printf("Layer 2 success (%s)[%d]: '%s'\n", rfid_layer2_name(l2h), uid_len, hexdump(uid_buf, uid_len)); + rc = iso15693_write_block(l2h,sector,data,len); + printf("write>>rc: %d\n",rc); + + }else { + printf("error during layer2_open\n"); + return ; + } + rfid_layer2_close(l2h); + rfid_layer2_fini(l2h); + } +} + +void iso15693_dump(struct rfid_reader_handle *rh,int layer2,int sector){ + unsigned int size; + unsigned int size_len = sizeof(size); + unsigned char buf[1024]; + int rc,i; + unsigned char uid_buf[16], block_sec; + unsigned int uid_len = sizeof(uid_buf); + + + if (rh->reader->l2_supported & (1 << layer2)) { + l2h = rfid_layer2_init(rh, layer2); + if (!l2h) { + printf("error during layer2(%d)_init (0=14a,1=14b,3=15)\n",layer2); + return; + } + printf("Layer2 init ok\n"); + rc = rfid_layer2_open(l2h); + if (rc>0){ + rfid_layer2_getopt(l2h, RFID_OPT_LAYER2_UID, &uid_buf, &uid_len); + printf("Layer 2 success (%s)[%d]: '%s'\n", rfid_layer2_name(l2h), uid_len, hexdump(uid_buf, uid_len)); + + if (sector < 0){ + if (sector<=-3) + iso15693_select(l2h); + for(i=0;i<=255;i++){ + rc = iso15693_read_block(l2h,i,buf,sizeof(buf),&block_sec); + if (rc>=0) + printf("block[%3d:%02x]sec:0x%0x data(%d): %s\n",i,i,block_sec,rc,rfid_hexdump(buf,rc)); + else{ + printf("no data(read_block(%d)>> %d)\n",i,rc); + if ((sector == -1)||(sector == -3)) + break; + } + } + }else{ + if (sector>255) + sector=255; + rc = iso15693_read_block(l2h,sector,buf,sizeof(buf)); + if (rc>=0) + printf("block[%d]data(%d): %s\n",i,rc,rfid_hexdump(buf,rc)); + else + printf("no data(read_block(%d)>> %d)\n",i,rc); + } + } else { + printf("error during layer2_open\n"); + return ; + } + rfid_layer2_close(l2h); + rfid_layer2_fini(l2h); + } +} + static char *proto_names[] = { [RFID_PROTOCOL_TCL] = "tcl", [RFID_PROTOCOL_MIFARE_UL] = "mifare-ultralight", [RFID_PROTOCOL_MIFARE_CLASSIC] = "mifare-classic", + [RFID_PROTOCOL_ICODE_SLI] = "icode", + [RFID_PROTOCOL_TAGIT] = "tagit", }; static int proto_by_name(const char *name) @@ -315,6 +395,7 @@ static char *l2_names[] = { [RFID_LAYER2_ISO14443A] = "iso14443a", [RFID_LAYER2_ISO14443B] = "iso14443b", [RFID_LAYER2_ISO15693] = "iso15693", + [RFID_LAYER2_ICODE1] = "icode1", }; static int l2_by_name(const char *name) @@ -330,9 +411,28 @@ static int l2_by_name(const char *name) return -1; } -static void do_scan(void) +static int do_scan(int first) { int rc; + unsigned int size; + unsigned int size_len = sizeof(size); + char *data; + unsigned int data_len; + + if (first) { + unsigned int opt; + unsigned int optlen = sizeof(opt); + + /* turn off RF */ + opt = 1; + rfid_reader_setopt(rh, RFID_OPT_RDR_RF_KILL, &opt, optlen); + + usleep(10*1000); + + /* turn on RF */ + opt = 0; + rfid_reader_setopt(rh, RFID_OPT_RDR_RF_KILL, &opt, optlen); + } printf("scanning for RFID token...\n"); rc = rfid_scan(rh, &l2h, &ph); if (rc >= 2) { @@ -345,54 +445,346 @@ static void do_scan(void) } if (rc >= 3) { printf("Protocol success (%s)\n", rfid_protocol_name(ph)); + + if (rfid_protocol_getopt(ph, RFID_OPT_PROTO_SIZE, + &size, &size_len) == 0) + printf("Size: %u bytes\n", size); + size_len = sizeof(size); + size = 0; + if (rfid_protocol_getopt(ph, RFID_OPT_P_TCL_ATS_LEN, + &size, &size_len) == 0) { + data_len = size + 1; + data = malloc(data_len); + if (data) { + if (rfid_protocol_getopt(ph, RFID_OPT_P_TCL_ATS, + data, &data_len) == 0) { + printf("Got ATS of %u bytes: %s\n", size, + hexdump(data, data_len)); + } + } + } } + + return rc; } -static void help(void) +static void do_endless_scan() { - printf( " -s --scan\n" - " -p --protocol {tcl,mifare-ultralight,mifare-classic}\n" - " -l --layer2 {iso14443a,iso14443b,iso15693}\n" - " -h --help\n"); + int rc; + int first = 1; + + while (1) { + if (first) + putc('\n', stdout); + printf("==> doing %s scan\n", first ? "first" : "successive"); + rc = do_scan(first); + if (rc >= 3) { + printf("closing proto\n"); + rfid_protocol_close(ph); + } + if (rc >= 2) { + printf("closing layer2\n"); + rfid_layer2_close(l2h); + first = 0; + } else + first = 1; + } } -static struct option opts[] = { +static void do_regdump(void) +{ + u_int8_t buffer[0xff]; + int i; + + printf("dumping rc632 regs...\n"); + + rc632_register_dump(rh->ah, buffer); + + printf("\n "); + for (i=0; i<=0x0f; i++) + printf(" 0x_%01X",i); + printf("\n-----------------------------------------------------------------------------------\n"); + + for (i=0; i <= 0x3f; i++) { + if ((i % 0x10) == 0) + printf("0x%01X_:",i/0x10); + printf(" 0x%02X", buffer[i]); + if ((i% 0x10) == 0x0f) + printf("\n"); + } + + /* print regdump as c-style array*/ + printf("u_int8_t rc632_regs[] = {"); + for (i = 0; i <= 0x3f; i++) { + if (((i+1) % 0x08) == 1) { + if (i > 7) + printf("//%2d..%2d",i-8,i-1); + printf("\n\t"); + } + printf(" 0x%02X, ",buffer[i]); + } + printf("//%2d..%2d\n\t 0 };\n",i-8,i-1); + +} + +static void do_enum(int layer2) +{ + int rc; + //unsigned int size; + //unsigned int size_len = sizeof(size); + unsigned char uid_buf[16]; + unsigned int uid_len; + + printf("scanning for RFID token on layer %s...\n", l2_names[layer2]); + + if (rh->reader->l2_supported & (1 << layer2)) { + l2h = rfid_layer2_init(rh, layer2); + if (!l2h) { + printf("error during layer2(%s)_init\n", + l2_names[layer2]); + return; + } + printf("Layer2 init ok\n"); + rc = rfid_layer2_open(l2h); + } else { + printf("error during layer2_open\n"); + return ; + } + + while (rc>=0) { + if (l2h) { + uid_len = sizeof(uid_buf); + rfid_layer2_getopt(l2h, RFID_OPT_LAYER2_UID, &uid_buf, &uid_len); + printf("Layer 2 success (%s)[%d]: '%s'\n", rfid_layer2_name(l2h), uid_len, hexdump(uid_buf, uid_len)); + } + + /* + ph = rfid_protocol_scan(l2h); + if (ph) { + printf("Protocol success (%s)\n", rfid_protocol_name(ph)); + + if (rfid_protocol_getopt(ph, RFID_OPT_PROTO_SIZE, + &size, &size_len) == 0) + printf("Size: %u bytes\n", size); + } else + printf("##############\n"); + */ + + if (rc >= 0) { + rfid_layer2_close(l2h); + } + rc = rfid_layer2_open(l2h); + } +} + +static void do_enum_loop(int layer2, unsigned int delay) +{ + while (1) { + do_enum(layer2); + { + unsigned int opt; + unsigned int optlen = sizeof(opt); + + /* turn off RF */ + opt = 1; + rfid_reader_setopt(rh, RFID_OPT_RDR_RF_KILL, &opt, optlen); + + usleep(10 * 1000); + + /* turn on RF */ + opt = 0; + rfid_reader_setopt(rh, RFID_OPT_RDR_RF_KILL, &opt, optlen); + } + usleep(delay * 1000); + printf("--- next run ---\n"); + } +} + +#define OPTION_OFFSET 256 + +static struct option original_opts[] = { { "help", 0, 0, 'h' }, { "layer2", 1, 0, 'l' }, { "protocol", 1, 0, 'p' }, + { "scan", 0, 0, 's' }, + { "scan-loop", 0, 0, 'S' }, + { "dump", 0, 0, 'd' }, + { "enum", 0, 0, 'e' }, + { "read", 1, 0, 'r' }, + { "write", 1, 0, 'w'}, + { "enum-loop", 1, 0, 'E' }, {0, 0, 0, 0} }; +/* module / option merging code */ +static struct option *opts = original_opts; +static unsigned int global_option_offset = 0; + +static char *program_name; +static char *program_version = LIBRFID_TOOL_VERSION; + +static void free_opts(int reset_offset) +{ + if (opts != original_opts) { + free(opts); + opts = original_opts; + if (reset_offset) + global_option_offset = 0; + } +} + +static struct option * +merge_options(struct option *oldopts, const struct option *newopts, + unsigned int *option_offset) +{ + unsigned int num_old, num_new, i; + struct option *merge; + + for (num_old = 0; oldopts[num_old].name; num_old++); + for (num_new = 0; oldopts[num_new].name; num_new++); + + global_option_offset += OPTION_OFFSET; + *option_offset = global_option_offset; + + merge = malloc(sizeof(struct option) * (num_new + num_old + 1)); + memcpy(merge, oldopts, num_old * sizeof(struct option)); + free_opts(0); /* Release previous options merged if any */ + for (i = 0; i < num_new; i++) { + merge[num_old + i] = newopts[i]; + merge[num_old + i].val += *option_offset; + } + memset(merge + num_old + num_new, 0, sizeof(struct option)); + + return merge; +} + +struct rfidtool_module *find_module(const char *name) +{ + return NULL; +} + +void register_module(struct rfidtool_module *me) +{ + struct rfidtool_module *old; + + if (strcmp(me->version, program_version) != 0) { + fprintf(stderr, "%s: target `%s' v%s (I'm v%s).\n", + program_name, me->name, me->version, program_version); + exit(1); + } + + old = find_module(me->name); + if (old) { + fprintf(stderr, "%s: target `%s' already registered.\n", + program_name, me->name); + exit(1); + } +} + +static void help(void) +{ + printf( " -s --scan scan until first RFID tag is found\n" + " -S --scan-loop endless scanning loop\n" + " -p --protocol {tcl,mifare-ultralight,mifare-classic,tagit,icode}\n" + " -l --layer2 {iso14443a,iso14443b,iso15693,icode1}\n" + " -d --dump dump rc632 registers\n" + " -e --enum enumerate all tag's in field \n" + " -E --enum-loop (ms) enumerate endless\n" + " -r --read read iso15693 sector \n\t\t\t(-1:0-255 stop on error, -2: 0-255 no stop)\n" + " -w --write write to iso15693 sector data: 01:02:03:04\n" + " -h --help\n"); +} + int main(int argc, char **argv) { int rc; - char buf[0x40]; - int i, protocol = -1, layer2 = -1; - - printf("librfid_tool - (C) 2006 by Harald Welte\n" + char buf[0x100]; + int i, len, protocol = -1, layer2 = -1; + +#ifdef __MINGW32__ + program_name = argv[0]; +#else /*__MINGW32__*/ + program_name = basename(argv[0]); +#endif/*__MINGW32__*/ + + printf("%s - (C) 2005-2008 by Harald Welte\n" "This program is Free Software and has " - "ABSOLUTELY NO WARRANTY\n\n"); + "ABSOLUTELY NO WARRANTY\n\n", program_name); printf("initializing librfid\n"); rfid_init(); while (1) { int c, option_index = 0; - c = getopt_long(argc, argv, "hp:l:s", opts, &option_index); + c = getopt_long(argc, argv, "hp:l:sSdeE:r:w:", opts, &option_index); if (c == -1) break; switch (c) { + case 'w': + //hexread(key, optarg, strlen(optarg)); + i = strtol(optarg, NULL, 10); + if (reader_init() < 0) + exit(1); + layer2 = RFID_LAYER2_ISO15693; + iso15693_write(rh,layer2,i,"\x1\x2\x3\x4",4); + rfid_reader_close(rh); + exit(0); + break; + case 'r': + i = strtol(optarg, NULL, 10); + if (reader_init() < 0) + exit(1); + //if (layer2 < 0) + layer2 = RFID_LAYER2_ISO15693; + iso15693_dump(rh,layer2,i); + rfid_reader_close(rh); + exit(0); + break; + case 'E': + i = strtol(optarg, NULL, 10); + + if (reader_init() < 0) + exit(1); + if (layer2<0) + layer2 = RFID_LAYER2_ISO14443A; + + do_enum_loop(layer2, i>1? i : 500); + rfid_reader_close(rh); + exit(0); + break; + case 'e': + if (reader_init() < 0) + exit(1); + if (layer2 < 0) + layer2 = RFID_LAYER2_ISO14443A; + do_enum(layer2); + rfid_reader_close(rh); + exit(0); + break; + case 'd': + if (reader_init() < 0) + exit(1); + do_regdump(); + rfid_reader_close(rh); + break; case 's': - if (reader() < 0) + if (reader_init() < 0) exit(1); - do_scan(); + do_scan(0); + rfid_reader_close(rh); + exit(0); + break; + case 'S': + if (reader_init() < 0) + exit(1); + do_endless_scan(); exit(0); break; case 'p': protocol = proto_by_name(optarg); if (protocol < 0) { - fprintf(stderr, "unknown protocol `%s'\n", + fprintf(stderr, "unknown protocol `%s'\n", optarg); exit(2); } @@ -405,10 +797,14 @@ int main(int argc, char **argv) exit(2); } break; + default: + printf("unknown cmd: %c\n",c); case 'h': help(); exit(0); break; + case '?': + exit(0); } } @@ -426,19 +822,22 @@ int main(int argc, char **argv) fprintf(stderr, "you have to specify --layer2\n"); exit(2); } - - if (reader() < 0) + + if (reader_init() < 0) exit(1); - if (init(layer2) < 0) + + if (l2_init(layer2) < 0) { + rfid_reader_close(rh); exit(1); + } - if (l3(protocol) < 0) + if (l3_init(protocol) < 0) { + rfid_reader_close(rh); exit(1); + } switch (protocol) { - char buf[32000]; - int len = 200; case RFID_PROTOCOL_TCL: printf("Protocol T=CL\n"); @@ -480,7 +879,7 @@ int main(int argc, char **argv) while (1) { printf("reading EF1\n"); - len = 200; + len = sizeof(buf); printf("reading ef\n"); rc = iso7816_read_binary(buf, &len); if (rc < 0) { @@ -504,32 +903,15 @@ int main(int argc, char **argv) break; case RFID_PROTOCOL_MIFARE_CLASSIC: printf("Protocol Mifare Classic\n"); - { - int sector; - for (sector = 1; sector < 31; sector++) { - rc = mfcl_set_key(ph, MIFARE_CL_KEYA_DEFAULT_INFINEON); - if (rc < 0) { - printf("key format error\n"); - exit(1); - } - rc = mfcl_auth(ph, RFID_CMD_MIFARE_AUTH1A, sector*4); - if (rc < 0) { - printf("mifare auth error\n"); - exit(1); - } else - printf("mifare authe succeeded!\n"); - - mifare_classic_read_sector(ph, sector); - } - } + mifare_classic_dump(ph); break; default: - printf("unknown protocol\n"); + printf("unknown protocol %u\n", protocol); exit(1); break; } rfid_reader_close(rh); - + exit(0); }