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