⚡ hyper-u256
Bibliothèque Rust no_std, zéro allocation et 100 % sécurisée (#![deny(unsafe_code)]) conçue pour l'arithmétique haute performance sur des entiers non signés de 256 bits (U256).
Elle fournit des primitives d'arithmétique tronquée (wrapping), de réduction modulaire de Montgomery (REDC) et de traitement vectoriel par lots (batching), optimisées pour l'auto-vectorisation par le compilateur.
✨ Points forts
- 🔒 100 % Safe Rust : Aucune utilisation de bloc
unsafe(#![deny(unsafe_code)]). - 📦
no_std& Zero-Allocation : Aucun gestionnaire d'allocation requis ; tout s'exécute sur la pile (stack) et dans les registres CPU. - 🎯 Alignement Mémoire Explicite :
U256est aligné sur 32 octets (#[repr(align(32))]) pour coïncider avec la taille des registres 256-bit (AVX2/AVX-512) et optimiser les accès cache.U256x2est aligné sur 64 octets (#[repr(align(64))]), épousant exactement la taille d'une ligne de cache L1 moderne (cache line).
- ⚡ Conçu pour l'Auto-Vectorisation : Structures adaptées à l'optimisation
autovectorizede LLVM sans compromettre la sécurité de la mémoire.
🛠 Structure du projet
La crate est articulée autour de trois piliers principaux :
| Module / Structure | Description |
|---|---|
U256 |
Entier 256 bits représenté sous forme de 4 mots de 64 bits ([u64; 4]). Supporte l'addition, la soustraction et la multiplication tronquées (wrapping). |
MontgomeryContext |
Gestionnaire de réduction modulaire de Montgomery (REDC) prenant une entrée de 512 bits (2x U256) pour retourner un résultat de 256 bits mod $N$. |
U256x2 |
Structure de traitement SIMD/batching regroupant deux instances de U256 (low et high) traitées en parallèle sans fuite de retenue (carry) entre les voies. |
🚀 Installation
Ajoute la dépendance suivante dans ton fichier Cargo.toml :
[]
= "0.1.0"
📖 Exemples d'utilisation1. Arithmétique de base (wrapping_add, wrapping_sub, wrapping_mul)
use U256;
// Instanciation à partir de 4 limbs u64 (du mot de poids faible au mot de poids fort)
let a = U256from_limbs;
let b = U256ONE;
// Addition wrapping (2^256)
let sum = a.wrapping_add;
assert_eq!;
// Soustraction wrapping
let diff = sum.wrapping_sub;
assert_eq!;
// Multiplication wrapping
let prod = a.wrapping_mul;
2. Réduction Modulaire de Montgomery (MontgomeryContext)Effectue la réduction REDC d'un nombre de 512 bits (représenté sous forme de deux U256 : low et high) vers un U256 strictement inférieur au module N.
use MontgomeryContext;
use U256;
// Module BN254_P
const BN254_P: U256 = U256from_limbs;
// Constante k0 = -N^-1 mod 2^64
const BN254_K0: u64 = 0xc2e1f593efffffff;
let ctx = new;
// Réduction de (low=0, high=0) -> 0
let res = ctx.reduce;
assert_eq!;
3. Traitement Vectoriel par Lots (U256x2)Exécute deux opérations arithmétiques 256 bits simultanément tout en garantissant l'isolation complète des voies (lanes).
use U256x2;
use U256;
let pair1 = new;
let pair2 = new;
// Addition en parallèle
let sum = pair1.add_pair;
assert_eq!;
assert_eq!;
// Multiplication en parallèle
let prod = pair1.mul_pair;
assert_eq!;
assert_eq!;
📐 Alignement et Finesse Mémoirehyper-u256 est conçu pour maximiser l'utilisation de la bande passante mémoire et éliminer les pénalités d'accès désalignés :
U256 (32 octets) : [ Limb 0 | Limb 1 | Limb 2 | Limb 3 ] -> Alignement 32 bytes U256x2 (64 octets) : [ U256 low | U256 high ] -> Alignement 64 bytes (1 L1 Cache Line)
🛡 Garanties de Sécurité
- #![no_std] : Compatible avec les environnements bare-metal, WebAssembly et noyaux applicatifs.
- #![deny(unsafe_code)] : Interdit tout comportement indéfini (undefined behavior). La sûreté mémoire est garantie à 100 % au niveau de la compilation.
✅ Tests
Couvre l'addition, la soustraction, la multiplication (y compris des cas de non-régression sur la propagation de retenue entre limbes) et la réduction de Montgomery contre des vecteurs vérifiés indépendamment.
🔬 Fuzzing Industriel (AFL / libFuzzer)
Le projet intègre un harness de fuzzing dans le dossier fuzz/ pour valider l'exactitude mathématique contre la référence num-bigint sur des centaines de millions de cas générés aléatoirement : Bash
cargo +nightly fuzz run fuzz_ops
📜 Licence
Ce projet est publié sous GPL-2.0-or-later. Voir le fichier LICENSE pour les détails.