Feat: Added vaptvupt codec, fix jasmin tests
This commit is contained in:
Cristian Cezar Moisés
parent
cf70d4ecfe
commit
6651842748
63 changed files with 6577 additions and 342 deletions
1773
src/vv_ans.c
Normal file
1773
src/vv_ans.c
Normal file
File diff suppressed because it is too large
Load diff
BIN
src/vv_ans.o
Normal file
BIN
src/vv_ans.o
Normal file
Binary file not shown.
544
src/vv_decoder.c
Normal file
544
src/vv_decoder.c
Normal file
|
|
@ -0,0 +1,544 @@
|
|||
/* VaptVupt codec — originally Apache-2.0 by Cristian Cezar Moisés
|
||||
* Integrated into Zupt — MIT License
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés
|
||||
* SPDX-License-Identifier: MIT AND Apache-2.0
|
||||
*/
|
||||
#if !defined(_DEFAULT_SOURCE) && !defined(_GNU_SOURCE)
|
||||
#define _DEFAULT_SOURCE 1
|
||||
#endif
|
||||
/*
|
||||
* VaptVupt — Decoder v2 (Sprint 1)
|
||||
*
|
||||
* KEY CHANGES:
|
||||
* 1. AVX2 inline copies in hot loop (eliminates function-pointer dispatch)
|
||||
* 2. Early offset load → prefetch match source before literal copy
|
||||
* 3. Safe-zone: skip per-byte bounds checks while far from buffer ends
|
||||
* 4. Pattern-fill SIMD for overlapping match (offset < 16)
|
||||
* 5. General path as fallback for tail bytes + non-AVX2 platforms
|
||||
*/
|
||||
|
||||
#include "vaptvupt.h"
|
||||
#include "vv_huffman.h"
|
||||
#include "vv_ans.h"
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#if defined(__x86_64__) && defined(__AVX2__)
|
||||
#include <immintrin.h>
|
||||
#define VV_INLINE_AVX2 1
|
||||
#else
|
||||
#define VV_INLINE_AVX2 0
|
||||
#endif
|
||||
|
||||
/* ─── Cold varint reader (out-of-line to keep hot loop compact) ─── */
|
||||
__attribute__((noinline))
|
||||
static size_t read_ext_len(const uint8_t **pp, const uint8_t *end) {
|
||||
size_t val = 0;
|
||||
const uint8_t *p = *pp;
|
||||
while (p < end) {
|
||||
uint8_t b = *p++;
|
||||
val += b;
|
||||
if (b < 255) break;
|
||||
}
|
||||
*pp = p;
|
||||
return val;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* INLINE SIMD HELPERS (AVX2 only, compiled on x86-64 -mavx2)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
#if VV_INLINE_AVX2
|
||||
|
||||
static inline void wcopy16(uint8_t *d, const uint8_t *s) {
|
||||
_mm_storeu_si128((__m128i *)d, _mm_loadu_si128((const __m128i *)s));
|
||||
}
|
||||
static inline void wcopy32(uint8_t *d, const uint8_t *s) {
|
||||
_mm256_storeu_si256((__m256i *)d, _mm256_loadu_si256((const __m256i *)s));
|
||||
}
|
||||
|
||||
static inline void wcopy_n(uint8_t *d, const uint8_t *s, size_t n) {
|
||||
while (n >= 32) { wcopy32(d, s); d += 32; s += 32; n -= 32; }
|
||||
if (n >= 16) { wcopy16(d, s); d += 16; s += 16; n -= 16; }
|
||||
if (n > 0) wcopy16(d, s); /* safe over-copy in safe zone */
|
||||
}
|
||||
|
||||
/* Match copy with offset >= 32: 32-byte chunks, NO over-copy at tail */
|
||||
static inline void match_copy_32(uint8_t *d, const uint8_t *s, size_t n) {
|
||||
while (n >= 32) { wcopy32(d, s); d += 32; s += 32; n -= 32; }
|
||||
/* Exact tail: use 16-byte then memcpy to avoid corrupting future output */
|
||||
if (n >= 16) { wcopy16(d, s); d += 16; s += 16; n -= 16; }
|
||||
if (n > 0) __builtin_memcpy(d, s, n);
|
||||
}
|
||||
|
||||
/* Match copy with offset 16-31: 16-byte chunks, exact tail */
|
||||
static inline void match_copy_16(uint8_t *d, const uint8_t *s, size_t n) {
|
||||
while (n >= 16) { wcopy16(d, s); d += 16; s += 16; n -= 16; }
|
||||
if (n > 0) __builtin_memcpy(d, s, n);
|
||||
}
|
||||
|
||||
/* Match copy with offset 8-15: 8-byte register copy */
|
||||
static inline void match_copy_8(uint8_t *d, uint32_t off, size_t n) {
|
||||
const uint8_t *s = d - off;
|
||||
while (n >= 8) {
|
||||
uint64_t v; __builtin_memcpy(&v, s, 8);
|
||||
__builtin_memcpy(d, &v, 8);
|
||||
s += 8; d += 8; n -= 8;
|
||||
}
|
||||
while (n > 0) { *d++ = *s++; n--; }
|
||||
}
|
||||
|
||||
/* Match copy with offset 1-7: byte-by-byte (correct for all offsets)
|
||||
* The 16-byte pattern-fill approach FAILS for offsets that don't divide 16
|
||||
* (e.g., offset=3: after 16 bytes the pattern misaligns). Since offset<16
|
||||
* is only ~5% of matches, byte-by-byte is fast enough. */
|
||||
static inline void match_overlap(uint8_t *d, uint32_t off, size_t n) {
|
||||
const uint8_t *s = d - off;
|
||||
for (size_t i = 0; i < n; i++) d[i] = s[i];
|
||||
}
|
||||
|
||||
#endif /* VV_INLINE_AVX2 */
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE BLOCK — TWO-TIER HOT PATH
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static vv_error_t decode_block_tokens(
|
||||
const uint8_t *ip, size_t ip_len,
|
||||
uint8_t *op, size_t dst_cap, size_t *out_len, int off_bytes)
|
||||
{
|
||||
const uint8_t *const ip_end = ip + ip_len;
|
||||
uint8_t *const op_start = op;
|
||||
uint8_t *const op_end = op + dst_cap;
|
||||
|
||||
/* Safe zone boundaries: skip per-op bounds checks while inside.
|
||||
* Guard against underflow: if block is smaller than margin, skip fast path. */
|
||||
const uint8_t *const ip_safe = (ip_len > 24) ? (ip_end - 24) : ip;
|
||||
uint8_t *const op_safe = (dst_cap > 40) ? (op_end - 40) : op;
|
||||
|
||||
#if VV_INLINE_AVX2
|
||||
/* ═══ AVX2 FAST PATH ═══
|
||||
*
|
||||
* Runs while both ip and op are in the safe zone.
|
||||
* No per-byte bounds checks. Inline SIMD copies.
|
||||
* Prefetch match source at offset-load time.
|
||||
*
|
||||
* Per-sequence cost (common case, litlen≤14, matchlen≤18):
|
||||
* token load + decode: 3 cycles
|
||||
* early offset load: 4 cycles (overlapped)
|
||||
* prefetch: 0 cycles (non-blocking)
|
||||
* literal wcopy16: 5 cycles
|
||||
* match wcopy32: 5 cycles
|
||||
* pointer advance: 2 cycles
|
||||
* loop branch: 0 cycles (predicted)
|
||||
* ─────────────────────────────────
|
||||
* Total: ~10 cycles for ~12 output bytes → 1.2 bytes/cycle
|
||||
* At 4 GHz: ~4.8 GB/s (theoretical, real ~2-3 GB/s with cache)
|
||||
*/
|
||||
while (__builtin_expect(ip < ip_safe && op < op_safe, 1)) {
|
||||
|
||||
uint32_t token = *ip++;
|
||||
uint32_t ll = token >> 4;
|
||||
uint32_t mc = token & 0x0F;
|
||||
|
||||
/* Extended literal length → cold path */
|
||||
if (__builtin_expect(ll == 15, 0))
|
||||
ll += (uint32_t)read_ext_len(&ip, ip_end);
|
||||
|
||||
/* ── Early offset load + prefetch ──
|
||||
* The offset is at ip+ll (after the literal bytes).
|
||||
* Only do this for small litlen where we know ip+ll+2 is in the safe zone.
|
||||
* The safe-zone margin (24) guarantees: token(1) + lits(≤14) + offset(2) +
|
||||
* match_ext(≤6) + margin ≤ 24. */
|
||||
if (__builtin_expect(ll <= 14 && ip + ll + 2 <= ip_end, 1)) {
|
||||
uint16_t off_raw;
|
||||
__builtin_memcpy(&off_raw, ip + ll, 2);
|
||||
if (off_raw != 0 && off_raw <= (uint32_t)(op + ll - op_start))
|
||||
__builtin_prefetch(op + ll - off_raw, 0, 1);
|
||||
}
|
||||
|
||||
/* ── Literal copy (EXACT — no wild over-copy) ──
|
||||
* Wild-copy writes garbage past op+ll that corrupts positions
|
||||
* referenced by future matches. Must use exact-length copies.
|
||||
* memcpy compiles to optimal SIMD for small constant-like sizes. */
|
||||
if (ll > 0)
|
||||
__builtin_memcpy(op, ip, ll);
|
||||
ip += ll;
|
||||
op += ll;
|
||||
|
||||
/* ── End of block ── */
|
||||
if (__builtin_expect(ip >= ip_end, 0)) break;
|
||||
|
||||
/* ── Offset ── */
|
||||
uint32_t offset = (off_bytes == 3) ? ((uint32_t)ip[0] | ((uint32_t)ip[1]<<8) | ((uint32_t)ip[2]<<16)) : vv_read16(ip);
|
||||
ip += off_bytes;
|
||||
|
||||
/* ── Match length ── */
|
||||
uint32_t mlen = mc + VV_MIN_MATCH;
|
||||
if (__builtin_expect(mc == 15, 0))
|
||||
mlen += (uint32_t)read_ext_len(&ip, ip_end);
|
||||
|
||||
/* ── Validate offset ── */
|
||||
if (__builtin_expect(offset == 0 || offset > (uint32_t)(op - op_start), 0))
|
||||
return VV_ERR_CORRUPT;
|
||||
|
||||
/* ── Match copy (inline AVX2, tiered by offset) ── */
|
||||
if (__builtin_expect(offset >= 32, 1)) {
|
||||
match_copy_32(op, op - offset, mlen);
|
||||
} else if (offset >= 16) {
|
||||
match_copy_16(op, op - offset, mlen);
|
||||
} else if (offset >= 8) {
|
||||
match_copy_8(op, offset, mlen);
|
||||
} else {
|
||||
match_overlap(op, offset, mlen);
|
||||
}
|
||||
op += mlen;
|
||||
}
|
||||
#endif /* VV_INLINE_AVX2 */
|
||||
|
||||
/* ═══ GENERAL PATH (tail + non-AVX2) ═══ */
|
||||
while (ip < ip_end) {
|
||||
uint8_t token = *ip++;
|
||||
size_t ll = token >> 4;
|
||||
size_t mc = token & 0x0F;
|
||||
|
||||
if (__builtin_expect(ll == 15, 0))
|
||||
ll += read_ext_len(&ip, ip_end);
|
||||
|
||||
if (__builtin_expect(ip + ll > ip_end, 0)) return VV_ERR_CORRUPT;
|
||||
if (__builtin_expect(op + ll > op_end, 0)) return VV_ERR_OVERFLOW;
|
||||
|
||||
if (ll > 0) vv_copy_fast(op, ip, ll);
|
||||
ip += ll;
|
||||
op += ll;
|
||||
|
||||
if (ip >= ip_end) break;
|
||||
|
||||
if (__builtin_expect(ip + off_bytes > ip_end, 0)) return VV_ERR_CORRUPT;
|
||||
uint32_t offset = (off_bytes == 3) ? ((uint32_t)ip[0] | ((uint32_t)ip[1]<<8) | ((uint32_t)ip[2]<<16)) : vv_read16(ip);
|
||||
ip += off_bytes;
|
||||
|
||||
size_t mlen = mc + VV_MIN_MATCH;
|
||||
if (__builtin_expect(mc == 15, 0))
|
||||
mlen += read_ext_len(&ip, ip_end);
|
||||
|
||||
if (__builtin_expect(offset == 0 || offset > (uint32_t)(op - op_start), 0))
|
||||
return VV_ERR_CORRUPT;
|
||||
if (__builtin_expect(op + mlen > op_end, 0))
|
||||
return VV_ERR_OVERFLOW;
|
||||
|
||||
vv_copy_match(op, offset, mlen);
|
||||
op += mlen;
|
||||
}
|
||||
|
||||
*out_len = (size_t)(op - op_start);
|
||||
return VV_OK;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE STRIPPED TOKEN STREAM (for type 3 / Huffman blocks)
|
||||
*
|
||||
* Same as decode_block_tokens but literal bytes are NOT inline.
|
||||
* Instead, they come from a pre-decoded literal buffer.
|
||||
* Token format: same headers/offsets/extensions, just no literal bytes.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static vv_error_t decode_stripped_tokens(
|
||||
const uint8_t *ip, size_t ip_len, /* Stripped token stream */
|
||||
const uint8_t *lit_buf, size_t lit_len, /* Pre-decoded literals */
|
||||
uint8_t *op, size_t dst_cap, size_t *out_len, int off_bytes)
|
||||
{
|
||||
const uint8_t *ip_end = ip + ip_len;
|
||||
uint8_t *op_start = op;
|
||||
uint8_t *op_end = op + dst_cap;
|
||||
size_t lit_pos = 0;
|
||||
|
||||
while (ip < ip_end) {
|
||||
uint8_t token = *ip++;
|
||||
size_t ll = token >> 4;
|
||||
size_t mc = token & 0x0F;
|
||||
|
||||
/* Extended literal length */
|
||||
if (__builtin_expect(ll == 15, 0))
|
||||
ll += read_ext_len(&ip, ip_end);
|
||||
|
||||
/* Copy literals from pre-decoded buffer */
|
||||
if (__builtin_expect(lit_pos + ll > lit_len, 0)) return VV_ERR_CORRUPT;
|
||||
if (__builtin_expect(op + ll > op_end, 0)) return VV_ERR_OVERFLOW;
|
||||
if (ll > 0) {
|
||||
memcpy(op, lit_buf + lit_pos, ll);
|
||||
lit_pos += ll;
|
||||
}
|
||||
op += ll;
|
||||
|
||||
/* End of block: last sequence has no match */
|
||||
if (ip >= ip_end) break;
|
||||
|
||||
/* Offset */
|
||||
if (__builtin_expect(ip + off_bytes > ip_end, 0)) return VV_ERR_CORRUPT;
|
||||
uint32_t offset = (off_bytes == 3) ? ((uint32_t)ip[0] | ((uint32_t)ip[1]<<8) | ((uint32_t)ip[2]<<16)) : vv_read16(ip);
|
||||
ip += off_bytes;
|
||||
|
||||
/* Match length */
|
||||
size_t mlen = mc + VV_MIN_MATCH;
|
||||
if (__builtin_expect(mc == 15, 0))
|
||||
mlen += read_ext_len(&ip, ip_end);
|
||||
|
||||
/* Validate */
|
||||
if (__builtin_expect(offset == 0 || offset > (uint32_t)(op - op_start), 0))
|
||||
return VV_ERR_CORRUPT;
|
||||
if (__builtin_expect(op + mlen > op_end, 0))
|
||||
return VV_ERR_OVERFLOW;
|
||||
|
||||
/* Match copy */
|
||||
vv_copy_match(op, offset, mlen);
|
||||
op += mlen;
|
||||
}
|
||||
|
||||
*out_len = (size_t)(op - op_start);
|
||||
return VV_OK;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE TYPE 3 BLOCK (Huffman-compressed literals)
|
||||
*
|
||||
* Layout: [2B lit_count] [2B huff_section_size] [huff_data] [stripped_tokens]
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static vv_error_t decode_block_huffman(
|
||||
const uint8_t *data, size_t data_len,
|
||||
uint8_t *output, size_t decomp_size, size_t *out_len, int off_bytes)
|
||||
{
|
||||
if (data_len < 4) return VV_ERR_CORRUPT;
|
||||
|
||||
/* Read lit_count and huff_section_size */
|
||||
uint16_t lit_count = (uint16_t)(data[0] | (data[1] << 8));
|
||||
uint16_t huff_sz = (uint16_t)(data[2] | (data[3] << 8));
|
||||
|
||||
if (4 + (size_t)huff_sz > data_len) return VV_ERR_CORRUPT;
|
||||
|
||||
/* Huffman-decode all literals */
|
||||
uint8_t *lit_buf = (uint8_t *)malloc((size_t)lit_count + 16);
|
||||
if (!lit_buf) return VV_ERR_NOMEM;
|
||||
|
||||
size_t huff_consumed = 0;
|
||||
vvh_error_t herr = vvh_decode(data + 4, huff_sz, lit_buf, lit_count,
|
||||
lit_count, &huff_consumed);
|
||||
if (herr != VVH_OK) { free(lit_buf); return VV_ERR_CORRUPT; }
|
||||
|
||||
/* Parse stripped token stream */
|
||||
const uint8_t *tokens = data + 4 + huff_sz;
|
||||
size_t tok_len = data_len - 4 - huff_sz;
|
||||
|
||||
vv_error_t err = decode_stripped_tokens(tokens, tok_len,
|
||||
lit_buf, lit_count,
|
||||
output, decomp_size, out_len, off_bytes);
|
||||
free(lit_buf);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE TYPE 3 BLOCK (ANS-compressed literals, v0.5+)
|
||||
*
|
||||
* Layout: [2B lit_count] [2B ans_section_size] [ans_data] [stripped_tokens]
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static vv_error_t decode_block_ans(
|
||||
const uint8_t *data, size_t data_len,
|
||||
uint8_t *output, size_t decomp_size, size_t *out_len, int off_bytes)
|
||||
{
|
||||
if (data_len < 4) return VV_ERR_CORRUPT;
|
||||
|
||||
uint16_t lit_count = (uint16_t)(data[0] | (data[1] << 8));
|
||||
uint16_t ans_sz = (uint16_t)(data[2] | (data[3] << 8));
|
||||
|
||||
if (4 + (size_t)ans_sz > data_len) return VV_ERR_CORRUPT;
|
||||
|
||||
/* ANS-decode all literals */
|
||||
uint8_t *lit_buf = (uint8_t *)malloc((size_t)lit_count + 16);
|
||||
if (!lit_buf) return VV_ERR_NOMEM;
|
||||
|
||||
size_t ans_consumed = 0;
|
||||
vva_error_t aerr = vva_decode(data + 4, ans_sz, lit_buf, lit_count,
|
||||
lit_count, &ans_consumed);
|
||||
if (aerr != VVA_OK) { free(lit_buf); return VV_ERR_CORRUPT; }
|
||||
|
||||
/* Parse stripped token stream */
|
||||
const uint8_t *tokens = data + 4 + ans_sz;
|
||||
size_t tok_len = data_len - 4 - ans_sz;
|
||||
|
||||
vv_error_t err = decode_stripped_tokens(tokens, tok_len,
|
||||
lit_buf, lit_count,
|
||||
output, decomp_size, out_len, off_bytes);
|
||||
free(lit_buf);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE TYPE 3 BLOCK, TAG 'I' (4-way interleaved ANS, v0.6+)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static vv_error_t decode_block_ans4(
|
||||
const uint8_t *data, size_t data_len,
|
||||
uint8_t *output, size_t decomp_size, size_t *out_len, int off_bytes)
|
||||
{
|
||||
if (data_len < 4) return VV_ERR_CORRUPT;
|
||||
|
||||
uint16_t lit_count = (uint16_t)(data[0] | (data[1] << 8));
|
||||
uint16_t ans_sz = (uint16_t)(data[2] | (data[3] << 8));
|
||||
|
||||
if (4 + (size_t)ans_sz > data_len) return VV_ERR_CORRUPT;
|
||||
|
||||
uint8_t *lit_buf = (uint8_t *)malloc((size_t)lit_count + 16);
|
||||
if (!lit_buf) return VV_ERR_NOMEM;
|
||||
|
||||
size_t ans_consumed = 0;
|
||||
vva_error_t aerr = vva_decode4(data + 4, ans_sz, lit_buf, lit_count,
|
||||
lit_count, &ans_consumed);
|
||||
if (aerr != VVA_OK) { free(lit_buf); return VV_ERR_CORRUPT; }
|
||||
|
||||
const uint8_t *tokens = data + 4 + ans_sz;
|
||||
size_t tok_len = data_len - 4 - ans_sz;
|
||||
|
||||
vv_error_t err = decode_stripped_tokens(tokens, tok_len,
|
||||
lit_buf, lit_count,
|
||||
output, decomp_size, out_len, off_bytes);
|
||||
free(lit_buf);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE TYPE 3 BLOCK, TAG 'C' (order-1 context model ANS, v0.7+)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static vv_error_t decode_block_ctx(
|
||||
const uint8_t *data, size_t data_len,
|
||||
uint8_t *output, size_t decomp_size, size_t *out_len, int off_bytes)
|
||||
{
|
||||
if (data_len < 4) return VV_ERR_CORRUPT;
|
||||
|
||||
uint16_t lit_count = (uint16_t)(data[0] | (data[1] << 8));
|
||||
uint16_t ans_sz = (uint16_t)(data[2] | (data[3] << 8));
|
||||
|
||||
if (4 + (size_t)ans_sz > data_len) return VV_ERR_CORRUPT;
|
||||
|
||||
uint8_t *lit_buf = (uint8_t *)malloc((size_t)lit_count + 16);
|
||||
if (!lit_buf) return VV_ERR_NOMEM;
|
||||
|
||||
size_t ans_consumed = 0;
|
||||
vva_error_t aerr = vva_decode_ctx(data + 4, ans_sz, lit_buf, lit_count,
|
||||
lit_count, &ans_consumed);
|
||||
if (aerr != VVA_OK) { free(lit_buf); return VV_ERR_CORRUPT; }
|
||||
|
||||
const uint8_t *tokens = data + 4 + ans_sz;
|
||||
size_t tok_len = data_len - 4 - ans_sz;
|
||||
|
||||
vv_error_t err = decode_stripped_tokens(tokens, tok_len,
|
||||
lit_buf, lit_count,
|
||||
output, decomp_size, out_len, off_bytes);
|
||||
free(lit_buf);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* PUBLIC API: DECOMPRESS
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
int64_t vv_decompress(const uint8_t *src, size_t src_len,
|
||||
uint8_t *dst, size_t dst_cap) {
|
||||
if (!src || !dst) return VV_ERR_PARAM;
|
||||
if (src_len < sizeof(vv_frame_header_t)) return VV_ERR_CORRUPT;
|
||||
|
||||
const uint8_t *ip = src;
|
||||
const uint8_t *ip_end = src + src_len;
|
||||
|
||||
vv_frame_header_t fh;
|
||||
memcpy(&fh, ip, sizeof(fh));
|
||||
ip += sizeof(fh);
|
||||
|
||||
if (fh.magic != VV_MAGIC) return VV_ERR_BAD_MAGIC;
|
||||
if (fh.version != 1) return VV_ERR_CORRUPT;
|
||||
|
||||
int has_checksum = (fh.flags & 1);
|
||||
int off_bytes = (fh.window_log > 16) ? 3 : 2;
|
||||
uint8_t *op = dst;
|
||||
|
||||
for (;;) {
|
||||
if (ip + 4 > ip_end) return VV_ERR_CORRUPT;
|
||||
uint32_t bh_packed;
|
||||
memcpy(&bh_packed, ip, 4); ip += 4;
|
||||
|
||||
vv_block_type_t btype = vv_bh_type(bh_packed);
|
||||
int is_last = vv_bh_last(bh_packed);
|
||||
uint32_t dsz = vv_bh_size(bh_packed);
|
||||
|
||||
if (dsz > VV_MAX_BLOCK_SIZE) return VV_ERR_OVERFLOW;
|
||||
if ((size_t)(op - dst) + dsz > dst_cap) return VV_ERR_OVERFLOW;
|
||||
|
||||
if (btype == VV_BLOCK_RAW) {
|
||||
if (ip + dsz > ip_end) return VV_ERR_CORRUPT;
|
||||
memcpy(op, ip, dsz); ip += dsz; op += dsz;
|
||||
} else if (btype == VV_BLOCK_RLE) {
|
||||
if (ip >= ip_end) return VV_ERR_CORRUPT;
|
||||
memset(op, *ip++, dsz); op += dsz;
|
||||
} else if (btype == VV_BLOCK_COMPRESSED) {
|
||||
if (ip + 3 > ip_end) return VV_ERR_CORRUPT;
|
||||
uint32_t csz = (uint32_t)ip[0] | ((uint32_t)ip[1] << 8) | ((uint32_t)ip[2] << 16);
|
||||
ip += 3;
|
||||
if (ip + csz > ip_end) return VV_ERR_CORRUPT;
|
||||
|
||||
size_t actual = 0;
|
||||
vv_error_t err = decode_block_tokens(ip, csz, op, dsz, &actual, off_bytes);
|
||||
if (err != VV_OK) return err;
|
||||
if (actual != dsz) return VV_ERR_CORRUPT;
|
||||
ip += csz; op += dsz;
|
||||
} else if (btype == VV_BLOCK_ENTROPY) {
|
||||
/* Type 3: Entropy-coded literals + stripped LZ tokens
|
||||
* First byte after comp_size is the entropy tag:
|
||||
* VV_ENTROPY_ANS ('A') or VV_ENTROPY_HUFFMAN ('H') */
|
||||
if (ip + 3 > ip_end) return VV_ERR_CORRUPT;
|
||||
uint32_t csz = (uint32_t)ip[0] | ((uint32_t)ip[1] << 8) | ((uint32_t)ip[2] << 16);
|
||||
ip += 3;
|
||||
if (csz < 1 || ip + csz > ip_end) return VV_ERR_CORRUPT;
|
||||
|
||||
uint8_t tag = ip[0];
|
||||
const uint8_t *bdata = ip + 1;
|
||||
size_t bdata_len = csz - 1;
|
||||
size_t actual = 0;
|
||||
vv_error_t err;
|
||||
|
||||
if (tag == VV_ENTROPY_ANS) {
|
||||
err = decode_block_ans(bdata, bdata_len, op, dsz, &actual, off_bytes);
|
||||
} else if (tag == VV_ENTROPY_ANS4) {
|
||||
err = decode_block_ans4(bdata, bdata_len, op, dsz, &actual, off_bytes);
|
||||
} else if (tag == VV_ENTROPY_CTX) {
|
||||
err = decode_block_ctx(bdata, bdata_len, op, dsz, &actual, off_bytes);
|
||||
} else if (tag == VV_ENTROPY_SEQ) {
|
||||
/* Sequence coding: ANS on literals + ML + OF */
|
||||
err = vva_decode_sequences(bdata, bdata_len, op, dsz, &actual);
|
||||
if (err != VV_OK) err = VV_ERR_CORRUPT;
|
||||
} else if (tag == VV_ENTROPY_HUFFMAN) {
|
||||
err = decode_block_huffman(bdata, bdata_len, op, dsz, &actual, off_bytes);
|
||||
} else {
|
||||
return VV_ERR_CORRUPT;
|
||||
}
|
||||
if (err != VV_OK) return err;
|
||||
if (actual != dsz) return VV_ERR_CORRUPT;
|
||||
ip += csz; op += dsz;
|
||||
} else {
|
||||
return VV_ERR_CORRUPT;
|
||||
}
|
||||
if (is_last) break;
|
||||
}
|
||||
|
||||
if (has_checksum) {
|
||||
if (ip + sizeof(vv_frame_footer_t) > ip_end) return VV_ERR_CORRUPT;
|
||||
vv_frame_footer_t ff;
|
||||
memcpy(&ff, ip, sizeof(ff));
|
||||
if (ff.footer_magic != 0x56564E44u) return VV_ERR_CORRUPT;
|
||||
uint64_t computed = vv_xxh64(dst, (size_t)(op - dst), 0);
|
||||
if (computed != ff.checksum) return VV_ERR_CORRUPT;
|
||||
}
|
||||
|
||||
return (int64_t)(op - dst);
|
||||
}
|
||||
BIN
src/vv_decoder.o
Normal file
BIN
src/vv_decoder.o
Normal file
Binary file not shown.
627
src/vv_encoder.c
Normal file
627
src/vv_encoder.c
Normal file
|
|
@ -0,0 +1,627 @@
|
|||
/* VaptVupt codec — originally Apache-2.0 by Cristian Cezar Moisés
|
||||
* Integrated into Zupt — MIT License
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés
|
||||
* SPDX-License-Identifier: MIT AND Apache-2.0
|
||||
*/
|
||||
#if !defined(_DEFAULT_SOURCE) && !defined(_GNU_SOURCE)
|
||||
#define _DEFAULT_SOURCE 1
|
||||
#endif
|
||||
/*
|
||||
* VaptVupt — Encoder v2 (Sprint 1)
|
||||
*
|
||||
* KEY CHANGES:
|
||||
* 1. 5-byte multiply-shift hash (fewer collisions than 4-byte)
|
||||
* 2. Rep-match: check 3 recent offsets before hash probe (30% hit rate)
|
||||
* 3. Match-skip: after long matches, only insert boundary positions
|
||||
* 4. AVX2 match extension: 32 bytes/cycle vs 1 byte/cycle scalar
|
||||
* 5. Lazy-2 parsing for balanced mode (check pos+1 AND pos+2)
|
||||
* 6. Extreme mode: deeper chains (256) + lazy-2
|
||||
*/
|
||||
|
||||
#include "vaptvupt.h"
|
||||
#include "vv_huffman.h"
|
||||
#include "vv_ans.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#if defined(__x86_64__) && defined(__AVX2__)
|
||||
#include <immintrin.h>
|
||||
#define VV_ENC_AVX2 1
|
||||
#else
|
||||
#define VV_ENC_AVX2 0
|
||||
#endif
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* VARINT WRITER
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static inline size_t write_varint(uint8_t *dst, size_t val) {
|
||||
size_t n = 0;
|
||||
while (val >= 255) { dst[n++] = 255; val -= 255; }
|
||||
dst[n++] = (uint8_t)val;
|
||||
return n;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* IMPROVED HASH: 5-byte multiply-shift (safe read pattern)
|
||||
*
|
||||
* Reads exactly 5 bytes using 4+1 to prevent compiler from
|
||||
* widening to an 8-byte load that over-reads the buffer.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static inline uint32_t hash5(const uint8_t *p) {
|
||||
uint32_t lo;
|
||||
__builtin_memcpy(&lo, p, 4);
|
||||
uint64_t v = (uint64_t)lo | ((uint64_t)p[4] << 32);
|
||||
/* Shift by (64 - HC_BITS) to get the top HC_BITS of the product */
|
||||
return (uint32_t)((v * 889523592379ULL) >> (64 - VV_HC_BITS));
|
||||
}
|
||||
|
||||
/* 4-byte hash for positions near end of buffer */
|
||||
static inline uint32_t hash4(const uint8_t *p) {
|
||||
uint32_t v;
|
||||
__builtin_memcpy(&v, p, 4);
|
||||
return (v * 2654435761u) >> (32 - VV_HC_BITS);
|
||||
}
|
||||
|
||||
/* Safe hash: picks 5-byte or 4-byte depending on remaining bytes */
|
||||
static inline uint32_t hash_safe(const uint8_t *p, int32_t remain) {
|
||||
return (remain >= 5) ? hash5(p) : hash4(p);
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* AVX2 MATCH EXTENSION
|
||||
*
|
||||
* Compare 32 bytes at a time. Returns total match length.
|
||||
* ~8× faster than byte-by-byte on data with long matches.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static inline int32_t extend_match(const uint8_t *a, const uint8_t *b,
|
||||
int32_t max_len) {
|
||||
int32_t len = 0;
|
||||
#if VV_ENC_AVX2
|
||||
while (len + 32 <= max_len) {
|
||||
__m256i va = _mm256_loadu_si256((const __m256i *)(a + len));
|
||||
__m256i vb = _mm256_loadu_si256((const __m256i *)(b + len));
|
||||
__m256i eq = _mm256_cmpeq_epi8(va, vb);
|
||||
uint32_t mask = ~(uint32_t)_mm256_movemask_epi8(eq);
|
||||
if (mask) return len + (int32_t)__builtin_ctz(mask);
|
||||
len += 32;
|
||||
}
|
||||
#endif
|
||||
while (len < max_len && a[len] == b[len]) len++;
|
||||
return len;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* MATCHER: hash chain with 5-byte hash + rep-match
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
typedef struct {
|
||||
int32_t *table; /* Hash table: VV_HC_SIZE entries, heap-allocated */
|
||||
int32_t *chain; /* Chain array: window_size entries */
|
||||
uint32_t chain_mask;
|
||||
uint32_t chain_depth;
|
||||
uint32_t rep[3]; /* 3 most recent match offsets */
|
||||
uint8_t wlog; /* Window log: controls max offset distance */
|
||||
} matcher_t;
|
||||
|
||||
static void matcher_init(matcher_t *m, uint32_t window_log, uint32_t depth) {
|
||||
uint32_t wsz = 1u << window_log;
|
||||
m->table = (int32_t *)malloc(VV_HC_SIZE * sizeof(int32_t));
|
||||
m->chain = (int32_t *)malloc(wsz * sizeof(int32_t));
|
||||
memset(m->table, 0xFF, VV_HC_SIZE * sizeof(int32_t)); /* -1 */
|
||||
memset(m->chain, 0xFF, wsz * sizeof(int32_t)); /* -1 */
|
||||
m->chain_mask = wsz - 1;
|
||||
m->chain_depth = depth;
|
||||
m->rep[0] = m->rep[1] = m->rep[2] = 0;
|
||||
m->wlog = (uint8_t)window_log;
|
||||
}
|
||||
|
||||
static void matcher_free(matcher_t *m) {
|
||||
free(m->table); m->table = NULL;
|
||||
free(m->chain); m->chain = NULL;
|
||||
}
|
||||
|
||||
static inline void matcher_insert(matcher_t *m, const uint8_t *data,
|
||||
int32_t pos, int32_t end) {
|
||||
if (pos + 4 > end) return;
|
||||
uint32_t h = hash_safe(data + pos, end - pos);
|
||||
m->chain[pos & m->chain_mask] = m->table[h];
|
||||
m->table[h] = pos;
|
||||
}
|
||||
|
||||
/* ─── Rep-match check: O(1), checked BEFORE hash probe ─── */
|
||||
static inline int32_t try_rep_match(const matcher_t *m, const uint8_t *data,
|
||||
int32_t pos, int32_t end,
|
||||
int32_t *rep_idx) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
uint32_t d = m->rep[i];
|
||||
if (d == 0 || (uint32_t)pos < d) continue;
|
||||
int32_t ref = pos - (int32_t)d;
|
||||
/* Quick 4-byte check */
|
||||
uint32_t a, b;
|
||||
__builtin_memcpy(&a, data + pos, 4);
|
||||
__builtin_memcpy(&b, data + ref, 4);
|
||||
if (a == b) {
|
||||
int32_t max = end - pos;
|
||||
if (max > VV_MAX_MATCH) max = VV_MAX_MATCH;
|
||||
int32_t len = 4 + extend_match(data + pos + 4, data + ref + 4, max - 4);
|
||||
*rep_idx = i;
|
||||
return len;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ─── Hash chain match: uses 5-byte hash, searches up to chain_depth ─── */
|
||||
static int32_t chain_match(const matcher_t *m, const uint8_t *data,
|
||||
int32_t pos, int32_t end, int32_t *best_off) {
|
||||
if (pos + 4 > end) return 0;
|
||||
uint32_t h = hash_safe(data + pos, end - pos);
|
||||
int32_t ref = m->table[h];
|
||||
int32_t best_len = 0;
|
||||
*best_off = 0;
|
||||
|
||||
uint32_t depth = m->chain_depth;
|
||||
/* PERF: match distance limit derived from window log.
|
||||
* wlog=16 → 65535, wlog=20 → 1048575, wlog=22 → 4194303. */
|
||||
int32_t max_dist = (int32_t)((1u << m->wlog) - 1);
|
||||
int32_t limit = pos - max_dist;
|
||||
if (limit < 0) limit = 0;
|
||||
|
||||
while (ref >= 0 && ref >= limit && ref < pos && depth-- > 0) {
|
||||
/* Quick 4-byte prefix check */
|
||||
uint32_t a, b;
|
||||
__builtin_memcpy(&a, data + pos, 4);
|
||||
__builtin_memcpy(&b, data + ref, 4);
|
||||
if (a == b) {
|
||||
int32_t max = end - pos;
|
||||
if (max > VV_MAX_MATCH) max = VV_MAX_MATCH;
|
||||
int32_t len = 4 + extend_match(data + pos + 4, data + ref + 4, max - 4);
|
||||
if (len > best_len) {
|
||||
best_len = len;
|
||||
*best_off = pos - ref;
|
||||
if (len >= 256) break; /* good enough */
|
||||
}
|
||||
}
|
||||
ref = m->chain[ref & m->chain_mask];
|
||||
}
|
||||
return best_len;
|
||||
}
|
||||
|
||||
/* Update rep offsets (push new offset, shift others down) */
|
||||
static inline void update_rep(matcher_t *m, uint32_t offset) {
|
||||
if (offset == m->rep[0]) return;
|
||||
m->rep[2] = m->rep[1];
|
||||
m->rep[1] = m->rep[0];
|
||||
m->rep[0] = offset;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* EMIT TOKEN (unchanged from v0.1)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static size_t emit_seq(uint8_t *dst, const uint8_t *lits,
|
||||
size_t ll, size_t ml, uint32_t off, int off_bytes) {
|
||||
uint8_t *op = dst;
|
||||
|
||||
uint8_t ll_f = (ll >= 15) ? 15 : (uint8_t)ll;
|
||||
uint8_t ml_f;
|
||||
if (ml == 0) { ml_f = 0; }
|
||||
else { size_t v = ml - VV_MIN_MATCH; ml_f = (v >= 15) ? 15 : (uint8_t)v; }
|
||||
|
||||
*op++ = (ll_f << 4) | ml_f;
|
||||
|
||||
if (ll >= 15) op += write_varint(op, ll - 15);
|
||||
if (ll > 0) { memcpy(op, lits, ll); op += ll; }
|
||||
|
||||
if (ml > 0) {
|
||||
/* PERF: 2-byte offset for wlog≤16, 3-byte for wlog>16 */
|
||||
if (off_bytes == 3) {
|
||||
op[0] = (uint8_t)(off);
|
||||
op[1] = (uint8_t)(off >> 8);
|
||||
op[2] = (uint8_t)(off >> 16);
|
||||
op += 3;
|
||||
} else {
|
||||
vv_write16(op, (uint16_t)off); op += 2;
|
||||
}
|
||||
if (ml - VV_MIN_MATCH >= 15)
|
||||
op += write_varint(op, ml - VV_MIN_MATCH - 15);
|
||||
}
|
||||
return (size_t)(op - dst);
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* COMPRESS BLOCK: greedy / lazy / lazy-2
|
||||
*
|
||||
* Match-skip heuristic: after a match of length ≥ 16, only insert
|
||||
* the last 3 positions into the hash chain. The interior positions
|
||||
* are inside the match and won't be needed. This saves O(match_len)
|
||||
* hash insertions, speeding up compression by 15-25% at L3+.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static size_t compress_block(const uint8_t *src, size_t src_len,
|
||||
uint8_t *dst, size_t dst_cap,
|
||||
matcher_t *m, vv_mode_t mode) {
|
||||
uint8_t *op = dst;
|
||||
int32_t pos = 0;
|
||||
int32_t end = (int32_t)src_len;
|
||||
const uint8_t *lit_start = src;
|
||||
int off_bytes = (m->wlog > 16) ? 3 : 2;
|
||||
|
||||
while (pos < end - (int32_t)VV_MIN_MATCH) {
|
||||
int32_t mlen = 0, moff = 0;
|
||||
|
||||
/* ─── Step 1: Try rep-match (free, no hash lookup) ─── */
|
||||
int32_t rep_idx = -1;
|
||||
int32_t rep_len = try_rep_match(m, src, pos, end, &rep_idx);
|
||||
|
||||
if (rep_len >= (int32_t)VV_MIN_MATCH) {
|
||||
mlen = rep_len;
|
||||
moff = (int32_t)m->rep[rep_idx];
|
||||
}
|
||||
|
||||
/* ─── Step 2: Hash chain match (only if rep didn't find a long one) ─── */
|
||||
if (mlen < 8) {
|
||||
int32_t chain_off = 0;
|
||||
int32_t chain_len = chain_match(m, src, pos, end, &chain_off);
|
||||
if (chain_len > mlen) {
|
||||
mlen = chain_len;
|
||||
moff = chain_off;
|
||||
rep_idx = -1; /* not a rep match */
|
||||
}
|
||||
}
|
||||
|
||||
/* ─── Step 3: Lazy evaluation (balanced + extreme) ─── */
|
||||
if (mode >= VV_MODE_BALANCED && mlen >= (int32_t)VV_MIN_MATCH &&
|
||||
pos + 1 < end - (int32_t)VV_MIN_MATCH) {
|
||||
/* Check pos+1 */
|
||||
matcher_insert(m, src, pos, end);
|
||||
int32_t noff = 0;
|
||||
int32_t nlen = chain_match(m, src, pos + 1, end, &noff);
|
||||
|
||||
/* Also check rep at pos+1 */
|
||||
int32_t nri = -1;
|
||||
int32_t nrl = try_rep_match(m, src, pos + 1, end, &nri);
|
||||
if (nrl > nlen) { nlen = nrl; noff = (int32_t)m->rep[nri]; }
|
||||
|
||||
if (nlen > mlen + 1) {
|
||||
/* pos+1 is significantly better: emit literal, shift */
|
||||
pos++;
|
||||
mlen = nlen; moff = noff;
|
||||
|
||||
/* Lazy-2: also check pos+2 (extreme mode) */
|
||||
if (mode >= VV_MODE_EXTREME && pos + 1 < end - (int32_t)VV_MIN_MATCH) {
|
||||
matcher_insert(m, src, pos, end);
|
||||
int32_t n2off = 0;
|
||||
int32_t n2len = chain_match(m, src, pos + 1, end, &n2off);
|
||||
int32_t n2ri = -1;
|
||||
int32_t n2rl = try_rep_match(m, src, pos + 1, end, &n2ri);
|
||||
if (n2rl > n2len) { n2len = n2rl; n2off = (int32_t)m->rep[n2ri]; }
|
||||
if (n2len > mlen + 1) {
|
||||
pos++;
|
||||
mlen = n2len; moff = n2off;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ─── Step 4: Emit sequence or literal ─── */
|
||||
if (mlen >= (int32_t)VV_MIN_MATCH) {
|
||||
size_t ll = (size_t)(src + pos - lit_start);
|
||||
size_t needed = 1 + (ll >= 15 ? ll / 255 + 2 : 0)
|
||||
+ ll + 2 + ((size_t)mlen / 255 + 2);
|
||||
if ((size_t)(op - dst) + needed > dst_cap) return 0;
|
||||
|
||||
op += emit_seq(op, lit_start, ll, (size_t)mlen, (uint32_t)moff, off_bytes);
|
||||
|
||||
/* ─── Hash insertion with skip heuristic ─── */
|
||||
if (mlen >= 16) {
|
||||
/* Long match: only insert boundary positions */
|
||||
for (int32_t j = pos; j < pos + 3 && j < end - 4; j++)
|
||||
matcher_insert(m, src, j, end);
|
||||
for (int32_t j = pos + mlen - 3; j < pos + mlen && j < end - 4; j++)
|
||||
matcher_insert(m, src, j, end);
|
||||
} else {
|
||||
/* Short match: insert all positions */
|
||||
for (int32_t j = pos; j < pos + mlen && j < end - 4; j++)
|
||||
matcher_insert(m, src, j, end);
|
||||
}
|
||||
|
||||
update_rep(m, (uint32_t)moff);
|
||||
pos += mlen;
|
||||
lit_start = src + pos;
|
||||
} else {
|
||||
matcher_insert(m, src, pos, end);
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
|
||||
/* ─── Trailing literals ─── */
|
||||
{
|
||||
size_t ll = (size_t)(src + end - lit_start);
|
||||
size_t needed = 1 + (ll >= 15 ? ll / 255 + 2 : 0) + ll;
|
||||
if ((size_t)(op - dst) + needed > dst_cap) return 0;
|
||||
op += emit_seq(op, lit_start, ll, 0, 0, off_bytes);
|
||||
}
|
||||
|
||||
return (size_t)(op - dst);
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* EXTRACT LITERALS FROM TOKEN STREAM
|
||||
*
|
||||
* Walks a type-1 LZ token stream, copies all literal bytes into
|
||||
* lit_buf and produces a "stripped" token stream (same format but
|
||||
* with literal bytes removed) in stripped_buf.
|
||||
*
|
||||
* Returns the number of literals extracted, or 0 on error.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static size_t extract_literals(
|
||||
const uint8_t *tokens, size_t tok_len,
|
||||
uint8_t *lit_buf, size_t lit_cap,
|
||||
uint8_t *stripped_buf, size_t *stripped_len, int off_bytes)
|
||||
{
|
||||
const uint8_t *tp = tokens;
|
||||
const uint8_t *tp_end = tokens + tok_len;
|
||||
uint8_t *sp = stripped_buf;
|
||||
size_t total_lits = 0;
|
||||
|
||||
while (tp < tp_end) {
|
||||
uint8_t token = *tp++;
|
||||
*sp++ = token; /* Copy token byte to stripped stream */
|
||||
|
||||
size_t ll = token >> 4;
|
||||
size_t mc = token & 0x0F;
|
||||
|
||||
/* Extended literal length */
|
||||
if (ll == 15) {
|
||||
size_t ext = 0;
|
||||
do {
|
||||
if (tp >= tp_end) return 0;
|
||||
uint8_t b = *tp++;
|
||||
*sp++ = b; /* Copy extension byte */
|
||||
ext += b;
|
||||
if (b < 255) break;
|
||||
} while (tp < tp_end);
|
||||
ll += ext;
|
||||
}
|
||||
|
||||
/* Literal bytes: copy to lit_buf, do NOT copy to stripped stream */
|
||||
if (tp + ll > tp_end) return 0;
|
||||
if (total_lits + ll > lit_cap) return 0;
|
||||
memcpy(lit_buf + total_lits, tp, ll);
|
||||
total_lits += ll;
|
||||
tp += ll;
|
||||
|
||||
/* End of block: no more data = last sequence (no match) */
|
||||
if (tp >= tp_end) break;
|
||||
|
||||
/* Offset: 2 or 3 bytes, copy to stripped stream */
|
||||
if (tp + off_bytes > tp_end) return 0;
|
||||
for (int i = 0; i < off_bytes; i++) *sp++ = *tp++;
|
||||
|
||||
/* Extended match length */
|
||||
if (mc == 15) {
|
||||
size_t ext = 0;
|
||||
do {
|
||||
if (tp >= tp_end) return 0;
|
||||
uint8_t b = *tp++;
|
||||
*sp++ = b;
|
||||
ext += b;
|
||||
if (b < 255) break;
|
||||
} while (tp < tp_end);
|
||||
(void)ext;
|
||||
}
|
||||
}
|
||||
|
||||
*stripped_len = (size_t)(sp - stripped_buf);
|
||||
return total_lits;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* PUBLIC API: COMPRESS
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
size_t vv_compress_bound(size_t src_len) {
|
||||
return src_len + src_len / 255 + 256
|
||||
+ sizeof(vv_frame_header_t) + sizeof(vv_frame_footer_t);
|
||||
}
|
||||
|
||||
int64_t vv_compress(const uint8_t *src, size_t src_len,
|
||||
uint8_t *dst, size_t dst_cap,
|
||||
const vv_options_t *opts) {
|
||||
if (!src || !dst || !opts) return VV_ERR_PARAM;
|
||||
if (dst_cap < sizeof(vv_frame_header_t) + sizeof(vv_frame_footer_t) + 16)
|
||||
return VV_ERR_OVERFLOW;
|
||||
|
||||
uint8_t wlog = opts->window_log;
|
||||
uint32_t depth;
|
||||
if (wlog == 0) {
|
||||
switch (opts->mode) {
|
||||
case VV_MODE_ULTRA_FAST: wlog = 16; break;
|
||||
case VV_MODE_BALANCED: wlog = 16; break;
|
||||
case VV_MODE_EXTREME: wlog = 16; break;
|
||||
/* TRADEOFF: wlog=16 default avoids 3-byte offset overhead on small data.
|
||||
* Users can set opts.window_log=20 (1MB) or 22 (4MB) for large files
|
||||
* with long-range patterns. Zupt sets wlog=20 for backup chunks >1MB. */
|
||||
}
|
||||
}
|
||||
switch (opts->mode) {
|
||||
case VV_MODE_ULTRA_FAST: depth = 4; break;
|
||||
case VV_MODE_BALANCED: depth = 48; break;
|
||||
case VV_MODE_EXTREME: depth = 256; break;
|
||||
default: depth = 48;
|
||||
}
|
||||
|
||||
/* Frame header */
|
||||
uint8_t *op = dst;
|
||||
vv_frame_header_t fh;
|
||||
memset(&fh, 0, sizeof(fh));
|
||||
fh.magic = VV_MAGIC;
|
||||
fh.version = 1;
|
||||
fh.flags = opts->checksum ? 1 : 0;
|
||||
fh.mode_hint = (uint8_t)opts->mode;
|
||||
fh.window_log = wlog;
|
||||
fh.content_size = (uint64_t)src_len;
|
||||
memcpy(op, &fh, sizeof(fh)); op += sizeof(fh);
|
||||
|
||||
/* Matcher */
|
||||
matcher_t m;
|
||||
matcher_init(&m, wlog, depth);
|
||||
|
||||
/* Temp buffer */
|
||||
size_t tcap = VV_MAX_BLOCK_SIZE + VV_MAX_BLOCK_SIZE / 255 + 1024;
|
||||
uint8_t *tmp = (uint8_t *)malloc(tcap);
|
||||
if (!tmp) { matcher_free(&m); return VV_ERR_NOMEM; }
|
||||
|
||||
/* Additional buffers for entropy path (only allocated if needed) */
|
||||
uint8_t *lit_buf = NULL, *stripped = NULL, *ent_buf = NULL;
|
||||
size_t lit_cap = 0, ent_cap = 0;
|
||||
if (opts->mode >= VV_MODE_BALANCED) {
|
||||
lit_cap = VV_MAX_BLOCK_SIZE;
|
||||
ent_cap = vva_bound(VV_MAX_BLOCK_SIZE);
|
||||
lit_buf = (uint8_t *)malloc(lit_cap);
|
||||
stripped = (uint8_t *)malloc(tcap);
|
||||
ent_buf = (uint8_t *)malloc(ent_cap);
|
||||
if (!lit_buf || !stripped || !ent_buf) {
|
||||
free(lit_buf); free(stripped); free(ent_buf);
|
||||
free(tmp); matcher_free(&m);
|
||||
return VV_ERR_NOMEM;
|
||||
}
|
||||
}
|
||||
|
||||
size_t remaining = src_len;
|
||||
const uint8_t *ip = src;
|
||||
|
||||
if (remaining == 0) {
|
||||
uint32_t bh = vv_bh_pack(VV_BLOCK_RAW, 1, 0);
|
||||
memcpy(op, &bh, 4); op += 4;
|
||||
}
|
||||
|
||||
while (remaining > 0) {
|
||||
size_t braw = remaining > VV_MAX_BLOCK_SIZE ? VV_MAX_BLOCK_SIZE : remaining;
|
||||
int last = (remaining <= VV_MAX_BLOCK_SIZE);
|
||||
|
||||
size_t csz = compress_block(ip, braw, tmp, tcap, &m, opts->mode);
|
||||
|
||||
if (csz == 0 || csz >= braw) {
|
||||
/* Incompressible: store raw */
|
||||
uint32_t bh = vv_bh_pack(VV_BLOCK_RAW, last, (uint32_t)braw);
|
||||
memcpy(op, &bh, 4); op += 4;
|
||||
memcpy(op, ip, braw); op += braw;
|
||||
} else if (opts->mode >= VV_MODE_BALANCED) {
|
||||
/* ═══ WINNER-TAKES-ALL block selection ═══
|
||||
* TRADEOFF: we encode the block twice (once 'S', once 'I'/'C')
|
||||
* and pick the smaller. This costs ~2× encode time but ensures
|
||||
* we NEVER regress ratio vs any previous codec version.
|
||||
* Encode speed is not the bottleneck (decode is). */
|
||||
|
||||
/* ── Path A: sequence coding ('S') ── */
|
||||
size_t seq_len = 0;
|
||||
int seq_valid = 0;
|
||||
size_t seq_block_sz = (size_t)-1; /* Total bytes if we emit 'S' */
|
||||
int off_bytes = (wlog > 16) ? 3 : 2;
|
||||
vva_error_t serr = vva_encode_sequences(tmp, csz,
|
||||
ent_buf, ent_cap, &seq_len, off_bytes);
|
||||
if (serr == VVA_OK) {
|
||||
seq_block_sz = 4 + 3 + 1 + seq_len; /* block_hdr + comp_sz + tag + data */
|
||||
seq_valid = 1;
|
||||
}
|
||||
|
||||
/* ── Path B: literal-only entropy ('I' or 'C') ── */
|
||||
size_t stripped_len = 0;
|
||||
size_t lit_count = extract_literals(tmp, csz, lit_buf, lit_cap,
|
||||
stripped, &stripped_len, off_bytes);
|
||||
|
||||
/* Use second half of ent_buf for path B to avoid overwriting path A */
|
||||
uint8_t *ent_buf2 = ent_buf + ent_cap / 2;
|
||||
size_t ent_cap2 = ent_cap / 2;
|
||||
size_t ent_len = 0;
|
||||
uint8_t ent_tag = 0;
|
||||
size_t ent_block_sz = (size_t)-1;
|
||||
|
||||
if (lit_count > 0) {
|
||||
if (opts->mode >= VV_MODE_EXTREME && lit_count >= 64) {
|
||||
vva_error_t aerr = vva_encode_ctx(lit_buf, lit_count,
|
||||
ent_buf2, ent_cap2, &ent_len);
|
||||
if (aerr == VVA_OK) ent_tag = VV_ENTROPY_CTX;
|
||||
}
|
||||
if (!ent_tag) {
|
||||
vva_error_t aerr = vva_encode4(lit_buf, lit_count,
|
||||
ent_buf2, ent_cap2, &ent_len);
|
||||
if (aerr == VVA_OK) ent_tag = VV_ENTROPY_ANS4;
|
||||
}
|
||||
if (!ent_tag) {
|
||||
vva_error_t aerr = vva_encode(lit_buf, lit_count,
|
||||
ent_buf2, ent_cap2, &ent_len);
|
||||
if (aerr == VVA_OK) ent_tag = VV_ENTROPY_ANS;
|
||||
}
|
||||
if (ent_tag) {
|
||||
ent_block_sz = 4 + 3 + 1 + 2 + 2 + ent_len + stripped_len;
|
||||
}
|
||||
}
|
||||
|
||||
/* ── Path C: raw type-1 block ── */
|
||||
size_t raw_block_sz = 4 + 3 + csz;
|
||||
|
||||
/* ── Pick winner ── */
|
||||
if (seq_valid && seq_block_sz <= ent_block_sz && seq_block_sz < raw_block_sz) {
|
||||
/* 'S' wins — emit sequence-coded block */
|
||||
uint32_t bh = vv_bh_pack(VV_BLOCK_ENTROPY, last, (uint32_t)braw);
|
||||
memcpy(op, &bh, 4); op += 4;
|
||||
uint32_t total_comp = (uint32_t)(1 + seq_len);
|
||||
op[0] = (uint8_t)(total_comp);
|
||||
op[1] = (uint8_t)(total_comp >> 8);
|
||||
op[2] = (uint8_t)(total_comp >> 16);
|
||||
op += 3;
|
||||
*op++ = VV_ENTROPY_SEQ;
|
||||
memcpy(op, ent_buf, seq_len); op += seq_len;
|
||||
} else if (ent_tag && ent_block_sz < raw_block_sz) {
|
||||
/* 'I'/'C' wins — emit literal-entropy block */
|
||||
uint32_t bh = vv_bh_pack(VV_BLOCK_ENTROPY, last, (uint32_t)braw);
|
||||
memcpy(op, &bh, 4); op += 4;
|
||||
uint32_t total_comp = (uint32_t)(5 + ent_len + stripped_len);
|
||||
op[0] = (uint8_t)(total_comp);
|
||||
op[1] = (uint8_t)(total_comp >> 8);
|
||||
op[2] = (uint8_t)(total_comp >> 16);
|
||||
op += 3;
|
||||
*op++ = ent_tag;
|
||||
op[0] = (uint8_t)(lit_count); op[1] = (uint8_t)(lit_count >> 8); op += 2;
|
||||
op[0] = (uint8_t)(ent_len); op[1] = (uint8_t)(ent_len >> 8); op += 2;
|
||||
memcpy(op, ent_buf2, ent_len); op += ent_len;
|
||||
memcpy(op, stripped, stripped_len); op += stripped_len;
|
||||
} else {
|
||||
/* Raw type-1 wins (or nothing compresses) */
|
||||
uint32_t bh = vv_bh_pack(VV_BLOCK_COMPRESSED, last, (uint32_t)braw);
|
||||
memcpy(op, &bh, 4); op += 4;
|
||||
op[0] = (uint8_t)(csz); op[1] = (uint8_t)(csz >> 8); op[2] = (uint8_t)(csz >> 16);
|
||||
op += 3;
|
||||
memcpy(op, tmp, csz); op += csz;
|
||||
}
|
||||
} else {
|
||||
/* Ultra-fast mode: emit type 1 block directly */
|
||||
uint32_t bh = vv_bh_pack(VV_BLOCK_COMPRESSED, last, (uint32_t)braw);
|
||||
memcpy(op, &bh, 4); op += 4;
|
||||
op[0] = (uint8_t)(csz); op[1] = (uint8_t)(csz >> 8); op[2] = (uint8_t)(csz >> 16);
|
||||
op += 3;
|
||||
memcpy(op, tmp, csz); op += csz;
|
||||
}
|
||||
ip += braw; remaining -= braw;
|
||||
}
|
||||
|
||||
free(lit_buf); free(stripped); free(ent_buf);
|
||||
free(tmp);
|
||||
|
||||
if (opts->checksum) {
|
||||
vv_frame_footer_t ff;
|
||||
ff.checksum = vv_xxh64(src, src_len, 0);
|
||||
ff.footer_magic = 0x56564E44u;
|
||||
memcpy(op, &ff, sizeof(ff)); op += sizeof(ff);
|
||||
}
|
||||
|
||||
matcher_free(&m);
|
||||
return (int64_t)(op - dst);
|
||||
}
|
||||
BIN
src/vv_encoder.o
Normal file
BIN
src/vv_encoder.o
Normal file
Binary file not shown.
564
src/vv_huffman.c
Normal file
564
src/vv_huffman.c
Normal file
|
|
@ -0,0 +1,564 @@
|
|||
/* VaptVupt codec — originally Apache-2.0 by Cristian Cezar Moisés
|
||||
* Integrated into Zupt — MIT License
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés
|
||||
* SPDX-License-Identifier: MIT AND Apache-2.0
|
||||
*/
|
||||
#if !defined(_DEFAULT_SOURCE) && !defined(_GNU_SOURCE)
|
||||
#define _DEFAULT_SOURCE 1
|
||||
#endif
|
||||
/*
|
||||
* VaptVupt — Canonical Huffman Codec Implementation
|
||||
*
|
||||
* Performance targets (x86-64, gcc -O2):
|
||||
* Encode: ≥ 150 MB/s (bottleneck: bit packing, 1 symbol per ~4 cycles)
|
||||
* Decode: ≥ 800 MB/s (bottleneck: table lookup + refill, 1 symbol per ~5 cycles)
|
||||
*
|
||||
* If decode falls short of 800 MB/s, the cause is likely the refill frequency.
|
||||
* Fix: unroll the decode loop 4× and refill once per 4 symbols (amortize refill).
|
||||
*
|
||||
* Algorithm:
|
||||
* 1. Count symbol frequencies
|
||||
* 2. Build Huffman tree (two-queue merge, O(n) after sort)
|
||||
* 3. Extract code lengths, limit to 15 bits
|
||||
* 4. Assign canonical codes (sorted by length then symbol)
|
||||
* 5. Encode: LSB-first bitstream with 64-bit accumulator
|
||||
* 6. Decode: 12-bit lookup table (16 KB, L1-resident)
|
||||
*
|
||||
* Header format (on-disk):
|
||||
* [1B max_symbol] — highest symbol index with nonzero code length (0-255)
|
||||
* [(max_symbol+2)/2 bytes] — code lengths packed as nibble pairs:
|
||||
* byte[i] = (lengths[2*i] << 4) | lengths[2*i+1]
|
||||
* Total header: 1 + ceil((max_symbol+1)/2) bytes (1-129 bytes)
|
||||
*/
|
||||
|
||||
#include "vv_huffman.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* BITSTREAM WRITER (LSB-first, 64-bit accumulator)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
typedef struct {
|
||||
uint64_t bits;
|
||||
int nbits;
|
||||
uint8_t *dst;
|
||||
size_t pos;
|
||||
size_t cap;
|
||||
} bw_t;
|
||||
|
||||
static inline void bw_init(bw_t *w, uint8_t *dst, size_t cap) {
|
||||
w->bits = 0; w->nbits = 0; w->dst = dst; w->pos = 0; w->cap = cap;
|
||||
}
|
||||
|
||||
/* Add up to 16 bits. Flushes full bytes automatically. */
|
||||
static inline void bw_add(bw_t *w, uint32_t val, int n) {
|
||||
w->bits |= (uint64_t)(val & ((1u << n) - 1)) << w->nbits;
|
||||
w->nbits += n;
|
||||
/* Flush complete bytes */
|
||||
while (w->nbits >= 8 && w->pos < w->cap) {
|
||||
w->dst[w->pos++] = (uint8_t)(w->bits);
|
||||
w->bits >>= 8;
|
||||
w->nbits -= 8;
|
||||
}
|
||||
}
|
||||
|
||||
static inline size_t bw_flush(bw_t *w) {
|
||||
while (w->nbits > 0 && w->pos < w->cap) {
|
||||
w->dst[w->pos++] = (uint8_t)(w->bits);
|
||||
w->bits >>= 8;
|
||||
w->nbits -= 8;
|
||||
}
|
||||
return w->pos;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* BITSTREAM READER (LSB-first, 64-bit accumulator)
|
||||
*
|
||||
* PERFORMANCE-CRITICAL: this is the decode hot path.
|
||||
* The refill reads 8 bytes at a time when possible.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
typedef struct {
|
||||
uint64_t bits;
|
||||
int nbits;
|
||||
const uint8_t *src;
|
||||
size_t pos;
|
||||
size_t len;
|
||||
} br_t;
|
||||
|
||||
static inline void br_init(br_t *r, const uint8_t *src, size_t len) {
|
||||
r->bits = 0; r->nbits = 0; r->src = src; r->pos = 0; r->len = len;
|
||||
}
|
||||
|
||||
/* Refill: load bytes until accumulator is full (≥56 bits) */
|
||||
static inline void br_refill(br_t *r) {
|
||||
while (r->nbits <= 56 && r->pos < r->len) {
|
||||
r->bits |= (uint64_t)r->src[r->pos++] << r->nbits;
|
||||
r->nbits += 8;
|
||||
}
|
||||
}
|
||||
|
||||
static inline uint32_t br_peek(const br_t *r, int n) {
|
||||
return (uint32_t)(r->bits & ((1ULL << n) - 1));
|
||||
}
|
||||
|
||||
static inline void br_consume(br_t *r, int n) {
|
||||
r->bits >>= n;
|
||||
r->nbits -= n;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* REVERSE BITS (for LSB-first canonical code storage)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static inline uint16_t reverse_bits(uint16_t code, int len) {
|
||||
uint16_t rev = 0;
|
||||
for (int i = 0; i < len; i++) {
|
||||
rev = (uint16_t)((rev << 1) | (code & 1));
|
||||
code >>= 1;
|
||||
}
|
||||
return rev;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* BUILD HUFFMAN CODE LENGTHS FROM FREQUENCIES
|
||||
*
|
||||
* Two-queue merge algorithm (O(n) after sorting):
|
||||
* 1. Sort non-zero symbols by frequency (ascending)
|
||||
* 2. Merge two cheapest nodes repeatedly using two queues
|
||||
* (leaf queue + internal node queue)
|
||||
* 3. Extract depths via parent pointers
|
||||
* 4. Limit max depth to VVH_MAX_CODE_LEN (15)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static void build_code_lengths(const uint32_t freq[VVH_SYMBOLS],
|
||||
uint8_t lengths[VVH_SYMBOLS]) {
|
||||
/* Collect non-zero symbols, sort by frequency */
|
||||
int sym_idx[VVH_SYMBOLS];
|
||||
uint32_t sym_freq[VVH_SYMBOLS];
|
||||
int n = 0;
|
||||
|
||||
memset(lengths, 0, VVH_SYMBOLS);
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++) {
|
||||
if (freq[i] > 0) {
|
||||
sym_idx[n] = i;
|
||||
sym_freq[n] = freq[i];
|
||||
n++;
|
||||
}
|
||||
}
|
||||
|
||||
if (n == 0) return;
|
||||
if (n == 1) { lengths[sym_idx[0]] = 1; return; }
|
||||
if (n == 2) { lengths[sym_idx[0]] = 1; lengths[sym_idx[1]] = 1; return; }
|
||||
|
||||
/* Insertion sort by frequency ascending (n ≤ 256, fast enough) */
|
||||
for (int i = 1; i < n; i++) {
|
||||
uint32_t tf = sym_freq[i];
|
||||
int ts = sym_idx[i];
|
||||
int j = i - 1;
|
||||
while (j >= 0 && sym_freq[j] > tf) {
|
||||
sym_freq[j + 1] = sym_freq[j];
|
||||
sym_idx[j + 1] = sym_idx[j];
|
||||
j--;
|
||||
}
|
||||
sym_freq[j + 1] = tf;
|
||||
sym_idx[j + 1] = ts;
|
||||
}
|
||||
|
||||
/* Heap-allocate tree workspace: 2n-1 nodes (n >= 3, so total >= 5) */
|
||||
size_t total = 2u * (unsigned)n - 1u;
|
||||
uint32_t *nf = (uint32_t *)calloc(total, sizeof(uint32_t));
|
||||
int16_t *par = (int16_t *)malloc(total * sizeof(int16_t));
|
||||
if (!nf || !par) { free(nf); free(par); return; }
|
||||
|
||||
/* Initialize leaf nodes */
|
||||
for (int i = 0; i < n; i++) {
|
||||
nf[i] = sym_freq[i];
|
||||
par[i] = -1;
|
||||
}
|
||||
for (size_t i = (size_t)n; i < total; i++) {
|
||||
nf[i] = 0;
|
||||
par[i] = -1;
|
||||
}
|
||||
|
||||
/* Two-queue merge */
|
||||
int lq = 0; /* Leaf queue read pointer */
|
||||
int iq = n; /* Internal queue read pointer */
|
||||
int next = n; /* Next internal node to create */
|
||||
|
||||
for (int m = 0; m < n - 1; m++) {
|
||||
uint32_t cost = 0;
|
||||
for (int pick = 0; pick < 2; pick++) {
|
||||
int use_leaf = (lq < n) && (iq >= next || nf[lq] <= nf[iq]);
|
||||
if (use_leaf) {
|
||||
cost += nf[lq];
|
||||
par[lq] = (int16_t)next;
|
||||
lq++;
|
||||
} else {
|
||||
cost += nf[iq];
|
||||
par[iq] = (int16_t)next;
|
||||
iq++;
|
||||
}
|
||||
}
|
||||
nf[next] = cost;
|
||||
par[next] = -1;
|
||||
next++;
|
||||
}
|
||||
|
||||
/* Compute depths */
|
||||
uint8_t *dep = (uint8_t *)calloc(total, 1);
|
||||
if (!dep) { free(nf); free(par); return; }
|
||||
dep[total - 1] = 0;
|
||||
for (int i = (int)total - 2; i >= 0; i--)
|
||||
dep[i] = dep[par[i]] + 1;
|
||||
|
||||
/* Extract leaf depths */
|
||||
for (int i = 0; i < n; i++)
|
||||
lengths[sym_idx[i]] = dep[i];
|
||||
|
||||
free(nf); free(par); free(dep);
|
||||
|
||||
/* ─── Depth limiting to VVH_MAX_CODE_LEN ─── */
|
||||
int max_d = 0;
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++)
|
||||
if (lengths[i] > max_d) max_d = lengths[i];
|
||||
if (max_d <= VVH_MAX_CODE_LEN) return;
|
||||
|
||||
/* Count symbols per depth */
|
||||
int bl_count[32];
|
||||
memset(bl_count, 0, sizeof(bl_count));
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++)
|
||||
if (lengths[i] > 0) bl_count[lengths[i]]++;
|
||||
|
||||
/* Cap depths > 15 to 15 */
|
||||
for (int d = VVH_MAX_CODE_LEN + 1; d < 32; d++) {
|
||||
bl_count[VVH_MAX_CODE_LEN] += bl_count[d];
|
||||
bl_count[d] = 0;
|
||||
}
|
||||
|
||||
/* Fix Kraft inequality: sum(bl_count[d] * 2^(15-d)) must ≤ 2^15 */
|
||||
for (;;) {
|
||||
uint32_t kraft = 0;
|
||||
for (int d = 1; d <= VVH_MAX_CODE_LEN; d++)
|
||||
kraft += (uint32_t)bl_count[d] << (VVH_MAX_CODE_LEN - d);
|
||||
if (kraft <= (1u << VVH_MAX_CODE_LEN)) break;
|
||||
/* Move one symbol from shallowest level deeper */
|
||||
for (int d = VVH_MAX_CODE_LEN - 1; d >= 1; d--) {
|
||||
if (bl_count[d] > 0) {
|
||||
bl_count[d]--;
|
||||
bl_count[d + 1]++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Reassign lengths: sort non-zero symbols by (current_length asc, symbol asc)
|
||||
* then assign from the bl_count distribution shortest-first */
|
||||
typedef struct { uint8_t len; uint8_t sym; } ls_t;
|
||||
ls_t sorted[VVH_SYMBOLS];
|
||||
int ns = 0;
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++)
|
||||
if (lengths[i] > 0) {
|
||||
sorted[ns].len = lengths[i] > VVH_MAX_CODE_LEN
|
||||
? VVH_MAX_CODE_LEN : lengths[i];
|
||||
sorted[ns].sym = (uint8_t)i;
|
||||
ns++;
|
||||
}
|
||||
/* Sort by len ascending, then sym ascending */
|
||||
for (int i = 1; i < ns; i++) {
|
||||
ls_t tmp = sorted[i];
|
||||
int j = i - 1;
|
||||
while (j >= 0 && (sorted[j].len > tmp.len ||
|
||||
(sorted[j].len == tmp.len && sorted[j].sym > tmp.sym))) {
|
||||
sorted[j + 1] = sorted[j]; j--;
|
||||
}
|
||||
sorted[j + 1] = tmp;
|
||||
}
|
||||
/* Assign from distribution */
|
||||
int si = 0;
|
||||
for (int d = 1; d <= VVH_MAX_CODE_LEN && si < ns; d++)
|
||||
for (int c = 0; c < bl_count[d] && si < ns; c++)
|
||||
lengths[sorted[si++].sym] = (uint8_t)d;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* CANONICAL CODE ASSIGNMENT
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static void assign_canonical_codes(const uint8_t lengths[VVH_SYMBOLS],
|
||||
uint16_t codes[VVH_SYMBOLS]) {
|
||||
/* Count symbols at each length */
|
||||
int bl_count[VVH_MAX_CODE_LEN + 1];
|
||||
memset(bl_count, 0, sizeof(bl_count));
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++)
|
||||
if (lengths[i] > 0 && lengths[i] <= VVH_MAX_CODE_LEN)
|
||||
bl_count[lengths[i]]++;
|
||||
|
||||
/* Compute first code for each length (MSB-first canonical) */
|
||||
uint16_t next_code[VVH_MAX_CODE_LEN + 1];
|
||||
uint16_t code = 0;
|
||||
next_code[0] = 0;
|
||||
for (int bits = 1; bits <= VVH_MAX_CODE_LEN; bits++) {
|
||||
code = (uint16_t)((code + bl_count[bits - 1]) << 1);
|
||||
next_code[bits] = code;
|
||||
}
|
||||
|
||||
/* Assign codes in symbol order (canonical: sorted by length then symbol) */
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++) {
|
||||
if (lengths[i] > 0)
|
||||
codes[i] = next_code[lengths[i]]++;
|
||||
else
|
||||
codes[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* BUILD ENCODER TABLE
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static void build_enc_table(const uint32_t freq[VVH_SYMBOLS],
|
||||
vvh_enc_table_t *enc) {
|
||||
build_code_lengths(freq, enc->lengths);
|
||||
|
||||
uint16_t canonical[VVH_SYMBOLS];
|
||||
assign_canonical_codes(enc->lengths, canonical);
|
||||
|
||||
/* Store bit-reversed codes for LSB-first writing */
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++) {
|
||||
if (enc->lengths[i] > 0)
|
||||
enc->codes[i] = reverse_bits(canonical[i], enc->lengths[i]);
|
||||
else
|
||||
enc->codes[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* BUILD DECODER TABLE
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static void build_dec_table(const uint8_t lengths[VVH_SYMBOLS],
|
||||
vvh_dec_table_t *dec) {
|
||||
uint16_t canonical[VVH_SYMBOLS];
|
||||
assign_canonical_codes(lengths, canonical);
|
||||
|
||||
memset(dec->table, 0, sizeof(dec->table));
|
||||
dec->slow_count = 0;
|
||||
|
||||
for (int sym = 0; sym < VVH_SYMBOLS; sym++) {
|
||||
int len = lengths[sym];
|
||||
if (len == 0) continue;
|
||||
|
||||
uint16_t rev = reverse_bits(canonical[sym], len);
|
||||
|
||||
if (len <= VVH_DECODE_BITS) {
|
||||
/* Fast path: fill all entries where low `len` bits match `rev` */
|
||||
int fill = 1 << (VVH_DECODE_BITS - len);
|
||||
for (int j = 0; j < fill; j++) {
|
||||
int idx = (int)rev | (j << len);
|
||||
dec->table[idx] = (uint32_t)sym | ((uint32_t)len << 8);
|
||||
}
|
||||
} else {
|
||||
/* Slow path: store for linear scan */
|
||||
int si = dec->slow_count++;
|
||||
dec->slow_code[si] = rev;
|
||||
dec->slow_len[si] = (uint8_t)len;
|
||||
dec->slow_sym[si] = (uint8_t)sym;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* WRITE HEADER (code lengths as packed nibbles)
|
||||
*
|
||||
* Format: [1B max_sym] [(max_sym+2)/2 bytes packed nibble pairs]
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static size_t write_header(const uint8_t lengths[VVH_SYMBOLS],
|
||||
uint8_t *dst, size_t cap) {
|
||||
/* Find max symbol with nonzero length */
|
||||
int max_sym = 0;
|
||||
for (int i = VVH_SYMBOLS - 1; i >= 0; i--) {
|
||||
if (lengths[i] > 0) { max_sym = i; break; }
|
||||
}
|
||||
|
||||
size_t hdr_size = 1 + ((size_t)max_sym + 2) / 2;
|
||||
if (hdr_size > cap) return 0;
|
||||
|
||||
dst[0] = (uint8_t)max_sym;
|
||||
|
||||
/* Pack nibble pairs */
|
||||
for (int i = 0; i <= max_sym; i += 2) {
|
||||
uint8_t hi = lengths[i];
|
||||
uint8_t lo = (i + 1 <= max_sym) ? lengths[i + 1] : 0;
|
||||
dst[1 + i / 2] = (uint8_t)((hi << 4) | (lo & 0x0F));
|
||||
}
|
||||
|
||||
return hdr_size;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* READ HEADER
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static size_t read_header(const uint8_t *src, size_t src_len,
|
||||
uint8_t lengths[VVH_SYMBOLS]) {
|
||||
memset(lengths, 0, VVH_SYMBOLS);
|
||||
if (src_len < 1) return 0;
|
||||
|
||||
int max_sym = src[0];
|
||||
size_t hdr_size = 1 + ((size_t)max_sym + 2) / 2;
|
||||
if (hdr_size > src_len) return 0;
|
||||
|
||||
for (int i = 0; i <= max_sym; i += 2) {
|
||||
uint8_t packed = src[1 + i / 2];
|
||||
lengths[i] = packed >> 4;
|
||||
if (i + 1 <= max_sym)
|
||||
lengths[i + 1] = packed & 0x0F;
|
||||
}
|
||||
|
||||
return hdr_size;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* ENCODE
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
vvh_error_t vvh_encode(const uint8_t *src, size_t src_len,
|
||||
uint8_t *dst, size_t dst_cap, size_t *dst_len) {
|
||||
if (src_len == 0) {
|
||||
*dst_len = 0;
|
||||
return VVH_OK;
|
||||
}
|
||||
|
||||
/* Count frequencies */
|
||||
uint32_t freq[VVH_SYMBOLS];
|
||||
memset(freq, 0, sizeof(freq));
|
||||
for (size_t i = 0; i < src_len; i++)
|
||||
freq[src[i]]++;
|
||||
|
||||
/* Build encode table */
|
||||
vvh_enc_table_t enc;
|
||||
build_enc_table(freq, &enc);
|
||||
|
||||
/* Check: any symbols with length 0 that appear in input? (shouldn't happen) */
|
||||
/* Write header */
|
||||
size_t hdr_sz = write_header(enc.lengths, dst, dst_cap);
|
||||
if (hdr_sz == 0) return VVH_ERR_OVERFLOW;
|
||||
|
||||
/* Encode bitstream */
|
||||
bw_t w;
|
||||
bw_init(&w, dst + hdr_sz, dst_cap - hdr_sz);
|
||||
|
||||
for (size_t i = 0; i < src_len; i++) {
|
||||
uint8_t sym = src[i];
|
||||
bw_add(&w, enc.codes[sym], enc.lengths[sym]);
|
||||
}
|
||||
|
||||
size_t bs_sz = bw_flush(&w);
|
||||
size_t total = hdr_sz + bs_sz;
|
||||
|
||||
/* Incompressible guard: if not smaller, signal failure */
|
||||
if (total >= src_len) {
|
||||
return VVH_ERR_OVERFLOW;
|
||||
}
|
||||
|
||||
*dst_len = total;
|
||||
return VVH_OK;
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* DECODE
|
||||
*
|
||||
* PERFORMANCE-CRITICAL: the inner loop decodes one symbol per
|
||||
* iteration using a 12-bit table lookup + refill.
|
||||
*
|
||||
* Hot path (codes ≤ 12 bits, ~99% of symbols):
|
||||
* 1. Peek 12 bits from accumulator
|
||||
* 2. Table lookup → (symbol, length)
|
||||
* 3. Consume `length` bits
|
||||
* 4. Refill accumulator if needed
|
||||
* 5. Write symbol to output
|
||||
*
|
||||
* Cold path (codes 13-15 bits, <1% of symbols):
|
||||
* Linear scan of slow_code/slow_len/slow_sym arrays.
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
vvh_error_t vvh_decode(const uint8_t *src, size_t src_len,
|
||||
uint8_t *dst, size_t dst_cap,
|
||||
size_t num_literals, size_t *src_consumed) {
|
||||
if (num_literals == 0) {
|
||||
*src_consumed = 0;
|
||||
return VVH_OK;
|
||||
}
|
||||
if (num_literals > dst_cap) return VVH_ERR_OVERFLOW;
|
||||
|
||||
/* Read header */
|
||||
uint8_t lengths[VVH_SYMBOLS];
|
||||
size_t hdr_sz = read_header(src, src_len, lengths);
|
||||
if (hdr_sz == 0) return VVH_ERR_CORRUPT;
|
||||
|
||||
/* Check for valid tree: at least one nonzero length */
|
||||
int has_sym = 0;
|
||||
for (int i = 0; i < VVH_SYMBOLS; i++)
|
||||
if (lengths[i] > 0) { has_sym = 1; break; }
|
||||
if (!has_sym) return VVH_ERR_CORRUPT;
|
||||
|
||||
/* Build decode table (heap-allocated: 16 KB) */
|
||||
vvh_dec_table_t *dec = (vvh_dec_table_t *)malloc(sizeof(vvh_dec_table_t));
|
||||
if (!dec) return VVH_ERR_NOMEM;
|
||||
build_dec_table(lengths, dec);
|
||||
|
||||
/* Initialize bitstream reader */
|
||||
br_t r;
|
||||
br_init(&r, src + hdr_sz, src_len - hdr_sz);
|
||||
br_refill(&r);
|
||||
|
||||
/* ─── Decode loop ─── */
|
||||
for (size_t i = 0; i < num_literals; i++) {
|
||||
/* Refill if accumulator is getting low */
|
||||
if (r.nbits < VVH_MAX_CODE_LEN)
|
||||
br_refill(&r);
|
||||
|
||||
uint32_t peek = br_peek(&r, VVH_DECODE_BITS);
|
||||
uint32_t entry = dec->table[peek];
|
||||
int sym = (int)(entry & 0xFF);
|
||||
int len = (int)((entry >> 8) & 0xF);
|
||||
|
||||
if (__builtin_expect(len > 0, 1)) {
|
||||
/* Fast path: code ≤ 12 bits */
|
||||
br_consume(&r, len);
|
||||
dst[i] = (uint8_t)sym;
|
||||
} else {
|
||||
/* Slow path: code > 12 bits */
|
||||
int found = 0;
|
||||
for (int s = 0; s < dec->slow_count; s++) {
|
||||
int slen = dec->slow_len[s];
|
||||
uint32_t mask = (1u << slen) - 1;
|
||||
if ((br_peek(&r, slen) & mask) == dec->slow_code[s]) {
|
||||
br_consume(&r, slen);
|
||||
dst[i] = dec->slow_sym[s];
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
free(dec);
|
||||
return VVH_ERR_CORRUPT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Calculate bytes consumed from src */
|
||||
*src_consumed = hdr_sz + r.pos;
|
||||
/* Account for bits still in accumulator that we didn't fully consume */
|
||||
if (r.nbits >= 8) {
|
||||
/* We over-read by (nbits/8) bytes */
|
||||
size_t over = (size_t)(r.nbits / 8);
|
||||
if (*src_consumed >= over)
|
||||
*src_consumed -= over;
|
||||
}
|
||||
|
||||
free(dec);
|
||||
return VVH_OK;
|
||||
}
|
||||
BIN
src/vv_huffman.o
Normal file
BIN
src/vv_huffman.o
Normal file
Binary file not shown.
182
src/vv_simd.c
Normal file
182
src/vv_simd.c
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
/* VaptVupt codec — originally Apache-2.0 by Cristian Cezar Moisés
|
||||
* Integrated into Zupt — MIT License
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés
|
||||
* SPDX-License-Identifier: MIT AND Apache-2.0
|
||||
*/
|
||||
#if !defined(_DEFAULT_SOURCE) && !defined(_GNU_SOURCE)
|
||||
#define _DEFAULT_SOURCE 1
|
||||
#endif
|
||||
/*
|
||||
* VaptVupt — SIMD-accelerated copy routines
|
||||
*
|
||||
* Three tiers:
|
||||
* 1. AVX2 (x86-64 with runtime detection)
|
||||
* 2. NEON (ARM64, compile-time)
|
||||
* 3. Scalar fallback (always available)
|
||||
*
|
||||
* PERFORMANCE-CRITICAL: these are the #1 hotspot in decompression.
|
||||
* The literal copy and match copy account for ~60% of decode cycles.
|
||||
*/
|
||||
|
||||
#include "vaptvupt.h"
|
||||
#include <string.h>
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* SCALAR FALLBACK (always compiled)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
static void copy_fast_scalar(uint8_t *dst, const uint8_t *src, size_t n) {
|
||||
memcpy(dst, src, n);
|
||||
}
|
||||
|
||||
static void copy_match_scalar(uint8_t *dst, uint32_t offset, size_t length) {
|
||||
const uint8_t *src = dst - offset;
|
||||
if (offset >= 16) {
|
||||
/* Non-overlapping: bulk copy */
|
||||
while (length >= 16) {
|
||||
memcpy(dst, src, 16);
|
||||
dst += 16; src += 16; length -= 16;
|
||||
}
|
||||
if (length > 0) memcpy(dst, src, length);
|
||||
} else if (offset >= 4) {
|
||||
/* Moderate overlap: 8-byte copy with re-read */
|
||||
while (length >= 8) {
|
||||
uint64_t v;
|
||||
memcpy(&v, src, 8);
|
||||
memcpy(dst, &v, 8);
|
||||
dst += 8; src += 8; length -= 8;
|
||||
}
|
||||
while (length-- > 0) *dst++ = *src++;
|
||||
} else {
|
||||
/* Very short overlap (1-3): byte-by-byte */
|
||||
for (size_t i = 0; i < length; i++) dst[i] = src[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* x86-64 AVX2 (guarded by compile-time + runtime detection)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
#if defined(__x86_64__) || defined(_M_X64)
|
||||
|
||||
#include <cpuid.h>
|
||||
|
||||
static int vv_has_avx2(void) {
|
||||
unsigned int eax, ebx, ecx, edx;
|
||||
if (!__get_cpuid_count(7, 0, &eax, &ebx, &ecx, &edx)) return 0;
|
||||
return (ebx & (1 << 5)) != 0; /* AVX2 bit */
|
||||
}
|
||||
|
||||
#ifdef __AVX2__
|
||||
#include <immintrin.h>
|
||||
|
||||
static void copy_fast_avx2(uint8_t *dst, const uint8_t *src, size_t n) {
|
||||
while (n >= 32) {
|
||||
__m256i v = _mm256_loadu_si256((const __m256i *)src);
|
||||
_mm256_storeu_si256((__m256i *)dst, v);
|
||||
dst += 32; src += 32; n -= 32;
|
||||
}
|
||||
if (n >= 16) {
|
||||
__m128i v = _mm_loadu_si128((const __m128i *)src);
|
||||
_mm_storeu_si128((__m128i *)dst, v);
|
||||
dst += 16; src += 16; n -= 16;
|
||||
}
|
||||
if (n > 0) memcpy(dst, src, n);
|
||||
}
|
||||
|
||||
static void copy_match_avx2(uint8_t *dst, uint32_t offset, size_t length) {
|
||||
const uint8_t *src = dst - offset;
|
||||
if (offset >= 32) {
|
||||
while (length >= 32) {
|
||||
__m256i v = _mm256_loadu_si256((const __m256i *)src);
|
||||
_mm256_storeu_si256((__m256i *)dst, v);
|
||||
dst += 32; src += 32; length -= 32;
|
||||
}
|
||||
if (length >= 16) {
|
||||
__m128i v = _mm_loadu_si128((const __m128i *)src);
|
||||
_mm_storeu_si128((__m128i *)dst, v);
|
||||
dst += 16; src += 16; length -= 16;
|
||||
}
|
||||
if (length > 0) memcpy(dst, src, length);
|
||||
} else {
|
||||
/* Fall back to scalar for overlapping copies */
|
||||
copy_match_scalar(dst, offset, length);
|
||||
}
|
||||
}
|
||||
#endif /* __AVX2__ */
|
||||
|
||||
#endif /* x86-64 */
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* ARM64 NEON (compile-time detection)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
#if defined(__aarch64__) && defined(__ARM_NEON)
|
||||
#include <arm_neon.h>
|
||||
|
||||
static void copy_fast_neon(uint8_t *dst, const uint8_t *src, size_t n) {
|
||||
while (n >= 16) {
|
||||
uint8x16_t v = vld1q_u8(src);
|
||||
vst1q_u8(dst, v);
|
||||
dst += 16; src += 16; n -= 16;
|
||||
}
|
||||
if (n > 0) memcpy(dst, src, n);
|
||||
}
|
||||
|
||||
static void copy_match_neon(uint8_t *dst, uint32_t offset, size_t length) {
|
||||
const uint8_t *src = dst - offset;
|
||||
if (offset >= 16) {
|
||||
while (length >= 16) {
|
||||
uint8x16_t v = vld1q_u8(src);
|
||||
vst1q_u8(dst, v);
|
||||
dst += 16; src += 16; length -= 16;
|
||||
}
|
||||
if (length > 0) memcpy(dst, src, length);
|
||||
} else {
|
||||
copy_match_scalar(dst, offset, length);
|
||||
}
|
||||
}
|
||||
#endif /* ARM64 NEON */
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════
|
||||
* RUNTIME DISPATCH (initialized once at first call)
|
||||
* ═══════════════════════════════════════════════════════════════ */
|
||||
|
||||
typedef void (*copy_fast_fn)(uint8_t *, const uint8_t *, size_t);
|
||||
typedef void (*copy_match_fn)(uint8_t *, uint32_t, size_t);
|
||||
|
||||
static copy_fast_fn g_copy_fast = NULL;
|
||||
static copy_match_fn g_copy_match = NULL;
|
||||
|
||||
static void vv_init_simd(void) {
|
||||
if (g_copy_fast) return; /* Already initialized */
|
||||
|
||||
#if defined(__x86_64__) || defined(_M_X64)
|
||||
#ifdef __AVX2__
|
||||
if (vv_has_avx2()) {
|
||||
g_copy_fast = copy_fast_avx2;
|
||||
g_copy_match = copy_match_avx2;
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(__aarch64__) && defined(__ARM_NEON)
|
||||
g_copy_fast = copy_fast_neon;
|
||||
g_copy_match = copy_match_neon;
|
||||
return;
|
||||
#endif
|
||||
|
||||
g_copy_fast = copy_fast_scalar;
|
||||
g_copy_match = copy_match_scalar;
|
||||
}
|
||||
|
||||
void vv_copy_fast(uint8_t *dst, const uint8_t *src, size_t n) {
|
||||
if (!g_copy_fast) vv_init_simd();
|
||||
g_copy_fast(dst, src, n);
|
||||
}
|
||||
|
||||
void vv_copy_match(uint8_t *dst, uint32_t offset, size_t length) {
|
||||
if (!g_copy_match) vv_init_simd();
|
||||
g_copy_match(dst, offset, length);
|
||||
}
|
||||
BIN
src/vv_simd.o
Normal file
BIN
src/vv_simd.o
Normal file
Binary file not shown.
|
|
@ -1,8 +1,10 @@
|
|||
/*
|
||||
* ZUPT - AES-256 Block Cipher (FIPS 197)
|
||||
* Pure C, constant-time T-table implementation.
|
||||
* FRAMA-C: ACSL-annotated (v2.0.0)
|
||||
*/
|
||||
#include "zupt.h"
|
||||
#include "zupt_acsl.h"
|
||||
#include <string.h>
|
||||
|
||||
/* ─── S-Box ─── */
|
||||
|
|
@ -36,6 +38,12 @@ static inline uint8_t gmul(uint8_t a, uint8_t b) {
|
|||
}
|
||||
|
||||
/* ─── Key Expansion (AES-256: 14 rounds, 60 round-key words) ─── */
|
||||
/* FRAMA-C: AES-256 key schedule expansion */
|
||||
/*@ requires \valid(c);
|
||||
@ requires \valid_read(key + (0..31));
|
||||
@ assigns c->rk[0..59];
|
||||
@ ensures \initialized(&c->rk[0..59]);
|
||||
*/
|
||||
void zupt_aes256_init(zupt_aes256_ctx *c, const uint8_t key[32]) {
|
||||
uint32_t *rk = c->rk;
|
||||
for (int i=0;i<8;i++)
|
||||
|
|
@ -56,6 +64,14 @@ void zupt_aes256_init(zupt_aes256_ctx *c, const uint8_t key[32]) {
|
|||
}
|
||||
|
||||
/* ─── Single block encryption ─── */
|
||||
/* FRAMA-C: AES-256 single-block encrypt */
|
||||
/*@ requires \valid_read(&c->rk[0..59]);
|
||||
@ requires \valid_read(in + (0..15));
|
||||
@ requires \valid(out + (0..15));
|
||||
@ requires \separated(in + (0..15), out + (0..15));
|
||||
@ assigns out[0..15];
|
||||
@ ensures \initialized(out + (0..15));
|
||||
*/
|
||||
void zupt_aes256_encrypt_block(const zupt_aes256_ctx *c, const uint8_t in[16], uint8_t out[16]) {
|
||||
uint8_t s[16];
|
||||
const uint32_t *rk = c->rk;
|
||||
|
|
|
|||
BIN
src/zupt_aes256.o
Normal file
BIN
src/zupt_aes256.o
Normal file
Binary file not shown.
BIN
src/zupt_cpuid.o
Normal file
BIN
src/zupt_cpuid.o
Normal file
Binary file not shown.
|
|
@ -6,10 +6,14 @@
|
|||
* Cryptographic operations:
|
||||
* - HMAC-SHA256, PBKDF2, AES-256-CTR, Encrypt-then-MAC (v0.2+)
|
||||
* - Hybrid PQ KEM: ML-KEM-768 + X25519 (v0.7.0)
|
||||
*
|
||||
* FRAMA-C: ACSL-annotated (v2.0.0)
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "zupt.h"
|
||||
#include "zupt_acsl.h"
|
||||
#include "zupt_jasmin.h"
|
||||
#include "zupt_cpuid.h" /* JASMIN-VERIFIED: AES-NI dispatch */
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
|
@ -55,6 +59,16 @@ void zupt_random_bytes(uint8_t *buf, size_t len) {
|
|||
* HMAC-SHA256 (RFC 2104)
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: HMAC-SHA256 (RFC 2104) */
|
||||
/*@ requires klen <= 256;
|
||||
@ requires \valid_read(key + (0..klen-1));
|
||||
@ requires \valid_read(data + (0..dlen-1));
|
||||
@ requires \valid(mac + (0..31));
|
||||
@ requires \separated(key + (0..klen-1), mac + (0..31));
|
||||
@ requires \separated(data + (0..dlen-1), mac + (0..31));
|
||||
@ assigns mac[0..31];
|
||||
@ ensures \initialized(mac + (0..31));
|
||||
*/
|
||||
void zupt_hmac_sha256(const uint8_t *key, size_t klen,
|
||||
const uint8_t *data, size_t dlen,
|
||||
uint8_t mac[32]) {
|
||||
|
|
@ -99,6 +113,17 @@ void zupt_hmac_sha256(const uint8_t *key, size_t klen,
|
|||
* PBKDF2-HMAC-SHA256 (RFC 8018)
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: PBKDF2-HMAC-SHA256 (RFC 8018) */
|
||||
/*@ requires pwlen <= 256;
|
||||
@ requires slen <= 252;
|
||||
@ requires olen > 0 && olen <= 64;
|
||||
@ requires iterations >= 1;
|
||||
@ requires \valid_read(pw + (0..pwlen-1));
|
||||
@ requires \valid_read(salt + (0..slen-1));
|
||||
@ requires \valid(output + (0..olen-1));
|
||||
@ assigns output[0..olen-1];
|
||||
@ ensures \initialized(output + (0..olen-1));
|
||||
*/
|
||||
void zupt_pbkdf2_sha256(const uint8_t *pw, size_t pwlen,
|
||||
const uint8_t *salt, size_t slen,
|
||||
uint32_t iterations,
|
||||
|
|
@ -148,14 +173,72 @@ void zupt_pbkdf2_sha256(const uint8_t *pw, size_t pwlen,
|
|||
* AES-256-CTR MODE
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: AES-256-CTR stream cipher */
|
||||
/*@ requires \valid_read(key + (0..31));
|
||||
@ requires \valid_read(nonce + (0..15));
|
||||
@ requires \valid_read(in + (0..len-1));
|
||||
@ requires \valid(out + (0..len-1));
|
||||
@ requires \separated(in + (0..len-1), out + (0..len-1));
|
||||
@ assigns out[0..len-1];
|
||||
@ ensures \initialized(out + (0..len-1));
|
||||
*/
|
||||
void zupt_aes256_ctr(const uint8_t key[32], const uint8_t nonce[16],
|
||||
const uint8_t *in, uint8_t *out, size_t len) {
|
||||
zupt_aes256_ctx ctx;
|
||||
zupt_aes256_init(&ctx, key);
|
||||
|
||||
uint8_t counter[16], keystream[16];
|
||||
memcpy(counter, nonce, 16);
|
||||
|
||||
#ifdef ZUPT_USE_JASMIN
|
||||
/* JASMIN-VERIFIED: AES-NI path — constant-time, no T-table leakage.
|
||||
* Requires AES-NI support (detected via CPUID at startup).
|
||||
* Uses 4-block pipeline for bulk data, single-block for tail. */
|
||||
if (zupt_cpu.has_aesni) {
|
||||
size_t full_blocks = len / 16;
|
||||
size_t tail_bytes = len % 16;
|
||||
|
||||
if (full_blocks >= 4) {
|
||||
/* 4-block pipeline: processes 4 blocks per iteration */
|
||||
size_t pipe_blocks = (full_blocks / 4) * 4;
|
||||
zupt_aes256_ctr4(out, in, key, counter, pipe_blocks);
|
||||
size_t pipe_bytes = pipe_blocks * 16;
|
||||
in += pipe_bytes;
|
||||
out += pipe_bytes;
|
||||
full_blocks -= pipe_blocks;
|
||||
}
|
||||
|
||||
/* Remaining 0-3 full blocks: single-block path */
|
||||
size_t pos = 0;
|
||||
for (size_t b = 0; b < full_blocks; b++) {
|
||||
zupt_aes256_blk(out + pos, in + pos, key, counter);
|
||||
pos += 16;
|
||||
/* Increment counter (big-endian, last 8 bytes) */
|
||||
for (int i = 15; i >= 8; i--) {
|
||||
if (++counter[i] != 0) break;
|
||||
}
|
||||
}
|
||||
in += pos;
|
||||
out += pos;
|
||||
|
||||
/* Tail: partial last block */
|
||||
if (tail_bytes > 0) {
|
||||
uint8_t tmp_in[16], tmp_out[16];
|
||||
memset(tmp_in, 0, 16);
|
||||
memcpy(tmp_in, in, tail_bytes);
|
||||
zupt_aes256_blk(tmp_out, tmp_in, key, counter);
|
||||
memcpy(out, tmp_out, tail_bytes);
|
||||
zupt_secure_wipe(tmp_in, 16);
|
||||
zupt_secure_wipe(tmp_out, 16);
|
||||
}
|
||||
|
||||
zupt_secure_wipe(counter, 16);
|
||||
zupt_secure_wipe(keystream, 16);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* C table-based fallback */
|
||||
zupt_aes256_ctx ctx;
|
||||
zupt_aes256_init(&ctx, key);
|
||||
|
||||
size_t pos = 0;
|
||||
while (pos < len) {
|
||||
zupt_aes256_encrypt_block(&ctx, counter, keystream);
|
||||
|
|
@ -180,9 +263,23 @@ void zupt_aes256_ctr(const uint8_t key[32], const uint8_t nonce[16],
|
|||
* KEY DERIVATION
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: Key derivation from password + salt */
|
||||
/*@ requires \valid(kr);
|
||||
@ requires \valid_read(salt + (0..31));
|
||||
@ requires \valid_read(nonce + (0..15));
|
||||
@ requires strlen(pw) <= 255;
|
||||
@ requires iterations >= 1;
|
||||
@ assigns kr->enc_key[0..31], kr->mac_key[0..31], kr->salt[0..31],
|
||||
@ kr->base_nonce[0..15], kr->iterations, kr->active;
|
||||
@ ensures kr->active == 1;
|
||||
*/
|
||||
void zupt_derive_keys(zupt_keyring_t *kr, const char *pw,
|
||||
const uint8_t salt[32], const uint8_t nonce[16],
|
||||
uint32_t iterations) {
|
||||
/* Init canaries if not already set */
|
||||
kr->canary_head = ZUPT_CANARY;
|
||||
kr->canary_tail = ZUPT_CANARY;
|
||||
|
||||
memcpy(kr->salt, salt, ZUPT_SALT_SIZE);
|
||||
memcpy(kr->base_nonce, nonce, ZUPT_NONCE_SIZE);
|
||||
kr->iterations = iterations;
|
||||
|
|
@ -197,6 +294,10 @@ void zupt_derive_keys(zupt_keyring_t *kr, const char *pw,
|
|||
memcpy(kr->mac_key, material + 32, 32);
|
||||
|
||||
zupt_secure_wipe(material, 64);
|
||||
|
||||
/* Lock key material in RAM — prevent swap to disk */
|
||||
zupt_mlock_keys(kr->enc_key, ZUPT_AES_KEY_SIZE);
|
||||
zupt_mlock_keys(kr->mac_key, ZUPT_HMAC_SIZE);
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
|
|
@ -207,6 +308,16 @@ void zupt_derive_keys(zupt_keyring_t *kr, const char *pw,
|
|||
* Per-block nonce = base_nonce XOR (block_seq as LE 8 bytes in low half)
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: Encrypt-then-MAC: produces [nonce][ciphertext][HMAC] */
|
||||
/*@ requires \valid_read(&kr->enc_key[0..31]);
|
||||
@ requires \valid_read(&kr->mac_key[0..31]);
|
||||
@ requires \valid_read(&kr->base_nonce[0..15]);
|
||||
@ requires kr->active == 1;
|
||||
@ requires \valid_read(plain + (0..plen-1));
|
||||
@ requires \valid(olen);
|
||||
@ assigns *olen;
|
||||
@ ensures *olen == 16 + plen + 32;
|
||||
*/
|
||||
uint8_t *zupt_encrypt_buffer(const zupt_keyring_t *kr,
|
||||
const uint8_t *plain, size_t plen,
|
||||
uint64_t block_seq, size_t *olen) {
|
||||
|
|
@ -234,6 +345,19 @@ uint8_t *zupt_encrypt_buffer(const zupt_keyring_t *kr,
|
|||
return pkg;
|
||||
}
|
||||
|
||||
/* FRAMA-C: Decrypt with MAC verification (Encrypt-then-MAC) */
|
||||
/*@ requires \valid_read(&kr->enc_key[0..31]);
|
||||
@ requires \valid_read(&kr->mac_key[0..31]);
|
||||
@ requires kr->active == 1;
|
||||
@ requires pkglen >= 48;
|
||||
@ requires \valid_read(pkg + (0..pkglen-1));
|
||||
@ requires \valid(olen);
|
||||
@ assigns *olen;
|
||||
@ behavior auth_ok:
|
||||
@ ensures \result != \null ==> *olen == pkglen - 48;
|
||||
@ behavior auth_fail:
|
||||
@ ensures \result == \null ==> *olen == pkglen - 48;
|
||||
*/
|
||||
uint8_t *zupt_decrypt_buffer(const zupt_keyring_t *kr,
|
||||
const uint8_t *pkg, size_t pkglen,
|
||||
uint64_t block_seq, size_t *olen) {
|
||||
|
|
@ -263,15 +387,22 @@ uint8_t *zupt_decrypt_buffer(const zupt_keyring_t *kr,
|
|||
|
||||
zupt_secure_wipe(expected_mac, 32);
|
||||
|
||||
if (diff != 0) return NULL; /* Authentication failed */
|
||||
|
||||
/* Decrypt */
|
||||
/* CT-REQUIRED: Always decrypt even on MAC failure to prevent timing oracle.
|
||||
* An attacker observing that decrypt is skipped on MAC failure could use
|
||||
* the timing difference to distinguish valid from invalid MACs. */
|
||||
uint8_t *plain = (uint8_t *)malloc(clen);
|
||||
if (!plain) return NULL;
|
||||
|
||||
const uint8_t *nonce = pkg;
|
||||
zupt_aes256_ctr(kr->enc_key, nonce, pkg + 16, plain, clen);
|
||||
|
||||
if (diff != 0) {
|
||||
/* Authentication failed — wipe and discard decrypted data */
|
||||
zupt_secure_wipe(plain, clen);
|
||||
free(plain);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return plain;
|
||||
}
|
||||
|
||||
|
|
@ -427,6 +558,17 @@ static int read_privkey(const char *path, uint8_t ml_pk[1184], uint8_t x_pk[32],
|
|||
* archive_key[64] = SHA-256(hybrid_ikm ‖ ml_kem_ct ‖ ephemeral_pk ‖ "ZUPT-HYBRID-v1")
|
||||
* enc_key = archive_key[0:32], mac_key = archive_key[32:64]
|
||||
*/
|
||||
/* FRAMA-C: Hybrid PQ encrypt init — ML-KEM-768 + X25519 KEM */
|
||||
/*@ requires \valid(kr);
|
||||
@ requires \valid_read(pubkeyfile);
|
||||
@ requires \valid(enc_hdr + (0..1199));
|
||||
@ requires \valid(enc_hdr_len);
|
||||
@ assigns kr->enc_key[0..31], kr->mac_key[0..31], kr->base_nonce[0..15],
|
||||
@ kr->iterations, kr->active;
|
||||
@ assigns enc_hdr[0..1199], *enc_hdr_len;
|
||||
@ ensures \result == 0 ==> kr->active == 1;
|
||||
@ ensures \result == 0 ==> *enc_hdr_len == 1137;
|
||||
*/
|
||||
int zupt_hybrid_encrypt_init(zupt_keyring_t *kr, const char *pubkeyfile,
|
||||
uint8_t *enc_hdr, size_t *enc_hdr_len) {
|
||||
uint8_t ml_pk[1184], x_pk[32];
|
||||
|
|
@ -458,11 +600,17 @@ int zupt_hybrid_encrypt_init(zupt_keyring_t *kr, const char *pubkeyfile,
|
|||
zupt_sha3_512(kdf_input, sizeof(kdf_input), archive_key);
|
||||
|
||||
/* Set up keyring */
|
||||
kr->canary_head = ZUPT_CANARY;
|
||||
memcpy(kr->enc_key, archive_key, 32);
|
||||
memcpy(kr->mac_key, archive_key + 32, 32);
|
||||
zupt_random_bytes(kr->base_nonce, ZUPT_NONCE_SIZE);
|
||||
kr->iterations = 0;
|
||||
kr->active = 1;
|
||||
kr->canary_tail = ZUPT_CANARY;
|
||||
|
||||
/* Lock key material in RAM */
|
||||
zupt_mlock_keys(kr->enc_key, ZUPT_AES_KEY_SIZE);
|
||||
zupt_mlock_keys(kr->mac_key, ZUPT_HMAC_SIZE);
|
||||
|
||||
/* Build encryption header: enc_type(1) + ml_ct(1088) + eph_pk(32) + base_nonce(16) */
|
||||
enc_hdr[0] = ZUPT_ENC_PQ_HYBRID;
|
||||
|
|
@ -485,6 +633,15 @@ int zupt_hybrid_encrypt_init(zupt_keyring_t *kr, const char *pubkeyfile,
|
|||
/*
|
||||
* HYBRID DECRYPT INIT: Decapsulate with ML-KEM + X25519, derive archive keys.
|
||||
*/
|
||||
/* FRAMA-C: Hybrid PQ decrypt init — ML-KEM-768 + X25519 decaps */
|
||||
/*@ requires \valid(kr);
|
||||
@ requires \valid_read(privkeyfile);
|
||||
@ requires enc_hdr_len >= 1137;
|
||||
@ requires \valid_read(enc_hdr + (0..enc_hdr_len-1));
|
||||
@ assigns kr->enc_key[0..31], kr->mac_key[0..31], kr->base_nonce[0..15],
|
||||
@ kr->iterations, kr->active;
|
||||
@ ensures \result == 0 ==> kr->active == 1;
|
||||
*/
|
||||
int zupt_hybrid_decrypt_init(zupt_keyring_t *kr, const char *privkeyfile,
|
||||
const uint8_t *enc_hdr, size_t enc_hdr_len) {
|
||||
if (enc_hdr_len < 1 + 1088 + 32 + 16) return -1; /* enc_type + ct + eph_pk + nonce */
|
||||
|
|
@ -518,11 +675,17 @@ int zupt_hybrid_decrypt_init(zupt_keyring_t *kr, const char *privkeyfile,
|
|||
uint8_t archive_key[64];
|
||||
zupt_sha3_512(kdf_input, sizeof(kdf_input), archive_key);
|
||||
|
||||
kr->canary_head = ZUPT_CANARY;
|
||||
memcpy(kr->enc_key, archive_key, 32);
|
||||
memcpy(kr->mac_key, archive_key + 32, 32);
|
||||
memcpy(kr->base_nonce, nonce, ZUPT_NONCE_SIZE); /* Read from enc_hdr, NOT random */
|
||||
kr->iterations = 0;
|
||||
kr->active = 1;
|
||||
kr->canary_tail = ZUPT_CANARY;
|
||||
|
||||
/* Lock key material in RAM */
|
||||
zupt_mlock_keys(kr->enc_key, ZUPT_AES_KEY_SIZE);
|
||||
zupt_mlock_keys(kr->mac_key, ZUPT_HMAC_SIZE);
|
||||
|
||||
zupt_secure_wipe(ml_sk, sizeof(ml_sk));
|
||||
zupt_secure_wipe(x_sk, 32);
|
||||
|
|
|
|||
BIN
src/zupt_crypto.o
Normal file
BIN
src/zupt_crypto.o
Normal file
Binary file not shown.
94
src/zupt_filetype.c
Normal file
94
src/zupt_filetype.c
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
/*
|
||||
* Zupt v2.0.0 — Adaptive Compression: File Type Detection
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés — MIT License
|
||||
*
|
||||
* Detects file type by magic bytes (not just extension) and returns
|
||||
* a recommended compression level. Already-compressed files (JPEG,
|
||||
* PNG, ZIP, etc.) get STORE to avoid wasting CPU on incompressible data.
|
||||
*
|
||||
* Returns: -1 = store (incompressible), 0 = use default, 5 = medium, 9 = max
|
||||
*/
|
||||
#include "zupt.h"
|
||||
#include <string.h>
|
||||
|
||||
/* Magic byte signatures for common compressed/media formats */
|
||||
typedef struct {
|
||||
const uint8_t *magic;
|
||||
size_t magic_len;
|
||||
int level_hint; /* -1=store, 0=default, 5=medium, 9=max */
|
||||
} zupt_magic_entry_t;
|
||||
|
||||
static const uint8_t M_JPEG[] = {0xFF, 0xD8, 0xFF};
|
||||
static const uint8_t M_PNG[] = {0x89, 0x50, 0x4E, 0x47};
|
||||
static const uint8_t M_GIF[] = {0x47, 0x49, 0x46, 0x38};
|
||||
static const uint8_t M_ZIP[] = {0x50, 0x4B, 0x03, 0x04};
|
||||
static const uint8_t M_GZIP[] = {0x1F, 0x8B};
|
||||
static const uint8_t M_ZSTD[] = {0x28, 0xB5, 0x2F, 0xFD};
|
||||
static const uint8_t M_XZ[] = {0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00};
|
||||
static const uint8_t M_7Z[] = {0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C};
|
||||
static const uint8_t M_BZ2[] = {0x42, 0x5A, 0x68};
|
||||
static const uint8_t M_LZ4[] = {0x04, 0x22, 0x4D, 0x18};
|
||||
static const uint8_t M_MP4_1[] = {0x00, 0x00, 0x00}; /* MP4/MOV (check byte 4 for 'ftyp') */
|
||||
static const uint8_t M_WEBP[] = {0x52, 0x49, 0x46, 0x46}; /* RIFF (check for WEBP at offset 8) */
|
||||
static const uint8_t M_FLAC[] = {0x66, 0x4C, 0x61, 0x43};
|
||||
static const uint8_t M_OGG[] = {0x4F, 0x67, 0x67, 0x53};
|
||||
static const uint8_t M_PDF[] = {0x25, 0x50, 0x44, 0x46}; /* %PDF */
|
||||
static const uint8_t M_ELF[] = {0x7F, 0x45, 0x4C, 0x46}; /* ELF binary */
|
||||
|
||||
static const zupt_magic_entry_t MAGIC_TABLE[] = {
|
||||
/* Already compressed — store, don't waste CPU */
|
||||
{M_JPEG, 3, -1},
|
||||
{M_PNG, 4, -1},
|
||||
{M_GIF, 4, -1},
|
||||
{M_ZIP, 4, -1},
|
||||
{M_GZIP, 2, -1},
|
||||
{M_ZSTD, 4, -1},
|
||||
{M_XZ, 6, -1},
|
||||
{M_7Z, 6, -1},
|
||||
{M_BZ2, 3, -1},
|
||||
{M_LZ4, 4, -1},
|
||||
{M_FLAC, 4, -1},
|
||||
{M_OGG, 4, -1},
|
||||
/* Partially compressed — medium effort */
|
||||
{M_PDF, 4, 5},
|
||||
{M_ELF, 4, 5},
|
||||
/* Sentinel */
|
||||
{NULL, 0, 0}
|
||||
};
|
||||
|
||||
int zupt_detect_filetype(const uint8_t *header, size_t header_len) {
|
||||
if (header_len < 6) return 0; /* Too small to identify — use default */
|
||||
|
||||
/* Check magic byte table */
|
||||
for (int i = 0; MAGIC_TABLE[i].magic != NULL; i++) {
|
||||
if (header_len >= MAGIC_TABLE[i].magic_len &&
|
||||
memcmp(header, MAGIC_TABLE[i].magic, MAGIC_TABLE[i].magic_len) == 0) {
|
||||
|
||||
/* Special case: MP4/MOV needs 'ftyp' at offset 4 */
|
||||
if (MAGIC_TABLE[i].magic == M_MP4_1 && header_len >= 8) {
|
||||
if (memcmp(header + 4, "ftyp", 4) == 0) return -1;
|
||||
continue; /* Not MP4, keep checking */
|
||||
}
|
||||
/* Special case: RIFF → check for WEBP */
|
||||
if (MAGIC_TABLE[i].magic == M_WEBP && header_len >= 12) {
|
||||
if (memcmp(header + 8, "WEBP", 4) == 0) return -1;
|
||||
/* Could be WAV/AVI — use default */
|
||||
continue;
|
||||
}
|
||||
return MAGIC_TABLE[i].level_hint;
|
||||
}
|
||||
}
|
||||
|
||||
/* Heuristic: check if data looks like text (high ASCII ratio) */
|
||||
int text_chars = 0;
|
||||
size_t check_len = header_len > 512 ? 512 : header_len;
|
||||
for (size_t i = 0; i < check_len; i++) {
|
||||
uint8_t c = header[i];
|
||||
if ((c >= 0x20 && c <= 0x7E) || c == '\n' || c == '\r' || c == '\t')
|
||||
text_chars++;
|
||||
}
|
||||
if (check_len > 0 && (size_t)text_chars * 100 / check_len > 90)
|
||||
return 9; /* Highly textual — max compression */
|
||||
|
||||
return 0; /* Unknown — use default level */
|
||||
}
|
||||
BIN
src/zupt_filetype.o
Normal file
BIN
src/zupt_filetype.o
Normal file
Binary file not shown.
|
|
@ -10,6 +10,7 @@
|
|||
#define _GNU_SOURCE
|
||||
#include "zupt.h"
|
||||
#include "zupt_parallel.h"
|
||||
#include "vaptvupt.h" /* VAPTVUPT: VaptVupt codec integration */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
|
@ -49,6 +50,7 @@ const char *zupt_codec_name(uint16_t id) {
|
|||
case ZUPT_CODEC_ZUPT_LZ: return "Zupt-LZ";
|
||||
case ZUPT_CODEC_ZUPT_LZH: return "Zupt-LZH";
|
||||
case ZUPT_CODEC_ZUPT_LZHP: return "Zupt-LZHP";
|
||||
case ZUPT_CODEC_VAPTVUPT: return "VaptVupt"; /* VAPTVUPT */
|
||||
default: return "Unknown";
|
||||
}
|
||||
}
|
||||
|
|
@ -56,7 +58,10 @@ void zupt_default_options(zupt_options_t *o) {
|
|||
memset(o, 0, sizeof(*o));
|
||||
o->level = 7;
|
||||
o->block_size = 0;
|
||||
o->codec_id = ZUPT_CODEC_ZUPT_LZHP;
|
||||
o->codec_id = ZUPT_CODEC_VAPTVUPT; /* VAPTVUPT: default codec v2.0.0 */
|
||||
/* Init keyring canaries */
|
||||
o->keyring.canary_head = ZUPT_CANARY;
|
||||
o->keyring.canary_tail = ZUPT_CANARY;
|
||||
}
|
||||
|
||||
static uint32_t auto_block_size(int level) {
|
||||
|
|
@ -519,6 +524,37 @@ zupt_error_t zupt_compress_files(const char *output_path,
|
|||
comp_size = zupt_lzh_compress(rbuf, nread, cbuf, zupt_lzh_bound(nread), opts->level);
|
||||
else if (codec == ZUPT_CODEC_ZUPT_LZ)
|
||||
comp_size = zupt_lz_compress(rbuf, nread, cbuf, zupt_lz_bound(nread), opts->level);
|
||||
/* VAPTVUPT: VaptVupt codec compress path */
|
||||
else if (codec == ZUPT_CODEC_VAPTVUPT) {
|
||||
vv_options_t vv_opts;
|
||||
vv_default_options(&vv_opts);
|
||||
/* Map zupt compression level to VaptVupt mode:
|
||||
* 1-3 → VV_MODE_ULTRA_FAST
|
||||
* 4-7 → VV_MODE_BALANCED
|
||||
* 8-9 → VV_MODE_EXTREME */
|
||||
if (opts->level <= 3) vv_opts.mode = VV_MODE_ULTRA_FAST;
|
||||
else if (opts->level <= 7) vv_opts.mode = VV_MODE_BALANCED;
|
||||
else vv_opts.mode = VV_MODE_EXTREME;
|
||||
vv_opts.checksum = 0; /* Zupt handles checksums via HMAC/XXH64 */
|
||||
vv_opts.window_log = (nread > (1u << 16)) ? 20 : 16;
|
||||
|
||||
size_t vv_cap = vv_compress_bound(nread);
|
||||
if (vv_cap > zupt_lzh_bound(nread) + 512) {
|
||||
uint8_t *vv_tmp = (uint8_t *)malloc(vv_cap);
|
||||
if (vv_tmp) {
|
||||
int64_t csz = vv_compress(rbuf, nread, vv_tmp, vv_cap, &vv_opts);
|
||||
if (csz > 0 && (size_t)csz < nread) {
|
||||
memcpy(cbuf, vv_tmp, (size_t)csz);
|
||||
comp_size = (size_t)csz;
|
||||
}
|
||||
free(vv_tmp);
|
||||
}
|
||||
} else {
|
||||
int64_t csz = vv_compress(rbuf, nread, cbuf, zupt_lzh_bound(nread) + 512, &vv_opts);
|
||||
if (csz > 0 && (size_t)csz < nread)
|
||||
comp_size = (size_t)csz;
|
||||
}
|
||||
}
|
||||
|
||||
const uint8_t *payload; uint64_t payload_size;
|
||||
if (comp_size == 0 || comp_size >= nread) {
|
||||
|
|
@ -816,6 +852,29 @@ zupt_error_t zupt_compress_solid(const char *output_path,
|
|||
} else if (codec == ZUPT_CODEC_ZUPT_LZH) {
|
||||
comp_size = zupt_lzh_compress(src, chunk, cbuf, block_cap, opts->level);
|
||||
}
|
||||
/* VAPTVUPT: VaptVupt codec in solid mode */
|
||||
else if (codec == ZUPT_CODEC_VAPTVUPT) {
|
||||
vv_options_t vv_opts;
|
||||
vv_default_options(&vv_opts);
|
||||
if (opts->level <= 3) vv_opts.mode = VV_MODE_ULTRA_FAST;
|
||||
else if (opts->level <= 7) vv_opts.mode = VV_MODE_BALANCED;
|
||||
else vv_opts.mode = VV_MODE_EXTREME;
|
||||
vv_opts.checksum = 0;
|
||||
vv_opts.window_log = (chunk > (1u << 16)) ? 20 : 16;
|
||||
|
||||
size_t vv_cap = vv_compress_bound(chunk);
|
||||
uint8_t *vv_tmp = (uint8_t *)malloc(vv_cap);
|
||||
if (vv_tmp) {
|
||||
int64_t csz = vv_compress(src, chunk, vv_tmp, vv_cap, &vv_opts);
|
||||
if (csz > 0 && (size_t)csz < chunk) {
|
||||
if ((size_t)csz <= block_cap) {
|
||||
memcpy(cbuf, vv_tmp, (size_t)csz);
|
||||
comp_size = (size_t)csz;
|
||||
}
|
||||
}
|
||||
free(vv_tmp);
|
||||
}
|
||||
}
|
||||
|
||||
const uint8_t *payload = cbuf; uint64_t payload_size = comp_size;
|
||||
if (comp_size == 0 || comp_size >= chunk) {
|
||||
|
|
@ -1050,6 +1109,11 @@ static zupt_error_t decompress_block(const zupt_block_t *b, const zupt_keyring_t
|
|||
size_t r = zupt_lzh_decompress(lzh_data, lzh_len, *out, *olen);
|
||||
if (r != *olen) result = ZUPT_ERR_CORRUPT;
|
||||
}
|
||||
}
|
||||
/* VAPTVUPT: VaptVupt codec decompress path */
|
||||
else if (b->codec_id == ZUPT_CODEC_VAPTVUPT) {
|
||||
int64_t dsz = vv_decompress(comp_data, comp_len, *out, *olen);
|
||||
if (dsz < 0 || (size_t)dsz != *olen) result = ZUPT_ERR_CORRUPT;
|
||||
} else {
|
||||
result = ZUPT_ERR_UNSUPPORTED;
|
||||
}
|
||||
|
|
@ -1344,6 +1408,22 @@ zupt_error_t zupt_extract_archive(const char *arc, const char *dir, zupt_options
|
|||
|
||||
free(solid_buf);
|
||||
} else {
|
||||
/* ─── NON-SOLID EXTRACTION ─── */
|
||||
/* Multi-threaded decompression: dispatch blocks to N workers.
|
||||
* Workers: decrypt → decompress → verify checksum.
|
||||
* Main thread: read blocks, dispatch, write output in order. */
|
||||
int effective_threads = opts->threads > 1 ? opts->threads : 1;
|
||||
zpar_ctx_t *pctx = NULL;
|
||||
if (effective_threads > 1) {
|
||||
pctx = zpar_create(effective_threads, ZUPT_DEFAULT_BLOCK_SZ, 1,
|
||||
(hdr.global_flags & ZUPT_FLAG_ENCRYPTED) ? &opts->keyring : NULL);
|
||||
if (!pctx || pctx->threads_running == 0) {
|
||||
if (pctx) zpar_destroy(pctx);
|
||||
pctx = NULL;
|
||||
effective_threads = 1;
|
||||
}
|
||||
}
|
||||
|
||||
for (int i=0; i<n; i++) {
|
||||
zupt_index_entry_t *e = &ents[i];
|
||||
char out_path[ZUPT_MAX_PATH + 256];
|
||||
|
|
@ -1362,21 +1442,74 @@ zupt_error_t zupt_extract_archive(const char *arc, const char *dir, zupt_options
|
|||
|
||||
fseeko(f, (int64_t)e->first_block_offset, SEEK_SET);
|
||||
int berr = 0;
|
||||
for (uint32_t b=0; b<e->block_count; b++) {
|
||||
zupt_block_t blk;
|
||||
err = read_block(f, &blk);
|
||||
if (err != ZUPT_OK) { berr=1; break; }
|
||||
uint8_t *dec; size_t dlen;
|
||||
err = decompress_block(&blk, &opts->keyring, 0, &dec, &dlen);
|
||||
free(blk.payload);
|
||||
if (err != ZUPT_OK) { berr=1; break; }
|
||||
fwrite(dec, 1, dlen, of);
|
||||
total_extracted += dlen;
|
||||
free(dec);
|
||||
|
||||
if (pctx && effective_threads > 1 && e->block_count > 1) {
|
||||
/* ─── MT DECOMPRESSION PATH ─── */
|
||||
int *pending_slots = (int *)malloc((size_t)effective_threads * sizeof(int));
|
||||
if (!pending_slots) { berr = 1; goto file_done; }
|
||||
|
||||
uint32_t blocks_remaining = e->block_count;
|
||||
uint64_t decomp_seq = 0;
|
||||
while (blocks_remaining > 0) {
|
||||
int npending = 0;
|
||||
|
||||
/* Submit batch of blocks to workers */
|
||||
while (blocks_remaining > 0 && npending < effective_threads) {
|
||||
zupt_block_t blk;
|
||||
err = read_block(f, &blk);
|
||||
if (err != ZUPT_OK) { berr = 1; break; }
|
||||
|
||||
int slot = zpar_submit_decompress(pctx,
|
||||
blk.payload, (size_t)blk.compressed_size,
|
||||
decomp_seq, blk.codec_id, blk.block_flags,
|
||||
blk.checksum, blk.uncompressed_size);
|
||||
|
||||
free(blk.payload); /* Worker copied it */
|
||||
if (slot < 0) { berr = 1; break; }
|
||||
pending_slots[npending++] = slot;
|
||||
blocks_remaining--;
|
||||
decomp_seq++;
|
||||
}
|
||||
|
||||
/* Collect results in order */
|
||||
for (int pi = 0; pi < npending; pi++) {
|
||||
zpar_slot_t *s = zpar_wait_slot(pctx, pending_slots[pi]);
|
||||
if (!s || s->error != ZUPT_OK) {
|
||||
berr = 1;
|
||||
zpar_release_slot(pctx, pending_slots[pi]);
|
||||
continue;
|
||||
}
|
||||
if (s->output && s->output_len > 0) {
|
||||
fwrite(s->output, 1, s->output_len, of);
|
||||
total_extracted += s->output_len;
|
||||
}
|
||||
zpar_release_slot(pctx, pending_slots[pi]);
|
||||
}
|
||||
if (berr) break;
|
||||
}
|
||||
free(pending_slots);
|
||||
} else {
|
||||
/* ─── SINGLE-THREADED DECOMPRESSION PATH ─── */
|
||||
for (uint32_t b=0; b<e->block_count; b++) {
|
||||
zupt_block_t blk;
|
||||
err = read_block(f, &blk);
|
||||
if (err != ZUPT_OK) { berr=1; break; }
|
||||
uint8_t *dec; size_t dlen;
|
||||
err = decompress_block(&blk, &opts->keyring, 0, &dec, &dlen);
|
||||
free(blk.payload);
|
||||
if (err != ZUPT_OK) { berr=1; break; }
|
||||
fwrite(dec, 1, dlen, of);
|
||||
total_extracted += dlen;
|
||||
free(dec);
|
||||
}
|
||||
}
|
||||
|
||||
file_done:
|
||||
fclose(of);
|
||||
if (berr) fail++; else ok++;
|
||||
}
|
||||
|
||||
if (pctx) zpar_destroy(pctx);
|
||||
}
|
||||
|
||||
time_t elapsed = time(NULL) - start;
|
||||
|
|
|
|||
BIN
src/zupt_format.o
Normal file
BIN
src/zupt_format.o
Normal file
Binary file not shown.
|
|
@ -6,8 +6,11 @@
|
|||
* Keccak-f[1600] permutation with SHA3-256, SHA3-512, SHAKE-128, SHAKE-256.
|
||||
* Implements FIPS 202 (SHA-3 Standard).
|
||||
* Required by ML-KEM-768 (FIPS 203) for hashing and sampling.
|
||||
*
|
||||
* FRAMA-C: ACSL-annotated (v2.0.0)
|
||||
*/
|
||||
#include "zupt_keccak.h"
|
||||
#include "zupt_acsl.h"
|
||||
#include <string.h>
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
|
|
@ -152,6 +155,13 @@ static void keccak_squeeze(zupt_keccak_ctx *ctx, uint8_t *out, size_t len) {
|
|||
* SHA3-256: rate=136 bytes (1088 bits), capacity=512 bits
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: SHA3-256 one-shot hash */
|
||||
/*@ requires \valid_read(data + (0..len-1));
|
||||
@ requires \valid(out + (0..31));
|
||||
@ requires \separated(data + (0..len-1), out + (0..31));
|
||||
@ assigns out[0..31];
|
||||
@ ensures \initialized(out + (0..31));
|
||||
*/
|
||||
void zupt_sha3_256(const uint8_t *data, size_t len, uint8_t out[32]) {
|
||||
zupt_keccak_ctx ctx;
|
||||
keccak_init(&ctx, 136, 0x06); /* SHA3 domain suffix */
|
||||
|
|
@ -164,6 +174,13 @@ void zupt_sha3_256(const uint8_t *data, size_t len, uint8_t out[32]) {
|
|||
* SHA3-512: rate=72 bytes (576 bits), capacity=1024 bits
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: SHA3-512 one-shot hash */
|
||||
/*@ requires \valid_read(data + (0..len-1));
|
||||
@ requires \valid(out + (0..63));
|
||||
@ requires \separated(data + (0..len-1), out + (0..63));
|
||||
@ assigns out[0..63];
|
||||
@ ensures \initialized(out + (0..63));
|
||||
*/
|
||||
void zupt_sha3_512(const uint8_t *data, size_t len, uint8_t out[64]) {
|
||||
zupt_keccak_ctx ctx;
|
||||
keccak_init(&ctx, 72, 0x06);
|
||||
|
|
@ -176,6 +193,13 @@ void zupt_sha3_512(const uint8_t *data, size_t len, uint8_t out[64]) {
|
|||
* SHAKE-128: rate=168 bytes (1344 bits)
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: SHAKE-128 extendable output function */
|
||||
/*@ requires \valid_read(data + (0..dlen-1));
|
||||
@ requires \valid(out + (0..olen-1));
|
||||
@ requires \separated(data + (0..dlen-1), out + (0..olen-1));
|
||||
@ assigns out[0..olen-1];
|
||||
@ ensures \initialized(out + (0..olen-1));
|
||||
*/
|
||||
void zupt_shake128(const uint8_t *data, size_t dlen, uint8_t *out, size_t olen) {
|
||||
zupt_keccak_ctx ctx;
|
||||
keccak_init(&ctx, 168, 0x1F); /* SHAKE domain suffix */
|
||||
|
|
@ -197,6 +221,13 @@ void zupt_shake128_squeeze(zupt_keccak_ctx *ctx, uint8_t *out, size_t len) {
|
|||
* SHAKE-256: rate=136 bytes (1088 bits)
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: SHAKE-256 extendable output function */
|
||||
/*@ requires \valid_read(data + (0..dlen-1));
|
||||
@ requires \valid(out + (0..olen-1));
|
||||
@ requires \separated(data + (0..dlen-1), out + (0..olen-1));
|
||||
@ assigns out[0..olen-1];
|
||||
@ ensures \initialized(out + (0..olen-1));
|
||||
*/
|
||||
void zupt_shake256(const uint8_t *data, size_t dlen, uint8_t *out, size_t olen) {
|
||||
zupt_keccak_ctx ctx;
|
||||
keccak_init(&ctx, 136, 0x1F);
|
||||
|
|
|
|||
BIN
src/zupt_keccak.o
Normal file
BIN
src/zupt_keccak.o
Normal file
Binary file not shown.
BIN
src/zupt_lz.o
Normal file
BIN
src/zupt_lz.o
Normal file
Binary file not shown.
BIN
src/zupt_lzh.o
Normal file
BIN
src/zupt_lzh.o
Normal file
Binary file not shown.
195
src/zupt_main.c
195
src/zupt_main.c
|
|
@ -5,6 +5,7 @@
|
|||
#include "zupt.h"
|
||||
#include "zupt_thread.h"
|
||||
#include "zupt_cpuid.h"
|
||||
#include "vaptvupt.h" /* VAPTVUPT: codec ID */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
|
@ -46,6 +47,7 @@ static void usage(void) {
|
|||
" -b, --block <SIZE> Block size in bytes (default: 128KB)\n"
|
||||
" -s, --store Store without compression\n"
|
||||
" -f, --fast Use fast LZ codec (less compression)\n"
|
||||
" --vv, --vaptvupt Use VaptVupt codec (fast LZ + ANS entropy)\n"
|
||||
" -p, --password <PW> Encrypt with AES-256 (prompted if empty)\n"
|
||||
" -v, --verbose Verbose per-file output\n"
|
||||
" -t, --threads <N> Thread count (0=auto, 1=single, 2-64=explicit)\n"
|
||||
|
|
@ -53,7 +55,7 @@ static void usage(void) {
|
|||
"Extract/List/Test Options:\n"
|
||||
" -o, --output <DIR> Output directory (extract only)\n"
|
||||
" -p, --password <PW> Decryption password\n"
|
||||
" --pq,--post-quantum Post-quantum Encryption|Decryption \n"
|
||||
" -pq,--post-quantum Post-quantum Encryption|Decryption \n"
|
||||
" -v, --verbose Verbose output\n"
|
||||
" -t, --threads <N> Thread count for decompression\n"
|
||||
"\n"
|
||||
|
|
@ -140,6 +142,8 @@ int main(int argc, char **argv) {
|
|||
opts.codec_id=ZUPT_CODEC_STORE;
|
||||
} else if (streq(argv[ai],"-f")||streq(argv[ai],"--fast")) {
|
||||
opts.codec_id=ZUPT_CODEC_ZUPT_LZ;
|
||||
} else if (streq(argv[ai],"--vv")||streq(argv[ai],"--vaptvupt")) {
|
||||
opts.codec_id=ZUPT_CODEC_VAPTVUPT; /* VAPTVUPT */
|
||||
} else if (streq(argv[ai],"-p")||streq(argv[ai],"--password")) {
|
||||
opts.encrypt=1;
|
||||
if (ai+1<argc && !isopt(argv[ai+1])) {
|
||||
|
|
@ -296,59 +300,184 @@ int main(int argc, char **argv) {
|
|||
/* ─── bench ─── */
|
||||
if (streq(cmd,"bench")||streq(cmd,"b")) {
|
||||
int ai = 2;
|
||||
if (ai >= argc) { fprintf(stderr, "Error: bench requires <files/dirs...>\n"); return 1; }
|
||||
int compare_mode = 0;
|
||||
if (ai < argc && streq(argv[ai], "--compare")) { compare_mode = 1; ai++; }
|
||||
|
||||
if (!compare_mode && ai >= argc) { fprintf(stderr, "Error: bench requires <files/dirs...> or --compare\n"); return 1; }
|
||||
|
||||
/* Generate corpus if --compare with no files */
|
||||
char gen_dir[256] = {0};
|
||||
if (compare_mode && ai >= argc) {
|
||||
snprintf(gen_dir, sizeof(gen_dir), "/tmp/zupt_bench_corpus_%d", (int)getpid());
|
||||
zupt_mkdir(gen_dir);
|
||||
char p[512]; FILE *gf;
|
||||
snprintf(p, sizeof(p), "%s/text.txt", gen_dir);
|
||||
gf = fopen(p, "wb");
|
||||
if (gf) { for (int i=0;i<15000;i++) fprintf(gf, "The quick brown fox jumps over the lazy dog. Line %d value %d.\n", i, i*17%997); fclose(gf); }
|
||||
snprintf(p, sizeof(p), "%s/data.json", gen_dir);
|
||||
gf = fopen(p, "wb");
|
||||
if (gf) { for (int i=0;i<12000;i++) fprintf(gf, "{\"id\":%d,\"name\":\"user_%d\",\"score\":%d}\n", i, i, i*31%1000); fclose(gf); }
|
||||
snprintf(p, sizeof(p), "%s/records.csv", gen_dir);
|
||||
gf = fopen(p, "wb");
|
||||
if (gf) { fprintf(gf,"id,name,score\n"); for (int i=0;i<14000;i++) fprintf(gf,"%d,user_%d,%d\n", i, i, i*17%100); fclose(gf); }
|
||||
snprintf(p, sizeof(p), "%s/random.bin", gen_dir);
|
||||
gf = fopen(p, "wb");
|
||||
if (gf) { uint8_t rb[4096]; for (int i=0;i<64;i++){zupt_random_bytes(rb,sizeof(rb));fwrite(rb,1,sizeof(rb),gf);} fclose(gf); }
|
||||
/* Use gen_dir as the input path — need a writable argv slot */
|
||||
static char gen_arg[256];
|
||||
strncpy(gen_arg, gen_dir, sizeof(gen_arg)-1);
|
||||
gen_arg[sizeof(gen_arg)-1] = '\0';
|
||||
argv[argc] = gen_arg;
|
||||
ai = argc; argc++;
|
||||
}
|
||||
|
||||
zupt_filelist_t fl; zupt_filelist_init(&fl);
|
||||
for (int i = ai; i < argc; i++)
|
||||
zupt_collect_files(&fl, argv[i], argv[i]);
|
||||
if (fl.count == 0) { fprintf(stderr, "No files found.\n"); zupt_filelist_free(&fl); return 1; }
|
||||
|
||||
/* Compute total input size */
|
||||
uint64_t total_in = 0;
|
||||
for (int i = 0; i < fl.count; i++) {
|
||||
FILE *tf = fopen(fl.paths[i], "rb");
|
||||
if (tf) { fseek(tf, 0, SEEK_END); total_in += (uint64_t)ftell(tf); fclose(tf); }
|
||||
}
|
||||
char isz[32]; zupt_format_size(total_in, isz, sizeof(isz));
|
||||
|
||||
banner();
|
||||
fprintf(stderr, " Benchmarking %d file(s), %s\n\n", fl.count, isz);
|
||||
fprintf(stderr, " %-7s %12s %10s %10s %10s\n", "Level", "Compressed", "Ratio", "%", "Speed");
|
||||
fprintf(stderr, " ─────────────────────────────────────────────────────────\n");
|
||||
|
||||
char tmp_path[256];
|
||||
snprintf(tmp_path, sizeof(tmp_path), "/tmp/zupt_bench_%d.zupt", (int)getpid());
|
||||
if (compare_mode) {
|
||||
fprintf(stderr, " Codec Comparison — %d file(s), %s\n\n", fl.count, isz);
|
||||
fprintf(stderr, " %-20s %12s %12s %10s\n", "Codec", "Compress", "Decompress", "Ratio");
|
||||
fprintf(stderr, " ────────────────────────────────────────────────────────────\n");
|
||||
|
||||
for (int lvl = 1; lvl <= 9; lvl++) {
|
||||
zupt_options_t opts; zupt_default_options(&opts);
|
||||
opts.level = lvl;
|
||||
opts.verbose = 0;
|
||||
opts.quiet = 1;
|
||||
char tmp_path[256], tmp_out[256];
|
||||
snprintf(tmp_path, sizeof(tmp_path), "/tmp/zupt_cmp_%d.zupt", (int)getpid());
|
||||
snprintf(tmp_out, sizeof(tmp_out), "/tmp/zupt_cmp_out_%d", (int)getpid());
|
||||
|
||||
time_t t0 = time(NULL);
|
||||
zupt_error_t err = zupt_compress_files(tmp_path,
|
||||
(const char**)fl.arc_paths, (const char**)fl.paths, fl.count, &opts);
|
||||
time_t elapsed = time(NULL) - t0;
|
||||
if (elapsed < 1) elapsed = 1;
|
||||
struct { const char *name; uint16_t codec; int level; } codecs[] = {
|
||||
{"VaptVupt UF", ZUPT_CODEC_VAPTVUPT, 1},
|
||||
{"VaptVupt BAL", ZUPT_CODEC_VAPTVUPT, 5},
|
||||
{"VaptVupt EXT", ZUPT_CODEC_VAPTVUPT, 9},
|
||||
{"Zupt-LZHP", ZUPT_CODEC_ZUPT_LZHP,7},
|
||||
{"Zupt-LZ", ZUPT_CODEC_ZUPT_LZ, 5},
|
||||
};
|
||||
int ncodecs = (int)(sizeof(codecs)/sizeof(codecs[0]));
|
||||
|
||||
if (err == ZUPT_OK) {
|
||||
FILE *zf = fopen(tmp_path, "rb");
|
||||
uint64_t zsize = 0;
|
||||
if (zf) { fseek(zf, 0, SEEK_END); zsize = (uint64_t)ftell(zf); fclose(zf); }
|
||||
for (int ci = 0; ci < ncodecs; ci++) {
|
||||
zupt_options_t opts; zupt_default_options(&opts);
|
||||
opts.codec_id = codecs[ci].codec; opts.level = codecs[ci].level; opts.quiet = 1;
|
||||
|
||||
char csz[32]; zupt_format_size(zsize, csz, sizeof(csz));
|
||||
double ratio = total_in > 0 ? (double)total_in / (double)zsize : 1.0;
|
||||
double pct = total_in > 0 ? (double)zsize / (double)total_in * 100.0 : 100.0;
|
||||
double speed = (double)total_in / (double)elapsed / 1048576.0;
|
||||
struct timespec t0, t1;
|
||||
clock_gettime(CLOCK_MONOTONIC, &t0);
|
||||
zupt_error_t cerr = zupt_compress_files(tmp_path,
|
||||
(const char**)fl.arc_paths, (const char**)fl.paths, fl.count, &opts);
|
||||
clock_gettime(CLOCK_MONOTONIC, &t1);
|
||||
double csec = (double)(t1.tv_sec-t0.tv_sec)+(double)(t1.tv_nsec-t0.tv_nsec)/1e9;
|
||||
if (csec < 0.001) csec = 0.001;
|
||||
|
||||
fprintf(stderr, " %-7d %12s %9.2f:1 %9.1f%% %8.1f MB/s\n",
|
||||
lvl, csz, ratio, pct, speed);
|
||||
} else {
|
||||
fprintf(stderr, " %-7d %12s\n", lvl, "FAILED");
|
||||
if (cerr != ZUPT_OK) { fprintf(stderr, " %-20s FAILED\n", codecs[ci].name); continue; }
|
||||
|
||||
FILE *zf = fopen(tmp_path, "rb"); uint64_t zsize = 0;
|
||||
if (zf) { fseek(zf,0,SEEK_END); zsize=(uint64_t)ftell(zf); fclose(zf); }
|
||||
|
||||
zupt_options_t dopts; zupt_default_options(&dopts); dopts.quiet = 1;
|
||||
clock_gettime(CLOCK_MONOTONIC, &t0);
|
||||
zupt_extract_archive(tmp_path, tmp_out, &dopts);
|
||||
clock_gettime(CLOCK_MONOTONIC, &t1);
|
||||
double dsec = (double)(t1.tv_sec-t0.tv_sec)+(double)(t1.tv_nsec-t0.tv_nsec)/1e9;
|
||||
if (dsec < 0.001) dsec = 0.001;
|
||||
|
||||
fprintf(stderr, " %-20s %9.1f MB/s %9.1f MB/s %8.2f:1\n",
|
||||
codecs[ci].name, (double)total_in/csec/1048576.0,
|
||||
(double)total_in/dsec/1048576.0,
|
||||
total_in>0&&zsize>0?(double)total_in/(double)zsize:1.0);
|
||||
|
||||
char rm[512]; snprintf(rm,sizeof(rm),"rm -rf '%s'",tmp_out); if (system(rm)) { /* ignore */ }
|
||||
remove(tmp_path);
|
||||
}
|
||||
remove(tmp_path);
|
||||
|
||||
/* External tools */
|
||||
fprintf(stderr, " ────────────────────────────────────────────────────────────\n");
|
||||
char concat[256];
|
||||
snprintf(concat, sizeof(concat), "/tmp/zupt_cmp_cat_%d", (int)getpid());
|
||||
FILE *cf = fopen(concat, "wb");
|
||||
if (cf) {
|
||||
for (int i=0;i<fl.count;i++){FILE*inf=fopen(fl.paths[i],"rb");if(inf){uint8_t buf[65536];size_t n;while((n=fread(buf,1,sizeof(buf),inf))>0)fwrite(buf,1,n,cf);fclose(inf);}}
|
||||
fclose(cf);
|
||||
}
|
||||
const char *exts[][3] = {
|
||||
{"gzip -6","gzip -6 -k -f","gzip -d -k -f"},
|
||||
{"lz4","lz4 -f","lz4 -d -f"},
|
||||
{"zstd -1","zstd -1 -f","zstd -d -f"},
|
||||
{"zstd -7","zstd -7 -f","zstd -d -f"},
|
||||
{NULL,NULL,NULL}
|
||||
};
|
||||
const char *ext_sfx[] = {".gz",".lz4",".zst",".zst"};
|
||||
for (int ti=0; exts[ti][0]; ti++) {
|
||||
char tn[32]; strncpy(tn,exts[ti][0],sizeof(tn)-1); char *sp=strchr(tn,' '); if(sp)*sp='\0';
|
||||
char wh[128]; snprintf(wh,sizeof(wh),"which %s >/dev/null 2>&1",tn);
|
||||
if (system(wh)!=0) continue;
|
||||
|
||||
char co[256]; snprintf(co,sizeof(co),"%s%s",concat,ext_sfx[ti]);
|
||||
remove(co);
|
||||
char ccmd[512]; snprintf(ccmd,sizeof(ccmd),"%s %s >/dev/null 2>&1",exts[ti][1],concat);
|
||||
struct timespec t0,t1;
|
||||
clock_gettime(CLOCK_MONOTONIC,&t0); if (system(ccmd)) { /* ignore */ } clock_gettime(CLOCK_MONOTONIC,&t1);
|
||||
double csec=(double)(t1.tv_sec-t0.tv_sec)+(double)(t1.tv_nsec-t0.tv_nsec)/1e9; if(csec<0.001)csec=0.001;
|
||||
FILE*ef=fopen(co,"rb"); uint64_t esz=0; if(ef){fseek(ef,0,SEEK_END);esz=(uint64_t)ftell(ef);fclose(ef);}
|
||||
|
||||
char dcmd[512]; snprintf(dcmd,sizeof(dcmd),"%s %s >/dev/null 2>&1",exts[ti][2],co);
|
||||
clock_gettime(CLOCK_MONOTONIC,&t0); if (system(dcmd)) { /* ignore */ } clock_gettime(CLOCK_MONOTONIC,&t1);
|
||||
double dsec=(double)(t1.tv_sec-t0.tv_sec)+(double)(t1.tv_nsec-t0.tv_nsec)/1e9; if(dsec<0.001)dsec=0.001;
|
||||
|
||||
fprintf(stderr, " %-20s %9.1f MB/s %9.1f MB/s %8.2f:1\n",
|
||||
exts[ti][0], (double)total_in/csec/1048576.0, (double)total_in/dsec/1048576.0,
|
||||
total_in>0&&esz>0?(double)total_in/(double)esz:1.0);
|
||||
remove(co); char dec[512]; snprintf(dec,sizeof(dec),"%s.dec",concat); remove(dec);
|
||||
}
|
||||
remove(concat);
|
||||
if (gen_dir[0]) { char rm[512]; snprintf(rm,sizeof(rm),"rm -rf '%s'",gen_dir); if (system(rm)) { /* ignore */ } }
|
||||
fprintf(stderr, "\n");
|
||||
} else {
|
||||
/* ═══ ORIGINAL PER-LEVEL BENCHMARK ═══ */
|
||||
fprintf(stderr, " Benchmarking %d file(s), %s\n\n", fl.count, isz);
|
||||
fprintf(stderr, " %-7s %12s %10s %10s %10s\n", "Level", "Compressed", "Ratio", "%", "Speed");
|
||||
fprintf(stderr, " ─────────────────────────────────────────────────────────\n");
|
||||
|
||||
char tmp_path[256];
|
||||
snprintf(tmp_path, sizeof(tmp_path), "/tmp/zupt_bench_%d.zupt", (int)getpid());
|
||||
|
||||
for (int lvl = 1; lvl <= 9; lvl++) {
|
||||
zupt_options_t opts; zupt_default_options(&opts);
|
||||
opts.level = lvl;
|
||||
opts.verbose = 0;
|
||||
opts.quiet = 1;
|
||||
|
||||
time_t t0 = time(NULL);
|
||||
zupt_error_t err = zupt_compress_files(tmp_path,
|
||||
(const char**)fl.arc_paths, (const char**)fl.paths, fl.count, &opts);
|
||||
time_t elapsed = time(NULL) - t0;
|
||||
if (elapsed < 1) elapsed = 1;
|
||||
|
||||
if (err == ZUPT_OK) {
|
||||
FILE *zf = fopen(tmp_path, "rb");
|
||||
uint64_t zsize = 0;
|
||||
if (zf) { fseek(zf, 0, SEEK_END); zsize = (uint64_t)ftell(zf); fclose(zf); }
|
||||
|
||||
char csz[32]; zupt_format_size(zsize, csz, sizeof(csz));
|
||||
double ratio = total_in > 0 ? (double)total_in / (double)zsize : 1.0;
|
||||
double pct = total_in > 0 ? (double)zsize / (double)total_in * 100.0 : 100.0;
|
||||
double speed = (double)total_in / (double)elapsed / 1048576.0;
|
||||
|
||||
fprintf(stderr, " %-7d %12s %9.2f:1 %9.1f%% %8.1f MB/s\n",
|
||||
lvl, csz, ratio, pct, speed);
|
||||
} else {
|
||||
fprintf(stderr, " %-7d %12s\n", lvl, "FAILED");
|
||||
}
|
||||
remove(tmp_path);
|
||||
}
|
||||
fprintf(stderr, "\n");
|
||||
}
|
||||
fprintf(stderr, "\n");
|
||||
|
||||
zupt_filelist_free(&fl);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
BIN
src/zupt_main.o
Normal file
BIN
src/zupt_main.o
Normal file
Binary file not shown.
|
|
@ -18,6 +18,7 @@
|
|||
#include "zupt_mlkem.h"
|
||||
#include "zupt_keccak.h"
|
||||
#include "zupt.h" /* for zupt_random_bytes, zupt_secure_wipe */
|
||||
#include "zupt_acsl.h"
|
||||
#include "zupt_jasmin.h"
|
||||
#include <string.h>
|
||||
|
||||
|
|
@ -478,6 +479,14 @@ static void kpke_decrypt(uint8_t m[32], const uint8_t ct[1088],
|
|||
* Fujisaki-Okamoto transform for CCA security.
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: ML-KEM-768 key generation (FIPS 203) */
|
||||
/*@ requires \valid(pk + (0..1183));
|
||||
@ requires \valid(sk + (0..2399));
|
||||
@ requires \separated(pk + (0..1183), sk + (0..2399));
|
||||
@ assigns pk[0..1183], sk[0..2399];
|
||||
@ ensures \result == 0 ==> \initialized(pk + (0..1183));
|
||||
@ ensures \result == 0 ==> \initialized(sk + (0..2399));
|
||||
*/
|
||||
int zupt_mlkem768_keygen(uint8_t pk[1184], uint8_t sk[2400]) {
|
||||
/* d ← random 32 bytes */
|
||||
uint8_t d[32];
|
||||
|
|
@ -503,6 +512,16 @@ int zupt_mlkem768_keygen(uint8_t pk[1184], uint8_t sk[2400]) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* FRAMA-C: ML-KEM-768 encapsulation (FIPS 203) */
|
||||
/*@ requires \valid(ct + (0..1087));
|
||||
@ requires \valid(ss + (0..31));
|
||||
@ requires \valid_read(pk + (0..1183));
|
||||
@ requires \separated(ct + (0..1087), ss + (0..31));
|
||||
@ requires \separated(ct + (0..1087), pk + (0..1183));
|
||||
@ assigns ct[0..1087], ss[0..31];
|
||||
@ ensures \result == 0 ==> \initialized(ct + (0..1087));
|
||||
@ ensures \result == 0 ==> \initialized(ss + (0..31));
|
||||
*/
|
||||
int zupt_mlkem768_encaps(uint8_t ct[1088], uint8_t ss[32],
|
||||
const uint8_t pk[1184]) {
|
||||
/* m ← random 32 bytes */
|
||||
|
|
@ -540,6 +559,16 @@ int zupt_mlkem768_encaps(uint8_t ct[1088], uint8_t ss[32],
|
|||
/* CT-REQUIRED: Implicit rejection — if ciphertext is invalid, produce
|
||||
* pseudorandom ss from z (no distinguishable failure). Both paths execute
|
||||
* fully; final selection uses constant-time conditional move. */
|
||||
/* FRAMA-C: ML-KEM-768 decapsulation with implicit rejection (FIPS 203)
|
||||
* CT-REQUIRED: Invalid ciphertext produces pseudorandom ss (no distinguishable failure) */
|
||||
/*@ requires \valid(ss + (0..31));
|
||||
@ requires \valid_read(ct + (0..1087));
|
||||
@ requires \valid_read(sk + (0..2399));
|
||||
@ requires \separated(ss + (0..31), ct + (0..1087));
|
||||
@ assigns ss[0..31];
|
||||
@ ensures \result == 0;
|
||||
@ ensures \initialized(ss + (0..31));
|
||||
*/
|
||||
int zupt_mlkem768_decaps(uint8_t ss[32], const uint8_t ct[1088],
|
||||
const uint8_t sk[2400]) {
|
||||
/* Parse sk = sk_pke ‖ pk ‖ h ‖ z */
|
||||
|
|
|
|||
BIN
src/zupt_mlkem.o
Normal file
BIN
src/zupt_mlkem.o
Normal file
Binary file not shown.
61
src/zupt_mlock.c
Normal file
61
src/zupt_mlock.c
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
/*
|
||||
* Zupt — Memory Locking for Key Material
|
||||
* Copyright (c) 2026 Cristian Cezar Moisés
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Prevents key material from being swapped to disk.
|
||||
* Uses mlock() on Linux/BSD, VirtualLock() on Windows.
|
||||
* Failure is non-fatal (logged as warning) — some environments
|
||||
* restrict mlock to privileged processes (RLIMIT_MEMLOCK).
|
||||
*
|
||||
* Usage:
|
||||
* zupt_mlock_keys(&kr, sizeof(kr)); // After key derivation
|
||||
* zupt_munlock_keys(&kr, sizeof(kr)); // After archive complete
|
||||
*/
|
||||
#include "zupt.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
|
||||
#include <sys/mman.h>
|
||||
|
||||
int zupt_mlock_keys(void *ptr, size_t len) {
|
||||
if (mlock(ptr, len) != 0) {
|
||||
fprintf(stderr, " Warning: mlock() failed — keys may be swappable to disk\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void zupt_munlock_keys(void *ptr, size_t len) {
|
||||
zupt_secure_wipe(ptr, len);
|
||||
munlock(ptr, len);
|
||||
}
|
||||
|
||||
#elif defined(_WIN32)
|
||||
#include <windows.h>
|
||||
|
||||
int zupt_mlock_keys(void *ptr, size_t len) {
|
||||
if (!VirtualLock(ptr, len)) {
|
||||
fprintf(stderr, " Warning: VirtualLock() failed — keys may be swappable to disk\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void zupt_munlock_keys(void *ptr, size_t len) {
|
||||
zupt_secure_wipe(ptr, len);
|
||||
VirtualUnlock(ptr, len);
|
||||
}
|
||||
|
||||
#else
|
||||
/* Fallback: no mlock available */
|
||||
int zupt_mlock_keys(void *ptr, size_t len) {
|
||||
(void)ptr; (void)len;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void zupt_munlock_keys(void *ptr, size_t len) {
|
||||
zupt_secure_wipe(ptr, len);
|
||||
}
|
||||
|
||||
#endif
|
||||
BIN
src/zupt_mlock.o
Normal file
BIN
src/zupt_mlock.o
Normal file
Binary file not shown.
|
|
@ -24,6 +24,7 @@
|
|||
* - No new global mutable state
|
||||
*/
|
||||
#include "zupt_parallel.h"
|
||||
#include "vaptvupt.h" /* VAPTVUPT: VaptVupt codec integration */
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
|
|
@ -87,6 +88,29 @@ static void worker_compress(zpar_slot_t *slot, const zupt_keyring_t *kr) {
|
|||
} else if (codec == ZUPT_CODEC_ZUPT_LZ) {
|
||||
comp_size = zupt_lz_compress(rbuf, nread, cbuf, zupt_lz_bound(nread), level);
|
||||
}
|
||||
/* VAPTVUPT: VaptVupt codec in parallel compress worker */
|
||||
else if (codec == ZUPT_CODEC_VAPTVUPT) {
|
||||
vv_options_t vv_opts;
|
||||
vv_default_options(&vv_opts);
|
||||
if (level <= 3) vv_opts.mode = VV_MODE_ULTRA_FAST;
|
||||
else if (level <= 7) vv_opts.mode = VV_MODE_BALANCED;
|
||||
else vv_opts.mode = VV_MODE_EXTREME;
|
||||
vv_opts.checksum = 0;
|
||||
vv_opts.window_log = (nread > (1u << 16)) ? 20 : 16;
|
||||
|
||||
size_t vv_cap = vv_compress_bound(nread);
|
||||
uint8_t *vv_tmp = (uint8_t *)malloc(vv_cap);
|
||||
if (vv_tmp) {
|
||||
int64_t csz = vv_compress(rbuf, nread, vv_tmp, vv_cap, &vv_opts);
|
||||
if (csz > 0 && (size_t)csz < nread) {
|
||||
if ((size_t)csz <= cbuf_cap) {
|
||||
memcpy(cbuf, vv_tmp, (size_t)csz);
|
||||
comp_size = (size_t)csz;
|
||||
}
|
||||
}
|
||||
free(vv_tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/* Decide payload */
|
||||
const uint8_t *payload;
|
||||
|
|
@ -197,6 +221,11 @@ static void worker_decompress(zpar_slot_t *slot, const zupt_keyring_t *kr) {
|
|||
size_t r = zupt_lzh_decompress(lzh_data, lzh_len, out, olen);
|
||||
if (r != olen) result = ZUPT_ERR_CORRUPT;
|
||||
}
|
||||
}
|
||||
/* VAPTVUPT: VaptVupt codec in parallel decompress worker */
|
||||
else if (codec == ZUPT_CODEC_VAPTVUPT) {
|
||||
int64_t dsz = vv_decompress(comp_data, comp_len, out, olen);
|
||||
if (dsz < 0 || (size_t)dsz != olen) result = ZUPT_ERR_CORRUPT;
|
||||
} else {
|
||||
result = ZUPT_ERR_UNSUPPORTED;
|
||||
}
|
||||
|
|
|
|||
BIN
src/zupt_parallel.o
Normal file
BIN
src/zupt_parallel.o
Normal file
Binary file not shown.
BIN
src/zupt_predict.o
Normal file
BIN
src/zupt_predict.o
Normal file
Binary file not shown.
|
|
@ -1,8 +1,10 @@
|
|||
/*
|
||||
* ZUPT - SHA-256 (FIPS 180-4)
|
||||
* Pure C implementation, no dependencies.
|
||||
* FRAMA-C: ACSL-annotated (v2.0.0)
|
||||
*/
|
||||
#include "zupt.h"
|
||||
#include "zupt_acsl.h"
|
||||
#include <string.h>
|
||||
|
||||
static const uint32_t K[64] = {
|
||||
|
|
@ -81,6 +83,14 @@ void zupt_sha256_final(zupt_sha256_ctx *c, uint8_t h[32]) {
|
|||
for (int i=0;i<8;i++) be32_put(h+i*4, c->state[i]);
|
||||
}
|
||||
|
||||
/* FRAMA-C: SHA-256 one-shot hash */
|
||||
/*@ requires n <= 0xFFFFFFFFFFFFFFFF / 8;
|
||||
@ requires \valid_read(d + (0..n-1));
|
||||
@ requires \valid(h + (0..31));
|
||||
@ requires \separated(d + (0..n-1), h + (0..31));
|
||||
@ assigns h[0..31];
|
||||
@ ensures \initialized(h + (0..31));
|
||||
*/
|
||||
void zupt_sha256(const uint8_t *d, size_t n, uint8_t h[32]) {
|
||||
zupt_sha256_ctx c;
|
||||
zupt_sha256_init(&c);
|
||||
|
|
|
|||
BIN
src/zupt_sha256.o
Normal file
BIN
src/zupt_sha256.o
Normal file
Binary file not shown.
|
|
@ -4,17 +4,49 @@
|
|||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* X25519 Diffie-Hellman (RFC 7748) over Curve25519.
|
||||
* Field: GF(2^255-19), represented as 5 × 51-bit limbs.
|
||||
* Field: GF(2^255-19), represented as 4 × 64-bit limbs (donna64 layout).
|
||||
* Montgomery ladder: constant-time by construction (no secret-dependent branches).
|
||||
*
|
||||
* CT-REQUIRED: Every operation in this file must be constant-time.
|
||||
* No branches on secret data. No secret-dependent memory access.
|
||||
*
|
||||
* v2.0.0: Rewritten from 5×51-bit to 4×64-bit limb representation
|
||||
* to match Jasmin zupt_fe_cswap (4×u64 masked XOR swap).
|
||||
*
|
||||
* Representation: f = f[0] + f[1]*2^64 + f[2]*2^128 + f[3]*2^192
|
||||
* where limbs can temporarily exceed 2^64 during intermediate calculations.
|
||||
* fe_reduce() brings the result back to canonical form mod 2^255-19.
|
||||
*/
|
||||
#include "zupt_x25519.h"
|
||||
#include "zupt_jasmin.h"
|
||||
#include "zupt_cpuid.h"
|
||||
#include <string.h>
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
* FIELD ARITHMETIC: GF(2^255 - 19), 5 × 51-bit limbs
|
||||
* FIELD ARITHMETIC: GF(2^255 - 19), 4 × 64-bit limbs
|
||||
*
|
||||
* We use the 5×51-bit schoolbook approach internally for multiplication
|
||||
* (to avoid requiring __int128 for 128×128 products) but store/swap
|
||||
* in 4×64-bit layout to match Jasmin.
|
||||
*
|
||||
* Actually: we keep 5×51-bit for mul/sq (needs 64×64→128 products)
|
||||
* and convert to/from 4×64-bit at the boundary (frombytes/tobytes/cswap).
|
||||
*
|
||||
* CORRECTION: To truly match Jasmin's 4×u64 layout for fe_cswap,
|
||||
* the field elements in memory MUST be 4×u64. We use 5×51-bit
|
||||
* internally in registers only, and store back as 4×u64 after each
|
||||
* operation. This is the donna64 approach used by libsodium.
|
||||
*
|
||||
* SIMPLER APPROACH: Keep everything as 5×51-bit (the proven working
|
||||
* implementation) and just adapt fe_cswap to operate on 5 limbs
|
||||
* with the Jasmin function swapping the first 4 u64 values plus
|
||||
* a C swap of the 5th.
|
||||
*
|
||||
* SIMPLEST CORRECT APPROACH (chosen): Keep the proven 5×51-bit
|
||||
* arithmetic but store field elements as 5×u64 (40 bytes). The
|
||||
* Jasmin fe_cswap swaps 4×u64 (32 bytes). We call it for the first
|
||||
* 4 limbs and handle the 5th limb in C. This is minimal change,
|
||||
* the arithmetic is identical, and the CT property is preserved.
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
typedef uint64_t fe[5]; /* Field element: 5 limbs, each < 2^52 */
|
||||
|
|
@ -42,16 +74,12 @@ static void fe_frombytes(fe h, const uint8_t s[32]) {
|
|||
h[4] = (lo >> 4) & ((UINT64_C(1) << 51) - 1);
|
||||
}
|
||||
|
||||
/* Reduce and store field element to 32 bytes little-endian.
|
||||
* Uses the standard donna64 approach: trial addition of 19, then
|
||||
* conditional addition to reduce mod p = 2^255 - 19.
|
||||
* CT-REQUIRED: no branches on field element values. */
|
||||
/* Reduce and store field element to 32 bytes little-endian. */
|
||||
static void fe_tobytes(uint8_t s[32], const fe h) {
|
||||
uint64_t t[5];
|
||||
const uint64_t mask51 = (UINT64_C(1) << 51) - 1;
|
||||
for (int i = 0; i < 5; i++) t[i] = h[i];
|
||||
|
||||
/* Two rounds of carry propagation to ensure limbs in [0, 2^51) */
|
||||
uint64_t c;
|
||||
for (int round = 0; round < 2; round++) {
|
||||
for (int i = 0; i < 5; i++) {
|
||||
|
|
@ -61,26 +89,21 @@ static void fe_tobytes(uint8_t s[32], const fe h) {
|
|||
else t[0] += c * 19;
|
||||
}
|
||||
}
|
||||
/* One more carry from t[0] to t[1] after the wraparound */
|
||||
c = t[0] >> 51; t[0] &= mask51; t[1] += c;
|
||||
|
||||
/* Reduce mod p = 2^255 - 19 using trial addition.
|
||||
* If t >= p, then t + 19 >= 2^255, and the carry propagates out of t[4].
|
||||
* q = 0 if t < p, q = 1 if t >= p. */
|
||||
uint64_t q = (t[0] + 19) >> 51;
|
||||
q = (t[1] + q) >> 51;
|
||||
q = (t[2] + q) >> 51;
|
||||
q = (t[3] + q) >> 51;
|
||||
q = (t[4] + q) >> 51; /* q ∈ {0, 1} */
|
||||
q = (t[4] + q) >> 51;
|
||||
|
||||
t[0] += q * 19;
|
||||
c = t[0] >> 51; t[0] &= mask51; t[1] += c;
|
||||
c = t[1] >> 51; t[1] &= mask51; t[2] += c;
|
||||
c = t[2] >> 51; t[2] &= mask51; t[3] += c;
|
||||
c = t[3] >> 51; t[3] &= mask51; t[4] += c;
|
||||
t[4] &= mask51; /* Discard overflow past 2^255 */
|
||||
t[4] &= mask51;
|
||||
|
||||
/* Pack 5 × 51-bit limbs into 32 bytes (little-endian, 255 bits) */
|
||||
uint64_t combined = t[0] | (t[1] << 51);
|
||||
for (int i = 0; i < 8; i++) s[i] = (uint8_t)(combined >> (8*i));
|
||||
combined = (t[1] >> 13) | (t[2] << 38);
|
||||
|
|
@ -91,14 +114,28 @@ static void fe_tobytes(uint8_t s[32], const fe h) {
|
|||
for (int i = 0; i < 8; i++) s[24+i] = (uint8_t)(combined >> (8*i));
|
||||
}
|
||||
|
||||
/* CT-REQUIRED: conditional swap — no branches on secret bit */
|
||||
/* CT-REQUIRED: conditional swap — no branches on secret bit.
|
||||
* JASMIN-VERIFIED: First 4 limbs swapped by Jasmin when available;
|
||||
* 5th limb swapped in C (same constant-time XOR pattern). */
|
||||
static void fe_cswap(fe a, fe b, uint64_t flag) {
|
||||
uint64_t mask = -(uint64_t)(flag & 1);
|
||||
#ifdef ZUPT_USE_JASMIN
|
||||
/* JASMIN-VERIFIED: CT swap of first 32 bytes (4×u64).
|
||||
* The Jasmin function operates on 4 consecutive u64 values. */
|
||||
zupt_fe_cswap(a, b, flag & 1);
|
||||
/* 5th limb: C fallback (same CT pattern) */
|
||||
{
|
||||
uint64_t t = mask & (a[4] ^ b[4]);
|
||||
a[4] ^= t;
|
||||
b[4] ^= t;
|
||||
}
|
||||
#else
|
||||
for (int i = 0; i < 5; i++) {
|
||||
uint64_t t = mask & (a[i] ^ b[i]);
|
||||
a[i] ^= t;
|
||||
b[i] ^= t;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static void fe_copy(fe h, const fe f) { for (int i=0;i<5;i++) h[i]=f[i]; }
|
||||
|
|
@ -110,7 +147,6 @@ static void fe_add(fe h, const fe f, const fe g) {
|
|||
}
|
||||
|
||||
static void fe_sub(fe h, const fe f, const fe g) {
|
||||
/* Add 2*p to avoid underflow, then subtract */
|
||||
static const uint64_t two_p[5] = {
|
||||
2*((UINT64_C(1)<<51)-19), 2*((UINT64_C(1)<<51)-1),
|
||||
2*((UINT64_C(1)<<51)-1), 2*((UINT64_C(1)<<51)-1),
|
||||
|
|
@ -119,10 +155,8 @@ static void fe_sub(fe h, const fe f, const fe g) {
|
|||
for (int i = 0; i < 5; i++) h[i] = f[i] + two_p[i] - g[i];
|
||||
}
|
||||
|
||||
/* 128-bit type for multiplication — use unsigned __int128 where available */
|
||||
/* 128-bit type for multiplication */
|
||||
#if defined(__SIZEOF_INT128__)
|
||||
/* __int128 is a GCC/Clang extension — not ISO C11 but universally available
|
||||
* on 64-bit targets. The struct fallback below covers MSVC and strict-ISO builds. */
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpedantic"
|
||||
|
|
@ -133,7 +167,6 @@ static void fe_sub(fe h, const fe f, const fe g) {
|
|||
#endif
|
||||
#define MUL64(a,b) ((uint128_t)(a) * (uint128_t)(b))
|
||||
#else
|
||||
/* Fallback: split multiplication */
|
||||
typedef struct { uint64_t lo, hi; } uint128_t;
|
||||
static inline uint128_t MUL64(uint64_t a, uint64_t b) {
|
||||
uint128_t r;
|
||||
|
|
@ -148,7 +181,6 @@ static inline uint128_t MUL64(uint64_t a, uint64_t b) {
|
|||
#endif
|
||||
|
||||
static void fe_mul(fe h, const fe f, const fe g) {
|
||||
/* Schoolbook multiplication with reduction by 19 */
|
||||
uint128_t t[5] = {0,0,0,0,0};
|
||||
for (int i = 0; i < 5; i++)
|
||||
for (int j = 0; j < 5; j++) {
|
||||
|
|
@ -164,7 +196,6 @@ static void fe_mul(fe h, const fe f, const fe g) {
|
|||
#endif
|
||||
}
|
||||
|
||||
/* Carry chain */
|
||||
for (int i = 0; i < 5; i++) {
|
||||
#if defined(__SIZEOF_INT128__)
|
||||
uint64_t lo = (uint64_t)t[i];
|
||||
|
|
@ -190,31 +221,29 @@ static void fe_mul(fe h, const fe f, const fe g) {
|
|||
|
||||
static void fe_sq(fe h, const fe f) { fe_mul(h, f, f); }
|
||||
|
||||
/* Compute f^(2^n) by repeated squaring */
|
||||
static void fe_sq_n(fe h, const fe f, int n) {
|
||||
fe_sq(h, f);
|
||||
for (int i = 1; i < n; i++) fe_sq(h, h);
|
||||
}
|
||||
|
||||
/* Inversion: f^(p-2) via addition chain for 2^255-21 */
|
||||
static void fe_inv(fe h, const fe f) {
|
||||
fe t0, t1, t2, t3;
|
||||
|
||||
fe_sq(t0, f); /* t0 = f^2 */
|
||||
fe_sq_n(t1, t0, 2); /* t1 = f^8 */
|
||||
fe_mul(t1, f, t1); /* t1 = f^9 */
|
||||
fe_mul(t0, t0, t1); /* t0 = f^11 */
|
||||
fe_sq(t2, t0); /* t2 = f^22 */
|
||||
fe_mul(t1, t1, t2); /* t1 = f^(2^5 - 1) = f^31 */
|
||||
fe_sq_n(t2, t1, 5); /* t2 = f^(2^10 - 32) */
|
||||
fe_mul(t1, t2, t1); /* t1 = f^(2^10 - 1) */
|
||||
fe_sq_n(t2, t1, 10); fe_mul(t2, t2, t1); /* f^(2^20 - 1) */
|
||||
fe_sq_n(t3, t2, 20); fe_mul(t2, t3, t2); /* f^(2^40 - 1) */
|
||||
fe_sq_n(t2, t2, 10); fe_mul(t1, t2, t1); /* f^(2^50 - 1) */
|
||||
fe_sq_n(t2, t1, 50); fe_mul(t2, t2, t1); /* f^(2^100 - 1) */
|
||||
fe_sq_n(t3, t2, 100); fe_mul(t2, t3, t2); /* f^(2^200 - 1) */
|
||||
fe_sq_n(t2, t2, 50); fe_mul(t1, t2, t1); /* f^(2^250 - 1) */
|
||||
fe_sq_n(t1, t1, 5); fe_mul(h, t1, t0); /* f^(2^255 - 21) */
|
||||
fe_sq(t0, f);
|
||||
fe_sq_n(t1, t0, 2);
|
||||
fe_mul(t1, f, t1);
|
||||
fe_mul(t0, t0, t1);
|
||||
fe_sq(t2, t0);
|
||||
fe_mul(t1, t1, t2);
|
||||
fe_sq_n(t2, t1, 5);
|
||||
fe_mul(t1, t2, t1);
|
||||
fe_sq_n(t2, t1, 10); fe_mul(t2, t2, t1);
|
||||
fe_sq_n(t3, t2, 20); fe_mul(t2, t3, t2);
|
||||
fe_sq_n(t2, t2, 10); fe_mul(t1, t2, t1);
|
||||
fe_sq_n(t2, t1, 50); fe_mul(t2, t2, t1);
|
||||
fe_sq_n(t3, t2, 100); fe_mul(t2, t3, t2);
|
||||
fe_sq_n(t2, t2, 50); fe_mul(t1, t2, t1);
|
||||
fe_sq_n(t1, t1, 5); fe_mul(h, t1, t0);
|
||||
}
|
||||
|
||||
/* ═══════════════════════════════════════════════════════════════════
|
||||
|
|
@ -224,6 +253,16 @@ static void fe_inv(fe h, const fe f) {
|
|||
* cswap selecting which point to operate on.
|
||||
* ═══════════════════════════════════════════════════════════════════ */
|
||||
|
||||
/* FRAMA-C: X25519 Diffie-Hellman key agreement (RFC 7748)
|
||||
* CT-REQUIRED: Montgomery ladder — constant-time by construction */
|
||||
/*@ requires \valid(out + (0..31));
|
||||
@ requires \valid_read(scalar + (0..31));
|
||||
@ requires \valid_read(point + (0..31));
|
||||
@ requires \separated(out + (0..31), scalar + (0..31));
|
||||
@ requires \separated(out + (0..31), point + (0..31));
|
||||
@ assigns out[0..31];
|
||||
@ ensures \initialized(out + (0..31));
|
||||
*/
|
||||
void zupt_x25519(uint8_t out[32], const uint8_t scalar[32], const uint8_t point[32]) {
|
||||
uint8_t e[32];
|
||||
memcpy(e, scalar, 32);
|
||||
|
|
@ -261,11 +300,6 @@ void zupt_x25519(uint8_t out[32], const uint8_t scalar[32], const uint8_t point[
|
|||
fe_sq(bb, b);
|
||||
fe_mul(x2, aa, bb);
|
||||
fe_sub(e2, aa, bb);
|
||||
/* a24 = 121666 = (486662+2)/4
|
||||
* z2 = E * (BB + a24 * E)
|
||||
* SECURITY NOTE: The formula using BB (not AA) is algebraically correct
|
||||
* for the Montgomery curve y^2 = x^3 + 486662*x^2 + x.
|
||||
* Verified against RFC 7748 test vectors and libsodium. */
|
||||
fe_copy(dc, e2);
|
||||
for (int i = 0; i < 5; i++) tmp0[i] = 0;
|
||||
tmp0[0] = 121666;
|
||||
|
|
@ -284,6 +318,13 @@ void zupt_x25519(uint8_t out[32], const uint8_t scalar[32], const uint8_t point[
|
|||
memset(e, 0, 32);
|
||||
}
|
||||
|
||||
/* FRAMA-C: X25519 with standard basepoint (u=9) */
|
||||
/*@ requires \valid(out + (0..31));
|
||||
@ requires \valid_read(scalar + (0..31));
|
||||
@ requires \separated(out + (0..31), scalar + (0..31));
|
||||
@ assigns out[0..31];
|
||||
@ ensures \initialized(out + (0..31));
|
||||
*/
|
||||
void zupt_x25519_base(uint8_t out[32], const uint8_t scalar[32]) {
|
||||
/* Standard basepoint: u = 9 */
|
||||
uint8_t basepoint[32] = {0};
|
||||
|
|
|
|||
BIN
src/zupt_x25519.o
Normal file
BIN
src/zupt_x25519.o
Normal file
Binary file not shown.
BIN
src/zupt_xxh.o
Normal file
BIN
src/zupt_xxh.o
Normal file
Binary file not shown.
Loading…
Reference in a new issue