Quantum Ark 🔐

Quantum Ark es una librería WebAssembly para hashing de contraseñas de nivel empresarial, diseñada con criptografía post-cuántica avanzada. Protege aplicaciones críticas contra ataques clásicos y cuánticos mediante técnicas inspiradas en estándares NIST PQC.

🛡️ Características de Seguridad

Seguridad Post-Cuántica

Resistencia Cuántica: Implementa primitivas basadas en lattice-based cryptography (inspirado en ML-KEM/Kyber y Dilithium)
Neural Network Caótica: Sistema de difusión no-lineal que previene análisis diferencial
PBKDF2 Extendido: 60,000-120,000 iteraciones con SHA3-512
Protección Timing-Attack: Comparaciones de tiempo constante para prevenir side-channel attacks

Arquitectura Segura

Zero-Knowledge: Ni el desarrollador ni terceros conocen las contraseñas generadas. Solo el algoritmo y el usuario tienen acceso
Determinismo Criptográfico: Mismo input → mismo hash, garantizando reproducibilidad sin comprometer seguridad
Formato Versionado: Sistema de prefijos (v2$, v2h$, v2x$) para compatibilidad futura

📦 Instalación

npm install quantum_ark

🚀 Uso Básico

JavaScript/TypeScript

import init, { 
  quantum_ark_hash,
  quantum_ark_hash_with_hmac,
  quantum_ark_verify 
} from 'quantum_ark';

async function hashPassword() {
  // Inicializar WebAssembly
  await init();
  
  const password = "mi_password_seguro";
  const appKey = "mi_clave_aplicacion_secreta";
  
  // Método 1: Hash estándar (recomendado para uso general)
  const hash = quantum_ark_hash(password, appKey);
  console.log('Hash V2:', hash);
  // Output: v2$<salt_64_chars><hash_128_chars>
  
  // Método 2: Hash con HMAC (máxima seguridad)
  const hashHMAC = quantum_ark_hash_with_hmac(password, appKey);
  console.log('Hash HMAC:', hashHMAC);
  // Output: v2h$<salt_64_chars><hash_128_chars><hmac_64_chars>
}

async function verifyPassword() {
  await init();
  
  const inputPassword = "password_usuario";
  const storedHash = "v2$a1b2c3..."; // desde base de datos
  const appKey = "mi_clave_aplicacion_secreta";
  
  const isValid = quantum_ark_verify(inputPassword, appKey, storedHash);
  
  if (isValid) {
    console.log("✅ Autenticación exitosa");
  } else {
    console.log("❌ Credenciales inválidas");
  }
}

hashPassword();

React Example

import { useEffect, useState } from 'react';
import init, { quantum_ark_hash_with_hmac, quantum_ark_verify } from 'quantum_ark';

function AuthComponent() {
  const [initialized, setInitialized] = useState(false);
  const APP_KEY = process.env.REACT_APP_QUANTUM_KEY; // desde .env

  useEffect(() => {
    init().then(() => setInitialized(true));
  }, []);

  const handleRegister = async (password) => {
    if (!initialized) return;
    
    const hash = quantum_ark_hash_with_hmac(password, APP_KEY);
    
    // Guardar en backend
    await fetch('/api/register', {
      method: 'POST',
      body: JSON.stringify({ hash })
    });
  };

  const handleLogin = async (password, storedHash) => {
    if (!initialized) return;
    
    const isValid = quantum_ark_verify(password, APP_KEY, storedHash);
    return isValid;
  };

  return (
    <div>
      {initialized ? <LoginForm onLogin={handleLogin} /> : <p>Loading...</p>}
    </div>
  );
}

