Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegación

Seguridad

Ejemplos de Criptografía

Ejemplos completos de criptografía incluyendo cifrado simétrico, asimétrico, funciones hash, firmas digitales y protocolos de intercambio de claves

Ejemplos

Entradas de esta colección

CódigopythonIntermedio

Cifrado Simétrico AES

Implementación del Estándar de Cifrado Avanzado (AES) para cifrado y descifrado seguro de datos

Dificultad

6/10

Tiempo estimado

25 min

Etiquetas

aes, encryption, cryptography, security

Requisitos previos

Python basics, Cryptography fundamentals

python
# Symmetric Encryption with AES
# Required: pip install cryptography pycryptodome

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding, hashes
from cryptography.hazmat.backends import default_backend
import os
import base64

class AESCipher:
    """AES Encryption/Decryption utility class"""

    def __init__(self, key: bytes = None):
        """Initialize with a key or generate a new one"""
        self.key = key or os.urandom(32)  # 256-bit key for AES-256
        self.iv = None

    def generate_key(self) -> bytes:
        """Generate a new random AES key"""
        return os.urandom(32)

    def encrypt_cbc(self, plaintext: str) -> dict:
        """Encrypt using AES-CBC mode"""
        # Generate random IV
        iv = os.urandom(16)

        # Pad the plaintext
        padder = padding.PKCS7(128).padder()
        padded_data = padder.update(plaintext.encode()) + padder.finalize()

        # Encrypt
        cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv), backend=default_backend())
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(padded_data) + encryptor.finalize()

        return {
            'ciphertext': base64.b64encode(ciphertext).decode(),
            'iv': base64.b64encode(iv).decode(),
            'mode': 'CBC'
        }

    def decrypt_cbc(self, ciphertext: str, iv: str) -> str:
        """Decrypt AES-CBC encrypted data"""
        ciphertext_bytes = base64.b64decode(ciphertext)
        iv_bytes = base64.b64decode(iv)

        # Decrypt
        cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv_bytes), backend=default_backend())
        decryptor = cipher.decryptor()
        padded_plaintext = decryptor.update(ciphertext_bytes) + decryptor.finalize()

        # Unpad
        unpadder = padding.PKCS7(128).unpadder()
        plaintext = unpadder.update(padded_plaintext) + unpadder.finalize()

        return plaintext.decode()

    def encrypt_gcm(self, plaintext: str, associated_data: str = None) -> dict:
        """Encrypt using AES-GCM mode (authenticated encryption)"""
        # Generate random IV and nonce
        iv = os.urandom(12)

        # Encrypt with GCM
        encryptor = Cipher(
            algorithms.AES(self.key),
            modes.GCM(iv),
            backend=default_backend()
        ).encryptor()

        # Add associated data if provided
        if associated_data:
            encryptor.authenticate_additional_data(associated_data.encode())

        ciphertext = encryptor.update(plaintext.encode()) + encryptor.finalize()

        return {
            'ciphertext': base64.b64encode(ciphertext).decode(),
            'iv': base64.b64encode(iv).decode(),
            'tag': base64.b64encode(encryptor.tag).decode(),
            'mode': 'GCM',
            'associated_data': associated_data
        }

    def decrypt_gcm(self, ciphertext: str, iv: str, tag: str, associated_data: str = None) -> str:
        """Decrypt AES-GCM encrypted data"""
        ciphertext_bytes = base64.b64decode(ciphertext)
        iv_bytes = base64.b64decode(iv)
        tag_bytes = base64.b64decode(tag)

        # Decrypt with GCM
        decryptor = Cipher(
            algorithms.AES(self.key),
            modes.GCM(iv_bytes, tag_bytes),
            backend=default_backend()
        ).decryptor()

        # Add associated data if provided
        if associated_data:
            decryptor.authenticate_additional_data(associated_data.encode())

        plaintext = decryptor.update(ciphertext_bytes) + decryptor.finalize()

        return plaintext.decode()

# Example Usage
def demo_aes_encryption():
    print("=== AES Encryption Demo ===")

    # Initialize cipher
    cipher = AESCipher()

    # Test data
    plaintext = "This is a secret message that needs to be encrypted securely!"

    print(f"Original: {plaintext}")
    print(f"Key (hex): {cipher.key.hex()}")

    # CBC Mode Encryption
    print("\n--- CBC Mode ---")
    cbc_result = cipher.encrypt_cbc(plaintext)
    print(f"Ciphertext (CBC): {cbc_result['ciphertext']}")
    print(f"IV (CBC): {cbc_result['iv']}")

    # CBC Mode Decryption
    decrypted_cbc = cipher.decrypt_cbc(cbc_result['ciphertext'], cbc_result['iv'])
    print(f"Decrypted (CBC): {decrypted_cbc}")

    # GCM Mode Encryption (with authentication)
    print("\n--- GCM Mode (Authenticated) ---")
    associated_data = "user-auth-token-123"
    gcm_result = cipher.encrypt_gcm(plaintext, associated_data)
    print(f"Ciphertext (GCM): {gcm_result['ciphertext']}")
    print(f"IV (GCM): {gcm_result['iv']}")
    print(f"Tag (GCM): {gcm_result['tag']}")
    print(f"Associated Data: {gcm_result['associated_data']}")

    # GCM Mode Decryption
    decrypted_gcm = cipher.decrypt_gcm(
        gcm_result['ciphertext'],
        gcm_result['iv'],
        gcm_result['tag'],
        gcm_result['associated_data']
    )
    print(f"Decrypted (GCM): {decrypted_gcm}")

if __name__ == "__main__":
    demo_aes_encryption()
CódigojavascriptIntermedio

Cifrado de Flujo ChaCha20

Implementación de cifrado autenticado ChaCha20-Poly1305 para comunicaciones seguras de alto rendimiento

Dificultad

7/10

Tiempo estimado

20 min

Etiquetas

chacha20, cryptography, encryption, nodejs

Requisitos previos

JavaScript/Node.js, Cryptography basics

javascript
// ChaCha20-Poly1305 Encryption with Node.js
// Required: npm install tweetnacl

const nacl = require('tweetnacl');
const util = require('tweetnacl-util');

class ChaCha20Cipher {
    constructor() {
        this.keyPair = null;
    }

    // Generate a new 256-bit key
    generateKey() {
        return nacl.randomBytes(32);
    }

    // Generate a 96-bit nonce for ChaCha20
    generateNonce() {
        return nacl.randomBytes(12);
    }

    // Encrypt message with ChaCha20-Poly1305
    encrypt(message, additionalData = null) {
        const key = this.generateKey();
        const nonce = this.generateNonce();

        // Convert message to Uint8Array
        const messageBytes = util.decodeUTF8(message);

        // Add additional authenticated data if provided
        const aadBytes = additionalData ? util.decodeUTF8(additionalData) : null;

        // Encrypt using ChaCha20-Poly1305
        const encrypted = nacl.secretbox(messageBytes, nonce, key);

        if (!encrypted) {
            throw new Error('Encryption failed');
        }

        return {
            ciphertext: util.encodeBase64(encrypted),
            nonce: util.encodeBase64(nonce),
            key: util.encodeBase64(key),
            additionalData: additionalData || null
        };
    }

    // Decrypt ChaCha20-Poly1305 encrypted message
    decrypt(ciphertext, nonce, key, additionalData = null) {
        try {
            const cipherBytes = util.decodeBase64(ciphertext);
            const nonceBytes = util.decodeBase64(nonce);
            const keyBytes = util.decodeBase64(key);

            // Decrypt
            const decrypted = nacl.secretbox.open(cipherBytes, nonceBytes, keyBytes);

            if (!decrypted) {
                throw new Error('Decryption failed - authentication failed');
            }

            return util.encodeUTF8(decrypted);
        } catch (error) {
            throw new Error(`Decryption failed: ${error.message}`);
        }
    }

