Säkerhets- & kryptografiverktyg

Skapa starka lösenord, hashvärden, HMAC, kontrollsummor och SHA-256-fingeravtryck i webbläsaren. Gratis, privat, noll uppladdningar.

100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis Säkerhets- & kryptografiverktyg?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Web Crypto CSPRNG-motor

Hämtar rå kryptografisk entropi direkt från webbläsarens crypto.getRandomValues() med stöd av OS-kärnans CSPRNG istället för det förutsägbara tillståndet i Math.random().

CSPRNG-baserat Diceware-ordval

Hämtar slumpmässiga engelska uppslagsord likformigt via Web Crypto crypto.getRandomValues() med väntevärdesriktig förkastelsesampling istället för förutsägbara mänskliga fraser.

Samtidig hashmatris för fem algoritmer

Beräknar 128-bitars MD5 (RFC 1321) tillsammans med 160-bitars SHA-1, 256-bitars SHA-256, 384-bitars SHA-384 och 512-bitars SHA-512 (NIST FIPS 180-4) från en enda UTF-8-sträng eller binär filbuffert i en enda körning.

Nativt Web Crypto API

Använder window.crypto.subtle hårdvaruacceleration för att beräkna SHA-256-kontrollsummor i maximal CPU-hastighet.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Dataintegritet & Säkerhet Noll serveruppladdningar (Bearbetning i webbläsaren) Laddar upp dina känsliga PDF-filer till externa molnservrar
Dataintegritet & Säkerhet Noll serveruppladdningar (Bearbetning i webbläsaren) Laddar upp dina känsliga PDF-filer till externa molnservrar
Maximal filstorlek Inga hårda gränser (begränsas endast av RAM) Strikta gränser på 10MB - 50MB
Dataintegritet & Säkerhet Noll serveruppladdningar (Bearbetning i webbläsaren) Laddar upp dina känsliga PDF-filer till externa molnservrar
Så fungerar det

Hur du använder Säkerhets- & kryptografiverktyg i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Ange längd och teckenklasser

Välj en längd mellan 4 och 128 tecken och aktivera versaler (A-Z), gemener (a-z), siffror (0-9) samt skrivbara ASCII-symboler för att matcha målsystemets krav.

2

Konfigurera exkluderingar och antal för bulkgenerering

Aktivera filtrering av tvetydiga tecken (0/O, 1/l/I) för manuell avskrivning eller öka batchantalet för att generera flera oberoende hemligheter samtidigt.

3

Granska entropibitar och kopiera

Verifiera realtidsavläsningen av kombinatorisk entropi och Shannon-entropi i bitar mot ditt säkerhetströskelvärde (128+ bitar för produktionshemligheter) och kopiera sedan lokalt.

Generera CSPRNG-lösenord med hög entropi: konfiguration och exempel

Snabbsvar: Anpassa teckenpooler och längd (4 till 128 tecken) efter hur hemligheten lagras och tolkas. Använd 24+ fullständiga ASCII-tecken för poster i lösenordshanterare, 32+ alfanumeriska tecken för URI-anslutningssträngar och .env-filer för att undvika tolkningsfel vid avgränsare, samt homoglyffiltrerade strängar för manuell konsolinmatning.

Olika körmiljöer ställer strikta tolkningskrav på autentiseringsuppgifter. Genom att välja den största säkra teckenpoolen N och skala längden L kan du uppnå dina mål för bitentropi utan att utlösa skalinterpolering eller fel i URI-tolkare.

Profil 1: Valvhemlighet i lösenordshanterare (fullständig skrivbar ASCII)

När du lagrar inloggningsuppgifter i ett krypterat valv (1Password, Bitwarden, KeePassXC eller HashiCorp Vault) för automatisk ifyllnad i formulär eller API-headers, aktivera alla fyra teckenklasserna (A-Z, a-z, 0-9 och 32 ASCII-skiljetecken, N = 94) vid L = 24:

