Outils de Sécurité & Cryptographie

Générez des mots de passe forts, des hash, HMAC, checksums et empreintes SHA-256 de fichiers dans votre navigateur. Gratuit, privé, zéro envoi.

100 % Privé • Aucun fichier envoyé sur un serveur

Pourquoi utiliser Outils de Sécurité & Cryptographie gratuitement sur Utiliome ?

Conçu pour garantir une confidentialité stricte, sans inscription ni abonnement requis.

Moteur CSPRNG Web Crypto

Puise l'entropie cryptographique brute directement depuis crypto.getRandomValues() adossé au CSPRNG du noyau de l'OS plutôt que dans l'état prévisible de Math.random().

Sélection de Mots Diceware par CSPRNG

Tire uniformément des mots aléatoires du dictionnaire via Web Crypto crypto.getRandomValues() avec échantillonnage par rejet sans biais au lieu de formulations humaines prévisibles.

Matrice de Condensats Simultanée à Cinq Algorithmes

Calcule en une seule passe les empreintes MD5 128 bits (RFC 1321) ainsi que SHA-1 160 bits, SHA-256 256 bits, SHA-384 384 bits et SHA-512 512 bits (NIST FIPS 180-4) à partir d'une chaîne UTF-8 ou d'un tampon binaire.

API Web Crypto Native

Utilise l'accélération matérielle window.crypto.subtle pour calculer les sommes de contrôle SHA-256 à la vitesse maximale du processeur.

Utiliome vs alternatives cloud traditionnelles

Comparez notre moteur local WebAssembly aux outils cloud anciens.

Fonctionnalité Utiliome (Navigateur local) Convertisseurs cloud anciens
Confidentialité & Sécurité Zéro envoi sur serveur (Traitement dans le navigateur) Envoie vos PDF confidentiels sur des serveurs cloud
Confidentialité & Sécurité Zéro envoi sur serveur (Traitement dans le navigateur) Envoie vos PDF confidentiels sur des serveurs cloud
Taille Maximale de Fichier Aucune limite stricte (limitée uniquement par la RAM) Limites strictes de 10 Mo à 50 Mo
Confidentialité & Sécurité Zéro envoi sur serveur (Traitement dans le navigateur) Envoie vos PDF confidentiels sur des serveurs cloud
Comment ça marche

Comment utiliser Outils de Sécurité & Cryptographie en 3 étapes simples

Aucune installation requise. Tout s'exécute directement dans votre navigateur web.

1

Définir la Longueur et les Classes de Caractères

Sélectionnez une longueur entre 4 et 128 caractères et activez les majuscules (A-Z), minuscules (a-z), chiffres (0-9) et symboles ASCII imprimables selon vos contraintes cibles.

2

Configurer les Exclusions et le Nombre par Lot

Activez le filtrage des caractères ambigus (0/O, 1/l/I) pour la saisie manuelle ou augmentez la taille du lot afin de générer plusieurs secrets indépendants simultanément.

3

Vérifier l'Entropie en Bits et Copier

Contrôlez en direct l'entropie combinatoire et l'entropie de Shannon en bits par rapport à votre seuil de sécurité (128+ bits pour la production), puis copiez localement.

Génération de Mots de Passe CSPRNG à Haute Entropie : Configuration et Exemples

Réponse rapide: Adaptez le jeu de caractères et la longueur (4 à 128 caractères) au mode de stockage et d'analyse du secret. Utilisez 24+ caractères ASCII complets pour un gestionnaire de mots de passe, 32+ caractères alphanumériques pour les URI de connexion et fichiers .env afin d'éviter les bogues d'échappement, et des chaînes sans homoglyphes pour la saisie console manuelle.

Les différents environnements d'exécution imposent des contraintes d'analyse strictes sur les identifiants. Choisir le plus grand jeu de caractères sûr N et ajuster la longueur L permet d'atteindre les marges d'entropie cibles sans provoquer d'interpolation shell ni d'erreur d'analyse d'URI.

Profil 1 : Secret pour Coffre-Fort de Gestionnaire de Mots de Passe (ASCII Imprimable Complet)

Lorsque vous stockez des identifiants dans un coffre-fort chiffré (1Password, Bitwarden, KeePassXC ou HashiCorp Vault) pour le remplissage automatique ou des en-têtes d'API, activez les quatre classes de caractères (A-Z, a-z, 0-9 et les 32 symboles de ponctuation ASCII, N = 94) avec L = 24 :

Configuration : Longueur = 24 | Maj + Min + Chiffres + Symboles (N = 94) | Exclure Ambigus = Non
Sortie        : v9#Km!2pQ@7xR$4nL^8wZ&5j
Entropie Pool : 24 * log2(94) = 157.31 bits
Espace Clés   : 94^24 = 2.26e+47 combinaisons

