cvs.zerfleddert.de Git - proxmark3-svn/blob - armsrc/BigBuf.c

   1 //-----------------------------------------------------------------------------
   2 // Jonathan Westhues, Aug 2005
   3 // Gerhard de Koning Gans, April 2008, May 2011
   4 //
   5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   6 // at your option, any later version. See the LICENSE.txt file for the text of
   7 // the license.
   8 //-----------------------------------------------------------------------------
   9 // BigBuf and functions to allocate/free parts of it.
  10 //-----------------------------------------------------------------------------
  11
  12 #include <stdint.h>
  13 #include "proxmark3.h"
  14 #include "apps.h"
  15 #include "string.h"
  16
  17 // BigBuf is the large multi-purpose buffer, typically used to hold A/D samples or traces.
  18 // Also used to hold various smaller buffers and the Mifare Emulator Memory.
  19
  20 // declare it as uint32_t to achieve alignment to 4 Byte boundary
  21 static uint32_t BigBuf[BIGBUF_SIZE/sizeof(uint32_t)];
  22
  23 // High memory mark
  24 static uint16_t BigBuf_hi = BIGBUF_SIZE;
  25
  26 // pointer to the emulator memory.
  27 static uint8_t *emulator_memory = NULL;
  28
  29 // trace related variables
  30 static uint16_t traceLen = 0;
  31 int tracing = 1; //Last global one.. todo static?
  32
  33 // get the address of BigBuf
  34 uint8_t *BigBuf_get_addr(void)
  35 {
  36         return (uint8_t *)BigBuf;
  37 }
  38
  39
  40 // get the address of the emulator memory. Allocate part of Bigbuf for it, if not yet done
  41 uint8_t *BigBuf_get_EM_addr(void)
  42 {
  43         if (emulator_memory == NULL) {          // not yet allocated
  44                 emulator_memory = BigBuf_malloc(CARD_MEMORY_SIZE);
  45         }
  46
  47         return emulator_memory;
  48 }
  49
  50
  51 // clear ALL of BigBuf
  52 void BigBuf_Clear(void)
  53 {
  54         BigBuf_Clear_ext(true);
  55 }
  56 // clear ALL of BigBuf
  57 void BigBuf_Clear_ext(bool verbose)
  58 {
  59         memset(BigBuf,0,BIGBUF_SIZE);
  60         if (verbose)
  61                 Dbprintf("Buffer cleared (%i bytes)",BIGBUF_SIZE);
  62 }
  63
  64 void BigBuf_Clear_keep_EM(void)
  65 {
  66         memset(BigBuf,0,BigBuf_hi);
  67 }
  68
  69 // allocate a chunk of memory from BigBuf. We allocate high memory first. The unallocated memory
  70 // at the beginning of BigBuf is always for traces/samples
  71 uint8_t *BigBuf_malloc(uint16_t chunksize)
  72 {
  73         if (BigBuf_hi - chunksize < 0) {
  74                 return NULL;                                                    // no memory left
  75         } else {
  76                 chunksize = (chunksize + 3) & 0xfffc;   // round to next multiple of 4
  77                 BigBuf_hi -= chunksize;                                 // aligned to 4 Byte boundary
  78                 return (uint8_t *)BigBuf + BigBuf_hi;
  79         }
  80 }
  81
  82
  83 // free ALL allocated chunks. The whole BigBuf is available for traces or samples again.
  84 void BigBuf_free(void)
  85 {
  86         BigBuf_hi = BIGBUF_SIZE;
  87         emulator_memory = NULL;
  88 }
  89
  90
  91 // free allocated chunks EXCEPT the emulator memory
  92 void BigBuf_free_keep_EM(void)
  93 {
  94         if (emulator_memory != NULL) {
  95                 BigBuf_hi = emulator_memory - (uint8_t *)BigBuf;
  96         } else {
  97                 BigBuf_hi = BIGBUF_SIZE;
  98         }
  99 }
 100
 101 void BigBuf_print_status(void)
 102 {
 103         Dbprintf("Memory");
 104         Dbprintf("  BIGBUF_SIZE.............%d", BIGBUF_SIZE);
 105         Dbprintf("  BigBuf_hi  .............%d", BigBuf_hi);
 106         Dbprintf("Tracing");
 107         Dbprintf("  tracing ................%d", tracing);
 108         Dbprintf("  traceLen ...............%d", traceLen);
 109 }
 110
 111
 112 // return the maximum trace length (i.e. the unallocated size of BigBuf)
 113 uint16_t BigBuf_max_traceLen(void)
 114 {
 115         return BigBuf_hi;
 116 }
 117
 118 void clear_trace() {
 119         traceLen = 0;
 120 }
 121
 122 void set_tracing(bool enable) {
 123         tracing = enable;
 124 }
 125
 126 /**
 127  * Get the number of bytes traced
 128  * @return
 129  */
 130 uint16_t BigBuf_get_traceLen(void)
 131 {
 132         return traceLen;
 133 }
 134
 135 /**
 136   This is a function to store traces. All protocols can use this generic tracer-function.
 137   The traces produced by calling this function can be fetched on the client-side
 138   by 'hf list raw', alternatively 'hf list <proto>' for protocol-specific
 139   annotation of commands/responses.
 140
 141 **/
 142 bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag)
 143 {
 144         if (!tracing) return FALSE;
 145
 146         uint8_t *trace = BigBuf_get_addr();
 147
 148         uint16_t num_paritybytes = (iLen-1)/8 + 1;      // number of valid paritybytes in *parity
 149         uint16_t duration = timestamp_end - timestamp_start;
 150
 151         // Return when trace is full
 152         uint16_t max_traceLen = BigBuf_max_traceLen();
 153
 154         if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= max_traceLen) {
 155                 tracing = FALSE;        // don't trace any more
 156                 return FALSE;
 157         }
 158         // Traceformat:
 159         // 32 bits timestamp (little endian)
 160         // 16 bits duration (little endian)
 161         // 16 bits data length (little endian, Highest Bit used as readerToTag flag)
 162         // y Bytes data
 163         // x Bytes parity (one byte per 8 bytes data)
 164
 165         // timestamp (start)
 166         trace[traceLen++] = ((timestamp_start >> 0) & 0xff);
 167         trace[traceLen++] = ((timestamp_start >> 8) & 0xff);
 168         trace[traceLen++] = ((timestamp_start >> 16) & 0xff);
 169         trace[traceLen++] = ((timestamp_start >> 24) & 0xff);
 170
 171         // duration
 172         trace[traceLen++] = ((duration >> 0) & 0xff);
 173         trace[traceLen++] = ((duration >> 8) & 0xff);
 174
 175         // data length
 176         trace[traceLen++] = ((iLen >> 0) & 0xff);
 177         trace[traceLen++] = ((iLen >> 8) & 0xff);
 178
 179         // readerToTag flag
 180         if (!readerToTag) {
 181                 trace[traceLen - 1] |= 0x80;
 182         }
 183
 184         // data bytes
 185         if (btBytes != NULL && iLen != 0) {
 186                 memcpy(trace + traceLen, btBytes, iLen);
 187         }
 188         traceLen += iLen;
 189
 190         // parity bytes
 191         if (num_paritybytes != 0) {
 192                 if (parity != NULL) {
 193                         memcpy(trace + traceLen, parity, num_paritybytes);
 194                 } else {
 195                         memset(trace + traceLen, 0x00, num_paritybytes);
 196                 }
 197         }
 198         traceLen += num_paritybytes;
 199
 200         return TRUE;
 201 }
 202
 203
 204 int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int readerToTag)
 205 {
 206         /**
 207           Todo, rewrite the logger to use the generic functionality instead. It should be noted, however,
 208           that this logger takes number of bits as argument, not number of bytes.
 209           **/
 210
 211         if (!tracing) return FALSE;
 212
 213         uint8_t *trace = BigBuf_get_addr();
 214         uint16_t iLen = nbytes(iBits);
 215         // Return when trace is full
 216         if (traceLen + sizeof(rsamples) + sizeof(dwParity) + sizeof(iBits) + iLen > BigBuf_max_traceLen()) return FALSE;
 217
 218         //Hitag traces appear to use this traceformat:
 219         // 32 bits timestamp (little endian,Highest Bit used as readerToTag flag)
 220         // 32 bits parity
 221         // 8 bits size (number of bits in the trace entry, not number of bytes)
 222         // y Bytes data
 223
 224         rsamples += iSamples;
 225         trace[traceLen++] = ((rsamples >> 0) & 0xff);
 226         trace[traceLen++] = ((rsamples >> 8) & 0xff);
 227         trace[traceLen++] = ((rsamples >> 16) & 0xff);
 228         trace[traceLen++] = ((rsamples >> 24) & 0xff);
 229
 230         if (!readerToTag) {
 231                 trace[traceLen - 1] |= 0x80;
 232         }
 233
 234         trace[traceLen++] = ((dwParity >> 0) & 0xff);
 235         trace[traceLen++] = ((dwParity >> 8) & 0xff);
 236         trace[traceLen++] = ((dwParity >> 16) & 0xff);
 237         trace[traceLen++] = ((dwParity >> 24) & 0xff);
 238         trace[traceLen++] = iBits;
 239
 240         memcpy(trace + traceLen, btBytes, iLen);
 241         traceLen += iLen;
 242
 243         return TRUE;
 244 }
 245
 246
 247 // Emulator memory
 248 uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length){
 249         uint8_t* mem = BigBuf_get_EM_addr();
 250         if(offset+length < CARD_MEMORY_SIZE)
 251         {
 252                 memcpy(mem+offset, data, length);
 253                 return 0;
 254         }else
 255         {
 256                 Dbprintf("Error, trying to set memory outside of bounds! %d  > %d", (offset+length), CARD_MEMORY_SIZE);
 257                 return 1;
 258         }
 259 }