crewID/libnfc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

moving win32 binaries

Browse source
This commit is contained in:
Roel Verdult 2009-04-29 12:47:41 +00:00
parent 767cf2b324
commit bbae6dcee5
27 changed files with 1550 additions and 1310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
README.TXT
View file

@ -2,145 +2,23 @@
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
------------------------------------------------------------------------
Welcome to the developers community of libnfc.
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.
Since it is hard to keep all information up to date
we decided to only maintain the online documentation.
Please visit the official website for more info:
http://www.libnfc.org
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
If you have questions, remarks, bug-reports, we encourage you to
post this in the developers community:
http://www.libnfc.org/community
------------------------------------------------------------------------
Welcome to the community of libnfc (website: http://www.libnfc.org).
Proprietary Notes:
libnfc version 1.0.0
Index:
1. Introduction
2. Hardware
3. Compilation
4. Examples
5. Todo
6. Contact
------------------------------------------------------------------------
1. Introduction
Since the RFID market is spoiled by proprietary hard and software
we want to contribute constructively by distributing a free library
which can be used in RFID/NFC applications.
------------------------------------------------------------------------
2. Hardware
To communicate with NFC targets/tags you need a USB device which is
called a "RFID Reader". The cheapest hardware around that can carries
a fully NFC complied chip is the ACR122 from the company ACS, Advanced
Card Systems Limited (website: http://www.acs.com.hk/acr122.php).
This reader uses the PN532 chipset from NXP Semiconductors. The reader
costs around the €60 and is available in different webshops all over
the world. The NFC reader used in the "tikitag" project is exactly the
same reader as the ACR122 but with a different logo. This reader is
available for only €35,- (website: http://www.tikitag.com). We would
recommend to use one of these readers, since we tested both of them.
Other NFC readers, like the SCL3710 from SCM Microsystems (website:
http://www.scmmicro.com/scl3710/) are not supported yet. They use the
same chipset, so the instruction set is completely the same. This means
that with little effort these readers could be added to be part of the
NFC library. We would be very pleased if someone is willing to add this
support to libnfc.
------------------------------------------------------------------------
3. Compilation
If you use linux, please make sure you have libpcsc-lite installed.
For Ubuntu this means you have to install the following packages:
$sudo apt-get install pcscd
$sudo apt-get install libpcsclite-dev
When these are installed, just run "make" and you are ready to go.
MacOSX users have to edit the "Makefile" file in the main directory.
Uncomment the following lines:
#LIB_TYPE=...
#LIB_FLAGS=...
#PCSC_HEADERS=...
#PCSC_LIB=...
Run "make" and you it should work like a charm.
Windows users can use the binairy files located in the "win32bin"
directory. Or they can open the VS2005 solution which can be found
in the "win32" directory. Compilation should work "out of the box".
------------------------------------------------------------------------
4. Examples
There are 6 example tools coming with this library. They can be used
as a reference during development of your software. All tools try to
demonstrate a different feature. Below there is short description of
the tools and their purpose.
anticol - Anti-collision demonstration tool for ISO14443A tags using
self constructed REQA/WUPA and SELECT frames.
list - List passive tags tool for ISO14443A tags using the commands
available in the instruction set of the hardware chip.
simulate - With this example you can turn your reader into a NFC target.
For testing purposes it simulates a ISO14443A tag with a UID
that consists of 0xDEADBEAF. The frames are delayed because
of the USB communication, so not all readers will recognize
the tag. The "Omnikey 5121" though has no problems with this
small delay.
relay - This tool allows the user to use 2 readers. One will similate
a ISO14443A tag, while the 2nd reader will stay a reader.
The original tag can be placed on the 2nd reader and the
simulated tag can be placed on top of the original reader.
All communication is relayed now and showed on the screen.
NOTE: relaying frames is time-consuming, not all readers
allow slow responds from the (simulated) tag. Though, one of
the most used RFID readers, the "Omnikey 5121" has no problem
and can perfectly be used for demonstrating this features.
mfread - With this tool a complete MIFARE card can be readout and stored
in a MIFARE dump file (*.mfd).
mfwrite - With this tool a complete MIFARE card can be restored from a
a MIFARE dump file (*.mfd) back to the tag.
A MIFARE dump file (*.mfd) is a plain 4KB image of a mifare tag. This
image should contain the data, keys and access bits on their usual position.
A Dump file is always 4KB, even when a 1KB tag is dumped. From the first
block, the manufacturer data, can be determined if you are dealing with
a 1KB or a 4KB tag. This is stored in the ATQA part of block0 (byte 6/7).
More info can be found in the MIFARE functional specification from NXP.
(Website: http://www.nxp.com/products/identification/mifare/classic)
------------------------------------------------------------------------
5. Todo
Support more communication protocols. Sony Felica, ISO14443B and Innovision
Jewel Topaz tags are supported by the chipset, but they are not used by
this library. It would be very useful if we could add support for these
tags in this library.
------------------------------------------------------------------------
6. Contact
Please visit the website (http://www.libnfc.org) and place your questions
in the community forum there. We are sure a member of the community will
help you out.
------------------------------------------------------------------------
Proprietary notes:
Note: FeliCa is s registered trademark of Sony Corporation. MIFARE is a
FeliCa is s registered trademark of Sony Corporation. MIFARE is a
trademark of NXP Semiconductors. Jewel Topaz is a trademark of Innovision
Research & Technology. All other trademarks are the property of their
respective owners.

292
anticol.c
View file

@ -1,142 +1,150 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libnfc.h"
static byte abtRecv[MAX_FRAME_LEN];
static ui32 uiRecvLen;
static byte abtUid[10];
static ui32 uiUidLen = 4;
static dev_id di;
// ISO14443A Anti-Collision Commands
byte abtWupa [1] = { 0x52 };
byte abtSelectAll [2] = { 0x93,0x20 };
byte abtSelectTag [9] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
byte abtRats [4] = { 0xe0,0x50,0xbc,0xa5 };
byte abtHalt [4] = { 0x50,0x00,0x57,0xcd };
bool transmit_7bits(const byte btTx)
{
bool bResult;
printf("R: %02x\n",btTx);
uiRecvLen = MAX_FRAME_LEN;
bResult = nfc_reader_transceive_7bits(di,btTx,abtRecv,&uiRecvLen);
if (bResult)
{
printf("T: ");
print_hex(abtRecv,uiRecvLen);
}
return bResult;
}
bool transmit_bytes(const byte* pbtTx, const ui32 uiTxLen)
{
bool bResult;
printf("R: ");
print_hex(pbtTx,uiTxLen);
uiRecvLen = MAX_FRAME_LEN;
bResult = nfc_reader_transceive_bytes(di,pbtTx,uiTxLen,abtRecv,&uiRecvLen);
if (bResult)
{
printf("T: ");
print_hex(abtRecv,uiRecvLen);
}
return bResult;
}
int main(int argc, const char* argv[])
{
// Try to open the NFC reader
di = acr122_connect(0);
if (di == INVALID_DEVICE_ID)
{
printf("Error connecting NFC reader\n");
return 1;
}
nfc_reader_init(di);
// Let the reader only try once to find a tag
nfc_configure_list_passive_infinite(di,false);
// Drop the field so the tag will be reset
nfc_configure_field(di,false);
// Configure the communication channel, we use our own CRC
nfc_configure_handle_crc(di,false);
nfc_configure_handle_parity(di,true);
// Enable the field so the more power consuming tags will respond
nfc_configure_field(di,true);
printf("\nConnected to NFC reader\n\n");
if (!transmit_7bits(*abtWupa))
{
printf("Error: No tag available\n");
return 1;
}
// Anti-collision
transmit_bytes(abtSelectAll,2);
// Save the UID
memcpy(abtUid,abtRecv,4);
memcpy(abtSelectTag+2,abtRecv,5);
append_iso14443a_crc(abtSelectTag,7);
transmit_bytes(abtSelectTag,9);
if (abtUid[0] == 0x88)
{
abtSelectAll[0] = 0x95;
abtSelectTag[0] = 0x95;
// Anti-collision
transmit_bytes(abtSelectAll,2);
// Save the UID
memcpy(abtUid+4,abtRecv,4);
memcpy(abtSelectTag+2,abtRecv,5);
append_iso14443a_crc(abtSelectTag,7);
transmit_bytes(abtSelectTag,9);
uiUidLen = 7;
}
// Request ATS, this only applies to tags that support ISO 14443A-4
if (abtRecv[0] & 0x20)
{
transmit_bytes(abtRats,4);
}
// Done, halt the tag now
transmit_bytes(abtHalt,4);
printf("\nFound tag with UID: ");
if (uiUidLen == 4)
{
printf("%08x\n",swap_endian32(abtUid));
} else {
printf("%014llx\n",swap_endian64(abtUid)&0x00ffffffffffffffull);
}
return 0;
}
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libnfc.h"
#define SAK_FLAG_ATS_SUPPORTED 0x20
static byte abtRx[MAX_FRAME_LEN];
static ui32 uiRxBits;
static ui32 uiRxLen;
static byte abtUid[10];
static ui32 uiUidLen = 4;
static dev_info* pdi;
// ISO14443A Anti-Collision Commands
byte abtReqa [1] = { 0x26 };
byte abtSelectAll [2] = { 0x93,0x20 };
byte abtSelectTag [9] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
byte abtRats [4] = { 0xe0,0x50,0xbc,0xa5 };
byte abtHalt [4] = { 0x50,0x00,0x57,0xcd };
bool transmit_bits(const byte* pbtTx, const ui32 uiTxBits)
{
// Show transmitted command
printf("R: "); print_hex_bits(pbtTx,uiTxBits);
// Transmit the bit frame command, we don't use the arbitrary parity feature
if (!nfc_reader_transceive_bits(pdi,pbtTx,uiTxBits,null,abtRx,&uiRxBits,null)) return false;
// Show received answer
printf("T: "); print_hex_bits(abtRx,uiRxBits);
// Succesful transfer
return true;
}
bool transmit_bytes(const byte* pbtTx, const ui32 uiTxLen)
{
// Show transmitted command
printf("R: "); print_hex(pbtTx,uiTxLen);
// Transmit the command bytes
if (!nfc_reader_transceive_bytes(pdi,pbtTx,uiTxLen,abtRx,&uiRxLen)) return false;
// Show received answer
printf("T: "); print_hex(abtRx,uiRxLen);
// Succesful transfer
return true;
}
int main(int argc, const char* argv[])
{
// Try to open the NFC reader
pdi = nfc_connect();
if (!pdi)
{
printf("Error connecting NFC reader\n");
return 1;
}
nfc_reader_init(pdi);
// Drop the field for a while
nfc_configure(pdi,DCO_ACTIVATE_FIELD,false);
// Configure the CRC and Parity settings
nfc_configure(pdi,DCO_HANDLE_CRC,false);
nfc_configure(pdi,DCO_HANDLE_PARITY,true);
// Enable field so more power consuming cards can power themselves up
nfc_configure(pdi,DCO_ACTIVATE_FIELD,true);
printf("\nConnected to NFC reader: %s\n\n",pdi->acName);
// Send the 7 bits request command specified in ISO 14443A (0x26)
if (!transmit_bits(abtReqa,7))
{
printf("Error: No tag available\n");
nfc_disconnect(pdi);
return 1;
}
// Anti-collision
transmit_bytes(abtSelectAll,2);
// Save the UID
memcpy(abtUid,abtRx,4);
memcpy(abtSelectTag+2,abtRx,5);
append_iso14443a_crc(abtSelectTag,7);
transmit_bytes(abtSelectTag,9);
// Test if we are dealing with a 4 bytes uid
if (abtUid[0]!= 0x88)
{
uiUidLen = 4;
} else {
// We have to do the anti-collision for cascade level 2
abtSelectAll[0] = 0x95;
abtSelectTag[0] = 0x95;
// Anti-collision
transmit_bytes(abtSelectAll,2);
// Save the UID
memcpy(abtUid+4,abtRx,4);
memcpy(abtSelectTag+2,abtRx,5);
append_iso14443a_crc(abtSelectTag,7);
transmit_bytes(abtSelectTag,9);
uiUidLen = 7;
}
// Request ATS, this only applies to tags that support ISO 14443A-4
if (abtRx[0] & SAK_FLAG_ATS_SUPPORTED) transmit_bytes(abtRats,4);
// Done, halt the tag now
transmit_bytes(abtHalt,4);
printf("\nFound tag with UID: ");
if (uiUidLen == 4)
{
printf("%08x\n",swap_endian32(abtUid));
} else {
printf("%014llx\n",swap_endian64(abtUid)&0x00ffffffffffffffull);
}
nfc_disconnect(pdi);
return 0;
}

68
bitutils.c
View file

@ -1,23 +1,23 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include "bitutils.h"
@ -116,7 +116,7 @@ ui32 swap_endian32(const void* pui32)
ui64 swap_endian64(const void* pui64)
{
ui64 ui64N = *((ui64*)pui64);
return (((ui64N&0xFF)<<56)+((ui64N&0xFF00)<<40)+((ui64N&0xFF0000)<<24)+((ui64N&0xFF000000)<<8)+((ui64N&0xFF00000000)>>8)+((ui64N&0xFF0000000000)>>24)+((ui64N&0xFF000000000000)>>40)+((ui64N&0xFF00000000000000)>>56));
return (((ui64N&0xFF)<<56)+((ui64N&0xFF00)<<40)+((ui64N&0xFF0000)<<24)+((ui64N&0xFF000000)<<8)+((ui64N&0xFF00000000ull)>>8)+((ui64N&0xFF0000000000ull)>>24)+((ui64N&0xFF000000000000ull)>>40)+((ui64N&0xFF00000000000000ull)>>56));
}
void append_iso14443a_crc(byte* pbtData, ui32 uiLen)
@ -135,16 +135,33 @@ void append_iso14443a_crc(byte* pbtData, ui32 uiLen)
*pbtData = (byte) ((wCrc >> 8) & 0xFF);
}
void print_hex(const byte* pbtData, const ui32 uiLen)
void print_hex(const byte* pbtData, const ui32 uiBytes)
{
ui32 uiPos;
for (uiPos=0; uiPos < uiLen; uiPos++)
for (uiPos=0; uiPos < uiBytes; uiPos++)
{
printf("%02x ",pbtData[uiPos]);
}
printf("\n");
}
void print_hex_bits(const byte* pbtData, const ui32 uiBits)
{
ui32 uiPos;
ui32 uiBytes = uiBits/8;
for (uiPos=0; uiPos < uiBytes; uiPos++)
{
printf("%02x ",pbtData[uiPos]);
}
// Print the rest bits, these cannot have no parity bit
if (uiBits%8 != 0) printf("%02x",pbtData[uiBytes]);
printf("\n");
}
void print_hex_par(const byte* pbtData, const ui32 uiBits, const byte* pbtDataPar)
{
ui32 uiPos;
@ -162,10 +179,7 @@ void print_hex_par(const byte* pbtData, const ui32 uiBits, const byte* pbtDataPa
}
// Print the rest bits, these cannot have no parity bit
if (uiBits%8 != 0)
{
printf("%02x",pbtData[uiBytes]);
}
if (uiBits%8 != 0) printf("%02x",pbtData[uiBytes]);
printf("\n");
}

59
bitutils.h
View file

@ -1,46 +1,28 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LIBNFC_BITUTILS_H_
#define _LIBNFC_BITUTILS_H_
#include "defines.h"
#define INNER_XOR8(n) {\
n ^= (n >> 4); \
n ^= (n >> 2); \
n ^= (n >> 1); \
n &= 0x01; \
}
#define INNER_XOR32(n) {\
n ^= (n >> 16); \
n ^= (n >> 8); \
INNER_XOR8(n); \
}
#define INNER_XOR64(n) {\
n ^= (n >> 32); \
INNER_XOR32(n); \
}
byte oddparity(const byte bt);
void oddparity_bytes(const byte* pbtData, const ui32 uiLen, byte* pbtPar);
@ -55,6 +37,7 @@ ui64 swap_endian64(const void* pui64);
void append_iso14443a_crc(byte* pbtData, ui32 uiLen);
void print_hex(const byte* pbtData, const ui32 uiLen);
void print_hex_bits(const byte* pbtData, const ui32 uiBits);
void print_hex_par(const byte* pbtData, const ui32 uiBits, const byte* pbtDataPar);
#endif // _LIBNFC_BITUTILS_H_

57
defines.h
View file

@ -1,26 +1,28 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LIBNFC_DEFINES_H_
#define _LIBNFC_DEFINES_H_
// #define _LIBNFC_VERBOSE_
typedef unsigned char byte;
typedef unsigned char ui8;
typedef unsigned short ui16;
@ -33,13 +35,16 @@ typedef int i32;
#define null 0
typedef void* dev_id; // Device Id
#define INVALID_DEVICE_ID null
typedef void* dev_spec; // Device connection specification
#define INVALID_DEVICE_INFO null
#define MAX_FRAME_LEN 264
#define DEVICE_NAME_LENGTH 256
#define min(a,b) (((a) < (b)) ? (a) : (b))
#define max(a,b) (((a) > (b)) ? (a) : (b))
// #define _LIBNFC_VERBOSE_
// Useful macros
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#define INNER_XOR8(n) {n ^= (n >> 4); n ^= (n >> 2); n ^= (n >> 1); n &= 0x01; }
#define INNER_XOR32(n) {n ^= (n >> 16); n ^= (n >> 8); INNER_XOR8(n); }
#define INNER_XOR64(n) {n ^= (n >> 32); INNER_XOR32(n); }
#endif // _LIBNFC_DEFINES_H_

1285
libnfc.c
View file

File diff suppressed because it is too large Load diff

73
libnfc.h
View file

@ -1,50 +1,47 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LIBNFC_H_
#define _LIBNFC_H_
#include "defines.h"
#include "types.h"
#include "bitutils.h"
#include "acr122.h"
#include "devices.h"
bool nfc_configure_handle_crc(const dev_id di, const bool bEnable);
bool nfc_configure_handle_parity(const dev_id di, const bool bEnable);
bool nfc_configure_field(const dev_id di, const bool bEnable);
bool nfc_configure_list_passive_infinite(const dev_id di, const bool bEnable);
bool nfc_configure_accept_invalid_frames(const dev_id di, const bool bEnable);
bool nfc_configure_accept_multiple_frames(const dev_id di, const bool bEnable);
dev_info* nfc_connect();
void nfc_disconnect(dev_info* pdi);
bool nfc_configure(dev_info* pdi, const dev_config_option dco, const bool bEnable);
bool nfc_reader_init(const dev_id di);
bool nfc_reader_list_passive(const dev_id di, const ModulationType mt, const byte* pbtInitData, const ui32 uiInitDataLen, byte* pbtTag, ui32* puiTagLen);
bool nfc_reader_transceive_7bits(const dev_id di, const byte btTx, byte* pbtRx, ui32* puiRxLen);
bool nfc_reader_transceive_bytes(const dev_id di, const byte* pbtTx, const ui32 uiTxLen, byte* pbtRx, ui32* puiRxLen);
bool nfc_reader_transceive_bits(const dev_id di, const byte* pbtTx, const ui32 uiTxBits, const byte* pbtTxPar, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar);
bool nfc_reader_mifare_cmd(const dev_id di, const MifareCmd mc, const ui8 ui8Block, MifareParam* pmp);
bool nfc_reader_init(const dev_info* pdi);
bool nfc_reader_select(const dev_info* pdi, const init_modulation im, const byte* pbtInitData, const ui32 uiInitDataLen, tag_info* pti);
bool nfc_reader_deselect(const dev_info* pdi);
bool nfc_reader_transceive_bits(const dev_info* pdi, const byte* pbtTx, const ui32 uiTxBits, const byte* pbtTxPar, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar);
bool nfc_reader_transceive_bytes(const dev_info* pdi, const byte* pbtTx, const ui32 uiTxLen, byte* pbtRx, ui32* puiRxLen);
bool nfc_reader_mifare_cmd(const dev_info* pdi, const mifare_cmd mc, const ui8 ui8Block, mifare_param* pmp);
bool nfc_target_init(const dev_id di, byte* pbtRx, ui32* puiRxLen);
bool nfc_target_receive_bytes(const dev_id di, byte* pbtRx, ui32* puiRxLen);
bool nfc_target_receive_bits(const dev_id di, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar);
bool nfc_target_send_bytes(const dev_id di, const byte* pbtTx, const ui32 uiTxLen);
bool nfc_target_send_bits(const dev_id di, const byte* pbtTx, const ui32 uiTxBits, const byte* pbtTxPar);
bool nfc_target_init(const dev_info* pdi, byte* pbtRx, ui32* puiRxBits);
bool nfc_target_receive_bits(const dev_info* pdi, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar);
bool nfc_target_receive_bytes(const dev_info* pdi, byte* pbtRx, ui32* puiRxLen);
bool nfc_target_send_bits(const dev_info* pdi, const byte* pbtTx, const ui32 uiTxBits, const byte* pbtTxPar);
bool nfc_target_send_bytes(const dev_info* pdi, const byte* pbtTx, const ui32 uiTxLen);
#endif // _LIBNFC_H_

85
list.c
View file

@ -23,61 +23,74 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <string.h>
#include "libnfc.h"
static byte abtRecv[MAX_FRAME_LEN];
static ui32 uiRecvLen;
static dev_id di;
static dev_info* pdi;
static byte abtFelica[5] = { 0x00, 0xff, 0xff, 0x00, 0x00 };
int main(int argc, const char* argv[])
{
tag_info ti;
// Try to open the NFC reader
di = acr122_connect(0);
pdi = nfc_connect();
if (di == INVALID_DEVICE_ID)
if (pdi == INVALID_DEVICE_INFO)
{
printf("Error connecting NFC reader\n");
return 1;
}
nfc_reader_init(di);
nfc_reader_init(pdi);
// Drop the field for a while
nfc_configure(pdi,DCO_ACTIVATE_FIELD,false);
// Let the reader only try once to find a tag
nfc_configure_list_passive_infinite(di,false);
nfc_configure(pdi,DCO_INFINITE_SELECT,false);
// Drop the field so the tag will be reset
nfc_configure_field(di,false);
// Configure the CRC and Parity settings
nfc_configure(pdi,DCO_HANDLE_CRC,true);
nfc_configure(pdi,DCO_HANDLE_PARITY,true);
// Configure the communication channel
nfc_configure_handle_crc(di,true);
nfc_configure_handle_parity(di,true);
// Enable field so more power consuming cards can power themselves up
nfc_configure(pdi,DCO_ACTIVATE_FIELD,true);
printf("\nConnected to NFC reader\n\n");
uiRecvLen = MAX_FRAME_LEN;
if (nfc_reader_list_passive(di,MT_ISO14443A_106,null,null,abtRecv,&uiRecvLen))
printf("\nConnected to NFC reader: %s\n\n",pdi->acName);
// Poll for a ISO14443A (MIFARE) tag
if (nfc_reader_select(pdi,IM_ISO14443A_106,null,null,&ti))
{
// ISO14443A tag info = ( tag_count[1], tag_nr[1], ATQA[2], SAK[1], uid_len[1], UID[uid_len], ats_len[1], ATS[ats_len-1] )
// ATS is optional
printf("The following (NFC) ISO14443A tag was found:\n\n");
printf("%17s","ATQA (SENS_RES): ");
print_hex(abtRecv+2,2);
printf("%17s","UID (NFCID1): ");
print_hex(abtRecv+6,abtRecv[5]);
printf("%17s","SAK (SEL_RES): ");
print_hex(abtRecv+4,1);
if (uiRecvLen > 6+(ui32)abtRecv[5])
printf(" ATQA (SENS_RES): "); print_hex(ti.tia.abtAtqa,2);
printf(" UID (NFCID%c): ",(ti.tia.abtUid[0]==0x08?'3':'1')); print_hex(ti.tia.abtUid,ti.tia.uiUidLen);
printf(" SAK (SEL_RES): "); print_hex(&ti.tia.btSak,1);
if (ti.tia.uiAtsLen)
{
printf("%17s","ATS (ATR): ");
print_hex(abtRecv+6+abtRecv[5]+1,abtRecv[6+abtRecv[5]]-1);
printf(" ATS (ATR): ");
print_hex(ti.tia.abtAts,ti.tia.uiAtsLen);
}
} else {
printf("Error: no tag was found\n");
}
// Todo: listing the folllowing tags types
//
// MT_FELICA_212
// MT_FELICA_424
// MT_ISO14443B_106
// MT_TOPAZ_106
// Poll for a Felica tag
if (nfc_reader_select(pdi,IM_FELICA_212,abtFelica,5,&ti) || nfc_reader_select(pdi,IM_FELICA_424,abtFelica,5,&ti))
{
printf("The following (NFC) Felica tag was found:\n\n");
printf("%18s","ID (NFCID2): "); print_hex(ti.tif.abtId,8);
printf("%18s","Parameter (PAD): "); print_hex(ti.tif.abtPad,8);
}
return 0;
// Poll for a ISO14443B tag
if (nfc_reader_select(pdi,IM_ISO14443B_106,null,null,&ti))
{
// No test results yet
printf("iso14443b\n");
}
// Poll for a Jewel tag
if (nfc_reader_select(pdi,IM_JEWEL_106,null,null,&ti))
{
// No test results yet
printf("jewel\n");
}
nfc_disconnect(pdi);
return 1;
}

76
mifaretag.h
View file

@ -1,54 +1,54 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#ifndef _MIFARE_TAG_H_
#define _MIFARE_TAG_H_
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LIBNFC_MIFARE_TAG_H_
#define _LIBNFC_MIFARE_TAG_H_
#include "defines.h"
typedef struct tagBlockManufacturer {
typedef struct {
byte abtUID[4];
byte btBCC;
byte btUnknown;
byte abtATQA[2];
byte abtUnknown[8];
} BlockManufacturer;
} mifare_block_manufacturer;
typedef struct tagBlockData {
byte abtContent[16];
} BlockData;
typedef struct {
byte abtData[16];
} mifare_block_data;
typedef struct tagBlockTrailer {
typedef struct {
byte abtKeyA[6];
byte abtAccessBits[4];
byte abtKeyB[6];
} BlockTrailer;
} mifare_block_trailer;
typedef union tagBlock {
BlockManufacturer bm;
BlockData bd;
BlockTrailer bt;
} Block;
typedef union {
mifare_block_manufacturer mbm;
mifare_block_data mbd;
mifare_block_trailer mbt;
} mifare_block;
typedef struct tagMifareTag {
Block blContent[256];
} MifareTag;
typedef struct {
mifare_block amb[256];
} mifare_tag;
#endif // _MIFARE_TAG_H_
#endif // _LIBNFC_MIFARE_TAG_H_

206
relay.c
View file

@ -1,107 +1,99 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libnfc.h"
static byte abtReaderRecv[MAX_FRAME_LEN];
static byte abtReaderRecvPar[MAX_FRAME_LEN];
static ui32 uiReaderRecvBits;
static byte abtTagRecv[MAX_FRAME_LEN];
static byte abtTagRecvPar[MAX_FRAME_LEN];
static ui32 uiTagRecvBits;
static dev_id diReader;
static dev_id diTag;
int main(int argc, const char* argv[])
{
// Try to open the NFC reader
diReader = acr122_connect(0);
if (diReader == INVALID_DEVICE_ID)
{
printf("Error connecting first NFC reader\n");
return 1;
}
diTag = acr122_connect(1);
if (diTag == INVALID_DEVICE_ID)
{
printf("Error connecting second NFC reader\n");
return 1;
}
printf("\n");
printf("[+] Connected to the both NFC readers\n");
acr122_led_red(diTag,true);
printf("[+] Identified simulated tag by setting the red light\n");
printf("[+] Place both readers on top of each other\n");
printf("[+] Please run 'anticol' tool in a different shell\n");
nfc_target_init(diTag,abtReaderRecv,&uiReaderRecvBits);
nfc_configure_handle_crc(diTag,false);
nfc_configure_handle_parity(diTag,false);
nfc_configure_accept_invalid_frames(diTag,true);
printf("[+] Thank you, the simulated tag is initialized\n");
printf("[+] Attaching to first NFC reader \n");
// Retry until it becomes ready
while (!nfc_reader_init(diReader))
{
acr122_disconnect(diReader);
printf("error\n");
diReader = acr122_connect(0);
}
nfc_configure_handle_crc(diReader,false);
nfc_configure_handle_parity(diReader,false);
nfc_configure_accept_invalid_frames(diReader,true);
printf("[+] Done, relaying frames now!\n\n");
while(true)
{
// Test if we received a frame from the reader
if (nfc_target_receive_bits(diTag,abtReaderRecv,&uiReaderRecvBits,abtReaderRecvPar))
{
// Drop down the field before sending a REQA command and start a new session
if (uiReaderRecvBits == 7 && abtReaderRecv[0] == 0x26)
{
// Drop down field for a very short time (tag will reboot)
nfc_configure_field(diReader,false);
printf("\n");
nfc_configure_field(diReader,true);
}
// Print the reader frame to the screen
printf("R: ");
print_hex_par(abtReaderRecv,uiReaderRecvBits,abtReaderRecvPar);
// Forward the frame to the original tag
if (nfc_reader_transceive_bits(diReader,abtReaderRecv,uiReaderRecvBits,abtReaderRecvPar,abtTagRecv,&uiTagRecvBits,abtTagRecvPar))
{
// Redirect the answer back to the reader
nfc_target_send_bits(diTag,abtTagRecv,uiTagRecvBits,abtTagRecvPar);
// Print the tag frame to the screen
printf("T: ");
print_hex_par(abtTagRecv,uiTagRecvBits,abtTagRecvPar);
}
}
}
}
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libnfc.h"
static byte abtReaderRx[MAX_FRAME_LEN];
static byte abtReaderRxPar[MAX_FRAME_LEN];
static ui32 uiReaderRxBits;
static byte abtTagRx[MAX_FRAME_LEN];
static byte abtTagRxPar[MAX_FRAME_LEN];
static ui32 uiTagRxBits;
static dev_info* pdiReader;
static dev_info* pdiTag;
int main(int argc, const char* argv[])
{
// Try to open the NFC emulator device
pdiTag = nfc_connect();
if (pdiTag == INVALID_DEVICE_INFO)
{
printf("Error connecting NFC emulator device\n");
return 1;
}
printf("\n");
printf("[+] Connected to the NFC emulator device\n");
printf("[+] Try to break out the auto-simulation, this requires a second reader!\n");
printf("[+] To do this, please send any command after the anti-collision\n");
printf("[+] For example, send a RATS command or use the \"anticol\" tool\n");
nfc_target_init(pdiTag,abtReaderRx,&uiReaderRxBits);
printf("[+] Configuring emulator settings\n");
nfc_configure(pdiTag,DCO_HANDLE_CRC,false);
nfc_configure(pdiTag,DCO_HANDLE_PARITY,false);
nfc_configure(pdiTag,DCO_ACCEPT_INVALID_FRAMES,true);
printf("[+] Thank you, the emulated tag is initialized\n");
// Try to open the NFC reader
pdiReader = INVALID_DEVICE_INFO;
while (pdiReader == INVALID_DEVICE_INFO) pdiReader = nfc_connect();
printf("[+] Configuring NFC reader settings\n");
nfc_configure(pdiReader,DCO_HANDLE_CRC,false);
nfc_configure(pdiReader,DCO_HANDLE_PARITY,false);
nfc_configure(pdiReader,DCO_ACCEPT_INVALID_FRAMES,true);
printf("[+] Done, relaying frames now!\n\n");
while(true)
{
// Test if we received a frame from the reader
if (nfc_target_receive_bits(pdiTag,abtReaderRx,&uiReaderRxBits,abtReaderRxPar))
{
// Drop down the field before sending a REQA command and start a new session
if (uiReaderRxBits == 7 && abtReaderRx[0] == 0x26)
{
// Drop down field for a very short time (original tag will reboot)
nfc_configure(pdiReader,DCO_ACTIVATE_FIELD,false);
printf("\n");
nfc_configure(pdiReader,DCO_ACTIVATE_FIELD,true);
}
// Print the reader frame to the screen
printf("R: ");
print_hex_par(abtReaderRx,uiReaderRxBits,abtReaderRxPar);
// Forward the frame to the original tag
if (nfc_reader_transceive_bits(pdiReader,abtReaderRx,uiReaderRxBits,abtReaderRxPar,abtTagRx,&uiTagRxBits,abtTagRxPar))
{
// Redirect the answer back to the reader
nfc_target_send_bits(pdiTag,abtTagRx,uiTagRxBits,abtTagRxPar);
// Print the tag frame to the screen
printf("T: ");
print_hex_par(abtTagRx,uiTagRxBits,abtTagRxPar);
}
}
}
nfc_disconnect(pdiTag);
nfc_disconnect(pdiReader);
}

219
simulate.c
View file

@ -1,108 +1,111 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libnfc.h"
static byte abtRecv[MAX_FRAME_LEN];
static ui32 uiRecvLen;
static dev_id di;
// ISO14443A Anti-Collision response
byte abtAtqa [2] = { 0x04,0x00 };
byte abtUidBcc [5] = { 0xDE,0xAD,0xBE,0xAF,0x62 };
byte abtSak [9] = { 0x08,0xb6,0xdd };
int main(int argc, const char* argv[])
{
byte* pbtTx;
ui32 uiTxLen;
// Try to open the NFC reader
di = acr122_connect(0);
if (di == INVALID_DEVICE_ID)
{
printf("Error connecting NFC reader\n");
return 1;
}
printf("\n");
printf("[+] Connected to NFC target\n");
acr122_led_red(di,true);
printf("[+] Identified simulated tag by setting the red light\n");
printf("[+] First we have to come out auto-simulation\n");
printf("[+] To do this, please send any command after the\n");
printf("[+] anti-collision, for example, the RATS command\n\n");
nfc_target_init(di,abtRecv,&uiRecvLen);
printf("[+] Initiator command: ");
print_hex(abtRecv,uiRecvLen);
printf("[+] Configuring communication");
nfc_configure_accept_invalid_frames(di,true);
nfc_configure_handle_crc(di,false);
printf("[+] Done, the simulated tag is initialized \n");
while(true)
{
// Test if we received a frame
if (nfc_target_receive_bytes(di,abtRecv,&uiRecvLen))
{
// Prepare the command to send back for the anti-collision request
switch(uiRecvLen)
{
case 1: // Request or Wakeup
pbtTx = abtAtqa;
uiTxLen = 2;
// New anti-collsion session started
printf("\n");
break;
case 2: // Select All
pbtTx = abtUidBcc;
uiTxLen = 5;
break;
case 9: // Select Tag
pbtTx = abtSak;
uiTxLen = 3;
break;
default: // unknown length?
uiTxLen = 0;
break;
}
printf("R: ");
print_hex(abtRecv,uiRecvLen);
// Test if we know how to respond
if(uiTxLen)
{
// Send and print the command to the screen
nfc_target_send_bytes(di,pbtTx,uiTxLen);
printf("T: ");
print_hex(pbtTx,uiTxLen);
}
}
}
}
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libnfc.h"
static byte abtRecv[MAX_FRAME_LEN];
static ui32 uiRecvBits;
static dev_info* pdi;
// ISO14443A Anti-Collision response
byte abtAtqa [2] = { 0x04,0x00 };
byte abtUidBcc [5] = { 0xDE,0xAD,0xBE,0xAF,0x62 };
byte abtSak [9] = { 0x08,0xb6,0xdd };
int main(int argc, const char* argv[])
{
byte* pbtTx = null;
ui32 uiTxBits;
// Try to open the NFC reader
pdi = nfc_connect();
if (pdi == INVALID_DEVICE_INFO)
{
printf("Error connecting NFC second reader\n");
return 1;
}
printf("\n");
printf("[+] Connected to NFC reader: %s\n",pdi->acName);
printf("[+] Try to break out the auto-simulation, this requires a second reader!\n");
printf("[+] To do this, please send any command after the anti-collision\n");
printf("[+] For example, send a RATS command or use the \"anticol\" tool\n");
if (!nfc_target_init(pdi,abtRecv,&uiRecvBits))
{
printf("Error: Could not come out of auto-simulation, no command was received\n");
return 1;
}
printf("[+] Received initiator command: ");
print_hex_bits(abtRecv,uiRecvBits);
printf("[+] Configuring communication\n");
nfc_configure(pdi,DCO_HANDLE_CRC,false);
nfc_configure(pdi,DCO_HANDLE_PARITY,true);
printf("[+] Done, the simulated tag is initialized\n\n");
while(true)
{
// Test if we received a frame
if (nfc_target_receive_bits(pdi,abtRecv,&uiRecvBits,null))
{
// Prepare the command to send back for the anti-collision request
switch(uiRecvBits)
{
case 7: // Request or Wakeup
pbtTx = abtAtqa;
uiTxBits = 16;
// New anti-collsion session started
printf("\n");
break;
case 16: // Select All
pbtTx = abtUidBcc;
uiTxBits = 40;
break;
case 72: // Select Tag
pbtTx = abtSak;
uiTxBits = 24;
break;
default: // unknown length?
uiTxBits = 0;
break;
}
printf("R: ");
print_hex_bits(abtRecv,uiRecvBits);
// Test if we know how to respond
if(uiTxBits)
{
// Send and print the command to the screen
nfc_target_send_bits(pdi,pbtTx,uiTxBits,null);
printf("T: ");
print_hex_bits(pbtTx,uiTxBits);
}
}
}
nfc_disconnect(pdi);
}

166
types.h
View file

@ -1,40 +1,126 @@
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
/*
Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
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, see <http://www.gnu.org/licenses/>.
*/
#ifndef _LIBNFC_TYPES_H_
#define _LIBNFC_TYPES_H_
#include "defines.h"
typedef enum {
false = 0x00,
true = 0x01
}bool;
// Compiler directive, set struct alignment to 1 byte for compatibility
#pragma pack(1)
typedef enum {
MT_ISO14443A_106 = 0x00,
MT_FELICA_212 = 0x01,
MT_FELICA_424 = 0x02,
MT_ISO14443B_106 = 0x03,
MT_TOPAZ_106 = 0x04,
}ModulationType;
false = 0x00,
true = 0x01
} bool;
typedef enum {
CT_PN531 = 0x10,
CT_PN532 = 0x20,
CT_PN533 = 0x30,
} chip_type;
struct dev_callbacks; // Prototype the callback struct
typedef struct {
const struct dev_callbacks* pdc; // Callback functions for handling device specific wrapping
char acName[DEVICE_NAME_LENGTH]; // Device name string, including device wrapper firmware
chip_type ct; // PN53X chip type, this is useful for some "bug" work-arounds
dev_spec ds; // Pointer to the device connection specification
bool bActive; // This represents if the PN53X device was initialized succesful
bool bCrc; // Is the crc automaticly added, checked and removed from the frames
bool bPar; // Does the PN53x chip handles parity bits, all parities are handled as data
ui8 ui8TxBits; // The last tx bits setting, we need to reset this if it does not apply anymore
} dev_info;
struct dev_callbacks {
const char* acDriver; // Driver description
dev_info* (*connect)(const ui32 uiIndex);
bool (*transceive)(const dev_spec ds, const byte* pbtTx, const ui32 uiTxLen, byte* pbtRx, ui32* puiRxLen);
void (*disconnect)(dev_info* pdi);
};
typedef enum {
DCO_HANDLE_CRC = 0x00,
DCO_HANDLE_PARITY = 0x01,
DCO_ACTIVATE_FIELD = 0x10,
DCO_ACTIVATE_CRYPTO1 = 0x11,
DCO_INFINITE_SELECT = 0x20,
DCO_ACCEPT_INVALID_FRAMES = 0x30,
DCO_ACCEPT_MULTIPLE_FRAMES = 0x31
}dev_config_option;
////////////////////////////////////////////////////////////////////
// nfc_reader_list_passive - using InListPassiveTarget
typedef enum {
IM_ISO14443A_106 = 0x00,
IM_FELICA_212 = 0x01,
IM_FELICA_424 = 0x02,
IM_ISO14443B_106 = 0x03,
IM_JEWEL_106 = 0x04
}init_modulation;
typedef struct {
byte abtAtqa[2];
byte btSak;
ui32 uiUidLen;
byte abtUid[10];
ui32 uiAtsLen;
byte abtAts[36];
}tag_info_iso14443a;
typedef struct {
ui32 uiLen;
byte btResCode;
byte abtId[8];
byte abtPad[8];
byte abtSysCode[2];
}tag_info_felica;
typedef struct {
byte abtAtqb[12];
byte abtId[4];
byte btParam1;
byte btParam2;
byte btParam3;
byte btParam4;
byte btCid;
ui32 uiInfLen;
byte abtInf[64];
}tag_info_iso14443b;
typedef struct {
byte btSensRes[2];
byte btId[4];
}tag_info_jewel;
typedef union {
tag_info_iso14443a tia;
tag_info_felica tif;
tag_info_iso14443b tib;
tag_info_jewel tij;
}tag_info;
////////////////////////////////////////////////////////////////////
// InDataExchange, MIFARE Classic card
typedef enum {
MC_AUTH_A = 0x60,
@ -45,25 +131,29 @@ typedef enum {
MC_DECREMENT = 0xC0,
MC_INCREMENT = 0xC1,
MC_STORE = 0xC2,
}MifareCmd;
}mifare_cmd;
// MIFARE Classic command params
typedef struct {
byte abtKey[6];
byte abtUid[4];
}MifareParamAuth;
}mifare_param_auth;
typedef struct {
byte abtData[16];
}MifareParamData;
}mifare_param_data;
typedef struct {
byte abtValue[4];
}MifareParamValue;
}mifare_param_value;
typedef union {
MifareParamAuth mpa;
MifareParamData mpd;
MifareParamValue mpv;
}MifareParam;
mifare_param_auth mpa;
mifare_param_data mpd;
mifare_param_value mpv;
}mifare_param;
// Reset struct alignment to default
#pragma pack()
#endif // _LIBNFC_TYPES_H_

