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

278 lignes
14 KiB
C

/* ============================================================================
* vercors.h -- interface C du coeur VERCORS ecrit en assembleur x86-64.
*
* Toutes les fonctions declarees ici sont implementees en assembleur, dans le
* repertoire asm. Il n'y a aucune implementation C de la cryptographie
* (contrainte projet).
*
* Les dispositions de structures doivent rester synchronisees avec les
* %define correspondants dans les fichiers .asm. Les _Static_assert en fin de
* fichier cassent la compilation si l'un des deux derive.
* ==========================================================================*/
#ifndef VERCORS_H
#define VERCORS_H
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/* --------------------------------------------------------------------------
* Constantes du protocole
* ------------------------------------------------------------------------*/
#define VC_DAY_SECONDS 86400u /* domaine de l'Heure Cible : 0..86399 */
#define VC_FRAME_BYTES 64u /* taille fixe d'une trame sur l'air */
#define VC_FRAME_MAXPAYLOAD 63u /* 64 - 1 octet de longueur */
/* ATTENTION : les jours de bascule de cle (ADR 0009), les octets 32..63
* portent la cle N+1 chiffree et la charge utile tombe a 31 octets. Un
* appelant qui dimensionne sur VC_FRAME_MAXPAYLOAD alloue juste, mais un
* appelant qui SUPPOSE que 63 octets passent toujours sera tronque un jour
* sur sept. Sans objet si l'ADR 0012 est retenu. */
#define VC_FRAME_MAXPAYLOAD_SWITCH 31u
#define VC_KEY_BYTES 32u /* AES-256 */
#define VC_CTR_BYTES 16u
#define VC_GRAIN_BYTES 32u /* Grain de Sel Temporel */
#define VC_WEEK_SECONDS 604800u /* 7 jours */
/* Epoque d'origine du compteur de semaines -- ADR 0011.
* Lundi 29 decembre 1969, 00:00:00 UTC : le lundi ouvrant la semaine ISO qui
* contient l'epoque Unix. Valeur de PROTOCOLE, pas de deploiement : deux
* extremites qui ne partagent pas cette constante derivent des grains
* differents et ne se parlent jamais, sans erreur visible. */
#define VC_WEEK_EPOCH_UNIX (-259200LL)
/* --------------------------------------------------------------------------
* SHA-256 (asm/sha256.asm)
* ------------------------------------------------------------------------*/
typedef struct {
uint32_t state[8]; /* +0 */
uint64_t bitlen; /* +32 */
uint64_t buflen; /* +40 */
uint8_t buf[64]; /* +48 */
} vc_sha256_ctx; /* 112 */
void vc_sha256_init (vc_sha256_ctx *ctx);
void vc_sha256_update(vc_sha256_ctx *ctx, const void *data, size_t len);
void vc_sha256_final (vc_sha256_ctx *ctx, uint8_t out[32]);
void vc_sha256 (const void *data, size_t len, uint8_t out[32]);
/* --------------------------------------------------------------------------
* AES-256 (asm/aes256.asm) -- logiciel, pas AES-NI. Chiffrement seul : le
* mode CTR n'a jamais besoin du dechiffrement de bloc. Voir docs/adr/0002.
* ------------------------------------------------------------------------*/
typedef struct {
uint8_t rk[240]; /* 15 cles de ronde de 16 octets */
} vc_aes_rk;
void vc_aes256_expand_key (const uint8_t key[32], vc_aes_rk *rk);
void vc_aes256_encrypt_block(const vc_aes_rk *rk, const uint8_t in[16],
uint8_t out[16]);
/* XOR sur place avec le flot CTR ; ctr est avance et laisse a jour. */
void vc_aes256_ctr_xor (const vc_aes_rk *rk, uint8_t ctr[16],
uint8_t *inout, size_t len);
/* --------------------------------------------------------------------------
* Primitives a temps constant (asm/const_time.asm)
* Convention de masque : 0xFFFFFFFFFFFFFFFF = vrai, 0 = faux.
* ------------------------------------------------------------------------*/
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);
/* --------------------------------------------------------------------------
* CSPRNG maison (asm/csprng.asm)
* Ne fabrique pas d'entropie : la graine vient de l'exterieur (TRNG sur
* STM32U5, harnais de test sur x86-64).
*
* DANGER -- le champ `seeded` ci-dessous est ECRIT MAIS JAMAIS LU.
* vc_csprng_bytes ne verifie pas l'initialisation : sur un contexte a zero il
* produit SHA256(0^32 || 0^8), c'est-a-dire une suite DETERMINISTE ET
* IDENTIQUE SUR TOUS LES BOITIERS. Ces octets servent au bourrage des trames,
* qui doit etre indistinguable du bruit -- et, les jours de bascule, ils
* jouxtent la cle N+1 chiffree. Le garde-fou existe dans la structure et ne
* sert a rien.
*
* Verifie par l'execution : le premier bloc servi vaut exactement SHA256(0^40),
* donc calculable hors ligne par quiconque (test_csprng_unseeded).
*
* Correctif NON APPLIQUE : vc_csprng_bytes_i est appele depuis
* vercors_keysched.asm et vercors_protocol.asm, qui n'attendent aucun code de
* retour -- refuser sans canal d'erreur les laisserait continuer sur un tampon
* non ecrit. Trois options dans docs/REVUE-2026-09-16.md, a trancher. */
typedef struct {
uint8_t V[32]; /* +0 */
uint64_t C; /* +32 */
uint64_t seeded; /* +40 */
} vc_csprng_ctx; /* 48 */
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);
/* --------------------------------------------------------------------------
* Protocole VERCORS (asm/vercors_protocol.asm)
*
* Points [2] [4] [7] [8] : entierement specifies par le cahier des charges.
* Les points [1] [3] [5] [6] sont plus bas, dans une section a part, car ils
* reposent sur des hypotheses provisoires et non sur une specification.
* ------------------------------------------------------------------------*/
/* [2] Heure Cible : SHA256(grain) -> 4 premiers octets big-endian -> methode
* de rejet -> uniforme sur 0..86399. */
uint32_t vc_derive_target_hour(const uint8_t *grain, size_t grain_len);
/* [4] Gating temporel, a appeler AVANT tout dechiffrement.
* Retourne un masque tout-a-un si la trame est recevable. */
uint64_t vc_gate_accept(uint32_t arrival_sec, uint32_t target_sec);
/* [7] Bourrage a taille fixe. Retourne 0, ou -1 si len > 63. */
int vc_frame_pad (vc_csprng_ctx *rng, const uint8_t *payload, size_t len,
uint8_t out[64]);
/* Retourne 0, ou -1 si l'octet de longueur est incoherent. */
int vc_frame_unpad(const uint8_t in[64], uint8_t *out, size_t *out_len);
/* ==========================================================================
* Points [1] [3] [5] [6] -- asm/vercors_keysched.asm
*
* HYPOTHESES PROVISOIRES, A VALIDER AVANT TOUT DEPLOIEMENT REEL.
* Le manifeste Gastinel Frame ne descend pas a ce niveau de detail. Voir
* docs/adr/0007 a 0010 et la section correspondante du README.
* ========================================================================*/
/* Separation de domaine des compteurs CTR. Sans elle, le creneau de cle et la
* trame partageraient un flot de cle sous la meme cle du jour -- reutilisation
* de flot, faute mortelle du mode CTR. */
#define VC_CTR_DOMAIN_FRAME 0x00u
#define VC_CTR_DOMAIN_KEYWRAP 0x01u
void vc_ctr_set_domain(uint8_t ctr[16], uint8_t domain);
/* --- [1] Grain de Sel Temporel ------------------------------------------
* grain = SHA256( K_M(32) || BE16(semaine) || BE32(compteur_anti_rejeu) )
* Ne transite jamais par la radio : chaque extremite le recalcule.
*
* ADR 0011 : le champ semaine est un COMPTEUR ABSOLU depuis
* VC_WEEK_EPOCH_UNIX, et non un numero de semaine ISO dans l'annee. Un
* numero ISO seul est ambigu -- il ne porte pas d'annee. */
void vc_derive_grain(const uint8_t km[32], uint32_t week,
uint32_t replay_counter, uint8_t out[32]);
/* Compteur de semaines pour un instant UTC donne -- ADR 0011.
*
* Arithmetique pure sur des secondes UTC : il n'y a pas de numero de semaine
* a faire basculer a minuit quelque part, donc pas de question de fuseau. Pas
* de code calendaire non plus, ce qui compte sur Cortex-M33.
*
* Calcul sur 64 bits : sur uint32 il buterait sur 2106, soit une limite plus
* proche que le debordement du champ BE16 (semaine 65535 = lundi 29 decembre
* 3225). Appele une fois par semaine, son cout est sans objet.
*
* Domaine : unix_utc >= VC_WEEK_EPOCH_UNIX. En deca le resultat n'a pas de
* sens -- la division entiere C tronque vers zero, pas vers moins l'infini. */
static inline uint32_t vc_week_from_unix(int64_t unix_utc)
{
return (uint32_t)((unix_utc - VC_WEEK_EPOCH_UNIX) / (int64_t)VC_WEEK_SECONDS);
}
/* --- [6] Cle Maitresse d'Usine ------------------------------------------
* PLACEHOLDER DE TEST sur ce prototype. Sur STM32U5, K_M vivra dans
* l'element securise STSAFE-A110 et cette API par pointeur disparaitra. */
const uint8_t *vc_factory_key(void);
/* --- [3] Fenetre de Garde Dynamique -------------------------------------- */
typedef struct {
uint32_t last_valid_sec; /* +0 instant du dernier paquet valide */
int32_t clock_offset; /* +4 recalage memorise, non applique */
uint32_t width; /* +8 demi-largeur courante (cache) */
uint32_t flags; /* +12 bit 0 = deja synchronise */
} vc_guard_ctx; /* 16 */
/* BASE DE TEMPS de toute la famille vc_guard_* et de vc_coldstart_needed :
* un COMPTEUR DE SECONDES ABSOLU et monotone (uptime ou temps UTC), PAS des
* secondes dans la journee. VC_COLDSTART_TIMEOUT vaut une semaine : il serait
* inatteignable avec un compteur borne a 86399, et le Cold Start par silence
* ne se declencherait jamais. */
#define VC_GUARD_MIN_SECONDS 2u /* demi-largeur au repos (hypothese) */
#define VC_GUARD_MAX_SECONDS 30u /* plafond fourni, a valider */
#define VC_GUARD_DRIFT_PPM 20u /* derive quartz supposee */
#define VC_COLDSTART_TIMEOUT 604800u /* 7 jours, periode du grain */
void vc_guard_init (vc_guard_ctx *g);
/* Paquet valide : resserrement + memorisation du recalage (ref - local). */
void vc_guard_on_valid (vc_guard_ctx *g, uint32_t local_sec,
uint32_t ref_sec);
/* Demi-largeur pour un temps ecoule donne : lineaire, plafonnee. */
uint32_t vc_guard_width (uint32_t elapsed_sec);
/* Demi-largeur courante, et mise a jour du cache. */
uint32_t vc_guard_width_now(vc_guard_ctx *g, uint32_t now_sec);
/* [4] + [3] : gating avec tolerance. Seul le bord inferieur est relache --
* le protocole prevoit que le message utile arrive APRES l'Heure Cible.
*
* BASE DE TEMPS : arrival_sec et target_sec sont des SECONDES DANS LA JOURNEE
* (0..86399), comme la sortie de vc_derive_target_hour. Ce n'est PAS la meme
* base que vc_guard_* et vc_coldstart_needed, qui prennent un compteur absolu
* (voir plus bas). Melanger les deux est silencieux et casse tout.
*
* LIMITE CONNUE -- ADR 0014 : la comparaison n'est pas modulaire. Une Heure
* Cible en fin de journee ouvre une fenetre qui devrait enjamber minuit ;
* elle est en fait refermee par le passage a 0. Non corrige ici : borner la
* fenetre par le haut est un changement de protocole, pas de code. */
uint64_t vc_gate_accept_window(uint32_t arrival_sec, uint32_t target_sec,
uint32_t width_sec);
/* --- [6] Cold Start ------------------------------------------------------ */
int vc_coldstart_needed(const vc_guard_ctx *g, uint32_t now_sec);
/* --- [5] Bascule de cle asynchrone ---------------------------------------
* La cle du jour suivant est chiffree sous la cle du JOUR COURANT (chainage
* cle N+1 protegee par cle N), puis logee dans la zone de bourrage. Le creneau
* etant du chiffre AES, il est indistinguable du bruit qui l'entoure, et la
* trame reste a 64 octets avec ou sans bascule. */
typedef struct {
vc_csprng_ctx *rng; /* +0 */
const uint8_t *payload; /* +8 */
size_t payload_len;/* +16 */
const uint8_t *next_key; /* +24 NULL = pas de bascule */
const vc_aes_rk *day_rk; /* +32 cle du jour courant */
const uint8_t *key_ctr; /* +40 domaine KEYWRAP */
} vc_frame_req; /* 48 */
typedef struct {
uint8_t payload[64]; /* +0 */
size_t payload_len; /* +64 */
uint64_t has_next_key; /* +72 */
uint8_t next_key[32]; /* +80 */
} vc_frame_out; /* 112 */
/* Longueurs utiles maximales : la bascule consomme les octets 32..63. */
#define VC_FRAME_KEYSW_MAXPAYLOAD 31u
int vc_frame_build(const vc_frame_req *req, uint8_t out[64]);
int vc_frame_parse(const uint8_t in[64], const vc_aes_rk *day_rk,
const uint8_t *key_ctr, vc_frame_out *out);
/* --------------------------------------------------------------------------
* Verrous de coherence ASM / C
* ------------------------------------------------------------------------*/
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
_Static_assert(sizeof(vc_sha256_ctx) == 112, "vc_sha256_ctx != CTX_SIZE asm");
_Static_assert(sizeof(vc_csprng_ctx) == 48, "vc_csprng_ctx != PRNG_SIZE asm");
_Static_assert(sizeof(vc_aes_rk) == 240, "vc_aes_rk != AES_RK_BYTES asm");
_Static_assert(sizeof(vc_guard_ctx) == 16, "vc_guard_ctx != GUARD_* asm");
_Static_assert(sizeof(vc_frame_req) == 48, "vc_frame_req != REQ_* asm");
_Static_assert(sizeof(vc_frame_out) == 112, "vc_frame_out != OUT_* asm");
#endif
#ifdef __cplusplus
}
#endif
#endif /* VERCORS_H */