HTML Vanilla

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <title>Quantum Ark Demo</title>
</head>
<body>
  <h1>Sistema de Autenticación Seguro</h1>
  
  <div>
    <input type="password" id="password" placeholder="Contraseña">
    <input type="text" id="key" placeholder="Clave de Aplicación">
    <button id="hashBtn">Generar Hash</button>
    <button id="verifyBtn">Verificar</button>
  </div>
  
  <pre id="output"></pre>

  <script type="module">
    import init, { 
      quantum_ark_hash_with_hmac,
      quantum_ark_verify 
    } from './node_modules/quantum_ark/quantum_ark.js';

    let storedHash = '';

    async function run() {
      await init();
      
      document.getElementById('hashBtn').addEventListener('click', () => {
        const password = document.getElementById('password').value;
        const key = document.getElementById('key').value;
        
        storedHash = quantum_ark_hash_with_hmac(password, key);
        document.getElementById('output').textContent = 
          `Hash generado:\n${storedHash}\n\nGuarda este hash en tu base de datos.`;
      });

      document.getElementById('verifyBtn').addEventListener('click', () => {
        const password = document.getElementById('password').value;
        const key = document.getElementById('key').value;
        
        if (!storedHash) {
          alert('Primero genera un hash');
          return;
        }
        
        const isValid = quantum_ark_verify(password, key, storedHash);
        document.getElementById('output').textContent = 
          isValid ? '✅ Password correcto' : '❌ Password incorrecto';
      });
    }
    
    run();
  </script>
</body>
</html>

🔧 API Reference

`quantum_ark_hash(password: string, key: string): string`

Genera un hash seguro estándar.

Parámetros:

password: Contraseña del usuario
key: Clave secreta de la aplicación (única por app)

Retorna: String formato v2$<salt><hash> (192 caracteres)

Uso recomendado: Aplicaciones de uso general con alta demanda de rendimiento.

`quantum_ark_hash_with_hmac(password: string, key: string): string`

Genera hash con verificación HMAC adicional.

Parámetros:

password: Contraseña del usuario
key: Clave secreta de la aplicación

Retorna: String formato v2h$<salt><hash><hmac> (256 caracteres)

Uso recomendado: Aplicaciones críticas (fintech, healthcare, government).

`quantum_ark_verify(password: string, key: string, storedHash: string): boolean`

Verifica una contraseña contra un hash almacenado con protección contra timing attacks.

Parámetros:

password: Contraseña a verificar
key: Clave secreta de la aplicación (debe ser la misma usada al hashear)
storedHash: Hash almacenado en la base de datos

Retorna: true si válido, false si inválido

Seguridad: Usa comparación de tiempo constante para prevenir side-channel attacks.

`quantum_ark_hash_extreme(password: string, key: string): string`

Hash con triple capa de seguridad (uso extremo).

Parámetros:

password: Contraseña del usuario
key: Clave secreta de la aplicación

Retorna: String formato v2x$<hash> (132 caracteres)

Uso recomendado: Solo para aplicaciones de máxima seguridad donde el rendimiento no es crítico.

`quantum_ark_generate_salt(): string`

Genera un salt aleatorio criptográficamente seguro.

Retorna: String hexadecimal de 64 caracteres

Uso: Opcional, el sistema ya genera salts internamente.

📊 Comparación de Métodos

Método	Formato	Longitud	Seguridad	Velocidad	Uso Recomendado
`quantum_ark_hash`	`v2$`	192 chars	Alta	Rápida	Producción general
`quantum_ark_hash_with_hmac`	`v2h$`	256 chars	Muy Alta	Media	Aplicaciones críticas
`quantum_ark_hash_extreme`	`v2x$`	132 chars	Extrema	Lenta	Máxima seguridad

🔒 Principios de Seguridad

Zero-Knowledge Architecture

Quantum Ark implementa un sistema de conocimiento cero:

❌ El desarrollador NO conoce las contraseñas generadas
❌ Terceros NO pueden reconstruir contraseñas desde el hash
✅ Solo el algoritmo y el usuario legítimo tienen acceso
✅ Determinista: Mismo input → mismo output (verificable)

Este diseño garantiza que incluso si el código fuente se compromete, las contraseñas permanecen seguras.

Protección Multi-Capa

PBKDF2: 60,000-120,000 iteraciones con SHA3-512
Lattice-Based Mixing: Resistencia contra algoritmos cuánticos
Neural Network Caótica: Difusión no-lineal
NTT de Dilithium: Transformaciones algebraicas avanzadas
HMAC-SHA3: Verificación de integridad (modo v2h$)

Resistencia a Ataques