6
win32/anticol.vcproj
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Version="8.00"
Name="anticol"
ProjectGUID="{71722DBB-4253-4D68-A29C-AA159360FCE4}"
RootNamespace="anticol"
@ -41,7 +41,7 @@
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
@ -118,7 +118,7 @@
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="../"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"

41
win32/libnfc.def
View file

@ -1,31 +1,33 @@
EXPORTS
; acr122.c
acr122_connect
acr122_disconnect
acr122_transceive
acr122_firmware
acr122_led_red
; dev_acr122.h
dev_acr122_connect
dev_acr122_disconnect
dev_acr122_transceive
dev_acr122_firmware
dev_acr122_led_red
; dev_pn531.h
dev_pn531_connect
dev_pn531_disconnect
dev_pn531_transceive
; libnfc.c
nfc_configure_handle_crc
nfc_configure_handle_parity
nfc_configure_field
nfc_configure_list_passive_infinite
nfc_configure_accept_invalid_frames
nfc_configure_accept_multiple_frames
; libnfc.h
nfc_connect
nfc_disconnect
nfc_configure
nfc_reader_init
nfc_reader_transceive_7bits
nfc_reader_transceive_bytes
nfc_reader_transceive_bits
nfc_reader_list_passive
nfc_reader_transceive_bytes
nfc_reader_select
nfc_reader_deselect
nfc_reader_mifare_cmd
nfc_target_init
nfc_target_receive_bytes
nfc_target_receive_bits
nfc_target_send_bytes
nfc_target_receive_bytes
nfc_target_send_bits
nfc_target_send_bytes
; bitutils.c
; bitutils.h
oddparity
oddparity_bytes
mirror
@ -36,6 +38,7 @@ EXPORTS
swap_endian64
append_iso14443a_crc
print_hex
print_hex_bits
print_hex_par