    // Encrypt with custom key (useful for key exchange scenarios)
    encryptWithKey(message, key, nonce = null) {
        const nonceBytes = nonce ? util.decodeBase64(nonce) : this.generateNonce();
        const messageBytes = util.decodeUTF8(message);
        const keyBytes = typeof key === 'string' ? util.decodeBase64(key) : key;

        const encrypted = nacl.secretbox(messageBytes, nonceBytes, keyBytes);

        if (!encrypted) {
            throw new Error('Encryption failed');
        }

        return {
            ciphertext: util.encodeBase64(encrypted),
            nonce: util.encodeBase64(nonceBytes)
        };
    }

    // Generate key pair for asymmetric encryption using X25519
    generateKeyPair() {
        this.keyPair = nacl.box.keyPair();
        return {
            publicKey: util.encodeBase64(this.keyPair.publicKey),
            secretKey: util.encodeBase64(this.keyPair.secretKey)
        };
    }

    // Derive shared secret using ECDH
    deriveSharedSecret(theirPublicKey, mySecretKey) {
        const theirPubKeyBytes = util.decodeBase64(theirPublicKey);
        const mySecretKeyBytes = util.decodeBase64(mySecretKey);

        const sharedSecret = nacl.box.before(theirPubKeyBytes, mySecretKeyBytes);
        return util.encodeBase64(sharedSecret);
    }
}

// Performance benchmarking
function benchmarkChaCha20() {
    console.log("=== ChaCha20 Performance Benchmark ===");

    const cipher = new ChaCha20Cipher();
    const testSizes = [1024, 10240, 102400, 1024000]; // 1KB, 10KB, 100KB, 1MB

    testSizes.forEach(size => {
        const message = 'A'.repeat(size);

        console.log(`\nTesting message size: ${size} bytes`);

        const startTime = process.hrtime.bigint();

        const encrypted = cipher.encrypt(message);
        const decrypted = cipher.decrypt(
            encrypted.ciphertext,
            encrypted.nonce,
            encrypted.key
        );

        const endTime = process.hrtime.bigint();
        const duration = Number(endTime - startTime) / 1000000; // Convert to milliseconds

        console.log(`Encryption + Decryption time: ${duration.toFixed(2)} ms`);
        console.log(`Throughput: ${(size * 2 / duration * 1000).toFixed(2)} bytes/sec`);
        console.log(`Original matches decrypted: ${message === decrypted}`);
    });
}

// Demo function
function demoChaCha20() {
    console.log("=== ChaCha20-Poly1305 Demo ===");

    const cipher = new ChaCha20Cipher();

    // Basic encryption/decryption
    const message = "This is a secret message encrypted with ChaCha20-Poly1305!";
    const additionalData = "user-session-123";

    console.log(`Original message: ${message}`);
    console.log(`Additional data: ${additionalData}`);

    // Encrypt
    const encrypted = cipher.encrypt(message, additionalData);
    console.log("\nEncrypted:");
    console.log(`Ciphertext: ${encrypted.ciphertext}`);
    console.log(`Nonce: ${encrypted.nonce}`);
    console.log(`Key: ${encrypted.key}`);

    // Decrypt
    const decrypted = cipher.decrypt(
        encrypted.ciphertext,
        encrypted.nonce,
        encrypted.key,
        encrypted.additionalData
    );
    console.log(`\nDecrypted message: ${decrypted}`);
    console.log(`Match with original: ${message === decrypted}`);

    // Key exchange demo
    console.log("\n--- Key Exchange Demo ---");
    const alice = new ChaCha20Cipher();
    const bob = new ChaCha20Cipher();

    const aliceKeys = alice.generateKeyPair();
    const bobKeys = bob.generateKeyPair();

    console.log("Alice's public key:", aliceKeys.publicKey);
    console.log("Bob's public key:", bobKeys.publicKey);

    // Derive shared secrets
    const aliceSharedSecret = alice.deriveSharedSecret(bobKeys.publicKey, aliceKeys.secretKey);
    const bobSharedSecret = bob.deriveSharedSecret(aliceKeys.publicKey, bobKeys.secretKey);

    console.log(`Shared secrets match: ${aliceSharedSecret === bobSharedSecret}`);

    // Use shared secret for encryption
    const secretMessage = "Alice and Bob's secret conversation";
    const aliceEncrypted = alice.encryptWithKey(secretMessage, aliceSharedSecret);
    const bobDecrypted = bob.decryptWithKey(
        aliceEncrypted.ciphertext,
        aliceEncrypted.nonce,
        bobSharedSecret
    );

    console.log(`Secret message decrypted by Bob: ${bobDecrypted}`);
}

// Add decryption method to ChaCha20Cipher class
ChaCha20Cipher.prototype.decryptWithKey = function(ciphertext, nonce, key) {
    return this.decrypt(ciphertext, nonce, key);
};

if (require.main === module) {
    demoChaCha20();
    benchmarkChaCha20();
}

module.exports = ChaCha20Cipher;
CódigojavaIntermedio

Cifrado Asimétrico RSA

Implementación de criptografía de clave pública RSA para intercambio seguro de claves y firmas digitales

Dificultad

7/10

Tiempo estimado

30 min

Etiquetas

rsa, digital-signature, java, cryptography

Requisitos previos

Java, Cryptography fundamentals

java
// RSA Asymmetric Encryption Implementation
// Required dependencies (Maven):
// <dependency>
//     <groupId>org.bouncycastle</groupId>
//     <artifactId>bcprov-jdk15on</artifactId>
//     <version>1.70</version>
// </dependency>

import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.util.Base64;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

public class RSACipher {

    private KeyPair keyPair;
    private static final String ALGORITHM = "RSA";
    private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";

    public RSACipher(int keySize) throws NoSuchAlgorithmException {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
        keyGen.initialize(keySize);
        this.keyPair = keyGen.generateKeyPair();
    }

    public RSACipher(KeyPair keyPair) {
        this.keyPair = keyPair;
    }

