Anúncios incomodam? Ir Sem anúncios Hoje 

Argon2 Hash Generator

DesenvolvedorSegurança

ENTRADA

Senha

Password / message to hash *

Argon2 Parameters

Variante

Argon2id (recommended) is a hybrid resistant to both side-channel and GPU attacks. Argon2i resists side-channel attacks; Argon2d maximises GPU resistance.

Memory cost (m)

KiB

Memory used during hashing, in KiB. Higher is more secure but slower. 65536 KiB = 64 MiB (a common default). Larger values may be slow or fail in the browser.

Iterations (t)

Number of passes over memory (time cost). Higher is more secure but slower.

Parallelism (p)

Number of parallel lanes. The in-browser engine runs them sequentially, so keep this low (1 is typical).

Hash length (bytes)

Length of the derived key in bytes. 32 bytes (256 bits) is a common default.

Salt

A random salt is generated for every hash by default — recommended. Choose Custom only when you need a reproducible salt.

Custom salt

Used verbatim (UTF-8 bytes) as the salt. Must be at least 8 bytes.

Saída

Formato de saída

PHC encoded string includes the variant, parameters and salt — the portable, verifiable format. Hex / Base64 output the raw derived key only.

Verify against hash

Optionally check whether the password above matches an existing Argon2 PHC-encoded hash.

SAÍDA

Lado cliente

ANUNCIADO Remover?

Guia

Argon2 Hash Generator

Generate real Argon2 password hashes right in your browser. Argon2 is the modern, memory-hard password-hashing algorithm that won the Password Hashing Competition, and it is the recommended choice for storing passwords securely. This tool computes genuine Argon2id, Argon2i and Argon2d hashes using a WebAssembly engine — your password, salt and resulting hash never leave your device.

Como usar

Enter the password or message you want to hash.
Choose a variant — Argon2id is recommended for password storage.
Tune the memory cost, iterations, parallelism and hash length, or keep the sensible defaults.
Let the tool auto-generate a random salt, or supply your own for reproducible results.
Pick your output format: a portable PHC encoded string, raw hex, or base64.
Clique Gerar hash. Optionally paste an existing Argon2 hash to verify a password against it.

Características

All three variants – Argon2id, Argon2i and Argon2d.
Configurable cost parameters – set memory, iterations, parallelism and hash length.
Flexible salt – cryptographically random by default, or bring your own.
Múltiplos formatos de saída – PHC encoded string, hex, or base64.
Built-in verify mode – check whether a password matches an existing Argon2 hash.
Fully private – everything runs locally in your browser; nothing is uploaded.

 Perguntas frequentes

What makes Argon2 resistant to GPU and ASIC cracking?

Argon2 is a memory-hard function: it deliberately uses a large, configurable amount of RAM during each computation. GPUs and custom ASICs get their speed from massive parallelism, but they have comparatively little fast memory per core, so forcing every guess to allocate tens of megabytes sharply limits how many hashes an attacker can compute in parallel.
What is the difference between Argon2id, Argon2i and Argon2d?

Argon2d accesses memory in a data-dependent way, which maximises resistance to GPU cracking but can leak information through side channels. Argon2i uses data-independent memory access, protecting against side-channel attacks but offering slightly less GPU resistance. Argon2id is a hybrid that runs the first half as Argon2i and the rest as Argon2d, giving balanced protection. It is the variant recommended for password hashing.
Why does a password hash need a salt?

A salt is a unique random value combined with the password before hashing. It ensures two users with the same password produce different hashes, and it defeats precomputed lookup tables such as rainbow tables. Because the salt does not need to be secret, it is stored alongside the hash, which is exactly what the PHC encoded format does.
What do the memory, iterations and parallelism parameters control?

Memory cost sets how much RAM (in KiB) each hash computation consumes. Iterations (time cost) sets how many passes are made over that memory, increasing the work linearly. Parallelism sets how many independent lanes are used. Together they let you tune Argon2 so a single hash takes a noticeable fraction of a second on your hardware, which is slow enough to frustrate attackers but fast enough for legitimate logins.