21
win32/libnfc.sln
View file

@ -10,26 +10,31 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "anticol", "anticol.vcproj",
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "simulate", "simulate.vcproj", "{9F813EB4-8F43-4E58-8C62-8E43D9AC137D}"
ProjectSection(ProjectDependencies) = postProject
{9CC505F9-AE58-4827-8921-A59E7C4839FE} = {9CC505F9-AE58-4827-8921-A59E7C4839FE}
{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3} = {BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}
{ADB1806A-745E-4DB4-9CDC-51658A5061E1} = {ADB1806A-745E-4DB4-9CDC-51658A5061E1}
{71722DBB-4253-4D68-A29C-AA159360FCE4} = {71722DBB-4253-4D68-A29C-AA159360FCE4}
{AAEEDA5F-F86F-452D-BFA3-53B1C00B8884} = {AAEEDA5F-F86F-452D-BFA3-53B1C00B8884}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "relay", "relay.vcproj", "{9CC505F9-AE58-4827-8921-A59E7C4839FE}"
ProjectSection(ProjectDependencies) = postProject
{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3} = {BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}
{ADB1806A-745E-4DB4-9CDC-51658A5061E1} = {ADB1806A-745E-4DB4-9CDC-51658A5061E1}
{71722DBB-4253-4D68-A29C-AA159360FCE4} = {71722DBB-4253-4D68-A29C-AA159360FCE4}
{AAEEDA5F-F86F-452D-BFA3-53B1C00B8884} = {AAEEDA5F-F86F-452D-BFA3-53B1C00B8884}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "list", "list.vcproj", "{ADB1806A-745E-4DB4-9CDC-51658A5061E1}"
ProjectSection(ProjectDependencies) = postProject
{71722DBB-4253-4D68-A29C-AA159360FCE4} = {71722DBB-4253-4D68-A29C-AA159360FCE4}
{AAEEDA5F-F86F-452D-BFA3-53B1C00B8884} = {AAEEDA5F-F86F-452D-BFA3-53B1C00B8884}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mfread", "mfread.vcproj", "{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}"
ProjectSection(ProjectDependencies) = postProject
{AAEEDA5F-F86F-452D-BFA3-53B1C00B8884} = {AAEEDA5F-F86F-452D-BFA3-53B1C00B8884}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mfwrite", "mfwrite.vcproj", "{77907F3D-BA6E-4A7F-AF9D-4F60C0A79952}"
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mftool", "mftool.vcproj", "{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}"
ProjectSection(ProjectDependencies) = postProject
{ADB1806A-745E-4DB4-9CDC-51658A5061E1} = {ADB1806A-745E-4DB4-9CDC-51658A5061E1}
{71722DBB-4253-4D68-A29C-AA159360FCE4} = {71722DBB-4253-4D68-A29C-AA159360FCE4}
{AAEEDA5F-F86F-452D-BFA3-53B1C00B8884} = {AAEEDA5F-F86F-452D-BFA3-53B1C00B8884}
EndProjectSection
EndProject
@ -63,10 +68,6 @@ Global
{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}.Debug|Win32.Build.0 = Debug|Win32
{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}.Release|Win32.ActiveCfg = Release|Win32
{BB0A837B-DAEF-4B3F-AF5B-9A757A97FFF3}.Release|Win32.Build.0 = Release|Win32
{77907F3D-BA6E-4A7F-AF9D-4F60C0A79952}.Debug|Win32.ActiveCfg = Debug|Win32
{77907F3D-BA6E-4A7F-AF9D-4F60C0A79952}.Debug|Win32.Build.0 = Debug|Win32
{77907F3D-BA6E-4A7F-AF9D-4F60C0A79952}.Release|Win32.ActiveCfg = Release|Win32
{77907F3D-BA6E-4A7F-AF9D-4F60C0A79952}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