    // Generate RSA key pair
    public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
        keyGen.initialize(keySize);
        return keyGen.generateKeyPair();
    }

    // Get public key as Base64 string
    public String getPublicKeyBase64() {
        return Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
    }

    // Get private key as Base64 string
    public String getPrivateKeyBase64() {
        return Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
    }

    // Encrypt data with public key
    public String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encrypted = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }

    // Decrypt data with private key
    public String decrypt(String encryptedData) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
        byte[] decoded = Base64.getDecoder().decode(encryptedData);
        byte[] decrypted = cipher.doFinal(decoded);
        return new String(decrypted);
    }

    // Create digital signature
    public String sign(String data) throws Exception {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(keyPair.getPrivate());
        signature.update(data.getBytes());
        byte[] signatureBytes = signature.sign();
        return Base64.getEncoder().encodeToString(signatureBytes);
    }

    // Verify digital signature
    public boolean verify(String data, String signatureStr, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data.getBytes());
        byte[] signatureBytes = Base64.getDecoder().decode(signatureStr);
        return signature.verify(signatureBytes);
    }

    // Hybrid encryption: encrypt symmetric key with RSA
    public String encryptLargeData(String data, PublicKey publicKey) throws Exception {
        // Generate random AES key for symmetric encryption
        KeyGenerator aesKeyGen = KeyGenerator.getInstance("AES");
        aesKeyGen.init(256);
        SecretKey aesKey = aesKeyGen.generateKey();

        // Encrypt data with AES
        Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding");
        aesCipher.init(Cipher.ENCRYPT_MODE, aesKey);
        byte[] iv = new byte[12]; // GCM IV
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);
        GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv);
        aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, gcmSpec);

        byte[] encryptedData = aesCipher.doFinal(data.getBytes());

        // Encrypt AES key with RSA
        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        rsaCipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedAesKey = rsaCipher.doFinal(aesKey.getEncoded());

        // Combine IV, encrypted AES key, and encrypted data
        byte[] combined = new byte[iv.length + encryptedAesKey.length + encryptedData.length];
        System.arraycopy(iv, 0, combined, 0, iv.length);
        System.arraycopy(encryptedAesKey, 0, combined, iv.length, encryptedAesKey.length);
        System.arraycopy(encryptedData, 0, combined, iv.length + encryptedAesKey.length, encryptedData.length);

        return Base64.getEncoder().encodeToString(combined);
    }

    // Hybrid decryption
    public String decryptLargeData(String combinedData) throws Exception {
        byte[] combined = Base64.getDecoder().decode(combinedData);

        // Extract IV, encrypted AES key, and encrypted data
        byte[] iv = new byte[12];
        int rsaKeySize = ((RSAPrivateKey) keyPair.getPrivate()).getModulus().bitLength() / 8;
        byte[] encryptedAesKey = new byte[rsaKeySize];
        byte[] encryptedData = new byte[combined.length - iv.length - encryptedAesKey.length];

        System.arraycopy(combined, 0, iv, 0, iv.length);
        System.arraycopy(combined, iv.length, encryptedAesKey, 0, encryptedAesKey.length);
        System.arraycopy(combined, iv.length + encryptedAesKey.length, encryptedData, 0, encryptedData.length);

        // Decrypt AES key with RSA
        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        rsaCipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
        byte[] aesKeyBytes = rsaCipher.doFinal(encryptedAesKey);
        SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES");

        // Decrypt data with AES
        GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv);
        Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding");
        aesCipher.init(Cipher.DECRYPT_MODE, aesKey, gcmSpec);
        byte[] decryptedData = aesCipher.doFinal(encryptedData);

        return new String(decryptedData);
    }

    public static void main(String[] args) {
        try {
            System.out.println("=== RSA Asymmetric Encryption Demo ===");

            // Generate RSA key pair
            RSACipher rsaCipher = new RSACipher(2048);

            String message = "This is a secret message that will be encrypted with RSA!";
            System.out.println("Original message: " + message);

            // Get keys as strings
            String publicKeyStr = rsaCipher.getPublicKeyBase64();
            String privateKeyStr = rsaCipher.getPrivateKeyBase64();

            System.out.println("\nPublic Key (Base64): " + publicKeyStr.substring(0, 50) + "...");
            System.out.println("Private Key (Base64): " + privateKeyStr.substring(0, 50) + "...");

            // Encrypt with public key
            String encrypted = rsaCipher.encrypt(message, rsaCipher.keyPair.getPublic());
            System.out.println("\nEncrypted message: " + encrypted);

            // Decrypt with private key
            String decrypted = rsaCipher.decrypt(encrypted);
            System.out.println("Decrypted message: " + decrypted);
            System.out.println("Original matches decrypted: " + message.equals(decrypted));

            // Digital signature demo
            System.out.println("\n--- Digital Signature Demo ---");
            String document = "Important document to be signed";
            String signature = rsaCipher.sign(document);
            System.out.println("Document: " + document);
            System.out.println("Signature: " + signature.substring(0, 50) + "...");

            boolean isValid = rsaCipher.verify(document, signature, rsaCipher.keyPair.getPublic());
            System.out.println("Signature is valid: " + isValid);

            // Try with modified document
            boolean isInvalid = rsaCipher.verify(document + " modified", signature, rsaCipher.keyPair.getPublic());
            System.out.println("Modified document signature is valid: " + isInvalid);

            // Hybrid encryption demo for large data
            System.out.println("\n--- Hybrid Encryption Demo (Large Data) ---");
            String largeMessage = "This is a very long message that exceeds RSA's data size limitations. ".repeat(10);
            System.out.println("Original message length: " + largeMessage.length() + " characters");

            String hybridEncrypted = rsaCipher.encryptLargeData(largeMessage, rsaCipher.keyPair.getPublic());
            System.out.println("Hybrid encrypted length: " + hybridEncrypted.length());

            String hybridDecrypted = rsaCipher.decryptLargeData(hybridEncrypted);
            System.out.println("Hybrid decrypted length: " + hybridDecrypted.length() + " characters");
            System.out.println("Large message matches hybrid decrypted: " + largeMessage.equals(hybridDecrypted));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
CódigogoComplejo

Criptografía de Curva Elíptica

Implementación ECC usando ECDSA para firmas digitales y ECDH para intercambio de claves

Dificultad

8/10

Tiempo estimado

35 min

Etiquetas

ecc, elliptic-curve, ecdsa, go, cryptography

Requisitos previos

Go programming, Advanced cryptography

go
// Elliptic Curve Cryptography Implementation in Go
// Run with: go run ecc.go

package main

import (
	"crypto/ecdsa"
	"crypto/ed25519"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/sha256"
	"crypto/x509"
	"encoding/base64"
	"encoding/hex"
	"encoding/pem"
	"fmt"
	"log"
	"math/big"
	"time"
)

// ECDSAKeyPair represents an ECDSA key pair
type ECDSAKeyPair struct {
	PrivateKey *ecdsa.PrivateKey
	PublicKey  *ecdsa.PublicKey
}

// Ed25519KeyPair represents an Ed25519 key pair
type Ed25519KeyPair struct {
	PrivateKey ed25519.PrivateKey
	PublicKey  ed25519.PublicKey
}

// ECDHSecret represents a shared secret from ECDH
type ECDHSecret struct {
	Secret []byte
	X      *big.Int
	Y      *big.Int
}

// Generate ECDSA key pair for specified curve
func GenerateECDSAKeyPair(curve elliptic.Curve) (*ECDSAKeyPair, error) {
	privateKey, err := ecdsa.GenerateKey(curve, rand.Reader)
	if err != nil {
		return nil, fmt.Errorf("failed to generate ECDSA key pair: %v", err)
	}

	return &ECDSAKeyPair{
		PrivateKey: privateKey,
		PublicKey:  &privateKey.PublicKey,
	}, nil
}

// Generate Ed25519 key pair
func GenerateEd25519KeyPair() (*Ed25519KeyPair, error) {
	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		return nil, fmt.Errorf("failed to generate Ed25519 key pair: %v", err)
	}

	return &Ed25519KeyPair{
		PrivateKey: privateKey,
		PublicKey:  publicKey,
	}, nil
}

// Sign data with ECDSA
func (kp *ECDSAKeyPair) Sign(data []byte) (string, string, error) {
	hash := sha256.Sum256(data)

	r, s, err := ecdsa.Sign(rand.Reader, kp.PrivateKey, hash[:])
	if err != nil {
		return "", "", fmt.Errorf("failed to sign data: %v", err)
	}

	signature := append(r.Bytes(), s.Bytes()...)

	return base64.StdEncoding.EncodeToString(signature),
		fmt.Sprintf("%032x", r) + fmt.Sprintf("%032x", s),
		nil
}

// Verify ECDSA signature
func (kp *ECDSAKeyPair) Verify(data []byte, signatureBase64 string) bool {
	signature, err := base64.StdEncoding.DecodeString(signatureBase64)
	if err != nil {
		return false
	}

	if len(signature) != 64 { // 32 bytes for r, 32 bytes for s
		return false
	}

	r := new(big.Int).SetBytes(signature[:32])
	s := new(big.Int).SetBytes(signature[32:])

	hash := sha256.Sum256(data)
	return ecdsa.Verify(kp.PublicKey, hash[:], r, s)
}

// Sign data with Ed25519
func (kp *Ed25519KeyPair) Sign(data []byte) string {
	signature := ed25519.Sign(kp.PrivateKey, data)
	return base64.StdEncoding.EncodeToString(signature)
}

// Verify Ed25519 signature
func (kp *Ed25519KeyPair) Verify(data []byte, signatureBase64 string) bool {
	signature, err := base64.StdEncoding.DecodeString(signatureBase64)
	if err != nil {
		return false
	}
	return ed25519.Verify(kp.PublicKey, data, signature)
}

// Perform ECDH key exchange
func (kp *ECDSAKeyPair) ECDH(theirPublicKey *ecdsa.PublicKey) (*ECDHSecret, error) {
	// Calculate shared secret
	scalarX, _ := theirPublicKey.Curve.ScalarMult(theirPublicKey.X, theirPublicKey.Y, kp.PrivateKey.D.Bytes())

	if scalarX == nil {
		return nil, fmt.Errorf("failed to compute ECDH secret")
	}

	// Hash the x-coordinate to get a uniform secret
	hash := sha256.Sum256(scalarX.Bytes())

	return &ECDHSecret{
		Secret: hash[:],
		X:      scalarX,
		Y:      theirPublicKey.Y,
	}, nil
}

// Export ECDSA public key to PEM format
func (kp *ECDSAKeyPair) ExportPublicKeyPEM() (string, error) {
	publicKeyBytes, err := x509.MarshalPKIXPublicKey(kp.PublicKey)
	if err != nil {
		return "", fmt.Errorf("failed to marshal public key: %v", err)
	}

	publicKeyPEM := pem.EncodeToMemory(&pem.Block{
		Type:  "PUBLIC KEY",
		Bytes: publicKeyBytes,
	})

	return string(publicKeyPEM), nil
}

// Export Ed25519 public key to base64
func (kp *Ed25519KeyPair) ExportPublicKeyBase64() string {
	return base64.StdEncoding.EncodeToString(kp.PublicKey)
}

// Get ECDSA key coordinates
func (kp *ECDSAKeyPair) GetCoordinates() (string, string) {
	return kp.PublicKey.X.String(), kp.PublicKey.Y.String()
}

// Benchmark different curves
func benchmarkCurves() {
	fmt.Println("=== ECC Curve Performance Benchmark ===")

	curves := map[string]elliptic.Curve{
		"P-256":  elliptic.P256(),
		"P-384":  elliptic.P384(),
		"P-521":  elliptic.P521(),
		"secp256k1": nil, // Will be handled separately
	}

	for name, curve := range curves {
		fmt.Printf("\n--- %s ---\n", name)

		var kp *ECDSAKeyPair
		var err error

		if name == "secp256k1" {
			// For secp256k1, we'd need an external library like btcec
			fmt.Println("secp256k1 requires external library (btcec)")
			continue
		}

		kp, err = GenerateECDSAKeyPair(curve)
		if err != nil {
			fmt.Printf("Failed to generate key pair: %v\n", err)
			continue
		}

		// Test signing performance
		data := []byte("Benchmark data for ECC performance testing")
		iterations := 1000

		start := makeTimestamp()
		for i := 0; i < iterations; i++ {
			_, _, err := kp.Sign(data)
			if err != nil {
				fmt.Printf("Sign failed: %v\n", err)
				break
			}
		}
		signDuration := makeTimestamp() - start

		// Test verification performance
		signature, _, err := kp.Sign(data)
		if err != nil {
			fmt.Printf("Failed to create signature for verification test\n")
			continue
		}

		start = makeTimestamp()
		for i := 0; i < iterations; i++ {
			kp.Verify(data, signature)
		}
		verifyDuration := makeTimestamp() - start

		fmt.Printf("Key size: %d bits\n", curve.Params().BitSize)
		fmt.Printf("Signing: %d ops in %.2f ms (%.2f ops/sec)\n",
			iterations, float64(signDuration)/1000000,
			float64(iterations)/float64(signDuration)*1000000000)
		fmt.Printf("Verification: %d ops in %.2f ms (%.2f ops/sec)\n",
			iterations, float64(verifyDuration)/1000000,
			float64(iterations)/float64(verifyDuration)*1000000000)
	}
}

// Helper function for timestamp
func makeTimestamp() int64 {
	return time.Now().UnixNano()
}

// Main demo function
func main() {
	fmt.Println("=== Elliptic Curve Cryptography Demo ===")

	// ECDSA Demo with P-256 curve
	fmt.Println("\n--- ECDSA with P-256 ---")
	ecdsaKp, err := GenerateECDSAKeyPair(elliptic.P256())
	if err != nil {
		log.Fatalf("Failed to generate ECDSA key pair: %v", err)
	}

	message := []byte("This message will be signed with ECDSA")
	fmt.Printf("Original message: %s\n", string(message))

	// Sign message
	signature, sigHex, err := ecdsaKp.Sign(message)
	if err != nil {
		log.Fatalf("Failed to sign message: %v", err)
	}

	fmt.Printf("Signature (Base64): %s\n", signature[:64]+"...")
	fmt.Printf("Signature (Hex): %s\n", sigHex)

	// Verify signature
	isValid := ecdsaKp.Verify(message, signature)
	fmt.Printf("Signature verification: %t\n", isValid)

	// Try with modified message
	modifiedMessage := []byte("This message will be signed with ECDSA - MODIFIED")
	isValid = ecdsaKp.Verify(modifiedMessage, signature)
	fmt.Printf("Modified message verification: %t\n", isValid)

	// Export public key
	pubKeyPEM, err := ecdsaKp.ExportPublicKeyPEM()
	if err != nil {
		log.Fatalf("Failed to export public key: %v", err)
	}
	fmt.Printf("Public Key (PEM format):\n%s\n", pubKeyPEM)

	// Get coordinates
	x, y := ecdsaKp.GetCoordinates()
	fmt.Printf("Public Key Coordinates:\n")
	fmt.Printf("  X: %s\n", x)
	fmt.Printf("  Y: %s\n", y)

	// Ed25519 Demo
	fmt.Println("\n--- Ed25519 ---")
	edKp, err := GenerateEd25519KeyPair()
	if err != nil {
		log.Fatalf("Failed to generate Ed25519 key pair: %v", err)
	}

	edMessage := []byte("This message will be signed with Ed25519")
	edSignature := edKp.Sign(edMessage)

	fmt.Printf("Original message: %s\n", string(edMessage))
	fmt.Printf("Signature (Base64): %s\n", edSignature[:64]+"...")

	edIsValid := edKp.Verify(edMessage, edSignature)
	fmt.Printf("Signature verification: %t\n", edIsValid)

	// ECDH Key Exchange Demo
	fmt.Println("\n--- ECDH Key Exchange ---")

	// Alice's key pair
	aliceKp, err := GenerateECDSAKeyPair(elliptic.P256())
	if err != nil {
		log.Fatalf("Failed to generate Alice's key pair: %v", err)
	}

	// Bob's key pair
	bobKp, err := GenerateECDSAKeyPair(elliptic.P256())
	if err != nil {
		log.Fatalf("Failed to generate Bob's key pair: %v", err)
	}

	// Alice computes shared secret using Bob's public key
	aliceSecret, err := aliceKp.ECDH(bobKp.PublicKey)
	if err != nil {
		log.Fatalf("Alice failed to compute shared secret: %v", err)
	}

	// Bob computes shared secret using Alice's public key
	bobSecret, err := bobKp.ECDH(aliceKp.PublicKey)
	if err != nil {
		log.Fatalf("Bob failed to compute shared secret: %v", err)
	}

	fmt.Printf("Alice's shared secret: %s\n", hex.EncodeToString(aliceSecret.Secret))
	fmt.Printf("Bob's shared secret: %s\n", hex.EncodeToString(bobSecret.Secret))
	fmt.Printf("Shared secrets match: %t\n",
		hex.EncodeToString(aliceSecret.Secret) == hex.EncodeToString(bobSecret.Secret))

	// Run benchmarks
	benchmarkCurves()

	fmt.Println("\n=== ECC Demo Complete ===")
}

CódigopythonIntermedio

Funciones Hash y Firmas Digitales

Implementaciones completas de funciones hash y esquemas de firmas digitales incluyendo SHA-256, HMAC y árboles Merkle

Dificultad

7/10

Tiempo estimado

30 min

Etiquetas

hash-functions, digital-signatures, merkle-tree, blockchain

Requisitos previos

Python, Cryptography basics

python
# Hash Functions and Digital Signatures
# Required: pip install cryptography pycryptodome

import hashlib
import hmac
import json
import time
from typing import List, Dict, Any, Optional
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import utils
from cryptography import x509
from cryptography.x509.oid import NameOID
import base64
import os
from datetime import datetime, timedelta

class HashFunctionManager:
    """Comprehensive hash function utilities"""

    @staticmethod
    def sha256(data: str) -> str:
        """SHA-256 hash function"""
        return hashlib.sha256(data.encode()).hexdigest()

    @staticmethod
    def sha512(data: str) -> str:
        """SHA-512 hash function"""
        return hashlib.sha512(data.encode()).hexdigest()

    @staticmethod
    def sha3_256(data: str) -> str:
        """SHA3-256 hash function"""
        return hashlib.sha3_256(data.encode()).hexdigest()

    @staticmethod
    def md5(data: str) -> str:
        """MD5 hash function (for legacy compatibility only)"""
        return hashlib.md5(data.encode()).hexdigest()

    @staticmethod
    def blake2b(data: str) -> str:
        """BLAKE2b hash function"""
        return hashlib.blake2b(data.encode()).hexdigest()

    @staticmethod
    def hmac_sha256(data: str, key: str) -> str:
        """HMAC with SHA-256"""
        return hmac.new(key.encode(), data.encode(), hashlib.sha256).hexdigest()

    @staticmethod
    def file_hash(file_path: str, algorithm: str = 'sha256') -> str:
        """Calculate hash of a file"""
        hash_func = getattr(hashlib, algorithm)()

        with open(file_path, 'rb') as f:
            for chunk in iter(lambda: f.read(4096), b""):
                hash_func.update(chunk)

        return hash_func.hexdigest()

class MerkleTree:
    """Merkle Tree implementation for data integrity verification"""

    def __init__(self, data_chunks: List[str]):
        self.leaves = [HashFunctionManager.sha256(chunk) for chunk in data_chunks]
        self.tree = self._build_tree(self.leaves)
        self.root = self.tree[0] if self.tree else ""

    def _build_tree(self, nodes: List[str]) -> List[str]:
        """Build merkle tree from leaf nodes"""
        if len(nodes) == 1:
            return nodes

        tree_level = []

        # Process pairs of nodes
        for i in range(0, len(nodes), 2):
            if i + 1 < len(nodes):
                # Hash concatenation of two nodes
                combined = nodes[i] + nodes[i + 1]
                tree_level.append(HashFunctionManager.sha256(combined))
            else:
                # Handle odd number of nodes by duplicating the last one
                combined = nodes[i] + nodes[i]
                tree_level.append(HashFunctionManager.sha256(combined))

        # Recursively build tree
        return self._build_tree(tree_level)

    def get_proof(self, data_chunk: str) -> List[Dict[str, Any]]:
        """Generate Merkle proof for a data chunk"""
        chunk_hash = HashFunctionManager.sha256(data_chunk)

        if chunk_hash not in self.leaves:
            raise ValueError("Data chunk not found in tree")

        proof = []
        current_level = self.leaves
        current_hash = chunk_hash
        index = current_level.index(current_hash)

        while len(current_level) > 1:
            # Determine if node is left or right child
            is_right_child = index % 2 == 1
            sibling_index = index - 1 if is_right_child else index + 1

            if sibling_index < len(current_level):
                proof.append({
                    'hash': current_level[sibling_index],
                    'direction': 'left' if is_right_child else 'right'
                })

            # Move to next level
            index = index // 2
            current_level = self._build_tree(current_level)

        return proof

    def verify_proof(self, data_chunk: str, proof: List[Dict[str, Any]]) -> bool:
        """Verify Merkle proof for a data chunk"""
        current_hash = HashFunctionManager.sha256(data_chunk)

        for proof_element in proof:
            if proof_element['direction'] == 'left':
                combined = proof_element['hash'] + current_hash
            else:
                combined = current_hash + proof_element['hash']

            current_hash = HashFunctionManager.sha256(combined)

        return current_hash == self.root

class DigitalSignatureManager:
    """Digital signature management with RSA and certificates"""

    def __init__(self):
        self.private_key = None
        self.public_key = None
        self.certificate = None

    def generate_rsa_key_pair(self, key_size: int = 2048) -> None:
        """Generate RSA key pair for signing"""
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=key_size
        )
        self.public_key = self.private_key.public_key()

    def create_self_signed_certificate(self, common_name: str = "Test Certificate") -> None:
        """Create a self-signed X.509 certificate"""
        if not self.private_key:
            raise ValueError("Private key not generated")

        subject = issuer = x509.Name([
            x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
            x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "California"),
            x509.NameAttribute(NameOID.LOCALITY_NAME, "San Francisco"),
            x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Test Org"),
            x509.NameAttribute(NameOID.COMMON_NAME, common_name),
        ])

        self.certificate = (
            x509.CertificateBuilder()
            .subject_name(subject)
            .issuer_name(issuer)
            .public_key(self.public_key)
            .serial_number(x509.random_serial_number())
            .not_valid_before(datetime.utcnow())
            .not_valid_after(datetime.utcnow() + timedelta(days=365))
            .add_extension(
                x509.SubjectAlternativeName([
                    x509.DNSName(common_name),
                ]),
                critical=False,
            )
            .sign(self.private_key, hashes.SHA256())
        )

    def sign_message(self, message: str) -> str:
        """Sign a message with RSA private key"""
        if not self.private_key:
            raise ValueError("Private key not generated")

        signature = self.private_key.sign(
            message.encode(),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )

        return base64.b64encode(signature).decode()

    def verify_signature(self, message: str, signature_b64: str, public_key_pem: str = None) -> bool:
        """Verify a digital signature"""
        try:
            signature = base64.b64decode(signature_b64)

            # Use provided public key or own public key
            if public_key_pem:
                pub_key = serialization.load_pem_public_key(
                    public_key_pem.encode()
                )
            else:
                pub_key = self.public_key

            pub_key.verify(
                signature,
                message.encode(),
                padding.PSS(
                    mgf=padding.MGF1(hashes.SHA256()),
                    salt_length=padding.PSS.MAX_LENGTH
                ),
                hashes.SHA256()
            )

            return True
        except Exception:
            return False

    def export_public_key_pem(self) -> str:
        """Export public key in PEM format"""
        if not self.public_key:
            raise ValueError("Public key not available")

        pem = self.public_key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        )

        return pem.decode()

    def export_certificate_pem(self) -> str:
        """Export certificate in PEM format"""
        if not self.certificate:
            raise ValueError("Certificate not created")

        pem = self.certificate.public_bytes(serialization.Encoding.PEM)
        return pem.decode()

