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

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)
+    if (s_dma_8.buf == NULL) {
-        s_dma_8.buf = BigBuf_malloc(DMA_BUFFER_SIZE);
+        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 *receivedCmd = BigBuf_calloc(MAX_FRAME_SIZE);
-    uint8_t *receivedCmdPar = BigBuf_malloc(MAX_PARITY_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 *receivedResp = BigBuf_calloc(MAX_FRAME_SIZE);
-    uint8_t *receivedRespPar = BigBuf_malloc(MAX_PARITY_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

armsrc/fpgaloader.c

@@ -523,10 +523,11 @@ void FpgaDownloadAndGo(int bitstream_target) {
     lz4_stream_t compressed_fpga_stream;
     LZ4_streamDecode_t lz4StreamDecode_body = {{ 0 }};
     compressed_fpga_stream.lz4StreamDecode = &lz4StreamDecode_body;
-    uint8_t *output_buffer = BigBuf_malloc(FPGA_RING_BUFFER_BYTES);
+    uint8_t *output_buffer = BigBuf_calloc(FPGA_RING_BUFFER_BYTES);
 
-    if (!reset_fpga_stream(bitstream_target, &compressed_fpga_stream, output_buffer))
+    if (reset_fpga_stream(bitstream_target, &compressed_fpga_stream, output_buffer) == false) {
         return;
+    }
 
     uint32_t bitstream_length;
     if (bitparse_find_section(bitstream_target, 'e', &bitstream_length, &compressed_fpga_stream, output_buffer)) {

armsrc/frozen.c

@@ -26,7 +26,7 @@
 #include "nprintf.h"
 
 #include "BigBuf.h"
-#define malloc(X) BigBuf_malloc(X)
+#define malloc(X) BigBuf_calloc(X)
 #define free(X)
 
 #if !defined(WEAK)

armsrc/hfsnoop.c

@@ -107,7 +107,7 @@ int HfSniff(uint32_t samplesToSkip, uint32_t triggersToSkip, uint16_t *len, uint
     SpinDelay(100);
 
     *len = BigBuf_max_traceLen();
-    uint8_t *mem = BigBuf_malloc(*len);
+    uint8_t *mem = BigBuf_calloc(*len);
 
     uint32_t trigger_cnt = 0;
     uint16_t r = 0, interval = 0;

armsrc/iclass.c

@@ -917,8 +917,9 @@ send:
 
     LEDsoff();
 
-    if (button_pressed)
+    if (button_pressed) {
         DbpString("button pressed");
+    }
 
     return button_pressed;
 }

armsrc/iso14443b.c

@@ -786,14 +786,14 @@ void SimulateIso14443bTag(const uint8_t *pupi) {
 
     // prepare "ATQB" tag answer (encoded):
     CodeIso14443bAsTag(respATQB, sizeof(respATQB));
-    uint8_t *encodedATQB = BigBuf_malloc(ts->max);
+    uint8_t *encodedATQB = BigBuf_calloc(ts->max);
     uint16_t encodedATQBLen = ts->max;
     memcpy(encodedATQB, ts->buf, ts->max);
 
 
     // prepare "OK" tag answer (encoded):
     CodeIso14443bAsTag(respOK, sizeof(respOK));
-    uint8_t *encodedOK = BigBuf_malloc(ts->max);
+    uint8_t *encodedOK = BigBuf_calloc(ts->max);
     uint16_t encodedOKLen = ts->max;
     memcpy(encodedOK, ts->buf, ts->max);
 
@@ -988,18 +988,18 @@ void Simulate_iso14443b_srx_tag(uint8_t *uid) {
 
     tosend_t *ts = get_tosend();
 
-    uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
+    uint8_t *receivedCmd = BigBuf_calloc(MAX_FRAME_SIZE);
 
     // prepare "ATQB" tag answer (encoded):
     CodeIso14443bAsTag(respATQB, sizeof(respATQB));
-    uint8_t *encodedATQB = BigBuf_malloc(ts->max);
+    uint8_t *encodedATQB = BigBuf_calloc(ts->max);
     uint16_t encodedATQBLen = ts->max;
     memcpy(encodedATQB, ts->buf, ts->max);
 
 
     // prepare "OK" tag answer (encoded):
     CodeIso14443bAsTag(respOK, sizeof(respOK));
-    uint8_t *encodedOK = BigBuf_malloc(ts->max);
+    uint8_t *encodedOK = BigBuf_calloc(ts->max);
     uint16_t encodedOKLen = ts->max;
     memcpy(encodedOK, ts->buf, ts->max);
 
@@ -2405,8 +2405,8 @@ void SniffIso14443b(void) {
     uint8_t ua_buf[MAX_FRAME_SIZE] = {0};
     Uart14bInit(ua_buf);
 
-    //Demod14bInit(BigBuf_malloc(MAX_FRAME_SIZE), MAX_FRAME_SIZE);
+    //Demod14bInit(BigBuf_calloc(MAX_FRAME_SIZE));
-    //Uart14bInit(BigBuf_malloc(MAX_FRAME_SIZE));
+    //Uart14bInit(BigBuf_calloc(MAX_FRAME_SIZE));
 
     // Set FPGA in the appropriate mode
     FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_SUBCARRIER_848_KHZ | FPGA_HF_READER_MODE_SNIFF_IQ);

armsrc/iso15693.c

@@ -180,8 +180,7 @@ static void CodeIso15693AsReaderEOF(void) {
 
 static int get_uid_slix(uint32_t start_time, uint32_t *eof_time, uint8_t *uid) {
 
-    uint8_t *answer = BigBuf_malloc(ISO15693_MAX_RESPONSE_LENGTH);
+    uint8_t *answer = BigBuf_calloc(ISO15693_MAX_RESPONSE_LENGTH);
-    memset(answer, 0x00, ISO15693_MAX_RESPONSE_LENGTH);
 
     start_time = *eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
 
@@ -1484,7 +1483,7 @@ int GetIso15693CommandFromReader(uint8_t *received, size_t max_len, uint32_t *eo
     bool gotFrame = false;
 
     // the decoder data structure
-    DecodeReader_t *dr = (DecodeReader_t *)BigBuf_malloc(sizeof(DecodeReader_t));
+    DecodeReader_t *dr = (DecodeReader_t *)BigBuf_calloc(sizeof(DecodeReader_t));
     DecodeReaderInit(dr, received, max_len, 0, NULL);
 
     // wait for last transfer to complete
@@ -1589,7 +1588,7 @@ void AcquireRawAdcSamplesIso15693(void) {
 
     LED_A_ON();
 
-    uint8_t *dest = BigBuf_malloc(4000);
+    uint8_t *dest = BigBuf_calloc(4096);
 
     // switch field on
     FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER);
@@ -2031,7 +2030,7 @@ void ReaderIso15693(iso15_card_select_t *p_card) {
     LED_A_ON();
     set_tracing(true);
 
-    uint8_t *answer = BigBuf_malloc(ISO15693_MAX_RESPONSE_LENGTH);
+    uint8_t *answer = BigBuf_calloc(ISO15693_MAX_RESPONSE_LENGTH);
     memset(answer, 0x00, ISO15693_MAX_RESPONSE_LENGTH);
 
     // FIRST WE RUN AN INVENTORY TO GET THE TAG UID

armsrc/lfops.c

@@ -340,7 +340,7 @@ t55xx_configurations_t *getT55xxConfig(void) {
 void loadT55xxConfig(void) {
 #ifdef WITH_FLASH
 
-    uint8_t *buf = BigBuf_malloc(T55XX_CONFIG_LEN);
+    uint8_t *buf = BigBuf_calloc(T55XX_CONFIG_LEN);
 
     uint32_t size = 0;
     if (exists_in_spiffs(T55XX_CONFIG_FILE)) {
@@ -2912,7 +2912,7 @@ void Cotag(uint32_t arg0, bool ledcontrol) {
             break;
         }
         case 1: {
-            uint8_t *dest = BigBuf_malloc(COTAG_BITS);
+            uint8_t *dest = BigBuf_calloc(COTAG_BITS);
             uint16_t bits = doCotagAcquisitionManchester(dest, COTAG_BITS);
             reply_ng(CMD_LF_COTAG_READ, PM3_SUCCESS, dest, bits);
             break;

armsrc/lfsampling.c

@@ -149,7 +149,7 @@ void initSampleBufferEx(uint32_t *sample_size, bool use_malloc) {
             data.buffer = BigBuf_get_addr();
         } else {
             *sample_size = MIN(*sample_size, BigBuf_max_traceLen());
-            data.buffer = BigBuf_malloc(*sample_size);
+            data.buffer = BigBuf_calloc(*sample_size);
         }
 
     } else {
@@ -669,7 +669,7 @@ void doT55x7Acquisition(size_t sample_size, bool ledcontrol) {
 void doCotagAcquisition(void) {
 
     uint16_t bufsize = BigBuf_max_traceLen();
-    uint8_t *dest = BigBuf_malloc(bufsize);
+    uint8_t *dest = BigBuf_calloc(bufsize);
 
     dest[0] = 0;
 

armsrc/mifarecmd.c

@@ -2252,7 +2252,7 @@ OUT:
             bar |= ((uint16_t)(found[m] & 1) << j++);
         }
 
-        uint8_t *tmp = BigBuf_malloc(480 + 10);
+        uint8_t *tmp = BigBuf_calloc(480 + 10);
         memcpy(tmp, k_sector, sectorcnt * sizeof(sector_t));
         num_to_bytes(foo, 8, tmp + 480);
         tmp[488] = bar & 0xFF;
@@ -2409,7 +2409,7 @@ void MifareChkKeys_file(uint8_t *fn) {
 
     int changed = rdv40_spiffs_lazy_mount();
     uint32_t size = size_in_spiffs((char *)fn);
-    uint8_t *mem = BigBuf_malloc(size);
+    uint8_t *mem = BigBuf_calloc(size);
 
     rdv40_spiffs_read_as_filetype((char *)fn, mem, size, RDV40_SPIFFS_SAFETY_SAFE);
 
@@ -3609,13 +3609,13 @@ void MifareG4ReadBlk(uint8_t blockno, uint8_t *pwd, uint8_t workFlags) {
     int res = 0;
     int retval = PM3_SUCCESS;
 
-    uint8_t *buf = BigBuf_malloc(PM3_CMD_DATA_SIZE);
+    uint8_t *buf = BigBuf_calloc(PM3_CMD_DATA_SIZE);
     if (buf == NULL) {
         retval = PM3_EMALLOC;
         goto OUT;
     }
 
-    uint8_t *par = BigBuf_malloc(MAX_PARITY_SIZE);
+    uint8_t *par = BigBuf_calloc(MAX_PARITY_SIZE);
     if (par == NULL) {
         retval = PM3_EMALLOC;
         goto OUT;
@@ -3685,7 +3685,7 @@ void MifareG4WriteBlk(uint8_t blockno, uint8_t *pwd, uint8_t *data, uint8_t work
     int res = 0;
     int retval = PM3_SUCCESS;
 
-    uint8_t *buf = BigBuf_malloc(PM3_CMD_DATA_SIZE);
+    uint8_t *buf = BigBuf_calloc(PM3_CMD_DATA_SIZE);
     if (buf == NULL) {
         retval = PM3_EMALLOC;
         goto OUT;
@@ -3697,7 +3697,7 @@ void MifareG4WriteBlk(uint8_t blockno, uint8_t *pwd, uint8_t *data, uint8_t work
         goto OUT;
     }
 
-    uint8_t *par = BigBuf_malloc(MAX_PARITY_SIZE);
+    uint8_t *par = BigBuf_calloc(MAX_PARITY_SIZE);
     if (par == NULL) {
         retval = PM3_EMALLOC;
         goto OUT;

armsrc/mifaresim.c

@@ -459,7 +459,7 @@ bool MifareSimInit(uint16_t flags, uint8_t *uid, uint16_t atqa, uint8_t sak, tag
     // 53 * 8 data bits, 53 * 1 parity bits, 18 start bits, 18 stop bits, 18 correction bits  ->   need 571 bytes buffer
 #define ALLOCATED_TAG_MODULATION_BUFFER_SIZE 571
 
-    uint8_t *free_buffer = BigBuf_malloc(ALLOCATED_TAG_MODULATION_BUFFER_SIZE);
+    uint8_t *free_buffer = BigBuf_calloc(ALLOCATED_TAG_MODULATION_BUFFER_SIZE);
     // modulation buffer pointer and current buffer free space size
     uint8_t *free_buffer_pointer = free_buffer;
     size_t free_buffer_size = ALLOCATED_TAG_MODULATION_BUFFER_SIZE;