Skip to content

Commit 6d15c23

Browse files
xMasterXxMasterX
committed
Merge branch 'ofw_dev' into dev
2 parents 7d7f15b + dd988ba commit 6d15c23

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

57 files changed

+667
-185
lines changed

‎applications/debug/unit_tests/lfrfid/bit_lib_test.c renamed to ‎applications/debug/unit_tests/bit_lib/bit_lib_test.c

Lines changed: 268 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
#include <furi.h>
22
#include "../minunit.h"
3-
#include <lfrfid/tools/bit_lib.h>
3+
#include <bit_lib/bit_lib.h>
44

55
MU_TEST(test_bit_lib_increment_index) {
66
uint32_t index = 0;
@@ -218,6 +218,178 @@ MU_TEST(test_bit_lib_get_bits_32) {
218218
mu_assert_int_eq(0b00001001101100011000110001100010, bit_lib_get_bits_32(value, 0, 32));
219219
}
220220

221+
MU_TEST(test_bit_lib_get_bits_64) {
222+
uint8_t value[8] = {
223+
0b00001001,
224+
0b10110001,
225+
0b10001100,
226+
0b01100010,
227+
0b00001001,
228+
0b10110001,
229+
0b10001100,
230+
0b01100010};
231+
mu_assert_int_eq(0b0, bit_lib_get_bits_64(value, 0, 1));
232+
mu_assert_int_eq(0b00, bit_lib_get_bits_64(value, 0, 2));
233+
mu_assert_int_eq(0b000, bit_lib_get_bits_64(value, 0, 3));
234+
mu_assert_int_eq(0b0000, bit_lib_get_bits_64(value, 0, 4));
235+
mu_assert_int_eq(0b00001, bit_lib_get_bits_64(value, 0, 5));
236+
mu_assert_int_eq(0b000010, bit_lib_get_bits_64(value, 0, 6));
237+
mu_assert_int_eq(0b0000100, bit_lib_get_bits_64(value, 0, 7));
238+
mu_assert_int_eq(0b00001001, bit_lib_get_bits_64(value, 0, 8));
239+
mu_assert_int_eq(0b000010011, bit_lib_get_bits_64(value, 0, 9));
240+
mu_assert_int_eq(0b0000100110, bit_lib_get_bits_64(value, 0, 10));
241+
mu_assert_int_eq(0b00001001101, bit_lib_get_bits_64(value, 0, 11));
242+
mu_assert_int_eq(0b000010011011, bit_lib_get_bits_64(value, 0, 12));
243+
mu_assert_int_eq(0b0000100110110, bit_lib_get_bits_64(value, 0, 13));
244+
mu_assert_int_eq(0b00001001101100, bit_lib_get_bits_64(value, 0, 14));
245+
mu_assert_int_eq(0b000010011011000, bit_lib_get_bits_64(value, 0, 15));
246+
mu_assert_int_eq(0b0000100110110001, bit_lib_get_bits_64(value, 0, 16));
247+
mu_assert_int_eq(0b00001001101100011, bit_lib_get_bits_64(value, 0, 17));
248+
mu_assert_int_eq(0b000010011011000110, bit_lib_get_bits_64(value, 0, 18));
249+
mu_assert_int_eq(0b0000100110110001100, bit_lib_get_bits_64(value, 0, 19));
250+
mu_assert_int_eq(0b00001001101100011000, bit_lib_get_bits_64(value, 0, 20));
251+
mu_assert_int_eq(0b000010011011000110001, bit_lib_get_bits_64(value, 0, 21));
252+
mu_assert_int_eq(0b0000100110110001100011, bit_lib_get_bits_64(value, 0, 22));
253+
mu_assert_int_eq(0b00001001101100011000110, bit_lib_get_bits_64(value, 0, 23));
254+
mu_assert_int_eq(0b000010011011000110001100, bit_lib_get_bits_64(value, 0, 24));
255+
mu_assert_int_eq(0b0000100110110001100011000, bit_lib_get_bits_64(value, 0, 25));
256+
mu_assert_int_eq(0b00001001101100011000110001, bit_lib_get_bits_64(value, 0, 26));
257+
mu_assert_int_eq(0b000010011011000110001100011, bit_lib_get_bits_64(value, 0, 27));
258+
mu_assert_int_eq(0b0000100110110001100011000110, bit_lib_get_bits_64(value, 0, 28));
259+
mu_assert_int_eq(0b00001001101100011000110001100, bit_lib_get_bits_64(value, 0, 29));
260+
mu_assert_int_eq(0b000010011011000110001100011000, bit_lib_get_bits_64(value, 0, 30));
261+
mu_assert_int_eq(0b0000100110110001100011000110001, bit_lib_get_bits_64(value, 0, 31));
262+
mu_assert_int_eq(0b00001001101100011000110001100010, bit_lib_get_bits_64(value, 0, 32));
263+
264+
uint64_t res = bit_lib_get_bits_64(value, 0, 33);
265+
uint64_t expected = 0b000010011011000110001100011000100;
266+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
267+
268+
res = bit_lib_get_bits_64(value, 0, 34);
269+
expected = 0b0000100110110001100011000110001000;
270+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
271+
272+
res = bit_lib_get_bits_64(value, 0, 35);
273+
expected = 0b00001001101100011000110001100010000;
274+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
275+
276+
res = bit_lib_get_bits_64(value, 0, 36);
277+
expected = 0b000010011011000110001100011000100000;
278+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
279+
280+
res = bit_lib_get_bits_64(value, 0, 37);
281+
expected = 0b0000100110110001100011000110001000001;
282+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
283+
284+
res = bit_lib_get_bits_64(value, 0, 38);
285+
expected = 0b00001001101100011000110001100010000010;
286+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
287+
288+
res = bit_lib_get_bits_64(value, 0, 39);
289+
expected = 0b000010011011000110001100011000100000100;
290+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
291+
292+
res = bit_lib_get_bits_64(value, 0, 40);
293+
expected = 0b0000100110110001100011000110001000001001;
294+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
295+
296+
res = bit_lib_get_bits_64(value, 0, 41);
297+
expected = 0b00001001101100011000110001100010000010011;
298+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
299+
300+
res = bit_lib_get_bits_64(value, 0, 42);
301+
expected = 0b000010011011000110001100011000100000100110;
302+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
303+
304+
res = bit_lib_get_bits_64(value, 0, 43);
305+
expected = 0b0000100110110001100011000110001000001001101;
306+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
307+
308+
res = bit_lib_get_bits_64(value, 0, 44);
309+
expected = 0b00001001101100011000110001100010000010011011;
310+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
311+
312+
res = bit_lib_get_bits_64(value, 0, 45);
313+
expected = 0b000010011011000110001100011000100000100110110;
314+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
315+
316+
res = bit_lib_get_bits_64(value, 0, 46);
317+
expected = 0b0000100110110001100011000110001000001001101100;
318+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
319+
320+
res = bit_lib_get_bits_64(value, 0, 47);
321+
expected = 0b00001001101100011000110001100010000010011011000;
322+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
323+
324+
res = bit_lib_get_bits_64(value, 0, 48);
325+
expected = 0b000010011011000110001100011000100000100110110001;
326+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
327+
328+
res = bit_lib_get_bits_64(value, 0, 49);
329+
expected = 0b0000100110110001100011000110001000001001101100011;
330+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
331+
332+
res = bit_lib_get_bits_64(value, 0, 50);
333+
expected = 0b00001001101100011000110001100010000010011011000110;
334+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
335+
336+
res = bit_lib_get_bits_64(value, 0, 51);
337+
expected = 0b000010011011000110001100011000100000100110110001100;
338+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
339+
340+
res = bit_lib_get_bits_64(value, 0, 52);
341+
expected = 0b0000100110110001100011000110001000001001101100011000;
342+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
343+
344+
res = bit_lib_get_bits_64(value, 0, 53);
345+
expected = 0b00001001101100011000110001100010000010011011000110001;
346+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
347+
348+
res = bit_lib_get_bits_64(value, 0, 54);
349+
expected = 0b000010011011000110001100011000100000100110110001100011;
350+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
351+
352+
res = bit_lib_get_bits_64(value, 0, 55);
353+
expected = 0b0000100110110001100011000110001000001001101100011000110;
354+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
355+
356+
res = bit_lib_get_bits_64(value, 0, 56);
357+
expected = 0b00001001101100011000110001100010000010011011000110001100;
358+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
359+
360+
res = bit_lib_get_bits_64(value, 0, 57);
361+
expected = 0b000010011011000110001100011000100000100110110001100011000;
362+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
363+
364+
res = bit_lib_get_bits_64(value, 0, 58);
365+
expected = 0b0000100110110001100011000110001000001001101100011000110001;
366+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
367+
368+
res = bit_lib_get_bits_64(value, 0, 59);
369+
expected = 0b00001001101100011000110001100010000010011011000110001100011;
370+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
371+
372+
res = bit_lib_get_bits_64(value, 0, 60);
373+
expected = 0b000010011011000110001100011000100000100110110001100011000110;
374+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
375+
376+
res = bit_lib_get_bits_64(value, 0, 61);
377+
expected = 0b0000100110110001100011000110001000001001101100011000110001100;
378+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
379+
380+
res = bit_lib_get_bits_64(value, 0, 62);
381+
expected = 0b00001001101100011000110001100010000010011011000110001100011000;
382+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
383+
384+
res = bit_lib_get_bits_64(value, 0, 63);
385+
expected = 0b000010011011000110001100011000100000100110110001100011000110001;
386+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
387+
388+
res = bit_lib_get_bits_64(value, 0, 64);
389+
expected = 0b0000100110110001100011000110001000001001101100011000110001100010;
390+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
391+
}
392+
221393
MU_TEST(test_bit_lib_test_parity_u32) {
222394
// test even parity
223395
mu_assert_int_eq(bit_lib_test_parity_32(0b00000000, BitLibParityEven), 0);
@@ -447,6 +619,95 @@ MU_TEST(test_bit_lib_crc16) {
447619
mu_assert_int_eq(0x31C3, bit_lib_crc16(data, data_size, 0x1021, 0x0000, false, false, 0x0000));
448620
}
449621

622+
MU_TEST(test_bit_lib_num_to_bytes_be) {
623+
uint8_t src[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
624+
uint8_t dest[8];
625+
626+
bit_lib_num_to_bytes_be(0x01, 1, dest);
627+
mu_assert_mem_eq(src, dest, sizeof(src[0]));
628+
629+
bit_lib_num_to_bytes_be(0x0123456789ABCDEF, 4, dest);
630+
mu_assert_mem_eq(src + 4, dest, 4 * sizeof(src[0]));
631+
632+
bit_lib_num_to_bytes_be(0x0123456789ABCDEF, 8, dest);
633+
mu_assert_mem_eq(src, dest, 8 * sizeof(src[0]));
634+
635+
bit_lib_num_to_bytes_be(bit_lib_bytes_to_num_be(src, 8), 8, dest);
636+
mu_assert_mem_eq(src, dest, 8 * sizeof(src[0]));
637+
}
638+
639+
MU_TEST(test_bit_lib_num_to_bytes_le) {
640+
uint8_t dest[8];
641+
642+
uint8_t n2b_le_expected_1[] = {0x01};
643+
bit_lib_num_to_bytes_le(0x01, 1, dest);
644+
mu_assert_mem_eq(n2b_le_expected_1, dest, sizeof(n2b_le_expected_1[0]));
645+
646+
uint8_t n2b_le_expected_2[] = {0xEF, 0xCD, 0xAB, 0x89};
647+
bit_lib_num_to_bytes_le(0x0123456789ABCDEF, 4, dest);
648+
mu_assert_mem_eq(n2b_le_expected_2, dest, 4 * sizeof(n2b_le_expected_2[0]));
649+
650+
uint8_t n2b_le_expected_3[] = {0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01};
651+
bit_lib_num_to_bytes_le(0x0123456789ABCDEF, 8, dest);
652+
mu_assert_mem_eq(n2b_le_expected_3, dest, 8 * sizeof(n2b_le_expected_3[0]));
653+
654+
bit_lib_num_to_bytes_le(bit_lib_bytes_to_num_le(n2b_le_expected_3, 8), 8, dest);
655+
mu_assert_mem_eq(n2b_le_expected_3, dest, 8 * sizeof(n2b_le_expected_3[0]));
656+
}
657+
658+
MU_TEST(test_bit_lib_bytes_to_num_be) {
659+
uint8_t src[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
660+
uint64_t res;
661+
662+
res = bit_lib_bytes_to_num_be(src, 1);
663+
mu_assert_int_eq(0x01, res);
664+
665+
res = bit_lib_bytes_to_num_be(src, 4);
666+
mu_assert_int_eq(0x01234567, res);
667+
668+
res = bit_lib_bytes_to_num_be(src, 8);
669+
uint64_t expected = 0x0123456789ABCDEF;
670+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
671+
}
672+
673+
MU_TEST(test_bit_lib_bytes_to_num_le) {
674+
uint8_t src[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
675+
uint64_t res;
676+
677+
res = bit_lib_bytes_to_num_le(src, 1);
678+
mu_assert_int_eq(0x01, res);
679+
680+
res = bit_lib_bytes_to_num_le(src, 4);
681+
mu_assert_int_eq(0x67452301, res);
682+
683+
res = bit_lib_bytes_to_num_le(src, 8);
684+
uint64_t expected = 0xEFCDAB8967452301;
685+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
686+
}
687+
688+
MU_TEST(test_bit_lib_bytes_to_num_bcd) {
689+
uint8_t src[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
690+
uint64_t res;
691+
bool is_bcd_res;
692+
693+
res = bit_lib_bytes_to_num_bcd(src, 1, &is_bcd_res);
694+
mu_assert_int_eq(01, res);
695+
mu_assert_int_eq(true, is_bcd_res);
696+
697+
res = bit_lib_bytes_to_num_bcd(src, 4, &is_bcd_res);
698+
mu_assert_int_eq(1234567, res);
699+
mu_assert_int_eq(true, is_bcd_res);
700+
701+
uint8_t digits[5] = {0x98, 0x76, 0x54, 0x32, 0x10};
702+
uint64_t expected = 9876543210;
703+
res = bit_lib_bytes_to_num_bcd(digits, 5, &is_bcd_res);
704+
mu_assert_mem_eq(&expected, &res, sizeof(expected));
705+
mu_assert_int_eq(true, is_bcd_res);
706+
707+
res = bit_lib_bytes_to_num_bcd(src, 8, &is_bcd_res);
708+
mu_assert_int_eq(false, is_bcd_res);
709+
}
710+
450711
MU_TEST_SUITE(test_bit_lib) {
451712
MU_RUN_TEST(test_bit_lib_increment_index);
452713
MU_RUN_TEST(test_bit_lib_is_set);
@@ -457,6 +718,7 @@ MU_TEST_SUITE(test_bit_lib) {
457718
MU_RUN_TEST(test_bit_lib_get_bits);
458719
MU_RUN_TEST(test_bit_lib_get_bits_16);
459720
MU_RUN_TEST(test_bit_lib_get_bits_32);
721+
MU_RUN_TEST(test_bit_lib_get_bits_64);
460722
MU_RUN_TEST(test_bit_lib_test_parity_u32);
461723
MU_RUN_TEST(test_bit_lib_test_parity);
462724
MU_RUN_TEST(test_bit_lib_remove_bit_every_nth);
@@ -465,6 +727,11 @@ MU_TEST_SUITE(test_bit_lib) {
465727
MU_RUN_TEST(test_bit_lib_get_bit_count);
466728
MU_RUN_TEST(test_bit_lib_reverse_16_fast);
467729
MU_RUN_TEST(test_bit_lib_crc16);
730+
MU_RUN_TEST(test_bit_lib_num_to_bytes_be);
731+
MU_RUN_TEST(test_bit_lib_num_to_bytes_le);
732+
MU_RUN_TEST(test_bit_lib_bytes_to_num_be);
733+
MU_RUN_TEST(test_bit_lib_bytes_to_num_le);
734+
MU_RUN_TEST(test_bit_lib_bytes_to_num_bcd);
468735
}
469736

470737
int run_minunit_test_bit_lib() {

‎applications/main/nfc/helpers/mfkey32_logger.c

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22

33
#include <m-array.h>
44

5-
#include <nfc/helpers/nfc_util.h>
5+
#include <bit_lib/bit_lib.h>
66
#include <stream/stream.h>
77
#include <stream/buffered_file_stream.h>
88

@@ -63,9 +63,9 @@ static bool mfkey32_logger_add_nonce_to_existing_params(
6363
if(params->sector_num != sector_num) continue;
6464
if(params->key_type != auth_context->key_type) continue;
6565

66-
params->nt1 = nfc_util_bytes2num(auth_context->nt.data, sizeof(MfClassicNt));
67-
params->nr1 = nfc_util_bytes2num(auth_context->nr.data, sizeof(MfClassicNr));
68-
params->ar1 = nfc_util_bytes2num(auth_context->ar.data, sizeof(MfClassicAr));
66+
params->nt1 = bit_lib_bytes_to_num_be(auth_context->nt.data, sizeof(MfClassicNt));
67+
params->nr1 = bit_lib_bytes_to_num_be(auth_context->nr.data, sizeof(MfClassicNr));
68+
params->ar1 = bit_lib_bytes_to_num_be(auth_context->ar.data, sizeof(MfClassicAr));
6969
params->is_filled = true;
7070

7171
instance->params_collected++;
@@ -90,9 +90,9 @@ void mfkey32_logger_add_nonce(Mfkey32Logger* instance, MfClassicAuthContext* aut
9090
.cuid = instance->cuid,
9191
.sector_num = sector_num,
9292
.key_type = auth_context->key_type,
93-
.nt0 = nfc_util_bytes2num(auth_context->nt.data, sizeof(MfClassicNt)),
94-
.nr0 = nfc_util_bytes2num(auth_context->nr.data, sizeof(MfClassicNr)),
95-
.ar0 = nfc_util_bytes2num(auth_context->ar.data, sizeof(MfClassicAr)),
93+
.nt0 = bit_lib_bytes_to_num_be(auth_context->nt.data, sizeof(MfClassicNt)),
94+
.nr0 = bit_lib_bytes_to_num_be(auth_context->nr.data, sizeof(MfClassicNr)),
95+
.ar0 = bit_lib_bytes_to_num_be(auth_context->ar.data, sizeof(MfClassicAr)),
9696
};
9797
Mfkey32LoggerParams_push_back(instance->params_arr, params);
9898
instance->nonces_saves++;

‎applications/main/nfc/plugins/supported_cards/aime.c

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
#include <flipper_application/flipper_application.h>
44

55
#include <nfc/nfc_device.h>
6-
#include <nfc/helpers/nfc_util.h>
6+
#include <bit_lib/bit_lib.h>
77
#include <nfc/protocols/mf_classic/mf_classic_poller_sync.h>
88

99
#define TAG "Aime"
@@ -19,7 +19,7 @@ bool aime_verify(Nfc* nfc) {
1919
FURI_LOG_D(TAG, "Verifying sector %u", verify_sector);
2020

2121
MfClassicKey key = {};
22-
nfc_util_num2bytes(aime_key, COUNT_OF(key.data), key.data);
22+
bit_lib_num_to_bytes_be(aime_key, COUNT_OF(key.data), key.data);
2323

2424
MfClassicAuthContext auth_ctx = {};
2525
MfClassicError error =
@@ -53,9 +53,9 @@ static bool aime_read(Nfc* nfc, NfcDevice* device) {
5353
data->type = type;
5454
MfClassicDeviceKeys keys = {};
5555
for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) {
56-
nfc_util_num2bytes(aime_key, sizeof(MfClassicKey), keys.key_a[i].data);
56+
bit_lib_num_to_bytes_be(aime_key, sizeof(MfClassicKey), keys.key_a[i].data);
5757
FURI_BIT_SET(keys.key_a_mask, i);
58-
nfc_util_num2bytes(aime_key, sizeof(MfClassicKey), keys.key_b[i].data);
58+
bit_lib_num_to_bytes_be(aime_key, sizeof(MfClassicKey), keys.key_b[i].data);
5959
FURI_BIT_SET(keys.key_b_mask, i);
6060
}
6161

@@ -85,7 +85,7 @@ static bool aime_parse(const NfcDevice* device, FuriString* parsed_data) {
8585
do {
8686
// verify key
8787
MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, 0);
88-
uint64_t key = nfc_util_bytes2num(sec_tr->key_a.data, 6);
88+
uint64_t key = bit_lib_bytes_to_num_be(sec_tr->key_a.data, 6);
8989
if(key != aime_key) break;
9090

9191
// Aime Magic is stored at block 1, starts from byte 0, len 4 bytes

0 commit comments

Comments
 (0)