class BlockchainHashing:
    """Blockchain-style hashing with proof of work"""

    @staticmethod
    def hash_block(block_data: Dict[str, Any], previous_hash: str, nonce: int = 0) -> str:
        """Hash a block with mining capability"""
        block_string = json.dumps({
            'data': block_data,
            'previous_hash': previous_hash,
            'nonce': nonce,
            'timestamp': time.time()
        }, sort_keys=True)

        return HashFunctionManager.sha256(block_string)

    @staticmethod
    def mine_block(block_data: Dict[str, Any], previous_hash: str, difficulty: int = 4) -> Dict[str, Any]:
        """Mine a block with proof of work"""
        target = "0" * difficulty
        nonce = 0

        while True:
            block_hash = BlockchainHashing.hash_block(block_data, previous_hash, nonce)

            if block_hash.startswith(target):
                return {
                    'data': block_data,
                    'previous_hash': previous_hash,
                    'nonce': nonce,
                    'hash': block_hash,
                    'timestamp': time.time(),
                    'difficulty': difficulty
                }

            nonce += 1

    @staticmethod
    def verify_chain(chain: List[Dict[str, Any]]) -> bool:
        """Verify blockchain integrity"""
        for i in range(1, len(chain)):
            current_block = chain[i]
            previous_block = chain[i - 1]

            # Verify hash
            expected_hash = BlockchainHashing.hash_block(
                current_block['data'],
                current_block['previous_hash'],
                current_block['nonce']
            )

            if expected_hash != current_block['hash']:
                return False

            # Verify previous hash link
            if current_block['previous_hash'] != previous_block['hash']:
                return False

        return True

