1
2
3
4
5
6

def quarter_round(a, b, c, d):
    a += b; d ^= a; d = ((d << 16) | (d >> 16)) & 0xffffffff
    c += d; b ^= c; b = ((b << 12) | (b >> 20)) & 0xffffffff
    a += b; d ^= a; d = ((d << 8)  | (d >> 24)) & 0xffffffff
    c += d; b ^= c; b = ((b << 7)  | (b >> 25)) & 0xffffffff
    return a, b, c, d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def chacha20_block(key, nonce, counter):
    # Inicializar estado
    state = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574]  # constants
    state.extend(key)  # key (8 words)
    state.extend([counter, nonce[0], nonce[1], nonce[2]])  # counter + nonce
    
    # 20 rondas (10 rondas dobles)
    working_state = state[:]
    for i in range(10):
        # Column rounds
        working_state[0], working_state[4], working_state[8],  working_state[12] = quarter_round(working_state[0], working_state[4], working_state[8],  working_state[12])
        working_state[1], working_state[5], working_state[9],  working_state[13] = quarter_round(working_state[1], working_state[5], working_state[9],  working_state[13])
        working_state[2], working_state[6], working_state[10], working_state[14] = quarter_round(working_state[2], working_state[6], working_state[10], working_state[14])
        working_state[3], working_state[7], working_state[11], working_state[15] = quarter_round(working_state[3], working_state[7], working_state[11], working_state[15])
        
        # Diagonal rounds
        working_state[0], working_state[5], working_state[10], working_state[15] = quarter_round(working_state[0], working_state[5], working_state[10], working_state[15])
        working_state[1], working_state[6], working_state[11], working_state[12] = quarter_round(working_state[1], working_state[6], working_state[11], working_state[12])
        working_state[2], working_state[7], working_state[8],  working_state[13] = quarter_round(working_state[2], working_state[7], working_state[8],  working_state[13])
        working_state[3], working_state[4], working_state[9],  working_state[14] = quarter_round(working_state[3], working_state[4], working_state[9],  working_state[14])
    
    # Sumar estado original
    for i in range(16):
        working_state[i] = (working_state[i] + state[i]) & 0xffffffff
    
    return working_state

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

def poly1305(key, message):
    # Clave de 256 bits
    r = key[:16]  # 128 bits
    s = key[16:]  # 128 bits
    
    # Máscara r
    r[3] &= 0x0f
    r[7] &= 0x0f
    r[11] &= 0x0f
    r[15] &= 0x0f
    r[4] &= 0xfc
    r[8] &= 0xfc
    r[12] &= 0xfc
    
    # Convertir a enteros
    r_int = int.from_bytes(r, 'little')
    s_int = int.from_bytes(s, 'little')
    
    # Procesar mensaje en bloques de 16 bytes
    accumulator = 0
    p = (1 << 130) - 5  # 2^130 - 5
    
    for i in range(0, len(message), 16):
        block = message[i:i+16]
        if len(block) < 16:
            block += b'\x01'  # Padding
            block += b'\x00' * (16 - len(block))
        
        n = int.from_bytes(block, 'little')
        accumulator = (accumulator + n) * r_int % p
    
    accumulator = (accumulator + s_int) % (1 << 128)
    
    return accumulator.to_bytes(16, 'little')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import os
from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305

def encrypt_chacha20_poly1305(key, nonce, plaintext, associated_data=b""):
    """Cifrar con ChaCha20-Poly1305"""
    cipher = ChaCha20Poly1305(key)
    ciphertext = cipher.encrypt(nonce, plaintext, associated_data)
    return ciphertext

def decrypt_chacha20_poly1305(key, nonce, ciphertext, associated_data=b""):
    """Descifrar con ChaCha20-Poly1305"""
    cipher = ChaCha20Poly1305(key)
    plaintext = cipher.decrypt(nonce, ciphertext, associated_data)
    return plaintext

# Ejemplo de uso
key = os.urandom(32)  # 256 bits
nonce = os.urandom(12)  # 96 bits
plaintext = b"Hello, World!"
associated_data = b"metadata"

# Cifrar
ciphertext = encrypt_chacha20_poly1305(key, nonce, plaintext, associated_data)
print(f"Ciphertext: {ciphertext.hex()}")

# Descifrar
decrypted = decrypt_chacha20_poly1305(key, nonce, ciphertext, associated_data)
print(f"Decrypted: {decrypted}")

1
2
3
4
5

# Cifrar archivo
openssl enc -chacha20-poly1305 -in plaintext.txt -out ciphertext.bin -K $(hexdump -v -e '/1 "%02x"' < key.bin) -iv $(hexdump -v -e '/1 "%02x"' < nonce.bin)

# Descifrar archivo
openssl enc -chacha20-poly1305 -d -in ciphertext.bin -out decrypted.txt -K $(hexdump -v -e '/1 "%02x"' < key.bin) -iv $(hexdump -v -e '/1 "%02x"' < nonce.bin)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

const crypto = require('crypto');

function encryptChaCha20Poly1305(key, nonce, plaintext, associatedData = Buffer.alloc(0)) {
    const cipher = crypto.createCipher('chacha20-poly1305', key);
    cipher.setAAD(associatedData);
    cipher.setAutoPadding(false);
    
    let ciphertext = cipher.update(plaintext);
    ciphertext = Buffer.concat([ciphertext, cipher.final()]);
    
    const tag = cipher.getAuthTag();
    
    return Buffer.concat([ciphertext, tag]);
}

function decryptChaCha20Poly1305(key, nonce, ciphertext, associatedData = Buffer.alloc(0)) {
    const tag = ciphertext.slice(-16);
    const encrypted = ciphertext.slice(0, -16);
    
    const decipher = crypto.createDecipher('chacha20-poly1305', key);
    decipher.setAAD(associatedData);
    decipher.setAuthTag(tag);
    
    let plaintext = decipher.update(encrypted);
    plaintext = Buffer.concat([plaintext, decipher.final()]);
    
    return plaintext;
}