libbitcoinpqc 0.1.0

Post-Quantum Cryptographic signature algorithms for Bitcoin (BIP-360)
Documentation 
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "../../include/libbitcoinpqc/bitcoinpqc.h"

int main() {
    printf("Direct test of ML-DSA-44 algorithm\n");

    // Generate random data for keygen
    uint8_t random_data[128];
    FILE *f = fopen("/dev/urandom", "r");
    if (!f) {
        printf("Failed to open /dev/urandom\n");
        return 1;
    }
    fread(random_data, 1, sizeof(random_data), f);
    fclose(f);

    // Test message
    const char *message = "ML-DSA-44 Test Message";
    size_t message_len = strlen(message);

    printf("Test message: '%s' (length: %zu)\n", message, message_len);

    // Generate keys
    bitcoin_pqc_keypair_t keypair;
    bitcoin_pqc_error_t result;

    result = bitcoin_pqc_keygen(BITCOIN_PQC_ML_DSA_44, &keypair, random_data, sizeof(random_data));
    if (result != BITCOIN_PQC_OK) {
        printf("Key generation failed with error %d\n", result);
        return 1;
    }

    printf("Key generation successful\n");
    printf("Public key size: %zu bytes\n", keypair.public_key_size);
    printf("Secret key size: %zu bytes\n", keypair.secret_key_size);

    // Generate signature
    bitcoin_pqc_signature_t signature;

    printf("Signing message...\n");

    result = bitcoin_pqc_sign(
        BITCOIN_PQC_ML_DSA_44,
        keypair.secret_key,
        keypair.secret_key_size,
        (const uint8_t *)message,
        message_len,
        &signature,
        random_data,  // Reuse random data
        sizeof(random_data)
    );

    if (result != BITCOIN_PQC_OK) {
        printf("Signing failed with error %d\n", result);
        bitcoin_pqc_keypair_free(&keypair);
        return 1;
    }

    printf("Signing successful\n");
    printf("Signature size: %zu bytes\n", signature.signature_size);

    // Print first few bytes of signature
    printf("Signature prefix: ");
    for (size_t i = 0; i < (signature.signature_size < 16 ? signature.signature_size : 16); i++) {
        printf("%02x ", signature.signature[i]);
    }
    printf("...\n");

    // Verify signature
    printf("Verifying signature...\n");

    result = bitcoin_pqc_verify(
        BITCOIN_PQC_ML_DSA_44,
        keypair.public_key,
        keypair.public_key_size,
        (const uint8_t *)message,
        message_len,
        signature.signature,
        signature.signature_size
    );

    if (result != BITCOIN_PQC_OK) {
        printf("Verification failed with error %d\n", result);
        bitcoin_pqc_signature_free(&signature);
        bitcoin_pqc_keypair_free(&keypair);
        return 1;
    }

    printf("Verification successful\n");

    // Try verification with modified message
    const char *modified_message = "ML-DSA-44 Modified Message";
    size_t modified_message_len = strlen(modified_message);

    printf("Verifying with modified message: '%s'\n", modified_message);

    result = bitcoin_pqc_verify(
        BITCOIN_PQC_ML_DSA_44,
        keypair.public_key,
        keypair.public_key_size,
        (const uint8_t *)modified_message,
        modified_message_len,
        signature.signature,
        signature.signature_size
    );

    if (result == BITCOIN_PQC_OK) {
        printf("Verification succeeded with modified message - THIS IS AN ERROR!\n");
        bitcoin_pqc_signature_free(&signature);
        bitcoin_pqc_keypair_free(&keypair);
        return 1;
    }

    printf("Verification correctly failed with modified message\n");

    // Clean up
    bitcoin_pqc_signature_free(&signature);
    bitcoin_pqc_keypair_free(&keypair);

    printf("ML-DSA-44 direct test completed successfully\n");
    return 0;
}