Branch data Line data Source code
1 : : /* gcrypt.h - GNU Cryptographic Library Interface -*- c -*-
2 : : Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006
3 : : 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 : :
5 : : This file is part of Libgcrypt.
6 : :
7 : : Libgcrypt is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU Lesser General Public License as
9 : : published by the Free Software Foundation; either version 2.1 of
10 : : the License, or (at your option) any later version.
11 : :
12 : : Libgcrypt is distributed in the hope that it will be useful,
13 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU Lesser General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU Lesser General Public
18 : : License along with this program; if not, see <http://www.gnu.org/licenses/>.
19 : :
20 : : File: src/gcrypt.h. Generated from gcrypt.h.in by configure. */
21 : :
22 : : #ifndef _GCRYPT_H
23 : : #define _GCRYPT_H
24 : :
25 : : #include <stdlib.h>
26 : : #include <stdarg.h>
27 : : #include <string.h>
28 : :
29 : : #include <gpg-error.h>
30 : :
31 : : #include <sys/types.h>
32 : :
33 : : #if defined _WIN32 || defined __WIN32__
34 : : # include <winsock2.h>
35 : : # include <ws2tcpip.h>
36 : : # include <time.h>
37 : : # ifndef __GNUC__
38 : : typedef long ssize_t;
39 : : typedef int pid_t;
40 : : # endif /*!__GNUC__*/
41 : : #else
42 : : # include <sys/socket.h>
43 : : # include <sys/time.h>
44 : : # include <sys/select.h>
45 : : #endif /*!_WIN32*/
46 : :
47 : : typedef socklen_t gcry_socklen_t;
48 : :
49 : : /* This is required for error code compatibility. */
50 : : #define _GCRY_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_GCRYPT
51 : :
52 : : #ifdef __cplusplus
53 : : extern "C" {
54 : : #if 0 /* (Keep Emacsens' auto-indent happy.) */
55 : : }
56 : : #endif
57 : : #endif
58 : :
59 : : /* The version of this header should match the one of the library. It
60 : : should not be used by a program because gcry_check_version() should
61 : : return the same version. The purpose of this macro is to let
62 : : autoconf (using the AM_PATH_GCRYPT macro) check that this header
63 : : matches the installed library. */
64 : : #define GCRYPT_VERSION "1.5.0"
65 : :
66 : : /* Internal: We can't use the convenience macros for the multi
67 : : precision integer functions when building this library. */
68 : : #ifdef _GCRYPT_IN_LIBGCRYPT
69 : : #ifndef GCRYPT_NO_MPI_MACROS
70 : : #define GCRYPT_NO_MPI_MACROS 1
71 : : #endif
72 : : #endif
73 : :
74 : : /* We want to use gcc attributes when possible. Warning: Don't use
75 : : these macros in your programs: As indicated by the leading
76 : : underscore they are subject to change without notice. */
77 : : #ifdef __GNUC__
78 : :
79 : : #define _GCRY_GCC_VERSION (__GNUC__ * 10000 \
80 : : + __GNUC_MINOR__ * 100 \
81 : : + __GNUC_PATCHLEVEL__)
82 : :
83 : : #if _GCRY_GCC_VERSION >= 30100
84 : : #define _GCRY_GCC_ATTR_DEPRECATED __attribute__ ((__deprecated__))
85 : : #endif
86 : :
87 : : #if _GCRY_GCC_VERSION >= 29600
88 : : #define _GCRY_GCC_ATTR_PURE __attribute__ ((__pure__))
89 : : #endif
90 : :
91 : : #if _GCRY_GCC_VERSION >= 30200
92 : : #define _GCRY_GCC_ATTR_MALLOC __attribute__ ((__malloc__))
93 : : #endif
94 : :
95 : : #endif /*__GNUC__*/
96 : :
97 : : #ifndef _GCRY_GCC_ATTR_DEPRECATED
98 : : #define _GCRY_GCC_ATTR_DEPRECATED
99 : : #endif
100 : : #ifndef _GCRY_GCC_ATTR_PURE
101 : : #define _GCRY_GCC_ATTR_PURE
102 : : #endif
103 : : #ifndef _GCRY_GCC_ATTR_MALLOC
104 : : #define _GCRY_GCC_ATTR_MALLOC
105 : : #endif
106 : :
107 : : /* Make up an attribute to mark functions and types as deprecated but
108 : : allow internal use by Libgcrypt. */
109 : : #ifdef _GCRYPT_IN_LIBGCRYPT
110 : : #define _GCRY_ATTR_INTERNAL
111 : : #else
112 : : #define _GCRY_ATTR_INTERNAL _GCRY_GCC_ATTR_DEPRECATED
113 : : #endif
114 : :
115 : : /* Wrappers for the libgpg-error library. */
116 : :
117 : : typedef gpg_error_t gcry_error_t;
118 : : typedef gpg_err_code_t gcry_err_code_t;
119 : : typedef gpg_err_source_t gcry_err_source_t;
120 : :
121 : : static GPG_ERR_INLINE gcry_error_t
122 : : gcry_err_make (gcry_err_source_t source, gcry_err_code_t code)
123 : : {
124 : : return gpg_err_make (source, code);
125 : : }
126 : :
127 : : /* The user can define GPG_ERR_SOURCE_DEFAULT before including this
128 : : file to specify a default source for gpg_error. */
129 : : #ifndef GCRY_ERR_SOURCE_DEFAULT
130 : : #define GCRY_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_USER_1
131 : : #endif
132 : :
133 : : static GPG_ERR_INLINE gcry_error_t
134 : : gcry_error (gcry_err_code_t code)
135 : : {
136 : : return gcry_err_make (GCRY_ERR_SOURCE_DEFAULT, code);
137 : : }
138 : :
139 : : static GPG_ERR_INLINE gcry_err_code_t
140 : 2 : gcry_err_code (gcry_error_t err)
141 : : {
142 : 2 : return gpg_err_code (err);
143 : : }
144 : :
145 : :
146 : : static GPG_ERR_INLINE gcry_err_source_t
147 : : gcry_err_source (gcry_error_t err)
148 : : {
149 : : return gpg_err_source (err);
150 : : }
151 : :
152 : : /* Return a pointer to a string containing a description of the error
153 : : code in the error value ERR. */
154 : : const char *gcry_strerror (gcry_error_t err);
155 : :
156 : : /* Return a pointer to a string containing a description of the error
157 : : source in the error value ERR. */
158 : : const char *gcry_strsource (gcry_error_t err);
159 : :
160 : : /* Retrieve the error code for the system error ERR. This returns
161 : : GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
162 : : this). */
163 : : gcry_err_code_t gcry_err_code_from_errno (int err);
164 : :
165 : : /* Retrieve the system error for the error code CODE. This returns 0
166 : : if CODE is not a system error code. */
167 : : int gcry_err_code_to_errno (gcry_err_code_t code);
168 : :
169 : : /* Return an error value with the error source SOURCE and the system
170 : : error ERR. */
171 : : gcry_error_t gcry_err_make_from_errno (gcry_err_source_t source, int err);
172 : :
173 : : /* Return an error value with the system error ERR. */
174 : : gcry_err_code_t gcry_error_from_errno (int err);
175 : :
176 : :
177 : : /* This enum is deprecated; it is only declared for the sake of
178 : : complete API compatibility. */
179 : : enum gcry_thread_option
180 : : {
181 : : _GCRY_THREAD_OPTION_DUMMY
182 : : } _GCRY_GCC_ATTR_DEPRECATED;
183 : :
184 : :
185 : : /* Constants defining the thread model to use. Used with the OPTION
186 : : field of the struct gcry_thread_cbs. */
187 : : #define GCRY_THREAD_OPTION_DEFAULT 0
188 : : #define GCRY_THREAD_OPTION_USER 1
189 : : #define GCRY_THREAD_OPTION_PTH 2
190 : : #define GCRY_THREAD_OPTION_PTHREAD 3
191 : :
192 : : /* The version number encoded in the OPTION field of the struct
193 : : gcry_thread_cbs. */
194 : : #define GCRY_THREAD_OPTION_VERSION 0
195 : :
196 : : /* Wrapper for struct ath_ops. */
197 : : struct gcry_thread_cbs
198 : : {
199 : : /* The OPTION field encodes the thread model and the version number
200 : : of this structure.
201 : : Bits 7 - 0 are used for the thread model
202 : : Bits 15 - 8 are used for the version number.
203 : : */
204 : : unsigned int option;
205 : :
206 : : int (*init) (void);
207 : : int (*mutex_init) (void **priv);
208 : : int (*mutex_destroy) (void **priv);
209 : : int (*mutex_lock) (void **priv);
210 : : int (*mutex_unlock) (void **priv);
211 : : ssize_t (*read) (int fd, void *buf, size_t nbytes);
212 : : ssize_t (*write) (int fd, const void *buf, size_t nbytes);
213 : : #ifdef _WIN32
214 : : ssize_t (*select) (int nfd, void *rset, void *wset, void *eset,
215 : : struct timeval *timeout);
216 : : ssize_t (*waitpid) (pid_t pid, int *status, int options);
217 : : int (*accept) (int s, void *addr, int *length_ptr);
218 : : int (*connect) (int s, void *addr, gcry_socklen_t length);
219 : : int (*sendmsg) (int s, const void *msg, int flags);
220 : : int (*recvmsg) (int s, void *msg, int flags);
221 : : #else
222 : : ssize_t (*select) (int nfd, fd_set *rset, fd_set *wset, fd_set *eset,
223 : : struct timeval *timeout);
224 : : ssize_t (*waitpid) (pid_t pid, int *status, int options);
225 : : int (*accept) (int s, struct sockaddr *addr, gcry_socklen_t *length_ptr);
226 : : int (*connect) (int s, struct sockaddr *addr, gcry_socklen_t length);
227 : : int (*sendmsg) (int s, const struct msghdr *msg, int flags);
228 : : int (*recvmsg) (int s, struct msghdr *msg, int flags);
229 : : #endif
230 : : };
231 : :
232 : : #ifdef _WIN32
233 : : # define _GCRY_THREAD_OPTION_PTH_IMPL_NET \
234 : : static ssize_t gcry_pth_select (int nfd, void *rset, void *wset, \
235 : : void *eset, struct timeval *timeout) \
236 : : { return pth_select (nfd, rset, wset, eset, timeout); } \
237 : : static ssize_t gcry_pth_waitpid (pid_t pid, int *status, int options) \
238 : : { return pth_waitpid (pid, status, options); } \
239 : : static int gcry_pth_accept (int s, void *addr, \
240 : : gcry_socklen_t *length_ptr) \
241 : : { return pth_accept (s, addr, length_ptr); } \
242 : : static int gcry_pth_connect (int s, void *addr, \
243 : : gcry_socklen_t length) \
244 : : { return pth_connect (s, addr, length); }
245 : : #else /*!_WIN32*/
246 : : # define _GCRY_THREAD_OPTION_PTH_IMPL_NET \
247 : : static ssize_t gcry_pth_select (int nfd, fd_set *rset, fd_set *wset, \
248 : : fd_set *eset, struct timeval *timeout) \
249 : : { return pth_select (nfd, rset, wset, eset, timeout); } \
250 : : static ssize_t gcry_pth_waitpid (pid_t pid, int *status, int options) \
251 : : { return pth_waitpid (pid, status, options); } \
252 : : static int gcry_pth_accept (int s, struct sockaddr *addr, \
253 : : gcry_socklen_t *length_ptr) \
254 : : { return pth_accept (s, addr, length_ptr); } \
255 : : static int gcry_pth_connect (int s, struct sockaddr *addr, \
256 : : gcry_socklen_t length) \
257 : : { return pth_connect (s, addr, length); }
258 : : #endif /*!_WIN32*/
259 : :
260 : :
261 : :
262 : : #define GCRY_THREAD_OPTION_PTH_IMPL \
263 : : static int gcry_pth_init (void) \
264 : : { return (pth_init () == FALSE) ? errno : 0; } \
265 : : static int gcry_pth_mutex_init (void **priv) \
266 : : { \
267 : : int err = 0; \
268 : : pth_mutex_t *lock = malloc (sizeof (pth_mutex_t)); \
269 : : \
270 : : if (!lock) \
271 : : err = ENOMEM; \
272 : : if (!err) \
273 : : { \
274 : : err = pth_mutex_init (lock); \
275 : : if (err == FALSE) \
276 : : err = errno; \
277 : : else \
278 : : err = 0; \
279 : : if (err) \
280 : : free (lock); \
281 : : else \
282 : : *priv = lock; \
283 : : } \
284 : : return err; \
285 : : } \
286 : : static int gcry_pth_mutex_destroy (void **lock) \
287 : : { /* GNU Pth has no destructor function. */ free (*lock); return 0; } \
288 : : static int gcry_pth_mutex_lock (void **lock) \
289 : : { return ((pth_mutex_acquire (*lock, 0, NULL)) == FALSE) \
290 : : ? errno : 0; } \
291 : : static int gcry_pth_mutex_unlock (void **lock) \
292 : : { return ((pth_mutex_release (*lock)) == FALSE) \
293 : : ? errno : 0; } \
294 : : static ssize_t gcry_pth_read (int fd, void *buf, size_t nbytes) \
295 : : { return pth_read (fd, buf, nbytes); } \
296 : : static ssize_t gcry_pth_write (int fd, const void *buf, size_t nbytes) \
297 : : { return pth_write (fd, buf, nbytes); } \
298 : : _GCRY_THREAD_OPTION_PTH_IMPL_NET \
299 : : \
300 : : /* Note: GNU Pth is missing pth_sendmsg and pth_recvmsg. */ \
301 : : static struct gcry_thread_cbs gcry_threads_pth = { \
302 : : (GCRY_THREAD_OPTION_PTH | (GCRY_THREAD_OPTION_VERSION << 8)), \
303 : : gcry_pth_init, gcry_pth_mutex_init, gcry_pth_mutex_destroy, \
304 : : gcry_pth_mutex_lock, gcry_pth_mutex_unlock, gcry_pth_read, gcry_pth_write, \
305 : : gcry_pth_select, gcry_pth_waitpid, gcry_pth_accept, gcry_pth_connect, \
306 : : NULL, NULL }
307 : :
308 : :
309 : : #define GCRY_THREAD_OPTION_PTHREAD_IMPL \
310 : : static int gcry_pthread_mutex_init (void **priv) \
311 : : { \
312 : : int err = 0; \
313 : : pthread_mutex_t *lock = (pthread_mutex_t*)malloc (sizeof (pthread_mutex_t));\
314 : : \
315 : : if (!lock) \
316 : : err = ENOMEM; \
317 : : if (!err) \
318 : : { \
319 : : err = pthread_mutex_init (lock, NULL); \
320 : : if (err) \
321 : : free (lock); \
322 : : else \
323 : : *priv = lock; \
324 : : } \
325 : : return err; \
326 : : } \
327 : : static int gcry_pthread_mutex_destroy (void **lock) \
328 : : { int err = pthread_mutex_destroy ((pthread_mutex_t*)*lock); \
329 : : free (*lock); return err; } \
330 : : static int gcry_pthread_mutex_lock (void **lock) \
331 : : { return pthread_mutex_lock ((pthread_mutex_t*)*lock); } \
332 : : static int gcry_pthread_mutex_unlock (void **lock) \
333 : : { return pthread_mutex_unlock ((pthread_mutex_t*)*lock); } \
334 : : \
335 : : static struct gcry_thread_cbs gcry_threads_pthread = { \
336 : : (GCRY_THREAD_OPTION_PTHREAD | (GCRY_THREAD_OPTION_VERSION << 8)), \
337 : : NULL, gcry_pthread_mutex_init, gcry_pthread_mutex_destroy, \
338 : : gcry_pthread_mutex_lock, gcry_pthread_mutex_unlock, \
339 : : NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
340 : :
341 : :
342 : : /* The data object used to hold a multi precision integer. */
343 : : struct gcry_mpi;
344 : : typedef struct gcry_mpi *gcry_mpi_t;
345 : :
346 : : #ifndef GCRYPT_NO_DEPRECATED
347 : : typedef struct gcry_mpi *GCRY_MPI _GCRY_GCC_ATTR_DEPRECATED;
348 : : typedef struct gcry_mpi *GcryMPI _GCRY_GCC_ATTR_DEPRECATED;
349 : : #endif
350 : :
351 : :
352 : :
353 : : /* Check that the library fulfills the version requirement. */
354 : : const char *gcry_check_version (const char *req_version);
355 : :
356 : : /* Codes for function dispatchers. */
357 : :
358 : : /* Codes used with the gcry_control function. */
359 : : enum gcry_ctl_cmds
360 : : {
361 : : GCRYCTL_SET_KEY = 1,
362 : : GCRYCTL_SET_IV = 2,
363 : : GCRYCTL_CFB_SYNC = 3,
364 : : GCRYCTL_RESET = 4, /* e.g. for MDs */
365 : : GCRYCTL_FINALIZE = 5,
366 : : GCRYCTL_GET_KEYLEN = 6,
367 : : GCRYCTL_GET_BLKLEN = 7,
368 : : GCRYCTL_TEST_ALGO = 8,
369 : : GCRYCTL_IS_SECURE = 9,
370 : : GCRYCTL_GET_ASNOID = 10,
371 : : GCRYCTL_ENABLE_ALGO = 11,
372 : : GCRYCTL_DISABLE_ALGO = 12,
373 : : GCRYCTL_DUMP_RANDOM_STATS = 13,
374 : : GCRYCTL_DUMP_SECMEM_STATS = 14,
375 : : GCRYCTL_GET_ALGO_NPKEY = 15,
376 : : GCRYCTL_GET_ALGO_NSKEY = 16,
377 : : GCRYCTL_GET_ALGO_NSIGN = 17,
378 : : GCRYCTL_GET_ALGO_NENCR = 18,
379 : : GCRYCTL_SET_VERBOSITY = 19,
380 : : GCRYCTL_SET_DEBUG_FLAGS = 20,
381 : : GCRYCTL_CLEAR_DEBUG_FLAGS = 21,
382 : : GCRYCTL_USE_SECURE_RNDPOOL= 22,
383 : : GCRYCTL_DUMP_MEMORY_STATS = 23,
384 : : GCRYCTL_INIT_SECMEM = 24,
385 : : GCRYCTL_TERM_SECMEM = 25,
386 : : GCRYCTL_DISABLE_SECMEM_WARN = 27,
387 : : GCRYCTL_SUSPEND_SECMEM_WARN = 28,
388 : : GCRYCTL_RESUME_SECMEM_WARN = 29,
389 : : GCRYCTL_DROP_PRIVS = 30,
390 : : GCRYCTL_ENABLE_M_GUARD = 31,
391 : : GCRYCTL_START_DUMP = 32,
392 : : GCRYCTL_STOP_DUMP = 33,
393 : : GCRYCTL_GET_ALGO_USAGE = 34,
394 : : GCRYCTL_IS_ALGO_ENABLED = 35,
395 : : GCRYCTL_DISABLE_INTERNAL_LOCKING = 36,
396 : : GCRYCTL_DISABLE_SECMEM = 37,
397 : : GCRYCTL_INITIALIZATION_FINISHED = 38,
398 : : GCRYCTL_INITIALIZATION_FINISHED_P = 39,
399 : : GCRYCTL_ANY_INITIALIZATION_P = 40,
400 : : GCRYCTL_SET_CBC_CTS = 41,
401 : : GCRYCTL_SET_CBC_MAC = 42,
402 : : GCRYCTL_SET_CTR = 43,
403 : : GCRYCTL_ENABLE_QUICK_RANDOM = 44,
404 : : GCRYCTL_SET_RANDOM_SEED_FILE = 45,
405 : : GCRYCTL_UPDATE_RANDOM_SEED_FILE = 46,
406 : : GCRYCTL_SET_THREAD_CBS = 47,
407 : : GCRYCTL_FAST_POLL = 48,
408 : : GCRYCTL_SET_RANDOM_DAEMON_SOCKET = 49,
409 : : GCRYCTL_USE_RANDOM_DAEMON = 50,
410 : : GCRYCTL_FAKED_RANDOM_P = 51,
411 : : GCRYCTL_SET_RNDEGD_SOCKET = 52,
412 : : GCRYCTL_PRINT_CONFIG = 53,
413 : : GCRYCTL_OPERATIONAL_P = 54,
414 : : GCRYCTL_FIPS_MODE_P = 55,
415 : : GCRYCTL_FORCE_FIPS_MODE = 56,
416 : : GCRYCTL_SELFTEST = 57,
417 : : /* Note: 58 .. 62 are used internally. */
418 : : GCRYCTL_DISABLE_HWF = 63
419 : : };
420 : :
421 : : /* Perform various operations defined by CMD. */
422 : : gcry_error_t gcry_control (enum gcry_ctl_cmds CMD, ...);
423 : :
424 : :
425 : : /* S-expression management. */
426 : :
427 : : /* The object to represent an S-expression as used with the public key
428 : : functions. */
429 : : struct gcry_sexp;
430 : : typedef struct gcry_sexp *gcry_sexp_t;
431 : :
432 : : #ifndef GCRYPT_NO_DEPRECATED
433 : : typedef struct gcry_sexp *GCRY_SEXP _GCRY_GCC_ATTR_DEPRECATED;
434 : : typedef struct gcry_sexp *GcrySexp _GCRY_GCC_ATTR_DEPRECATED;
435 : : #endif
436 : :
437 : : /* The possible values for the S-expression format. */
438 : : enum gcry_sexp_format
439 : : {
440 : : GCRYSEXP_FMT_DEFAULT = 0,
441 : : GCRYSEXP_FMT_CANON = 1,
442 : : GCRYSEXP_FMT_BASE64 = 2,
443 : : GCRYSEXP_FMT_ADVANCED = 3
444 : : };
445 : :
446 : : /* Create an new S-expression object from BUFFER of size LENGTH and
447 : : return it in RETSEXP. With AUTODETECT set to 0 the data in BUFFER
448 : : is expected to be in canonized format. */
449 : : gcry_error_t gcry_sexp_new (gcry_sexp_t *retsexp,
450 : : const void *buffer, size_t length,
451 : : int autodetect);
452 : :
453 : : /* Same as gcry_sexp_new but allows to pass a FREEFNC which has the
454 : : effect to transfer ownership of BUFFER to the created object. */
455 : : gcry_error_t gcry_sexp_create (gcry_sexp_t *retsexp,
456 : : void *buffer, size_t length,
457 : : int autodetect, void (*freefnc) (void *));
458 : :
459 : : /* Scan BUFFER and return a new S-expression object in RETSEXP. This
460 : : function expects a printf like string in BUFFER. */
461 : : gcry_error_t gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
462 : : const char *buffer, size_t length);
463 : :
464 : : /* Same as gcry_sexp_sscan but expects a string in FORMAT and can thus
465 : : only be used for certain encodings. */
466 : : gcry_error_t gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
467 : : const char *format, ...);
468 : :
469 : : /* Like gcry_sexp_build, but uses an array instead of variable
470 : : function arguments. */
471 : : gcry_error_t gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
472 : : const char *format, void **arg_list);
473 : :
474 : : /* Release the S-expression object SEXP */
475 : : void gcry_sexp_release (gcry_sexp_t sexp);
476 : :
477 : : /* Calculate the length of an canonized S-expresion in BUFFER and
478 : : check for a valid encoding. */
479 : : size_t gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
480 : : size_t *erroff, gcry_error_t *errcode);
481 : :
482 : : /* Copies the S-expression object SEXP into BUFFER using the format
483 : : specified in MODE. */
484 : : size_t gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer,
485 : : size_t maxlength);
486 : :
487 : : /* Dumps the S-expression object A in a format suitable for debugging
488 : : to Libgcrypt's logging stream. */
489 : : void gcry_sexp_dump (const gcry_sexp_t a);
490 : :
491 : : gcry_sexp_t gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b);
492 : : gcry_sexp_t gcry_sexp_alist (const gcry_sexp_t *array);
493 : : gcry_sexp_t gcry_sexp_vlist (const gcry_sexp_t a, ...);
494 : : gcry_sexp_t gcry_sexp_append (const gcry_sexp_t a, const gcry_sexp_t n);
495 : : gcry_sexp_t gcry_sexp_prepend (const gcry_sexp_t a, const gcry_sexp_t n);
496 : :
497 : : /* Scan the S-expression for a sublist with a type (the car of the
498 : : list) matching the string TOKEN. If TOKLEN is not 0, the token is
499 : : assumed to be raw memory of this length. The function returns a
500 : : newly allocated S-expression consisting of the found sublist or
501 : : `NULL' when not found. */
502 : : gcry_sexp_t gcry_sexp_find_token (gcry_sexp_t list,
503 : : const char *tok, size_t toklen);
504 : : /* Return the length of the LIST. For a valid S-expression this
505 : : should be at least 1. */
506 : : int gcry_sexp_length (const gcry_sexp_t list);
507 : :
508 : : /* Create and return a new S-expression from the element with index
509 : : NUMBER in LIST. Note that the first element has the index 0. If
510 : : there is no such element, `NULL' is returned. */
511 : : gcry_sexp_t gcry_sexp_nth (const gcry_sexp_t list, int number);
512 : :
513 : : /* Create and return a new S-expression from the first element in
514 : : LIST; this called the "type" and should always exist and be a
515 : : string. `NULL' is returned in case of a problem. */
516 : : gcry_sexp_t gcry_sexp_car (const gcry_sexp_t list);
517 : :
518 : : /* Create and return a new list form all elements except for the first
519 : : one. Note, that this function may return an invalid S-expression
520 : : because it is not guaranteed, that the type exists and is a string.
521 : : However, for parsing a complex S-expression it might be useful for
522 : : intermediate lists. Returns `NULL' on error. */
523 : : gcry_sexp_t gcry_sexp_cdr (const gcry_sexp_t list);
524 : :
525 : : gcry_sexp_t gcry_sexp_cadr (const gcry_sexp_t list);
526 : :
527 : :
528 : : /* This function is used to get data from a LIST. A pointer to the
529 : : actual data with index NUMBER is returned and the length of this
530 : : data will be stored to DATALEN. If there is no data at the given
531 : : index or the index represents another list, `NULL' is returned.
532 : : *Note:* The returned pointer is valid as long as LIST is not
533 : : modified or released. */
534 : : const char *gcry_sexp_nth_data (const gcry_sexp_t list, int number,
535 : : size_t *datalen);
536 : :
537 : : /* This function is used to get and convert data from a LIST. The
538 : : data is assumed to be a Nul terminated string. The caller must
539 : : release the returned value using `gcry_free'. If there is no data
540 : : at the given index, the index represents a list or the value can't
541 : : be converted to a string, `NULL' is returned. */
542 : : char *gcry_sexp_nth_string (gcry_sexp_t list, int number);
543 : :
544 : : /* This function is used to get and convert data from a LIST. This
545 : : data is assumed to be an MPI stored in the format described by
546 : : MPIFMT and returned as a standard Libgcrypt MPI. The caller must
547 : : release this returned value using `gcry_mpi_release'. If there is
548 : : no data at the given index, the index represents a list or the
549 : : value can't be converted to an MPI, `NULL' is returned. */
550 : : gcry_mpi_t gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt);
551 : :
552 : :
553 : :
554 : : /*******************************************
555 : : * *
556 : : * Multi Precision Integer Functions *
557 : : * *
558 : : *******************************************/
559 : :
560 : : /* Different formats of external big integer representation. */
561 : : enum gcry_mpi_format
562 : : {
563 : : GCRYMPI_FMT_NONE= 0,
564 : : GCRYMPI_FMT_STD = 1, /* Twos complement stored without length. */
565 : : GCRYMPI_FMT_PGP = 2, /* As used by OpenPGP (unsigned only). */
566 : : GCRYMPI_FMT_SSH = 3, /* As used by SSH (like STD but with length). */
567 : : GCRYMPI_FMT_HEX = 4, /* Hex format. */
568 : : GCRYMPI_FMT_USG = 5 /* Like STD but unsigned. */
569 : : };
570 : :
571 : : /* Flags used for creating big integers. */
572 : : enum gcry_mpi_flag
573 : : {
574 : : GCRYMPI_FLAG_SECURE = 1, /* Allocate the number in "secure" memory. */
575 : : GCRYMPI_FLAG_OPAQUE = 2 /* The number is not a real one but just
576 : : a way to store some bytes. This is
577 : : useful for encrypted big integers. */
578 : : };
579 : :
580 : :
581 : : /* Allocate a new big integer object, initialize it with 0 and
582 : : initially allocate memory for a number of at least NBITS. */
583 : : gcry_mpi_t gcry_mpi_new (unsigned int nbits);
584 : :
585 : : /* Same as gcry_mpi_new() but allocate in "secure" memory. */
586 : : gcry_mpi_t gcry_mpi_snew (unsigned int nbits);
587 : :
588 : : /* Release the number A and free all associated resources. */
589 : : void gcry_mpi_release (gcry_mpi_t a);
590 : :
591 : : /* Create a new number with the same value as A. */
592 : : gcry_mpi_t gcry_mpi_copy (const gcry_mpi_t a);
593 : :
594 : : /* Store the big integer value U in W. */
595 : : gcry_mpi_t gcry_mpi_set (gcry_mpi_t w, const gcry_mpi_t u);
596 : :
597 : : /* Store the unsigned integer value U in W. */
598 : : gcry_mpi_t gcry_mpi_set_ui (gcry_mpi_t w, unsigned long u);
599 : :
600 : : /* Swap the values of A and B. */
601 : : void gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b);
602 : :
603 : : /* Compare the big integer number U and V returning 0 for equality, a
604 : : positive value for U > V and a negative for U < V. */
605 : : int gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v);
606 : :
607 : : /* Compare the big integer number U with the unsigned integer V
608 : : returning 0 for equality, a positive value for U > V and a negative
609 : : for U < V. */
610 : : int gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v);
611 : :
612 : : /* Convert the external representation of an integer stored in BUFFER
613 : : with a length of BUFLEN into a newly create MPI returned in
614 : : RET_MPI. If NSCANNED is not NULL, it will receive the number of
615 : : bytes actually scanned after a successful operation. */
616 : : gcry_error_t gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
617 : : const void *buffer, size_t buflen,
618 : : size_t *nscanned);
619 : :
620 : : /* Convert the big integer A into the external representation
621 : : described by FORMAT and store it in the provided BUFFER which has
622 : : been allocated by the user with a size of BUFLEN bytes. NWRITTEN
623 : : receives the actual length of the external representation unless it
624 : : has been passed as NULL. */
625 : : gcry_error_t gcry_mpi_print (enum gcry_mpi_format format,
626 : : unsigned char *buffer, size_t buflen,
627 : : size_t *nwritten,
628 : : const gcry_mpi_t a);
629 : :
630 : : /* Convert the big integer A int the external representation described
631 : : by FORMAT and store it in a newly allocated buffer which address
632 : : will be put into BUFFER. NWRITTEN receives the actual lengths of the
633 : : external representation. */
634 : : gcry_error_t gcry_mpi_aprint (enum gcry_mpi_format format,
635 : : unsigned char **buffer, size_t *nwritten,
636 : : const gcry_mpi_t a);
637 : :
638 : : /* Dump the value of A in a format suitable for debugging to
639 : : Libgcrypt's logging stream. Note that one leading space but no
640 : : trailing space or linefeed will be printed. It is okay to pass
641 : : NULL for A. */
642 : : void gcry_mpi_dump (const gcry_mpi_t a);
643 : :
644 : :
645 : : /* W = U + V. */
646 : : void gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
647 : :
648 : : /* W = U + V. V is an unsigned integer. */
649 : : void gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v);
650 : :
651 : : /* W = U + V mod M. */
652 : : void gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m);
653 : :
654 : : /* W = U - V. */
655 : : void gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
656 : :
657 : : /* W = U - V. V is an unsigned integer. */
658 : : void gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v );
659 : :
660 : : /* W = U - V mod M */
661 : : void gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m);
662 : :
663 : : /* W = U * V. */
664 : : void gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
665 : :
666 : : /* W = U * V. V is an unsigned integer. */
667 : : void gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v );
668 : :
669 : : /* W = U * V mod M. */
670 : : void gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m);
671 : :
672 : : /* W = U * (2 ^ CNT). */
673 : : void gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt);
674 : :
675 : : /* Q = DIVIDEND / DIVISOR, R = DIVIDEND % DIVISOR,
676 : : Q or R may be passed as NULL. ROUND should be negative or 0. */
677 : : void gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r,
678 : : gcry_mpi_t dividend, gcry_mpi_t divisor, int round);
679 : :
680 : : /* R = DIVIDEND % DIVISOR */
681 : : void gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor);
682 : :
683 : : /* W = B ^ E mod M. */
684 : : void gcry_mpi_powm (gcry_mpi_t w,
685 : : const gcry_mpi_t b, const gcry_mpi_t e,
686 : : const gcry_mpi_t m);
687 : :
688 : : /* Set G to the greatest common divisor of A and B.
689 : : Return true if the G is 1. */
690 : : int gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b);
691 : :
692 : : /* Set X to the multiplicative inverse of A mod M.
693 : : Return true if the value exists. */
694 : : int gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m);
695 : :
696 : :
697 : : /* Return the number of bits required to represent A. */
698 : : unsigned int gcry_mpi_get_nbits (gcry_mpi_t a);
699 : :
700 : : /* Return true when bit number N (counting from 0) is set in A. */
701 : : int gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n);
702 : :
703 : : /* Set bit number N in A. */
704 : : void gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n);
705 : :
706 : : /* Clear bit number N in A. */
707 : : void gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n);
708 : :
709 : : /* Set bit number N in A and clear all bits greater than N. */
710 : : void gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n);
711 : :
712 : : /* Clear bit number N in A and all bits greater than N. */
713 : : void gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n);
714 : :
715 : : /* Shift the value of A by N bits to the right and store the result in X. */
716 : : void gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n);
717 : :
718 : : /* Shift the value of A by N bits to the left and store the result in X. */
719 : : void gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n);
720 : :
721 : : /* Store NBITS of the value P points to in A and mark A as an opaque
722 : : value. WARNING: Never use an opaque MPI for anything thing else then
723 : : gcry_mpi_release, gcry_mpi_get_opaque. */
724 : : gcry_mpi_t gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits);
725 : :
726 : : /* Return a pointer to an opaque value stored in A and return its size
727 : : in NBITS. Note that the returned pointer is still owned by A and
728 : : that the function should never be used for an non-opaque MPI. */
729 : : void *gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits);
730 : :
731 : : /* Set the FLAG for the big integer A. Currently only the flag
732 : : GCRYMPI_FLAG_SECURE is allowed to convert A into an big intger
733 : : stored in "secure" memory. */
734 : : void gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag);
735 : :
736 : : /* Clear FLAG for the big integer A. Note that this function is
737 : : currently useless as no flags are allowed. */
738 : : void gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag);
739 : :
740 : : /* Return true when the FLAG is set for A. */
741 : : int gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag);
742 : :
743 : : /* Unless the GCRYPT_NO_MPI_MACROS is used, provide a couple of
744 : : convenience macros for the big integer functions. */
745 : : #ifndef GCRYPT_NO_MPI_MACROS
746 : : #define mpi_new(n) gcry_mpi_new( (n) )
747 : : #define mpi_secure_new( n ) gcry_mpi_snew( (n) )
748 : : #define mpi_release(a) \
749 : : do \
750 : : { \
751 : : gcry_mpi_release ((a)); \
752 : : (a) = NULL; \
753 : : } \
754 : : while (0)
755 : :
756 : : #define mpi_copy( a ) gcry_mpi_copy( (a) )
757 : : #define mpi_set( w, u) gcry_mpi_set( (w), (u) )
758 : : #define mpi_set_ui( w, u) gcry_mpi_set_ui( (w), (u) )
759 : : #define mpi_cmp( u, v ) gcry_mpi_cmp( (u), (v) )
760 : : #define mpi_cmp_ui( u, v ) gcry_mpi_cmp_ui( (u), (v) )
761 : :
762 : : #define mpi_add_ui(w,u,v) gcry_mpi_add_ui((w),(u),(v))
763 : : #define mpi_add(w,u,v) gcry_mpi_add ((w),(u),(v))
764 : : #define mpi_addm(w,u,v,m) gcry_mpi_addm ((w),(u),(v),(m))
765 : : #define mpi_sub_ui(w,u,v) gcry_mpi_sub_ui ((w),(u),(v))
766 : : #define mpi_sub(w,u,v) gcry_mpi_sub ((w),(u),(v))
767 : : #define mpi_subm(w,u,v,m) gcry_mpi_subm ((w),(u),(v),(m))
768 : : #define mpi_mul_ui(w,u,v) gcry_mpi_mul_ui ((w),(u),(v))
769 : : #define mpi_mul_2exp(w,u,v) gcry_mpi_mul_2exp ((w),(u),(v))
770 : : #define mpi_mul(w,u,v) gcry_mpi_mul ((w),(u),(v))
771 : : #define mpi_mulm(w,u,v,m) gcry_mpi_mulm ((w),(u),(v),(m))
772 : : #define mpi_powm(w,b,e,m) gcry_mpi_powm ( (w), (b), (e), (m) )
773 : : #define mpi_tdiv(q,r,a,m) gcry_mpi_div ( (q), (r), (a), (m), 0)
774 : : #define mpi_fdiv(q,r,a,m) gcry_mpi_div ( (q), (r), (a), (m), -1)
775 : : #define mpi_mod(r,a,m) gcry_mpi_mod ((r), (a), (m))
776 : : #define mpi_gcd(g,a,b) gcry_mpi_gcd ( (g), (a), (b) )
777 : : #define mpi_invm(g,a,b) gcry_mpi_invm ( (g), (a), (b) )
778 : :
779 : : #define mpi_get_nbits(a) gcry_mpi_get_nbits ((a))
780 : : #define mpi_test_bit(a,b) gcry_mpi_test_bit ((a),(b))
781 : : #define mpi_set_bit(a,b) gcry_mpi_set_bit ((a),(b))
782 : : #define mpi_set_highbit(a,b) gcry_mpi_set_highbit ((a),(b))
783 : : #define mpi_clear_bit(a,b) gcry_mpi_clear_bit ((a),(b))
784 : : #define mpi_clear_highbit(a,b) gcry_mpi_clear_highbit ((a),(b))
785 : : #define mpi_rshift(a,b,c) gcry_mpi_rshift ((a),(b),(c))
786 : : #define mpi_lshift(a,b,c) gcry_mpi_lshift ((a),(b),(c))
787 : :
788 : : #define mpi_set_opaque(a,b,c) gcry_mpi_set_opaque( (a), (b), (c) )
789 : : #define mpi_get_opaque(a,b) gcry_mpi_get_opaque( (a), (b) )
790 : : #endif /* GCRYPT_NO_MPI_MACROS */
791 : :
792 : :
793 : :
794 : : /************************************
795 : : * *
796 : : * Symmetric Cipher Functions *
797 : : * *
798 : : ************************************/
799 : :
800 : : /* The data object used to hold a handle to an encryption object. */
801 : : struct gcry_cipher_handle;
802 : : typedef struct gcry_cipher_handle *gcry_cipher_hd_t;
803 : :
804 : : #ifndef GCRYPT_NO_DEPRECATED
805 : : typedef struct gcry_cipher_handle *GCRY_CIPHER_HD _GCRY_GCC_ATTR_DEPRECATED;
806 : : typedef struct gcry_cipher_handle *GcryCipherHd _GCRY_GCC_ATTR_DEPRECATED;
807 : : #endif
808 : :
809 : : /* All symmetric encryption algorithms are identified by their IDs.
810 : : More IDs may be registered at runtime. */
811 : : enum gcry_cipher_algos
812 : : {
813 : : GCRY_CIPHER_NONE = 0,
814 : : GCRY_CIPHER_IDEA = 1,
815 : : GCRY_CIPHER_3DES = 2,
816 : : GCRY_CIPHER_CAST5 = 3,
817 : : GCRY_CIPHER_BLOWFISH = 4,
818 : : GCRY_CIPHER_SAFER_SK128 = 5,
819 : : GCRY_CIPHER_DES_SK = 6,
820 : : GCRY_CIPHER_AES = 7,
821 : : GCRY_CIPHER_AES192 = 8,
822 : : GCRY_CIPHER_AES256 = 9,
823 : : GCRY_CIPHER_TWOFISH = 10,
824 : :
825 : : /* Other cipher numbers are above 300 for OpenPGP reasons. */
826 : : GCRY_CIPHER_ARCFOUR = 301, /* Fully compatible with RSA's RC4 (tm). */
827 : : GCRY_CIPHER_DES = 302, /* Yes, this is single key 56 bit DES. */
828 : : GCRY_CIPHER_TWOFISH128 = 303,
829 : : GCRY_CIPHER_SERPENT128 = 304,
830 : : GCRY_CIPHER_SERPENT192 = 305,
831 : : GCRY_CIPHER_SERPENT256 = 306,
832 : : GCRY_CIPHER_RFC2268_40 = 307, /* Ron's Cipher 2 (40 bit). */
833 : : GCRY_CIPHER_RFC2268_128 = 308, /* Ron's Cipher 2 (128 bit). */
834 : : GCRY_CIPHER_SEED = 309, /* 128 bit cipher described in RFC4269. */
835 : : GCRY_CIPHER_CAMELLIA128 = 310,
836 : : GCRY_CIPHER_CAMELLIA192 = 311,
837 : : GCRY_CIPHER_CAMELLIA256 = 312
838 : : };
839 : :
840 : : /* The Rijndael algorithm is basically AES, so provide some macros. */
841 : : #define GCRY_CIPHER_AES128 GCRY_CIPHER_AES
842 : : #define GCRY_CIPHER_RIJNDAEL GCRY_CIPHER_AES
843 : : #define GCRY_CIPHER_RIJNDAEL128 GCRY_CIPHER_AES128
844 : : #define GCRY_CIPHER_RIJNDAEL192 GCRY_CIPHER_AES192
845 : : #define GCRY_CIPHER_RIJNDAEL256 GCRY_CIPHER_AES256
846 : :
847 : : /* The supported encryption modes. Note that not all of them are
848 : : supported for each algorithm. */
849 : : enum gcry_cipher_modes
850 : : {
851 : : GCRY_CIPHER_MODE_NONE = 0, /* Not yet specified. */
852 : : GCRY_CIPHER_MODE_ECB = 1, /* Electronic codebook. */
853 : : GCRY_CIPHER_MODE_CFB = 2, /* Cipher feedback. */
854 : : GCRY_CIPHER_MODE_CBC = 3, /* Cipher block chaining. */
855 : : GCRY_CIPHER_MODE_STREAM = 4, /* Used with stream ciphers. */
856 : : GCRY_CIPHER_MODE_OFB = 5, /* Outer feedback. */
857 : : GCRY_CIPHER_MODE_CTR = 6, /* Counter. */
858 : : GCRY_CIPHER_MODE_AESWRAP= 7 /* AES-WRAP algorithm. */
859 : : };
860 : :
861 : : /* Flags used with the open function. */
862 : : enum gcry_cipher_flags
863 : : {
864 : : GCRY_CIPHER_SECURE = 1, /* Allocate in secure memory. */
865 : : GCRY_CIPHER_ENABLE_SYNC = 2, /* Enable CFB sync mode. */
866 : : GCRY_CIPHER_CBC_CTS = 4, /* Enable CBC cipher text stealing (CTS). */
867 : : GCRY_CIPHER_CBC_MAC = 8 /* Enable CBC message auth. code (MAC). */
868 : : };
869 : :
870 : :
871 : : /* Create a handle for algorithm ALGO to be used in MODE. FLAGS may
872 : : be given as an bitwise OR of the gcry_cipher_flags values. */
873 : : gcry_error_t gcry_cipher_open (gcry_cipher_hd_t *handle,
874 : : int algo, int mode, unsigned int flags);
875 : :
876 : : /* Close the cioher handle H and release all resource. */
877 : : void gcry_cipher_close (gcry_cipher_hd_t h);
878 : :
879 : : /* Perform various operations on the cipher object H. */
880 : : gcry_error_t gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer,
881 : : size_t buflen);
882 : :
883 : : /* Retrieve various information about the cipher object H. */
884 : : gcry_error_t gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer,
885 : : size_t *nbytes);
886 : :
887 : : /* Retrieve various information about the cipher algorithm ALGO. */
888 : : gcry_error_t gcry_cipher_algo_info (int algo, int what, void *buffer,
889 : : size_t *nbytes);
890 : :
891 : : /* Map the cipher algorithm whose ID is contained in ALGORITHM to a
892 : : string representation of the algorithm name. For unknown algorithm
893 : : IDs this function returns "?". */
894 : : const char *gcry_cipher_algo_name (int algorithm) _GCRY_GCC_ATTR_PURE;
895 : :
896 : : /* Map the algorithm name NAME to an cipher algorithm ID. Return 0 if
897 : : the algorithm name is not known. */
898 : : int gcry_cipher_map_name (const char *name) _GCRY_GCC_ATTR_PURE;
899 : :
900 : : /* Given an ASN.1 object identifier in standard IETF dotted decimal
901 : : format in STRING, return the encryption mode associated with that
902 : : OID or 0 if not known or applicable. */
903 : : int gcry_cipher_mode_from_oid (const char *string) _GCRY_GCC_ATTR_PURE;
904 : :
905 : : /* Encrypt the plaintext of size INLEN in IN using the cipher handle H
906 : : into the buffer OUT which has an allocated length of OUTSIZE. For
907 : : most algorithms it is possible to pass NULL for in and 0 for INLEN
908 : : and do a in-place decryption of the data provided in OUT. */
909 : : gcry_error_t gcry_cipher_encrypt (gcry_cipher_hd_t h,
910 : : void *out, size_t outsize,
911 : : const void *in, size_t inlen);
912 : :
913 : : /* The counterpart to gcry_cipher_encrypt. */
914 : : gcry_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h,
915 : : void *out, size_t outsize,
916 : : const void *in, size_t inlen);
917 : :
918 : : /* Set KEY of length KEYLEN bytes for the cipher handle HD. */
919 : : gcry_error_t gcry_cipher_setkey (gcry_cipher_hd_t hd,
920 : : const void *key, size_t keylen);
921 : :
922 : :
923 : : /* Set initialization vector IV of length IVLEN for the cipher handle HD. */
924 : : gcry_error_t gcry_cipher_setiv (gcry_cipher_hd_t hd,
925 : : const void *iv, size_t ivlen);
926 : :
927 : :
928 : : /* Reset the handle to the state after open. */
929 : : #define gcry_cipher_reset(h) gcry_cipher_ctl ((h), GCRYCTL_RESET, NULL, 0)
930 : :
931 : : /* Perform the OpenPGP sync operation if this is enabled for the
932 : : cipher handle H. */
933 : : #define gcry_cipher_sync(h) gcry_cipher_ctl( (h), GCRYCTL_CFB_SYNC, NULL, 0)
934 : :
935 : : /* Enable or disable CTS in future calls to gcry_encrypt(). CBC mode only. */
936 : : #define gcry_cipher_cts(h,on) gcry_cipher_ctl( (h), GCRYCTL_SET_CBC_CTS, \
937 : : NULL, on )
938 : :
939 : : /* Set counter for CTR mode. (CTR,CTRLEN) must denote a buffer of
940 : : block size length, or (NULL,0) to set the CTR to the all-zero block. */
941 : : gpg_error_t gcry_cipher_setctr (gcry_cipher_hd_t hd,
942 : : const void *ctr, size_t ctrlen);
943 : :
944 : : /* Retrieved the key length in bytes used with algorithm A. */
945 : : size_t gcry_cipher_get_algo_keylen (int algo);
946 : :
947 : : /* Retrieve the block length in bytes used with algorithm A. */
948 : : size_t gcry_cipher_get_algo_blklen (int algo);
949 : :
950 : : /* Return 0 if the algorithm A is available for use. */
951 : : #define gcry_cipher_test_algo(a) \
952 : : gcry_cipher_algo_info( (a), GCRYCTL_TEST_ALGO, NULL, NULL )
953 : :
954 : : /* Get a list consisting of the IDs of the loaded cipher modules. If
955 : : LIST is zero, write the number of loaded cipher modules to
956 : : LIST_LENGTH and return. If LIST is non-zero, the first
957 : : *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
958 : : according size. In case there are less cipher modules than
959 : : *LIST_LENGTH, *LIST_LENGTH is updated to the correct number. */
960 : : gcry_error_t gcry_cipher_list (int *list, int *list_length);
961 : :
962 : :
963 : : /************************************
964 : : * *
965 : : * Asymmetric Cipher Functions *
966 : : * *
967 : : ************************************/
968 : :
969 : : /* The algorithms and their IDs we support. */
970 : : enum gcry_pk_algos
971 : : {
972 : : GCRY_PK_RSA = 1,
973 : : GCRY_PK_RSA_E = 2, /* (deprecated) */
974 : : GCRY_PK_RSA_S = 3, /* (deprecated) */
975 : : GCRY_PK_ELG_E = 16,
976 : : GCRY_PK_DSA = 17,
977 : : GCRY_PK_ELG = 20,
978 : : GCRY_PK_ECDSA = 301,
979 : : GCRY_PK_ECDH = 302
980 : : };
981 : :
982 : : /* Flags describing usage capabilities of a PK algorithm. */
983 : : #define GCRY_PK_USAGE_SIGN 1 /* Good for signatures. */
984 : : #define GCRY_PK_USAGE_ENCR 2 /* Good for encryption. */
985 : : #define GCRY_PK_USAGE_CERT 4 /* Good to certify other keys. */
986 : : #define GCRY_PK_USAGE_AUTH 8 /* Good for authentication. */
987 : : #define GCRY_PK_USAGE_UNKN 128 /* Unknown usage flag. */
988 : :
989 : : /* Encrypt the DATA using the public key PKEY and store the result as
990 : : a newly created S-expression at RESULT. */
991 : : gcry_error_t gcry_pk_encrypt (gcry_sexp_t *result,
992 : : gcry_sexp_t data, gcry_sexp_t pkey);
993 : :
994 : : /* Decrypt the DATA using the private key SKEY and store the result as
995 : : a newly created S-expression at RESULT. */
996 : : gcry_error_t gcry_pk_decrypt (gcry_sexp_t *result,
997 : : gcry_sexp_t data, gcry_sexp_t skey);
998 : :
999 : : /* Sign the DATA using the private key SKEY and store the result as
1000 : : a newly created S-expression at RESULT. */
1001 : : gcry_error_t gcry_pk_sign (gcry_sexp_t *result,
1002 : : gcry_sexp_t data, gcry_sexp_t skey);
1003 : :
1004 : : /* Check the signature SIGVAL on DATA using the public key PKEY. */
1005 : : gcry_error_t gcry_pk_verify (gcry_sexp_t sigval,
1006 : : gcry_sexp_t data, gcry_sexp_t pkey);
1007 : :
1008 : : /* Check that private KEY is sane. */
1009 : : gcry_error_t gcry_pk_testkey (gcry_sexp_t key);
1010 : :
1011 : : /* Generate a new key pair according to the parameters given in
1012 : : S_PARMS. The new key pair is returned in as an S-expression in
1013 : : R_KEY. */
1014 : : gcry_error_t gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms);
1015 : :
1016 : : /* Catch all function for miscellaneous operations. */
1017 : : gcry_error_t gcry_pk_ctl (int cmd, void *buffer, size_t buflen);
1018 : :
1019 : : /* Retrieve information about the public key algorithm ALGO. */
1020 : : gcry_error_t gcry_pk_algo_info (int algo, int what,
1021 : : void *buffer, size_t *nbytes);
1022 : :
1023 : : /* Map the public key algorithm whose ID is contained in ALGORITHM to
1024 : : a string representation of the algorithm name. For unknown
1025 : : algorithm IDs this functions returns "?". */
1026 : : const char *gcry_pk_algo_name (int algorithm) _GCRY_GCC_ATTR_PURE;
1027 : :
1028 : : /* Map the algorithm NAME to a public key algorithm Id. Return 0 if
1029 : : the algorithm name is not known. */
1030 : : int gcry_pk_map_name (const char* name) _GCRY_GCC_ATTR_PURE;
1031 : :
1032 : : /* Return what is commonly referred as the key length for the given
1033 : : public or private KEY. */
1034 : : unsigned int gcry_pk_get_nbits (gcry_sexp_t key) _GCRY_GCC_ATTR_PURE;
1035 : :
1036 : : /* Please note that keygrip is still experimental and should not be
1037 : : used without contacting the author. */
1038 : : unsigned char *gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array);
1039 : :
1040 : : /* Return the name of the curve matching KEY. */
1041 : : const char *gcry_pk_get_curve (gcry_sexp_t key, int iterator,
1042 : : unsigned int *r_nbits);
1043 : :
1044 : : /* Return an S-expression with the parameters of the named ECC curve
1045 : : NAME. ALGO must be set to an ECC algorithm. */
1046 : : gcry_sexp_t gcry_pk_get_param (int algo, const char *name);
1047 : :
1048 : : /* Return 0 if the public key algorithm A is available for use. */
1049 : : #define gcry_pk_test_algo(a) \
1050 : : gcry_pk_algo_info( (a), GCRYCTL_TEST_ALGO, NULL, NULL )
1051 : :
1052 : : /* Get a list consisting of the IDs of the loaded pubkey modules. If
1053 : : LIST is zero, write the number of loaded pubkey modules to
1054 : : LIST_LENGTH and return. If LIST is non-zero, the first
1055 : : *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
1056 : : according size. In case there are less pubkey modules than
1057 : : *LIST_LENGTH, *LIST_LENGTH is updated to the correct number. */
1058 : : gcry_error_t gcry_pk_list (int *list, int *list_length);
1059 : :
1060 : :
1061 : :
1062 : : /************************************
1063 : : * *
1064 : : * Cryptograhic Hash Functions *
1065 : : * *
1066 : : ************************************/
1067 : :
1068 : : /* Algorithm IDs for the hash functions we know about. Not all of them
1069 : : are implemnted. */
1070 : : enum gcry_md_algos
1071 : : {
1072 : : GCRY_MD_NONE = 0,
1073 : : GCRY_MD_MD5 = 1,
1074 : : GCRY_MD_SHA1 = 2,
1075 : : GCRY_MD_RMD160 = 3,
1076 : : GCRY_MD_MD2 = 5,
1077 : : GCRY_MD_TIGER = 6, /* TIGER/192 as used by gpg <= 1.3.2. */
1078 : : GCRY_MD_HAVAL = 7, /* HAVAL, 5 pass, 160 bit. */
1079 : : GCRY_MD_SHA256 = 8,
1080 : : GCRY_MD_SHA384 = 9,
1081 : : GCRY_MD_SHA512 = 10,
1082 : : GCRY_MD_SHA224 = 11,
1083 : : GCRY_MD_MD4 = 301,
1084 : : GCRY_MD_CRC32 = 302,
1085 : : GCRY_MD_CRC32_RFC1510 = 303,
1086 : : GCRY_MD_CRC24_RFC2440 = 304,
1087 : : GCRY_MD_WHIRLPOOL = 305,
1088 : : GCRY_MD_TIGER1 = 306, /* TIGER fixed. */
1089 : : GCRY_MD_TIGER2 = 307 /* TIGER2 variant. */
1090 : : };
1091 : :
1092 : : /* Flags used with the open function. */
1093 : : enum gcry_md_flags
1094 : : {
1095 : : GCRY_MD_FLAG_SECURE = 1, /* Allocate all buffers in "secure" memory. */
1096 : : GCRY_MD_FLAG_HMAC = 2 /* Make an HMAC out of this algorithm. */
1097 : : };
1098 : :
1099 : : /* (Forward declaration.) */
1100 : : struct gcry_md_context;
1101 : :
1102 : : /* This object is used to hold a handle to a message digest object.
1103 : : This structure is private - only to be used by the public gcry_md_*
1104 : : macros. */
1105 : : typedef struct gcry_md_handle
1106 : : {
1107 : : /* Actual context. */
1108 : : struct gcry_md_context *ctx;
1109 : :
1110 : : /* Buffer management. */
1111 : : int bufpos;
1112 : : int bufsize;
1113 : : unsigned char buf[1];
1114 : : } *gcry_md_hd_t;
1115 : :
1116 : : /* Compatibility types, do not use them. */
1117 : : #ifndef GCRYPT_NO_DEPRECATED
1118 : : typedef struct gcry_md_handle *GCRY_MD_HD _GCRY_GCC_ATTR_DEPRECATED;
1119 : : typedef struct gcry_md_handle *GcryMDHd _GCRY_GCC_ATTR_DEPRECATED;
1120 : : #endif
1121 : :
1122 : : /* Create a message digest object for algorithm ALGO. FLAGS may be
1123 : : given as an bitwise OR of the gcry_md_flags values. ALGO may be
1124 : : given as 0 if the algorithms to be used are later set using
1125 : : gcry_md_enable. */
1126 : : gcry_error_t gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags);
1127 : :
1128 : : /* Release the message digest object HD. */
1129 : : void gcry_md_close (gcry_md_hd_t hd);
1130 : :
1131 : : /* Add the message digest algorithm ALGO to the digest object HD. */
1132 : : gcry_error_t gcry_md_enable (gcry_md_hd_t hd, int algo);
1133 : :
1134 : : /* Create a new digest object as an exact copy of the object HD. */
1135 : : gcry_error_t gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd);
1136 : :
1137 : : /* Reset the digest object HD to its initial state. */
1138 : : void gcry_md_reset (gcry_md_hd_t hd);
1139 : :
1140 : : /* Perform various operations on the digest object HD. */
1141 : : gcry_error_t gcry_md_ctl (gcry_md_hd_t hd, int cmd,
1142 : : void *buffer, size_t buflen);
1143 : :
1144 : : /* Pass LENGTH bytes of data in BUFFER to the digest object HD so that
1145 : : it can update the digest values. This is the actual hash
1146 : : function. */
1147 : : void gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length);
1148 : :
1149 : : /* Read out the final digest from HD return the digest value for
1150 : : algorithm ALGO. */
1151 : : unsigned char *gcry_md_read (gcry_md_hd_t hd, int algo);
1152 : :
1153 : : /* Convenience function to calculate the hash from the data in BUFFER
1154 : : of size LENGTH using the algorithm ALGO avoiding the creating of a
1155 : : hash object. The hash is returned in the caller provided buffer
1156 : : DIGEST which must be large enough to hold the digest of the given
1157 : : algorithm. */
1158 : : void gcry_md_hash_buffer (int algo, void *digest,
1159 : : const void *buffer, size_t length);
1160 : :
1161 : : /* Retrieve the algorithm used with HD. This does not work reliable
1162 : : if more than one algorithm is enabled in HD. */
1163 : : int gcry_md_get_algo (gcry_md_hd_t hd);
1164 : :
1165 : : /* Retrieve the length in bytes of the digest yielded by algorithm
1166 : : ALGO. */
1167 : : unsigned int gcry_md_get_algo_dlen (int algo);
1168 : :
1169 : : /* Return true if the the algorithm ALGO is enabled in the digest
1170 : : object A. */
1171 : : int gcry_md_is_enabled (gcry_md_hd_t a, int algo);
1172 : :
1173 : : /* Return true if the digest object A is allocated in "secure" memory. */
1174 : : int gcry_md_is_secure (gcry_md_hd_t a);
1175 : :
1176 : : /* Retrieve various information about the object H. */
1177 : : gcry_error_t gcry_md_info (gcry_md_hd_t h, int what, void *buffer,
1178 : : size_t *nbytes);
1179 : :
1180 : : /* Retrieve various information about the algorithm ALGO. */
1181 : : gcry_error_t gcry_md_algo_info (int algo, int what, void *buffer,
1182 : : size_t *nbytes);
1183 : :
1184 : : /* Map the digest algorithm id ALGO to a string representation of the
1185 : : algorithm name. For unknown algorithms this function returns
1186 : : "?". */
1187 : : const char *gcry_md_algo_name (int algo) _GCRY_GCC_ATTR_PURE;
1188 : :
1189 : : /* Map the algorithm NAME to a digest algorithm Id. Return 0 if
1190 : : the algorithm name is not known. */
1191 : : int gcry_md_map_name (const char* name) _GCRY_GCC_ATTR_PURE;
1192 : :
1193 : : /* For use with the HMAC feature, the set MAC key to the KEY of
1194 : : KEYLEN bytes. */
1195 : : gcry_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
1196 : :
1197 : : /* Start or stop debugging for digest handle HD; i.e. create a file
1198 : : named dbgmd-<n>.<suffix> while hashing. If SUFFIX is NULL,
1199 : : debugging stops and the file will be closed. */
1200 : : void gcry_md_debug (gcry_md_hd_t hd, const char *suffix);
1201 : :
1202 : :
1203 : : /* Update the hash(s) of H with the character C. This is a buffered
1204 : : version of the gcry_md_write function. */
1205 : : #define gcry_md_putc(h,c) \
1206 : : do { \
1207 : : gcry_md_hd_t h__ = (h); \
1208 : : if( (h__)->bufpos == (h__)->bufsize ) \
1209 : : gcry_md_write( (h__), NULL, 0 ); \
1210 : : (h__)->buf[(h__)->bufpos++] = (c) & 0xff; \
1211 : : } while(0)
1212 : :
1213 : : /* Finalize the digest calculation. This is not really needed because
1214 : : gcry_md_read() does this implicitly. */
1215 : : #define gcry_md_final(a) \
1216 : : gcry_md_ctl ((a), GCRYCTL_FINALIZE, NULL, 0)
1217 : :
1218 : : /* Return 0 if the algorithm A is available for use. */
1219 : : #define gcry_md_test_algo(a) \
1220 : : gcry_md_algo_info( (a), GCRYCTL_TEST_ALGO, NULL, NULL )
1221 : :
1222 : : /* Return an DER encoded ASN.1 OID for the algorithm A in buffer B. N
1223 : : must point to size_t variable with the available size of buffer B.
1224 : : After return it will receive the actual size of the returned
1225 : : OID. */
1226 : : #define gcry_md_get_asnoid(a,b,n) \
1227 : : gcry_md_algo_info((a), GCRYCTL_GET_ASNOID, (b), (n))
1228 : :
1229 : : /* Enable debugging for digest object A; i.e. create files named
1230 : : dbgmd-<n>.<string> while hashing. B is a string used as the suffix
1231 : : for the filename. This macro is deprecated, use gcry_md_debug. */
1232 : : #ifndef GCRYPT_NO_DEPRECATED
1233 : : #define gcry_md_start_debug(a,b) \
1234 : : gcry_md_ctl( (a), GCRYCTL_START_DUMP, (b), 0 )
1235 : :
1236 : : /* Disable the debugging of A. This macro is deprecated, use
1237 : : gcry_md_debug. */
1238 : : #define gcry_md_stop_debug(a,b) \
1239 : : gcry_md_ctl( (a), GCRYCTL_STOP_DUMP, (b), 0 )
1240 : : #endif
1241 : :
1242 : : /* Get a list consisting of the IDs of the loaded message digest
1243 : : modules. If LIST is zero, write the number of loaded message
1244 : : digest modules to LIST_LENGTH and return. If LIST is non-zero, the
1245 : : first *LIST_LENGTH algorithm IDs are stored in LIST, which must be
1246 : : of according size. In case there are less message digest modules
1247 : : than *LIST_LENGTH, *LIST_LENGTH is updated to the correct
1248 : : number. */
1249 : : gcry_error_t gcry_md_list (int *list, int *list_length);
1250 : :
1251 : :
1252 : : /* Alternative interface for asymmetric cryptography. This interface
1253 : : is deprecated. */
1254 : :
1255 : : /* The algorithm IDs. */
1256 : : typedef enum gcry_ac_id
1257 : : {
1258 : : GCRY_AC_RSA = 1,
1259 : : GCRY_AC_DSA = 17,
1260 : : GCRY_AC_ELG = 20,
1261 : : GCRY_AC_ELG_E = 16
1262 : : }
1263 : : gcry_ac_id_t _GCRY_ATTR_INTERNAL;
1264 : :
1265 : : /* Key types. */
1266 : : typedef enum gcry_ac_key_type
1267 : : {
1268 : : GCRY_AC_KEY_SECRET,
1269 : : GCRY_AC_KEY_PUBLIC
1270 : : }
1271 : : gcry_ac_key_type_t _GCRY_ATTR_INTERNAL;
1272 : :
1273 : : /* Encoding methods. */
1274 : : typedef enum gcry_ac_em
1275 : : {
1276 : : GCRY_AC_EME_PKCS_V1_5,
1277 : : GCRY_AC_EMSA_PKCS_V1_5
1278 : : }
1279 : : gcry_ac_em_t _GCRY_ATTR_INTERNAL;
1280 : :
1281 : : /* Encryption and Signature schemes. */
1282 : : typedef enum gcry_ac_scheme
1283 : : {
1284 : : GCRY_AC_ES_PKCS_V1_5,
1285 : : GCRY_AC_SSA_PKCS_V1_5
1286 : : }
1287 : : gcry_ac_scheme_t _GCRY_ATTR_INTERNAL;
1288 : :
1289 : : /* AC data. */
1290 : : #define GCRY_AC_FLAG_DEALLOC (1 << 0)
1291 : : #define GCRY_AC_FLAG_COPY (1 << 1)
1292 : : #define GCRY_AC_FLAG_NO_BLINDING (1 << 2)
1293 : :
1294 : : /* This type represents a `data set'. */
1295 : : typedef struct gcry_ac_data *gcry_ac_data_t _GCRY_ATTR_INTERNAL;
1296 : :
1297 : : /* This type represents a single `key', either a secret one or a
1298 : : public one. */
1299 : : typedef struct gcry_ac_key *gcry_ac_key_t _GCRY_ATTR_INTERNAL;
1300 : :
1301 : : /* This type represents a `key pair' containing a secret and a public
1302 : : key. */
1303 : : typedef struct gcry_ac_key_pair *gcry_ac_key_pair_t _GCRY_ATTR_INTERNAL;
1304 : :
1305 : : /* This type represents a `handle' that is needed by functions
1306 : : performing cryptographic operations. */
1307 : : typedef struct gcry_ac_handle *gcry_ac_handle_t _GCRY_ATTR_INTERNAL;
1308 : :
1309 : : typedef gpg_error_t (*gcry_ac_data_read_cb_t) (void *opaque,
1310 : : unsigned char *buffer,
1311 : : size_t *buffer_n)
1312 : : /* */ _GCRY_ATTR_INTERNAL;
1313 : :
1314 : : typedef gpg_error_t (*gcry_ac_data_write_cb_t) (void *opaque,
1315 : : unsigned char *buffer,
1316 : : size_t buffer_n)
1317 : : /* */ _GCRY_ATTR_INTERNAL;
1318 : :
1319 : : typedef enum
1320 : : {
1321 : : GCRY_AC_IO_READABLE,
1322 : : GCRY_AC_IO_WRITABLE
1323 : : }
1324 : : gcry_ac_io_mode_t _GCRY_ATTR_INTERNAL;
1325 : :
1326 : : typedef enum
1327 : : {
1328 : : GCRY_AC_IO_STRING,
1329 : : GCRY_AC_IO_CALLBACK
1330 : : }
1331 : : gcry_ac_io_type_t _GCRY_ATTR_INTERNAL;
1332 : :
1333 : : typedef struct gcry_ac_io
1334 : : {
1335 : : /* This is an INTERNAL structure, do NOT use manually. */
1336 : : gcry_ac_io_mode_t mode _GCRY_ATTR_INTERNAL;
1337 : : gcry_ac_io_type_t type _GCRY_ATTR_INTERNAL;
1338 : : union
1339 : : {
1340 : : union
1341 : : {
1342 : : struct
1343 : : {
1344 : : gcry_ac_data_read_cb_t cb;
1345 : : void *opaque;
1346 : : } callback;
1347 : : struct
1348 : : {
1349 : : unsigned char *data;
1350 : : size_t data_n;
1351 : : } string;
1352 : : void *opaque;
1353 : : } readable;
1354 : : union
1355 : : {
1356 : : struct
1357 : : {
1358 : : gcry_ac_data_write_cb_t cb;
1359 : : void *opaque;
1360 : : } callback;
1361 : : struct
1362 : : {
1363 : : unsigned char **data;
1364 : : size_t *data_n;
1365 : : } string;
1366 : : void *opaque;
1367 : : } writable;
1368 : : } io _GCRY_ATTR_INTERNAL;
1369 : : }
1370 : : gcry_ac_io_t _GCRY_ATTR_INTERNAL;
1371 : :
1372 : : /* The caller of gcry_ac_key_pair_generate can provide one of these
1373 : : structures in order to influence the key generation process in an
1374 : : algorithm-specific way. */
1375 : : typedef struct gcry_ac_key_spec_rsa
1376 : : {
1377 : : gcry_mpi_t e; /* E to use. */
1378 : : } gcry_ac_key_spec_rsa_t _GCRY_ATTR_INTERNAL;
1379 : :
1380 : : /* Structure used for passing data to the implementation of the
1381 : : `EME-PKCS-V1_5' encoding method. */
1382 : : typedef struct gcry_ac_eme_pkcs_v1_5
1383 : : {
1384 : : size_t key_size;
1385 : : } gcry_ac_eme_pkcs_v1_5_t _GCRY_ATTR_INTERNAL;
1386 : :
1387 : : typedef enum gcry_md_algos gcry_md_algo_t _GCRY_ATTR_INTERNAL;
1388 : :
1389 : : /* Structure used for passing data to the implementation of the
1390 : : `EMSA-PKCS-V1_5' encoding method. */
1391 : : typedef struct gcry_ac_emsa_pkcs_v1_5
1392 : : {
1393 : : gcry_md_algo_t md;
1394 : : size_t em_n;
1395 : : } gcry_ac_emsa_pkcs_v1_5_t _GCRY_ATTR_INTERNAL;
1396 : :
1397 : : /* Structure used for passing data to the implementation of the
1398 : : `SSA-PKCS-V1_5' signature scheme. */
1399 : : typedef struct gcry_ac_ssa_pkcs_v1_5
1400 : : {
1401 : : gcry_md_algo_t md;
1402 : : } gcry_ac_ssa_pkcs_v1_5_t _GCRY_ATTR_INTERNAL;
1403 : :
1404 : :
1405 : : #ifndef GCRYPT_NO_DEPRECATED
1406 : : /* Returns a new, empty data set in DATA. */
1407 : : gcry_error_t gcry_ac_data_new (gcry_ac_data_t *data)
1408 : : /* */ _GCRY_ATTR_INTERNAL;
1409 : :
1410 : : /* Destroy the data set DATA. */
1411 : : void gcry_ac_data_destroy (gcry_ac_data_t data)
1412 : : /* */ _GCRY_ATTR_INTERNAL;
1413 : :
1414 : : /* Create a copy of the data set DATA and store it in DATA_CP. */
1415 : : gcry_error_t gcry_ac_data_copy (gcry_ac_data_t *data_cp,
1416 : : gcry_ac_data_t data)
1417 : : /* */ _GCRY_ATTR_INTERNAL;
1418 : :
1419 : : /* Return the number of named MPI values inside of the data set
1420 : : DATA. */
1421 : : unsigned int gcry_ac_data_length (gcry_ac_data_t data)
1422 : : /* */ _GCRY_ATTR_INTERNAL;
1423 : :
1424 : : /* Destroy any values contained in the data set DATA. */
1425 : : void gcry_ac_data_clear (gcry_ac_data_t data)
1426 : : /* */ _GCRY_ATTR_INTERNAL;
1427 : :
1428 : : /* Add the value MPI to DATA with the label NAME. If FLAGS contains
1429 : : GCRY_AC_FLAG_DATA_COPY, the data set will contain copies of NAME
1430 : : and MPI. If FLAGS contains GCRY_AC_FLAG_DATA_DEALLOC or
1431 : : GCRY_AC_FLAG_DATA_COPY, the values contained in the data set will
1432 : : be deallocated when they are to be removed from the data set. */
1433 : : gcry_error_t gcry_ac_data_set (gcry_ac_data_t data, unsigned int flags,
1434 : : const char *name, gcry_mpi_t mpi)
1435 : : /* */ _GCRY_ATTR_INTERNAL;
1436 : :
1437 : : /* Store the value labelled with NAME found in DATA in MPI. If FLAGS
1438 : : contains GCRY_AC_FLAG_COPY, store a copy of the MPI value contained
1439 : : in the data set. MPI may be NULL. */
1440 : : gcry_error_t gcry_ac_data_get_name (gcry_ac_data_t data, unsigned int flags,
1441 : : const char *name, gcry_mpi_t *mpi)
1442 : : /* */ _GCRY_ATTR_INTERNAL;
1443 : :
1444 : : /* Stores in NAME and MPI the named MPI value contained in the data
1445 : : set DATA with the index IDX. If FLAGS contains GCRY_AC_FLAG_COPY,
1446 : : store copies of the values contained in the data set. NAME or MPI
1447 : : may be NULL. */
1448 : : gcry_error_t gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int flags,
1449 : : unsigned int idx,
1450 : : const char **name, gcry_mpi_t *mpi)
1451 : : /* */ _GCRY_ATTR_INTERNAL;
1452 : :
1453 : : /* Convert the data set DATA into a new S-Expression, which is to be
1454 : : stored in SEXP, according to the identifiers contained in
1455 : : IDENTIFIERS. */
1456 : : gcry_error_t gcry_ac_data_to_sexp (gcry_ac_data_t data, gcry_sexp_t *sexp,
1457 : : const char **identifiers)
1458 : : /* */ _GCRY_ATTR_INTERNAL;
1459 : :
1460 : : /* Create a new data set, which is to be stored in DATA_SET, from the
1461 : : S-Expression SEXP, according to the identifiers contained in
1462 : : IDENTIFIERS. */
1463 : : gcry_error_t gcry_ac_data_from_sexp (gcry_ac_data_t *data, gcry_sexp_t sexp,
1464 : : const char **identifiers)
1465 : : /* */ _GCRY_ATTR_INTERNAL;
1466 : :
1467 : : /* Initialize AC_IO according to MODE, TYPE and the variable list of
1468 : : arguments. The list of variable arguments to specify depends on
1469 : : the given TYPE. */
1470 : : void gcry_ac_io_init (gcry_ac_io_t *ac_io, gcry_ac_io_mode_t mode,
1471 : : gcry_ac_io_type_t type, ...)
1472 : : /* */ _GCRY_ATTR_INTERNAL;
1473 : :
1474 : : /* Initialize AC_IO according to MODE, TYPE and the variable list of
1475 : : arguments AP. The list of variable arguments to specify depends on
1476 : : the given TYPE. */
1477 : : void gcry_ac_io_init_va (gcry_ac_io_t *ac_io, gcry_ac_io_mode_t mode,
1478 : : gcry_ac_io_type_t type, va_list ap)
1479 : : /* */ _GCRY_ATTR_INTERNAL;
1480 : :
1481 : : /* Create a new ac handle. */
1482 : : gcry_error_t gcry_ac_open (gcry_ac_handle_t *handle,
1483 : : gcry_ac_id_t algorithm, unsigned int flags)
1484 : : /* */ _GCRY_ATTR_INTERNAL;
1485 : :
1486 : : /* Destroy an ac handle. */
1487 : : void gcry_ac_close (gcry_ac_handle_t handle)
1488 : : /* */ _GCRY_ATTR_INTERNAL;
1489 : :
1490 : : /* Initialize a key from a given data set. */
1491 : : gcry_error_t gcry_ac_key_init (gcry_ac_key_t *key, gcry_ac_handle_t handle,
1492 : : gcry_ac_key_type_t type, gcry_ac_data_t data)
1493 : : /* */ _GCRY_ATTR_INTERNAL;
1494 : :
1495 : : /* Generates a new key pair via the handle HANDLE of NBITS bits and
1496 : : stores it in KEY_PAIR. In case non-standard settings are wanted, a
1497 : : pointer to a structure of type gcry_ac_key_spec_<algorithm>_t,
1498 : : matching the selected algorithm, can be given as KEY_SPEC.
1499 : : MISC_DATA is not used yet. */
1500 : : gcry_error_t gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
1501 : : unsigned int nbits, void *spec,
1502 : : gcry_ac_key_pair_t *key_pair,
1503 : : gcry_mpi_t **misc_data)
1504 : : /* */ _GCRY_ATTR_INTERNAL;
1505 : :
1506 : : /* Returns the key of type WHICH out of the key pair KEY_PAIR. */
1507 : : gcry_ac_key_t gcry_ac_key_pair_extract (gcry_ac_key_pair_t key_pair,
1508 : : gcry_ac_key_type_t which)
1509 : : /* */ _GCRY_ATTR_INTERNAL;
1510 : :
1511 : : /* Returns the data set contained in the key KEY. */
1512 : : gcry_ac_data_t gcry_ac_key_data_get (gcry_ac_key_t key)
1513 : : /* */ _GCRY_ATTR_INTERNAL;
1514 : :
1515 : : /* Verifies that the key KEY is sane via HANDLE. */
1516 : : gcry_error_t gcry_ac_key_test (gcry_ac_handle_t handle, gcry_ac_key_t key)
1517 : : /* */ _GCRY_ATTR_INTERNAL;
1518 : :
1519 : : /* Stores the number of bits of the key KEY in NBITS via HANDLE. */
1520 : : gcry_error_t gcry_ac_key_get_nbits (gcry_ac_handle_t handle,
1521 : : gcry_ac_key_t key, unsigned int *nbits)
1522 : : /* */ _GCRY_ATTR_INTERNAL;
1523 : :
1524 : : /* Writes the 20 byte long key grip of the key KEY to KEY_GRIP via
1525 : : HANDLE. */
1526 : : gcry_error_t gcry_ac_key_get_grip (gcry_ac_handle_t handle, gcry_ac_key_t key,
1527 : : unsigned char *key_grip)
1528 : : /* */ _GCRY_ATTR_INTERNAL;
1529 : :
1530 : : /* Destroy a key. */
1531 : : void gcry_ac_key_destroy (gcry_ac_key_t key)
1532 : : /* */ _GCRY_ATTR_INTERNAL;
1533 : :
1534 : : /* Destroy a key pair. */
1535 : : void gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair)
1536 : : /* */ _GCRY_ATTR_INTERNAL;
1537 : :
1538 : : /* Encodes a message according to the encoding method METHOD. OPTIONS
1539 : : must be a pointer to a method-specific structure
1540 : : (gcry_ac_em*_t). */
1541 : : gcry_error_t gcry_ac_data_encode (gcry_ac_em_t method,
1542 : : unsigned int flags, void *options,
1543 : : gcry_ac_io_t *io_read,
1544 : : gcry_ac_io_t *io_write)
1545 : : /* */ _GCRY_ATTR_INTERNAL;
1546 : :
1547 : : /* Decodes a message according to the encoding method METHOD. OPTIONS
1548 : : must be a pointer to a method-specific structure
1549 : : (gcry_ac_em*_t). */
1550 : : gcry_error_t gcry_ac_data_decode (gcry_ac_em_t method,
1551 : : unsigned int flags, void *options,
1552 : : gcry_ac_io_t *io_read,
1553 : : gcry_ac_io_t *io_write)
1554 : : /* */ _GCRY_ATTR_INTERNAL;
1555 : :
1556 : : /* Encrypt the plain text MPI value DATA_PLAIN with the key KEY under
1557 : : the control of the flags FLAGS and store the resulting data set
1558 : : into DATA_ENCRYPTED. */
1559 : : gcry_error_t gcry_ac_data_encrypt (gcry_ac_handle_t handle,
1560 : : unsigned int flags,
1561 : : gcry_ac_key_t key,
1562 : : gcry_mpi_t data_plain,
1563 : : gcry_ac_data_t *data_encrypted)
1564 : : /* */ _GCRY_ATTR_INTERNAL;
1565 : :
1566 : : /* Decrypt the decrypted data contained in the data set DATA_ENCRYPTED
1567 : : with the key KEY under the control of the flags FLAGS and store the
1568 : : resulting plain text MPI value in DATA_PLAIN. */
1569 : : gcry_error_t gcry_ac_data_decrypt (gcry_ac_handle_t handle,
1570 : : unsigned int flags,
1571 : : gcry_ac_key_t key,
1572 : : gcry_mpi_t *data_plain,
1573 : : gcry_ac_data_t data_encrypted)
1574 : : /* */ _GCRY_ATTR_INTERNAL;
1575 : :
1576 : : /* Sign the data contained in DATA with the key KEY and store the
1577 : : resulting signature in the data set DATA_SIGNATURE. */
1578 : : gcry_error_t gcry_ac_data_sign (gcry_ac_handle_t handle,
1579 : : gcry_ac_key_t key,
1580 : : gcry_mpi_t data,
1581 : : gcry_ac_data_t *data_signature)
1582 : : /* */ _GCRY_ATTR_INTERNAL;
1583 : :
1584 : : /* Verify that the signature contained in the data set DATA_SIGNATURE
1585 : : is indeed the result of signing the data contained in DATA with the
1586 : : secret key belonging to the public key KEY. */
1587 : : gcry_error_t gcry_ac_data_verify (gcry_ac_handle_t handle,
1588 : : gcry_ac_key_t key,
1589 : : gcry_mpi_t data,
1590 : : gcry_ac_data_t data_signature)
1591 : : /* */ _GCRY_ATTR_INTERNAL;
1592 : :
1593 : : /* Encrypts the plain text readable from IO_MESSAGE through HANDLE
1594 : : with the public key KEY according to SCHEME, FLAGS and OPTS. If
1595 : : OPTS is not NULL, it has to be a pointer to a structure specific to
1596 : : the chosen scheme (gcry_ac_es_*_t). The encrypted message is
1597 : : written to IO_CIPHER. */
1598 : : gcry_error_t gcry_ac_data_encrypt_scheme (gcry_ac_handle_t handle,
1599 : : gcry_ac_scheme_t scheme,
1600 : : unsigned int flags, void *opts,
1601 : : gcry_ac_key_t key,
1602 : : gcry_ac_io_t *io_message,
1603 : : gcry_ac_io_t *io_cipher)
1604 : : /* */ _GCRY_ATTR_INTERNAL;
1605 : :
1606 : : /* Decrypts the cipher text readable from IO_CIPHER through HANDLE
1607 : : with the secret key KEY according to SCHEME, @var{flags} and OPTS.
1608 : : If OPTS is not NULL, it has to be a pointer to a structure specific
1609 : : to the chosen scheme (gcry_ac_es_*_t). The decrypted message is
1610 : : written to IO_MESSAGE. */
1611 : : gcry_error_t gcry_ac_data_decrypt_scheme (gcry_ac_handle_t handle,
1612 : : gcry_ac_scheme_t scheme,
1613 : : unsigned int flags, void *opts,
1614 : : gcry_ac_key_t key,
1615 : : gcry_ac_io_t *io_cipher,
1616 : : gcry_ac_io_t *io_message)
1617 : : /* */ _GCRY_ATTR_INTERNAL;
1618 : :
1619 : : /* Signs the message readable from IO_MESSAGE through HANDLE with the
1620 : : secret key KEY according to SCHEME, FLAGS and OPTS. If OPTS is not
1621 : : NULL, it has to be a pointer to a structure specific to the chosen
1622 : : scheme (gcry_ac_ssa_*_t). The signature is written to
1623 : : IO_SIGNATURE. */
1624 : : gcry_error_t gcry_ac_data_sign_scheme (gcry_ac_handle_t handle,
1625 : : gcry_ac_scheme_t scheme,
1626 : : unsigned int flags, void *opts,
1627 : : gcry_ac_key_t key,
1628 : : gcry_ac_io_t *io_message,
1629 : : gcry_ac_io_t *io_signature)
1630 : : /* */ _GCRY_ATTR_INTERNAL;
1631 : :
1632 : : /* Verifies through HANDLE that the signature readable from
1633 : : IO_SIGNATURE is indeed the result of signing the message readable
1634 : : from IO_MESSAGE with the secret key belonging to the public key KEY
1635 : : according to SCHEME and OPTS. If OPTS is not NULL, it has to be an
1636 : : anonymous structure (gcry_ac_ssa_*_t) specific to the chosen
1637 : : scheme. */
1638 : : gcry_error_t gcry_ac_data_verify_scheme (gcry_ac_handle_t handle,
1639 : : gcry_ac_scheme_t scheme,
1640 : : unsigned int flags, void *opts,
1641 : : gcry_ac_key_t key,
1642 : : gcry_ac_io_t *io_message,
1643 : : gcry_ac_io_t *io_signature)
1644 : : /* */ _GCRY_ATTR_INTERNAL;
1645 : :
1646 : : /* Store the textual representation of the algorithm whose id is given
1647 : : in ALGORITHM in NAME. This function is deprecated; use
1648 : : gcry_pk_algo_name. */
1649 : : gcry_error_t gcry_ac_id_to_name (gcry_ac_id_t algorithm,
1650 : : const char **name)
1651 : : /* */ _GCRY_GCC_ATTR_DEPRECATED;
1652 : : /* Store the numeric ID of the algorithm whose textual representation
1653 : : is contained in NAME in ALGORITHM. This function is deprecated;
1654 : : use gcry_pk_map_name. */
1655 : : gcry_error_t gcry_ac_name_to_id (const char *name,
1656 : : gcry_ac_id_t *algorithm)
1657 : : /* */ _GCRY_GCC_ATTR_DEPRECATED;
1658 : : #endif /*GCRYPT_NO_DEPRECATED*/
1659 : :
1660 : :
1661 : : /******************************
1662 : : * *
1663 : : * Key Derivation Functions *
1664 : : * *
1665 : : ******************************/
1666 : :
1667 : : /* Algorithm IDs for the KDFs. */
1668 : : enum gcry_kdf_algos
1669 : : {
1670 : : GCRY_KDF_NONE = 0,
1671 : : GCRY_KDF_SIMPLE_S2K = 16,
1672 : : GCRY_KDF_SALTED_S2K = 17,
1673 : : GCRY_KDF_ITERSALTED_S2K = 19,
1674 : : GCRY_KDF_PBKDF1 = 33,
1675 : : GCRY_KDF_PBKDF2 = 34
1676 : : };
1677 : :
1678 : : /* Derive a key from a passphrase. */
1679 : : gpg_error_t gcry_kdf_derive (const void *passphrase, size_t passphraselen,
1680 : : int algo, int subalgo,
1681 : : const void *salt, size_t saltlen,
1682 : : unsigned long iterations,
1683 : : size_t keysize, void *keybuffer);
1684 : :
1685 : :
1686 : :
1687 : :
1688 : : /************************************
1689 : : * *
1690 : : * Random Generating Functions *
1691 : : * *
1692 : : ************************************/
1693 : :
1694 : : /* The possible values for the random quality. The rule of thumb is
1695 : : to use STRONG for session keys and VERY_STRONG for key material.
1696 : : WEAK is usually an alias for STRONG and should not be used anymore
1697 : : (except with gcry_mpi_randomize); use gcry_create_nonce instead. */
1698 : : typedef enum gcry_random_level
1699 : : {
1700 : : GCRY_WEAK_RANDOM = 0,
1701 : : GCRY_STRONG_RANDOM = 1,
1702 : : GCRY_VERY_STRONG_RANDOM = 2
1703 : : }
1704 : : gcry_random_level_t;
1705 : :
1706 : : /* Fill BUFFER with LENGTH bytes of random, using random numbers of
1707 : : quality LEVEL. */
1708 : : void gcry_randomize (void *buffer, size_t length,
1709 : : enum gcry_random_level level);
1710 : :
1711 : : /* Add the external random from BUFFER with LENGTH bytes into the
1712 : : pool. QUALITY should either be -1 for unknown or in the range of 0
1713 : : to 100 */
1714 : : gcry_error_t gcry_random_add_bytes (const void *buffer, size_t length,
1715 : : int quality);
1716 : :
1717 : : /* If random numbers are used in an application, this macro should be
1718 : : called from time to time so that new stuff gets added to the
1719 : : internal pool of the RNG. */
1720 : : #define gcry_fast_random_poll() gcry_control (GCRYCTL_FAST_POLL, NULL)
1721 : :
1722 : :
1723 : : /* Return NBYTES of allocated random using a random numbers of quality
1724 : : LEVEL. */
1725 : : void *gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
1726 : : _GCRY_GCC_ATTR_MALLOC;
1727 : :
1728 : : /* Return NBYTES of allocated random using a random numbers of quality
1729 : : LEVEL. The random numbers are created returned in "secure"
1730 : : memory. */
1731 : : void *gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
1732 : : _GCRY_GCC_ATTR_MALLOC;
1733 : :
1734 : :
1735 : : /* Set the big integer W to a random value of NBITS using a random
1736 : : generator with quality LEVEL. Note that by using a level of
1737 : : GCRY_WEAK_RANDOM gcry_create_nonce is used internally. */
1738 : : void gcry_mpi_randomize (gcry_mpi_t w,
1739 : : unsigned int nbits, enum gcry_random_level level);
1740 : :
1741 : :
1742 : : /* Create an unpredicable nonce of LENGTH bytes in BUFFER. */
1743 : : void gcry_create_nonce (void *buffer, size_t length);
1744 : :
1745 : :
1746 : :
1747 : :
1748 : :
1749 : : /*******************************/
1750 : : /* */
1751 : : /* Prime Number Functions */
1752 : : /* */
1753 : : /*******************************/
1754 : :
1755 : : /* Mode values passed to a gcry_prime_check_func_t. */
1756 : : #define GCRY_PRIME_CHECK_AT_FINISH 0
1757 : : #define GCRY_PRIME_CHECK_AT_GOT_PRIME 1
1758 : : #define GCRY_PRIME_CHECK_AT_MAYBE_PRIME 2
1759 : :
1760 : : /* The function should return 1 if the operation shall continue, 0 to
1761 : : reject the prime candidate. */
1762 : : typedef int (*gcry_prime_check_func_t) (void *arg, int mode,
1763 : : gcry_mpi_t candidate);
1764 : :
1765 : : /* Flags for gcry_prime_generate(): */
1766 : :
1767 : : /* Allocate prime numbers and factors in secure memory. */
1768 : : #define GCRY_PRIME_FLAG_SECRET (1 << 0)
1769 : :
1770 : : /* Make sure that at least one prime factor is of size
1771 : : `FACTOR_BITS'. */
1772 : : #define GCRY_PRIME_FLAG_SPECIAL_FACTOR (1 << 1)
1773 : :
1774 : : /* Generate a new prime number of PRIME_BITS bits and store it in
1775 : : PRIME. If FACTOR_BITS is non-zero, one of the prime factors of
1776 : : (prime - 1) / 2 must be FACTOR_BITS bits long. If FACTORS is
1777 : : non-zero, allocate a new, NULL-terminated array holding the prime
1778 : : factors and store it in FACTORS. FLAGS might be used to influence
1779 : : the prime number generation process. */
1780 : : gcry_error_t gcry_prime_generate (gcry_mpi_t *prime,
1781 : : unsigned int prime_bits,
1782 : : unsigned int factor_bits,
1783 : : gcry_mpi_t **factors,
1784 : : gcry_prime_check_func_t cb_func,
1785 : : void *cb_arg,
1786 : : gcry_random_level_t random_level,
1787 : : unsigned int flags);
1788 : :
1789 : : /* Find a generator for PRIME where the factorization of (prime-1) is
1790 : : in the NULL terminated array FACTORS. Return the generator as a
1791 : : newly allocated MPI in R_G. If START_G is not NULL, use this as
1792 : : teh start for the search. */
1793 : : gcry_error_t gcry_prime_group_generator (gcry_mpi_t *r_g,
1794 : : gcry_mpi_t prime,
1795 : : gcry_mpi_t *factors,
1796 : : gcry_mpi_t start_g);
1797 : :
1798 : :
1799 : : /* Convenience function to release the FACTORS array. */
1800 : : void gcry_prime_release_factors (gcry_mpi_t *factors);
1801 : :
1802 : :
1803 : : /* Check wether the number X is prime. */
1804 : : gcry_error_t gcry_prime_check (gcry_mpi_t x, unsigned int flags);
1805 : :
1806 : :
1807 : :
1808 : : /************************************
1809 : : * *
1810 : : * Miscellaneous Stuff *
1811 : : * *
1812 : : ************************************/
1813 : :
1814 : : /* Log levels used by the internal logging facility. */
1815 : : enum gcry_log_levels
1816 : : {
1817 : : GCRY_LOG_CONT = 0, /* (Continue the last log line.) */
1818 : : GCRY_LOG_INFO = 10,
1819 : : GCRY_LOG_WARN = 20,
1820 : : GCRY_LOG_ERROR = 30,
1821 : : GCRY_LOG_FATAL = 40,
1822 : : GCRY_LOG_BUG = 50,
1823 : : GCRY_LOG_DEBUG = 100
1824 : : };
1825 : :
1826 : : /* Type for progress handlers. */
1827 : : typedef void (*gcry_handler_progress_t) (void *, const char *, int, int, int);
1828 : :
1829 : : /* Type for memory allocation handlers. */
1830 : : typedef void *(*gcry_handler_alloc_t) (size_t n);
1831 : :
1832 : : /* Type for secure memory check handlers. */
1833 : : typedef int (*gcry_handler_secure_check_t) (const void *);
1834 : :
1835 : : /* Type for memory reallocation handlers. */
1836 : : typedef void *(*gcry_handler_realloc_t) (void *p, size_t n);
1837 : :
1838 : : /* Type for memory free handlers. */
1839 : : typedef void (*gcry_handler_free_t) (void *);
1840 : :
1841 : : /* Type for out-of-memory handlers. */
1842 : : typedef int (*gcry_handler_no_mem_t) (void *, size_t, unsigned int);
1843 : :
1844 : : /* Type for fatal error handlers. */
1845 : : typedef void (*gcry_handler_error_t) (void *, int, const char *);
1846 : :
1847 : : /* Type for logging handlers. */
1848 : : typedef void (*gcry_handler_log_t) (void *, int, const char *, va_list);
1849 : :
1850 : : /* Certain operations can provide progress information. This function
1851 : : is used to register a handler for retrieving these information. */
1852 : : void gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data);
1853 : :
1854 : :
1855 : : /* Register a custom memory allocation functions. */
1856 : : void gcry_set_allocation_handler (
1857 : : gcry_handler_alloc_t func_alloc,
1858 : : gcry_handler_alloc_t func_alloc_secure,
1859 : : gcry_handler_secure_check_t func_secure_check,
1860 : : gcry_handler_realloc_t func_realloc,
1861 : : gcry_handler_free_t func_free);
1862 : :
1863 : : /* Register a function used instead of the internal out of memory
1864 : : handler. */
1865 : : void gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque);
1866 : :
1867 : : /* Register a function used instead of the internal fatal error
1868 : : handler. */
1869 : : void gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque);
1870 : :
1871 : : /* Register a function used instead of the internal logging
1872 : : facility. */
1873 : : void gcry_set_log_handler (gcry_handler_log_t f, void *opaque);
1874 : :
1875 : : /* Reserved for future use. */
1876 : : void gcry_set_gettext_handler (const char *(*f)(const char*));
1877 : :
1878 : : /* Libgcrypt uses its own memory allocation. It is important to use
1879 : : gcry_free () to release memory allocated by libgcrypt. */
1880 : : void *gcry_malloc (size_t n) _GCRY_GCC_ATTR_MALLOC;
1881 : : void *gcry_calloc (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
1882 : : void *gcry_malloc_secure (size_t n) _GCRY_GCC_ATTR_MALLOC;
1883 : : void *gcry_calloc_secure (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
1884 : : void *gcry_realloc (void *a, size_t n);
1885 : : char *gcry_strdup (const char *string) _GCRY_GCC_ATTR_MALLOC;
1886 : : void *gcry_xmalloc (size_t n) _GCRY_GCC_ATTR_MALLOC;
1887 : : void *gcry_xcalloc (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
1888 : : void *gcry_xmalloc_secure (size_t n) _GCRY_GCC_ATTR_MALLOC;
1889 : : void *gcry_xcalloc_secure (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
1890 : : void *gcry_xrealloc (void *a, size_t n);
1891 : : char *gcry_xstrdup (const char * a) _GCRY_GCC_ATTR_MALLOC;
1892 : : void gcry_free (void *a);
1893 : :
1894 : : /* Return true if A is allocated in "secure" memory. */
1895 : : int gcry_is_secure (const void *a) _GCRY_GCC_ATTR_PURE;
1896 : :
1897 : : /* Return true if Libgcrypt is in FIPS mode. */
1898 : : #define gcry_fips_mode_active() !!gcry_control (GCRYCTL_FIPS_MODE_P, 0)
1899 : :
1900 : :
1901 : : /* Include support for Libgcrypt modules. */
1902 : : #include <gcrypt-module.h>
1903 : :
1904 : : #if 0 /* (Keep Emacsens' auto-indent happy.) */
1905 : : {
1906 : : #endif
1907 : : #ifdef __cplusplus
1908 : : }
1909 : : #endif
1910 : : #endif /* _GCRYPT_H */
1911 : : /*
1912 : : Local Variables:
1913 : : buffer-read-only: t
1914 : : End:
1915 : : */
|