42
win32/libnfc.vcproj
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Version="8.00"
Name="libnfc"
ProjectGUID="{AAEEDA5F-F86F-452D-BFA3-53B1C00B8884}"
RootNamespace="libnfc"
@ -40,7 +40,8 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBNFC_EXPORTS"
AdditionalIncludeDirectories="libusb"
PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBNFC_EXPORTS;_CRT_SECURE_NO_WARNINGS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
@ -61,8 +62,9 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="winscard.lib"
AdditionalDependencies="winscard.lib libusb.lib"
LinkIncremental="2"
AdditionalLibraryDirectories="libusb"
ModuleDefinitionFile="libnfc.def"
GenerateDebugInformation="true"
SubSystem="2"
@ -118,7 +120,8 @@
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBNFC_EXPORTS"
AdditionalIncludeDirectories="libusb"
PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBNFC_EXPORTS;_CRT_SECURE_NO_WARNINGS"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
@ -137,8 +140,9 @@
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="winscard.lib"
AdditionalDependencies="winscard.lib libusb.lib"
LinkIncremental="1"
AdditionalLibraryDirectories="libusb"
ModuleDefinitionFile="libnfc.def"
GenerateDebugInformation="true"
SubSystem="2"
@ -175,14 +179,6 @@
<References>
</References>
<Files>
<File
RelativePath="..\acr122.c"
>
</File>
<File
RelativePath="..\acr122.h"
>
</File>
<File
RelativePath="..\bitutils.c"
>
@ -195,6 +191,26 @@
RelativePath="..\defines.h"
>
</File>
<File
RelativePath="..\dev_acr122.c"
>
</File>
<File
RelativePath="..\dev_acr122.h"
>
</File>
<File
RelativePath="..\dev_pn531.c"
>
</File>
<File
RelativePath="..\dev_pn531.h"
>
</File>
<File
RelativePath="..\devices.h"
>
</File>
<File
RelativePath="..\libnfc.c"
>