Configuration : Length = 24 | Upper + Lower + Digits + Symbols (N = 94) | Exclude Ambiguous = Off
Output        : v9#Km!2pQ@7xR$4nL^8wZ&5j
Pool Entropy  : 24 * log2(94) = 157.31 bits
Search Space  : 94^24 = 2.26e+47 combinations

Profil 2: URI-säker och skalsäker tjänstehemlighet (endast alfanumeriska tecken)

Databas-DSN:er (postgres://user:password@db.internal:5432/app) och Docker .env-filer går ofta sönder när lösenord innehåller reserverade URI-avgränsare enligt RFC 3986 (:, /, ?, #, [, ], @) eller tecken för skalexpansion ($, `, ", ', \). Genom att inaktivera symboler (N = 62) och öka längden till L = 32 får du högre entropi än med ett 24-teckens symbollösenord, helt utan risk för escape-relaterade buggar:

Configuration : Length = 32 | Upper + Lower + Digits (N = 62) | Symbols = Off
Output        : 8fKp3mQv9xRt2nLw7zJc4bYh6dGs5aPe
Pool Entropy  : 32 * log2(62) = 190.53 bits
Search Space  : 62^32 = 2.27e+57 combinations

Profil 3: Nödåtkomstkoder i bulk (tvetydiga tecken exkluderade)

För out-of-band-konsoler (IPMI/iLO) eller utskrivna katastrofåterställningsblad där en tekniker måste läsa av tecken på en skärm med fast eller proportionellt teckenavstånd, aktivera exkludering av tvetydiga tecken (0, O, 1, l, I borttagna från N = 62, vilket ger N = 57) och generera en batch:

Configuration : Length = 20 | Upper + Lower + Digits | Exclude Ambiguous (0/O, 1/l/I) = On (N = 57) | Bulk = 3
Outputs       :
  1. 7mKp4xQv9nRw3zJc8bYh
  2. 5dGs2fPe6tMa9kVu4wNx
  3. 3hBz8qJr7cLy2pWt6gKm
Pool Entropy  : 20 * log2(57) = 116.66 bits per credential
Funktion ISO 32000 / WebAssembly / Web Crypto Utiliome (Lokal webbläsare)
Säker lösenordsgenerator Web Crypto CSPRNG (getRandomValues) Generera kryptografiskt säkra och komplexa slumpmässiga lösenord.
Lättihågkomna lösenord Cryptographic Diceware Passphrases Skapa säkra och lättihågkomna lösenord med hjälp av Diceware & mnemoteknik.
Hash-generator SHA-256 / SHA-512 / SHA-1 (FIPS 180-4) Generera säkra kryptografiska hashar (SHA-256, SHA-512) från text.
HMAC-generator Keyed-Hash HMAC (RFC 2104 / FIPS 198-1) Generera och verifiera HMAC-koder (HMAC-SHA256, HMAC-SHA512) lokalt.
Beräkna kontrollsumma Multi-Hash Binary File Fingerprinting Beräkna SHA-1, SHA-256, SHA-384 och SHA-512-hashar lokalt i webbläsaren.
SHA256-fil Local Multi-GB SHA-256 Verification Beräkna och verifiera SHA-256-hash för filer lokalt utan uppladdning.

Bygga Diceware-lösenfraser: Antal ord, avgränsare och utdataexempel

Snabbsvar: En lösenfras på 6 ord som dras likformigt ur en Diceware-ordlista med 7 776 ord ger 77,55 bitar kryptografisk entropi samtidigt som den är enkel att memorera och skriva utan att titta. Genom att lägga till en slumpmässig siffra och symbol ökar den totala styrkan till över 85 bitar och passerar strikta teckenklassvaliderare i företagsmiljöer.

Det mänskliga minnet har svårt att komma ihåg 16 slumpmässiga ASCII-tecken (v9#Km!2pQ@7xR$4n), men minns enkelt 5 till 7 konkreta ord sammanfogade som en mental bild. Att använda en CSPRNG för att välja ord oberoende av varandra bevarar strikt matematisk säkerhet samtidigt som skrivupplevelsen optimeras.

Profil 1: Huvudnyckel för lösenordshanterare och hårddiskkryptering (LUKS2 / FileVault)

Vid inmatning av lösenord för helhårddiskkryptering före systemstart (LUKS2, VeraCrypt, FileVault) fungerar inte urklippshanteraren, och nordiska eller icke-amerikanska tangentbordslayouter kan placera specialtecken på oväntade ställen. Sex gemena ord separerade med bindestreck från en standardiserad Diceware-ordlista på 7 776 ord eliminerar skrivfel med Skift-tangenten och ger massivt skydd mot offline-attacker via 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: Efterlevnad av företags-SSO och Active Directory-policyer

Många IAM- och Active Directory-policyer i företag kräver reguljära uttryck med versaler, gemener, en siffra [0-9] och en symbol. Genom att använda Inledande Versal (Title Case) med understreck eller punkt som avgränsare plus en CSPRNG-dragen siffra (+3,32 bitar) och en CSPRNG-symbol (t.ex. från en pool med 32 symboler, +5,00 bitar) uppfylls äldre valideringskrav utan problem:

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: Air-gappad GPG-huvudnyckel eller lösenfras för Root CA

För långlivade kryptografiska rötter offline (OpenPGP-certifieringsnycklar, kalla age-/SSH-nycklar eller BIP-39-lösenfrasförlängningar för hårdvaruplånböcker), skala upp till 7 eller 8 mellanslagsseparerade ord:

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

Vad är en SHA-256-kontrollsumma?

Snabbsvar: En SHA-256-kontrollsumma är ett unikt hexadecimalt värde på 64 tecken som representerar det exakta binära innehållet i en fil. Det fungerar som ett digitalt fingeravtryck.

SHA-256 (Secure Hash Algorithm 256-bit) ingår i SHA-2-familjen definierad av NIST. Den genererar ett fast 256-bitars (32-byte) hashvärde, vanligtvis visat som en hexadecimal sträng på 64 tecken.

  På grund av den kryptografiska *lavineffekten* kommer ändring av en enda byte i en fil på flera gigabyte att ge ett helt annorlunda SHA-256-resultat. Detta gör SHA-256 till standarden för att verifiera programvarunedladdningar, OS ISO-bilder och databas-backuper.

Beräkna och verifiera HMAC-signaturer för webhooks och API:er: Praktisk genomgång

Snabbsvar: Att signera meddelandet what do ya want for nothing? med den 4 byte långa hemligheten Jefe (IETF RFC 4231 Testfall 2) under HMAC-SHA256 ger 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 i Hex och W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= i Base64 oavsett om nyckelläget är UTF-8, Hex (4a656665) eller Base64 (SmVmZQ==).

En Keyed-Hash Message Authentication Code (HMAC) bevisar både dataintegritet (att payloaden inte har ändrats under överföringen) och autenticitet (att avsändaren innehar den delade hemliga nyckeln). För att återskapa en tjänsteleverantörs signatur krävs att tre exakta parametrar matchar: den underliggande hashprimitiven, råbyteavkodningen av den hemliga nyckeln och den exakta bytesekvensen för den signerade payloaden.

Exempel 1: IETF RFC 2104 / RFC 2202 / RFC 4231 Testfall 2

Oavsett om du anger den 4 byte långa hemliga nyckeln som UTF-8-text Jefe, rå hexadecimal 4a656665 eller Base64 SmVmZQ==, avkodas den till den identiska nyckelbufferten [0x4a, 0x65, 0x66, 0x65]. Att signera det 28 byte långa UTF-8-meddelandet what do ya want for nothing? ger:

{
  "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"
  }
}

Exempel 2: Base64 kontra Base64URL och kanoniska payloads för webhooks

Standard-Base64 (RFC 4648 sektion 4) genererar +, / och avslutande =-utfyllnad, medan URL-säker Base64URL (RFC 4648 sektion 5, som används i JWS/JWT-signaturer och signerade URL:er) ersätter + med -, / med _ och tar bort =-utfyllnad. Att signera The quick brown fox jumps over the lazy dog med UTF-8-nyckeln key under HMAC-SHA256 illustrerar kodningsskillnaden direkt:

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

När du verifierar verkliga webhook-headers måste du konstruera den exakta payloaden som definieras av respektive leverantör innan du tar bort header-prefix:

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

Säkerhets- & kryptografiverktyg FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis lösenordsgenerator och sha256 kontrollsumma online.

Varför bör jag inaktivera symboler för databasanslutningssträngar och .env-filer?

RFC 3986 reserverar tecken som :, /, ?, #, [, ], @ och % som strukturella URI-avgränsare, medan POSIX-skal och .env-inläsare tolkar $, gravaccenter (backticks), citattecken, # och \ som variabelexpansioner, kommentarer eller escape-sekvenser. Att generera ett 32 tecken långt alfanumeriskt lösenord (A-Z, a-z, 0-9, N = 62) ger 190.53 bitar i entropi – starkare än ett 24-teckens symbollösenord (157.31 bitar) – samtidigt som det eliminerar tolknings- och URL-kodningsfel i Kubernetes Secrets, Terraform samt JDBC/libpq-drivrutiner.

Om ordlistan är publik, kan inte en angripare knäcka min lösenfras med en ordlisteattack?

Även när en angripare laddar in den exakta ordlistan med 7 776 ord i Hashcat i kombinatorläge, tvingar likformigt CSPRNG-urval dem att söka igenom varje W^k-kombination. För en lösenfras på 6 ord motsvarar 7 776^6 totalt 2,21 x 10^23 lika sannolika kandidater (77,55 bitar) – exakt samma beräkningsbarriär som en rå binär nyckel på 77,5 bitar, med noll grammatiska mönster att ta genvägar via.

Varför returnerar mitt terminalkommando echo "text" | sha256sum en annan hash än när jag klistrar in text här?

Som standard lägger echo till ett avslutande radmatningstecken (<LF>, byte 0x0a) till din sträng, så echo "abc" hashar egentligen 4-bytesekvensen 61 62 63 0a i stället för 3-bytesträngen 61 62 63. Kör printf '%s' 'abc' | sha256sum (eller echo -n 'abc' | sha256sum) i ditt skal för att utelämna den avslutande radbrytningen och matcha exakta UTF-8-stränghashar.

Varför misslyckas min webhook HMAC-verifiering trots att min hemliga nyckel och JSON-fälten ser identiska ut?

Två problem orsakar över 90 % av alla fel vid HMAC-verifiering av webhooks. För det första tolkar och omserialiserar middleware som Express express.json() JSON-data, vilket ändrar blanksteg, Unicode-kodning eller nyckelordning i förhållande till den råa TCP-byteström som avsändaren signerade – signera alltid den råa, otolkade requestbufferten och inkludera leverantörens tidsstämpelprefix (såsom Stripes <timestamp>.<body> eller Slacks v0:<timestamp>:<body>). För det andra bör du kontrollera om leverantörens hemlighet måste avkodas från Base64 eller Hex till råa byte istället för att läsas som en UTF-8-sträng.

Vad är en checksum och varför är den viktig?

En checksum är en unik alfanumerisk sträng som skapas med en kryptografisk algoritm utifrån filens innehåll. Den fungerar som ett digitalt fingeravtryck för att säkerställa att filen inte skadats eller ändrats.

Laddas mina filer upp till någon server?

Nej. Alla beräkningar sker lokalt i din webbläsares minne med hjälp av det nativa Web Crypto API:et.