github/proxmark3
1
0
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2025-07-16 02:03:00 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Clean up data types, some header cleanup, etc.

Browse source
This commit is contained in:
marcansoft 2010-02-20 22:51:00 +00:00
parent 8419248d2d
commit f7e3ed8287
17 changed files with 410 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

37
armsrc/appmain.c
View file

@ -7,7 +7,10 @@
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "apps.h"
#include "util.h"
#include "legicrf.h" #include "legicrf.h"
#ifdef WITH_LCD #ifdef WITH_LCD
# include "fonts.h" # include "fonts.h"
# include "LCD.h" # include "LCD.h"
@ -28,7 +31,7 @@ int kvsprintf(char const *fmt, void *arg, int radix, va_list ap);
// is the order in which they go out on the wire. // is the order in which they go out on the wire.
//============================================================================= //=============================================================================
BYTE ToSend[512]; uint8_t ToSend[512];
int ToSendMax; int ToSendMax;
static int ToSendBit; static int ToSendBit;
struct common_area common_area __attribute__((section(".commonarea"))); struct common_area common_area __attribute__((section(".commonarea")));
@ -83,7 +86,7 @@ void DbpString(char *str)
} }
memcpy(c.d.asBytes, str, c.arg[0]); memcpy(c.d.asBytes, str, c.arg[0]);
UsbSendPacket((BYTE *)&c, sizeof(c)); UsbSendPacket((uint8_t *)&c, sizeof(c));
// TODO fix USB so stupid things like this aren't req'd // TODO fix USB so stupid things like this aren't req'd
SpinDelay(50); SpinDelay(50);
} }
@ -101,7 +104,7 @@ void DbpIntegers(int x1, int x2, int x3)
c.arg[1] = x2; c.arg[1] = x2;
c.arg[2] = x3; c.arg[2] = x3;
UsbSendPacket((BYTE *)&c, sizeof(c)); UsbSendPacket((uint8_t *)&c, sizeof(c));
// XXX // XXX
SpinDelay(50); SpinDelay(50);
} }
@ -126,7 +129,7 @@ void Dbprintf(const char *fmt, ...) {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static int ReadAdc(int ch) static int ReadAdc(int ch)
{ {
DWORD d; uint32_t d;
AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST; AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
AT91C_BASE_ADC->ADC_MR = AT91C_BASE_ADC->ADC_MR =
@ -157,7 +160,7 @@ static int AvgAdc(int ch)
void MeasureAntennaTuning(void) void MeasureAntennaTuning(void)
{ {
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int i, ptr = 0, adcval = 0, peak = 0, peakv = 0, peakf = 0;; int i, ptr = 0, adcval = 0, peak = 0, peakv = 0, peakf = 0;;
int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV
@ -204,7 +207,7 @@ void MeasureAntennaTuning(void)
c.arg[0] = (vLf125 << 0) | (vLf134 << 16); c.arg[0] = (vLf125 << 0) | (vLf134 << 16);
c.arg[1] = vHf; c.arg[1] = vHf;
c.arg[2] = peakf | (peakv << 16); c.arg[2] = peakf | (peakv << 16);
UsbSendPacket((BYTE *)&c, sizeof(c)); UsbSendPacket((uint8_t *)&c, sizeof(c));
} }
void MeasureAntennaTuningHf(void) void MeasureAntennaTuningHf(void)
@ -230,9 +233,9 @@ void MeasureAntennaTuningHf(void)
void SimulateTagHfListen(void) void SimulateTagHfListen(void)
{ {
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int n = sizeof(BigBuf); int n = sizeof(BigBuf);
BYTE v = 0; uint8_t v = 0;
int i; int i;
int p = 0; int p = 0;
@ -251,7 +254,7 @@ void SimulateTagHfListen(void)
AT91C_BASE_SSC->SSC_THR = 0xff; AT91C_BASE_SSC->SSC_THR = 0xff;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
BYTE r = (BYTE)AT91C_BASE_SSC->SSC_RHR; uint8_t r = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
v <<= 1; v <<= 1;
if(r & 1) { if(r & 1) {
@ -276,7 +279,7 @@ void SimulateTagHfListen(void)
void ReadMem(int addr) void ReadMem(int addr)
{ {
const BYTE *data = ((BYTE *)addr); const uint8_t *data = ((uint8_t *)addr);
Dbprintf("%x: %02x %02x %02x %02x %02x %02x %02x %02x", Dbprintf("%x: %02x %02x %02x %02x %02x %02x %02x %02x",
addr, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); addr, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
@ -567,7 +570,7 @@ void ListenReaderField(int limit)
} }
} }
void UsbPacketReceived(BYTE *packet, int len) void UsbPacketReceived(uint8_t *packet, int len)
{ {
UsbCommand *c = (UsbCommand *)packet; UsbCommand *c = (UsbCommand *)packet;
UsbCommand ack; UsbCommand ack;
@ -577,7 +580,7 @@ void UsbPacketReceived(BYTE *packet, int len)
#ifdef WITH_LF #ifdef WITH_LF
case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K: case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
AcquireRawAdcSamples125k(c->arg[0]); AcquireRawAdcSamples125k(c->arg[0]);
UsbSendPacket((BYTE*)&ack, sizeof(ack)); UsbSendPacket((uint8_t*)&ack, sizeof(ack));
break; break;
#endif #endif
@ -718,16 +721,16 @@ void UsbPacketReceived(BYTE *packet, int len)
n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE; n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE;
} }
n.arg[0] = c->arg[0]; n.arg[0] = c->arg[0];
memcpy(n.d.asDwords, BigBuf+c->arg[0], 12*sizeof(DWORD)); memcpy(n.d.asDwords, BigBuf+c->arg[0], 12*sizeof(uint32_t));
UsbSendPacket((BYTE *)&n, sizeof(n)); UsbSendPacket((uint8_t *)&n, sizeof(n));
break; break;
} }
case CMD_DOWNLOADED_SIM_SAMPLES_125K: { case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
BYTE *b = (BYTE *)BigBuf; uint8_t *b = (uint8_t *)BigBuf;
memcpy(b+c->arg[0], c->d.asBytes, 48); memcpy(b+c->arg[0], c->d.asBytes, 48);
//Dbprintf("copied 48 bytes to %i",b+c->arg[0]); //Dbprintf("copied 48 bytes to %i",b+c->arg[0]);
UsbSendPacket((BYTE*)&ack, sizeof(ack)); UsbSendPacket((uint8_t*)&ack, sizeof(ack));
break; break;
} }
@ -800,7 +803,7 @@ void UsbPacketReceived(BYTE *packet, int len)
c.cmd = CMD_DEVICE_INFO; c.cmd = CMD_DEVICE_INFO;
c.arg[0] = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS; c.arg[0] = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
if(common_area.flags.bootrom_present) c.arg[0] |= DEVICE_INFO_FLAG_BOOTROM_PRESENT; if(common_area.flags.bootrom_present) c.arg[0] |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
UsbSendPacket((BYTE*)&c, sizeof(c)); UsbSendPacket((uint8_t*)&c, sizeof(c));
} }
break; break;
default: default:

66
armsrc/apps.h
View file

@ -7,13 +7,13 @@
#ifndef __APPS_H #ifndef __APPS_H
#define __APPS_H #define __APPS_H
#include "stdint.h" #include <stdint.h>
#include "stddef.h" #include <stddef.h>
typedef unsigned char byte_t; typedef unsigned char byte_t;
// The large multi-purpose buffer, typically used to hold A/D samples, // The large multi-purpose buffer, typically used to hold A/D samples,
// maybe processed in some way. // maybe processed in some way.
DWORD BigBuf[8000]; uint32_t BigBuf[8000];
/// appmain.h /// appmain.h
void ReadMem(int addr); void ReadMem(int addr);
@ -26,21 +26,21 @@ void Dbprintf(const char *fmt, ...);
void ToSendStuffBit(int b); void ToSendStuffBit(int b);
void ToSendReset(void); void ToSendReset(void);
void ListenReaderField(int limit); void ListenReaderField(int limit);
void AcquireRawAdcSamples125k(BOOL at134khz); void AcquireRawAdcSamples125k(int at134khz);
void DoAcquisition125k(void); void DoAcquisition125k(void);
extern int ToSendMax; extern int ToSendMax;
extern BYTE ToSend[]; extern uint8_t ToSend[];
extern DWORD BigBuf[]; extern uint32_t BigBuf[];
/// fpga.h /// fpga.h
void FpgaSendCommand(WORD cmd, WORD v); void FpgaSendCommand(uint16_t cmd, uint16_t v);
void FpgaWriteConfWord(BYTE v); void FpgaWriteConfWord(uint8_t v);
void FpgaDownloadAndGo(void); void FpgaDownloadAndGo(void);
void FpgaGatherVersion(char *dst, int len); void FpgaGatherVersion(char *dst, int len);
void FpgaSetupSsc(void); void FpgaSetupSsc(void);
void SetupSpi(int mode); void SetupSpi(int mode);
void FpgaSetupSscDma(BYTE *buf, int len); void FpgaSetupSscDma(uint8_t *buf, int len);
void SetAdcMuxFor(DWORD whichGpio); void SetAdcMuxFor(uint32_t whichGpio);
// Definitions for the FPGA commands. // Definitions for the FPGA commands.
#define FPGA_CMD_SET_CONFREG (1<<12) #define FPGA_CMD_SET_CONFREG (1<<12)
@ -72,10 +72,10 @@ void SetAdcMuxFor(DWORD whichGpio);
#define FPGA_HF_ISO14443A_READER_MOD (4<<0) #define FPGA_HF_ISO14443A_READER_MOD (4<<0)
/// lfops.h /// lfops.h
void AcquireRawAdcSamples125k(BOOL at134khz); void AcquireRawAdcSamples125k(int at134khz);
void ModThenAcquireRawAdcSamples125k(int delay_off,int period_0,int period_1,BYTE *command); void ModThenAcquireRawAdcSamples125k(int delay_off,int period_0,int period_1,uint8_t *command);
void ReadTItag(void); void ReadTItag(void);
void WriteTItag(DWORD idhi, DWORD idlo, WORD crc); void WriteTItag(uint32_t idhi, uint32_t idlo, uint16_t crc);
void AcquireTiType(void); void AcquireTiType(void);
void AcquireRawBitsTI(void); void AcquireRawBitsTI(void);
void SimulateTagLowFrequency(int period, int gap, int ledcontrol); void SimulateTagLowFrequency(int period, int gap, int ledcontrol);
@ -85,47 +85,23 @@ void SimulateTagLowFrequencyBidir(int divisor, int max_bitlen);
/// iso14443.h /// iso14443.h
void SimulateIso14443Tag(void); void SimulateIso14443Tag(void);
void AcquireRawAdcSamplesIso14443(DWORD parameter); void AcquireRawAdcSamplesIso14443(uint32_t parameter);
void ReadSRI512Iso14443(DWORD parameter); void ReadSRI512Iso14443(uint32_t parameter);
void ReadSRIX4KIso14443(DWORD parameter); void ReadSRIX4KIso14443(uint32_t parameter);
void ReadSTMemoryIso14443(DWORD parameter,DWORD dwLast); void ReadSTMemoryIso14443(uint32_t parameter,uint32_t dwLast);
void SnoopIso14443(void); void SnoopIso14443(void);
/// iso14443a.h /// iso14443a.h
void SnoopIso14443a(void); void SnoopIso14443a(void);
void SimulateIso14443aTag(int tagType, int TagUid); // ## simulate iso14443a tag void SimulateIso14443aTag(int tagType, int TagUid); // ## simulate iso14443a tag
void ReaderIso14443a(DWORD parameter); void ReaderIso14443a(uint32_t parameter);
void ReaderMifare(DWORD parameter); void ReaderMifare(uint32_t parameter);
/// iso15693.h /// iso15693.h
void AcquireRawAdcSamplesIso15693(void); void AcquireRawAdcSamplesIso15693(void);
void ReaderIso15693(DWORD parameter); // Simulate an ISO15693 reader - greg void ReaderIso15693(uint32_t parameter); // Simulate an ISO15693 reader - greg
void SimTagIso15693(DWORD parameter); // simulate an ISO15693 tag - greg void SimTagIso15693(uint32_t parameter); // simulate an ISO15693 tag - greg
/// util.h /// util.h
#define LED_RED 1
#define LED_ORANGE 2
#define LED_GREEN 4
#define LED_RED2 8
#define BUTTON_HOLD 1
#define BUTTON_NO_CLICK 0
#define BUTTON_SINGLE_CLICK -1
#define BUTTON_DOUBLE_CLICK -2
#define BUTTON_ERROR -99
int strlen(char *str);
void *memcpy(void *dest, const void *src, int len);
void *memset(void *dest, int c, int len);
int memcmp(const void *av, const void *bv, int len);
char *strncat(char *dest, const char *src, unsigned int n);
void num_to_bytes(uint64_t n, size_t len, byte_t* dest);
uint64_t bytes_to_num(byte_t* src, size_t len);
void SpinDelay(int ms);
void SpinDelayUs(int us);
void LED(int led, int ms);
void LEDsoff();
int BUTTON_CLICKED(int ms);
int BUTTON_HELD(int ms);
void FormatVersionInformation(char *dst, int len, const char *prefix, void *version_information);
#endif #endif

21
armsrc/fpgaloader.c
View file

@ -6,6 +6,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "apps.h"
#include "util.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Set up the Serial Peripheral Interface as master // Set up the Serial Peripheral Interface as master
@ -129,11 +130,11 @@ void FpgaSetupSsc(void)
// ourselves, not to another buffer). The stuff to manipulate those buffers // ourselves, not to another buffer). The stuff to manipulate those buffers
// is in apps.h, because it should be inlined, for speed. // is in apps.h, because it should be inlined, for speed.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void FpgaSetupSscDma(BYTE *buf, int len) void FpgaSetupSscDma(uint8_t *buf, int len)
{ {
AT91C_BASE_PDC_SSC->PDC_RPR = (DWORD)buf; AT91C_BASE_PDC_SSC->PDC_RPR = (uint32_t) buf;
AT91C_BASE_PDC_SSC->PDC_RCR = len; AT91C_BASE_PDC_SSC->PDC_RCR = len;
AT91C_BASE_PDC_SSC->PDC_RNPR = (DWORD)buf; AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) buf;
AT91C_BASE_PDC_SSC->PDC_RNCR = len; AT91C_BASE_PDC_SSC->PDC_RNCR = len;
AT91C_BASE_PDC_SSC->PDC_PTCR = AT91C_PDC_RXTEN; AT91C_BASE_PDC_SSC->PDC_PTCR = AT91C_PDC_RXTEN;
} }
@ -207,8 +208,8 @@ static void DownloadFPGA(const char *FpgaImage, int FpgaImageLen, int byterevers
} }
if(bytereversal) { if(bytereversal) {
/* This is only supported for DWORD aligned images */ /* This is only supported for uint32_t aligned images */
if( ((int)FpgaImage % sizeof(DWORD)) == 0 ) { if( ((int)FpgaImage % sizeof(uint32_t)) == 0 ) {
i=0; i=0;
while(FpgaImageLen-->0) while(FpgaImageLen-->0)
DownloadFPGA_byte(FpgaImage[(i++)^0x3]); DownloadFPGA_byte(FpgaImage[(i++)^0x3]);
@ -330,12 +331,12 @@ void FpgaDownloadAndGo(void)
/* Fallback for the old flash image format: Check for the magic marker 0xFFFFFFFF /* Fallback for the old flash image format: Check for the magic marker 0xFFFFFFFF
* 0xAA995566 at address 0x102000. This is raw bitstream with a size of 336,768 bits * 0xAA995566 at address 0x102000. This is raw bitstream with a size of 336,768 bits
* = 10,524 DWORDs, stored as DWORDS e.g. little-endian in memory, but each DWORD * = 10,524 uint32_t, stored as uint32_t e.g. little-endian in memory, but each DWORD
* is still to be transmitted in MSBit first order. Set the invert flag to indicate * is still to be transmitted in MSBit first order. Set the invert flag to indicate
* that the DownloadFPGA function should invert every 4 byte sequence when doing * that the DownloadFPGA function should invert every 4 byte sequence when doing
* the bytewise download. * the bytewise download.
*/ */
if( *(DWORD*)0x102000 == 0xFFFFFFFF && *(DWORD*)0x102004 == 0xAA995566 ) if( *(uint32_t*)0x102000 == 0xFFFFFFFF && *(uint32_t*)0x102004 == 0xAA995566 )
DownloadFPGA((char*)0x102000, 10524*4, 1); DownloadFPGA((char*)0x102000, 10524*4, 1);
} }
@ -375,7 +376,7 @@ void FpgaGatherVersion(char *dst, int len)
// The bit format is: C3 C2 C1 C0 D11 D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 // The bit format is: C3 C2 C1 C0 D11 D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0
// where C is the 4 bit command and D is the 12 bit data // where C is the 4 bit command and D is the 12 bit data
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void FpgaSendCommand(WORD cmd, WORD v) void FpgaSendCommand(uint16_t cmd, uint16_t v)
{ {
SetupSpi(SPI_FPGA_MODE); SetupSpi(SPI_FPGA_MODE);
while ((AT91C_BASE_SPI->SPI_SR & AT91C_SPI_TXEMPTY) == 0); // wait for the transfer to complete while ((AT91C_BASE_SPI->SPI_SR & AT91C_SPI_TXEMPTY) == 0); // wait for the transfer to complete
@ -386,7 +387,7 @@ void FpgaSendCommand(WORD cmd, WORD v)
// vs. clone vs. etc.). This is now a special case of FpgaSendCommand() to // vs. clone vs. etc.). This is now a special case of FpgaSendCommand() to
// avoid changing this function's occurence everywhere in the source code. // avoid changing this function's occurence everywhere in the source code.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void FpgaWriteConfWord(BYTE v) void FpgaWriteConfWord(uint8_t v)
{ {
FpgaSendCommand(FPGA_CMD_SET_CONFREG, v); FpgaSendCommand(FPGA_CMD_SET_CONFREG, v);
} }
@ -396,7 +397,7 @@ void FpgaWriteConfWord(BYTE v)
// closable, but should only close one at a time. Not an FPGA thing, but // closable, but should only close one at a time. Not an FPGA thing, but
// the samples from the ADC always flow through the FPGA. // the samples from the ADC always flow through the FPGA.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void SetAdcMuxFor(DWORD whichGpio) void SetAdcMuxFor(uint32_t whichGpio)
{ {
AT91C_BASE_PIOA->PIO_OER = AT91C_BASE_PIOA->PIO_OER =
GPIO_MUXSEL_HIPKD | GPIO_MUXSEL_HIPKD |

4
armsrc/hitag2.c
View file

@ -8,9 +8,9 @@
*/ */
#include "proxmark3.h" #include "proxmark3.h"
#include <stdint.h>
#include "apps.h" #include "apps.h"
#include "util.h"
#include "hitag2.h" #include "hitag2.h"
struct hitag2_cipher_state { struct hitag2_cipher_state {

113
armsrc/iso14443.c
View file

@ -6,10 +6,11 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "apps.h"
#include "util.h"
#include "iso14443crc.h" #include "iso14443crc.h"
//static void GetSamplesFor14443(int weTx, int n);
//static void GetSamplesFor14443(BOOL weTx, int n);
#define DEMOD_TRACE_SIZE 4096 #define DEMOD_TRACE_SIZE 4096
#define READER_TAG_BUFFER_SIZE 2048 #define READER_TAG_BUFFER_SIZE 2048
@ -29,7 +30,7 @@
// that here) so that they can be transmitted to the reader. Doesn't transmit // that here) so that they can be transmitted to the reader. Doesn't transmit
// them yet, just leaves them ready to send in ToSend[]. // them yet, just leaves them ready to send in ToSend[].
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void CodeIso14443bAsTag(const BYTE *cmd, int len) static void CodeIso14443bAsTag(const uint8_t *cmd, int len)
{ {
int i; int i;
@ -62,7 +63,7 @@ static void CodeIso14443bAsTag(const BYTE *cmd, int len)
for(i = 0; i < len; i++) { for(i = 0; i < len; i++) {
int j; int j;
BYTE b = cmd[i]; uint8_t b = cmd[i];
// Start bit // Start bit
ToSendStuffBit(0); ToSendStuffBit(0);
@ -126,12 +127,12 @@ static struct {
STATE_RECEIVING_DATA, STATE_RECEIVING_DATA,
STATE_ERROR_WAIT STATE_ERROR_WAIT
} state; } state;
WORD shiftReg; uint16_t shiftReg;
int bitCnt; int bitCnt;
int byteCnt; int byteCnt;
int byteCntMax; int byteCntMax;
int posCnt; int posCnt;
BYTE *output; uint8_t *output;
} Uart; } Uart;
/* Receive & handle a bit coming from the reader. /* Receive & handle a bit coming from the reader.
@ -143,7 +144,7 @@ static struct {
* Returns: true if we received a EOF * Returns: true if we received a EOF
* false if we are still waiting for some more * false if we are still waiting for some more
*/ */
static BOOL Handle14443UartBit(int bit) static int Handle14443UartBit(int bit)
{ {
switch(Uart.state) { switch(Uart.state) {
case STATE_UNSYNCD: case STATE_UNSYNCD:
@ -275,9 +276,9 @@ static BOOL Handle14443UartBit(int bit)
// Assume that we're called with the SSC (to the FPGA) and ADC path set // Assume that we're called with the SSC (to the FPGA) and ADC path set
// correctly. // correctly.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static BOOL GetIso14443CommandFromReader(BYTE *received, int *len, int maxLen) static int GetIso14443CommandFromReader(uint8_t *received, int *len, int maxLen)
{ {
BYTE mask; uint8_t mask;
int i, bit; int i, bit;
// Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen // Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen
@ -302,7 +303,7 @@ static BOOL GetIso14443CommandFromReader(BYTE *received, int *len, int maxLen)
AT91C_BASE_SSC->SSC_THR = 0x00; AT91C_BASE_SSC->SSC_THR = 0x00;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
BYTE b = (BYTE)AT91C_BASE_SSC->SSC_RHR; uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
mask = 0x80; mask = 0x80;
for(i = 0; i < 8; i++, mask >>= 1) { for(i = 0; i < 8; i++, mask >>= 1) {
@ -322,19 +323,19 @@ static BOOL GetIso14443CommandFromReader(BYTE *received, int *len, int maxLen)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void SimulateIso14443Tag(void) void SimulateIso14443Tag(void)
{ {
static const BYTE cmd1[] = { 0x05, 0x00, 0x08, 0x39, 0x73 }; static const uint8_t cmd1[] = { 0x05, 0x00, 0x08, 0x39, 0x73 };
static const BYTE response1[] = { static const uint8_t response1[] = {
0x50, 0x82, 0x0d, 0xe1, 0x74, 0x20, 0x38, 0x19, 0x22, 0x50, 0x82, 0x0d, 0xe1, 0x74, 0x20, 0x38, 0x19, 0x22,
0x00, 0x21, 0x85, 0x5e, 0xd7 0x00, 0x21, 0x85, 0x5e, 0xd7
}; };
BYTE *resp; uint8_t *resp;
int respLen; int respLen;
BYTE *resp1 = (((BYTE *)BigBuf) + 800); uint8_t *resp1 = (((uint8_t *)BigBuf) + 800);
int resp1Len; int resp1Len;
BYTE *receivedCmd = (BYTE *)BigBuf; uint8_t *receivedCmd = (uint8_t *)BigBuf;
int len; int len;
int i; int i;
@ -353,7 +354,7 @@ void SimulateIso14443Tag(void)
cmdsRecvd = 0; cmdsRecvd = 0;
for(;;) { for(;;) {
BYTE b1, b2; uint8_t b1, b2;
if(!GetIso14443CommandFromReader(receivedCmd, &len, 100)) { if(!GetIso14443CommandFromReader(receivedCmd, &len, 100)) {
Dbprintf("button pressed, received %d commands", cmdsRecvd); Dbprintf("button pressed, received %d commands", cmdsRecvd);
@ -400,7 +401,7 @@ void SimulateIso14443Tag(void)
i = 0; i = 0;
for(;;) { for(;;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
BYTE b = resp[i]; uint8_t b = resp[i];
AT91C_BASE_SSC->SSC_THR = b; AT91C_BASE_SSC->SSC_THR = b;
@ -410,7 +411,7 @@ void SimulateIso14443Tag(void)
} }
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile BYTE b = (BYTE)AT91C_BASE_SSC->SSC_RHR; volatile uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
(void)b; (void)b;
} }
} }
@ -439,8 +440,8 @@ static struct {
int thisBit; int thisBit;
int metric; int metric;
int metricN; int metricN;
WORD shiftReg; uint16_t shiftReg;
BYTE *output; uint8_t *output;
int len; int len;
int sumI; int sumI;
int sumQ; int sumQ;
@ -457,7 +458,7 @@ static struct {
* false if we are still waiting for some more * false if we are still waiting for some more
* *
*/ */
static BOOL Handle14443SamplesDemod(int ci, int cq) static int Handle14443SamplesDemod(int ci, int cq)
{ {
int v; int v;
@ -581,9 +582,9 @@ static BOOL Handle14443SamplesDemod(int ci, int cq)
Demod.bitCount++; Demod.bitCount++;
if(Demod.bitCount == 10) { if(Demod.bitCount == 10) {
WORD s = Demod.shiftReg; uint16_t s = Demod.shiftReg;
if((s & 0x200) && !(s & 0x001)) { if((s & 0x200) && !(s & 0x001)) {
BYTE b = (s >> 1); uint8_t b = (s >> 1);
Demod.output[Demod.len] = b; Demod.output[Demod.len] = b;
Demod.len++; Demod.len++;
Demod.state = DEMOD_AWAITING_START_BIT; Demod.state = DEMOD_AWAITING_START_BIT;
@ -615,16 +616,16 @@ static BOOL Handle14443SamplesDemod(int ci, int cq)
* set to 'FALSE' if we behave like a snooper * set to 'FALSE' if we behave like a snooper
* quiet: set to 'TRUE' to disable debug output * quiet: set to 'TRUE' to disable debug output
*/ */
static void GetSamplesFor14443Demod(BOOL weTx, int n, BOOL quiet) static void GetSamplesFor14443Demod(int weTx, int n, int quiet)
{ {
int max = 0; int max = 0;
BOOL gotFrame = FALSE; int gotFrame = FALSE;
//# define DMA_BUFFER_SIZE 8 //# define DMA_BUFFER_SIZE 8
SBYTE *dmaBuf; int8_t *dmaBuf;
int lastRxCounter; int lastRxCounter;
SBYTE *upTo; int8_t *upTo;
int ci, cq; int ci, cq;
@ -632,20 +633,20 @@ static void GetSamplesFor14443Demod(BOOL weTx, int n, BOOL quiet)
// Clear out the state of the "UART" that receives from the tag. // Clear out the state of the "UART" that receives from the tag.
memset(BigBuf, 0x44, 400); memset(BigBuf, 0x44, 400);
Demod.output = (BYTE *)BigBuf; Demod.output = (uint8_t *)BigBuf;
Demod.len = 0; Demod.len = 0;
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
// And the UART that receives from the reader // And the UART that receives from the reader
Uart.output = (((BYTE *)BigBuf) + 1024); Uart.output = (((uint8_t *)BigBuf) + 1024);
Uart.byteCntMax = 100; Uart.byteCntMax = 100;
Uart.state = STATE_UNSYNCD; Uart.state = STATE_UNSYNCD;
// Setup for the DMA. // Setup for the DMA.
dmaBuf = (SBYTE *)(BigBuf + 32); dmaBuf = (int8_t *)(BigBuf + 32);
upTo = dmaBuf; upTo = dmaBuf;
lastRxCounter = DMA_BUFFER_SIZE; lastRxCounter = DMA_BUFFER_SIZE;
FpgaSetupSscDma((BYTE *)dmaBuf, DMA_BUFFER_SIZE); FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE);
// Signal field is ON with the appropriate LED: // Signal field is ON with the appropriate LED:
if (weTx) LED_D_ON(); else LED_D_OFF(); if (weTx) LED_D_ON(); else LED_D_OFF();
@ -666,7 +667,7 @@ static void GetSamplesFor14443Demod(BOOL weTx, int n, BOOL quiet)
upTo += 2; upTo += 2;
if(upTo - dmaBuf > DMA_BUFFER_SIZE) { if(upTo - dmaBuf > DMA_BUFFER_SIZE) {
upTo -= DMA_BUFFER_SIZE; upTo -= DMA_BUFFER_SIZE;
AT91C_BASE_PDC_SSC->PDC_RNPR = (DWORD)upTo; AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) upTo;
AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE; AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
} }
lastRxCounter -= 2; lastRxCounter -= 2;
@ -697,9 +698,9 @@ static void GetSamplesFor14443Demod(BOOL weTx, int n, BOOL quiet)
// samples from the FPGA, which we will later do some signal processing on, // samples from the FPGA, which we will later do some signal processing on,
// to get the bits. // to get the bits.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/*static void GetSamplesFor14443(BOOL weTx, int n) /*static void GetSamplesFor14443(int weTx, int n)
{ {
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int c; int c;
FpgaWriteConfWord( FpgaWriteConfWord(
@ -712,10 +713,10 @@ static void GetSamplesFor14443Demod(BOOL weTx, int n, BOOL quiet)
AT91C_BASE_SSC->SSC_THR = 0x43; AT91C_BASE_SSC->SSC_THR = 0x43;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
SBYTE b; int8_t b;
b = (SBYTE)AT91C_BASE_SSC->SSC_RHR; b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
dest[c++] = (BYTE)b; dest[c++] = (uint8_t)b;
if(c >= n) { if(c >= n) {
break; break;
@ -750,7 +751,7 @@ static void TransmitFor14443(void)
c++; c++;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -766,7 +767,7 @@ static void TransmitFor14443(void)
} }
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -778,10 +779,10 @@ static void TransmitFor14443(void)
// Code a layer 2 command (string of octets, including CRC) into ToSend[], // Code a layer 2 command (string of octets, including CRC) into ToSend[],
// so that it is ready to transmit to the tag using TransmitFor14443(). // so that it is ready to transmit to the tag using TransmitFor14443().
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CodeIso14443bAsReader(const BYTE *cmd, int len) void CodeIso14443bAsReader(const uint8_t *cmd, int len)
{ {
int i, j; int i, j;
BYTE b; uint8_t b;
ToSendReset(); ToSendReset();
@ -836,9 +837,9 @@ void CodeIso14443bAsReader(const BYTE *cmd, int len)
// The command name is misleading, it actually decodes the reponse in HEX // The command name is misleading, it actually decodes the reponse in HEX
// into the output buffer (read the result using hexsamples, not hisamples) // into the output buffer (read the result using hexsamples, not hisamples)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void AcquireRawAdcSamplesIso14443(DWORD parameter) void AcquireRawAdcSamplesIso14443(uint32_t parameter)
{ {
BYTE cmd1[] = { 0x05, 0x00, 0x08, 0x39, 0x73 }; uint8_t cmd1[] = { 0x05, 0x00, 0x08, 0x39, 0x73 };
// Make sure that we start from off, since the tags are stateful; // Make sure that we start from off, since the tags are stateful;
// confusing things will happen if we don't reset them between reads. // confusing things will happen if we don't reset them between reads.
@ -872,18 +873,18 @@ void AcquireRawAdcSamplesIso14443(DWORD parameter)
// //
// I tried to be systematic and check every answer of the tag, every CRC, etc... // I tried to be systematic and check every answer of the tag, every CRC, etc...
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ReadSRI512Iso14443(DWORD parameter) void ReadSRI512Iso14443(uint32_t parameter)
{ {
ReadSTMemoryIso14443(parameter,0x0F); ReadSTMemoryIso14443(parameter,0x0F);
} }
void ReadSRIX4KIso14443(DWORD parameter) void ReadSRIX4KIso14443(uint32_t parameter)
{ {
ReadSTMemoryIso14443(parameter,0x7F); ReadSTMemoryIso14443(parameter,0x7F);
} }
void ReadSTMemoryIso14443(DWORD parameter,DWORD dwLast) void ReadSTMemoryIso14443(uint32_t parameter,uint32_t dwLast)
{ {
BYTE i = 0x00; uint8_t i = 0x00;
// Make sure that we start from off, since the tags are stateful; // Make sure that we start from off, since the tags are stateful;
// confusing things will happen if we don't reset them between reads. // confusing things will happen if we don't reset them between reads.
@ -902,7 +903,7 @@ void ReadSTMemoryIso14443(DWORD parameter,DWORD dwLast)
SpinDelay(200); SpinDelay(200);
// First command: wake up the tag using the INITIATE command // First command: wake up the tag using the INITIATE command
BYTE cmd1[] = { 0x06, 0x00, 0x97, 0x5b}; uint8_t cmd1[] = { 0x06, 0x00, 0x97, 0x5b};
CodeIso14443bAsReader(cmd1, sizeof(cmd1)); CodeIso14443bAsReader(cmd1, sizeof(cmd1));
TransmitFor14443(); TransmitFor14443();
// LED_A_ON(); // LED_A_ON();
@ -1027,22 +1028,22 @@ void SnoopIso14443(void)
// We won't start recording the frames that we acquire until we trigger; // We won't start recording the frames that we acquire until we trigger;
// a good trigger condition to get started is probably when we see a // a good trigger condition to get started is probably when we see a
// response from the tag. // response from the tag.
BOOL triggered = FALSE; int triggered = FALSE;
// The command (reader -> tag) that we're working on receiving. // The command (reader -> tag) that we're working on receiving.
BYTE *receivedCmd = (BYTE *)(BigBuf) + DEMOD_TRACE_SIZE; uint8_t *receivedCmd = (uint8_t *)(BigBuf) + DEMOD_TRACE_SIZE;
// The response (tag -> reader) that we're working on receiving. // The response (tag -> reader) that we're working on receiving.
BYTE *receivedResponse = (BYTE *)(BigBuf) + DEMOD_TRACE_SIZE + READER_TAG_BUFFER_SIZE; uint8_t *receivedResponse = (uint8_t *)(BigBuf) + DEMOD_TRACE_SIZE + READER_TAG_BUFFER_SIZE;
// As we receive stuff, we copy it from receivedCmd or receivedResponse // As we receive stuff, we copy it from receivedCmd or receivedResponse
// into trace, along with its length and other annotations. // into trace, along with its length and other annotations.
BYTE *trace = (BYTE *)BigBuf; uint8_t *trace = (uint8_t *)BigBuf;
int traceLen = 0; int traceLen = 0;
// The DMA buffer, used to stream samples from the FPGA. // The DMA buffer, used to stream samples from the FPGA.
SBYTE *dmaBuf = (SBYTE *)(BigBuf) + DEMOD_TRACE_SIZE + READER_TAG_BUFFER_SIZE + TAG_READER_BUFFER_SIZE; int8_t *dmaBuf = (int8_t *)(BigBuf) + DEMOD_TRACE_SIZE + READER_TAG_BUFFER_SIZE + TAG_READER_BUFFER_SIZE;
int lastRxCounter; int lastRxCounter;
SBYTE *upTo; int8_t *upTo;
int ci, cq; int ci, cq;
int maxBehindBy = 0; int maxBehindBy = 0;
@ -1087,7 +1088,7 @@ void SnoopIso14443(void)
FpgaSetupSsc(); FpgaSetupSsc();
upTo = dmaBuf; upTo = dmaBuf;
lastRxCounter = DMA_BUFFER_SIZE; lastRxCounter = DMA_BUFFER_SIZE;
FpgaSetupSscDma((BYTE *)dmaBuf, DMA_BUFFER_SIZE); FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE);
// And now we loop, receiving samples. // And now we loop, receiving samples.
for(;;) { for(;;) {
// Blink the LED while Snooping // Blink the LED while Snooping
@ -1118,7 +1119,7 @@ void SnoopIso14443(void)
if(upTo - dmaBuf > DMA_BUFFER_SIZE) { if(upTo - dmaBuf > DMA_BUFFER_SIZE) {
upTo -= DMA_BUFFER_SIZE; upTo -= DMA_BUFFER_SIZE;
lastRxCounter += DMA_BUFFER_SIZE; lastRxCounter += DMA_BUFFER_SIZE;
AT91C_BASE_PDC_SSC->PDC_RNPR = (DWORD) upTo; AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) upTo;
AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE; AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
} }

173
armsrc/iso14443a.c
View file

@ -5,12 +5,13 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "apps.h"
#include "util.h"
#include "iso14443crc.h" #include "iso14443crc.h"
static BYTE *trace = (BYTE *) BigBuf; static uint8_t *trace = (uint8_t *) BigBuf;
static int traceLen = 0; static int traceLen = 0;
static int rsamples = 0; static int rsamples = 0;
static BOOL tracing = TRUE; static int tracing = TRUE;
typedef enum { typedef enum {
SEC_D = 1, SEC_D = 1,
@ -21,7 +22,7 @@ typedef enum {
SEC_Z = 6 SEC_Z = 6
} SecType; } SecType;
static const BYTE OddByteParity[256] = { static const uint8_t OddByteParity[256] = {
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
@ -51,10 +52,10 @@ static const BYTE OddByteParity[256] = {
// Generate the parity value for a byte sequence // Generate the parity value for a byte sequence
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
DWORD GetParity(const BYTE * pbtCmd, int iLen) uint32_t GetParity(const uint8_t * pbtCmd, int iLen)
{ {
int i; int i;
DWORD dwPar = 0; uint32_t dwPar = 0;
// Generate the encrypted data // Generate the encrypted data
for (i = 0; i < iLen; i++) { for (i = 0; i < iLen; i++) {
@ -64,12 +65,12 @@ DWORD GetParity(const BYTE * pbtCmd, int iLen)
return dwPar; return dwPar;
} }
static void AppendCrc14443a(BYTE* data, int len) static void AppendCrc14443a(uint8_t* data, int len)
{ {
ComputeCrc14443(CRC_14443_A,data,len,data+len,data+len+1); ComputeCrc14443(CRC_14443_A,data,len,data+len,data+len+1);
} }
BOOL LogTrace(const BYTE * btBytes, int iLen, int iSamples, DWORD dwParity, BOOL bReader) int LogTrace(const uint8_t * btBytes, int iLen, int iSamples, uint32_t dwParity, int bReader)
{ {
// Return when trace is full // Return when trace is full
if (traceLen >= TRACE_LENGTH) return FALSE; if (traceLen >= TRACE_LENGTH) return FALSE;
@ -93,7 +94,7 @@ BOOL LogTrace(const BYTE * btBytes, int iLen, int iSamples, DWORD dwParity, BOOL
return TRUE; return TRUE;
} }
BOOL LogTraceInfo(byte_t* data, size_t len) int LogTraceInfo(byte_t* data, size_t len)
{ {
return LogTrace(data,len,0,GetParity(data,len),TRUE); return LogTrace(data,len,0,GetParity(data,len),TRUE);
} }
@ -111,7 +112,7 @@ static struct {
STATE_MILLER_Z, STATE_MILLER_Z,
STATE_ERROR_WAIT STATE_ERROR_WAIT
} state; } state;
WORD shiftReg; uint16_t shiftReg;
int bitCnt; int bitCnt;
int byteCnt; int byteCnt;
int byteCntMax; int byteCntMax;
@ -126,10 +127,10 @@ static struct {
DROP_FIRST_HALF, DROP_FIRST_HALF,
DROP_SECOND_HALF DROP_SECOND_HALF
} drop; } drop;
BYTE *output; uint8_t *output;
} Uart; } Uart;
static BOOL MillerDecoding(int bit) static int MillerDecoding(int bit)
{ {
int error = 0; int error = 0;
int bitright; int bitright;
@ -143,7 +144,7 @@ static BOOL MillerDecoding(int bit)
Uart.bitBuffer ^= bit; Uart.bitBuffer ^= bit;
} }
BOOL EOC = FALSE; int EOC = FALSE;
if(Uart.state != STATE_UNSYNCD) { if(Uart.state != STATE_UNSYNCD) {
Uart.posCnt++; Uart.posCnt++;
@ -380,7 +381,7 @@ static struct {
int posCount; int posCount;
int syncBit; int syncBit;
int parityBits; int parityBits;
WORD shiftReg; uint16_t shiftReg;
int buffer; int buffer;
int buff; int buff;
int samples; int samples;
@ -390,10 +391,10 @@ static struct {
SUB_FIRST_HALF, SUB_FIRST_HALF,
SUB_SECOND_HALF SUB_SECOND_HALF
} sub; } sub;
BYTE *output; uint8_t *output;
} Demod; } Demod;
static BOOL ManchesterDecoding(int v) static int ManchesterDecoding(int v)
{ {
int bit; int bit;
int modulation; int modulation;
@ -600,24 +601,24 @@ void SnoopIso14443a(void)
// We won't start recording the frames that we acquire until we trigger; // We won't start recording the frames that we acquire until we trigger;
// a good trigger condition to get started is probably when we see a // a good trigger condition to get started is probably when we see a
// response from the tag. // response from the tag.
BOOL triggered = TRUE; // FALSE to wait first for card int triggered = TRUE; // FALSE to wait first for card
// The command (reader -> tag) that we're receiving. // The command (reader -> tag) that we're receiving.
// The length of a received command will in most cases be no more than 18 bytes. // The length of a received command will in most cases be no more than 18 bytes.
// So 32 should be enough! // So 32 should be enough!
BYTE *receivedCmd = (((BYTE *)BigBuf) + RECV_CMD_OFFSET); uint8_t *receivedCmd = (((uint8_t *)BigBuf) + RECV_CMD_OFFSET);
// The response (tag -> reader) that we're receiving. // The response (tag -> reader) that we're receiving.
BYTE *receivedResponse = (((BYTE *)BigBuf) + RECV_RES_OFFSET); uint8_t *receivedResponse = (((uint8_t *)BigBuf) + RECV_RES_OFFSET);
// As we receive stuff, we copy it from receivedCmd or receivedResponse // As we receive stuff, we copy it from receivedCmd or receivedResponse
// into trace, along with its length and other annotations. // into trace, along with its length and other annotations.
//BYTE *trace = (BYTE *)BigBuf; //uint8_t *trace = (uint8_t *)BigBuf;
//int traceLen = 0; //int traceLen = 0;
// The DMA buffer, used to stream samples from the FPGA // The DMA buffer, used to stream samples from the FPGA
SBYTE *dmaBuf = ((SBYTE *)BigBuf) + DMA_BUFFER_OFFSET; int8_t *dmaBuf = ((int8_t *)BigBuf) + DMA_BUFFER_OFFSET;
int lastRxCounter; int lastRxCounter;
SBYTE *upTo; int8_t *upTo;
int smpl; int smpl;
int maxBehindBy = 0; int maxBehindBy = 0;
@ -649,7 +650,7 @@ void SnoopIso14443a(void)
FpgaSetupSsc(); FpgaSetupSsc();
upTo = dmaBuf; upTo = dmaBuf;
lastRxCounter = DMA_BUFFER_SIZE; lastRxCounter = DMA_BUFFER_SIZE;
FpgaSetupSscDma((BYTE *)dmaBuf, DMA_BUFFER_SIZE); FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE);
LED_A_ON(); LED_A_ON();
@ -673,7 +674,7 @@ void SnoopIso14443a(void)
if(upTo - dmaBuf > DMA_BUFFER_SIZE) { if(upTo - dmaBuf > DMA_BUFFER_SIZE) {
upTo -= DMA_BUFFER_SIZE; upTo -= DMA_BUFFER_SIZE;
lastRxCounter += DMA_BUFFER_SIZE; lastRxCounter += DMA_BUFFER_SIZE;
AT91C_BASE_PDC_SSC->PDC_RNPR = (DWORD)upTo; AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) upTo;
AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE; AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
} }
@ -798,7 +799,7 @@ void Sequence(SecType seq)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Prepare tag messages // Prepare tag messages
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void CodeIso14443aAsTag(const BYTE *cmd, int len) static void CodeIso14443aAsTag(const uint8_t *cmd, int len)
{ {
int i; int i;
int oddparity; int oddparity;
@ -820,7 +821,7 @@ static void CodeIso14443aAsTag(const BYTE *cmd, int len)
for(i = 0; i < len; i++) { for(i = 0; i < len; i++) {
int j; int j;
BYTE b = cmd[i]; uint8_t b = cmd[i];
// Data bits // Data bits
oddparity = 0x01; oddparity = 0x01;
@ -912,7 +913,7 @@ static void CodeStrangeAnswer()
// Stop when button is pressed // Stop when button is pressed
// Or return TRUE when command is captured // Or return TRUE when command is captured
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static BOOL GetIso14443aCommandFromReader(BYTE *received, int *len, int maxLen) static int GetIso14443aCommandFromReader(uint8_t *received, int *len, int maxLen)
{ {
// Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen // Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen
// only, since we are receiving, not transmitting). // only, since we are receiving, not transmitting).
@ -934,7 +935,7 @@ static BOOL GetIso14443aCommandFromReader(BYTE *received, int *len, int maxLen)
AT91C_BASE_SSC->SSC_THR = 0x00; AT91C_BASE_SSC->SSC_THR = 0x00;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
BYTE b = (BYTE)AT91C_BASE_SSC->SSC_RHR; uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
if(MillerDecoding((b & 0xf0) >> 4)) { if(MillerDecoding((b & 0xf0) >> 4)) {
*len = Uart.byteCnt; *len = Uart.byteCnt;
return TRUE; return TRUE;
@ -956,40 +957,40 @@ void SimulateIso14443aTag(int tagType, int TagUid)
// This function contains the tag emulation // This function contains the tag emulation
// Prepare protocol messages // Prepare protocol messages
// static const BYTE cmd1[] = { 0x26 }; // static const uint8_t cmd1[] = { 0x26 };
// static const BYTE response1[] = { 0x02, 0x00 }; // Says: I am Mifare 4k - original line - greg // static const uint8_t response1[] = { 0x02, 0x00 }; // Says: I am Mifare 4k - original line - greg
// //
static const BYTE response1[] = { 0x44, 0x03 }; // Says: I am a DESFire Tag, ph33r me static const uint8_t response1[] = { 0x44, 0x03 }; // Says: I am a DESFire Tag, ph33r me
// static const BYTE response1[] = { 0x44, 0x00 }; // Says: I am a ULTRALITE Tag, 0wn me // static const uint8_t response1[] = { 0x44, 0x00 }; // Says: I am a ULTRALITE Tag, 0wn me
// UID response // UID response
// static const BYTE cmd2[] = { 0x93, 0x20 }; // static const uint8_t cmd2[] = { 0x93, 0x20 };
//static const BYTE response2[] = { 0x9a, 0xe5, 0xe4, 0x43, 0xd8 }; // original value - greg //static const uint8_t response2[] = { 0x9a, 0xe5, 0xe4, 0x43, 0xd8 }; // original value - greg
// my desfire // my desfire
static const BYTE response2[] = { 0x88, 0x04, 0x21, 0x3f, 0x4d }; // known uid - note cascade (0x88), 2nd byte (0x04) = NXP/Phillips static const uint8_t response2[] = { 0x88, 0x04, 0x21, 0x3f, 0x4d }; // known uid - note cascade (0x88), 2nd byte (0x04) = NXP/Phillips
// When reader selects us during cascade1 it will send cmd3 // When reader selects us during cascade1 it will send cmd3
//BYTE response3[] = { 0x04, 0x00, 0x00 }; // SAK Select (cascade1) successful response (ULTRALITE) //uint8_t response3[] = { 0x04, 0x00, 0x00 }; // SAK Select (cascade1) successful response (ULTRALITE)
BYTE response3[] = { 0x24, 0x00, 0x00 }; // SAK Select (cascade1) successful response (DESFire) uint8_t response3[] = { 0x24, 0x00, 0x00 }; // SAK Select (cascade1) successful response (DESFire)
ComputeCrc14443(CRC_14443_A, response3, 1, &response3[1], &response3[2]); ComputeCrc14443(CRC_14443_A, response3, 1, &response3[1], &response3[2]);
// send cascade2 2nd half of UID // send cascade2 2nd half of UID
static const BYTE response2a[] = { 0x51, 0x48, 0x1d, 0x80, 0x84 }; // uid - cascade2 - 2nd half (4 bytes) of UID+ BCCheck static const uint8_t response2a[] = { 0x51, 0x48, 0x1d, 0x80, 0x84 }; // uid - cascade2 - 2nd half (4 bytes) of UID+ BCCheck
// NOTE : THE CRC on the above may be wrong as I have obfuscated the actual UID // NOTE : THE CRC on the above may be wrong as I have obfuscated the actual UID
// When reader selects us during cascade2 it will send cmd3a // When reader selects us during cascade2 it will send cmd3a
//BYTE response3a[] = { 0x00, 0x00, 0x00 }; // SAK Select (cascade2) successful response (ULTRALITE) //uint8_t response3a[] = { 0x00, 0x00, 0x00 }; // SAK Select (cascade2) successful response (ULTRALITE)
BYTE response3a[] = { 0x20, 0x00, 0x00 }; // SAK Select (cascade2) successful response (DESFire) uint8_t response3a[] = { 0x20, 0x00, 0x00 }; // SAK Select (cascade2) successful response (DESFire)
ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]); ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]);
static const BYTE response5[] = { 0x00, 0x00, 0x00, 0x00 }; // Very random tag nonce static const uint8_t response5[] = { 0x00, 0x00, 0x00, 0x00 }; // Very random tag nonce
BYTE *resp; uint8_t *resp;
int respLen; int respLen;
// Longest possible response will be 16 bytes + 2 CRC = 18 bytes // Longest possible response will be 16 bytes + 2 CRC = 18 bytes
@ -1007,40 +1008,40 @@ ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]);
// Respond with card type // Respond with card type
BYTE *resp1 = (((BYTE *)BigBuf) + 800); uint8_t *resp1 = (((uint8_t *)BigBuf) + 800);
int resp1Len; int resp1Len;
// Anticollision cascade1 - respond with uid // Anticollision cascade1 - respond with uid
BYTE *resp2 = (((BYTE *)BigBuf) + 970); uint8_t *resp2 = (((uint8_t *)BigBuf) + 970);
int resp2Len; int resp2Len;
// Anticollision cascade2 - respond with 2nd half of uid if asked // Anticollision cascade2 - respond with 2nd half of uid if asked
// we're only going to be asked if we set the 1st byte of the UID (during cascade1) to 0x88 // we're only going to be asked if we set the 1st byte of the UID (during cascade1) to 0x88
BYTE *resp2a = (((BYTE *)BigBuf) + 1140); uint8_t *resp2a = (((uint8_t *)BigBuf) + 1140);
int resp2aLen; int resp2aLen;
// Acknowledge select - cascade 1 // Acknowledge select - cascade 1
BYTE *resp3 = (((BYTE *)BigBuf) + 1310); uint8_t *resp3 = (((uint8_t *)BigBuf) + 1310);
int resp3Len; int resp3Len;
// Acknowledge select - cascade 2 // Acknowledge select - cascade 2
BYTE *resp3a = (((BYTE *)BigBuf) + 1480); uint8_t *resp3a = (((uint8_t *)BigBuf) + 1480);
int resp3aLen; int resp3aLen;
// Response to a read request - not implemented atm // Response to a read request - not implemented atm
BYTE *resp4 = (((BYTE *)BigBuf) + 1550); uint8_t *resp4 = (((uint8_t *)BigBuf) + 1550);
int resp4Len; int resp4Len;
// Authenticate response - nonce // Authenticate response - nonce
BYTE *resp5 = (((BYTE *)BigBuf) + 1720); uint8_t *resp5 = (((uint8_t *)BigBuf) + 1720);
int resp5Len; int resp5Len;
BYTE *receivedCmd = (BYTE *)BigBuf; uint8_t *receivedCmd = (uint8_t *)BigBuf;
int len; int len;
int i; int i;
int u; int u;
BYTE b; uint8_t b;
// To control where we are in the protocol // To control where we are in the protocol
int order = 0; int order = 0;
@ -1052,7 +1053,7 @@ ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]);
int cmdsRecvd = 0; int cmdsRecvd = 0;
BOOL fdt_indicator; int fdt_indicator;
memset(receivedCmd, 0x44, 400); memset(receivedCmd, 0x44, 400);
@ -1209,7 +1210,7 @@ ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]);
fdt_indicator = FALSE; fdt_indicator = FALSE;
for(;;) { for(;;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile BYTE b = (BYTE)AT91C_BASE_SSC->SSC_RHR; volatile uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
(void)b; (void)b;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
@ -1240,7 +1241,7 @@ ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]);
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Transmit the command (to the tag) that was placed in ToSend[]. // Transmit the command (to the tag) that was placed in ToSend[].
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void TransmitFor14443a(const BYTE *cmd, int len, int *samples, int *wait) static void TransmitFor14443a(const uint8_t *cmd, int len, int *samples, int *wait)
{ {
int c; int c;
@ -1256,7 +1257,7 @@ static void TransmitFor14443a(const BYTE *cmd, int len, int *samples, int *wait)
c++; c++;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -1272,7 +1273,7 @@ static void TransmitFor14443a(const BYTE *cmd, int len, int *samples, int *wait)
} }
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -1284,12 +1285,12 @@ static void TransmitFor14443a(const BYTE *cmd, int len, int *samples, int *wait)
// To generate an arbitrary stream from reader // To generate an arbitrary stream from reader
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ArbitraryFromReader(const BYTE *cmd, int parity, int len) void ArbitraryFromReader(const uint8_t *cmd, int parity, int len)
{ {
int i; int i;
int j; int j;
int last; int last;
BYTE b; uint8_t b;
ToSendReset(); ToSendReset();
@ -1364,11 +1365,11 @@ void ArbitraryFromReader(const BYTE *cmd, int parity, int len)
// Code a 7-bit command without parity bit // Code a 7-bit command without parity bit
// This is especially for 0x26 and 0x52 (REQA and WUPA) // This is especially for 0x26 and 0x52 (REQA and WUPA)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ShortFrameFromReader(const BYTE bt) void ShortFrameFromReader(const uint8_t bt)
{ {
int j; int j;
int last; int last;
BYTE b; uint8_t b;
ToSendReset(); ToSendReset();
@ -1422,11 +1423,11 @@ void ShortFrameFromReader(const BYTE bt)
// Prepare reader command to send to FPGA // Prepare reader command to send to FPGA
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void CodeIso14443aAsReaderPar(const BYTE * cmd, int len, DWORD dwParity) void CodeIso14443aAsReaderPar(const uint8_t * cmd, int len, uint32_t dwParity)
{ {
int i, j; int i, j;
int last; int last;
BYTE b; uint8_t b;
ToSendReset(); ToSendReset();
@ -1500,7 +1501,7 @@ void CodeIso14443aAsReaderPar(const BYTE * cmd, int len, DWORD dwParity)
// If a response is captured return TRUE // If a response is captured return TRUE
// If it takes to long return FALSE // If it takes to long return FALSE
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static BOOL GetIso14443aAnswerFromTag(BYTE *receivedResponse, int maxLen, int *samples, int *elapsed) //BYTE *buffer static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed) //uint8_t *buffer
{ {
// buffer needs to be 512 bytes // buffer needs to be 512 bytes
int c; int c;
@ -1516,7 +1517,7 @@ static BOOL GetIso14443aAnswerFromTag(BYTE *receivedResponse, int maxLen, int *s
Demod.len = 0; Demod.len = 0;
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
BYTE b; uint8_t b;
if (elapsed) *elapsed = 0; if (elapsed) *elapsed = 0;
c = 0; c = 0;
@ -1529,7 +1530,7 @@ static BOOL GetIso14443aAnswerFromTag(BYTE *receivedResponse, int maxLen, int *s
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
if(c < 512) { c++; } else { return FALSE; } if(c < 512) { c++; } else { return FALSE; }
b = (BYTE)AT91C_BASE_SSC->SSC_RHR; b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
if(ManchesterDecoding((b & 0xf0) >> 4)) { if(ManchesterDecoding((b & 0xf0) >> 4)) {
*samples = ((c - 1) << 3) + 4; *samples = ((c - 1) << 3) + 4;
return TRUE; return TRUE;
@ -1542,7 +1543,7 @@ static BOOL GetIso14443aAnswerFromTag(BYTE *receivedResponse, int maxLen, int *s
} }
} }
void ReaderTransmitShort(const BYTE* bt) void ReaderTransmitShort(const uint8_t* bt)
{ {
int wait = 0; int wait = 0;
int samples = 0; int samples = 0;
@ -1556,13 +1557,13 @@ void ReaderTransmitShort(const BYTE* bt)
if (tracing) LogTrace(bt,1,0,GetParity(bt,1),TRUE); if (tracing) LogTrace(bt,1,0,GetParity(bt,1),TRUE);
} }
void ReaderTransmitPar(BYTE* frame, int len, DWORD par) void ReaderTransmitPar(uint8_t* frame, int len, uint32_t par)
{ {
int wait = 0; int wait = 0;
int samples = 0; int samples = 0;
// This is tied to other size changes // This is tied to other size changes
// BYTE* frame_addr = ((BYTE*)BigBuf) + 2024; // uint8_t* frame_addr = ((uint8_t*)BigBuf) + 2024;
CodeIso14443aAsReaderPar(frame,len,par); CodeIso14443aAsReaderPar(frame,len,par);
// Select the card // Select the card
@ -1573,13 +1574,13 @@ void ReaderTransmitPar(BYTE* frame, int len, DWORD par)
} }
void ReaderTransmit(BYTE* frame, int len) void ReaderTransmit(uint8_t* frame, int len)
{ {
// Generate parity and redirect // Generate parity and redirect
ReaderTransmitPar(frame,len,GetParity(frame,len)); ReaderTransmitPar(frame,len,GetParity(frame,len));
} }
BOOL ReaderReceive(BYTE* receivedAnswer) int ReaderReceive(uint8_t* receivedAnswer)
{ {
int samples = 0; int samples = 0;
if (!GetIso14443aAnswerFromTag(receivedAnswer,100,&samples,0)) return FALSE; if (!GetIso14443aAnswerFromTag(receivedAnswer,100,&samples,0)) return FALSE;
@ -1591,20 +1592,20 @@ BOOL ReaderReceive(BYTE* receivedAnswer)
// Read an ISO 14443a tag. Send out commands and store answers. // Read an ISO 14443a tag. Send out commands and store answers.
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ReaderIso14443a(DWORD parameter) void ReaderIso14443a(uint32_t parameter)
{ {
// Anticollision // Anticollision
BYTE wupa[] = { 0x52 }; uint8_t wupa[] = { 0x52 };
BYTE sel_all[] = { 0x93,0x20 }; uint8_t sel_all[] = { 0x93,0x20 };
BYTE sel_uid[] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; uint8_t sel_uid[] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
BYTE sel_all_c2[] = { 0x95,0x20 }; uint8_t sel_all_c2[] = { 0x95,0x20 };
BYTE sel_uid_c2[] = { 0x95,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; uint8_t sel_uid_c2[] = { 0x95,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
// Mifare AUTH // Mifare AUTH
BYTE mf_auth[] = { 0x60,0x00,0xf5,0x7b }; uint8_t mf_auth[] = { 0x60,0x00,0xf5,0x7b };
// BYTE mf_nr_ar[] = { 0x00,0x00,0x00,0x00 }; // uint8_t mf_nr_ar[] = { 0x00,0x00,0x00,0x00 };
BYTE* receivedAnswer = (((BYTE *)BigBuf) + 3560); // was 3560 - tied to other size changes uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + 3560); // was 3560 - tied to other size changes
traceLen = 0; traceLen = 0;
// Setup SSC // Setup SSC
@ -1701,19 +1702,19 @@ void ReaderIso14443a(DWORD parameter)
// Read an ISO 14443a tag. Send out commands and store answers. // Read an ISO 14443a tag. Send out commands and store answers.
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ReaderMifare(DWORD parameter) void ReaderMifare(uint32_t parameter)
{ {
// Anticollision // Anticollision
BYTE wupa[] = { 0x52 }; uint8_t wupa[] = { 0x52 };
BYTE sel_all[] = { 0x93,0x20 }; uint8_t sel_all[] = { 0x93,0x20 };
BYTE sel_uid[] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; uint8_t sel_uid[] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
// Mifare AUTH // Mifare AUTH
BYTE mf_auth[] = { 0x60,0x00,0xf5,0x7b }; uint8_t mf_auth[] = { 0x60,0x00,0xf5,0x7b };
BYTE mf_nr_ar[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; uint8_t mf_nr_ar[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
BYTE* receivedAnswer = (((BYTE *)BigBuf) + 3560); // was 3560 - tied to other size changes uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + 3560); // was 3560 - tied to other size changes
traceLen = 0; traceLen = 0;
tracing = false; tracing = false;
@ -1758,7 +1759,7 @@ void ReaderMifare(DWORD parameter)
byte_t par = 0; byte_t par = 0;
byte_t par_mask = 0xff; byte_t par_mask = 0xff;
byte_t par_low = 0; byte_t par_low = 0;
BOOL led_on = TRUE; int led_on = TRUE;
tracing = FALSE; tracing = FALSE;
byte_t nt[4]; byte_t nt[4];

135
armsrc/iso15693.c
View file

@ -9,6 +9,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "proxmark3.h" #include "proxmark3.h"
#include "util.h"
#include "apps.h" #include "apps.h"
// FROM winsrc\prox.h ////////////////////////////////// // FROM winsrc\prox.h //////////////////////////////////
@ -65,7 +66,7 @@
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
}; };
static void CodeIso15693AsReader(BYTE *cmd, int n) static void CodeIso15693AsReader(uint8_t *cmd, int n)
{ {
int i, j; int i, j;
@ -145,14 +146,14 @@ static void CodeIso15693AsReader(BYTE *cmd, int n)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// The CRC used by ISO 15693. // The CRC used by ISO 15693.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static WORD Crc(BYTE *v, int n) static uint16_t Crc(uint8_t *v, int n)
{ {
DWORD reg; uint32_t reg;
int i, j; int i, j;
reg = 0xffff; reg = 0xffff;
for(i = 0; i < n; i++) { for(i = 0; i < n; i++) {
reg = reg ^ ((DWORD)v[i]); reg = reg ^ ((uint32_t)v[i]);
for (j = 0; j < 8; j++) { for (j = 0; j < 8; j++) {
if (reg & 0x0001) { if (reg & 0x0001) {
reg = (reg >> 1) ^ 0x8408; reg = (reg >> 1) ^ 0x8408;
@ -216,9 +217,9 @@ void itoa(int n, char s[])
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void BuildIdentifyRequest(void) static void BuildIdentifyRequest(void)
{ {
BYTE cmd[5]; uint8_t cmd[5];
WORD crc; uint16_t crc;
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
// AFI is at bit 5 (1<<4) when doing an INVENTORY // AFI is at bit 5 (1<<4) when doing an INVENTORY
cmd[0] = (1 << 2) | (1 << 5) | (1 << 1); cmd[0] = (1 << 2) | (1 << 5) | (1 << 1);
@ -234,11 +235,11 @@ static void BuildIdentifyRequest(void)
CodeIso15693AsReader(cmd, sizeof(cmd)); CodeIso15693AsReader(cmd, sizeof(cmd));
} }
static void __attribute__((unused)) BuildSysInfoRequest(BYTE *uid) static void __attribute__((unused)) BuildSysInfoRequest(uint8_t *uid)
{ {
BYTE cmd[12]; uint8_t cmd[12];
WORD crc; uint16_t crc;
// If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
// followed by teh block data // followed by teh block data
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
@ -263,13 +264,13 @@ static void __attribute__((unused)) BuildSysInfoRequest(BYTE *uid)
CodeIso15693AsReader(cmd, sizeof(cmd)); CodeIso15693AsReader(cmd, sizeof(cmd));
} }
static void BuildSelectRequest( BYTE uid[]) static void BuildSelectRequest( uint8_t uid[])
{ {
// uid[6]=0x31; // this is getting ignored - the uid array is not happening... // uid[6]=0x31; // this is getting ignored - the uid array is not happening...
BYTE cmd[12]; uint8_t cmd[12];
WORD crc; uint16_t crc;
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
//cmd[0] = (1 << 2) | (1 << 5) | (1 << 1); // INVENTROY FLAGS //cmd[0] = (1 << 2) | (1 << 5) | (1 << 1); // INVENTROY FLAGS
cmd[0] = (1 << 4) | (1 << 5) | (1 << 1); // Select and addressed FLAGS cmd[0] = (1 << 4) | (1 << 5) | (1 << 1); // Select and addressed FLAGS
@ -302,11 +303,11 @@ static void BuildSelectRequest( BYTE uid[])
CodeIso15693AsReader(cmd, sizeof(cmd)); CodeIso15693AsReader(cmd, sizeof(cmd));
} }
static void __attribute__((unused)) BuildReadBlockRequest(BYTE *uid, BYTE blockNumber ) static void __attribute__((unused)) BuildReadBlockRequest(uint8_t *uid, uint8_t blockNumber )
{ {
BYTE cmd[13]; uint8_t cmd[13];
WORD crc; uint16_t crc;
// If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
// followed by teh block data // followed by teh block data
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
@ -333,11 +334,11 @@ static void __attribute__((unused)) BuildReadBlockRequest(BYTE *uid, BYTE blockN
CodeIso15693AsReader(cmd, sizeof(cmd)); CodeIso15693AsReader(cmd, sizeof(cmd));
} }
static void __attribute__((unused)) BuildReadMultiBlockRequest(BYTE *uid) static void __attribute__((unused)) BuildReadMultiBlockRequest(uint8_t *uid)
{ {
BYTE cmd[14]; uint8_t cmd[14];
WORD crc; uint16_t crc;
// If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
// followed by teh block data // followed by teh block data
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
@ -366,11 +367,11 @@ static void __attribute__((unused)) BuildReadMultiBlockRequest(BYTE *uid)
CodeIso15693AsReader(cmd, sizeof(cmd)); CodeIso15693AsReader(cmd, sizeof(cmd));
} }
static void __attribute__((unused)) BuildArbitraryRequest(BYTE *uid,BYTE CmdCode) static void __attribute__((unused)) BuildArbitraryRequest(uint8_t *uid,uint8_t CmdCode)
{ {
BYTE cmd[14]; uint8_t cmd[14];
WORD crc; uint16_t crc;
// If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
// followed by teh block data // followed by teh block data
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
@ -400,11 +401,11 @@ static void __attribute__((unused)) BuildArbitraryRequest(BYTE *uid,BYTE CmdCode
CodeIso15693AsReader(cmd, sizeof(cmd)); CodeIso15693AsReader(cmd, sizeof(cmd));
} }
static void __attribute__((unused)) BuildArbitraryCustomRequest(BYTE uid[], BYTE CmdCode) static void __attribute__((unused)) BuildArbitraryCustomRequest(uint8_t uid[], uint8_t CmdCode)
{ {
BYTE cmd[14]; uint8_t cmd[14];
WORD crc; uint16_t crc;
// If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
// followed by teh block data // followed by teh block data
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
@ -440,9 +441,9 @@ static void __attribute__((unused)) BuildArbitraryCustomRequest(BYTE uid[], BYTE
static void BuildInventoryResponse(void) static void BuildInventoryResponse(void)
{ {
BYTE cmd[12]; uint8_t cmd[12];
WORD crc; uint16_t crc;
// one sub-carrier, inventory, 1 slot, fast rate // one sub-carrier, inventory, 1 slot, fast rate
// AFI is at bit 5 (1<<4) when doing an INVENTORY // AFI is at bit 5 (1<<4) when doing an INVENTORY
cmd[0] = 0; //(1 << 2) | (1 << 5) | (1 << 1); cmd[0] = 0; //(1 << 2) | (1 << 5) | (1 << 1);
@ -467,7 +468,7 @@ static void __attribute__((unused)) BuildArbitraryCustomRequest(BYTE uid[], BYTE
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Transmit the command (to the tag) that was placed in ToSend[]. // Transmit the command (to the tag) that was placed in ToSend[].
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void TransmitTo15693Tag(const BYTE *cmd, int len, int *samples, int *wait) static void TransmitTo15693Tag(const uint8_t *cmd, int len, int *samples, int *wait)
{ {
int c; int c;
@ -481,7 +482,7 @@ static void TransmitTo15693Tag(const BYTE *cmd, int len, int *samples, int *wait
// c++; // c++;
// } // }
// if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { // if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
// volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; // volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
// (void)r; // (void)r;
// } // }
// WDT_HIT(); // WDT_HIT();
@ -497,7 +498,7 @@ static void TransmitTo15693Tag(const BYTE *cmd, int len, int *samples, int *wait
} }
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -508,7 +509,7 @@ static void TransmitTo15693Tag(const BYTE *cmd, int len, int *samples, int *wait
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Transmit the command (to the reader) that was placed in ToSend[]. // Transmit the command (to the reader) that was placed in ToSend[].
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void TransmitTo15693Reader(const BYTE *cmd, int len, int *samples, int *wait) static void TransmitTo15693Reader(const uint8_t *cmd, int len, int *samples, int *wait)
{ {
int c; int c;
@ -526,7 +527,7 @@ static void TransmitTo15693Reader(const BYTE *cmd, int len, int *samples, int *w
} }
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -534,13 +535,13 @@ static void TransmitTo15693Reader(const BYTE *cmd, int len, int *samples, int *w
*samples = (c + *wait) << 3; *samples = (c + *wait) << 3;
} }
static int GetIso15693AnswerFromTag(BYTE *receivedResponse, int maxLen, int *samples, int *elapsed) static int GetIso15693AnswerFromTag(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed)
{ {
int c = 0; int c = 0;
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int getNext = 0; int getNext = 0;
SBYTE prev = 0; int8_t prev = 0;
// NOW READ RESPONSE // NOW READ RESPONSE
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
@ -552,15 +553,15 @@ static int GetIso15693AnswerFromTag(BYTE *receivedResponse, int maxLen, int *sam
AT91C_BASE_SSC->SSC_THR = 0x43; AT91C_BASE_SSC->SSC_THR = 0x43;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
SBYTE b; int8_t b;
b = (SBYTE)AT91C_BASE_SSC->SSC_RHR; b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
// The samples are correlations against I and Q versions of the // The samples are correlations against I and Q versions of the
// tone that the tag AM-modulates, so every other sample is I, // tone that the tag AM-modulates, so every other sample is I,
// every other is Q. We just want power, so abs(I) + abs(Q) is // every other is Q. We just want power, so abs(I) + abs(Q) is
// close to what we want. // close to what we want.
if(getNext) { if(getNext) {
SBYTE r; int8_t r;
if(b < 0) { if(b < 0) {
r = -b; r = -b;
@ -573,7 +574,7 @@ static int GetIso15693AnswerFromTag(BYTE *receivedResponse, int maxLen, int *sam
r += prev; r += prev;
} }
dest[c++] = (BYTE)r; dest[c++] = (uint8_t)r;
if(c >= 2000) { if(c >= 2000) {
break; break;
@ -618,9 +619,9 @@ static int GetIso15693AnswerFromTag(BYTE *receivedResponse, int maxLen, int *sam
i = maxPos + arraylen(FrameSOF)/skip; i = maxPos + arraylen(FrameSOF)/skip;
BYTE outBuf[20]; uint8_t outBuf[20];
memset(outBuf, 0, sizeof(outBuf)); memset(outBuf, 0, sizeof(outBuf));
BYTE mask = 0x01; uint8_t mask = 0x01;
for(;;) { for(;;) {
int corr0 = 0, corr1 = 0, corrEOF = 0; int corr0 = 0, corr1 = 0, corrEOF = 0;
for(j = 0; j < arraylen(Logic0); j += skip) { for(j = 0; j < arraylen(Logic0); j += skip) {
@ -659,7 +660,7 @@ static int GetIso15693AnswerFromTag(BYTE *receivedResponse, int maxLen, int *sam
DbpString("error, uneven octet! (discard extra bits!)"); DbpString("error, uneven octet! (discard extra bits!)");
/// DbpString(" mask=%02x", mask); /// DbpString(" mask=%02x", mask);
} }
// BYTE str1 [8]; // uint8_t str1 [8];
// itoa(k,str1); // itoa(k,str1);
// strcat(str1," octets read"); // strcat(str1," octets read");
@ -681,13 +682,13 @@ static int GetIso15693AnswerFromTag(BYTE *receivedResponse, int maxLen, int *sam
} }
// Now the GetISO15693 message from sniffing command // Now the GetISO15693 message from sniffing command
static int GetIso15693AnswerFromSniff(BYTE *receivedResponse, int maxLen, int *samples, int *elapsed) static int GetIso15693AnswerFromSniff(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed)
{ {
int c = 0; int c = 0;
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int getNext = 0; int getNext = 0;
SBYTE prev = 0; int8_t prev = 0;
// NOW READ RESPONSE // NOW READ RESPONSE
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
@ -699,15 +700,15 @@ static int GetIso15693AnswerFromSniff(BYTE *receivedResponse, int maxLen, int *s
AT91C_BASE_SSC->SSC_THR = 0x43; AT91C_BASE_SSC->SSC_THR = 0x43;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
SBYTE b; int8_t b;
b = (SBYTE)AT91C_BASE_SSC->SSC_RHR; b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
// The samples are correlations against I and Q versions of the // The samples are correlations against I and Q versions of the
// tone that the tag AM-modulates, so every other sample is I, // tone that the tag AM-modulates, so every other sample is I,
// every other is Q. We just want power, so abs(I) + abs(Q) is // every other is Q. We just want power, so abs(I) + abs(Q) is
// close to what we want. // close to what we want.
if(getNext) { if(getNext) {
SBYTE r; int8_t r;
if(b < 0) { if(b < 0) {
r = -b; r = -b;
@ -720,7 +721,7 @@ static int GetIso15693AnswerFromSniff(BYTE *receivedResponse, int maxLen, int *s
r += prev; r += prev;
} }
dest[c++] = (BYTE)r; dest[c++] = (uint8_t)r;
if(c >= 20000) { if(c >= 20000) {
break; break;
@ -765,9 +766,9 @@ static int GetIso15693AnswerFromSniff(BYTE *receivedResponse, int maxLen, int *s
i = maxPos + arraylen(FrameSOF)/skip; i = maxPos + arraylen(FrameSOF)/skip;
BYTE outBuf[20]; uint8_t outBuf[20];
memset(outBuf, 0, sizeof(outBuf)); memset(outBuf, 0, sizeof(outBuf));
BYTE mask = 0x01; uint8_t mask = 0x01;
for(;;) { for(;;) {
int corr0 = 0, corr1 = 0, corrEOF = 0; int corr0 = 0, corr1 = 0, corrEOF = 0;
for(j = 0; j < arraylen(Logic0); j += skip) { for(j = 0; j < arraylen(Logic0); j += skip) {
@ -806,7 +807,7 @@ static int GetIso15693AnswerFromSniff(BYTE *receivedResponse, int maxLen, int *s
DbpString("error, uneven octet! (discard extra bits!)"); DbpString("error, uneven octet! (discard extra bits!)");
/// DbpString(" mask=%02x", mask); /// DbpString(" mask=%02x", mask);
} }
// BYTE str1 [8]; // uint8_t str1 [8];
// itoa(k,str1); // itoa(k,str1);
// strcat(str1," octets read"); // strcat(str1," octets read");
@ -834,10 +835,10 @@ static int GetIso15693AnswerFromSniff(BYTE *receivedResponse, int maxLen, int *s
void AcquireRawAdcSamplesIso15693(void) void AcquireRawAdcSamplesIso15693(void)
{ {
int c = 0; int c = 0;
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int getNext = 0; int getNext = 0;
SBYTE prev = 0; int8_t prev = 0;
BuildIdentifyRequest(); BuildIdentifyRequest();
@ -861,7 +862,7 @@ void AcquireRawAdcSamplesIso15693(void)
} }
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile DWORD r = AT91C_BASE_SSC->SSC_RHR; volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r; (void)r;
} }
WDT_HIT(); WDT_HIT();
@ -876,15 +877,15 @@ void AcquireRawAdcSamplesIso15693(void)
AT91C_BASE_SSC->SSC_THR = 0x43; AT91C_BASE_SSC->SSC_THR = 0x43;
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
SBYTE b; int8_t b;
b = (SBYTE)AT91C_BASE_SSC->SSC_RHR; b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
// The samples are correlations against I and Q versions of the // The samples are correlations against I and Q versions of the
// tone that the tag AM-modulates, so every other sample is I, // tone that the tag AM-modulates, so every other sample is I,
// every other is Q. We just want power, so abs(I) + abs(Q) is // every other is Q. We just want power, so abs(I) + abs(Q) is
// close to what we want. // close to what we want.
if(getNext) { if(getNext) {
SBYTE r; int8_t r;
if(b < 0) { if(b < 0) {
r = -b; r = -b;
@ -897,7 +898,7 @@ void AcquireRawAdcSamplesIso15693(void)
r += prev; r += prev;
} }
dest[c++] = (BYTE)r; dest[c++] = (uint8_t)r;
if(c >= 2000) { if(c >= 2000) {
break; break;
@ -915,7 +916,7 @@ void AcquireRawAdcSamplesIso15693(void)
// Simulate an ISO15693 reader, perform anti-collision and then attempt to read a sector // Simulate an ISO15693 reader, perform anti-collision and then attempt to read a sector
// all demodulation performed in arm rather than host. - greg // all demodulation performed in arm rather than host. - greg
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ReaderIso15693(DWORD parameter) void ReaderIso15693(uint32_t parameter)
{ {
LED_A_ON(); LED_A_ON();
LED_B_ON(); LED_B_ON();
@ -924,11 +925,11 @@ void ReaderIso15693(DWORD parameter)
//DbpString(parameter); //DbpString(parameter);
//BYTE *answer0 = (((BYTE *)BigBuf) + 3560); // allow 100 bytes per reponse (way too much) //uint8_t *answer0 = (((uint8_t *)BigBuf) + 3560); // allow 100 bytes per reponse (way too much)
BYTE *answer1 = (((BYTE *)BigBuf) + 3660); // uint8_t *answer1 = (((uint8_t *)BigBuf) + 3660); //
BYTE *answer2 = (((BYTE *)BigBuf) + 3760); uint8_t *answer2 = (((uint8_t *)BigBuf) + 3760);
BYTE *answer3 = (((BYTE *)BigBuf) + 3860); uint8_t *answer3 = (((uint8_t *)BigBuf) + 3860);
//BYTE *TagUID= (((BYTE *)BigBuf) + 3960); // where we hold the uid for hi15reader //uint8_t *TagUID= (((uint8_t *)BigBuf) + 3960); // where we hold the uid for hi15reader
// int answerLen0 = 0; // int answerLen0 = 0;
int answerLen1 = 0; int answerLen1 = 0;
int answerLen2 = 0; int answerLen2 = 0;
@ -963,7 +964,7 @@ void ReaderIso15693(DWORD parameter)
// FIRST WE RUN AN INVENTORY TO GET THE TAG UID // FIRST WE RUN AN INVENTORY TO GET THE TAG UID
// THIS MEANS WE CAN PRE-BUILD REQUESTS TO SAVE CPU TIME // THIS MEANS WE CAN PRE-BUILD REQUESTS TO SAVE CPU TIME
BYTE TagUID[7]; // where we hold the uid for hi15reader uint8_t TagUID[7]; // where we hold the uid for hi15reader
// BuildIdentifyRequest(); // BuildIdentifyRequest();
// //TransmitTo15693Tag(ToSend,ToSendMax+3,&tsamples, &wait); // //TransmitTo15693Tag(ToSend,ToSendMax+3,&tsamples, &wait);
@ -1053,14 +1054,14 @@ void ReaderIso15693(DWORD parameter)
// Simulate an ISO15693 TAG, perform anti-collision and then print any reader commands // Simulate an ISO15693 TAG, perform anti-collision and then print any reader commands
// all demodulation performed in arm rather than host. - greg // all demodulation performed in arm rather than host. - greg
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void SimTagIso15693(DWORD parameter) void SimTagIso15693(uint32_t parameter)
{ {
LED_A_ON(); LED_A_ON();
LED_B_ON(); LED_B_ON();
LED_C_OFF(); LED_C_OFF();
LED_D_OFF(); LED_D_OFF();
BYTE *answer1 = (((BYTE *)BigBuf) + 3660); // uint8_t *answer1 = (((uint8_t *)BigBuf) + 3660); //
int answerLen1 = 0; int answerLen1 = 0;
// Blank arrays // Blank arrays

5
armsrc/legicrf.c
View file

@ -5,11 +5,10 @@
*/ */
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "apps.h"
#include "legicrf.h" #include "util.h"
#include <stdint.h>
#include "legicrf.h"
#include "legic_prng.h" #include "legic_prng.h"
#include "crc.h" #include "crc.h"

35
armsrc/lfops.c
View file

@ -6,10 +6,11 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "apps.h"
#include "util.h"
#include "hitag2.h" #include "hitag2.h"
#include "crc16.h" #include "crc16.h"
void AcquireRawAdcSamples125k(BOOL at134khz) void AcquireRawAdcSamples125k(int at134khz)
{ {
if (at134khz) if (at134khz)
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
@ -34,7 +35,7 @@ void AcquireRawAdcSamples125k(BOOL at134khz)
// split into two routines so we can avoid timing issues after sending commands // // split into two routines so we can avoid timing issues after sending commands //
void DoAcquisition125k(void) void DoAcquisition125k(void)
{ {
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int n = sizeof(BigBuf); int n = sizeof(BigBuf);
int i; int i;
@ -46,7 +47,7 @@ void DoAcquisition125k(void)
LED_D_ON(); LED_D_ON();
} }
if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) { if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY) {
dest[i] = (BYTE)AT91C_BASE_SSC->SSC_RHR; dest[i] = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
i++; i++;
LED_D_OFF(); LED_D_OFF();
if (i >= n) break; if (i >= n) break;
@ -56,9 +57,9 @@ void DoAcquisition125k(void)
dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]); dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
} }
void ModThenAcquireRawAdcSamples125k(int delay_off, int period_0, int period_1, BYTE *command) void ModThenAcquireRawAdcSamples125k(int delay_off, int period_0, int period_1, uint8_t *command)
{ {
BOOL at134khz; int at134khz;
/* Make sure the tag is reset */ /* Make sure the tag is reset */
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
@ -141,13 +142,13 @@ void ReadTItag(void)
// int n = GraphTraceLen; // int n = GraphTraceLen;
// 128 bit shift register [shift3:shift2:shift1:shift0] // 128 bit shift register [shift3:shift2:shift1:shift0]
DWORD shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0; uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
int i, cycles=0, samples=0; int i, cycles=0, samples=0;
// how many sample points fit in 16 cycles of each frequency // how many sample points fit in 16 cycles of each frequency
DWORD sampleslo = (FSAMPLE<<4)/FREQLO, sampleshi = (FSAMPLE<<4)/FREQHI; uint32_t sampleslo = (FSAMPLE<<4)/FREQLO, sampleshi = (FSAMPLE<<4)/FREQHI;
// when to tell if we're close enough to one freq or another // when to tell if we're close enough to one freq or another
DWORD threshold = (sampleslo - sampleshi + 1)>>1; uint32_t threshold = (sampleslo - sampleshi + 1)>>1;
// TI tags charge at 134.2Khz // TI tags charge at 134.2Khz
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
@ -236,7 +237,7 @@ void ReadTItag(void)
// i'm 99% sure the crc algorithm is correct, but it may need to eat the // i'm 99% sure the crc algorithm is correct, but it may need to eat the
// bytes in reverse or something // bytes in reverse or something
// calculate CRC // calculate CRC
DWORD crc=0; uint32_t crc=0;
crc = update_crc16(crc, (shift0)&0xff); crc = update_crc16(crc, (shift0)&0xff);
crc = update_crc16(crc, (shift0>>8)&0xff); crc = update_crc16(crc, (shift0>>8)&0xff);
@ -257,7 +258,7 @@ void ReadTItag(void)
} }
} }
void WriteTIbyte(BYTE b) void WriteTIbyte(uint8_t b)
{ {
int i = 0; int i = 0;
@ -286,7 +287,7 @@ void AcquireTiType(void)
{ {
int i, j, n; int i, j, n;
// tag transmission is <20ms, sampling at 2M gives us 40K samples max // tag transmission is <20ms, sampling at 2M gives us 40K samples max
// each sample is 1 bit stuffed into a DWORD so we need 1250 DWORDS // each sample is 1 bit stuffed into a uint32_t so we need 1250 uint32_t
#define TIBUFLEN 1250 #define TIBUFLEN 1250
// clear buffer // clear buffer
@ -355,7 +356,7 @@ void AcquireTiType(void)
// arguments: 64bit data split into 32bit idhi:idlo and optional 16bit crc // arguments: 64bit data split into 32bit idhi:idlo and optional 16bit crc
// if crc provided, it will be written with the data verbatim (even if bogus) // if crc provided, it will be written with the data verbatim (even if bogus)
// if not provided a valid crc will be computed from the data and written. // if not provided a valid crc will be computed from the data and written.
void WriteTItag(DWORD idhi, DWORD idlo, WORD crc) void WriteTItag(uint32_t idhi, uint32_t idlo, uint16_t crc)
{ {
if(crc == 0) { if(crc == 0) {
crc = update_crc16(crc, (idlo)&0xff); crc = update_crc16(crc, (idlo)&0xff);
@ -426,7 +427,7 @@ void WriteTItag(DWORD idhi, DWORD idlo, WORD crc)
void SimulateTagLowFrequency(int period, int gap, int ledcontrol) void SimulateTagLowFrequency(int period, int gap, int ledcontrol)
{ {
int i; int i;
BYTE *tab = (BYTE *)BigBuf; uint8_t *tab = (uint8_t *)BigBuf;
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_SIMULATOR); FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_SIMULATOR);
@ -673,7 +674,7 @@ static void hitag_handle_frame(int t0, int frame_len, char *frame)
// compose fc/8 fc/10 waveform // compose fc/8 fc/10 waveform
static void fc(int c, int *n) { static void fc(int c, int *n) {
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int idx; int idx;
// for when we want an fc8 pattern every 4 logical bits // for when we want an fc8 pattern every 4 logical bits
@ -778,9 +779,9 @@ void CmdHIDsimTAG(int hi, int lo, int ledcontrol)
// loop to capture raw HID waveform then FSK demodulate the TAG ID from it // loop to capture raw HID waveform then FSK demodulate the TAG ID from it
void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol) void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
BYTE *dest = (BYTE *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int m=0, n=0, i=0, idx=0, found=0, lastval=0; int m=0, n=0, i=0, idx=0, found=0, lastval=0;
DWORD hi=0, lo=0; uint32_t hi=0, lo=0;
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_READER); FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_READER);
@ -815,7 +816,7 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
LED_D_ON(); LED_D_ON();
} }
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
dest[i] = (BYTE)AT91C_BASE_SSC->SSC_RHR; dest[i] = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
// we don't care about actual value, only if it's more or less than a // we don't care about actual value, only if it's more or less than a
// threshold essentially we capture zero crossings for later analysis // threshold essentially we capture zero crossings for later analysis
if(dest[i] < 127) dest[i] = 0; else dest[i] = 1; if(dest[i] < 127) dest[i] = 0; else dest[i] = 1;

41
armsrc/printf.c
View file

@ -34,40 +34,28 @@
* @(#)subr_prf.c 8.3 (Berkeley) 1/21/94 * @(#)subr_prf.c 8.3 (Berkeley) 1/21/94
*/ */
typedef unsigned long size_t; #include <stddef.h>
typedef long ssize_t; #include <stdarg.h>
#ifdef __64BIT__ #include "printf.h"
typedef unsigned long long uintmax_t; #include "util.h"
typedef long long intmax_t;
#else typedef uint32_t uintmax_t;
typedef unsigned int uintmax_t; typedef int32_t intmax_t;
typedef int intmax_t;
#endif
typedef unsigned char u_char; typedef unsigned char u_char;
typedef unsigned int u_int; typedef unsigned int u_int;
typedef unsigned long u_long; typedef unsigned long u_long;
typedef unsigned short u_short; typedef unsigned short u_short;
typedef unsigned long long u_quad_t; typedef unsigned long long u_quad_t;
typedef long long quad_t; typedef long long quad_t;
typedef unsigned long uintptr_t;
typedef long ptrdiff_t; typedef int ssize_t;
#define NULL ((void*)0)
#define NBBY 8 /* number of bits in a byte */ #define NBBY 8 /* number of bits in a byte */
char const hex2ascii_data[] = "0123456789abcdefghijklmnopqrstuvwxyz"; char const hex2ascii_data[] = "0123456789abcdefghijklmnopqrstuvwxyz";
#define hex2ascii(hex) (hex2ascii_data[hex]) #define hex2ascii(hex) (hex2ascii_data[hex])
#define va_list __builtin_va_list
#define va_start __builtin_va_start
#define va_arg __builtin_va_arg
#define va_end __builtin_va_end
#define toupper(c) ((c) - 0x20 * (((c) >= 'a') && ((c) <= 'z'))) #define toupper(c) ((c) - 0x20 * (((c) >= 'a') && ((c) <= 'z')))
static size_t
strlen(const char *s)
{
size_t l = 0;
while (*s++)
l++;
return l;
}
/* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */ /* Max number conversion buffer length: a u_quad_t in base 2, plus NUL byte. */
#define MAXNBUF (sizeof(intmax_t) * NBBY + 1) #define MAXNBUF (sizeof(intmax_t) * NBBY + 1)
@ -431,6 +419,11 @@ number:
#undef PCHAR #undef PCHAR
} }
int vsprintf(char *dest, const char *fmt, va_list ap)
{
return kvsprintf(fmt, dest, 10, ap);
}
int int
sprintf(char *dest, const char *fmt, ...) sprintf(char *dest, const char *fmt, ...)
{ {

12
armsrc/printf.h Normal file
View file

@ -0,0 +1,12 @@
#ifndef __PRINTF_H
#define __PRINTF_H
#include <stdarg.h>
int kvsprintf(const char *format, void *arg, int radix, va_list ap) __attribute__ ((format (printf, 1, 0)));
int vsprintf(char *str, const char *format, va_list ap) __attribute__ ((format (printf, 2, 0)));
int sprintf(char *str, const char *format, ...) __attribute__ ((format (printf, 2, 3)));
#endif

40
armsrc/util.c
View file

@ -3,12 +3,12 @@
// Jonathan Westhues, Sept 2005 // Jonathan Westhues, Sept 2005
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "proxmark3.h" #include "proxmark3.h"
#include "apps.h" #include "util.h"
void *memcpy(void *dest, const void *src, int len) void *memcpy(void *dest, const void *src, int len)
{ {
BYTE *d = dest; uint8_t *d = dest;
const BYTE *s = src; const uint8_t *s = src;
while((len--) > 0) { while((len--) > 0) {
*d = *s; *d = *s;
d++; d++;
@ -19,7 +19,7 @@ void *memcpy(void *dest, const void *src, int len)
void *memset(void *dest, int c, int len) void *memset(void *dest, int c, int len)
{ {
BYTE *d = dest; uint8_t *d = dest;
while((len--) > 0) { while((len--) > 0) {
*d = c; *d = c;
d++; d++;
@ -29,8 +29,8 @@ void *memset(void *dest, int c, int len)
int memcmp(const void *av, const void *bv, int len) int memcmp(const void *av, const void *bv, int len)
{ {
const BYTE *a = av; const uint8_t *a = av;
const BYTE *b = bv; const uint8_t *b = bv;
while((len--) > 0) { while((len--) > 0) {
if(*a != *b) { if(*a != *b) {
@ -42,7 +42,7 @@ int memcmp(const void *av, const void *bv, int len)
return 0; return 0;
} }
int strlen(char *str) int strlen(const char *str)
{ {
int l = 0; int l = 0;
while(*str) { while(*str) {
@ -64,15 +64,15 @@ char* strncat(char *dest, const char *src, unsigned int n)
return dest; return dest;
} }
void num_to_bytes(uint64_t n, size_t len, byte_t* dest) void num_to_bytes(uint64_t n, size_t len, uint8_t* dest)
{ {
while (len--) { while (len--) {
dest[len] = (byte_t) n; dest[len] = (uint8_t) n;
n >>= 8; n >>= 8;
} }
} }
uint64_t bytes_to_num(byte_t* src, size_t len) uint64_t bytes_to_num(uint8_t* src, size_t len)
{ {
uint64_t num = 0; uint64_t num = 0;
while (len--) while (len--)
@ -139,12 +139,12 @@ int BUTTON_CLICKED(int ms)
AT91C_BASE_PWMC_CH0->PWMC_CDTYR = 0; AT91C_BASE_PWMC_CH0->PWMC_CDTYR = 0;
AT91C_BASE_PWMC_CH0->PWMC_CPRDR = 0xffff; AT91C_BASE_PWMC_CH0->PWMC_CPRDR = 0xffff;
WORD start = AT91C_BASE_PWMC_CH0->PWMC_CCNTR; uint16_t start = AT91C_BASE_PWMC_CH0->PWMC_CCNTR;
int letoff = 0; int letoff = 0;
for(;;) for(;;)
{ {
WORD now = AT91C_BASE_PWMC_CH0->PWMC_CCNTR; uint16_t now = AT91C_BASE_PWMC_CH0->PWMC_CCNTR;
// We haven't let off the button yet // We haven't let off the button yet
if (!letoff) if (!letoff)
@ -162,7 +162,7 @@ int BUTTON_CLICKED(int ms)
// Still haven't let it off // Still haven't let it off
else else
// Have we held down a full second? // Have we held down a full second?
if (now == (WORD)(start + ticks)) if (now == (uint16_t)(start + ticks))
return BUTTON_HOLD; return BUTTON_HOLD;
} }
@ -174,7 +174,7 @@ int BUTTON_CLICKED(int ms)
// Have we ran out of time to double click? // Have we ran out of time to double click?
else else
if (now == (WORD)(start + ticks)) if (now == (uint16_t)(start + ticks))
// At least we did a single click // At least we did a single click
return BUTTON_SINGLE_CLICK; return BUTTON_SINGLE_CLICK;
@ -202,11 +202,11 @@ int BUTTON_HELD(int ms)
AT91C_BASE_PWMC_CH0->PWMC_CDTYR = 0; AT91C_BASE_PWMC_CH0->PWMC_CDTYR = 0;
AT91C_BASE_PWMC_CH0->PWMC_CPRDR = 0xffff; AT91C_BASE_PWMC_CH0->PWMC_CPRDR = 0xffff;
WORD start = AT91C_BASE_PWMC_CH0->PWMC_CCNTR; uint16_t start = AT91C_BASE_PWMC_CH0->PWMC_CCNTR;
for(;;) for(;;)
{ {
WORD now = AT91C_BASE_PWMC_CH0->PWMC_CCNTR; uint16_t now = AT91C_BASE_PWMC_CH0->PWMC_CCNTR;
// As soon as our button let go, we didn't hold long enough // As soon as our button let go, we didn't hold long enough
if (!BUTTON_PRESS()) if (!BUTTON_PRESS())
@ -214,7 +214,7 @@ int BUTTON_HELD(int ms)
// Have we waited the full second? // Have we waited the full second?
else else
if (now == (WORD)(start + ticks)) if (now == (uint16_t)(start + ticks))
return BUTTON_HOLD; return BUTTON_HOLD;
WDT_HIT(); WDT_HIT();
@ -237,11 +237,11 @@ void SpinDelayUs(int us)
AT91C_BASE_PWMC_CH0->PWMC_CDTYR = 0; AT91C_BASE_PWMC_CH0->PWMC_CDTYR = 0;
AT91C_BASE_PWMC_CH0->PWMC_CPRDR = 0xffff; AT91C_BASE_PWMC_CH0->PWMC_CPRDR = 0xffff;
WORD start = AT91C_BASE_PWMC_CH0->PWMC_CCNTR; uint16_t start = AT91C_BASE_PWMC_CH0->PWMC_CCNTR;
for(;;) { for(;;) {
WORD now = AT91C_BASE_PWMC_CH0->PWMC_CCNTR; uint16_t now = AT91C_BASE_PWMC_CH0->PWMC_CCNTR;
if (now == (WORD)(start + ticks)) if (now == (uint16_t)(start + ticks))
return; return;
WDT_HIT(); WDT_HIT();

32
armsrc/util.h Normal file
View file

@ -0,0 +1,32 @@
#ifndef __UTIL_H
#define __UTIL_H
#include <stddef.h>
#include <stdint.h>
#define LED_RED 1
#define LED_ORANGE 2
#define LED_GREEN 4
#define LED_RED2 8
#define BUTTON_HOLD 1
#define BUTTON_NO_CLICK 0
#define BUTTON_SINGLE_CLICK -1
#define BUTTON_DOUBLE_CLICK -2
#define BUTTON_ERROR -99
int strlen(const char *str);
void *memcpy(void *dest, const void *src, int len);
void *memset(void *dest, int c, int len);
int memcmp(const void *av, const void *bv, int len);
char *strncat(char *dest, const char *src, unsigned int n);
void num_to_bytes(uint64_t n, size_t len, uint8_t* dest);
uint64_t bytes_to_num(uint8_t* src, size_t len);
void SpinDelay(int ms);
void SpinDelayUs(int us);
void LED(int led, int ms);
void LEDsoff();
int BUTTON_CLICKED(int ms);
int BUTTON_HELD(int ms);
void FormatVersionInformation(char *dst, int len, const char *prefix, void *version_information);
#endif

8
bootrom/bootrom.c
View file

@ -69,11 +69,11 @@ static void Fatal(void)
for(;;); for(;;);
} }
void UsbPacketReceived(BYTE *packet, int len) void UsbPacketReceived(uint8_t *packet, int len)
{ {
int i, dont_ack=0; int i, dont_ack=0;
UsbCommand *c = (UsbCommand *)packet; UsbCommand *c = (UsbCommand *)packet;
volatile DWORD *p; volatile uint32_t *p;
if(len != sizeof(*c)) { if(len != sizeof(*c)) {
Fatal(); Fatal();
@ -93,14 +93,14 @@ void UsbPacketReceived(BYTE *packet, int len)
/* The temporary write buffer of the embedded flash controller is mapped to the /* The temporary write buffer of the embedded flash controller is mapped to the
* whole memory region, only the last 8 bits are decoded. * whole memory region, only the last 8 bits are decoded.
*/ */
p = (volatile DWORD *)&_flash_start; p = (volatile uint32_t *)&_flash_start;
for(i = 0; i < 12; i++) { for(i = 0; i < 12; i++) {
p[i+c->arg[0]] = c->d.asDwords[i]; p[i+c->arg[0]] = c->d.asDwords[i];
} }
break; break;
case CMD_FINISH_WRITE: case CMD_FINISH_WRITE:
p = (volatile DWORD *)&_flash_start; p = (volatile uint32_t *)&_flash_start;
for(i = 0; i < 4; i++) { for(i = 0; i < 4; i++) {
p[i+60] = c->d.asDwords[i]; p[i+60] = c->d.asDwords[i];
} }

6
bootrom/fromflash.c
View file

@ -5,9 +5,9 @@ void __attribute__((section(".bootphase1"))) CopyBootToRAM(void)
{ {
int i; int i;
volatile DWORD *s = (volatile DWORD *)&__bootphase2_src_start__; volatile uint32_t *s = (volatile uint32_t *)&__bootphase2_src_start__;
volatile DWORD *d = (volatile DWORD *)&__bootphase2_start__; volatile uint32_t *d = (volatile uint32_t *)&__bootphase2_start__;
unsigned int l = (int)&__bootphase2_end__ - (int)&__bootphase2_start__; unsigned int l = (int)&__bootphase2_end__ - (int)&__bootphase2_start__;
for(i = 0; i < l/sizeof(DWORD); i++) *d++ = *s++; for(i = 0; i < l/sizeof(uint32_t); i++) *d++ = *s++;
} }

56
common/usb.c
View file

@ -10,11 +10,11 @@
#define USB_REPORT_PACKET_SIZE 64 #define USB_REPORT_PACKET_SIZE 64
typedef struct PACKED { typedef struct PACKED {
BYTE bmRequestType; uint8_t bmRequestType;
BYTE bRequest; uint8_t bRequest;
WORD wValue; uint16_t wValue;
WORD wIndex; uint16_t wIndex;
WORD wLength; uint16_t wLength;
} UsbSetupData; } UsbSetupData;
#define USB_REQUEST_GET_STATUS 0 #define USB_REQUEST_GET_STATUS 0
@ -42,7 +42,7 @@ typedef struct PACKED {
#define USB_DEVICE_CLASS_HID 0x03 #define USB_DEVICE_CLASS_HID 0x03
static const BYTE HidReportDescriptor[] = { static const uint8_t HidReportDescriptor[] = {
0x06,0xA0,0xFF, // Usage Page (vendor defined) FFA0 0x06,0xA0,0xFF, // Usage Page (vendor defined) FFA0
0x09,0x01, // Usage (vendor defined) 0x09,0x01, // Usage (vendor defined)
0xA1,0x01, // Collection (Application) 0xA1,0x01, // Collection (Application)
@ -77,7 +77,7 @@ static const BYTE HidReportDescriptor[] = {
0xC0, // End Collection 0xC0, // End Collection
}; };
static const BYTE DeviceDescriptor[] = { static const uint8_t DeviceDescriptor[] = {
0x12, // Descriptor length (18 bytes) 0x12, // Descriptor length (18 bytes)
0x01, // Descriptor type (Device) 0x01, // Descriptor type (Device)
0x10,0x01, // Complies with USB Spec. Release (0110h = release 1.10) 0x10,0x01, // Complies with USB Spec. Release (0110h = release 1.10)
@ -94,7 +94,7 @@ static const BYTE DeviceDescriptor[] = {
0x01, // Number of possible configurations (1) 0x01, // Number of possible configurations (1)
}; };
static const BYTE ConfigurationDescriptor[] = { static const uint8_t ConfigurationDescriptor[] = {
0x09, // Descriptor length (9 bytes) 0x09, // Descriptor length (9 bytes)
0x02, // Descriptor type (Configuration) 0x02, // Descriptor type (Configuration)
0x29,0x00, // Total data length (41 bytes) 0x29,0x00, // Total data length (41 bytes)
@ -142,14 +142,14 @@ static const BYTE ConfigurationDescriptor[] = {
0x01, // Polling interval (1 ms) 0x01, // Polling interval (1 ms)
}; };
static const BYTE StringDescriptor0[] = { static const uint8_t StringDescriptor0[] = {
0x04, // Length 0x04, // Length
0x03, // Type is string 0x03, // Type is string
0x09, // English 0x09, // English
0x04, // US 0x04, // US
}; };
static const BYTE StringDescriptor1[] = { static const uint8_t StringDescriptor1[] = {
24, // Length 24, // Length
0x03, // Type is string 0x03, // Type is string
'J', 0x00, 'J', 0x00,
@ -165,7 +165,7 @@ static const BYTE StringDescriptor1[] = {
's', 0x00, 's', 0x00,
}; };
static const BYTE StringDescriptor2[] = { static const uint8_t StringDescriptor2[] = {
54, // Length 54, // Length
0x03, // Type is string 0x03, // Type is string
'P', 0x00, 'P', 0x00,
@ -196,19 +196,19 @@ static const BYTE StringDescriptor2[] = {
't', 0x00, 't', 0x00,
}; };
static const BYTE * const StringDescriptors[] = { static const uint8_t * const StringDescriptors[] = {
StringDescriptor0, StringDescriptor0,
StringDescriptor1, StringDescriptor1,
StringDescriptor2, StringDescriptor2,
}; };
static BYTE UsbBuffer[64]; static uint8_t UsbBuffer[64];
static int UsbSoFarCount; static int UsbSoFarCount;
static BYTE CurrentConfiguration; static uint8_t CurrentConfiguration;
static void UsbSendEp0(const BYTE *data, int len) static void UsbSendEp0(const uint8_t *data, int len)
{ {
int thisTime, i; int thisTime, i;
@ -278,7 +278,7 @@ static void HandleRxdSetupData(void)
UsbSetupData usd; UsbSetupData usd;
for(i = 0; i < sizeof(usd); i++) { for(i = 0; i < sizeof(usd); i++) {
((BYTE *)&usd)[i] = AT91C_BASE_UDP->UDP_FDR[0]; ((uint8_t *)&usd)[i] = AT91C_BASE_UDP->UDP_FDR[0];
} }
if(usd.bmRequestType & 0x80) { if(usd.bmRequestType & 0x80) {
@ -294,19 +294,19 @@ static void HandleRxdSetupData(void)
switch(usd.bRequest) { switch(usd.bRequest) {
case USB_REQUEST_GET_DESCRIPTOR: case USB_REQUEST_GET_DESCRIPTOR:
if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_DEVICE) { if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_DEVICE) {
UsbSendEp0((BYTE *)&DeviceDescriptor, UsbSendEp0((uint8_t *)&DeviceDescriptor,
min(sizeof(DeviceDescriptor), usd.wLength)); min(sizeof(DeviceDescriptor), usd.wLength));
} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_CONFIGURATION) { } else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_CONFIGURATION) {
UsbSendEp0((BYTE *)&ConfigurationDescriptor, UsbSendEp0((uint8_t *)&ConfigurationDescriptor,
min(sizeof(ConfigurationDescriptor), usd.wLength)); min(sizeof(ConfigurationDescriptor), usd.wLength));
} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_STRING) { } else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_STRING) {
const BYTE *s = StringDescriptors[usd.wValue & 0xff]; const uint8_t *s = StringDescriptors[usd.wValue & 0xff];
UsbSendEp0(s, min(s[0], usd.wLength)); UsbSendEp0(s, min(s[0], usd.wLength));
} else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_HID_REPORT) { } else if((usd.wValue >> 8) == USB_DESCRIPTOR_TYPE_HID_REPORT) {
UsbSendEp0((BYTE *)&HidReportDescriptor, UsbSendEp0((uint8_t *)&HidReportDescriptor,
min(sizeof(HidReportDescriptor), usd.wLength)); min(sizeof(HidReportDescriptor), usd.wLength));
} else { } else {
*((DWORD *)0x00200000) = usd.wValue; *((uint32_t *)0x00200000) = usd.wValue;
} }
break; break;
@ -326,8 +326,8 @@ static void HandleRxdSetupData(void)
case USB_REQUEST_GET_STATUS: { case USB_REQUEST_GET_STATUS: {
if(usd.bmRequestType & 0x80) { if(usd.bmRequestType & 0x80) {
WORD w = 0; uint16_t w = 0;
UsbSendEp0((BYTE *)&w, sizeof(w)); UsbSendEp0((uint8_t *)&w, sizeof(w));
} }
break; break;
} }
@ -348,7 +348,7 @@ static void HandleRxdSetupData(void)
break; break;
case USB_REQUEST_GET_INTERFACE: { case USB_REQUEST_GET_INTERFACE: {
BYTE b = 0; uint8_t b = 0;
UsbSendEp0(&b, sizeof(b)); UsbSendEp0(&b, sizeof(b));
break; break;
} }
@ -368,7 +368,7 @@ static void HandleRxdSetupData(void)
} }
} }
void UsbSendPacket(BYTE *packet, int len) void UsbSendPacket(uint8_t *packet, int len)
{ {
int i, thisTime; int i, thisTime;
@ -451,7 +451,7 @@ void UsbStart(void)
} }
} }
BOOL UsbConnected() int UsbConnected()
{ {
if (AT91C_BASE_UDP->UDP_GLBSTATE & AT91C_UDP_CONFG) if (AT91C_BASE_UDP->UDP_GLBSTATE & AT91C_UDP_CONFG)
return TRUE; return TRUE;
@ -459,9 +459,9 @@ BOOL UsbConnected()
return FALSE; return FALSE;
} }
BOOL UsbPoll(BOOL blinkLeds) int UsbPoll(int blinkLeds)
{ {
BOOL ret = FALSE; int ret = FALSE;
if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) { if(AT91C_BASE_UDP->UDP_ISR & AT91C_UDP_ENDBUSRES) {
AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES; AT91C_BASE_UDP->UDP_ICR = AT91C_UDP_ENDBUSRES;

20
include/proxmark3.h
View file

@ -7,8 +7,8 @@
#define __PROXMARK3_H #define __PROXMARK3_H
// Might as well have the hardware-specific defines everywhere. // Might as well have the hardware-specific defines everywhere.
#include <at91sam7s512.h> #include "at91sam7s512.h"
#include <config_gpio.h> #include "config_gpio.h"
#define WDT_HIT() AT91C_BASE_WDTC->WDTC_WDCR = 0xa5000001 #define WDT_HIT() AT91C_BASE_WDTC->WDTC_WDCR = 0xa5000001
@ -67,14 +67,6 @@
#define SPI_FPGA_MODE 0 #define SPI_FPGA_MODE 0
#define SPI_LCD_MODE 1 #define SPI_LCD_MODE 1
typedef unsigned long DWORD;
typedef signed long SDWORD;
typedef unsigned long long QWORD;
typedef int BOOL;
typedef unsigned char BYTE;
typedef signed char SBYTE;
typedef unsigned short WORD;
typedef signed short SWORD;
#define TRUE 1 #define TRUE 1
#define FALSE 0 #define FALSE 0
@ -102,14 +94,14 @@ typedef signed short SWORD;
//-------------------------------- //--------------------------------
// USB declarations // USB declarations
void UsbSendPacket(BYTE *packet, int len); void UsbSendPacket(uint8_t *packet, int len);
BOOL UsbConnected(); int UsbConnected();
BOOL UsbPoll(BOOL blinkLeds); int UsbPoll(int blinkLeds);
void UsbStart(void); void UsbStart(void);
// This function is provided by the apps/bootrom, and called from UsbPoll // This function is provided by the apps/bootrom, and called from UsbPoll
// if data are available. // if data are available.
void UsbPacketReceived(BYTE *packet, int len); void UsbPacketReceived(uint8_t *packet, int len);
#define VERSION_INFORMATION_MAGIC 0x56334d50 #define VERSION_INFORMATION_MAGIC 0x56334d50
struct version_information { struct version_information {