Add hex editor, security analysis, ZIP download, and file management features

Round 2 feature batch: full hex editor with byte-level editing, SHA-256
file hashing (firmware + web), entropy analysis for encrypted/packed file
detection, EXIF metadata viewer and stripping, recursive security scan
with exportable reports, multi-file ZIP download, clipboard paste upload,
recursive directory delete, drive formatting, grid/list view toggle, and
keyboard shortcuts for file navigation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bod09

README.md

@@ -13,8 +13,11 @@ Built for incident response, security research, air-gapped environments, and any
 | **Autorun / malware execution** | Drive is never mounted by your PC — no autorun, no shell extensions, no thumbnail handlers |
 | **Filesystem driver exploits** | Your OS filesystem drivers (NTFS, exFAT, etc.) never touch the drive. FatFS on the RP2350 parses the filesystem in an isolated environment |
 | **Malicious USB device attacks** | The drive connects to the RP2350's USB host port, not your PC. Your PC only sees a standard HID keyboard + CDC serial device |
-| **Content inspection** | Built-in file preview (text, images, audio, video, PDF) lets you examine contents without downloading. Magic bytes mismatch detection flags files where the extension doesn't match the actual content |
-| **Suspicious file detection** | Known dangerous extensions (.exe, .bat, .ps1, .vbs, .scr, autorun.inf, etc.) are flagged with warning icons. Security scan summarizes threats in the current directory |
+| **Content inspection** | Built-in file preview (text, images, audio, video, PDF, hex editor) lets you examine contents without downloading. Magic bytes mismatch detection flags files where the extension doesn't match the actual content |
+| **Suspicious file detection** | Known dangerous extensions (.exe, .bat, .ps1, .vbs, .scr, autorun.inf, etc.) are flagged with warning icons. Recursive security scan with exportable reports |
+| **Entropy analysis** | Shannon entropy calculation flags encrypted, compressed, or packed files that may be obfuscated malware |
+| **File hashing** | On-device SHA-256 hashing — verify file integrity without downloading |
+| **EXIF metadata** | View and strip EXIF metadata from JPEG images — remove GPS coordinates, camera info, and other identifying data before downloading |
 | **Browser sandbox** | All file rendering happens inside the browser's sandboxed environment — even if you preview a malicious file, it can't escape the browser sandbox |
 
 ### Limitations
@@ -26,10 +29,17 @@ Built for incident response, security research, air-gapped environments, and any
 
 ## Features
 
-- **File browser** — Navigate directories, upload, download, rename, delete files on the USB drive
-- **File preview & edit** — Open files directly in the browser: text (with editing), images, audio, video, PDF, and hex dump for unknown formats
+- **File browser** — Navigate directories with list or grid view, upload, download, rename, delete files
+- **File preview & edit** — Text editor, image viewer with zoom, audio/video player, PDF viewer, full hex editor with byte-level editing
+- **Multi-file ZIP download** — Select multiple files and download as a single ZIP archive
+- **Clipboard paste upload** — Paste images or files from clipboard directly into the file browser
 - **Folder sizes** — Directories show total recursive size (calculated on-device)
-- **Security scanning** — Warning icons on suspicious files, magic bytes mismatch detection, one-click threat scan
+- **SHA-256 hashing** — Compute file hashes on-device for integrity verification
+- **Security scanning** — Recursive threat scan with warning icons, entropy analysis, magic bytes mismatch detection, exportable scan reports
+- **EXIF viewer & stripper** — Inspect and remove EXIF metadata from JPEG images
+- **Recursive delete** — Delete directories and all their contents in one operation
+- **Format drive** — Reformat the drive from the settings page
+- **Keyboard shortcuts** — Arrow keys, Enter, Delete, Ctrl+A, Backspace navigation
 - **Air-gap indicator** — Visual confirmation that the drive is accessed through the RP2350, not directly by your PC
 - **PWA support** — Installable as a standalone app with offline caching
 
@@ -122,6 +132,9 @@ Newline-delimited JSON over CDC serial. Commands:
 | `{"cmd":"delete","path":"/file.txt"}` | Delete file/directory |
 | `{"cmd":"rename","from":"/old","to":"/new"}` | Rename/move |
 | `{"cmd":"dirsize","path":"/dir"}` | Recursive directory size |
+| `{"cmd":"hash","path":"/file.txt"}` | SHA-256 file hash |
+| `{"cmd":"rmdir","path":"/dir"}` | Recursive directory delete |
+| `{"cmd":"format"}` | Format drive |
 | `{"cmd":"df"}` | Disk free space |
 | `{"cmd":"eject"}` | Safe unmount |
 | `{"cmd":"status"}` | Drive status |

