Fichiers
2026-10-11 01:55:11 +02:00

231 lignes
6.9 KiB
NASM

; =============================================================================
; csprng.asm -- generateur pseudo-aleatoire cryptographique maison, bati sur le
; SHA-256 du projet. Aucune dependance externe (contrainte projet).
;
; VERCORS en a besoin pour :
; - le bourrage aleatoire des trames a taille fixe (64 octets) : le prompt
; exige explicitement des octets de bruit, pas des zeros ;
; - la generation isolee du Grain de Sel Temporel hebdomadaire.
;
; CONSTRUCTION (voir docs/adr/0004) -- DRBG a base de hachage, dans l'esprit de
; Hash_DRBG (NIST SP 800-90A) mais volontairement simplifie :
;
; seed(graine) V <- SHA256(graine) ; C <- 0
; bytes(n) pour chaque bloc de 32 octets :
; sortie <- SHA256(V || BE64(C))
; C <- C + 1
; puis, une fois la demande servie :
; V <- SHA256(0x01 || V)
;
; Le rafraichissement final de V donne la resistance au retour en arriere : la
; compromission de l'etat apres coup ne permet pas de recalculer les octets
; deja emis, ce qui protege le bourrage des trames deja transmises.
;
; CE QUE CE MODULE NE FAIT PAS : il ne fabrique pas d'entropie. La graine doit
; venir de l'exterieur. Sur x86-64 le harnais de test la fournit ; sur STM32U5
; ce sera le TRNG materiel. C'est la seule difference de fond au portage, et
; elle est isolee derriere vc_csprng_seed.
;
; API publique :
; void vc_csprng_seed (vc_csprng_ctx *ctx, const void *seed, size_t len);
; void vc_csprng_reseed(vc_csprng_ctx *ctx, const void *seed, size_t len);
; void vc_csprng_bytes (vc_csprng_ctx *ctx, void *out, size_t len);
;
; Disposition de vc_csprng_ctx (48 octets, voir include/vercors.h) :
; +0 uint8_t V[32]
; +32 uint64_t C compteur de blocs
; +40 uint64_t seeded 0 = non initialise
;
; PORTABILITE Cortex-M33 : entierement portable, la seule instruction
; x86-64-specifique etant bswap (rev en Thumb-2) et rep movsb.
; =============================================================================
%include "abi.inc"
%define PRNG_V 0
%define PRNG_C 32
%define PRNG_SEEDED 40
%define PRNG_SIZE 48
extern vc_sha256_i
extern sha256_init_i
extern sha256_update_i
extern sha256_final_i
section .text
global vc_csprng_seed_i
global vc_csprng_bytes_i
; -----------------------------------------------------------------------------
; vc_csprng_seed_i -- interne. rdi = ctx, rsi = graine, rdx = longueur.
; V <- SHA256(graine), C <- 0.
; -----------------------------------------------------------------------------
vc_csprng_seed_i:
push rbx
mov rbx, rdi
mov rdi, rsi ; data = graine
mov rsi, rdx ; len
mov rdx, rbx ; out = V
call vc_sha256_i
mov qword [rbx + PRNG_C], 0
mov qword [rbx + PRNG_SEEDED], 1
pop rbx
ret
; -----------------------------------------------------------------------------
; vc_csprng_reseed_i -- interne. rdi = ctx, rsi = graine, rdx = longueur.
; V <- SHA256(V || graine). Melange la nouvelle entropie sans jeter
; l'ancienne : un reseed avec une source degradee ne peut pas affaiblir
; l'etat courant.
; -----------------------------------------------------------------------------
vc_csprng_reseed_i:
push rbx
push r12
push r13
push r14
sub rsp, 128 ; contexte SHA-256 (112) sur la pile
mov rbx, rdi ; ctx PRNG
mov r12, rsi ; graine
mov r13, rdx ; longueur
mov r14, rsp ; contexte SHA
mov rdi, r14
call sha256_init_i
mov rdi, r14
lea rsi, [rbx + PRNG_V]
mov rdx, 32
call sha256_update_i
mov rdi, r14
mov rsi, r12
mov rdx, r13
call sha256_update_i
mov rdi, r14
lea rsi, [rbx + PRNG_V]
call sha256_final_i
mov qword [rbx + PRNG_SEEDED], 1
; effacement du contexte SHA
mov rdi, r14
mov rcx, 14
xor eax, eax
rep stosq
add rsp, 128
pop r14
pop r13
pop r12
pop rbx
ret
; -----------------------------------------------------------------------------
; vc_csprng_bytes_i -- interne. rdi = ctx, rsi = sortie, rdx = longueur.
;
; Cadre de pile (r14) :
; [r14 + 0 .. 39] bloc d'entree du hachage : V (32) || BE64(C) (8)
; [r14 + 48 .. 79] bloc de sortie du hachage
; -----------------------------------------------------------------------------
vc_csprng_bytes_i:
push rbx
push r12
push r13
push r14
sub rsp, 80
mov rbx, rdi ; ctx
mov r12, rsi ; sortie
mov r13, rdx ; octets restants
mov r14, rsp
.block_loop:
test r13, r13
jz .refresh
; --- entree = V || BE64(C)
mov rax, [rbx + PRNG_V + 0]
mov [r14 + 0], rax
mov rax, [rbx + PRNG_V + 8]
mov [r14 + 8], rax
mov rax, [rbx + PRNG_V + 16]
mov [r14 + 16], rax
mov rax, [rbx + PRNG_V + 24]
mov [r14 + 24], rax
mov rax, [rbx + PRNG_C]
bswap rax
mov [r14 + 32], rax
mov rdi, r14
mov rsi, 40
lea rdx, [r14 + 48]
call vc_sha256_i
inc qword [rbx + PRNG_C]
; --- n = min(32, restant)
mov rax, 32
cmp r13, rax
cmovb rax, r13
lea rsi, [r14 + 48]
mov rdi, r12
mov rcx, rax
add r12, rax
sub r13, rax
rep movsb
jmp .block_loop
.refresh:
; --- V <- SHA256(0x01 || V) : resistance au retour en arriere
mov byte [r14 + 0], 0x01
mov rax, [rbx + PRNG_V + 0]
mov [r14 + 1], rax
mov rax, [rbx + PRNG_V + 8]
mov [r14 + 9], rax
mov rax, [rbx + PRNG_V + 16]
mov [r14 + 17], rax
mov rax, [rbx + PRNG_V + 24]
mov [r14 + 25], rax
mov rdi, r14
mov rsi, 33
lea rdx, [rbx + PRNG_V]
call vc_sha256_i
; --- effacement du cadre (il contient V et du flot deja emis)
mov rdi, r14
mov rcx, 10 ; 80 octets
xor eax, eax
rep stosq
add rsp, 80
pop r14
pop r13
pop r12
pop rbx
ret
; =============================================================================
; Enveloppes publiques
; =============================================================================
VC_FUNC vc_csprng_seed
VC_ARGS ; rdi = ctx, rsi = seed, rdx = len
call vc_csprng_seed_i
VC_RET
VC_FUNC vc_csprng_reseed
VC_ARGS ; rdi = ctx, rsi = seed, rdx = len
call vc_csprng_reseed_i
VC_RET
VC_FUNC vc_csprng_bytes
VC_ARGS ; rdi = ctx, rsi = out, rdx = len
call vc_csprng_bytes_i
VC_RET