Zupt v2.1.2: add full-disk backup/restore, expand test suite, improve compression handling
- Introduced full-disk backup/restore (src/zupt_disk.c, ~530 LOC) - Backup: streams 4MB blocks with sparse detection and all codecs - Restore: per-block checksum validation for integrity - Supports password (-p), PQ hybrid (--pq), or no encryption - Real-time progress bar with throughput reporting (stderr) - Implemented sparse detection (8-byte zero scan) - Zero blocks stored as STORE (near-zero overhead) - Added disk-aware safeguards - ZUPT_FLAG_DISK_IMAGE prevents misuse with extract - Immediate failure on wrong password during first block decrypt - Cross-platform device size detection - Linux: BLKGETSIZE64 - macOS: DKIOCGETBLOCKCOUNT - Fallback: lseek - Compression behavior - ~2928:1 on highly repetitive data - ~1.33:1 on random data (auto STORE fallback) - Expanded test suite to 77 tests: - 11 VV unit - 13 NIST/RFC vectors - 22 regression - 14 multi-threaded - 10 post-quantum - 7 disk (normal, encrypted, PQ, sparse, LZHP, extreme compression, wrong-password) Release stats: - 74 files, 168KB, zero .o artifacts - 77/77 tests passing - Fully clean under ASAN + UBSan
This commit is contained in:
Cristian Cezar Moisés
parent
2b68548e93
commit
5fcb9977ad
7 changed files with 1010 additions and 9 deletions
15
CHANGELOG.md
15
CHANGELOG.md
|
|
@ -5,6 +5,20 @@ Format follows [Keep a Changelog](https://keepachangelog.com/).
|
|||
|
||||
---
|
||||
|
||||
## [2.1.2] — 2026-04-06
|
||||
|
||||
### Added — Full-Disk Backup/Restore
|
||||
- **`zupt disk backup`** — streams a raw block device or file in 4MB chunks, compresses each block with the selected codec (VaptVupt default), detects all-zero (sparse) blocks and stores them with near-zero overhead. Supports password encryption (`-p`), post-quantum encryption (`--pq`), compression level override (`-l 1-9`), and codec selection (`--vv`, `--lzhp`). Real-time progress bar with throughput on stderr.
|
||||
- **`zupt disk restore`** — reads a disk image archive block-by-block, decrypts + decompresses each block, validates per-block XXH64 checksums, and writes sequentially to the target device or file. Rejects wrong passwords/keys immediately on first block failure.
|
||||
- **`ZUPT_FLAG_DISK_IMAGE (1u << 6)`** — new global flag in the archive header. `zupt disk restore` validates this flag and rejects non-disk archives. Standard `zupt extract` rejects disk archives with a clear error message.
|
||||
- **`src/zupt_disk.c`** — 530 lines. Portable device size detection: `BLKGETSIZE64` on Linux, `DKIOCGETBLOCKCOUNT` on macOS, `lseek(SEEK_END)` fallback on FreeBSD/generic. 8-byte-wide sparse block detection.
|
||||
- CLI: `zupt disk backup [OPTIONS] <output.zupt> <device_or_file>` / `zupt disk restore [OPTIONS] <archive.zupt> <target>`
|
||||
|
||||
### Tests
|
||||
- **77 tests total:** 11 VV unit + 13 NIST/RFC vectors + 22 regression + 14 multi-threaded + 10 post-quantum + 7 disk backup (normal, encrypted, PQ, sparse, LZHP, extreme, wrong-password rejection). ASAN + UBSan clean across all paths.
|
||||
|
||||
---
|
||||
|
||||
## [2.1.1] — 2026-04-06
|
||||
|
||||
### Fixed — Multi-Architecture Build
|
||||
|
|
@ -259,6 +273,7 @@ All 4 `.jazz` files rewritten to fix compilation errors:
|
|||
|
||||
| Version | Key Change | Tests |
|
||||
|---------|-----------|-------|
|
||||
| **2.1.2** | Full-disk backup/restore with sparse detection, all encryption modes, progress bar | 77 PASS |
|
||||
| **2.1.1** | Termux/Android build fix, arch-safety guard, Keccak UB fix, no stale .o in tarballs | 70 PASS |
|
||||
| **2.1.0** | VaptVupt 1.4.0: cross-block dictionary, context prefetch, faster adaptive window, integration API | 70 PASS |
|
||||
| **2.0.0** | VaptVupt 1.1.0 codec, auto codec detection, all 5 Jasmin wired, AVX SIGILL fix, multi-arch, copy_match fix, litlen overflow fix | 70 PASS |
|
||||
|
|
|
|||
2
Makefile
2
Makefile
|
|
@ -50,7 +50,7 @@ ZUPT_SOURCES = src/zupt_main.c src/zupt_format.c src/zupt_lz.c src/zupt_lzh.c \
|
|||
src/zupt_xxh.c src/zupt_sha256.c src/zupt_aes256.c src/zupt_crypto.c \
|
||||
src/zupt_predict.c src/zupt_parallel.c src/zupt_keccak.c \
|
||||
src/zupt_x25519.c src/zupt_mlkem.c src/zupt_cpuid.c src/zupt_mlock.c \
|
||||
src/zupt_filetype.c
|
||||
src/zupt_filetype.c src/zupt_disk.c
|
||||
|
||||
# --- VAPTVUPT: VaptVupt codec sources (Apache-2.0, integrated under MIT) ---
|
||||
VV_SOURCES = src/vv_encoder.c src/vv_decoder.c src/vv_ans.c \
|
||||
|
|
|
|||
95
README.md
95
README.md
|
|
@ -4,11 +4,11 @@
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Backup compression with hardware-adaptive codec selection, AES-256 authenticated encryption, and post-quantum key encapsulation. Pure C11, zero dependencies, ~12,000 lines. Builds and runs on x86_64, aarch64, armhf, ppc64le, s390x, and riscv64.
|
||||
Backup compression with hardware-adaptive codec selection, AES-256 authenticated encryption, post-quantum key encapsulation, and full-disk backup. Pure C11, zero dependencies, ~13,000 lines. Builds and runs on x86_64, aarch64, armhf, ppc64le, s390x, and riscv64.
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -18,6 +18,7 @@ Backup compression with hardware-adaptive codec selection, AES-256 authenticated
|
|||
- **Post-quantum encryption** — `--pq` mode uses ML-KEM-768 + X25519 hybrid KEM (same approach as Signal and iMessage). Protects against "harvest now, decrypt later" quantum attacks.
|
||||
- **AES-NI hardware acceleration** — AES-256-CTR via Jasmin-verified assembly with 4-block interleaved pipeline. Safe AVX detection with OSXSAVE/XCR0 validation — no SIGILL on any CPU. Falls back to C table-based AES on unsupported hardware.
|
||||
- **Multi-threaded** — Compression and decompression both parallelized. `-t 0` auto-detects cores.
|
||||
- **Full-disk backup** — `zupt disk backup` clones entire disks or partitions in one command. Sparse block detection skips zero regions, real-time progress bar, all encryption modes supported. Restore with byte-for-byte verification via per-block XXH64 checksums.
|
||||
- **Encrypted backups in one command** — `zupt compress -p changeme backup.zupt ~/data/` — AES-256 + HMAC-SHA256, file names hidden.
|
||||
- **Per-block integrity** — XXH64 checksum + HMAC-SHA256 per block. Wrong password rejected instantly.
|
||||
- **Formally verified crypto** — 5 Jasmin assembly functions with constant-time proofs. 19 ACSL-annotated functions for Frama-C memory safety analysis.
|
||||
|
|
@ -155,6 +156,84 @@ Public key → ML-KEM-768 Encaps + X25519 ECDH → hybrid shared secret
|
|||
|
||||
---
|
||||
|
||||
## Full-Disk Backup
|
||||
|
||||
Clone entire disks, partitions, or raw images with compression and encryption in one command.
|
||||
|
||||
### Quick start
|
||||
```bash
|
||||
# Clone a partition (requires read access)
|
||||
sudo zupt disk backup backup.zupt /dev/sda1
|
||||
|
||||
# Clone with post-quantum encryption (strongest)
|
||||
zupt keygen -o mykey.key
|
||||
zupt keygen --pub -o pub.key -k mykey.key
|
||||
sudo zupt disk backup --pq pub.key backup.zupt /dev/nvme0n1p2
|
||||
|
||||
# Clone with password encryption
|
||||
sudo zupt disk backup -p backup.zupt /dev/sda1
|
||||
|
||||
# Maximum compression (level 9, extreme mode)
|
||||
sudo zupt disk backup -l 9 backup.zupt /dev/sda1
|
||||
|
||||
# Restore to a device or file
|
||||
sudo zupt disk restore backup.zupt /dev/sda1
|
||||
sudo zupt disk restore --pq mykey.key backup.zupt /dev/sda1
|
||||
```
|
||||
|
||||
### How it works
|
||||
|
||||
```
|
||||
Source device → Read 4MB blocks → Sparse detection → Compress → Encrypt → Write .zupt
|
||||
│ │ │
|
||||
│ │ └─ AES-256-CTR + HMAC-SHA256
|
||||
│ └─ VaptVupt/LZHP (auto-selected)
|
||||
└─ Zero blocks stored as STORE (near-zero overhead)
|
||||
```
|
||||
|
||||
Zupt reads the source device sequentially in 4MB chunks. Each block is checked for all-zero content (sparse detection uses 8-byte-wide comparison). Zero blocks are stored with codec `STORE` — effectively just the block header with no payload, saving both compression CPU time and archive space. Non-zero blocks are compressed with the selected codec and optionally encrypted. Per-block XXH64 checksums ensure byte-for-byte integrity on restore.
|
||||
|
||||
### Best practices
|
||||
|
||||
**Encryption hierarchy (strongest → fastest):**
|
||||
|
||||
| Mode | Command | Security Level | Speed Impact |
|
||||
|------|---------|---------------|-------------|
|
||||
| PQ Hybrid | `--pq pub.key` | Quantum-resistant + classical | ~5% overhead |
|
||||
| Password | `-p` | AES-256, PBKDF2 600K iter | ~3% overhead |
|
||||
| None | (default) | Integrity only (XXH64) | Fastest |
|
||||
|
||||
**Compression levels for disks:**
|
||||
|
||||
| Level | Mode | Best for | Typical ratio |
|
||||
|-------|------|----------|--------------|
|
||||
| `-l 1` to `-l 3` | Ultra-Fast | Live systems, NVMe (speed priority) | 1.5–2.5:1 |
|
||||
| `-l 4` to `-l 7` | Balanced (default) | General partitions, ext4/NTFS | 2–5:1 |
|
||||
| `-l 8` to `-l 9` | Extreme | Cold storage, archival backups | 3–10:1 |
|
||||
|
||||
**Operational guidance:**
|
||||
|
||||
- **Unmount before backup** for filesystem consistency. For live systems, use LVM snapshots or filesystem freeze: `fsfreeze -f /mnt/data && zupt disk backup ... && fsfreeze -u /mnt/data`.
|
||||
- **Block devices require root** on Linux. Regular files (disk images, `.img`, `.raw`) do not.
|
||||
- **Sparse-heavy disks** (freshly formatted, VMs with thin provisioning) compress extremely well — the sparse detector skips zero blocks at memory-copy speed with no compression overhead.
|
||||
- **Verify after backup** with `zupt test archive.zupt` — checks every block's XXH64 checksum without extracting.
|
||||
- **PQ encryption for long-term** — disk backups stored for years should use `--pq` to resist future quantum attacks. Generate one keypair, store the private key offline, distribute the public key.
|
||||
- **Restore is non-destructive on files** — writing to a regular file creates/overwrites it. Writing to a block device overwrites the raw device. Double-check the target path before restoring to a device.
|
||||
|
||||
### Comparison with other tools
|
||||
|
||||
| Feature | Zupt disk | dd + gzip | Clonezilla | partclone |
|
||||
|---------|-----------|-----------|------------|-----------|
|
||||
| Compression | VaptVupt/LZHP (adaptive) | gzip (fixed) | Multiple | Multiple |
|
||||
| Encryption | AES-256 + PQ hybrid | None (pipe to gpg) | None | None |
|
||||
| Sparse detection | Automatic | None | Filesystem-aware | Filesystem-aware |
|
||||
| Per-block integrity | XXH64 per block | None | None | CRC32 |
|
||||
| Single binary | ✓ (zero deps) | 2+ tools | ISO boot | Multiple |
|
||||
| Post-quantum | ML-KEM-768 | — | — | — |
|
||||
| Cross-platform | 6 architectures | ✓ | x86 only | Linux only |
|
||||
|
||||
---
|
||||
|
||||
## Multi-Architecture Support
|
||||
|
||||
Zupt builds and runs on all major architectures. The Makefile auto-detects the platform and enables the best available features.
|
||||
|
|
@ -178,9 +257,10 @@ make install DESTDIR=/buildroot
|
|||
|
||||
## Feature Comparison
|
||||
|
||||
| Feature | Zupt v2.0 | gzip | zstd | 7-Zip |
|
||||
| Feature | Zupt v2.1 | gzip | zstd | 7-Zip |
|
||||
|---------|-----------|------|------|-------|
|
||||
| Default codec | VaptVupt/LZHP (auto) | DEFLATE | FSE+Huffman | LZMA2 |
|
||||
| Full-disk backup | **`zupt disk`** | — | — | — |
|
||||
| Post-quantum encryption | **ML-KEM-768** | — | — | — |
|
||||
| Password encryption | AES-256 + HMAC | — | — | AES-256 |
|
||||
| AES-NI hardware accel | **Jasmin-verified** | — | — | — |
|
||||
|
|
@ -220,6 +300,8 @@ zupt compress [OPTIONS] <output.zupt> <files/dirs...>
|
|||
zupt extract [OPTIONS] <archive.zupt>
|
||||
zupt list [OPTIONS] <archive.zupt>
|
||||
zupt test [OPTIONS] <archive.zupt>
|
||||
zupt disk backup [OPTIONS] <output.zupt> <device_or_file>
|
||||
zupt disk restore [OPTIONS] <archive.zupt> <target>
|
||||
zupt bench [--compare] <files/dirs...>
|
||||
zupt keygen [-o file] [--pub] [-k privkey]
|
||||
zupt version
|
||||
|
|
@ -248,7 +330,7 @@ zupt help
|
|||
```bash
|
||||
make # Auto-detects arch, Jasmin, AVX2
|
||||
make V=1 # Verbose build output
|
||||
make test-all # 70 tests: regression + NIST + VV + MT + PQ
|
||||
make test-all # 77 tests: regression + NIST + VV + MT + PQ + disk
|
||||
make test-vv # VaptVupt codec unit tests only
|
||||
make test-asan # AddressSanitizer + UBSan build
|
||||
make fuzz-build # AFL++ fuzzing harnesses
|
||||
|
|
@ -290,9 +372,10 @@ All codecs are forward-compatible: archives created with any codec can be read b
|
|||
| v1.1–v1.4 | X25519 fix, NIST vectors, CPUID detection, Jasmin source files fixed |
|
||||
| v1.5 | Jasmin CT assembly linked (MAC verify + ML-KEM select active) |
|
||||
| v1.5.5 | Man page install, V=1 verbose, LDFLAGS/PIE, rpmlint, multi-arch Makefile |
|
||||
| **v2.1.1** | **Termux/Android build fix, arch-safety guard removes stale cross-arch .o, Keccak ROL64 UB fix, zero UBSan violations** |
|
||||
| v2.1 | VaptVupt 1.4.0: cross-block dictionary carry, context decode prefetch, faster adaptive window trial (2.6× encode), integration API |
|
||||
| v2.0 | VaptVupt 1.1.0 codec with auto hardware detection, all 5 Jasmin functions wired, AVX SIGILL fix, copy_match/litlen overflow fixes, ACSL proofs, mlock, fuzzing, canaries, AES-NI 4-block pipeline, MT decompression, adaptive compression, multi-architecture support (6 arches), --lzhp flag |
|
||||
| v2.1 | VaptVupt 1.4.0: cross-block dictionary carry, context decode prefetch, faster adaptive window trial (2.6× encode), integration API |
|
||||
| v2.1.1 | Termux/Android build fix, arch-safety guard removes stale cross-arch .o, Keccak ROL64 UB fix, zero UBSan violations |
|
||||
| **v2.1.2** | **Full-disk backup/restore (`zupt disk`), sparse detection, all encryption modes, per-block XXH64 verification, progress bar, 77 tests** |
|
||||
|
||||
See [CHANGELOG.md](CHANGELOG.md) for detailed per-version changes.
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@
|
|||
| **v1.5.5** | **✅** | **Man page install, V=1 verbose, LDFLAGS/PIE, rpmlint, multi-arch Makefile** |
|
||||
| **v2.0** | **✅** | **VaptVupt 1.1.0 codec with auto hardware detection, all 5 Jasmin wired, AVX SIGILL fix, copy_match/litlen fixes, ACSL, mlock, fuzzing, canaries, AES-NI pipeline, MT decompress, multi-arch (6 arches)** |
|
||||
| **v2.1** | **✅** | **VaptVupt 1.4.0: cross-block dictionary, context prefetch, faster adaptive window, integration API** |
|
||||
| **v2.1.1** | **✅ Current** | **Termux/Android build fix, arch-safety guard, Keccak UB fix, no stale .o in tarballs** |
|
||||
| **v2.1.1** | **✅** | **Termux/Android build fix, arch-safety guard, Keccak UB fix, no stale .o in tarballs** |
|
||||
| **v2.1.2** | **✅ Current** | **Full-disk backup/restore with sparse detection, all encryption modes, progress bar, 77 tests** |
|
||||
|
||||
## Planned
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@
|
|||
#define zupt_mkdir(p) mkdir(p, 0755)
|
||||
#endif
|
||||
|
||||
#define ZUPT_VERSION_STRING "2.1.1"
|
||||
#define ZUPT_VERSION_STRING "2.1.2"
|
||||
#define ZUPT_FORMAT_MAJOR 1
|
||||
#define ZUPT_FORMAT_MINOR 4
|
||||
|
||||
|
|
@ -333,4 +333,18 @@ void zupt_format_size(uint64_t bytes, char *buf, size_t cap);
|
|||
* Decompression of ALL codecs works on ALL architectures. */
|
||||
uint16_t zupt_resolve_auto_codec(void);
|
||||
|
||||
/* ─── Full-Disk Backup/Restore ─── */
|
||||
#define ZUPT_FLAG_DISK_IMAGE (1u << 6) /* Archive contains a raw disk/partition image */
|
||||
|
||||
/* Compress a raw block device or file as a disk image.
|
||||
* Reads source in block_size chunks, detects zero/sparse regions,
|
||||
* compresses non-zero blocks. Supports encryption + PQ. */
|
||||
zupt_error_t zupt_disk_backup(const char *output_path, const char *source_path,
|
||||
zupt_options_t *opts);
|
||||
|
||||
/* Restore a disk image archive to a block device or file.
|
||||
* Writes blocks sequentially, restoring sparse regions as zeros. */
|
||||
zupt_error_t zupt_disk_restore(const char *archive_path, const char *target_path,
|
||||
zupt_options_t *opts);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
789
src/zupt_disk.c
Normal file
789
src/zupt_disk.c
Normal file
|
|
@ -0,0 +1,789 @@
|
|||
/*
|
||||
* Zupt v2.1.2 — Full-Disk Backup/Restore
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés — MIT License
|
||||
*
|
||||
* Reads a raw block device or file, compresses in streaming chunks,
|
||||
* writes a single-file solid .zupt archive. Detects all-zero blocks
|
||||
* (sparse regions) and stores them as STORE codec with minimal overhead.
|
||||
*
|
||||
* Design:
|
||||
* - Streaming: reads source in block_size chunks (default 4MB for disks)
|
||||
* - Sparse detection: zero blocks stored as ZUPT_CODEC_STORE (1 byte overhead)
|
||||
* - Multi-threaded: uses existing zpar_ctx_t parallel pipeline
|
||||
* - Encryption: full support for password (-p) and PQ (--pq) modes
|
||||
* - Progress: real-time progress bar on stderr
|
||||
* - Portable: works on Linux, macOS, *BSD (raw /dev/ access)
|
||||
* On Android/Termux: requires root for block devices
|
||||
*
|
||||
* Archive format: standard .zupt with ZUPT_FLAG_DISK_IMAGE set.
|
||||
* - Single index entry with path = source device/file path
|
||||
* - Content = raw byte-for-byte disk image (decompressed)
|
||||
* - Sparse blocks encoded as codec=STORE with all-zero payload
|
||||
*
|
||||
* Usage:
|
||||
* zupt disk backup output.zupt /dev/sda1
|
||||
* zupt disk backup -p secret output.zupt /dev/nvme0n1p2
|
||||
* zupt disk backup --pq pub.key output.zupt disk.img
|
||||
* zupt disk restore archive.zupt /dev/sda1
|
||||
* zupt disk restore -p secret archive.zupt /dev/sda1
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "zupt.h"
|
||||
#include "zupt_cpuid.h"
|
||||
#include "vaptvupt_api.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <io.h>
|
||||
#define fseeko _fseeki64
|
||||
#define ftello _ftelli64
|
||||
#else
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#ifdef __linux__
|
||||
#include <sys/ioctl.h>
|
||||
#include <linux/fs.h> /* BLKGETSIZE64 */
|
||||
#endif
|
||||
#ifdef __APPLE__
|
||||
#include <sys/disk.h> /* DKIOCGETBLOCKCOUNT, DKIOCGETBLOCKSIZE */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
* DEVICE SIZE DETECTION
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
static int64_t get_device_size(const char *path) {
|
||||
#ifdef _WIN32
|
||||
/* Windows: use GetFileSizeEx for files, IOCTL_DISK_GET_LENGTH_INFO for devices */
|
||||
HANDLE h = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||||
NULL, OPEN_EXISTING, 0, NULL);
|
||||
if (h == INVALID_HANDLE_VALUE) return -1;
|
||||
LARGE_INTEGER sz;
|
||||
if (GetFileSizeEx(h, &sz)) { CloseHandle(h); return (int64_t)sz.QuadPart; }
|
||||
/* Try disk IOCTL */
|
||||
GET_LENGTH_INFORMATION gli;
|
||||
DWORD ret;
|
||||
if (DeviceIoControl(h, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &gli, sizeof(gli), &ret, NULL)) {
|
||||
CloseHandle(h); return (int64_t)gli.Length.QuadPart;
|
||||
}
|
||||
CloseHandle(h);
|
||||
return -1;
|
||||
#else
|
||||
struct stat st;
|
||||
if (stat(path, &st) != 0) return -1;
|
||||
|
||||
if (S_ISREG(st.st_mode)) {
|
||||
return (int64_t)st.st_size;
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
if (S_ISBLK(st.st_mode)) {
|
||||
int fd = open(path, O_RDONLY);
|
||||
if (fd < 0) return -1;
|
||||
uint64_t sz = 0;
|
||||
if (ioctl(fd, BLKGETSIZE64, &sz) == 0) {
|
||||
close(fd);
|
||||
return (int64_t)sz;
|
||||
}
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __APPLE__
|
||||
if (S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode)) {
|
||||
int fd = open(path, O_RDONLY);
|
||||
if (fd < 0) return -1;
|
||||
uint64_t bc = 0, bs = 0;
|
||||
if (ioctl(fd, DKIOCGETBLOCKCOUNT, &bc) == 0 &&
|
||||
ioctl(fd, DKIOCGETBLOCKSIZE, &bs) == 0) {
|
||||
close(fd);
|
||||
return (int64_t)(bc * bs);
|
||||
}
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* FreeBSD/generic: try seeking to end */
|
||||
int fd = open(path, O_RDONLY);
|
||||
if (fd < 0) return -1;
|
||||
off_t end = lseek(fd, 0, SEEK_END);
|
||||
close(fd);
|
||||
return (end >= 0) ? (int64_t)end : -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
* SPARSE DETECTION
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* Check if a block is all zeros. Uses 8-byte wide check for speed. */
|
||||
static int block_is_zero(const uint8_t *buf, size_t len) {
|
||||
/* Check 8 bytes at a time */
|
||||
const uint64_t *p64 = (const uint64_t *)(const void *)buf;
|
||||
size_t n64 = len / 8;
|
||||
for (size_t i = 0; i < n64; i++) {
|
||||
if (p64[i] != 0) return 0;
|
||||
}
|
||||
/* Check remaining bytes */
|
||||
for (size_t i = n64 * 8; i < len; i++) {
|
||||
if (buf[i] != 0) return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
* PROGRESS BAR
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
static void disk_progress(const char *label, uint64_t done, uint64_t total, time_t start) {
|
||||
if (total == 0) return;
|
||||
int pct = (int)(done * 100 / total);
|
||||
int bar = pct / 2;
|
||||
char buf[60]; memset(buf, ' ', 50); buf[50] = '\0';
|
||||
for (int i = 0; i < bar && i < 50; i++) buf[i] = '#';
|
||||
|
||||
time_t elapsed = time(NULL) - start;
|
||||
if (elapsed < 1) elapsed = 1;
|
||||
double speed = (double)done / (double)elapsed / 1048576.0;
|
||||
|
||||
char done_str[16], total_str[16];
|
||||
zupt_format_size(done, done_str, sizeof(done_str));
|
||||
zupt_format_size(total, total_str, sizeof(total_str));
|
||||
|
||||
fprintf(stderr, "\r %s [%-50s] %3d%% %s / %s %.1f MB/s",
|
||||
label, buf, pct, done_str, total_str, speed);
|
||||
if (done >= total) fprintf(stderr, "\n");
|
||||
fflush(stderr);
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
* DISK BACKUP (compress device → archive)
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* Forward declarations from zupt_format.c */
|
||||
extern int zupt_write_varint(FILE *f, uint64_t v);
|
||||
|
||||
zupt_error_t zupt_disk_backup(const char *output_path, const char *source_path,
|
||||
zupt_options_t *opts) {
|
||||
/* Detect source size */
|
||||
int64_t source_size = get_device_size(source_path);
|
||||
if (source_size <= 0) {
|
||||
fprintf(stderr, "Error: Cannot determine size of '%s': %s\n",
|
||||
source_path, strerror(errno));
|
||||
return ZUPT_ERR_IO;
|
||||
}
|
||||
|
||||
/* Use 4MB blocks for disk images (good balance of ratio vs memory) */
|
||||
if (opts->block_size == 0)
|
||||
opts->block_size = 4 * 1024 * 1024;
|
||||
if (opts->block_size < ZUPT_MIN_BLOCK_SZ)
|
||||
opts->block_size = ZUPT_MIN_BLOCK_SZ;
|
||||
|
||||
/* Resolve AUTO codec */
|
||||
if (opts->codec_id == ZUPT_CODEC_AUTO)
|
||||
opts->codec_id = zupt_resolve_auto_codec();
|
||||
|
||||
char sz_str[16];
|
||||
zupt_format_size((uint64_t)source_size, sz_str, sizeof(sz_str));
|
||||
fprintf(stderr, " Source: %s (%s)\n", source_path, sz_str);
|
||||
fprintf(stderr, " Block size: %u bytes\n", opts->block_size);
|
||||
fprintf(stderr, " Codec: %s\n", zupt_codec_name(opts->codec_id));
|
||||
if (opts->encrypt) fprintf(stderr, " Encryption: ENABLED\n");
|
||||
fprintf(stderr, "\n");
|
||||
|
||||
/* Open source */
|
||||
FILE *src_f = fopen(source_path, "rb");
|
||||
if (!src_f) {
|
||||
fprintf(stderr, "Error: Cannot open '%s': %s\n", source_path, strerror(errno));
|
||||
return ZUPT_ERR_IO;
|
||||
}
|
||||
|
||||
/* Open output */
|
||||
FILE *out = fopen(output_path, "wb");
|
||||
if (!out) {
|
||||
fprintf(stderr, "Error: Cannot create '%s': %s\n", output_path, strerror(errno));
|
||||
fclose(src_f);
|
||||
return ZUPT_ERR_IO;
|
||||
}
|
||||
|
||||
int write_err = 0;
|
||||
|
||||
/* ─── Write archive header ─── */
|
||||
zupt_archive_header_t hdr;
|
||||
memset(&hdr, 0, sizeof(hdr));
|
||||
hdr.magic[0] = ZUPT_MAGIC_0; hdr.magic[1] = ZUPT_MAGIC_1;
|
||||
hdr.magic[2] = ZUPT_MAGIC_2; hdr.magic[3] = ZUPT_MAGIC_3;
|
||||
hdr.magic[4] = ZUPT_MAGIC_4; hdr.magic[5] = ZUPT_MAGIC_5;
|
||||
hdr.version_major = ZUPT_FORMAT_MAJOR;
|
||||
hdr.version_minor = ZUPT_FORMAT_MINOR;
|
||||
hdr.global_flags = ZUPT_FLAG_CKSUM_XXH64 | ZUPT_FLAG_SOLID | ZUPT_FLAG_DISK_IMAGE;
|
||||
if (opts->encrypt) hdr.global_flags |= ZUPT_FLAG_ENCRYPTED;
|
||||
if (opts->threads > 1) hdr.global_flags |= ZUPT_FLAG_MULTITHREADED;
|
||||
hdr.creation_time = (uint64_t)time(NULL) * 1000000000ULL;
|
||||
zupt_random_bytes(hdr.archive_id, 16);
|
||||
hdr.archive_id[6] = (hdr.archive_id[6] & 0x0F) | 0x40;
|
||||
hdr.archive_id[8] = (hdr.archive_id[8] & 0x3F) | 0x80;
|
||||
if (fwrite(&hdr, sizeof(hdr), 1, out) != 1) write_err = 1;
|
||||
|
||||
/* ─── Encryption header ─── */
|
||||
if (opts->encrypt) {
|
||||
hdr.encryption_header_off = (uint64_t)ftello(out);
|
||||
|
||||
if (opts->pq_mode) {
|
||||
uint8_t enc_hdr_buf[1200];
|
||||
size_t enc_hdr_len = 0;
|
||||
fprintf(stderr, " Post-quantum key encapsulation (ML-KEM-768 + X25519)...\n");
|
||||
if (zupt_hybrid_encrypt_init(&opts->keyring, opts->keyfile,
|
||||
enc_hdr_buf, &enc_hdr_len) != 0) {
|
||||
fprintf(stderr, "Error: PQ hybrid key encapsulation failed.\n");
|
||||
fclose(src_f); fclose(out);
|
||||
return ZUPT_ERR_AUTH_FAIL;
|
||||
}
|
||||
|
||||
/* Write encryption block */
|
||||
uint8_t bm0 = 0xBB, bm1 = 0x01, bt = ZUPT_BLOCK_ENC_HEADER;
|
||||
fwrite(&bm0, 1, 1, out); fwrite(&bm1, 1, 1, out); fwrite(&bt, 1, 1, out);
|
||||
uint8_t cs[2] = {0, 0}; fwrite(cs, 1, 2, out); fwrite(cs, 1, 2, out);
|
||||
zupt_write_varint(out, enc_hdr_len);
|
||||
zupt_write_varint(out, enc_hdr_len);
|
||||
uint64_t ck = zupt_xxh64(enc_hdr_buf, enc_hdr_len, 0);
|
||||
uint8_t ck8[8]; for (int i = 0; i < 8; i++) ck8[i] = (uint8_t)(ck >> (i*8));
|
||||
fwrite(ck8, 1, 8, out);
|
||||
fwrite(enc_hdr_buf, 1, enc_hdr_len, out);
|
||||
|
||||
hdr.global_flags |= ZUPT_FLAG_PQ_HYBRID;
|
||||
fseeko(out, 0, SEEK_SET);
|
||||
fwrite(&hdr, sizeof(hdr), 1, out);
|
||||
fseeko(out, 0, SEEK_END);
|
||||
|
||||
fprintf(stderr, " Encryption: PQ Hybrid (ML-KEM-768 + X25519)\n\n");
|
||||
} else {
|
||||
uint8_t salt[ZUPT_SALT_SIZE], nonce[ZUPT_NONCE_SIZE];
|
||||
zupt_random_bytes(salt, ZUPT_SALT_SIZE);
|
||||
zupt_random_bytes(nonce, ZUPT_NONCE_SIZE);
|
||||
|
||||
fprintf(stderr, " Deriving encryption key (PBKDF2-SHA256, %d iterations)...\n",
|
||||
ZUPT_KDF_ITERATIONS);
|
||||
zupt_derive_keys(&opts->keyring, opts->password, salt, nonce, ZUPT_KDF_ITERATIONS);
|
||||
|
||||
uint8_t enc_hdr[53];
|
||||
enc_hdr[0] = 0x01; /* ZUPT_ENC_PBKDF2 */
|
||||
memcpy(enc_hdr + 1, salt, 32);
|
||||
memcpy(enc_hdr + 33, nonce, 16);
|
||||
uint32_t iter = ZUPT_KDF_ITERATIONS;
|
||||
memcpy(enc_hdr + 49, &iter, 4);
|
||||
|
||||
uint8_t bm0 = 0xBB, bm1 = 0x01, bt = ZUPT_BLOCK_ENC_HEADER;
|
||||
fwrite(&bm0, 1, 1, out); fwrite(&bm1, 1, 1, out); fwrite(&bt, 1, 1, out);
|
||||
uint8_t cs[2] = {0, 0}; fwrite(cs, 1, 2, out); fwrite(cs, 1, 2, out);
|
||||
zupt_write_varint(out, 53); zupt_write_varint(out, 53);
|
||||
uint64_t ck = zupt_xxh64(enc_hdr, 53, 0);
|
||||
uint8_t ck8[8]; for (int i = 0; i < 8; i++) ck8[i] = (uint8_t)(ck >> (i*8));
|
||||
fwrite(ck8, 1, 8, out);
|
||||
fwrite(enc_hdr, 1, 53, out);
|
||||
|
||||
fseeko(out, 0, SEEK_SET);
|
||||
fwrite(&hdr, sizeof(hdr), 1, out);
|
||||
fseeko(out, 0, SEEK_END);
|
||||
|
||||
fprintf(stderr, " Encryption: AES-256-CTR + HMAC-SHA256\n\n");
|
||||
}
|
||||
}
|
||||
|
||||
/* ─── Compress blocks ─── */
|
||||
uint8_t *rbuf = (uint8_t *)malloc(opts->block_size);
|
||||
size_t comp_cap = vvz_compress_bound(opts->block_size) + 512;
|
||||
if (comp_cap < zupt_lzh_bound(opts->block_size) + 512)
|
||||
comp_cap = zupt_lzh_bound(opts->block_size) + 512;
|
||||
uint8_t *cbuf = (uint8_t *)malloc(comp_cap);
|
||||
|
||||
if (!rbuf || !cbuf) {
|
||||
free(rbuf); free(cbuf);
|
||||
fclose(src_f); fclose(out);
|
||||
return ZUPT_ERR_NOMEM;
|
||||
}
|
||||
|
||||
uint64_t total_read = 0, total_written = 0;
|
||||
uint64_t block_seq = 0;
|
||||
uint64_t sparse_blocks = 0, data_blocks = 0;
|
||||
uint64_t first_block_off = (uint64_t)ftello(out);
|
||||
time_t start_time = time(NULL);
|
||||
|
||||
while (total_read < (uint64_t)source_size) {
|
||||
size_t to_read = opts->block_size;
|
||||
if (total_read + to_read > (uint64_t)source_size)
|
||||
to_read = (size_t)((uint64_t)source_size - total_read);
|
||||
|
||||
size_t nread = fread(rbuf, 1, to_read, src_f);
|
||||
if (nread == 0) break;
|
||||
|
||||
/* Pad partial last block with zeros */
|
||||
if (nread < to_read)
|
||||
memset(rbuf + nread, 0, to_read - nread);
|
||||
|
||||
uint64_t checksum = zupt_xxh64(rbuf, nread, 0);
|
||||
|
||||
/* Sparse detection: skip zero blocks */
|
||||
uint16_t codec = opts->codec_id;
|
||||
size_t comp_size = 0;
|
||||
|
||||
if (block_is_zero(rbuf, nread)) {
|
||||
codec = ZUPT_CODEC_STORE;
|
||||
comp_size = nread;
|
||||
sparse_blocks++;
|
||||
} else {
|
||||
/* Compress with selected codec */
|
||||
if (codec == ZUPT_CODEC_VAPTVUPT) {
|
||||
int64_t csz = vvz_compress(rbuf, nread, cbuf, comp_cap, opts->level);
|
||||
if (csz > 0 && (size_t)csz < nread)
|
||||
comp_size = (size_t)csz;
|
||||
} else if (codec == ZUPT_CODEC_ZUPT_LZHP) {
|
||||
/* LZHP with prediction */
|
||||
float benefit = zupt_predict_benefit(rbuf, nread);
|
||||
if (benefit > 0.02f && nread > 256) {
|
||||
uint8_t pred[256];
|
||||
zupt_predict_build(rbuf, nread, pred);
|
||||
cbuf[0] = 0x01;
|
||||
memcpy(cbuf + 1, pred, 256);
|
||||
size_t plain = zupt_lzh_compress(rbuf, nread, cbuf + 257,
|
||||
comp_cap - 257, opts->level);
|
||||
if (plain > 0 && 257 + plain < nread)
|
||||
comp_size = 257 + plain;
|
||||
} else {
|
||||
cbuf[0] = 0x00;
|
||||
size_t plain = zupt_lzh_compress(rbuf, nread, cbuf + 1,
|
||||
comp_cap - 1, opts->level);
|
||||
if (plain > 0 && 1 + plain < nread)
|
||||
comp_size = 1 + plain;
|
||||
}
|
||||
} else if (codec == ZUPT_CODEC_ZUPT_LZH) {
|
||||
comp_size = zupt_lzh_compress(rbuf, nread, cbuf, comp_cap, opts->level);
|
||||
} else if (codec == ZUPT_CODEC_ZUPT_LZ) {
|
||||
comp_size = zupt_lz_compress(rbuf, nread, cbuf, comp_cap, opts->level);
|
||||
}
|
||||
|
||||
data_blocks++;
|
||||
}
|
||||
|
||||
/* Fallback to store if compression didn't help */
|
||||
const uint8_t *payload;
|
||||
uint64_t payload_size;
|
||||
if (comp_size == 0 || comp_size >= nread) {
|
||||
codec = ZUPT_CODEC_STORE;
|
||||
payload = rbuf;
|
||||
payload_size = nread;
|
||||
} else {
|
||||
payload = cbuf;
|
||||
payload_size = comp_size;
|
||||
}
|
||||
|
||||
/* Encrypt if active */
|
||||
uint8_t *enc_payload = NULL;
|
||||
uint16_t bflags = 0;
|
||||
if (opts->encrypt && opts->keyring.active) {
|
||||
size_t enc_len;
|
||||
enc_payload = zupt_encrypt_buffer(&opts->keyring, payload, payload_size,
|
||||
block_seq, &enc_len);
|
||||
if (!enc_payload) {
|
||||
free(rbuf); free(cbuf);
|
||||
fclose(src_f); fclose(out);
|
||||
return ZUPT_ERR_NOMEM;
|
||||
}
|
||||
payload = enc_payload;
|
||||
payload_size = enc_len;
|
||||
bflags |= ZUPT_BFLAG_ENCRYPTED;
|
||||
}
|
||||
|
||||
/* Write block: magic + type + codec + flags + uncomp_size + comp_size + checksum + payload */
|
||||
uint8_t bm[2] = {ZUPT_BLOCK_MAGIC_0, ZUPT_BLOCK_MAGIC_1};
|
||||
fwrite(bm, 1, 2, out);
|
||||
uint8_t bt = ZUPT_BLOCK_DATA;
|
||||
fwrite(&bt, 1, 1, out);
|
||||
/* codec (2B LE) */
|
||||
uint8_t c16[2]; c16[0] = (uint8_t)(codec & 0xFF); c16[1] = (uint8_t)(codec >> 8);
|
||||
fwrite(c16, 1, 2, out);
|
||||
/* flags (2B LE) */
|
||||
uint8_t f16[2]; f16[0] = (uint8_t)(bflags & 0xFF); f16[1] = (uint8_t)(bflags >> 8);
|
||||
fwrite(f16, 1, 2, out);
|
||||
zupt_write_varint(out, (uint64_t)nread);
|
||||
zupt_write_varint(out, payload_size);
|
||||
/* checksum (8B LE) */
|
||||
uint8_t ck8[8]; for (int i = 0; i < 8; i++) ck8[i] = (uint8_t)(checksum >> (i*8));
|
||||
fwrite(ck8, 1, 8, out);
|
||||
if (fwrite(payload, 1, (size_t)payload_size, out) != (size_t)payload_size)
|
||||
write_err = 1;
|
||||
|
||||
free(enc_payload);
|
||||
total_read += nread;
|
||||
total_written += payload_size;
|
||||
block_seq++;
|
||||
|
||||
/* Progress */
|
||||
if (!opts->quiet)
|
||||
disk_progress("Backup", total_read, (uint64_t)source_size, start_time);
|
||||
}
|
||||
|
||||
/* ─── Write index (single entry for the disk image) ─── */
|
||||
uint8_t idx_buf[4096];
|
||||
size_t idx_pos = 0;
|
||||
|
||||
/* File count (4B LE) */
|
||||
idx_buf[idx_pos++] = 1; idx_buf[idx_pos++] = 0;
|
||||
idx_buf[idx_pos++] = 0; idx_buf[idx_pos++] = 0;
|
||||
|
||||
/* Path (varint length + bytes) */
|
||||
size_t path_len = strlen(source_path);
|
||||
if (path_len > ZUPT_MAX_PATH - 1) path_len = ZUPT_MAX_PATH - 1;
|
||||
idx_pos += zupt_encode_varint(idx_buf + idx_pos, path_len);
|
||||
memcpy(idx_buf + idx_pos, source_path, path_len);
|
||||
idx_pos += path_len;
|
||||
|
||||
/* Uncompressed size (8B LE) */
|
||||
for (int i = 0; i < 8; i++) idx_buf[idx_pos++] = (uint8_t)((uint64_t)source_size >> (i*8));
|
||||
/* Compressed size (8B LE) */
|
||||
for (int i = 0; i < 8; i++) idx_buf[idx_pos++] = (uint8_t)(total_written >> (i*8));
|
||||
/* Modification time (8B LE) */
|
||||
uint64_t mtime = (uint64_t)time(NULL) * 1000000000ULL;
|
||||
for (int i = 0; i < 8; i++) idx_buf[idx_pos++] = (uint8_t)(mtime >> (i*8));
|
||||
/* Content hash (8B LE) */
|
||||
uint64_t content_hash = zupt_xxh64(source_path, path_len, (uint64_t)source_size);
|
||||
for (int i = 0; i < 8; i++) idx_buf[idx_pos++] = (uint8_t)(content_hash >> (i*8));
|
||||
/* First block offset (8B LE) */
|
||||
for (int i = 0; i < 8; i++) idx_buf[idx_pos++] = (uint8_t)(first_block_off >> (i*8));
|
||||
/* Block count (4B LE) */
|
||||
for (int i = 0; i < 4; i++) idx_buf[idx_pos++] = (uint8_t)(block_seq >> (i*8));
|
||||
/* Attributes (4B LE) */
|
||||
idx_buf[idx_pos++] = 0; idx_buf[idx_pos++] = 0;
|
||||
idx_buf[idx_pos++] = 0; idx_buf[idx_pos++] = 0;
|
||||
|
||||
/* Write index block */
|
||||
uint64_t index_offset = (uint64_t)ftello(out);
|
||||
uint64_t idx_ck = zupt_xxh64(idx_buf, idx_pos, 0);
|
||||
{
|
||||
uint8_t bm[2] = {ZUPT_BLOCK_MAGIC_0, ZUPT_BLOCK_MAGIC_1};
|
||||
fwrite(bm, 1, 2, out);
|
||||
uint8_t bt = ZUPT_BLOCK_INDEX;
|
||||
fwrite(&bt, 1, 1, out);
|
||||
uint8_t c16[2] = {0, 0}; fwrite(c16, 1, 2, out);
|
||||
uint8_t f16[2] = {0, 0}; fwrite(f16, 1, 2, out);
|
||||
zupt_write_varint(out, idx_pos);
|
||||
zupt_write_varint(out, idx_pos);
|
||||
uint8_t ck8[8]; for (int i = 0; i < 8; i++) ck8[i] = (uint8_t)(idx_ck >> (i*8));
|
||||
fwrite(ck8, 1, 8, out);
|
||||
fwrite(idx_buf, 1, idx_pos, out);
|
||||
}
|
||||
|
||||
/* ─── Write footer ─── */
|
||||
zupt_footer_t ft;
|
||||
ft.index_offset = index_offset;
|
||||
ft.total_blocks = block_seq;
|
||||
ft.archive_checksum = zupt_xxh64(&hdr, sizeof(hdr), block_seq);
|
||||
ft.footer_magic[0] = 'Z'; ft.footer_magic[1] = 'E';
|
||||
ft.footer_magic[2] = 'N'; ft.footer_magic[3] = 'D';
|
||||
ft.footer_version = 1;
|
||||
fwrite(&ft, sizeof(ft), 1, out);
|
||||
|
||||
/* Get final archive size before closing */
|
||||
uint64_t out_bytes = (uint64_t)ftello(out);
|
||||
|
||||
free(rbuf); free(cbuf);
|
||||
fclose(src_f); fclose(out);
|
||||
|
||||
/* Summary */
|
||||
time_t elapsed = time(NULL) - start_time;
|
||||
if (elapsed < 1) elapsed = 1;
|
||||
char out_sz[16], in_sz[16];
|
||||
|
||||
zupt_format_size((uint64_t)source_size, in_sz, sizeof(in_sz));
|
||||
|
||||
/* Re-open to get actual file size */
|
||||
{
|
||||
FILE *check = fopen(output_path, "rb");
|
||||
if (check) {
|
||||
fseeko(check, 0, SEEK_END);
|
||||
out_bytes = (uint64_t)ftello(check);
|
||||
fclose(check);
|
||||
}
|
||||
}
|
||||
zupt_format_size(out_bytes, out_sz, sizeof(out_sz));
|
||||
|
||||
fprintf(stderr, "\n Disk backup complete:\n");
|
||||
fprintf(stderr, " Source: %s\n", in_sz);
|
||||
fprintf(stderr, " Archive: %s\n", out_sz);
|
||||
fprintf(stderr, " Ratio: %.2f:1\n",
|
||||
out_bytes > 0 ? (double)source_size / (double)out_bytes : 1.0);
|
||||
fprintf(stderr, " Blocks: %llu (%llu data, %llu sparse/zero)\n",
|
||||
(unsigned long long)block_seq,
|
||||
(unsigned long long)data_blocks,
|
||||
(unsigned long long)sparse_blocks);
|
||||
fprintf(stderr, " Speed: %.1f MB/s\n",
|
||||
(double)source_size / (double)elapsed / 1048576.0);
|
||||
if (opts->encrypt) fprintf(stderr, " Encrypted: YES\n");
|
||||
fprintf(stderr, "\n");
|
||||
|
||||
return write_err ? ZUPT_ERR_IO : ZUPT_OK;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
* DISK RESTORE (extract archive → device/file)
|
||||
*
|
||||
* Uses the standard zupt_extract_archive path but writes to a single
|
||||
* file (the target device) instead of creating a directory tree.
|
||||
* For disk images, the archive contains exactly one index entry.
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
zupt_error_t zupt_disk_restore(const char *archive_path, const char *target_path,
|
||||
zupt_options_t *opts) {
|
||||
/* Open archive */
|
||||
FILE *f = fopen(archive_path, "rb");
|
||||
if (!f) {
|
||||
fprintf(stderr, "Error: Cannot open '%s': %s\n", archive_path, strerror(errno));
|
||||
return ZUPT_ERR_IO;
|
||||
}
|
||||
|
||||
/* Read archive header */
|
||||
zupt_archive_header_t hdr;
|
||||
if (fread(&hdr, sizeof(hdr), 1, f) != 1) { fclose(f); return ZUPT_ERR_IO; }
|
||||
|
||||
/* Verify magic */
|
||||
if (hdr.magic[0] != ZUPT_MAGIC_0 || hdr.magic[1] != ZUPT_MAGIC_1 ||
|
||||
hdr.magic[2] != ZUPT_MAGIC_2 || hdr.magic[3] != ZUPT_MAGIC_3) {
|
||||
fclose(f);
|
||||
fprintf(stderr, "Error: Not a .zupt archive\n");
|
||||
return ZUPT_ERR_BAD_MAGIC;
|
||||
}
|
||||
|
||||
/* Check disk image flag */
|
||||
if (!(hdr.global_flags & ZUPT_FLAG_DISK_IMAGE)) {
|
||||
fclose(f);
|
||||
fprintf(stderr, "Error: Archive is not a disk image. Use 'zupt extract' instead.\n");
|
||||
return ZUPT_ERR_INVALID;
|
||||
}
|
||||
|
||||
/* Handle encryption */
|
||||
if (hdr.global_flags & ZUPT_FLAG_ENCRYPTED) {
|
||||
if (!opts->encrypt && opts->password[0] == '\0' && !opts->pq_mode) {
|
||||
fclose(f);
|
||||
fprintf(stderr, "Error: Archive is encrypted. Use -p or --pq to provide key.\n");
|
||||
return ZUPT_ERR_AUTH_FAIL;
|
||||
}
|
||||
|
||||
/* Read encryption header block */
|
||||
fseeko(f, (int64_t)hdr.encryption_header_off, SEEK_SET);
|
||||
|
||||
/* Skip block magic (2B) + type (1B) + codec (2B) + flags (2B) */
|
||||
uint8_t skip[7];
|
||||
if (fread(skip, 1, 7, f) != 7) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
|
||||
uint64_t uncomp_sz, comp_sz;
|
||||
if (zupt_read_varint(f, &uncomp_sz) < 0) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
if (zupt_read_varint(f, &comp_sz) < 0) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
|
||||
/* Skip checksum (8B) */
|
||||
uint8_t ck_skip[8];
|
||||
if (fread(ck_skip, 1, 8, f) != 8) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
|
||||
uint8_t *enc_data = (uint8_t *)malloc((size_t)comp_sz);
|
||||
if (!enc_data) { fclose(f); return ZUPT_ERR_NOMEM; }
|
||||
if (fread(enc_data, 1, (size_t)comp_sz, f) != (size_t)comp_sz) {
|
||||
free(enc_data); fclose(f); return ZUPT_ERR_CORRUPT;
|
||||
}
|
||||
|
||||
if (opts->pq_mode) {
|
||||
if (zupt_hybrid_decrypt_init(&opts->keyring, opts->keyfile,
|
||||
enc_data, (size_t)comp_sz) != 0) {
|
||||
free(enc_data); fclose(f);
|
||||
fprintf(stderr, "Error: PQ decryption failed.\n");
|
||||
return ZUPT_ERR_AUTH_FAIL;
|
||||
}
|
||||
} else {
|
||||
/* Password mode */
|
||||
if (comp_sz < 53) { free(enc_data); fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
uint8_t enc_type = enc_data[0];
|
||||
if (enc_type != 0x01) { free(enc_data); fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
uint8_t *salt = enc_data + 1;
|
||||
uint8_t *nonce = enc_data + 33;
|
||||
uint32_t iter;
|
||||
memcpy(&iter, enc_data + 49, 4);
|
||||
zupt_derive_keys(&opts->keyring, opts->password, salt, nonce, iter);
|
||||
}
|
||||
free(enc_data);
|
||||
}
|
||||
|
||||
/* Read footer to find index */
|
||||
fseeko(f, -(int64_t)sizeof(zupt_footer_t), SEEK_END);
|
||||
zupt_footer_t ft;
|
||||
if (fread(&ft, sizeof(ft), 1, f) != 1) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
if (ft.footer_magic[0] != 'Z' || ft.footer_magic[1] != 'E') {
|
||||
fclose(f); return ZUPT_ERR_BAD_MAGIC;
|
||||
}
|
||||
|
||||
/* Seek to first data block (skip archive header + encryption header) */
|
||||
fseeko(f, sizeof(zupt_archive_header_t), SEEK_SET);
|
||||
if (hdr.global_flags & ZUPT_FLAG_ENCRYPTED) {
|
||||
/* Skip past encryption header block to reach data blocks */
|
||||
fseeko(f, (int64_t)hdr.encryption_header_off, SEEK_SET);
|
||||
/* Skip the enc header block entirely */
|
||||
uint8_t skip2[7];
|
||||
if (fread(skip2, 1, 7, f) != 7) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
uint64_t u1, u2; zupt_read_varint(f, &u1); zupt_read_varint(f, &u2);
|
||||
uint8_t sk8[8];
|
||||
if (fread(sk8, 1, 8, f) != 8) { fclose(f); return ZUPT_ERR_CORRUPT; }
|
||||
fseeko(f, (int64_t)u2, SEEK_CUR);
|
||||
}
|
||||
|
||||
/* Open target for writing */
|
||||
FILE *tgt = fopen(target_path, "wb");
|
||||
if (!tgt) {
|
||||
fprintf(stderr, "Error: Cannot open target '%s': %s\n", target_path, strerror(errno));
|
||||
fclose(f);
|
||||
return ZUPT_ERR_IO;
|
||||
}
|
||||
|
||||
fprintf(stderr, " Restoring disk image to: %s\n", target_path);
|
||||
fprintf(stderr, " Blocks: %llu\n\n", (unsigned long long)ft.total_blocks);
|
||||
|
||||
time_t start_time = time(NULL);
|
||||
uint64_t total_written = 0;
|
||||
int errors = 0;
|
||||
|
||||
for (uint64_t bi = 0; bi < ft.total_blocks; bi++) {
|
||||
/* Read block header */
|
||||
uint8_t bm[2];
|
||||
if (fread(bm, 1, 2, f) != 2) { errors++; break; }
|
||||
if (bm[0] != ZUPT_BLOCK_MAGIC_0 || bm[1] != ZUPT_BLOCK_MAGIC_1) {
|
||||
errors++; break;
|
||||
}
|
||||
|
||||
uint8_t block_type;
|
||||
if (fread(&block_type, 1, 1, f) != 1) { errors++; break; }
|
||||
if (block_type == ZUPT_BLOCK_INDEX) break; /* reached index */
|
||||
|
||||
uint8_t c16[2], f16[2];
|
||||
if (fread(c16, 1, 2, f) != 2) { errors++; break; }
|
||||
if (fread(f16, 1, 2, f) != 2) { errors++; break; }
|
||||
uint16_t codec = (uint16_t)c16[0] | ((uint16_t)c16[1] << 8);
|
||||
uint16_t bflags = (uint16_t)f16[0] | ((uint16_t)f16[1] << 8);
|
||||
|
||||
uint64_t uncomp_size, comp_size, checksum;
|
||||
if (zupt_read_varint(f, &uncomp_size) < 0) { errors++; break; }
|
||||
if (zupt_read_varint(f, &comp_size) < 0) { errors++; break; }
|
||||
uint8_t ck8[8];
|
||||
if (fread(ck8, 1, 8, f) != 8) { errors++; break; }
|
||||
checksum = 0;
|
||||
for (int i = 7; i >= 0; i--) checksum = (checksum << 8) | ck8[i];
|
||||
|
||||
/* Read payload */
|
||||
if (comp_size > ZUPT_MAX_BLOCK_SZ + 1024) { errors++; break; }
|
||||
uint8_t *payload = (uint8_t *)malloc((size_t)comp_size);
|
||||
if (!payload) { errors++; break; }
|
||||
if (fread(payload, 1, (size_t)comp_size, f) != (size_t)comp_size) {
|
||||
free(payload); errors++; break;
|
||||
}
|
||||
|
||||
/* Decrypt if needed */
|
||||
const uint8_t *comp_data = payload;
|
||||
size_t comp_len = (size_t)comp_size;
|
||||
uint8_t *dec_payload = NULL;
|
||||
|
||||
if (bflags & ZUPT_BFLAG_ENCRYPTED) {
|
||||
if (!opts->keyring.active) { free(payload); errors++; break; }
|
||||
size_t dec_len;
|
||||
dec_payload = zupt_decrypt_buffer(&opts->keyring, comp_data, comp_len, bi, &dec_len);
|
||||
if (!dec_payload) {
|
||||
fprintf(stderr, " Block %llu: decryption failed\n", (unsigned long long)bi);
|
||||
free(payload); errors++; break;
|
||||
}
|
||||
comp_data = dec_payload;
|
||||
comp_len = dec_len;
|
||||
}
|
||||
|
||||
/* Decompress */
|
||||
uint8_t *out_buf = (uint8_t *)malloc((size_t)uncomp_size);
|
||||
if (!out_buf) { free(dec_payload); free(payload); errors++; break; }
|
||||
|
||||
if (codec == ZUPT_CODEC_STORE) {
|
||||
if (comp_len >= (size_t)uncomp_size)
|
||||
memcpy(out_buf, comp_data, (size_t)uncomp_size);
|
||||
else { free(out_buf); free(dec_payload); free(payload); errors++; break; }
|
||||
} else if (codec == ZUPT_CODEC_VAPTVUPT) {
|
||||
int64_t dsz = vvz_decompress(comp_data, comp_len, out_buf, (size_t)uncomp_size);
|
||||
if (dsz < 0 || (size_t)dsz != (size_t)uncomp_size) {
|
||||
free(out_buf); free(dec_payload); free(payload); errors++; break;
|
||||
}
|
||||
} else if (codec == ZUPT_CODEC_ZUPT_LZHP) {
|
||||
if (comp_len < 1) { free(out_buf); free(dec_payload); free(payload); errors++; break; }
|
||||
uint8_t pflag = comp_data[0];
|
||||
if (pflag & 0x01) {
|
||||
if (comp_len < 257) { free(out_buf); free(dec_payload); free(payload); errors++; break; }
|
||||
uint8_t pred[256]; memcpy(pred, comp_data + 1, 256);
|
||||
uint8_t *temp = (uint8_t *)malloc((size_t)uncomp_size);
|
||||
if (!temp) { free(out_buf); free(dec_payload); free(payload); errors++; break; }
|
||||
size_t r = zupt_lzh_decompress(comp_data + 257, comp_len - 257, temp, (size_t)uncomp_size);
|
||||
if (r == (size_t)uncomp_size)
|
||||
zupt_predict_decode(temp, out_buf, (size_t)uncomp_size, pred);
|
||||
else errors++;
|
||||
free(temp);
|
||||
} else {
|
||||
size_t r = zupt_lzh_decompress(comp_data + 1, comp_len - 1, out_buf, (size_t)uncomp_size);
|
||||
if (r != (size_t)uncomp_size) errors++;
|
||||
}
|
||||
} else if (codec == ZUPT_CODEC_ZUPT_LZH) {
|
||||
size_t r = zupt_lzh_decompress(comp_data, comp_len, out_buf, (size_t)uncomp_size);
|
||||
if (r != (size_t)uncomp_size) errors++;
|
||||
} else if (codec == ZUPT_CODEC_ZUPT_LZ) {
|
||||
size_t r = zupt_lz_decompress(comp_data, comp_len, out_buf, (size_t)uncomp_size);
|
||||
if (r != (size_t)uncomp_size) errors++;
|
||||
} else {
|
||||
errors++;
|
||||
}
|
||||
|
||||
free(dec_payload);
|
||||
free(payload);
|
||||
|
||||
if (errors) { free(out_buf); break; }
|
||||
|
||||
/* Verify checksum */
|
||||
uint64_t actual_ck = zupt_xxh64(out_buf, (size_t)uncomp_size, 0);
|
||||
if (actual_ck != checksum) {
|
||||
fprintf(stderr, " Block %llu: checksum mismatch\n", (unsigned long long)bi);
|
||||
free(out_buf); errors++; break;
|
||||
}
|
||||
|
||||
/* Write to target */
|
||||
if (fwrite(out_buf, 1, (size_t)uncomp_size, tgt) != (size_t)uncomp_size) {
|
||||
free(out_buf); errors++; break;
|
||||
}
|
||||
total_written += uncomp_size;
|
||||
free(out_buf);
|
||||
|
||||
/* Progress */
|
||||
if (!opts->quiet && ft.total_blocks > 0)
|
||||
disk_progress("Restore", bi + 1, ft.total_blocks, start_time);
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
fclose(tgt);
|
||||
|
||||
if (errors > 0) {
|
||||
fprintf(stderr, "\n Restore FAILED: %d error(s)\n", errors);
|
||||
return ZUPT_ERR_CORRUPT;
|
||||
}
|
||||
|
||||
char sz_str[16];
|
||||
zupt_format_size(total_written, sz_str, sizeof(sz_str));
|
||||
time_t elapsed = time(NULL) - start_time;
|
||||
if (elapsed < 1) elapsed = 1;
|
||||
fprintf(stderr, "\n Restore complete: %s written (%.1f MB/s)\n\n",
|
||||
sz_str, (double)total_written / (double)elapsed / 1048576.0);
|
||||
|
||||
return ZUPT_OK;
|
||||
}
|
||||
|
|
@ -34,6 +34,7 @@ static void usage(void) {
|
|||
" zupt list [OPTIONS] <archive.zupt>\n"
|
||||
" zupt test [OPTIONS] <archive.zupt>\n"
|
||||
" zupt bench <files/dirs...> Compare levels 1-9\n"
|
||||
" zupt disk backup|restore Full-disk backup/restore\n"
|
||||
" zupt keygen Key generation"
|
||||
" zupt version\n"
|
||||
" zupt help\n"
|
||||
|
|
@ -489,6 +490,104 @@ int main(int argc, char **argv) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* ─── disk (backup/restore) ─── */
|
||||
if (streq(cmd,"disk")) {
|
||||
if (argc < 3) {
|
||||
fprintf(stderr, "Usage:\n");
|
||||
fprintf(stderr, " zupt disk backup [OPTIONS] <output.zupt> <device_or_file>\n");
|
||||
fprintf(stderr, " zupt disk restore [OPTIONS] <archive.zupt> <target_device_or_file>\n");
|
||||
fprintf(stderr, "\nOptions:\n");
|
||||
fprintf(stderr, " -l <1-9> Compression level (default: 7)\n");
|
||||
fprintf(stderr, " -b <SIZE> Block size (default: 4MB for disks)\n");
|
||||
fprintf(stderr, " -p [PW] Password encryption\n");
|
||||
fprintf(stderr, " --pq <keyfile> Post-quantum encryption\n");
|
||||
fprintf(stderr, " --vv Force VaptVupt codec\n");
|
||||
fprintf(stderr, " --lzhp Force Zupt-LZHP codec\n");
|
||||
fprintf(stderr, " -t <N> Thread count\n");
|
||||
fprintf(stderr, " -v Verbose\n");
|
||||
fprintf(stderr, "\nExamples:\n");
|
||||
fprintf(stderr, " zupt disk backup backup.zupt /dev/sda1\n");
|
||||
fprintf(stderr, " zupt disk backup -p secret encrypted.zupt /dev/nvme0n1p2\n");
|
||||
fprintf(stderr, " zupt disk backup --pq pub.key pq_backup.zupt disk.img\n");
|
||||
fprintf(stderr, " zupt disk restore backup.zupt /dev/sda1\n");
|
||||
fprintf(stderr, " zupt disk restore -p secret encrypted.zupt /dev/sda1\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
const char *subcmd = argv[2];
|
||||
if (!streq(subcmd,"backup") && !streq(subcmd,"restore")) {
|
||||
fprintf(stderr, "Error: disk subcommand must be 'backup' or 'restore'\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
zupt_options_t opts; zupt_default_options(&opts);
|
||||
int ai = 3;
|
||||
while (ai<argc && isopt(argv[ai])) {
|
||||
if ((streq(argv[ai],"-l")||streq(argv[ai],"--level"))&&ai+1<argc) {
|
||||
opts.level=atoi(argv[++ai]); if(opts.level<1)opts.level=1; if(opts.level>9)opts.level=9;
|
||||
} else if ((streq(argv[ai],"-b")||streq(argv[ai],"--block"))&&ai+1<argc) {
|
||||
opts.block_size=(uint32_t)atol(argv[++ai]);
|
||||
if(opts.block_size<ZUPT_MIN_BLOCK_SZ)opts.block_size=ZUPT_MIN_BLOCK_SZ;
|
||||
if(opts.block_size>ZUPT_MAX_BLOCK_SZ)opts.block_size=ZUPT_MAX_BLOCK_SZ;
|
||||
} else if (streq(argv[ai],"--vv")||streq(argv[ai],"--vaptvupt")) {
|
||||
opts.codec_id=ZUPT_CODEC_VAPTVUPT;
|
||||
} else if (streq(argv[ai],"--lzhp")) {
|
||||
opts.codec_id=ZUPT_CODEC_ZUPT_LZHP;
|
||||
} else if (streq(argv[ai],"-s")||streq(argv[ai],"--store")) {
|
||||
opts.codec_id=ZUPT_CODEC_STORE;
|
||||
} else if (streq(argv[ai],"-p")||streq(argv[ai],"--password")) {
|
||||
opts.encrypt=1;
|
||||
if (ai+1<argc && !isopt(argv[ai+1])) {
|
||||
strncpy(opts.password, argv[++ai], sizeof(opts.password)-1);
|
||||
} else {
|
||||
prompt_password("Password: ", opts.password, sizeof(opts.password));
|
||||
if (streq(subcmd,"backup")) {
|
||||
char confirm[256];
|
||||
prompt_password("Confirm: ", confirm, sizeof(confirm));
|
||||
if (strcmp(opts.password, confirm)!=0) {
|
||||
fprintf(stderr, "Error: Passwords do not match.\n"); return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (streq(argv[ai],"-v")||streq(argv[ai],"--verbose")) {
|
||||
opts.verbose=1;
|
||||
} else if ((streq(argv[ai],"-t")||streq(argv[ai],"--threads"))&&ai+1<argc) {
|
||||
opts.threads=atoi(argv[++ai]);
|
||||
} else if (streq(argv[ai],"--pq")&&ai+1<argc) {
|
||||
opts.pq_mode=1; opts.encrypt=1;
|
||||
strncpy(opts.keyfile, argv[++ai], sizeof(opts.keyfile)-1);
|
||||
} else {
|
||||
fprintf(stderr,"Error: Unknown option '%s'\n",argv[ai]); return 1;
|
||||
}
|
||||
ai++;
|
||||
}
|
||||
|
||||
if (argc - ai < 2) {
|
||||
fprintf(stderr, "Error: disk %s requires <archive> <device/file>\n", subcmd);
|
||||
return 1;
|
||||
}
|
||||
|
||||
banner();
|
||||
|
||||
if (streq(subcmd,"backup")) {
|
||||
const char *output = argv[ai];
|
||||
const char *source = argv[ai+1];
|
||||
fprintf(stderr, " Full-Disk Backup\n");
|
||||
fprintf(stderr, " ═══════════════════════════════════════\n\n");
|
||||
zupt_error_t err = zupt_disk_backup(output, source, &opts);
|
||||
zupt_secure_wipe(opts.password, sizeof(opts.password));
|
||||
return err == ZUPT_OK ? 0 : 1;
|
||||
} else {
|
||||
const char *archive = argv[ai];
|
||||
const char *target = argv[ai+1];
|
||||
fprintf(stderr, " Full-Disk Restore\n");
|
||||
fprintf(stderr, " ═══════════════════════════════════════\n\n");
|
||||
zupt_error_t err = zupt_disk_restore(archive, target, &opts);
|
||||
zupt_secure_wipe(opts.password, sizeof(opts.password));
|
||||
return err == ZUPT_OK ? 0 : 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* ─── keygen ─── */
|
||||
if (streq(cmd,"keygen")) {
|
||||
const char *outfile = NULL;
|
||||
|
|
|
|||
Loading…
Reference in a new issue