def demo_hash_functions():
    print("=== Hash Functions Demo ===")

    data = "Hello, Cryptography!"

    print(f"Original data: {data}")
    print(f"SHA-256: {HashFunctionManager.sha256(data)}")
    print(f"SHA-512: {HashFunctionManager.sha512(data)}")
    print(f"SHA3-256: {HashFunctionManager.sha3_256(data)}")
    print(f"MD5: {HashFunctionManager.md5(data)}")
    print(f"BLAKE2b: {HashFunctionManager.blake2b(data)}")

    # HMAC Demo
    key = "secret-key-123"
    hmac_result = HashFunctionManager.hmac_sha256(data, key)
    print(f"\nHMAC-SHA256 with key '{key}': {hmac_result}")

def demo_merkle_tree():
    print("\n=== Merkle Tree Demo ===")

    # Sample data chunks
    documents = [
        "Document 1: Important contract",
        "Document 2: Financial report",
        "Document 3: Medical records",
        "Document 4: Legal notice",
        "Document 5: Tax information"
    ]

    merkle_tree = MerkleTree(documents)

    print("Documents:")
    for i, doc in enumerate(documents):
        print(f"  {i+1}. {doc}")

    print(f"\nMerkle Root: {merkle_tree.root}")

    # Generate and verify proof for document 3
    target_doc = documents[2]
    proof = merkle_tree.get_proof(target_doc)

    print(f"\nProof for document '{target_doc[:20]}...':")
    for i, proof_element in enumerate(proof):
        print(f"  Step {i+1}: {proof_element['hash'][:16]}... ({proof_element['direction']})")

    # Verify proof
    is_valid = merkle_tree.verify_proof(target_doc, proof)
    print(f"\nProof verification: {is_valid}")

    # Try with modified document
    modified_doc = target_doc + " (modified)"
    is_valid_modified = merkle_tree.verify_proof(modified_doc, proof)
    print(f"Modified document verification: {is_valid_modified}")