6
win32/list.vcproj
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Version="8.00"
Name="list"
ProjectGUID="{ADB1806A-745E-4DB4-9CDC-51658A5061E1}"
RootNamespace="list"
@ -40,7 +40,7 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
@ -116,7 +116,7 @@
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"

6
win32/relay.vcproj
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Version="8.00"
Name="relay"
ProjectGUID="{9CC505F9-AE58-4827-8921-A59E7C4839FE}"
RootNamespace="relay"
@ -40,7 +40,7 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
@ -116,7 +116,7 @@
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"

6
win32/simulate.vcproj
View file

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Version="8.00"
Name="simulate"
ProjectGUID="{9F813EB4-8F43-4E58-8C62-8E43D9AC137D}"
RootNamespace="simulate"
@ -40,7 +40,7 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
@ -116,7 +116,7 @@
/>
<Tool
Name="VCCLCompilerTool"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"

BIN
win32bin/anticol.exe
View file

Binary file not shown.

BIN
win32bin/libnfc.dll
View file

Binary file not shown.

BIN
win32bin/libnfc.lib
View file

Binary file not shown.

BIN
win32bin/list.exe
View file

Binary file not shown.

BIN
win32bin/mfread.exe
View file

Binary file not shown.

BIN
win32bin/mfwrite.exe
View file

Binary file not shown.

BIN
win32bin/relay.exe
View file

Binary file not shown.

BIN
win32bin/simulate.exe
View file

Binary file not shown.