GNUnet 0.21.0
gnunet_crypto_lib.h
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2001-2023 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
47#if ! defined (__GNUNET_UTIL_LIB_H_INSIDE__)
48#error "Only <gnunet_util_lib.h> can be included directly."
49#endif
50
51#ifndef GNUNET_CRYPTO_LIB_H
52#define GNUNET_CRYPTO_LIB_H
53
54#ifdef __cplusplus
55extern "C" {
56#if 0 /* keep Emacsens' auto-indent happy */
57}
58#endif
59#endif
60
61
62#include <stdbool.h>
63#include <sodium.h>
64
69
70#include <gcrypt.h>
71
72
77#define GNUNET_CRYPTO_ECC_SIGNATURE_DATA_ENCODING_LENGTH 126
78
79
85{
92
98
105
106
110#define GNUNET_CRYPTO_AES_KEY_LENGTH (256 / 8)
111
115#define GNUNET_CRYPTO_HASH_LENGTH (512 / 8)
116
121#define GNUNET_CRYPTO_PKEY_ASCII_LENGTH 52
122
127{
128 unsigned char encoding[104];
129};
130
131
133
134
141{
148
156};
157
158
164{
168 unsigned char r[256 / 8];
169
173 unsigned char s[256 / 8];
174};
175
176
181{
185 unsigned char r[256 / 8];
186
190 unsigned char s[256 / 8];
191};
192
193
201{
207 unsigned char q_y[256 / 8];
208};
209
210
216{
221 unsigned char q_y[256 / 8];
222};
223
224
229{
231};
232
233
240{
245 unsigned char q_y[256 / 8];
246};
247
248
254{
258 unsigned char d[256 / 8];
259};
260
266{
270 unsigned char d[256 / 8];
271};
272
278{
282 unsigned char d[256 / 8];
283};
284
285
291{
295 unsigned char s[512 / 8];
296};
297
304{
309 unsigned char a[256 / 8];
310
315 unsigned char b[256 / 8];
316};
317
318
326{
332 unsigned char q_y[256 / 8];
333};
334
339{
343 unsigned char r[256 / 8];
344
348 unsigned char s[256 / 8];
349};
350
355{
360 unsigned char r[256 / 8];
361};
362
367{
373
380
387{
393 uint32_t type;
394
395 union
396 {
401
406 };
407};
408
409
414{
420 uint32_t type;
421
422 union
423 {
428
433 };
434};
435
436
441{
447 uint32_t type;
448
449 union
450 {
455
460 };
461};
462
467{
472
477};
478
483{
488};
489
491
499{
501
503};
504
505
510{
512};
513
514
519#define GNUNET_CRYPTO_PAILLIER_BITS 2048
520
521
526{
530 unsigned char n[GNUNET_CRYPTO_PAILLIER_BITS / 8];
531};
532
533
538{
546 unsigned char mu[GNUNET_CRYPTO_PAILLIER_BITS / 8];
547};
548
549
554{
560
564 unsigned char bits[GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8];
565};
566
567
572{
576 unsigned char d[crypto_core_ed25519_SCALARBYTES];
577};
578
579
584{
589 unsigned char y[crypto_core_ed25519_BYTES];
590};
591
592
597{
599};
600
601
606{
608};
609
610
615{
618};
619
620
625{
627};
628
629
634{
636};
637
638
643{
645};
646
647
652{
654};
655
656
661{
663};
664
665
670{
675
680};
681
682
688{
689 /*a nonce*/
690 unsigned char snonce[256 / 8];
691};
692
693
699{
700 /*a nonce*/
701 unsigned char bnonce[256 / 8];
702};
703
704
705/* **************** Functions and Macros ************* */
706
714void
715GNUNET_CRYPTO_seed_weak_random (int32_t seed);
716
717
726uint8_t
727GNUNET_CRYPTO_crc8_n (const void *buf, size_t len);
728
729
738uint32_t
739GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len);
740
741
748uint16_t
750
751
760uint16_t
761GNUNET_CRYPTO_crc16_n (const void *buf, size_t len);
762
763
773int32_t
774GNUNET_CRYPTO_crc32_n (const void *buf, size_t len);
775
784void
785GNUNET_CRYPTO_zero_keys (void *buffer, size_t length);
786
787
796void
798 void *buffer,
799 size_t length);
800
801
812void
814 struct GNUNET_Uuid *uuid);
815
816
825uint32_t
827
828
837uint64_t
839
840
850unsigned int *
852
853
860void
863
864
876ssize_t
878 const void *block,
879 size_t size,
880 const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
882 void *result);
883
884
896ssize_t
898 const void *block,
899 size_t size,
900 const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
902 void *result);
903
904
914void
917 const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
918 const void *salt,
919 size_t salt_len,
920 ...);
921
922
931void
934 const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
935 const void *salt,
936 size_t salt_len,
937 va_list argp);
938
939
947void
948GNUNET_CRYPTO_hash_to_enc (const struct GNUNET_HashCode *block,
950
951
963 size_t enclen,
964 struct GNUNET_HashCode *result);
965
966
975#define GNUNET_CRYPTO_hash_from_string(enc, result) \
976 GNUNET_CRYPTO_hash_from_string2 (enc, strlen (enc), result)
977
978
991uint32_t
993 const struct GNUNET_HashCode *b);
994
995
1004void
1005GNUNET_CRYPTO_hash (const void *block,
1006 size_t size,
1007 struct GNUNET_HashCode *ret);
1008
1009
1014{
1015 char salt[crypto_pwhash_argon2id_SALTBYTES];
1016};
1017
1018
1027void
1029 const void *buf,
1030 size_t buf_len,
1031 struct GNUNET_HashCode *result);
1032
1033
1037struct GNUNET_HashContext;
1038
1039
1045struct GNUNET_HashContext *
1047
1048
1055struct GNUNET_HashContext *
1057
1058
1066void
1068 const void *buf,
1069 size_t size);
1070
1071
1078void
1080 struct GNUNET_HashCode *r_hash);
1081
1082
1088void
1090
1091
1103void
1104GNUNET_CRYPTO_hmac_raw (const void *key,
1105 size_t key_len,
1106 const void *plaintext,
1107 size_t plaintext_len,
1108 struct GNUNET_HashCode *hmac);
1109
1110
1120void
1122 const void *plaintext,
1123 size_t plaintext_len,
1124 struct GNUNET_HashCode *hmac);
1125
1126
1134typedef void
1136 void *cls,
1137 const struct GNUNET_HashCode *res);
1138
1139
1144
1145
1159 const char *filename,
1160 size_t blocksize,
1162 void *callback_cls);
1163
1164
1170void
1172
1173
1181void
1183 struct GNUNET_HashCode *result);
1184
1185
1194void
1196 const struct GNUNET_HashCode *b,
1197 struct GNUNET_HashCode *result);
1198
1199
1208void
1210 const struct GNUNET_HashCode *delta,
1211 struct GNUNET_HashCode *result);
1212
1213
1222void
1224 const struct GNUNET_HashCode *b,
1225 struct GNUNET_HashCode *result);
1226
1227
1234unsigned int
1236
1237
1244unsigned int
1246
1247
1256void
1258 const struct GNUNET_HashCode *hc,
1261
1262
1272int
1273GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
1274 const struct GNUNET_HashCode *h2);
1275
1276
1287int
1289 const struct GNUNET_HashCode *h2,
1290 const struct GNUNET_HashCode *target);
1291
1292
1302void
1304 struct GNUNET_CRYPTO_AuthKey *key,
1305 const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
1306 const void *salt,
1307 size_t salt_len,
1308 va_list argp);
1309
1310
1320void
1322 struct GNUNET_CRYPTO_AuthKey *key,
1323 const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey,
1324 const void *salt,
1325 size_t salt_len,
1326 ...);
1327
1328
1345 size_t out_len,
1346 int xtr_algo,
1347 int prf_algo,
1348 const void *xts,
1349 size_t xts_len,
1350 const void *skm,
1351 size_t skm_len,
1352 ...);
1353
1354
1371 size_t out_len,
1372 int xtr_algo,
1373 int prf_algo,
1374 const void *xts,
1375 size_t xts_len,
1376 const void *skm,
1377 size_t skm_len,
1378 va_list argp);
1379
1380
1394 size_t out_len,
1395 const void *xts,
1396 size_t xts_len,
1397 const void *skm,
1398 size_t skm_len,
1399 va_list argp);
1400
1401
1414void
1415GNUNET_CRYPTO_kdf_mod_mpi (gcry_mpi_t *r,
1416 gcry_mpi_t n,
1417 const void *xts,
1418 size_t xts_len,
1419 const void *skm,
1420 size_t skm_len,
1421 const char *ctx);
1422
1423
1438 size_t out_len,
1439 const void *xts,
1440 size_t xts_len,
1441 const void *skm,
1442 size_t skm_len,
1443 ...);
1444
1445
1453void
1455 const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
1457
1465void
1467 const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
1469
1477void
1479 const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv,
1481
1489void
1491 const struct GNUNET_CRYPTO_EcdhePrivateKey *priv,
1493
1494
1501char *
1503 const struct GNUNET_CRYPTO_EcdsaPublicKey *pub);
1504
1511char *
1513 const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv);
1514
1515
1522char *
1524 const struct GNUNET_CRYPTO_EddsaPrivateKey *priv);
1525
1526
1533char *
1535 const struct GNUNET_CRYPTO_EddsaPublicKey *pub);
1536
1537
1548 const char *enc,
1549 size_t enclen,
1551
1552
1563 const char *enc,
1564 size_t enclen,
1565 struct GNUNET_CRYPTO_EddsaPrivateKey *priv);
1566
1567
1578 const char *enc,
1579 size_t enclen,
1581
1582
1600 int do_create,
1602
1603
1621 int do_create,
1623
1624
1629
1630
1642 const struct GNUNET_CONFIGURATION_Handle *cfg);
1643
1644
1651void
1653
1654
1661void
1663
1664
1671void
1673
1683void
1685 const void *seed,
1686 size_t seedsize,
1688
1698void
1700
1701
1708void
1710
1711
1718void
1720
1727void
1729
1736void
1738
1739
1746const struct GNUNET_CRYPTO_EcdsaPrivateKey *
1748
1749
1759void
1761
1762
1774 struct GNUNET_PeerIdentity *dst);
1775
1776
1790 const struct
1792 struct GNUNET_CRYPTO_EddsaSignature *sig);
1793
1794
1806GNUNET_CRYPTO_verify_peer_identity (uint32_t purpose,
1807 const struct
1809 const struct
1811 const struct GNUNET_PeerIdentity *identity);
1812
1813
1818
1819
1825{
1830 unsigned char v[256 / 8];
1831};
1832
1837{
1838 unsigned char v[256 / 8];
1839};
1840
1850 unsigned int mem);
1851
1852
1861int
1863 const struct GNUNET_CRYPTO_EccPoint *input);
1864
1865
1877void
1878GNUNET_CRYPTO_ecc_dexp (int val,
1879 struct GNUNET_CRYPTO_EccPoint*r);
1880
1881
1892 struct GNUNET_CRYPTO_EccPoint *r);
1893
1894
1905 const struct GNUNET_CRYPTO_EccScalar *val,
1906 struct GNUNET_CRYPTO_EccPoint *r);
1907
1908
1919 const struct GNUNET_CRYPTO_EccPoint *b,
1920 struct GNUNET_CRYPTO_EccPoint *r);
1921
1922
1933 struct GNUNET_CRYPTO_EccPoint *r_inv);
1934
1935
1943void
1945 struct GNUNET_CRYPTO_EccScalar *r_neg);
1946
1947
1953void
1955
1956
1962void
1964
1965
1972void
1974 struct GNUNET_CRYPTO_EccScalar *r);
1975
1976
1991 const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
1992 struct GNUNET_HashCode *key_material);
1993
1994
2011 const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
2012 struct GNUNET_HashCode *key_material);
2013
2027 const struct GNUNET_CRYPTO_EcdhePublicKey *c,
2028 struct GNUNET_HashCode *key_material);
2029
2043 struct GNUNET_HashCode *key_material);
2044
2049{
2050 /* The output of the FO-OWTF F(x) */
2052
2053 /* The ephemeral public key from the DH in the KEM */
2055};
2056
2071 const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
2072 struct GNUNET_CRYPTO_FoKemC *c,
2073 struct GNUNET_HashCode *key_material);
2074
2075
2091 const struct GNUNET_CRYPTO_FoKemC *c,
2092 struct GNUNET_HashCode *key_material);
2093
2109 struct GNUNET_CRYPTO_FoKemC *c,
2110 struct GNUNET_HashCode *key_material);
2111
2112
2128 struct GNUNET_CRYPTO_FoKemC *c,
2129 struct GNUNET_HashCode *key_material);
2130
2143 const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
2144 struct GNUNET_HashCode *key_material);
2145
2146
2163 const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
2164 struct GNUNET_HashCode *key_material);
2165
2166
2179 const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
2180 struct GNUNET_HashCode *key_material);
2181
2182
2200 const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
2201 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
2202 struct GNUNET_CRYPTO_EddsaSignature *sig);
2203
2204
2217#define GNUNET_CRYPTO_eddsa_sign(priv,ps,sig) do { \
2218 /* check size is set correctly */ \
2219 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*ps)); \
2220 /* check 'ps' begins with the purpose */ \
2221 GNUNET_static_assert (((void*) (ps)) == \
2222 ((void*) &(ps)->purpose)); \
2223 GNUNET_assert (GNUNET_OK == \
2224 GNUNET_CRYPTO_eddsa_sign_ (priv, \
2225 &(ps)->purpose, \
2226 sig)); \
2227} while (0)
2228
2229
2247 const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
2248 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
2249 struct GNUNET_CRYPTO_EcdsaSignature *sig);
2250
2262 const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
2263 void *data,
2264 size_t size,
2265 struct GNUNET_CRYPTO_EddsaSignature *sig);
2266
2279#define GNUNET_CRYPTO_ecdsa_sign(priv,ps,sig) do { \
2280 /* check size is set correctly */ \
2281 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
2282 /* check 'ps' begins with the purpose */ \
2283 GNUNET_static_assert (((void*) (ps)) == \
2284 ((void*) &(ps)->purpose)); \
2285 GNUNET_assert (GNUNET_OK == \
2286 GNUNET_CRYPTO_ecdsa_sign_ (priv, \
2287 &(ps)->purpose, \
2288 sig)); \
2289} while (0)
2290
2308 const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv,
2309 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
2311
2312
2326#define GNUNET_CRYPTO_edx25519_sign(priv,ps,sig) do { \
2327 /* check size is set correctly */ \
2328 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
2329 /* check 'ps' begins with the purpose */ \
2330 GNUNET_static_assert (((void*) (ps)) == \
2331 ((void*) &(ps)->purpose)); \
2332 GNUNET_assert (GNUNET_OK == \
2333 GNUNET_CRYPTO_edx25519_sign_ (priv, \
2334 &(ps)->purpose, \
2335 sig)); \
2336} while (0)
2337
2338
2359 uint32_t purpose,
2360 const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
2361 const struct GNUNET_CRYPTO_EddsaSignature *sig,
2362 const struct GNUNET_CRYPTO_EddsaPublicKey *pub);
2363
2364
2379#define GNUNET_CRYPTO_eddsa_verify(purp,ps,sig,pub) ({ \
2380 /* check size is set correctly */ \
2381 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
2382 /* check 'ps' begins with the purpose */ \
2383 GNUNET_static_assert (((void*) (ps)) == \
2384 ((void*) &(ps)->purpose)); \
2385 GNUNET_CRYPTO_eddsa_verify_ (purp, \
2386 &(ps)->purpose, \
2387 sig, \
2388 pub); \
2389 })
2390
2411 uint32_t purpose,
2412 const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
2413 const struct GNUNET_CRYPTO_EcdsaSignature *sig,
2414 const struct GNUNET_CRYPTO_EcdsaPublicKey *pub);
2415
2416
2431#define GNUNET_CRYPTO_ecdsa_verify(purp,ps,sig,pub) ({ \
2432 /* check size is set correctly */ \
2433 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
2434 /* check 'ps' begins with the purpose */ \
2435 GNUNET_static_assert (((void*) (ps)) == \
2436 ((void*) &(ps)->purpose)); \
2437 GNUNET_CRYPTO_ecdsa_verify_ (purp, \
2438 &(ps)->purpose, \
2439 sig, \
2440 pub); \
2441 })
2442
2463 uint32_t purpose,
2464 const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
2465 const struct GNUNET_CRYPTO_Edx25519Signature *sig,
2466 const struct GNUNET_CRYPTO_Edx25519PublicKey *pub);
2467
2468
2483#define GNUNET_CRYPTO_edx25519_verify(purp,ps,sig,pub) ({ \
2484 /* check size is set correctly */ \
2485 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
2486 /* check 'ps' begins with the purpose */ \
2487 GNUNET_static_assert (((void*) (ps)) == \
2488 ((void*) &(ps)->purpose)); \
2489 GNUNET_CRYPTO_edx25519_verify_ (purp, \
2490 &(ps)->purpose, \
2491 sig, \
2492 pub); \
2493 })
2494
2510 const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv,
2511 const char *label,
2512 const char *context);
2513
2514
2526void
2528 const struct GNUNET_CRYPTO_EcdsaPublicKey *pub,
2529 const char *label,
2530 const char *context,
2532
2547 const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
2548 const char *label,
2549 const char *context,
2550 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
2551 struct GNUNET_CRYPTO_EcdsaSignature *sig);
2552
2553
2570void
2572 const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
2573 const char *label,
2574 const char *context,
2576
2577
2589void
2591 const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
2592 const char *label,
2593 const char *context,
2595
2596
2612 const struct GNUNET_CRYPTO_EddsaPrivateKey *pkey,
2613 const char *label,
2614 const char *context,
2615 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
2616 struct GNUNET_CRYPTO_EddsaSignature *sig);
2617
2618
2625void
2627 const struct GNUNET_CRYPTO_EddsaPrivateScalar *s,
2629
2642void
2644 const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv,
2645 const void *seed,
2646 size_t seedsize,
2648
2649
2660void
2663 const void *seed,
2664 size_t seedsize,
2666
2667
2676void
2678 struct GNUNET_CRYPTO_EcdhePublicKey *point,
2679 bool *high_y,
2680 const struct GNUNET_CRYPTO_ElligatorRepresentative *representative);
2681
2692bool
2695 const struct GNUNET_CRYPTO_EcdhePublicKey *pub,
2696 bool high_y);
2697
2698
2712
2713
2721void
2725
2738 const struct GNUNET_CRYPTO_EddsaPublicKey *pub,
2740 struct GNUNET_HashCode *key_material);
2741
2754 const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
2756 struct GNUNET_HashCode *key_material);
2757
2758
2767void
2769 size_t size,
2770 gcry_mpi_t val);
2771
2772
2782void
2784 const void *data,
2785 size_t size);
2786
2787
2794void
2796 struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
2797 struct GNUNET_CRYPTO_PaillierPrivateKey *private_key);
2798
2799
2811int
2813 const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
2814 const gcry_mpi_t m,
2815 int desired_ops,
2816 struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext);
2817
2818
2827void
2829 const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key,
2830 const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
2831 const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext,
2832 gcry_mpi_t m);
2833
2834
2849int
2851 const struct GNUNET_CRYPTO_PaillierPublicKey *public_key,
2852 const struct GNUNET_CRYPTO_PaillierCiphertext *c1,
2853 const struct GNUNET_CRYPTO_PaillierCiphertext *c2,
2855
2856
2863int
2865 const struct GNUNET_CRYPTO_PaillierCiphertext *c);
2866
2867
2868/* ********* Chaum-style RSA-based blind signatures ******************* */
2869
2870
2875
2880
2885{
2891};
2892
2897
2898
2906GNUNET_CRYPTO_rsa_private_key_create (unsigned int len);
2907
2908
2914void
2916
2917
2926size_t
2928 const struct GNUNET_CRYPTO_RsaPrivateKey *key,
2929 void **buffer);
2930
2931
2942 size_t buf_size);
2943
2944
2953 const struct GNUNET_CRYPTO_RsaPrivateKey *key);
2954
2955
2964 const struct GNUNET_CRYPTO_RsaPrivateKey *priv);
2965
2966
2973void
2975 const struct GNUNET_CRYPTO_RsaPublicKey *key,
2976 struct GNUNET_HashCode *hc);
2977
2978
2984bool
2986 const struct GNUNET_CRYPTO_RsaPublicKey *key);
2987
2994unsigned int
2996
2997
3003void
3005
3006
3015size_t
3017 const struct GNUNET_CRYPTO_RsaPublicKey *key,
3018 void **buffer);
3019
3020
3031 size_t len);
3032
3033
3042
3043
3051int
3053 const struct GNUNET_CRYPTO_RsaSignature *s2);
3054
3062int
3064 const struct GNUNET_CRYPTO_RsaPrivateKey *p1,
3065 const struct GNUNET_CRYPTO_RsaPrivateKey *p2);
3066
3067
3075int
3077 const struct GNUNET_CRYPTO_RsaPublicKey *p2);
3078
3079
3084{
3090
3095};
3096
3097
3109GNUNET_CRYPTO_rsa_blind (const void *message,
3110 size_t message_size,
3111 const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
3114
3115
3125 const struct
3127
3128
3139 const void *message,
3140 size_t message_size);
3141
3142
3149void
3152
3153
3159void
3161
3162
3170size_t
3172 const struct GNUNET_CRYPTO_RsaSignature *sig,
3173 void **buffer);
3174
3175
3186 const void *buf,
3187 size_t buf_size);
3188
3189
3198 const struct GNUNET_CRYPTO_RsaSignature *sig);
3199
3200
3213 const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks,
3215
3216
3228GNUNET_CRYPTO_rsa_verify (const void *message,
3229 size_t message_size,
3230 const struct GNUNET_CRYPTO_RsaSignature *sig,
3231 const struct GNUNET_CRYPTO_RsaPublicKey *public_key);
3232
3233
3239void
3241
3242
3249void
3251 const struct GNUNET_CRYPTO_CsPrivateKey *priv,
3253
3254
3268void
3270 const struct GNUNET_CRYPTO_CsSessionNonce *nonce,
3271 const char *seed,
3272 const struct GNUNET_CRYPTO_CsPrivateKey *lts,
3273 struct GNUNET_CRYPTO_CsRSecret r[2]);
3274
3275
3282void
3284 const struct GNUNET_CRYPTO_CsRSecret *r_priv,
3285 struct GNUNET_CRYPTO_CsRPublic *r_pub);
3286
3287
3298void
3300 const struct GNUNET_CRYPTO_CsBlindingNonce *blind_seed,
3301 struct GNUNET_CRYPTO_CsBlindingSecret bs[2]);
3302
3303
3309{
3314
3319
3320};
3321
3322
3327{
3329};
3330
3331
3344void
3346 const struct GNUNET_CRYPTO_CsBlindingSecret bs[2],
3347 const struct GNUNET_CRYPTO_CsRPublic r_pub[2],
3348 const struct GNUNET_CRYPTO_CsPublicKey *pub,
3349 const void *msg,
3350 size_t msg_len,
3351 struct GNUNET_CRYPTO_CsC blinded_c[2],
3352 struct GNUNET_CRYPTO_CSPublicRPairP *r_pub_blind);
3353
3354
3361{
3366 unsigned int b;
3367
3372};
3373
3374
3389void
3391 const struct GNUNET_CRYPTO_CsPrivateKey *priv,
3392 const struct GNUNET_CRYPTO_CsRSecret r[2],
3393 const struct GNUNET_CRYPTO_CsBlindedMessage *bm,
3394 struct GNUNET_CRYPTO_CsBlindSignature *cs_blind_sig);
3395
3396
3404void
3406 const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar,
3407 const struct GNUNET_CRYPTO_CsBlindingSecret *bs,
3408 struct GNUNET_CRYPTO_CsS *signature_scalar);
3409
3410
3423 const struct GNUNET_CRYPTO_CsSignature *sig,
3424 const struct GNUNET_CRYPTO_CsPublicKey *pub,
3425 const void *msg,
3426 size_t msg_len);
3427
3428
3433{
3434
3439
3444
3450
3451
3456{
3457
3462
3466 unsigned int rc;
3467
3471 union
3472 {
3477
3482
3484
3485};
3486
3487
3493{
3494
3499
3503 unsigned int rc;
3504
3508 union
3509 {
3516
3521
3523
3524};
3525
3526
3531{
3532
3537
3541 unsigned int rc;
3542
3547
3551 union
3552 {
3557
3562
3564};
3565
3566
3571{
3572
3577
3581 unsigned int rc;
3582
3586 union
3587 {
3592
3597
3599};
3600
3601
3606{
3611
3615 unsigned int rc;
3616
3620 union
3621 {
3626
3631
3633};
3634
3635
3640{
3642};
3643
3644
3649{
3650
3655
3659 unsigned int rc;
3660
3664 union
3665 {
3670
3672
3673};
3674
3675
3681{
3686};
3687
3688
3700 const struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv,
3701 const union GNUNET_CRYPTO_BlindSessionNonce *nonce,
3702 const char *salt);
3703
3704
3710void
3712 struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub);
3713
3714
3720void
3722 struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv);
3723
3724
3730void
3732 struct GNUNET_CRYPTO_UnblindedSignature *ub_sig);
3733
3734
3740void
3742 struct GNUNET_CRYPTO_BlindedSignature *blind_sig);
3743
3744
3750void
3752 struct GNUNET_CRYPTO_BlindedMessage *bm);
3753
3754
3763 struct GNUNET_CRYPTO_BlindedMessage *bm);
3764
3765
3775
3776
3783void
3786
3787
3796 struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub);
3797
3798
3807 struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv);
3808
3809
3818
3819
3828 struct GNUNET_CRYPTO_BlindedSignature *blind_sig);
3829
3830
3838int
3840 const struct GNUNET_CRYPTO_BlindSignPublicKey *bp1,
3841 const struct GNUNET_CRYPTO_BlindSignPublicKey *bp2);
3842
3843
3851int
3853 const struct GNUNET_CRYPTO_UnblindedSignature *sig2);
3854
3855
3863int
3865 const struct GNUNET_CRYPTO_BlindedSignature *sig1,
3866 const struct GNUNET_CRYPTO_BlindedSignature *sig2);
3867
3868
3876int
3878 const struct GNUNET_CRYPTO_BlindedMessage *bp1,
3879 const struct GNUNET_CRYPTO_BlindedMessage *bp2);
3880
3881
3897 struct GNUNET_CRYPTO_BlindSignPrivateKey **bsign_priv,
3898 struct GNUNET_CRYPTO_BlindSignPublicKey **bsign_pub,
3900 ...);
3901
3902
3918 struct GNUNET_CRYPTO_BlindSignPrivateKey **bsign_priv,
3919 struct GNUNET_CRYPTO_BlindSignPublicKey **bsign_pub,
3921 va_list ap);
3922
3923
3928{
3933
3938};
3939
3940
3955 const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub,
3956 const union GNUNET_CRYPTO_BlindingSecretP *bks,
3957 const union GNUNET_CRYPTO_BlindSessionNonce *nonce,
3958 const void *message,
3959 size_t message_size,
3960 const struct GNUNET_CRYPTO_BlindingInputValues *alg_values);
3961
3962
3974 const struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv,
3975 const char *salt,
3976 const struct GNUNET_CRYPTO_BlindedMessage *blinded_message);
3977
3978
3992 const struct GNUNET_CRYPTO_BlindedSignature *blinded_sig,
3993 const union GNUNET_CRYPTO_BlindingSecretP *bks,
3994 const void *message,
3995 size_t message_size,
3996 const struct GNUNET_CRYPTO_BlindingInputValues *alg_values,
3997 const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub);
3998
3999
4011 const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub,
4012 const struct GNUNET_CRYPTO_UnblindedSignature *ub_sig,
4013 const void *message,
4014 size_t message_size);
4015
4016
4027ssize_t
4030
4046 const void *buffer,
4047 size_t len,
4049 size_t *read);
4050
4061ssize_t
4063 const struct GNUNET_CRYPTO_PrivateKey *key);
4064
4065
4078ssize_t
4081 void*buffer,
4082 size_t len);
4083
4084
4099 const void*buffer,
4100 size_t len,
4102 size_t *read);
4103
4104
4117ssize_t
4119 const struct GNUNET_CRYPTO_PrivateKey *key,
4120 void*buffer,
4121 size_t len);
4122
4123
4134ssize_t
4136 const struct GNUNET_CRYPTO_Signature *sig);
4137
4138
4149ssize_t
4151
4152
4165ssize_t
4167 struct GNUNET_CRYPTO_Signature *sig,
4168 const void*buffer,
4169 size_t len);
4170
4171
4184ssize_t
4186 const struct GNUNET_CRYPTO_Signature *sig,
4187 void*buffer,
4188 size_t len);
4189
4190
4206 const struct GNUNET_CRYPTO_PrivateKey *priv,
4207 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
4208 struct GNUNET_CRYPTO_Signature *sig);
4209
4225 const struct GNUNET_CRYPTO_PrivateKey *priv,
4226 const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
4227 unsigned char *sig);
4228
4229
4241#define GNUNET_CRYPTO_sign(priv,ps,sig) do { \
4242 /* check size is set correctly */ \
4243 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
4244 /* check 'ps' begins with the purpose */ \
4245 GNUNET_static_assert (((void*) (ps)) == \
4246 ((void*) &(ps)->purpose)); \
4247 GNUNET_assert (GNUNET_OK == \
4248 GNUNET_CRYPTO_sign_ (priv, \
4249 &(ps)->purpose, \
4250 sig)); \
4251} while (0)
4252
4253
4273 uint32_t purpose,
4274 const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
4275 const struct GNUNET_CRYPTO_Signature *sig,
4276 const struct GNUNET_CRYPTO_PublicKey *pub);
4277
4295 uint32_t purpose,
4296 const struct GNUNET_CRYPTO_EccSignaturePurpose *validate,
4297 const unsigned char *sig,
4298 const struct GNUNET_CRYPTO_PublicKey *pub);
4299
4300
4314#define GNUNET_CRYPTO_signature_verify(purp,ps,sig,pub) ({ \
4315 /* check size is set correctly */ \
4316 GNUNET_assert (ntohl ((ps)->purpose.size) == sizeof (*(ps))); \
4317 /* check 'ps' begins with the purpose */ \
4318 GNUNET_static_assert (((void*) (ps)) == \
4319 ((void*) &(ps)->purpose)); \
4320 GNUNET_CRYPTO_signature_verify_ (purp, \
4321 &(ps)->purpose, \
4322 sig, \
4323 pub); \
4324 })
4325
4326
4342ssize_t
4343GNUNET_CRYPTO_encrypt_old (const void *block,
4344 size_t size,
4345 const struct GNUNET_CRYPTO_PublicKey *pub,
4346 struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
4347 void *result);
4348
4349
4364ssize_t
4366 const void *block,
4367 size_t size,
4368 const struct GNUNET_CRYPTO_PrivateKey *priv,
4369 const struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
4370 void *result);
4371
4372#define GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES (crypto_secretbox_MACBYTES \
4373 + sizeof (struct \
4374 GNUNET_CRYPTO_FoKemC))
4375
4392GNUNET_CRYPTO_encrypt (const void *block,
4393 size_t size,
4394 const struct GNUNET_CRYPTO_PublicKey *pub,
4395 void *result,
4396 size_t result_size);
4397
4398
4411GNUNET_CRYPTO_decrypt (const void *block,
4412 size_t size,
4413 const struct GNUNET_CRYPTO_PrivateKey *priv,
4414 void *result,
4415 size_t result_size);
4416
4417
4426char *
4428 const struct GNUNET_CRYPTO_PublicKey *key);
4429
4430
4439char *
4441 const struct GNUNET_CRYPTO_PrivateKey *key);
4442
4443
4455
4456
4468
4469
4478GNUNET_CRYPTO_key_get_public (const struct
4479 GNUNET_CRYPTO_PrivateKey *privkey,
4481
4482#if 0 /* keep Emacsens' auto-indent happy */
4483{
4484#endif
4485#ifdef __cplusplus
4486}
4487#endif
4488
4489
4490/* ifndef GNUNET_CRYPTO_LIB_H */
4491#endif
4492 /* end of group addition */
4494
4495/* end of gnunet_crypto_lib.h */
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int ret
Final status code.
Definition: gnunet-arm.c:94
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static char * data
The data to insert into the dht.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_FS_Handle * ctx
static char * filename
static pa_context * context
Pulseaudio context.
static OpusEncoder * enc
OPUS encoder.
struct GNUNET_CRYPTO_PrivateKey pk
Private key from command line option, or NULL.
static char * pkey
Public key of the zone to look in, in ASCII.
static char * res
Currently read line or NULL on EOF.
static uint32_t type
Type string converted to DNS type value.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static int result
Global testing status.
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:47
static struct GNUNET_CRYPTO_PowSalt salt
Salt for PoW calcualations.
Definition: gnunet-scrypt.c:34
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static enum @44 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_fo_kem_decaps(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_FoKemC *c, struct GNUNET_HashCode *key_material)
Decapsulate key material using a CCA-secure KEM.
Definition: crypto_ecc.c:924
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_ecdh(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a public and a private ECC key.
Definition: crypto_ecc.c:714
void GNUNET_CRYPTO_ecdhe_key_create(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:436
void GNUNET_CRYPTO_edx25519_key_get_public(const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv, struct GNUNET_CRYPTO_Edx25519PublicKey *pub)
Extract the public key for the given private key.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_sign_by_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
Sign a given block with a specific purpose using the host's peer identity.
struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_private_key_derive(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const char *label, const char *context)
Derive a private key from a given private key and a label.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_kem_decaps(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *c, struct GNUNET_HashCode *key_material)
Decapsulate a key for a private EdDSA key.
Definition: crypto_ecc.c:749
void GNUNET_CRYPTO_eddsa_private_key_derive(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const char *label, const char *context, struct GNUNET_CRYPTO_EddsaPrivateScalar *result)
Derive a private scalar from a given private key and a label.
void GNUNET_CRYPTO_symmetric_create_session_key(struct GNUNET_CRYPTO_SymmetricSessionKey *key)
Create a new random session key.
void GNUNET_CRYPTO_edx25519_key_clear(struct GNUNET_CRYPTO_Edx25519PrivateKey *pk)
Clear memory that was used to store a private key.
bool GNUNET_CRYPTO_ecdhe_elligator_encoding(struct GNUNET_CRYPTO_ElligatorRepresentative *r, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, bool high_y)
Encodes a point on Curve25519 to a an element of the underlying finite field.
void GNUNET_CRYPTO_edx25519_private_key_derive(const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv, const void *seed, size_t seedsize, struct GNUNET_CRYPTO_Edx25519PrivateKey *result)
Derive a private scalar from a given private key and a label.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_elligator_kem_encaps(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_CRYPTO_ElligatorRepresentative *r, struct GNUNET_HashCode *key_material)
Carries out ecdh encapsulation with given public key and the private key from a freshly created ephem...
void GNUNET_CRYPTO_edx25519_key_create_from_seed(const void *seed, size_t seedsize, struct GNUNET_CRYPTO_Edx25519PrivateKey *pk)
Create a new private key for Edx25519 from a given seed.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_key_from_file(const char *filename, int do_create, struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey)
Create a new private key by reading it from a file.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_fo_kem_encaps(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_CRYPTO_FoKemC *c, struct GNUNET_HashCode *key_material)
Encapsulate key material using a CCA-secure KEM.
Definition: crypto_ecc.c:840
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_key_from_file(const char *filename, int do_create, struct GNUNET_CRYPTO_EddsaPrivateKey *pkey)
Create a new private key by reading it from a file.
void GNUNET_CRYPTO_edx25519_public_key_derive(const struct GNUNET_CRYPTO_Edx25519PublicKey *pub, const void *seed, size_t seedsize, struct GNUNET_CRYPTO_Edx25519PublicKey *result)
Derive a public key from a given public key and a label.
void GNUNET_CRYPTO_random_timeflake(enum GNUNET_CRYPTO_Quality mode, struct GNUNET_Uuid *uuid)
Fill UUID with a timeflake pseudo-random value.
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:198
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_ecdh(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a ECDH public key and a private ECDSA key.
Definition: crypto_ecc.c:759
void GNUNET_CRYPTO_eddsa_key_clear(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Clear memory that was used to store a private key.
Definition: crypto_ecc.c:429
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_sign_(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
ECDSA Sign a given block.
Definition: crypto_ecc.c:536
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_fo_kem_encaps(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, struct GNUNET_CRYPTO_FoKemC *c, struct GNUNET_HashCode *key_material)
Encapsulate key material using a CCA-secure KEM.
Definition: crypto_ecc.c:807
void GNUNET_CRYPTO_eddsa_setup_hostkey(const char *cfg_name)
Setup a hostkey file for a peer given the name of the configuration file (!).
ssize_t GNUNET_CRYPTO_symmetric_encrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Encrypt a block using a symmetric sessionkey.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_kem_encaps(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_CRYPTO_EcdhePublicKey *c, struct GNUNET_HashCode *key_material)
Encapsulate key material for a EdDSA public key.
Definition: crypto_ecc.c:794
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_ecdh(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a ECDH public key and a private EdDSA key.
Definition: crypto_ecc.c:727
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdh_ecdsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a EcDSA public key and a private ECDH key.
Definition: crypto_ecc.c:940
void GNUNET_CRYPTO_eddsa_key_create(struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:462
void GNUNET_CRYPTO_symmetric_derive_iv(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, const void *salt, size_t salt_len,...)
Derive an IV.
void GNUNET_CRYPTO_ecdhe_elligator_decoding(struct GNUNET_CRYPTO_EcdhePublicKey *point, bool *high_y, const struct GNUNET_CRYPTO_ElligatorRepresentative *representative)
Clears the most significant bit and second most significant bit of the serialized representaive befor...
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdh_eddsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a EdDSA public key and a private ECDH key.
Definition: crypto_ecc.c:777
GNUNET_CRYPTO_Quality
Desired quality level for random numbers.
void GNUNET_CRYPTO_ecdhe_elligator_key_create(struct GNUNET_CRYPTO_ElligatorRepresentative *repr, struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Generates a private key for Curve25519 and the elligator representative of the corresponding public k...
void GNUNET_CRYPTO_seed_weak_random(int32_t seed)
Seed a weak random generator.
Definition: crypto_random.c:91
void GNUNET_CRYPTO_ecdsa_key_create(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:447
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
EdDSA sign a given block.
Definition: crypto_ecc.c:607
void GNUNET_CRYPTO_ecdsa_key_clear(struct GNUNET_CRYPTO_EcdsaPrivateKey *pk)
Clear memory that was used to store a private key.
Definition: crypto_ecc.c:422
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EcdsaSignature *sig, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Verify ECDSA signature.
Definition: crypto_ecc.c:631
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_fo_kem_decaps(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_FoKemC *c, struct GNUNET_HashCode *key_material)
Decapsulate key material using a CCA-secure KEM.
Definition: crypto_ecc.c:908
void GNUNET_CRYPTO_eddsa_public_key_derive(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EddsaPublicKey *result)
Derive a public key from a given public key and a label.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_key_get_anonymous(void)
Get the shared private key we use for anonymous users.
Definition: crypto_ecc.c:482
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
void GNUNET_CRYPTO_edx25519_key_create(struct GNUNET_CRYPTO_Edx25519PrivateKey *pk)
Create a new private key.
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:187
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Verify EdDSA signature.
Definition: crypto_ecc.c:690
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_edx25519_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_Edx25519Signature *sig, const struct GNUNET_CRYPTO_Edx25519PublicKey *pub)
Verify Edx25519 signature.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_edx25519_sign_(const struct GNUNET_CRYPTO_Edx25519PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_Edx25519Signature *sig)
Edx25519 sign a given block.
unsigned int * GNUNET_CRYPTO_random_permute(enum GNUNET_CRYPTO_Quality mode, unsigned int n)
Get an array with a random permutation of the numbers 0...n-1.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_elligator_kem_decaps(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_ElligatorRepresentative *r, struct GNUNET_HashCode *key_material)
Carries out ecdh decapsulation with own private key and the representative of the received public key...
void GNUNET_CRYPTO_zero_keys(void *buffer, size_t length)
Zero out buffer, securely against compiler optimizations.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_get_peer_identity(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *dst)
Retrieve the identity of the host's peer.
void GNUNET_CRYPTO_ecdhe_key_clear(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Clear memory that was used to store a private key.
Definition: crypto_ecc.c:415
void GNUNET_CRYPTO_ecdhe_key_get_public(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, struct GNUNET_CRYPTO_EcdhePublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:214
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdhe_elligator_generate_public_key(struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Generates a valid public key for elligator's inverse map by adding a lower order point to a prime ord...
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_verify_peer_identity(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_PeerIdentity *identity)
Verify a given signature with a peer's identity.
ssize_t GNUNET_CRYPTO_symmetric_decrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Decrypt a given block using a symmetric sessionkey.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
@ GNUNET_CRYPTO_QUALITY_STRONG
High-quality operations are desired.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
void GNUNET_CRYPTO_hash_difference(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
compute result = b - a
Definition: crypto_hash.c:111
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
struct GNUNET_CRYPTO_FileHashContext * GNUNET_CRYPTO_hash_file(enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
Compute the hash of an entire file.
void GNUNET_CRYPTO_hash_to_enc(const struct GNUNET_HashCode *block, struct GNUNET_CRYPTO_HashAsciiEncoded *result)
Convert hash to ASCII encoding.
Definition: crypto_hash.c:55
void GNUNET_CRYPTO_hash_create_random(enum GNUNET_CRYPTO_Quality mode, struct GNUNET_HashCode *result)
Create a random hash code.
Definition: crypto_hash.c:100
int32_t GNUNET_CRYPTO_crc32_n(const void *buf, size_t len)
Compute the CRC32 checksum for the first len bytes of the buffer.
Definition: crypto_crc.c:99
void GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104)
Definition: crypto_hash.c:330
void GNUNET_CRYPTO_hash_sum(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *delta, struct GNUNET_HashCode *result)
compute result = a + delta
Definition: crypto_hash.c:123
void GNUNET_CRYPTO_hash_xor(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b, struct GNUNET_HashCode *result)
compute result = a ^ b
Definition: crypto_hash.c:135
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_v(void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len, va_list argp)
Derive key.
Definition: crypto_hkdf.c:166
uint8_t GNUNET_CRYPTO_crc8_n(const void *buf, size_t len)
Calculate the checksum of a buffer in one step.
Definition: crypto_crc.c:151
int GNUNET_CRYPTO_hash_xorcmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2, const struct GNUNET_HashCode *target)
Find out which of the two GNUNET_CRYPTO_hash codes is closer to target in the XOR metric (Kademlia).
Definition: crypto_hash.c:243
void GNUNET_CRYPTO_hmac_derive_key_v(struct GNUNET_CRYPTO_AuthKey *key, const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey, const void *salt, size_t salt_len, va_list argp)
Derive an authentication key.
Definition: crypto_hash.c:286
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf(void *result, size_t out_len, int xtr_algo, int prf_algo, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_hkdf.c:341
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hash_from_string2(const char *enc, size_t enclen, struct GNUNET_HashCode *result)
Convert ASCII encoding back to a 'struct GNUNET_HashCode'.
Definition: crypto_hash.c:72
uint16_t GNUNET_CRYPTO_crc16_n(const void *buf, size_t len)
Calculate the checksum of a buffer in one step.
Definition: crypto_crc.c:133
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:221
uint32_t GNUNET_CRYPTO_hash_distance_u32(const struct GNUNET_HashCode *a, const struct GNUNET_HashCode *b)
Compute the distance between 2 hashcodes.
Definition: crypto_hash.c:89
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_kdf.c:70
void GNUNET_CRYPTO_hmac_derive_key(struct GNUNET_CRYPTO_AuthKey *key, const struct GNUNET_CRYPTO_SymmetricSessionKey *rkey, const void *salt, size_t salt_len,...)
Derive an authentication key.
Definition: crypto_hash.c:267
void GNUNET_CRYPTO_hash_to_aes_key(const struct GNUNET_HashCode *hc, struct GNUNET_CRYPTO_SymmetricSessionKey *skey, struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
Convert a hashcode into a key.
Definition: crypto_hash.c:152
char * GNUNET_CRYPTO_eddsa_private_key_to_string(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
Convert a private key to a string.
Definition: crypto_ecc.c:279
unsigned int GNUNET_CRYPTO_hash_count_leading_zeros(const struct GNUNET_HashCode *h)
Count the number of leading 0 bits in h.
Definition: crypto_hash.c:177
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_sign_raw_(const struct GNUNET_CRYPTO_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, unsigned char *sig)
Sign a given block.
Definition: crypto_pkey.c:264
struct GNUNET_CRYPTO_BlindSignPrivateKey * GNUNET_CRYPTO_bsign_priv_incref(struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv)
Increment reference counter of the given bsign_priv.
#define GNUNET_CRYPTO_HASH_LENGTH
Length of a hash value.
void(* GNUNET_CRYPTO_HashCompletedCallback)(void *cls, const struct GNUNET_HashCode *res)
Function called once the hash computation over the specified file has completed.
void GNUNET_CRYPTO_blinded_message_decref(struct GNUNET_CRYPTO_BlindedMessage *bm)
Decrement reference counter of a bm, and free it if it reaches zero.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_signature_verify_raw_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const unsigned char *sig, const struct GNUNET_CRYPTO_PublicKey *pub)
Verify a given signature.
Definition: crypto_pkey.c:346
void GNUNET_CRYPTO_mpi_scan_unsigned(gcry_mpi_t *result, const void *data, size_t size)
Convert data buffer into MPI value.
Definition: crypto_mpi.c:132
#define GNUNET_NETWORK_STRUCT_BEGIN
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32.
int GNUNET_CRYPTO_paillier_hom_get_remaining(const struct GNUNET_CRYPTO_PaillierCiphertext *c)
Get the number of remaining supported homomorphic operations.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_raw(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, void *data, size_t size, struct GNUNET_CRYPTO_EddsaSignature *sig)
Definition: crypto_ecc.c:586
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_blind_sign_keys_create(struct GNUNET_CRYPTO_BlindSignPrivateKey **bsign_priv, struct GNUNET_CRYPTO_BlindSignPublicKey **bsign_pub, enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher,...)
Initialize public-private key pair for blind signatures.
ssize_t GNUNET_CRYPTO_read_signature_from_buffer(struct GNUNET_CRYPTO_Signature *sig, const void *buffer, size_t len)
Reads a GNUNET_CRYPTO_Signature from a compact buffer.
Definition: crypto_pkey.c:226
ssize_t GNUNET_CRYPTO_public_key_get_length(const struct GNUNET_CRYPTO_PublicKey *key)
Get the compacted length of a GNUNET_CRYPTO_PublicKey.
Definition: crypto_pkey.c:68
void GNUNET_CRYPTO_ecc_rnd_mpi(struct GNUNET_CRYPTO_EccScalar *r, struct GNUNET_CRYPTO_EccScalar *r_neg)
Obtain a random scalar for point multiplication on the curve and its additive inverse.
#define GNUNET_CRYPTO_PAILLIER_BITS
Size of paillier plain texts and public keys.
void GNUNET_CRYPTO_rsa_signature_free(struct GNUNET_CRYPTO_RsaSignature *sig)
Free memory occupied by signature.
Definition: crypto_rsa.c:1015
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_rsa_blind(const void *message, size_t message_size, const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks, struct GNUNET_CRYPTO_RsaPublicKey *pkey, struct GNUNET_CRYPTO_RsaBlindedMessage *bm)
Blinds the given message with the given blinding key.
Definition: crypto_rsa.c:807
GNUNET_CRYPTO_KeyType
Key type for the generic public key union.
struct GNUNET_CRYPTO_BlindedSignature * GNUNET_CRYPTO_blind_sig_incref(struct GNUNET_CRYPTO_BlindedSignature *blind_sig)
Increment reference counter of the given blind_sig.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_signature_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_Signature *sig, const struct GNUNET_CRYPTO_PublicKey *pub)
Verify a given signature.
Definition: crypto_pkey.c:317
void GNUNET_CRYPTO_cs_r_get_public(const struct GNUNET_CRYPTO_CsRSecret *r_priv, struct GNUNET_CRYPTO_CsRPublic *r_pub)
Extract the public R of the given secret r.
Definition: crypto_cs.c:98
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_dexp_mpi(const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing v...
struct GNUNET_CRYPTO_RsaPrivateKey * GNUNET_CRYPTO_rsa_private_key_create(unsigned int len)
Create a new private key.
Definition: crypto_rsa.c:144
void GNUNET_CRYPTO_rsa_private_key_free(struct GNUNET_CRYPTO_RsaPrivateKey *key)
Free memory occupied by the private key.
Definition: crypto_rsa.c:173
int GNUNET_CRYPTO_bsign_pub_cmp(const struct GNUNET_CRYPTO_BlindSignPublicKey *bp1, const struct GNUNET_CRYPTO_BlindSignPublicKey *bp2)
Compare two denomination public keys.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_pmul_mpi(const struct GNUNET_CRYPTO_EccPoint *p, const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the point p on the elliptic curve by val.
struct GNUNET_CRYPTO_UnblindedSignature * GNUNET_CRYPTO_blind_sig_unblind(const struct GNUNET_CRYPTO_BlindedSignature *blinded_sig, const union GNUNET_CRYPTO_BlindingSecretP *bks, const void *message, size_t message_size, const struct GNUNET_CRYPTO_BlindingInputValues *alg_values, const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub)
Unblind blind signature.
ssize_t GNUNET_CRYPTO_decrypt_old(const void *block, size_t size, const struct GNUNET_CRYPTO_PrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
Decrypt a given block with GNUNET_CRYPTO_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ec...
Definition: crypto_pkey.c:516
void GNUNET_CRYPTO_kdf_mod_mpi(gcry_mpi_t *r, gcry_mpi_t n, const void *xts, size_t xts_len, const void *skm, size_t skm_len, const char *ctx)
Deterministically generate a pseudo-random number uniformly from the integers modulo a libgcrypt mpi.
Definition: crypto_kdf.c:95
struct GNUNET_CRYPTO_BlindedSignature * GNUNET_CRYPTO_blind_sign(const struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv, const char *salt, const struct GNUNET_CRYPTO_BlindedMessage *blinded_message)
Create blind signature.
char * GNUNET_CRYPTO_public_key_to_string(const struct GNUNET_CRYPTO_PublicKey *key)
Creates a (Base32) string representation of the public key.
Definition: crypto_pkey.c:551
struct GNUNET_CRYPTO_RsaSignature * GNUNET_CRYPTO_rsa_signature_dup(const struct GNUNET_CRYPTO_RsaSignature *sig)
Duplicate the given rsa signature.
Definition: crypto_rsa.c:1268
void GNUNET_CRYPTO_cs_r_derive(const struct GNUNET_CRYPTO_CsSessionNonce *nonce, const char *seed, const struct GNUNET_CRYPTO_CsPrivateKey *lts, struct GNUNET_CRYPTO_CsRSecret r[2])
Derive a new secret r pair r0 and r1.
Definition: crypto_cs.c:79
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:333
int GNUNET_CRYPTO_ecc_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *input)
Calculate ECC discrete logarithm for small factors.
struct GNUNET_CRYPTO_RsaSignature * GNUNET_CRYPTO_rsa_signature_decode(const void *buf, size_t buf_size)
Decode the signature from the data-format back to the "normal", internal format.
Definition: crypto_rsa.c:1063
GNUNET_CRYPTO_BlindSignatureAlgorithm
Types of public keys used for blind signatures.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_encrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_PublicKey *pub, void *result, size_t result_size)
Encrypt a block with GNUNET_CRYPTO_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is requ...
Definition: crypto_pkey.c:416
struct GNUNET_CRYPTO_UnblindedSignature * GNUNET_CRYPTO_ub_sig_incref(struct GNUNET_CRYPTO_UnblindedSignature *ub_sig)
Increment reference counter of the given ub_sig.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_private_key_from_string(const char *str, struct GNUNET_CRYPTO_PrivateKey *key)
Parses a (Base32) string representation of the private key.
Definition: crypto_pkey.c:587
void GNUNET_CRYPTO_hash_context_read(struct GNUNET_HashContext *hc, const void *buf, size_t size)
Add data to be hashed.
Definition: crypto_hash.c:366
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_derived(const struct GNUNET_CRYPTO_EddsaPrivateKey *pkey, const char *label, const char *context, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
This is a signature function for EdDSA which takes a private key and derives it using the label and c...
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_copy(const struct GNUNET_HashContext *hc)
Make a copy of the hash computation.
Definition: crypto_hash.c:377
uint16_t GNUNET_CRYPTO_crc16_finish(uint32_t sum)
Convert results from GNUNET_CRYPTO_crc16_step to final crc16.
Definition: crypto_crc.c:123
struct GNUNET_CRYPTO_RsaPublicKey * GNUNET_CRYPTO_rsa_public_key_decode(const char *buf, size_t len)
Decode the public key from the data-format back to the "normal", internal format.
Definition: crypto_rsa.c:423
int GNUNET_CRYPTO_ub_sig_cmp(const struct GNUNET_CRYPTO_UnblindedSignature *sig1, const struct GNUNET_CRYPTO_UnblindedSignature *sig2)
Compare two denomination signatures.
ssize_t GNUNET_CRYPTO_write_public_key_to_buffer(const struct GNUNET_CRYPTO_PublicKey *key, void *buffer, size_t len)
Writes a GNUNET_CRYPTO_PublicKey to a compact buffer.
Definition: crypto_pkey.c:128
struct GNUNET_CRYPTO_BlindedMessage * GNUNET_CRYPTO_message_blind_to_sign(const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub, const union GNUNET_CRYPTO_BlindingSecretP *bks, const union GNUNET_CRYPTO_BlindSessionNonce *nonce, const void *message, size_t message_size, const struct GNUNET_CRYPTO_BlindingInputValues *alg_values)
Blind message for blind signing with dk using blinding secret coin_bks.
int GNUNET_CRYPTO_blinded_message_cmp(const struct GNUNET_CRYPTO_BlindedMessage *bp1, const struct GNUNET_CRYPTO_BlindedMessage *bp2)
Compare two blinded messages.
int GNUNET_CRYPTO_rsa_signature_cmp(const struct GNUNET_CRYPTO_RsaSignature *s1, const struct GNUNET_CRYPTO_RsaSignature *s2)
Compare the values of two signatures.
Definition: crypto_rsa.c:602
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_key_get_public(const struct GNUNET_CRYPTO_PrivateKey *privkey, struct GNUNET_CRYPTO_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: crypto_pkey.c:602
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_sign_(const struct GNUNET_CRYPTO_PrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_Signature *sig)
Sign a given block.
Definition: crypto_pkey.c:291
int GNUNET_CRYPTO_blind_sig_cmp(const struct GNUNET_CRYPTO_BlindedSignature *sig1, const struct GNUNET_CRYPTO_BlindedSignature *sig2)
Compare two blinded denomination signatures.
void GNUNET_CRYPTO_cs_private_key_get_public(const struct GNUNET_CRYPTO_CsPrivateKey *priv, struct GNUNET_CRYPTO_CsPublicKey *pub)
Extract the public key of the given private key.
Definition: crypto_cs.c:52
uint32_t GNUNET_CRYPTO_crc16_step(uint32_t sum, const void *buf, size_t len)
Perform an incremental step in a CRC16 (for TCP/IP) calculation.
Definition: crypto_crc.c:110
void GNUNET_CRYPTO_cs_unblind(const struct GNUNET_CRYPTO_CsBlindS *blinded_signature_scalar, const struct GNUNET_CRYPTO_CsBlindingSecret *bs, struct GNUNET_CRYPTO_CsS *signature_scalar)
Unblind a blind-signed signature using a c that was blinded.
Definition: crypto_cs.c:321
int GNUNET_CRYPTO_paillier_encrypt(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const gcry_mpi_t m, int desired_ops, struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
Encrypt a plaintext with a paillier public key.
bool GNUNET_CRYPTO_rsa_public_key_check(const struct GNUNET_CRYPTO_RsaPublicKey *key)
Check if key is well-formed.
Definition: crypto_rsa.c:301
#define GNUNET_CRYPTO_AES_KEY_LENGTH
length of the sessionkey in bytes (256 BIT sessionkey)
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf_v(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len, va_list argp)
Derive key.
Definition: crypto_kdf.c:38
char * GNUNET_CRYPTO_eddsa_public_key_to_string(const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:252
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_blind_sign_keys_create_va(struct GNUNET_CRYPTO_BlindSignPrivateKey **bsign_priv, struct GNUNET_CRYPTO_BlindSignPublicKey **bsign_pub, enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher, va_list ap)
Initialize public-private key pair for blind signatures.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:358
unsigned int GNUNET_CRYPTO_rsa_public_key_len(const struct GNUNET_CRYPTO_RsaPublicKey *key)
Obtain the length of the RSA key in bits.
Definition: crypto_rsa.c:680
void GNUNET_CRYPTO_rsa_blinded_message_free(struct GNUNET_CRYPTO_RsaBlindedMessage *bm)
Free memory occupied by blinded message.
Definition: crypto_rsa.c:799
char * GNUNET_CRYPTO_private_key_to_string(const struct GNUNET_CRYPTO_PrivateKey *key)
Creates a (Base32) string representation of the private key.
Definition: crypto_pkey.c:561
struct GNUNET_CRYPTO_RsaPublicKey * GNUNET_CRYPTO_rsa_public_key_dup(const struct GNUNET_CRYPTO_RsaPublicKey *key)
Duplicate the given public key.
Definition: crypto_rsa.c:1099
struct GNUNET_CRYPTO_RsaSignature * GNUNET_CRYPTO_rsa_sign_fdh(const struct GNUNET_CRYPTO_RsaPrivateKey *key, const void *message, size_t message_size)
Create and sign a full domain hash of a message.
Definition: crypto_rsa.c:992
ssize_t GNUNET_CRYPTO_encrypt_old(const void *block, size_t size, const struct GNUNET_CRYPTO_PublicKey *pub, struct GNUNET_CRYPTO_EcdhePublicKey *ecc, void *result)
Encrypt a block with GNUNET_CRYPTO_PublicKey and derives a GNUNET_CRYPTO_EcdhePublicKey which is requ...
Definition: crypto_pkey.c:377
ssize_t GNUNET_CRYPTO_signature_get_raw_length_by_type(uint32_t type)
Get the compacted length of a signature by type.
Definition: crypto_pkey.c:208
void GNUNET_CRYPTO_rsa_public_key_hash(const struct GNUNET_CRYPTO_RsaPublicKey *key, struct GNUNET_HashCode *hc)
Compute hash over the public key.
Definition: crypto_rsa.c:407
struct GNUNET_CRYPTO_RsaPrivateKey * GNUNET_CRYPTO_rsa_private_key_decode(const void *buf, size_t buf_size)
Decode the private key from the data-format back to the "normal", internal format.
Definition: crypto_rsa.c:204
void GNUNET_CRYPTO_hash_context_abort(struct GNUNET_HashContext *hc)
Abort hashing, do not bother calculating final result.
Definition: crypto_hash.c:408
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_sign_derived(const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, const char *context, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
This is a signature function for ECDSA which takes a private key, derives/blinds it and signs the mes...
void GNUNET_CRYPTO_pow_hash(const struct GNUNET_CRYPTO_PowSalt *salt, const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
Calculate the 'proof-of-work' hash (an expensive hash).
Definition: crypto_pow.c:42
void GNUNET_CRYPTO_rsa_public_key_free(struct GNUNET_CRYPTO_RsaPublicKey *key)
Free memory occupied by the public key.
Definition: crypto_rsa.c:268
void GNUNET_CRYPTO_mpi_print_unsigned(void *buf, size_t size, gcry_mpi_t val)
Output the given MPI value to the given buffer in network byte order.
Definition: crypto_mpi.c:79
GNUNET_SCHEDULER_Priority
Valid task priorities.
ssize_t GNUNET_CRYPTO_write_signature_to_buffer(const struct GNUNET_CRYPTO_Signature *sig, void *buffer, size_t len)
Writes a GNUNET_CRYPTO_Signature to a compact buffer.
Definition: crypto_pkey.c:246
#define GNUNET_NETWORK_STRUCT_END
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;.
void GNUNET_CRYPTO_cs_calc_blinded_c(const struct GNUNET_CRYPTO_CsBlindingSecret bs[2], const struct GNUNET_CRYPTO_CsRPublic r_pub[2], const struct GNUNET_CRYPTO_CsPublicKey *pub, const void *msg, size_t msg_len, struct GNUNET_CRYPTO_CsC blinded_c[2], struct GNUNET_CRYPTO_CSPublicRPairP *r_pub_blind)
Calculate two blinded c's.
Definition: crypto_cs.c:241
size_t GNUNET_CRYPTO_rsa_public_key_encode(const struct GNUNET_CRYPTO_RsaPublicKey *key, void **buffer)
Encode the public key in a format suitable for storing it into a file.
Definition: crypto_rsa.c:325
void GNUNET_CRYPTO_paillier_create(struct GNUNET_CRYPTO_PaillierPublicKey *public_key, struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
Create a freshly generated paillier public key.
ssize_t GNUNET_CRYPTO_private_key_get_length(const struct GNUNET_CRYPTO_PrivateKey *key)
Get the compacted length of a GNUNET_CRYPTO_PrivateKey.
Definition: crypto_pkey.c:47
void GNUNET_CRYPTO_eddsa_key_get_public_from_scalar(const struct GNUNET_CRYPTO_EddsaPrivateScalar *s, struct GNUNET_CRYPTO_EddsaPublicKey *pkey)
Extract the public key of the given private scalar.
int GNUNET_CRYPTO_rsa_private_key_cmp(const struct GNUNET_CRYPTO_RsaPrivateKey *p1, const struct GNUNET_CRYPTO_RsaPrivateKey *p2)
Compare the values of two private keys.
Definition: crypto_rsa.c:654
void GNUNET_CRYPTO_blinding_input_values_decref(struct GNUNET_CRYPTO_BlindingInputValues *bm)
Decrement reference counter of the given bi, and free it if it reaches zero.
void GNUNET_CRYPTO_hash_context_finish(struct GNUNET_HashContext *hc, struct GNUNET_HashCode *r_hash)
Finish the hash computation.
Definition: crypto_hash.c:390
size_t GNUNET_CRYPTO_rsa_signature_encode(const struct GNUNET_CRYPTO_RsaSignature *sig, void **buffer)
Encode the given signature in a format suitable for storing it into a file.
Definition: crypto_rsa.c:1023
void GNUNET_CRYPTO_ecc_dexp(int val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing v...
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_blind_sig_verify(const struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub, const struct GNUNET_CRYPTO_UnblindedSignature *ub_sig, const void *message, size_t message_size)
Verify signature made blindly.
struct GNUNET_CRYPTO_BlindingInputValues * GNUNET_CRYPTO_blinding_input_values_incref(struct GNUNET_CRYPTO_BlindingInputValues *bm)
Increment reference counter of the given bi.
void GNUNET_CRYPTO_symmetric_derive_iv_v(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const struct GNUNET_CRYPTO_SymmetricSessionKey *skey, const void *salt, size_t salt_len, va_list argp)
Derive an IV.
ssize_t GNUNET_CRYPTO_write_private_key_to_buffer(const struct GNUNET_CRYPTO_PrivateKey *key, void *buffer, size_t len)
Writes a GNUNET_CRYPTO_PrivateKey to a compact buffer.
Definition: crypto_pkey.c:171
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
struct GNUNET_CRYPTO_EccDlogContext * GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max, unsigned int mem)
Do pre-calculation for ECC discrete logarithm for small factors.
char * GNUNET_CRYPTO_ecdsa_public_key_to_string(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:225
void GNUNET_CRYPTO_unblinded_sig_decref(struct GNUNET_CRYPTO_UnblindedSignature *ub_sig)
Decrement reference counter of a ub_sig, and free it if it reaches zero.
int GNUNET_CRYPTO_paillier_hom_add(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *c1, const struct GNUNET_CRYPTO_PaillierCiphertext *c2, struct GNUNET_CRYPTO_PaillierCiphertext *result)
Compute a ciphertext that represents the sum of the plaintext in c1 and c2.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_decrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_PrivateKey *priv, void *result, size_t result_size)
Decrypt a given block with GNUNET_CRYPTO_PrivateKey and a given GNUNET_CRYPTO_EcdhePublicKey using ec...
Definition: crypto_pkey.c:467
struct GNUNET_CRYPTO_RsaSignature * GNUNET_CRYPTO_rsa_sign_blinded(const struct GNUNET_CRYPTO_RsaPrivateKey *key, const struct GNUNET_CRYPTO_RsaBlindedMessage *bm)
Sign a blinded value, which must be a full domain hash of a message.
Definition: crypto_rsa.c:970
struct GNUNET_CRYPTO_BlindedMessage * GNUNET_CRYPTO_blinded_message_incref(struct GNUNET_CRYPTO_BlindedMessage *bm)
Increment reference counter of the given bm.
ssize_t GNUNET_CRYPTO_signature_get_length(const struct GNUNET_CRYPTO_Signature *sig)
Get the compacted length of a GNUNET_CRYPTO_Signature.
Definition: crypto_pkey.c:189
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_private_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
Convert a string representing a private key to a private key.
Definition: crypto_ecc.c:383
void GNUNET_CRYPTO_blinded_sig_decref(struct GNUNET_CRYPTO_BlindedSignature *blind_sig)
Decrement reference counter of a blind_sig, and free it if it reaches zero.
unsigned int GNUNET_CRYPTO_hash_count_tailing_zeros(const struct GNUNET_HashCode *h)
Count the number of tailing 0 bits in h.
Definition: crypto_hash.c:199
char * GNUNET_CRYPTO_ecdsa_private_key_to_string(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv)
Convert a private key to a string.
Definition: crypto_ecc.c:306
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_rnd(struct GNUNET_CRYPTO_EccPoint *r, struct GNUNET_CRYPTO_EccPoint *r_inv)
Obtain a random point on the curve and its additive inverse.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_cs_verify(const struct GNUNET_CRYPTO_CsSignature *sig, const struct GNUNET_CRYPTO_CsPublicKey *pub, const void *msg, size_t msg_len)
Verify whether the given message corresponds to the given signature and the signature is valid with r...
Definition: crypto_cs.c:333
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_CRYPTO_PublicKey *key, size_t *read)
Reads a GNUNET_CRYPTO_PublicKey from a compact buffer.
Definition: crypto_pkey.c:103
int GNUNET_CRYPTO_rsa_public_key_cmp(const struct GNUNET_CRYPTO_RsaPublicKey *p1, const struct GNUNET_CRYPTO_RsaPublicKey *p2)
Compare the values of two public keys.
Definition: crypto_rsa.c:628
void GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccScalar *r)
Generate a random value mod n.
struct GNUNET_CRYPTO_RsaPrivateKey * GNUNET_CRYPTO_rsa_private_key_dup(const struct GNUNET_CRYPTO_RsaPrivateKey *key)
Duplicate the given private key.
Definition: crypto_rsa.c:1248
void GNUNET_CRYPTO_paillier_decrypt(const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key, const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext, gcry_mpi_t m)
Decrypt a paillier ciphertext with a private key.
GNUNET_GenericReturnValue
Named constants for return values.
struct GNUNET_CRYPTO_BlindSignPublicKey * GNUNET_CRYPTO_bsign_pub_incref(struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub)
Increment reference counter of the given bsign_pub.
struct GNUNET_CRYPTO_RsaSignature * GNUNET_CRYPTO_rsa_unblind(const struct GNUNET_CRYPTO_RsaSignature *sig, const struct GNUNET_CRYPTO_RsaBlindingKeySecret *bks, struct GNUNET_CRYPTO_RsaPublicKey *pkey)
Unblind a blind-signed signature.
Definition: crypto_rsa.c:1118
struct GNUNET_CRYPTO_RsaPublicKey * GNUNET_CRYPTO_rsa_private_key_get_public(const struct GNUNET_CRYPTO_RsaPrivateKey *priv)
Extract the public key of the given private key.
Definition: crypto_rsa.c:233
void GNUNET_CRYPTO_blind_sign_pub_decref(struct GNUNET_CRYPTO_BlindSignPublicKey *bsign_pub)
Decrement reference counter of a bsign_pub, and free it if it reaches zero.
void GNUNET_CRYPTO_cs_sign_derive(const struct GNUNET_CRYPTO_CsPrivateKey *priv, const struct GNUNET_CRYPTO_CsRSecret r[2], const struct GNUNET_CRYPTO_CsBlindedMessage *bm, struct GNUNET_CRYPTO_CsBlindSignature *cs_blind_sig)
Sign a blinded c.
Definition: crypto_cs.c:285
void GNUNET_CRYPTO_cs_private_key_generate(struct GNUNET_CRYPTO_CsPrivateKey *priv)
Create a new random private key.
Definition: crypto_cs.c:45
void GNUNET_CRYPTO_blind_sign_priv_decref(struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv)
Decrement reference counter of a bsign_priv, and free it if it reaches zero.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_read_private_key_from_buffer(const void *buffer, size_t len, struct GNUNET_CRYPTO_PrivateKey *key, size_t *read)
Reads a GNUNET_CRYPTO_PrivateKey from a compact buffer.
Definition: crypto_pkey.c:146
struct GNUNET_HashContext * GNUNET_CRYPTO_hash_context_start(void)
Start incremental hashing operation.
Definition: crypto_hash.c:350
void GNUNET_CRYPTO_hmac_raw(const void *key, size_t key_len, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104) TODO: Shouldn't this be the standard hmac function and the abo...
Definition: crypto_hash.c:300
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_rsa_verify(const void *message, size_t message_size, const struct GNUNET_CRYPTO_RsaSignature *sig, const struct GNUNET_CRYPTO_RsaPublicKey *public_key)
Verify whether the given hash corresponds to the given signature and the signature is valid with resp...
Definition: crypto_rsa.c:1199
size_t GNUNET_CRYPTO_rsa_private_key_encode(const struct GNUNET_CRYPTO_RsaPrivateKey *key, void **buffer)
Encode the private key in a format suitable for storing it into a file.
Definition: crypto_rsa.c:181
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_public_key_from_string(const char *str, struct GNUNET_CRYPTO_PublicKey *key)
Parses a (Base32) string representation of the public key.
Definition: crypto_pkey.c:571
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_add(const struct GNUNET_CRYPTO_EccPoint *a, const struct GNUNET_CRYPTO_EccPoint *b, struct GNUNET_CRYPTO_EccPoint *r)
Add two points on the elliptic curve.
#define GNUNET_PACKED
gcc-ism to get packed structs.
struct GNUNET_CRYPTO_BlindingInputValues * GNUNET_CRYPTO_get_blinding_input_values(const struct GNUNET_CRYPTO_BlindSignPrivateKey *bsign_priv, const union GNUNET_CRYPTO_BlindSessionNonce *nonce, const char *salt)
Compute blinding input values for a given nonce and salt.
void GNUNET_CRYPTO_cs_blinding_secrets_derive(const struct GNUNET_CRYPTO_CsBlindingNonce *blind_seed, struct GNUNET_CRYPTO_CsBlindingSecret bs[2])
Derives new random blinding factors.
Definition: crypto_cs.c:108
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
@ GNUNET_PUBLIC_KEY_TYPE_ECDSA
The identity type.
@ GNUNET_CRYPTO_BSA_INVALID
Invalid type of signature.
@ GNUNET_CRYPTO_BSA_CS
Clause Blind Schnorr signature.
@ GNUNET_CRYPTO_BSA_RSA
RSA blind signature.
#define max(x, y)
static unsigned int size
Size of the "table".
Definition: peer.c:68
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
type for (message) authentication keys
unsigned char key[(512/8)]
Type of private signing keys for blind signing.
struct GNUNET_CRYPTO_CsPrivateKey cs_private_key
If we use GNUNET_CRYPTO_BSA_CS in cipher.
unsigned int rc
Reference counter.
struct GNUNET_CRYPTO_RsaPrivateKey * rsa_private_key
If we use GNUNET_CRYPTO_BSA_RSA in cipher.
enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher
Type of the public key.
union GNUNET_CRYPTO_BlindSignPrivateKey::@17 details
Details, depending on cipher.
Type of public signing keys for blind signatures.
union GNUNET_CRYPTO_BlindSignPublicKey::@16 details
Details, depending on cipher.
unsigned int rc
Reference counter.
struct GNUNET_HashCode pub_key_hash
Hash of the public key.
struct GNUNET_CRYPTO_CsPublicKey cs_public_key
If we use GNUNET_CRYPTO_BSA_CS in cipher.
enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher
Type of the public key.
struct GNUNET_CRYPTO_RsaPublicKey * rsa_public_key
If we use GNUNET_CRYPTO_BSA_RSA in cipher.
Blinded message ready for blind signing.
unsigned int rc
Reference counter.
enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher
Type of the sign blinded message.
struct GNUNET_CRYPTO_CsBlindedMessage cs_blinded_message
If we use GNUNET_CRYPTO_BSA_CS in cipher.
union GNUNET_CRYPTO_BlindedMessage::@18 details
Details, depending on cipher.
struct GNUNET_CRYPTO_RsaBlindedMessage rsa_blinded_message
If we use GNUNET_CRYPTO_BSA_RSA in cipher.
Type for blinded signatures.
unsigned int rc
Reference counter.
struct GNUNET_CRYPTO_CsBlindSignature blinded_cs_answer
If we use GNUNET_CRYPTO_BSA_CS in cipher.
union GNUNET_CRYPTO_BlindedSignature::@15 details
Details, depending on cipher.
enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher
Type of the signature.
struct GNUNET_CRYPTO_RsaSignature * blinded_rsa_signature
If we use GNUNET_CRYPTO_BSA_RSA in cipher.
Input needed for blinding a message.
unsigned int rc
Reference counter.
struct GNUNET_CRYPTO_CSPublicRPairP cs_values
If we use GNUNET_CRYPTO_BSA_CS in cipher.
union GNUNET_CRYPTO_BlindingInputValues::@19 details
Details, depending on cipher.
enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher
Type of the signature.
Secret r for Cs denominations.
struct GNUNET_CRYPTO_CsRSecret r[2]
Pair of Public R values for Cs denominations.
struct GNUNET_CRYPTO_CsRPublic r_pub[2]
Type of a nonce used for challenges.
struct GNUNET_ShortHashCode value
The value of the nonce.
unsigned char y[crypto_core_ed25519_BYTES]
This is a point on the Curve25519.
unsigned char d[crypto_core_ed25519_SCALARBYTES]
32 byte scalar
blinded s in the signature
struct GNUNET_CRYPTO_Cs25519Scalar scalar
The Sign Answer for Clause Blind Schnorr signature.
struct GNUNET_CRYPTO_CsBlindS s_scalar
The blinded s scalar calculated from c_b.
unsigned int b
To make ROS problem harder, the signer chooses an unpredictable b and only calculates signature of c_...
CS Parameters derived from the message during blinding to create blinded signature.
struct GNUNET_CRYPTO_CsC c[2]
The Clause Schnorr c_0 and c_1 containing the blinded message.
struct GNUNET_CRYPTO_CsSessionNonce nonce
Nonce used in initial request.
Nonce for computing blinding factors.
Secret used for blinding (alpha and beta).
struct GNUNET_CRYPTO_Cs25519Scalar alpha
struct GNUNET_CRYPTO_Cs25519Scalar beta
Schnorr c to be signed.
struct GNUNET_CRYPTO_Cs25519Scalar scalar
The private information of an Schnorr key pair.
struct GNUNET_CRYPTO_Cs25519Scalar scalar
The public information of an Schnorr key pair.
struct GNUNET_CRYPTO_Cs25519Point point
the public R (derived from r) used in c
struct GNUNET_CRYPTO_Cs25519Point point
the private r used in the signature
struct GNUNET_CRYPTO_Cs25519Scalar scalar
s in the signature
struct GNUNET_CRYPTO_Cs25519Scalar scalar
Nonce for the session, picked by client, shared with the signer.
CS Signtature containing scalar s and point R.
struct GNUNET_CRYPTO_CsS s_scalar
Schnorr signatures are composed of a scalar s and a curve point.
struct GNUNET_CRYPTO_CsRPublic r_point
Curve point of the Schnorr signature.
Internal structure used to cache pre-calculated values for DLOG calculation.
unsigned int mem
How much memory should we use (relates to the number of entries in the map).
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
unsigned char v[256/8]
Q consists of an x- and a y-value, each mod p (256 bits), given here in affine coordinates and Ed2551...
A ECC scalar for use in point multiplications.
unsigned char v[256/8]
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Private ECC key encoded for transmission.
unsigned char d[256/8]
d is a value mod n, where n has at most 256 bits.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and encr...
unsigned char q_y[256/8]
Q consists of an x- and a y-value, each mod p (256 bits), given here in affine coordinates and Ed2551...
Private ECC key encoded for transmission.
unsigned char d[256/8]
d is a value mod n, where n has at most 256 bits.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
unsigned char q_y[256/8]
Q consists of an x- and a y-value, each mod p (256 bits), given here in affine coordinates and Ed2551...
an ECC signature using ECDSA
unsigned char s[256/8]
S value.
unsigned char r[256/8]
R value.
Private ECC key encoded for transmission.
unsigned char d[256/8]
d is a value mod n, where n has at most 256 bits.
Private ECC scalar encoded for transmission.
unsigned char s[512/8]
s is the expandedprivate 512-bit scalar of a private key.
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
unsigned char q_y[256/8]
Point Q consists of a y-value mod p (256 bits); the x-value is always positive.
an ECC signature using EdDSA.
unsigned char s[256/8]
S value.
unsigned char r[256/8]
R value.
Private ECC key material encoded for transmission.
unsigned char b[256/8]
b consists of 32 bytes which where originally the lower 32bytes of the key expansion.
unsigned char a[256/8]
a is a value mod n, where n has at most 256 bits.
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
unsigned char q_y[256/8]
Point Q consists of a y-value mod p (256 bits); the x-value is always positive.
an ECC signature using Edx25519 (same as in EdDSA).
unsigned char s[256/8]
S value.
unsigned char r[256/8]
R value.
Elligator representative (always for Curve25519)
unsigned char r[256/8]
Represents an element of Curve25519 finite field.
Context used when hashing a file.
GNUNET_CRYPTO_HashCompletedCallback callback
Function to call upon completion.
void * callback_cls
Closure for callback.
enum GNUNET_SCHEDULER_Priority priority
Priority we use.
This is the encapsulated key of our FO-KEM.
struct GNUNET_CRYPTO_EcdhePublicKey pub
struct GNUNET_HashCode y
0-terminated ASCII encoding of a struct GNUNET_HashCode.
int32_t remaining_ops
Guaranteed minimum number of homomorphic operations with this ciphertext, in network byte order (NBO)...
unsigned char bits[2048 *2/8]
The bits of the ciphertext.
unsigned char mu[2048/8]
Mu-component of the private key.
unsigned char lambda[2048/8]
Lambda-component of the private key.
unsigned char n[2048/8]
N value.
Value for a salt for GNUNET_CRYPTO_pow_hash().
char salt[crypto_pwhash_argon2id_SALTBYTES]
A private key for an identity as per LSD0001.
uint32_t type
Type of public key.
struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_key
AN EdDSA identtiy key.
struct GNUNET_CRYPTO_EcdsaPrivateKey ecdsa_key
An ECDSA identity key.
An identity key as per LSD0001.
uint32_t type
Type of public key.
struct GNUNET_CRYPTO_EcdsaPublicKey ecdsa_key
An ECDSA identity key.
struct GNUNET_CRYPTO_EddsaPublicKey eddsa_key
AN EdDSA identtiy key.
RSA Parameters to create blinded signature.
size_t blinded_msg_size
Size of the blinded_msg to be signed.
void * blinded_msg
Blinded message to be signed Note: is malloc()'ed!
Constant-size pre-secret for blinding key generation.
uint32_t pre_secret[8]
Bits used to generate the blinding key.
The private information of an RSA key pair.
Definition: crypto_rsa.c:41
The public information of an RSA key pair.
Definition: crypto_rsa.c:53
an RSA signature
Definition: crypto_rsa.c:65
An identity signature as per LSD0001.
struct GNUNET_CRYPTO_EddsaSignature eddsa_signature
AN EdDSA signature.
struct GNUNET_CRYPTO_EcdsaSignature ecdsa_signature
An ECDSA signature.
uint32_t type
Type of signature.
unsigned char twofish_key[(256/8)]
Actual key for TwoFish.
unsigned char aes_key[(256/8)]
Actual key for AES.
Type of (unblinded) signatures.
struct GNUNET_CRYPTO_RsaSignature * rsa_signature
If we use GNUNET_CRYPTO_BSA_RSA in cipher.
unsigned int rc
Reference counter.
union GNUNET_CRYPTO_UnblindedSignature::@14 details
Details, depending on cipher.
struct GNUNET_CRYPTO_CsSignature cs_signature
If we use GNUNET_CRYPTO_BSA_CS in cipher.
enum GNUNET_CRYPTO_BlindSignatureAlgorithm cipher
Type of the signature.
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
A 256-bit hashcode.
A UUID, a 128 bit "random" value.
Nonce used to deterministiacally derive input values used in multi-round blind signature protocols.
struct GNUNET_CRYPTO_CsSessionNonce cs_nonce
Nonce used when signing with CS.
Type of blinding secrets.
struct GNUNET_CRYPTO_CsBlindingNonce nonce
Clause Schnorr nonce.
struct GNUNET_CRYPTO_RsaBlindingKeySecret rsa_bks
Variant for RSA for blind signatures.