firmware/CMakeLists.txt

@@ -50,6 +50,7 @@ add_executable(storage_bridge
     src/msc_diskio.c
     src/file_ops.c
     src/base64.c
+    src/sha256.c
     # FatFS core — compiled from build dir copy that has our ffconf.h
     ${FATFS_BUILD_DIR}/ff.c
     ${FATFS_BUILD_DIR}/ffunicode.c

firmware/src/ffconf.h

@@ -11,7 +11,7 @@
 #define FF_FS_READONLY    0     // Read-write
 #define FF_FS_MINIMIZE    0     // Full API
 #define FF_USE_FIND       1     // f_findfirst / f_findnext
-#define FF_USE_MKFS       0     // No formatting support
+#define FF_USE_MKFS       1     // Enable formatting support
 #define FF_USE_FASTSEEK   0
 #define FF_USE_EXPAND     0
 #define FF_USE_CHMOD      0

firmware/src/file_ops.c

@@ -2,6 +2,7 @@
 #include "serial_cmd.h"
 #include "base64.h"
 #include "msc_host.h"
+#include "sha256.h"
 #include "ff.h"
 #include "tusb.h"
 #include "hardware/watchdog.h"
@@ -298,3 +299,139 @@ void file_op_dirsize(const char* path) {
                        path, total_size, file_count, dir_count);
     cdc_write_chunked(buf, len);
 }
+
+void file_op_hash(const char* path) {
+    FIL fil;
+    FRESULT res = f_open(&fil, path, FA_READ);
+    if (res != FR_OK) { send_error(res); return; }
+
+    sha256_ctx ctx;
+    sha256_init(&ctx);
+
+    uint32_t fsize = f_size(&fil);
+    uint32_t remaining = fsize;
+    uint32_t tick = 0;
+
+    while (remaining > 0) {
+        uint32_t chunk = remaining > FILE_CHUNK_SIZE ? FILE_CHUNK_SIZE : remaining;
+        UINT bytes_read = 0;
+        res = f_read(&fil, file_buf, chunk, &bytes_read);
+        if (res != FR_OK) { f_close(&fil); send_error(res); return; }
+        sha256_update(&ctx, file_buf, bytes_read);
+        remaining -= bytes_read;
+
+        if (++tick % 4 == 0) {
+            watchdog_update();
+            tud_task();
+            tuh_task();
+        }
+    }
+
+    f_close(&fil);
+
+    uint8_t hash[32];
+    sha256_final(&ctx, hash);
+
+    char hex[65];
+    for (int i = 0; i < 32; i++) {
+        hex[i * 2]     = "0123456789abcdef"[hash[i] >> 4];
+        hex[i * 2 + 1] = "0123456789abcdef"[hash[i] & 0x0F];
+    }
+    hex[64] = '\0';
+
+    char buf[384];
+    int len = snprintf(buf, sizeof(buf),
+                       "{\"type\":\"hash\",\"path\":\"%s\",\"sha256\":\"%s\","
+                       "\"size\":%" PRIu32 "}\n",
+                       path, hex, fsize);
+    cdc_write_chunked(buf, len);
+}
+
+#define RMRF_MAX_DEPTH 8
+
+void file_op_delete_recursive(const char* path) {
+    // First try simple unlink (works for files and empty dirs)
+    FRESULT res = f_unlink(path);
+    if (res == FR_OK) {
+        cdc_send("{\"status\":\"ok\"}\n");
+        return;
+    }
+
+    // Must be a non-empty directory — walk and delete bottom-up
+    DIR dir_stack[RMRF_MAX_DEPTH];
+    // Phase flags: 0 = scanning entries, 1 = done scanning (ready to delete dir)
+    uint8_t phase[RMRF_MAX_DEPTH];
+    int depth = 0;
+    FILINFO fno;
+    char pathbuf[256];
+    uint32_t tick = 0;
+
+    strncpy(pathbuf, path, sizeof(pathbuf) - 1);
+    pathbuf[sizeof(pathbuf) - 1] = '\0';
+
+    res = f_opendir(&dir_stack[0], pathbuf);
+    if (res != FR_OK) { send_error(res); return; }
+    phase[0] = 0;
+
+    while (depth >= 0) {
+        if (++tick % 20 == 0) {
+            watchdog_update();
+            tud_task();
+            tuh_task();
+        }
+
+        res = f_readdir(&dir_stack[depth], &fno);
+        if (res != FR_OK || fno.fname[0] == '\0') {
+            // End of directory — close and delete the now-empty dir
+            f_closedir(&dir_stack[depth]);
+            if (depth > 0) {
+                f_unlink(pathbuf);
+                char* slash = strrchr(pathbuf, '/');
+                if (slash && slash != pathbuf) *slash = '\0';
+                else if (slash == pathbuf) pathbuf[1] = '\0';
+            }
+            depth--;
+            continue;
+        }
+
+        if (fno.fname[0] == '.') continue;
+
+        // Build full path for this entry
+        size_t plen = strlen(pathbuf);
+        bool needs_slash = (plen > 0 && pathbuf[plen - 1] != '/');
+        int written = snprintf(pathbuf + plen, sizeof(pathbuf) - plen,
+                               "%s%s", needs_slash ? "/" : "", fno.fname);
+        if (plen + written >= sizeof(pathbuf)) {
+            pathbuf[plen] = '\0';
+            continue; // path too long, skip
+        }
+
+        if (fno.fattrib & AM_DIR) {
+            if (depth + 1 < RMRF_MAX_DEPTH) {
+                depth++;
+                res = f_opendir(&dir_stack[depth], pathbuf);
+                if (res != FR_OK) {
+                    pathbuf[plen] = '\0';
+                    depth--;
+                }
+                phase[depth] = 0;
+            } else {
+                pathbuf[plen] = '\0'; // too deep
+            }
+        } else {
+            f_unlink(pathbuf);
+            pathbuf[plen] = '\0';
+        }
+    }
+
+    // Delete the root directory itself
+    f_unlink(path);
+    cdc_send("{\"status\":\"ok\"}\n");
+}
+
+void file_op_format(void) {
+    BYTE work[FF_MAX_SS];
+    FRESULT res = f_mkfs("", FM_ANY, 0, work, sizeof(work));
+    if (res != FR_OK) { send_error(res); return; }
+    cdc_send("{\"status\":\"ok\"}\n");
+}

