diff options
Diffstat (limited to 'src/util')
-rw-r--r-- | src/util/Makefile.am | 9 | ||||
-rw-r--r-- | src/util/crypto-test-vectors.json | 56 | ||||
-rw-r--r-- | src/util/crypto_rsa.c | 4 | ||||
-rw-r--r-- | src/util/gnunet-crypto-tvg.c | 874 | ||||
-rw-r--r-- | src/util/perf_crypto_rsa.c | 14 | ||||
-rwxr-xr-x | src/util/test_crypto_vectors.sh | 3 |
6 files changed, 874 insertions, 86 deletions
diff --git a/src/util/Makefile.am b/src/util/Makefile.am index c5059bbb1..d2e4b4d1a 100644 --- a/src/util/Makefile.am +++ b/src/util/Makefile.am | |||
@@ -138,7 +138,7 @@ libgnunetutil_la_LIBADD = \ | |||
138 | 138 | ||
139 | libgnunetutil_la_LDFLAGS = \ | 139 | libgnunetutil_la_LDFLAGS = \ |
140 | $(GN_LIB_LDFLAGS) \ | 140 | $(GN_LIB_LDFLAGS) \ |
141 | -version-info 13:2:0 | 141 | -version-info 13:2:1 |
142 | 142 | ||
143 | if HAVE_TESTING | 143 | if HAVE_TESTING |
144 | GNUNET_ECC = gnunet-ecc | 144 | GNUNET_ECC = gnunet-ecc |
@@ -169,7 +169,7 @@ noinst_PROGRAMS = \ | |||
169 | 169 | ||
170 | if ENABLE_TEST_RUN | 170 | if ENABLE_TEST_RUN |
171 | AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME; | 171 | AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME; |
172 | TESTS = $(check_PROGRAMS) | 172 | TESTS = $(check_PROGRAMS) $(check_SCRIPTS) |
173 | endif | 173 | endif |
174 | 174 | ||
175 | gnunet_timeout_SOURCES = \ | 175 | gnunet_timeout_SOURCES = \ |
@@ -195,7 +195,7 @@ gnunet_crypto_tvg_SOURCES = \ | |||
195 | gnunet-crypto-tvg.c | 195 | gnunet-crypto-tvg.c |
196 | gnunet_crypto_tvg_LDADD = \ | 196 | gnunet_crypto_tvg_LDADD = \ |
197 | libgnunetutil.la \ | 197 | libgnunetutil.la \ |
198 | $(GN_LIBINTL) -lgcrypt | 198 | $(GN_LIBINTL) -lgcrypt -ljansson |
199 | 199 | ||
200 | gnunet_ecc_SOURCES = \ | 200 | gnunet_ecc_SOURCES = \ |
201 | gnunet-ecc.c | 201 | gnunet-ecc.c |
@@ -255,6 +255,9 @@ if HAVE_SSH_KEY | |||
255 | # SSH_USING_TESTS = test_socks.nc | 255 | # SSH_USING_TESTS = test_socks.nc |
256 | endif | 256 | endif |
257 | 257 | ||
258 | check_SCRIPTS = \ | ||
259 | test_crypto_vectors.sh | ||
260 | |||
258 | check_PROGRAMS = \ | 261 | check_PROGRAMS = \ |
259 | test_bio \ | 262 | test_bio \ |
260 | test_client.nc \ | 263 | test_client.nc \ |
diff --git a/src/util/crypto-test-vectors.json b/src/util/crypto-test-vectors.json new file mode 100644 index 000000000..972b62c3e --- /dev/null +++ b/src/util/crypto-test-vectors.json | |||
@@ -0,0 +1,56 @@ | |||
1 | { | ||
2 | "encoding": "base32crockford", | ||
3 | "producer": "GNUnet 0.14.0 git-64ad3b0a1", | ||
4 | "vectors": [ | ||
5 | { | ||
6 | "operation": "hash", | ||
7 | "input": "91JPRV3F5GG4EKJNDSJQ8", | ||
8 | "output": "D0R24RZ1TPASVQ2NY56CT8AJDYZE9ZGDB0GVZ05E9D4YGZQW2RC5YFPQ0Q86EPW836DY7VYQTNFFJT3ZR2K508F4JVS5JNJKYN2MMFR" | ||
9 | }, | ||
10 | { | ||
11 | "operation": "ecc_ecdh", | ||
12 | "priv1": "TFA439C75RT2JK9V6GTRRXH3QR3QC4SVJ1KBQ4MNY3S338GT6T50", | ||
13 | "pub1": "E19WJDA83485BC8EC8RV7FTAK86BESJG1YNYRENEC0JV7XEZ7M80", | ||
14 | "priv2": "2DT3B0TMY6VVP56YZKG5ASRSQAEV0GB4QMT9N6CTPDARNJ905APG", | ||
15 | "skm": "GY63DCHR6BGV2AKDM44V7A4H4DA0WJC7D5C2R7DXTWC9D83H7XM0PEQKKZ1K2HWMWBSBNPDWXDN7PA1R1WJKVQ2RDTNF1PBXCFHM9QR" | ||
16 | }, | ||
17 | { | ||
18 | "operation": "eddsa_key_derivation", | ||
19 | "priv": "8QC2VNF8443S5KPNKMB4XMV58BTHWAKZ7SVW5WG3KRB37567XS90", | ||
20 | "pub": "3M9KK1WSNM1RTY5P72HKFA264V4B7MVHVJ08Y90CV06DYHV8XPP0" | ||
21 | }, | ||
22 | { | ||
23 | "operation": "eddsa_signing", | ||
24 | "priv": "5077XJR9AMH4T97ACKFBVBJD0KFENHPV66B2Y1JBSKXBJKNZJ4E0", | ||
25 | "pub": "6E2F03JJ8AEDANTTZZ4SBZDFEEZSF8A9DVGTS6VFBCVZQYQ46RRG", | ||
26 | "data": "00000300000000000000", | ||
27 | "sig": "XCNJGJ96WPDH60YVMH6C74NGQSGJE3BC1TYMGX6BHY5DMZZZKTB373QTXJ507K5EBSG9YS2EYKHCX3ATRQ6P5MY9MXC4ZB1XSZ2X23G" | ||
28 | }, | ||
29 | { | ||
30 | "operation": "kdf", | ||
31 | "salt": "94KPT83PCNS7J83KC5P78Y8", | ||
32 | "ikm": "94KPT83MD1JJ0WV5CDS6AX10D5Q70XBM41NPAY90DNGQ8SBJD5GPR", | ||
33 | "ctx": "94KPT83141HPYVKMCNW78833D1TPWTSC41GPRWVF41NPWVVQDRG62WS04XMPWSKF4WG6JVH0EHM6A82J8S1G", | ||
34 | "out_len %u\n": 64, | ||
35 | "out": "GTMR4QT05Z9WF5HKVG0WK9RPXGHSMHJNW377G9GJXCA8B0FEKPF4D27RJMSJZYWSQNTBJ5EYVV7ZW18B48Z0JVJJ80RHB706Y96Q358" | ||
36 | }, | ||
37 | { | ||
38 | "operation": "eddsa_ecdh", | ||
39 | "priv_ecdhe": "5FBRFZY942H2PD96NFNYWZKYXCRFY11JWQ59V7G9B4M8EX1KE100", | ||
40 | "pub_ecdhe": "GDX7FC01AZYMG0BY0AMHR6E7KCGX9F6SWES16WZ1QWZ2VSYXKH00", | ||
41 | "priv_eddsa": "3HYHM9DZQ3D61APDQNBCSKJE452YEP6JK01DWR1J3VZAASFEA570", | ||
42 | "pub_eddsa": "87N7PFAHBX97HRE8XYW8KYN64YZDF4FCBR2BZ5SZN3QE3D2BF0R0", | ||
43 | "key_material": "QH0RAXXC9RYDEAXKNTAWM0WXJS25RS67H5T252EGA22RA6JTYRFDAEK8CJY85QSYWGYHQXK5Y1SWSRB3P0NXNXYP237EXMXQ3P2WE00" | ||
44 | }, | ||
45 | { | ||
46 | "operation": "rsa_blind_signing", | ||
47 | "message_hash": "XKQMJ4CNTXBFE1V2WR6JS063J7PZQE4XMB5JH3RS5X0THQ1JQSQ69Y7KDBC9TYRJEZH48MEPY2SF4QHQ4VHXC0YQX5935MQEGP0AX6R", | ||
48 | "rsa_public_key": "040000YRN1NVJ68RS6RJF52PGRCQG19ZKWQPSTJX2G7ZDCKSZFE2VW3HHA81YF5C639JHJF5TX8YTEE2FW2WQCG1PTKNBSPPJEJGA032CN3E8QZ27VWY0K6JFT8ZSYWRH2SKDMXW56A4QKY46JJBWJ6T0ZRVBW6S1HTHXVE2RW8MXRW5T801077MDY13N5F8Z1JZVKBJ06TK3S0YPEDBXK0VEHRHEQJ5X5XYKR4KQTFAZNBMKXY8836VCHBXTK4YNX6AJ1CK29SMJH3Z3QRM16A2TNQGFR0HSMV446BF7FMT2E379ZAT5ST4G3BM2NWZYW545S2SW5MG5S6M88XZZ7SKFD48YVXNZ205GGSEYJPVBMR76WG4ZG30WBCPC1N54XE12RMAG81D8C09WG22PKGGDHYXX68N04002", | ||
49 | "rsa_private_key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| ||
50 | "blinding_key_secret": "3SWF49XZPHQMENTSBZQR7Z0B8ZSZ2JRARE79Q4VXZMQ7W6QABXMG", | ||
51 | "blinded_message": "3KHKZJZ30ABB4E56MA2V0EQWGCWH0QQG9P2ZHYHR186C5HZXJMM4N9WXAQTKS94QSV9Y17GGNXN5MB1PZZFG7Q0FY88QPKKRG4MYCPSMTZK5W59R0MJVNJ4P4AQM96TDG5W7RV8GSNR1QQZ1GNHW3CX6D6ZRTMXB2NKB5SSYTDJS79F5ZFBRZ4HVED9JBBPWSR79KVV5QQ4APBGHBCKGMF9NJJS53A1BVYHDEVYAGFYF2SNEP827ZP50FKJ5GKGV8NQ15ESEZ69AT7GJG0T3TZVENY2YN9CVR98W3BKEZ53J7VTANARG8SJS8AMJQ7S23P5HRJ7XE9KTNRNXKH49MXV9JHHYE5535N7AGWEKR47SBCGNF44Z7XJ9RV5BQV12ZRJKN4HBZQHDNCMH3QKX9Z6G64", | ||
52 | "blinded_sig": "ND1V807BK0G73SDXN582BP3Q21MWF4A76EGWD0KA3XGJAWPSVHNHKA44931ZRB9M76SYAFD8ZPTG3A7FH5G2CWGX76VXTCDX5XNRW7EEBNMPDAQ0ZEKF6AHP872SKCGRH89SK4NGC57M8BRA3ZRPDDT9XCBG3XY02VQH4Z0F39DPBS48K0EBMK7B9S3X6QDNR5ND5MV0G7G7T3VPKZRW94MQBKPY1T6K53MQGG4PV81D9YEWNRM3WE04NNQREYDA5ETVDWQ5ZCYV9HF4ZCMWVVGWDBDH732JA3NKZ2B8QK0E6XS0Y4GGGQJS6HFQ4PATGK3TS5GHJEPDF3A6XAFNJQV99CSJW7V1NC504NTQ5NJ8KAVC1758MBBV3SS2BND4YHF0Y4NWJNVH3STV166YWFKR8W", | ||
53 | "sig": "EC5MVSPGQMM96N2VT4R2G5104E61V8RY4PR6AK9F614TVVEN7D152T0DP97CDTRDDSQGBV4GZWXQPM90SW30R2RAKKHNDCXHQFAMRSW1XCBEKVKBGC6FP0AQY9S37NVR01VJ2WVX8PN29H2ZFFQBQ9JK96GTJZ3B7DD583S8Y93GH5KWEM41CZJ73QCRT1A2AGVXX5ACFR0T448MC81QB4EGCKP5Z96VCX6RPDD5S9A4295M0E9PPQJCN5G5JKWKG17HWEDF4A26ZMD8YW27EQBZ69GSEZX4PWEV7AXFGG5X0RPKCQEPCX7XDY6NXJ1E2FZBX259RDRCFNDAZS80T0DHD9NVE73QDDESZYEZTM1TM669GHPN8AF4QV8DNW7SFZZKJ67FWR8CZC0PWTEN4ZPTRM" | ||
54 | } | ||
55 | ] | ||
56 | } | ||
diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c index d5eca6225..fec4d13db 100644 --- a/src/util/crypto_rsa.c +++ b/src/util/crypto_rsa.c | |||
@@ -262,8 +262,8 @@ GNUNET_CRYPTO_rsa_private_key_decode (const void *buf, | |||
262 | * @return NULL on error, otherwise the public key | 262 | * @return NULL on error, otherwise the public key |
263 | */ | 263 | */ |
264 | struct GNUNET_CRYPTO_RsaPublicKey * | 264 | struct GNUNET_CRYPTO_RsaPublicKey * |
265 | GNUNET_CRYPTO_rsa_private_key_get_public (const struct | 265 | GNUNET_CRYPTO_rsa_private_key_get_public ( |
266 | GNUNET_CRYPTO_RsaPrivateKey *priv) | 266 | const struct GNUNET_CRYPTO_RsaPrivateKey *priv) |
267 | { | 267 | { |
268 | struct GNUNET_CRYPTO_RsaPublicKey *pub; | 268 | struct GNUNET_CRYPTO_RsaPublicKey *pub; |
269 | gcry_mpi_t ne[2]; | 269 | gcry_mpi_t ne[2]; |
diff --git a/src/util/gnunet-crypto-tvg.c b/src/util/gnunet-crypto-tvg.c index c3fead62e..8949f427c 100644 --- a/src/util/gnunet-crypto-tvg.c +++ b/src/util/gnunet-crypto-tvg.c | |||
@@ -22,11 +22,36 @@ | |||
22 | * @file util/gnunet-crypto-tgv.c | 22 | * @file util/gnunet-crypto-tgv.c |
23 | * @brief Generate test vectors for cryptographic operations. | 23 | * @brief Generate test vectors for cryptographic operations. |
24 | * @author Florian Dold | 24 | * @author Florian Dold |
25 | * | ||
26 | * Note that this program shouldn't depend on code in src/json/, | ||
27 | * so we're using raw jansson and no GNUnet JSON helpers. | ||
28 | * | ||
29 | * Test vectors have the following format (TypeScript pseudo code): | ||
30 | * | ||
31 | * interface TestVectorFile { | ||
32 | * encoding: "base32crockford"; | ||
33 | * producer?: string; | ||
34 | * vectors: TestVector[]; | ||
35 | * } | ||
36 | * | ||
37 | * enum Operation { | ||
38 | * Hash("hash"), | ||
39 | * ... | ||
40 | * } | ||
41 | * | ||
42 | * interface TestVector { | ||
43 | * operation: Operation; | ||
44 | * // Inputs for the operation | ||
45 | * [ k: string]: string | number; | ||
46 | * }; | ||
47 | * | ||
48 | * | ||
25 | */ | 49 | */ |
26 | #include "platform.h" | 50 | #include "platform.h" |
27 | #include "gnunet_util_lib.h" | 51 | #include "gnunet_util_lib.h" |
28 | #include "gnunet_signatures.h" | 52 | #include "gnunet_signatures.h" |
29 | #include "gnunet_testing_lib.h" | 53 | #include "gnunet_testing_lib.h" |
54 | #include <jansson.h> | ||
30 | #include <gcrypt.h> | 55 | #include <gcrypt.h> |
31 | 56 | ||
32 | GNUNET_NETWORK_STRUCT_BEGIN | 57 | GNUNET_NETWORK_STRUCT_BEGIN |
@@ -46,46 +71,660 @@ GNUNET_NETWORK_STRUCT_END | |||
46 | 71 | ||
47 | 72 | ||
48 | /** | 73 | /** |
49 | * Print data base32-crockford with a preceding label. | 74 | * Should we verify or output test vectors? |
75 | */ | ||
76 | static int verify_flag = GNUNET_NO; | ||
77 | |||
78 | |||
79 | /** | ||
80 | * Global exit code. | ||
81 | */ | ||
82 | static int global_ret = 0; | ||
83 | |||
84 | |||
85 | /** | ||
86 | * Create a fresh test vector for a given operation label. | ||
87 | * | ||
88 | * @param vecs array of vectors to append the new vector to | ||
89 | * @param vecname label for the operation of the vector | ||
90 | * @returns the fresh test vector | ||
91 | */ | ||
92 | static json_t * | ||
93 | vec_for (json_t *vecs, const char *vecname) | ||
94 | { | ||
95 | json_t *t = json_object (); | ||
96 | |||
97 | json_object_set_new (t, | ||
98 | "operation", | ||
99 | json_string (vecname)); | ||
100 | json_array_append_new (vecs, t); | ||
101 | return t; | ||
102 | } | ||
103 | |||
104 | |||
105 | /** | ||
106 | * Add a base32crockford encoded value | ||
107 | * to a test vector. | ||
50 | * | 108 | * |
51 | * @param label label to print | 109 | * @param vec test vector to add to |
52 | * @param data data to print | 110 | * @param label label for the value |
111 | * @param data data to add | ||
53 | * @param size size of data | 112 | * @param size size of data |
54 | */ | 113 | */ |
55 | static void | 114 | static void |
56 | display_data (char *label, void *data, size_t size) | 115 | d2j (json_t *vec, |
116 | const char *label, | ||
117 | const void *data, | ||
118 | size_t size) | ||
57 | { | 119 | { |
58 | char *enc = GNUNET_STRINGS_data_to_string_alloc (data, size); | 120 | char *buf; |
59 | printf ("%s %s\n", label, enc); | 121 | json_t *json; |
60 | GNUNET_free (enc); | ||
61 | } | ||
62 | 122 | ||
123 | buf = GNUNET_STRINGS_data_to_string_alloc (data, size); | ||
124 | json = json_string (buf); | ||
125 | GNUNET_free (buf); | ||
126 | GNUNET_break (NULL != json); | ||
127 | |||
128 | json_object_set_new (vec, label, json); | ||
129 | } | ||
63 | 130 | ||
64 | /** | 131 | /** |
65 | * Main function that will be run. | 132 | * Add a number to a test vector. |
66 | * | 133 | * |
67 | * @param cls closure | 134 | * @param vec test vector to add to |
68 | * @param args remaining command-line arguments | 135 | * @param label label for the value |
69 | * @param cfgfile name of the configuration file used (for saving, can be NULL!) | 136 | * @param data data to add |
70 | * @param cfg configuration | 137 | * @param size size of data |
71 | */ | 138 | */ |
72 | static void | 139 | static void |
73 | run (void *cls, | 140 | uint2j (json_t *vec, |
74 | char *const *args, | 141 | const char *label, |
75 | const char *cfgfile, | 142 | unsigned int num) |
76 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 143 | { |
144 | json_t *json = json_integer (num); | ||
145 | |||
146 | json_object_set_new (vec, label, json); | ||
147 | } | ||
148 | |||
149 | |||
150 | static int | ||
151 | expect_data_fixed (json_t *vec, | ||
152 | const char *name, | ||
153 | void *data, | ||
154 | size_t expect_len) | ||
155 | { | ||
156 | const char *s = json_string_value (json_object_get (vec, name)); | ||
157 | |||
158 | if (NULL == s) | ||
159 | return GNUNET_NO; | ||
160 | |||
161 | if (GNUNET_OK != GNUNET_STRINGS_string_to_data (s, | ||
162 | strlen (s), | ||
163 | data, | ||
164 | expect_len)) | ||
165 | return GNUNET_NO; | ||
166 | return GNUNET_OK; | ||
167 | } | ||
168 | |||
169 | static int | ||
170 | expect_data_dynamic (json_t *vec, | ||
171 | const char *name, | ||
172 | void **data, | ||
173 | size_t *ret_len) | ||
174 | { | ||
175 | const char *s = json_string_value (json_object_get (vec, name)); | ||
176 | size_t len; | ||
177 | |||
178 | if (NULL == s) | ||
179 | return GNUNET_NO; | ||
180 | |||
181 | len = (strlen (s) * 5) / 8; | ||
182 | if (NULL != ret_len) | ||
183 | *ret_len = len; | ||
184 | *data = GNUNET_malloc (len); | ||
185 | |||
186 | if (GNUNET_OK != GNUNET_STRINGS_string_to_data (s, strlen (s), *data, len)) | ||
187 | return GNUNET_NO; | ||
188 | return GNUNET_OK; | ||
189 | } | ||
190 | |||
191 | |||
192 | /** | ||
193 | * Check a single vector. | ||
194 | * | ||
195 | * @param operation operator of the vector | ||
196 | * @param vec the vector, a JSON object. | ||
197 | * | ||
198 | * @returns GNUNET_OK if the vector is okay | ||
199 | */ | ||
200 | static int | ||
201 | checkvec (const char *operation, | ||
202 | json_t *vec) | ||
203 | { | ||
204 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
205 | "checking %s\n", operation); | ||
206 | |||
207 | if (0 == strcmp (operation, "hash")) | ||
208 | { | ||
209 | void *data; | ||
210 | size_t data_len; | ||
211 | struct GNUNET_HashCode hash_out; | ||
212 | struct GNUNET_HashCode hc; | ||
213 | |||
214 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
215 | "input", | ||
216 | &data, | ||
217 | &data_len)) | ||
218 | { | ||
219 | GNUNET_break (0); | ||
220 | return GNUNET_SYSERR; | ||
221 | } | ||
222 | if (GNUNET_OK != expect_data_fixed (vec, | ||
223 | "output", | ||
224 | &hash_out, | ||
225 | sizeof (hash_out))) | ||
226 | { | ||
227 | GNUNET_break (0); | ||
228 | return GNUNET_NO; | ||
229 | } | ||
230 | |||
231 | GNUNET_CRYPTO_hash (data, data_len, &hc); | ||
232 | |||
233 | if (0 != GNUNET_memcmp (&hc, &hash_out)) | ||
234 | { | ||
235 | GNUNET_break (0); | ||
236 | return GNUNET_NO; | ||
237 | } | ||
238 | } | ||
239 | else if (0 == strcmp (operation, "ecc_ecdh")) | ||
240 | { | ||
241 | struct GNUNET_CRYPTO_EcdhePrivateKey priv1; | ||
242 | struct GNUNET_CRYPTO_EcdhePublicKey pub1; | ||
243 | struct GNUNET_CRYPTO_EcdhePrivateKey priv2; | ||
244 | struct GNUNET_HashCode skm; | ||
245 | struct GNUNET_HashCode skm_comp; | ||
246 | |||
247 | if (GNUNET_OK != expect_data_fixed (vec, | ||
248 | "priv1", | ||
249 | &priv1, | ||
250 | sizeof (priv1))) | ||
251 | { | ||
252 | GNUNET_break (0); | ||
253 | return GNUNET_NO; | ||
254 | } | ||
255 | if (GNUNET_OK != expect_data_fixed (vec, | ||
256 | "priv2", | ||
257 | &priv2, | ||
258 | sizeof (priv2))) | ||
259 | { | ||
260 | GNUNET_break (0); | ||
261 | return GNUNET_NO; | ||
262 | } | ||
263 | if (GNUNET_OK != expect_data_fixed (vec, | ||
264 | "pub1", | ||
265 | &pub1, | ||
266 | sizeof (pub1))) | ||
267 | { | ||
268 | GNUNET_break (0); | ||
269 | return GNUNET_NO; | ||
270 | } | ||
271 | if (GNUNET_OK != expect_data_fixed (vec, | ||
272 | "skm", | ||
273 | &skm, | ||
274 | sizeof (skm))) | ||
275 | { | ||
276 | GNUNET_break (0); | ||
277 | return GNUNET_NO; | ||
278 | } | ||
279 | GNUNET_assert (GNUNET_OK == | ||
280 | GNUNET_CRYPTO_ecc_ecdh (&priv2, | ||
281 | &pub1, | ||
282 | &skm_comp)); | ||
283 | if (0 != GNUNET_memcmp (&skm, &skm_comp)) | ||
284 | { | ||
285 | GNUNET_break (0); | ||
286 | return GNUNET_NO; | ||
287 | } | ||
288 | } | ||
289 | else if (0 == strcmp (operation, "eddsa_key_derivation")) | ||
290 | { | ||
291 | struct GNUNET_CRYPTO_EddsaPrivateKey priv; | ||
292 | struct GNUNET_CRYPTO_EddsaPublicKey pub; | ||
293 | struct GNUNET_CRYPTO_EddsaPublicKey pub_comp; | ||
294 | |||
295 | if (GNUNET_OK != expect_data_fixed (vec, | ||
296 | "priv", | ||
297 | &priv, | ||
298 | sizeof (priv))) | ||
299 | { | ||
300 | GNUNET_break (0); | ||
301 | return GNUNET_NO; | ||
302 | } | ||
303 | |||
304 | if (GNUNET_OK != expect_data_fixed (vec, | ||
305 | "pub", | ||
306 | &pub, | ||
307 | sizeof (pub))) | ||
308 | { | ||
309 | GNUNET_break (0); | ||
310 | return GNUNET_NO; | ||
311 | } | ||
312 | |||
313 | GNUNET_CRYPTO_eddsa_key_get_public (&priv, | ||
314 | &pub_comp); | ||
315 | if (0 != GNUNET_memcmp (&pub, &pub_comp)) | ||
316 | { | ||
317 | GNUNET_break (0); | ||
318 | return GNUNET_NO; | ||
319 | } | ||
320 | |||
321 | } | ||
322 | else if (0 == strcmp (operation, "eddsa_signing")) | ||
323 | { | ||
324 | struct GNUNET_CRYPTO_EddsaPrivateKey priv; | ||
325 | struct GNUNET_CRYPTO_EddsaPublicKey pub; | ||
326 | struct TestSignatureDataPS data = { 0 }; | ||
327 | struct GNUNET_CRYPTO_EddsaSignature sig; | ||
328 | struct GNUNET_CRYPTO_EddsaSignature sig_comp; | ||
329 | |||
330 | if (GNUNET_OK != expect_data_fixed (vec, | ||
331 | "priv", | ||
332 | &priv, | ||
333 | sizeof (priv))) | ||
334 | { | ||
335 | GNUNET_break (0); | ||
336 | return GNUNET_NO; | ||
337 | } | ||
338 | |||
339 | if (GNUNET_OK != expect_data_fixed (vec, | ||
340 | "pub", | ||
341 | &pub, | ||
342 | sizeof (pub))) | ||
343 | { | ||
344 | GNUNET_break (0); | ||
345 | return GNUNET_NO; | ||
346 | } | ||
347 | |||
348 | if (GNUNET_OK != expect_data_fixed (vec, | ||
349 | "data", | ||
350 | &data, | ||
351 | sizeof (data))) | ||
352 | { | ||
353 | GNUNET_break (0); | ||
354 | return GNUNET_NO; | ||
355 | } | ||
356 | |||
357 | if (GNUNET_OK != expect_data_fixed (vec, | ||
358 | "sig", | ||
359 | &sig, | ||
360 | sizeof (sig))) | ||
361 | { | ||
362 | GNUNET_break (0); | ||
363 | return GNUNET_NO; | ||
364 | } | ||
365 | |||
366 | GNUNET_CRYPTO_eddsa_sign (&priv, | ||
367 | &data, | ||
368 | &sig_comp); | ||
369 | GNUNET_assert (GNUNET_OK == | ||
370 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, | ||
371 | &data, | ||
372 | &sig, | ||
373 | &pub)); | ||
374 | if (0 != GNUNET_memcmp (&sig, &sig_comp)) | ||
375 | { | ||
376 | GNUNET_break (0); | ||
377 | return GNUNET_NO; | ||
378 | } | ||
379 | } | ||
380 | else if (0 == strcmp (operation, "kdf")) | ||
381 | { | ||
382 | size_t out_len; | ||
383 | void *out; | ||
384 | size_t out_len_comp; | ||
385 | void *out_comp; | ||
386 | void *ikm; | ||
387 | size_t ikm_len; | ||
388 | void *salt; | ||
389 | size_t salt_len; | ||
390 | void *ctx; | ||
391 | size_t ctx_len; | ||
392 | |||
393 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
394 | "out", | ||
395 | &out, | ||
396 | &out_len)) | ||
397 | { | ||
398 | GNUNET_break (0); | ||
399 | return GNUNET_SYSERR; | ||
400 | } | ||
401 | |||
402 | out_len_comp = out_len; | ||
403 | out_comp = GNUNET_malloc (out_len_comp); | ||
404 | |||
405 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
406 | "ikm", | ||
407 | &ikm, | ||
408 | &ikm_len)) | ||
409 | { | ||
410 | GNUNET_break (0); | ||
411 | return GNUNET_SYSERR; | ||
412 | } | ||
413 | |||
414 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
415 | "salt", | ||
416 | &salt, | ||
417 | &salt_len)) | ||
418 | { | ||
419 | GNUNET_break (0); | ||
420 | return GNUNET_SYSERR; | ||
421 | } | ||
422 | |||
423 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
424 | "ctx", | ||
425 | &ctx, | ||
426 | &ctx_len)) | ||
427 | { | ||
428 | GNUNET_break (0); | ||
429 | return GNUNET_SYSERR; | ||
430 | } | ||
431 | |||
432 | GNUNET_assert (GNUNET_OK == | ||
433 | GNUNET_CRYPTO_kdf (out_comp, | ||
434 | out_len_comp, | ||
435 | salt, | ||
436 | salt_len, | ||
437 | ikm, | ||
438 | ikm_len, | ||
439 | ctx, | ||
440 | ctx_len, | ||
441 | NULL)); | ||
442 | |||
443 | if (0 != memcmp (out, out_comp, out_len)) | ||
444 | { | ||
445 | GNUNET_break (0); | ||
446 | return GNUNET_NO; | ||
447 | } | ||
448 | |||
449 | } | ||
450 | else if (0 == strcmp (operation, "eddsa_ecdh")) | ||
451 | { | ||
452 | struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe; | ||
453 | struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe; | ||
454 | struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa; | ||
455 | struct GNUNET_CRYPTO_EddsaPublicKey pub_eddsa; | ||
456 | struct GNUNET_HashCode key_material; | ||
457 | struct GNUNET_HashCode key_material_comp; | ||
458 | |||
459 | if (GNUNET_OK != expect_data_fixed (vec, | ||
460 | "priv_ecdhe", | ||
461 | &priv_ecdhe, | ||
462 | sizeof (priv_ecdhe))) | ||
463 | { | ||
464 | GNUNET_break (0); | ||
465 | return GNUNET_NO; | ||
466 | } | ||
467 | |||
468 | if (GNUNET_OK != expect_data_fixed (vec, | ||
469 | "pub_ecdhe", | ||
470 | &pub_ecdhe, | ||
471 | sizeof (pub_ecdhe))) | ||
472 | { | ||
473 | GNUNET_break (0); | ||
474 | return GNUNET_NO; | ||
475 | } | ||
476 | |||
477 | if (GNUNET_OK != expect_data_fixed (vec, | ||
478 | "priv_eddsa", | ||
479 | &priv_eddsa, | ||
480 | sizeof (priv_eddsa))) | ||
481 | { | ||
482 | GNUNET_break (0); | ||
483 | return GNUNET_NO; | ||
484 | } | ||
485 | |||
486 | if (GNUNET_OK != expect_data_fixed (vec, | ||
487 | "pub_eddsa", | ||
488 | &pub_eddsa, | ||
489 | sizeof (pub_eddsa))) | ||
490 | { | ||
491 | GNUNET_break (0); | ||
492 | return GNUNET_NO; | ||
493 | } | ||
494 | |||
495 | if (GNUNET_OK != expect_data_fixed (vec, | ||
496 | "key_material", | ||
497 | &key_material, | ||
498 | sizeof (key_material))) | ||
499 | { | ||
500 | GNUNET_break (0); | ||
501 | return GNUNET_NO; | ||
502 | } | ||
503 | |||
504 | GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material_comp); | ||
505 | |||
506 | if (0 != GNUNET_memcmp (&key_material, &key_material_comp)) | ||
507 | { | ||
508 | GNUNET_break (0); | ||
509 | return GNUNET_NO; | ||
510 | } | ||
511 | } | ||
512 | else if (0 == strcmp (operation, "rsa_blind_signing")) | ||
513 | { | ||
514 | struct GNUNET_CRYPTO_RsaPrivateKey *skey; | ||
515 | struct GNUNET_CRYPTO_RsaPublicKey *pkey; | ||
516 | struct GNUNET_HashCode message_hash; | ||
517 | struct GNUNET_CRYPTO_RsaBlindingKeySecret bks; | ||
518 | struct GNUNET_CRYPTO_RsaSignature *blinded_sig; | ||
519 | struct GNUNET_CRYPTO_RsaSignature *sig; | ||
520 | void *blinded_data; | ||
521 | size_t blinded_len; | ||
522 | void *blinded_data_comp; | ||
523 | size_t blinded_len_comp; | ||
524 | void *public_enc_data; | ||
525 | size_t public_enc_len; | ||
526 | void *secret_enc_data; | ||
527 | size_t secret_enc_len; | ||
528 | void *sig_enc_data; | ||
529 | size_t sig_enc_length; | ||
530 | void *sig_enc_data_comp; | ||
531 | size_t sig_enc_length_comp; | ||
532 | |||
533 | if (GNUNET_OK != expect_data_fixed (vec, | ||
534 | "message_hash", | ||
535 | &message_hash, | ||
536 | sizeof (message_hash))) | ||
537 | { | ||
538 | GNUNET_break (0); | ||
539 | return GNUNET_SYSERR; | ||
540 | } | ||
541 | |||
542 | if (GNUNET_OK != expect_data_fixed (vec, | ||
543 | "blinding_key_secret", | ||
544 | &bks, | ||
545 | sizeof (bks))) | ||
546 | { | ||
547 | GNUNET_break (0); | ||
548 | return GNUNET_SYSERR; | ||
549 | } | ||
550 | |||
551 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
552 | "blinded_message", | ||
553 | &blinded_data, | ||
554 | &blinded_len)) | ||
555 | { | ||
556 | GNUNET_break (0); | ||
557 | return GNUNET_SYSERR; | ||
558 | } | ||
559 | |||
560 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
561 | "rsa_public_key", | ||
562 | &public_enc_data, | ||
563 | &public_enc_len)) | ||
564 | { | ||
565 | GNUNET_break (0); | ||
566 | return GNUNET_SYSERR; | ||
567 | } | ||
568 | |||
569 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
570 | "rsa_private_key", | ||
571 | &secret_enc_data, | ||
572 | &secret_enc_len)) | ||
573 | { | ||
574 | GNUNET_break (0); | ||
575 | return GNUNET_SYSERR; | ||
576 | } | ||
577 | |||
578 | if (GNUNET_OK != expect_data_dynamic (vec, | ||
579 | "sig", | ||
580 | &sig_enc_data, | ||
581 | &sig_enc_length)) | ||
582 | { | ||
583 | GNUNET_break (0); | ||
584 | return GNUNET_SYSERR; | ||
585 | } | ||
586 | |||
587 | pkey = GNUNET_CRYPTO_rsa_public_key_decode (public_enc_data, | ||
588 | public_enc_len); | ||
589 | GNUNET_assert (NULL != pkey); | ||
590 | skey = GNUNET_CRYPTO_rsa_private_key_decode (secret_enc_data, | ||
591 | secret_enc_len); | ||
592 | GNUNET_assert (NULL != skey); | ||
593 | |||
594 | GNUNET_assert (GNUNET_YES == | ||
595 | GNUNET_CRYPTO_rsa_blind (&message_hash, | ||
596 | &bks, | ||
597 | pkey, | ||
598 | &blinded_data_comp, | ||
599 | &blinded_len_comp)); | ||
600 | if ( (blinded_len != blinded_len_comp) || (0 != memcmp (blinded_data, | ||
601 | blinded_data_comp, | ||
602 | blinded_len)) ) | ||
603 | { | ||
604 | GNUNET_break (0); | ||
605 | return GNUNET_NO; | ||
606 | } | ||
607 | blinded_sig = GNUNET_CRYPTO_rsa_sign_blinded (skey, blinded_data, | ||
608 | blinded_len); | ||
609 | sig = GNUNET_CRYPTO_rsa_unblind (blinded_sig, &bks, pkey); | ||
610 | GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_rsa_verify (&message_hash, sig, | ||
611 | pkey)); | ||
612 | public_enc_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey, | ||
613 | &public_enc_data); | ||
614 | sig_enc_length_comp = GNUNET_CRYPTO_rsa_signature_encode (sig, &sig_enc_data_comp); | ||
615 | |||
616 | if ( (sig_enc_length != sig_enc_length_comp) || | ||
617 | (0 != memcmp (sig_enc_data, sig_enc_data_comp, sig_enc_length) )) | ||
618 | { | ||
619 | GNUNET_break (0); | ||
620 | return GNUNET_NO; | ||
621 | } | ||
622 | } | ||
623 | else | ||
624 | { | ||
625 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
626 | "unsupported operation '%s'\n", operation); | ||
627 | } | ||
628 | |||
629 | return GNUNET_OK; | ||
630 | } | ||
631 | |||
632 | /** | ||
633 | * Check test vectors from stdin. | ||
634 | * | ||
635 | * @returns global exit code | ||
636 | */ | ||
637 | static int | ||
638 | check_vectors () | ||
639 | { | ||
640 | json_error_t err; | ||
641 | json_t *vecfile = json_loadf (stdin, 0, &err); | ||
642 | const char *encoding; | ||
643 | json_t *vectors; | ||
644 | |||
645 | if (NULL == vecfile) | ||
646 | { | ||
647 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "unable to parse JSON\n"); | ||
648 | return 1; | ||
649 | } | ||
650 | encoding = json_string_value (json_object_get (vecfile, | ||
651 | "encoding")); | ||
652 | if ( (NULL == encoding) || (0 != strcmp (encoding, "base32crockford")) ) | ||
653 | { | ||
654 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "unsupported or missing encoding\n"); | ||
655 | json_decref (vecfile); | ||
656 | return 1; | ||
657 | } | ||
658 | vectors = json_object_get (vecfile, "vectors"); | ||
659 | if (!json_is_array (vectors)) | ||
660 | { | ||
661 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bad vectors\n"); | ||
662 | json_decref (vecfile); | ||
663 | return 1; | ||
664 | } | ||
665 | { | ||
666 | /* array is a JSON array */ | ||
667 | size_t index; | ||
668 | json_t *value; | ||
669 | int ret; | ||
670 | |||
671 | json_array_foreach (vectors, index, value) { | ||
672 | const char *op = json_string_value (json_object_get (value, | ||
673 | "operation")); | ||
674 | |||
675 | if (NULL == op) | ||
676 | { | ||
677 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
678 | "missing operation\n"); | ||
679 | ret = GNUNET_SYSERR; | ||
680 | break; | ||
681 | } | ||
682 | ret = checkvec (op, value); | ||
683 | if (GNUNET_OK != ret) | ||
684 | { | ||
685 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
686 | "bad vector %u\n", | ||
687 | (unsigned int) index); | ||
688 | break; | ||
689 | } | ||
690 | } | ||
691 | return (ret == GNUNET_OK) ? 0 : 1; | ||
692 | } | ||
693 | } | ||
694 | |||
695 | /** | ||
696 | * Output test vectors. | ||
697 | * | ||
698 | * @returns global exit code | ||
699 | */ | ||
700 | static int | ||
701 | output_vectors () | ||
77 | { | 702 | { |
703 | json_t *vecfile = json_object (); | ||
704 | json_t *vecs = json_array (); | ||
705 | |||
706 | json_object_set_new (vecfile, | ||
707 | "encoding", | ||
708 | json_string ("base32crockford")); | ||
709 | json_object_set_new (vecfile, | ||
710 | "producer", | ||
711 | json_string ("GNUnet " PACKAGE_VERSION " " VCS_VERSION)); | ||
712 | json_object_set_new (vecfile, | ||
713 | "vectors", | ||
714 | vecs); | ||
715 | |||
78 | { | 716 | { |
717 | json_t *vec = vec_for (vecs, "hash"); | ||
79 | struct GNUNET_HashCode hc; | 718 | struct GNUNET_HashCode hc; |
80 | char *str = "Hello, GNUnet"; | 719 | char *str = "Hello, GNUnet"; |
81 | 720 | ||
82 | GNUNET_CRYPTO_hash (str, strlen (str), &hc); | 721 | GNUNET_CRYPTO_hash (str, strlen (str), &hc); |
83 | 722 | ||
84 | printf ("hash code:\n"); | 723 | d2j (vec, "input", str, strlen (str)); |
85 | display_data (" input", str, strlen (str)); | 724 | d2j (vec, "output", &hc, sizeof (struct GNUNET_HashCode)); |
86 | display_data (" output", &hc, sizeof (struct GNUNET_HashCode)); | ||
87 | } | 725 | } |
88 | { | 726 | { |
727 | json_t *vec = vec_for (vecs, "ecc_ecdh"); | ||
89 | struct GNUNET_CRYPTO_EcdhePrivateKey priv1; | 728 | struct GNUNET_CRYPTO_EcdhePrivateKey priv1; |
90 | struct GNUNET_CRYPTO_EcdhePublicKey pub1; | 729 | struct GNUNET_CRYPTO_EcdhePublicKey pub1; |
91 | struct GNUNET_CRYPTO_EcdhePrivateKey priv2; | 730 | struct GNUNET_CRYPTO_EcdhePrivateKey priv2; |
@@ -100,22 +739,26 @@ run (void *cls, | |||
100 | &pub1, | 739 | &pub1, |
101 | &skm)); | 740 | &skm)); |
102 | 741 | ||
103 | printf ("ecdhe key:\n"); | 742 | d2j (vec, |
104 | display_data (" priv1", | 743 | "priv1", |
105 | &priv1, | 744 | &priv1, |
106 | sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey)); | 745 | sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey)); |
107 | display_data (" pub1", | 746 | d2j (vec, |
108 | &pub1, | 747 | "pub1", |
109 | sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); | 748 | &pub1, |
110 | display_data (" priv2", | 749 | sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); |
111 | &priv2, | 750 | d2j (vec, |
112 | sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey)); | 751 | "priv2", |
113 | display_data (" skm", | 752 | &priv2, |
114 | &skm, | 753 | sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey)); |
115 | sizeof (struct GNUNET_HashCode)); | 754 | d2j (vec, |
755 | "skm", | ||
756 | &skm, | ||
757 | sizeof (struct GNUNET_HashCode)); | ||
116 | } | 758 | } |
117 | 759 | ||
118 | { | 760 | { |
761 | json_t *vec = vec_for (vecs, "eddsa_key_derivation"); | ||
119 | struct GNUNET_CRYPTO_EddsaPrivateKey priv; | 762 | struct GNUNET_CRYPTO_EddsaPrivateKey priv; |
120 | struct GNUNET_CRYPTO_EddsaPublicKey pub; | 763 | struct GNUNET_CRYPTO_EddsaPublicKey pub; |
121 | 764 | ||
@@ -123,15 +766,17 @@ run (void *cls, | |||
123 | GNUNET_CRYPTO_eddsa_key_get_public (&priv, | 766 | GNUNET_CRYPTO_eddsa_key_get_public (&priv, |
124 | &pub); | 767 | &pub); |
125 | 768 | ||
126 | printf ("eddsa key:\n"); | 769 | d2j (vec, |
127 | display_data (" priv", | 770 | "priv", |
128 | &priv, | 771 | &priv, |
129 | sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)); | 772 | sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)); |
130 | display_data (" pub", | 773 | d2j (vec, |
131 | &pub, | 774 | "pub", |
132 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); | 775 | &pub, |
776 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); | ||
133 | } | 777 | } |
134 | { | 778 | { |
779 | json_t *vec = vec_for (vecs, "eddsa_signing"); | ||
135 | struct GNUNET_CRYPTO_EddsaPrivateKey priv; | 780 | struct GNUNET_CRYPTO_EddsaPrivateKey priv; |
136 | struct GNUNET_CRYPTO_EddsaPublicKey pub; | 781 | struct GNUNET_CRYPTO_EddsaPublicKey pub; |
137 | struct GNUNET_CRYPTO_EddsaSignature sig; | 782 | struct GNUNET_CRYPTO_EddsaSignature sig; |
@@ -151,22 +796,26 @@ run (void *cls, | |||
151 | &sig, | 796 | &sig, |
152 | &pub)); | 797 | &pub)); |
153 | 798 | ||
154 | printf ("eddsa sig:\n"); | 799 | d2j (vec, |
155 | display_data (" priv", | 800 | "priv", |
156 | &priv, | 801 | &priv, |
157 | sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)); | 802 | sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)); |
158 | display_data (" pub", | 803 | d2j (vec, |
159 | &pub, | 804 | "pub", |
160 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); | 805 | &pub, |
161 | display_data (" data", | 806 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); |
162 | &data, | 807 | d2j (vec, |
163 | sizeof (struct TestSignatureDataPS)); | 808 | "data", |
164 | display_data (" sig", | 809 | &data, |
165 | &sig, | 810 | sizeof (struct TestSignatureDataPS)); |
166 | sizeof (struct GNUNET_CRYPTO_EddsaSignature)); | 811 | d2j (vec, |
812 | "sig", | ||
813 | &sig, | ||
814 | sizeof (struct GNUNET_CRYPTO_EddsaSignature)); | ||
167 | } | 815 | } |
168 | 816 | ||
169 | { | 817 | { |
818 | json_t *vec = vec_for (vecs, "kdf"); | ||
170 | size_t out_len = 64; | 819 | size_t out_len = 64; |
171 | char out[out_len]; | 820 | char out[out_len]; |
172 | char *ikm = "I'm the secret input key material"; | 821 | char *ikm = "I'm the secret input key material"; |
@@ -184,14 +833,28 @@ run (void *cls, | |||
184 | strlen (ctx), | 833 | strlen (ctx), |
185 | NULL)); | 834 | NULL)); |
186 | 835 | ||
187 | printf ("kdf:\n"); | 836 | d2j (vec, |
188 | display_data (" salt", salt, strlen (salt)); | 837 | "salt", |
189 | display_data (" ikm", ikm, strlen (ikm)); | 838 | salt, |
190 | display_data (" ctx", ctx, strlen (ctx)); | 839 | strlen (salt)); |
191 | printf (" out_len %u\n", (unsigned int) out_len); | 840 | d2j (vec, |
192 | display_data (" out", out, out_len); | 841 | "ikm", |
842 | ikm, | ||
843 | strlen (ikm)); | ||
844 | d2j (vec, | ||
845 | "ctx", | ||
846 | ctx, | ||
847 | strlen (ctx)); | ||
848 | uint2j (vec, | ||
849 | "out_len", | ||
850 | (unsigned int) out_len); | ||
851 | d2j (vec, | ||
852 | "out", | ||
853 | out, | ||
854 | out_len); | ||
193 | } | 855 | } |
194 | { | 856 | { |
857 | json_t *vec = vec_for (vecs, "eddsa_ecdh"); | ||
195 | struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe; | 858 | struct GNUNET_CRYPTO_EcdhePrivateKey priv_ecdhe; |
196 | struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe; | 859 | struct GNUNET_CRYPTO_EcdhePublicKey pub_ecdhe; |
197 | struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa; | 860 | struct GNUNET_CRYPTO_EddsaPrivateKey priv_eddsa; |
@@ -204,25 +867,26 @@ run (void *cls, | |||
204 | GNUNET_CRYPTO_eddsa_key_get_public (&priv_eddsa, &pub_eddsa); | 867 | GNUNET_CRYPTO_eddsa_key_get_public (&priv_eddsa, &pub_eddsa); |
205 | GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material); | 868 | GNUNET_CRYPTO_ecdh_eddsa (&priv_ecdhe, &pub_eddsa, &key_material); |
206 | 869 | ||
207 | printf ("eddsa_ecdh:\n"); | 870 | d2j (vec, "priv_ecdhe", |
208 | display_data (" priv_ecdhe", | ||
209 | &priv_ecdhe, | 871 | &priv_ecdhe, |
210 | sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey)); | 872 | sizeof (struct GNUNET_CRYPTO_EcdhePrivateKey)); |
211 | display_data (" pub_ecdhe", | 873 | d2j (vec, "pub_ecdhe", |
212 | &pub_ecdhe, | 874 | &pub_ecdhe, |
213 | sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); | 875 | sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); |
214 | display_data (" priv_eddsa", | 876 | d2j (vec, "priv_eddsa", |
215 | &priv_eddsa, | 877 | &priv_eddsa, |
216 | sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)); | 878 | sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)); |
217 | display_data (" pub_eddsa", | 879 | d2j (vec, "pub_eddsa", |
218 | &pub_eddsa, | 880 | &pub_eddsa, |
219 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); | 881 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); |
220 | display_data (" key_material", | 882 | d2j (vec, "key_material", |
221 | &key_material, | 883 | &key_material, |
222 | sizeof (struct GNUNET_HashCode)); | 884 | sizeof (struct GNUNET_HashCode)); |
223 | } | 885 | } |
224 | 886 | ||
225 | { | 887 | { |
888 | json_t *vec = vec_for (vecs, "rsa_blind_signing"); | ||
889 | |||
226 | struct GNUNET_CRYPTO_RsaPrivateKey *skey; | 890 | struct GNUNET_CRYPTO_RsaPrivateKey *skey; |
227 | struct GNUNET_CRYPTO_RsaPublicKey *pkey; | 891 | struct GNUNET_CRYPTO_RsaPublicKey *pkey; |
228 | struct GNUNET_HashCode message_hash; | 892 | struct GNUNET_HashCode message_hash; |
@@ -233,10 +897,13 @@ run (void *cls, | |||
233 | size_t blinded_len; | 897 | size_t blinded_len; |
234 | void *public_enc_data; | 898 | void *public_enc_data; |
235 | size_t public_enc_len; | 899 | size_t public_enc_len; |
900 | void *secret_enc_data; | ||
901 | size_t secret_enc_len; | ||
236 | void *blinded_sig_enc_data; | 902 | void *blinded_sig_enc_data; |
237 | size_t blinded_sig_enc_length; | 903 | size_t blinded_sig_enc_length; |
238 | void *sig_enc_data; | 904 | void *sig_enc_data; |
239 | size_t sig_enc_length; | 905 | size_t sig_enc_length; |
906 | |||
240 | skey = GNUNET_CRYPTO_rsa_private_key_create (2048); | 907 | skey = GNUNET_CRYPTO_rsa_private_key_create (2048); |
241 | pkey = GNUNET_CRYPTO_rsa_private_key_get_public (skey); | 908 | pkey = GNUNET_CRYPTO_rsa_private_key_get_public (skey); |
242 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, | 909 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, |
@@ -259,25 +926,75 @@ run (void *cls, | |||
259 | pkey)); | 926 | pkey)); |
260 | public_enc_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey, | 927 | public_enc_len = GNUNET_CRYPTO_rsa_public_key_encode (pkey, |
261 | &public_enc_data); | 928 | &public_enc_data); |
929 | secret_enc_len = GNUNET_CRYPTO_rsa_private_key_encode (skey, | ||
930 | &secret_enc_data); | ||
262 | blinded_sig_enc_length = GNUNET_CRYPTO_rsa_signature_encode (blinded_sig, | 931 | blinded_sig_enc_length = GNUNET_CRYPTO_rsa_signature_encode (blinded_sig, |
263 | & | 932 | & |
264 | blinded_sig_enc_data); | 933 | blinded_sig_enc_data); |
265 | sig_enc_length = GNUNET_CRYPTO_rsa_signature_encode (sig, &sig_enc_data); | 934 | sig_enc_length = GNUNET_CRYPTO_rsa_signature_encode (sig, &sig_enc_data); |
266 | printf ("blind signing:\n"); | 935 | d2j (vec, |
267 | display_data (" message_hash", &message_hash, sizeof (struct | 936 | "message_hash", |
268 | GNUNET_HashCode)); | 937 | &message_hash, |
269 | display_data (" rsa_public_key", public_enc_data, public_enc_len); | 938 | sizeof (struct GNUNET_HashCode)); |
270 | display_data (" blinding_key_secret", &bks, sizeof (struct | 939 | d2j (vec, |
271 | GNUNET_CRYPTO_RsaBlindingKeySecret)); | 940 | "rsa_public_key", |
272 | display_data (" blinded_message", blinded_data, blinded_len); | 941 | public_enc_data, |
273 | display_data (" blinded_sig", blinded_sig_enc_data, | 942 | public_enc_len); |
274 | blinded_sig_enc_length); | 943 | d2j (vec, |
275 | display_data (" sig", sig_enc_data, sig_enc_length); | 944 | "rsa_private_key", |
945 | secret_enc_data, | ||
946 | secret_enc_len); | ||
947 | d2j (vec, | ||
948 | "blinding_key_secret", | ||
949 | &bks, | ||
950 | sizeof (struct GNUNET_CRYPTO_RsaBlindingKeySecret)); | ||
951 | d2j (vec, | ||
952 | "blinded_message", | ||
953 | blinded_data, | ||
954 | blinded_len); | ||
955 | d2j (vec, | ||
956 | "blinded_sig", | ||
957 | blinded_sig_enc_data, | ||
958 | blinded_sig_enc_length); | ||
959 | d2j (vec, | ||
960 | "sig", | ||
961 | sig_enc_data, | ||
962 | sig_enc_length); | ||
276 | GNUNET_CRYPTO_rsa_private_key_free (skey); | 963 | GNUNET_CRYPTO_rsa_private_key_free (skey); |
277 | GNUNET_CRYPTO_rsa_public_key_free (pkey); | 964 | GNUNET_CRYPTO_rsa_public_key_free (pkey); |
278 | GNUNET_CRYPTO_rsa_signature_free (sig); | 965 | GNUNET_CRYPTO_rsa_signature_free (sig); |
279 | GNUNET_CRYPTO_rsa_signature_free (blinded_sig); | 966 | GNUNET_CRYPTO_rsa_signature_free (blinded_sig); |
967 | GNUNET_free (public_enc_data); | ||
968 | GNUNET_free (blinded_data); | ||
969 | GNUNET_free (sig_enc_data); | ||
970 | GNUNET_free (blinded_sig_enc_data); | ||
280 | } | 971 | } |
972 | |||
973 | json_dumpf (vecfile, stdout, JSON_INDENT (2)); | ||
974 | json_decref (vecfile); | ||
975 | printf ("\n"); | ||
976 | |||
977 | return 0; | ||
978 | } | ||
979 | |||
980 | /** | ||
981 | * Main function that will be run. | ||
982 | * | ||
983 | * @param cls closure | ||
984 | * @param args remaining command-line arguments | ||
985 | * @param cfgfile name of the configuration file used (for saving, can be NULL!) | ||
986 | * @param cfg configuration | ||
987 | */ | ||
988 | static void | ||
989 | run (void *cls, | ||
990 | char *const *args, | ||
991 | const char *cfgfile, | ||
992 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
993 | { | ||
994 | if (GNUNET_YES == verify_flag) | ||
995 | global_ret = check_vectors (); | ||
996 | else | ||
997 | global_ret = output_vectors (); | ||
281 | } | 998 | } |
282 | 999 | ||
283 | 1000 | ||
@@ -293,6 +1010,11 @@ main (int argc, | |||
293 | char *const *argv) | 1010 | char *const *argv) |
294 | { | 1011 | { |
295 | const struct GNUNET_GETOPT_CommandLineOption options[] = { | 1012 | const struct GNUNET_GETOPT_CommandLineOption options[] = { |
1013 | GNUNET_GETOPT_option_flag ('V', | ||
1014 | "verify", | ||
1015 | gettext_noop ( | ||
1016 | "verify a test vector from stdin"), | ||
1017 | &verify_flag), | ||
296 | GNUNET_GETOPT_OPTION_END | 1018 | GNUNET_GETOPT_OPTION_END |
297 | }; | 1019 | }; |
298 | 1020 | ||
@@ -307,7 +1029,7 @@ main (int argc, | |||
307 | options, | 1029 | options, |
308 | &run, NULL)) | 1030 | &run, NULL)) |
309 | return 1; | 1031 | return 1; |
310 | return 0; | 1032 | return global_ret; |
311 | } | 1033 | } |
312 | 1034 | ||
313 | 1035 | ||
diff --git a/src/util/perf_crypto_rsa.c b/src/util/perf_crypto_rsa.c index d652e8d4e..aba61786f 100644 --- a/src/util/perf_crypto_rsa.c +++ b/src/util/perf_crypto_rsa.c | |||
@@ -44,7 +44,7 @@ eval (unsigned int len) | |||
44 | struct GNUNET_CRYPTO_RsaBlindingKeySecret bsec[10]; | 44 | struct GNUNET_CRYPTO_RsaBlindingKeySecret bsec[10]; |
45 | unsigned int i; | 45 | unsigned int i; |
46 | char sbuf[128]; | 46 | char sbuf[128]; |
47 | char *bbuf; | 47 | void *bbuf; |
48 | size_t bbuf_len; | 48 | size_t bbuf_len; |
49 | struct GNUNET_HashCode hc; | 49 | struct GNUNET_HashCode hc; |
50 | 50 | ||
@@ -88,14 +88,16 @@ eval (unsigned int len) | |||
88 | 64 * 1024 / (1 + | 88 | 64 * 1024 / (1 + |
89 | GNUNET_TIME_absolute_get_duration | 89 | GNUNET_TIME_absolute_get_duration |
90 | (start).rel_value_us / 1000LL), "keys/ms"); | 90 | (start).rel_value_us / 1000LL), "keys/ms"); |
91 | */start = GNUNET_TIME_absolute_get (); | 91 | */ |
92 | start = GNUNET_TIME_absolute_get (); | ||
92 | GNUNET_CRYPTO_hash ("test", 4, &hc); | 93 | GNUNET_CRYPTO_hash ("test", 4, &hc); |
93 | for (i = 0; i < 10; i++) | 94 | for (i = 0; i < 10; i++) |
94 | { | 95 | { |
95 | GNUNET_CRYPTO_rsa_blind (&hc, | 96 | GNUNET_CRYPTO_rsa_blind (&hc, |
96 | &bsec[i], | 97 | &bsec[i], |
97 | public_key, | 98 | public_key, |
98 | &bbuf, &bbuf_len); | 99 | &bbuf, |
100 | &bbuf_len); | ||
99 | GNUNET_free (bbuf); | 101 | GNUNET_free (bbuf); |
100 | } | 102 | } |
101 | printf ("10x %u-blinding took %s\n", | 103 | printf ("10x %u-blinding took %s\n", |
@@ -115,12 +117,14 @@ eval (unsigned int len) | |||
115 | GNUNET_CRYPTO_rsa_blind (&hc, | 117 | GNUNET_CRYPTO_rsa_blind (&hc, |
116 | &bsec[0], | 118 | &bsec[0], |
117 | public_key, | 119 | public_key, |
118 | &bbuf, &bbuf_len); | 120 | &bbuf, |
121 | &bbuf_len); | ||
119 | start = GNUNET_TIME_absolute_get (); | 122 | start = GNUNET_TIME_absolute_get (); |
120 | for (i = 0; i < 10; i++) | 123 | for (i = 0; i < 10; i++) |
121 | { | 124 | { |
122 | sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key, | 125 | sig = GNUNET_CRYPTO_rsa_sign_blinded (private_key, |
123 | bbuf, bbuf_len); | 126 | bbuf, |
127 | bbuf_len); | ||
124 | GNUNET_CRYPTO_rsa_signature_free (sig); | 128 | GNUNET_CRYPTO_rsa_signature_free (sig); |
125 | } | 129 | } |
126 | printf ("10x %u-signing took %s\n", | 130 | printf ("10x %u-signing took %s\n", |
diff --git a/src/util/test_crypto_vectors.sh b/src/util/test_crypto_vectors.sh new file mode 100755 index 000000000..40700a324 --- /dev/null +++ b/src/util/test_crypto_vectors.sh | |||
@@ -0,0 +1,3 @@ | |||
1 | #!/usr/bin/env bash | ||
2 | |||
3 | cat ./crypto-test-vectors.json | ./gnunet-crypto-tvg --verify | ||