Strumenti di Sicurezza e Crittografia

Genera password forti, hash, HMAC, checksum e impronte SHA-256 dei file nel tuo browser. Gratis, privato, zero caricamenti.

100% Privato • Nessun Caricamento File su Server

Perché usare il Strumenti di Sicurezza e Crittografia gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Motore Web Crypto CSPRNG

Attinge entropia crittografica grezza direttamente da crypto.getRandomValues() del browser basato sul CSPRNG del kernel OS anziché dallo stato prevedibile di Math.random().

Selezione Parole Diceware CSPRNG

Estrae parole casuali dal dizionario in modo uniforme tramite Web Crypto crypto.getRandomValues() con rejection sampling imparziale anziché frasi umane prevedibili.

Matrice di Digest Simultanea a Cinque Algoritmi

Calcola in un singolo passaggio MD5 a 128 bit (RFC 1321) insieme a SHA-1 a 160 bit, SHA-256 a 256 bit, SHA-384 a 384 bit e SHA-512 a 512 bit (NIST FIPS 180-4) da una stringa UTF-8 o dal buffer binario di un file.

API Web Crypto Nativa

Sfrutta l'accelerazione hardware di window.crypto.subtle per calcolare i checksum SHA-256 alla massima velocità della CPU.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Privacy e Sicurezza dei Dati Zero upload su server (Elaborazione nel browser) Carica i tuoi PDF riservati su server cloud remoti
Privacy e Sicurezza dei Dati Zero upload su server (Elaborazione nel browser) Carica i tuoi PDF riservati su server cloud remoti
Dimensione Max File Nessun limite rigido (limitato solo dalla RAM) Limiti severi da 10MB a 50MB
Privacy e Sicurezza dei Dati Zero upload su server (Elaborazione nel browser) Carica i tuoi PDF riservati su server cloud remoti
Come funziona

Come usare Strumenti di Sicurezza e Crittografia in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Imposta Lunghezza e Classi di Caratteri

Seleziona una lunghezza tra 4 e 128 caratteri e attiva maiuscole (A-Z), minuscole (a-z), cifre (0-9) e simboli ASCII stampabili per rispettare i vincoli del sistema di destinazione.

2

Configura Esclusioni e Generazione Multipla

Abilita il filtro dei caratteri ambigui (0/O, 1/l/I) per facilitare la trascrizione manuale o aumenta la quantità del lotto per generare più segreti indipendenti contemporaneamente.

3

Verifica i Bit di Entropia e Copia

Controlla in tempo reale l'entropia combinatoria e di Shannon in bit rispetto alla tua soglia di sicurezza (128+ bit per credenziali di produzione), quindi copia in locale.

Generazione di Password CSPRNG ad Alta Entropia: Configurazione ed Esempi

Risposta Rapida: Adatta il set di caratteri e la lunghezza (da 4 a 128 caratteri) al modo in cui il segreto viene archiviato e analizzato. Usa oltre 24 caratteri ASCII completi per i password manager, oltre 32 caratteri alfanumerici per stringhe di connessione URI e file .env per evitare bug di escaping dei delimitatori, e stringhe filtrate dagli omoglifi per l'inserimento manuale da console.

Diversi ambienti di runtime impongono rigorosi vincoli di parsing sulle credenziali. Selezionare il pool di caratteri sicuro più ampio N e scalare la lunghezza L consente di raggiungere i margini di entropia in bit desiderati senza innescare interpolazioni della shell o errori nei parser URI.

Profilo 1: Segreto per Vault di Password Manager (ASCII Stampabile Completo)

Quando si archiviano credenziali all'interno di un vault crittografato (1Password, Bitwarden, KeePassXC o HashiCorp Vault) per la compilazione automatica dei form o per gli header API, abilita tutte e quattro le classi di caratteri (A-Z, a-z, 0-9 e 32 simboli di punteggiatura ASCII, N = 94) con L = 24:

Configurazione : Lunghezza = 24 | Maiusc + Minusc + Cifre + Simboli (N = 94) | Escludi Ambigui = Off
Output         : v9#Km!2pQ@7xR$4nL^8wZ&5j
Entropia Pool  : 24 * log2(94) = 157.31 bit
Spazio Ricerca : 94^24 = 2.26e+47 combinazioni

Profilo 2: Credenziale di Servizio Sicura per URI e Shell (Solo Alfanumerici)

I DSN dei database (postgres://user:password@db.internal:5432/app) e i file .env di Docker si interrompono frequentemente quando le password contengono delimitatori URI riservati secondo RFC 3986 (:, /, ?, #, [, ], @) o token di espansione della shell ($, `, ", ', \). Disabilitare i simboli (N = 62) ed espandere la lunghezza a L = 32 fornisce un'entropia superiore rispetto a una password di 24 caratteri con simboli, azzerando i rischi di escaping:

Configurazione : Lunghezza = 32 | Maiusc + Minusc + Cifre (N = 62) | Simboli = Off
Output         : 8fKp3mQv9xRt2nLw7zJc4bYh6dGs5aPe
Entropia Pool  : 32 * log2(62) = 190.53 bit
Spazio Ricerca : 62^32 = 2.27e+57 combinazioni

Profilo 3: Codici Break-Glass in Blocco (Caratteri Ambigui Esclusi)

Per le console out-of-band IPMI/iLO o le schede di disaster recovery in cui un ingegnere deve leggere i caratteri su uno schermo con font monospazio o proporzionali, abilita l'esclusione dei caratteri ambigui (0, O, 1, l, I rimossi da N = 62, lasciando N = 57) e genera un lotto:

Configurazione : Lunghezza = 20 | Maiusc + Minusc + Cifre | Escludi Ambigui (0/O, 1/l/I) = On (N = 57) | Blocco = 3
Output         :
  1. 7mKp4xQv9nRw3zJc8bYh
  2. 5dGs2fPe6tMa9kVu4wNx
  3. 3hBz8qJr7cLy2pWt6gKm
Entropia Pool  : 20 * log2(57) = 116.66 bit per credenziale
Funzionalità ISO 32000 / WebAssembly / Web Crypto Utiliome (Browser Locale)
Generatore Password Sicure Web Crypto CSPRNG (getRandomValues) Genera password casuali complesse e crittograficamente sicure.
Password Facili da Ricordare Cryptographic Diceware Passphrases Crea password matematicamente sicure e facili da ricordare con Diceware.
Generatore di Hash SHA-256 / SHA-512 / SHA-1 (FIPS 180-4) Genera hash crittografici sicuri (SHA-256, SHA-512, ecc.) da qualsiasi testo.
Generatore HMAC Keyed-Hash HMAC (RFC 2104 / FIPS 198-1) Genera e verifica codici HMAC (HMAC-SHA256, HMAC-SHA512, MD5) nel browser.
Calcolatore Checksum Multi-Hash Binary File Fingerprinting Calcola hash SHA-1, SHA-256, SHA-384 e SHA-512 per qualsiasi file nel browser.
File SHA256 Local Multi-GB SHA-256 Verification Calcola e verifica l'hash SHA-256 di qualsiasi file localmente senza upload.

Creazione di Passphrase Diceware: Numero di Parole, Delimitatori ed Esempi di Output

Risposta Rapida: Una passphrase di 6 parole estratta uniformemente da un dizionario Diceware di 7.776 parole fornisce 77,55 bit di entropia crittografica pur rimanendo facile da memorizzare e digitare alla cieca. L'aggiunta di una cifra e di un simbolo casuali porta la sicurezza totale oltre gli 85 bit e supera i rigorosi validatori aziendali basati sulle classi di caratteri.

La memoria umana fatica a ricordare 16 glifi ASCII casuali (v9#Km!2pQ@7xR$4n), ma trattiene facilmente da 5 a 7 parole concrete associate in un'immagine mentale. L'utilizzo di un CSPRNG per estrarre le parole in modo indipendente preserva una rigorosa sicurezza matematica ottimizzando al contempo l'ergonomia di digitazione.

Profilo 1: Master Key per Password Manager e Crittografia Completa del Disco (LUKS2 / FileVault)

Durante le richieste di crittografia completa del disco pre-boot (LUKS2, VeraCrypt, FileVault), l'incolla dagli appunti non è disponibile e i layout di tastiera non statunitensi possono spostare la punteggiatura ottenuta con il tasto Shift. Sei parole in minuscolo separate da trattini su un dizionario Diceware standard di 7.776 parole eliminano gli errori di battitura dovuti al tasto Shift, offrendo al contempo un'enorme resistenza offline alle 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

Profilo 2: Conformità alle Policy Enterprise SSO e Active Directory

Molte policy aziendali IAM e Active Directory impongono controlli regex che richiedono lettere maiuscole, minuscole, una cifra [0-9] e un simbolo. L'applicazione di Iniziali Maiuscole (Title Case) con delimitatori underscore o punto, più una cifra estratta tramite CSPRNG (+3.32 bits) e un simbolo CSPRNG (ad es. da un pool di 32 simboli, +5.00 bits), soddisfa in modo pulito i validatori legacy:

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

Profilo 3: Master Key GPG Air-Gapped o Passphrase Root CA

Per radici di fiducia crittografiche offline a lunga durata (chiavi di certificazione OpenPGP, chiavi cold age/SSH o estensioni passphrase BIP-39 per hardware wallet), scala fino a 7 o 8 parole separate da spazi:

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

Cos'è un Checksum di File SHA-256?

Risposta Rapida: Un checksum SHA-256 è un'impronta esadecimale di 64 caratteri che rappresenta l'esatto contenuto binario di un file. Funziona come un'impronta digitale per garantire che il file non sia corrotto o alterato.

Il SHA-256 (Secure Hash Algorithm 256-bit) fa parte della famiglia SHA-2 definita dal NIST. Genera un valore hash fisso a 256 bit (32 byte), solitamente visualizzato come una stringa esadecimale di 64 caratteri.

  A causa dell'*effetto valanga* crittografico, la modifica anche di un solo byte in un file di diversi gigabyte produrrà un valore SHA-256 del tutto differente. Ciò rende SHA-256 lo standard ideale per verificare il download di software, immagini ISO e backup di database.

Calcolo e Verifica di Firme HMAC per Webhook e API: Guida Pratica

Risposta Rapida: Firmare il messaggio what do ya want for nothing? con il segreto di 4 byte Jefe (Caso di Test 2 IETF RFC 4231) con HMAC-SHA256 produce 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 in Hex e W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= in Base64 in tutte le modalità di chiave UTF-8, Hex (4a656665) e Base64 (SmVmZQ==).

Un Keyed-Hash Message Authentication Code (HMAC) dimostra sia l'integrità dei dati (il payload non è stato alterato durante il transito) sia l'autenticità (il mittente possiede la chiave segreta condivisa). Riprodurre la firma di un provider richiede la corrispondenza esatta di tre parametri: la primitiva di hash sottostante, la decodifica in byte grezzi della chiave segreta e la sequenza esatta di byte del payload firmato.

Esempio 1: Caso di Test 2 IETF RFC 2104 / RFC 2202 / RFC 4231

Sia che tu inserisca la chiave segreta di 4 byte come testo UTF-8 Jefe, esadecimale grezzo 4a656665 o Base64 SmVmZQ==, essa viene decodificata nell'identico buffer di chiave [0x4a, 0x65, 0x66, 0x65]. Firmando il messaggio UTF-8 di 28 byte what do ya want for nothing? si ottiene:

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

Esempio 2: Base64 vs Base64URL e Payload Canonici dei Webhook

Il formato Base64 standard (RFC 4648 Sezione 4) emette +, / e il padding finale =, mentre il formato URL-safe Base64URL (RFC 4648 Sezione 5, utilizzato nelle firme JWS/JWT e negli URL firmati) sostituisce + con -, / con _ e rimuove il padding =. Firmare The quick brown fox jumps over the lazy dog con la chiave UTF-8 key sotto HMAC-SHA256 illustra direttamente la differenza di codifica:

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

Quando verifichi gli header dei webhook reali, costruisci l'esatto payload pre-firma definito da ciascun provider prima di rimuovere i prefissi degli header:

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>
Domande frequenti

FAQ e Guida Tecnica su Strumenti di Sicurezza e Crittografia

Tutto ciò che devi sapere sull'uso di generatore password e checksum sha256 online e gratuito di Utiliome.

Perché dovrei disabilitare i simboli per le stringhe di connessione ai database e i file .env?

L'RFC 3986 riserva caratteri come :, /, ?, #, [, ], @ e % come delimitatori strutturali URI, mentre le shell POSIX e i loader .env interpretano $, backtick, virgolette, # e \ come espansioni di variabili, commenti o sequenze di escape. Generare una password alfanumerica di 32 caratteri (A-Z, a-z, 0-9, N = 62) produce 190.53 bit di entropia — più robusta di una password di 24 caratteri con simboli (157.31 bit) — eliminando al contempo errori di parsing e codifica URL su Kubernetes Secrets, Terraform e driver JDBC/libpq.

Se la wordlist è pubblica, un attaccante non può violare la mia passphrase con un attacco a dizionario?

Anche quando un attaccante carica l'esatto dizionario di 7.776 parole in Hashcat in modalità combinatoria, la selezione uniforme tramite CSPRNG lo costringe a cercare in ogni combinazione W^k. Per una passphrase di 6 parole, 7.776^6 equivale a 2.21 x 10^23 candidati equiprobabili (77.55 bits), esattamente la stessa barriera computazionale di una chiave binaria grezza da 77,5 bit, con zero pattern grammaticali da sfruttare come scorciatoia.

Perché il comando da terminale echo "text" | sha256sum restituisce un hash diverso rispetto a quando incollo text qui?

Per impostazione predefinita, echo aggiunge un carattere di nuova riga finale (<LF>, byte 0x0a) alla stringa; di conseguenza echo "abc" calcola in realtà l'hash della sequenza di 4 byte 61 62 63 0a anziché della stringa di 3 byte 61 62 63. Esegui printf '%s' 'abc' | sha256sum (oppure echo -n 'abc' | sha256sum) nella shell per omettere il ritorno a capo finale e ottenere esattamente gli stessi digest UTF-8.

Perché la verifica HMAC del mio webhook fallisce anche quando la chiave segreta e i campi JSON sembrano identici?

Due problemi causano oltre il 90% delle mancate corrispondenze HMAC nei webhook. Innanzitutto, middleware come express.json() di Express analizzano e ri-serializzano il JSON, alterando spazi bianchi, escaping Unicode o l'ordine delle chiavi rispetto al flusso di byte TCP grezzo firmato dal mittente: firma sempre il buffer della richiesta grezzo non analizzato e includi i prefissi di timestamp del provider (come <timestamp>.<body> di Stripe o v0:<timestamp>:<body> di Slack). In secondo luogo, verifica se il segreto del provider deve essere decodificato da Base64 o Hex in byte grezzi anziché essere letto come stringa UTF-8.

Che cos'è un checksum e perché è importante?

Un checksum è una stringa alfanumerica unica generata applicando un algoritmo crittografico al contenuto di un file. Funziona come un'impronta digitale: se anche un solo byte del file viene modificato, il checksum cambia radicalmente. È importante perché ti aiuta a verificare che un file scaricato sia identico all'originale, assicurando che non sia corrotto o infetto da malware.

I miei file vengono caricati su qualche server?

No. Tutti i calcoli avvengono in locale nella memoria del browser mediante l'API Web Crypto nativa.