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 Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult 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 Welcome to the developers community of libnfc.
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, Since it is hard to keep all information up to date
but WITHOUT ANY WARRANTY; without even the implied warranty of we decided to only maintain the online documentation.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Please visit the official website for more info:
GNU General Public License for more details. http://www.libnfc.org
You should have received a copy of the GNU General Public License If you have questions, remarks, bug-reports, we encourage you to
along with this program. If not, see <http://www.gnu.org/licenses/>. 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 FeliCa is s registered trademark of Sony Corporation. MIFARE is a
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
trademark of NXP Semiconductors. Jewel Topaz is a trademark of Innovision trademark of NXP Semiconductors. Jewel Topaz is a trademark of Innovision
Research & Technology. All other trademarks are the property of their Research & Technology. All other trademarks are the property of their
respective owners. respective owners.

292
anticol.c
View file

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

59
bitutils.h
View file

@ -1,46 +1,28 @@
/* /*
Public platform independent Near Field Communication (NFC) library Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef _LIBNFC_BITUTILS_H_ #ifndef _LIBNFC_BITUTILS_H_
#define _LIBNFC_BITUTILS_H_ #define _LIBNFC_BITUTILS_H_
#include "defines.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); byte oddparity(const byte bt);
void oddparity_bytes(const byte* pbtData, const ui32 uiLen, byte* pbtPar); 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 append_iso14443a_crc(byte* pbtData, ui32 uiLen);
void print_hex(const byte* pbtData, const 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); void print_hex_par(const byte* pbtData, const ui32 uiBits, const byte* pbtDataPar);
#endif // _LIBNFC_BITUTILS_H_ #endif // _LIBNFC_BITUTILS_H_

57
defines.h
View file

@ -1,26 +1,28 @@
/* /*
Public platform independent Near Field Communication (NFC) library Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef _LIBNFC_DEFINES_H_ #ifndef _LIBNFC_DEFINES_H_
#define _LIBNFC_DEFINES_H_ #define _LIBNFC_DEFINES_H_
// #define _LIBNFC_VERBOSE_
typedef unsigned char byte; typedef unsigned char byte;
typedef unsigned char ui8; typedef unsigned char ui8;
typedef unsigned short ui16; typedef unsigned short ui16;
@ -33,13 +35,16 @@ typedef int i32;
#define null 0 #define null 0
typedef void* dev_id; // Device Id typedef void* dev_spec; // Device connection specification
#define INVALID_DEVICE_ID null #define INVALID_DEVICE_INFO null
#define MAX_FRAME_LEN 264 #define MAX_FRAME_LEN 264
#define DEVICE_NAME_LENGTH 256
#define min(a,b) (((a) < (b)) ? (a) : (b)) // Useful macros
#define max(a,b) (((a) > (b)) ? (a) : (b)) #define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
// #define _LIBNFC_VERBOSE_ #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_ #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 Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef _LIBNFC_H_ #ifndef _LIBNFC_H_
#define _LIBNFC_H_ #define _LIBNFC_H_
#include "defines.h" #include "defines.h"
#include "types.h" #include "types.h"
#include "bitutils.h" #include "bitutils.h"
#include "acr122.h" #include "devices.h"
bool nfc_configure_handle_crc(const dev_id di, const bool bEnable); dev_info* nfc_connect();
bool nfc_configure_handle_parity(const dev_id di, const bool bEnable); void nfc_disconnect(dev_info* pdi);
bool nfc_configure_field(const dev_id di, const bool bEnable); bool nfc_configure(dev_info* pdi, const dev_config_option dco, 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);
bool nfc_reader_init(const dev_id di); bool nfc_reader_init(const dev_info* pdi);
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_select(const dev_info* pdi, const init_modulation im, const byte* pbtInitData, const ui32 uiInitDataLen, tag_info* pti);
bool nfc_reader_transceive_7bits(const dev_id di, const byte btTx, byte* pbtRx, ui32* puiRxLen); bool nfc_reader_deselect(const dev_info* pdi);
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_info* pdi, const byte* pbtTx, const ui32 uiTxBits, const byte* pbtTxPar, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar);
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_transceive_bytes(const dev_info* pdi, const byte* pbtTx, const ui32 uiTxLen, byte* pbtRx, ui32* puiRxLen);
bool nfc_reader_mifare_cmd(const dev_id di, const MifareCmd mc, const ui8 ui8Block, MifareParam* pmp); 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_init(const dev_info* pdi, byte* pbtRx, ui32* puiRxBits);
bool nfc_target_receive_bytes(const dev_id di, byte* pbtRx, ui32* puiRxLen); bool nfc_target_receive_bits(const dev_info* pdi, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar);
bool nfc_target_receive_bits(const dev_id di, byte* pbtRx, ui32* puiRxBits, byte* pbtRxPar); bool nfc_target_receive_bytes(const dev_info* pdi, byte* pbtRx, ui32* puiRxLen);
bool nfc_target_send_bytes(const dev_id di, const byte* pbtTx, const ui32 uiTxLen); bool nfc_target_send_bits(const dev_info* pdi, const byte* pbtTx, const ui32 uiTxBits, const byte* pbtTxPar);
bool nfc_target_send_bits(const dev_id di, 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_ #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 <string.h>
#include "libnfc.h" #include "libnfc.h"
static byte abtRecv[MAX_FRAME_LEN]; static dev_info* pdi;
static ui32 uiRecvLen; static byte abtFelica[5] = { 0x00, 0xff, 0xff, 0x00, 0x00 };
static dev_id di;
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
tag_info ti;
// Try to open the NFC reader // 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"); printf("Error connecting NFC reader\n");
return 1; 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 // 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 // Configure the CRC and Parity settings
nfc_configure_field(di,false); nfc_configure(pdi,DCO_HANDLE_CRC,true);
nfc_configure(pdi,DCO_HANDLE_PARITY,true);
// Configure the communication channel // Enable field so more power consuming cards can power themselves up
nfc_configure_handle_crc(di,true); nfc_configure(pdi,DCO_ACTIVATE_FIELD,true);
nfc_configure_handle_parity(di,true);
printf("\nConnected to NFC reader\n\n"); printf("\nConnected to NFC reader: %s\n\n",pdi->acName);
uiRecvLen = MAX_FRAME_LEN; // Poll for a ISO14443A (MIFARE) tag
if (nfc_reader_list_passive(di,MT_ISO14443A_106,null,null,abtRecv,&uiRecvLen)) 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("The following (NFC) ISO14443A tag was found:\n\n");
printf("%17s","ATQA (SENS_RES): "); printf(" ATQA (SENS_RES): "); print_hex(ti.tia.abtAtqa,2);
print_hex(abtRecv+2,2); printf(" UID (NFCID%c): ",(ti.tia.abtUid[0]==0x08?'3':'1')); print_hex(ti.tia.abtUid,ti.tia.uiUidLen);
printf("%17s","UID (NFCID1): "); printf(" SAK (SEL_RES): "); print_hex(&ti.tia.btSak,1);
print_hex(abtRecv+6,abtRecv[5]); if (ti.tia.uiAtsLen)
printf("%17s","SAK (SEL_RES): ");
print_hex(abtRecv+4,1);
if (uiRecvLen > 6+(ui32)abtRecv[5])
{ {
printf("%17s","ATS (ATR): "); printf(" ATS (ATR): ");
print_hex(abtRecv+6+abtRecv[5]+1,abtRecv[6+abtRecv[5]]-1); print_hex(ti.tia.abtAts,ti.tia.uiAtsLen);
} }
} else {
printf("Error: no tag was found\n");
} }
// Todo: listing the folllowing tags types // 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))
// MT_FELICA_212 {
// MT_FELICA_424 printf("The following (NFC) Felica tag was found:\n\n");
// MT_ISO14443B_106 printf("%18s","ID (NFCID2): "); print_hex(ti.tif.abtId,8);
// MT_TOPAZ_106 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 Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef _MIFARE_TAG_H_ #ifndef _LIBNFC_MIFARE_TAG_H_
#define _MIFARE_TAG_H_ #define _LIBNFC_MIFARE_TAG_H_
#include "defines.h" #include "defines.h"
typedef struct tagBlockManufacturer { typedef struct {
byte abtUID[4]; byte abtUID[4];
byte btBCC; byte btBCC;
byte btUnknown; byte btUnknown;
byte abtATQA[2]; byte abtATQA[2];
byte abtUnknown[8]; byte abtUnknown[8];
} BlockManufacturer; } mifare_block_manufacturer;
typedef struct tagBlockData { typedef struct {
byte abtContent[16]; byte abtData[16];
} BlockData; } mifare_block_data;
typedef struct tagBlockTrailer { typedef struct {
byte abtKeyA[6]; byte abtKeyA[6];
byte abtAccessBits[4]; byte abtAccessBits[4];
byte abtKeyB[6]; byte abtKeyB[6];
} BlockTrailer; } mifare_block_trailer;
typedef union tagBlock { typedef union {
BlockManufacturer bm; mifare_block_manufacturer mbm;
BlockData bd; mifare_block_data mbd;
BlockTrailer bt; mifare_block_trailer mbt;
} Block; } mifare_block;
typedef struct tagMifareTag { typedef struct {
Block blContent[256]; mifare_block amb[256];
} MifareTag; } 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 Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "libnfc.h" #include "libnfc.h"
static byte abtReaderRecv[MAX_FRAME_LEN]; static byte abtReaderRx[MAX_FRAME_LEN];
static byte abtReaderRecvPar[MAX_FRAME_LEN]; static byte abtReaderRxPar[MAX_FRAME_LEN];
static ui32 uiReaderRecvBits; static ui32 uiReaderRxBits;
static byte abtTagRecv[MAX_FRAME_LEN]; static byte abtTagRx[MAX_FRAME_LEN];
static byte abtTagRecvPar[MAX_FRAME_LEN]; static byte abtTagRxPar[MAX_FRAME_LEN];
static ui32 uiTagRecvBits; static ui32 uiTagRxBits;
static dev_id diReader; static dev_info* pdiReader;
static dev_id diTag; static dev_info* pdiTag;
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
// Try to open the NFC reader // Try to open the NFC emulator device
diReader = acr122_connect(0); pdiTag = nfc_connect();
if (diReader == INVALID_DEVICE_ID) if (pdiTag == INVALID_DEVICE_INFO)
{ {
printf("Error connecting first NFC reader\n"); printf("Error connecting NFC emulator device\n");
return 1; return 1;
} }
diTag = acr122_connect(1); printf("\n");
if (diTag == INVALID_DEVICE_ID) printf("[+] Connected to the NFC emulator device\n");
{ printf("[+] Try to break out the auto-simulation, this requires a second reader!\n");
printf("Error connecting second NFC reader\n"); printf("[+] To do this, please send any command after the anti-collision\n");
return 1; printf("[+] For example, send a RATS command or use the \"anticol\" tool\n");
} nfc_target_init(pdiTag,abtReaderRx,&uiReaderRxBits);
printf("[+] Configuring emulator settings\n");
printf("\n"); nfc_configure(pdiTag,DCO_HANDLE_CRC,false);
printf("[+] Connected to the both NFC readers\n"); nfc_configure(pdiTag,DCO_HANDLE_PARITY,false);
acr122_led_red(diTag,true); nfc_configure(pdiTag,DCO_ACCEPT_INVALID_FRAMES,true);
printf("[+] Identified simulated tag by setting the red light\n"); printf("[+] Thank you, the emulated tag is initialized\n");
printf("[+] Place both readers on top of each other\n");
printf("[+] Please run 'anticol' tool in a different shell\n"); // Try to open the NFC reader
nfc_target_init(diTag,abtReaderRecv,&uiReaderRecvBits); pdiReader = INVALID_DEVICE_INFO;
nfc_configure_handle_crc(diTag,false); while (pdiReader == INVALID_DEVICE_INFO) pdiReader = nfc_connect();
nfc_configure_handle_parity(diTag,false); printf("[+] Configuring NFC reader settings\n");
nfc_configure_accept_invalid_frames(diTag,true); nfc_configure(pdiReader,DCO_HANDLE_CRC,false);
printf("[+] Thank you, the simulated tag is initialized\n"); nfc_configure(pdiReader,DCO_HANDLE_PARITY,false);
nfc_configure(pdiReader,DCO_ACCEPT_INVALID_FRAMES,true);
printf("[+] Attaching to first NFC reader \n"); printf("[+] Done, relaying frames now!\n\n");
// Retry until it becomes ready
while (!nfc_reader_init(diReader)) while(true)
{ {
acr122_disconnect(diReader); // Test if we received a frame from the reader
printf("error\n"); if (nfc_target_receive_bits(pdiTag,abtReaderRx,&uiReaderRxBits,abtReaderRxPar))
diReader = acr122_connect(0); {
} // Drop down the field before sending a REQA command and start a new session
nfc_configure_handle_crc(diReader,false); if (uiReaderRxBits == 7 && abtReaderRx[0] == 0x26)
nfc_configure_handle_parity(diReader,false); {
nfc_configure_accept_invalid_frames(diReader,true); // Drop down field for a very short time (original tag will reboot)
printf("[+] Done, relaying frames now!\n\n"); nfc_configure(pdiReader,DCO_ACTIVATE_FIELD,false);
printf("\n");
while(true) nfc_configure(pdiReader,DCO_ACTIVATE_FIELD,true);
{ }
// Test if we received a frame from the reader
if (nfc_target_receive_bits(diTag,abtReaderRecv,&uiReaderRecvBits,abtReaderRecvPar)) // Print the reader frame to the screen
{ printf("R: ");
// Drop down the field before sending a REQA command and start a new session print_hex_par(abtReaderRx,uiReaderRxBits,abtReaderRxPar);
if (uiReaderRecvBits == 7 && abtReaderRecv[0] == 0x26)
{ // Forward the frame to the original tag
// Drop down field for a very short time (tag will reboot) if (nfc_reader_transceive_bits(pdiReader,abtReaderRx,uiReaderRxBits,abtReaderRxPar,abtTagRx,&uiTagRxBits,abtTagRxPar))
nfc_configure_field(diReader,false); {
printf("\n"); // Redirect the answer back to the reader
nfc_configure_field(diReader,true); nfc_target_send_bits(pdiTag,abtTagRx,uiTagRxBits,abtTagRxPar);
}
// Print the tag frame to the screen
// Print the reader frame to the screen printf("T: ");
printf("R: "); print_hex_par(abtTagRx,uiTagRxBits,abtTagRxPar);
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))
{ nfc_disconnect(pdiTag);
// Redirect the answer back to the reader nfc_disconnect(pdiReader);
nfc_target_send_bits(diTag,abtTagRecv,uiTagRecvBits,abtTagRecvPar); }
// Print the tag frame to the screen
printf("T: ");
print_hex_par(abtTagRecv,uiTagRecvBits,abtTagRecvPar);
}
}
}
}

219
simulate.c
View file

@ -1,108 +1,111 @@
/* /*
Public platform independent Near Field Communication (NFC) library Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "libnfc.h" #include "libnfc.h"
static byte abtRecv[MAX_FRAME_LEN]; static byte abtRecv[MAX_FRAME_LEN];
static ui32 uiRecvLen; static ui32 uiRecvBits;
static dev_id di; static dev_info* pdi;
// ISO14443A Anti-Collision response // ISO14443A Anti-Collision response
byte abtAtqa [2] = { 0x04,0x00 }; byte abtAtqa [2] = { 0x04,0x00 };
byte abtUidBcc [5] = { 0xDE,0xAD,0xBE,0xAF,0x62 }; byte abtUidBcc [5] = { 0xDE,0xAD,0xBE,0xAF,0x62 };
byte abtSak [9] = { 0x08,0xb6,0xdd }; byte abtSak [9] = { 0x08,0xb6,0xdd };
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
byte* pbtTx; byte* pbtTx = null;
ui32 uiTxLen; ui32 uiTxBits;
// Try to open the NFC reader // 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"); printf("Error connecting NFC second reader\n");
return 1; return 1;
} }
printf("\n"); printf("\n");
printf("[+] Connected to NFC target\n"); printf("[+] Connected to NFC reader: %s\n",pdi->acName);
acr122_led_red(di,true); printf("[+] Try to break out the auto-simulation, this requires a second reader!\n");
printf("[+] Identified simulated tag by setting the red light\n"); printf("[+] To do this, please send any command after the anti-collision\n");
printf("[+] First we have to come out auto-simulation\n"); printf("[+] For example, send a RATS command or use the \"anticol\" tool\n");
printf("[+] To do this, please send any command after the\n"); if (!nfc_target_init(pdi,abtRecv,&uiRecvBits))
printf("[+] anti-collision, for example, the RATS command\n\n"); {
nfc_target_init(di,abtRecv,&uiRecvLen); printf("Error: Could not come out of auto-simulation, no command was received\n");
printf("[+] Initiator command: "); return 1;
print_hex(abtRecv,uiRecvLen); }
printf("[+] Configuring communication"); printf("[+] Received initiator command: ");
nfc_configure_accept_invalid_frames(di,true); print_hex_bits(abtRecv,uiRecvBits);
nfc_configure_handle_crc(di,false); printf("[+] Configuring communication\n");
printf("[+] Done, the simulated tag is initialized \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)
{ while(true)
// Test if we received a frame {
if (nfc_target_receive_bytes(di,abtRecv,&uiRecvLen)) // 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(uiRecvLen) // Prepare the command to send back for the anti-collision request
{ switch(uiRecvBits)
case 1: // Request or Wakeup {
pbtTx = abtAtqa; case 7: // Request or Wakeup
uiTxLen = 2; pbtTx = abtAtqa;
// New anti-collsion session started uiTxBits = 16;
printf("\n"); // New anti-collsion session started
break; printf("\n");
break;
case 2: // Select All
pbtTx = abtUidBcc; case 16: // Select All
uiTxLen = 5; pbtTx = abtUidBcc;
break; uiTxBits = 40;
break;
case 9: // Select Tag
pbtTx = abtSak; case 72: // Select Tag
uiTxLen = 3; pbtTx = abtSak;
break; uiTxBits = 24;
break;
default: // unknown length?
uiTxLen = 0; default: // unknown length?
break; uiTxBits = 0;
} break;
}
printf("R: ");
print_hex(abtRecv,uiRecvLen); printf("R: ");
print_hex_bits(abtRecv,uiRecvBits);
// Test if we know how to respond
if(uiTxLen) // Test if we know how to respond
{ if(uiTxBits)
// Send and print the command to the screen {
nfc_target_send_bytes(di,pbtTx,uiTxLen); // Send and print the command to the screen
printf("T: "); nfc_target_send_bits(pdi,pbtTx,uiTxBits,null);
print_hex(pbtTx,uiTxLen); 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 Public platform independent Near Field Communication (NFC) library
Copyright (C) 2009, Roel Verdult Copyright (C) 2009, Roel Verdult
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef _LIBNFC_TYPES_H_ #ifndef _LIBNFC_TYPES_H_
#define _LIBNFC_TYPES_H_ #define _LIBNFC_TYPES_H_
#include "defines.h" #include "defines.h"
typedef enum { // Compiler directive, set struct alignment to 1 byte for compatibility
false = 0x00, #pragma pack(1)
true = 0x01
}bool;
typedef enum { typedef enum {
MT_ISO14443A_106 = 0x00, false = 0x00,
MT_FELICA_212 = 0x01, true = 0x01
MT_FELICA_424 = 0x02, } bool;
MT_ISO14443B_106 = 0x03,
MT_TOPAZ_106 = 0x04, typedef enum {
}ModulationType; 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 { typedef enum {
MC_AUTH_A = 0x60, MC_AUTH_A = 0x60,
@ -45,25 +131,29 @@ typedef enum {
MC_DECREMENT = 0xC0, MC_DECREMENT = 0xC0,
MC_INCREMENT = 0xC1, MC_INCREMENT = 0xC1,
MC_STORE = 0xC2, MC_STORE = 0xC2,
}MifareCmd; }mifare_cmd;
// MIFARE Classic command params
typedef struct { typedef struct {
byte abtKey[6]; byte abtKey[6];
byte abtUid[4]; byte abtUid[4];
}MifareParamAuth; }mifare_param_auth;
typedef struct { typedef struct {
byte abtData[16]; byte abtData[16];
}MifareParamData; }mifare_param_data;
typedef struct { typedef struct {
byte abtValue[4]; byte abtValue[4];
}MifareParamValue; }mifare_param_value;
typedef union { typedef union {
MifareParamAuth mpa; mifare_param_auth mpa;
MifareParamData mpd; mifare_param_data mpd;
MifareParamValue mpv; mifare_param_value mpv;
}MifareParam; }mifare_param;
// Reset struct alignment to default
#pragma pack()
#endif // _LIBNFC_TYPES_H_ #endif // _LIBNFC_TYPES_H_

6
win32/anticol.vcproj
View file

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

41
win32/libnfc.def
View file

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

21
win32/libnfc.sln
View file

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

42
win32/libnfc.vcproj
View file

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

6
win32/list.vcproj
View file

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

6
win32/relay.vcproj
View file

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

6
win32/simulate.vcproj
View file

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