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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*
* Copyright (c) 2024 Vaughn Nugent
*
* Library: noscrypt
* Package: noscrypt
* File: test.c
*
* noscrypt is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 2 of the License,
* or (at your option) any later version.
*
* noscrypt is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with noscrypt. If not, see http://www.gnu.org/licenses/.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "../src/noscrypt.h"
#include "../include/mbedtls/sha256.h"
#if defined(_MSC_VER) || defined(WIN32) || defined(_WIN32)
#define IS_WINDOWS
#endif
#ifdef IS_WINDOWS
#include <windows.h>
#include <wincrypt.h>
//Prints a string literal to the console
#define PRINTL(x) printf(x); printf("\r\n");
#define TEST(x) printf("Testing %s\n", #x); if(!(x)) { printf("Test failed!\n"); return 1; } else { printf("Test passed\n\n"); }
#define TASSERT(x) if(!(x)) { printf("ERROR! Internal test assumption failed: %s.\n Aborting tests...\n", #x); ExitProcess(1); }
#else
#include <stdlib.h>
//Prints a string literal to the console
#define PRINTL(x) printf(x); printf("\n");
#define TEST(x) printf("Testing %s\n", #x); if(!(x)) { printf("Test failed!\n"); return 1; } else { printf("Test passed\n\n"); }
#define TASSERT(x) if(!(x)) { printf("Internal assumption failed: %s\n", #x); exit(1); }
#endif
static void FillRandomData(uint8_t* pbBuffer, size_t length);
static int TestEcdsa(NCContext* context);
int main(char* argv[], int argc)
{
NCContext ctx;
uint8_t ctxRandom[32];
PRINTL("Begining basic noscrypt tests\n")
FillRandomData(ctxRandom, 32);
//Context struct size should aways match the size of the struct returned by NCGetContextStructSize
TEST(NCGetContextStructSize() == sizeof(NCContext))
TEST(NCInitContext(&ctx, ctxRandom) == NC_SUCCESS)
if (TestEcdsa(&ctx) != 0)
{
return 1;
}
PRINTL("ECDSA tests passed\n")
TEST(NCDestroyContext(&ctx) == NC_SUCCESS)
return 0;
}
static void _sha256(const uint8_t* data, size_t length, uint8_t digest[32])
{
mbedtls_sha256_context sha256;
mbedtls_sha256_init(&sha256);
TASSERT(0 == mbedtls_sha256_starts(&sha256, 0))
TASSERT(0 == mbedtls_sha256_update(&sha256, data, length))
TASSERT(0 == mbedtls_sha256_finish(&sha256, digest))
mbedtls_sha256_free(&sha256);
}
static const char* message = "Test message to sign";
static int TestEcdsa(NCContext* context)
{
uint8_t digestToSign[32];
uint8_t secretKey[NC_SEC_KEY_SIZE];
uint8_t publicKey[NC_PUBKEY_SIZE];
uint8_t sigEntropy[32];
uint8_t invalidSig[64];
NCSecretKey* secKey;
NCPublicKey* pubKey;
PRINTL("Begining basic Nostr ECDSA tests")
//Convert to internal key structs
secKey = NCToSecKey(secretKey);
pubKey = NCToPubKey(publicKey);
TEST((&secKey->key) == &secretKey);
//Init a new secret key with random data
FillRandomData(secretKey, sizeof(secretKey));
FillRandomData(invalidSig, sizeof(invalidSig));
FillRandomData(sigEntropy, sizeof(sigEntropy));
//Verify that the secret key is valid for the curve
TEST(NCValidateSecretKey(context, secKey) == NC_SUCCESS);
//Generate a public key from the secret key
TEST(NCGetPublicKey(context, secKey, pubKey) == NC_SUCCESS);
//Sign and verify digest
{
uint8_t sig[64];
//compute sha256 of the test string
_sha256((uint8_t*)message, strlen(message), digestToSign);
TEST(NCSignDigest(context, secKey, sigEntropy, digestToSign, sig) == NC_SUCCESS);
TEST(NCVerifyDigest(context, pubKey, digestToSign, sig) == NC_SUCCESS);
}
//Sign and verify raw data
{
uint8_t sig[64];
TEST(NCSignData(context, secKey, sigEntropy, (uint8_t*)message, strlen(message), sig) == NC_SUCCESS);
TEST(NCVerifyData(context, pubKey, (uint8_t*)message, strlen(message), sig) == NC_SUCCESS);
}
//test verification of invalid signature
{
TEST(NCVerifyDigest(context, pubKey, digestToSign, invalidSig) == E_INVALID_ARG);
}
return 0;
}
static const char* encMessage = "Test message to encrypt";
static int TestEcdh(NCContext* ctx)
{
PRINTL("Begining basic Nostr Encryption tests")
}
static void FillRandomData(uint8_t* pbBuffer, size_t length)
{
#ifdef IS_WINDOWS
HCRYPTPROV hCryptProv;
TASSERT(CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0));
TASSERT(CryptGenRandom(hCryptProv, (DWORD)length, pbBuffer))
TASSERT(CryptReleaseContext(hCryptProv, 0));
#else
FILE* f = fopen("/dev/urandom", "rb");
TASSERT(f != NULL);
TASSERT(fread(pbBuffer, 1, length, f) == length);
fclose(f);
#endif
}
|