def demo_digital_signatures():
    print("\n=== Digital Signatures Demo ===")

    # Initialize signature manager
    sig_manager = DigitalSignatureManager()
    sig_manager.generate_rsa_key_pair(2048)
    sig_manager.create_self_signed_certificate("example.com")

    # Sign a message
    message = "This is a legally binding electronic document"
    signature = sig_manager.sign_message(message)

    print(f"Original message: {message}")
    print(f"Signature: {signature[:64]}...")

    # Export keys and certificate
    public_key_pem = sig_manager.export_public_key_pem()
    certificate_pem = sig_manager.export_certificate_pem()

    print(f"\nPublic Key (PEM format):")
    print(public_key_pem[:100] + "...")

    print(f"\nCertificate (PEM format):")
    print(certificate_pem[:100] + "...")

    # Verify signature
    is_valid = sig_manager.verify_signature(message, signature)
    print(f"\nSignature verification: {is_valid}")

    # Try with modified message
    modified_message = message + " (modified)"
    is_valid_modified = sig_manager.verify_signature(modified_message, signature)
    print(f"Modified message verification: {is_valid_modified}")

    # Verify with exported public key
    is_valid_exported = sig_manager.verify_signature(message, signature, public_key_pem)
    print(f"Verification with exported public key: {is_valid_exported}")

def demo_blockchain_hashing():
    print("\n=== Blockchain Hashing Demo ===")

    # Create a simple blockchain
    block1 = BlockchainHashing.mine_block(
        {"transactions": ["Alice pays Bob 10 BTC"]},
        "0" * 64,  # Genesis block previous hash
        difficulty=2
    )

    block2 = BlockchainHashing.mine_block(
        {"transactions": ["Bob pays Charlie 5 BTC"]},
        block1['hash'],
        difficulty=2
    )

    block3 = BlockchainHashing.mine_block(
        {"transactions": ["Charlie pays Dave 3 BTC"]},
        block2['hash'],
        difficulty=2
    )

    blockchain = [block1, block2, block3]

    print("Blockchain:")
    for i, block in enumerate(blockchain):
        print(f"\nBlock {i+1}:")
        print(f"  Data: {block['data']}")
        print(f"  Nonce: {block['nonce']}")
        print(f"  Hash: {block['hash']}")
        print(f"  Previous Hash: {block['previous_hash']}")

    # Verify blockchain integrity
    is_valid_chain = BlockchainHashing.verify_chain(blockchain)
    print(f"\nBlockchain integrity: {is_valid_chain}")

    # Tamper with blockchain and verify
    tampered_blockchain = [block1, block2, block3.copy()]
    tampered_blockchain[2]['data'] = {"transactions": ["Charlie pays Eve 100 BTC"]}

    is_tampered_valid = BlockchainHashing.verify_chain(tampered_blockchain)
    print(f"Tampered blockchain integrity: {is_tampered_valid}")

def main():
    print("=== Cryptography: Hash Functions and Digital Signatures ===")

    demo_hash_functions()
    demo_merkle_tree()
    demo_digital_signatures()
    demo_blockchain_hashing()

    print("\n=== Demo Complete ===")

if __name__ == "__main__":
    main()
CódigorustComplejo

Protocolos de Intercambio de Claves

Implementaciones de protocolos seguros de intercambio de claves incluyendo Diffie-Hellman, ECDH y métodos post-cuánticos

Dificultad

9/10

Tiempo estimado

40 min

Etiquetas

key-exchange, diffie-hellman, ecdh, post-quantum

Requisitos previos

Rust programming, Advanced cryptography

rust
// Key Exchange Protocols Implementation in Rust
// Cargo.toml dependencies:
// [dependencies]
// ring = "0.16"
// x25519-dalek = "2.0"
// curve25519-dalek = "4.0"
// sha2 = "0.10"
// rand = "0.8"
// serde = { version = "1.0", features = ["derive"] }
// base64 = "0.21"

use curve25519_dalek::{ristretto::RistrettoPoint, scalar::Scalar, constants::RISTRETTO_BASEPOINT_POINT};
use ring::{rand::SecureRandom, agreement, digest};
use sha2::{Sha256, Digest};
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct DiffieHellmanKeyPair {
    pub private_key: Vec<u8>,
    pub public_key: Vec<u8>,
}

#[derive(Debug, Clone)]
pub struct ECDHKeyPair {
    pub private_key: Scalar,
    pub public_key: RistrettoPoint,
}

#[derive(Debug, Clone)]
pub struct KeyExchangeResult {
    pub shared_secret: Vec<u8>,
    pub session_key: Vec<u8>,
    pub exchange_id: String,
}

pub struct KeyExchangeManager {
    rng: ring::rand::SystemRandom,
}

impl KeyExchangeManager {
    pub fn new() -> Self {
        Self {
            rng: ring::rand::SystemRandom::new(),
        }
    }

    /// Traditional Diffie-Hellman key exchange
    pub fn diffie_hellman_generate(&self, key_size: usize) -> Result<DiffieHellmanKeyPair, &'static str> {
        let mut private_key = vec![0u8; key_size];
        let mut public_key = vec![0u8; key_size];

        // Generate private key
        self.rng.fill(&mut private_key);

        // For demonstration, we'll use a simple generator (2) and large prime
        // In practice, use well-known safe primes like RFC 3526 groups
        let generator = 2u64;
        let prime = 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFFu64;

        // Calculate public key: g^private_key mod p
        let private_val = u64::from_le_bytes([
            private_key[0], private_key[1], private_key[2], private_key[3],
            private_key[4], private_key[5], private_key[6], private_key[7],
        ]);

        let public_val = generator.modpow(private_val, prime);
        public_key[..8].copy_from_slice(&public_val.to_le_bytes());

