249 lines
6.2 KiB
C
249 lines
6.2 KiB
C
/* mifare-tool - a small command-line tool for librfid mifare testing
|
|
*
|
|
* (C) 2006 by Harald Welte <laforge@gnumonks.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* 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,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#ifndef __MINGW32__
|
|
#include <libgen.h>
|
|
#endif
|
|
|
|
#define _GNU_SOURCE
|
|
#include <getopt.h>
|
|
|
|
#include <librfid/rfid.h>
|
|
#include <librfid/rfid_scan.h>
|
|
#include <librfid/rfid_reader.h>
|
|
#include <librfid/rfid_layer2.h>
|
|
#include <librfid/rfid_protocol.h>
|
|
|
|
#include <librfid/rfid_protocol_mifare_classic.h>
|
|
#include <librfid/rfid_protocol_mifare_ul.h>
|
|
|
|
#include <librfid/rfid_access_mifare_classic.h>
|
|
|
|
#include "librfid-tool.h"
|
|
|
|
static char *program_name;
|
|
|
|
static void help(void)
|
|
{
|
|
printf( " -h --help Print this help message\n"
|
|
" -r --read Read a mifare sector\n"
|
|
" -l --loop-read Loop reading a mifare sector\n"
|
|
" -w --write Write a mifare sector\n"
|
|
" -k --key Specify mifare access key (in hex tuples)\n"
|
|
" -b --brute-force n Brute Force read sector n\n");
|
|
}
|
|
|
|
static struct option mifare_opts[] = {
|
|
{ "key", 1, 0, 'k' },
|
|
{ "read", 1, 0, 'r' },
|
|
{ "loop-read", 1, 0, 'l' },
|
|
{ "write", 1 ,0, 'w' },
|
|
{ "help", 0, 0, 'h' },
|
|
{ "brute-force", 1, 0, 'b' },
|
|
{ 0, 0, 0, 0 }
|
|
};
|
|
|
|
static int mifare_cl_auth(unsigned char *key, int page)
|
|
{
|
|
int rc;
|
|
|
|
rc = mfcl_set_key(ph, key);
|
|
if (rc < 0) {
|
|
fprintf(stderr, "key format error\n");
|
|
return rc;
|
|
}
|
|
rc = mfcl_auth(ph, RFID_CMD_MIFARE_AUTH1A, page);
|
|
if (rc < 0) {
|
|
fprintf(stderr, "mifare auth error\n");
|
|
return rc;
|
|
} else
|
|
printf("mifare auth succeeded!\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void mifare_l3(void)
|
|
{
|
|
while (l2_init(RFID_LAYER2_ISO14443A) < 0) ;
|
|
|
|
printf("ISO14443-3A anticollision succeeded\n");
|
|
|
|
while (l3_init(RFID_PROTOCOL_MIFARE_CLASSIC) < 0) ;
|
|
|
|
printf("Mifare card available\n");
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int len, rc, c, option_index = 0;
|
|
unsigned int page,uid,uid_len;
|
|
char key[MIFARE_CL_KEY_LEN];
|
|
char buf[MIFARE_CL_PAGE_SIZE];
|
|
|
|
#ifdef __MINGW32__
|
|
program_name = argv[0];
|
|
#else
|
|
program_name = basename(argv[0]);
|
|
#endif/*__MINGW32__*/
|
|
|
|
memcpy(key, MIFARE_CL_KEYA_DEFAULT_INFINEON, MIFARE_CL_KEY_LEN);
|
|
|
|
printf("%s - (C) 2006 by Harald Welte\n"
|
|
"This program is Free Software and has "
|
|
"ABSOLUTELY NO WARRANTY\n\n", program_name);
|
|
|
|
printf("initializing librfid\n");
|
|
rfid_init();
|
|
|
|
if (reader_init() < 0) {
|
|
fprintf(stderr, "error opening reader\n");
|
|
exit(1);
|
|
}
|
|
|
|
while (1) {
|
|
c = getopt_long(argc, argv, "k:r:l:w:b:h", mifare_opts,
|
|
&option_index);
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c) {
|
|
int i;
|
|
case 'b':
|
|
page = atoi(optarg);
|
|
printf("key: %s\n", hexdump(key, MIFARE_CL_KEY_LEN));
|
|
len = MIFARE_CL_PAGE_SIZE;
|
|
mifare_l3();
|
|
for (i = 0; i <= 0xff; i++) {
|
|
key[MIFARE_CL_KEY_LEN-1]=i;
|
|
if (mifare_cl_auth(key, page) >= 0)
|
|
printf("KEY: %s\n",hexdump(key, MIFARE_CL_KEY_LEN));
|
|
}
|
|
|
|
break;
|
|
case 'k':
|
|
hexread(key, optarg, strlen(optarg));
|
|
printf("key: %s\n", hexdump(key, MIFARE_CL_KEY_LEN));
|
|
break;
|
|
case 'r':
|
|
page = atoi(optarg);
|
|
printf("read(key='%s',page=%u):",
|
|
hexdump(key, MIFARE_CL_KEY_LEN), page);
|
|
len = MIFARE_CL_PAGE_SIZE;
|
|
mifare_l3();
|
|
if (mifare_cl_auth(key, page) < 0)
|
|
exit(1);
|
|
|
|
uid_len=sizeof(uid);
|
|
uid=0;
|
|
if(rfid_layer2_getopt(l2h,RFID_OPT_LAYER2_UID,&uid,&uid_len)>=0)
|
|
printf("UID=%08X (len=%u)\n",uid,uid_len);
|
|
|
|
len=MIFARE_CL_PAGE_SIZE;
|
|
rc = rfid_protocol_read(ph, page, buf, &len);
|
|
if (rc < 0) {
|
|
printf("\n");
|
|
fprintf(stderr, "error during read\n");
|
|
break;
|
|
}
|
|
printf("len=%u data=%s\n", len, hexdump(buf, len));
|
|
|
|
if (page & 0x3 == 0x3) {
|
|
struct mfcl_access_sect s;
|
|
struct mfcl_access_exp_sect es;
|
|
int b;
|
|
u_int8_t recreated[4];
|
|
mfcl_parse_access(&s, buf+6);
|
|
printf("access b0:%u b1:%u b2:%u b3:%u\n",
|
|
s.block[0], s.block[1],
|
|
s.block[2], s.block[3]);
|
|
mfcl_access_to_exp(&es, &s);
|
|
for (b = 0; b < 3; b++)
|
|
printf("%u: %s\n", b, mfcl_access_exp_stringify(&es.block[b]));
|
|
printf("3: %s\n", mfcl_access_exp_acc_stringify(&es.acc));
|
|
#if 0
|
|
mfcl_compile_access(recreated, &s);
|
|
printf("recreated; %s\n", hexdump(recreated,4));
|
|
#endif
|
|
}
|
|
break;
|
|
case 'l':
|
|
page = atoi(optarg);
|
|
printf("read_loop(key='%s',page=%u):\n",
|
|
hexdump(key, MIFARE_CL_KEY_LEN), page);
|
|
while (1) {
|
|
mifare_l3();
|
|
if (mifare_cl_auth(key, page) < 0)
|
|
continue;
|
|
|
|
uid_len=sizeof(uid);
|
|
uid=0;
|
|
if(rfid_layer2_getopt(l2h,RFID_OPT_LAYER2_UID,&uid,&uid_len)>=0)
|
|
printf("UID=%08X (len=%u)\n",uid,uid_len);
|
|
|
|
len=MIFARE_CL_PAGE_SIZE;
|
|
rc = rfid_protocol_read(ph, page, buf, &len);
|
|
if (rc < 0) {
|
|
printf("\n");
|
|
fprintf(stderr, "error during read\n");
|
|
continue;
|
|
}
|
|
printf("%s\n", hexdump(buf, len));
|
|
}
|
|
break;
|
|
case 'w':
|
|
page = atoi(optarg);
|
|
len = strlen(argv[optind]);
|
|
len = hexread(buf, argv[optind], len);
|
|
printf("write(key='%s',page=%u):",
|
|
hexdump(key, MIFARE_CL_KEY_LEN), page);
|
|
printf(" '%s'(%u):", hexdump(buf, len), len);
|
|
mifare_l3();
|
|
if (mifare_cl_auth(key, page) < 0)
|
|
exit(1);
|
|
rc = rfid_protocol_write(ph, page, buf, len);
|
|
if (rc < 0) {
|
|
printf("\n");
|
|
fprintf(stderr, "error during write\n");
|
|
break;
|
|
}
|
|
printf("success\n");
|
|
break;
|
|
case 'h':
|
|
default:
|
|
help();
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
rfid_protocol_close(ph);
|
|
rfid_protocol_fini(ph);
|
|
|
|
rfid_layer2_close(l2h);
|
|
rfid_layer2_fini(l2h);
|
|
#endif
|
|
rfid_reader_close(rh);
|
|
exit(0);
|
|
}
|
|
|