X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/117d9ec25c7cbc88555a6a990293ca95a544b915..b7eddc14db9262a51ad3100ade7386d03500ace8:/armsrc/BigBuf.c?ds=sidebyside diff --git a/armsrc/BigBuf.c b/armsrc/BigBuf.c index 987fee7d..703ade65 100644 --- a/armsrc/BigBuf.c +++ b/armsrc/BigBuf.c @@ -14,22 +14,37 @@ #include "apps.h" #include "string.h" -// The large multi-purpose buffer, typically used to hold A/D samples or traces, -// may be processed in some way. Also used to hold various smaller buffers. -static uint8_t BigBuf[BIGBUF_SIZE]; +// BigBuf is the large multi-purpose buffer, typically used to hold A/D samples or traces. +// Also used to hold various smaller buffers and the Mifare Emulator Memory. + +// declare it as uint32_t to achieve alignment to 4 Byte boundary +static uint32_t BigBuf[BIGBUF_SIZE/sizeof(uint32_t)]; // High memory mark static uint16_t BigBuf_hi = BIGBUF_SIZE; -// trace related global variables. Change to function calls? -//uint8_t *trace = BigBuf; -uint16_t traceLen; +// pointer to the emulator memory. +static uint8_t *emulator_memory = NULL; +// trace related variables +static uint16_t traceLen = 0; +int tracing = 1; //Last global one.. todo static? // get the address of BigBuf uint8_t *BigBuf_get_addr(void) { - return BigBuf; + return (uint8_t *)BigBuf; +} + + +// get the address of the emulator memory. Allocate part of Bigbuf for it, if not yet done +uint8_t *BigBuf_get_EM_addr(void) +{ + if (emulator_memory == NULL) { // not yet allocated + emulator_memory = BigBuf_malloc(CARD_MEMORY_SIZE); + } + + return emulator_memory; } @@ -41,28 +56,184 @@ void BigBuf_Clear(void) } -// allocate a chunk of memory from BigBuf. We allocate high memory first. Low memory -// is always for traces/samples +// allocate a chunk of memory from BigBuf. We allocate high memory first. The unallocated memory +// at the beginning of BigBuf is always for traces/samples uint8_t *BigBuf_malloc(uint16_t chunksize) { if (BigBuf_hi - chunksize < 0) { - return NULL; // no memory left + return NULL; // no memory left } else { - BigBuf_hi -= chunksize; // aligned to 4 Byte boundary - return BigBuf + BigBuf_hi; + chunksize = (chunksize + 3) & 0xfffc; // round to next multiple of 4 + BigBuf_hi -= chunksize; // aligned to 4 Byte boundary + return (uint8_t *)BigBuf + BigBuf_hi; } } -// free ALL allocated chunks. The whole BigBuf is available for traces again. +// free ALL allocated chunks. The whole BigBuf is available for traces or samples again. void BigBuf_free(void) { BigBuf_hi = BIGBUF_SIZE; + emulator_memory = NULL; +} + + +// free allocated chunks EXCEPT the emulator memory +void BigBuf_free_keep_EM(void) +{ + if (emulator_memory != NULL) { + BigBuf_hi = emulator_memory - (uint8_t *)BigBuf; + } else { + BigBuf_hi = BIGBUF_SIZE; + } } // return the maximum trace length (i.e. the unallocated size of BigBuf) -uint16_t BigBuf_max_trace_len(void) +uint16_t BigBuf_max_traceLen(void) { return BigBuf_hi; -} \ No newline at end of file +} + +void clear_trace() { + uint8_t *trace = BigBuf_get_addr(); + uint16_t max_traceLen = BigBuf_max_traceLen(); + memset(trace, 0x44, max_traceLen); + traceLen = 0; +} + +void set_tracing(bool enable) { + tracing = enable; +} + +/** + * Get the number of bytes traced + * @return + */ +uint16_t BigBuf_get_traceLen(void) +{ + return traceLen; +} + +/** + This is a function to store traces. All protocols can use this generic tracer-function. + The traces produced by calling this function can be fetched on the client-side + by 'hf list raw', alternatively 'hf list ' for protocol-specific + annotation of commands/responses. + +**/ +bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag) +{ + if (!tracing) return FALSE; + + uint8_t *trace = BigBuf_get_addr(); + + uint16_t num_paritybytes = (iLen-1)/8 + 1; // number of valid paritybytes in *parity + uint16_t duration = timestamp_end - timestamp_start; + + // Return when trace is full + uint16_t max_traceLen = BigBuf_max_traceLen(); + + if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= max_traceLen) { + tracing = FALSE; // don't trace any more + return FALSE; + } + // Traceformat: + // 32 bits timestamp (little endian) + // 16 bits duration (little endian) + // 16 bits data length (little endian, Highest Bit used as readerToTag flag) + // y Bytes data + // x Bytes parity (one byte per 8 bytes data) + + // timestamp (start) + trace[traceLen++] = ((timestamp_start >> 0) & 0xff); + trace[traceLen++] = ((timestamp_start >> 8) & 0xff); + trace[traceLen++] = ((timestamp_start >> 16) & 0xff); + trace[traceLen++] = ((timestamp_start >> 24) & 0xff); + + // duration + trace[traceLen++] = ((duration >> 0) & 0xff); + trace[traceLen++] = ((duration >> 8) & 0xff); + + // data length + trace[traceLen++] = ((iLen >> 0) & 0xff); + trace[traceLen++] = ((iLen >> 8) & 0xff); + + // readerToTag flag + if (!readerToTag) { + trace[traceLen - 1] |= 0x80; + } + + // data bytes + if (btBytes != NULL && iLen != 0) { + memcpy(trace + traceLen, btBytes, iLen); + } + traceLen += iLen; + + // parity bytes + if (parity != NULL && iLen != 0) { + memcpy(trace + traceLen, parity, num_paritybytes); + } + traceLen += num_paritybytes; + + if(traceLen +4 < max_traceLen) + { //If it hadn't been cleared, for whatever reason.. + memset(trace+traceLen,0x44, 4); + } + + return TRUE; +} +int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int readerToTag) +{ + /** + Todo, rewrite the logger to use the generic functionality instead. It should be noted, however, + that this logger takes number of bits as argument, not number of bytes. + **/ + + if (!tracing) return FALSE; + + uint8_t *trace = BigBuf_get_addr(); + uint16_t iLen = nbytes(iBits); + // Return when trace is full + if (traceLen + sizeof(rsamples) + sizeof(dwParity) + sizeof(iBits) + iLen > BigBuf_max_traceLen()) return FALSE; + + //Hitag traces appear to use this traceformat: + // 32 bits timestamp (little endian,Highest Bit used as readerToTag flag) + // 32 bits parity + // 8 bits size (number of bits in the trace entry, not number of bytes) + // y Bytes data + + rsamples += iSamples; + trace[traceLen++] = ((rsamples >> 0) & 0xff); + trace[traceLen++] = ((rsamples >> 8) & 0xff); + trace[traceLen++] = ((rsamples >> 16) & 0xff); + trace[traceLen++] = ((rsamples >> 24) & 0xff); + + if (!readerToTag) { + trace[traceLen - 1] |= 0x80; + } + + trace[traceLen++] = ((dwParity >> 0) & 0xff); + trace[traceLen++] = ((dwParity >> 8) & 0xff); + trace[traceLen++] = ((dwParity >> 16) & 0xff); + trace[traceLen++] = ((dwParity >> 24) & 0xff); + trace[traceLen++] = iBits; + + memcpy(trace + traceLen, btBytes, iLen); + traceLen += iLen; + + return TRUE; +} +// Emulator memory +uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length){ + uint8_t* mem = BigBuf_get_EM_addr(); + if(offset+length < CARD_MEMORY_SIZE) + { + memcpy(mem+offset, data, length); + return 0; + }else + { + Dbprintf("Error, trying to set memory outside of bounds! %d > %d", (offset+length), CARD_MEMORY_SIZE); + return 1; + } +}