密碼學 - 一次性簽章

import hashlib
import secrets

private_key = [[None for _ in range(256)] for _ in range(2)]
public_key = [[None for _ in range(256)] for _ in range(2)]
for i in range(256):
    private_key[0][i] = secrets.token_bytes(32)  # 256 bit
    private_key[1][i] = secrets.token_bytes(32)
    public_key[0][i] = hashlib.sha256(private_key[0][i]).digest()
    public_key[1][i] = hashlib.sha256(private_key[1][i]).digest()

import hashlib


def generate_signature(message, secret_keys):
    # Convert the message to bytes if it's not already
    if isinstance(message, str):
        message = message.encode('utf-8')

    # Hash the message
    hashed_message = hashlib.sha256(message).digest()

    # Convert hash to an integer (little endian)
    msg_int = int.from_bytes(hashed_message, 'little')

    # Generate the signature
    signature = []
    for i in range(256):
        bit = (msg_int >> i) & 1
        signature.append(secret_keys[bit][i])

    return signature


# Example usage
raw_message = 'Hello, World! I am the message.'
signature = generate_signature(raw_message, private_key)  # Assuming 'sk' is defined as before

print(f"Message: {raw_message}")
print(f"Signature length: {len(signature)}")
print(f"First few bytes of signature: {signature[:5]}")

def verify_signature(message, signature, public_keys):
    """
    Verify the digital signature of a given message.

    :param message: The original message (bytes or string)
    :param signature: The signature to verify (list of 256 byte strings)
    :param public_keys: The public key set (2x256 list of byte strings)
    :return: Boolean indicating if the signature is valid
    """
    # Convert the message to bytes if it's not already
    if isinstance(message, str):
        message = message.encode('utf-8')

    # Hash the message
    hashed_message = hashlib.sha256(message).digest()

    # Convert hash to an integer (little endian)
    msg_int = int.from_bytes(hashed_message, 'little')

    try:
        for i in range(256):
            bit = (msg_int >> i) & 1
            if hashlib.sha256(signature[i]).digest() != public_keys[bit][i]:
                return False
        return True
    except Exception as e:
        print(f"Error during signature verification: {e}")
        return False


# Assuming 'signature' and 'pk' (public keys) are already defined
is_valid = verify_signature(raw_message, signature, public_key)

print(f"Message: {raw_message}")
print(f"Signature is valid: {is_valid}")

import hashlib
import secrets


def generate_lamport_keypair():
    private_key = [[secrets.token_bytes(32) for _ in range(256)] for _ in range(2)]
    public_key = [[hashlib.sha256(private_key[i][j]).digest() for j in range(256)] for i in range(2)]
    return private_key, public_key


def hash_public_key(public_key):
    # 直接返回公鑰的串聯，不進行額外的哈希
    return b''.join(b''.join(row) for row in public_key)


class MerkleTree:
    def __init__(self, leaves):
        self.leaves = leaves
        self.layers = [leaves]
        self.build_tree()

    def build_tree(self):
        layer = self.leaves
        while len(layer) > 1:
            next_layer = []
            for i in range(0, len(layer), 2):
                if i + 1 < len(layer):
                    next_layer.append(hashlib.sha256(layer[i] + layer[i + 1]).digest())
                else:
                    next_layer.append(layer[i])
            self.layers.append(next_layer)
            layer = next_layer
        self.root = layer[0]

    def get_proof(self, index):
        proof = []
        for layer in self.layers:
            if index % 2 == 0:
                if index + 1 < len(layer):
                    proof.append(('R', layer[index + 1]))
            else:
                proof.append(('L', layer[index - 1]))
            index //= 2
        return proof


# Generate Merkle tree
num_keypairs = 8
lamport_keypairs = [generate_lamport_keypair() for _ in range(num_keypairs)]
public_key_hashes = [hash_public_key(pk) for _, pk in lamport_keypairs]
merkle_tree = MerkleTree(public_key_hashes)

# Sign a message
message = "Hello, Merkle signature!"
keypair_index = 0  # Use the first keypair
private_key, public_key = lamport_keypairs[keypair_index]

merkle_proof = merkle_tree.get_proof(keypair_index)

import hashlib
import secrets


def hash_public_key(public_key):
    # 直接返回公鑰的串聯，不進行額外的哈希
    return b''.join(b''.join(row) for row in public_key)


class MerkleTree:
    def __init__(self, leaves):
        self.leaves = leaves
        self.layers = [leaves]
        self.build_tree()

    def build_tree(self):
        layer = self.leaves
        while len(layer) > 1:
            next_layer = []
            for i in range(0, len(layer), 2):
                if i + 1 < len(layer):
                    next_layer.append(hashlib.sha256(layer[i] + layer[i + 1]).digest())
                else:
                    next_layer.append(layer[i])
            self.layers.append(next_layer)
            layer = next_layer
        self.root = layer[0]

    def get_proof(self, index):
        proof = []
        for layer in self.layers:
            if index % 2 == 0:
                if index + 1 < len(layer):
                    proof.append(('R', layer[index + 1]))
            else:
                proof.append(('L', layer[index - 1]))
            index //= 2
        return proof


def verify_proof(leaf, proof, root):
    current = leaf
    for direction, sibling in proof:
        if direction == 'L':
            current = hashlib.sha256(sibling + current).digest()
        else:
            current = hashlib.sha256(current + sibling).digest()
    return current == root


# Verify the signature
leaf_hash = hash_public_key(public_key)
is_merkle_valid = verify_proof(leaf_hash, merkle_proof, merkle_tree.root)

print(f"Message: {message}")
print(f"Merkle proof valid: {is_merkle_valid}")

import hashlib
import secrets


def hash_function(data):
    return hashlib.sha256(data).digest()


def generate_winternitz_keypair(w):
    l = 256 // w  # 假設我們使用 256 位的雜湊函數
    private_key = [secrets.token_bytes(32) for _ in range(l)]
    public_key = [apply_hash(key, 2 ** w - 1) for key in private_key]
    return private_key, public_key


def apply_hash(data, times):
    for _ in range(times):
        data = hash_function(data)
    return data


def winternitz_sign(message, private_key, w):
    l = len(private_key)
    m = int.from_bytes(hash_function(message.encode()), 'big')
    signature = []
    for i in range(l):
        block = (m >> (w * (l - 1 - i))) & ((1 << w) - 1)
        signature.append(apply_hash(private_key[i], block))
    return signature


def winternitz_verify(message, signature, public_key, w):
    l = len(public_key)
    m = int.from_bytes(hash_function(message.encode()), 'big')
    for i in range(l):
        block = (m >> (w * (l - 1 - i))) & ((1 << w) - 1)
        if apply_hash(signature[i], 2 ** w - 1 - block) != public_key[i]:
            return False
    return True


# 使用 Winternitz 簽章
w = 8
private_key, public_key = generate_winternitz_keypair(w)
print(f"Private key: {private_key}")
print(f"Public key: {public_key}")
message = "Hello, Winternitz signature!"
signature = winternitz_sign(message, private_key, w)
print(f"Signature: {signature}")
is_valid = winternitz_verify(message, signature, public_key, w)
print(f"Signature valid: {is_valid}")