        Ok(DiffieHellmanKeyPair {
            private_key,
            public_key,
        })
    }

    /// Compute shared secret using Diffie-Hellman
    pub fn diffie_hellman_compute_secret(
        &self,
        my_private: &[u8],
        their_public: &[u8],
        key_size: usize,
    ) -> Result<Vec<u8>, &'static str> {
        // Extract values (simplified for demonstration)
        let private_val = u64::from_le_bytes([
            my_private[0], my_private[1], my_private[2], my_private[3],
            my_private[4], my_private[5], my_private[6], my_private[7],
        ]);

        let their_public_val = u64::from_le_bytes([
            their_public[0], their_public[1], their_public[2], their_public[3],
            their_public[4], their_public[5], their_public[6], their_public[7],
        ]);

        let prime = 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFFu64;

        // Compute shared secret: their_public^my_private mod p
        let shared_val = their_public_val.modpow(private_val, prime);

        let mut shared_secret = vec![0u8; key_size];
        shared_secret[..8].copy_from_slice(&shared_val.to_le_bytes());

        Ok(shared_secret)
    }

    /// Generate ECDH key pair using Ristretto (Curve25519 variant)
    pub fn ecdh_generate(&self) -> Result<ECDHKeyPair, &'static str> {
        let mut private_bytes = [0u8; 32];
        self.rng.fill(&mut private_bytes);

        let private_key = Scalar::from_bytes_mod_order(private_bytes);
        let public_key = RistrettoPoint::mult_base_private(&private_key);

        Ok(ECDHKeyPair {
            private_key,
            public_key,
        })
    }

    /// Compute ECDH shared secret
    pub fn ecdh_compute_secret(
        &self,
        my_private: &Scalar,
        their_public: &RistrettoPoint,
    ) -> Vec<u8> {
        let shared_point = their_public * my_private;
        shared_point.compress().to_bytes().to_vec()
    }

    /// Post-quantum key resistant key exchange (Kyber-like)
    pub fn post_quantum_key_exchange(&self) -> Result<(Vec<u8>, Vec<u8>), &'static str> {
        // Simplified post-quantum key exchange based on lattice-based cryptography
        // In practice, use libraries like pqcrypto or ML-KEM

        // Generate random lattice parameters
        let mut seed = [0u8; 32];
        self.rng.fill(&mut seed);

        // Generate "public key" (commitment) and "private key" (trapdoor)
        let mut public_key = [0u8; 1024];
        let mut private_key = [0u8; 2048];

        // Fill with pseudo-random data based on seed
        let mut hasher = Sha256::new();
        hasher.update(seed);
        let hash = hasher.finalize();

        for i in 0..1024 {
            public_key[i] = hash[i % 32] ^ (i as u8);
        }

        for i in 0..2048 {
            private_key[i] = hash[i % 32] ^ ((i >> 3) as u8);
        }

        Ok((public_key.to_vec(), private_key.to_vec()))
    }

    /// Derive session key from shared secret
    pub fn derive_session_key(
        &self,
        shared_secret: &[u8],
        context: &[u8],
        key_length: usize,
    ) -> Vec<u8> {
        let mut hasher = Sha256::new();
        hasher.update(shared_secret);
        hasher.update(context);

        let mut key = vec![0u8; key_length];
        let hash = hasher.finalize();

        // Simple key derivation: repeat hash if needed
        for i in 0..key_length {
            key[i] = hash[i % 32];
        }

        key
    }

    /// Authenticated key exchange using digital signatures
    pub fn authenticated_key_exchange(
        &self,
        identity: &str,
    ) -> Result<(Vec<u8>, Vec<u8>), &'static str> {
        // Generate ECDH key pair
        let ecdh_keypair = self.ecdh_generate()?;

        // Create identity-based signature
        let mut hasher = Sha256::new();
        hasher.update(identity.as_bytes());
        hasher.update(ecdh_keypair.public_key.compress().to_bytes());
        let signature = hasher.finalize();

        // Return public key and signature
        Ok((
            ecdh_keypair.public_key.compress().to_bytes().to_vec(),
            signature.to_vec(),
        ))
    }

    /// Verify authenticated key exchange
    pub fn verify_authenticated_exchange(
        &self,
        identity: &str,
        public_key_bytes: &[u8],
        signature: &[u8],
    ) -> bool {
        let mut hasher = Sha256::new();
        hasher.update(identity.as_bytes());
        hasher.update(public_key_bytes);
        let expected_signature = hasher.finalize();

        signature == expected_signature.as_slice()
    }

    /// Perfect Forward Secrecy with ephemeral keys
    pub fn perfect_forward_secrecy_exchange(&self) -> Result<KeyExchangeResult, &'static str> {
        // Generate ephemeral ECDH key pair
        let ephemeral_keypair = self.ecdh_generate()?;

        // Generate long-term key pair
        let longterm_keypair = self.ecdh_generate()?;

        // Compute shared secrets
        let shared_secret = self.ecdh_compute_secret(&ephemeral_keypair.private_key, &longterm_keypair.public_key);

        // Derive session keys
        let session_key = self.derive_session_key(&shared_secret, b"PFS-session", 32);

        // Generate exchange ID
        let exchange_id = format!("pfs-{}", std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs());

        Ok(KeyExchangeResult {
            shared_secret,
            session_key,
            exchange_id,
        })
    }

    /// Group key exchange (TreeKEM-like protocol)
    pub fn group_key_exchange(&self, participants: &[String]) -> Result<HashMap<String, Vec<u8>>, &'static str> {
        let mut group_keys = HashMap::new();

        // Sort participants for deterministic ordering
        let mut sorted_participants = participants.clone();
        sorted_participants.sort();

        // Generate a master secret
        let mut master_secret = [0u8; 32];
        self.rng.fill(&mut master_secret);

        // Derive individual keys for each participant
        for (i, participant) in sorted_participants.iter().enumerate() {
            let mut hasher = Sha256::new();
            hasher.update(&master_secret);
            hasher.update(participant.as_bytes());
            hasher.update(&(i as u64).to_le_bytes());

            let participant_key = hasher.finalize();
            group_keys.insert(participant.clone(), participant_key.to_vec());
        }

        Ok(group_keys)
    }

    /// Key rotation for long-term security
    pub fn rotate_key(&self, current_key: &[u8], rotation_id: &str) -> Vec<u8> {
        let mut hasher = Sha256::new();
        hasher.update(current_key);
        hasher.update(rotation_id.as_bytes());
        hasher.update(&std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
            .to_le_bytes());

        hasher.finalize().to_vec()
    }
}

fn benchmark_key_exchanges() {
    println!("=== Key Exchange Performance Benchmark ===");

    let manager = KeyExchangeManager::new();
    let iterations = 1000;

    // Benchmark Diffie-Hellman
    let start = std::time::Instant::now();
    for _ in 0..iterations {
        let _ = manager.diffie_hellman_generate(256);
    }
    let dh_duration = start.elapsed();

    // Benchmark ECDH
    let start = std::time::Instant::now();
    for _ in 0..iterations {
        let _ = manager.ecdh_generate();
    }
    let ecdh_duration = start.elapsed();

    println!("Diffie-Hellman ({} ops): {:?}", iterations, dh_duration);
    println!("ECDH ({} ops): {:?}", iterations, ecdh_duration);

    let dh_ops_per_sec = iterations as f64 / dh_duration.as_secs_f64();
    let ecdh_ops_per_sec = iterations as f64 / ecdh_duration.as_secs_f64();

    println!("Diffie-Hellman: {:.2} ops/sec", dh_ops_per_sec);
    println!("ECDH: {:.2} ops/sec", ecdh_ops_per_sec);
}