firmware/src/file_ops.h

@@ -17,5 +17,8 @@ void file_op_write(const char* path, uint32_t offset,
                    const uint8_t* data, uint32_t data_len, bool done);
 void file_op_df(void);
 void file_op_dirsize(const char* path);
+void file_op_hash(const char* path);
+void file_op_delete_recursive(const char* path);
+void file_op_format(void);
 
 #endif // FILE_OPS_H

firmware/src/serial_cmd.c

@@ -205,6 +205,24 @@ static void process_command(const char* cmd) {
         json_get_string(cmd, "path", path, sizeof(path));
         file_op_dirsize(path);
     }
+    else if (strstr(cmd, "\"cmd\":\"hash\"")) {
+        if (!info->mounted) { cdc_send("{\"status\":\"error\",\"msg\":\"No drive\"}\n"); return; }
+        if (!json_get_string(cmd, "path", path, sizeof(path))) {
+            cdc_send("{\"status\":\"error\",\"msg\":\"Missing path\"}\n"); return;
+        }
+        file_op_hash(path);
+    }
+    else if (strstr(cmd, "\"cmd\":\"rmdir\"")) {
+        if (!info->mounted) { cdc_send("{\"status\":\"error\",\"msg\":\"No drive\"}\n"); return; }
+        if (!json_get_string(cmd, "path", path, sizeof(path))) {
+            cdc_send("{\"status\":\"error\",\"msg\":\"Missing path\"}\n"); return;
+        }
+        file_op_delete_recursive(path);
+    }
+    else if (strstr(cmd, "\"cmd\":\"format\"")) {
+        if (!info->mounted) { cdc_send("{\"status\":\"error\",\"msg\":\"No drive\"}\n"); return; }
+        file_op_format();
+    }
     else if (strstr(cmd, "\"cmd\":\"df\"")) {
         file_op_df();
     }

firmware/src/sha256.c

