MohandOussadi
Retour au blog
Signatures crypto côté web : SIWE, EIP-712 et vérification serveur

Signatures crypto côté web : SIWE, EIP-712 et vérification serveur

6 octobre 2026
4 min de lecture
Web3
Cryptographie
Sécurité

Dans une application web3, la signature remplace souvent le mot de passe : on prouve qu'on contrôle une adresse en signant un message. C'est simple à utiliser, mais facile à mal implémenter. Une signature vérifiée sans nonce, sans domaine ou sans chainId peut être rejouée ailleurs. Voici ce qu'il faut comprendre pour le faire correctement.

Les briques cryptographiques

  • secp256k1 / ECDSA : la courbe elliptique et l'algorithme de signature utilisés par Ethereum (comme Bitcoin). Une clé privée de 32 octets donne une clé publique.
  • Adresse : les 20 derniers octets du hash keccak256 de la clé publique. On ne publie donc jamais la clé publique en clair avant la première signature.
  • Signature : 65 octets, r, s et v. Le paramètre v permet de retrouver la clé publique à partir du message et de la signature (ecrecover), donc l'adresse du signataire, sans la connaître à l'avance.
  • Malléabilité : pour une même signature valide, il existe une variante avec s « haut ». Les bibliothèques modernes n'acceptent que la forme s bas ; ne jamais utiliser une signature brute comme identifiant unique.

Signer un message : EIP-191

Un portefeuille ne signe jamais un message brut : personal_sign préfixe le contenu par \x19Ethereum Signed Message:\n suivi de sa longueur. Ce préfixe empêche qu'un message apparemment anodin soit en réalité une transaction valide signée à l'insu de l'utilisateur.

Sign-In with Ethereum (EIP-4361)

SIWE standardise le message de connexion pour qu'il soit lisible par l'utilisateur et vérifiable par le serveur. Il contient notamment le domaine, l'adresse, l'URI, le chainId, un nonce et des dates d'émission et d'expiration.

Séquence Sign-In with Ethereum : le serveur émet un nonce, le portefeuille signe le message, le serveur vérifie la signature, le domaine et le nonce puis crée la session
Séquence Sign-In with Ethereum : le serveur émet un nonce, le portefeuille signe le message, le serveur vérifie la signature, le domaine et le nonce puis crée la session

Le nonce est généré par le serveur, stocké dans la session et à usage unique : c'est lui qui empêche de rejouer une signature interceptée. Le domaine empêche un site de phishing de réutiliser une signature obtenue pour lui-même. Côté serveur avec viem :

// app/api/auth/verify/route.ts
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";
import { parseSiweMessage } from "viem/siwe";
import { getSession } from "@/lib/session";

const client = createPublicClient({ chain: mainnet, transport: http(process.env.RPC_URL) });

export async function POST(req: Request) {
  const { message, signature } = await req.json();
  const session = await getSession();
  if (!session.nonce) return new Response("Missing nonce", { status: 400 });

  // Vérifie la signature (EOA ou smart account), le domaine, le nonce et l'expiration
  const valid = await client.verifySiweMessage({
    message,
    signature,
    domain: "example.com",
    nonce: session.nonce,
  });

  session.nonce = undefined; // usage unique, même en cas d'échec
  if (!valid) {
    await session.save();
    return new Response("Invalid signature", { status: 401 });
  }

  const { address } = parseSiweMessage(message);
  session.address = address;
  await session.save();
  return Response.json({ address });
}

EIP-712 : signer des données typées

Pour autoriser une action (un ordre de vente, un vote, un permit de token), on ne signe pas une chaîne de caractères mais une structure typée. Le portefeuille affiche les champs un par un, et le hash signé est keccak256(0x1901 ‖ domainSeparator ‖ hashStruct(message)).

  • Le domain separator contient le nom de l'application, sa version, le chainId et l'adresse du contrat vérificateur. Une signature valide sur un testnet ou pour un autre contrat ne l'est donc pas ici : c'est la protection contre le rejeu inter-chaînes et inter-contrats.
  • Un nonce et une échéance dans le message : pour qu'un ordre signé ne puisse être exécuté qu'une fois, et pas dans six mois.
  • Côté serveur, verifyTypedData de viem recalcule le hash avec les mêmes types et vérifie le signataire.

Et les smart accounts ?

Un smart account n'a pas de clé privée unique : ecrecover ne peut pas le vérifier. La norme ERC-1271 définit une fonction isValidSignature(hash, signature) que le contrat implémente avec sa propre logique (multisig, passkey…). Pour un compte pas encore déployé, ERC-6492 enveloppe la signature avec les données de déploiement.

Conséquence pratique : une vérification purement hors ligne avec ecrecover rejette les utilisateurs de smart wallets. Il faut vérifier via un client connecté à la chaîne (c'est ce que fait verifySiweMessage ci-dessus) et ne jamais comparer soi-même l'adresse récupérée.

Les erreurs classiques

  • Nonce généré côté client ou réutilisable : la signature devient rejouable.
  • Domaine non vérifié : un site de phishing peut faire signer un message destiné au vôtre.
  • Comparaison d'adresses sensible à la casse : les adresses ont une casse de contrôle (EIP-55) ; comparer en minuscules ou avec isAddressEqual.
  • Session sans expiration : une signature prouve le contrôle à un instant donné, la session doit rester courte et révocable.
  • Messages illisibles : faire signer un hash opaque habitue l'utilisateur à signer n'importe quoi. Préférer SIWE et EIP-712.

Conclusion

Les signatures Ethereum reposent sur des primitives solides : ECDSA, keccak256, récupération de clé publique. Les failles viennent presque toujours de l'application : nonce absent, domaine ignoré, chainId oublié, smart accounts non pris en charge. Avec SIWE pour l'authentification, EIP-712 pour les autorisations et une vérification serveur compatible ERC-1271, on obtient une authentification sans mot de passe robuste.

Partager cet article