fn main() {
    println!("=== Key Exchange Protocols Demo ===");

    let manager = KeyExchangeManager::new();

    // Traditional Diffie-Hellman Demo
    println!("\n--- Traditional Diffie-Hellman ---");
    let alice_dh = manager.diffie_hellman_generate(256).unwrap();
    let bob_dh = manager.diffie_hellman_generate(256).unwrap();

    println!("Alice's private key: {}", hex::encode(&alice_dh.private_key[..16]));
    println!("Alice's public key: {}", hex::encode(&alice_dh.public_key[..16]));
    println!("Bob's private key: {}", hex::encode(&bob_dh.private_key[..16]));
    println!("Bob's public key: {}", hex::encode(&bob_dh.public_key[..16]));

    let alice_shared = manager.diffie_hellman_compute_secret(
        &alice_dh.private_key,
        &bob_dh.public_key,
        256,
    ).unwrap();

    let bob_shared = manager.diffie_hellman_compute_secret(
        &bob_dh.private_key,
        &alice_dh.public_key,
        256,
    ).unwrap();

    println!("Alice's shared secret: {}", hex::encode(&alice_shared[..16]));
    println!("Bob's shared secret: {}", hex::encode(&bob_shared[..16]));
    println!("Shared secrets match: {}", alice_shared == bob_shared);

    // ECDH Demo
    println!("\n--- Elliptic Curve Diffie-Hellman ---");
    let alice_ecdh = manager.ecdh_generate().unwrap();
    let bob_ecdh = manager.ecdh_generate().unwrap();

    let alice_ecdh_shared = manager.ecdh_compute_secret(&alice_ecdh.private_key, &bob_ecdh.public_key);
    let bob_ecdh_shared = manager.ecdh_compute_secret(&bob_ecdh.private_key, &alice_ecdh.public_key);

    println!("Alice's ECDH shared secret: {}", hex::encode(&alice_ecdh_shared[..16]));
    println!("Bob's ECDH shared secret: {}", hex::encode(&bob_ecdh_shared[..16]));
    println!("ECDH shared secrets match: {}", alice_ecdh_shared == bob_ecdh_shared);

    // Session Key Derivation
    println!("\n--- Session Key Derivation ---");
    let session_key = manager.derive_session_key(&alice_ecdh_shared, b"session-context", 32);
    println!("Derived session key: {}", hex::encode(&session_key));

    // Authenticated Key Exchange
    println!("\n--- Authenticated Key Exchange ---");
    let alice_public_key = manager.authenticated_key_exchange("alice@example.com").unwrap();
    let alice_auth_valid = manager.verify_authenticated_exchange(
        "alice@example.com",
        &alice_public_key.0,
        &alice_public_key.1,
    );
    println!("Alice's authenticated key exchange valid: {}", alice_auth_valid);

    // Perfect Forward Secrecy
    println!("\n--- Perfect Forward Secrecy ---");
    let pfs_result = manager.perfect_forward_secrecy_exchange().unwrap();
    println!("PFS Exchange ID: {}", pfs_result.exchange_id);
    println!("PFS Session Key: {}", hex::encode(&pfs_result.session_key));

    // Group Key Exchange
    println!("\n--- Group Key Exchange ---");
    let participants = vec![
        "alice".to_string(),
        "bob".to_string(),
        "charlie".to_string(),
        "diana".to_string(),
    ];

    let group_keys = manager.group_key_exchange(&participants).unwrap();
    println!("Group keys for {} participants:", participants.len());
    for (participant, key) in &group_keys {
        println!("  {}: {}", participant, hex::encode(&key[..16]));
    }

    // Key Rotation Demo
    println!("\n--- Key Rotation ---");
    let original_key = b"original-secret-key-123456";
    let rotated_key1 = manager.rotate_key(original_key, "rotation-1");
    let rotated_key2 = manager.rotate_key(&rotated_key1, "rotation-2");

    println!("Original key: {}", hex::encode(original_key));
    println!("After rotation 1: {}", hex::encode(&rotated_key1[..16]));
    println!("After rotation 2: {}", hex::encode(&rotated_key2[..16]));

    // Post-Quantum Key Exchange
    println!("\n--- Post-Quantum Key Exchange ---");
    let (pq_public, pq_private) = manager.post_quantum_key_exchange().unwrap();
    println!("Post-quantum public key size: {} bytes", pq_public.len());
    println!("Post-quantum private key size: {} bytes", pq_private.len());

    // Run benchmarks
    benchmark_key_exchanges();

    println!("\n=== Key Exchange Demo Complete ===");
}

// Add this to Cargo.toml for hex encoding
// hex = "0.4"

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Tema

Revisión e integración de un componente de sorteos autoalojado

Revisa la configuración, las respuestas de ejemplo, la legibilidad y el diseño adaptable antes de entregar los archivos y las pruebas de integración del sorteo.

Tema

Modelos farmacocineticos docentes y revision de resultados

Explora formulas farmacocineticas, supuestos de modelo y coherencia de resultados para docencia o QA, sin dar dosis ni consejo clinico.

Tema

Herramientas de cifrado clásico y moderno

Practica cifrados seguros para educación o CTF comparando transformaciones clásicas reversibles con cifrado moderno y sus límites de seguridad.

Tema

Revisión de una lección Markdown interactiva y entrega sin conexión

Revisa contenido y configuración, ensaya el HTML exportado sin conexión y separa archivos del público de fuentes privadas.

Inicio
Herramientas3212
Ejemplos593
Visualizaciones471
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web193

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Security

Herramienta de cifrado AES

Cifra o descifra texto y archivos con AES-256-GCM y exporta paquetes basados en IV

Format Conversion

Codificador de Web Push: petición RFC 8030 + VAPID + cifrado RFC 8291

Codifica un envío completo de Web Push: cifrado aes128gcm del RFC 8291, JWT ES256 VAPID del RFC 8292, cabeceras RFC 8030, correspondencia con APNs/FCM y verificación por descifrado de ida y vuelta.

Security

Generador de firma digital

Firma un mensaje con una clave privada o verifica una firma con una clave pública — soporta RSA-PSS (SHA-256), ECDSA (P-256) y Ed25519. Criptografía puramente local (Node crypto.createSign/createVerify), sin red. Pega una clave PEM para firmar o verificar una firma base64. Esta herramienta firma/verifica; no genera pares de claves.

Security

Cifrado / Descifrado RSA

Cifra texto con una clave pública RSA o descifra el texto cifrado con la clave privada correspondiente, usando padding OAEP (SHA-1 o SHA-256). Maneja mensajes largos por bloques. Las claves y datos se quedan en local. No se ofrece PKCS#1 v1.5 (Node lo deshabilita para descifrar por ataques Bleichenbacher).

Cryptography

Generador Bcrypt

Generar hash bcrypt desde contraseña

Security

Generador y Analizador de JWK

Genera JSON Web Keys (JWK) para RSA, EC (P-256/P-384/P-521/secp256k1) y OKP (Ed25519/Ed448/X25519/X448), o analiza un JWK existente para inspeccionar parámetros, huella y metadatos

Security

Generador de Pares de Claves

Genera pares de claves pública/privada para varios algoritmos criptográficos

Cryptography

Generador PBKDF2

Generar hash de derivación de clave PBKDF2

Java

Ejemplos de Criptografía Android Java

Ejemplos de criptografía Android Java incluyendo cálculo de hash, encriptación AES y codificación Base64

Kotlin

Ejemplos de Criptografía Android Kotlin

Ejemplos de criptografía Android Kotlin incluyendo cálculo de hash, encriptación AES y codificación Base64

Swift

Ejemplos de Criptografía macOS Swift

Ejemplos de criptografía macOS Swift incluyendo funciones hash, cifrado/descifrado y firmas digitales

Go

Ejemplos de Criptografía Web Go

Ejemplos de criptografía y seguridad Web Go incluyendo cálculo de hash, cifrado simétrico y codificación/decodificación Base64

Python

Ejemplos de Criptografía Web Python

Ejemplos de criptografía y seguridad Web Python incluyendo computación de hash, cifrado simétrico y codificación Base64

Rust

Ejemplos de Criptografía Web Rust

Ejemplos de criptografía Web Rust incluyendo cálculo de hash, cifrado simétrico y codificación Base64