@@ -0,0 +1,91 @@
+#include "sha256.h"
+#include <string.h>
+
+static const uint32_t K[64] = {
+    0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
+    0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
+    0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
+    0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
+    0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
+    0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
+    0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
+    0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
+};
+
+#define ROR(x,n) (((x)>>(n))|((x)<<(32-(n))))
+#define CH(x,y,z) (((x)&(y))^(~(x)&(z)))
+#define MAJ(x,y,z) (((x)&(y))^((x)&(z))^((y)&(z)))
+#define EP0(x) (ROR(x,2)^ROR(x,13)^ROR(x,22))
+#define EP1(x) (ROR(x,6)^ROR(x,11)^ROR(x,25))
+#define SIG0(x) (ROR(x,7)^ROR(x,18)^((x)>>3))
+#define SIG1(x) (ROR(x,17)^ROR(x,19)^((x)>>10))
+
+static void sha256_transform(sha256_ctx* ctx, const uint8_t block[64]) {
+    uint32_t w[64], a, b, c, d, e, f, g, h, t1, t2;
+
+    for (int i = 0; i < 16; i++)
+        w[i] = ((uint32_t)block[i*4]<<24)|((uint32_t)block[i*4+1]<<16)|
+               ((uint32_t)block[i*4+2]<<8)|block[i*4+3];
+    for (int i = 16; i < 64; i++)
+        w[i] = SIG1(w[i-2]) + w[i-7] + SIG0(w[i-15]) + w[i-16];
+
+    a=ctx->state[0]; b=ctx->state[1]; c=ctx->state[2]; d=ctx->state[3];
+    e=ctx->state[4]; f=ctx->state[5]; g=ctx->state[6]; h=ctx->state[7];
+
+    for (int i = 0; i < 64; i++) {
+        t1 = h + EP1(e) + CH(e,f,g) + K[i] + w[i];
+        t2 = EP0(a) + MAJ(a,b,c);
+        h=g; g=f; f=e; e=d+t1; d=c; c=b; b=a; a=t1+t2;
+    }
+
+    ctx->state[0]+=a; ctx->state[1]+=b; ctx->state[2]+=c; ctx->state[3]+=d;
+    ctx->state[4]+=e; ctx->state[5]+=f; ctx->state[6]+=g; ctx->state[7]+=h;
+}
+
+void sha256_init(sha256_ctx* ctx) {
+    ctx->state[0]=0x6a09e667; ctx->state[1]=0xbb67ae85;
+    ctx->state[2]=0x3c6ef372; ctx->state[3]=0xa54ff53a;
+    ctx->state[4]=0x510e527f; ctx->state[5]=0x9b05688c;
+    ctx->state[6]=0x1f83d9ab; ctx->state[7]=0x5be0cd19;
+    ctx->count = 0;
+    memset(ctx->buf, 0, 64);
+}
+
+void sha256_update(sha256_ctx* ctx, const uint8_t* data, size_t len) {
+    size_t i = 0;
+    size_t idx = (size_t)(ctx->count & 63);
+    ctx->count += len;
+
+    if (idx) {
+        size_t rem = 64 - idx;
+        if (len < rem) { memcpy(ctx->buf + idx, data, len); return; }
+        memcpy(ctx->buf + idx, data, rem);
+        sha256_transform(ctx, ctx->buf);
+        i = rem;
+    }
+    for (; i + 64 <= len; i += 64)
+        sha256_transform(ctx, data + i);
+    if (i < len)
+        memcpy(ctx->buf, data + i, len - i);
+}
+
+void sha256_final(sha256_ctx* ctx, uint8_t hash[32]) {
+    size_t idx = (size_t)(ctx->count & 63);
+    ctx->buf[idx++] = 0x80;
+    if (idx > 56) {
+        memset(ctx->buf + idx, 0, 64 - idx);
+        sha256_transform(ctx, ctx->buf);
+        idx = 0;
+    }
+    memset(ctx->buf + idx, 0, 56 - idx);
+    uint64_t bits = ctx->count * 8;
+    for (int i = 0; i < 8; i++)
+        ctx->buf[56 + i] = (uint8_t)(bits >> (56 - i * 8));
+    sha256_transform(ctx, ctx->buf);
+    for (int i = 0; i < 8; i++) {
+        hash[i*4]   = (uint8_t)(ctx->state[i]>>24);
+        hash[i*4+1] = (uint8_t)(ctx->state[i]>>16);
+        hash[i*4+2] = (uint8_t)(ctx->state[i]>>8);
+        hash[i*4+3] = (uint8_t)(ctx->state[i]);
+    }
+}

firmware/src/sha256.h

@@ -0,0 +1,17 @@
+#ifndef SHA256_H
+#define SHA256_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef struct {
+    uint32_t state[8];
+    uint64_t count;
+    uint8_t buf[64];
+} sha256_ctx;
+
+void sha256_init(sha256_ctx* ctx);
+void sha256_update(sha256_ctx* ctx, const uint8_t* data, size_t len);
+void sha256_final(sha256_ctx* ctx, uint8_t hash[32]);
+
+#endif

web/css/components.css

@@ -58,6 +58,9 @@
   font-size: 13px;
   color: var(--text-secondary);
   margin-bottom: 16px;
+  white-space: pre-wrap;
+  max-height: 50vh;
+  overflow-y: auto;
 }
 
 .modal-content .input-group {
@@ -210,5 +213,15 @@
   margin-top: 1px;
 }
 
+/* Danger button */
+.danger {
+  color: var(--error) !important;
+  border-color: var(--error) !important;
+}
+
+.danger:hover {
+  background: rgba(255, 59, 48, 0.1) !important;
+}
+
 /* Hidden file input */
 #uploadInput { display: none; }