Tipo de Ataque	Protección
Fuerza Bruta	PBKDF2 + complejidad algorítmica
Rainbow Tables	Salt único por hash
Timing Attacks	Comparación de tiempo constante
Preimagen	SHA3-512 + transformaciones no-lineales
Colisiones	Espacio de salida de 2^512
Ataques Cuánticos	Lattice-based primitives

⚙️ Configuración Avanzada

Variables de Entorno (Recomendadas)

# .env
QUANTUM_ARK_APP_KEY=tu_clave_secreta_unica_de_64_caracteres_minimo

// En tu aplicación
const APP_KEY = process.env.QUANTUM_ARK_APP_KEY;

Best Practices

✅ DO:

Usa quantum_ark_hash_with_hmac() para aplicaciones críticas
Mantén la key secreta y única por aplicación
Almacena hashes en columnas VARCHAR(256) o superior
Usa HTTPS para transmitir contraseñas
Implementa rate limiting en endpoints de login

❌ DON'T:

No reutilices key entre diferentes aplicaciones
No almacenes contraseñas en texto plano (obvio)
No intentes modificar el WebAssembly compilado
No uses key predecibles (ej: "ARK", "password", "123")
No omitas la verificación de integridad del paquete

🧪 Testing

Ejemplo de Test Unitario (Jest)

import init, { quantum_ark_hash, quantum_ark_verify } from 'quantum_ark';
import wasmUrl from "quantum_ark/quantum_ark_bg.wasm?url";

describe('Quantum Ark Tests', () => {
  beforeAll(async () => {
    await init();
  });

  test('Hash es determinista', () => {
    const password = "test123";
    const key = "key123";
    
    const hash1 = quantum_ark_hash(password, key);
    const hash2 = quantum_ark_hash(password, key);
    
    expect(hash1).toBe(hash2);
  });

  test('Verificación correcta', () => {
    const password = "myPassword";
    const key = "myKey";
    const hash = quantum_ark_hash(password, key);
    
    expect(quantum_ark_verify(password, key, hash)).toBe(true);
    expect(quantum_ark_verify("wrongPass", key, hash)).toBe(false);
  });

  test('Formato de hash válido', () => {
    const hash = quantum_ark_hash("test", "key");
    
    expect(hash).toMatch(/^v2\$/);
    expect(hash.length).toBe(192);
  });
});

🌐 Compatibilidad

Navegadores Soportados

Navegador	Versión Mínima
Chrome	57+
Firefox	52+
Safari	11+
Edge	16+
Opera	44+

Entornos Node.js

Node.js 16+ (LTS recomendado)
Deno 1.0+ (con flags de compatibilidad)

📈 Rendimiento

En hardware moderno (Intel i7 / Apple M1):

quantum_ark_hash: ~50-100ms por operación
quantum_ark_hash_with_hmac: ~80-150ms por operación
quantum_ark_verify: ~50-100ms por operación

Nota: El overhead es intencional para prevenir ataques de fuerza bruta.

🐛 Troubleshooting

Error: "WebAssembly module not initialized"

// Solución: Asegúrate de llamar await init() antes de usar funciones
await init();

Error: "Hash format invalid"

// Verifica que el hash almacenado no esté corrupto o truncado
// Los hashes deben mantener su longitud completa (192-256 chars)

Rendimiento lento

// Para alta concurrencia, considera un worker pool:
import { Worker } from 'worker_threads';
// Implementa hashing en workers separados

📄 Licencia

GPL-3.0 - Este proyecto es software libre. Puedes redistribuirlo y/o modificarlo bajo los términos de la Licencia Pública General de GNU versión 3.

🔍 Verificación de Integridad (SHA-256)

Para garantizar la confianza y transparencia, puedes verificar manualmente
que el archivo binario .wasm instalado no haya sido modificado.

📄 Archivo a verificar

node_modules/quantum_ark/quantum_ark_bg.wasm

🔑 Hash oficial SHA-256

7963F599A12946338E4272907543E918026D057D1EA7E37090B3BD5DA2919E09

🧩 Cómo verificarlo

🔹 En Windows (PowerShell)

Get-FileHash .\node_modules\quantum_ark\quantum_ark_bg.wasm -Algorithm SHA256

