141 lignes
5.6 KiB
NASM
141 lignes
5.6 KiB
NASM
; =============================================================================
|
|
; const_time.asm -- primitives a temps d'execution constant.
|
|
;
|
|
; Contrainte projet : aucune comparaison de cle ou de MAC ne doit sortir tot.
|
|
; Toutes les fonctions de ce fichier ont un flot de controle qui ne depend que
|
|
; de la LONGUEUR des donnees, jamais de leur VALEUR. Concretement : pas un seul
|
|
; saut conditionnel dont la condition derive d'un octet secret.
|
|
;
|
|
; API publique :
|
|
; uint32_t vc_ct_memcmp (const void *a, const void *b, size_t len);
|
|
; uint64_t vc_ct_mask_eq_u32(uint32_t a, uint32_t b);
|
|
; uint64_t vc_ct_mask_lt_u32(uint32_t a, uint32_t b);
|
|
; void vc_ct_cmov (void *dst, const void *src, size_t len,
|
|
; uint64_t mask);
|
|
; void vc_ct_memzero (void *p, size_t len);
|
|
;
|
|
; Convention des masques : 0xFFFFFFFFFFFFFFFF pour vrai, 0 pour faux. Un masque
|
|
; se combine par and/or/xor sans jamais brancher.
|
|
;
|
|
; PORTABILITE Cortex-M33 : la technique est integralement portable (Thumb-2 a
|
|
; sbc, rsb et les memes drapeaux). Sont x86-64-specifiques :
|
|
; - l'idiome sbb reg, reg pour materialiser CF en masque (equivalent
|
|
; Thumb-2 : sbc r, r, r) ;
|
|
; - rep stosb.
|
|
; Attention au portage : sur Cortex-M il faudra verifier que le compilateur ne
|
|
; reintroduit pas de branche, et que vc_ct_memzero ne soit pas remplace par un
|
|
; memset optimisable. Le fait de l'ecrire en assembleur est precisement la
|
|
; garantie recherchee ici -- un memset C peut etre supprime par le compilateur
|
|
; sur un tampon mort, pas ce code.
|
|
; =============================================================================
|
|
|
|
%include "abi.inc"
|
|
|
|
section .text
|
|
|
|
global vc_ct_memcmp_i
|
|
global vc_ct_memzero_i
|
|
global vc_ct_cmov_i
|
|
|
|
; -----------------------------------------------------------------------------
|
|
; uint32_t vc_ct_memcmp(const void *a, const void *b, size_t len)
|
|
; Retourne 0 si les zones sont identiques, 1 sinon.
|
|
; Les len octets sont TOUJOURS lus, quelle que soit la position du premier
|
|
; ecart : l'accumulateur agrege les differences par ou, sans sortie anticipee.
|
|
; -----------------------------------------------------------------------------
|
|
VC_FUNC vc_ct_memcmp
|
|
VC_ARGS ; rdi = a, rsi = b, rdx = len
|
|
call vc_ct_memcmp_i
|
|
VC_RET
|
|
|
|
vc_ct_memcmp_i:
|
|
xor eax, eax ; accumulateur de differences
|
|
xor ecx, ecx
|
|
test rdx, rdx
|
|
jz .normalize ; longueur nulle : pas de secret implique
|
|
|
|
.loop:
|
|
mov r8b, [rdi + rcx]
|
|
xor r8b, [rsi + rcx]
|
|
or al, r8b
|
|
inc rcx
|
|
cmp rcx, rdx ; borne = longueur, pas une valeur secrete
|
|
jb .loop
|
|
|
|
.normalize:
|
|
; al != 0 -> 1 ; al == 0 -> 0, sans branchement
|
|
movzx eax, al
|
|
neg eax ; CF = 1 si eax etait non nul
|
|
sbb eax, eax ; 0xffffffff si different, 0 si egal
|
|
and eax, 1
|
|
ret
|
|
|
|
; -----------------------------------------------------------------------------
|
|
; uint64_t vc_ct_mask_eq_u32(uint32_t a, uint32_t b)
|
|
; Tout-a-un si a == b, zero sinon.
|
|
; -----------------------------------------------------------------------------
|
|
VC_FUNC vc_ct_mask_eq_u32
|
|
VC_ARGS ; edi = a, esi = b
|
|
mov eax, edi
|
|
xor eax, esi ; 0 si et seulement si egaux
|
|
neg eax ; CF = 1 si non nul
|
|
sbb rax, rax ; -1 si different, 0 si egal
|
|
not rax ; -1 si egal, 0 si different
|
|
VC_RET
|
|
|
|
; -----------------------------------------------------------------------------
|
|
; uint64_t vc_ct_mask_lt_u32(uint32_t a, uint32_t b)
|
|
; Tout-a-un si a < b (non signe), zero sinon.
|
|
; Utilise par le gating temporel : compare l'instant d'arrivee a l'Heure
|
|
; Cible sans produire de branche exploitable au timing.
|
|
; -----------------------------------------------------------------------------
|
|
VC_FUNC vc_ct_mask_lt_u32
|
|
VC_ARGS ; edi = a, esi = b
|
|
cmp edi, esi ; CF = 1 si a < b
|
|
sbb rax, rax ; -1 si a < b, 0 sinon
|
|
VC_RET
|
|
|
|
; -----------------------------------------------------------------------------
|
|
; void vc_ct_cmov(void *dst, const void *src, size_t len, uint64_t mask)
|
|
; dst <- src si mask est tout-a-un, dst inchange si mask est nul.
|
|
; Les deux zones sont lues et dst est TOUJOURS reecrit : la trace d'acces
|
|
; memoire est la meme dans les deux cas.
|
|
; -----------------------------------------------------------------------------
|
|
VC_FUNC vc_ct_cmov
|
|
VC_ARGS ; rdi = dst, rsi = src, rdx = len, rcx = mask
|
|
call vc_ct_cmov_i
|
|
VC_RET
|
|
|
|
vc_ct_cmov_i:
|
|
test rdx, rdx
|
|
jz .done
|
|
xor r8, r8
|
|
.loop:
|
|
movzx r9d, byte [rdi + r8] ; ancien
|
|
movzx r10d, byte [rsi + r8] ; nouveau
|
|
xor r10d, r9d
|
|
and r10, rcx ; masque applique a la difference
|
|
xor r10d, r9d ; = mask ? nouveau : ancien
|
|
mov [rdi + r8], r10b
|
|
inc r8
|
|
cmp r8, rdx
|
|
jb .loop
|
|
.done:
|
|
ret
|
|
|
|
; -----------------------------------------------------------------------------
|
|
; void vc_ct_memzero(void *p, size_t len)
|
|
; Effacement qui ne peut pas etre elimine par un optimiseur, contrairement a
|
|
; un memset C sur un tampon en fin de vie.
|
|
; -----------------------------------------------------------------------------
|
|
VC_FUNC vc_ct_memzero
|
|
VC_ARGS ; rdi = p, rsi = len
|
|
call vc_ct_memzero_i
|
|
VC_RET
|
|
|
|
vc_ct_memzero_i:
|
|
mov rcx, rsi
|
|
xor eax, eax
|
|
rep stosb
|
|
ret
|