1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2018 grauerfuchs
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
7 //-----------------------------------------------------------------------------
8 // HID card format packing/unpacking routines
9 //-----------------------------------------------------------------------------
16 #include "hidcardformats.h"
17 #include "hidcardformatutils.h"
18 #include "parity.h" // for parity
21 bool Pack_H10301(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
22 memset(packed
, 0, sizeof(hidproxmessage_t
));
23 if (card
->FacilityCode
> 0xFF) return false; // Can't encode FC.
24 if (card
->CardNumber
> 0xFFFF) return false; // Can't encode CN.
25 if (card
->IssueLevel
> 0) return false; // Not used in this format
27 packed
->Length
= 26; // Set number of bits
28 packed
->bot
|= (card
->CardNumber
& 0xFFFF) << 1;
29 packed
->bot
|= (card
->FacilityCode
& 0xFF) << 17;
30 if (card
->ParitySupported
){
31 packed
->bot
|= oddparity32((packed
->bot
>> 1) & 0xFFF) & 1;
32 packed
->bot
|= (evenparity32((packed
->bot
>> 13) & 0xFFF) & 1) << 25;
34 return add_HID_header(packed
);
36 bool Unpack_H10301(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
37 memset(card
, 0, sizeof(hidproxcard_t
));
38 if (packed
->Length
!= 26) return false; // Wrong length? Stop here.
39 card
->CardNumber
= (packed
->bot
>> 1) & 0xFFFF;
40 card
->FacilityCode
= (packed
->bot
>> 17) & 0xFF;
41 card
->ParitySupported
= true;
43 (oddparity32((packed
->bot
>> 1) & 0xFFF) == (packed
->bot
& 1)) &&
44 ((evenparity32((packed
->bot
>> 13) & 0xFFF) & 1) == ((packed
->bot
>> 25) & 1));
48 bool Pack_Tecom27(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
49 memset(packed
, 0, sizeof(hidproxmessage_t
));
50 if (card
->FacilityCode
> 0x7FF) return false; // Can't encode FC.
51 if (card
->CardNumber
> 0xFFFF) return false; // Can't encode CN.
52 if (card
->IssueLevel
> 0) return false; // Not used in this format
55 set_nonlinear_field(packed
, card
->FacilityCode
, 10, (uint8_t[]){15, 19, 24, 23, 22, 18, 6, 10, 14, 3, 2});
56 set_nonlinear_field(packed
, card
->CardNumber
, 16, (uint8_t[]){0, 1, 13, 12, 9, 26, 20, 16, 17, 21, 25, 7, 8, 11, 4, 5});
57 return add_HID_header(packed
);
59 bool Unpack_Tecom27(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
60 memset(card
, 0, sizeof(hidproxcard_t
));
61 if (packed
->Length
!= 27) return false; // Wrong length? Stop here.
62 card
->CardNumber
= get_nonlinear_field(packed
, 16, (uint8_t[]){0, 1, 13, 12, 9, 26, 20, 16, 17, 21, 25, 7, 8, 11, 4, 5});
63 card
->FacilityCode
= get_nonlinear_field(packed
, 10, (uint8_t[]){15, 19, 24, 23, 22, 18, 6, 10, 14, 3, 2});
64 card
->ParitySupported
= false;
68 bool Pack_2804W(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
69 memset(packed
, 0, sizeof(hidproxmessage_t
));
70 if (card
->FacilityCode
> 0x0FF) return false; // Can't encode FC.
71 if (card
->CardNumber
> 0x7FFF) return false; // Can't encode CN.
72 if (card
->IssueLevel
> 0) return false; // Not used in this format
75 set_linear_field(packed
, card
->FacilityCode
, 4, 8);
76 set_linear_field(packed
, card
->CardNumber
, 12, 15);
77 if (card
->ParitySupported
){
78 set_bit_by_position(packed
,
79 oddparity32(get_nonlinear_field(packed
, 16, (uint8_t[]){4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26}))
81 set_bit_by_position(packed
,
82 evenparity32(get_linear_field(packed
, 1, 13))
84 set_bit_by_position(packed
,
85 oddparity32(get_linear_field(packed
, 0, 27))
88 return add_HID_header(packed
);
90 bool Unpack_2804W(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
91 memset(card
, 0, sizeof(hidproxcard_t
));
92 if (packed
->Length
!= 28) return false; // Wrong length? Stop here.
93 card
->FacilityCode
= get_linear_field(packed
, 4, 8);
94 card
->CardNumber
= get_linear_field(packed
, 12, 15);
95 card
->ParitySupported
= true;
97 (get_bit_by_position(packed
, 0) == evenparity32(get_linear_field(packed
, 1, 13))) &&
98 (get_bit_by_position(packed
, 2) == oddparity32(get_nonlinear_field(packed
, 16, (uint8_t[]){4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26}))) &&
99 (get_bit_by_position(packed
, 27) == oddparity32(get_linear_field(packed
, 0, 27)));
103 bool Pack_ATSW30(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
104 memset(packed
, 0, sizeof(hidproxmessage_t
));
105 if (card
->FacilityCode
> 0xFFF) return false; // Can't encode FC.
106 if (card
->CardNumber
> 0xFFFF) return false; // Can't encode CN.
107 if (card
->IssueLevel
> 0) return false; // Not used in this format
110 set_linear_field(packed
, card
->FacilityCode
, 1, 12);
111 set_linear_field(packed
, card
->CardNumber
, 13, 16);
112 if (card
->ParitySupported
){
113 set_bit_by_position(packed
,
114 evenparity32(get_linear_field(packed
, 1, 12))
116 set_bit_by_position(packed
,
117 oddparity32(get_linear_field(packed
, 13, 16))
120 return add_HID_header(packed
);
122 bool Unpack_ATSW30(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
123 memset(card
, 0, sizeof(hidproxcard_t
));
124 if (packed
->Length
!= 30) return false; // Wrong length? Stop here.
125 card
->FacilityCode
= get_linear_field(packed
, 1, 12);
126 card
->CardNumber
= get_linear_field(packed
, 13, 16);
127 card
->ParitySupported
= true;
129 (get_bit_by_position(packed
, 0) == evenparity32(get_linear_field(packed
, 1, 12))) &&
130 (get_bit_by_position(packed
, 29) == oddparity32(get_linear_field(packed
, 13, 16)));
133 bool Pack_ADT31(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
134 memset(packed
, 0, sizeof(hidproxmessage_t
));
135 if (card
->FacilityCode
> 0x0F) return false; // Can't encode FC.
136 if (card
->CardNumber
> 0x7FFFFF) return false; // Can't encode CN.
137 if (card
->IssueLevel
> 0) return false; // Not used in this format
140 set_linear_field(packed
, card
->FacilityCode
, 1, 4);
141 set_linear_field(packed
, card
->CardNumber
, 5, 23);
142 // Parity not known, but 4 bits are unused.
143 return add_HID_header(packed
);
145 bool Unpack_ADT31(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
146 memset(card
, 0, sizeof(hidproxcard_t
));
147 if (packed
->Length
!= 31) return false; // Wrong length? Stop here.
148 card
->FacilityCode
= get_linear_field(packed
, 1, 4);
149 card
->CardNumber
= get_linear_field(packed
, 5, 23);
150 card
->ParitySupported
= false;
154 bool Pack_D10202(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
155 memset(packed
, 0, sizeof(hidproxmessage_t
));
156 if (card
->FacilityCode
> 0x007F) return false; // Can't encode FC.
157 if (card
->CardNumber
> 0x00FFFFFF) return false; // Can't encode CN.
158 if (card
->IssueLevel
> 0) return false; // Not used in this format
160 packed
->Length
= 33; // Set number of bits
161 set_linear_field(packed
, card
->FacilityCode
, 1, 7);
162 set_linear_field(packed
, card
->CardNumber
, 8, 24);
164 if (card
->ParitySupported
){
165 set_bit_by_position(packed
, evenparity32(get_linear_field(packed
, 1, 16)), 0);
166 set_bit_by_position(packed
, oddparity32(get_linear_field(packed
, 16, 16)), 32);
168 return add_HID_header(packed
);
170 bool Unpack_D10202(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
171 memset(card
, 0, sizeof(hidproxcard_t
));
172 if (packed
->Length
!= 33) return false; // Wrong length? Stop here.
174 card
->CardNumber
= get_linear_field(packed
, 8, 24);
175 card
->FacilityCode
= get_linear_field(packed
, 1, 7);
176 card
->ParitySupported
= true;
178 (get_bit_by_position(packed
, 0) == evenparity32(get_linear_field(packed
, 1, 16))) &&
179 (get_bit_by_position(packed
, 32) == oddparity32(get_linear_field(packed
, 16, 16)));
184 bool Pack_H10306(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
185 memset(packed
, 0, sizeof(hidproxmessage_t
));
186 if (card
->FacilityCode
> 0xFFFF) return false; // Can't encode FC.
187 if (card
->CardNumber
> 0xFFFF) return false; // Can't encode CN.
188 if (card
->IssueLevel
> 0) return false; // Not used in this format
190 packed
->Length
= 34; // Set number of bits
191 packed
->bot
|= (card
->CardNumber
& 0xFFFF) << 1;
192 packed
->bot
|= (card
->FacilityCode
& 0x7FFF) << 17;
193 packed
->mid
|= (card
->FacilityCode
& 0x8000) >> 15;
194 if (card
->ParitySupported
){
195 packed
->mid
|= (evenparity32((packed
->mid
& 0x00000001) ^ (packed
->bot
& 0xFFFE0000)) & 1) << 1;
196 packed
->bot
|= ( oddparity32(packed
->bot
& 0x0001FFFE) & 1);
198 return add_HID_header(packed
);
200 bool Unpack_H10306(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
201 memset(card
, 0, sizeof(hidproxcard_t
));
202 if (packed
->Length
!= 34) return false; // Wrong length? Stop here.
204 card
->CardNumber
= (packed
->bot
>> 1) & 0xFFFF;
205 card
->FacilityCode
= ((packed
->mid
& 1) << 15) | ((packed
->bot
>> 17) & 0xFF);
206 card
->ParitySupported
= true;
208 ((evenparity32((packed
->mid
& 0x00000001) ^ (packed
->bot
& 0xFFFE0000)) & 1) == ((packed
->mid
>> 1) & 1)) &&
209 ((oddparity32(packed
->bot
& 0x0001FFFE) & 1) == ((packed
->bot
& 1)));
212 bool Pack_N1002(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
213 memset(packed
, 0, sizeof(hidproxmessage_t
));
214 if (card
->FacilityCode
> 0xFF) return false; // Can't encode FC.
215 if (card
->CardNumber
> 0xFFFF) return false; // Can't encode CN.
216 if (card
->IssueLevel
> 0) return false; // Not used in this format
218 packed
->Length
= 34; // Set number of bits
219 set_linear_field(packed
, card
->FacilityCode
, 9, 8);
220 set_linear_field(packed
, card
->CardNumber
, 17, 16);
221 return add_HID_header(packed
);
223 bool Unpack_N1002(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
224 memset(card
, 0, sizeof(hidproxcard_t
));
225 if (packed
->Length
!= 34) return false; // Wrong length? Stop here.
227 card
->CardNumber
= get_linear_field(packed
, 17, 16);
228 card
->FacilityCode
= get_linear_field(packed
, 9, 8);
229 card
->ParitySupported
= false;
234 bool Pack_C1k35s(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
235 memset(packed
, 0, sizeof(hidproxmessage_t
));
236 if (card
->FacilityCode
> 0xFFF) return false; // Can't encode FC.
237 if (card
->CardNumber
> 0xFFFFF) return false; // Can't encode CN.
238 if (card
->IssueLevel
> 0) return false; // Not used in this format
240 packed
->Length
= 35; // Set number of bits
241 packed
->bot
|= (card
->CardNumber
& 0x000FFFFF) << 1;
242 packed
->bot
|= (card
->FacilityCode
& 0x000007FF) << 21;
243 packed
->mid
|= (card
->FacilityCode
& 0x00000800) >> 11;
244 if (card
->ParitySupported
){
245 packed
->mid
|= (evenparity32((packed
->mid
& 0x00000001) ^ (packed
->bot
& 0xB6DB6DB6)) & 1) << 1;
246 packed
->bot
|= ( oddparity32((packed
->mid
& 0x00000003) ^ (packed
->bot
& 0x6DB6DB6C)) & 1);
247 packed
->mid
|= ( oddparity32((packed
->mid
& 0x00000003) ^ (packed
->bot
& 0xFFFFFFFF)) & 1) << 2;
249 return add_HID_header(packed
);
251 bool Unpack_C1k35s(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
252 memset(card
, 0, sizeof(hidproxcard_t
));
253 if (packed
->Length
!= 35) return false; // Wrong length? Stop here.
255 card
->CardNumber
= (packed
->bot
>> 1) & 0x000FFFFF;
256 card
->FacilityCode
= ((packed
->mid
& 1) << 11) | ((packed
->bot
>> 21));
257 card
->ParitySupported
= true;
259 (evenparity32((packed
->mid
& 0x00000001) ^ (packed
->bot
& 0xB6DB6DB6)) == ((packed
->mid
>> 1) & 1)) &&
260 ( oddparity32((packed
->mid
& 0x00000003) ^ (packed
->bot
& 0x6DB6DB6C)) == ((packed
->bot
>> 0) & 1)) &&
261 ( oddparity32((packed
->mid
& 0x00000003) ^ (packed
->bot
& 0xFFFFFFFF)) == ((packed
->mid
>> 2) & 1));
265 bool Pack_H10320(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
266 memset(packed
, 0, sizeof(hidproxmessage_t
));
267 if (card
->FacilityCode
> 0) return false; // Can't encode FC. (none in this format)
268 if (card
->CardNumber
> 99999999) return false; // Can't encode CN.
269 if (card
->IssueLevel
> 0) return false; // Not used in this format
271 packed
->Length
= 36; // Set number of bits
272 // This card is BCD-encoded rather than binary. Set the 4-bit groups independently.
273 for (uint32_t idx
= 0; idx
< 8; idx
++){
274 set_linear_field(packed
, (uint64_t)(card
->CardNumber
/ pow(10, 7-idx
)) % 10, idx
* 4, 4);
276 if (card
->ParitySupported
){
277 set_bit_by_position(packed
, evenparity32(
278 get_nonlinear_field(packed
, 8, (uint8_t[]){0, 4, 8, 12, 16, 20, 24, 28})
280 set_bit_by_position(packed
, oddparity32(
281 get_nonlinear_field(packed
, 8, (uint8_t[]){1, 5, 9, 13, 17, 21, 25, 29})
283 set_bit_by_position(packed
, evenparity32(
284 get_nonlinear_field(packed
, 8, (uint8_t[]){2, 6, 10, 14, 18, 22, 28, 30})
286 set_bit_by_position(packed
, evenparity32(
287 get_nonlinear_field(packed
, 8, (uint8_t[]){3, 7, 11, 15, 19, 23, 29, 31})
290 return add_HID_header(packed
);
292 bool Unpack_H10320(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
293 memset(card
, 0, sizeof(hidproxcard_t
));
294 if (packed
->Length
!= 36) return false; // Wrong length? Stop here.
295 // This card is BCD-encoded rather than binary. Get the 4-bit groups independently.
296 for (uint32_t idx
= 0; idx
< 8; idx
++){
297 uint64_t val
= get_linear_field(packed
, idx
* 4, 4);
299 // Violation of BCD; Zero and exit.
300 card
->CardNumber
= 0;
303 card
->CardNumber
+= val
* pow(10, 7-idx
);
306 card
->ParitySupported
= true;
308 (get_bit_by_position(packed
, 32) == evenparity32(get_nonlinear_field(packed
, 8, (uint8_t[]){0, 4, 8, 12, 16, 20, 24, 28}))) &&
309 (get_bit_by_position(packed
, 33) == oddparity32(get_nonlinear_field(packed
, 8, (uint8_t[]){1, 5, 9, 13, 17, 21, 25, 29}))) &&
310 (get_bit_by_position(packed
, 34) == evenparity32(get_nonlinear_field(packed
, 8, (uint8_t[]){2, 6, 10, 14, 18, 22, 28, 30}))) &&
311 (get_bit_by_position(packed
, 35) == evenparity32(get_nonlinear_field(packed
, 8, (uint8_t[]){3, 7, 11, 15, 19, 23, 29, 31})));
315 bool Pack_S12906(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
316 memset(packed
, 0, sizeof(hidproxmessage_t
));
317 if (card
->FacilityCode
> 0xFF) return false; // Can't encode FC.
318 if (card
->IssueLevel
> 0x03) return false; // Can't encode IL.
319 if (card
->CardNumber
> 0x00FFFFFF) return false; // Can't encode CN.
321 packed
->Length
= 36; // Set number of bits
322 set_linear_field(packed
, card
->FacilityCode
, 1, 8);
323 set_linear_field(packed
, card
->IssueLevel
, 9, 2);
324 set_linear_field(packed
, card
->CardNumber
, 11, 24);
325 if (card
->ParitySupported
){
326 set_bit_by_position(packed
,
327 oddparity32(get_linear_field(packed
, 1, 17))
329 set_bit_by_position(packed
,
330 oddparity32(get_linear_field(packed
, 17, 18))
333 return add_HID_header(packed
);
335 bool Unpack_S12906(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
336 memset(card
, 0, sizeof(hidproxcard_t
));
337 if (packed
->Length
!= 36) return false; // Wrong length? Stop here.
339 card
->FacilityCode
= get_linear_field(packed
, 1, 8);
340 card
->IssueLevel
= get_linear_field(packed
, 9, 2);
341 card
->CardNumber
= get_linear_field(packed
, 11, 24);
343 card
->ParitySupported
= true;
345 (get_bit_by_position(packed
, 0) == oddparity32(get_linear_field(packed
, 1, 17))) &&
346 (get_bit_by_position(packed
, 35) == oddparity32(get_linear_field(packed
, 17, 18)));
351 bool Pack_Sie36(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
352 memset(packed
, 0, sizeof(hidproxmessage_t
));
353 if (card
->FacilityCode
> 0x0003FFFF) return false; // Can't encode FC.
354 if (card
->IssueLevel
> 0x00) return false; // Can't encode IL.
355 if (card
->CardNumber
> 0x0000FFFF) return false; // Can't encode CN.
356 if (card
->IssueLevel
> 0) return false; // Not used in this format
358 packed
->Length
= 36; // Set number of bits
359 set_linear_field(packed
, card
->FacilityCode
, 1, 18);
360 set_linear_field(packed
, card
->CardNumber
, 19, 16);
361 if (card
->ParitySupported
){
362 set_bit_by_position(packed
,
363 oddparity32(get_nonlinear_field(packed
, 23, (uint8_t[]){1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21, 22, 24, 25, 27, 28, 30, 31, 33, 34}))
365 set_bit_by_position(packed
,
366 evenparity32(get_nonlinear_field(packed
, 23, (uint8_t[]){1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26, 28, 29, 31, 32, 34}))
369 return add_HID_header(packed
);
371 bool Unpack_Sie36(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
372 memset(card
, 0, sizeof(hidproxcard_t
));
373 if (packed
->Length
!= 36) return false; // Wrong length? Stop here.
375 card
->FacilityCode
= get_linear_field(packed
, 1, 18);
376 card
->CardNumber
= get_linear_field(packed
, 19, 16);
378 card
->ParitySupported
= true;
380 (get_bit_by_position(packed
, 0) == oddparity32(get_nonlinear_field(packed
, 23, (uint8_t[]){1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21, 22, 24, 25, 27, 28, 30, 31, 33, 34}))) &&
381 (get_bit_by_position(packed
, 35) == oddparity32(get_nonlinear_field(packed
, 23, (uint8_t[]){1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26, 28, 29, 31, 32, 34})));
387 bool Pack_H10302(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
388 memset(packed
, 0, sizeof(hidproxmessage_t
));
389 if (card
->FacilityCode
> 0) return false; // Can't encode FC. (none in this format)
390 if (card
->CardNumber
> 0x00000007FFFFFFFF) return false; // Can't encode CN.
391 if (card
->IssueLevel
> 0) return false; // Not used in this format
393 packed
->Length
= 37; // Set number of bits
394 set_linear_field(packed
, card
->CardNumber
, 1, 35);
395 if (card
->ParitySupported
){
396 set_bit_by_position(packed
,
397 evenparity32(get_linear_field(packed
, 1, 18))
399 set_bit_by_position(packed
,
400 oddparity32(get_linear_field(packed
, 18, 18))
403 return add_HID_header(packed
);
405 bool Unpack_H10302(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
406 memset(card
, 0, sizeof(hidproxcard_t
));
407 if (packed
->Length
!= 37) return false; // Wrong length? Stop here.
409 card
->CardNumber
= get_linear_field(packed
, 1, 35);
410 card
->ParitySupported
= true;
412 (get_bit_by_position(packed
, 0) == evenparity32(get_linear_field(packed
, 1, 18))) &&
413 (get_bit_by_position(packed
, 36) == oddparity32(get_linear_field(packed
, 18, 18)));
418 bool Pack_H10304(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
419 memset(packed
, 0, sizeof(hidproxmessage_t
));
420 if (card
->FacilityCode
> 0x0000FFFF) return false; // Can't encode FC.
421 if (card
->CardNumber
> 0x0007FFFF) return false; // Can't encode CN.
422 if (card
->IssueLevel
> 0) return false; // Not used in this format
424 packed
->Length
= 37; // Set number of bits
425 packed
->bot
|= (card
->CardNumber
& 0x0007FFFF) << 1;
426 packed
->bot
|= (card
->FacilityCode
& 0x00000FFF) << 20;
427 packed
->mid
|= (card
->FacilityCode
& 0x0000F000) >> 12;
428 if (card
->ParitySupported
){
429 packed
->mid
|= (evenparity32((packed
->mid
& 0x0000000F) ^ (packed
->bot
& 0xFFFC0000)) & 1) << 4;
430 packed
->bot
|= ( oddparity32(packed
->bot
& 0x0007FFFE) & 1);
432 return add_HID_header(packed
);
434 bool Unpack_H10304(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
435 memset(card
, 0, sizeof(hidproxcard_t
));
436 if (packed
->Length
!= 37) return false; // Wrong length? Stop here.
438 card
->CardNumber
= (packed
->bot
>> 1) & 0x0007FFFF;
439 card
->FacilityCode
= ((packed
->mid
& 0xF) << 12) | ((packed
->bot
>> 20));
440 card
->ParitySupported
= true;
442 (evenparity32((packed
->mid
& 0x0000000F) ^ (packed
->bot
& 0xFFFC0000)) == ((packed
->mid
>> 4) & 1)) &&
443 (oddparity32( packed
->bot
& 0x0007FFFE) == (packed
->bot
& 1));
448 bool Pack_P10001(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
449 memset(packed
, 0, sizeof(hidproxmessage_t
));
450 if (card
->FacilityCode
> 0xFFF) return false; // Can't encode FC.
451 if (card
->CardNumber
> 0xFFFF) return false; // Can't encode CN.
452 if (card
->IssueLevel
> 0) return false; // Not used in this format
454 packed
->Length
= 40; // Set number of bits
455 set_linear_field(packed
, 0xF, 0, 4);
456 set_linear_field(packed
, card
->FacilityCode
, 4, 12);
457 set_linear_field(packed
, card
->CardNumber
, 16, 16);
459 if (card
->ParitySupported
){
460 set_linear_field(packed
,
461 get_linear_field(packed
, 0, 8) ^
462 get_linear_field(packed
, 8, 8) ^
463 get_linear_field(packed
, 16, 8) ^
464 get_linear_field(packed
, 24, 8)
467 return add_HID_header(packed
);
469 bool Unpack_P10001(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
470 memset(card
, 0, sizeof(hidproxcard_t
));
471 if (packed
->Length
!= 40) return false; // Wrong length? Stop here.
473 card
->CardNumber
= get_linear_field(packed
, 16, 16);
474 card
->FacilityCode
= get_linear_field(packed
, 4, 12);
475 card
->ParitySupported
= true;
476 card
->ParityValid
= (
477 get_linear_field(packed
, 0, 8) ^
478 get_linear_field(packed
, 8, 8) ^
479 get_linear_field(packed
, 16, 8) ^
480 get_linear_field(packed
, 24, 8)
481 ) == get_linear_field(packed
, 32, 8);
486 bool Pack_C1k48s(/*in*/hidproxcard_t
* card
, /*out*/hidproxmessage_t
* packed
){
487 memset(packed
, 0, sizeof(hidproxmessage_t
));
488 if (card
->FacilityCode
> 0x003FFFFF) return false; // Can't encode FC.
489 if (card
->CardNumber
> 0x007FFFFF) return false; // Can't encode CN.
490 if (card
->IssueLevel
> 0) return false; // Not used in this format
492 packed
->Length
= 48; // Set number of bits
493 packed
->bot
|= (card
->CardNumber
& 0x007FFFFF) << 1;
494 packed
->bot
|= (card
->FacilityCode
& 0x000000FF) << 24;
495 packed
->mid
|= (card
->FacilityCode
& 0x003FFF00) >> 8;
496 if (card
->ParitySupported
){
497 packed
->mid
|= (evenparity32((packed
->mid
& 0x00001B6D) ^ (packed
->bot
& 0xB6DB6DB6)) & 1) << 14;
498 packed
->bot
|= ( oddparity32((packed
->mid
& 0x000036DB) ^ (packed
->bot
& 0x6DB6DB6C)) & 1);
499 packed
->mid
|= ( oddparity32((packed
->mid
& 0x00007FFF) ^ (packed
->bot
& 0xFFFFFFFF)) & 1) << 15;
501 return add_HID_header(packed
);
503 bool Unpack_C1k48s(/*in*/hidproxmessage_t
* packed
, /*out*/hidproxcard_t
* card
){
504 memset(card
, 0, sizeof(hidproxcard_t
));
505 if (packed
->Length
!= 48) return false; // Wrong length? Stop here.
507 card
->CardNumber
= (packed
->bot
>> 1) & 0x007FFFFF;
508 card
->FacilityCode
= ((packed
->mid
& 0x00003FFF) << 8) | ((packed
->bot
>> 24));
509 card
->ParitySupported
= true;
511 (evenparity32((packed
->mid
& 0x00001B6D) ^ (packed
->bot
& 0xB6DB6DB6)) == ((packed
->mid
>> 14) & 1)) &&
512 ( oddparity32((packed
->mid
& 0x000036DB) ^ (packed
->bot
& 0x6DB6DB6C)) == ((packed
->bot
>> 0) & 1)) &&
513 ( oddparity32((packed
->mid
& 0x00007FFF) ^ (packed
->bot
& 0xFFFFFFFF)) == ((packed
->mid
>> 15) & 1));
517 static const hidcardformat_t FormatTable
[] = {
518 {"H10301", Pack_H10301
, Unpack_H10301
, "HID H10301 26-bit"}, // imported from old pack/unpack
519 {"Tecom27", Pack_Tecom27
, Unpack_Tecom27
, "Tecom 27-bit"}, // from cardinfo.barkweb.com.au
520 {"2804W", Pack_2804W
, Unpack_2804W
, "2804 Wiegand"}, // from cardinfo.barkweb.com.au
521 {"ATSW30", Pack_ATSW30
, Unpack_ATSW30
, "ATS Wiegand 30-bit"}, // from cardinfo.barkweb.com.au
522 {"ADT31", Pack_ADT31
, Unpack_ADT31
, "HID ADT 31-bit"}, // from cardinfo.barkweb.com.au
523 {"D10202", Pack_D10202
, Unpack_D10202
, "HID D10202 33-bit"}, // from cardinfo.barkweb.com.au
524 {"H10306", Pack_H10306
, Unpack_H10306
, "HID H10306 34-bit"}, // imported from old pack/unpack
525 {"N1002", Pack_N1002
, Unpack_N1002
, "HID N1002 34-bit"}, // from cardinfo.barkweb.com.au
526 {"C1k35s", Pack_C1k35s
, Unpack_C1k35s
, "HID Corporate 1000 35-bit standard layout"}, // imported from old pack/unpack
527 {"S12906", Pack_S12906
, Unpack_S12906
, "HID Simplex 36-bit"}, // from cardinfo.barkweb.com.au
528 {"Sie36", Pack_Sie36
, Unpack_Sie36
, "HID 36-bit Siemens"}, // from cardinfo.barkweb.com.au
529 {"H10320", Pack_H10320
, Unpack_H10320
, "HID H10320 36-bit BCD, Card num only"}, // from Proxmark forums
530 {"H10302", Pack_H10302
, Unpack_H10302
, "HID H10302 37-bit huge, Card num only"}, // from Proxmark forums
531 {"H10304", Pack_H10304
, Unpack_H10304
, "HID H10304 37-bit"}, // imported from old pack/unpack
532 {"P10001", Pack_P10001
, Unpack_P10001
, "HID P10001 Honeywell 40-bit"}, // from cardinfo.barkweb.com.au
533 {"C1k48s", Pack_C1k48s
, Unpack_C1k48s
, "HID Corporate 1000 48-bit standard layout"}, // imported from old pack/unpack
534 {NULL
, NULL
, NULL
, NULL
} // Must null terminate array
537 void HIDListFormats(){
538 if (FormatTable
[0].Name
== NULL
)
541 PrintAndLog("%-10s %s", "Name", "Description");
542 PrintAndLog("------------------------------------------------------------");
543 while (FormatTable
[i
].Name
)
545 PrintAndLog("%-10s %s", FormatTable
[i
].Name
, FormatTable
[i
].Descrp
);
552 hidcardformat_t
HIDGetCardFormat(int idx
){
553 return FormatTable
[idx
];
556 int HIDFindCardFormat(const char *format
)
558 if (FormatTable
[0].Name
== NULL
)
561 while (FormatTable
[i
].Name
&& strcmp(FormatTable
[i
].Name
, format
))
566 if (FormatTable
[i
].Name
) {
573 bool HIDPack(/* in */int FormatIndex
, /* in */hidproxcard_t
* card
, /* out */hidproxmessage_t
* packed
){
574 memset(packed
, 0, sizeof(hidproxmessage_t
));
575 if (FormatIndex
< 0 || FormatIndex
>= (sizeof(FormatTable
) / sizeof(FormatTable
[0]))) return false;
576 return FormatTable
[FormatIndex
].Pack(card
, packed
);
579 bool HIDTryUnpack(/* in */hidproxmessage_t
* packed
, /* in */bool ignoreParity
){
580 if (FormatTable
[0].Name
== NULL
)
586 memset(&card
, 0, sizeof(hidproxcard_t
));
587 while (FormatTable
[i
].Name
)
589 if (FormatTable
[i
].Unpack(packed
, &card
)){
590 if (ignoreParity
|| !card
.ParitySupported
|| card
.ParityValid
){
592 PrintAndLog("%-16s FC: %u, Card: %"PRIu64
", IL: %u, Parity %s",
597 (card
.ParitySupported
) ? ((card
.ParityValid
) ? "valid" : "invalid") : "n/a"