🔹 En CMD clásico

certutil -hashfile node_modules\quantum_ark\quantum_ark_bg.wasm SHA256

🔹 En macOS / Linux

shasum -a 256 node_modules/quantum_ark/quantum_ark_bg.wasm

✅ Resultado esperado

El valor generado debe coincidir exactamente con:

7963F599A12946338E4272907543E918026D057D1EA7E37090B3BD5DA2919E09

Si el resultado no coincide, no utilices el paquete y reporta el incidente
a través del repositorio oficial o por correo seguro.

🔐 Auditoría y Transparencia

Reporte de Vulnerabilidades

Si descubres una vulnerabilidad de seguridad, NO la publiques públicamente. Contacta directamente:

📧 Email: [email protected]
🔒 PGP Key: [Fingerprint: 7FEA B5FE 7E86 EC6B 56BE E0A0 3D26 BED8 64C4 28D8]

🔐 Ver PGP Public Key (Click para expandir)

📞 Soporte

GitHub Issues: Reportar problemas
Documentación: Wiki completo

🙏 Contribuciones

Quantum Ark es un proyecto de código cerrado para proteger la seguridad de su implementación. Sin embargo, aceptamos:

📝 Mejoras en documentación
🐛 Reportes de bugs (vía issues)
💡 Sugerencias de features
🧪 Casos de prueba adicionales

⚠️ Advertencia Legal

USO RESPONSABLE: Este software está diseñado para proteger datos sensibles. El uso indebido (ingeniería inversa, modificación del WebAssembly, o intentos de comprometer la seguridad) puede violar leyes locales e internacionales.

GARANTÍA: Este software se proporciona "TAL CUAL", sin garantías de ningún tipo. El uso en producción es responsabilidad del implementador.

🌟 Desarrollado por

Joel Andres - GitHub | NPM

Quantum Ark - Security Beyond Tomorrow 🛡️

Protegiendo el presente, preparados para el futuro

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
node_modules		node_modules
README.md		README.md
index.html		index.html
package-lock.json		package-lock.json
package.json		package.json

Uh oh!

Uh oh!

Jhoel777ar/Quantum_Ark_Encrypt

Folders and files

Latest commit

History

Repository files navigation

Quantum Ark 🔐

🛡️ Características de Seguridad

Seguridad Post-Cuántica

Arquitectura Segura

📦 Instalación

🚀 Uso Básico

JavaScript/TypeScript

React Example

HTML Vanilla

🔧 API Reference

quantum_ark_hash(password: string, key: string): string

quantum_ark_hash_with_hmac(password: string, key: string): string

quantum_ark_verify(password: string, key: string, storedHash: string): boolean

quantum_ark_hash_extreme(password: string, key: string): string

quantum_ark_generate_salt(): string

📊 Comparación de Métodos

🔒 Principios de Seguridad

Zero-Knowledge Architecture

Protección Multi-Capa

Resistencia a Ataques

⚙️ Configuración Avanzada

Variables de Entorno (Recomendadas)

Best Practices

🧪 Testing

Ejemplo de Test Unitario (Jest)

🌐 Compatibilidad

Navegadores Soportados

Entornos Node.js

📈 Rendimiento

🐛 Troubleshooting

Error: "WebAssembly module not initialized"

Error: "Hash format invalid"

Rendimiento lento

📄 Licencia

🔍 Verificación de Integridad (SHA-256)

📄 Archivo a verificar

🔑 Hash oficial SHA-256

🧩 Cómo verificarlo

🔹 En Windows (PowerShell)

🔹 En CMD clásico

🔹 En macOS / Linux

✅ Resultado esperado

🔐 Auditoría y Transparencia

Reporte de Vulnerabilidades

📞 Soporte

🙏 Contribuciones

⚠️ Advertencia Legal

🌟 Desarrollado por

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

`quantum_ark_hash(password: string, key: string): string`

`quantum_ark_hash_with_hmac(password: string, key: string): string`

`quantum_ark_verify(password: string, key: string, storedHash: string): boolean`

`quantum_ark_hash_extreme(password: string, key: string): string`

`quantum_ark_generate_salt(): string`

Packages