You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7586 lines
218 KiB
C
7586 lines
218 KiB
C
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef long unsigned int size_t;
|
|
|
|
|
|
typedef __builtin_va_list __gnuc_va_list;
|
|
|
|
|
|
|
|
typedef unsigned char __u_char;
|
|
typedef unsigned short int __u_short;
|
|
typedef unsigned int __u_int;
|
|
typedef unsigned long int __u_long;
|
|
|
|
|
|
typedef signed char __int8_t;
|
|
typedef unsigned char __uint8_t;
|
|
typedef signed short int __int16_t;
|
|
typedef unsigned short int __uint16_t;
|
|
typedef signed int __int32_t;
|
|
typedef unsigned int __uint32_t;
|
|
|
|
typedef signed long int __int64_t;
|
|
typedef unsigned long int __uint64_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __int8_t __int_least8_t;
|
|
typedef __uint8_t __uint_least8_t;
|
|
typedef __int16_t __int_least16_t;
|
|
typedef __uint16_t __uint_least16_t;
|
|
typedef __int32_t __int_least32_t;
|
|
typedef __uint32_t __uint_least32_t;
|
|
typedef __int64_t __int_least64_t;
|
|
typedef __uint64_t __uint_least64_t;
|
|
|
|
|
|
|
|
typedef long int __quad_t;
|
|
typedef unsigned long int __u_quad_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef long int __intmax_t;
|
|
typedef unsigned long int __uintmax_t;
|
|
|
|
|
|
typedef unsigned long int __dev_t;
|
|
typedef unsigned int __uid_t;
|
|
typedef unsigned int __gid_t;
|
|
typedef unsigned long int __ino_t;
|
|
typedef unsigned long int __ino64_t;
|
|
typedef unsigned int __mode_t;
|
|
typedef unsigned long int __nlink_t;
|
|
typedef long int __off_t;
|
|
typedef long int __off64_t;
|
|
typedef int __pid_t;
|
|
typedef struct { int __val[2]; } __fsid_t;
|
|
typedef long int __clock_t;
|
|
typedef unsigned long int __rlim_t;
|
|
typedef unsigned long int __rlim64_t;
|
|
typedef unsigned int __id_t;
|
|
typedef long int __time_t;
|
|
typedef unsigned int __useconds_t;
|
|
typedef long int __suseconds_t;
|
|
|
|
typedef int __daddr_t;
|
|
typedef int __key_t;
|
|
|
|
|
|
typedef int __clockid_t;
|
|
|
|
|
|
typedef void * __timer_t;
|
|
|
|
|
|
typedef long int __blksize_t;
|
|
|
|
|
|
|
|
|
|
typedef long int __blkcnt_t;
|
|
typedef long int __blkcnt64_t;
|
|
|
|
|
|
typedef unsigned long int __fsblkcnt_t;
|
|
typedef unsigned long int __fsblkcnt64_t;
|
|
|
|
|
|
typedef unsigned long int __fsfilcnt_t;
|
|
typedef unsigned long int __fsfilcnt64_t;
|
|
|
|
|
|
typedef long int __fsword_t;
|
|
|
|
typedef long int __ssize_t;
|
|
|
|
|
|
typedef long int __syscall_slong_t;
|
|
|
|
typedef unsigned long int __syscall_ulong_t;
|
|
|
|
|
|
|
|
typedef __off64_t __loff_t;
|
|
typedef char *__caddr_t;
|
|
|
|
|
|
typedef long int __intptr_t;
|
|
|
|
|
|
typedef unsigned int __socklen_t;
|
|
|
|
|
|
|
|
|
|
typedef int __sig_atomic_t;
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int __count;
|
|
union
|
|
{
|
|
unsigned int __wch;
|
|
char __wchb[4];
|
|
} __value;
|
|
} __mbstate_t;
|
|
|
|
|
|
|
|
|
|
typedef struct _G_fpos_t
|
|
{
|
|
__off_t __pos;
|
|
__mbstate_t __state;
|
|
} __fpos_t;
|
|
typedef struct _G_fpos64_t
|
|
{
|
|
__off64_t __pos;
|
|
__mbstate_t __state;
|
|
} __fpos64_t;
|
|
|
|
|
|
|
|
struct _IO_FILE;
|
|
typedef struct _IO_FILE __FILE;
|
|
|
|
|
|
|
|
struct _IO_FILE;
|
|
|
|
|
|
typedef struct _IO_FILE FILE;
|
|
struct _IO_FILE;
|
|
struct _IO_marker;
|
|
struct _IO_codecvt;
|
|
struct _IO_wide_data;
|
|
|
|
|
|
|
|
|
|
typedef void _IO_lock_t;
|
|
|
|
|
|
|
|
|
|
|
|
struct _IO_FILE
|
|
{
|
|
int _flags;
|
|
|
|
|
|
char *_IO_read_ptr;
|
|
char *_IO_read_end;
|
|
char *_IO_read_base;
|
|
char *_IO_write_base;
|
|
char *_IO_write_ptr;
|
|
char *_IO_write_end;
|
|
char *_IO_buf_base;
|
|
char *_IO_buf_end;
|
|
|
|
|
|
char *_IO_save_base;
|
|
char *_IO_backup_base;
|
|
char *_IO_save_end;
|
|
|
|
struct _IO_marker *_markers;
|
|
|
|
struct _IO_FILE *_chain;
|
|
|
|
int _fileno;
|
|
int _flags2;
|
|
__off_t _old_offset;
|
|
|
|
|
|
unsigned short _cur_column;
|
|
signed char _vtable_offset;
|
|
char _shortbuf[1];
|
|
|
|
_IO_lock_t *_lock;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__off64_t _offset;
|
|
|
|
struct _IO_codecvt *_codecvt;
|
|
struct _IO_wide_data *_wide_data;
|
|
struct _IO_FILE *_freeres_list;
|
|
void *_freeres_buf;
|
|
size_t __pad5;
|
|
int _mode;
|
|
|
|
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
|
|
};
|
|
typedef __gnuc_va_list va_list;
|
|
typedef __off_t off_t;
|
|
typedef __ssize_t ssize_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __fpos_t fpos_t;
|
|
|
|
|
|
|
|
extern FILE *stdin;
|
|
extern FILE *stdout;
|
|
extern FILE *stderr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern int renameat (int __oldfd, const char *__old, int __newfd,
|
|
const char *__new) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern FILE *tmpfile (void) ;
|
|
extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
|
|
extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
extern char *tempnam (const char *__dir, const char *__pfx)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fclose (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
extern int fflush (FILE *__stream);
|
|
extern int fflush_unlocked (FILE *__stream);
|
|
extern FILE *fopen (const char *__restrict __filename,
|
|
const char *__restrict __modes) ;
|
|
|
|
|
|
|
|
|
|
extern FILE *freopen (const char *__restrict __filename,
|
|
const char *__restrict __modes,
|
|
FILE *__restrict __stream) ;
|
|
extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
|
|
__attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
|
|
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
|
|
int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
|
|
size_t __size) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fprintf (FILE *__restrict __stream,
|
|
const char *__restrict __format, ...);
|
|
|
|
|
|
|
|
|
|
extern int printf (const char *__restrict __format, ...);
|
|
|
|
extern int sprintf (char *__restrict __s,
|
|
const char *__restrict __format, ...) __attribute__ ((__nothrow__));
|
|
|
|
|
|
|
|
|
|
|
|
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
|
|
__gnuc_va_list __arg);
|
|
|
|
|
|
|
|
|
|
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
|
|
|
|
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
|
|
__gnuc_va_list __arg) __attribute__ ((__nothrow__));
|
|
|
|
|
|
|
|
extern int snprintf (char *__restrict __s, size_t __maxlen,
|
|
const char *__restrict __format, ...)
|
|
__attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
|
|
|
|
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
|
|
const char *__restrict __format, __gnuc_va_list __arg)
|
|
__attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
|
|
extern int vdprintf (int __fd, const char *__restrict __fmt,
|
|
__gnuc_va_list __arg)
|
|
__attribute__ ((__format__ (__printf__, 2, 0)));
|
|
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
|
|
__attribute__ ((__format__ (__printf__, 2, 3)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fscanf (FILE *__restrict __stream,
|
|
const char *__restrict __format, ...) ;
|
|
|
|
|
|
|
|
|
|
extern int scanf (const char *__restrict __format, ...) ;
|
|
|
|
extern int sscanf (const char *__restrict __s,
|
|
const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
|
|
|
|
;
|
|
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
|
|
;
|
|
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__))
|
|
|
|
;
|
|
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
|
|
__gnuc_va_list __arg)
|
|
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
|
|
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
|
|
|
|
|
|
extern int vsscanf (const char *__restrict __s,
|
|
const char *__restrict __format, __gnuc_va_list __arg)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
|
|
|
|
|
|
|
|
|
|
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
|
|
|
|
|
|
|
|
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
|
|
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
|
|
|
|
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
|
|
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
|
|
|
|
|
|
|
|
__attribute__ ((__format__ (__scanf__, 2, 0)));
|
|
extern int fgetc (FILE *__stream);
|
|
extern int getc (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int getchar (void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int getc_unlocked (FILE *__stream);
|
|
extern int getchar_unlocked (void);
|
|
extern int fgetc_unlocked (FILE *__stream);
|
|
extern int fputc (int __c, FILE *__stream);
|
|
extern int putc (int __c, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int putchar (int __c);
|
|
extern int fputc_unlocked (int __c, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int putc_unlocked (int __c, FILE *__stream);
|
|
extern int putchar_unlocked (int __c);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int getw (FILE *__stream);
|
|
|
|
|
|
extern int putw (int __w, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
|
|
;
|
|
extern __ssize_t __getdelim (char **__restrict __lineptr,
|
|
size_t *__restrict __n, int __delimiter,
|
|
FILE *__restrict __stream) ;
|
|
extern __ssize_t getdelim (char **__restrict __lineptr,
|
|
size_t *__restrict __n, int __delimiter,
|
|
FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern __ssize_t getline (char **__restrict __lineptr,
|
|
size_t *__restrict __n,
|
|
FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern int puts (const char *__s);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int ungetc (int __c, FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t fread (void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __stream) ;
|
|
|
|
|
|
|
|
|
|
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __s);
|
|
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __stream) ;
|
|
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
|
|
size_t __n, FILE *__restrict __stream);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int fseek (FILE *__stream, long int __off, int __whence);
|
|
|
|
|
|
|
|
|
|
extern long int ftell (FILE *__stream) ;
|
|
|
|
|
|
|
|
|
|
extern void rewind (FILE *__stream);
|
|
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
|
|
|
|
|
|
|
|
|
|
extern __off_t ftello (FILE *__stream) ;
|
|
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
|
|
|
|
|
|
|
|
|
|
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
|
|
extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void perror (const char *__s);
|
|
|
|
|
|
|
|
|
|
|
|
extern int sys_nerr;
|
|
extern const char *const sys_errlist[];
|
|
|
|
|
|
|
|
|
|
extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
|
|
extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
extern FILE *popen (const char *__command, const char *__modes) ;
|
|
|
|
|
|
|
|
|
|
|
|
extern int pclose (FILE *__stream);
|
|
|
|
|
|
|
|
|
|
|
|
extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern int __uflow (FILE *);
|
|
extern int __overflow (FILE *, int);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __int8_t int8_t;
|
|
typedef __int16_t int16_t;
|
|
typedef __int32_t int32_t;
|
|
typedef __int64_t int64_t;
|
|
|
|
|
|
typedef __uint8_t uint8_t;
|
|
typedef __uint16_t uint16_t;
|
|
typedef __uint32_t uint32_t;
|
|
typedef __uint64_t uint64_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef __int_least8_t int_least8_t;
|
|
typedef __int_least16_t int_least16_t;
|
|
typedef __int_least32_t int_least32_t;
|
|
typedef __int_least64_t int_least64_t;
|
|
|
|
|
|
typedef __uint_least8_t uint_least8_t;
|
|
typedef __uint_least16_t uint_least16_t;
|
|
typedef __uint_least32_t uint_least32_t;
|
|
typedef __uint_least64_t uint_least64_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef signed char int_fast8_t;
|
|
|
|
typedef long int int_fast16_t;
|
|
typedef long int int_fast32_t;
|
|
typedef long int int_fast64_t;
|
|
typedef unsigned char uint_fast8_t;
|
|
|
|
typedef unsigned long int uint_fast16_t;
|
|
typedef unsigned long int uint_fast32_t;
|
|
typedef unsigned long int uint_fast64_t;
|
|
typedef long int intptr_t;
|
|
|
|
|
|
typedef unsigned long int uintptr_t;
|
|
typedef __intmax_t intmax_t;
|
|
typedef __uintmax_t uintmax_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef int wchar_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int quot;
|
|
int rem;
|
|
} div_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
long int quot;
|
|
long int rem;
|
|
} ldiv_t;
|
|
|
|
|
|
|
|
|
|
|
|
__extension__ typedef struct
|
|
{
|
|
long long int quot;
|
|
long long int rem;
|
|
} lldiv_t;
|
|
extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
extern double atof (const char *__nptr)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
extern int atoi (const char *__nptr)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
extern long int atol (const char *__nptr)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
__extension__ extern long long int atoll (const char *__nptr)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
extern double strtod (const char *__restrict __nptr,
|
|
char **__restrict __endptr)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
extern float strtof (const char *__restrict __nptr,
|
|
char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
extern long double strtold (const char *__restrict __nptr,
|
|
char **__restrict __endptr)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
extern long int strtol (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
extern unsigned long int strtoul (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
__extension__
|
|
extern long long int strtoq (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
__extension__
|
|
extern unsigned long long int strtouq (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
__extension__
|
|
extern long long int strtoll (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
__extension__
|
|
extern unsigned long long int strtoull (const char *__restrict __nptr,
|
|
char **__restrict __endptr, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
extern long int a64l (const char *__s)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __u_char u_char;
|
|
typedef __u_short u_short;
|
|
typedef __u_int u_int;
|
|
typedef __u_long u_long;
|
|
typedef __quad_t quad_t;
|
|
typedef __u_quad_t u_quad_t;
|
|
typedef __fsid_t fsid_t;
|
|
|
|
|
|
typedef __loff_t loff_t;
|
|
|
|
|
|
|
|
|
|
typedef __ino_t ino_t;
|
|
typedef __dev_t dev_t;
|
|
|
|
|
|
|
|
|
|
typedef __gid_t gid_t;
|
|
|
|
|
|
|
|
|
|
typedef __mode_t mode_t;
|
|
|
|
|
|
|
|
|
|
typedef __nlink_t nlink_t;
|
|
|
|
|
|
|
|
|
|
typedef __uid_t uid_t;
|
|
typedef __pid_t pid_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef __id_t id_t;
|
|
typedef __daddr_t daddr_t;
|
|
typedef __caddr_t caddr_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef __key_t key_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __clock_t clock_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __clockid_t clockid_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __time_t time_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __timer_t timer_t;
|
|
|
|
|
|
|
|
typedef unsigned long int ulong;
|
|
typedef unsigned short int ushort;
|
|
typedef unsigned int uint;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __uint8_t u_int8_t;
|
|
typedef __uint16_t u_int16_t;
|
|
typedef __uint32_t u_int32_t;
|
|
typedef __uint64_t u_int64_t;
|
|
|
|
|
|
typedef int register_t __attribute__ ((__mode__ (__word__)));
|
|
static __inline __uint16_t
|
|
__bswap_16 (__uint16_t __bsx)
|
|
{
|
|
|
|
return __builtin_bswap16 (__bsx);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static __inline __uint32_t
|
|
__bswap_32 (__uint32_t __bsx)
|
|
{
|
|
|
|
return __builtin_bswap32 (__bsx);
|
|
|
|
|
|
|
|
}
|
|
__extension__ static __inline __uint64_t
|
|
__bswap_64 (__uint64_t __bsx)
|
|
{
|
|
|
|
return __builtin_bswap64 (__bsx);
|
|
|
|
|
|
|
|
}
|
|
static __inline __uint16_t
|
|
__uint16_identity (__uint16_t __x)
|
|
{
|
|
return __x;
|
|
}
|
|
|
|
static __inline __uint32_t
|
|
__uint32_identity (__uint32_t __x)
|
|
{
|
|
return __x;
|
|
}
|
|
|
|
static __inline __uint64_t
|
|
__uint64_identity (__uint64_t __x)
|
|
{
|
|
return __x;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
|
|
} __sigset_t;
|
|
|
|
|
|
typedef __sigset_t sigset_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct timeval
|
|
{
|
|
__time_t tv_sec;
|
|
__suseconds_t tv_usec;
|
|
};
|
|
|
|
struct timespec
|
|
{
|
|
__time_t tv_sec;
|
|
__syscall_slong_t tv_nsec;
|
|
};
|
|
|
|
|
|
|
|
typedef __suseconds_t suseconds_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef long int __fd_mask;
|
|
typedef struct
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
|
|
__fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
|
|
|
|
|
|
} fd_set;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __fd_mask fd_mask;
|
|
|
|
extern int select (int __nfds, fd_set *__restrict __readfds,
|
|
fd_set *__restrict __writefds,
|
|
fd_set *__restrict __exceptfds,
|
|
struct timeval *__restrict __timeout);
|
|
extern int pselect (int __nfds, fd_set *__restrict __readfds,
|
|
fd_set *__restrict __writefds,
|
|
fd_set *__restrict __exceptfds,
|
|
const struct timespec *__restrict __timeout,
|
|
const __sigset_t *__restrict __sigmask);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __blksize_t blksize_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef __blkcnt_t blkcnt_t;
|
|
|
|
|
|
|
|
typedef __fsblkcnt_t fsblkcnt_t;
|
|
|
|
|
|
|
|
typedef __fsfilcnt_t fsfilcnt_t;
|
|
struct __pthread_rwlock_arch_t
|
|
{
|
|
unsigned int __readers;
|
|
unsigned int __writers;
|
|
unsigned int __wrphase_futex;
|
|
unsigned int __writers_futex;
|
|
unsigned int __pad3;
|
|
unsigned int __pad4;
|
|
|
|
int __cur_writer;
|
|
int __shared;
|
|
signed char __rwelision;
|
|
|
|
|
|
|
|
|
|
unsigned char __pad1[7];
|
|
|
|
|
|
unsigned long int __pad2;
|
|
|
|
|
|
unsigned int __flags;
|
|
};
|
|
|
|
|
|
|
|
|
|
typedef struct __pthread_internal_list
|
|
{
|
|
struct __pthread_internal_list *__prev;
|
|
struct __pthread_internal_list *__next;
|
|
} __pthread_list_t;
|
|
struct __pthread_mutex_s
|
|
{
|
|
int __lock ;
|
|
unsigned int __count;
|
|
int __owner;
|
|
|
|
unsigned int __nusers;
|
|
int __kind;
|
|
|
|
|
|
|
|
|
|
|
|
short __spins; short __elision;
|
|
__pthread_list_t __list;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct __pthread_cond_s
|
|
{
|
|
__extension__ union
|
|
{
|
|
__extension__ unsigned long long int __wseq;
|
|
struct
|
|
{
|
|
unsigned int __low;
|
|
unsigned int __high;
|
|
} __wseq32;
|
|
};
|
|
__extension__ union
|
|
{
|
|
__extension__ unsigned long long int __g1_start;
|
|
struct
|
|
{
|
|
unsigned int __low;
|
|
unsigned int __high;
|
|
} __g1_start32;
|
|
};
|
|
unsigned int __g_refs[2] ;
|
|
unsigned int __g_size[2];
|
|
unsigned int __g1_orig_size;
|
|
unsigned int __wrefs;
|
|
unsigned int __g_signals[2];
|
|
};
|
|
|
|
|
|
|
|
typedef unsigned long int pthread_t;
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
char __size[4];
|
|
int __align;
|
|
} pthread_mutexattr_t;
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
char __size[4];
|
|
int __align;
|
|
} pthread_condattr_t;
|
|
|
|
|
|
|
|
typedef unsigned int pthread_key_t;
|
|
|
|
|
|
|
|
typedef int pthread_once_t;
|
|
|
|
|
|
union pthread_attr_t
|
|
{
|
|
char __size[56];
|
|
long int __align;
|
|
};
|
|
|
|
typedef union pthread_attr_t pthread_attr_t;
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
struct __pthread_mutex_s __data;
|
|
char __size[40];
|
|
long int __align;
|
|
} pthread_mutex_t;
|
|
|
|
|
|
typedef union
|
|
{
|
|
struct __pthread_cond_s __data;
|
|
char __size[48];
|
|
__extension__ long long int __align;
|
|
} pthread_cond_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
struct __pthread_rwlock_arch_t __data;
|
|
char __size[56];
|
|
long int __align;
|
|
} pthread_rwlock_t;
|
|
|
|
typedef union
|
|
{
|
|
char __size[8];
|
|
long int __align;
|
|
} pthread_rwlockattr_t;
|
|
|
|
|
|
|
|
|
|
|
|
typedef volatile int pthread_spinlock_t;
|
|
|
|
|
|
|
|
|
|
typedef union
|
|
{
|
|
char __size[32];
|
|
long int __align;
|
|
} pthread_barrier_t;
|
|
|
|
typedef union
|
|
{
|
|
char __size[4];
|
|
int __align;
|
|
} pthread_barrierattr_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
extern char *initstate (unsigned int __seed, char *__statebuf,
|
|
size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
|
|
extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct random_data
|
|
{
|
|
int32_t *fptr;
|
|
int32_t *rptr;
|
|
int32_t *state;
|
|
int rand_type;
|
|
int rand_deg;
|
|
int rand_sep;
|
|
int32_t *end_ptr;
|
|
};
|
|
|
|
extern int random_r (struct random_data *__restrict __buf,
|
|
int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
|
|
|
|
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
|
|
size_t __statelen,
|
|
struct random_data *__restrict __buf)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
|
|
|
|
extern int setstate_r (char *__restrict __statebuf,
|
|
struct random_data *__restrict __buf)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern long int nrand48 (unsigned short int __xsubi[3])
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern long int jrand48 (unsigned short int __xsubi[3])
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
struct drand48_data
|
|
{
|
|
unsigned short int __x[3];
|
|
unsigned short int __old_x[3];
|
|
unsigned short int __c;
|
|
unsigned short int __init;
|
|
__extension__ unsigned long long int __a;
|
|
|
|
};
|
|
|
|
|
|
extern int drand48_r (struct drand48_data *__restrict __buffer,
|
|
double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
extern int erand48_r (unsigned short int __xsubi[3],
|
|
struct drand48_data *__restrict __buffer,
|
|
double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int lrand48_r (struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
extern int nrand48_r (unsigned short int __xsubi[3],
|
|
struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int mrand48_r (struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
extern int jrand48_r (unsigned short int __xsubi[3],
|
|
struct drand48_data *__restrict __buffer,
|
|
long int *__restrict __result)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
|
|
|
|
extern int seed48_r (unsigned short int __seed16v[3],
|
|
struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
extern int lcong48_r (unsigned short int __param[7],
|
|
struct drand48_data *__buffer)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
|
|
|
|
|
|
|
extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
|
|
__attribute__ ((__alloc_size__ (1))) ;
|
|
|
|
extern void *calloc (size_t __nmemb, size_t __size)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *realloc (void *__ptr, size_t __size)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__))
|
|
__attribute__ ((__alloc_size__ (2, 3)));
|
|
|
|
|
|
|
|
extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
|
|
__attribute__ ((__alloc_size__ (1))) ;
|
|
|
|
|
|
|
|
|
|
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
|
|
|
|
|
|
|
|
|
|
extern void *aligned_alloc (size_t __alignment, size_t __size)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
|
|
|
|
|
|
|
|
extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
|
|
extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
|
|
|
|
|
|
|
|
|
|
extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
|
|
extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int setenv (const char *__name, const char *__value, int __replace)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
|
|
|
|
|
|
extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
|
|
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
|
|
extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
|
|
extern int system (const char *__command) ;
|
|
extern char *realpath (const char *__restrict __name,
|
|
char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef int (*__compar_fn_t) (const void *, const void *);
|
|
extern void *bsearch (const void *__key, const void *__base,
|
|
size_t __nmemb, size_t __size, __compar_fn_t __compar)
|
|
__attribute__ ((__nonnull__ (1, 2, 5))) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern void qsort (void *__base, size_t __nmemb, size_t __size,
|
|
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
|
|
extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
|
|
extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
|
|
|
|
|
|
__extension__ extern long long int llabs (long long int __x)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern div_t div (int __numer, int __denom)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
|
|
extern ldiv_t ldiv (long int __numer, long int __denom)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
|
|
|
|
|
|
__extension__ extern lldiv_t lldiv (long long int __numer,
|
|
long long int __denom)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
|
|
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
|
|
|
|
|
|
|
|
|
|
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
|
|
|
|
|
|
|
|
|
|
extern char *gcvt (double __value, int __ndigit, char *__buf)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
|
|
|
|
|
|
|
|
|
|
extern char *qecvt (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
|
|
extern char *qfcvt (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
|
|
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
|
|
|
|
|
|
|
|
|
|
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign, char *__restrict __buf,
|
|
size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
|
|
int *__restrict __sign, char *__restrict __buf,
|
|
size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
|
|
extern int qecvt_r (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign,
|
|
char *__restrict __buf, size_t __len)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
extern int qfcvt_r (long double __value, int __ndigit,
|
|
int *__restrict __decpt, int *__restrict __sign,
|
|
char *__restrict __buf, size_t __len)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
|
|
|
|
|
|
|
|
|
|
|
|
extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int mbtowc (wchar_t *__restrict __pwc,
|
|
const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
|
|
const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
extern size_t wcstombs (char *__restrict __s,
|
|
const wchar_t *__restrict __pwcs, size_t __n)
|
|
__attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
|
|
extern int getsubopt (char **__restrict __optionp,
|
|
char *const *__restrict __tokens,
|
|
char **__restrict __valuep)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) ;
|
|
extern int getloadavg (double __loadavg[], int __nelem)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct stack_st {
|
|
int num;
|
|
char **data;
|
|
int sorted;
|
|
|
|
int num_alloc;
|
|
int (*comp)(const void *, const void *);
|
|
} _STACK;
|
|
|
|
|
|
|
|
|
|
int sk_num(const _STACK *);
|
|
void *sk_value(const _STACK *, int);
|
|
|
|
void *sk_set(_STACK *, int, void *);
|
|
|
|
_STACK *sk_new(int (*cmp)(const void *, const void *));
|
|
_STACK *sk_new_null(void);
|
|
void sk_free(_STACK *);
|
|
void sk_pop_free(_STACK *st, void (*func)(void *));
|
|
int sk_insert(_STACK *sk, void *data, int where);
|
|
void *sk_delete(_STACK *st, int loc);
|
|
void *sk_delete_ptr(_STACK *st, void *p);
|
|
int sk_find(_STACK *st, void *data);
|
|
int sk_find_ex(_STACK *st, void *data);
|
|
int sk_push(_STACK *st, void *data);
|
|
int sk_unshift(_STACK *st, void *data);
|
|
void *sk_shift(_STACK *st);
|
|
void *sk_pop(_STACK *st);
|
|
void sk_zero(_STACK *st);
|
|
int (*sk_set_cmp_func(_STACK *sk, int (*c)(const void *, const void *)))(
|
|
const void *, const void *);
|
|
_STACK *sk_dup(_STACK *st);
|
|
void sk_sort(_STACK *st);
|
|
int sk_is_sorted(const _STACK *st);
|
|
typedef char *OPENSSL_STRING;
|
|
|
|
typedef const char *OPENSSL_CSTRING;
|
|
struct stack_st_OPENSSL_STRING { _STACK stack; };
|
|
|
|
|
|
|
|
|
|
|
|
typedef void *OPENSSL_BLOCK;
|
|
struct stack_st_OPENSSL_BLOCK { _STACK stack; };
|
|
|
|
typedef struct asn1_string_st ASN1_INTEGER;
|
|
typedef struct asn1_string_st ASN1_ENUMERATED;
|
|
typedef struct asn1_string_st ASN1_BIT_STRING;
|
|
typedef struct asn1_string_st ASN1_OCTET_STRING;
|
|
typedef struct asn1_string_st ASN1_PRINTABLESTRING;
|
|
typedef struct asn1_string_st ASN1_T61STRING;
|
|
typedef struct asn1_string_st ASN1_IA5STRING;
|
|
typedef struct asn1_string_st ASN1_GENERALSTRING;
|
|
typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
|
|
typedef struct asn1_string_st ASN1_BMPSTRING;
|
|
typedef struct asn1_string_st ASN1_UTCTIME;
|
|
typedef struct asn1_string_st ASN1_TIME;
|
|
typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
|
|
typedef struct asn1_string_st ASN1_VISIBLESTRING;
|
|
typedef struct asn1_string_st ASN1_UTF8STRING;
|
|
typedef struct asn1_string_st ASN1_STRING;
|
|
typedef int ASN1_BOOLEAN;
|
|
typedef int ASN1_NULL;
|
|
|
|
typedef struct ASN1_ITEM_st ASN1_ITEM;
|
|
typedef struct asn1_pctx_st ASN1_PCTX;
|
|
typedef struct bignum_st BIGNUM;
|
|
typedef struct bignum_ctx BN_CTX;
|
|
typedef struct bn_blinding_st BN_BLINDING;
|
|
typedef struct bn_mont_ctx_st BN_MONT_CTX;
|
|
typedef struct bn_recp_ctx_st BN_RECP_CTX;
|
|
typedef struct bn_gencb_st BN_GENCB;
|
|
|
|
typedef struct buf_mem_st BUF_MEM;
|
|
|
|
typedef struct evp_cipher_st EVP_CIPHER;
|
|
typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
|
|
typedef struct env_md_st EVP_MD;
|
|
typedef struct env_md_ctx_st EVP_MD_CTX;
|
|
typedef struct evp_pkey_st EVP_PKEY;
|
|
|
|
typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
|
|
|
|
typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
|
|
typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
|
|
|
|
typedef struct dh_st DH;
|
|
typedef struct dh_method DH_METHOD;
|
|
|
|
typedef struct dsa_st DSA;
|
|
typedef struct dsa_method DSA_METHOD;
|
|
|
|
typedef struct rsa_st RSA;
|
|
typedef struct rsa_meth_st RSA_METHOD;
|
|
|
|
typedef struct rand_meth_st RAND_METHOD;
|
|
|
|
typedef struct ecdh_method ECDH_METHOD;
|
|
typedef struct ecdsa_method ECDSA_METHOD;
|
|
|
|
typedef struct x509_st X509;
|
|
typedef struct X509_algor_st X509_ALGOR;
|
|
typedef struct X509_crl_st X509_CRL;
|
|
typedef struct x509_crl_method_st X509_CRL_METHOD;
|
|
typedef struct x509_revoked_st X509_REVOKED;
|
|
typedef struct X509_name_st X509_NAME;
|
|
typedef struct X509_pubkey_st X509_PUBKEY;
|
|
typedef struct x509_store_st X509_STORE;
|
|
typedef struct x509_store_ctx_st X509_STORE_CTX;
|
|
|
|
typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
|
|
|
|
typedef struct v3_ext_ctx X509V3_CTX;
|
|
typedef struct conf_st CONF;
|
|
|
|
typedef struct store_st STORE;
|
|
typedef struct store_method_st STORE_METHOD;
|
|
|
|
typedef struct ui_st UI;
|
|
typedef struct ui_method_st UI_METHOD;
|
|
|
|
typedef struct st_ERR_FNS ERR_FNS;
|
|
|
|
typedef struct engine_st ENGINE;
|
|
typedef struct ssl_st SSL;
|
|
typedef struct ssl_ctx_st SSL_CTX;
|
|
|
|
typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
|
|
typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
|
|
typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
|
|
typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
|
|
|
|
typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
|
|
typedef struct DIST_POINT_st DIST_POINT;
|
|
typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
|
|
typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
|
|
|
|
typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
|
|
int idx, long argl, void *argp);
|
|
typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
|
|
int idx, long argl, void *argp);
|
|
typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from,
|
|
void *from_d, int idx, long argl, void *argp);
|
|
|
|
typedef struct ocsp_req_ctx_st OCSP_REQ_CTX;
|
|
typedef struct ocsp_response_st OCSP_RESPONSE;
|
|
typedef struct ocsp_responder_id_st OCSP_RESPID;
|
|
typedef struct openssl_item_st {
|
|
int code;
|
|
void *value;
|
|
size_t value_size;
|
|
size_t *value_length;
|
|
} OPENSSL_ITEM;
|
|
typedef struct {
|
|
int references;
|
|
struct CRYPTO_dynlock_value *data;
|
|
} CRYPTO_dynlock;
|
|
typedef struct bio_st BIO_dummy;
|
|
|
|
struct crypto_ex_data_st {
|
|
struct stack_st_void *sk;
|
|
};
|
|
struct stack_st_void { _STACK stack; };
|
|
|
|
|
|
|
|
|
|
typedef struct crypto_ex_data_func_st {
|
|
long argl;
|
|
void *argp;
|
|
CRYPTO_EX_new *new_func;
|
|
CRYPTO_EX_free *free_func;
|
|
CRYPTO_EX_dup *dup_func;
|
|
} CRYPTO_EX_DATA_FUNCS;
|
|
|
|
struct stack_st_CRYPTO_EX_DATA_FUNCS { _STACK stack; };
|
|
int CRYPTO_mem_ctrl(int mode);
|
|
int CRYPTO_is_mem_check_on(void);
|
|
const char *OpenSSL_version(int type);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
unsigned long OpenSSL_version_num(void);
|
|
|
|
const char *SSLeay_version(int type);
|
|
unsigned long SSLeay(void);
|
|
|
|
|
|
typedef struct st_CRYPTO_EX_DATA_IMPL CRYPTO_EX_DATA_IMPL;
|
|
|
|
const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void);
|
|
|
|
int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i);
|
|
|
|
int CRYPTO_ex_data_new_class(void);
|
|
|
|
int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
|
|
CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
|
|
CRYPTO_EX_free *free_func);
|
|
|
|
|
|
int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
|
|
int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
|
|
CRYPTO_EX_DATA *from);
|
|
void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
|
|
|
|
|
|
int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
|
|
void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
|
|
|
|
|
|
void CRYPTO_cleanup_all_ex_data(void);
|
|
|
|
void CRYPTO_lock(int mode, int type, const char *file, int line);
|
|
int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
|
|
int line);
|
|
|
|
|
|
typedef struct crypto_threadid_st {
|
|
void *ptr;
|
|
unsigned long val;
|
|
} CRYPTO_THREADID;
|
|
void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
|
|
int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b);
|
|
void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src);
|
|
unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
|
|
|
|
|
|
|
|
void CRYPTO_set_id_callback(unsigned long (*func)(void));
|
|
unsigned long (*CRYPTO_get_id_callback(void))(void);
|
|
unsigned long CRYPTO_thread_id(void);
|
|
|
|
int CRYPTO_get_new_lockid(char *name);
|
|
const char *CRYPTO_get_lock_name(int type);
|
|
|
|
int CRYPTO_num_locks(void);
|
|
void CRYPTO_set_locking_callback(void (*func)(int mode, int type,
|
|
const char *file, int line));
|
|
void (*CRYPTO_get_locking_callback(void))(int mode, int type,
|
|
const char *file, int line);
|
|
void CRYPTO_set_add_lock_callback(int (*func)(int *num, int mount, int type,
|
|
const char *file, int line));
|
|
int (*CRYPTO_get_add_lock_callback(void))(int *num, int mount, int type,
|
|
const char *file, int line);
|
|
|
|
void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
|
|
void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
|
|
int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
|
|
void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
|
|
|
|
int CRYPTO_get_new_dynlockid(void);
|
|
void CRYPTO_destroy_dynlockid(int i);
|
|
struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i);
|
|
void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line));
|
|
void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
|
|
void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line));
|
|
struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file, int line);
|
|
void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line);
|
|
void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file, int line);
|
|
|
|
|
|
|
|
|
|
int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t), void (*f)(void *));
|
|
int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
|
|
int CRYPTO_set_mem_ex_functions(void *(*m)(size_t, const char *, int),
|
|
void *(*r)(void *, size_t, const char *, int), void (*f)(void *));
|
|
int CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t, const char *, int),
|
|
void (*free_func)(void *));
|
|
int CRYPTO_set_mem_debug_functions(
|
|
void (*m)(void *, int, const char *, int, int),
|
|
void (*r)(void *, void *, int, const char *, int, int),
|
|
void (*f)(void *, int), void (*so)(long), long (*go)(void));
|
|
void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
|
|
void (**f)(void *));
|
|
void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
|
|
void CRYPTO_get_mem_ex_functions(void *(**m)(size_t, const char *, int),
|
|
void *(**r)(void *, size_t, const char *, int), void (**f)(void *));
|
|
void CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t, const char *, int),
|
|
void (**f)(void *));
|
|
void CRYPTO_get_mem_debug_functions(
|
|
void (**m)(void *, int, const char *, int, int),
|
|
void (**r)(void *, void *, int, const char *, int, int),
|
|
void (**f)(void *, int), void (**so)(long), long (**go)(void));
|
|
|
|
|
|
void *CRYPTO_malloc_locked(int num, const char *file, int line);
|
|
void CRYPTO_free_locked(void *ptr);
|
|
void *CRYPTO_malloc(int num, const char *file, int line);
|
|
char *CRYPTO_strdup(const char *str, const char *file, int line);
|
|
void CRYPTO_free(void *ptr);
|
|
void *CRYPTO_realloc(void *addr, int num, const char *file, int line);
|
|
|
|
|
|
void *CRYPTO_realloc_clean(void *addr, int old_num, int num,
|
|
const char *file, int line);
|
|
void *CRYPTO_remalloc(void *addr, int num, const char *file, int line);
|
|
|
|
|
|
void OPENSSL_cleanse(void *ptr, size_t len);
|
|
|
|
|
|
void CRYPTO_set_mem_debug_options(long bits);
|
|
long CRYPTO_get_mem_debug_options(void);
|
|
|
|
|
|
|
|
int CRYPTO_push_info_(const char *info, const char *file, int line);
|
|
int CRYPTO_pop_info(void);
|
|
int CRYPTO_remove_all_info(void);
|
|
void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line, int before_p)
|
|
__attribute__ ((deprecated));
|
|
void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num, const char *file, int line, int before_p)
|
|
__attribute__ ((deprecated));
|
|
void CRYPTO_dbg_free(void *addr, int before_p)
|
|
__attribute__ ((deprecated));
|
|
void CRYPTO_dbg_set_options(long bits)
|
|
__attribute__ ((deprecated));
|
|
long CRYPTO_dbg_get_options(void)
|
|
__attribute__ ((deprecated));
|
|
|
|
|
|
int CRYPTO_mem_leaks_fp(FILE *);
|
|
int CRYPTO_mem_leaks(struct bio_st *bio);
|
|
|
|
typedef int *CRYPTO_MEM_LEAK_CB(unsigned long, const char *, int, int, void *);
|
|
int CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb);
|
|
|
|
|
|
void OpenSSLDie(const char *file, int line, const char *assertion);
|
|
|
|
|
|
uint64_t OPENSSL_cpu_caps(void);
|
|
|
|
int OPENSSL_isservice(void);
|
|
|
|
|
|
void OPENSSL_init(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int CRYPTO_memcmp(const void *a, const void *b, size_t len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_CRYPTO_strings(void);
|
|
int OPENSSL_init_crypto(uint64_t opts, const void *settings);
|
|
typedef struct bio_st BIO;
|
|
|
|
void BIO_set_flags(BIO *b, int flags);
|
|
int BIO_test_flags(const BIO *b, int flags);
|
|
void BIO_clear_flags(BIO *b, int flags);
|
|
long (*BIO_get_callback(const BIO *b))(struct bio_st *, int, const char *,
|
|
int, long, long);
|
|
void BIO_set_callback(BIO *b,
|
|
long (*callback)(struct bio_st *, int, const char *, int, long, long));
|
|
char *BIO_get_callback_arg(const BIO *b);
|
|
void BIO_set_callback_arg(BIO *b, char *arg);
|
|
|
|
const char * BIO_method_name(const BIO *b);
|
|
int BIO_method_type(const BIO *b);
|
|
|
|
typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long);
|
|
typedef int BIO_info_cb(BIO *, int, int);
|
|
|
|
typedef struct bio_method_st {
|
|
int type;
|
|
const char *name;
|
|
int (*bwrite)(BIO *, const char *, int);
|
|
int (*bread)(BIO *, char *, int);
|
|
int (*bputs)(BIO *, const char *);
|
|
int (*bgets)(BIO *, char *, int);
|
|
long (*ctrl)(BIO *, int, long, void *);
|
|
int (*create)(BIO *);
|
|
int (*destroy)(BIO *);
|
|
long (*callback_ctrl)(BIO *, int, bio_info_cb *);
|
|
} BIO_METHOD;
|
|
|
|
struct bio_st {
|
|
const BIO_METHOD *method;
|
|
|
|
long (*callback)(struct bio_st *, int, const char *, int, long, long);
|
|
char *cb_arg;
|
|
|
|
int init;
|
|
int shutdown;
|
|
int flags;
|
|
int retry_reason;
|
|
int num;
|
|
void *ptr;
|
|
struct bio_st *next_bio;
|
|
struct bio_st *prev_bio;
|
|
int references;
|
|
unsigned long num_read;
|
|
unsigned long num_write;
|
|
|
|
CRYPTO_EX_DATA ex_data;
|
|
};
|
|
|
|
struct stack_st_BIO { _STACK stack; };
|
|
|
|
typedef struct bio_f_buffer_ctx_struct {
|
|
int ibuf_size;
|
|
int obuf_size;
|
|
|
|
char *ibuf;
|
|
int ibuf_len;
|
|
int ibuf_off;
|
|
|
|
char *obuf;
|
|
int obuf_len;
|
|
int obuf_off;
|
|
} BIO_F_BUFFER_CTX;
|
|
|
|
|
|
typedef int asn1_ps_func(BIO *b, unsigned char **pbuf, int *plen, void *parg);
|
|
|
|
|
|
BIO_METHOD *BIO_meth_new(int type, const char *name);
|
|
void BIO_meth_free(BIO_METHOD *biom);
|
|
int (*BIO_meth_get_write(const BIO_METHOD *biom))(BIO *, const char *, int);
|
|
int BIO_meth_set_write(BIO_METHOD *biom,
|
|
int (*write)(BIO *, const char *, int));
|
|
int (*BIO_meth_get_read(const BIO_METHOD *biom))(BIO *, char *, int);
|
|
int BIO_meth_set_read(BIO_METHOD *biom, int (*read)(BIO *, char *, int));
|
|
int (*BIO_meth_get_puts(const BIO_METHOD *biom))(BIO *, const char *);
|
|
int BIO_meth_set_puts(BIO_METHOD *biom, int (*puts)(BIO *, const char *));
|
|
int (*BIO_meth_get_gets(const BIO_METHOD *biom))(BIO *, char *, int);
|
|
int BIO_meth_set_gets(BIO_METHOD *biom, int (*gets)(BIO *, char *, int));
|
|
long (*BIO_meth_get_ctrl(const BIO_METHOD *biom))(BIO *, int, long, void *);
|
|
int BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl)(BIO *, int, long, void *));
|
|
int (*BIO_meth_get_create(const BIO_METHOD *biom))(BIO *);
|
|
int BIO_meth_set_create(BIO_METHOD *biom, int (*create)(BIO *));
|
|
int (*BIO_meth_get_destroy(const BIO_METHOD *biom))(BIO *);
|
|
int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy)(BIO *));
|
|
long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))(BIO *, int, BIO_info_cb *);
|
|
int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
|
|
long (*callback_ctrl)(BIO *, int, BIO_info_cb *));
|
|
size_t BIO_ctrl_pending(BIO *b);
|
|
size_t BIO_ctrl_wpending(BIO *b);
|
|
size_t BIO_ctrl_get_write_guarantee(BIO *b);
|
|
size_t BIO_ctrl_get_read_request(BIO *b);
|
|
int BIO_ctrl_reset_read_request(BIO *b);
|
|
int BIO_set_ex_data(BIO *bio, int idx, void *data);
|
|
void *BIO_get_ex_data(BIO *bio, int idx);
|
|
int
|
|
BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
unsigned long BIO_number_read(BIO *bio);
|
|
unsigned long BIO_number_written(BIO *bio);
|
|
|
|
|
|
int
|
|
BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
|
|
asn1_ps_func *prefix_free);
|
|
int
|
|
BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
|
|
asn1_ps_func **pprefix_free);
|
|
int
|
|
BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
|
|
asn1_ps_func *suffix_free);
|
|
int
|
|
BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
|
|
asn1_ps_func **psuffix_free);
|
|
|
|
int BIO_get_new_index(void);
|
|
const BIO_METHOD *BIO_s_file(void);
|
|
BIO *BIO_new_file(const char *filename, const char *mode);
|
|
BIO *BIO_new_fp(FILE *stream, int close_flag);
|
|
|
|
BIO *BIO_new(const BIO_METHOD *type);
|
|
int BIO_set(BIO *a, const BIO_METHOD *type);
|
|
int BIO_free(BIO *a);
|
|
int BIO_up_ref(BIO *bio);
|
|
void *BIO_get_data(BIO *a);
|
|
void BIO_set_data(BIO *a, void *ptr);
|
|
void BIO_set_init(BIO *a, int init);
|
|
int BIO_get_shutdown(BIO *a);
|
|
void BIO_set_shutdown(BIO *a, int shut);
|
|
void BIO_vfree(BIO *a);
|
|
int BIO_read(BIO *b, void *data, int len)
|
|
__attribute__(());
|
|
int BIO_gets(BIO *bp, char *buf, int size)
|
|
__attribute__(());
|
|
int BIO_write(BIO *b, const void *data, int len)
|
|
__attribute__(());
|
|
int BIO_puts(BIO *bp, const char *buf);
|
|
int BIO_indent(BIO *b, int indent, int max);
|
|
long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
|
|
long BIO_callback_ctrl(BIO *b, int cmd,
|
|
void (*fp)(struct bio_st *, int, const char *, int, long, long));
|
|
char * BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
|
|
long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
|
|
BIO * BIO_push(BIO *b, BIO *append);
|
|
BIO * BIO_pop(BIO *b);
|
|
void BIO_free_all(BIO *a);
|
|
BIO * BIO_find_type(BIO *b, int bio_type);
|
|
BIO * BIO_next(BIO *b);
|
|
BIO * BIO_get_retry_BIO(BIO *bio, int *reason);
|
|
int BIO_get_retry_reason(BIO *bio);
|
|
BIO * BIO_dup_chain(BIO *in);
|
|
|
|
int BIO_nread0(BIO *bio, char **buf);
|
|
int BIO_nread(BIO *bio, char **buf, int num);
|
|
int BIO_nwrite0(BIO *bio, char **buf);
|
|
int BIO_nwrite(BIO *bio, char **buf, int num);
|
|
|
|
long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi,
|
|
long argl, long ret);
|
|
|
|
const BIO_METHOD *BIO_s_mem(void);
|
|
BIO *BIO_new_mem_buf(const void *buf, int len);
|
|
const BIO_METHOD *BIO_s_socket(void);
|
|
const BIO_METHOD *BIO_s_connect(void);
|
|
const BIO_METHOD *BIO_s_accept(void);
|
|
const BIO_METHOD *BIO_s_fd(void);
|
|
const BIO_METHOD *BIO_s_log(void);
|
|
const BIO_METHOD *BIO_s_bio(void);
|
|
const BIO_METHOD *BIO_s_null(void);
|
|
const BIO_METHOD *BIO_f_null(void);
|
|
const BIO_METHOD *BIO_f_buffer(void);
|
|
const BIO_METHOD *BIO_f_nbio_test(void);
|
|
|
|
const BIO_METHOD *BIO_s_datagram(void);
|
|
|
|
|
|
|
|
|
|
int BIO_sock_should_retry(int i);
|
|
int BIO_sock_non_fatal_error(int _error);
|
|
int BIO_dgram_non_fatal_error(int _error);
|
|
|
|
int BIO_fd_should_retry(int i);
|
|
int BIO_fd_non_fatal_error(int _error);
|
|
int
|
|
BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u),
|
|
void *u, const char *s, int len);
|
|
int
|
|
BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
|
|
void *u, const char *s, int len, int indent);
|
|
int BIO_dump(BIO *b, const char *bytes, int len);
|
|
int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent);
|
|
int BIO_dump_fp(FILE *fp, const char *s, int len);
|
|
int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent);
|
|
struct hostent *BIO_gethostbyname(const char *name);
|
|
int BIO_sock_error(int sock);
|
|
int BIO_socket_ioctl(int fd, long type, void *arg);
|
|
int BIO_socket_nbio(int fd, int mode);
|
|
int BIO_get_port(const char *str, unsigned short *port_ptr);
|
|
int BIO_get_host_ip(const char *str, unsigned char *ip);
|
|
int BIO_get_accept_socket(char *host_port, int mode);
|
|
int BIO_accept(int sock, char **ip_port);
|
|
int BIO_sock_init(void );
|
|
void BIO_sock_cleanup(void);
|
|
int BIO_set_tcp_ndelay(int sock, int turn_on);
|
|
|
|
BIO *BIO_new_socket(int sock, int close_flag);
|
|
BIO *BIO_new_dgram(int fd, int close_flag);
|
|
BIO *BIO_new_fd(int fd, int close_flag);
|
|
BIO *BIO_new_connect(const char *host_port);
|
|
BIO *BIO_new_accept(const char *host_port);
|
|
|
|
int
|
|
BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
|
|
BIO **bio2, size_t writebuf2);
|
|
|
|
|
|
|
|
|
|
|
|
void BIO_copy_next_retry(BIO *b);
|
|
int
|
|
BIO_printf(BIO *bio, const char *format, ...)
|
|
__attribute__((__format__(__printf__, 2, 3), __nonnull__(2)));
|
|
int
|
|
BIO_vprintf(BIO *bio, const char *format, va_list args)
|
|
__attribute__((__format__(__printf__, 2, 0), __nonnull__(2)));
|
|
int
|
|
BIO_snprintf(char *buf, size_t n, const char *format, ...)
|
|
__attribute__((__deprecated__, __format__(__printf__, 3, 4),
|
|
__nonnull__(3)));
|
|
int
|
|
BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
|
|
__attribute__((__deprecated__, __format__(__printf__, 3, 0),
|
|
__nonnull__(3)));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_BIO_strings(void);
|
|
typedef struct lhash_node_st {
|
|
void *data;
|
|
struct lhash_node_st *next;
|
|
|
|
unsigned long hash;
|
|
|
|
} LHASH_NODE;
|
|
|
|
typedef int (*LHASH_COMP_FN_TYPE)(const void *, const void *);
|
|
typedef unsigned long (*LHASH_HASH_FN_TYPE)(const void *);
|
|
typedef void (*LHASH_DOALL_FN_TYPE)(void *);
|
|
typedef void (*LHASH_DOALL_ARG_FN_TYPE)(void *, void *);
|
|
typedef struct lhash_st {
|
|
LHASH_NODE **b;
|
|
LHASH_COMP_FN_TYPE comp;
|
|
LHASH_HASH_FN_TYPE hash;
|
|
unsigned int num_nodes;
|
|
unsigned int num_alloc_nodes;
|
|
unsigned int p;
|
|
unsigned int pmax;
|
|
unsigned long up_load;
|
|
unsigned long down_load;
|
|
unsigned long num_items;
|
|
|
|
unsigned long num_expands;
|
|
unsigned long num_expand_reallocs;
|
|
unsigned long num_contracts;
|
|
unsigned long num_contract_reallocs;
|
|
unsigned long num_hash_calls;
|
|
unsigned long num_comp_calls;
|
|
unsigned long num_insert;
|
|
unsigned long num_replace;
|
|
unsigned long num_delete;
|
|
unsigned long num_no_delete;
|
|
unsigned long num_retrieve;
|
|
unsigned long num_retrieve_miss;
|
|
unsigned long num_hash_comps;
|
|
|
|
int error;
|
|
} _LHASH;
|
|
_LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c);
|
|
void lh_free(_LHASH *lh);
|
|
void *lh_insert(_LHASH *lh, void *data);
|
|
void *lh_delete(_LHASH *lh, const void *data);
|
|
void *lh_retrieve(_LHASH *lh, const void *data);
|
|
void lh_doall(_LHASH *lh, LHASH_DOALL_FN_TYPE func);
|
|
void lh_doall_arg(_LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg);
|
|
unsigned long lh_strhash(const char *c);
|
|
unsigned long lh_num_items(const _LHASH *lh);
|
|
|
|
void lh_stats(const _LHASH *lh, FILE *out);
|
|
void lh_node_stats(const _LHASH *lh, FILE *out);
|
|
void lh_node_usage_stats(const _LHASH *lh, FILE *out);
|
|
|
|
|
|
void lh_stats_bio(const _LHASH *lh, BIO *out);
|
|
void lh_node_stats_bio(const _LHASH *lh, BIO *out);
|
|
void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out);
|
|
struct lhash_st_OPENSSL_STRING { int dummy; };
|
|
struct lhash_st_OPENSSL_CSTRING { int dummy; };
|
|
typedef struct {
|
|
char *section;
|
|
char *name;
|
|
char *value;
|
|
} CONF_VALUE;
|
|
|
|
struct stack_st_CONF_VALUE { _STACK stack; };
|
|
struct lhash_st_CONF_VALUE { int dummy; };
|
|
|
|
struct conf_st;
|
|
struct conf_method_st;
|
|
typedef struct conf_method_st CONF_METHOD;
|
|
|
|
struct conf_method_st {
|
|
const char *name;
|
|
CONF *(*create)(CONF_METHOD *meth);
|
|
int (*init)(CONF *conf);
|
|
int (*destroy)(CONF *conf);
|
|
int (*destroy_data)(CONF *conf);
|
|
int (*load_bio)(CONF *conf, BIO *bp, long *eline);
|
|
int (*dump)(const CONF *conf, BIO *bp);
|
|
int (*is_number)(const CONF *conf, char c);
|
|
int (*to_int)(const CONF *conf, char c);
|
|
int (*load)(CONF *conf, const char *name, long *eline);
|
|
};
|
|
|
|
|
|
|
|
typedef struct conf_imodule_st CONF_IMODULE;
|
|
typedef struct conf_module_st CONF_MODULE;
|
|
|
|
struct stack_st_CONF_MODULE { _STACK stack; };
|
|
struct stack_st_CONF_IMODULE { _STACK stack; };
|
|
|
|
|
|
typedef int conf_init_func(CONF_IMODULE *md, const CONF *cnf);
|
|
typedef void conf_finish_func(CONF_IMODULE *md);
|
|
int CONF_set_default_method(CONF_METHOD *meth);
|
|
void CONF_set_nconf(CONF *conf, struct lhash_st_CONF_VALUE *hash);
|
|
struct lhash_st_CONF_VALUE *CONF_load(struct lhash_st_CONF_VALUE *conf, const char *file,
|
|
long *eline);
|
|
struct lhash_st_CONF_VALUE *CONF_load_fp(struct lhash_st_CONF_VALUE *conf, FILE *fp,
|
|
long *eline);
|
|
struct lhash_st_CONF_VALUE *CONF_load_bio(struct lhash_st_CONF_VALUE *conf, BIO *bp, long *eline);
|
|
struct stack_st_CONF_VALUE *CONF_get_section(struct lhash_st_CONF_VALUE *conf,
|
|
const char *section);
|
|
char *CONF_get_string(struct lhash_st_CONF_VALUE *conf, const char *group,
|
|
const char *name);
|
|
long CONF_get_number(struct lhash_st_CONF_VALUE *conf, const char *group,
|
|
const char *name);
|
|
void CONF_free(struct lhash_st_CONF_VALUE *conf);
|
|
int CONF_dump_fp(struct lhash_st_CONF_VALUE *conf, FILE *out);
|
|
int CONF_dump_bio(struct lhash_st_CONF_VALUE *conf, BIO *out);
|
|
|
|
void OPENSSL_config(const char *config_name);
|
|
void OPENSSL_no_config(void);
|
|
|
|
|
|
|
|
|
|
struct conf_st {
|
|
CONF_METHOD *meth;
|
|
void *meth_data;
|
|
struct lhash_st_CONF_VALUE *data;
|
|
};
|
|
|
|
CONF *NCONF_new(CONF_METHOD *meth);
|
|
CONF_METHOD *NCONF_default(void);
|
|
CONF_METHOD *NCONF_WIN32(void);
|
|
void NCONF_free(CONF *conf);
|
|
void NCONF_free_data(CONF *conf);
|
|
|
|
int NCONF_load(CONF *conf, const char *file, long *eline);
|
|
int NCONF_load_fp(CONF *conf, FILE *fp, long *eline);
|
|
int NCONF_load_bio(CONF *conf, BIO *bp, long *eline);
|
|
struct stack_st_CONF_VALUE *NCONF_get_section(const CONF *conf, const char *section);
|
|
char *NCONF_get_string(const CONF *conf, const char *group, const char *name);
|
|
int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
|
|
long *result);
|
|
int NCONF_dump_fp(const CONF *conf, FILE *out);
|
|
int NCONF_dump_bio(const CONF *conf, BIO *out);
|
|
|
|
|
|
|
|
|
|
|
|
int CONF_modules_load(const CONF *cnf, const char *appname,
|
|
unsigned long flags);
|
|
int CONF_modules_load_file(const char *filename, const char *appname,
|
|
unsigned long flags);
|
|
void CONF_modules_unload(int all);
|
|
void CONF_modules_finish(void);
|
|
void CONF_modules_free(void);
|
|
int CONF_module_add(const char *name, conf_init_func *ifunc,
|
|
conf_finish_func *ffunc);
|
|
|
|
const char *CONF_imodule_get_name(const CONF_IMODULE *md);
|
|
const char *CONF_imodule_get_value(const CONF_IMODULE *md);
|
|
void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
|
|
void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
|
|
CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
|
|
unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
|
|
void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
|
|
void *CONF_module_get_usr_data(CONF_MODULE *pmod);
|
|
void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
|
|
|
|
char *CONF_get1_default_config_file(void);
|
|
|
|
int CONF_parse_list(const char *list, int sep, int nospc,
|
|
int (*list_cb)(const char *elem, int len, void *usr), void *arg);
|
|
|
|
void OPENSSL_load_builtin_modules(void);
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_CONF_strings(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int *__errno_location (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct err_state_st {
|
|
CRYPTO_THREADID tid;
|
|
int err_flags[16];
|
|
unsigned long err_buffer[16];
|
|
char *err_data[16];
|
|
int err_data_flags[16];
|
|
const char *err_file[16];
|
|
int err_line[16];
|
|
int top, bottom;
|
|
} ERR_STATE;
|
|
typedef struct ERR_string_data_st {
|
|
unsigned long error;
|
|
const char *string;
|
|
} ERR_STRING_DATA;
|
|
|
|
void ERR_put_error(int lib, int func, int reason, const char *file, int line);
|
|
void ERR_set_error_data(char *data, int flags);
|
|
|
|
unsigned long ERR_get_error(void);
|
|
unsigned long ERR_get_error_line(const char **file, int *line);
|
|
unsigned long ERR_get_error_line_data(const char **file, int *line,
|
|
const char **data, int *flags);
|
|
unsigned long ERR_peek_error(void);
|
|
unsigned long ERR_peek_error_line(const char **file, int *line);
|
|
unsigned long ERR_peek_error_line_data(const char **file, int *line,
|
|
const char **data, int *flags);
|
|
unsigned long ERR_peek_last_error(void);
|
|
unsigned long ERR_peek_last_error_line(const char **file, int *line);
|
|
unsigned long ERR_peek_last_error_line_data(const char **file, int *line,
|
|
const char **data, int *flags);
|
|
void ERR_clear_error(void );
|
|
char *ERR_error_string(unsigned long e, char *buf);
|
|
void ERR_error_string_n(unsigned long e, char *buf, size_t len);
|
|
const char *ERR_lib_error_string(unsigned long e);
|
|
const char *ERR_func_error_string(unsigned long e);
|
|
const char *ERR_reason_error_string(unsigned long e);
|
|
void ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u),
|
|
void *u);
|
|
void ERR_print_errors_fp(FILE *fp);
|
|
|
|
void ERR_print_errors(BIO *bp);
|
|
|
|
void ERR_asprintf_error_data(char * format, ...);
|
|
|
|
void ERR_add_error_data(int num, ...);
|
|
void ERR_add_error_vdata(int num, va_list args);
|
|
|
|
void ERR_load_strings(int lib, ERR_STRING_DATA str[]);
|
|
void ERR_unload_strings(int lib, ERR_STRING_DATA str[]);
|
|
void ERR_load_ERR_strings(void);
|
|
void ERR_load_crypto_strings(void);
|
|
void ERR_free_strings(void);
|
|
|
|
void ERR_remove_thread_state(const CRYPTO_THREADID *tid);
|
|
|
|
void ERR_remove_state(unsigned long pid);
|
|
|
|
ERR_STATE *ERR_get_state(void);
|
|
|
|
|
|
struct lhash_st_ERR_STRING_DATA *ERR_get_string_table(void);
|
|
struct lhash_st_ERR_STATE *ERR_get_err_state_table(void);
|
|
void ERR_release_err_state_table(struct lhash_st_ERR_STATE **hash);
|
|
|
|
|
|
int ERR_get_next_error_library(void);
|
|
|
|
int ERR_set_mark(void);
|
|
int ERR_pop_to_mark(void);
|
|
|
|
|
|
|
|
|
|
|
|
const ERR_FNS *ERR_get_implementation(void);
|
|
|
|
|
|
int ERR_set_implementation(const ERR_FNS *fns);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct tm
|
|
{
|
|
int tm_sec;
|
|
int tm_min;
|
|
int tm_hour;
|
|
int tm_mday;
|
|
int tm_mon;
|
|
int tm_year;
|
|
int tm_wday;
|
|
int tm_yday;
|
|
int tm_isdst;
|
|
|
|
|
|
long int tm_gmtoff;
|
|
const char *tm_zone;
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct itimerspec
|
|
{
|
|
struct timespec it_interval;
|
|
struct timespec it_value;
|
|
};
|
|
struct sigevent;
|
|
struct __locale_struct
|
|
{
|
|
|
|
struct __locale_data *__locales[13];
|
|
|
|
|
|
const unsigned short int *__ctype_b;
|
|
const int *__ctype_tolower;
|
|
const int *__ctype_toupper;
|
|
|
|
|
|
const char *__names[13];
|
|
};
|
|
|
|
typedef struct __locale_struct *__locale_t;
|
|
|
|
typedef __locale_t locale_t;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern double difftime (time_t __time1, time_t __time0)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
|
|
|
|
|
|
extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
extern size_t strftime (char *__restrict __s, size_t __maxsize,
|
|
const char *__restrict __format,
|
|
const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
|
|
const char *__restrict __format,
|
|
const struct tm *__restrict __tp,
|
|
locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
extern struct tm *gmtime_r (const time_t *__restrict __timer,
|
|
struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern struct tm *localtime_r (const time_t *__restrict __timer,
|
|
struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern char *asctime_r (const struct tm *__restrict __tp,
|
|
char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern char *ctime_r (const time_t *__restrict __timer,
|
|
char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
extern char *__tzname[2];
|
|
extern int __daylight;
|
|
extern long int __timezone;
|
|
|
|
|
|
|
|
|
|
extern char *tzname[2];
|
|
|
|
|
|
|
|
extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
extern int daylight;
|
|
extern long int timezone;
|
|
|
|
|
|
|
|
|
|
|
|
extern int stime (const time_t *__when) __attribute__ ((__nothrow__ , __leaf__));
|
|
extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
|
|
extern int nanosleep (const struct timespec *__requested_time,
|
|
struct timespec *__remaining);
|
|
|
|
|
|
|
|
extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
|
|
__attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
|
|
const struct timespec *__req,
|
|
struct timespec *__rem);
|
|
|
|
|
|
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
extern int timer_create (clockid_t __clock_id,
|
|
struct sigevent *__restrict __evp,
|
|
timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int timer_settime (timer_t __timerid, int __flags,
|
|
const struct itimerspec *__restrict __value,
|
|
struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
|
|
__attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
|
|
|
|
|
|
|
|
|
|
|
|
extern int timespec_get (struct timespec *__ts, int __base)
|
|
__attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
|
|
|
|
|
|
|
|
|
|
struct bignum_st {
|
|
unsigned long *d;
|
|
int top;
|
|
|
|
int dmax;
|
|
int neg;
|
|
int flags;
|
|
};
|
|
|
|
|
|
struct bn_mont_ctx_st {
|
|
int ri;
|
|
BIGNUM RR;
|
|
BIGNUM N;
|
|
BIGNUM Ni;
|
|
|
|
unsigned long n0[2];
|
|
|
|
int flags;
|
|
};
|
|
|
|
|
|
|
|
|
|
struct bn_recp_ctx_st {
|
|
BIGNUM N;
|
|
BIGNUM Nr;
|
|
int num_bits;
|
|
int shift;
|
|
int flags;
|
|
};
|
|
|
|
|
|
struct bn_gencb_st {
|
|
unsigned int ver;
|
|
void *arg;
|
|
union {
|
|
|
|
void (*cb_1)(int, int, void *);
|
|
|
|
int (*cb_2)(int, int, BN_GENCB *);
|
|
} cb;
|
|
};
|
|
|
|
BN_GENCB *BN_GENCB_new(void);
|
|
void BN_GENCB_free(BN_GENCB *cb);
|
|
void *BN_GENCB_get_arg(BN_GENCB *cb);
|
|
|
|
|
|
int BN_GENCB_call(BN_GENCB *cb, int a, int b);
|
|
const BIGNUM *BN_value_one(void);
|
|
char * BN_options(void);
|
|
BN_CTX *BN_CTX_new(void);
|
|
|
|
void BN_CTX_init(BN_CTX *c);
|
|
|
|
void BN_CTX_free(BN_CTX *c);
|
|
void BN_CTX_start(BN_CTX *ctx);
|
|
BIGNUM *BN_CTX_get(BN_CTX *ctx);
|
|
void BN_CTX_end(BN_CTX *ctx);
|
|
int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
|
|
int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
|
|
int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
|
|
int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
|
|
int BN_num_bits(const BIGNUM *a);
|
|
int BN_num_bits_word(unsigned long);
|
|
BIGNUM *BN_new(void);
|
|
void BN_init(BIGNUM *);
|
|
void BN_clear_free(BIGNUM *a);
|
|
BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
|
|
void BN_swap(BIGNUM *a, BIGNUM *b);
|
|
BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
|
|
int BN_bn2bin(const BIGNUM *a, unsigned char *to);
|
|
BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
|
|
int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
|
|
int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
|
int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
|
int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
|
int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
|
int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
|
int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
void BN_set_negative(BIGNUM *b, int n);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
|
|
BN_CTX *ctx);
|
|
|
|
|
|
int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
|
|
int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m);
|
|
int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m);
|
|
int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
|
|
int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
|
|
|
|
unsigned long BN_mod_word(const BIGNUM *a, unsigned long w);
|
|
unsigned long BN_div_word(BIGNUM *a, unsigned long w);
|
|
int BN_mul_word(BIGNUM *a, unsigned long w);
|
|
int BN_add_word(BIGNUM *a, unsigned long w);
|
|
int BN_sub_word(BIGNUM *a, unsigned long w);
|
|
int BN_set_word(BIGNUM *a, unsigned long w);
|
|
unsigned long BN_get_word(const BIGNUM *a);
|
|
|
|
int BN_cmp(const BIGNUM *a, const BIGNUM *b);
|
|
void BN_free(BIGNUM *a);
|
|
int BN_is_bit_set(const BIGNUM *a, int n);
|
|
int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
|
|
int BN_lshift1(BIGNUM *r, const BIGNUM *a);
|
|
int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
|
|
|
|
|
int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
|
|
|
int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont);
|
|
int BN_mod_exp_mont_word(BIGNUM *r, unsigned long a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
|
int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
|
|
const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
|
|
BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
|
int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx);
|
|
|
|
int BN_mask_bits(BIGNUM *a, int n);
|
|
int BN_print_fp(FILE *fp, const BIGNUM *a);
|
|
int BN_print(BIO *fp, const BIGNUM *a);
|
|
int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
|
|
int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
|
|
int BN_rshift1(BIGNUM *r, const BIGNUM *a);
|
|
void BN_clear(BIGNUM *a);
|
|
BIGNUM *BN_dup(const BIGNUM *a);
|
|
int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
|
|
int BN_set_bit(BIGNUM *a, int n);
|
|
int BN_clear_bit(BIGNUM *a, int n);
|
|
char * BN_bn2hex(const BIGNUM *a);
|
|
char * BN_bn2dec(const BIGNUM *a);
|
|
int BN_hex2bn(BIGNUM **a, const char *str);
|
|
int BN_dec2bn(BIGNUM **a, const char *str);
|
|
int BN_asc2bn(BIGNUM **a, const char *str);
|
|
|
|
int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
|
|
|
int BN_kronecker(const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx);
|
|
|
|
BIGNUM *BN_mod_inverse(BIGNUM *ret,
|
|
const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
|
|
|
|
BIGNUM *BN_mod_sqrt(BIGNUM *ret,
|
|
const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
|
|
|
|
void BN_consttime_swap(unsigned long swap, BIGNUM *a, BIGNUM *b, int nwords);
|
|
|
|
|
|
|
|
BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
|
|
const BIGNUM *add, const BIGNUM *rem,
|
|
void (*callback)(int, int, void *), void *cb_arg);
|
|
int BN_is_prime(const BIGNUM *p, int nchecks,
|
|
void (*callback)(int, int, void *),
|
|
BN_CTX *ctx, void *cb_arg);
|
|
int BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
|
|
void (*callback)(int, int, void *), BN_CTX *ctx, void *cb_arg,
|
|
int do_trial_division);
|
|
|
|
|
|
|
|
int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
|
|
const BIGNUM *rem, BN_GENCB *cb);
|
|
int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
|
|
int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
|
|
int do_trial_division, BN_GENCB *cb);
|
|
|
|
int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
|
|
|
|
int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
|
|
const BIGNUM *Xp, const BIGNUM *Xp1, const BIGNUM *Xp2,
|
|
const BIGNUM *e, BN_CTX *ctx, BN_GENCB *cb);
|
|
int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
|
|
BIGNUM *Xp1, BIGNUM *Xp2,
|
|
const BIGNUM *Xp,
|
|
const BIGNUM *e, BN_CTX *ctx,
|
|
BN_GENCB *cb);
|
|
|
|
BN_MONT_CTX *BN_MONT_CTX_new(void );
|
|
void BN_MONT_CTX_init(BN_MONT_CTX *ctx);
|
|
int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
BN_MONT_CTX *mont, BN_CTX *ctx);
|
|
|
|
|
|
int BN_from_montgomery(BIGNUM *r, const BIGNUM *a,
|
|
BN_MONT_CTX *mont, BN_CTX *ctx);
|
|
void BN_MONT_CTX_free(BN_MONT_CTX *mont);
|
|
int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
|
|
BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
|
|
BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, int lock,
|
|
const BIGNUM *mod, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
|
|
void BN_BLINDING_free(BN_BLINDING *b);
|
|
int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
|
|
int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
|
|
int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
|
|
int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
|
int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *);
|
|
|
|
unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);
|
|
void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);
|
|
|
|
CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);
|
|
unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
|
|
void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
|
|
BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
|
|
const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
|
|
int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),
|
|
BN_MONT_CTX *m_ctx);
|
|
|
|
|
|
void BN_set_params(int mul, int high, int low, int mont);
|
|
int BN_get_params(int which);
|
|
|
|
|
|
void BN_RECP_CTX_init(BN_RECP_CTX *recp);
|
|
BN_RECP_CTX *BN_RECP_CTX_new(void);
|
|
void BN_RECP_CTX_free(BN_RECP_CTX *recp);
|
|
int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
|
|
int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
|
|
BN_RECP_CTX *recp, BN_CTX *ctx);
|
|
int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx);
|
|
int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
|
|
BN_RECP_CTX *recp, BN_CTX *ctx);
|
|
int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
|
|
|
|
int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
|
|
int
|
|
BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const BIGNUM *p, BN_CTX *ctx);
|
|
int
|
|
BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
BN_CTX *ctx);
|
|
int
|
|
BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p,
|
|
BN_CTX *ctx);
|
|
int
|
|
BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const BIGNUM *p, BN_CTX *ctx);
|
|
int
|
|
BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const BIGNUM *p, BN_CTX *ctx);
|
|
int
|
|
BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
BN_CTX *ctx);
|
|
int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
|
|
|
|
int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const int p[], BN_CTX *ctx);
|
|
int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
|
|
BN_CTX *ctx);
|
|
int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
|
|
BN_CTX *ctx);
|
|
int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const int p[], BN_CTX *ctx);
|
|
int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|
const int p[], BN_CTX *ctx);
|
|
int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
|
|
const int p[], BN_CTX *ctx);
|
|
int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
|
|
const int p[], BN_CTX *ctx);
|
|
int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
|
|
int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
|
|
|
|
|
|
|
|
|
|
|
|
int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
|
int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
|
int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
|
int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
|
int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
|
|
|
|
const BIGNUM *BN_get0_nist_prime_192(void);
|
|
const BIGNUM *BN_get0_nist_prime_224(void);
|
|
const BIGNUM *BN_get0_nist_prime_256(void);
|
|
const BIGNUM *BN_get0_nist_prime_384(void);
|
|
const BIGNUM *BN_get0_nist_prime_521(void);
|
|
|
|
|
|
BIGNUM *get_rfc2409_prime_768(BIGNUM *bn);
|
|
BIGNUM *get_rfc2409_prime_1024(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
|
|
|
|
|
|
BIGNUM *get_rfc3526_prime_1536(BIGNUM *bn);
|
|
BIGNUM *get_rfc3526_prime_2048(BIGNUM *bn);
|
|
BIGNUM *get_rfc3526_prime_3072(BIGNUM *bn);
|
|
BIGNUM *get_rfc3526_prime_4096(BIGNUM *bn);
|
|
BIGNUM *get_rfc3526_prime_6144(BIGNUM *bn);
|
|
BIGNUM *get_rfc3526_prime_8192(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
|
|
BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_BN_strings(void);
|
|
struct X509_algor_st;
|
|
struct stack_st_X509_ALGOR { _STACK stack; };
|
|
typedef struct asn1_ctx_st {
|
|
unsigned char *p;
|
|
int eos;
|
|
int error;
|
|
int inf;
|
|
int tag;
|
|
int xclass;
|
|
long slen;
|
|
unsigned char *max;
|
|
unsigned char *q;
|
|
unsigned char **pp;
|
|
int line;
|
|
} ASN1_CTX;
|
|
|
|
typedef struct asn1_const_ctx_st {
|
|
const unsigned char *p;
|
|
int eos;
|
|
int error;
|
|
int inf;
|
|
int tag;
|
|
int xclass;
|
|
long slen;
|
|
const unsigned char *max;
|
|
const unsigned char *q;
|
|
const unsigned char **pp;
|
|
int line;
|
|
} ASN1_const_CTX;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct asn1_object_st {
|
|
const char *sn, *ln;
|
|
int nid;
|
|
int length;
|
|
const unsigned char *data;
|
|
int flags;
|
|
} ASN1_OBJECT;
|
|
struct asn1_string_st {
|
|
int length;
|
|
int type;
|
|
unsigned char *data;
|
|
|
|
|
|
|
|
|
|
long flags;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct ASN1_ENCODING_st {
|
|
unsigned char *enc;
|
|
long len;
|
|
int modified;
|
|
} ASN1_ENCODING;
|
|
typedef struct asn1_string_table_st {
|
|
int nid;
|
|
long minsize;
|
|
long maxsize;
|
|
unsigned long mask;
|
|
unsigned long flags;
|
|
} ASN1_STRING_TABLE;
|
|
|
|
struct stack_st_ASN1_STRING_TABLE { _STACK stack; };
|
|
typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
|
|
typedef struct ASN1_TLC_st ASN1_TLC;
|
|
|
|
typedef struct ASN1_VALUE_st ASN1_VALUE;
|
|
typedef void *d2i_of_void(void **,const unsigned char **,long); typedef int i2d_of_void(void *,unsigned char **);
|
|
typedef const ASN1_ITEM ASN1_ITEM_EXP;
|
|
struct stack_st_ASN1_INTEGER { _STACK stack; };
|
|
|
|
struct stack_st_ASN1_GENERALSTRING { _STACK stack; };
|
|
|
|
typedef struct asn1_type_st {
|
|
int type;
|
|
union {
|
|
char *ptr;
|
|
ASN1_BOOLEAN boolean;
|
|
ASN1_STRING * asn1_string;
|
|
ASN1_OBJECT * object;
|
|
ASN1_INTEGER * integer;
|
|
ASN1_ENUMERATED * enumerated;
|
|
ASN1_BIT_STRING * bit_string;
|
|
ASN1_OCTET_STRING * octet_string;
|
|
ASN1_PRINTABLESTRING * printablestring;
|
|
ASN1_T61STRING * t61string;
|
|
ASN1_IA5STRING * ia5string;
|
|
ASN1_GENERALSTRING * generalstring;
|
|
ASN1_BMPSTRING * bmpstring;
|
|
ASN1_UNIVERSALSTRING * universalstring;
|
|
ASN1_UTCTIME * utctime;
|
|
ASN1_GENERALIZEDTIME * generalizedtime;
|
|
ASN1_VISIBLESTRING * visiblestring;
|
|
ASN1_UTF8STRING * utf8string;
|
|
|
|
|
|
ASN1_STRING * set;
|
|
ASN1_STRING * sequence;
|
|
ASN1_VALUE * asn1_value;
|
|
} value;
|
|
} ASN1_TYPE;
|
|
|
|
struct stack_st_ASN1_TYPE { _STACK stack; };
|
|
|
|
typedef struct stack_st_ASN1_TYPE ASN1_SEQUENCE_ANY;
|
|
|
|
ASN1_SEQUENCE_ANY *d2i_ASN1_SEQUENCE_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_SEQUENCE_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_SEQUENCE_ANY_it;
|
|
ASN1_SEQUENCE_ANY *d2i_ASN1_SET_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_SET_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_SET_ANY_it;
|
|
|
|
typedef struct NETSCAPE_X509_st {
|
|
ASN1_OCTET_STRING *header;
|
|
X509 *cert;
|
|
} NETSCAPE_X509;
|
|
|
|
|
|
typedef struct BIT_STRING_BITNAME_st {
|
|
int bitnum;
|
|
const char *lname;
|
|
const char *sname;
|
|
} BIT_STRING_BITNAME;
|
|
ASN1_TYPE *ASN1_TYPE_new(void);
|
|
void ASN1_TYPE_free(ASN1_TYPE *a);
|
|
ASN1_TYPE *d2i_ASN1_TYPE(ASN1_TYPE **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_TYPE(ASN1_TYPE *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_ANY_it;
|
|
|
|
int ASN1_TYPE_get(const ASN1_TYPE *a);
|
|
void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
|
|
int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
|
|
int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
|
|
|
|
ASN1_OBJECT *ASN1_OBJECT_new(void);
|
|
void ASN1_OBJECT_free(ASN1_OBJECT *a);
|
|
int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp);
|
|
ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
|
|
long length);
|
|
ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
|
|
long length);
|
|
|
|
extern const ASN1_ITEM ASN1_OBJECT_it;
|
|
|
|
struct stack_st_ASN1_OBJECT { _STACK stack; };
|
|
|
|
ASN1_STRING *ASN1_STRING_new(void);
|
|
void ASN1_STRING_free(ASN1_STRING *a);
|
|
int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
|
|
ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a);
|
|
ASN1_STRING *ASN1_STRING_type_new(int type);
|
|
int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
|
|
|
|
|
|
int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
|
|
void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
|
|
int ASN1_STRING_length(const ASN1_STRING *x);
|
|
void ASN1_STRING_length_set(ASN1_STRING *x, int n);
|
|
int ASN1_STRING_type(const ASN1_STRING *x);
|
|
unsigned char *ASN1_STRING_data(ASN1_STRING *x);
|
|
const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);
|
|
|
|
ASN1_BIT_STRING *ASN1_BIT_STRING_new(void);
|
|
void ASN1_BIT_STRING_free(ASN1_BIT_STRING *a);
|
|
ASN1_BIT_STRING *d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_BIT_STRING_it;
|
|
int i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp);
|
|
ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
|
|
const unsigned char **pp, long length);
|
|
int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
|
|
int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
|
|
int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
|
|
int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
|
|
const unsigned char *flags, int flags_len);
|
|
|
|
|
|
int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
|
|
BIT_STRING_BITNAME *tbl, int indent);
|
|
|
|
int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
|
|
int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
|
|
BIT_STRING_BITNAME *tbl);
|
|
|
|
int i2d_ASN1_BOOLEAN(int a, unsigned char **pp);
|
|
int d2i_ASN1_BOOLEAN(int *a, const unsigned char **pp, long length);
|
|
|
|
ASN1_INTEGER *ASN1_INTEGER_new(void);
|
|
void ASN1_INTEGER_free(ASN1_INTEGER *a);
|
|
ASN1_INTEGER *d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_INTEGER_it;
|
|
int i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp);
|
|
ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp,
|
|
long length);
|
|
ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
|
|
long length);
|
|
ASN1_INTEGER * ASN1_INTEGER_dup(const ASN1_INTEGER *x);
|
|
int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);
|
|
|
|
ASN1_ENUMERATED *ASN1_ENUMERATED_new(void);
|
|
void ASN1_ENUMERATED_free(ASN1_ENUMERATED *a);
|
|
ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_ENUMERATED_it;
|
|
|
|
int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
|
|
ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
|
|
ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
|
|
int offset_day, long offset_sec);
|
|
int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
|
|
|
|
|
|
int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);
|
|
|
|
|
|
int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
|
|
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
|
|
time_t t);
|
|
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
|
|
time_t t, int offset_day, long offset_sec);
|
|
int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);
|
|
|
|
ASN1_OCTET_STRING *ASN1_OCTET_STRING_new(void);
|
|
void ASN1_OCTET_STRING_free(ASN1_OCTET_STRING *a);
|
|
ASN1_OCTET_STRING *d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_OCTET_STRING(ASN1_OCTET_STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_OCTET_STRING_it;
|
|
ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a);
|
|
int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
|
|
const ASN1_OCTET_STRING *b);
|
|
int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
|
|
int len);
|
|
|
|
ASN1_VISIBLESTRING *ASN1_VISIBLESTRING_new(void);
|
|
void ASN1_VISIBLESTRING_free(ASN1_VISIBLESTRING *a);
|
|
ASN1_VISIBLESTRING *d2i_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_VISIBLESTRING_it;
|
|
ASN1_UNIVERSALSTRING *ASN1_UNIVERSALSTRING_new(void);
|
|
void ASN1_UNIVERSALSTRING_free(ASN1_UNIVERSALSTRING *a);
|
|
ASN1_UNIVERSALSTRING *d2i_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_UNIVERSALSTRING_it;
|
|
ASN1_UTF8STRING *ASN1_UTF8STRING_new(void);
|
|
void ASN1_UTF8STRING_free(ASN1_UTF8STRING *a);
|
|
ASN1_UTF8STRING *d2i_ASN1_UTF8STRING(ASN1_UTF8STRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_UTF8STRING(ASN1_UTF8STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_UTF8STRING_it;
|
|
ASN1_NULL *ASN1_NULL_new(void);
|
|
void ASN1_NULL_free(ASN1_NULL *a);
|
|
ASN1_NULL *d2i_ASN1_NULL(ASN1_NULL **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_NULL(ASN1_NULL *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_NULL_it;
|
|
ASN1_BMPSTRING *ASN1_BMPSTRING_new(void);
|
|
void ASN1_BMPSTRING_free(ASN1_BMPSTRING *a);
|
|
ASN1_BMPSTRING *d2i_ASN1_BMPSTRING(ASN1_BMPSTRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_BMPSTRING(ASN1_BMPSTRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_BMPSTRING_it;
|
|
|
|
ASN1_STRING *ASN1_PRINTABLE_new(void);
|
|
void ASN1_PRINTABLE_free(ASN1_STRING *a);
|
|
ASN1_STRING *d2i_ASN1_PRINTABLE(ASN1_STRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_PRINTABLE(ASN1_STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_PRINTABLE_it;
|
|
|
|
ASN1_STRING *DIRECTORYSTRING_new(void);
|
|
void DIRECTORYSTRING_free(ASN1_STRING *a);
|
|
ASN1_STRING *d2i_DIRECTORYSTRING(ASN1_STRING **a, const unsigned char **in, long len);
|
|
int i2d_DIRECTORYSTRING(ASN1_STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM DIRECTORYSTRING_it;
|
|
ASN1_STRING *DISPLAYTEXT_new(void);
|
|
void DISPLAYTEXT_free(ASN1_STRING *a);
|
|
ASN1_STRING *d2i_DISPLAYTEXT(ASN1_STRING **a, const unsigned char **in, long len);
|
|
int i2d_DISPLAYTEXT(ASN1_STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM DISPLAYTEXT_it;
|
|
ASN1_PRINTABLESTRING *ASN1_PRINTABLESTRING_new(void);
|
|
void ASN1_PRINTABLESTRING_free(ASN1_PRINTABLESTRING *a);
|
|
ASN1_PRINTABLESTRING *d2i_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_PRINTABLESTRING_it;
|
|
ASN1_T61STRING *ASN1_T61STRING_new(void);
|
|
void ASN1_T61STRING_free(ASN1_T61STRING *a);
|
|
ASN1_T61STRING *d2i_ASN1_T61STRING(ASN1_T61STRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_T61STRING(ASN1_T61STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_T61STRING_it;
|
|
ASN1_IA5STRING *ASN1_IA5STRING_new(void);
|
|
void ASN1_IA5STRING_free(ASN1_IA5STRING *a);
|
|
ASN1_IA5STRING *d2i_ASN1_IA5STRING(ASN1_IA5STRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_IA5STRING(ASN1_IA5STRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_IA5STRING_it;
|
|
ASN1_GENERALSTRING *ASN1_GENERALSTRING_new(void);
|
|
void ASN1_GENERALSTRING_free(ASN1_GENERALSTRING *a);
|
|
ASN1_GENERALSTRING *d2i_ASN1_GENERALSTRING(ASN1_GENERALSTRING **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_GENERALSTRING(ASN1_GENERALSTRING *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_GENERALSTRING_it;
|
|
ASN1_UTCTIME *ASN1_UTCTIME_new(void);
|
|
void ASN1_UTCTIME_free(ASN1_UTCTIME *a);
|
|
ASN1_UTCTIME *d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_UTCTIME_it;
|
|
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_new(void);
|
|
void ASN1_GENERALIZEDTIME_free(ASN1_GENERALIZEDTIME *a);
|
|
ASN1_GENERALIZEDTIME *d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_GENERALIZEDTIME_it;
|
|
ASN1_TIME *ASN1_TIME_new(void);
|
|
void ASN1_TIME_free(ASN1_TIME *a);
|
|
ASN1_TIME *d2i_ASN1_TIME(ASN1_TIME **a, const unsigned char **in, long len);
|
|
int i2d_ASN1_TIME(ASN1_TIME *a, unsigned char **out);
|
|
extern const ASN1_ITEM ASN1_TIME_it;
|
|
|
|
extern const ASN1_ITEM ASN1_OCTET_STRING_NDEF_it;
|
|
|
|
ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
|
|
ASN1_TIME *ASN1_TIME_set_tm(ASN1_TIME *s, struct tm *tm);
|
|
ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, int offset_day,
|
|
long offset_sec);
|
|
int ASN1_TIME_check(const ASN1_TIME *t);
|
|
ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
|
|
ASN1_GENERALIZEDTIME **out);
|
|
int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
|
|
|
|
|
|
int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
|
|
int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
|
|
int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
|
|
int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
|
|
int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
|
|
int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
|
|
int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
|
|
|
|
int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);
|
|
|
|
int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
|
|
ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
|
|
const char *sn, const char *ln);
|
|
|
|
int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
|
|
long ASN1_INTEGER_get(const ASN1_INTEGER *a);
|
|
ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
|
|
BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);
|
|
|
|
int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
|
|
long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
|
|
ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
|
|
BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);
|
|
|
|
|
|
|
|
int ASN1_PRINTABLE_type(const unsigned char *s, int max);
|
|
|
|
|
|
int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
|
|
int *pclass, long omax);
|
|
int ASN1_check_infinite_end(unsigned char **p, long len);
|
|
int ASN1_const_check_infinite_end(const unsigned char **p, long len);
|
|
void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
|
|
int xclass);
|
|
int ASN1_put_eoc(unsigned char **pp);
|
|
int ASN1_object_size(int constructed, int length, int tag);
|
|
|
|
void *ASN1_item_dup(const ASN1_ITEM *it, void *x);
|
|
|
|
|
|
|
|
void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x);
|
|
|
|
|
|
|
|
void *ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
|
|
int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x);
|
|
int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x);
|
|
int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str,
|
|
unsigned long flags);
|
|
|
|
int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);
|
|
|
|
|
|
void *ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x);
|
|
int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x);
|
|
int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x);
|
|
int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
|
|
int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
|
|
int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a);
|
|
int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
|
|
int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
|
|
int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
|
|
unsigned char *buf, int off);
|
|
int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
|
|
int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, int dump);
|
|
|
|
|
|
unsigned long ASN1_tag2bit(int tag);
|
|
const char *ASN1_tag2str(int tag);
|
|
|
|
|
|
|
|
NETSCAPE_X509 *NETSCAPE_X509_new(void);
|
|
void NETSCAPE_X509_free(NETSCAPE_X509 *a);
|
|
NETSCAPE_X509 *d2i_NETSCAPE_X509(NETSCAPE_X509 **a, const unsigned char **in, long len);
|
|
int i2d_NETSCAPE_X509(NETSCAPE_X509 *a, unsigned char **out);
|
|
extern const ASN1_ITEM NETSCAPE_X509_it;
|
|
|
|
int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);
|
|
|
|
int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, const unsigned char *data, int len);
|
|
int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data,
|
|
int max_len);
|
|
int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, const unsigned char *data,
|
|
int len);
|
|
int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
|
|
unsigned char *data, int max_len);
|
|
|
|
ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
|
|
ASN1_OCTET_STRING **oct);
|
|
void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);
|
|
|
|
void ASN1_STRING_set_default_mask(unsigned long mask);
|
|
int ASN1_STRING_set_default_mask_asc(const char *p);
|
|
unsigned long ASN1_STRING_get_default_mask(void);
|
|
int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
|
|
int inform, unsigned long mask);
|
|
int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
|
|
int inform, unsigned long mask, long minsize, long maxsize);
|
|
|
|
ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
|
|
const unsigned char *in, int inlen, int inform, int nid);
|
|
ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
|
|
int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
|
|
void ASN1_STRING_TABLE_cleanup(void);
|
|
|
|
|
|
|
|
|
|
ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
|
|
void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
|
|
ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
|
|
long len, const ASN1_ITEM *it);
|
|
int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
|
|
int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
|
|
|
|
void ASN1_add_oid_module(void);
|
|
|
|
ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
|
|
ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
|
|
int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent,
|
|
const ASN1_ITEM *it, const ASN1_PCTX *pctx);
|
|
ASN1_PCTX *ASN1_PCTX_new(void);
|
|
void ASN1_PCTX_free(ASN1_PCTX *p);
|
|
unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
|
|
void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
|
|
unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
|
|
void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
|
|
unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
|
|
void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
|
|
unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
|
|
void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
|
|
unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
|
|
void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);
|
|
|
|
const BIO_METHOD *BIO_f_asn1(void);
|
|
|
|
BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);
|
|
|
|
int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
|
|
const ASN1_ITEM *it);
|
|
int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
|
|
const char *hdr, const ASN1_ITEM *it);
|
|
int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
|
|
int ctype_nid, int econt_nid, struct stack_st_X509_ALGOR *mdalgs,
|
|
const ASN1_ITEM *it);
|
|
ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
|
|
int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
|
|
int SMIME_text(BIO *in, BIO *out);
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_ASN1_strings(void);
|
|
int ASN1_time_parse(const char *_bytes, size_t _len, struct tm *_tm, int _mode);
|
|
int ASN1_time_tm_cmp(struct tm *_tm1, struct tm *_tm2);
|
|
typedef struct obj_name_st {
|
|
int type;
|
|
int alias;
|
|
const char *name;
|
|
const char *data;
|
|
} OBJ_NAME;
|
|
|
|
|
|
|
|
|
|
int OBJ_NAME_init(void);
|
|
int OBJ_NAME_new_index(unsigned long (*hash_func)(const char *),
|
|
int (*cmp_func)(const char *, const char *),
|
|
void (*free_func)(const char *, int, const char *));
|
|
const char *OBJ_NAME_get(const char *name, int type);
|
|
int OBJ_NAME_add(const char *name, int type, const char *data);
|
|
int OBJ_NAME_remove(const char *name, int type);
|
|
void OBJ_NAME_cleanup(int type);
|
|
void OBJ_NAME_do_all(int type, void (*fn)(const OBJ_NAME *, void *arg),
|
|
void *arg);
|
|
void OBJ_NAME_do_all_sorted(int type, void (*fn)(const OBJ_NAME *, void *arg),
|
|
void *arg);
|
|
|
|
ASN1_OBJECT * OBJ_dup(const ASN1_OBJECT *o);
|
|
ASN1_OBJECT * OBJ_nid2obj(int n);
|
|
const char * OBJ_nid2ln(int n);
|
|
const char * OBJ_nid2sn(int n);
|
|
int OBJ_obj2nid(const ASN1_OBJECT *o);
|
|
ASN1_OBJECT * OBJ_txt2obj(const char *s, int no_name);
|
|
int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name);
|
|
int OBJ_txt2nid(const char *s);
|
|
int OBJ_ln2nid(const char *s);
|
|
int OBJ_sn2nid(const char *s);
|
|
int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b);
|
|
const void * OBJ_bsearch_(const void *key, const void *base, int num,
|
|
int size, int (*cmp)(const void *, const void *));
|
|
const void * OBJ_bsearch_ex_(const void *key, const void *base, int num,
|
|
int size, int (*cmp)(const void *, const void *),
|
|
int flags);
|
|
int OBJ_new_nid(int num);
|
|
int OBJ_add_object(const ASN1_OBJECT *obj);
|
|
int OBJ_create(const char *oid, const char *sn, const char *ln);
|
|
void OBJ_cleanup(void );
|
|
int OBJ_create_objects(BIO *in);
|
|
|
|
int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid);
|
|
int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid);
|
|
int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
|
|
void OBJ_sigid_free(void);
|
|
|
|
extern int obj_cleanup_defer;
|
|
void check_defer(int nid);
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_OBJ_strings(void);
|
|
struct evp_pkey_st {
|
|
int type;
|
|
int save_type;
|
|
int references;
|
|
const EVP_PKEY_ASN1_METHOD *ameth;
|
|
ENGINE *engine;
|
|
union {
|
|
char *ptr;
|
|
|
|
struct rsa_st *rsa;
|
|
|
|
|
|
struct dsa_st *dsa;
|
|
|
|
|
|
struct dh_st *dh;
|
|
|
|
|
|
struct ec_key_st *ec;
|
|
|
|
|
|
struct gost_key_st *gost;
|
|
|
|
} pkey;
|
|
int save_parameters;
|
|
struct stack_st_X509_ATTRIBUTE *attributes;
|
|
} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef int evp_sign_method(int type, const unsigned char *m,
|
|
unsigned int m_length, unsigned char *sigret, unsigned int *siglen,
|
|
void *key);
|
|
typedef int evp_verify_method(int type, const unsigned char *m,
|
|
unsigned int m_length, const unsigned char *sigbuf, unsigned int siglen,
|
|
void *key);
|
|
|
|
|
|
struct env_md_st {
|
|
int type;
|
|
int pkey_type;
|
|
int md_size;
|
|
unsigned long flags;
|
|
int (*init)(EVP_MD_CTX *ctx);
|
|
int (*update)(EVP_MD_CTX *ctx, const void *data, size_t count);
|
|
int (*final)(EVP_MD_CTX *ctx, unsigned char *md);
|
|
int (*copy)(EVP_MD_CTX *to, const EVP_MD_CTX *from);
|
|
int (*cleanup)(EVP_MD_CTX *ctx);
|
|
|
|
evp_sign_method *sign;
|
|
evp_verify_method *verify;
|
|
int required_pkey_type[5];
|
|
int block_size;
|
|
int ctx_size;
|
|
|
|
int (*md_ctrl)(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
|
|
} ;
|
|
struct env_md_ctx_st {
|
|
const EVP_MD *digest;
|
|
ENGINE *engine;
|
|
unsigned long flags;
|
|
void *md_data;
|
|
|
|
EVP_PKEY_CTX *pctx;
|
|
|
|
int (*update)(EVP_MD_CTX *ctx, const void *data, size_t count);
|
|
} ;
|
|
struct evp_cipher_st {
|
|
int nid;
|
|
int block_size;
|
|
int key_len;
|
|
int iv_len;
|
|
unsigned long flags;
|
|
int (*init)(EVP_CIPHER_CTX *ctx, const unsigned char *key,
|
|
const unsigned char *iv, int enc);
|
|
int (*do_cipher)(EVP_CIPHER_CTX *ctx, unsigned char *out,
|
|
const unsigned char *in, size_t inl);
|
|
int (*cleanup)(EVP_CIPHER_CTX *);
|
|
int ctx_size;
|
|
int (*set_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *);
|
|
int (*get_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *);
|
|
int (*ctrl)(EVP_CIPHER_CTX *, int type, int arg, void *ptr);
|
|
void *app_data;
|
|
} ;
|
|
typedef struct evp_cipher_info_st {
|
|
const EVP_CIPHER *cipher;
|
|
unsigned char iv[16];
|
|
} EVP_CIPHER_INFO;
|
|
|
|
struct evp_cipher_ctx_st {
|
|
const EVP_CIPHER *cipher;
|
|
ENGINE *engine;
|
|
int encrypt;
|
|
int buf_len;
|
|
|
|
unsigned char oiv[16];
|
|
unsigned char iv[16];
|
|
unsigned char buf[32];
|
|
int num;
|
|
|
|
void *app_data;
|
|
int key_len;
|
|
unsigned long flags;
|
|
void *cipher_data;
|
|
int final_used;
|
|
int block_mask;
|
|
unsigned char final[32];
|
|
} ;
|
|
|
|
typedef struct evp_Encode_Ctx_st {
|
|
int num;
|
|
int length;
|
|
|
|
|
|
|
|
|
|
unsigned char enc_data[80];
|
|
int line_num;
|
|
int expect_nl;
|
|
} EVP_ENCODE_CTX;
|
|
|
|
|
|
typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
|
|
ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md, int en_de);
|
|
int EVP_MD_type(const EVP_MD *md);
|
|
|
|
|
|
int EVP_MD_pkey_type(const EVP_MD *md);
|
|
int EVP_MD_size(const EVP_MD *md);
|
|
int EVP_MD_block_size(const EVP_MD *md);
|
|
unsigned long EVP_MD_flags(const EVP_MD *md);
|
|
|
|
const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
int EVP_CIPHER_nid(const EVP_CIPHER *cipher);
|
|
|
|
int EVP_CIPHER_block_size(const EVP_CIPHER *cipher);
|
|
int EVP_CIPHER_key_length(const EVP_CIPHER *cipher);
|
|
int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher);
|
|
unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher);
|
|
|
|
|
|
const EVP_CIPHER * EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_CIPHER_CTX_get_iv(const EVP_CIPHER_CTX *ctx,
|
|
unsigned char *iv, size_t len);
|
|
int EVP_CIPHER_CTX_set_iv(EVP_CIPHER_CTX *ctx,
|
|
const unsigned char *iv, size_t len);
|
|
int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
|
|
void * EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
|
|
void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
|
|
|
|
unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx);
|
|
int EVP_Cipher(EVP_CIPHER_CTX *c, unsigned char *out, const unsigned char *in,
|
|
unsigned int inl);
|
|
EVP_MD_CTX *EVP_MD_CTX_new(void);
|
|
void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
|
|
void EVP_MD_CTX_init(EVP_MD_CTX *ctx);
|
|
int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
|
|
EVP_MD_CTX *EVP_MD_CTX_create(void);
|
|
void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx);
|
|
int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx);
|
|
int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
|
|
void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
|
|
void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
|
|
int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr);
|
|
int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
|
|
|
|
int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
|
|
int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
|
|
int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);
|
|
int EVP_Digest(const void *data, size_t count, unsigned char *md,
|
|
unsigned int *size, const EVP_MD *type, ENGINE *impl);
|
|
|
|
int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in);
|
|
int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
|
|
int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);
|
|
|
|
int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify);
|
|
int EVP_read_pw_string_min(char *buf, int minlen, int maxlen,
|
|
const char *prompt, int verify);
|
|
void EVP_set_pw_prompt(const char *prompt);
|
|
char *EVP_get_pw_prompt(void);
|
|
|
|
int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
|
|
const unsigned char *salt, const unsigned char *data, int datal, int count,
|
|
unsigned char *key, unsigned char *iv);
|
|
|
|
void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
|
|
void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
|
|
int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);
|
|
|
|
int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
|
|
const unsigned char *key, const unsigned char *iv);
|
|
int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
|
|
ENGINE *impl, const unsigned char *key, const unsigned char *iv);
|
|
int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
|
|
const unsigned char *in, int inl);
|
|
int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
|
|
|
|
int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
|
|
|
|
|
|
int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
|
|
const unsigned char *key, const unsigned char *iv);
|
|
int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
|
|
ENGINE *impl, const unsigned char *key, const unsigned char *iv);
|
|
int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
|
|
const unsigned char *in, int inl);
|
|
int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
|
|
|
|
int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
|
|
|
|
|
|
int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
|
|
const unsigned char *key, const unsigned char *iv, int enc);
|
|
int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
|
|
ENGINE *impl, const unsigned char *key, const unsigned char *iv, int enc);
|
|
int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
|
|
const unsigned char *in, int inl);
|
|
int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
|
|
|
|
int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
|
|
|
|
|
|
int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
|
|
EVP_PKEY *pkey);
|
|
|
|
int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
|
|
unsigned int siglen, EVP_PKEY *pkey);
|
|
|
|
int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
|
|
const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey);
|
|
int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, size_t *siglen);
|
|
|
|
int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
|
|
const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey);
|
|
int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
|
|
size_t siglen);
|
|
|
|
int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
|
|
const unsigned char *ek, int ekl, const unsigned char *iv, EVP_PKEY *priv);
|
|
int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
|
|
|
|
int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
|
|
unsigned char **ek, int *ekl, unsigned char *iv, EVP_PKEY **pubk,
|
|
int npubk);
|
|
int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
|
|
|
|
EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
|
|
void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
|
|
void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
|
|
int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
|
|
const unsigned char *in, int inl);
|
|
void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
|
|
int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
|
|
|
|
void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
|
|
int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
|
|
const unsigned char *in, int inl);
|
|
int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
|
|
int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
|
|
|
|
void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a);
|
|
int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a);
|
|
EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
|
|
void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *a);
|
|
int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *a);
|
|
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
|
|
int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
|
|
int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
|
|
int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
|
|
|
|
|
|
const BIO_METHOD *BIO_f_md(void);
|
|
const BIO_METHOD *BIO_f_base64(void);
|
|
const BIO_METHOD *BIO_f_cipher(void);
|
|
int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
|
|
const unsigned char *i, int enc);
|
|
|
|
|
|
const EVP_MD *EVP_md_null(void);
|
|
|
|
const EVP_MD *EVP_md4(void);
|
|
|
|
|
|
const EVP_MD *EVP_md5(void);
|
|
const EVP_MD *EVP_md5_sha1(void);
|
|
|
|
|
|
const EVP_MD *EVP_sha1(void);
|
|
const EVP_MD *EVP_dss(void);
|
|
const EVP_MD *EVP_dss1(void);
|
|
const EVP_MD *EVP_ecdsa(void);
|
|
|
|
|
|
const EVP_MD *EVP_sha224(void);
|
|
const EVP_MD *EVP_sha256(void);
|
|
|
|
|
|
const EVP_MD *EVP_sha384(void);
|
|
const EVP_MD *EVP_sha512(void);
|
|
|
|
|
|
const EVP_MD *EVP_sm3(void);
|
|
|
|
|
|
const EVP_MD *EVP_ripemd160(void);
|
|
|
|
|
|
const EVP_MD *EVP_whirlpool(void);
|
|
|
|
|
|
const EVP_MD *EVP_gostr341194(void);
|
|
const EVP_MD *EVP_gost2814789imit(void);
|
|
const EVP_MD *EVP_streebog256(void);
|
|
const EVP_MD *EVP_streebog512(void);
|
|
|
|
const EVP_CIPHER *EVP_enc_null(void);
|
|
|
|
const EVP_CIPHER *EVP_des_ecb(void);
|
|
const EVP_CIPHER *EVP_des_ede(void);
|
|
const EVP_CIPHER *EVP_des_ede3(void);
|
|
const EVP_CIPHER *EVP_des_ede_ecb(void);
|
|
const EVP_CIPHER *EVP_des_ede3_ecb(void);
|
|
const EVP_CIPHER *EVP_des_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_des_cfb1(void);
|
|
const EVP_CIPHER *EVP_des_cfb8(void);
|
|
const EVP_CIPHER *EVP_des_ede_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_des_ede3_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_des_ede3_cfb1(void);
|
|
const EVP_CIPHER *EVP_des_ede3_cfb8(void);
|
|
const EVP_CIPHER *EVP_des_ofb(void);
|
|
const EVP_CIPHER *EVP_des_ede_ofb(void);
|
|
const EVP_CIPHER *EVP_des_ede3_ofb(void);
|
|
const EVP_CIPHER *EVP_des_cbc(void);
|
|
const EVP_CIPHER *EVP_des_ede_cbc(void);
|
|
const EVP_CIPHER *EVP_des_ede3_cbc(void);
|
|
const EVP_CIPHER *EVP_desx_cbc(void);
|
|
|
|
|
|
const EVP_CIPHER *EVP_rc4(void);
|
|
const EVP_CIPHER *EVP_rc4_40(void);
|
|
|
|
const EVP_CIPHER *EVP_rc4_hmac_md5(void);
|
|
|
|
|
|
|
|
const EVP_CIPHER *EVP_idea_ecb(void);
|
|
const EVP_CIPHER *EVP_idea_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_idea_ofb(void);
|
|
const EVP_CIPHER *EVP_idea_cbc(void);
|
|
|
|
|
|
const EVP_CIPHER *EVP_rc2_ecb(void);
|
|
const EVP_CIPHER *EVP_rc2_cbc(void);
|
|
const EVP_CIPHER *EVP_rc2_40_cbc(void);
|
|
const EVP_CIPHER *EVP_rc2_64_cbc(void);
|
|
const EVP_CIPHER *EVP_rc2_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_rc2_ofb(void);
|
|
|
|
|
|
const EVP_CIPHER *EVP_bf_ecb(void);
|
|
const EVP_CIPHER *EVP_bf_cbc(void);
|
|
const EVP_CIPHER *EVP_bf_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_bf_ofb(void);
|
|
|
|
|
|
const EVP_CIPHER *EVP_cast5_ecb(void);
|
|
const EVP_CIPHER *EVP_cast5_cbc(void);
|
|
const EVP_CIPHER *EVP_cast5_cfb64(void);
|
|
|
|
const EVP_CIPHER *EVP_cast5_ofb(void);
|
|
|
|
|
|
const EVP_CIPHER *EVP_aes_128_ecb(void);
|
|
const EVP_CIPHER *EVP_aes_128_cbc(void);
|
|
const EVP_CIPHER *EVP_aes_128_cfb1(void);
|
|
const EVP_CIPHER *EVP_aes_128_cfb8(void);
|
|
const EVP_CIPHER *EVP_aes_128_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_aes_128_ofb(void);
|
|
const EVP_CIPHER *EVP_aes_128_ctr(void);
|
|
const EVP_CIPHER *EVP_aes_128_ccm(void);
|
|
const EVP_CIPHER *EVP_aes_128_gcm(void);
|
|
const EVP_CIPHER *EVP_aes_128_wrap(void);
|
|
const EVP_CIPHER *EVP_aes_128_xts(void);
|
|
const EVP_CIPHER *EVP_aes_192_ecb(void);
|
|
const EVP_CIPHER *EVP_aes_192_cbc(void);
|
|
const EVP_CIPHER *EVP_aes_192_cfb1(void);
|
|
const EVP_CIPHER *EVP_aes_192_cfb8(void);
|
|
const EVP_CIPHER *EVP_aes_192_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_aes_192_ofb(void);
|
|
const EVP_CIPHER *EVP_aes_192_ctr(void);
|
|
const EVP_CIPHER *EVP_aes_192_ccm(void);
|
|
const EVP_CIPHER *EVP_aes_192_gcm(void);
|
|
const EVP_CIPHER *EVP_aes_192_wrap(void);
|
|
const EVP_CIPHER *EVP_aes_256_ecb(void);
|
|
const EVP_CIPHER *EVP_aes_256_cbc(void);
|
|
const EVP_CIPHER *EVP_aes_256_cfb1(void);
|
|
const EVP_CIPHER *EVP_aes_256_cfb8(void);
|
|
const EVP_CIPHER *EVP_aes_256_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_aes_256_ofb(void);
|
|
const EVP_CIPHER *EVP_aes_256_ctr(void);
|
|
const EVP_CIPHER *EVP_aes_256_ccm(void);
|
|
const EVP_CIPHER *EVP_aes_256_gcm(void);
|
|
const EVP_CIPHER *EVP_aes_256_wrap(void);
|
|
const EVP_CIPHER *EVP_aes_256_xts(void);
|
|
|
|
const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
|
|
const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
|
|
|
|
|
|
|
|
const EVP_CIPHER *EVP_camellia_128_ecb(void);
|
|
const EVP_CIPHER *EVP_camellia_128_cbc(void);
|
|
const EVP_CIPHER *EVP_camellia_128_cfb1(void);
|
|
const EVP_CIPHER *EVP_camellia_128_cfb8(void);
|
|
const EVP_CIPHER *EVP_camellia_128_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_camellia_128_ofb(void);
|
|
const EVP_CIPHER *EVP_camellia_192_ecb(void);
|
|
const EVP_CIPHER *EVP_camellia_192_cbc(void);
|
|
const EVP_CIPHER *EVP_camellia_192_cfb1(void);
|
|
const EVP_CIPHER *EVP_camellia_192_cfb8(void);
|
|
const EVP_CIPHER *EVP_camellia_192_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_camellia_192_ofb(void);
|
|
const EVP_CIPHER *EVP_camellia_256_ecb(void);
|
|
const EVP_CIPHER *EVP_camellia_256_cbc(void);
|
|
const EVP_CIPHER *EVP_camellia_256_cfb1(void);
|
|
const EVP_CIPHER *EVP_camellia_256_cfb8(void);
|
|
const EVP_CIPHER *EVP_camellia_256_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_camellia_256_ofb(void);
|
|
|
|
|
|
|
|
const EVP_CIPHER *EVP_chacha20(void);
|
|
|
|
|
|
|
|
const EVP_CIPHER *EVP_gost2814789_ecb(void);
|
|
const EVP_CIPHER *EVP_gost2814789_cfb64(void);
|
|
const EVP_CIPHER *EVP_gost2814789_cnt(void);
|
|
|
|
|
|
|
|
const EVP_CIPHER *EVP_sm4_ecb(void);
|
|
const EVP_CIPHER *EVP_sm4_cbc(void);
|
|
const EVP_CIPHER *EVP_sm4_cfb128(void);
|
|
|
|
const EVP_CIPHER *EVP_sm4_ofb(void);
|
|
const EVP_CIPHER *EVP_sm4_ctr(void);
|
|
|
|
|
|
void OPENSSL_add_all_algorithms_noconf(void);
|
|
void OPENSSL_add_all_algorithms_conf(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void OpenSSL_add_all_ciphers(void);
|
|
void OpenSSL_add_all_digests(void);
|
|
|
|
|
|
|
|
|
|
|
|
int EVP_add_cipher(const EVP_CIPHER *cipher);
|
|
int EVP_add_digest(const EVP_MD *digest);
|
|
|
|
const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
|
|
const EVP_MD *EVP_get_digestbyname(const char *name);
|
|
void EVP_cleanup(void);
|
|
|
|
void EVP_CIPHER_do_all(void (*fn)(const EVP_CIPHER *ciph, const char *from,
|
|
const char *to, void *x), void *arg);
|
|
void EVP_CIPHER_do_all_sorted(void (*fn)(const EVP_CIPHER *ciph,
|
|
const char *from, const char *to, void *x), void *arg);
|
|
|
|
void EVP_MD_do_all(void (*fn)(const EVP_MD *ciph, const char *from,
|
|
const char *to, void *x), void *arg);
|
|
void EVP_MD_do_all_sorted(void (*fn)(const EVP_MD *ciph, const char *from,
|
|
const char *to, void *x), void *arg);
|
|
|
|
int EVP_PKEY_decrypt_old(unsigned char *dec_key, const unsigned char *enc_key,
|
|
int enc_key_len, EVP_PKEY *private_key);
|
|
int EVP_PKEY_encrypt_old(unsigned char *enc_key, const unsigned char *key,
|
|
int key_len, EVP_PKEY *pub_key);
|
|
int EVP_PKEY_type(int type);
|
|
int EVP_PKEY_id(const EVP_PKEY *pkey);
|
|
int EVP_PKEY_base_id(const EVP_PKEY *pkey);
|
|
int EVP_PKEY_bits(const EVP_PKEY *pkey);
|
|
int EVP_PKEY_size(const EVP_PKEY *pkey);
|
|
int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
|
|
int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
|
|
int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key);
|
|
void *EVP_PKEY_get0(const EVP_PKEY *pkey);
|
|
const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);
|
|
|
|
|
|
struct rsa_st;
|
|
struct rsa_st *EVP_PKEY_get0_RSA(EVP_PKEY *pkey);
|
|
struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
|
|
int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key);
|
|
|
|
|
|
struct dsa_st;
|
|
struct dsa_st *EVP_PKEY_get0_DSA(EVP_PKEY *pkey);
|
|
struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
|
|
int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key);
|
|
|
|
|
|
struct dh_st;
|
|
struct dh_st *EVP_PKEY_get0_DH(EVP_PKEY *pkey);
|
|
struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
|
|
int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key);
|
|
|
|
|
|
struct ec_key_st;
|
|
struct ec_key_st *EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey);
|
|
struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
|
|
int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key);
|
|
|
|
|
|
struct gost_key_st;
|
|
|
|
|
|
EVP_PKEY *EVP_PKEY_new(void);
|
|
void EVP_PKEY_free(EVP_PKEY *pkey);
|
|
int EVP_PKEY_up_ref(EVP_PKEY *pkey);
|
|
|
|
EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
|
|
long length);
|
|
int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp);
|
|
|
|
EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp,
|
|
long length);
|
|
EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
|
|
long length);
|
|
int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp);
|
|
|
|
int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
|
|
int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
|
|
int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode);
|
|
int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
|
|
|
|
int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
|
|
|
|
int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, int indent,
|
|
ASN1_PCTX *pctx);
|
|
int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, int indent,
|
|
ASN1_PCTX *pctx);
|
|
int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, int indent,
|
|
ASN1_PCTX *pctx);
|
|
|
|
int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
|
|
|
|
int EVP_CIPHER_type(const EVP_CIPHER *ctx);
|
|
|
|
|
|
int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
|
|
int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
|
|
|
|
|
|
int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
|
|
int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
|
|
|
|
|
|
int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
|
|
ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md, int en_de);
|
|
int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
|
|
const unsigned char *salt, int saltlen, int iter, int keylen,
|
|
unsigned char *out);
|
|
int PKCS5_PBKDF2_HMAC(const char *pass, int passlen, const unsigned char *salt,
|
|
int saltlen, int iter, const EVP_MD *digest, int keylen,
|
|
unsigned char *out);
|
|
int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
|
|
ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md,
|
|
int en_de);
|
|
|
|
void PKCS5_PBE_add(void);
|
|
|
|
int EVP_PBE_CipherInit (ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
|
|
ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
|
|
int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid,
|
|
EVP_PBE_KEYGEN *keygen);
|
|
int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
|
|
EVP_PBE_KEYGEN *keygen);
|
|
int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid,
|
|
EVP_PBE_KEYGEN **pkeygen);
|
|
void EVP_PBE_cleanup(void);
|
|
int EVP_PKEY_asn1_get_count(void);
|
|
const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
|
|
const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type);
|
|
const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
|
|
const char *str, int len);
|
|
int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth);
|
|
int EVP_PKEY_asn1_add_alias(int to, int from);
|
|
int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id, int *ppkey_flags,
|
|
const char **pinfo, const char **ppem_str,
|
|
const EVP_PKEY_ASN1_METHOD *ameth);
|
|
|
|
const EVP_PKEY_ASN1_METHOD* EVP_PKEY_get0_asn1(const EVP_PKEY *pkey);
|
|
EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags, const char *pem_str,
|
|
const char *info);
|
|
void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
|
|
const EVP_PKEY_ASN1_METHOD *src);
|
|
void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
|
|
void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
|
|
int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub),
|
|
int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk),
|
|
int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
|
|
int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent,
|
|
ASN1_PCTX *pctx),
|
|
int (*pkey_size)(const EVP_PKEY *pk),
|
|
int (*pkey_bits)(const EVP_PKEY *pk));
|
|
void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
|
|
int (*priv_decode)(EVP_PKEY *pk, const PKCS8_PRIV_KEY_INFO *p8inf),
|
|
int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk),
|
|
int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
|
|
ASN1_PCTX *pctx));
|
|
void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
|
|
int (*param_decode)(EVP_PKEY *pkey, const unsigned char **pder, int derlen),
|
|
int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder),
|
|
int (*param_missing)(const EVP_PKEY *pk),
|
|
int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from),
|
|
int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b),
|
|
int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
|
|
ASN1_PCTX *pctx));
|
|
|
|
void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
|
|
void (*pkey_free)(EVP_PKEY *pkey));
|
|
void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
|
|
int (*pkey_ctrl)(EVP_PKEY *pkey, int op, long arg1, void *arg2));
|
|
const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
|
|
EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags);
|
|
void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
|
|
const EVP_PKEY_METHOD *meth);
|
|
void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src);
|
|
void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
|
|
int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
|
|
|
|
EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
|
|
EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
|
|
EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx);
|
|
void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
|
|
|
|
int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, int cmd,
|
|
int p1, void *p2);
|
|
int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
|
|
const char *value);
|
|
|
|
int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx);
|
|
void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen);
|
|
|
|
EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e, const unsigned char *key,
|
|
int keylen);
|
|
|
|
void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data);
|
|
void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx);
|
|
EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx);
|
|
|
|
EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx);
|
|
|
|
void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
|
|
void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
|
|
|
|
int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
|
|
const unsigned char *tbs, size_t tbslen);
|
|
int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
|
|
const unsigned char *tbs, size_t tbslen);
|
|
int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, unsigned char *rout,
|
|
size_t *routlen, const unsigned char *sig, size_t siglen);
|
|
int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
|
|
const unsigned char *in, size_t inlen);
|
|
int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
|
|
const unsigned char *in, size_t inlen);
|
|
|
|
int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
|
|
int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
|
|
|
|
typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
|
|
|
|
int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
|
|
int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
|
|
int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
|
|
|
|
void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
|
|
EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);
|
|
|
|
int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
|
|
|
|
void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
|
|
int (*init)(EVP_PKEY_CTX *ctx));
|
|
|
|
void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
|
|
int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src));
|
|
|
|
void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
|
|
void (*cleanup)(EVP_PKEY_CTX *ctx));
|
|
|
|
void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
|
|
int (*paramgen_init)(EVP_PKEY_CTX *ctx),
|
|
int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
|
|
|
|
void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
|
|
int (*keygen_init)(EVP_PKEY_CTX *ctx),
|
|
int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
|
|
|
|
void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
|
|
int (*sign_init)(EVP_PKEY_CTX *ctx),
|
|
int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
|
|
const unsigned char *tbs, size_t tbslen));
|
|
|
|
void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
|
|
int (*verify_init)(EVP_PKEY_CTX *ctx),
|
|
int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
|
|
const unsigned char *tbs, size_t tbslen));
|
|
|
|
void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
|
|
int (*verify_recover_init)(EVP_PKEY_CTX *ctx),
|
|
int (*verify_recover)(EVP_PKEY_CTX *ctx, unsigned char *sig,
|
|
size_t *siglen, const unsigned char *tbs, size_t tbslen));
|
|
|
|
void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
|
|
int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
|
|
int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
|
|
EVP_MD_CTX *mctx));
|
|
|
|
void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
|
|
int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
|
|
int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
|
|
EVP_MD_CTX *mctx));
|
|
|
|
void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
|
|
int (*encrypt_init)(EVP_PKEY_CTX *ctx),
|
|
int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
|
|
const unsigned char *in, size_t inlen));
|
|
|
|
void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
|
|
int (*decrypt_init)(EVP_PKEY_CTX *ctx),
|
|
int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
|
|
const unsigned char *in, size_t inlen));
|
|
|
|
void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
|
|
int (*derive_init)(EVP_PKEY_CTX *ctx),
|
|
int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
|
|
|
|
void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
|
|
int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
|
|
int (*ctrl_str)(EVP_PKEY_CTX *ctx, const char *type, const char *value));
|
|
struct evp_aead_st;
|
|
typedef struct evp_aead_st EVP_AEAD;
|
|
|
|
|
|
|
|
const EVP_AEAD *EVP_aead_aes_128_gcm(void);
|
|
|
|
const EVP_AEAD *EVP_aead_aes_256_gcm(void);
|
|
|
|
|
|
|
|
|
|
const EVP_AEAD *EVP_aead_chacha20_poly1305(void);
|
|
|
|
const EVP_AEAD *EVP_aead_xchacha20_poly1305(void);
|
|
|
|
|
|
|
|
size_t EVP_AEAD_key_length(const EVP_AEAD *aead);
|
|
|
|
|
|
size_t EVP_AEAD_nonce_length(const EVP_AEAD *aead);
|
|
|
|
|
|
|
|
size_t EVP_AEAD_max_overhead(const EVP_AEAD *aead);
|
|
|
|
|
|
|
|
|
|
size_t EVP_AEAD_max_tag_len(const EVP_AEAD *aead);
|
|
|
|
|
|
|
|
typedef struct evp_aead_ctx_st {
|
|
const EVP_AEAD *aead;
|
|
|
|
void *aead_state;
|
|
} EVP_AEAD_CTX;
|
|
int EVP_AEAD_CTX_init(EVP_AEAD_CTX *ctx, const EVP_AEAD *aead,
|
|
const unsigned char *key, size_t key_len, size_t tag_len, ENGINE *impl);
|
|
|
|
|
|
void EVP_AEAD_CTX_cleanup(EVP_AEAD_CTX *ctx);
|
|
int EVP_AEAD_CTX_seal(const EVP_AEAD_CTX *ctx, unsigned char *out,
|
|
size_t *out_len, size_t max_out_len, const unsigned char *nonce,
|
|
size_t nonce_len, const unsigned char *in, size_t in_len,
|
|
const unsigned char *ad, size_t ad_len);
|
|
int EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, unsigned char *out,
|
|
size_t *out_len, size_t max_out_len, const unsigned char *nonce,
|
|
size_t nonce_len, const unsigned char *in, size_t in_len,
|
|
const unsigned char *ad, size_t ad_len);
|
|
|
|
void EVP_add_alg_module(void);
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_EVP_strings(void);
|
|
|
|
|
|
|
|
typedef long int ptrdiff_t;
|
|
typedef struct {
|
|
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
|
|
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
|
|
} max_align_t;
|
|
|
|
|
|
|
|
|
|
|
|
struct buf_mem_st {
|
|
size_t length;
|
|
char *data;
|
|
size_t max;
|
|
};
|
|
|
|
BUF_MEM *BUF_MEM_new(void);
|
|
void BUF_MEM_free(BUF_MEM *a);
|
|
int BUF_MEM_grow(BUF_MEM *str, size_t len);
|
|
int BUF_MEM_grow_clean(BUF_MEM *str, size_t len);
|
|
|
|
|
|
char * BUF_strdup(const char *str);
|
|
char * BUF_strndup(const char *str, size_t siz);
|
|
void * BUF_memdup(const void *data, size_t siz);
|
|
void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz);
|
|
|
|
|
|
size_t BUF_strlcpy(char *dst, const char *src, size_t siz)
|
|
__attribute__ (());
|
|
size_t BUF_strlcat(char *dst, const char *src, size_t siz)
|
|
__attribute__ (());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_BUF_strings(void);
|
|
typedef enum {
|
|
|
|
|
|
POINT_CONVERSION_COMPRESSED = 2,
|
|
|
|
POINT_CONVERSION_UNCOMPRESSED = 4,
|
|
|
|
|
|
POINT_CONVERSION_HYBRID = 6
|
|
} point_conversion_form_t;
|
|
|
|
|
|
typedef struct ec_method_st EC_METHOD;
|
|
|
|
typedef struct ec_group_st
|
|
EC_GROUP;
|
|
|
|
typedef struct ec_point_st EC_POINT;
|
|
const EC_METHOD *EC_GFp_simple_method(void);
|
|
|
|
|
|
|
|
|
|
const EC_METHOD *EC_GFp_mont_method(void);
|
|
|
|
|
|
|
|
|
|
const EC_METHOD *EC_GFp_nist_method(void);
|
|
const EC_METHOD *EC_GF2m_simple_method(void);
|
|
EC_GROUP *EC_GROUP_new(const EC_METHOD *meth);
|
|
|
|
|
|
|
|
|
|
void EC_GROUP_free(EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
void EC_GROUP_clear_free(EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EC_GROUP *EC_GROUP_dup(const EC_GROUP *src);
|
|
|
|
|
|
|
|
|
|
|
|
const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_METHOD_get_field_type(const EC_METHOD *meth);
|
|
int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor);
|
|
|
|
|
|
|
|
|
|
|
|
const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
void EC_GROUP_set_curve_name(EC_GROUP *group, int nid);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_get_curve_name(const EC_GROUP *group);
|
|
|
|
void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag);
|
|
int EC_GROUP_get_asn1_flag(const EC_GROUP *group);
|
|
|
|
void EC_GROUP_set_point_conversion_form(EC_GROUP *group, point_conversion_form_t form);
|
|
point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *);
|
|
|
|
unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x);
|
|
size_t EC_GROUP_get_seed_len(const EC_GROUP *);
|
|
size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len);
|
|
int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
|
int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);
|
|
int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
|
int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_get_degree(const EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx);
|
|
EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
|
EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EC_GROUP *EC_GROUP_new_by_curve_name(int nid);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
int nid;
|
|
const char *comment;
|
|
} EC_builtin_curve;
|
|
|
|
|
|
|
|
|
|
|
|
size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems);
|
|
|
|
const char *EC_curve_nid2nist(int nid);
|
|
int EC_curve_nist2nid(const char *name);
|
|
EC_POINT *EC_POINT_new(const EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
void EC_POINT_free(EC_POINT *point);
|
|
|
|
|
|
|
|
|
|
void EC_POINT_clear_free(EC_POINT *point);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
|
|
const EC_METHOD *EC_POINT_method_of(const EC_POINT *point);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point);
|
|
int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *p,
|
|
const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx);
|
|
int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
|
|
const EC_POINT *p, BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx);
|
|
int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *p,
|
|
const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
|
|
int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
|
|
const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
|
|
int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *p,
|
|
const BIGNUM *x, int y_bit, BN_CTX *ctx);
|
|
int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p,
|
|
const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
|
|
int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group,
|
|
const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
|
|
int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p,
|
|
const BIGNUM *x, int y_bit, BN_CTX *ctx);
|
|
size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p,
|
|
point_conversion_form_t form,
|
|
unsigned char *buf, size_t len, BN_CTX *ctx);
|
|
int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p,
|
|
const unsigned char *buf, size_t len, BN_CTX *ctx);
|
|
|
|
|
|
BIGNUM *EC_POINT_point2bn(const EC_GROUP *, const EC_POINT *,
|
|
point_conversion_form_t form, BIGNUM *, BN_CTX *);
|
|
EC_POINT *EC_POINT_bn2point(const EC_GROUP *, const BIGNUM *,
|
|
EC_POINT *, BN_CTX *);
|
|
char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *,
|
|
point_conversion_form_t form, BN_CTX *);
|
|
EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *,
|
|
EC_POINT *, BN_CTX *);
|
|
int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx);
|
|
int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx);
|
|
int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx);
|
|
|
|
int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx);
|
|
int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx);
|
|
int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, size_t num, const EC_POINT *p[], const BIGNUM *m[], BN_CTX *ctx);
|
|
int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_GROUP_have_precompute_mult(const EC_GROUP *group);
|
|
int EC_GROUP_get_basis_type(const EC_GROUP *);
|
|
|
|
int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k);
|
|
int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1,
|
|
unsigned int *k2, unsigned int *k3);
|
|
|
|
|
|
|
|
|
|
typedef struct ecpk_parameters_st ECPKPARAMETERS;
|
|
|
|
EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len);
|
|
int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out);
|
|
int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off);
|
|
|
|
int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct ec_key_st EC_KEY;
|
|
typedef struct ec_key_method_st EC_KEY_METHOD;
|
|
EC_KEY *EC_KEY_new(void);
|
|
|
|
int EC_KEY_get_flags(const EC_KEY *key);
|
|
|
|
void EC_KEY_set_flags(EC_KEY *key, int flags);
|
|
|
|
void EC_KEY_clear_flags(EC_KEY *key, int flags);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EC_KEY *EC_KEY_new_by_curve_name(int nid);
|
|
|
|
|
|
|
|
|
|
void EC_KEY_free(EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src);
|
|
|
|
|
|
|
|
|
|
|
|
EC_KEY *EC_KEY_dup(const EC_KEY *src);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_up_ref(EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group);
|
|
|
|
|
|
|
|
|
|
|
|
const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv);
|
|
|
|
|
|
|
|
|
|
|
|
const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub);
|
|
|
|
unsigned EC_KEY_get_enc_flags(const EC_KEY *key);
|
|
void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags);
|
|
point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key);
|
|
void EC_KEY_set_conv_form(EC_KEY *eckey, point_conversion_form_t cform);
|
|
|
|
void *EC_KEY_get_key_method_data(EC_KEY *key,
|
|
void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *));
|
|
void *EC_KEY_insert_key_method_data(EC_KEY *key, void *data,
|
|
void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *));
|
|
|
|
void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_generate_key(EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_check_key(const EC_KEY *key);
|
|
int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y);
|
|
EC_KEY *d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int i2d_ECPrivateKey(EC_KEY *key, unsigned char **out);
|
|
EC_KEY *d2i_ECParameters(EC_KEY **key, const unsigned char **in, long len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int i2d_ECParameters(EC_KEY *key, unsigned char **out);
|
|
EC_KEY *o2i_ECPublicKey(EC_KEY **key, const unsigned char **in, long len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int ECParameters_print(BIO *bp, const EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_print(BIO *bp, const EC_KEY *key, int off);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int ECParameters_print_fp(FILE *fp, const EC_KEY *key);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off);
|
|
|
|
|
|
|
|
int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg);
|
|
void *EC_KEY_get_ex_data(const EC_KEY *key, int idx);
|
|
|
|
const EC_KEY_METHOD *EC_KEY_OpenSSL(void);
|
|
const EC_KEY_METHOD *EC_KEY_get_default_method(void);
|
|
void EC_KEY_set_default_method(const EC_KEY_METHOD *meth);
|
|
const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key);
|
|
int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth);
|
|
EC_KEY *EC_KEY_new_method(ENGINE *engine);
|
|
EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth);
|
|
void EC_KEY_METHOD_free(EC_KEY_METHOD *meth);
|
|
void EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
|
|
int (*init)(EC_KEY *key),
|
|
void (*finish)(EC_KEY *key),
|
|
int (*copy)(EC_KEY *dest, const EC_KEY *src),
|
|
int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
|
|
int (*set_private)(EC_KEY *key, const BIGNUM *priv_key),
|
|
int (*set_public)(EC_KEY *key, const EC_POINT *pub_key));
|
|
void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth,
|
|
int (*keygen)(EC_KEY *key));
|
|
void EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
|
|
int (*ckey)(void *out, size_t outlen, const EC_POINT *pub_key, EC_KEY *ecdh,
|
|
void *(*KDF) (const void *in, size_t inlen, void *out, size_t *outlen)));
|
|
void EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth,
|
|
int (**pinit)(EC_KEY *key),
|
|
void (**pfinish)(EC_KEY *key),
|
|
int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
|
|
int (**pset_group)(EC_KEY *key, const EC_GROUP *grp),
|
|
int (**pset_private)(EC_KEY *key, const BIGNUM *priv_key),
|
|
int (**pset_public)(EC_KEY *key, const EC_POINT *pub_key));
|
|
void EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
|
|
int (**pkeygen)(EC_KEY *key));
|
|
void EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
|
|
int (**pck)(void *out, size_t outlen, const EC_POINT *pub_key, EC_KEY *ecdh,
|
|
void *(*KDF) (const void *in, size_t inlen, void *out, size_t *outlen)));
|
|
|
|
EC_KEY *ECParameters_dup(EC_KEY *key);
|
|
void ERR_load_EC_strings(void);
|
|
|
|
|
|
|
|
typedef struct ECDSA_SIG_st ECDSA_SIG;
|
|
|
|
struct ecdsa_method {
|
|
const char *name;
|
|
ECDSA_SIG *(*ecdsa_do_sign)(const unsigned char *dgst, int dgst_len,
|
|
const BIGNUM *inv, const BIGNUM *rp, EC_KEY *eckey);
|
|
int (*ecdsa_sign_setup)(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
|
|
BIGNUM **r);
|
|
int (*ecdsa_do_verify)(const unsigned char *dgst, int dgst_len,
|
|
const ECDSA_SIG *sig, EC_KEY *eckey);
|
|
|
|
|
|
|
|
|
|
int flags;
|
|
char *app_data;
|
|
};
|
|
struct ECDSA_SIG_st {
|
|
BIGNUM *r;
|
|
BIGNUM *s;
|
|
};
|
|
|
|
|
|
|
|
|
|
ECDSA_SIG *ECDSA_SIG_new(void);
|
|
|
|
|
|
|
|
|
|
void ECDSA_SIG_free(ECDSA_SIG *sig);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
|
|
ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
|
|
ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
|
|
EC_KEY *eckey);
|
|
ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
|
|
const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey);
|
|
int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
|
|
const ECDSA_SIG *sig, EC_KEY* eckey);
|
|
|
|
const ECDSA_METHOD *ECDSA_OpenSSL(void);
|
|
|
|
|
|
|
|
|
|
void ECDSA_set_default_method(const ECDSA_METHOD *meth);
|
|
|
|
|
|
|
|
|
|
const ECDSA_METHOD *ECDSA_get_default_method(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth);
|
|
|
|
|
|
|
|
|
|
|
|
int ECDSA_size(const EC_KEY *eckey);
|
|
int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
|
|
BIGNUM **rp);
|
|
int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen,
|
|
unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
|
|
int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen,
|
|
unsigned char *sig, unsigned int *siglen, const BIGNUM *kinv,
|
|
const BIGNUM *rp, EC_KEY *eckey);
|
|
int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen,
|
|
const unsigned char *sig, int siglen, EC_KEY *eckey);
|
|
|
|
|
|
int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
|
|
void *ECDSA_get_ex_data(EC_KEY *d, int idx);
|
|
|
|
|
|
|
|
void EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
|
|
int (*sign)(int type, const unsigned char *dgst,
|
|
int dlen, unsigned char *sig, unsigned int *siglen,
|
|
const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey),
|
|
int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
|
|
BIGNUM **kinvp, BIGNUM **rp),
|
|
ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
|
|
int dgst_len, const BIGNUM *in_kinv, const BIGNUM *in_r,
|
|
EC_KEY *eckey));
|
|
void EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
|
|
int (*verify)(int type, const unsigned char *dgst, int dgst_len,
|
|
const unsigned char *sigbuf, int sig_len, EC_KEY *eckey),
|
|
int (*verify_sig)(const unsigned char *dgst, int dgst_len,
|
|
const ECDSA_SIG *sig, EC_KEY *eckey));
|
|
void EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
|
|
int (**psign)(int type, const unsigned char *dgst,
|
|
int dlen, unsigned char *sig, unsigned int *siglen,
|
|
const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey),
|
|
int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
|
|
BIGNUM **kinvp, BIGNUM **rp),
|
|
ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
|
|
int dgst_len, const BIGNUM *in_kinv, const BIGNUM *in_r,
|
|
EC_KEY *eckey));
|
|
void EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
|
|
int (**pverify)(int type, const unsigned char *dgst, int dgst_len,
|
|
const unsigned char *sigbuf, int sig_len, EC_KEY *eckey),
|
|
int (**pverify_sig)(const unsigned char *dgst, int dgst_len,
|
|
const ECDSA_SIG *sig, EC_KEY *eckey));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_ECDSA_strings(void);
|
|
|
|
|
|
|
|
const ECDH_METHOD *ECDH_OpenSSL(void);
|
|
|
|
void ECDH_set_default_method(const ECDH_METHOD *);
|
|
const ECDH_METHOD *ECDH_get_default_method(void);
|
|
int ECDH_set_method(EC_KEY *, const ECDH_METHOD *);
|
|
|
|
int ECDH_size(const EC_KEY *ecdh);
|
|
int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key,
|
|
EC_KEY *ecdh,
|
|
void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen));
|
|
|
|
int ECDH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new
|
|
*new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int ECDH_set_ex_data(EC_KEY *d, int idx, void *arg);
|
|
void *ECDH_get_ex_data(EC_KEY *d, int idx);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_ECDH_strings(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct rsa_meth_st {
|
|
const char *name;
|
|
int (*rsa_pub_enc)(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int (*rsa_pub_dec)(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int (*rsa_priv_enc)(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int (*rsa_priv_dec)(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int (*rsa_mod_exp)(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
|
|
BN_CTX *ctx);
|
|
int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
|
|
int (*init)(RSA *rsa);
|
|
int (*finish)(RSA *rsa);
|
|
int flags;
|
|
char *app_data;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int (*rsa_sign)(int type, const unsigned char *m, unsigned int m_length,
|
|
unsigned char *sigret, unsigned int *siglen, const RSA *rsa);
|
|
int (*rsa_verify)(int dtype, const unsigned char *m,
|
|
unsigned int m_length, const unsigned char *sigbuf,
|
|
unsigned int siglen, const RSA *rsa);
|
|
|
|
|
|
|
|
|
|
int (*rsa_keygen)(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
|
|
};
|
|
|
|
struct rsa_st {
|
|
|
|
|
|
int pad;
|
|
long version;
|
|
const RSA_METHOD *meth;
|
|
|
|
ENGINE *engine;
|
|
BIGNUM *n;
|
|
BIGNUM *e;
|
|
BIGNUM *d;
|
|
BIGNUM *p;
|
|
BIGNUM *q;
|
|
BIGNUM *dmp1;
|
|
BIGNUM *dmq1;
|
|
BIGNUM *iqmp;
|
|
|
|
CRYPTO_EX_DATA ex_data;
|
|
int references;
|
|
int flags;
|
|
|
|
|
|
BN_MONT_CTX *_method_mod_n;
|
|
BN_MONT_CTX *_method_mod_p;
|
|
BN_MONT_CTX *_method_mod_q;
|
|
|
|
|
|
|
|
BN_BLINDING *blinding;
|
|
BN_BLINDING *mt_blinding;
|
|
};
|
|
RSA *RSA_new(void);
|
|
RSA *RSA_new_method(ENGINE *engine);
|
|
int RSA_bits(const RSA *rsa);
|
|
int RSA_size(const RSA *rsa);
|
|
|
|
|
|
|
|
RSA *RSA_generate_key(int bits, unsigned long e,
|
|
void (*callback)(int, int, void *), void *cb_arg);
|
|
|
|
|
|
|
|
int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
|
|
|
|
int RSA_check_key(const RSA *);
|
|
|
|
int RSA_public_encrypt(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int RSA_private_encrypt(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int RSA_public_decrypt(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
int RSA_private_decrypt(int flen, const unsigned char *from,
|
|
unsigned char *to, RSA *rsa, int padding);
|
|
void RSA_free(RSA *r);
|
|
|
|
int RSA_up_ref(RSA *r);
|
|
|
|
int RSA_flags(const RSA *r);
|
|
|
|
void RSA_set_default_method(const RSA_METHOD *meth);
|
|
const RSA_METHOD *RSA_get_default_method(void);
|
|
const RSA_METHOD *RSA_get_method(const RSA *rsa);
|
|
int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
|
|
|
|
|
|
const RSA_METHOD *RSA_PKCS1_SSLeay(void);
|
|
|
|
const RSA_METHOD *RSA_null_method(void);
|
|
|
|
RSA *d2i_RSAPublicKey(RSA **a, const unsigned char **in, long len);
|
|
int i2d_RSAPublicKey(const RSA *a, unsigned char **out);
|
|
extern const ASN1_ITEM RSAPublicKey_it;
|
|
RSA *d2i_RSAPrivateKey(RSA **a, const unsigned char **in, long len);
|
|
int i2d_RSAPrivateKey(const RSA *a, unsigned char **out);
|
|
extern const ASN1_ITEM RSAPrivateKey_it;
|
|
|
|
typedef struct rsa_pss_params_st {
|
|
X509_ALGOR *hashAlgorithm;
|
|
X509_ALGOR *maskGenAlgorithm;
|
|
ASN1_INTEGER *saltLength;
|
|
ASN1_INTEGER *trailerField;
|
|
} RSA_PSS_PARAMS;
|
|
|
|
RSA_PSS_PARAMS *RSA_PSS_PARAMS_new(void);
|
|
void RSA_PSS_PARAMS_free(RSA_PSS_PARAMS *a);
|
|
RSA_PSS_PARAMS *d2i_RSA_PSS_PARAMS(RSA_PSS_PARAMS **a, const unsigned char **in, long len);
|
|
int i2d_RSA_PSS_PARAMS(RSA_PSS_PARAMS *a, unsigned char **out);
|
|
extern const ASN1_ITEM RSA_PSS_PARAMS_it;
|
|
|
|
int RSA_print_fp(FILE *fp, const RSA *r, int offset);
|
|
|
|
|
|
int RSA_print(BIO *bp, const RSA *r, int offset);
|
|
|
|
|
|
|
|
int i2d_RSA_NET(const RSA *a, unsigned char **pp,
|
|
int (*cb)(char *buf, int len, const char *prompt, int verify), int sgckey);
|
|
RSA *d2i_RSA_NET(RSA **a, const unsigned char **pp, long length,
|
|
int (*cb)(char *buf, int len, const char *prompt, int verify), int sgckey);
|
|
|
|
int i2d_Netscape_RSA(const RSA *a, unsigned char **pp,
|
|
int (*cb)(char *buf, int len, const char *prompt, int verify));
|
|
RSA *d2i_Netscape_RSA(RSA **a, const unsigned char **pp, long length,
|
|
int (*cb)(char *buf, int len, const char *prompt, int verify));
|
|
|
|
|
|
|
|
|
|
int RSA_sign(int type, const unsigned char *m, unsigned int m_length,
|
|
unsigned char *sigret, unsigned int *siglen, RSA *rsa);
|
|
int RSA_verify(int type, const unsigned char *m, unsigned int m_length,
|
|
const unsigned char *sigbuf, unsigned int siglen, RSA *rsa);
|
|
|
|
|
|
|
|
int RSA_sign_ASN1_OCTET_STRING(int type, const unsigned char *m,
|
|
unsigned int m_length, unsigned char *sigret, unsigned int *siglen,
|
|
RSA *rsa);
|
|
int RSA_verify_ASN1_OCTET_STRING(int type, const unsigned char *m,
|
|
unsigned int m_length, unsigned char *sigbuf, unsigned int siglen,
|
|
RSA *rsa);
|
|
|
|
int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);
|
|
void RSA_blinding_off(RSA *rsa);
|
|
BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx);
|
|
|
|
int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl);
|
|
int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl, int rsa_len);
|
|
int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl);
|
|
int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl, int rsa_len);
|
|
int PKCS1_MGF1(unsigned char *mask, long len,
|
|
const unsigned char *seed, long seedlen, const EVP_MD *dgst);
|
|
int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl,
|
|
const unsigned char *p, int pl);
|
|
int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl, int rsa_len,
|
|
const unsigned char *p, int pl);
|
|
int RSA_padding_add_none(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl);
|
|
int RSA_padding_check_none(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl, int rsa_len);
|
|
int RSA_padding_add_X931(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl);
|
|
int RSA_padding_check_X931(unsigned char *to, int tlen,
|
|
const unsigned char *f, int fl, int rsa_len);
|
|
int RSA_X931_hash_id(int nid);
|
|
|
|
int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
|
|
const EVP_MD *Hash, const unsigned char *EM, int sLen);
|
|
int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
|
|
const unsigned char *mHash, const EVP_MD *Hash, int sLen);
|
|
|
|
int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
|
|
const EVP_MD *Hash, const EVP_MD *mgf1Hash, const unsigned char *EM,
|
|
int sLen);
|
|
|
|
int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
|
|
const unsigned char *mHash, const EVP_MD *Hash, const EVP_MD *mgf1Hash,
|
|
int sLen);
|
|
|
|
int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int RSA_set_ex_data(RSA *r, int idx, void *arg);
|
|
void *RSA_get_ex_data(const RSA *r, int idx);
|
|
|
|
void RSA_get0_key(const RSA *r, const BIGNUM **n, const BIGNUM **e,
|
|
const BIGNUM **d);
|
|
int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
|
|
void RSA_get0_crt_params(const RSA *r, const BIGNUM **dmp1, const BIGNUM **dmq1,
|
|
const BIGNUM **iqmp);
|
|
int RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp);
|
|
void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q);
|
|
int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q);
|
|
void RSA_clear_flags(RSA *r, int flags);
|
|
int RSA_test_flags(const RSA *r, int flags);
|
|
void RSA_set_flags(RSA *r, int flags);
|
|
|
|
RSA *RSAPublicKey_dup(RSA *rsa);
|
|
RSA *RSAPrivateKey_dup(RSA *rsa);
|
|
RSA_METHOD *RSA_meth_new(const char *name, int flags);
|
|
void RSA_meth_free(RSA_METHOD *meth);
|
|
RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth);
|
|
int RSA_meth_set1_name(RSA_METHOD *meth, const char *name);
|
|
int RSA_meth_set_priv_enc(RSA_METHOD *meth, int (*priv_enc)(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding));
|
|
int RSA_meth_set_priv_dec(RSA_METHOD *meth, int (*priv_dec)(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding));
|
|
int (*RSA_meth_get_finish(const RSA_METHOD *meth))(RSA *rsa);
|
|
int RSA_meth_set_finish(RSA_METHOD *meth, int (*finish)(RSA *rsa));
|
|
int RSA_meth_set_pub_enc(RSA_METHOD *meth, int (*pub_enc)(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding));
|
|
int RSA_meth_set_pub_dec(RSA_METHOD *meth, int (*pub_dec)(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding));
|
|
int RSA_meth_set_mod_exp(RSA_METHOD *meth, int (*mod_exp)(BIGNUM *r0,
|
|
const BIGNUM *i, RSA *rsa, BN_CTX *ctx));
|
|
int RSA_meth_set_bn_mod_exp(RSA_METHOD *meth, int (*bn_mod_exp)(BIGNUM *r,
|
|
const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
|
|
BN_MONT_CTX *m_ctx));
|
|
int RSA_meth_set_init(RSA_METHOD *meth, int (*init)(RSA *rsa));
|
|
int RSA_meth_set_keygen(RSA_METHOD *meth, int (*keygen)(RSA *rsa, int bits,
|
|
BIGNUM *e, BN_GENCB *cb));
|
|
int RSA_meth_set_flags(RSA_METHOD *meth, int flags);
|
|
int RSA_meth_set0_app_data(RSA_METHOD *meth, void *app_data);
|
|
const char *RSA_meth_get0_name(const RSA_METHOD *);
|
|
int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth))(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
|
|
int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth))(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
|
|
int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth))(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
|
|
int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth))(int flen,
|
|
const unsigned char *from, unsigned char *to, RSA *rsa, int padding);
|
|
int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth))(BIGNUM *r0, const BIGNUM *i,
|
|
RSA *rsa, BN_CTX *ctx);
|
|
int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth))(BIGNUM *r,
|
|
const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
|
|
BN_MONT_CTX *m_ctx);
|
|
int (*RSA_meth_get_init(const RSA_METHOD *meth))(RSA *rsa);
|
|
int (*RSA_meth_get_keygen(const RSA_METHOD *meth))(RSA *rsa, int bits, BIGNUM *e,
|
|
BN_GENCB *cb);
|
|
int RSA_meth_get_flags(const RSA_METHOD *meth);
|
|
void *RSA_meth_get0_app_data(const RSA_METHOD *meth);
|
|
int (*RSA_meth_get_sign(const RSA_METHOD *meth))(int type,
|
|
const unsigned char *m, unsigned int m_length,
|
|
unsigned char *sigret, unsigned int *siglen,
|
|
const RSA *rsa);
|
|
int RSA_meth_set_sign(RSA_METHOD *rsa, int (*sign)(int type,
|
|
const unsigned char *m, unsigned int m_length, unsigned char *sigret,
|
|
unsigned int *siglen, const RSA *rsa));
|
|
int (*RSA_meth_get_verify(const RSA_METHOD *meth))(int dtype,
|
|
const unsigned char *m, unsigned int m_length, const unsigned char *sigbuf,
|
|
unsigned int siglen, const RSA *rsa);
|
|
int RSA_meth_set_verify(RSA_METHOD *rsa, int (*verify)(int dtype,
|
|
const unsigned char *m, unsigned int m_length, const unsigned char *sigbuf,
|
|
unsigned int siglen, const RSA *rsa));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_RSA_strings(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct dh_method
|
|
{
|
|
const char *name;
|
|
|
|
int (*generate_key)(DH *dh);
|
|
int (*compute_key)(unsigned char *key,const BIGNUM *pub_key,DH *dh);
|
|
int (*bn_mod_exp)(const DH *dh, BIGNUM *r, const BIGNUM *a,
|
|
const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
|
|
BN_MONT_CTX *m_ctx);
|
|
|
|
int (*init)(DH *dh);
|
|
int (*finish)(DH *dh);
|
|
int flags;
|
|
char *app_data;
|
|
|
|
int (*generate_params)(DH *dh, int prime_len, int generator, BN_GENCB *cb);
|
|
};
|
|
|
|
struct dh_st
|
|
{
|
|
|
|
|
|
int pad;
|
|
int version;
|
|
BIGNUM *p;
|
|
BIGNUM *g;
|
|
long length;
|
|
BIGNUM *pub_key;
|
|
BIGNUM *priv_key;
|
|
|
|
int flags;
|
|
BN_MONT_CTX *method_mont_p;
|
|
|
|
BIGNUM *q;
|
|
BIGNUM *j;
|
|
unsigned char *seed;
|
|
int seedlen;
|
|
BIGNUM *counter;
|
|
|
|
int references;
|
|
CRYPTO_EX_DATA ex_data;
|
|
const DH_METHOD *meth;
|
|
ENGINE *engine;
|
|
};
|
|
DH *d2i_DHparams_bio(BIO *bp, DH **a);
|
|
int i2d_DHparams_bio(BIO *bp, DH *a);
|
|
DH *d2i_DHparams_fp(FILE *fp, DH **a);
|
|
int i2d_DHparams_fp(FILE *fp, DH *a);
|
|
|
|
DH *DHparams_dup(DH *);
|
|
|
|
const DH_METHOD *DH_OpenSSL(void);
|
|
|
|
void DH_set_default_method(const DH_METHOD *meth);
|
|
const DH_METHOD *DH_get_default_method(void);
|
|
int DH_set_method(DH *dh, const DH_METHOD *meth);
|
|
DH *DH_new_method(ENGINE *engine);
|
|
|
|
DH * DH_new(void);
|
|
void DH_free(DH *dh);
|
|
int DH_up_ref(DH *dh);
|
|
int DH_size(const DH *dh);
|
|
int DH_bits(const DH *dh);
|
|
int DH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int DH_set_ex_data(DH *d, int idx, void *arg);
|
|
void *DH_get_ex_data(DH *d, int idx);
|
|
|
|
ENGINE *DH_get0_engine(DH *d);
|
|
void DH_get0_pqg(const DH *dh, const BIGNUM **p, const BIGNUM **q,
|
|
const BIGNUM **g);
|
|
int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g);
|
|
void DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key);
|
|
int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key);
|
|
void DH_clear_flags(DH *dh, int flags);
|
|
int DH_test_flags(const DH *dh, int flags);
|
|
void DH_set_flags(DH *dh, int flags);
|
|
int DH_set_length(DH *dh, long length);
|
|
|
|
|
|
|
|
DH * DH_generate_parameters(int prime_len,int generator,
|
|
void (*callback)(int,int,void *),void *cb_arg);
|
|
|
|
|
|
|
|
int DH_generate_parameters_ex(DH *dh, int prime_len,int generator, BN_GENCB *cb);
|
|
|
|
int DH_check(const DH *dh,int *codes);
|
|
int DH_check_pub_key(const DH *dh,const BIGNUM *pub_key, int *codes);
|
|
int DH_generate_key(DH *dh);
|
|
int DH_compute_key(unsigned char *key,const BIGNUM *pub_key,DH *dh);
|
|
DH * d2i_DHparams(DH **a,const unsigned char **pp, long length);
|
|
int i2d_DHparams(const DH *a,unsigned char **pp);
|
|
int DHparams_print_fp(FILE *fp, const DH *x);
|
|
|
|
int DHparams_print(BIO *bp, const DH *x);
|
|
void ERR_load_DH_strings(void);
|
|
typedef struct DSA_SIG_st
|
|
{
|
|
BIGNUM *r;
|
|
BIGNUM *s;
|
|
} DSA_SIG;
|
|
|
|
struct dsa_method
|
|
{
|
|
const char *name;
|
|
DSA_SIG * (*dsa_do_sign)(const unsigned char *dgst, int dlen, DSA *dsa);
|
|
int (*dsa_sign_setup)(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp,
|
|
BIGNUM **rp);
|
|
int (*dsa_do_verify)(const unsigned char *dgst, int dgst_len,
|
|
DSA_SIG *sig, DSA *dsa);
|
|
int (*dsa_mod_exp)(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1,
|
|
BIGNUM *a2, BIGNUM *p2, BIGNUM *m, BN_CTX *ctx,
|
|
BN_MONT_CTX *in_mont);
|
|
int (*bn_mod_exp)(DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p,
|
|
const BIGNUM *m, BN_CTX *ctx,
|
|
BN_MONT_CTX *m_ctx);
|
|
int (*init)(DSA *dsa);
|
|
int (*finish)(DSA *dsa);
|
|
int flags;
|
|
char *app_data;
|
|
|
|
int (*dsa_paramgen)(DSA *dsa, int bits,
|
|
const unsigned char *seed, int seed_len,
|
|
int *counter_ret, unsigned long *h_ret,
|
|
BN_GENCB *cb);
|
|
|
|
int (*dsa_keygen)(DSA *dsa);
|
|
};
|
|
|
|
struct dsa_st
|
|
{
|
|
|
|
|
|
int pad;
|
|
long version;
|
|
int write_params;
|
|
BIGNUM *p;
|
|
BIGNUM *q;
|
|
BIGNUM *g;
|
|
|
|
BIGNUM *pub_key;
|
|
BIGNUM *priv_key;
|
|
|
|
BIGNUM *kinv;
|
|
BIGNUM *r;
|
|
|
|
int flags;
|
|
|
|
BN_MONT_CTX *method_mont_p;
|
|
int references;
|
|
CRYPTO_EX_DATA ex_data;
|
|
const DSA_METHOD *meth;
|
|
|
|
ENGINE *engine;
|
|
};
|
|
|
|
DSA *d2i_DSAparams_bio(BIO *bp, DSA **a);
|
|
int i2d_DSAparams_bio(BIO *bp, DSA *a);
|
|
DSA *d2i_DSAparams_fp(FILE *fp, DSA **a);
|
|
int i2d_DSAparams_fp(FILE *fp, DSA *a);
|
|
|
|
DSA *DSAparams_dup(DSA *x);
|
|
DSA_SIG * DSA_SIG_new(void);
|
|
void DSA_SIG_free(DSA_SIG *a);
|
|
int i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp);
|
|
DSA_SIG * d2i_DSA_SIG(DSA_SIG **v, const unsigned char **pp, long length);
|
|
void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
|
|
int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s);
|
|
|
|
DSA_SIG * DSA_do_sign(const unsigned char *dgst,int dlen,DSA *dsa);
|
|
int DSA_do_verify(const unsigned char *dgst,int dgst_len,
|
|
DSA_SIG *sig,DSA *dsa);
|
|
|
|
const DSA_METHOD *DSA_OpenSSL(void);
|
|
|
|
void DSA_set_default_method(const DSA_METHOD *);
|
|
const DSA_METHOD *DSA_get_default_method(void);
|
|
int DSA_set_method(DSA *dsa, const DSA_METHOD *);
|
|
|
|
DSA * DSA_new(void);
|
|
DSA * DSA_new_method(ENGINE *engine);
|
|
void DSA_free(DSA *r);
|
|
|
|
int DSA_up_ref(DSA *r);
|
|
int DSA_size(const DSA *);
|
|
|
|
int DSA_sign_setup( DSA *dsa,BN_CTX *ctx_in,BIGNUM **kinvp,BIGNUM **rp);
|
|
int DSA_sign(int type,const unsigned char *dgst,int dlen,
|
|
unsigned char *sig, unsigned int *siglen, DSA *dsa);
|
|
int DSA_verify(int type,const unsigned char *dgst,int dgst_len,
|
|
const unsigned char *sigbuf, int siglen, DSA *dsa);
|
|
int DSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int DSA_set_ex_data(DSA *d, int idx, void *arg);
|
|
void *DSA_get_ex_data(DSA *d, int idx);
|
|
|
|
DSA *d2i_DSAPublicKey(DSA **a, const unsigned char **pp, long length);
|
|
int i2d_DSAPublicKey(const DSA *a, unsigned char **pp);
|
|
extern const ASN1_ITEM DSAPublicKey_it;
|
|
|
|
DSA *d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length);
|
|
int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp);
|
|
extern const ASN1_ITEM DSAPrivateKey_it;
|
|
|
|
DSA *d2i_DSAparams(DSA **a, const unsigned char **pp, long length);
|
|
int i2d_DSAparams(const DSA *a,unsigned char **pp);
|
|
extern const ASN1_ITEM DSAparams_it;
|
|
|
|
|
|
|
|
DSA * DSA_generate_parameters(int bits,
|
|
unsigned char *seed,int seed_len,
|
|
int *counter_ret, unsigned long *h_ret,void
|
|
(*callback)(int, int, void *),void *cb_arg);
|
|
|
|
|
|
|
|
int DSA_generate_parameters_ex(DSA *dsa, int bits,
|
|
const unsigned char *seed,int seed_len,
|
|
int *counter_ret, unsigned long *h_ret, BN_GENCB *cb);
|
|
|
|
int DSA_generate_key(DSA *a);
|
|
|
|
|
|
int DSAparams_print(BIO *bp, const DSA *x);
|
|
int DSA_print(BIO *bp, const DSA *x, int off);
|
|
|
|
int DSAparams_print_fp(FILE *fp, const DSA *x);
|
|
int DSA_print_fp(FILE *bp, const DSA *x, int off);
|
|
DH *DSA_dup_DH(const DSA *r);
|
|
|
|
|
|
void DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q,
|
|
const BIGNUM **g);
|
|
int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g);
|
|
void DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key);
|
|
int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key);
|
|
void DSA_clear_flags(DSA *d, int flags);
|
|
int DSA_test_flags(const DSA *d, int flags);
|
|
void DSA_set_flags(DSA *d, int flags);
|
|
ENGINE *DSA_get0_engine(DSA *d);
|
|
|
|
DSA_METHOD *DSA_meth_new(const char *name, int flags);
|
|
void DSA_meth_free(DSA_METHOD *meth);
|
|
DSA_METHOD *DSA_meth_dup(const DSA_METHOD *meth);
|
|
int DSA_meth_set_sign(DSA_METHOD *meth,
|
|
DSA_SIG *(*sign)(const unsigned char *, int, DSA *));
|
|
int DSA_meth_set_finish(DSA_METHOD *meth, int (*finish)(DSA *));
|
|
void ERR_load_DSA_strings(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct SHAstate_st
|
|
{
|
|
unsigned int h0,h1,h2,h3,h4;
|
|
unsigned int Nl,Nh;
|
|
unsigned int data[16];
|
|
unsigned int num;
|
|
} SHA_CTX;
|
|
|
|
|
|
int SHA1_Init(SHA_CTX *c);
|
|
int SHA1_Update(SHA_CTX *c, const void *data, size_t len)
|
|
__attribute__ (());
|
|
int SHA1_Final(unsigned char *md, SHA_CTX *c);
|
|
unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md)
|
|
__attribute__ (());
|
|
void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
|
|
typedef struct SHA256state_st
|
|
{
|
|
unsigned int h[8];
|
|
unsigned int Nl,Nh;
|
|
unsigned int data[16];
|
|
unsigned int num,md_len;
|
|
} SHA256_CTX;
|
|
|
|
|
|
int SHA224_Init(SHA256_CTX *c);
|
|
int SHA224_Update(SHA256_CTX *c, const void *data, size_t len)
|
|
__attribute__ (());
|
|
int SHA224_Final(unsigned char *md, SHA256_CTX *c);
|
|
unsigned char *SHA224(const unsigned char *d, size_t n,unsigned char *md)
|
|
__attribute__ (());
|
|
int SHA256_Init(SHA256_CTX *c);
|
|
int SHA256_Update(SHA256_CTX *c, const void *data, size_t len)
|
|
__attribute__ (());
|
|
int SHA256_Final(unsigned char *md, SHA256_CTX *c);
|
|
unsigned char *SHA256(const unsigned char *d, size_t n,unsigned char *md)
|
|
__attribute__ (());
|
|
void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
|
|
typedef struct SHA512state_st
|
|
{
|
|
unsigned long h[8];
|
|
unsigned long Nl,Nh;
|
|
union {
|
|
unsigned long d[16];
|
|
unsigned char p[(16*8)];
|
|
} u;
|
|
unsigned int num,md_len;
|
|
} SHA512_CTX;
|
|
|
|
|
|
|
|
int SHA384_Init(SHA512_CTX *c);
|
|
int SHA384_Update(SHA512_CTX *c, const void *data, size_t len)
|
|
__attribute__ (());
|
|
int SHA384_Final(unsigned char *md, SHA512_CTX *c);
|
|
unsigned char *SHA384(const unsigned char *d, size_t n,unsigned char *md)
|
|
__attribute__ (());
|
|
int SHA512_Init(SHA512_CTX *c);
|
|
int SHA512_Update(SHA512_CTX *c, const void *data, size_t len)
|
|
__attribute__ (());
|
|
int SHA512_Final(unsigned char *md, SHA512_CTX *c);
|
|
unsigned char *SHA512(const unsigned char *d, size_t n,unsigned char *md)
|
|
__attribute__ (());
|
|
void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
|
|
typedef struct X509_objects_st
|
|
{
|
|
int nid;
|
|
int (*a2i)(void);
|
|
int (*i2a)(void);
|
|
} X509_OBJECTS;
|
|
|
|
struct X509_algor_st
|
|
{
|
|
ASN1_OBJECT *algorithm;
|
|
ASN1_TYPE *parameter;
|
|
} ;
|
|
|
|
|
|
typedef struct stack_st_X509_ALGOR X509_ALGORS;
|
|
|
|
typedef struct X509_val_st
|
|
{
|
|
ASN1_TIME *notBefore;
|
|
ASN1_TIME *notAfter;
|
|
} X509_VAL;
|
|
|
|
struct X509_pubkey_st
|
|
{
|
|
X509_ALGOR *algor;
|
|
ASN1_BIT_STRING *public_key;
|
|
EVP_PKEY *pkey;
|
|
};
|
|
|
|
typedef struct X509_sig_st
|
|
{
|
|
X509_ALGOR *algor;
|
|
ASN1_OCTET_STRING *digest;
|
|
} X509_SIG;
|
|
|
|
typedef struct X509_name_entry_st
|
|
{
|
|
ASN1_OBJECT *object;
|
|
ASN1_STRING *value;
|
|
int set;
|
|
int size;
|
|
} X509_NAME_ENTRY;
|
|
|
|
struct stack_st_X509_NAME_ENTRY { _STACK stack; };
|
|
|
|
|
|
struct X509_name_st
|
|
{
|
|
struct stack_st_X509_NAME_ENTRY *entries;
|
|
int modified;
|
|
|
|
BUF_MEM *bytes;
|
|
|
|
|
|
|
|
|
|
unsigned char *canon_enc;
|
|
int canon_enclen;
|
|
} ;
|
|
|
|
struct stack_st_X509_NAME { _STACK stack; };
|
|
|
|
|
|
|
|
typedef struct X509_extension_st
|
|
{
|
|
ASN1_OBJECT *object;
|
|
ASN1_BOOLEAN critical;
|
|
ASN1_OCTET_STRING *value;
|
|
} X509_EXTENSION;
|
|
|
|
typedef struct stack_st_X509_EXTENSION X509_EXTENSIONS;
|
|
|
|
struct stack_st_X509_EXTENSION { _STACK stack; };
|
|
|
|
|
|
typedef struct x509_attributes_st
|
|
{
|
|
ASN1_OBJECT *object;
|
|
int single;
|
|
union {
|
|
char *ptr;
|
|
struct stack_st_ASN1_TYPE *set;
|
|
ASN1_TYPE *single;
|
|
} value;
|
|
} X509_ATTRIBUTE;
|
|
|
|
struct stack_st_X509_ATTRIBUTE { _STACK stack; };
|
|
|
|
|
|
typedef struct X509_req_info_st
|
|
{
|
|
ASN1_ENCODING enc;
|
|
ASN1_INTEGER *version;
|
|
X509_NAME *subject;
|
|
X509_PUBKEY *pubkey;
|
|
|
|
struct stack_st_X509_ATTRIBUTE *attributes;
|
|
} X509_REQ_INFO;
|
|
|
|
typedef struct X509_req_st
|
|
{
|
|
X509_REQ_INFO *req_info;
|
|
X509_ALGOR *sig_alg;
|
|
ASN1_BIT_STRING *signature;
|
|
int references;
|
|
} X509_REQ;
|
|
|
|
typedef struct x509_cinf_st
|
|
{
|
|
ASN1_INTEGER *version;
|
|
ASN1_INTEGER *serialNumber;
|
|
X509_ALGOR *signature;
|
|
X509_NAME *issuer;
|
|
X509_VAL *validity;
|
|
X509_NAME *subject;
|
|
X509_PUBKEY *key;
|
|
ASN1_BIT_STRING *issuerUID;
|
|
ASN1_BIT_STRING *subjectUID;
|
|
struct stack_st_X509_EXTENSION *extensions;
|
|
ASN1_ENCODING enc;
|
|
} X509_CINF;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct x509_cert_aux_st
|
|
{
|
|
struct stack_st_ASN1_OBJECT *trust;
|
|
struct stack_st_ASN1_OBJECT *reject;
|
|
ASN1_UTF8STRING *alias;
|
|
ASN1_OCTET_STRING *keyid;
|
|
struct stack_st_X509_ALGOR *other;
|
|
} X509_CERT_AUX;
|
|
|
|
struct x509_st
|
|
{
|
|
X509_CINF *cert_info;
|
|
X509_ALGOR *sig_alg;
|
|
ASN1_BIT_STRING *signature;
|
|
int valid;
|
|
int references;
|
|
char *name;
|
|
CRYPTO_EX_DATA ex_data;
|
|
|
|
long ex_pathlen;
|
|
long ex_pcpathlen;
|
|
unsigned long ex_flags;
|
|
unsigned long ex_kusage;
|
|
unsigned long ex_xkusage;
|
|
unsigned long ex_nscert;
|
|
ASN1_OCTET_STRING *skid;
|
|
AUTHORITY_KEYID *akid;
|
|
X509_POLICY_CACHE *policy_cache;
|
|
struct stack_st_DIST_POINT *crldp;
|
|
struct stack_st_GENERAL_NAME *altname;
|
|
NAME_CONSTRAINTS *nc;
|
|
|
|
unsigned char sha1_hash[20];
|
|
|
|
X509_CERT_AUX *aux;
|
|
} ;
|
|
|
|
struct stack_st_X509 { _STACK stack; };
|
|
|
|
|
|
|
|
typedef struct x509_trust_st {
|
|
int trust;
|
|
int flags;
|
|
int (*check_trust)(struct x509_trust_st *, X509 *, int);
|
|
char *name;
|
|
int arg1;
|
|
void *arg2;
|
|
} X509_TRUST;
|
|
|
|
struct stack_st_X509_TRUST { _STACK stack; };
|
|
|
|
typedef struct x509_cert_pair_st {
|
|
X509 *forward;
|
|
X509 *reverse;
|
|
} X509_CERT_PAIR;
|
|
struct x509_revoked_st
|
|
{
|
|
ASN1_INTEGER *serialNumber;
|
|
ASN1_TIME *revocationDate;
|
|
struct stack_st_X509_EXTENSION *extensions;
|
|
|
|
struct stack_st_GENERAL_NAME *issuer;
|
|
|
|
int reason;
|
|
int sequence;
|
|
};
|
|
|
|
struct stack_st_X509_REVOKED { _STACK stack; };
|
|
|
|
typedef struct X509_crl_info_st
|
|
{
|
|
ASN1_INTEGER *version;
|
|
X509_ALGOR *sig_alg;
|
|
X509_NAME *issuer;
|
|
ASN1_TIME *lastUpdate;
|
|
ASN1_TIME *nextUpdate;
|
|
struct stack_st_X509_REVOKED *revoked;
|
|
struct stack_st_X509_EXTENSION *extensions;
|
|
ASN1_ENCODING enc;
|
|
} X509_CRL_INFO;
|
|
|
|
struct X509_crl_st
|
|
{
|
|
|
|
X509_CRL_INFO *crl;
|
|
X509_ALGOR *sig_alg;
|
|
ASN1_BIT_STRING *signature;
|
|
int references;
|
|
int flags;
|
|
|
|
AUTHORITY_KEYID *akid;
|
|
ISSUING_DIST_POINT *idp;
|
|
|
|
int idp_flags;
|
|
int idp_reasons;
|
|
|
|
ASN1_INTEGER *crl_number;
|
|
ASN1_INTEGER *base_crl_number;
|
|
|
|
unsigned char sha1_hash[20];
|
|
|
|
struct stack_st_GENERAL_NAMES *issuers;
|
|
const X509_CRL_METHOD *meth;
|
|
void *meth_data;
|
|
} ;
|
|
|
|
struct stack_st_X509_CRL { _STACK stack; };
|
|
|
|
typedef struct private_key_st
|
|
{
|
|
int version;
|
|
|
|
X509_ALGOR *enc_algor;
|
|
ASN1_OCTET_STRING *enc_pkey;
|
|
|
|
|
|
EVP_PKEY *dec_pkey;
|
|
|
|
|
|
int key_length;
|
|
char *key_data;
|
|
int key_free;
|
|
|
|
|
|
EVP_CIPHER_INFO cipher;
|
|
|
|
int references;
|
|
} X509_PKEY;
|
|
|
|
|
|
typedef struct X509_info_st
|
|
{
|
|
X509 *x509;
|
|
X509_CRL *crl;
|
|
X509_PKEY *x_pkey;
|
|
|
|
EVP_CIPHER_INFO enc_cipher;
|
|
int enc_len;
|
|
char *enc_data;
|
|
|
|
int references;
|
|
} X509_INFO;
|
|
|
|
struct stack_st_X509_INFO { _STACK stack; };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct Netscape_spkac_st
|
|
{
|
|
X509_PUBKEY *pubkey;
|
|
ASN1_IA5STRING *challenge;
|
|
} NETSCAPE_SPKAC;
|
|
|
|
typedef struct Netscape_spki_st
|
|
{
|
|
NETSCAPE_SPKAC *spkac;
|
|
X509_ALGOR *sig_algor;
|
|
ASN1_BIT_STRING *signature;
|
|
} NETSCAPE_SPKI;
|
|
|
|
|
|
typedef struct Netscape_certificate_sequence
|
|
{
|
|
ASN1_OBJECT *type;
|
|
struct stack_st_X509 *certs;
|
|
} NETSCAPE_CERT_SEQUENCE;
|
|
typedef struct PBEPARAM_st {
|
|
ASN1_OCTET_STRING *salt;
|
|
ASN1_INTEGER *iter;
|
|
} PBEPARAM;
|
|
|
|
|
|
|
|
typedef struct PBE2PARAM_st {
|
|
X509_ALGOR *keyfunc;
|
|
X509_ALGOR *encryption;
|
|
} PBE2PARAM;
|
|
|
|
typedef struct PBKDF2PARAM_st {
|
|
ASN1_TYPE *salt;
|
|
ASN1_INTEGER *iter;
|
|
ASN1_INTEGER *keylength;
|
|
X509_ALGOR *prf;
|
|
} PBKDF2PARAM;
|
|
|
|
|
|
|
|
|
|
struct pkcs8_priv_key_info_st {
|
|
ASN1_INTEGER *version;
|
|
X509_ALGOR *pkeyalg;
|
|
ASN1_OCTET_STRING *pkey;
|
|
struct stack_st_X509_ATTRIBUTE *attributes;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct x509_file_st
|
|
{
|
|
int num_paths;
|
|
int num_alloced;
|
|
char **paths;
|
|
int *path_type;
|
|
} X509_CERT_FILE_CTX;
|
|
typedef struct x509_object_st
|
|
{
|
|
|
|
int type;
|
|
union {
|
|
char *ptr;
|
|
X509 *x509;
|
|
X509_CRL *crl;
|
|
EVP_PKEY *pkey;
|
|
} data;
|
|
} X509_OBJECT;
|
|
|
|
typedef struct x509_lookup_st X509_LOOKUP;
|
|
|
|
struct stack_st_X509_LOOKUP { _STACK stack; };
|
|
struct stack_st_X509_OBJECT { _STACK stack; };
|
|
|
|
|
|
typedef struct x509_lookup_method_st
|
|
{
|
|
const char *name;
|
|
int (*new_item)(X509_LOOKUP *ctx);
|
|
void (*free)(X509_LOOKUP *ctx);
|
|
int (*init)(X509_LOOKUP *ctx);
|
|
int (*shutdown)(X509_LOOKUP *ctx);
|
|
int (*ctrl)(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
|
|
char **ret);
|
|
int (*get_by_subject)(X509_LOOKUP *ctx, int type, X509_NAME *name,
|
|
X509_OBJECT *ret);
|
|
int (*get_by_issuer_serial)(X509_LOOKUP *ctx, int type, X509_NAME *name,
|
|
ASN1_INTEGER *serial,X509_OBJECT *ret);
|
|
int (*get_by_fingerprint)(X509_LOOKUP *ctx, int type,
|
|
const unsigned char *bytes, int len, X509_OBJECT *ret);
|
|
int (*get_by_alias)(X509_LOOKUP *ctx, int type, const char *str,
|
|
int len, X509_OBJECT *ret);
|
|
} X509_LOOKUP_METHOD;
|
|
|
|
typedef struct X509_VERIFY_PARAM_ID_st X509_VERIFY_PARAM_ID;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct X509_VERIFY_PARAM_st
|
|
{
|
|
char *name;
|
|
time_t check_time;
|
|
unsigned long inh_flags;
|
|
unsigned long flags;
|
|
int purpose;
|
|
int trust;
|
|
int depth;
|
|
struct stack_st_ASN1_OBJECT *policies;
|
|
X509_VERIFY_PARAM_ID *id;
|
|
} X509_VERIFY_PARAM;
|
|
|
|
struct stack_st_X509_VERIFY_PARAM { _STACK stack; };
|
|
|
|
|
|
|
|
|
|
struct x509_store_st
|
|
{
|
|
|
|
int cache;
|
|
struct stack_st_X509_OBJECT *objs;
|
|
|
|
|
|
struct stack_st_X509_LOOKUP *get_cert_methods;
|
|
|
|
X509_VERIFY_PARAM *param;
|
|
|
|
|
|
int (*verify)(X509_STORE_CTX *ctx);
|
|
int (*verify_cb)(int ok,X509_STORE_CTX *ctx);
|
|
int (*get_issuer)(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
|
|
int (*check_issued)(X509_STORE_CTX *ctx, X509 *x, X509 *issuer);
|
|
int (*check_revocation)(X509_STORE_CTX *ctx);
|
|
int (*get_crl)(X509_STORE_CTX *ctx, X509_CRL **crl, X509 *x);
|
|
int (*check_crl)(X509_STORE_CTX *ctx, X509_CRL *crl);
|
|
int (*cert_crl)(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x);
|
|
struct stack_st_X509 * (*lookup_certs)(X509_STORE_CTX *ctx, X509_NAME *nm);
|
|
struct stack_st_X509_CRL * (*lookup_crls)(X509_STORE_CTX *ctx, X509_NAME *nm);
|
|
int (*cleanup)(X509_STORE_CTX *ctx);
|
|
|
|
CRYPTO_EX_DATA ex_data;
|
|
int references;
|
|
} ;
|
|
|
|
int X509_STORE_set_depth(X509_STORE *store, int depth);
|
|
|
|
|
|
|
|
|
|
|
|
struct x509_lookup_st
|
|
{
|
|
int init;
|
|
int skip;
|
|
X509_LOOKUP_METHOD *method;
|
|
char *method_data;
|
|
|
|
X509_STORE *store_ctx;
|
|
} ;
|
|
|
|
|
|
|
|
|
|
struct x509_store_ctx_st
|
|
{
|
|
X509_STORE *ctx;
|
|
int current_method;
|
|
|
|
|
|
X509 *cert;
|
|
struct stack_st_X509 *untrusted;
|
|
struct stack_st_X509_CRL *crls;
|
|
|
|
X509_VERIFY_PARAM *param;
|
|
void *other_ctx;
|
|
|
|
|
|
int (*verify)(X509_STORE_CTX *ctx);
|
|
int (*verify_cb)(int ok,X509_STORE_CTX *ctx);
|
|
int (*get_issuer)(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
|
|
int (*check_issued)(X509_STORE_CTX *ctx, X509 *x, X509 *issuer);
|
|
int (*check_revocation)(X509_STORE_CTX *ctx);
|
|
int (*get_crl)(X509_STORE_CTX *ctx, X509_CRL **crl, X509 *x);
|
|
int (*check_crl)(X509_STORE_CTX *ctx, X509_CRL *crl);
|
|
int (*cert_crl)(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x);
|
|
int (*check_policy)(X509_STORE_CTX *ctx);
|
|
struct stack_st_X509 * (*lookup_certs)(X509_STORE_CTX *ctx, X509_NAME *nm);
|
|
struct stack_st_X509_CRL * (*lookup_crls)(X509_STORE_CTX *ctx, X509_NAME *nm);
|
|
int (*cleanup)(X509_STORE_CTX *ctx);
|
|
|
|
|
|
int valid;
|
|
int last_untrusted;
|
|
struct stack_st_X509 *chain;
|
|
X509_POLICY_TREE *tree;
|
|
|
|
int explicit_policy;
|
|
|
|
|
|
int error_depth;
|
|
int error;
|
|
X509 *current_cert;
|
|
X509 *current_issuer;
|
|
X509_CRL *current_crl;
|
|
|
|
int current_crl_score;
|
|
unsigned int current_reasons;
|
|
|
|
X509_STORE_CTX *parent;
|
|
|
|
CRYPTO_EX_DATA ex_data;
|
|
} ;
|
|
|
|
void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth);
|
|
int X509_OBJECT_idx_by_subject(struct stack_st_X509_OBJECT *h, int type,
|
|
X509_NAME *name);
|
|
X509_OBJECT *X509_OBJECT_retrieve_by_subject(struct stack_st_X509_OBJECT *h,int type,X509_NAME *name);
|
|
X509_OBJECT *X509_OBJECT_retrieve_match(struct stack_st_X509_OBJECT *h, X509_OBJECT *x);
|
|
int X509_OBJECT_up_ref_count(X509_OBJECT *a);
|
|
int X509_OBJECT_get_type(const X509_OBJECT *a);
|
|
void X509_OBJECT_free_contents(X509_OBJECT *a);
|
|
X509 *X509_OBJECT_get0_X509(const X509_OBJECT *xo);
|
|
X509_CRL *X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo);
|
|
|
|
X509_STORE *X509_STORE_new(void);
|
|
void X509_STORE_free(X509_STORE *v);
|
|
int X509_STORE_up_ref(X509_STORE *x);
|
|
struct stack_st_X509* X509_STORE_get1_certs(X509_STORE_CTX *st, X509_NAME *nm);
|
|
struct stack_st_X509_CRL* X509_STORE_get1_crls(X509_STORE_CTX *st, X509_NAME *nm);
|
|
struct stack_st_X509_OBJECT *X509_STORE_get0_objects(X509_STORE *xs);
|
|
void *X509_STORE_get_ex_data(X509_STORE *xs, int idx);
|
|
int X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data);
|
|
|
|
|
|
|
|
|
|
|
|
int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags);
|
|
int X509_STORE_set_purpose(X509_STORE *ctx, int purpose);
|
|
int X509_STORE_set_trust(X509_STORE *ctx, int trust);
|
|
int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *pm);
|
|
X509_VERIFY_PARAM *X509_STORE_get0_param(X509_STORE *ctx);
|
|
|
|
void X509_STORE_set_verify_cb(X509_STORE *ctx,
|
|
int (*verify_cb)(int, X509_STORE_CTX *));
|
|
|
|
X509_STORE_CTX *X509_STORE_CTX_new(void);
|
|
|
|
int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
|
|
|
|
void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
|
|
int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store,
|
|
X509 *x509, struct stack_st_X509 *chain);
|
|
X509 *X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx);
|
|
struct stack_st_X509 *X509_STORE_CTX_get0_chain(X509_STORE_CTX *xs);
|
|
X509_STORE *X509_STORE_CTX_get0_store(X509_STORE_CTX *xs);
|
|
struct stack_st_X509 *X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx);
|
|
void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, struct stack_st_X509 *sk);
|
|
void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, struct stack_st_X509 *sk);
|
|
void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, struct stack_st_X509 *sk);
|
|
void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx);
|
|
|
|
X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m);
|
|
|
|
X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void);
|
|
X509_LOOKUP_METHOD *X509_LOOKUP_file(void);
|
|
X509_LOOKUP_METHOD *X509_LOOKUP_mem(void);
|
|
|
|
int X509_STORE_add_cert(X509_STORE *ctx, X509 *x);
|
|
int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x);
|
|
|
|
int X509_STORE_get_by_subject(X509_STORE_CTX *vs,int type,X509_NAME *name,
|
|
X509_OBJECT *ret);
|
|
|
|
int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc,
|
|
long argl, char **ret);
|
|
|
|
int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type);
|
|
int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type);
|
|
int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type);
|
|
|
|
|
|
X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method);
|
|
void X509_LOOKUP_free(X509_LOOKUP *ctx);
|
|
int X509_LOOKUP_init(X509_LOOKUP *ctx);
|
|
int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,
|
|
X509_OBJECT *ret);
|
|
int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name,
|
|
ASN1_INTEGER *serial, X509_OBJECT *ret);
|
|
int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type,
|
|
const unsigned char *bytes, int len, X509_OBJECT *ret);
|
|
int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, const char *str,
|
|
int len, X509_OBJECT *ret);
|
|
int X509_LOOKUP_shutdown(X509_LOOKUP *ctx);
|
|
|
|
int X509_STORE_load_locations (X509_STORE *ctx,
|
|
const char *file, const char *dir);
|
|
int X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len);
|
|
int X509_STORE_set_default_paths(X509_STORE *ctx);
|
|
|
|
int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx,int idx,void *data);
|
|
void * X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx,int idx);
|
|
int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx);
|
|
void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx,int s);
|
|
int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx);
|
|
X509 * X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx);
|
|
X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx);
|
|
X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx);
|
|
X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx);
|
|
struct stack_st_X509 *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx);
|
|
struct stack_st_X509 *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx);
|
|
void X509_STORE_CTX_set_cert(X509_STORE_CTX *c,X509 *x);
|
|
void X509_STORE_CTX_set_chain(X509_STORE_CTX *c,struct stack_st_X509 *sk);
|
|
void X509_STORE_CTX_set0_crls(X509_STORE_CTX *c,struct stack_st_X509_CRL *sk);
|
|
int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose);
|
|
int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust);
|
|
int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
|
|
int purpose, int trust);
|
|
void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags);
|
|
void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags,
|
|
time_t t);
|
|
void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
|
|
int (*verify_cb)(int, X509_STORE_CTX *));
|
|
|
|
X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx);
|
|
int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx);
|
|
|
|
X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx);
|
|
void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param);
|
|
int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name);
|
|
|
|
|
|
|
|
X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void);
|
|
void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param);
|
|
int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to,
|
|
const X509_VERIFY_PARAM *from);
|
|
int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
|
|
const X509_VERIFY_PARAM *from);
|
|
int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name);
|
|
int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags);
|
|
int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,
|
|
unsigned long flags);
|
|
unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param);
|
|
int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose);
|
|
int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust);
|
|
void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth);
|
|
void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);
|
|
int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,
|
|
ASN1_OBJECT *policy);
|
|
int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
|
|
struct stack_st_ASN1_OBJECT *policies);
|
|
int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);
|
|
int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param, const char *name,
|
|
size_t namelen);
|
|
int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param, const char *name,
|
|
size_t namelen);
|
|
void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
|
|
unsigned int flags);
|
|
char *X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param);
|
|
int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param, const char *email,
|
|
size_t emaillen);
|
|
int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip,
|
|
size_t iplen);
|
|
int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc);
|
|
const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param);
|
|
const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id);
|
|
int X509_VERIFY_PARAM_get_count(void);
|
|
|
|
int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param);
|
|
const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name);
|
|
void X509_VERIFY_PARAM_table_cleanup(void);
|
|
|
|
int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy,
|
|
struct stack_st_X509 *certs,
|
|
struct stack_st_ASN1_OBJECT *policy_oids,
|
|
unsigned int flags);
|
|
|
|
void X509_policy_tree_free(X509_POLICY_TREE *tree);
|
|
|
|
int X509_policy_tree_level_count(const X509_POLICY_TREE *tree);
|
|
X509_POLICY_LEVEL *
|
|
X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i);
|
|
|
|
struct stack_st_X509_POLICY_NODE *
|
|
X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree);
|
|
|
|
struct stack_st_X509_POLICY_NODE *
|
|
X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree);
|
|
|
|
int X509_policy_level_node_count(X509_POLICY_LEVEL *level);
|
|
|
|
X509_POLICY_NODE *X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i);
|
|
|
|
const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node);
|
|
|
|
struct stack_st_POLICYQUALINFO *
|
|
X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node);
|
|
const X509_POLICY_NODE *
|
|
X509_policy_node_get0_parent(const X509_POLICY_NODE *node);
|
|
typedef struct pkcs7_issuer_and_serial_st {
|
|
X509_NAME *issuer;
|
|
ASN1_INTEGER *serial;
|
|
} PKCS7_ISSUER_AND_SERIAL;
|
|
|
|
typedef struct pkcs7_signer_info_st {
|
|
ASN1_INTEGER *version;
|
|
PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
|
|
X509_ALGOR *digest_alg;
|
|
struct stack_st_X509_ATTRIBUTE *auth_attr;
|
|
X509_ALGOR *digest_enc_alg;
|
|
ASN1_OCTET_STRING *enc_digest;
|
|
struct stack_st_X509_ATTRIBUTE *unauth_attr;
|
|
|
|
|
|
EVP_PKEY *pkey;
|
|
} PKCS7_SIGNER_INFO;
|
|
|
|
struct stack_st_PKCS7_SIGNER_INFO { _STACK stack; };
|
|
|
|
typedef struct pkcs7_recip_info_st {
|
|
ASN1_INTEGER *version;
|
|
PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
|
|
X509_ALGOR *key_enc_algor;
|
|
ASN1_OCTET_STRING *enc_key;
|
|
X509 *cert;
|
|
} PKCS7_RECIP_INFO;
|
|
|
|
struct stack_st_PKCS7_RECIP_INFO { _STACK stack; };
|
|
|
|
typedef struct pkcs7_signed_st {
|
|
ASN1_INTEGER *version;
|
|
struct stack_st_X509_ALGOR *md_algs;
|
|
struct stack_st_X509 *cert;
|
|
struct stack_st_X509_CRL *crl;
|
|
struct stack_st_PKCS7_SIGNER_INFO *signer_info;
|
|
|
|
struct pkcs7_st *contents;
|
|
} PKCS7_SIGNED;
|
|
|
|
|
|
|
|
typedef struct pkcs7_enc_content_st {
|
|
ASN1_OBJECT *content_type;
|
|
X509_ALGOR *algorithm;
|
|
ASN1_OCTET_STRING *enc_data;
|
|
const EVP_CIPHER *cipher;
|
|
} PKCS7_ENC_CONTENT;
|
|
|
|
typedef struct pkcs7_enveloped_st {
|
|
ASN1_INTEGER *version;
|
|
struct stack_st_PKCS7_RECIP_INFO *recipientinfo;
|
|
PKCS7_ENC_CONTENT *enc_data;
|
|
} PKCS7_ENVELOPE;
|
|
|
|
typedef struct pkcs7_signedandenveloped_st {
|
|
ASN1_INTEGER *version;
|
|
struct stack_st_X509_ALGOR *md_algs;
|
|
struct stack_st_X509 *cert;
|
|
struct stack_st_X509_CRL *crl;
|
|
struct stack_st_PKCS7_SIGNER_INFO *signer_info;
|
|
|
|
PKCS7_ENC_CONTENT *enc_data;
|
|
struct stack_st_PKCS7_RECIP_INFO *recipientinfo;
|
|
} PKCS7_SIGN_ENVELOPE;
|
|
|
|
typedef struct pkcs7_digest_st {
|
|
ASN1_INTEGER *version;
|
|
X509_ALGOR *md;
|
|
struct pkcs7_st *contents;
|
|
ASN1_OCTET_STRING *digest;
|
|
} PKCS7_DIGEST;
|
|
|
|
typedef struct pkcs7_encrypted_st {
|
|
ASN1_INTEGER *version;
|
|
PKCS7_ENC_CONTENT *enc_data;
|
|
} PKCS7_ENCRYPT;
|
|
|
|
typedef struct pkcs7_st {
|
|
|
|
|
|
unsigned char *asn1;
|
|
long length;
|
|
|
|
|
|
|
|
|
|
int state;
|
|
|
|
int detached;
|
|
|
|
ASN1_OBJECT *type;
|
|
|
|
|
|
|
|
union {
|
|
char *ptr;
|
|
|
|
|
|
ASN1_OCTET_STRING *data;
|
|
|
|
|
|
PKCS7_SIGNED *sign;
|
|
|
|
|
|
PKCS7_ENVELOPE *enveloped;
|
|
|
|
|
|
PKCS7_SIGN_ENVELOPE *signed_and_enveloped;
|
|
|
|
|
|
PKCS7_DIGEST *digest;
|
|
|
|
|
|
PKCS7_ENCRYPT *encrypted;
|
|
|
|
|
|
ASN1_TYPE *other;
|
|
} d;
|
|
} PKCS7;
|
|
|
|
struct stack_st_PKCS7 { _STACK stack; };
|
|
|
|
PKCS7_ISSUER_AND_SERIAL *PKCS7_ISSUER_AND_SERIAL_new(void);
|
|
void PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a);
|
|
PKCS7_ISSUER_AND_SERIAL *d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_ISSUER_AND_SERIAL_it;
|
|
|
|
int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
|
|
const EVP_MD *type, unsigned char *md, unsigned int *len);
|
|
PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7);
|
|
int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7);
|
|
PKCS7 *PKCS7_dup(PKCS7 *p7);
|
|
PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7);
|
|
int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7);
|
|
int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
|
|
int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
|
|
|
|
PKCS7_SIGNER_INFO *PKCS7_SIGNER_INFO_new(void);
|
|
void PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a);
|
|
PKCS7_SIGNER_INFO *d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_SIGNER_INFO_it;
|
|
PKCS7_RECIP_INFO *PKCS7_RECIP_INFO_new(void);
|
|
void PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a);
|
|
PKCS7_RECIP_INFO *d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_RECIP_INFO_it;
|
|
PKCS7_SIGNED *PKCS7_SIGNED_new(void);
|
|
void PKCS7_SIGNED_free(PKCS7_SIGNED *a);
|
|
PKCS7_SIGNED *d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_SIGNED_it;
|
|
PKCS7_ENC_CONTENT *PKCS7_ENC_CONTENT_new(void);
|
|
void PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a);
|
|
PKCS7_ENC_CONTENT *d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_ENC_CONTENT_it;
|
|
PKCS7_ENVELOPE *PKCS7_ENVELOPE_new(void);
|
|
void PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a);
|
|
PKCS7_ENVELOPE *d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_ENVELOPE_it;
|
|
PKCS7_SIGN_ENVELOPE *PKCS7_SIGN_ENVELOPE_new(void);
|
|
void PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a);
|
|
PKCS7_SIGN_ENVELOPE *d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_SIGN_ENVELOPE_it;
|
|
PKCS7_DIGEST *PKCS7_DIGEST_new(void);
|
|
void PKCS7_DIGEST_free(PKCS7_DIGEST *a);
|
|
PKCS7_DIGEST *d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_DIGEST_it;
|
|
PKCS7_ENCRYPT *PKCS7_ENCRYPT_new(void);
|
|
void PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a);
|
|
PKCS7_ENCRYPT *d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_ENCRYPT_it;
|
|
PKCS7 *PKCS7_new(void);
|
|
void PKCS7_free(PKCS7 *a);
|
|
PKCS7 *d2i_PKCS7(PKCS7 **a, const unsigned char **in, long len);
|
|
int i2d_PKCS7(PKCS7 *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS7_it;
|
|
|
|
extern const ASN1_ITEM PKCS7_ATTR_SIGN_it;
|
|
extern const ASN1_ITEM PKCS7_ATTR_VERIFY_it;
|
|
|
|
int i2d_PKCS7_NDEF(PKCS7 *a, unsigned char **out);
|
|
int PKCS7_print_ctx(BIO *out, PKCS7 *x, int indent, const ASN1_PCTX *pctx);
|
|
|
|
long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg);
|
|
|
|
int PKCS7_set_type(PKCS7 *p7, int type);
|
|
int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other);
|
|
int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data);
|
|
int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
|
|
const EVP_MD *dgst);
|
|
int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si);
|
|
int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i);
|
|
int PKCS7_add_certificate(PKCS7 *p7, X509 *x509);
|
|
int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509);
|
|
int PKCS7_content_new(PKCS7 *p7, int nid);
|
|
int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx,
|
|
BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si);
|
|
int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
|
|
X509 *x509);
|
|
|
|
BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio);
|
|
int PKCS7_dataFinal(PKCS7 *p7, BIO *bio);
|
|
BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert);
|
|
|
|
|
|
PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509,
|
|
EVP_PKEY *pkey, const EVP_MD *dgst);
|
|
X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si);
|
|
int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md);
|
|
struct stack_st_PKCS7_SIGNER_INFO *PKCS7_get_signer_info(PKCS7 *p7);
|
|
|
|
PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509);
|
|
void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
|
|
X509_ALGOR **pdig, X509_ALGOR **psig);
|
|
void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc);
|
|
int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri);
|
|
int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509);
|
|
int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher);
|
|
int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
|
|
|
|
PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx);
|
|
ASN1_OCTET_STRING *PKCS7_digest_from_attributes(struct stack_st_X509_ATTRIBUTE *sk);
|
|
int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type,
|
|
void *data);
|
|
int PKCS7_add_attribute (PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
|
|
void *value);
|
|
ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid);
|
|
ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid);
|
|
int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
|
|
struct stack_st_X509_ATTRIBUTE *sk);
|
|
int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, struct stack_st_X509_ATTRIBUTE *sk);
|
|
|
|
|
|
PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, struct stack_st_X509 *certs,
|
|
BIO *data, int flags);
|
|
|
|
PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7,
|
|
X509 *signcert, EVP_PKEY *pkey, const EVP_MD *md,
|
|
int flags);
|
|
|
|
int PKCS7_final(PKCS7 *p7, BIO *data, int flags);
|
|
int PKCS7_verify(PKCS7 *p7, struct stack_st_X509 *certs, X509_STORE *store,
|
|
BIO *indata, BIO *out, int flags);
|
|
struct stack_st_X509 *PKCS7_get0_signers(PKCS7 *p7, struct stack_st_X509 *certs, int flags);
|
|
PKCS7 *PKCS7_encrypt(struct stack_st_X509 *certs, BIO *in, const EVP_CIPHER *cipher,
|
|
int flags);
|
|
int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags);
|
|
|
|
int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
|
|
struct stack_st_X509_ALGOR *cap);
|
|
struct stack_st_X509_ALGOR *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si);
|
|
int PKCS7_simple_smimecap(struct stack_st_X509_ALGOR *sk, int nid, int arg);
|
|
|
|
int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid);
|
|
int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t);
|
|
int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si,
|
|
const unsigned char *md, int mdlen);
|
|
|
|
int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags);
|
|
PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont);
|
|
|
|
BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_PKCS7_strings(void);
|
|
int X509_CRL_up_ref(X509_CRL *x);
|
|
int X509_CRL_get_signature_nid(const X509_CRL *crl);
|
|
|
|
const struct stack_st_X509_EXTENSION *X509_CRL_get0_extensions(const X509_CRL *crl);
|
|
long X509_CRL_get_version(const X509_CRL *crl);
|
|
const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl);
|
|
const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl);
|
|
ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl);
|
|
ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl);
|
|
X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl);
|
|
struct stack_st_X509_REVOKED *X509_CRL_get_REVOKED(X509_CRL *crl);
|
|
void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
|
|
const X509_ALGOR **palg);
|
|
|
|
int X509_REQ_get_signature_nid(const X509_REQ *req);
|
|
|
|
void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
|
|
const X509_ALGOR **palg);
|
|
|
|
void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);
|
|
X509_CRL_METHOD *X509_CRL_METHOD_new(
|
|
int (*crl_init)(X509_CRL *crl),
|
|
int (*crl_free)(X509_CRL *crl),
|
|
int (*crl_lookup)(X509_CRL *crl, X509_REVOKED **ret,
|
|
ASN1_INTEGER *ser, X509_NAME *issuer),
|
|
int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk));
|
|
void X509_CRL_METHOD_free(X509_CRL_METHOD *m);
|
|
|
|
void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);
|
|
void *X509_CRL_get_meth_data(X509_CRL *crl);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *X509_verify_cert_error_string(long n);
|
|
|
|
|
|
int X509_verify(X509 *a, EVP_PKEY *r);
|
|
|
|
int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
|
|
int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
|
|
int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);
|
|
|
|
NETSCAPE_SPKI * NETSCAPE_SPKI_b64_decode(const char *str, int len);
|
|
char * NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);
|
|
EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);
|
|
int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);
|
|
|
|
int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);
|
|
|
|
int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);
|
|
int X509_signature_print(BIO *bp, const X509_ALGOR *alg,
|
|
const ASN1_STRING *sig);
|
|
|
|
int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
|
|
int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);
|
|
int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
|
|
int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
|
|
int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
|
|
int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
|
|
int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
|
|
|
|
int X509_pubkey_digest(const X509 *data,const EVP_MD *type,
|
|
unsigned char *md, unsigned int *len);
|
|
int X509_digest(const X509 *data,const EVP_MD *type,
|
|
unsigned char *md, unsigned int *len);
|
|
int X509_CRL_digest(const X509_CRL *data,const EVP_MD *type,
|
|
unsigned char *md, unsigned int *len);
|
|
int X509_REQ_digest(const X509_REQ *data,const EVP_MD *type,
|
|
unsigned char *md, unsigned int *len);
|
|
int X509_NAME_digest(const X509_NAME *data,const EVP_MD *type,
|
|
unsigned char *md, unsigned int *len);
|
|
|
|
|
|
X509 *d2i_X509_fp(FILE *fp, X509 **x509);
|
|
int i2d_X509_fp(FILE *fp,X509 *x509);
|
|
X509_CRL *d2i_X509_CRL_fp(FILE *fp,X509_CRL **crl);
|
|
int i2d_X509_CRL_fp(FILE *fp,X509_CRL *crl);
|
|
X509_REQ *d2i_X509_REQ_fp(FILE *fp,X509_REQ **req);
|
|
int i2d_X509_REQ_fp(FILE *fp,X509_REQ *req);
|
|
|
|
RSA *d2i_RSAPrivateKey_fp(FILE *fp,RSA **rsa);
|
|
int i2d_RSAPrivateKey_fp(FILE *fp,RSA *rsa);
|
|
RSA *d2i_RSAPublicKey_fp(FILE *fp,RSA **rsa);
|
|
int i2d_RSAPublicKey_fp(FILE *fp,RSA *rsa);
|
|
RSA *d2i_RSA_PUBKEY_fp(FILE *fp,RSA **rsa);
|
|
int i2d_RSA_PUBKEY_fp(FILE *fp,RSA *rsa);
|
|
|
|
|
|
DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
|
|
int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa);
|
|
int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
|
|
|
|
|
|
EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
|
|
int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey);
|
|
EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
|
|
int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey);
|
|
|
|
X509_SIG *d2i_PKCS8_fp(FILE *fp,X509_SIG **p8);
|
|
int i2d_PKCS8_fp(FILE *fp,X509_SIG *p8);
|
|
PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
|
|
PKCS8_PRIV_KEY_INFO **p8inf);
|
|
int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,PKCS8_PRIV_KEY_INFO *p8inf);
|
|
int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key);
|
|
int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey);
|
|
EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
|
|
int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey);
|
|
EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
|
|
|
|
|
|
X509 *d2i_X509_bio(BIO *bp,X509 **x509);
|
|
int i2d_X509_bio(BIO *bp,X509 *x509);
|
|
X509_CRL *d2i_X509_CRL_bio(BIO *bp,X509_CRL **crl);
|
|
int i2d_X509_CRL_bio(BIO *bp,X509_CRL *crl);
|
|
X509_REQ *d2i_X509_REQ_bio(BIO *bp,X509_REQ **req);
|
|
int i2d_X509_REQ_bio(BIO *bp,X509_REQ *req);
|
|
|
|
RSA *d2i_RSAPrivateKey_bio(BIO *bp,RSA **rsa);
|
|
int i2d_RSAPrivateKey_bio(BIO *bp,RSA *rsa);
|
|
RSA *d2i_RSAPublicKey_bio(BIO *bp,RSA **rsa);
|
|
int i2d_RSAPublicKey_bio(BIO *bp,RSA *rsa);
|
|
RSA *d2i_RSA_PUBKEY_bio(BIO *bp,RSA **rsa);
|
|
int i2d_RSA_PUBKEY_bio(BIO *bp,RSA *rsa);
|
|
|
|
|
|
DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
|
|
int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa);
|
|
DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
|
|
int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
|
|
|
|
|
|
EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
|
|
int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey);
|
|
EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
|
|
int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey);
|
|
|
|
X509_SIG *d2i_PKCS8_bio(BIO *bp,X509_SIG **p8);
|
|
int i2d_PKCS8_bio(BIO *bp,X509_SIG *p8);
|
|
PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
|
|
PKCS8_PRIV_KEY_INFO **p8inf);
|
|
int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,PKCS8_PRIV_KEY_INFO *p8inf);
|
|
int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key);
|
|
int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey);
|
|
EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
|
|
int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey);
|
|
EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
|
|
|
|
|
|
X509 *X509_dup(X509 *x509);
|
|
X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa);
|
|
X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex);
|
|
X509_CRL *X509_CRL_dup(X509_CRL *crl);
|
|
X509_REQ *X509_REQ_dup(X509_REQ *req);
|
|
X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn);
|
|
int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval);
|
|
void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype, const void **ppval,
|
|
const X509_ALGOR *algor);
|
|
void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
|
|
int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
|
|
|
|
X509_NAME *X509_NAME_dup(X509_NAME *xn);
|
|
int X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, size_t *pderlen);
|
|
X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);
|
|
|
|
int X509_cmp_time(const ASN1_TIME *s, time_t *t);
|
|
int X509_cmp_current_time(const ASN1_TIME *s);
|
|
ASN1_TIME * X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
|
|
ASN1_TIME * X509_time_adj_ex(ASN1_TIME *s,
|
|
int offset_day, long offset_sec, time_t *t);
|
|
ASN1_TIME * X509_gmtime_adj(ASN1_TIME *s, long adj);
|
|
|
|
const char * X509_get_default_cert_area(void );
|
|
const char * X509_get_default_cert_dir(void );
|
|
const char * X509_get_default_cert_file(void );
|
|
const char * X509_get_default_cert_dir_env(void );
|
|
const char * X509_get_default_cert_file_env(void );
|
|
const char * X509_get_default_private_dir(void );
|
|
|
|
X509_REQ * X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
|
|
X509 * X509_REQ_to_X509(X509_REQ *r, int days,EVP_PKEY *pkey);
|
|
|
|
X509_ALGOR *X509_ALGOR_new(void);
|
|
void X509_ALGOR_free(X509_ALGOR *a);
|
|
X509_ALGOR *d2i_X509_ALGOR(X509_ALGOR **a, const unsigned char **in, long len);
|
|
int i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_ALGOR_it;
|
|
X509_ALGORS *d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len);
|
|
int i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_ALGORS_it;
|
|
X509_VAL *X509_VAL_new(void);
|
|
void X509_VAL_free(X509_VAL *a);
|
|
X509_VAL *d2i_X509_VAL(X509_VAL **a, const unsigned char **in, long len);
|
|
int i2d_X509_VAL(X509_VAL *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_VAL_it;
|
|
|
|
X509_PUBKEY *X509_PUBKEY_new(void);
|
|
void X509_PUBKEY_free(X509_PUBKEY *a);
|
|
X509_PUBKEY *d2i_X509_PUBKEY(X509_PUBKEY **a, const unsigned char **in, long len);
|
|
int i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_PUBKEY_it;
|
|
|
|
int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
|
|
EVP_PKEY * X509_PUBKEY_get(X509_PUBKEY *key);
|
|
EVP_PKEY * X509_PUBKEY_get0(X509_PUBKEY *key);
|
|
int X509_get_pubkey_parameters(EVP_PKEY *pkey,
|
|
struct stack_st_X509 *chain);
|
|
int i2d_PUBKEY(EVP_PKEY *a,unsigned char **pp);
|
|
EVP_PKEY * d2i_PUBKEY(EVP_PKEY **a,const unsigned char **pp,
|
|
long length);
|
|
|
|
int i2d_RSA_PUBKEY(RSA *a,unsigned char **pp);
|
|
RSA * d2i_RSA_PUBKEY(RSA **a,const unsigned char **pp,
|
|
long length);
|
|
|
|
|
|
int i2d_DSA_PUBKEY(DSA *a,unsigned char **pp);
|
|
DSA * d2i_DSA_PUBKEY(DSA **a,const unsigned char **pp,
|
|
long length);
|
|
|
|
|
|
int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp);
|
|
EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp,
|
|
long length);
|
|
|
|
|
|
X509_SIG *X509_SIG_new(void);
|
|
void X509_SIG_free(X509_SIG *a);
|
|
X509_SIG *d2i_X509_SIG(X509_SIG **a, const unsigned char **in, long len);
|
|
int i2d_X509_SIG(X509_SIG *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_SIG_it;
|
|
X509_REQ_INFO *X509_REQ_INFO_new(void);
|
|
void X509_REQ_INFO_free(X509_REQ_INFO *a);
|
|
X509_REQ_INFO *d2i_X509_REQ_INFO(X509_REQ_INFO **a, const unsigned char **in, long len);
|
|
int i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_REQ_INFO_it;
|
|
X509_REQ *X509_REQ_new(void);
|
|
void X509_REQ_free(X509_REQ *a);
|
|
X509_REQ *d2i_X509_REQ(X509_REQ **a, const unsigned char **in, long len);
|
|
int i2d_X509_REQ(X509_REQ *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_REQ_it;
|
|
|
|
X509_ATTRIBUTE *X509_ATTRIBUTE_new(void);
|
|
void X509_ATTRIBUTE_free(X509_ATTRIBUTE *a);
|
|
X509_ATTRIBUTE *d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **a, const unsigned char **in, long len);
|
|
int i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_ATTRIBUTE_it;
|
|
X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
|
|
|
|
X509_EXTENSION *X509_EXTENSION_new(void);
|
|
void X509_EXTENSION_free(X509_EXTENSION *a);
|
|
X509_EXTENSION *d2i_X509_EXTENSION(X509_EXTENSION **a, const unsigned char **in, long len);
|
|
int i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_EXTENSION_it;
|
|
X509_EXTENSIONS *d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len);
|
|
int i2d_X509_EXTENSIONS(X509_EXTENSIONS *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_EXTENSIONS_it;
|
|
|
|
X509_NAME_ENTRY *X509_NAME_ENTRY_new(void);
|
|
void X509_NAME_ENTRY_free(X509_NAME_ENTRY *a);
|
|
X509_NAME_ENTRY *d2i_X509_NAME_ENTRY(X509_NAME_ENTRY **a, const unsigned char **in, long len);
|
|
int i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_NAME_ENTRY_it;
|
|
|
|
X509_NAME *X509_NAME_new(void);
|
|
void X509_NAME_free(X509_NAME *a);
|
|
X509_NAME *d2i_X509_NAME(X509_NAME **a, const unsigned char **in, long len);
|
|
int i2d_X509_NAME(X509_NAME *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_NAME_it;
|
|
|
|
int X509_NAME_set(X509_NAME **xn, X509_NAME *name);
|
|
|
|
X509_CINF *X509_CINF_new(void);
|
|
void X509_CINF_free(X509_CINF *a);
|
|
X509_CINF *d2i_X509_CINF(X509_CINF **a, const unsigned char **in, long len);
|
|
int i2d_X509_CINF(X509_CINF *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_CINF_it;
|
|
|
|
X509 *X509_new(void);
|
|
void X509_free(X509 *a);
|
|
X509 *d2i_X509(X509 **a, const unsigned char **in, long len);
|
|
int i2d_X509(X509 *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_it;
|
|
X509_CERT_AUX *X509_CERT_AUX_new(void);
|
|
void X509_CERT_AUX_free(X509_CERT_AUX *a);
|
|
X509_CERT_AUX *d2i_X509_CERT_AUX(X509_CERT_AUX **a, const unsigned char **in, long len);
|
|
int i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_CERT_AUX_it;
|
|
|
|
X509_CERT_PAIR *X509_CERT_PAIR_new(void);
|
|
void X509_CERT_PAIR_free(X509_CERT_PAIR *a);
|
|
X509_CERT_PAIR *d2i_X509_CERT_PAIR(X509_CERT_PAIR **a, const unsigned char **in, long len);
|
|
int i2d_X509_CERT_PAIR(X509_CERT_PAIR *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_CERT_PAIR_it;
|
|
|
|
int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
|
|
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|
int X509_set_ex_data(X509 *r, int idx, void *arg);
|
|
void *X509_get_ex_data(X509 *r, int idx);
|
|
int i2d_X509_AUX(X509 *a,unsigned char **pp);
|
|
X509 * d2i_X509_AUX(X509 **a,const unsigned char **pp,long length);
|
|
void X509_get0_signature(const ASN1_BIT_STRING **psig,
|
|
const X509_ALGOR **palg, const X509 *x);
|
|
int X509_get_signature_nid(const X509 *x);
|
|
|
|
int X509_alias_set1(X509 *x, const unsigned char *name, int len);
|
|
int X509_keyid_set1(X509 *x, const unsigned char *id, int len);
|
|
unsigned char *X509_alias_get0(X509 *x, int *len);
|
|
unsigned char *X509_keyid_get0(X509 *x, int *len);
|
|
int (*X509_TRUST_set_default(int (*trust)(int , X509 *, int)))(int, X509 *, int);
|
|
int X509_TRUST_set(int *t, int trust);
|
|
int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj);
|
|
int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj);
|
|
void X509_trust_clear(X509 *x);
|
|
void X509_reject_clear(X509 *x);
|
|
|
|
X509_REVOKED *X509_REVOKED_new(void);
|
|
void X509_REVOKED_free(X509_REVOKED *a);
|
|
X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *a);
|
|
X509_REVOKED *d2i_X509_REVOKED(X509_REVOKED **a, const unsigned char **in, long len);
|
|
int i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_REVOKED_it;
|
|
|
|
X509_CRL_INFO *X509_CRL_INFO_new(void);
|
|
void X509_CRL_INFO_free(X509_CRL_INFO *a);
|
|
X509_CRL_INFO *d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len);
|
|
int i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_CRL_INFO_it;
|
|
|
|
X509_CRL *X509_CRL_new(void);
|
|
void X509_CRL_free(X509_CRL *a);
|
|
X509_CRL *d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len);
|
|
int i2d_X509_CRL(X509_CRL *a, unsigned char **out);
|
|
extern const ASN1_ITEM X509_CRL_it;
|
|
|
|
int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
|
|
int X509_CRL_get0_by_serial(X509_CRL *crl,
|
|
X509_REVOKED **ret, ASN1_INTEGER *serial);
|
|
int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
|
|
|
|
X509_PKEY * X509_PKEY_new(void );
|
|
void X509_PKEY_free(X509_PKEY *a);
|
|
|
|
NETSCAPE_SPKI *NETSCAPE_SPKI_new(void);
|
|
void NETSCAPE_SPKI_free(NETSCAPE_SPKI *a);
|
|
NETSCAPE_SPKI *d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **a, const unsigned char **in, long len);
|
|
int i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **out);
|
|
extern const ASN1_ITEM NETSCAPE_SPKI_it;
|
|
NETSCAPE_SPKAC *NETSCAPE_SPKAC_new(void);
|
|
void NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a);
|
|
NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **a, const unsigned char **in, long len);
|
|
int i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **out);
|
|
extern const ASN1_ITEM NETSCAPE_SPKAC_it;
|
|
NETSCAPE_CERT_SEQUENCE *NETSCAPE_CERT_SEQUENCE_new(void);
|
|
void NETSCAPE_CERT_SEQUENCE_free(NETSCAPE_CERT_SEQUENCE *a);
|
|
NETSCAPE_CERT_SEQUENCE *d2i_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE **a, const unsigned char **in, long len);
|
|
int i2d_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE *a, unsigned char **out);
|
|
extern const ASN1_ITEM NETSCAPE_CERT_SEQUENCE_it;
|
|
|
|
|
|
X509_INFO * X509_INFO_new(void);
|
|
void X509_INFO_free(X509_INFO *a);
|
|
char * X509_NAME_oneline(const X509_NAME *a, char *buf, int size);
|
|
|
|
int ASN1_item_digest(const ASN1_ITEM *it,const EVP_MD *type,void *data,
|
|
unsigned char *md,unsigned int *len);
|
|
|
|
int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1,
|
|
ASN1_BIT_STRING *signature,void *data,EVP_PKEY *pkey);
|
|
|
|
int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
|
|
ASN1_BIT_STRING *signature,
|
|
void *data, EVP_PKEY *pkey, const EVP_MD *type);
|
|
int ASN1_item_sign_ctx(const ASN1_ITEM *it,
|
|
X509_ALGOR *algor1, X509_ALGOR *algor2,
|
|
ASN1_BIT_STRING *signature, void *asn, EVP_MD_CTX *ctx);
|
|
|
|
|
|
const struct stack_st_X509_EXTENSION *X509_get0_extensions(const X509 *x);
|
|
const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x);
|
|
int X509_set_version(X509 *x, long version);
|
|
long X509_get_version(const X509 *x);
|
|
int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
|
|
ASN1_INTEGER * X509_get_serialNumber(X509 *x);
|
|
const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x);
|
|
int X509_set_issuer_name(X509 *x, X509_NAME *name);
|
|
X509_NAME * X509_get_issuer_name(const X509 *a);
|
|
int X509_set_subject_name(X509 *x, X509_NAME *name);
|
|
X509_NAME * X509_get_subject_name(const X509 *a);
|
|
int X509_set_notBefore(X509 *x, const ASN1_TIME *tm);
|
|
int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm);
|
|
int X509_set_notAfter(X509 *x, const ASN1_TIME *tm);
|
|
int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm);
|
|
const ASN1_TIME *X509_get0_notBefore(const X509 *x);
|
|
ASN1_TIME *X509_getm_notBefore(const X509 *x);
|
|
const ASN1_TIME *X509_get0_notAfter(const X509 *x);
|
|
ASN1_TIME *X509_getm_notAfter(const X509 *x);
|
|
int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
|
|
EVP_PKEY * X509_get_pubkey(X509 *x);
|
|
EVP_PKEY * X509_get0_pubkey(const X509 *x);
|
|
ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);
|
|
int X509_certificate_type(const X509 *x, const EVP_PKEY *pubkey);
|
|
int X509_get_signature_type(const X509 *x);
|
|
|
|
|
|
|
|
|
|
int X509_REQ_set_version(X509_REQ *x,long version);
|
|
long X509_REQ_get_version(const X509_REQ *x);
|
|
int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name);
|
|
X509_NAME *X509_REQ_get_subject_name(const X509_REQ *x);
|
|
int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
|
|
EVP_PKEY * X509_REQ_get_pubkey(X509_REQ *req);
|
|
int X509_REQ_extension_nid(int nid);
|
|
int * X509_REQ_get_extension_nids(void);
|
|
void X509_REQ_set_extension_nids(int *nids);
|
|
struct stack_st_X509_EXTENSION *X509_REQ_get_extensions(X509_REQ *req);
|
|
int X509_REQ_add_extensions_nid(X509_REQ *req, struct stack_st_X509_EXTENSION *exts,
|
|
int nid);
|
|
int X509_REQ_add_extensions(X509_REQ *req, struct stack_st_X509_EXTENSION *exts);
|
|
int X509_REQ_get_attr_count(const X509_REQ *req);
|
|
int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid,
|
|
int lastpos);
|
|
int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
|
|
int lastpos);
|
|
X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
|
|
X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
|
|
int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
|
|
int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
|
|
const ASN1_OBJECT *obj, int type,
|
|
const unsigned char *bytes, int len);
|
|
int X509_REQ_add1_attr_by_NID(X509_REQ *req,
|
|
int nid, int type,
|
|
const unsigned char *bytes, int len);
|
|
int X509_REQ_add1_attr_by_txt(X509_REQ *req,
|
|
const char *attrname, int type,
|
|
const unsigned char *bytes, int len);
|
|
|
|
int X509_CRL_set_version(X509_CRL *x, long version);
|
|
int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name);
|
|
int X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
|
|
int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
|
|
int X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
|
|
int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
|
|
int X509_CRL_sort(X509_CRL *crl);
|
|
|
|
const struct stack_st_X509_EXTENSION *X509_REVOKED_get0_extensions(const X509_REVOKED *x);
|
|
const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x);
|
|
const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x);
|
|
int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
|
|
int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
|
|
|
|
int X509_REQ_check_private_key(X509_REQ *x509,EVP_PKEY *pkey);
|
|
|
|
int X509_check_private_key(const X509 *x509, const EVP_PKEY *pkey);
|
|
|
|
int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
|
|
unsigned long X509_issuer_and_serial_hash(X509 *a);
|
|
|
|
int X509_issuer_name_cmp(const X509 *a, const X509 *b);
|
|
unsigned long X509_issuer_name_hash(X509 *a);
|
|
|
|
int X509_subject_name_cmp(const X509 *a, const X509 *b);
|
|
unsigned long X509_subject_name_hash(X509 *x);
|
|
|
|
|
|
unsigned long X509_issuer_name_hash_old(X509 *a);
|
|
unsigned long X509_subject_name_hash_old(X509 *x);
|
|
|
|
|
|
int X509_cmp(const X509 *a, const X509 *b);
|
|
int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
|
|
unsigned long X509_NAME_hash(X509_NAME *x);
|
|
unsigned long X509_NAME_hash_old(X509_NAME *x);
|
|
|
|
int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
|
|
int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
|
|
int X509_print_ex_fp(FILE *bp,X509 *x, unsigned long nmflag, unsigned long cflag);
|
|
int X509_print_fp(FILE *bp,X509 *x);
|
|
int X509_CRL_print_fp(FILE *bp,X509_CRL *x);
|
|
int X509_REQ_print_fp(FILE *bp,X509_REQ *req);
|
|
int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
|
|
unsigned long flags);
|
|
|
|
|
|
int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase);
|
|
int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
|
|
unsigned long flags);
|
|
int X509_print_ex(BIO *bp,X509 *x, unsigned long nmflag, unsigned long cflag);
|
|
int X509_print(BIO *bp,X509 *x);
|
|
int X509_ocspid_print(BIO *bp,X509 *x);
|
|
int X509_CERT_AUX_print(BIO *bp,X509_CERT_AUX *x, int indent);
|
|
int X509_CRL_print(BIO *bp,X509_CRL *x);
|
|
int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, unsigned long cflag);
|
|
int X509_REQ_print(BIO *bp,X509_REQ *req);
|
|
|
|
|
|
int X509_NAME_entry_count(const X509_NAME *name);
|
|
int X509_NAME_get_text_by_NID(X509_NAME *name, int nid,
|
|
char *buf,int len);
|
|
int X509_NAME_get_text_by_OBJ(X509_NAME *name,
|
|
const ASN1_OBJECT *obj, char *buf,int len);
|
|
|
|
|
|
|
|
int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid,
|
|
int lastpos);
|
|
int X509_NAME_get_index_by_OBJ(const X509_NAME *name,
|
|
const ASN1_OBJECT *obj, int lastpos);
|
|
X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc);
|
|
X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
|
|
int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne,
|
|
int loc, int set);
|
|
int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj,
|
|
int type, const unsigned char *bytes, int len, int loc, int set);
|
|
int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
|
|
const unsigned char *bytes, int len, int loc, int set);
|
|
X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
|
|
const char *field, int type, const unsigned char *bytes, int len);
|
|
X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
|
|
int type, const unsigned char *bytes, int len);
|
|
int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
|
|
const unsigned char *bytes, int len, int loc, int set);
|
|
X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
|
|
const ASN1_OBJECT *obj, int type,
|
|
const unsigned char *bytes, int len);
|
|
int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne,
|
|
const ASN1_OBJECT *obj);
|
|
int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
|
|
const unsigned char *bytes, int len);
|
|
ASN1_OBJECT * X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne);
|
|
ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne);
|
|
int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
|
|
|
|
int X509v3_get_ext_count(const struct stack_st_X509_EXTENSION *x);
|
|
int X509v3_get_ext_by_NID(const struct stack_st_X509_EXTENSION *x,
|
|
int nid, int lastpos);
|
|
int X509v3_get_ext_by_OBJ(const struct stack_st_X509_EXTENSION *x,
|
|
const ASN1_OBJECT *obj, int lastpos);
|
|
int X509v3_get_ext_by_critical(const struct stack_st_X509_EXTENSION *x,
|
|
int crit, int lastpos);
|
|
X509_EXTENSION *X509v3_get_ext(const struct stack_st_X509_EXTENSION *x, int loc);
|
|
X509_EXTENSION *X509v3_delete_ext(struct stack_st_X509_EXTENSION *x, int loc);
|
|
struct stack_st_X509_EXTENSION *X509v3_add_ext(struct stack_st_X509_EXTENSION **x,
|
|
X509_EXTENSION *ex, int loc);
|
|
|
|
int X509_get_ext_count(const X509 *x);
|
|
int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos);
|
|
int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj,
|
|
int lastpos);
|
|
int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos);
|
|
X509_EXTENSION *X509_get_ext(const X509 *x, int loc);
|
|
X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
|
|
int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
|
|
void * X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx);
|
|
int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
|
|
unsigned long flags);
|
|
|
|
int X509_CRL_get_ext_count(const X509_CRL *x);
|
|
int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid,
|
|
int lastpos);
|
|
int X509_CRL_get_ext_by_OBJ(const X509_CRL *x,
|
|
const ASN1_OBJECT *obj, int lastpos);
|
|
int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit,
|
|
int lastpos);
|
|
X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc);
|
|
X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
|
|
int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
|
|
void * X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit,
|
|
int *idx);
|
|
int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value,
|
|
int crit, unsigned long flags);
|
|
|
|
int X509_REVOKED_get_ext_count(const X509_REVOKED *x);
|
|
int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid,
|
|
int lastpos);
|
|
int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x,
|
|
const ASN1_OBJECT *obj, int lastpos);
|
|
int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x,
|
|
int crit, int lastpos);
|
|
X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc);
|
|
X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
|
|
int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex,
|
|
int loc);
|
|
void * X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid,
|
|
int *crit, int *idx);
|
|
int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value,
|
|
int crit, unsigned long flags);
|
|
|
|
X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
|
|
int nid, int crit, ASN1_OCTET_STRING *data);
|
|
X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
|
|
const ASN1_OBJECT *obj, int crit, ASN1_OCTET_STRING *data);
|
|
int X509_EXTENSION_set_object(X509_EXTENSION *ex,
|
|
const ASN1_OBJECT *obj);
|
|
int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
|
|
int X509_EXTENSION_set_data(X509_EXTENSION *ex,
|
|
ASN1_OCTET_STRING *data);
|
|
ASN1_OBJECT * X509_EXTENSION_get_object(X509_EXTENSION *ex);
|
|
ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
|
|
int X509_EXTENSION_get_critical(const X509_EXTENSION *ex);
|
|
|
|
int X509at_get_attr_count(const struct stack_st_X509_ATTRIBUTE *x);
|
|
int X509at_get_attr_by_NID(const struct stack_st_X509_ATTRIBUTE *x, int nid,
|
|
int lastpos);
|
|
int X509at_get_attr_by_OBJ(const struct stack_st_X509_ATTRIBUTE *sk,
|
|
const ASN1_OBJECT *obj, int lastpos);
|
|
X509_ATTRIBUTE *X509at_get_attr(const struct stack_st_X509_ATTRIBUTE *x, int loc);
|
|
X509_ATTRIBUTE *X509at_delete_attr(struct stack_st_X509_ATTRIBUTE *x, int loc);
|
|
struct stack_st_X509_ATTRIBUTE *X509at_add1_attr(struct stack_st_X509_ATTRIBUTE **x,
|
|
X509_ATTRIBUTE *attr);
|
|
struct stack_st_X509_ATTRIBUTE *X509at_add1_attr_by_OBJ(struct stack_st_X509_ATTRIBUTE **x,
|
|
const ASN1_OBJECT *obj, int type,
|
|
const unsigned char *bytes, int len);
|
|
struct stack_st_X509_ATTRIBUTE *X509at_add1_attr_by_NID(struct stack_st_X509_ATTRIBUTE **x,
|
|
int nid, int type,
|
|
const unsigned char *bytes, int len);
|
|
struct stack_st_X509_ATTRIBUTE *X509at_add1_attr_by_txt(struct stack_st_X509_ATTRIBUTE **x,
|
|
const char *attrname, int type,
|
|
const unsigned char *bytes, int len);
|
|
void *X509at_get0_data_by_OBJ(struct stack_st_X509_ATTRIBUTE *x,
|
|
const ASN1_OBJECT *obj, int lastpos, int type);
|
|
X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
|
|
int atrtype, const void *data, int len);
|
|
X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
|
|
const ASN1_OBJECT *obj, int atrtype, const void *data, int len);
|
|
X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
|
|
const char *atrname, int type, const unsigned char *bytes, int len);
|
|
int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
|
|
int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, int len);
|
|
void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
|
|
int atrtype, void *data);
|
|
int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr);
|
|
ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
|
|
ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
|
|
|
|
int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
|
|
int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid,
|
|
int lastpos);
|
|
int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
|
|
int lastpos);
|
|
X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
|
|
X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
|
|
int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
|
|
int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
|
|
const ASN1_OBJECT *obj, int type,
|
|
const unsigned char *bytes, int len);
|
|
int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
|
|
int nid, int type,
|
|
const unsigned char *bytes, int len);
|
|
int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
|
|
const char *attrname, int type,
|
|
const unsigned char *bytes, int len);
|
|
|
|
int X509_verify_cert(X509_STORE_CTX *ctx);
|
|
|
|
|
|
X509 *X509_find_by_issuer_and_serial(struct stack_st_X509 *sk,X509_NAME *name,
|
|
ASN1_INTEGER *serial);
|
|
X509 *X509_find_by_subject(struct stack_st_X509 *sk,X509_NAME *name);
|
|
|
|
PBEPARAM *PBEPARAM_new(void);
|
|
void PBEPARAM_free(PBEPARAM *a);
|
|
PBEPARAM *d2i_PBEPARAM(PBEPARAM **a, const unsigned char **in, long len);
|
|
int i2d_PBEPARAM(PBEPARAM *a, unsigned char **out);
|
|
extern const ASN1_ITEM PBEPARAM_it;
|
|
PBE2PARAM *PBE2PARAM_new(void);
|
|
void PBE2PARAM_free(PBE2PARAM *a);
|
|
PBE2PARAM *d2i_PBE2PARAM(PBE2PARAM **a, const unsigned char **in, long len);
|
|
int i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **out);
|
|
extern const ASN1_ITEM PBE2PARAM_it;
|
|
PBKDF2PARAM *PBKDF2PARAM_new(void);
|
|
void PBKDF2PARAM_free(PBKDF2PARAM *a);
|
|
PBKDF2PARAM *d2i_PBKDF2PARAM(PBKDF2PARAM **a, const unsigned char **in, long len);
|
|
int i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **out);
|
|
extern const ASN1_ITEM PBKDF2PARAM_it;
|
|
|
|
int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
|
|
const unsigned char *salt, int saltlen);
|
|
|
|
X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
|
|
const unsigned char *salt, int saltlen);
|
|
X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
|
|
unsigned char *salt, int saltlen);
|
|
X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
|
|
unsigned char *salt, int saltlen,
|
|
unsigned char *aiv, int prf_nid);
|
|
|
|
X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
|
|
int prf_nid, int keylen);
|
|
|
|
|
|
|
|
PKCS8_PRIV_KEY_INFO *PKCS8_PRIV_KEY_INFO_new(void);
|
|
void PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO *a);
|
|
PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO **a, const unsigned char **in, long len);
|
|
int i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO *a, unsigned char **out);
|
|
extern const ASN1_ITEM PKCS8_PRIV_KEY_INFO_it;
|
|
|
|
EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8);
|
|
PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey);
|
|
|
|
int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, int version,
|
|
int ptype, void *pval, unsigned char *penc, int penclen);
|
|
int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, const unsigned char **pk,
|
|
int *ppklen, const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8);
|
|
|
|
const struct stack_st_X509_ATTRIBUTE *PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8);
|
|
int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
|
|
const unsigned char *bytes, int len);
|
|
|
|
int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
|
|
int ptype, void *pval,
|
|
unsigned char *penc, int penclen);
|
|
int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
|
|
const unsigned char **pk, int *ppklen,
|
|
X509_ALGOR **pa,
|
|
X509_PUBKEY *pub);
|
|
|
|
int X509_check_trust(X509 *x, int id, int flags);
|
|
int X509_TRUST_get_count(void);
|
|
X509_TRUST * X509_TRUST_get0(int idx);
|
|
int X509_TRUST_get_by_id(int id);
|
|
int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
|
|
const char *name, int arg1, void *arg2);
|
|
void X509_TRUST_cleanup(void);
|
|
int X509_TRUST_get_flags(const X509_TRUST *xp);
|
|
char *X509_TRUST_get0_name(const X509_TRUST *xp);
|
|
int X509_TRUST_get_trust(const X509_TRUST *xp);
|
|
|
|
int X509_up_ref(X509 *x);
|
|
struct stack_st_X509 *X509_chain_up_ref(struct stack_st_X509 *chain);
|
|
|
|
|
|
|
|
|
|
|
|
void ERR_load_X509_strings(void);
|