swapped from bigbuf malloc calls to calloc calls on device side. Now all allocations should start from a known state of memory

Author: iceman1001

CHANGELOG.md

@@ -3,6 +3,7 @@ All notable changes to this project will be documented in this file.
 This project uses the changelog in accordance with [keepchangelog](http://keepachangelog.com/). Please use this to write notable changes, which is not the same as git commit log...
 
 ## [unreleased][unreleased]
+- Changed from Bigbuf malloc to Bigbuf calloc calls on device side (@iceman1001)
 - Added `lf t55xx view` - now viewing of T55XX dump files is possible (@iceman1001)
 - Fixed `lf indala cone` - now writing the right bits when using `--fc` and `--cn`
 - Changed readline hack logic for async dbg msg to be ready for readline 8.3 (@doegox)

armsrc/BigBuf.c

@@ -354,7 +354,7 @@ int emlGet(uint8_t *out, uint32_t offset, uint32_t length) {
 tosend_t *get_tosend(void) {
 
     if (s_toSend.buf == NULL) {
-        s_toSend.buf = BigBuf_malloc(TOSEND_BUFFER_SIZE);
+        s_toSend.buf = BigBuf_calloc(TOSEND_BUFFER_SIZE);
     }
     return &s_toSend;
 }
@@ -377,8 +377,9 @@ void tosend_stuffbit(int b) {
         s_toSend.bit = 0;
     }
 
-    if (b)
+    if (b) {
         s_toSend.buf[s_toSend.max] |= (1 << (7 - s_toSend.bit));
+    }
 
     s_toSend.bit++;
 
@@ -389,15 +390,14 @@ void tosend_stuffbit(int b) {
 
 dmabuf16_t *get_dma16(void) {
     if (s_dma_16.buf == NULL) {
-        s_dma_16.buf = (uint16_t *)BigBuf_malloc(DMA_BUFFER_SIZE * sizeof(uint16_t));
+        s_dma_16.buf = (uint16_t *)BigBuf_calloc(DMA_BUFFER_SIZE * sizeof(uint16_t));
     }
-
     return &s_dma_16;
 }
 
 dmabuf8_t *get_dma8(void) {
-    if (s_dma_8.buf == NULL)
-        s_dma_8.buf = BigBuf_malloc(DMA_BUFFER_SIZE);
-
+    if (s_dma_8.buf == NULL) {
+        s_dma_8.buf = BigBuf_calloc(DMA_BUFFER_SIZE);
+    }
     return &s_dma_8;
 }

armsrc/Standalone/hf_bog.c

@@ -63,18 +63,18 @@ static void RAMFUNC SniffAndStore(uint8_t param) {
     set_tracing(true);
 
     // Array to store the authpwds
-    uint8_t *capturedPwds = BigBuf_malloc(4 * MAX_PWDS_PER_SESSION);
+    uint8_t *capturedPwds = BigBuf_calloc(4 * MAX_PWDS_PER_SESSION);
 
     // The command (reader -> tag) that we're receiving.
-    uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
-    uint8_t *receivedCmdPar = BigBuf_malloc(MAX_PARITY_SIZE);
+    uint8_t *receivedCmd = BigBuf_calloc(MAX_FRAME_SIZE);
+    uint8_t *receivedCmdPar = BigBuf_calloc(MAX_PARITY_SIZE);
 
     // The response (tag -> reader) that we're receiving.
-    uint8_t *receivedResp = BigBuf_malloc(MAX_FRAME_SIZE);
-    uint8_t *receivedRespPar = BigBuf_malloc(MAX_PARITY_SIZE);
+    uint8_t *receivedResp = BigBuf_calloc(MAX_FRAME_SIZE);
+    uint8_t *receivedRespPar = BigBuf_calloc(MAX_PARITY_SIZE);
 
     // The DMA buffer, used to stream samples from the FPGA
-    uint8_t *dmaBuf = BigBuf_malloc(DMA_BUFFER_SIZE);
+    uint8_t *dmaBuf = BigBuf_calloc(DMA_BUFFER_SIZE);
     uint8_t *data = dmaBuf;
 
     uint8_t previous_data = 0;

armsrc/Standalone/hf_colin.c

@@ -250,7 +250,7 @@ static char *ReadSchemasFromSPIFFS(char *filename) {
 
     int changed = rdv40_spiffs_lazy_mount();
     uint32_t size = size_in_spiffs((char *)filename);
-    uint8_t *mem = BigBuf_malloc(size);
+    uint8_t *mem = BigBuf_calloc(size);
     rdv40_spiffs_read_as_filetype((char *)filename, (uint8_t *)mem, size, RDV40_SPIFFS_SAFETY_SAFE);
 
     if (changed) {
@@ -292,7 +292,7 @@ static void ReadLastTagFromFlash(void) {
     DbprintfEx(FLAG_NEWLINE, "Button HELD ! Using LAST Known TAG for Simulation...");
     cjSetCursLeft();
 
-    uint8_t *mem = BigBuf_malloc(size);
+    uint8_t *mem = BigBuf_calloc(size);
 
     // this one will handle filetype (symlink or not) and resolving by itself
     rdv40_spiffs_read_as_filetype((char *)HFCOLIN_LASTTAG_SYMLINK, (uint8_t *)mem, len, RDV40_SPIFFS_SAFETY_SAFE);
@@ -445,11 +445,11 @@ void RunMod(void) {
     };
 
     // Can remember something like that in case of Bigbuf
-    keyBlock = BigBuf_malloc(ARRAYLEN(mfKeys) * 6);
+    keyBlock = BigBuf_calloc(ARRAYLEN(mfKeys) * MF_KEY_LENGTH);
     int mfKeysCnt = ARRAYLEN(mfKeys);
 
     for (int mfKeyCounter = 0; mfKeyCounter < mfKeysCnt; mfKeyCounter++) {
-        num_to_bytes(mfKeys[mfKeyCounter], 6, (uint8_t *)(keyBlock + mfKeyCounter * 6));
+        num_to_bytes(mfKeys[mfKeyCounter], MF_KEY_LENGTH, (uint8_t *)(keyBlock + (mfKeyCounter * MF_KEY_LENGTH)));
     }
 
     // TODO : remember why we actually had need to initialize this array in such specific case

armsrc/Standalone/hf_iceclass.c

@@ -238,7 +238,7 @@ static int reader_attack_mode(void) {
 
     BigBuf_free();
     uint16_t mac_response_len = 0;
-    uint8_t *mac_responses = BigBuf_malloc(MAC_RESPONSES_SIZE);
+    uint8_t *mac_responses = BigBuf_calloc(MAC_RESPONSES_SIZE);
 
     iclass_simulate(ICLASS_SIM_MODE_READER_ATTACK, NUM_CSNS, false, csns, mac_responses, &mac_response_len);
 
@@ -250,7 +250,7 @@ static int reader_attack_mode(void) {
 
         size_t dumplen = NUM_CSNS * 24;
 
-        uint8_t *dump = BigBuf_malloc(dumplen);
+        uint8_t *dump = BigBuf_calloc(dumplen);
         if (dump == false) {
             Dbprintf("Failed to allocate memory");
             return PM3_EMALLOC;
@@ -305,6 +305,7 @@ static int reader_dump_mode(void) {
         BigBuf_free();
 
         uint8_t *card_data = BigBuf_malloc(ICLASS_16KS_SIZE);
+        // Don't use calloc since we set allocated memory to 0xFF's
         memset(card_data, 0xFF, ICLASS_16KS_SIZE);
 
         if (BUTTON_PRESS()) {
@@ -442,6 +443,7 @@ static int dump_sim_mode(void) {
         BigBuf_free();
 
         uint8_t *card_data = BigBuf_malloc(ICLASS_16KS_SIZE);
+        // Don't use calloc since we set allocated memory to 0xFF's
         memset(card_data, 0xFF, ICLASS_16KS_SIZE);
 
         if (BUTTON_PRESS()) {

armsrc/Standalone/hf_mattyrun.c

@@ -247,7 +247,7 @@ void RunMod(void) {
     // usb_disable();
 
     // Allocate dictionary buffer
-    uint64_t *const mfcKeys = (uint64_t *)BigBuf_malloc(
+    uint64_t *const mfcKeys = (uint64_t *)BigBuf_calloc(
                                   sizeof(uint64_t) * (ARRAYLEN(MATTYRUN_MFC_ESSENTIAL_KEYS) +
                                                       ARRAYLEN(MATTYRUN_MFC_DEFAULT_KEYS) +
                                                       MIFARE_4K_MAXSECTOR * 2));

armsrc/Standalone/lf_icehid.c

@@ -199,7 +199,7 @@ static uint32_t IceIOdemod(void) {
 
     size_t size = MIN(12000, BigBuf_max_traceLen());
 
-//    uint8_t *dest = BigBuf_malloc(size);
+//    uint8_t *dest = BigBuf_calloc(size);
     uint8_t *dest = BigBuf_get_addr();
 
     //fskdemod and get start index
@@ -243,7 +243,7 @@ static uint32_t IceHIDDemod(void) {
     // large enough to catch 2 sequences of largest format
 //    size_t size = 50 * 128 * 2;  // 12800 bytes
     size_t size = MIN(12800, BigBuf_max_traceLen());
-    //uint8_t *dest = BigBuf_malloc(size);
+    //uint8_t *dest = BigBuf_calloc(size);
     uint8_t *dest = BigBuf_get_addr();
 
     // FSK demodulator

armsrc/Standalone/lf_tharexde.c

@@ -103,9 +103,9 @@ static bool get_input_data_from_file(uint32_t *tag, char *inputfile) {
     if (exists_in_spiffs(inputfile)) {
 
         uint32_t size = size_in_spiffs(inputfile);
-        uint8_t *mem = BigBuf_malloc(size);
+        uint8_t *mem = BigBuf_calloc(size);
 
-        Dbprintf(_YELLOW_("found input file %s"), inputfile);
+        Dbprintf("found input file `" _YELLOW_("%s") "`", inputfile);
 
         rdv40_spiffs_read_as_filetype(inputfile, mem, size, RDV40_SPIFFS_SAFETY_SAFE);
 

armsrc/desfire_crypto.c

@@ -334,7 +334,7 @@ void cmac(const desfirekey_t key, uint8_t *ivect, const uint8_t *data, size_t le
         return;
     }
 
-    uint8_t *buffer = BigBuf_malloc(padded_data_length(len, kbs));
+    uint8_t *buffer = BigBuf_calloc(padded_data_length(len, kbs));
 
     memcpy(buffer, data, len);
 

armsrc/felica.c

@@ -497,7 +497,7 @@ static void iso18092_setup(uint8_t fpga_minor_mode) {
     BigBuf_Clear_ext(false);
 
     // Initialize Demod and Uart structs
-    // DemodInit(BigBuf_malloc(MAX_FRAME_SIZE));
+    // DemodInit(BigBuf_calloc(MAX_FRAME_SIZE));
     FelicaFrameinit(BigBuf_calloc(FELICA_MAX_FRAME_SIZE));
 
     felica_nexttransfertime = 2 * DELAY_ARM2AIR_AS_READER;  // 418