Segurança e Criptografia

Gerador de Argon2

Gere um hash Argon2id no formato PHC, com salt de 16 bytes.

Argon2 é uma família de algoritmos para derivação de hashes de senha, com parâmetros de memória e processamento. A variante Argon2id é usada nesta ferramenta para gerar exemplos com salt e parâmetros registrados no resultado, permitindo estudar seu funcionamento e testar verificações.

Argon2id, versão 19, saída de 32 bytes. O salt e os parâmetros ficam incluídos no hash.

Resultado

Entradas e resultados permanecem nesta página e não são enviados a um serviço externo. Nenhum segredo é salvo pelo utilitário.

Esta ferramenta foi desenvolvida para apoiar estudantes e programadores em atividades de aprendizagem, desenvolvimento e testes autorizados. Utilize os resultados com responsabilidade, respeitando a privacidade, os direitos de terceiros e as regras do ambiente em que forem aplicados. Sua finalidade é educativa e técnica, sem promover fraude, uso indevido de dados ou qualquer ação que prejudique instituições, pessoas ou grupos.

Como usar

Configure os campos e execute a ferramenta. O processamento acontece localmente no navegador. Copie o resultado ou baixe os arquivos quando disponíveis. Os exemplos ao lado usam os parâmetros padrão.

Exemplos de código

Implemente no seu projeto

import * as __biblioteca0 from "hash-wasm";
async function executar(values = { "password": "Senha de exemplo", "memory": "65536", "iterations": "3", "parallelism": "1" }) {
    function integer(values, key, fallback, min, max) {
        const raw = values[key] ?? String(fallback);
        const value = Number(raw);
        if (!/^\d+$/.test(raw) || !Number.isSafeInteger(value) || value < min || value > max)
            throw new Error(`${key}: informe um inteiro entre ${min} e ${max}.`);
        return value;
    }
    function required(values, key) {
        if (!values[key])
            throw new Error(`Preencha o campo ${key}.`);
        return values[key];
    }
    function randomBytes(size) { return crypto.getRandomValues(new Uint8Array(size)); }
    async function runSecurityTool(kind, values) {
        if (!crypto.subtle)
            throw new Error('Esta ferramenta requer Web Crypto em HTTPS ou localhost.');
        if (Object.values(values).some(value => value.length > 1000000))
            throw new Error('Limite de entrada: 1 milhão de caracteres por campo.');
        {
            {
                const { argon2id } = await __biblioteca0;
                const memory = integer(values, 'memory', 65536, 8192, 131072), iterations = integer(values, 'iterations', 3, 1, 10), parallelism = integer(values, 'parallelism', 1, 1, 4);
                const salt = randomBytes(16);
                return { text: await argon2id({ password: required(values, 'password'), salt, memorySize: memory, iterations, parallelism, hashLength: 32, outputType: 'encoded' }) };
            }
        }
    }
    return await runSecurityTool("argon2", values);
}

from argon2 import PasswordHasher, Type
import re

def executar(values=None):
    values = {'password': 'Senha de exemplo', 'memory': '65536', 'iterations': '3', 'parallelism': '1'} if values is None else values
    if not isinstance(values, dict) or any(not isinstance(v,str) or len(v.encode('utf-16-le',errors='surrogatepass')) // 2 > 1000000 for v in values.values()): raise ValueError('Informe campos textuais de até 1 milhão de caracteres')
    def integer(key):
        raw = values.get(key,'')
        if not re.fullmatch(r'[0-9]+',raw): raise ValueError('Informe inteiro válido: ' + key)
        return int(raw)
    def process(password='Uma senha de exemplo', memory=65536, iterations=3, parallelism=1):
        if any((type(x) is not int for x in (memory, iterations, parallelism))) or not 8192 <= memory <= 131072 or (not 1 <= iterations <= 10) or (not 1 <= parallelism <= 4):
            raise ValueError('Parâmetros Argon2 fora dos limites')
        hasher = PasswordHasher(time_cost=iterations, memory_cost=memory, parallelism=parallelism, hash_len=32, salt_len=16, type=Type.ID)
        return hasher.hash(password)
    result = process(password=values.get('password', ''), memory=integer('memory'), iterations=integer('iterations'), parallelism=integer('parallelism'))
    return {'text':result}

<?php

function executar($values = ['password'=>'Senha de exemplo','memory'=>'65536','iterations'=>'3','parallelism'=>'1']) {
  foreach ($values as $value) if (!is_string($value) || strlen($value)>1000000) throw new InvalidArgumentException("Informe campos textuais de até 1 milhão de bytes");
  $integer = function ($key) use ($values) { $raw = $values[$key] ?? ""; if (!preg_match("/^[0-9]+$/D",$raw)) throw new InvalidArgumentException("Inteiro inválido: " . $key); return (int)$raw; };
  $process = function ($password = 'Uma senha de exemplo', $memory = 65536, $iterations = 3, $parallelism = 1) {
    if (!is_int($memory) || !is_int($iterations) || !is_int($parallelism) || $memory < 8192 || $memory > 131072 || $iterations < 1 || $iterations > 10 || $parallelism < 1 || $parallelism > 4) throw new InvalidArgumentException('Parâmetros Argon2 fora dos limites');
    if (!defined('PASSWORD_ARGON2ID')) throw new RuntimeException('Argon2id indisponível');
    return password_hash($password, PASSWORD_ARGON2ID, ['memory_cost'=>$memory, 'time_cost'=>$iterations, 'threads'=>$parallelism]);
  };
  $result = $process($values['password'] ?? '', $integer('memory'), $integer('iterations'), $integer('parallelism'));
  return ['text'=>$result];
}