Profil 2 : Identifiant de Service Compatible URI et Shell (Alphanumérique Uniquement)

Les DSN de bases de données (postgres://user:password@db.internal:5432/app) et les fichiers .env Docker cassent fréquemment lorsque les mots de passe contiennent des délimiteurs d'URI réservés par la RFC 3986 (:, /, ?, #, [, ], @) ou des jetons d'expansion shell ($, `, ", ', \). Désactiver les symboles (N = 62) et porter la longueur à L = 32 offre une entropie supérieure à celle d'un mot de passe de 24 caractères avec symboles, sans aucun risque d'échappement :

Configuration : Longueur = 32 | Maj + Min + Chiffres (N = 62) | Symboles = Non
Sortie        : 8fKp3mQv9xRt2nLw7zJc4bYh6dGs5aPe
Entropie Pool : 32 * log2(62) = 190.53 bits
Espace Clés   : 62^32 = 2.27e+57 combinaisons

Profil 3 : Codes d'Urgence Break-Glass par Lot (Caractères Ambigus Exclus)

Pour les consoles hors bande IPMI/iLO ou les fiches de reprise après sinistre où un ingénieur doit relire des caractères à l'écran dans des polices à chasse fixe ou proportionnelle, activez l'exclusion des caractères ambigus (0, O, 1, l, I retirés de N = 62, laissant N = 57) et générez un lot :

Configuration : Longueur = 20 | Maj + Min + Chiffres | Exclure Ambigus (0/O, 1/l/I) = Oui (N = 57) | Lot = 3
Sorties       :
  1. 7mKp4xQv9nRw3zJc8bYh
  2. 5dGs2fPe6tMa9kVu4wNx
  3. 3hBz8qJr7cLy2pWt6gKm
Entropie Pool : 20 * log2(57) = 116.66 bits par identifiant
Fonctionnalité ISO 32000 / WebAssembly / Web Crypto Utiliome (Navigateur local)
Générateur de mot de passe Web Crypto CSPRNG (getRandomValues) Générer des mots de passe aléatoires et complexes sur votre appareil.
Mots de passe mémorables Cryptographic Diceware Passphrases Créer des mots de passe ultra-sécurisés et faciles à retenir.
Générateur de hash SHA-256 / SHA-512 / SHA-1 (FIPS 180-4) Générer des hashs cryptographiques (SHA-256, SHA-512) depuis un texte.
Générateur HMAC Keyed-Hash HMAC (RFC 2104 / FIPS 198-1) Générer et vérifier des codes HMAC (HMAC-SHA256, HMAC-SHA512) en local.
Calculateur de checksum Multi-Hash Binary File Fingerprinting Calculer les hashs SHA-1, SHA-256, SHA-384 et SHA-512 localement.
Fichier SHA256 Local Multi-GB SHA-256 Verification Calculer et vérifier le hash SHA-256 d'un fichier en local sans envoi.

Construire des Phrases de Passe Diceware : Nombre de Mots, Délimiteurs et Exemples

Réponse rapide: Une phrase de passe de 6 mots tirée uniformément d'un dictionnaire Diceware de 7 776 mots offre 77,55 bits d'entropie cryptographique tout en restant facile à mémoriser et à taper à l'aveugle. L'ajout d'un chiffre et d'un symbole aléatoires porte la robustesse totale au-delà de 85 bits et passe les validateurs stricts de classes de caractères en entreprise.

La mémoire humaine peine à retenir 16 glyphes ASCII aléatoires (v9#Km!2pQ@7xR$4n), mais retient facilement 5 à 7 mots anglais concrets assemblés sous forme d'image mentale. L'utilisation d'un CSPRNG pour choisir les mots indépendamment préserve une sécurité mathématique stricte tout en optimisant l'ergonomie de frappe.

Profil 1 : Clé Maîtresse de Gestionnaire de Mots de Passe et Chiffrement Complet de Disque (LUKS2 / FileVault)

Lors des invites de chiffrement de disque au pré-démarrage (LUKS2, VeraCrypt, FileVault), le collage depuis le presse-papiers est indisponible et les dispositions de clavier non-US (comme l'AZERTY) peuvent décaler la ponctuation avec touche Maj. Six mots en minuscules séparés par des tirets issus d'un dictionnaire Diceware standard de 7,776 mots éliminent les fautes de frappe liées à la touche Maj tout en offrant une résistance massive aux attaques hors ligne sur les KDF :

Configuration : 6 Words | Separator = Hyphen (-) | Casing = lowercase | Extras = Off
Output        : lantern-cobalt-harvest-velvet-orbit-spruce
Word Entropy  : 6 * log2(7776) = 77.55 bits
Search Space  : 7776^6 = 2.21e+23 combinations

Profil 2 : Conformité aux Politiques SSO d'Entreprise et Active Directory

De nombreuses politiques IAM et Active Directory d'entreprise imposent des vérifications par expression régulière exigeant une majuscule, une minuscule, un chiffre [0-9] et un symbole. L'application du mode Casse Titre avec des délimiteurs underscore ou point, plus un chiffre tiré par CSPRNG (+3.32 bits) et un symbole CSPRNG (par exemple, issu d'un jeu de 32 symboles, +5.00 bits) satisfait proprement les validateurs existants :

Configuration : 5 Words | Separator = Period (.) | Casing = Title Case | Append Digit + Symbol = On
Output        : Glacier.Badger.Summit.Quartz.Anchor.7#
Total Entropy : (5 * 12.925) + log2(10) + log2(32) = 72.95 bits

Profil 3 : Clé Maîtresse GPG Isolée (Air-Gapped) ou Phrase de Passe d'Autorité de Certification Racine

Pour les racines de confiance cryptographiques hors ligne à longue durée de vie (clés de certification OpenPGP, clés à froid age/SSH ou extensions de phrase de passe BIP-39 pour portefeuilles matériels), passez à 7 ou 8 mots séparés par des espaces :

Configuration : 8 Words | Separator = Space ( ) | Casing = lowercase | Extras = Off
Output        : canyon timber falcon magnet fossil harbor meadow quartz
Word Entropy  : 8 * log2(7776) = 103.40 bits
Search Space  : 7776^8 = 1.34e+31 combinations

Qu'est-ce qu'une Somme de Contrôle SHA-256 ?

Réponse rapide: Une somme de contrôle SHA-256 est une empreinte hexadécimale unique de 64 caractères représentant le contenu binaire exact d'un fichier. Elle agit comme une empreinte digitale pour garantir que le fichier n'est ni altéré ni corrompu.

Le SHA-256 (Secure Hash Algorithm 256-bit) appartient à la famille SHA-2 définie par le NIST. Il produit une valeur de hachage fixe de 256 bits (32 octets), généralement représentée sous la forme d'une chaîne hexadécimale de 64 caractères.

  En raison de l'*effet d'avalanche* cryptographique, la modification d'un seul octet ou bit dans un fichier de plusieurs gigaoctets produira un résultat SHA-256 totalement différent. Cela fait du SHA-256 la référence pour vérifier les téléchargements de logiciels, les images ISO et les sauvegardes de bases de données.

Calcul et vérification des signatures HMAC de Webhooks et d'API : Guide pratique

Réponse rapide: Signer le message what do ya want for nothing? avec le secret de 4 octets Jefe (Cas de test 2 de l'IETF RFC 4231) sous HMAC-SHA256 produit 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 en Hex et W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= en Base64, que la clé soit fournie en mode UTF-8, Hex (4a656665) ou Base64 (SmVmZQ==).

Un code d'authentification de message par hachage à clé (HMAC, Keyed-Hash Message Authentication Code) prouve à la fois l'intégrité des données (le payload n'a pas été altéré en transit) et l'authenticité (l'expéditeur détient la clé secrète partagée). Pour reproduire la signature d'un fournisseur, trois paramètres exacts doivent correspondre : la primitive de hachage sous-jacente, le décodage en octets bruts de la clé secrète et la séquence exacte d'octets du payload signé.

Exemple 1 : Cas de test 2 IETF RFC 2104 / RFC 2202 / RFC 4231

Que vous saisissiez la clé secrète de 4 octets en texte UTF-8 Jefe, en hexadécimal brut 4a656665 ou en Base64 SmVmZQ==, elle est décodée dans le même tampon d'octets [0x4a, 0x65, 0x66, 0x65]. La signature du message UTF-8 de 28 octets what do ya want for nothing? produit :

{
  "keyUtf8": "Jefe",
  "keyHex": "4a656665",
  "keyBase64": "SmVmZQ==",
  "message": "what do ya want for nothing?",
  "signatures": {
    "hmac_md5_hex": "750c783e6ab0b503eaa86e310a5db738",
    "hmac_sha1_hex": "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
    "hmac_sha256_hex": "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
    "hmac_sha256_base64": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM=",
    "hmac_sha256_base64url": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM",
    "hmac_sha384_hex": "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
    "hmac_sha512_hex": "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
  }
}

Exemple 2 : Base64 vs Base64URL et Payloads canoniques de Webhooks

Le Base64 standard (RFC 4648 Section 4) émet les caractères +, / et un bourrage final =, tandis que le Base64URL compatible avec les URL (RFC 4648 Section 5, utilisé dans les signatures JWS/JWT et les URL signées) remplace + par -, / par _ et supprime le bourrage =. Signer The quick brown fox jumps over the lazy dog avec la clé UTF-8 key sous HMAC-SHA256 illustre directement cette différence d'encodage :

Key (UTF-8):     key
Message (UTF-8): The quick brown fox jumps over the lazy dog

HMAC-SHA256 Hex:       f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8
HMAC-SHA256 Base64:    97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg=
HMAC-SHA256 Base64URL: 97yD9DBThCSxMpjmqm-xQ-9NWaFJRhdZl0edvC0aPNg

Lors de la vérification d'en-têtes de webhooks réels, construisez le payload exact de pré-signature défini par chaque fournisseur avant de retirer les préfixes d'en-tête :

GitHub (X-Hub-Signature-256: sha256=<hex>):
  Signed input = <raw_http_body>

Stripe (Stripe-Signature: t=1730419200,v1=<hex>):
  Signed input = 1730419200.<raw_http_body>

Slack (X-Slack-Signature: v0=<hex>):
  Signed input = v0:1730419200:<raw_http_body>

Shopify (X-Shopify-Hmac-Sha256: <base64>):
  Signed input = <raw_http_body>
FAQ

FAQ et guide technique sur Outils de Sécurité & Cryptographie

Tout ce qu'il faut savoir sur l'utilisation en ligne gratuite de générateur de mots de passe et sha256.

Pourquoi faut-il désactiver les symboles pour les chaînes de connexion aux bases de données et les fichiers .env ?

La RFC 3986 réserve des caractères tels que :, /, ?, #, [, ], @ et % comme délimiteurs structurels d'URI, tandis que les shells POSIX et les chargeurs .env interprètent $, les accents graves (backticks), les guillemets, # et \ comme des expansions de variables, des commentaires ou des séquences d'échappement. Générer un mot de passe alphanumérique de 32 caractères (A-Z, a-z, 0-9, N = 62) produit 190.53 bits d'entropie — soit plus qu'un mot de passe de 24 caractères avec symboles (157.31 bits) — tout en éliminant les erreurs d'analyse et d'encodage URL dans les Secrets Kubernetes, Terraform et les pilotes JDBC/libpq.

Si la liste de mots est publique, un attaquant ne peut-il pas craquer ma phrase de passe avec une attaque par dictionnaire ?

Même lorsqu'un attaquant charge le dictionnaire exact de 7,776 mots dans Hashcat en mode combinatoire, la sélection uniforme par CSPRNG l'oblige à parcourir chaque combinaison W^k. Pour une phrase de passe de 6 mots, 7,776^6 équivaut à 2.21 x 10^23 candidats équiprobables (77.55 bits) — exactement la même barrière de calcul qu'une clé binaire brute de 77,5 bits, sans aucun motif grammatical permettant de prendre un raccourci.

Pourquoi ma commande de terminal echo "text" | sha256sum renvoie-t-elle un hachage différent de celui obtenu en collant text ici ?

Par défaut, echo ajoute un caractère de saut de ligne final (<LF>, octet 0x0a) à votre chaîne ; ainsi, echo "abc" hache en réalité la séquence de 4 octets 61 62 63 0a au lieu de la chaîne de 3 octets 61 62 63. Exécutez printf '%s' 'abc' | sha256sum (ou echo -n 'abc' | sha256sum) dans votre shell pour omettre le saut de ligne final et obtenir exactement les mêmes condensats de chaîne UTF-8.

Pourquoi la vérification HMAC de mon webhook échoue-t-elle alors que ma clé secrète et mes champs JSON semblent identiques ?

Deux problèmes expliquent plus de 90 % des erreurs de correspondance HMAC sur les webhooks. Premièrement, des middlewares comme express.json() dans Express analysent et re-sérialisent le JSON, modifiant les espaces, l'échappement Unicode ou l'ordre des clés par rapport au flux d'octets TCP brut signé par l'expéditeur — signez toujours le tampon brut non analysé de la requête et incluez les préfixes d'horodatage du fournisseur (comme <timestamp>.<body> pour Stripe ou v0:<timestamp>:<body> pour Slack). Deuxièmement, vérifiez si le secret du fournisseur doit être décodé depuis Base64 ou Hex en octets bruts plutôt que lu comme une chaîne UTF-8.

Qu'est-ce qu'un checksum et pourquoi est-il important ?

Un checksum est una chaîne alphanumérique unique générée par un algorithme cryptographique appliqué au contenu d'un fichier. Il agit comme une empreinte numérique. Si le fichier est modifié, le checksum change radicalement. Il permet de vérifier qu'un fichier téléchargé est identique à l'original et exempt de corruption ou de malware.

Mes fichiers sont-ils envoyés sur un serveur ?

Non. Tout le calcul est effectué localement dans la mémoire de votre navigateur via l'API Web Crypto native.