mirror of https://github.com/lukechilds/node.git
Browse Source
This just replaces all sources of openssl-1.0.1t.tar.gz into deps/openssl/openssl. Fixes: https://github.com/nodejs/node/issues/6458 PR-URL: https://github.com/nodejs/node/pull/6553 Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>v0.10
Shigeki Ohtsu
9 years ago
129 changed files with 884 additions and 37654 deletions
@ -1 +1,253 @@ |
|||
#include "../../config/opensslconf.h" |
|||
/* opensslconf.h */ |
|||
/* WARNING: Generated automatically from opensslconf.h.in by Configure. */ |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
/* OpenSSL was configured with the following options: */ |
|||
#ifndef OPENSSL_DOING_MAKEDEPEND |
|||
|
|||
|
|||
#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 |
|||
# define OPENSSL_NO_EC_NISTP_64_GCC_128 |
|||
#endif |
|||
#ifndef OPENSSL_NO_GMP |
|||
# define OPENSSL_NO_GMP |
|||
#endif |
|||
#ifndef OPENSSL_NO_JPAKE |
|||
# define OPENSSL_NO_JPAKE |
|||
#endif |
|||
#ifndef OPENSSL_NO_KRB5 |
|||
# define OPENSSL_NO_KRB5 |
|||
#endif |
|||
#ifndef OPENSSL_NO_MD2 |
|||
# define OPENSSL_NO_MD2 |
|||
#endif |
|||
#ifndef OPENSSL_NO_RC5 |
|||
# define OPENSSL_NO_RC5 |
|||
#endif |
|||
#ifndef OPENSSL_NO_RFC3779 |
|||
# define OPENSSL_NO_RFC3779 |
|||
#endif |
|||
#ifndef OPENSSL_NO_SCTP |
|||
# define OPENSSL_NO_SCTP |
|||
#endif |
|||
#ifndef OPENSSL_NO_SSL2 |
|||
# define OPENSSL_NO_SSL2 |
|||
#endif |
|||
#ifndef OPENSSL_NO_STORE |
|||
# define OPENSSL_NO_STORE |
|||
#endif |
|||
#ifndef OPENSSL_NO_UNIT_TEST |
|||
# define OPENSSL_NO_UNIT_TEST |
|||
#endif |
|||
#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS |
|||
# define OPENSSL_NO_WEAK_SSL_CIPHERS |
|||
#endif |
|||
|
|||
#endif /* OPENSSL_DOING_MAKEDEPEND */ |
|||
|
|||
#ifndef OPENSSL_NO_DYNAMIC_ENGINE |
|||
# define OPENSSL_NO_DYNAMIC_ENGINE |
|||
#endif |
|||
|
|||
/* The OPENSSL_NO_* macros are also defined as NO_* if the application
|
|||
asks for it. This is a transient feature that is provided for those |
|||
who haven't had the time to do the appropriate changes in their |
|||
applications. */ |
|||
#ifdef OPENSSL_ALGORITHM_DEFINES |
|||
# if defined(OPENSSL_NO_EC_NISTP_64_GCC_128) && !defined(NO_EC_NISTP_64_GCC_128) |
|||
# define NO_EC_NISTP_64_GCC_128 |
|||
# endif |
|||
# if defined(OPENSSL_NO_GMP) && !defined(NO_GMP) |
|||
# define NO_GMP |
|||
# endif |
|||
# if defined(OPENSSL_NO_JPAKE) && !defined(NO_JPAKE) |
|||
# define NO_JPAKE |
|||
# endif |
|||
# if defined(OPENSSL_NO_KRB5) && !defined(NO_KRB5) |
|||
# define NO_KRB5 |
|||
# endif |
|||
# if defined(OPENSSL_NO_MD2) && !defined(NO_MD2) |
|||
# define NO_MD2 |
|||
# endif |
|||
# if defined(OPENSSL_NO_RC5) && !defined(NO_RC5) |
|||
# define NO_RC5 |
|||
# endif |
|||
# if defined(OPENSSL_NO_RFC3779) && !defined(NO_RFC3779) |
|||
# define NO_RFC3779 |
|||
# endif |
|||
# if defined(OPENSSL_NO_SCTP) && !defined(NO_SCTP) |
|||
# define NO_SCTP |
|||
# endif |
|||
# if defined(OPENSSL_NO_SSL2) && !defined(NO_SSL2) |
|||
# define NO_SSL2 |
|||
# endif |
|||
# if defined(OPENSSL_NO_STORE) && !defined(NO_STORE) |
|||
# define NO_STORE |
|||
# endif |
|||
# if defined(OPENSSL_NO_UNIT_TEST) && !defined(NO_UNIT_TEST) |
|||
# define NO_UNIT_TEST |
|||
# endif |
|||
# if defined(OPENSSL_NO_WEAK_SSL_CIPHERS) && !defined(NO_WEAK_SSL_CIPHERS) |
|||
# define NO_WEAK_SSL_CIPHERS |
|||
# endif |
|||
#endif |
|||
|
|||
/* crypto/opensslconf.h.in */ |
|||
|
|||
/* Generate 80386 code? */ |
|||
#undef I386_ONLY |
|||
|
|||
#if !(defined(VMS) || defined(__VMS)) /* VMS uses logical names instead */ |
|||
#if defined(HEADER_CRYPTLIB_H) && !defined(OPENSSLDIR) |
|||
#define ENGINESDIR "/usr/local/ssl/lib/engines" |
|||
#define OPENSSLDIR "/usr/local/ssl" |
|||
#endif |
|||
#endif |
|||
|
|||
#undef OPENSSL_UNISTD |
|||
#define OPENSSL_UNISTD <unistd.h> |
|||
|
|||
#undef OPENSSL_EXPORT_VAR_AS_FUNCTION |
|||
|
|||
#if defined(HEADER_IDEA_H) && !defined(IDEA_INT) |
|||
#define IDEA_INT unsigned int |
|||
#endif |
|||
|
|||
#if defined(HEADER_MD2_H) && !defined(MD2_INT) |
|||
#define MD2_INT unsigned int |
|||
#endif |
|||
|
|||
#if defined(HEADER_RC2_H) && !defined(RC2_INT) |
|||
/* I need to put in a mod for the alpha - eay */ |
|||
#define RC2_INT unsigned int |
|||
#endif |
|||
|
|||
#if defined(HEADER_RC4_H) |
|||
#if !defined(RC4_INT) |
|||
/* using int types make the structure larger but make the code faster
|
|||
* on most boxes I have tested - up to %20 faster. */ |
|||
/*
|
|||
* I don't know what does "most" mean, but declaring "int" is a must on: |
|||
* - Intel P6 because partial register stalls are very expensive; |
|||
* - elder Alpha because it lacks byte load/store instructions; |
|||
*/ |
|||
#define RC4_INT unsigned int |
|||
#endif |
|||
#if !defined(RC4_CHUNK) |
|||
/*
|
|||
* This enables code handling data aligned at natural CPU word |
|||
* boundary. See crypto/rc4/rc4_enc.c for further details. |
|||
*/ |
|||
#undef RC4_CHUNK |
|||
#endif |
|||
#endif |
|||
|
|||
#if (defined(HEADER_NEW_DES_H) || defined(HEADER_DES_H)) && !defined(DES_LONG) |
|||
/* If this is set to 'unsigned int' on a DEC Alpha, this gives about a
|
|||
* %20 speed up (longs are 8 bytes, int's are 4). */ |
|||
#ifndef DES_LONG |
|||
#define DES_LONG unsigned long |
|||
#endif |
|||
#endif |
|||
|
|||
#if defined(HEADER_BN_H) && !defined(CONFIG_HEADER_BN_H) |
|||
#define CONFIG_HEADER_BN_H |
|||
#undef BN_LLONG |
|||
|
|||
/* Should we define BN_DIV2W here? */ |
|||
|
|||
/* Only one for the following should be defined */ |
|||
#undef SIXTY_FOUR_BIT_LONG |
|||
#undef SIXTY_FOUR_BIT |
|||
#define THIRTY_TWO_BIT |
|||
#endif |
|||
|
|||
#if defined(HEADER_RC4_LOCL_H) && !defined(CONFIG_HEADER_RC4_LOCL_H) |
|||
#define CONFIG_HEADER_RC4_LOCL_H |
|||
/* if this is defined data[i] is used instead of *data, this is a %20
|
|||
* speedup on x86 */ |
|||
#undef RC4_INDEX |
|||
#endif |
|||
|
|||
#if defined(HEADER_BF_LOCL_H) && !defined(CONFIG_HEADER_BF_LOCL_H) |
|||
#define CONFIG_HEADER_BF_LOCL_H |
|||
#undef BF_PTR |
|||
#endif /* HEADER_BF_LOCL_H */ |
|||
|
|||
#if defined(HEADER_DES_LOCL_H) && !defined(CONFIG_HEADER_DES_LOCL_H) |
|||
#define CONFIG_HEADER_DES_LOCL_H |
|||
#ifndef DES_DEFAULT_OPTIONS |
|||
/* the following is tweaked from a config script, that is why it is a
|
|||
* protected undef/define */ |
|||
#ifndef DES_PTR |
|||
#undef DES_PTR |
|||
#endif |
|||
|
|||
/* This helps C compiler generate the correct code for multiple functional
|
|||
* units. It reduces register dependancies at the expense of 2 more |
|||
* registers */ |
|||
#ifndef DES_RISC1 |
|||
#undef DES_RISC1 |
|||
#endif |
|||
|
|||
#ifndef DES_RISC2 |
|||
#undef DES_RISC2 |
|||
#endif |
|||
|
|||
#if defined(DES_RISC1) && defined(DES_RISC2) |
|||
#error YOU SHOULD NOT HAVE BOTH DES_RISC1 AND DES_RISC2 DEFINED!!!!! |
|||
#endif |
|||
|
|||
/* Unroll the inner loop, this sometimes helps, sometimes hinders.
|
|||
* Very mucy CPU dependant */ |
|||
#ifndef DES_UNROLL |
|||
#undef DES_UNROLL |
|||
#endif |
|||
|
|||
/* These default values were supplied by
|
|||
* Peter Gutman <pgut001@cs.auckland.ac.nz> |
|||
* They are only used if nothing else has been defined */ |
|||
#if !defined(DES_PTR) && !defined(DES_RISC1) && !defined(DES_RISC2) && !defined(DES_UNROLL) |
|||
/* Special defines which change the way the code is built depending on the
|
|||
CPU and OS. For SGI machines you can use _MIPS_SZLONG (32 or 64) to find |
|||
even newer MIPS CPU's, but at the moment one size fits all for |
|||
optimization options. Older Sparc's work better with only UNROLL, but |
|||
there's no way to tell at compile time what it is you're running on */ |
|||
|
|||
#if defined( __sun ) || defined ( sun ) /* Newer Sparc's */ |
|||
# define DES_PTR |
|||
# define DES_RISC1 |
|||
# define DES_UNROLL |
|||
#elif defined( __ultrix ) /* Older MIPS */ |
|||
# define DES_PTR |
|||
# define DES_RISC2 |
|||
# define DES_UNROLL |
|||
#elif defined( __osf1__ ) /* Alpha */ |
|||
# define DES_PTR |
|||
# define DES_RISC2 |
|||
#elif defined ( _AIX ) /* RS6000 */ |
|||
/* Unknown */ |
|||
#elif defined( __hpux ) /* HP-PA */ |
|||
/* Unknown */ |
|||
#elif defined( __aux ) /* 68K */ |
|||
/* Unknown */ |
|||
#elif defined( __dgux ) /* 88K (but P6 in latest boxes) */ |
|||
# define DES_UNROLL |
|||
#elif defined( __sgi ) /* Newer MIPS */ |
|||
# define DES_PTR |
|||
# define DES_RISC2 |
|||
# define DES_UNROLL |
|||
#elif defined(i386) || defined(__i386__) /* x86 boxes, should be gcc */ |
|||
# define DES_PTR |
|||
# define DES_RISC1 |
|||
# define DES_UNROLL |
|||
#endif /* Systems-specific speed defines */ |
|||
#endif |
|||
|
|||
#endif /* DES_DEFAULT_OPTIONS */ |
|||
#endif /* HEADER_DES_LOCL_H */ |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
@ -1,438 +0,0 @@ |
|||
#!/usr/bin/env perl |
|||
# |
|||
# ==================================================================== |
|||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL |
|||
# project. Rights for redistribution and usage in source and binary |
|||
# forms are granted according to the OpenSSL license. |
|||
# ==================================================================== |
|||
# |
|||
# sha256/512_block procedure for x86_64. |
|||
# |
|||
# 40% improvement over compiler-generated code on Opteron. On EM64T |
|||
# sha256 was observed to run >80% faster and sha512 - >40%. No magical |
|||
# tricks, just straight implementation... I really wonder why gcc |
|||
# [being armed with inline assembler] fails to generate as fast code. |
|||
# The only thing which is cool about this module is that it's very |
|||
# same instruction sequence used for both SHA-256 and SHA-512. In |
|||
# former case the instructions operate on 32-bit operands, while in |
|||
# latter - on 64-bit ones. All I had to do is to get one flavor right, |
|||
# the other one passed the test right away:-) |
|||
# |
|||
# sha256_block runs in ~1005 cycles on Opteron, which gives you |
|||
# asymptotic performance of 64*1000/1005=63.7MBps times CPU clock |
|||
# frequency in GHz. sha512_block runs in ~1275 cycles, which results |
|||
# in 128*1000/1275=100MBps per GHz. Is there room for improvement? |
|||
# Well, if you compare it to IA-64 implementation, which maintains |
|||
# X[16] in register bank[!], tends to 4 instructions per CPU clock |
|||
# cycle and runs in 1003 cycles, 1275 is very good result for 3-way |
|||
# issue Opteron pipeline and X[16] maintained in memory. So that *if* |
|||
# there is a way to improve it, *then* the only way would be to try to |
|||
# offload X[16] updates to SSE unit, but that would require "deeper" |
|||
# loop unroll, which in turn would naturally cause size blow-up, not |
|||
# to mention increased complexity! And once again, only *if* it's |
|||
# actually possible to noticeably improve overall ILP, instruction |
|||
# level parallelism, on a given CPU implementation in this case. |
|||
# |
|||
# Special note on Intel EM64T. While Opteron CPU exhibits perfect |
|||
# perfromance ratio of 1.5 between 64- and 32-bit flavors [see above], |
|||
# [currently available] EM64T CPUs apparently are far from it. On the |
|||
# contrary, 64-bit version, sha512_block, is ~30% *slower* than 32-bit |
|||
# sha256_block:-( This is presumably because 64-bit shifts/rotates |
|||
# apparently are not atomic instructions, but implemented in microcode. |
|||
|
|||
$flavour = shift; |
|||
$output = shift; |
|||
if ($flavour =~ /\./) { $output = $flavour; undef $flavour; } |
|||
|
|||
$win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/); |
|||
|
|||
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1; |
|||
( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or |
|||
( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or |
|||
die "can't locate x86_64-xlate.pl"; |
|||
|
|||
open OUT,"| \"$^X\" $xlate $flavour $output"; |
|||
*STDOUT=*OUT; |
|||
|
|||
$func="sha256_block_data_order"; |
|||
$TABLE="K256"; |
|||
$SZ=4; |
|||
@ROT=($A,$B,$C,$D,$E,$F,$G,$H)=("%eax","%ebx","%ecx","%edx", |
|||
"%r8d","%r9d","%r10d","%r11d"); |
|||
($T1,$a0,$a1,$a2)=("%r12d","%r13d","%r14d","%r15d"); |
|||
@Sigma0=( 2,13,22); |
|||
@Sigma1=( 6,11,25); |
|||
@sigma0=( 7,18, 3); |
|||
@sigma1=(17,19,10); |
|||
$rounds=64; |
|||
|
|||
|
|||
$ctx="%rdi"; # 1st arg |
|||
$round="%rdi"; # zaps $ctx |
|||
$inp="%rsi"; # 2nd arg |
|||
$Tbl="%rbp"; |
|||
|
|||
$_ctx="16*$SZ+0*8(%rsp)"; |
|||
$_inp="16*$SZ+1*8(%rsp)"; |
|||
$_end="16*$SZ+2*8(%rsp)"; |
|||
$_rsp="16*$SZ+3*8(%rsp)"; |
|||
$framesz="16*$SZ+4*8"; |
|||
|
|||
|
|||
sub ROUND_00_15() |
|||
{ my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_; |
|||
|
|||
$code.=<<___; |
|||
ror \$`$Sigma1[2]-$Sigma1[1]`,$a0 |
|||
mov $f,$a2 |
|||
mov $T1,`$SZ*($i&0xf)`(%rsp) |
|||
|
|||
ror \$`$Sigma0[2]-$Sigma0[1]`,$a1 |
|||
xor $e,$a0 |
|||
xor $g,$a2 # f^g |
|||
|
|||
ror \$`$Sigma1[1]-$Sigma1[0]`,$a0 |
|||
add $h,$T1 # T1+=h |
|||
xor $a,$a1 |
|||
|
|||
add ($Tbl,$round,$SZ),$T1 # T1+=K[round] |
|||
and $e,$a2 # (f^g)&e |
|||
mov $b,$h |
|||
|
|||
ror \$`$Sigma0[1]-$Sigma0[0]`,$a1 |
|||
xor $e,$a0 |
|||
xor $g,$a2 # Ch(e,f,g)=((f^g)&e)^g |
|||
|
|||
xor $c,$h # b^c |
|||
xor $a,$a1 |
|||
add $a2,$T1 # T1+=Ch(e,f,g) |
|||
mov $b,$a2 |
|||
|
|||
ror \$$Sigma1[0],$a0 # Sigma1(e) |
|||
and $a,$h # h=(b^c)&a |
|||
and $c,$a2 # b&c |
|||
|
|||
ror \$$Sigma0[0],$a1 # Sigma0(a) |
|||
add $a0,$T1 # T1+=Sigma1(e) |
|||
add $a2,$h # h+=b&c (completes +=Maj(a,b,c) |
|||
|
|||
add $T1,$d # d+=T1 |
|||
add $T1,$h # h+=T1 |
|||
lea 1($round),$round # round++ |
|||
add $a1,$h # h+=Sigma0(a) |
|||
|
|||
___ |
|||
} |
|||
|
|||
sub ROUND_16_XX() |
|||
{ my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_; |
|||
|
|||
$code.=<<___; |
|||
mov `$SZ*(($i+1)&0xf)`(%rsp),$a0 |
|||
mov `$SZ*(($i+14)&0xf)`(%rsp),$a1 |
|||
mov $a0,$T1 |
|||
mov $a1,$a2 |
|||
|
|||
ror \$`$sigma0[1]-$sigma0[0]`,$T1 |
|||
xor $a0,$T1 |
|||
shr \$$sigma0[2],$a0 |
|||
|
|||
ror \$$sigma0[0],$T1 |
|||
xor $T1,$a0 # sigma0(X[(i+1)&0xf]) |
|||
mov `$SZ*(($i+9)&0xf)`(%rsp),$T1 |
|||
|
|||
ror \$`$sigma1[1]-$sigma1[0]`,$a2 |
|||
xor $a1,$a2 |
|||
shr \$$sigma1[2],$a1 |
|||
|
|||
ror \$$sigma1[0],$a2 |
|||
add $a0,$T1 |
|||
xor $a2,$a1 # sigma1(X[(i+14)&0xf]) |
|||
|
|||
add `$SZ*($i&0xf)`(%rsp),$T1 |
|||
mov $e,$a0 |
|||
add $a1,$T1 |
|||
mov $a,$a1 |
|||
___ |
|||
&ROUND_00_15(@_); |
|||
} |
|||
|
|||
$code=<<___; |
|||
.text |
|||
|
|||
.globl $func |
|||
.type $func,\@function,4 |
|||
.align 16 |
|||
$func: |
|||
push %rbx |
|||
push %rbp |
|||
push %r12 |
|||
push %r13 |
|||
push %r14 |
|||
push %r15 |
|||
mov %rsp,%r11 # copy %rsp |
|||
shl \$4,%rdx # num*16 |
|||
sub \$$framesz,%rsp |
|||
lea ($inp,%rdx,$SZ),%rdx # inp+num*16*$SZ |
|||
and \$-64,%rsp # align stack frame |
|||
mov $ctx,$_ctx # save ctx, 1st arg |
|||
mov $inp,$_inp # save inp, 2nd arh |
|||
mov %rdx,$_end # save end pointer, "3rd" arg |
|||
mov %r11,$_rsp # save copy of %rsp |
|||
.Lprologue: |
|||
|
|||
lea $TABLE(%rip),$Tbl |
|||
|
|||
mov $SZ*0($ctx),$A |
|||
mov $SZ*1($ctx),$B |
|||
mov $SZ*2($ctx),$C |
|||
mov $SZ*3($ctx),$D |
|||
mov $SZ*4($ctx),$E |
|||
mov $SZ*5($ctx),$F |
|||
mov $SZ*6($ctx),$G |
|||
mov $SZ*7($ctx),$H |
|||
jmp .Lloop |
|||
|
|||
.align 16 |
|||
.Lloop: |
|||
xor $round,$round |
|||
___ |
|||
for($i=0;$i<16;$i++) { |
|||
$code.=" mov $SZ*$i($inp),$T1\n"; |
|||
$code.=" mov @ROT[4],$a0\n"; |
|||
$code.=" mov @ROT[0],$a1\n"; |
|||
$code.=" bswap $T1\n"; |
|||
&ROUND_00_15($i,@ROT); |
|||
unshift(@ROT,pop(@ROT)); |
|||
} |
|||
$code.=<<___; |
|||
jmp .Lrounds_16_xx |
|||
.align 16 |
|||
.Lrounds_16_xx: |
|||
___ |
|||
for(;$i<32;$i++) { |
|||
&ROUND_16_XX($i,@ROT); |
|||
unshift(@ROT,pop(@ROT)); |
|||
} |
|||
|
|||
$code.=<<___; |
|||
cmp \$$rounds,$round |
|||
jb .Lrounds_16_xx |
|||
|
|||
mov $_ctx,$ctx |
|||
lea 16*$SZ($inp),$inp |
|||
|
|||
add $SZ*0($ctx),$A |
|||
add $SZ*1($ctx),$B |
|||
add $SZ*2($ctx),$C |
|||
add $SZ*3($ctx),$D |
|||
add $SZ*4($ctx),$E |
|||
add $SZ*5($ctx),$F |
|||
add $SZ*6($ctx),$G |
|||
add $SZ*7($ctx),$H |
|||
|
|||
cmp $_end,$inp |
|||
|
|||
mov $A,$SZ*0($ctx) |
|||
mov $B,$SZ*1($ctx) |
|||
mov $C,$SZ*2($ctx) |
|||
mov $D,$SZ*3($ctx) |
|||
mov $E,$SZ*4($ctx) |
|||
mov $F,$SZ*5($ctx) |
|||
mov $G,$SZ*6($ctx) |
|||
mov $H,$SZ*7($ctx) |
|||
jb .Lloop |
|||
|
|||
mov $_rsp,%rsi |
|||
mov (%rsi),%r15 |
|||
mov 8(%rsi),%r14 |
|||
mov 16(%rsi),%r13 |
|||
mov 24(%rsi),%r12 |
|||
mov 32(%rsi),%rbp |
|||
mov 40(%rsi),%rbx |
|||
lea 48(%rsi),%rsp |
|||
.Lepilogue: |
|||
ret |
|||
.size $func,.-$func |
|||
___ |
|||
|
|||
if ($SZ==4) { |
|||
$code.=<<___; |
|||
.align 64 |
|||
.type $TABLE,\@object |
|||
$TABLE: |
|||
.long 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5 |
|||
.long 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5 |
|||
.long 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3 |
|||
.long 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174 |
|||
.long 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc |
|||
.long 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da |
|||
.long 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7 |
|||
.long 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967 |
|||
.long 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13 |
|||
.long 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85 |
|||
.long 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3 |
|||
.long 0xd192e819,0xd6990624,0xf40e3585,0x106aa070 |
|||
.long 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5 |
|||
.long 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3 |
|||
.long 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208 |
|||
.long 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2 |
|||
___ |
|||
} else { |
|||
$code.=<<___; |
|||
.align 64 |
|||
.type $TABLE,\@object |
|||
$TABLE: |
|||
.quad 0x428a2f98d728ae22,0x7137449123ef65cd |
|||
.quad 0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc |
|||
.quad 0x3956c25bf348b538,0x59f111f1b605d019 |
|||
.quad 0x923f82a4af194f9b,0xab1c5ed5da6d8118 |
|||
.quad 0xd807aa98a3030242,0x12835b0145706fbe |
|||
.quad 0x243185be4ee4b28c,0x550c7dc3d5ffb4e2 |
|||
.quad 0x72be5d74f27b896f,0x80deb1fe3b1696b1 |
|||
.quad 0x9bdc06a725c71235,0xc19bf174cf692694 |
|||
.quad 0xe49b69c19ef14ad2,0xefbe4786384f25e3 |
|||
.quad 0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65 |
|||
.quad 0x2de92c6f592b0275,0x4a7484aa6ea6e483 |
|||
.quad 0x5cb0a9dcbd41fbd4,0x76f988da831153b5 |
|||
.quad 0x983e5152ee66dfab,0xa831c66d2db43210 |
|||
.quad 0xb00327c898fb213f,0xbf597fc7beef0ee4 |
|||
.quad 0xc6e00bf33da88fc2,0xd5a79147930aa725 |
|||
.quad 0x06ca6351e003826f,0x142929670a0e6e70 |
|||
.quad 0x27b70a8546d22ffc,0x2e1b21385c26c926 |
|||
.quad 0x4d2c6dfc5ac42aed,0x53380d139d95b3df |
|||
.quad 0x650a73548baf63de,0x766a0abb3c77b2a8 |
|||
.quad 0x81c2c92e47edaee6,0x92722c851482353b |
|||
.quad 0xa2bfe8a14cf10364,0xa81a664bbc423001 |
|||
.quad 0xc24b8b70d0f89791,0xc76c51a30654be30 |
|||
.quad 0xd192e819d6ef5218,0xd69906245565a910 |
|||
.quad 0xf40e35855771202a,0x106aa07032bbd1b8 |
|||
.quad 0x19a4c116b8d2d0c8,0x1e376c085141ab53 |
|||
.quad 0x2748774cdf8eeb99,0x34b0bcb5e19b48a8 |
|||
.quad 0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb |
|||
.quad 0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3 |
|||
.quad 0x748f82ee5defb2fc,0x78a5636f43172f60 |
|||
.quad 0x84c87814a1f0ab72,0x8cc702081a6439ec |
|||
.quad 0x90befffa23631e28,0xa4506cebde82bde9 |
|||
.quad 0xbef9a3f7b2c67915,0xc67178f2e372532b |
|||
.quad 0xca273eceea26619c,0xd186b8c721c0c207 |
|||
.quad 0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178 |
|||
.quad 0x06f067aa72176fba,0x0a637dc5a2c898a6 |
|||
.quad 0x113f9804bef90dae,0x1b710b35131c471b |
|||
.quad 0x28db77f523047d84,0x32caab7b40c72493 |
|||
.quad 0x3c9ebe0a15c9bebc,0x431d67c49c100d4c |
|||
.quad 0x4cc5d4becb3e42b6,0x597f299cfc657e2a |
|||
.quad 0x5fcb6fab3ad6faec,0x6c44198c4a475817 |
|||
___ |
|||
} |
|||
|
|||
# EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame, |
|||
# CONTEXT *context,DISPATCHER_CONTEXT *disp) |
|||
if ($win64) { |
|||
$rec="%rcx"; |
|||
$frame="%rdx"; |
|||
$context="%r8"; |
|||
$disp="%r9"; |
|||
|
|||
$code.=<<___; |
|||
.extern __imp_RtlVirtualUnwind |
|||
.type se_handler,\@abi-omnipotent |
|||
.align 16 |
|||
se_handler: |
|||
push %rsi |
|||
push %rdi |
|||
push %rbx |
|||
push %rbp |
|||
push %r12 |
|||
push %r13 |
|||
push %r14 |
|||
push %r15 |
|||
pushfq |
|||
sub \$64,%rsp |
|||
|
|||
mov 120($context),%rax # pull context->Rax |
|||
mov 248($context),%rbx # pull context->Rip |
|||
|
|||
lea .Lprologue(%rip),%r10 |
|||
cmp %r10,%rbx # context->Rip<.Lprologue |
|||
jb .Lin_prologue |
|||
|
|||
mov 152($context),%rax # pull context->Rsp |
|||
|
|||
lea .Lepilogue(%rip),%r10 |
|||
cmp %r10,%rbx # context->Rip>=.Lepilogue |
|||
jae .Lin_prologue |
|||
|
|||
mov 16*$SZ+3*8(%rax),%rax # pull $_rsp |
|||
lea 48(%rax),%rax |
|||
|
|||
mov -8(%rax),%rbx |
|||
mov -16(%rax),%rbp |
|||
mov -24(%rax),%r12 |
|||
mov -32(%rax),%r13 |
|||
mov -40(%rax),%r14 |
|||
mov -48(%rax),%r15 |
|||
mov %rbx,144($context) # restore context->Rbx |
|||
mov %rbp,160($context) # restore context->Rbp |
|||
mov %r12,216($context) # restore context->R12 |
|||
mov %r13,224($context) # restore context->R13 |
|||
mov %r14,232($context) # restore context->R14 |
|||
mov %r15,240($context) # restore context->R15 |
|||
|
|||
.Lin_prologue: |
|||
mov 8(%rax),%rdi |
|||
mov 16(%rax),%rsi |
|||
mov %rax,152($context) # restore context->Rsp |
|||
mov %rsi,168($context) # restore context->Rsi |
|||
mov %rdi,176($context) # restore context->Rdi |
|||
|
|||
mov 40($disp),%rdi # disp->ContextRecord |
|||
mov $context,%rsi # context |
|||
mov \$154,%ecx # sizeof(CONTEXT) |
|||
.long 0xa548f3fc # cld; rep movsq |
|||
|
|||
mov $disp,%rsi |
|||
xor %rcx,%rcx # arg1, UNW_FLAG_NHANDLER |
|||
mov 8(%rsi),%rdx # arg2, disp->ImageBase |
|||
mov 0(%rsi),%r8 # arg3, disp->ControlPc |
|||
mov 16(%rsi),%r9 # arg4, disp->FunctionEntry |
|||
mov 40(%rsi),%r10 # disp->ContextRecord |
|||
lea 56(%rsi),%r11 # &disp->HandlerData |
|||
lea 24(%rsi),%r12 # &disp->EstablisherFrame |
|||
mov %r10,32(%rsp) # arg5 |
|||
mov %r11,40(%rsp) # arg6 |
|||
mov %r12,48(%rsp) # arg7 |
|||
mov %rcx,56(%rsp) # arg8, (NULL) |
|||
call *__imp_RtlVirtualUnwind(%rip) |
|||
|
|||
mov \$1,%eax # ExceptionContinueSearch |
|||
add \$64,%rsp |
|||
popfq |
|||
pop %r15 |
|||
pop %r14 |
|||
pop %r13 |
|||
pop %r12 |
|||
pop %rbp |
|||
pop %rbx |
|||
pop %rdi |
|||
pop %rsi |
|||
ret |
|||
.size se_handler,.-se_handler |
|||
|
|||
.section .pdata |
|||
.align 4 |
|||
.rva .LSEH_begin_$func |
|||
.rva .LSEH_end_$func |
|||
.rva .LSEH_info_$func |
|||
|
|||
.section .xdata |
|||
.align 8 |
|||
.LSEH_info_$func: |
|||
.byte 9,0,0,0 |
|||
.rva se_handler |
|||
___ |
|||
} |
|||
|
|||
$code =~ s/\`([^\`]*)\`/eval $1/gem; |
|||
print $code; |
|||
close STDOUT; |
|||
@ -0,0 +1,127 @@ |
|||
=pod |
|||
|
|||
=head1 NAME |
|||
|
|||
EVP_EncodeInit, EVP_EncodeUpdate, EVP_EncodeFinal, EVP_EncodeBlock, |
|||
EVP_DecodeInit, EVP_DecodeUpdate, EVP_DecodeFinal, EVP_DecodeBlock - EVP base 64 |
|||
encode/decode routines |
|||
|
|||
=head1 SYNOPSIS |
|||
|
|||
#include <openssl/evp.h> |
|||
|
|||
void EVP_EncodeInit(EVP_ENCODE_CTX *ctx); |
|||
void 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); |
|||
|
|||
=head1 DESCRIPTION |
|||
|
|||
The EVP encode routines provide a high level interface to base 64 encoding and |
|||
decoding. Base 64 encoding converts binary data into a printable form that uses |
|||
the characters A-Z, a-z, 0-9, "+" and "/" to represent the data. For every 3 |
|||
bytes of binary data provided 4 bytes of base 64 encoded data will be produced |
|||
plus some occasional newlines (see below). If the input data length is not a |
|||
multiple of 3 then the output data will be padded at the end using the "=" |
|||
character. |
|||
|
|||
Encoding of binary data is performed in blocks of 48 input bytes (or less for |
|||
the final block). For each 48 byte input block encoded 64 bytes of base 64 data |
|||
is output plus an additional newline character (i.e. 65 bytes in total). The |
|||
final block (which may be less than 48 bytes) will output 4 bytes for every 3 |
|||
bytes of input. If the data length is not divisible by 3 then a full 4 bytes is |
|||
still output for the final 1 or 2 bytes of input. Similarly a newline character |
|||
will also be output. |
|||
|
|||
EVP_EncodeInit() initialises B<ctx> for the start of a new encoding operation. |
|||
|
|||
EVP_EncodeUpdate() encode B<inl> bytes of data found in the buffer pointed to by |
|||
B<in>. The output is stored in the buffer B<out> and the number of bytes output |
|||
is stored in B<*outl>. It is the caller's responsibility to ensure that the |
|||
buffer at B<out> is sufficiently large to accommodate the output data. Only full |
|||
blocks of data (48 bytes) will be immediately processed and output by this |
|||
function. Any remainder is held in the B<ctx> object and will be processed by a |
|||
subsequent call to EVP_EncodeUpdate() or EVP_EncodeFinal(). To calculate the |
|||
required size of the output buffer add together the value of B<inl> with the |
|||
amount of unprocessed data held in B<ctx> and divide the result by 48 (ignore |
|||
any remainder). This gives the number of blocks of data that will be processed. |
|||
Ensure the output buffer contains 65 bytes of storage for each block, plus an |
|||
additional byte for a NUL terminator. EVP_EncodeUpdate() may be called |
|||
repeatedly to process large amounts of input data. In the event of an error |
|||
EVP_EncodeUpdate() will set B<*outl> to 0. |
|||
|
|||
EVP_EncodeFinal() must be called at the end of an encoding operation. It will |
|||
process any partial block of data remaining in the B<ctx> object. The output |
|||
data will be stored in B<out> and the length of the data written will be stored |
|||
in B<*outl>. It is the caller's responsibility to ensure that B<out> is |
|||
sufficiently large to accommodate the output data which will never be more than |
|||
65 bytes plus an additional NUL terminator (i.e. 66 bytes in total). |
|||
|
|||
EVP_EncodeBlock() encodes a full block of input data in B<f> and of length |
|||
B<dlen> and stores it in B<t>. For every 3 bytes of input provided 4 bytes of |
|||
output data will be produced. If B<dlen> is not divisible by 3 then the block is |
|||
encoded as a final block of data and the output is padded such that it is always |
|||
divisible by 4. Additionally a NUL terminator character will be added. For |
|||
example if 16 bytes of input data is provided then 24 bytes of encoded data is |
|||
created plus 1 byte for a NUL terminator (i.e. 25 bytes in total). The length of |
|||
the data generated I<without> the NUL terminator is returned from the function. |
|||
|
|||
EVP_DecodeInit() initialises B<ctx> for the start of a new decoding operation. |
|||
|
|||
EVP_DecodeUpdate() decodes B<inl> characters of data found in the buffer pointed |
|||
to by B<in>. The output is stored in the buffer B<out> and the number of bytes |
|||
output is stored in B<*outl>. It is the caller's responsibility to ensure that |
|||
the buffer at B<out> is sufficiently large to accommodate the output data. This |
|||
function will attempt to decode as much data as possible in 4 byte chunks. Any |
|||
whitespace, newline or carriage return characters are ignored. Any partial chunk |
|||
of unprocessed data (1, 2 or 3 bytes) that remains at the end will be held in |
|||
the B<ctx> object and processed by a subsequent call to EVP_DecodeUpdate(). If |
|||
any illegal base 64 characters are encountered or if the base 64 padding |
|||
character "=" is encountered in the middle of the data then the function returns |
|||
-1 to indicate an error. A return value of 0 or 1 indicates successful |
|||
processing of the data. A return value of 0 additionally indicates that the last |
|||
input data characters processed included the base 64 padding character "=" and |
|||
therefore no more non-padding character data is expected to be processed. For |
|||
every 4 valid base 64 bytes processed (ignoring whitespace, carriage returns and |
|||
line feeds), 3 bytes of binary output data will be produced (or less at the end |
|||
of the data where the padding character "=" has been used). |
|||
|
|||
EVP_DecodeFinal() must be called at the end of a decoding operation. If there |
|||
is any unprocessed data still in B<ctx> then the input data must not have been |
|||
a multiple of 4 and therefore an error has occurred. The function will return -1 |
|||
in this case. Otherwise the function returns 1 on success. |
|||
|
|||
EVP_DecodeBlock() will decode the block of B<n> characters of base 64 data |
|||
contained in B<f> and store the result in B<t>. Any leading whitespace will be |
|||
trimmed as will any trailing whitespace, newlines, carriage returns or EOF |
|||
characters. After such trimming the length of the data in B<f> must be divisbile |
|||
by 4. For every 4 input bytes exactly 3 output bytes will be produced. The |
|||
output will be padded with 0 bits if necessary to ensure that the output is |
|||
always 3 bytes for every 4 input bytes. This function will return the length of |
|||
the data decoded or -1 on error. |
|||
|
|||
=head1 RETURN VALUES |
|||
|
|||
EVP_EncodeBlock() returns the number of bytes encoded excluding the NUL |
|||
terminator. |
|||
|
|||
EVP_DecodeUpdate() returns -1 on error and 0 or 1 on success. If 0 is returned |
|||
then no more non-padding base 64 characters are expected. |
|||
|
|||
EVP_DecodeFinal() returns -1 on error or 1 on success. |
|||
|
|||
EVP_DecodeBlock() returns the length of the data decoded or -1 on error. |
|||
|
|||
=head1 SEE ALSO |
|||
|
|||
L<evp(3)> |
|||
|
|||
=cut |
|||
@ -1,149 +0,0 @@ |
|||
/* crypto/aes/aes.h */ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_AES_H |
|||
# define HEADER_AES_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_AES |
|||
# error AES is disabled. |
|||
# endif |
|||
|
|||
# include <stddef.h> |
|||
|
|||
# define AES_ENCRYPT 1 |
|||
# define AES_DECRYPT 0 |
|||
|
|||
/*
|
|||
* Because array size can't be a const in C, the following two are macros. |
|||
* Both sizes are in bytes. |
|||
*/ |
|||
# define AES_MAXNR 14 |
|||
# define AES_BLOCK_SIZE 16 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* This should be a hidden type, but EVP requires that the size be known */ |
|||
struct aes_key_st { |
|||
# ifdef AES_LONG |
|||
unsigned long rd_key[4 * (AES_MAXNR + 1)]; |
|||
# else |
|||
unsigned int rd_key[4 * (AES_MAXNR + 1)]; |
|||
# endif |
|||
int rounds; |
|||
}; |
|||
typedef struct aes_key_st AES_KEY; |
|||
|
|||
const char *AES_options(void); |
|||
|
|||
int AES_set_encrypt_key(const unsigned char *userKey, const int bits, |
|||
AES_KEY *key); |
|||
int AES_set_decrypt_key(const unsigned char *userKey, const int bits, |
|||
AES_KEY *key); |
|||
|
|||
int private_AES_set_encrypt_key(const unsigned char *userKey, const int bits, |
|||
AES_KEY *key); |
|||
int private_AES_set_decrypt_key(const unsigned char *userKey, const int bits, |
|||
AES_KEY *key); |
|||
|
|||
void AES_encrypt(const unsigned char *in, unsigned char *out, |
|||
const AES_KEY *key); |
|||
void AES_decrypt(const unsigned char *in, unsigned char *out, |
|||
const AES_KEY *key); |
|||
|
|||
void AES_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
const AES_KEY *key, const int enc); |
|||
void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char *ivec, const int enc); |
|||
void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char *ivec, int *num, const int enc); |
|||
void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char *ivec, int *num, const int enc); |
|||
void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char *ivec, int *num, const int enc); |
|||
void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char *ivec, int *num); |
|||
void AES_ctr128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char ivec[AES_BLOCK_SIZE], |
|||
unsigned char ecount_buf[AES_BLOCK_SIZE], |
|||
unsigned int *num); |
|||
/* NB: the IV is _two_ blocks long */ |
|||
void AES_ige_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
unsigned char *ivec, const int enc); |
|||
/* NB: the IV is _four_ blocks long */ |
|||
void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const AES_KEY *key, |
|||
const AES_KEY *key2, const unsigned char *ivec, |
|||
const int enc); |
|||
|
|||
int AES_wrap_key(AES_KEY *key, const unsigned char *iv, |
|||
unsigned char *out, |
|||
const unsigned char *in, unsigned int inlen); |
|||
int AES_unwrap_key(AES_KEY *key, const unsigned char *iv, |
|||
unsigned char *out, |
|||
const unsigned char *in, unsigned int inlen); |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif /* !HEADER_AES_H */ |
|||
File diff suppressed because it is too large
@ -1,579 +0,0 @@ |
|||
/* crypto/asn1/asn1_mac.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_ASN1_MAC_H |
|||
# define HEADER_ASN1_MAC_H |
|||
|
|||
# include <openssl/asn1.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifndef ASN1_MAC_ERR_LIB |
|||
# define ASN1_MAC_ERR_LIB ERR_LIB_ASN1 |
|||
# endif |
|||
|
|||
# define ASN1_MAC_H_err(f,r,line) \ |
|||
ERR_PUT_error(ASN1_MAC_ERR_LIB,(f),(r),__FILE__,(line)) |
|||
|
|||
# define M_ASN1_D2I_vars(a,type,func) \ |
|||
ASN1_const_CTX c; \ |
|||
type ret=NULL; \ |
|||
\ |
|||
c.pp=(const unsigned char **)pp; \ |
|||
c.q= *(const unsigned char **)pp; \ |
|||
c.error=ERR_R_NESTED_ASN1_ERROR; \ |
|||
if ((a == NULL) || ((*a) == NULL)) \ |
|||
{ if ((ret=(type)func()) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } } \ |
|||
else ret=(*a); |
|||
|
|||
# define M_ASN1_D2I_Init() \ |
|||
c.p= *(const unsigned char **)pp; \ |
|||
c.max=(length == 0)?0:(c.p+length); |
|||
|
|||
# define M_ASN1_D2I_Finish_2(a) \ |
|||
if (!asn1_const_Finish(&c)) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
*(const unsigned char **)pp=c.p; \ |
|||
if (a != NULL) (*a)=ret; \ |
|||
return(ret); |
|||
|
|||
# define M_ASN1_D2I_Finish(a,func,e) \ |
|||
M_ASN1_D2I_Finish_2(a); \ |
|||
err:\ |
|||
ASN1_MAC_H_err((e),c.error,c.line); \ |
|||
asn1_add_error(*(const unsigned char **)pp,(int)(c.q- *pp)); \ |
|||
if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ |
|||
return(NULL) |
|||
|
|||
# define M_ASN1_D2I_start_sequence() \ |
|||
if (!asn1_GetSequence(&c,&length)) \ |
|||
{ c.line=__LINE__; goto err; } |
|||
/* Begin reading ASN1 without a surrounding sequence */ |
|||
# define M_ASN1_D2I_begin() \ |
|||
c.slen = length; |
|||
|
|||
/* End reading ASN1 with no check on length */ |
|||
# define M_ASN1_D2I_Finish_nolen(a, func, e) \ |
|||
*pp=c.p; \ |
|||
if (a != NULL) (*a)=ret; \ |
|||
return(ret); \ |
|||
err:\ |
|||
ASN1_MAC_H_err((e),c.error,c.line); \ |
|||
asn1_add_error(*pp,(int)(c.q- *pp)); \ |
|||
if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ |
|||
return(NULL) |
|||
|
|||
# define M_ASN1_D2I_end_sequence() \ |
|||
(((c.inf&1) == 0)?(c.slen <= 0): \ |
|||
(c.eos=ASN1_const_check_infinite_end(&c.p,c.slen))) |
|||
|
|||
/* Don't use this with d2i_ASN1_BOOLEAN() */ |
|||
# define M_ASN1_D2I_get(b, func) \ |
|||
c.q=c.p; \ |
|||
if (func(&(b),&c.p,c.slen) == NULL) \ |
|||
{c.line=__LINE__; goto err; } \ |
|||
c.slen-=(c.p-c.q); |
|||
|
|||
/* Don't use this with d2i_ASN1_BOOLEAN() */ |
|||
# define M_ASN1_D2I_get_x(type,b,func) \ |
|||
c.q=c.p; \ |
|||
if (((D2I_OF(type))func)(&(b),&c.p,c.slen) == NULL) \ |
|||
{c.line=__LINE__; goto err; } \ |
|||
c.slen-=(c.p-c.q); |
|||
|
|||
/* use this instead () */ |
|||
# define M_ASN1_D2I_get_int(b,func) \ |
|||
c.q=c.p; \ |
|||
if (func(&(b),&c.p,c.slen) < 0) \ |
|||
{c.line=__LINE__; goto err; } \ |
|||
c.slen-=(c.p-c.q); |
|||
|
|||
# define M_ASN1_D2I_get_opt(b,func,type) \ |
|||
if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ |
|||
== (V_ASN1_UNIVERSAL|(type)))) \ |
|||
{ \ |
|||
M_ASN1_D2I_get(b,func); \ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_int_opt(b,func,type) \ |
|||
if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ |
|||
== (V_ASN1_UNIVERSAL|(type)))) \ |
|||
{ \ |
|||
M_ASN1_D2I_get_int(b,func); \ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_imp(b,func, type) \ |
|||
M_ASN1_next=(_tmp& V_ASN1_CONSTRUCTED)|type; \ |
|||
c.q=c.p; \ |
|||
if (func(&(b),&c.p,c.slen) == NULL) \ |
|||
{c.line=__LINE__; M_ASN1_next_prev = _tmp; goto err; } \ |
|||
c.slen-=(c.p-c.q);\ |
|||
M_ASN1_next_prev=_tmp; |
|||
|
|||
# define M_ASN1_D2I_get_IMP_opt(b,func,tag,type) \ |
|||
if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) == \ |
|||
(V_ASN1_CONTEXT_SPECIFIC|(tag)))) \ |
|||
{ \ |
|||
unsigned char _tmp = M_ASN1_next; \ |
|||
M_ASN1_D2I_get_imp(b,func, type);\ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_set(r,func,free_func) \ |
|||
M_ASN1_D2I_get_imp_set(r,func,free_func, \ |
|||
V_ASN1_SET,V_ASN1_UNIVERSAL); |
|||
|
|||
# define M_ASN1_D2I_get_set_type(type,r,func,free_func) \ |
|||
M_ASN1_D2I_get_imp_set_type(type,r,func,free_func, \ |
|||
V_ASN1_SET,V_ASN1_UNIVERSAL); |
|||
|
|||
# define M_ASN1_D2I_get_set_opt(r,func,free_func) \ |
|||
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
|||
V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ |
|||
{ M_ASN1_D2I_get_set(r,func,free_func); } |
|||
|
|||
# define M_ASN1_D2I_get_set_opt_type(type,r,func,free_func) \ |
|||
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
|||
V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ |
|||
{ M_ASN1_D2I_get_set_type(type,r,func,free_func); } |
|||
|
|||
# define M_ASN1_I2D_len_SET_opt(a,f) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
M_ASN1_I2D_len_SET(a,f); |
|||
|
|||
# define M_ASN1_I2D_put_SET_opt(a,f) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
M_ASN1_I2D_put_SET(a,f); |
|||
|
|||
# define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
M_ASN1_I2D_put_SEQUENCE(a,f); |
|||
|
|||
# define M_ASN1_I2D_put_SEQUENCE_opt_type(type,a,f) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
M_ASN1_I2D_put_SEQUENCE_type(type,a,f); |
|||
|
|||
# define M_ASN1_D2I_get_IMP_set_opt(b,func,free_func,tag) \ |
|||
if ((c.slen != 0) && \ |
|||
(M_ASN1_next == \ |
|||
(V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ |
|||
{ \ |
|||
M_ASN1_D2I_get_imp_set(b,func,free_func,\ |
|||
tag,V_ASN1_CONTEXT_SPECIFIC); \ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_IMP_set_opt_type(type,b,func,free_func,tag) \ |
|||
if ((c.slen != 0) && \ |
|||
(M_ASN1_next == \ |
|||
(V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ |
|||
{ \ |
|||
M_ASN1_D2I_get_imp_set_type(type,b,func,free_func,\ |
|||
tag,V_ASN1_CONTEXT_SPECIFIC); \ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_seq(r,func,free_func) \ |
|||
M_ASN1_D2I_get_imp_set(r,func,free_func,\ |
|||
V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL); |
|||
|
|||
# define M_ASN1_D2I_get_seq_type(type,r,func,free_func) \ |
|||
M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ |
|||
V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) |
|||
|
|||
# define M_ASN1_D2I_get_seq_opt(r,func,free_func) \ |
|||
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
|||
V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ |
|||
{ M_ASN1_D2I_get_seq(r,func,free_func); } |
|||
|
|||
# define M_ASN1_D2I_get_seq_opt_type(type,r,func,free_func) \ |
|||
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
|||
V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ |
|||
{ M_ASN1_D2I_get_seq_type(type,r,func,free_func); } |
|||
|
|||
# define M_ASN1_D2I_get_IMP_set(r,func,free_func,x) \ |
|||
M_ASN1_D2I_get_imp_set(r,func,free_func,\ |
|||
x,V_ASN1_CONTEXT_SPECIFIC); |
|||
|
|||
# define M_ASN1_D2I_get_IMP_set_type(type,r,func,free_func,x) \ |
|||
M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ |
|||
x,V_ASN1_CONTEXT_SPECIFIC); |
|||
|
|||
# define M_ASN1_D2I_get_imp_set(r,func,free_func,a,b) \ |
|||
c.q=c.p; \ |
|||
if (d2i_ASN1_SET(&(r),&c.p,c.slen,(char *(*)())func,\ |
|||
(void (*)())free_func,a,b) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
c.slen-=(c.p-c.q); |
|||
|
|||
# define M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,a,b) \ |
|||
c.q=c.p; \ |
|||
if (d2i_ASN1_SET_OF_##type(&(r),&c.p,c.slen,func,\ |
|||
free_func,a,b) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
c.slen-=(c.p-c.q); |
|||
|
|||
# define M_ASN1_D2I_get_set_strings(r,func,a,b) \ |
|||
c.q=c.p; \ |
|||
if (d2i_ASN1_STRING_SET(&(r),&c.p,c.slen,a,b) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
c.slen-=(c.p-c.q); |
|||
|
|||
# define M_ASN1_D2I_get_EXP_opt(r,func,tag) \ |
|||
if ((c.slen != 0L) && (M_ASN1_next == \ |
|||
(V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ |
|||
{ \ |
|||
int Tinf,Ttag,Tclass; \ |
|||
long Tlen; \ |
|||
\ |
|||
c.q=c.p; \ |
|||
Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ |
|||
if (Tinf & 0x80) \ |
|||
{ c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ |
|||
c.line=__LINE__; goto err; } \ |
|||
if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ |
|||
Tlen = c.slen - (c.p - c.q) - 2; \ |
|||
if (func(&(r),&c.p,Tlen) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ |
|||
Tlen = c.slen - (c.p - c.q); \ |
|||
if(!ASN1_const_check_infinite_end(&c.p, Tlen)) \ |
|||
{ c.error=ERR_R_MISSING_ASN1_EOS; \ |
|||
c.line=__LINE__; goto err; } \ |
|||
}\ |
|||
c.slen-=(c.p-c.q); \ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_EXP_set_opt(r,func,free_func,tag,b) \ |
|||
if ((c.slen != 0) && (M_ASN1_next == \ |
|||
(V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ |
|||
{ \ |
|||
int Tinf,Ttag,Tclass; \ |
|||
long Tlen; \ |
|||
\ |
|||
c.q=c.p; \ |
|||
Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ |
|||
if (Tinf & 0x80) \ |
|||
{ c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ |
|||
c.line=__LINE__; goto err; } \ |
|||
if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ |
|||
Tlen = c.slen - (c.p - c.q) - 2; \ |
|||
if (d2i_ASN1_SET(&(r),&c.p,Tlen,(char *(*)())func, \ |
|||
(void (*)())free_func, \ |
|||
b,V_ASN1_UNIVERSAL) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ |
|||
Tlen = c.slen - (c.p - c.q); \ |
|||
if(!ASN1_check_infinite_end(&c.p, Tlen)) \ |
|||
{ c.error=ERR_R_MISSING_ASN1_EOS; \ |
|||
c.line=__LINE__; goto err; } \ |
|||
}\ |
|||
c.slen-=(c.p-c.q); \ |
|||
} |
|||
|
|||
# define M_ASN1_D2I_get_EXP_set_opt_type(type,r,func,free_func,tag,b) \ |
|||
if ((c.slen != 0) && (M_ASN1_next == \ |
|||
(V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ |
|||
{ \ |
|||
int Tinf,Ttag,Tclass; \ |
|||
long Tlen; \ |
|||
\ |
|||
c.q=c.p; \ |
|||
Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ |
|||
if (Tinf & 0x80) \ |
|||
{ c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ |
|||
c.line=__LINE__; goto err; } \ |
|||
if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ |
|||
Tlen = c.slen - (c.p - c.q) - 2; \ |
|||
if (d2i_ASN1_SET_OF_##type(&(r),&c.p,Tlen,func, \ |
|||
free_func,b,V_ASN1_UNIVERSAL) == NULL) \ |
|||
{ c.line=__LINE__; goto err; } \ |
|||
if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ |
|||
Tlen = c.slen - (c.p - c.q); \ |
|||
if(!ASN1_check_infinite_end(&c.p, Tlen)) \ |
|||
{ c.error=ERR_R_MISSING_ASN1_EOS; \ |
|||
c.line=__LINE__; goto err; } \ |
|||
}\ |
|||
c.slen-=(c.p-c.q); \ |
|||
} |
|||
|
|||
/* New macros */ |
|||
# define M_ASN1_New_Malloc(ret,type) \ |
|||
if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) \ |
|||
{ c.line=__LINE__; goto err2; } |
|||
|
|||
# define M_ASN1_New(arg,func) \ |
|||
if (((arg)=func()) == NULL) return(NULL) |
|||
|
|||
# define M_ASN1_New_Error(a) \ |
|||
/*- err: ASN1_MAC_H_err((a),ERR_R_NESTED_ASN1_ERROR,c.line); \
|
|||
return(NULL);*/ \ |
|||
err2: ASN1_MAC_H_err((a),ERR_R_MALLOC_FAILURE,c.line); \ |
|||
return(NULL) |
|||
|
|||
/*
|
|||
* BIG UGLY WARNING! This is so damn ugly I wanna puke. Unfortunately, some |
|||
* macros that use ASN1_const_CTX still insist on writing in the input |
|||
* stream. ARGH! ARGH! ARGH! Let's get rid of this macro package. Please? -- |
|||
* Richard Levitte |
|||
*/ |
|||
# define M_ASN1_next (*((unsigned char *)(c.p))) |
|||
# define M_ASN1_next_prev (*((unsigned char *)(c.q))) |
|||
|
|||
/*************************************************/ |
|||
|
|||
# define M_ASN1_I2D_vars(a) int r=0,ret=0; \ |
|||
unsigned char *p; \ |
|||
if (a == NULL) return(0) |
|||
|
|||
/* Length Macros */ |
|||
# define M_ASN1_I2D_len(a,f) ret+=f(a,NULL) |
|||
# define M_ASN1_I2D_len_IMP_opt(a,f) if (a != NULL) M_ASN1_I2D_len(a,f) |
|||
|
|||
# define M_ASN1_I2D_len_SET(a,f) \ |
|||
ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET); |
|||
|
|||
# define M_ASN1_I2D_len_SET_type(type,a,f) \ |
|||
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SET, \ |
|||
V_ASN1_UNIVERSAL,IS_SET); |
|||
|
|||
# define M_ASN1_I2D_len_SEQUENCE(a,f) \ |
|||
ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \ |
|||
IS_SEQUENCE); |
|||
|
|||
# define M_ASN1_I2D_len_SEQUENCE_type(type,a,f) \ |
|||
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SEQUENCE, \ |
|||
V_ASN1_UNIVERSAL,IS_SEQUENCE) |
|||
|
|||
# define M_ASN1_I2D_len_SEQUENCE_opt(a,f) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
M_ASN1_I2D_len_SEQUENCE(a,f); |
|||
|
|||
# define M_ASN1_I2D_len_SEQUENCE_opt_type(type,a,f) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
M_ASN1_I2D_len_SEQUENCE_type(type,a,f); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SET(a,f,x) \ |
|||
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SET_type(type,a,f,x) \ |
|||
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ |
|||
V_ASN1_CONTEXT_SPECIFIC,IS_SET); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SET_opt(a,f,x) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SET); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SET_opt_type(type,a,f,x) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ |
|||
V_ASN1_CONTEXT_SPECIFIC,IS_SET); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SEQUENCE(a,f,x) \ |
|||
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SEQUENCE); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SEQUENCE_opt(a,f,x) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SEQUENCE); |
|||
|
|||
# define M_ASN1_I2D_len_IMP_SEQUENCE_opt_type(type,a,f,x) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ |
|||
V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SEQUENCE); |
|||
|
|||
# define M_ASN1_I2D_len_EXP_opt(a,f,mtag,v) \ |
|||
if (a != NULL)\ |
|||
{ \ |
|||
v=f(a,NULL); \ |
|||
ret+=ASN1_object_size(1,v,mtag); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_len_EXP_SET_opt(a,f,mtag,tag,v) \ |
|||
if ((a != NULL) && (sk_num(a) != 0))\ |
|||
{ \ |
|||
v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL,IS_SET); \ |
|||
ret+=ASN1_object_size(1,v,mtag); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_len_EXP_SEQUENCE_opt(a,f,mtag,tag,v) \ |
|||
if ((a != NULL) && (sk_num(a) != 0))\ |
|||
{ \ |
|||
v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL, \ |
|||
IS_SEQUENCE); \ |
|||
ret+=ASN1_object_size(1,v,mtag); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_len_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0))\ |
|||
{ \ |
|||
v=i2d_ASN1_SET_OF_##type(a,NULL,f,tag, \ |
|||
V_ASN1_UNIVERSAL, \ |
|||
IS_SEQUENCE); \ |
|||
ret+=ASN1_object_size(1,v,mtag); \ |
|||
} |
|||
|
|||
/* Put Macros */ |
|||
# define M_ASN1_I2D_put(a,f) f(a,&p) |
|||
|
|||
# define M_ASN1_I2D_put_IMP_opt(a,f,t) \ |
|||
if (a != NULL) \ |
|||
{ \ |
|||
unsigned char *q=p; \ |
|||
f(a,&p); \ |
|||
*q=(V_ASN1_CONTEXT_SPECIFIC|t|(*q&V_ASN1_CONSTRUCTED));\ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_put_SET(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SET,\ |
|||
V_ASN1_UNIVERSAL,IS_SET) |
|||
# define M_ASN1_I2D_put_SET_type(type,a,f) \ |
|||
i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET) |
|||
# define M_ASN1_I2D_put_IMP_SET(a,f,x) i2d_ASN1_SET(a,&p,f,x,\ |
|||
V_ASN1_CONTEXT_SPECIFIC,IS_SET) |
|||
# define M_ASN1_I2D_put_IMP_SET_type(type,a,f,x) \ |
|||
i2d_ASN1_SET_OF_##type(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET) |
|||
# define M_ASN1_I2D_put_IMP_SEQUENCE(a,f,x) i2d_ASN1_SET(a,&p,f,x,\ |
|||
V_ASN1_CONTEXT_SPECIFIC,IS_SEQUENCE) |
|||
|
|||
# define M_ASN1_I2D_put_SEQUENCE(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SEQUENCE,\ |
|||
V_ASN1_UNIVERSAL,IS_SEQUENCE) |
|||
|
|||
# define M_ASN1_I2D_put_SEQUENCE_type(type,a,f) \ |
|||
i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \ |
|||
IS_SEQUENCE) |
|||
|
|||
# define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
M_ASN1_I2D_put_SEQUENCE(a,f); |
|||
|
|||
# define M_ASN1_I2D_put_IMP_SET_opt(a,f,x) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
{ i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SET); } |
|||
|
|||
# define M_ASN1_I2D_put_IMP_SET_opt_type(type,a,f,x) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
{ i2d_ASN1_SET_OF_##type(a,&p,f,x, \ |
|||
V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SET); } |
|||
|
|||
# define M_ASN1_I2D_put_IMP_SEQUENCE_opt(a,f,x) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
{ i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SEQUENCE); } |
|||
|
|||
# define M_ASN1_I2D_put_IMP_SEQUENCE_opt_type(type,a,f,x) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
{ i2d_ASN1_SET_OF_##type(a,&p,f,x, \ |
|||
V_ASN1_CONTEXT_SPECIFIC, \ |
|||
IS_SEQUENCE); } |
|||
|
|||
# define M_ASN1_I2D_put_EXP_opt(a,f,tag,v) \ |
|||
if (a != NULL) \ |
|||
{ \ |
|||
ASN1_put_object(&p,1,v,tag,V_ASN1_CONTEXT_SPECIFIC); \ |
|||
f(a,&p); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_put_EXP_SET_opt(a,f,mtag,tag,v) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
{ \ |
|||
ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ |
|||
i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SET); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_put_EXP_SEQUENCE_opt(a,f,mtag,tag,v) \ |
|||
if ((a != NULL) && (sk_num(a) != 0)) \ |
|||
{ \ |
|||
ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ |
|||
i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SEQUENCE); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_put_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \ |
|||
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
|||
{ \ |
|||
ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ |
|||
i2d_ASN1_SET_OF_##type(a,&p,f,tag,V_ASN1_UNIVERSAL, \ |
|||
IS_SEQUENCE); \ |
|||
} |
|||
|
|||
# define M_ASN1_I2D_seq_total() \ |
|||
r=ASN1_object_size(1,ret,V_ASN1_SEQUENCE); \ |
|||
if (pp == NULL) return(r); \ |
|||
p= *pp; \ |
|||
ASN1_put_object(&p,1,ret,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) |
|||
|
|||
# define M_ASN1_I2D_INF_seq_start(tag,ctx) \ |
|||
*(p++)=(V_ASN1_CONSTRUCTED|(tag)|(ctx)); \ |
|||
*(p++)=0x80 |
|||
|
|||
# define M_ASN1_I2D_INF_seq_end() *(p++)=0x00; *(p++)=0x00 |
|||
|
|||
# define M_ASN1_I2D_finish() *pp=p; \ |
|||
return(r); |
|||
|
|||
int asn1_GetSequence(ASN1_const_CTX *c, long *length); |
|||
void asn1_add_error(const unsigned char *address, int offset); |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,973 +0,0 @@ |
|||
/* asn1t.h */ |
|||
/*
|
|||
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project |
|||
* 2000. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
#ifndef HEADER_ASN1T_H |
|||
# define HEADER_ASN1T_H |
|||
|
|||
# include <stddef.h> |
|||
# include <openssl/e_os2.h> |
|||
# include <openssl/asn1.h> |
|||
|
|||
# ifdef OPENSSL_BUILD_SHLIBCRYPTO |
|||
# undef OPENSSL_EXTERN |
|||
# define OPENSSL_EXTERN OPENSSL_EXPORT |
|||
# endif |
|||
|
|||
/* ASN1 template defines, structures and functions */ |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION |
|||
|
|||
/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ |
|||
# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) |
|||
|
|||
/* Macros for start and end of ASN1_ITEM definition */ |
|||
|
|||
# define ASN1_ITEM_start(itname) \ |
|||
OPENSSL_GLOBAL const ASN1_ITEM itname##_it = { |
|||
|
|||
# define ASN1_ITEM_end(itname) \ |
|||
}; |
|||
|
|||
# else |
|||
|
|||
/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ |
|||
# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr())) |
|||
|
|||
/* Macros for start and end of ASN1_ITEM definition */ |
|||
|
|||
# define ASN1_ITEM_start(itname) \ |
|||
const ASN1_ITEM * itname##_it(void) \ |
|||
{ \ |
|||
static const ASN1_ITEM local_it = { |
|||
|
|||
# define ASN1_ITEM_end(itname) \ |
|||
}; \ |
|||
return &local_it; \ |
|||
} |
|||
|
|||
# endif |
|||
|
|||
/* Macros to aid ASN1 template writing */ |
|||
|
|||
# define ASN1_ITEM_TEMPLATE(tname) \ |
|||
static const ASN1_TEMPLATE tname##_item_tt |
|||
|
|||
# define ASN1_ITEM_TEMPLATE_END(tname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_PRIMITIVE,\ |
|||
-1,\ |
|||
&tname##_item_tt,\ |
|||
0,\ |
|||
NULL,\ |
|||
0,\ |
|||
#tname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
/* This is a ASN1 type which just embeds a template */ |
|||
|
|||
/*-
|
|||
* This pair helps declare a SEQUENCE. We can do: |
|||
* |
|||
* ASN1_SEQUENCE(stname) = { |
|||
* ... SEQUENCE components ... |
|||
* } ASN1_SEQUENCE_END(stname) |
|||
* |
|||
* This will produce an ASN1_ITEM called stname_it |
|||
* for a structure called stname. |
|||
* |
|||
* If you want the same structure but a different |
|||
* name then use: |
|||
* |
|||
* ASN1_SEQUENCE(itname) = { |
|||
* ... SEQUENCE components ... |
|||
* } ASN1_SEQUENCE_END_name(stname, itname) |
|||
* |
|||
* This will create an item called itname_it using |
|||
* a structure called stname. |
|||
*/ |
|||
|
|||
# define ASN1_SEQUENCE(tname) \ |
|||
static const ASN1_TEMPLATE tname##_seq_tt[] |
|||
|
|||
# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) |
|||
|
|||
# define ASN1_SEQUENCE_END_name(stname, tname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_SEQUENCE,\ |
|||
V_ASN1_SEQUENCE,\ |
|||
tname##_seq_tt,\ |
|||
sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ |
|||
NULL,\ |
|||
sizeof(stname),\ |
|||
#stname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
# define ASN1_NDEF_SEQUENCE(tname) \ |
|||
ASN1_SEQUENCE(tname) |
|||
|
|||
# define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ |
|||
ASN1_SEQUENCE_cb(tname, cb) |
|||
|
|||
# define ASN1_SEQUENCE_cb(tname, cb) \ |
|||
static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ |
|||
ASN1_SEQUENCE(tname) |
|||
|
|||
# define ASN1_BROKEN_SEQUENCE(tname) \ |
|||
static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ |
|||
ASN1_SEQUENCE(tname) |
|||
|
|||
# define ASN1_SEQUENCE_ref(tname, cb, lck) \ |
|||
static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), lck, cb, 0}; \ |
|||
ASN1_SEQUENCE(tname) |
|||
|
|||
# define ASN1_SEQUENCE_enc(tname, enc, cb) \ |
|||
static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ |
|||
ASN1_SEQUENCE(tname) |
|||
|
|||
# define ASN1_NDEF_SEQUENCE_END(tname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_NDEF_SEQUENCE,\ |
|||
V_ASN1_SEQUENCE,\ |
|||
tname##_seq_tt,\ |
|||
sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ |
|||
NULL,\ |
|||
sizeof(tname),\ |
|||
#tname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
# define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) |
|||
|
|||
# define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) |
|||
|
|||
# define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) |
|||
|
|||
# define ASN1_SEQUENCE_END_ref(stname, tname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_SEQUENCE,\ |
|||
V_ASN1_SEQUENCE,\ |
|||
tname##_seq_tt,\ |
|||
sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ |
|||
&tname##_aux,\ |
|||
sizeof(stname),\ |
|||
#stname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
# define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_NDEF_SEQUENCE,\ |
|||
V_ASN1_SEQUENCE,\ |
|||
tname##_seq_tt,\ |
|||
sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ |
|||
&tname##_aux,\ |
|||
sizeof(stname),\ |
|||
#stname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
/*-
|
|||
* This pair helps declare a CHOICE type. We can do: |
|||
* |
|||
* ASN1_CHOICE(chname) = { |
|||
* ... CHOICE options ... |
|||
* ASN1_CHOICE_END(chname) |
|||
* |
|||
* This will produce an ASN1_ITEM called chname_it |
|||
* for a structure called chname. The structure |
|||
* definition must look like this: |
|||
* typedef struct { |
|||
* int type; |
|||
* union { |
|||
* ASN1_SOMETHING *opt1; |
|||
* ASN1_SOMEOTHER *opt2; |
|||
* } value; |
|||
* } chname; |
|||
* |
|||
* the name of the selector must be 'type'. |
|||
* to use an alternative selector name use the |
|||
* ASN1_CHOICE_END_selector() version. |
|||
*/ |
|||
|
|||
# define ASN1_CHOICE(tname) \ |
|||
static const ASN1_TEMPLATE tname##_ch_tt[] |
|||
|
|||
# define ASN1_CHOICE_cb(tname, cb) \ |
|||
static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ |
|||
ASN1_CHOICE(tname) |
|||
|
|||
# define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) |
|||
|
|||
# define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) |
|||
|
|||
# define ASN1_CHOICE_END_selector(stname, tname, selname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_CHOICE,\ |
|||
offsetof(stname,selname) ,\ |
|||
tname##_ch_tt,\ |
|||
sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ |
|||
NULL,\ |
|||
sizeof(stname),\ |
|||
#stname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
# define ASN1_CHOICE_END_cb(stname, tname, selname) \ |
|||
;\ |
|||
ASN1_ITEM_start(tname) \ |
|||
ASN1_ITYPE_CHOICE,\ |
|||
offsetof(stname,selname) ,\ |
|||
tname##_ch_tt,\ |
|||
sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ |
|||
&tname##_aux,\ |
|||
sizeof(stname),\ |
|||
#stname \ |
|||
ASN1_ITEM_end(tname) |
|||
|
|||
/* This helps with the template wrapper form of ASN1_ITEM */ |
|||
|
|||
# define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ |
|||
(flags), (tag), 0,\ |
|||
#name, ASN1_ITEM_ref(type) } |
|||
|
|||
/* These help with SEQUENCE or CHOICE components */ |
|||
|
|||
/* used to declare other types */ |
|||
|
|||
# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ |
|||
(flags), (tag), offsetof(stname, field),\ |
|||
#field, ASN1_ITEM_ref(type) } |
|||
|
|||
/* used when the structure is combined with the parent */ |
|||
|
|||
# define ASN1_EX_COMBINE(flags, tag, type) { \ |
|||
(flags)|ASN1_TFLG_COMBINE, (tag), 0, NULL, ASN1_ITEM_ref(type) } |
|||
|
|||
/* implicit and explicit helper macros */ |
|||
|
|||
# define ASN1_IMP_EX(stname, field, type, tag, ex) \ |
|||
ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type) |
|||
|
|||
# define ASN1_EXP_EX(stname, field, type, tag, ex) \ |
|||
ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type) |
|||
|
|||
/* Any defined by macros: the field used is in the table itself */ |
|||
|
|||
# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION |
|||
# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } |
|||
# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } |
|||
# else |
|||
# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb } |
|||
# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb } |
|||
# endif |
|||
/* Plain simple type */ |
|||
# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) |
|||
|
|||
/* OPTIONAL simple type */ |
|||
# define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) |
|||
|
|||
/* IMPLICIT tagged simple type */ |
|||
# define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) |
|||
|
|||
/* IMPLICIT tagged OPTIONAL simple type */ |
|||
# define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) |
|||
|
|||
/* Same as above but EXPLICIT */ |
|||
|
|||
# define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) |
|||
# define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) |
|||
|
|||
/* SEQUENCE OF type */ |
|||
# define ASN1_SEQUENCE_OF(stname, field, type) \ |
|||
ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) |
|||
|
|||
/* OPTIONAL SEQUENCE OF */ |
|||
# define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ |
|||
ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) |
|||
|
|||
/* Same as above but for SET OF */ |
|||
|
|||
# define ASN1_SET_OF(stname, field, type) \ |
|||
ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) |
|||
|
|||
# define ASN1_SET_OF_OPT(stname, field, type) \ |
|||
ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) |
|||
|
|||
/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ |
|||
|
|||
# define ASN1_IMP_SET_OF(stname, field, type, tag) \ |
|||
ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) |
|||
|
|||
# define ASN1_EXP_SET_OF(stname, field, type, tag) \ |
|||
ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) |
|||
|
|||
# define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ |
|||
ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) |
|||
|
|||
# define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ |
|||
ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) |
|||
|
|||
# define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ |
|||
ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) |
|||
|
|||
# define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ |
|||
ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) |
|||
|
|||
# define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ |
|||
ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) |
|||
|
|||
# define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ |
|||
ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) |
|||
|
|||
/* EXPLICIT using indefinite length constructed form */ |
|||
# define ASN1_NDEF_EXP(stname, field, type, tag) \ |
|||
ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) |
|||
|
|||
/* EXPLICIT OPTIONAL using indefinite length constructed form */ |
|||
# define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ |
|||
ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) |
|||
|
|||
/* Macros for the ASN1_ADB structure */ |
|||
|
|||
# define ASN1_ADB(name) \ |
|||
static const ASN1_ADB_TABLE name##_adbtbl[] |
|||
|
|||
# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION |
|||
|
|||
# define ASN1_ADB_END(name, flags, field, app_table, def, none) \ |
|||
;\ |
|||
static const ASN1_ADB name##_adb = {\ |
|||
flags,\ |
|||
offsetof(name, field),\ |
|||
app_table,\ |
|||
name##_adbtbl,\ |
|||
sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ |
|||
def,\ |
|||
none\ |
|||
} |
|||
|
|||
# else |
|||
|
|||
# define ASN1_ADB_END(name, flags, field, app_table, def, none) \ |
|||
;\ |
|||
static const ASN1_ITEM *name##_adb(void) \ |
|||
{ \ |
|||
static const ASN1_ADB internal_adb = \ |
|||
{\ |
|||
flags,\ |
|||
offsetof(name, field),\ |
|||
app_table,\ |
|||
name##_adbtbl,\ |
|||
sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ |
|||
def,\ |
|||
none\ |
|||
}; \ |
|||
return (const ASN1_ITEM *) &internal_adb; \ |
|||
} \ |
|||
void dummy_function(void) |
|||
|
|||
# endif |
|||
|
|||
# define ADB_ENTRY(val, template) {val, template} |
|||
|
|||
# define ASN1_ADB_TEMPLATE(name) \ |
|||
static const ASN1_TEMPLATE name##_tt |
|||
|
|||
/*
|
|||
* This is the ASN1 template structure that defines a wrapper round the |
|||
* actual type. It determines the actual position of the field in the value |
|||
* structure, various flags such as OPTIONAL and the field name. |
|||
*/ |
|||
|
|||
struct ASN1_TEMPLATE_st { |
|||
unsigned long flags; /* Various flags */ |
|||
long tag; /* tag, not used if no tagging */ |
|||
unsigned long offset; /* Offset of this field in structure */ |
|||
# ifndef NO_ASN1_FIELD_NAMES |
|||
const char *field_name; /* Field name */ |
|||
# endif |
|||
ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ |
|||
}; |
|||
|
|||
/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ |
|||
|
|||
# define ASN1_TEMPLATE_item(t) (t->item_ptr) |
|||
# define ASN1_TEMPLATE_adb(t) (t->item_ptr) |
|||
|
|||
typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; |
|||
typedef struct ASN1_ADB_st ASN1_ADB; |
|||
|
|||
struct ASN1_ADB_st { |
|||
unsigned long flags; /* Various flags */ |
|||
unsigned long offset; /* Offset of selector field */ |
|||
STACK_OF(ASN1_ADB_TABLE) **app_items; /* Application defined items */ |
|||
const ASN1_ADB_TABLE *tbl; /* Table of possible types */ |
|||
long tblcount; /* Number of entries in tbl */ |
|||
const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ |
|||
const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ |
|||
}; |
|||
|
|||
struct ASN1_ADB_TABLE_st { |
|||
long value; /* NID for an object or value for an int */ |
|||
const ASN1_TEMPLATE tt; /* item for this value */ |
|||
}; |
|||
|
|||
/* template flags */ |
|||
|
|||
/* Field is optional */ |
|||
# define ASN1_TFLG_OPTIONAL (0x1) |
|||
|
|||
/* Field is a SET OF */ |
|||
# define ASN1_TFLG_SET_OF (0x1 << 1) |
|||
|
|||
/* Field is a SEQUENCE OF */ |
|||
# define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) |
|||
|
|||
/*
|
|||
* Special case: this refers to a SET OF that will be sorted into DER order |
|||
* when encoded *and* the corresponding STACK will be modified to match the |
|||
* new order. |
|||
*/ |
|||
# define ASN1_TFLG_SET_ORDER (0x3 << 1) |
|||
|
|||
/* Mask for SET OF or SEQUENCE OF */ |
|||
# define ASN1_TFLG_SK_MASK (0x3 << 1) |
|||
|
|||
/*
|
|||
* These flags mean the tag should be taken from the tag field. If EXPLICIT |
|||
* then the underlying type is used for the inner tag. |
|||
*/ |
|||
|
|||
/* IMPLICIT tagging */ |
|||
# define ASN1_TFLG_IMPTAG (0x1 << 3) |
|||
|
|||
/* EXPLICIT tagging, inner tag from underlying type */ |
|||
# define ASN1_TFLG_EXPTAG (0x2 << 3) |
|||
|
|||
# define ASN1_TFLG_TAG_MASK (0x3 << 3) |
|||
|
|||
/* context specific IMPLICIT */ |
|||
# define ASN1_TFLG_IMPLICIT ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT |
|||
|
|||
/* context specific EXPLICIT */ |
|||
# define ASN1_TFLG_EXPLICIT ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT |
|||
|
|||
/*
|
|||
* If tagging is in force these determine the type of tag to use. Otherwise |
|||
* the tag is determined by the underlying type. These values reflect the |
|||
* actual octet format. |
|||
*/ |
|||
|
|||
/* Universal tag */ |
|||
# define ASN1_TFLG_UNIVERSAL (0x0<<6) |
|||
/* Application tag */ |
|||
# define ASN1_TFLG_APPLICATION (0x1<<6) |
|||
/* Context specific tag */ |
|||
# define ASN1_TFLG_CONTEXT (0x2<<6) |
|||
/* Private tag */ |
|||
# define ASN1_TFLG_PRIVATE (0x3<<6) |
|||
|
|||
# define ASN1_TFLG_TAG_CLASS (0x3<<6) |
|||
|
|||
/*
|
|||
* These are for ANY DEFINED BY type. In this case the 'item' field points to |
|||
* an ASN1_ADB structure which contains a table of values to decode the |
|||
* relevant type |
|||
*/ |
|||
|
|||
# define ASN1_TFLG_ADB_MASK (0x3<<8) |
|||
|
|||
# define ASN1_TFLG_ADB_OID (0x1<<8) |
|||
|
|||
# define ASN1_TFLG_ADB_INT (0x1<<9) |
|||
|
|||
/*
|
|||
* This flag means a parent structure is passed instead of the field: this is |
|||
* useful is a SEQUENCE is being combined with a CHOICE for example. Since |
|||
* this means the structure and item name will differ we need to use the |
|||
* ASN1_CHOICE_END_name() macro for example. |
|||
*/ |
|||
|
|||
# define ASN1_TFLG_COMBINE (0x1<<10) |
|||
|
|||
/*
|
|||
* This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes |
|||
* indefinite length constructed encoding to be used if required. |
|||
*/ |
|||
|
|||
# define ASN1_TFLG_NDEF (0x1<<11) |
|||
|
|||
/* This is the actual ASN1 item itself */ |
|||
|
|||
struct ASN1_ITEM_st { |
|||
char itype; /* The item type, primitive, SEQUENCE, CHOICE
|
|||
* or extern */ |
|||
long utype; /* underlying type */ |
|||
const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
|
|||
* the contents */ |
|||
long tcount; /* Number of templates if SEQUENCE or CHOICE */ |
|||
const void *funcs; /* functions that handle this type */ |
|||
long size; /* Structure size (usually) */ |
|||
# ifndef NO_ASN1_FIELD_NAMES |
|||
const char *sname; /* Structure name */ |
|||
# endif |
|||
}; |
|||
|
|||
/*-
|
|||
* These are values for the itype field and |
|||
* determine how the type is interpreted. |
|||
* |
|||
* For PRIMITIVE types the underlying type |
|||
* determines the behaviour if items is NULL. |
|||
* |
|||
* Otherwise templates must contain a single |
|||
* template and the type is treated in the |
|||
* same way as the type specified in the template. |
|||
* |
|||
* For SEQUENCE types the templates field points |
|||
* to the members, the size field is the |
|||
* structure size. |
|||
* |
|||
* For CHOICE types the templates field points |
|||
* to each possible member (typically a union) |
|||
* and the 'size' field is the offset of the |
|||
* selector. |
|||
* |
|||
* The 'funcs' field is used for application |
|||
* specific functions. |
|||
* |
|||
* For COMPAT types the funcs field gives a |
|||
* set of functions that handle this type, this |
|||
* supports the old d2i, i2d convention. |
|||
* |
|||
* The EXTERN type uses a new style d2i/i2d. |
|||
* The new style should be used where possible |
|||
* because it avoids things like the d2i IMPLICIT |
|||
* hack. |
|||
* |
|||
* MSTRING is a multiple string type, it is used |
|||
* for a CHOICE of character strings where the |
|||
* actual strings all occupy an ASN1_STRING |
|||
* structure. In this case the 'utype' field |
|||
* has a special meaning, it is used as a mask |
|||
* of acceptable types using the B_ASN1 constants. |
|||
* |
|||
* NDEF_SEQUENCE is the same as SEQUENCE except |
|||
* that it will use indefinite length constructed |
|||
* encoding if requested. |
|||
* |
|||
*/ |
|||
|
|||
# define ASN1_ITYPE_PRIMITIVE 0x0 |
|||
|
|||
# define ASN1_ITYPE_SEQUENCE 0x1 |
|||
|
|||
# define ASN1_ITYPE_CHOICE 0x2 |
|||
|
|||
# define ASN1_ITYPE_COMPAT 0x3 |
|||
|
|||
# define ASN1_ITYPE_EXTERN 0x4 |
|||
|
|||
# define ASN1_ITYPE_MSTRING 0x5 |
|||
|
|||
# define ASN1_ITYPE_NDEF_SEQUENCE 0x6 |
|||
|
|||
/*
|
|||
* Cache for ASN1 tag and length, so we don't keep re-reading it for things |
|||
* like CHOICE |
|||
*/ |
|||
|
|||
struct ASN1_TLC_st { |
|||
char valid; /* Values below are valid */ |
|||
int ret; /* return value */ |
|||
long plen; /* length */ |
|||
int ptag; /* class value */ |
|||
int pclass; /* class value */ |
|||
int hdrlen; /* header length */ |
|||
}; |
|||
|
|||
/* Typedefs for ASN1 function pointers */ |
|||
|
|||
typedef ASN1_VALUE *ASN1_new_func(void); |
|||
typedef void ASN1_free_func(ASN1_VALUE *a); |
|||
typedef ASN1_VALUE *ASN1_d2i_func(ASN1_VALUE **a, const unsigned char **in, |
|||
long length); |
|||
typedef int ASN1_i2d_func(ASN1_VALUE *a, unsigned char **in); |
|||
|
|||
typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, |
|||
const ASN1_ITEM *it, int tag, int aclass, char opt, |
|||
ASN1_TLC *ctx); |
|||
|
|||
typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, |
|||
const ASN1_ITEM *it, int tag, int aclass); |
|||
typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
|
|||
typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, |
|||
int indent, const char *fname, |
|||
const ASN1_PCTX *pctx); |
|||
|
|||
typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, |
|||
int *putype, const ASN1_ITEM *it); |
|||
typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, |
|||
int len, int utype, char *free_cont, |
|||
const ASN1_ITEM *it); |
|||
typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, |
|||
const ASN1_ITEM *it, int indent, |
|||
const ASN1_PCTX *pctx); |
|||
|
|||
typedef struct ASN1_COMPAT_FUNCS_st { |
|||
ASN1_new_func *asn1_new; |
|||
ASN1_free_func *asn1_free; |
|||
ASN1_d2i_func *asn1_d2i; |
|||
ASN1_i2d_func *asn1_i2d; |
|||
} ASN1_COMPAT_FUNCS; |
|||
|
|||
typedef struct ASN1_EXTERN_FUNCS_st { |
|||
void *app_data; |
|||
ASN1_ex_new_func *asn1_ex_new; |
|||
ASN1_ex_free_func *asn1_ex_free; |
|||
ASN1_ex_free_func *asn1_ex_clear; |
|||
ASN1_ex_d2i *asn1_ex_d2i; |
|||
ASN1_ex_i2d *asn1_ex_i2d; |
|||
ASN1_ex_print_func *asn1_ex_print; |
|||
} ASN1_EXTERN_FUNCS; |
|||
|
|||
typedef struct ASN1_PRIMITIVE_FUNCS_st { |
|||
void *app_data; |
|||
unsigned long flags; |
|||
ASN1_ex_new_func *prim_new; |
|||
ASN1_ex_free_func *prim_free; |
|||
ASN1_ex_free_func *prim_clear; |
|||
ASN1_primitive_c2i *prim_c2i; |
|||
ASN1_primitive_i2c *prim_i2c; |
|||
ASN1_primitive_print *prim_print; |
|||
} ASN1_PRIMITIVE_FUNCS; |
|||
|
|||
/*
|
|||
* This is the ASN1_AUX structure: it handles various miscellaneous |
|||
* requirements. For example the use of reference counts and an informational |
|||
* callback. The "informational callback" is called at various points during |
|||
* the ASN1 encoding and decoding. It can be used to provide minor |
|||
* customisation of the structures used. This is most useful where the |
|||
* supplied routines *almost* do the right thing but need some extra help at |
|||
* a few points. If the callback returns zero then it is assumed a fatal |
|||
* error has occurred and the main operation should be abandoned. If major |
|||
* changes in the default behaviour are required then an external type is |
|||
* more appropriate. |
|||
*/ |
|||
|
|||
typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, |
|||
void *exarg); |
|||
|
|||
typedef struct ASN1_AUX_st { |
|||
void *app_data; |
|||
int flags; |
|||
int ref_offset; /* Offset of reference value */ |
|||
int ref_lock; /* Lock type to use */ |
|||
ASN1_aux_cb *asn1_cb; |
|||
int enc_offset; /* Offset of ASN1_ENCODING structure */ |
|||
} ASN1_AUX; |
|||
|
|||
/* For print related callbacks exarg points to this structure */ |
|||
typedef struct ASN1_PRINT_ARG_st { |
|||
BIO *out; |
|||
int indent; |
|||
const ASN1_PCTX *pctx; |
|||
} ASN1_PRINT_ARG; |
|||
|
|||
/* For streaming related callbacks exarg points to this structure */ |
|||
typedef struct ASN1_STREAM_ARG_st { |
|||
/* BIO to stream through */ |
|||
BIO *out; |
|||
/* BIO with filters appended */ |
|||
BIO *ndef_bio; |
|||
/* Streaming I/O boundary */ |
|||
unsigned char **boundary; |
|||
} ASN1_STREAM_ARG; |
|||
|
|||
/* Flags in ASN1_AUX */ |
|||
|
|||
/* Use a reference count */ |
|||
# define ASN1_AFLG_REFCOUNT 1 |
|||
/* Save the encoding of structure (useful for signatures) */ |
|||
# define ASN1_AFLG_ENCODING 2 |
|||
/* The Sequence length is invalid */ |
|||
# define ASN1_AFLG_BROKEN 4 |
|||
|
|||
/* operation values for asn1_cb */ |
|||
|
|||
# define ASN1_OP_NEW_PRE 0 |
|||
# define ASN1_OP_NEW_POST 1 |
|||
# define ASN1_OP_FREE_PRE 2 |
|||
# define ASN1_OP_FREE_POST 3 |
|||
# define ASN1_OP_D2I_PRE 4 |
|||
# define ASN1_OP_D2I_POST 5 |
|||
# define ASN1_OP_I2D_PRE 6 |
|||
# define ASN1_OP_I2D_POST 7 |
|||
# define ASN1_OP_PRINT_PRE 8 |
|||
# define ASN1_OP_PRINT_POST 9 |
|||
# define ASN1_OP_STREAM_PRE 10 |
|||
# define ASN1_OP_STREAM_POST 11 |
|||
# define ASN1_OP_DETACHED_PRE 12 |
|||
# define ASN1_OP_DETACHED_POST 13 |
|||
|
|||
/* Macro to implement a primitive type */ |
|||
# define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) |
|||
# define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ |
|||
ASN1_ITEM_start(itname) \ |
|||
ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ |
|||
ASN1_ITEM_end(itname) |
|||
|
|||
/* Macro to implement a multi string type */ |
|||
# define IMPLEMENT_ASN1_MSTRING(itname, mask) \ |
|||
ASN1_ITEM_start(itname) \ |
|||
ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ |
|||
ASN1_ITEM_end(itname) |
|||
|
|||
/* Macro to implement an ASN1_ITEM in terms of old style funcs */ |
|||
|
|||
# define IMPLEMENT_COMPAT_ASN1(sname) IMPLEMENT_COMPAT_ASN1_type(sname, V_ASN1_SEQUENCE) |
|||
|
|||
# define IMPLEMENT_COMPAT_ASN1_type(sname, tag) \ |
|||
static const ASN1_COMPAT_FUNCS sname##_ff = { \ |
|||
(ASN1_new_func *)sname##_new, \ |
|||
(ASN1_free_func *)sname##_free, \ |
|||
(ASN1_d2i_func *)d2i_##sname, \ |
|||
(ASN1_i2d_func *)i2d_##sname, \ |
|||
}; \ |
|||
ASN1_ITEM_start(sname) \ |
|||
ASN1_ITYPE_COMPAT, \ |
|||
tag, \ |
|||
NULL, \ |
|||
0, \ |
|||
&sname##_ff, \ |
|||
0, \ |
|||
#sname \ |
|||
ASN1_ITEM_end(sname) |
|||
|
|||
# define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ |
|||
ASN1_ITEM_start(sname) \ |
|||
ASN1_ITYPE_EXTERN, \ |
|||
tag, \ |
|||
NULL, \ |
|||
0, \ |
|||
&fptrs, \ |
|||
0, \ |
|||
#sname \ |
|||
ASN1_ITEM_end(sname) |
|||
|
|||
/* Macro to implement standard functions in terms of ASN1_ITEM structures */ |
|||
|
|||
# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) |
|||
|
|||
# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) |
|||
|
|||
# define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ |
|||
IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) |
|||
|
|||
# define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ |
|||
IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) |
|||
|
|||
# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ |
|||
IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) |
|||
|
|||
# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ |
|||
pre stname *fname##_new(void) \ |
|||
{ \ |
|||
return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ |
|||
} \ |
|||
pre void fname##_free(stname *a) \ |
|||
{ \ |
|||
ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ |
|||
stname *fname##_new(void) \ |
|||
{ \ |
|||
return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ |
|||
} \ |
|||
void fname##_free(stname *a) \ |
|||
{ \ |
|||
ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ |
|||
IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ |
|||
IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) |
|||
|
|||
# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ |
|||
stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ |
|||
{ \ |
|||
return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ |
|||
} \ |
|||
int i2d_##fname(stname *a, unsigned char **out) \ |
|||
{ \ |
|||
return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ |
|||
} |
|||
|
|||
# define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ |
|||
int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ |
|||
{ \ |
|||
return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ |
|||
} |
|||
|
|||
/*
|
|||
* This includes evil casts to remove const: they will go away when full ASN1 |
|||
* constification is done. |
|||
*/ |
|||
# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ |
|||
stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ |
|||
{ \ |
|||
return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ |
|||
} \ |
|||
int i2d_##fname(const stname *a, unsigned char **out) \ |
|||
{ \ |
|||
return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ |
|||
} |
|||
|
|||
# define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ |
|||
stname * stname##_dup(stname *x) \ |
|||
{ \ |
|||
return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ |
|||
IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) |
|||
|
|||
# define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ |
|||
int fname##_print_ctx(BIO *out, stname *x, int indent, \ |
|||
const ASN1_PCTX *pctx) \ |
|||
{ \ |
|||
return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ |
|||
ASN1_ITEM_rptr(itname), pctx); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ |
|||
IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) |
|||
|
|||
# define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ |
|||
IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ |
|||
IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) |
|||
|
|||
/* external definitions for primitive types */ |
|||
|
|||
DECLARE_ASN1_ITEM(ASN1_BOOLEAN) |
|||
DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) |
|||
DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) |
|||
DECLARE_ASN1_ITEM(ASN1_SEQUENCE) |
|||
DECLARE_ASN1_ITEM(CBIGNUM) |
|||
DECLARE_ASN1_ITEM(BIGNUM) |
|||
DECLARE_ASN1_ITEM(LONG) |
|||
DECLARE_ASN1_ITEM(ZLONG) |
|||
|
|||
DECLARE_STACK_OF(ASN1_VALUE) |
|||
|
|||
/* Functions used internally by the ASN1 code */ |
|||
|
|||
int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); |
|||
int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
|
|||
void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); |
|||
int ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, |
|||
const ASN1_TEMPLATE *tt); |
|||
int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, |
|||
const ASN1_ITEM *it, int tag, int aclass, char opt, |
|||
ASN1_TLC *ctx); |
|||
|
|||
int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, |
|||
const ASN1_ITEM *it, int tag, int aclass); |
|||
int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, |
|||
const ASN1_TEMPLATE *tt); |
|||
void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
|
|||
int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, |
|||
const ASN1_ITEM *it); |
|||
int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, |
|||
int utype, char *free_cont, const ASN1_ITEM *it); |
|||
|
|||
int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
int asn1_set_choice_selector(ASN1_VALUE **pval, int value, |
|||
const ASN1_ITEM *it); |
|||
|
|||
ASN1_VALUE **asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); |
|||
|
|||
const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, |
|||
int nullerr); |
|||
|
|||
int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it); |
|||
|
|||
void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it); |
|||
int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, |
|||
const ASN1_ITEM *it); |
|||
int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen, |
|||
const ASN1_ITEM *it); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,879 +0,0 @@ |
|||
/* crypto/bio/bio.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_BIO_H |
|||
# define HEADER_BIO_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
# include <stdio.h> |
|||
# endif |
|||
# include <stdarg.h> |
|||
|
|||
# include <openssl/crypto.h> |
|||
|
|||
# ifndef OPENSSL_NO_SCTP |
|||
# ifndef OPENSSL_SYS_VMS |
|||
# include <stdint.h> |
|||
# else |
|||
# include <inttypes.h> |
|||
# endif |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* These are the 'types' of BIOs */ |
|||
# define BIO_TYPE_NONE 0 |
|||
# define BIO_TYPE_MEM (1|0x0400) |
|||
# define BIO_TYPE_FILE (2|0x0400) |
|||
|
|||
# define BIO_TYPE_FD (4|0x0400|0x0100) |
|||
# define BIO_TYPE_SOCKET (5|0x0400|0x0100) |
|||
# define BIO_TYPE_NULL (6|0x0400) |
|||
# define BIO_TYPE_SSL (7|0x0200) |
|||
# define BIO_TYPE_MD (8|0x0200)/* passive filter */ |
|||
# define BIO_TYPE_BUFFER (9|0x0200)/* filter */ |
|||
# define BIO_TYPE_CIPHER (10|0x0200)/* filter */ |
|||
# define BIO_TYPE_BASE64 (11|0x0200)/* filter */ |
|||
# define BIO_TYPE_CONNECT (12|0x0400|0x0100)/* socket - connect */ |
|||
# define BIO_TYPE_ACCEPT (13|0x0400|0x0100)/* socket for accept */ |
|||
# define BIO_TYPE_PROXY_CLIENT (14|0x0200)/* client proxy BIO */ |
|||
# define BIO_TYPE_PROXY_SERVER (15|0x0200)/* server proxy BIO */ |
|||
# define BIO_TYPE_NBIO_TEST (16|0x0200)/* server proxy BIO */ |
|||
# define BIO_TYPE_NULL_FILTER (17|0x0200) |
|||
# define BIO_TYPE_BER (18|0x0200)/* BER -> bin filter */ |
|||
# define BIO_TYPE_BIO (19|0x0400)/* (half a) BIO pair */ |
|||
# define BIO_TYPE_LINEBUFFER (20|0x0200)/* filter */ |
|||
# define BIO_TYPE_DGRAM (21|0x0400|0x0100) |
|||
# ifndef OPENSSL_NO_SCTP |
|||
# define BIO_TYPE_DGRAM_SCTP (24|0x0400|0x0100) |
|||
# endif |
|||
# define BIO_TYPE_ASN1 (22|0x0200)/* filter */ |
|||
# define BIO_TYPE_COMP (23|0x0200)/* filter */ |
|||
|
|||
# define BIO_TYPE_DESCRIPTOR 0x0100/* socket, fd, connect or accept */ |
|||
# define BIO_TYPE_FILTER 0x0200 |
|||
# define BIO_TYPE_SOURCE_SINK 0x0400 |
|||
|
|||
/*
|
|||
* BIO_FILENAME_READ|BIO_CLOSE to open or close on free. |
|||
* BIO_set_fp(in,stdin,BIO_NOCLOSE); |
|||
*/ |
|||
# define BIO_NOCLOSE 0x00 |
|||
# define BIO_CLOSE 0x01 |
|||
|
|||
/*
|
|||
* These are used in the following macros and are passed to BIO_ctrl() |
|||
*/ |
|||
# define BIO_CTRL_RESET 1/* opt - rewind/zero etc */ |
|||
# define BIO_CTRL_EOF 2/* opt - are we at the eof */ |
|||
# define BIO_CTRL_INFO 3/* opt - extra tit-bits */ |
|||
# define BIO_CTRL_SET 4/* man - set the 'IO' type */ |
|||
# define BIO_CTRL_GET 5/* man - get the 'IO' type */ |
|||
# define BIO_CTRL_PUSH 6/* opt - internal, used to signify change */ |
|||
# define BIO_CTRL_POP 7/* opt - internal, used to signify change */ |
|||
# define BIO_CTRL_GET_CLOSE 8/* man - set the 'close' on free */ |
|||
# define BIO_CTRL_SET_CLOSE 9/* man - set the 'close' on free */ |
|||
# define BIO_CTRL_PENDING 10/* opt - is their more data buffered */ |
|||
# define BIO_CTRL_FLUSH 11/* opt - 'flush' buffered output */ |
|||
# define BIO_CTRL_DUP 12/* man - extra stuff for 'duped' BIO */ |
|||
# define BIO_CTRL_WPENDING 13/* opt - number of bytes still to write */ |
|||
/* callback is int cb(BIO *bio,state,ret); */ |
|||
# define BIO_CTRL_SET_CALLBACK 14/* opt - set callback function */ |
|||
# define BIO_CTRL_GET_CALLBACK 15/* opt - set callback function */ |
|||
|
|||
# define BIO_CTRL_SET_FILENAME 30/* BIO_s_file special */ |
|||
|
|||
/* dgram BIO stuff */ |
|||
# define BIO_CTRL_DGRAM_CONNECT 31/* BIO dgram special */ |
|||
# define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected |
|||
* socket to be passed in */ |
|||
# define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */ |
|||
# define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */ |
|||
# define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */ |
|||
# define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */ |
|||
|
|||
# define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */ |
|||
# define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation tiemd out */ |
|||
|
|||
/* #ifdef IP_MTU_DISCOVER */ |
|||
# define BIO_CTRL_DGRAM_MTU_DISCOVER 39/* set DF bit on egress packets */ |
|||
/* #endif */ |
|||
|
|||
# define BIO_CTRL_DGRAM_QUERY_MTU 40/* as kernel for current MTU */ |
|||
# define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47 |
|||
# define BIO_CTRL_DGRAM_GET_MTU 41/* get cached value for MTU */ |
|||
# define BIO_CTRL_DGRAM_SET_MTU 42/* set cached value for MTU. |
|||
* want to use this if asking |
|||
* the kernel fails */ |
|||
|
|||
# define BIO_CTRL_DGRAM_MTU_EXCEEDED 43/* check whether the MTU was |
|||
* exceed in the previous write |
|||
* operation */ |
|||
|
|||
# define BIO_CTRL_DGRAM_GET_PEER 46 |
|||
# define BIO_CTRL_DGRAM_SET_PEER 44/* Destination for the data */ |
|||
|
|||
# define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45/* Next DTLS handshake timeout |
|||
* to adjust socket timeouts */ |
|||
|
|||
# define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49 |
|||
|
|||
# ifndef OPENSSL_NO_SCTP |
|||
/* SCTP stuff */ |
|||
# define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50 |
|||
# define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51 |
|||
# define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52 |
|||
# define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53 |
|||
# define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60 |
|||
# define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61 |
|||
# define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62 |
|||
# define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63 |
|||
# define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64 |
|||
# define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65 |
|||
# define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70 |
|||
# endif |
|||
|
|||
/* modifiers */ |
|||
# define BIO_FP_READ 0x02 |
|||
# define BIO_FP_WRITE 0x04 |
|||
# define BIO_FP_APPEND 0x08 |
|||
# define BIO_FP_TEXT 0x10 |
|||
|
|||
# define BIO_FLAGS_READ 0x01 |
|||
# define BIO_FLAGS_WRITE 0x02 |
|||
# define BIO_FLAGS_IO_SPECIAL 0x04 |
|||
# define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL) |
|||
# define BIO_FLAGS_SHOULD_RETRY 0x08 |
|||
# ifndef BIO_FLAGS_UPLINK |
|||
/*
|
|||
* "UPLINK" flag denotes file descriptors provided by application. It |
|||
* defaults to 0, as most platforms don't require UPLINK interface. |
|||
*/ |
|||
# define BIO_FLAGS_UPLINK 0 |
|||
# endif |
|||
|
|||
/* Used in BIO_gethostbyname() */ |
|||
# define BIO_GHBN_CTRL_HITS 1 |
|||
# define BIO_GHBN_CTRL_MISSES 2 |
|||
# define BIO_GHBN_CTRL_CACHE_SIZE 3 |
|||
# define BIO_GHBN_CTRL_GET_ENTRY 4 |
|||
# define BIO_GHBN_CTRL_FLUSH 5 |
|||
|
|||
/* Mostly used in the SSL BIO */ |
|||
/*-
|
|||
* Not used anymore |
|||
* #define BIO_FLAGS_PROTOCOL_DELAYED_READ 0x10 |
|||
* #define BIO_FLAGS_PROTOCOL_DELAYED_WRITE 0x20 |
|||
* #define BIO_FLAGS_PROTOCOL_STARTUP 0x40 |
|||
*/ |
|||
|
|||
# define BIO_FLAGS_BASE64_NO_NL 0x100 |
|||
|
|||
/*
|
|||
* This is used with memory BIOs: it means we shouldn't free up or change the |
|||
* data in any way. |
|||
*/ |
|||
# define BIO_FLAGS_MEM_RDONLY 0x200 |
|||
|
|||
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); |
|||
|
|||
# define BIO_get_flags(b) BIO_test_flags(b, ~(0x0)) |
|||
# define BIO_set_retry_special(b) \ |
|||
BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY)) |
|||
# define BIO_set_retry_read(b) \ |
|||
BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY)) |
|||
# define BIO_set_retry_write(b) \ |
|||
BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY)) |
|||
|
|||
/* These are normally used internally in BIOs */ |
|||
# define BIO_clear_retry_flags(b) \ |
|||
BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) |
|||
# define BIO_get_retry_flags(b) \ |
|||
BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) |
|||
|
|||
/* These should be used by the application to tell why we should retry */ |
|||
# define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ) |
|||
# define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE) |
|||
# define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL) |
|||
# define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS) |
|||
# define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY) |
|||
|
|||
/*
|
|||
* The next three are used in conjunction with the BIO_should_io_special() |
|||
* condition. After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int |
|||
* *reason); will walk the BIO stack and return the 'reason' for the special |
|||
* and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return |
|||
* the code. |
|||
*/ |
|||
/*
|
|||
* Returned from the SSL bio when the certificate retrieval code had an error |
|||
*/ |
|||
# define BIO_RR_SSL_X509_LOOKUP 0x01 |
|||
/* Returned from the connect BIO when a connect would have blocked */ |
|||
# define BIO_RR_CONNECT 0x02 |
|||
/* Returned from the accept BIO when an accept would have blocked */ |
|||
# define BIO_RR_ACCEPT 0x03 |
|||
|
|||
/* These are passed by the BIO callback */ |
|||
# define BIO_CB_FREE 0x01 |
|||
# define BIO_CB_READ 0x02 |
|||
# define BIO_CB_WRITE 0x03 |
|||
# define BIO_CB_PUTS 0x04 |
|||
# define BIO_CB_GETS 0x05 |
|||
# define BIO_CB_CTRL 0x06 |
|||
|
|||
/*
|
|||
* The callback is called before and after the underling operation, The |
|||
* BIO_CB_RETURN flag indicates if it is after the call |
|||
*/ |
|||
# define BIO_CB_RETURN 0x80 |
|||
# define BIO_CB_return(a) ((a)|BIO_CB_RETURN) |
|||
# define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) |
|||
# define BIO_cb_post(a) ((a)&BIO_CB_RETURN) |
|||
|
|||
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 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 { |
|||
BIO_METHOD *method; |
|||
/* bio, mode, argp, argi, argl, ret */ |
|||
long (*callback) (struct bio_st *, int, const char *, int, long, long); |
|||
char *cb_arg; /* first argument for the callback */ |
|||
int init; |
|||
int shutdown; |
|||
int flags; /* extra storage */ |
|||
int retry_reason; |
|||
int num; |
|||
void *ptr; |
|||
struct bio_st *next_bio; /* used by filter BIOs */ |
|||
struct bio_st *prev_bio; /* used by filter BIOs */ |
|||
int references; |
|||
unsigned long num_read; |
|||
unsigned long num_write; |
|||
CRYPTO_EX_DATA ex_data; |
|||
}; |
|||
|
|||
DECLARE_STACK_OF(BIO) |
|||
|
|||
typedef struct bio_f_buffer_ctx_struct { |
|||
/*-
|
|||
* Buffers are setup like this: |
|||
* |
|||
* <---------------------- size -----------------------> |
|||
* +---------------------------------------------------+ |
|||
* | consumed | remaining | free space | |
|||
* +---------------------------------------------------+ |
|||
* <-- off --><------- len -------> |
|||
*/ |
|||
/*- BIO *bio; *//*
|
|||
* this is now in the BIO struct |
|||
*/ |
|||
int ibuf_size; /* how big is the input buffer */ |
|||
int obuf_size; /* how big is the output buffer */ |
|||
char *ibuf; /* the char array */ |
|||
int ibuf_len; /* how many bytes are in it */ |
|||
int ibuf_off; /* write/read offset */ |
|||
char *obuf; /* the char array */ |
|||
int obuf_len; /* how many bytes are in it */ |
|||
int obuf_off; /* write/read offset */ |
|||
} BIO_F_BUFFER_CTX; |
|||
|
|||
/* Prefix and suffix callback in ASN1 BIO */ |
|||
typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen, |
|||
void *parg); |
|||
|
|||
# ifndef OPENSSL_NO_SCTP |
|||
/* SCTP parameter structs */ |
|||
struct bio_dgram_sctp_sndinfo { |
|||
uint16_t snd_sid; |
|||
uint16_t snd_flags; |
|||
uint32_t snd_ppid; |
|||
uint32_t snd_context; |
|||
}; |
|||
|
|||
struct bio_dgram_sctp_rcvinfo { |
|||
uint16_t rcv_sid; |
|||
uint16_t rcv_ssn; |
|||
uint16_t rcv_flags; |
|||
uint32_t rcv_ppid; |
|||
uint32_t rcv_tsn; |
|||
uint32_t rcv_cumtsn; |
|||
uint32_t rcv_context; |
|||
}; |
|||
|
|||
struct bio_dgram_sctp_prinfo { |
|||
uint16_t pr_policy; |
|||
uint32_t pr_value; |
|||
}; |
|||
# endif |
|||
|
|||
/* connect BIO stuff */ |
|||
# define BIO_CONN_S_BEFORE 1 |
|||
# define BIO_CONN_S_GET_IP 2 |
|||
# define BIO_CONN_S_GET_PORT 3 |
|||
# define BIO_CONN_S_CREATE_SOCKET 4 |
|||
# define BIO_CONN_S_CONNECT 5 |
|||
# define BIO_CONN_S_OK 6 |
|||
# define BIO_CONN_S_BLOCKED_CONNECT 7 |
|||
# define BIO_CONN_S_NBIO 8 |
|||
/*
|
|||
* #define BIO_CONN_get_param_hostname BIO_ctrl |
|||
*/ |
|||
|
|||
# define BIO_C_SET_CONNECT 100 |
|||
# define BIO_C_DO_STATE_MACHINE 101 |
|||
# define BIO_C_SET_NBIO 102 |
|||
# define BIO_C_SET_PROXY_PARAM 103 |
|||
# define BIO_C_SET_FD 104 |
|||
# define BIO_C_GET_FD 105 |
|||
# define BIO_C_SET_FILE_PTR 106 |
|||
# define BIO_C_GET_FILE_PTR 107 |
|||
# define BIO_C_SET_FILENAME 108 |
|||
# define BIO_C_SET_SSL 109 |
|||
# define BIO_C_GET_SSL 110 |
|||
# define BIO_C_SET_MD 111 |
|||
# define BIO_C_GET_MD 112 |
|||
# define BIO_C_GET_CIPHER_STATUS 113 |
|||
# define BIO_C_SET_BUF_MEM 114 |
|||
# define BIO_C_GET_BUF_MEM_PTR 115 |
|||
# define BIO_C_GET_BUFF_NUM_LINES 116 |
|||
# define BIO_C_SET_BUFF_SIZE 117 |
|||
# define BIO_C_SET_ACCEPT 118 |
|||
# define BIO_C_SSL_MODE 119 |
|||
# define BIO_C_GET_MD_CTX 120 |
|||
# define BIO_C_GET_PROXY_PARAM 121 |
|||
# define BIO_C_SET_BUFF_READ_DATA 122/* data to read first */ |
|||
# define BIO_C_GET_CONNECT 123 |
|||
# define BIO_C_GET_ACCEPT 124 |
|||
# define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125 |
|||
# define BIO_C_GET_SSL_NUM_RENEGOTIATES 126 |
|||
# define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127 |
|||
# define BIO_C_FILE_SEEK 128 |
|||
# define BIO_C_GET_CIPHER_CTX 129 |
|||
# define BIO_C_SET_BUF_MEM_EOF_RETURN 130/* return end of input |
|||
* value */ |
|||
# define BIO_C_SET_BIND_MODE 131 |
|||
# define BIO_C_GET_BIND_MODE 132 |
|||
# define BIO_C_FILE_TELL 133 |
|||
# define BIO_C_GET_SOCKS 134 |
|||
# define BIO_C_SET_SOCKS 135 |
|||
|
|||
# define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */ |
|||
# define BIO_C_GET_WRITE_BUF_SIZE 137 |
|||
# define BIO_C_MAKE_BIO_PAIR 138 |
|||
# define BIO_C_DESTROY_BIO_PAIR 139 |
|||
# define BIO_C_GET_WRITE_GUARANTEE 140 |
|||
# define BIO_C_GET_READ_REQUEST 141 |
|||
# define BIO_C_SHUTDOWN_WR 142 |
|||
# define BIO_C_NREAD0 143 |
|||
# define BIO_C_NREAD 144 |
|||
# define BIO_C_NWRITE0 145 |
|||
# define BIO_C_NWRITE 146 |
|||
# define BIO_C_RESET_READ_REQUEST 147 |
|||
# define BIO_C_SET_MD_CTX 148 |
|||
|
|||
# define BIO_C_SET_PREFIX 149 |
|||
# define BIO_C_GET_PREFIX 150 |
|||
# define BIO_C_SET_SUFFIX 151 |
|||
# define BIO_C_GET_SUFFIX 152 |
|||
|
|||
# define BIO_C_SET_EX_ARG 153 |
|||
# define BIO_C_GET_EX_ARG 154 |
|||
|
|||
# define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,arg) |
|||
# define BIO_get_app_data(s) BIO_get_ex_data(s,0) |
|||
|
|||
/* BIO_s_connect() and BIO_s_socks4a_connect() */ |
|||
# define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0,(char *)name) |
|||
# define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1,(char *)port) |
|||
# define BIO_set_conn_ip(b,ip) BIO_ctrl(b,BIO_C_SET_CONNECT,2,(char *)ip) |
|||
# define BIO_set_conn_int_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,3,(char *)port) |
|||
# define BIO_get_conn_hostname(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0) |
|||
# define BIO_get_conn_port(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1) |
|||
# define BIO_get_conn_ip(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2) |
|||
# define BIO_get_conn_int_port(b) BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL) |
|||
|
|||
# define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) |
|||
|
|||
/* BIO_s_accept() */ |
|||
# define BIO_set_accept_port(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0,(char *)name) |
|||
# define BIO_get_accept_port(b) BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0) |
|||
/* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */ |
|||
# define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,1,(n)?(void *)"a":NULL) |
|||
# define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(char *)bio) |
|||
|
|||
# define BIO_BIND_NORMAL 0 |
|||
# define BIO_BIND_REUSEADDR_IF_UNUSED 1 |
|||
# define BIO_BIND_REUSEADDR 2 |
|||
# define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL) |
|||
# define BIO_get_bind_mode(b,mode) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL) |
|||
|
|||
/* BIO_s_accept() and BIO_s_connect() */ |
|||
# define BIO_do_connect(b) BIO_do_handshake(b) |
|||
# define BIO_do_accept(b) BIO_do_handshake(b) |
|||
# define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL) |
|||
|
|||
/* BIO_s_proxy_client() */ |
|||
# define BIO_set_url(b,url) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,0,(char *)(url)) |
|||
# define BIO_set_proxies(b,p) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,1,(char *)(p)) |
|||
/* BIO_set_nbio(b,n) */ |
|||
# define BIO_set_filter_bio(b,s) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,2,(char *)(s)) |
|||
/* BIO *BIO_get_filter_bio(BIO *bio); */ |
|||
# define BIO_set_proxy_cb(b,cb) BIO_callback_ctrl(b,BIO_C_SET_PROXY_PARAM,3,(void *(*cb)())) |
|||
# define BIO_set_proxy_header(b,sk) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,4,(char *)sk) |
|||
# define BIO_set_no_connect_return(b,bool) BIO_int_ctrl(b,BIO_C_SET_PROXY_PARAM,5,bool) |
|||
|
|||
# define BIO_get_proxy_header(b,skp) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,0,(char *)skp) |
|||
# define BIO_get_proxies(b,pxy_p) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,1,(char *)(pxy_p)) |
|||
# define BIO_get_url(b,url) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,2,(char *)(url)) |
|||
# define BIO_get_no_connect_return(b) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,5,NULL) |
|||
|
|||
/* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */ |
|||
# define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd) |
|||
# define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)c) |
|||
|
|||
/* BIO_s_file() */ |
|||
# define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)fp) |
|||
# define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)fpp) |
|||
|
|||
/* BIO_s_fd() and BIO_s_file() */ |
|||
# define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL) |
|||
# define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL) |
|||
|
|||
/*
|
|||
* name is cast to lose const, but might be better to route through a |
|||
* function so we can do it safely |
|||
*/ |
|||
# ifdef CONST_STRICT |
|||
/*
|
|||
* If you are wondering why this isn't defined, its because CONST_STRICT is |
|||
* purely a compile-time kludge to allow const to be checked. |
|||
*/ |
|||
int BIO_read_filename(BIO *b, const char *name); |
|||
# else |
|||
# define BIO_read_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ |
|||
BIO_CLOSE|BIO_FP_READ,(char *)name) |
|||
# endif |
|||
# define BIO_write_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ |
|||
BIO_CLOSE|BIO_FP_WRITE,name) |
|||
# define BIO_append_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ |
|||
BIO_CLOSE|BIO_FP_APPEND,name) |
|||
# define BIO_rw_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ |
|||
BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name) |
|||
|
|||
/*
|
|||
* WARNING WARNING, this ups the reference count on the read bio of the SSL |
|||
* structure. This is because the ssl read BIO is now pointed to by the |
|||
* next_bio field in the bio. So when you free the BIO, make sure you are |
|||
* doing a BIO_free_all() to catch the underlying BIO. |
|||
*/ |
|||
# define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)ssl) |
|||
# define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)sslp) |
|||
# define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL) |
|||
# define BIO_set_ssl_renegotiate_bytes(b,num) \ |
|||
BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL); |
|||
# define BIO_get_num_renegotiates(b) \ |
|||
BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL); |
|||
# define BIO_set_ssl_renegotiate_timeout(b,seconds) \ |
|||
BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL); |
|||
|
|||
/* defined in evp.h */ |
|||
/* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)md) */ |
|||
|
|||
# define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp) |
|||
# define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)bm) |
|||
# define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0,(char *)pp) |
|||
# define BIO_set_mem_eof_return(b,v) \ |
|||
BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL) |
|||
|
|||
/* For the BIO_f_buffer() type */ |
|||
# define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL) |
|||
# define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL) |
|||
# define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0) |
|||
# define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1) |
|||
# define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf) |
|||
|
|||
/* Don't use the next one unless you know what you are doing :-) */ |
|||
# define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret)) |
|||
|
|||
# define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL) |
|||
# define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL) |
|||
# define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL) |
|||
# define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL) |
|||
# define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL) |
|||
# define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL) |
|||
/* ...pending macros have inappropriate return type */ |
|||
size_t BIO_ctrl_pending(BIO *b); |
|||
size_t BIO_ctrl_wpending(BIO *b); |
|||
# define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL) |
|||
# define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \ |
|||
cbp) |
|||
# define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb) |
|||
|
|||
/* For the BIO_f_buffer() type */ |
|||
# define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL) |
|||
|
|||
/* For BIO_s_bio() */ |
|||
# define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL) |
|||
# define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL) |
|||
# define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2) |
|||
# define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL) |
|||
# define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL) |
|||
/* macros with inappropriate type -- but ...pending macros use int too: */ |
|||
# define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL) |
|||
# define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL) |
|||
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); |
|||
|
|||
/* ctrl macros for dgram */ |
|||
# define BIO_ctrl_dgram_connect(b,peer) \ |
|||
(int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)peer) |
|||
# define BIO_ctrl_set_connected(b, state, peer) \ |
|||
(int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, state, (char *)peer) |
|||
# define BIO_dgram_recv_timedout(b) \ |
|||
(int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL) |
|||
# define BIO_dgram_send_timedout(b) \ |
|||
(int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL) |
|||
# define BIO_dgram_get_peer(b,peer) \ |
|||
(int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)peer) |
|||
# define BIO_dgram_set_peer(b,peer) \ |
|||
(int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)peer) |
|||
# define BIO_dgram_get_mtu_overhead(b) \ |
|||
(unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL) |
|||
|
|||
/* These two aren't currently implemented */ |
|||
/* int BIO_get_ex_num(BIO *bio); */ |
|||
/* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */ |
|||
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); |
|||
|
|||
/* For BIO_f_asn1() */ |
|||
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); |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
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); |
|||
# define BIO_s_file_internal BIO_s_file |
|||
# endif |
|||
BIO *BIO_new(BIO_METHOD *type); |
|||
int BIO_set(BIO *a, BIO_METHOD *type); |
|||
int BIO_free(BIO *a); |
|||
void BIO_vfree(BIO *a); |
|||
int BIO_read(BIO *b, void *data, int len); |
|||
int BIO_gets(BIO *bp, char *buf, int size); |
|||
int BIO_write(BIO *b, const void *data, int len); |
|||
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); |
|||
|
|||
BIO_METHOD *BIO_s_mem(void); |
|||
BIO *BIO_new_mem_buf(void *buf, int len); |
|||
BIO_METHOD *BIO_s_socket(void); |
|||
BIO_METHOD *BIO_s_connect(void); |
|||
BIO_METHOD *BIO_s_accept(void); |
|||
BIO_METHOD *BIO_s_fd(void); |
|||
# ifndef OPENSSL_SYS_OS2 |
|||
BIO_METHOD *BIO_s_log(void); |
|||
# endif |
|||
BIO_METHOD *BIO_s_bio(void); |
|||
BIO_METHOD *BIO_s_null(void); |
|||
BIO_METHOD *BIO_f_null(void); |
|||
BIO_METHOD *BIO_f_buffer(void); |
|||
# ifdef OPENSSL_SYS_VMS |
|||
BIO_METHOD *BIO_f_linebuffer(void); |
|||
# endif |
|||
BIO_METHOD *BIO_f_nbio_test(void); |
|||
# ifndef OPENSSL_NO_DGRAM |
|||
BIO_METHOD *BIO_s_datagram(void); |
|||
# ifndef OPENSSL_NO_SCTP |
|||
BIO_METHOD *BIO_s_datagram_sctp(void); |
|||
# endif |
|||
# endif |
|||
|
|||
/* BIO_METHOD *BIO_f_ber(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); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
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); |
|||
# endif |
|||
struct hostent *BIO_gethostbyname(const char *name); |
|||
/*-
|
|||
* We might want a thread-safe interface too: |
|||
* struct hostent *BIO_gethostbyname_r(const char *name, |
|||
* struct hostent *result, void *buffer, size_t buflen); |
|||
* or something similar (caller allocates a struct hostent, |
|||
* pointed to by "result", and additional buffer space for the various |
|||
* substructures; if the buffer does not suffice, NULL is returned |
|||
* and an appropriate error code is set). |
|||
*/ |
|||
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); |
|||
# ifndef OPENSSL_NO_SCTP |
|||
BIO *BIO_new_dgram_sctp(int fd, int close_flag); |
|||
int BIO_dgram_is_sctp(BIO *bio); |
|||
int BIO_dgram_sctp_notification_cb(BIO *b, |
|||
void (*handle_notifications) (BIO *bio, |
|||
void |
|||
*context, |
|||
void *buf), |
|||
void *context); |
|||
int BIO_dgram_sctp_wait_for_dry(BIO *b); |
|||
int BIO_dgram_sctp_msg_waiting(BIO *b); |
|||
# endif |
|||
BIO *BIO_new_fd(int fd, int close_flag); |
|||
BIO *BIO_new_connect(char *host_port); |
|||
BIO *BIO_new_accept(char *host_port); |
|||
|
|||
int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, |
|||
BIO **bio2, size_t writebuf2); |
|||
/*
|
|||
* If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. |
|||
* Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default |
|||
* value. |
|||
*/ |
|||
|
|||
void BIO_copy_next_retry(BIO *b); |
|||
|
|||
/*
|
|||
* long BIO_ghbn_ctrl(int cmd,int iarg,char *parg); |
|||
*/ |
|||
|
|||
# ifdef __GNUC__ |
|||
# define __bio_h__attr__ __attribute__ |
|||
# else |
|||
# define __bio_h__attr__(x) |
|||
# endif |
|||
int BIO_printf(BIO *bio, const char *format, ...) |
|||
__bio_h__attr__((__format__(__printf__, 2, 3))); |
|||
int BIO_vprintf(BIO *bio, const char *format, va_list args) |
|||
__bio_h__attr__((__format__(__printf__, 2, 0))); |
|||
int BIO_snprintf(char *buf, size_t n, const char *format, ...) |
|||
__bio_h__attr__((__format__(__printf__, 3, 4))); |
|||
int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) |
|||
__bio_h__attr__((__format__(__printf__, 3, 0))); |
|||
# undef __bio_h__attr__ |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_BIO_strings(void); |
|||
|
|||
/* Error codes for the BIO functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define BIO_F_ACPT_STATE 100 |
|||
# define BIO_F_BIO_ACCEPT 101 |
|||
# define BIO_F_BIO_BER_GET_HEADER 102 |
|||
# define BIO_F_BIO_CALLBACK_CTRL 131 |
|||
# define BIO_F_BIO_CTRL 103 |
|||
# define BIO_F_BIO_GETHOSTBYNAME 120 |
|||
# define BIO_F_BIO_GETS 104 |
|||
# define BIO_F_BIO_GET_ACCEPT_SOCKET 105 |
|||
# define BIO_F_BIO_GET_HOST_IP 106 |
|||
# define BIO_F_BIO_GET_PORT 107 |
|||
# define BIO_F_BIO_MAKE_PAIR 121 |
|||
# define BIO_F_BIO_NEW 108 |
|||
# define BIO_F_BIO_NEW_FILE 109 |
|||
# define BIO_F_BIO_NEW_MEM_BUF 126 |
|||
# define BIO_F_BIO_NREAD 123 |
|||
# define BIO_F_BIO_NREAD0 124 |
|||
# define BIO_F_BIO_NWRITE 125 |
|||
# define BIO_F_BIO_NWRITE0 122 |
|||
# define BIO_F_BIO_PUTS 110 |
|||
# define BIO_F_BIO_READ 111 |
|||
# define BIO_F_BIO_SOCK_INIT 112 |
|||
# define BIO_F_BIO_WRITE 113 |
|||
# define BIO_F_BUFFER_CTRL 114 |
|||
# define BIO_F_CONN_CTRL 127 |
|||
# define BIO_F_CONN_STATE 115 |
|||
# define BIO_F_DGRAM_SCTP_READ 132 |
|||
# define BIO_F_DGRAM_SCTP_WRITE 133 |
|||
# define BIO_F_FILE_CTRL 116 |
|||
# define BIO_F_FILE_READ 130 |
|||
# define BIO_F_LINEBUFFER_CTRL 129 |
|||
# define BIO_F_MEM_READ 128 |
|||
# define BIO_F_MEM_WRITE 117 |
|||
# define BIO_F_SSL_NEW 118 |
|||
# define BIO_F_WSASTARTUP 119 |
|||
|
|||
/* Reason codes. */ |
|||
# define BIO_R_ACCEPT_ERROR 100 |
|||
# define BIO_R_BAD_FOPEN_MODE 101 |
|||
# define BIO_R_BAD_HOSTNAME_LOOKUP 102 |
|||
# define BIO_R_BROKEN_PIPE 124 |
|||
# define BIO_R_CONNECT_ERROR 103 |
|||
# define BIO_R_EOF_ON_MEMORY_BIO 127 |
|||
# define BIO_R_ERROR_SETTING_NBIO 104 |
|||
# define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET 105 |
|||
# define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET 106 |
|||
# define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107 |
|||
# define BIO_R_INVALID_ARGUMENT 125 |
|||
# define BIO_R_INVALID_IP_ADDRESS 108 |
|||
# define BIO_R_IN_USE 123 |
|||
# define BIO_R_KEEPALIVE 109 |
|||
# define BIO_R_NBIO_CONNECT_ERROR 110 |
|||
# define BIO_R_NO_ACCEPT_PORT_SPECIFIED 111 |
|||
# define BIO_R_NO_HOSTNAME_SPECIFIED 112 |
|||
# define BIO_R_NO_PORT_DEFINED 113 |
|||
# define BIO_R_NO_PORT_SPECIFIED 114 |
|||
# define BIO_R_NO_SUCH_FILE 128 |
|||
# define BIO_R_NULL_PARAMETER 115 |
|||
# define BIO_R_TAG_MISMATCH 116 |
|||
# define BIO_R_UNABLE_TO_BIND_SOCKET 117 |
|||
# define BIO_R_UNABLE_TO_CREATE_SOCKET 118 |
|||
# define BIO_R_UNABLE_TO_LISTEN_SOCKET 119 |
|||
# define BIO_R_UNINITIALIZED 120 |
|||
# define BIO_R_UNSUPPORTED_METHOD 121 |
|||
# define BIO_R_WRITE_TO_READ_ONLY_BIO 126 |
|||
# define BIO_R_WSASTARTUP 122 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,130 +0,0 @@ |
|||
/* crypto/bf/blowfish.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_BLOWFISH_H |
|||
# define HEADER_BLOWFISH_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef OPENSSL_NO_BF |
|||
# error BF is disabled. |
|||
# endif |
|||
|
|||
# define BF_ENCRYPT 1 |
|||
# define BF_DECRYPT 0 |
|||
|
|||
/*-
|
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
* ! BF_LONG has to be at least 32 bits wide. If it's wider, then ! |
|||
* ! BF_LONG_LOG2 has to be defined along. ! |
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
*/ |
|||
|
|||
# if defined(__LP32__) |
|||
# define BF_LONG unsigned long |
|||
# elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) |
|||
# define BF_LONG unsigned long |
|||
# define BF_LONG_LOG2 3 |
|||
/*
|
|||
* _CRAY note. I could declare short, but I have no idea what impact |
|||
* does it have on performance on none-T3E machines. I could declare |
|||
* int, but at least on C90 sizeof(int) can be chosen at compile time. |
|||
* So I've chosen long... |
|||
* <appro@fy.chalmers.se> |
|||
*/ |
|||
# else |
|||
# define BF_LONG unsigned int |
|||
# endif |
|||
|
|||
# define BF_ROUNDS 16 |
|||
# define BF_BLOCK 8 |
|||
|
|||
typedef struct bf_key_st { |
|||
BF_LONG P[BF_ROUNDS + 2]; |
|||
BF_LONG S[4 * 256]; |
|||
} BF_KEY; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
void private_BF_set_key(BF_KEY *key, int len, const unsigned char *data); |
|||
# endif |
|||
void BF_set_key(BF_KEY *key, int len, const unsigned char *data); |
|||
|
|||
void BF_encrypt(BF_LONG *data, const BF_KEY *key); |
|||
void BF_decrypt(BF_LONG *data, const BF_KEY *key); |
|||
|
|||
void BF_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
const BF_KEY *key, int enc); |
|||
void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, |
|||
const BF_KEY *schedule, unsigned char *ivec, int enc); |
|||
void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, const BF_KEY *schedule, |
|||
unsigned char *ivec, int *num, int enc); |
|||
void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, const BF_KEY *schedule, |
|||
unsigned char *ivec, int *num); |
|||
const char *BF_options(void); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,967 +0,0 @@ |
|||
/* crypto/bn/bn.h */ |
|||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. |
|||
* |
|||
* Portions of the attached software ("Contribution") are developed by |
|||
* SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. |
|||
* |
|||
* The Contribution is licensed pursuant to the Eric Young open source |
|||
* license provided above. |
|||
* |
|||
* The binary polynomial arithmetic software is originally written by |
|||
* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories. |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_BN_H |
|||
# define HEADER_BN_H |
|||
|
|||
# include <limits.h> |
|||
# include <openssl/e_os2.h> |
|||
# ifndef OPENSSL_NO_FP_API |
|||
# include <stdio.h> /* FILE */ |
|||
# endif |
|||
# include <openssl/ossl_typ.h> |
|||
# include <openssl/crypto.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/*
|
|||
* These preprocessor symbols control various aspects of the bignum headers |
|||
* and library code. They're not defined by any "normal" configuration, as |
|||
* they are intended for development and testing purposes. NB: defining all |
|||
* three can be useful for debugging application code as well as openssl |
|||
* itself. BN_DEBUG - turn on various debugging alterations to the bignum |
|||
* code BN_DEBUG_RAND - uses random poisoning of unused words to trip up |
|||
* mismanagement of bignum internals. You must also define BN_DEBUG. |
|||
*/ |
|||
/* #define BN_DEBUG */ |
|||
/* #define BN_DEBUG_RAND */ |
|||
|
|||
# ifndef OPENSSL_SMALL_FOOTPRINT |
|||
# define BN_MUL_COMBA |
|||
# define BN_SQR_COMBA |
|||
# define BN_RECURSION |
|||
# endif |
|||
|
|||
/*
|
|||
* This next option uses the C libraries (2 word)/(1 word) function. If it is |
|||
* not defined, I use my C version (which is slower). The reason for this |
|||
* flag is that when the particular C compiler library routine is used, and |
|||
* the library is linked with a different compiler, the library is missing. |
|||
* This mostly happens when the library is built with gcc and then linked |
|||
* using normal cc. This would be a common occurrence because gcc normally |
|||
* produces code that is 2 times faster than system compilers for the big |
|||
* number stuff. For machines with only one compiler (or shared libraries), |
|||
* this should be on. Again this in only really a problem on machines using |
|||
* "long long's", are 32bit, and are not using my assembler code. |
|||
*/ |
|||
# if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || \ |
|||
defined(OPENSSL_SYS_WIN32) || defined(linux) |
|||
# ifndef BN_DIV2W |
|||
# define BN_DIV2W |
|||
# endif |
|||
# endif |
|||
|
|||
/*
|
|||
* assuming long is 64bit - this is the DEC Alpha unsigned long long is only |
|||
* 64 bits :-(, don't define BN_LLONG for the DEC Alpha |
|||
*/ |
|||
# ifdef SIXTY_FOUR_BIT_LONG |
|||
# define BN_ULLONG unsigned long long |
|||
# define BN_ULONG unsigned long |
|||
# define BN_LONG long |
|||
# define BN_BITS 128 |
|||
# define BN_BYTES 8 |
|||
# define BN_BITS2 64 |
|||
# define BN_BITS4 32 |
|||
# define BN_MASK (0xffffffffffffffffffffffffffffffffLL) |
|||
# define BN_MASK2 (0xffffffffffffffffL) |
|||
# define BN_MASK2l (0xffffffffL) |
|||
# define BN_MASK2h (0xffffffff00000000L) |
|||
# define BN_MASK2h1 (0xffffffff80000000L) |
|||
# define BN_TBIT (0x8000000000000000L) |
|||
# define BN_DEC_CONV (10000000000000000000UL) |
|||
# define BN_DEC_FMT1 "%lu" |
|||
# define BN_DEC_FMT2 "%019lu" |
|||
# define BN_DEC_NUM 19 |
|||
# define BN_HEX_FMT1 "%lX" |
|||
# define BN_HEX_FMT2 "%016lX" |
|||
# endif |
|||
|
|||
/*
|
|||
* This is where the long long data type is 64 bits, but long is 32. For |
|||
* machines where there are 64bit registers, this is the mode to use. IRIX, |
|||
* on R4000 and above should use this mode, along with the relevant assembler |
|||
* code :-). Do NOT define BN_LLONG. |
|||
*/ |
|||
# ifdef SIXTY_FOUR_BIT |
|||
# undef BN_LLONG |
|||
# undef BN_ULLONG |
|||
# define BN_ULONG unsigned long long |
|||
# define BN_LONG long long |
|||
# define BN_BITS 128 |
|||
# define BN_BYTES 8 |
|||
# define BN_BITS2 64 |
|||
# define BN_BITS4 32 |
|||
# define BN_MASK2 (0xffffffffffffffffLL) |
|||
# define BN_MASK2l (0xffffffffL) |
|||
# define BN_MASK2h (0xffffffff00000000LL) |
|||
# define BN_MASK2h1 (0xffffffff80000000LL) |
|||
# define BN_TBIT (0x8000000000000000LL) |
|||
# define BN_DEC_CONV (10000000000000000000ULL) |
|||
# define BN_DEC_FMT1 "%llu" |
|||
# define BN_DEC_FMT2 "%019llu" |
|||
# define BN_DEC_NUM 19 |
|||
# define BN_HEX_FMT1 "%llX" |
|||
# define BN_HEX_FMT2 "%016llX" |
|||
# endif |
|||
|
|||
# ifdef THIRTY_TWO_BIT |
|||
# ifdef BN_LLONG |
|||
# if defined(_WIN32) && !defined(__GNUC__) |
|||
# define BN_ULLONG unsigned __int64 |
|||
# define BN_MASK (0xffffffffffffffffI64) |
|||
# else |
|||
# define BN_ULLONG unsigned long long |
|||
# define BN_MASK (0xffffffffffffffffLL) |
|||
# endif |
|||
# endif |
|||
# define BN_ULONG unsigned int |
|||
# define BN_LONG int |
|||
# define BN_BITS 64 |
|||
# define BN_BYTES 4 |
|||
# define BN_BITS2 32 |
|||
# define BN_BITS4 16 |
|||
# define BN_MASK2 (0xffffffffL) |
|||
# define BN_MASK2l (0xffff) |
|||
# define BN_MASK2h1 (0xffff8000L) |
|||
# define BN_MASK2h (0xffff0000L) |
|||
# define BN_TBIT (0x80000000L) |
|||
# define BN_DEC_CONV (1000000000L) |
|||
# define BN_DEC_FMT1 "%u" |
|||
# define BN_DEC_FMT2 "%09u" |
|||
# define BN_DEC_NUM 9 |
|||
# define BN_HEX_FMT1 "%X" |
|||
# define BN_HEX_FMT2 "%08X" |
|||
# endif |
|||
|
|||
/*
|
|||
* 2011-02-22 SMS. In various places, a size_t variable or a type cast to |
|||
* size_t was used to perform integer-only operations on pointers. This |
|||
* failed on VMS with 64-bit pointers (CC /POINTER_SIZE = 64) because size_t |
|||
* is still only 32 bits. What's needed in these cases is an integer type |
|||
* with the same size as a pointer, which size_t is not certain to be. The |
|||
* only fix here is VMS-specific. |
|||
*/ |
|||
# if defined(OPENSSL_SYS_VMS) |
|||
# if __INITIAL_POINTER_SIZE == 64 |
|||
# define PTR_SIZE_INT long long |
|||
# else /* __INITIAL_POINTER_SIZE == 64 */ |
|||
# define PTR_SIZE_INT int |
|||
# endif /* __INITIAL_POINTER_SIZE == 64 [else] */ |
|||
# else /* defined(OPENSSL_SYS_VMS) */ |
|||
# define PTR_SIZE_INT size_t |
|||
# endif /* defined(OPENSSL_SYS_VMS) [else] */ |
|||
|
|||
# define BN_DEFAULT_BITS 1280 |
|||
|
|||
# define BN_FLG_MALLOCED 0x01 |
|||
# define BN_FLG_STATIC_DATA 0x02 |
|||
|
|||
/*
|
|||
* avoid leaking exponent information through timing, |
|||
* BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, |
|||
* BN_div() will call BN_div_no_branch, |
|||
* BN_mod_inverse() will call BN_mod_inverse_no_branch. |
|||
*/ |
|||
# define BN_FLG_CONSTTIME 0x04 |
|||
|
|||
# ifdef OPENSSL_NO_DEPRECATED |
|||
/* deprecated name for the flag */ |
|||
# define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME |
|||
/*
|
|||
* avoid leaking exponent information through timings |
|||
* (BN_mod_exp_mont() will call BN_mod_exp_mont_consttime) |
|||
*/ |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# define BN_FLG_FREE 0x8000 |
|||
/* used for debuging */ |
|||
# endif |
|||
# define BN_set_flags(b,n) ((b)->flags|=(n)) |
|||
# define BN_get_flags(b,n) ((b)->flags&(n)) |
|||
|
|||
/*
|
|||
* get a clone of a BIGNUM with changed flags, for *temporary* use only (the |
|||
* two BIGNUMs cannot not be used in parallel!) |
|||
*/ |
|||
# define BN_with_flags(dest,b,n) ((dest)->d=(b)->d, \ |
|||
(dest)->top=(b)->top, \ |
|||
(dest)->dmax=(b)->dmax, \ |
|||
(dest)->neg=(b)->neg, \ |
|||
(dest)->flags=(((dest)->flags & BN_FLG_MALLOCED) \ |
|||
| ((b)->flags & ~BN_FLG_MALLOCED) \ |
|||
| BN_FLG_STATIC_DATA \ |
|||
| (n))) |
|||
|
|||
/* Already declared in ossl_typ.h */ |
|||
# if 0 |
|||
typedef struct bignum_st BIGNUM; |
|||
/* Used for temp variables (declaration hidden in bn_lcl.h) */ |
|||
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; |
|||
# endif |
|||
|
|||
struct bignum_st { |
|||
BN_ULONG *d; /* Pointer to an array of 'BN_BITS2' bit
|
|||
* chunks. */ |
|||
int top; /* Index of last used d +1. */ |
|||
/* The next are internal book keeping for bn_expand. */ |
|||
int dmax; /* Size of the d array. */ |
|||
int neg; /* one if the number is negative */ |
|||
int flags; |
|||
}; |
|||
|
|||
/* Used for montgomery multiplication */ |
|||
struct bn_mont_ctx_st { |
|||
int ri; /* number of bits in R */ |
|||
BIGNUM RR; /* used to convert to montgomery form */ |
|||
BIGNUM N; /* The modulus */ |
|||
BIGNUM Ni; /* R*(1/R mod N) - N*Ni = 1 (Ni is only
|
|||
* stored for bignum algorithm) */ |
|||
BN_ULONG n0[2]; /* least significant word(s) of Ni; (type
|
|||
* changed with 0.9.9, was "BN_ULONG n0;" |
|||
* before) */ |
|||
int flags; |
|||
}; |
|||
|
|||
/*
|
|||
* Used for reciprocal division/mod functions It cannot be shared between |
|||
* threads |
|||
*/ |
|||
struct bn_recp_ctx_st { |
|||
BIGNUM N; /* the divisor */ |
|||
BIGNUM Nr; /* the reciprocal */ |
|||
int num_bits; |
|||
int shift; |
|||
int flags; |
|||
}; |
|||
|
|||
/* Used for slow "generation" functions. */ |
|||
struct bn_gencb_st { |
|||
unsigned int ver; /* To handle binary (in)compatibility */ |
|||
void *arg; /* callback-specific data */ |
|||
union { |
|||
/* if(ver==1) - handles old style callbacks */ |
|||
void (*cb_1) (int, int, void *); |
|||
/* if(ver==2) - new callback style */ |
|||
int (*cb_2) (int, int, BN_GENCB *); |
|||
} cb; |
|||
}; |
|||
/* Wrapper function to make using BN_GENCB easier, */ |
|||
int BN_GENCB_call(BN_GENCB *cb, int a, int b); |
|||
/* Macro to populate a BN_GENCB structure with an "old"-style callback */ |
|||
# define BN_GENCB_set_old(gencb, callback, cb_arg) { \ |
|||
BN_GENCB *tmp_gencb = (gencb); \ |
|||
tmp_gencb->ver = 1; \ |
|||
tmp_gencb->arg = (cb_arg); \ |
|||
tmp_gencb->cb.cb_1 = (callback); } |
|||
/* Macro to populate a BN_GENCB structure with a "new"-style callback */ |
|||
# define BN_GENCB_set(gencb, callback, cb_arg) { \ |
|||
BN_GENCB *tmp_gencb = (gencb); \ |
|||
tmp_gencb->ver = 2; \ |
|||
tmp_gencb->arg = (cb_arg); \ |
|||
tmp_gencb->cb.cb_2 = (callback); } |
|||
|
|||
# define BN_prime_checks 0 /* default: select number of iterations based |
|||
* on the size of the number */ |
|||
|
|||
/*
|
|||
* number of Miller-Rabin iterations for an error rate of less than 2^-80 for |
|||
* random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook of |
|||
* Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996]; |
|||
* original paper: Damgaard, Landrock, Pomerance: Average case error |
|||
* estimates for the strong probable prime test. -- Math. Comp. 61 (1993) |
|||
* 177-194) |
|||
*/ |
|||
# define BN_prime_checks_for_size(b) ((b) >= 1300 ? 2 : \ |
|||
(b) >= 850 ? 3 : \ |
|||
(b) >= 650 ? 4 : \ |
|||
(b) >= 550 ? 5 : \ |
|||
(b) >= 450 ? 6 : \ |
|||
(b) >= 400 ? 7 : \ |
|||
(b) >= 350 ? 8 : \ |
|||
(b) >= 300 ? 9 : \ |
|||
(b) >= 250 ? 12 : \ |
|||
(b) >= 200 ? 15 : \ |
|||
(b) >= 150 ? 18 : \ |
|||
/* b >= 100 */ 27) |
|||
|
|||
# define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) |
|||
|
|||
/* Note that BN_abs_is_word didn't work reliably for w == 0 until 0.9.8 */ |
|||
# define BN_abs_is_word(a,w) ((((a)->top == 1) && ((a)->d[0] == (BN_ULONG)(w))) || \ |
|||
(((w) == 0) && ((a)->top == 0))) |
|||
# define BN_is_zero(a) ((a)->top == 0) |
|||
# define BN_is_one(a) (BN_abs_is_word((a),1) && !(a)->neg) |
|||
# define BN_is_word(a,w) (BN_abs_is_word((a),(w)) && (!(w) || !(a)->neg)) |
|||
# define BN_is_odd(a) (((a)->top > 0) && ((a)->d[0] & 1)) |
|||
|
|||
# define BN_one(a) (BN_set_word((a),1)) |
|||
# define BN_zero_ex(a) \ |
|||
do { \ |
|||
BIGNUM *_tmp_bn = (a); \ |
|||
_tmp_bn->top = 0; \ |
|||
_tmp_bn->neg = 0; \ |
|||
} while(0) |
|||
# ifdef OPENSSL_NO_DEPRECATED |
|||
# define BN_zero(a) BN_zero_ex(a) |
|||
# else |
|||
# define BN_zero(a) (BN_set_word((a),0)) |
|||
# endif |
|||
|
|||
const BIGNUM *BN_value_one(void); |
|||
char *BN_options(void); |
|||
BN_CTX *BN_CTX_new(void); |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
void BN_CTX_init(BN_CTX *c); |
|||
# endif |
|||
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(BN_ULONG); |
|||
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); |
|||
/** BN_set_negative sets sign of a BIGNUM
|
|||
* \param b pointer to the BIGNUM object |
|||
* \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise |
|||
*/ |
|||
void BN_set_negative(BIGNUM *b, int n); |
|||
/** BN_is_negative returns 1 if the BIGNUM is negative
|
|||
* \param a pointer to the BIGNUM object |
|||
* \return 1 if a < 0 and 0 otherwise |
|||
*/ |
|||
# define BN_is_negative(a) ((a)->neg != 0) |
|||
|
|||
int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, |
|||
BN_CTX *ctx); |
|||
# define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(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); |
|||
|
|||
BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); |
|||
BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); |
|||
int BN_mul_word(BIGNUM *a, BN_ULONG w); |
|||
int BN_add_word(BIGNUM *a, BN_ULONG w); |
|||
int BN_sub_word(BIGNUM *a, BN_ULONG w); |
|||
int BN_set_word(BIGNUM *a, BN_ULONG w); |
|||
BN_ULONG 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, BN_ULONG 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); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
int BN_print_fp(FILE *fp, const BIGNUM *a); |
|||
# endif |
|||
# ifdef HEADER_BIO_H |
|||
int BN_print(BIO *fp, const BIGNUM *a); |
|||
# else |
|||
int BN_print(void *fp, const BIGNUM *a); |
|||
# endif |
|||
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); /* returns
|
|||
* -2 for |
|||
* error */ |
|||
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(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords); |
|||
|
|||
/* Deprecated versions */ |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
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); |
|||
# endif /* !defined(OPENSSL_NO_DEPRECATED) */ |
|||
|
|||
/* Newer versions */ |
|||
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); |
|||
# define BN_to_montgomery(r,a,mont,ctx) BN_mod_mul_montgomery(\ |
|||
(r),(a),&((mont)->RR),(mont),(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 flags */ |
|||
# define BN_BLINDING_NO_UPDATE 0x00000001 |
|||
# define BN_BLINDING_NO_RECREATE 0x00000002 |
|||
|
|||
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 *); |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *); |
|||
void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long); |
|||
# endif |
|||
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); |
|||
|
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
void BN_set_params(int mul, int high, int low, int mont); |
|||
int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */ |
|||
# endif |
|||
|
|||
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); |
|||
|
|||
# ifndef OPENSSL_NO_EC2M |
|||
|
|||
/*
|
|||
* Functions for arithmetic over binary polynomials represented by BIGNUMs. |
|||
* The BIGNUM::neg property of BIGNUMs representing binary polynomials is |
|||
* ignored. Note that input arguments are not const so that their bit arrays |
|||
* can be expanded to the appropriate size if needed. |
|||
*/ |
|||
|
|||
/*
|
|||
* r = a + b |
|||
*/ |
|||
int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); |
|||
# define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) |
|||
/*
|
|||
* r=a mod p |
|||
*/ |
|||
int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); |
|||
/* r = (a * b) mod p */ |
|||
int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
|||
const BIGNUM *p, BN_CTX *ctx); |
|||
/* r = (a * a) mod p */ |
|||
int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); |
|||
/* r = (1 / b) mod p */ |
|||
int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx); |
|||
/* r = (a / b) mod p */ |
|||
int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
|||
const BIGNUM *p, BN_CTX *ctx); |
|||
/* r = (a ^ b) mod p */ |
|||
int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
|||
const BIGNUM *p, BN_CTX *ctx); |
|||
/* r = sqrt(a) mod p */ |
|||
int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, |
|||
BN_CTX *ctx); |
|||
/* r^2 + r = a mod p */ |
|||
int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, |
|||
BN_CTX *ctx); |
|||
# define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) |
|||
/*-
|
|||
* Some functions allow for representation of the irreducible polynomials |
|||
* as an unsigned int[], say p. The irreducible f(t) is then of the form: |
|||
* t^p[0] + t^p[1] + ... + t^p[k] |
|||
* where m = p[0] > p[1] > ... > p[k] = 0. |
|||
*/ |
|||
/* r = a mod p */ |
|||
int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); |
|||
/* r = (a * b) mod p */ |
|||
int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
|||
const int p[], BN_CTX *ctx); |
|||
/* r = (a * a) mod p */ |
|||
int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], |
|||
BN_CTX *ctx); |
|||
/* r = (1 / b) mod p */ |
|||
int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], |
|||
BN_CTX *ctx); |
|||
/* r = (a / b) mod p */ |
|||
int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
|||
const int p[], BN_CTX *ctx); |
|||
/* r = (a ^ b) mod p */ |
|||
int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, |
|||
const int p[], BN_CTX *ctx); |
|||
/* r = sqrt(a) mod p */ |
|||
int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, |
|||
const int p[], BN_CTX *ctx); |
|||
/* r^2 + r = a mod p */ |
|||
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); |
|||
|
|||
# endif |
|||
|
|||
/*
|
|||
* faster mod functions for the 'NIST primes' 0 <= a < p^2 |
|||
*/ |
|||
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); |
|||
|
|||
/* library internal functions */ |
|||
|
|||
# define bn_expand(a,bits) \ |
|||
( \ |
|||
bits > (INT_MAX - BN_BITS2 + 1) ? \ |
|||
NULL \ |
|||
: \ |
|||
(((bits+BN_BITS2-1)/BN_BITS2) <= (a)->dmax) ? \ |
|||
(a) \ |
|||
: \ |
|||
bn_expand2((a),(bits+BN_BITS2-1)/BN_BITS2) \ |
|||
) |
|||
|
|||
# define bn_wexpand(a,words) (((words) <= (a)->dmax)?(a):bn_expand2((a),(words))) |
|||
BIGNUM *bn_expand2(BIGNUM *a, int words); |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
BIGNUM *bn_dup_expand(const BIGNUM *a, int words); /* unused */ |
|||
# endif |
|||
|
|||
/*-
|
|||
* Bignum consistency macros |
|||
* There is one "API" macro, bn_fix_top(), for stripping leading zeroes from |
|||
* bignum data after direct manipulations on the data. There is also an |
|||
* "internal" macro, bn_check_top(), for verifying that there are no leading |
|||
* zeroes. Unfortunately, some auditing is required due to the fact that |
|||
* bn_fix_top() has become an overabused duct-tape because bignum data is |
|||
* occasionally passed around in an inconsistent state. So the following |
|||
* changes have been made to sort this out; |
|||
* - bn_fix_top()s implementation has been moved to bn_correct_top() |
|||
* - if BN_DEBUG isn't defined, bn_fix_top() maps to bn_correct_top(), and |
|||
* bn_check_top() is as before. |
|||
* - if BN_DEBUG *is* defined; |
|||
* - bn_check_top() tries to pollute unused words even if the bignum 'top' is |
|||
* consistent. (ed: only if BN_DEBUG_RAND is defined) |
|||
* - bn_fix_top() maps to bn_check_top() rather than "fixing" anything. |
|||
* The idea is to have debug builds flag up inconsistent bignums when they |
|||
* occur. If that occurs in a bn_fix_top(), we examine the code in question; if |
|||
* the use of bn_fix_top() was appropriate (ie. it follows directly after code |
|||
* that manipulates the bignum) it is converted to bn_correct_top(), and if it |
|||
* was not appropriate, we convert it permanently to bn_check_top() and track |
|||
* down the cause of the bug. Eventually, no internal code should be using the |
|||
* bn_fix_top() macro. External applications and libraries should try this with |
|||
* their own code too, both in terms of building against the openssl headers |
|||
* with BN_DEBUG defined *and* linking with a version of OpenSSL built with it |
|||
* defined. This not only improves external code, it provides more test |
|||
* coverage for openssl's own code. |
|||
*/ |
|||
|
|||
# ifdef BN_DEBUG |
|||
|
|||
/* We only need assert() when debugging */ |
|||
# include <assert.h> |
|||
|
|||
# ifdef BN_DEBUG_RAND |
|||
/* To avoid "make update" cvs wars due to BN_DEBUG, use some tricks */ |
|||
# ifndef RAND_pseudo_bytes |
|||
int RAND_pseudo_bytes(unsigned char *buf, int num); |
|||
# define BN_DEBUG_TRIX |
|||
# endif |
|||
# define bn_pollute(a) \ |
|||
do { \ |
|||
const BIGNUM *_bnum1 = (a); \ |
|||
if(_bnum1->top < _bnum1->dmax) { \ |
|||
unsigned char _tmp_char; \ |
|||
/* We cast away const without the compiler knowing, any \
|
|||
* *genuinely* constant variables that aren't mutable \ |
|||
* wouldn't be constructed with top!=dmax. */ \ |
|||
BN_ULONG *_not_const; \ |
|||
memcpy(&_not_const, &_bnum1->d, sizeof(BN_ULONG*)); \ |
|||
/* Debug only - safe to ignore error return */ \ |
|||
RAND_pseudo_bytes(&_tmp_char, 1); \ |
|||
memset((unsigned char *)(_not_const + _bnum1->top), _tmp_char, \ |
|||
(_bnum1->dmax - _bnum1->top) * sizeof(BN_ULONG)); \ |
|||
} \ |
|||
} while(0) |
|||
# ifdef BN_DEBUG_TRIX |
|||
# undef RAND_pseudo_bytes |
|||
# endif |
|||
# else |
|||
# define bn_pollute(a) |
|||
# endif |
|||
# define bn_check_top(a) \ |
|||
do { \ |
|||
const BIGNUM *_bnum2 = (a); \ |
|||
if (_bnum2 != NULL) { \ |
|||
assert((_bnum2->top == 0) || \ |
|||
(_bnum2->d[_bnum2->top - 1] != 0)); \ |
|||
bn_pollute(_bnum2); \ |
|||
} \ |
|||
} while(0) |
|||
|
|||
# define bn_fix_top(a) bn_check_top(a) |
|||
|
|||
# define bn_check_size(bn, bits) bn_wcheck_size(bn, ((bits+BN_BITS2-1))/BN_BITS2) |
|||
# define bn_wcheck_size(bn, words) \ |
|||
do { \ |
|||
const BIGNUM *_bnum2 = (bn); \ |
|||
assert((words) <= (_bnum2)->dmax && (words) >= (_bnum2)->top); \ |
|||
/* avoid unused variable warning with NDEBUG */ \ |
|||
(void)(_bnum2); \ |
|||
} while(0) |
|||
|
|||
# else /* !BN_DEBUG */ |
|||
|
|||
# define bn_pollute(a) |
|||
# define bn_check_top(a) |
|||
# define bn_fix_top(a) bn_correct_top(a) |
|||
# define bn_check_size(bn, bits) |
|||
# define bn_wcheck_size(bn, words) |
|||
|
|||
# endif |
|||
|
|||
# define bn_correct_top(a) \ |
|||
{ \ |
|||
BN_ULONG *ftl; \ |
|||
int tmp_top = (a)->top; \ |
|||
if (tmp_top > 0) \ |
|||
{ \ |
|||
for (ftl= &((a)->d[tmp_top-1]); tmp_top > 0; tmp_top--) \ |
|||
if (*(ftl--)) break; \ |
|||
(a)->top = tmp_top; \ |
|||
} \ |
|||
bn_pollute(a); \ |
|||
} |
|||
|
|||
BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, int num, |
|||
BN_ULONG w); |
|||
BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w); |
|||
void bn_sqr_words(BN_ULONG *rp, const BN_ULONG *ap, int num); |
|||
BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d); |
|||
BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, |
|||
int num); |
|||
BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, |
|||
int num); |
|||
|
|||
/* Primes from RFC 2409 */ |
|||
BIGNUM *get_rfc2409_prime_768(BIGNUM *bn); |
|||
BIGNUM *get_rfc2409_prime_1024(BIGNUM *bn); |
|||
|
|||
/* Primes from RFC 3526 */ |
|||
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); |
|||
|
|||
int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_BN_strings(void); |
|||
|
|||
/* Error codes for the BN functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define BN_F_BNRAND 127 |
|||
# define BN_F_BN_BLINDING_CONVERT_EX 100 |
|||
# define BN_F_BN_BLINDING_CREATE_PARAM 128 |
|||
# define BN_F_BN_BLINDING_INVERT_EX 101 |
|||
# define BN_F_BN_BLINDING_NEW 102 |
|||
# define BN_F_BN_BLINDING_UPDATE 103 |
|||
# define BN_F_BN_BN2DEC 104 |
|||
# define BN_F_BN_BN2HEX 105 |
|||
# define BN_F_BN_CTX_GET 116 |
|||
# define BN_F_BN_CTX_NEW 106 |
|||
# define BN_F_BN_CTX_START 129 |
|||
# define BN_F_BN_DIV 107 |
|||
# define BN_F_BN_DIV_NO_BRANCH 138 |
|||
# define BN_F_BN_DIV_RECP 130 |
|||
# define BN_F_BN_EXP 123 |
|||
# define BN_F_BN_EXPAND2 108 |
|||
# define BN_F_BN_EXPAND_INTERNAL 120 |
|||
# define BN_F_BN_GF2M_MOD 131 |
|||
# define BN_F_BN_GF2M_MOD_EXP 132 |
|||
# define BN_F_BN_GF2M_MOD_MUL 133 |
|||
# define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134 |
|||
# define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135 |
|||
# define BN_F_BN_GF2M_MOD_SQR 136 |
|||
# define BN_F_BN_GF2M_MOD_SQRT 137 |
|||
# define BN_F_BN_LSHIFT 145 |
|||
# define BN_F_BN_MOD_EXP2_MONT 118 |
|||
# define BN_F_BN_MOD_EXP_MONT 109 |
|||
# define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124 |
|||
# define BN_F_BN_MOD_EXP_MONT_WORD 117 |
|||
# define BN_F_BN_MOD_EXP_RECP 125 |
|||
# define BN_F_BN_MOD_EXP_SIMPLE 126 |
|||
# define BN_F_BN_MOD_INVERSE 110 |
|||
# define BN_F_BN_MOD_INVERSE_NO_BRANCH 139 |
|||
# define BN_F_BN_MOD_LSHIFT_QUICK 119 |
|||
# define BN_F_BN_MOD_MUL_RECIPROCAL 111 |
|||
# define BN_F_BN_MOD_SQRT 121 |
|||
# define BN_F_BN_MPI2BN 112 |
|||
# define BN_F_BN_NEW 113 |
|||
# define BN_F_BN_RAND 114 |
|||
# define BN_F_BN_RAND_RANGE 122 |
|||
# define BN_F_BN_RSHIFT 146 |
|||
# define BN_F_BN_USUB 115 |
|||
|
|||
/* Reason codes. */ |
|||
# define BN_R_ARG2_LT_ARG3 100 |
|||
# define BN_R_BAD_RECIPROCAL 101 |
|||
# define BN_R_BIGNUM_TOO_LONG 114 |
|||
# define BN_R_BITS_TOO_SMALL 118 |
|||
# define BN_R_CALLED_WITH_EVEN_MODULUS 102 |
|||
# define BN_R_DIV_BY_ZERO 103 |
|||
# define BN_R_ENCODING_ERROR 104 |
|||
# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 |
|||
# define BN_R_INPUT_NOT_REDUCED 110 |
|||
# define BN_R_INVALID_LENGTH 106 |
|||
# define BN_R_INVALID_RANGE 115 |
|||
# define BN_R_INVALID_SHIFT 119 |
|||
# define BN_R_NOT_A_SQUARE 111 |
|||
# define BN_R_NOT_INITIALIZED 107 |
|||
# define BN_R_NO_INVERSE 108 |
|||
# define BN_R_NO_SOLUTION 116 |
|||
# define BN_R_P_IS_NOT_PRIME 112 |
|||
# define BN_R_TOO_MANY_ITERATIONS 113 |
|||
# define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,124 +0,0 @@ |
|||
/* crypto/buffer/buffer.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_BUFFER_H |
|||
# define HEADER_BUFFER_H |
|||
|
|||
# include <openssl/ossl_typ.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# include <stddef.h> |
|||
|
|||
# if !defined(NO_SYS_TYPES_H) |
|||
# include <sys/types.h> |
|||
# endif |
|||
|
|||
/* Already declared in ossl_typ.h */ |
|||
/* typedef struct buf_mem_st BUF_MEM; */ |
|||
|
|||
struct buf_mem_st { |
|||
size_t length; /* current number of bytes */ |
|||
char *data; |
|||
size_t max; /* size of buffer */ |
|||
}; |
|||
|
|||
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); |
|||
|
|||
/*
|
|||
* Like strndup, but in addition, explicitly guarantees to never read past the |
|||
* first |siz| bytes of |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); |
|||
|
|||
/* safe string functions */ |
|||
size_t BUF_strlcpy(char *dst, const char *src, size_t siz); |
|||
size_t BUF_strlcat(char *dst, const char *src, size_t siz); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_BUF_strings(void); |
|||
|
|||
/* Error codes for the BUF functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define BUF_F_BUF_MEMDUP 103 |
|||
# define BUF_F_BUF_MEM_GROW 100 |
|||
# define BUF_F_BUF_MEM_GROW_CLEAN 105 |
|||
# define BUF_F_BUF_MEM_NEW 101 |
|||
# define BUF_F_BUF_STRDUP 102 |
|||
# define BUF_F_BUF_STRNDUP 104 |
|||
|
|||
/* Reason codes. */ |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,132 +0,0 @@ |
|||
/* crypto/camellia/camellia.h */ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2006 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_CAMELLIA_H |
|||
# define HEADER_CAMELLIA_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_CAMELLIA |
|||
# error CAMELLIA is disabled. |
|||
# endif |
|||
|
|||
# include <stddef.h> |
|||
|
|||
# define CAMELLIA_ENCRYPT 1 |
|||
# define CAMELLIA_DECRYPT 0 |
|||
|
|||
/*
|
|||
* Because array size can't be a const in C, the following two are macros. |
|||
* Both sizes are in bytes. |
|||
*/ |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* This should be a hidden type, but EVP requires that the size be known */ |
|||
|
|||
# define CAMELLIA_BLOCK_SIZE 16 |
|||
# define CAMELLIA_TABLE_BYTE_LEN 272 |
|||
# define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4) |
|||
|
|||
typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
|
|||
* with WORD */ |
|||
|
|||
struct camellia_key_st { |
|||
union { |
|||
double d; /* ensures 64-bit align */ |
|||
KEY_TABLE_TYPE rd_key; |
|||
} u; |
|||
int grand_rounds; |
|||
}; |
|||
typedef struct camellia_key_st CAMELLIA_KEY; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
int private_Camellia_set_key(const unsigned char *userKey, const int bits, |
|||
CAMELLIA_KEY *key); |
|||
# endif |
|||
int Camellia_set_key(const unsigned char *userKey, const int bits, |
|||
CAMELLIA_KEY *key); |
|||
|
|||
void Camellia_encrypt(const unsigned char *in, unsigned char *out, |
|||
const CAMELLIA_KEY *key); |
|||
void Camellia_decrypt(const unsigned char *in, unsigned char *out, |
|||
const CAMELLIA_KEY *key); |
|||
|
|||
void Camellia_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
const CAMELLIA_KEY *key, const int enc); |
|||
void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const CAMELLIA_KEY *key, |
|||
unsigned char *ivec, const int enc); |
|||
void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const CAMELLIA_KEY *key, |
|||
unsigned char *ivec, int *num, const int enc); |
|||
void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const CAMELLIA_KEY *key, |
|||
unsigned char *ivec, int *num, const int enc); |
|||
void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const CAMELLIA_KEY *key, |
|||
unsigned char *ivec, int *num, const int enc); |
|||
void Camellia_ofb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const CAMELLIA_KEY *key, |
|||
unsigned char *ivec, int *num); |
|||
void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const CAMELLIA_KEY *key, |
|||
unsigned char ivec[CAMELLIA_BLOCK_SIZE], |
|||
unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE], |
|||
unsigned int *num); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif /* !HEADER_Camellia_H */ |
|||
@ -1,107 +0,0 @@ |
|||
/* crypto/cast/cast.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_CAST_H |
|||
# define HEADER_CAST_H |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_CAST |
|||
# error CAST is disabled. |
|||
# endif |
|||
|
|||
# define CAST_ENCRYPT 1 |
|||
# define CAST_DECRYPT 0 |
|||
|
|||
# define CAST_LONG unsigned int |
|||
|
|||
# define CAST_BLOCK 8 |
|||
# define CAST_KEY_LENGTH 16 |
|||
|
|||
typedef struct cast_key_st { |
|||
CAST_LONG data[32]; |
|||
int short_key; /* Use reduced rounds for short key */ |
|||
} CAST_KEY; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
void private_CAST_set_key(CAST_KEY *key, int len, const unsigned char *data); |
|||
# endif |
|||
void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data); |
|||
void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
const CAST_KEY *key, int enc); |
|||
void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key); |
|||
void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key); |
|||
void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, const CAST_KEY *ks, unsigned char *iv, |
|||
int enc); |
|||
void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, const CAST_KEY *schedule, |
|||
unsigned char *ivec, int *num, int enc); |
|||
void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, const CAST_KEY *schedule, |
|||
unsigned char *ivec, int *num); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,82 +0,0 @@ |
|||
/* crypto/cmac/cmac.h */ |
|||
/*
|
|||
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL |
|||
* project. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2010 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
*/ |
|||
|
|||
#ifndef HEADER_CMAC_H |
|||
# define HEADER_CMAC_H |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# include <openssl/evp.h> |
|||
|
|||
/* Opaque */ |
|||
typedef struct CMAC_CTX_st CMAC_CTX; |
|||
|
|||
CMAC_CTX *CMAC_CTX_new(void); |
|||
void CMAC_CTX_cleanup(CMAC_CTX *ctx); |
|||
void CMAC_CTX_free(CMAC_CTX *ctx); |
|||
EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx); |
|||
int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in); |
|||
|
|||
int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen, |
|||
const EVP_CIPHER *cipher, ENGINE *impl); |
|||
int CMAC_Update(CMAC_CTX *ctx, const void *data, size_t dlen); |
|||
int CMAC_Final(CMAC_CTX *ctx, unsigned char *out, size_t *poutlen); |
|||
int CMAC_resume(CMAC_CTX *ctx); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,505 +0,0 @@ |
|||
/* crypto/cms/cms.h */ |
|||
/*
|
|||
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL |
|||
* project. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2008 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
*/ |
|||
|
|||
#ifndef HEADER_CMS_H |
|||
# define HEADER_CMS_H |
|||
|
|||
# include <openssl/x509.h> |
|||
|
|||
# ifdef OPENSSL_NO_CMS |
|||
# error CMS is disabled. |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct CMS_ContentInfo_st CMS_ContentInfo; |
|||
typedef struct CMS_SignerInfo_st CMS_SignerInfo; |
|||
typedef struct CMS_CertificateChoices CMS_CertificateChoices; |
|||
typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice; |
|||
typedef struct CMS_RecipientInfo_st CMS_RecipientInfo; |
|||
typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest; |
|||
typedef struct CMS_Receipt_st CMS_Receipt; |
|||
|
|||
DECLARE_STACK_OF(CMS_SignerInfo) |
|||
DECLARE_STACK_OF(GENERAL_NAMES) |
|||
DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo) |
|||
DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest) |
|||
DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo) |
|||
|
|||
# define CMS_SIGNERINFO_ISSUER_SERIAL 0 |
|||
# define CMS_SIGNERINFO_KEYIDENTIFIER 1 |
|||
|
|||
# define CMS_RECIPINFO_TRANS 0 |
|||
# define CMS_RECIPINFO_AGREE 1 |
|||
# define CMS_RECIPINFO_KEK 2 |
|||
# define CMS_RECIPINFO_PASS 3 |
|||
# define CMS_RECIPINFO_OTHER 4 |
|||
|
|||
/* S/MIME related flags */ |
|||
|
|||
# define CMS_TEXT 0x1 |
|||
# define CMS_NOCERTS 0x2 |
|||
# define CMS_NO_CONTENT_VERIFY 0x4 |
|||
# define CMS_NO_ATTR_VERIFY 0x8 |
|||
# define CMS_NOSIGS \ |
|||
(CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY) |
|||
# define CMS_NOINTERN 0x10 |
|||
# define CMS_NO_SIGNER_CERT_VERIFY 0x20 |
|||
# define CMS_NOVERIFY 0x20 |
|||
# define CMS_DETACHED 0x40 |
|||
# define CMS_BINARY 0x80 |
|||
# define CMS_NOATTR 0x100 |
|||
# define CMS_NOSMIMECAP 0x200 |
|||
# define CMS_NOOLDMIMETYPE 0x400 |
|||
# define CMS_CRLFEOL 0x800 |
|||
# define CMS_STREAM 0x1000 |
|||
# define CMS_NOCRL 0x2000 |
|||
# define CMS_PARTIAL 0x4000 |
|||
# define CMS_REUSE_DIGEST 0x8000 |
|||
# define CMS_USE_KEYID 0x10000 |
|||
# define CMS_DEBUG_DECRYPT 0x20000 |
|||
|
|||
const ASN1_OBJECT *CMS_get0_type(CMS_ContentInfo *cms); |
|||
|
|||
BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont); |
|||
int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio); |
|||
|
|||
ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms); |
|||
int CMS_is_detached(CMS_ContentInfo *cms); |
|||
int CMS_set_detached(CMS_ContentInfo *cms, int detached); |
|||
|
|||
# ifdef HEADER_PEM_H |
|||
DECLARE_PEM_rw_const(CMS, CMS_ContentInfo) |
|||
# endif |
|||
int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms); |
|||
CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms); |
|||
int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms); |
|||
|
|||
BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms); |
|||
int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags); |
|||
int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, |
|||
int flags); |
|||
CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont); |
|||
int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags); |
|||
|
|||
int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont, |
|||
unsigned int flags); |
|||
|
|||
CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey, |
|||
STACK_OF(X509) *certs, BIO *data, |
|||
unsigned int flags); |
|||
|
|||
CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si, |
|||
X509 *signcert, EVP_PKEY *pkey, |
|||
STACK_OF(X509) *certs, unsigned int flags); |
|||
|
|||
int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags); |
|||
CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags); |
|||
|
|||
int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out, |
|||
unsigned int flags); |
|||
CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md, |
|||
unsigned int flags); |
|||
|
|||
int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms, |
|||
const unsigned char *key, size_t keylen, |
|||
BIO *dcont, BIO *out, unsigned int flags); |
|||
|
|||
CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher, |
|||
const unsigned char *key, |
|||
size_t keylen, unsigned int flags); |
|||
|
|||
int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph, |
|||
const unsigned char *key, size_t keylen); |
|||
|
|||
int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs, |
|||
X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags); |
|||
|
|||
int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms, |
|||
STACK_OF(X509) *certs, |
|||
X509_STORE *store, unsigned int flags); |
|||
|
|||
STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms); |
|||
|
|||
CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in, |
|||
const EVP_CIPHER *cipher, unsigned int flags); |
|||
|
|||
int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert, |
|||
BIO *dcont, BIO *out, unsigned int flags); |
|||
|
|||
int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert); |
|||
int CMS_decrypt_set1_key(CMS_ContentInfo *cms, |
|||
unsigned char *key, size_t keylen, |
|||
unsigned char *id, size_t idlen); |
|||
int CMS_decrypt_set1_password(CMS_ContentInfo *cms, |
|||
unsigned char *pass, ossl_ssize_t passlen); |
|||
|
|||
STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms); |
|||
int CMS_RecipientInfo_type(CMS_RecipientInfo *ri); |
|||
CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher); |
|||
CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms, |
|||
X509 *recip, unsigned int flags); |
|||
int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey); |
|||
int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert); |
|||
int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri, |
|||
EVP_PKEY **pk, X509 **recip, |
|||
X509_ALGOR **palg); |
|||
int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri, |
|||
ASN1_OCTET_STRING **keyid, |
|||
X509_NAME **issuer, |
|||
ASN1_INTEGER **sno); |
|||
|
|||
CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid, |
|||
unsigned char *key, size_t keylen, |
|||
unsigned char *id, size_t idlen, |
|||
ASN1_GENERALIZEDTIME *date, |
|||
ASN1_OBJECT *otherTypeId, |
|||
ASN1_TYPE *otherType); |
|||
|
|||
int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri, |
|||
X509_ALGOR **palg, |
|||
ASN1_OCTET_STRING **pid, |
|||
ASN1_GENERALIZEDTIME **pdate, |
|||
ASN1_OBJECT **potherid, |
|||
ASN1_TYPE **pothertype); |
|||
|
|||
int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, |
|||
unsigned char *key, size_t keylen); |
|||
|
|||
int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, |
|||
const unsigned char *id, size_t idlen); |
|||
|
|||
int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri, |
|||
unsigned char *pass, |
|||
ossl_ssize_t passlen); |
|||
|
|||
CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms, |
|||
int iter, int wrap_nid, |
|||
int pbe_nid, |
|||
unsigned char *pass, |
|||
ossl_ssize_t passlen, |
|||
const EVP_CIPHER *kekciph); |
|||
|
|||
int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); |
|||
|
|||
int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out, |
|||
unsigned int flags); |
|||
CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags); |
|||
|
|||
int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid); |
|||
const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms); |
|||
|
|||
CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms); |
|||
int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert); |
|||
int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert); |
|||
STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms); |
|||
|
|||
CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms); |
|||
int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl); |
|||
int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl); |
|||
STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms); |
|||
|
|||
int CMS_SignedData_init(CMS_ContentInfo *cms); |
|||
CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms, |
|||
X509 *signer, EVP_PKEY *pk, const EVP_MD *md, |
|||
unsigned int flags); |
|||
STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms); |
|||
|
|||
void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer); |
|||
int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, |
|||
ASN1_OCTET_STRING **keyid, |
|||
X509_NAME **issuer, ASN1_INTEGER **sno); |
|||
int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert); |
|||
int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs, |
|||
unsigned int flags); |
|||
void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, |
|||
X509 **signer, X509_ALGOR **pdig, |
|||
X509_ALGOR **psig); |
|||
int CMS_SignerInfo_sign(CMS_SignerInfo *si); |
|||
int CMS_SignerInfo_verify(CMS_SignerInfo *si); |
|||
int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain); |
|||
|
|||
int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs); |
|||
int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, |
|||
int algnid, int keysize); |
|||
int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap); |
|||
|
|||
int CMS_signed_get_attr_count(const CMS_SignerInfo *si); |
|||
int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid, |
|||
int lastpos); |
|||
int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, ASN1_OBJECT *obj, |
|||
int lastpos); |
|||
X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc); |
|||
X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc); |
|||
int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); |
|||
int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si, |
|||
const ASN1_OBJECT *obj, int type, |
|||
const void *bytes, int len); |
|||
int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si, |
|||
int nid, int type, |
|||
const void *bytes, int len); |
|||
int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si, |
|||
const char *attrname, int type, |
|||
const void *bytes, int len); |
|||
void *CMS_signed_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, |
|||
int lastpos, int type); |
|||
|
|||
int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si); |
|||
int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid, |
|||
int lastpos); |
|||
int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si, ASN1_OBJECT *obj, |
|||
int lastpos); |
|||
X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc); |
|||
X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc); |
|||
int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); |
|||
int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si, |
|||
const ASN1_OBJECT *obj, int type, |
|||
const void *bytes, int len); |
|||
int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si, |
|||
int nid, int type, |
|||
const void *bytes, int len); |
|||
int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si, |
|||
const char *attrname, int type, |
|||
const void *bytes, int len); |
|||
void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, |
|||
int lastpos, int type); |
|||
|
|||
# ifdef HEADER_X509V3_H |
|||
|
|||
int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr); |
|||
CMS_ReceiptRequest *CMS_ReceiptRequest_create0(unsigned char *id, int idlen, |
|||
int allorfirst, |
|||
STACK_OF(GENERAL_NAMES) |
|||
*receiptList, STACK_OF(GENERAL_NAMES) |
|||
*receiptsTo); |
|||
int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr); |
|||
void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr, |
|||
ASN1_STRING **pcid, |
|||
int *pallorfirst, |
|||
STACK_OF(GENERAL_NAMES) **plist, |
|||
STACK_OF(GENERAL_NAMES) **prto); |
|||
|
|||
# endif |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_CMS_strings(void); |
|||
|
|||
/* Error codes for the CMS functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define CMS_F_CHECK_CONTENT 99 |
|||
# define CMS_F_CMS_ADD0_CERT 164 |
|||
# define CMS_F_CMS_ADD0_RECIPIENT_KEY 100 |
|||
# define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD 165 |
|||
# define CMS_F_CMS_ADD1_RECEIPTREQUEST 158 |
|||
# define CMS_F_CMS_ADD1_RECIPIENT_CERT 101 |
|||
# define CMS_F_CMS_ADD1_SIGNER 102 |
|||
# define CMS_F_CMS_ADD1_SIGNINGTIME 103 |
|||
# define CMS_F_CMS_COMPRESS 104 |
|||
# define CMS_F_CMS_COMPRESSEDDATA_CREATE 105 |
|||
# define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO 106 |
|||
# define CMS_F_CMS_COPY_CONTENT 107 |
|||
# define CMS_F_CMS_COPY_MESSAGEDIGEST 108 |
|||
# define CMS_F_CMS_DATA 109 |
|||
# define CMS_F_CMS_DATAFINAL 110 |
|||
# define CMS_F_CMS_DATAINIT 111 |
|||
# define CMS_F_CMS_DECRYPT 112 |
|||
# define CMS_F_CMS_DECRYPT_SET1_KEY 113 |
|||
# define CMS_F_CMS_DECRYPT_SET1_PASSWORD 166 |
|||
# define CMS_F_CMS_DECRYPT_SET1_PKEY 114 |
|||
# define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX 115 |
|||
# define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO 116 |
|||
# define CMS_F_CMS_DIGESTEDDATA_DO_FINAL 117 |
|||
# define CMS_F_CMS_DIGEST_VERIFY 118 |
|||
# define CMS_F_CMS_ENCODE_RECEIPT 161 |
|||
# define CMS_F_CMS_ENCRYPT 119 |
|||
# define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO 120 |
|||
# define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT 121 |
|||
# define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT 122 |
|||
# define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY 123 |
|||
# define CMS_F_CMS_ENVELOPEDDATA_CREATE 124 |
|||
# define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO 125 |
|||
# define CMS_F_CMS_ENVELOPED_DATA_INIT 126 |
|||
# define CMS_F_CMS_FINAL 127 |
|||
# define CMS_F_CMS_GET0_CERTIFICATE_CHOICES 128 |
|||
# define CMS_F_CMS_GET0_CONTENT 129 |
|||
# define CMS_F_CMS_GET0_ECONTENT_TYPE 130 |
|||
# define CMS_F_CMS_GET0_ENVELOPED 131 |
|||
# define CMS_F_CMS_GET0_REVOCATION_CHOICES 132 |
|||
# define CMS_F_CMS_GET0_SIGNED 133 |
|||
# define CMS_F_CMS_MSGSIGDIGEST_ADD1 162 |
|||
# define CMS_F_CMS_RECEIPTREQUEST_CREATE0 159 |
|||
# define CMS_F_CMS_RECEIPT_VERIFY 160 |
|||
# define CMS_F_CMS_RECIPIENTINFO_DECRYPT 134 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT 135 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT 136 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID 137 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP 138 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP 139 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT 140 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT 141 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS 142 |
|||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID 143 |
|||
# define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT 167 |
|||
# define CMS_F_CMS_RECIPIENTINFO_SET0_KEY 144 |
|||
# define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD 168 |
|||
# define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY 145 |
|||
# define CMS_F_CMS_SET1_SIGNERIDENTIFIER 146 |
|||
# define CMS_F_CMS_SET_DETACHED 147 |
|||
# define CMS_F_CMS_SIGN 148 |
|||
# define CMS_F_CMS_SIGNED_DATA_INIT 149 |
|||
# define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN 150 |
|||
# define CMS_F_CMS_SIGNERINFO_SIGN 151 |
|||
# define CMS_F_CMS_SIGNERINFO_VERIFY 152 |
|||
# define CMS_F_CMS_SIGNERINFO_VERIFY_CERT 153 |
|||
# define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT 154 |
|||
# define CMS_F_CMS_SIGN_RECEIPT 163 |
|||
# define CMS_F_CMS_STREAM 155 |
|||
# define CMS_F_CMS_UNCOMPRESS 156 |
|||
# define CMS_F_CMS_VERIFY 157 |
|||
|
|||
/* Reason codes. */ |
|||
# define CMS_R_ADD_SIGNER_ERROR 99 |
|||
# define CMS_R_CERTIFICATE_ALREADY_PRESENT 175 |
|||
# define CMS_R_CERTIFICATE_HAS_NO_KEYID 160 |
|||
# define CMS_R_CERTIFICATE_VERIFY_ERROR 100 |
|||
# define CMS_R_CIPHER_INITIALISATION_ERROR 101 |
|||
# define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102 |
|||
# define CMS_R_CMS_DATAFINAL_ERROR 103 |
|||
# define CMS_R_CMS_LIB 104 |
|||
# define CMS_R_CONTENTIDENTIFIER_MISMATCH 170 |
|||
# define CMS_R_CONTENT_NOT_FOUND 105 |
|||
# define CMS_R_CONTENT_TYPE_MISMATCH 171 |
|||
# define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106 |
|||
# define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107 |
|||
# define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108 |
|||
# define CMS_R_CONTENT_VERIFY_ERROR 109 |
|||
# define CMS_R_CTRL_ERROR 110 |
|||
# define CMS_R_CTRL_FAILURE 111 |
|||
# define CMS_R_DECRYPT_ERROR 112 |
|||
# define CMS_R_DIGEST_ERROR 161 |
|||
# define CMS_R_ERROR_GETTING_PUBLIC_KEY 113 |
|||
# define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114 |
|||
# define CMS_R_ERROR_SETTING_KEY 115 |
|||
# define CMS_R_ERROR_SETTING_RECIPIENTINFO 116 |
|||
# define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117 |
|||
# define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176 |
|||
# define CMS_R_INVALID_KEY_LENGTH 118 |
|||
# define CMS_R_MD_BIO_INIT_ERROR 119 |
|||
# define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120 |
|||
# define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121 |
|||
# define CMS_R_MSGSIGDIGEST_ERROR 172 |
|||
# define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162 |
|||
# define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163 |
|||
# define CMS_R_NEED_ONE_SIGNER 164 |
|||
# define CMS_R_NOT_A_SIGNED_RECEIPT 165 |
|||
# define CMS_R_NOT_ENCRYPTED_DATA 122 |
|||
# define CMS_R_NOT_KEK 123 |
|||
# define CMS_R_NOT_KEY_TRANSPORT 124 |
|||
# define CMS_R_NOT_PWRI 177 |
|||
# define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125 |
|||
# define CMS_R_NO_CIPHER 126 |
|||
# define CMS_R_NO_CONTENT 127 |
|||
# define CMS_R_NO_CONTENT_TYPE 173 |
|||
# define CMS_R_NO_DEFAULT_DIGEST 128 |
|||
# define CMS_R_NO_DIGEST_SET 129 |
|||
# define CMS_R_NO_KEY 130 |
|||
# define CMS_R_NO_KEY_OR_CERT 174 |
|||
# define CMS_R_NO_MATCHING_DIGEST 131 |
|||
# define CMS_R_NO_MATCHING_RECIPIENT 132 |
|||
# define CMS_R_NO_MATCHING_SIGNATURE 166 |
|||
# define CMS_R_NO_MSGSIGDIGEST 167 |
|||
# define CMS_R_NO_PASSWORD 178 |
|||
# define CMS_R_NO_PRIVATE_KEY 133 |
|||
# define CMS_R_NO_PUBLIC_KEY 134 |
|||
# define CMS_R_NO_RECEIPT_REQUEST 168 |
|||
# define CMS_R_NO_SIGNERS 135 |
|||
# define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136 |
|||
# define CMS_R_RECEIPT_DECODE_ERROR 169 |
|||
# define CMS_R_RECIPIENT_ERROR 137 |
|||
# define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138 |
|||
# define CMS_R_SIGNFINAL_ERROR 139 |
|||
# define CMS_R_SMIME_TEXT_ERROR 140 |
|||
# define CMS_R_STORE_INIT_ERROR 141 |
|||
# define CMS_R_TYPE_NOT_COMPRESSED_DATA 142 |
|||
# define CMS_R_TYPE_NOT_DATA 143 |
|||
# define CMS_R_TYPE_NOT_DIGESTED_DATA 144 |
|||
# define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145 |
|||
# define CMS_R_TYPE_NOT_ENVELOPED_DATA 146 |
|||
# define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147 |
|||
# define CMS_R_UNKNOWN_CIPHER 148 |
|||
# define CMS_R_UNKNOWN_DIGEST_ALGORIHM 149 |
|||
# define CMS_R_UNKNOWN_ID 150 |
|||
# define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151 |
|||
# define CMS_R_UNSUPPORTED_CONTENT_TYPE 152 |
|||
# define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153 |
|||
# define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179 |
|||
# define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154 |
|||
# define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE 155 |
|||
# define CMS_R_UNSUPPORTED_TYPE 156 |
|||
# define CMS_R_UNWRAP_ERROR 157 |
|||
# define CMS_R_UNWRAP_FAILURE 180 |
|||
# define CMS_R_VERIFICATION_FAILURE 158 |
|||
# define CMS_R_WRAP_ERROR 159 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,79 +0,0 @@ |
|||
|
|||
#ifndef HEADER_COMP_H |
|||
# define HEADER_COMP_H |
|||
|
|||
# include <openssl/crypto.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct comp_ctx_st COMP_CTX; |
|||
|
|||
typedef struct comp_method_st { |
|||
int type; /* NID for compression library */ |
|||
const char *name; /* A text string to identify the library */ |
|||
int (*init) (COMP_CTX *ctx); |
|||
void (*finish) (COMP_CTX *ctx); |
|||
int (*compress) (COMP_CTX *ctx, |
|||
unsigned char *out, unsigned int olen, |
|||
unsigned char *in, unsigned int ilen); |
|||
int (*expand) (COMP_CTX *ctx, |
|||
unsigned char *out, unsigned int olen, |
|||
unsigned char *in, unsigned int ilen); |
|||
/*
|
|||
* The following two do NOTHING, but are kept for backward compatibility |
|||
*/ |
|||
long (*ctrl) (void); |
|||
long (*callback_ctrl) (void); |
|||
} COMP_METHOD; |
|||
|
|||
struct comp_ctx_st { |
|||
COMP_METHOD *meth; |
|||
unsigned long compress_in; |
|||
unsigned long compress_out; |
|||
unsigned long expand_in; |
|||
unsigned long expand_out; |
|||
CRYPTO_EX_DATA ex_data; |
|||
}; |
|||
|
|||
COMP_CTX *COMP_CTX_new(COMP_METHOD *meth); |
|||
void COMP_CTX_free(COMP_CTX *ctx); |
|||
int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen, |
|||
unsigned char *in, int ilen); |
|||
int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen, |
|||
unsigned char *in, int ilen); |
|||
COMP_METHOD *COMP_rle(void); |
|||
COMP_METHOD *COMP_zlib(void); |
|||
void COMP_zlib_cleanup(void); |
|||
|
|||
# ifdef HEADER_BIO_H |
|||
# ifdef ZLIB |
|||
BIO_METHOD *BIO_f_zlib(void); |
|||
# endif |
|||
# endif |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_COMP_strings(void); |
|||
|
|||
/* Error codes for the COMP functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define COMP_F_BIO_ZLIB_FLUSH 99 |
|||
# define COMP_F_BIO_ZLIB_NEW 100 |
|||
# define COMP_F_BIO_ZLIB_READ 101 |
|||
# define COMP_F_BIO_ZLIB_WRITE 102 |
|||
|
|||
/* Reason codes. */ |
|||
# define COMP_R_ZLIB_DEFLATE_ERROR 99 |
|||
# define COMP_R_ZLIB_INFLATE_ERROR 100 |
|||
# define COMP_R_ZLIB_NOT_SUPPORTED 101 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,267 +0,0 @@ |
|||
/* crypto/conf/conf.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_CONF_H |
|||
# define HEADER_CONF_H |
|||
|
|||
# include <openssl/bio.h> |
|||
# include <openssl/lhash.h> |
|||
# include <openssl/stack.h> |
|||
# include <openssl/safestack.h> |
|||
# include <openssl/e_os2.h> |
|||
|
|||
# include <openssl/ossl_typ.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct { |
|||
char *section; |
|||
char *name; |
|||
char *value; |
|||
} CONF_VALUE; |
|||
|
|||
DECLARE_STACK_OF(CONF_VALUE) |
|||
DECLARE_LHASH_OF(CONF_VALUE); |
|||
|
|||
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); |
|||
}; |
|||
|
|||
/* Module definitions */ |
|||
|
|||
typedef struct conf_imodule_st CONF_IMODULE; |
|||
typedef struct conf_module_st CONF_MODULE; |
|||
|
|||
DECLARE_STACK_OF(CONF_MODULE) |
|||
DECLARE_STACK_OF(CONF_IMODULE) |
|||
|
|||
/* DSO module function typedefs */ |
|||
typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf); |
|||
typedef void conf_finish_func (CONF_IMODULE *md); |
|||
|
|||
# define CONF_MFLAGS_IGNORE_ERRORS 0x1 |
|||
# define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2 |
|||
# define CONF_MFLAGS_SILENT 0x4 |
|||
# define CONF_MFLAGS_NO_DSO 0x8 |
|||
# define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10 |
|||
# define CONF_MFLAGS_DEFAULT_SECTION 0x20 |
|||
|
|||
int CONF_set_default_method(CONF_METHOD *meth); |
|||
void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash); |
|||
LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file, |
|||
long *eline); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp, |
|||
long *eline); |
|||
# endif |
|||
LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp, |
|||
long *eline); |
|||
STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf, |
|||
const char *section); |
|||
char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group, |
|||
const char *name); |
|||
long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group, |
|||
const char *name); |
|||
void CONF_free(LHASH_OF(CONF_VALUE) *conf); |
|||
int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out); |
|||
int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out); |
|||
|
|||
void OPENSSL_config(const char *config_name); |
|||
void OPENSSL_no_config(void); |
|||
|
|||
/*
|
|||
* New conf code. The semantics are different from the functions above. If |
|||
* that wasn't the case, the above functions would have been replaced |
|||
*/ |
|||
|
|||
struct conf_st { |
|||
CONF_METHOD *meth; |
|||
void *meth_data; |
|||
LHASH_OF(CONF_VALUE) *data; |
|||
}; |
|||
|
|||
CONF *NCONF_new(CONF_METHOD *meth); |
|||
CONF_METHOD *NCONF_default(void); |
|||
CONF_METHOD *NCONF_WIN32(void); |
|||
# if 0 /* Just to give you an idea of what I have in |
|||
* mind */ |
|||
CONF_METHOD *NCONF_XML(void); |
|||
# endif |
|||
void NCONF_free(CONF *conf); |
|||
void NCONF_free_data(CONF *conf); |
|||
|
|||
int NCONF_load(CONF *conf, const char *file, long *eline); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
int NCONF_load_fp(CONF *conf, FILE *fp, long *eline); |
|||
# endif |
|||
int NCONF_load_bio(CONF *conf, BIO *bp, long *eline); |
|||
STACK_OF(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); |
|||
|
|||
# if 0 /* The following function has no error |
|||
* checking, and should therefore be avoided */ |
|||
long NCONF_get_number(CONF *conf, char *group, char *name); |
|||
# else |
|||
# define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r) |
|||
# endif |
|||
|
|||
/* Module functions */ |
|||
|
|||
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); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_CONF_strings(void); |
|||
|
|||
/* Error codes for the CONF functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define CONF_F_CONF_DUMP_FP 104 |
|||
# define CONF_F_CONF_LOAD 100 |
|||
# define CONF_F_CONF_LOAD_BIO 102 |
|||
# define CONF_F_CONF_LOAD_FP 103 |
|||
# define CONF_F_CONF_MODULES_LOAD 116 |
|||
# define CONF_F_CONF_PARSE_LIST 119 |
|||
# define CONF_F_DEF_LOAD 120 |
|||
# define CONF_F_DEF_LOAD_BIO 121 |
|||
# define CONF_F_MODULE_INIT 115 |
|||
# define CONF_F_MODULE_LOAD_DSO 117 |
|||
# define CONF_F_MODULE_RUN 118 |
|||
# define CONF_F_NCONF_DUMP_BIO 105 |
|||
# define CONF_F_NCONF_DUMP_FP 106 |
|||
# define CONF_F_NCONF_GET_NUMBER 107 |
|||
# define CONF_F_NCONF_GET_NUMBER_E 112 |
|||
# define CONF_F_NCONF_GET_SECTION 108 |
|||
# define CONF_F_NCONF_GET_STRING 109 |
|||
# define CONF_F_NCONF_LOAD 113 |
|||
# define CONF_F_NCONF_LOAD_BIO 110 |
|||
# define CONF_F_NCONF_LOAD_FP 114 |
|||
# define CONF_F_NCONF_NEW 111 |
|||
# define CONF_F_STR_COPY 101 |
|||
|
|||
/* Reason codes. */ |
|||
# define CONF_R_ERROR_LOADING_DSO 110 |
|||
# define CONF_R_LIST_CANNOT_BE_NULL 115 |
|||
# define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100 |
|||
# define CONF_R_MISSING_EQUAL_SIGN 101 |
|||
# define CONF_R_MISSING_FINISH_FUNCTION 111 |
|||
# define CONF_R_MISSING_INIT_FUNCTION 112 |
|||
# define CONF_R_MODULE_INITIALIZATION_ERROR 109 |
|||
# define CONF_R_NO_CLOSE_BRACE 102 |
|||
# define CONF_R_NO_CONF 105 |
|||
# define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106 |
|||
# define CONF_R_NO_SECTION 107 |
|||
# define CONF_R_NO_SUCH_FILE 114 |
|||
# define CONF_R_NO_VALUE 108 |
|||
# define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103 |
|||
# define CONF_R_UNKNOWN_MODULE_NAME 113 |
|||
# define CONF_R_VARIABLE_HAS_NO_VALUE 104 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,89 +0,0 @@ |
|||
/* conf_api.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_CONF_API_H |
|||
# define HEADER_CONF_API_H |
|||
|
|||
# include <openssl/lhash.h> |
|||
# include <openssl/conf.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Up until OpenSSL 0.9.5a, this was new_section */ |
|||
CONF_VALUE *_CONF_new_section(CONF *conf, const char *section); |
|||
/* Up until OpenSSL 0.9.5a, this was get_section */ |
|||
CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section); |
|||
/* Up until OpenSSL 0.9.5a, this was CONF_get_section */ |
|||
STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf, |
|||
const char *section); |
|||
|
|||
int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value); |
|||
char *_CONF_get_string(const CONF *conf, const char *section, |
|||
const char *name); |
|||
long _CONF_get_number(const CONF *conf, const char *section, |
|||
const char *name); |
|||
|
|||
int _CONF_new_data(CONF *conf); |
|||
void _CONF_free_data(CONF *conf); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,661 +0,0 @@ |
|||
/* crypto/crypto.h */ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. |
|||
* ECDH support in OpenSSL originally developed by |
|||
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. |
|||
*/ |
|||
|
|||
#ifndef HEADER_CRYPTO_H |
|||
# define HEADER_CRYPTO_H |
|||
|
|||
# include <stdlib.h> |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
# include <stdio.h> |
|||
# endif |
|||
|
|||
# include <openssl/stack.h> |
|||
# include <openssl/safestack.h> |
|||
# include <openssl/opensslv.h> |
|||
# include <openssl/ossl_typ.h> |
|||
|
|||
# ifdef CHARSET_EBCDIC |
|||
# include <openssl/ebcdic.h> |
|||
# endif |
|||
|
|||
/*
|
|||
* Resolve problems on some operating systems with symbol names that clash |
|||
* one way or another |
|||
*/ |
|||
# include <openssl/symhacks.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Backward compatibility to SSLeay */ |
|||
/*
|
|||
* This is more to be used to check the correct DLL is being used in the MS |
|||
* world. |
|||
*/ |
|||
# define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER |
|||
# define SSLEAY_VERSION 0 |
|||
/* #define SSLEAY_OPTIONS 1 no longer supported */ |
|||
# define SSLEAY_CFLAGS 2 |
|||
# define SSLEAY_BUILT_ON 3 |
|||
# define SSLEAY_PLATFORM 4 |
|||
# define SSLEAY_DIR 5 |
|||
|
|||
/* Already declared in ossl_typ.h */ |
|||
# if 0 |
|||
typedef struct crypto_ex_data_st CRYPTO_EX_DATA; |
|||
/* Called when a new object is created */ |
|||
typedef int CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad, |
|||
int idx, long argl, void *argp); |
|||
/* Called when an object is free()ed */ |
|||
typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad, |
|||
int idx, long argl, void *argp); |
|||
/* Called when we need to dup an object */ |
|||
typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, |
|||
void *from_d, int idx, long argl, void *argp); |
|||
# endif |
|||
|
|||
/* A generic structure to pass assorted data in a expandable way */ |
|||
typedef struct openssl_item_st { |
|||
int code; |
|||
void *value; /* Not used for flag attributes */ |
|||
size_t value_size; /* Max size of value for output, length for
|
|||
* input */ |
|||
size_t *value_length; /* Returned length of value for output */ |
|||
} OPENSSL_ITEM; |
|||
|
|||
/*
|
|||
* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock |
|||
* names in cryptlib.c |
|||
*/ |
|||
|
|||
# define CRYPTO_LOCK_ERR 1 |
|||
# define CRYPTO_LOCK_EX_DATA 2 |
|||
# define CRYPTO_LOCK_X509 3 |
|||
# define CRYPTO_LOCK_X509_INFO 4 |
|||
# define CRYPTO_LOCK_X509_PKEY 5 |
|||
# define CRYPTO_LOCK_X509_CRL 6 |
|||
# define CRYPTO_LOCK_X509_REQ 7 |
|||
# define CRYPTO_LOCK_DSA 8 |
|||
# define CRYPTO_LOCK_RSA 9 |
|||
# define CRYPTO_LOCK_EVP_PKEY 10 |
|||
# define CRYPTO_LOCK_X509_STORE 11 |
|||
# define CRYPTO_LOCK_SSL_CTX 12 |
|||
# define CRYPTO_LOCK_SSL_CERT 13 |
|||
# define CRYPTO_LOCK_SSL_SESSION 14 |
|||
# define CRYPTO_LOCK_SSL_SESS_CERT 15 |
|||
# define CRYPTO_LOCK_SSL 16 |
|||
# define CRYPTO_LOCK_SSL_METHOD 17 |
|||
# define CRYPTO_LOCK_RAND 18 |
|||
# define CRYPTO_LOCK_RAND2 19 |
|||
# define CRYPTO_LOCK_MALLOC 20 |
|||
# define CRYPTO_LOCK_BIO 21 |
|||
# define CRYPTO_LOCK_GETHOSTBYNAME 22 |
|||
# define CRYPTO_LOCK_GETSERVBYNAME 23 |
|||
# define CRYPTO_LOCK_READDIR 24 |
|||
# define CRYPTO_LOCK_RSA_BLINDING 25 |
|||
# define CRYPTO_LOCK_DH 26 |
|||
# define CRYPTO_LOCK_MALLOC2 27 |
|||
# define CRYPTO_LOCK_DSO 28 |
|||
# define CRYPTO_LOCK_DYNLOCK 29 |
|||
# define CRYPTO_LOCK_ENGINE 30 |
|||
# define CRYPTO_LOCK_UI 31 |
|||
# define CRYPTO_LOCK_ECDSA 32 |
|||
# define CRYPTO_LOCK_EC 33 |
|||
# define CRYPTO_LOCK_ECDH 34 |
|||
# define CRYPTO_LOCK_BN 35 |
|||
# define CRYPTO_LOCK_EC_PRE_COMP 36 |
|||
# define CRYPTO_LOCK_STORE 37 |
|||
# define CRYPTO_LOCK_COMP 38 |
|||
# define CRYPTO_LOCK_FIPS 39 |
|||
# define CRYPTO_LOCK_FIPS2 40 |
|||
# define CRYPTO_NUM_LOCKS 41 |
|||
|
|||
# define CRYPTO_LOCK 1 |
|||
# define CRYPTO_UNLOCK 2 |
|||
# define CRYPTO_READ 4 |
|||
# define CRYPTO_WRITE 8 |
|||
|
|||
# ifndef OPENSSL_NO_LOCKING |
|||
# ifndef CRYPTO_w_lock |
|||
# define CRYPTO_w_lock(type) \ |
|||
CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__) |
|||
# define CRYPTO_w_unlock(type) \ |
|||
CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__) |
|||
# define CRYPTO_r_lock(type) \ |
|||
CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__) |
|||
# define CRYPTO_r_unlock(type) \ |
|||
CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__) |
|||
# define CRYPTO_add(addr,amount,type) \ |
|||
CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__) |
|||
# endif |
|||
# else |
|||
# define CRYPTO_w_lock(a) |
|||
# define CRYPTO_w_unlock(a) |
|||
# define CRYPTO_r_lock(a) |
|||
# define CRYPTO_r_unlock(a) |
|||
# define CRYPTO_add(a,b,c) ((*(a))+=(b)) |
|||
# endif |
|||
|
|||
/*
|
|||
* Some applications as well as some parts of OpenSSL need to allocate and |
|||
* deallocate locks in a dynamic fashion. The following typedef makes this |
|||
* possible in a type-safe manner. |
|||
*/ |
|||
/* struct CRYPTO_dynlock_value has to be defined by the application. */ |
|||
typedef struct { |
|||
int references; |
|||
struct CRYPTO_dynlock_value *data; |
|||
} CRYPTO_dynlock; |
|||
|
|||
/*
|
|||
* The following can be used to detect memory leaks in the SSLeay library. It |
|||
* used, it turns on malloc checking |
|||
*/ |
|||
|
|||
# define CRYPTO_MEM_CHECK_OFF 0x0/* an enume */ |
|||
# define CRYPTO_MEM_CHECK_ON 0x1/* a bit */ |
|||
# define CRYPTO_MEM_CHECK_ENABLE 0x2/* a bit */ |
|||
# define CRYPTO_MEM_CHECK_DISABLE 0x3/* an enume */ |
|||
|
|||
/*
|
|||
* The following are bit values to turn on or off options connected to the |
|||
* malloc checking functionality |
|||
*/ |
|||
|
|||
/* Adds time to the memory checking information */ |
|||
# define V_CRYPTO_MDEBUG_TIME 0x1/* a bit */ |
|||
/* Adds thread number to the memory checking information */ |
|||
# define V_CRYPTO_MDEBUG_THREAD 0x2/* a bit */ |
|||
|
|||
# define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD) |
|||
|
|||
/* predec of the BIO type */ |
|||
typedef struct bio_st BIO_dummy; |
|||
|
|||
struct crypto_ex_data_st { |
|||
STACK_OF(void) *sk; |
|||
/* gcc is screwing up this data structure :-( */ |
|||
int dummy; |
|||
}; |
|||
DECLARE_STACK_OF(void) |
|||
|
|||
/*
|
|||
* This stuff is basically class callback functions The current classes are |
|||
* SSL_CTX, SSL, SSL_SESSION, and a few more |
|||
*/ |
|||
|
|||
typedef struct crypto_ex_data_func_st { |
|||
long argl; /* Arbitary long */ |
|||
void *argp; /* Arbitary void * */ |
|||
CRYPTO_EX_new *new_func; |
|||
CRYPTO_EX_free *free_func; |
|||
CRYPTO_EX_dup *dup_func; |
|||
} CRYPTO_EX_DATA_FUNCS; |
|||
|
|||
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS) |
|||
|
|||
/*
|
|||
* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA |
|||
* entry. |
|||
*/ |
|||
|
|||
# define CRYPTO_EX_INDEX_BIO 0 |
|||
# define CRYPTO_EX_INDEX_SSL 1 |
|||
# define CRYPTO_EX_INDEX_SSL_CTX 2 |
|||
# define CRYPTO_EX_INDEX_SSL_SESSION 3 |
|||
# define CRYPTO_EX_INDEX_X509_STORE 4 |
|||
# define CRYPTO_EX_INDEX_X509_STORE_CTX 5 |
|||
# define CRYPTO_EX_INDEX_RSA 6 |
|||
# define CRYPTO_EX_INDEX_DSA 7 |
|||
# define CRYPTO_EX_INDEX_DH 8 |
|||
# define CRYPTO_EX_INDEX_ENGINE 9 |
|||
# define CRYPTO_EX_INDEX_X509 10 |
|||
# define CRYPTO_EX_INDEX_UI 11 |
|||
# define CRYPTO_EX_INDEX_ECDSA 12 |
|||
# define CRYPTO_EX_INDEX_ECDH 13 |
|||
# define CRYPTO_EX_INDEX_COMP 14 |
|||
# define CRYPTO_EX_INDEX_STORE 15 |
|||
|
|||
/*
|
|||
* Dynamically assigned indexes start from this value (don't use directly, |
|||
* use via CRYPTO_ex_data_new_class). |
|||
*/ |
|||
# define CRYPTO_EX_INDEX_USER 100 |
|||
|
|||
/*
|
|||
* This is the default callbacks, but we can have others as well: this is |
|||
* needed in Win32 where the application malloc and the library malloc may |
|||
* not be the same. |
|||
*/ |
|||
# define CRYPTO_malloc_init() CRYPTO_set_mem_functions(\ |
|||
malloc, realloc, free) |
|||
|
|||
# if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD |
|||
# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */ |
|||
# define CRYPTO_MDEBUG |
|||
# endif |
|||
# endif |
|||
|
|||
/*
|
|||
* Set standard debugging functions (not done by default unless CRYPTO_MDEBUG |
|||
* is defined) |
|||
*/ |
|||
# define CRYPTO_malloc_debug_init() do {\ |
|||
CRYPTO_set_mem_debug_functions(\ |
|||
CRYPTO_dbg_malloc,\ |
|||
CRYPTO_dbg_realloc,\ |
|||
CRYPTO_dbg_free,\ |
|||
CRYPTO_dbg_set_options,\ |
|||
CRYPTO_dbg_get_options);\ |
|||
} while(0) |
|||
|
|||
int CRYPTO_mem_ctrl(int mode); |
|||
int CRYPTO_is_mem_check_on(void); |
|||
|
|||
/* for applications */ |
|||
# define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON) |
|||
# define MemCheck_stop() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF) |
|||
|
|||
/* for library-internal use */ |
|||
# define MemCheck_on() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE) |
|||
# define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE) |
|||
# define is_MemCheck_on() CRYPTO_is_mem_check_on() |
|||
|
|||
# define OPENSSL_malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__) |
|||
# define OPENSSL_strdup(str) CRYPTO_strdup((str),__FILE__,__LINE__) |
|||
# define OPENSSL_realloc(addr,num) \ |
|||
CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__) |
|||
# define OPENSSL_realloc_clean(addr,old_num,num) \ |
|||
CRYPTO_realloc_clean(addr,old_num,num,__FILE__,__LINE__) |
|||
# define OPENSSL_remalloc(addr,num) \ |
|||
CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__) |
|||
# define OPENSSL_freeFunc CRYPTO_free |
|||
# define OPENSSL_free(addr) CRYPTO_free(addr) |
|||
|
|||
# define OPENSSL_malloc_locked(num) \ |
|||
CRYPTO_malloc_locked((int)num,__FILE__,__LINE__) |
|||
# define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr) |
|||
|
|||
const char *SSLeay_version(int type); |
|||
unsigned long SSLeay(void); |
|||
|
|||
int OPENSSL_issetugid(void); |
|||
|
|||
/* An opaque type representing an implementation of "ex_data" support */ |
|||
typedef struct st_CRYPTO_EX_DATA_IMPL CRYPTO_EX_DATA_IMPL; |
|||
/* Return an opaque pointer to the current "ex_data" implementation */ |
|||
const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void); |
|||
/* Sets the "ex_data" implementation to be used (if it's not too late) */ |
|||
int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i); |
|||
/* Get a new "ex_data" class, and return the corresponding "class_index" */ |
|||
int CRYPTO_ex_data_new_class(void); |
|||
/* Within a given class, get/register a new index */ |
|||
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); |
|||
/*
|
|||
* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a |
|||
* given class (invokes whatever per-class callbacks are applicable) |
|||
*/ |
|||
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); |
|||
/*
|
|||
* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular |
|||
* index (relative to the class type involved) |
|||
*/ |
|||
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); |
|||
/*
|
|||
* This function cleans up all "ex_data" state. It mustn't be called under |
|||
* potential race-conditions. |
|||
*/ |
|||
void CRYPTO_cleanup_all_ex_data(void); |
|||
|
|||
int CRYPTO_get_new_lockid(char *name); |
|||
|
|||
int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */ |
|||
void CRYPTO_lock(int mode, int type, const char *file, int line); |
|||
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); |
|||
|
|||
/* Don't use this structure directly. */ |
|||
typedef struct crypto_threadid_st { |
|||
void *ptr; |
|||
unsigned long val; |
|||
} CRYPTO_THREADID; |
|||
/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ |
|||
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 *); |
|||
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); |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
void CRYPTO_set_id_callback(unsigned long (*func) (void)); |
|||
unsigned long (*CRYPTO_get_id_callback(void)) (void); |
|||
unsigned long CRYPTO_thread_id(void); |
|||
# endif |
|||
|
|||
const char *CRYPTO_get_lock_name(int type); |
|||
int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file, |
|||
int line); |
|||
|
|||
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); |
|||
|
|||
/*
|
|||
* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions -- call |
|||
* the latter last if you need different functions |
|||
*/ |
|||
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); |
|||
|
|||
# define CRYPTO_push_info(info) \ |
|||
CRYPTO_push_info_(info, __FILE__, __LINE__); |
|||
int CRYPTO_push_info_(const char *info, const char *file, int line); |
|||
int CRYPTO_pop_info(void); |
|||
int CRYPTO_remove_all_info(void); |
|||
|
|||
/*
|
|||
* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro; |
|||
* used as default in CRYPTO_MDEBUG compilations): |
|||
*/ |
|||
/*-
|
|||
* The last argument has the following significance: |
|||
* |
|||
* 0: called before the actual memory allocation has taken place |
|||
* 1: called after the actual memory allocation has taken place |
|||
*/ |
|||
void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line, |
|||
int before_p); |
|||
void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num, const char *file, |
|||
int line, int before_p); |
|||
void CRYPTO_dbg_free(void *addr, int before_p); |
|||
/*-
|
|||
* Tell the debugging code about options. By default, the following values |
|||
* apply: |
|||
* |
|||
* 0: Clear all options. |
|||
* V_CRYPTO_MDEBUG_TIME (1): Set the "Show Time" option. |
|||
* V_CRYPTO_MDEBUG_THREAD (2): Set the "Show Thread Number" option. |
|||
* V_CRYPTO_MDEBUG_ALL (3): 1 + 2 |
|||
*/ |
|||
void CRYPTO_dbg_set_options(long bits); |
|||
long CRYPTO_dbg_get_options(void); |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
void CRYPTO_mem_leaks_fp(FILE *); |
|||
# endif |
|||
void CRYPTO_mem_leaks(struct bio_st *bio); |
|||
/* unsigned long order, char *file, int line, int num_bytes, char *addr */ |
|||
typedef void *CRYPTO_MEM_LEAK_CB (unsigned long, const char *, int, int, |
|||
void *); |
|||
void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb); |
|||
|
|||
/* die if we have to */ |
|||
void OpenSSLDie(const char *file, int line, const char *assertion); |
|||
# define OPENSSL_assert(e) (void)((e) ? 0 : (OpenSSLDie(__FILE__, __LINE__, #e),1)) |
|||
|
|||
unsigned long *OPENSSL_ia32cap_loc(void); |
|||
# define OPENSSL_ia32cap (*(OPENSSL_ia32cap_loc())) |
|||
int OPENSSL_isservice(void); |
|||
|
|||
int FIPS_mode(void); |
|||
int FIPS_mode_set(int r); |
|||
|
|||
void OPENSSL_init(void); |
|||
|
|||
# define fips_md_init(alg) fips_md_init_ctx(alg, alg) |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
# define fips_md_init_ctx(alg, cx) \ |
|||
int alg##_Init(cx##_CTX *c) \ |
|||
{ \ |
|||
if (FIPS_mode()) OpenSSLDie(__FILE__, __LINE__, \ |
|||
"Low level API call to digest " #alg " forbidden in FIPS mode!"); \ |
|||
return private_##alg##_Init(c); \ |
|||
} \ |
|||
int private_##alg##_Init(cx##_CTX *c) |
|||
|
|||
# define fips_cipher_abort(alg) \ |
|||
if (FIPS_mode()) OpenSSLDie(__FILE__, __LINE__, \ |
|||
"Low level API call to cipher " #alg " forbidden in FIPS mode!") |
|||
|
|||
# else |
|||
# define fips_md_init_ctx(alg, cx) \ |
|||
int alg##_Init(cx##_CTX *c) |
|||
# define fips_cipher_abort(alg) while(0) |
|||
# endif |
|||
|
|||
/*
|
|||
* CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. |
|||
* It takes an amount of time dependent on |len|, but independent of the |
|||
* contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements |
|||
* into a defined order as the return value when a != b is undefined, other |
|||
* than to be non-zero. |
|||
*/ |
|||
int CRYPTO_memcmp(const void *a, const void *b, size_t len); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_CRYPTO_strings(void); |
|||
|
|||
/* Error codes for the CRYPTO functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100 |
|||
# define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID 103 |
|||
# define CRYPTO_F_CRYPTO_GET_NEW_LOCKID 101 |
|||
# define CRYPTO_F_CRYPTO_SET_EX_DATA 102 |
|||
# define CRYPTO_F_DEF_ADD_INDEX 104 |
|||
# define CRYPTO_F_DEF_GET_CLASS 105 |
|||
# define CRYPTO_F_FIPS_MODE_SET 109 |
|||
# define CRYPTO_F_INT_DUP_EX_DATA 106 |
|||
# define CRYPTO_F_INT_FREE_EX_DATA 107 |
|||
# define CRYPTO_F_INT_NEW_EX_DATA 108 |
|||
|
|||
/* Reason codes. */ |
|||
# define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101 |
|||
# define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK 100 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,257 +0,0 @@ |
|||
/* crypto/des/des.h */ |
|||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_NEW_DES_H |
|||
# define HEADER_NEW_DES_H |
|||
|
|||
# include <openssl/e_os2.h> /* OPENSSL_EXTERN, OPENSSL_NO_DES, DES_LONG |
|||
* (via openssl/opensslconf.h */ |
|||
|
|||
# ifdef OPENSSL_NO_DES |
|||
# error DES is disabled. |
|||
# endif |
|||
|
|||
# ifdef OPENSSL_BUILD_SHLIBCRYPTO |
|||
# undef OPENSSL_EXTERN |
|||
# define OPENSSL_EXTERN OPENSSL_EXPORT |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef unsigned char DES_cblock[8]; |
|||
typedef /* const */ unsigned char const_DES_cblock[8]; |
|||
/*
|
|||
* With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and |
|||
* const_DES_cblock * are incompatible pointer types. |
|||
*/ |
|||
|
|||
typedef struct DES_ks { |
|||
union { |
|||
DES_cblock cblock; |
|||
/*
|
|||
* make sure things are correct size on machines with 8 byte longs |
|||
*/ |
|||
DES_LONG deslong[2]; |
|||
} ks[16]; |
|||
} DES_key_schedule; |
|||
|
|||
# ifndef OPENSSL_DISABLE_OLD_DES_SUPPORT |
|||
# ifndef OPENSSL_ENABLE_OLD_DES_SUPPORT |
|||
# define OPENSSL_ENABLE_OLD_DES_SUPPORT |
|||
# endif |
|||
# endif |
|||
|
|||
# ifdef OPENSSL_ENABLE_OLD_DES_SUPPORT |
|||
# include <openssl/des_old.h> |
|||
# endif |
|||
|
|||
# define DES_KEY_SZ (sizeof(DES_cblock)) |
|||
# define DES_SCHEDULE_SZ (sizeof(DES_key_schedule)) |
|||
|
|||
# define DES_ENCRYPT 1 |
|||
# define DES_DECRYPT 0 |
|||
|
|||
# define DES_CBC_MODE 0 |
|||
# define DES_PCBC_MODE 1 |
|||
|
|||
# define DES_ecb2_encrypt(i,o,k1,k2,e) \ |
|||
DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) |
|||
|
|||
# define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ |
|||
DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) |
|||
|
|||
# define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ |
|||
DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) |
|||
|
|||
# define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ |
|||
DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) |
|||
|
|||
OPENSSL_DECLARE_GLOBAL(int, DES_check_key); /* defaults to false */ |
|||
# define DES_check_key OPENSSL_GLOBAL_REF(DES_check_key) |
|||
OPENSSL_DECLARE_GLOBAL(int, DES_rw_mode); /* defaults to DES_PCBC_MODE */ |
|||
# define DES_rw_mode OPENSSL_GLOBAL_REF(DES_rw_mode) |
|||
|
|||
const char *DES_options(void); |
|||
void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output, |
|||
DES_key_schedule *ks1, DES_key_schedule *ks2, |
|||
DES_key_schedule *ks3, int enc); |
|||
DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output, |
|||
long length, DES_key_schedule *schedule, |
|||
const_DES_cblock *ivec); |
|||
/* DES_cbc_encrypt does not update the IV! Use DES_ncbc_encrypt instead. */ |
|||
void DES_cbc_encrypt(const unsigned char *input, unsigned char *output, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, int enc); |
|||
void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, int enc); |
|||
void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, const_DES_cblock *inw, |
|||
const_DES_cblock *outw, int enc); |
|||
void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, int enc); |
|||
void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output, |
|||
DES_key_schedule *ks, int enc); |
|||
|
|||
/*
|
|||
* This is the DES encryption function that gets called by just about every |
|||
* other DES routine in the library. You should not use this function except |
|||
* to implement 'modes' of DES. I say this because the functions that call |
|||
* this routine do the conversion from 'char *' to long, and this needs to be |
|||
* done to make sure 'non-aligned' memory access do not occur. The |
|||
* characters are loaded 'little endian'. Data is a pointer to 2 unsigned |
|||
* long's and ks is the DES_key_schedule to use. enc, is non zero specifies |
|||
* encryption, zero if decryption. |
|||
*/ |
|||
void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc); |
|||
|
|||
/*
|
|||
* This functions is the same as DES_encrypt1() except that the DES initial |
|||
* permutation (IP) and final permutation (FP) have been left out. As for |
|||
* DES_encrypt1(), you should not use this function. It is used by the |
|||
* routines in the library that implement triple DES. IP() DES_encrypt2() |
|||
* DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1() |
|||
* DES_encrypt1() DES_encrypt1() except faster :-). |
|||
*/ |
|||
void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc); |
|||
|
|||
void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, |
|||
DES_key_schedule *ks2, DES_key_schedule *ks3); |
|||
void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, |
|||
DES_key_schedule *ks2, DES_key_schedule *ks3); |
|||
void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output, |
|||
long length, |
|||
DES_key_schedule *ks1, DES_key_schedule *ks2, |
|||
DES_key_schedule *ks3, DES_cblock *ivec, int enc); |
|||
void DES_ede3_cbcm_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, |
|||
DES_key_schedule *ks1, DES_key_schedule *ks2, |
|||
DES_key_schedule *ks3, |
|||
DES_cblock *ivec1, DES_cblock *ivec2, int enc); |
|||
void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, DES_key_schedule *ks1, |
|||
DES_key_schedule *ks2, DES_key_schedule *ks3, |
|||
DES_cblock *ivec, int *num, int enc); |
|||
void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out, |
|||
int numbits, long length, DES_key_schedule *ks1, |
|||
DES_key_schedule *ks2, DES_key_schedule *ks3, |
|||
DES_cblock *ivec, int enc); |
|||
void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, DES_key_schedule *ks1, |
|||
DES_key_schedule *ks2, DES_key_schedule *ks3, |
|||
DES_cblock *ivec, int *num); |
|||
# if 0 |
|||
void DES_xwhite_in2out(const_DES_cblock *DES_key, const_DES_cblock *in_white, |
|||
DES_cblock *out_white); |
|||
# endif |
|||
|
|||
int DES_enc_read(int fd, void *buf, int len, DES_key_schedule *sched, |
|||
DES_cblock *iv); |
|||
int DES_enc_write(int fd, const void *buf, int len, DES_key_schedule *sched, |
|||
DES_cblock *iv); |
|||
char *DES_fcrypt(const char *buf, const char *salt, char *ret); |
|||
char *DES_crypt(const char *buf, const char *salt); |
|||
void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec); |
|||
void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, int enc); |
|||
DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[], |
|||
long length, int out_count, DES_cblock *seed); |
|||
int DES_random_key(DES_cblock *ret); |
|||
void DES_set_odd_parity(DES_cblock *key); |
|||
int DES_check_key_parity(const_DES_cblock *key); |
|||
int DES_is_weak_key(const_DES_cblock *key); |
|||
/*
|
|||
* DES_set_key (= set_key = DES_key_sched = key_sched) calls |
|||
* DES_set_key_checked if global variable DES_check_key is set, |
|||
* DES_set_key_unchecked otherwise. |
|||
*/ |
|||
int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule); |
|||
int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule); |
|||
int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule); |
|||
void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule); |
|||
# ifdef OPENSSL_FIPS |
|||
void private_DES_set_key_unchecked(const_DES_cblock *key, |
|||
DES_key_schedule *schedule); |
|||
# endif |
|||
void DES_string_to_key(const char *str, DES_cblock *key); |
|||
void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2); |
|||
void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, int *num, int enc); |
|||
void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, DES_key_schedule *schedule, |
|||
DES_cblock *ivec, int *num); |
|||
|
|||
int DES_read_password(DES_cblock *key, const char *prompt, int verify); |
|||
int DES_read_2passwords(DES_cblock *key1, DES_cblock *key2, |
|||
const char *prompt, int verify); |
|||
|
|||
# define DES_fixup_key_parity DES_set_odd_parity |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,497 +0,0 @@ |
|||
/* crypto/des/des_old.h */ |
|||
|
|||
/*-
|
|||
* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING |
|||
* |
|||
* The function names in here are deprecated and are only present to |
|||
* provide an interface compatible with openssl 0.9.6 and older as |
|||
* well as libdes. OpenSSL now provides functions where "des_" has |
|||
* been replaced with "DES_" in the names, to make it possible to |
|||
* make incompatible changes that are needed for C type security and |
|||
* other stuff. |
|||
* |
|||
* This include files has two compatibility modes: |
|||
* |
|||
* - If OPENSSL_DES_LIBDES_COMPATIBILITY is defined, you get an API |
|||
* that is compatible with libdes and SSLeay. |
|||
* - If OPENSSL_DES_LIBDES_COMPATIBILITY isn't defined, you get an |
|||
* API that is compatible with OpenSSL 0.9.5x to 0.9.6x. |
|||
* |
|||
* Note that these modes break earlier snapshots of OpenSSL, where |
|||
* libdes compatibility was the only available mode or (later on) the |
|||
* prefered compatibility mode. However, after much consideration |
|||
* (and more or less violent discussions with external parties), it |
|||
* was concluded that OpenSSL should be compatible with earlier versions |
|||
* of itself before anything else. Also, in all honesty, libdes is |
|||
* an old beast that shouldn't really be used any more. |
|||
* |
|||
* Please consider starting to use the DES_ functions rather than the |
|||
* des_ ones. The des_ functions will disappear completely before |
|||
* OpenSSL 1.0! |
|||
* |
|||
* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING |
|||
*/ |
|||
|
|||
/*
|
|||
* Written by Richard Levitte (richard@levitte.org) for the OpenSSL project |
|||
* 2001. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_DES_H |
|||
# define HEADER_DES_H |
|||
|
|||
# include <openssl/e_os2.h> /* OPENSSL_EXTERN, OPENSSL_NO_DES, DES_LONG */ |
|||
|
|||
# ifdef OPENSSL_NO_DES |
|||
# error DES is disabled. |
|||
# endif |
|||
|
|||
# ifndef HEADER_NEW_DES_H |
|||
# error You must include des.h, not des_old.h directly. |
|||
# endif |
|||
|
|||
# ifdef _KERBEROS_DES_H |
|||
# error <openssl/des_old.h> replaces <kerberos/des.h>. |
|||
# endif |
|||
|
|||
# include <openssl/symhacks.h> |
|||
|
|||
# ifdef OPENSSL_BUILD_SHLIBCRYPTO |
|||
# undef OPENSSL_EXTERN |
|||
# define OPENSSL_EXTERN OPENSSL_EXPORT |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef _ |
|||
# undef _ |
|||
# endif |
|||
|
|||
typedef unsigned char _ossl_old_des_cblock[8]; |
|||
typedef struct _ossl_old_des_ks_struct { |
|||
union { |
|||
_ossl_old_des_cblock _; |
|||
/*
|
|||
* make sure things are correct size on machines with 8 byte longs |
|||
*/ |
|||
DES_LONG pad[2]; |
|||
} ks; |
|||
} _ossl_old_des_key_schedule[16]; |
|||
|
|||
# ifndef OPENSSL_DES_LIBDES_COMPATIBILITY |
|||
# define des_cblock DES_cblock |
|||
# define const_des_cblock const_DES_cblock |
|||
# define des_key_schedule DES_key_schedule |
|||
# define des_ecb3_encrypt(i,o,k1,k2,k3,e)\ |
|||
DES_ecb3_encrypt((i),(o),&(k1),&(k2),&(k3),(e)) |
|||
# define des_ede3_cbc_encrypt(i,o,l,k1,k2,k3,iv,e)\ |
|||
DES_ede3_cbc_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv),(e)) |
|||
# define des_ede3_cbcm_encrypt(i,o,l,k1,k2,k3,iv1,iv2,e)\ |
|||
DES_ede3_cbcm_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv1),(iv2),(e)) |
|||
# define des_ede3_cfb64_encrypt(i,o,l,k1,k2,k3,iv,n,e)\ |
|||
DES_ede3_cfb64_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv),(n),(e)) |
|||
# define des_ede3_ofb64_encrypt(i,o,l,k1,k2,k3,iv,n)\ |
|||
DES_ede3_ofb64_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv),(n)) |
|||
# define des_options()\ |
|||
DES_options() |
|||
# define des_cbc_cksum(i,o,l,k,iv)\ |
|||
DES_cbc_cksum((i),(o),(l),&(k),(iv)) |
|||
# define des_cbc_encrypt(i,o,l,k,iv,e)\ |
|||
DES_cbc_encrypt((i),(o),(l),&(k),(iv),(e)) |
|||
# define des_ncbc_encrypt(i,o,l,k,iv,e)\ |
|||
DES_ncbc_encrypt((i),(o),(l),&(k),(iv),(e)) |
|||
# define des_xcbc_encrypt(i,o,l,k,iv,inw,outw,e)\ |
|||
DES_xcbc_encrypt((i),(o),(l),&(k),(iv),(inw),(outw),(e)) |
|||
# define des_cfb_encrypt(i,o,n,l,k,iv,e)\ |
|||
DES_cfb_encrypt((i),(o),(n),(l),&(k),(iv),(e)) |
|||
# define des_ecb_encrypt(i,o,k,e)\ |
|||
DES_ecb_encrypt((i),(o),&(k),(e)) |
|||
# define des_encrypt1(d,k,e)\ |
|||
DES_encrypt1((d),&(k),(e)) |
|||
# define des_encrypt2(d,k,e)\ |
|||
DES_encrypt2((d),&(k),(e)) |
|||
# define des_encrypt3(d,k1,k2,k3)\ |
|||
DES_encrypt3((d),&(k1),&(k2),&(k3)) |
|||
# define des_decrypt3(d,k1,k2,k3)\ |
|||
DES_decrypt3((d),&(k1),&(k2),&(k3)) |
|||
# define des_xwhite_in2out(k,i,o)\ |
|||
DES_xwhite_in2out((k),(i),(o)) |
|||
# define des_enc_read(f,b,l,k,iv)\ |
|||
DES_enc_read((f),(b),(l),&(k),(iv)) |
|||
# define des_enc_write(f,b,l,k,iv)\ |
|||
DES_enc_write((f),(b),(l),&(k),(iv)) |
|||
# define des_fcrypt(b,s,r)\ |
|||
DES_fcrypt((b),(s),(r)) |
|||
# if 0 |
|||
# define des_crypt(b,s)\ |
|||
DES_crypt((b),(s)) |
|||
# if !defined(PERL5) && !defined(__FreeBSD__) && !defined(NeXT) && !defined(__OpenBSD__) |
|||
# define crypt(b,s)\ |
|||
DES_crypt((b),(s)) |
|||
# endif |
|||
# endif |
|||
# define des_ofb_encrypt(i,o,n,l,k,iv)\ |
|||
DES_ofb_encrypt((i),(o),(n),(l),&(k),(iv)) |
|||
# define des_pcbc_encrypt(i,o,l,k,iv,e)\ |
|||
DES_pcbc_encrypt((i),(o),(l),&(k),(iv),(e)) |
|||
# define des_quad_cksum(i,o,l,c,s)\ |
|||
DES_quad_cksum((i),(o),(l),(c),(s)) |
|||
# define des_random_seed(k)\ |
|||
_ossl_096_des_random_seed((k)) |
|||
# define des_random_key(r)\ |
|||
DES_random_key((r)) |
|||
# define des_read_password(k,p,v) \ |
|||
DES_read_password((k),(p),(v)) |
|||
# define des_read_2passwords(k1,k2,p,v) \ |
|||
DES_read_2passwords((k1),(k2),(p),(v)) |
|||
# define des_set_odd_parity(k)\ |
|||
DES_set_odd_parity((k)) |
|||
# define des_check_key_parity(k)\ |
|||
DES_check_key_parity((k)) |
|||
# define des_is_weak_key(k)\ |
|||
DES_is_weak_key((k)) |
|||
# define des_set_key(k,ks)\ |
|||
DES_set_key((k),&(ks)) |
|||
# define des_key_sched(k,ks)\ |
|||
DES_key_sched((k),&(ks)) |
|||
# define des_set_key_checked(k,ks)\ |
|||
DES_set_key_checked((k),&(ks)) |
|||
# define des_set_key_unchecked(k,ks)\ |
|||
DES_set_key_unchecked((k),&(ks)) |
|||
# define des_string_to_key(s,k)\ |
|||
DES_string_to_key((s),(k)) |
|||
# define des_string_to_2keys(s,k1,k2)\ |
|||
DES_string_to_2keys((s),(k1),(k2)) |
|||
# define des_cfb64_encrypt(i,o,l,ks,iv,n,e)\ |
|||
DES_cfb64_encrypt((i),(o),(l),&(ks),(iv),(n),(e)) |
|||
# define des_ofb64_encrypt(i,o,l,ks,iv,n)\ |
|||
DES_ofb64_encrypt((i),(o),(l),&(ks),(iv),(n)) |
|||
|
|||
# define des_ecb2_encrypt(i,o,k1,k2,e) \ |
|||
des_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) |
|||
|
|||
# define des_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ |
|||
des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) |
|||
|
|||
# define des_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ |
|||
des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) |
|||
|
|||
# define des_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ |
|||
des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) |
|||
|
|||
# define des_check_key DES_check_key |
|||
# define des_rw_mode DES_rw_mode |
|||
# else /* libdes compatibility */ |
|||
/*
|
|||
* Map all symbol names to _ossl_old_des_* form, so we avoid all clashes with |
|||
* libdes |
|||
*/ |
|||
# define des_cblock _ossl_old_des_cblock |
|||
# define des_key_schedule _ossl_old_des_key_schedule |
|||
# define des_ecb3_encrypt(i,o,k1,k2,k3,e)\ |
|||
_ossl_old_des_ecb3_encrypt((i),(o),(k1),(k2),(k3),(e)) |
|||
# define des_ede3_cbc_encrypt(i,o,l,k1,k2,k3,iv,e)\ |
|||
_ossl_old_des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k3),(iv),(e)) |
|||
# define des_ede3_cfb64_encrypt(i,o,l,k1,k2,k3,iv,n,e)\ |
|||
_ossl_old_des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k3),(iv),(n),(e)) |
|||
# define des_ede3_ofb64_encrypt(i,o,l,k1,k2,k3,iv,n)\ |
|||
_ossl_old_des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k3),(iv),(n)) |
|||
# define des_options()\ |
|||
_ossl_old_des_options() |
|||
# define des_cbc_cksum(i,o,l,k,iv)\ |
|||
_ossl_old_des_cbc_cksum((i),(o),(l),(k),(iv)) |
|||
# define des_cbc_encrypt(i,o,l,k,iv,e)\ |
|||
_ossl_old_des_cbc_encrypt((i),(o),(l),(k),(iv),(e)) |
|||
# define des_ncbc_encrypt(i,o,l,k,iv,e)\ |
|||
_ossl_old_des_ncbc_encrypt((i),(o),(l),(k),(iv),(e)) |
|||
# define des_xcbc_encrypt(i,o,l,k,iv,inw,outw,e)\ |
|||
_ossl_old_des_xcbc_encrypt((i),(o),(l),(k),(iv),(inw),(outw),(e)) |
|||
# define des_cfb_encrypt(i,o,n,l,k,iv,e)\ |
|||
_ossl_old_des_cfb_encrypt((i),(o),(n),(l),(k),(iv),(e)) |
|||
# define des_ecb_encrypt(i,o,k,e)\ |
|||
_ossl_old_des_ecb_encrypt((i),(o),(k),(e)) |
|||
# define des_encrypt(d,k,e)\ |
|||
_ossl_old_des_encrypt((d),(k),(e)) |
|||
# define des_encrypt2(d,k,e)\ |
|||
_ossl_old_des_encrypt2((d),(k),(e)) |
|||
# define des_encrypt3(d,k1,k2,k3)\ |
|||
_ossl_old_des_encrypt3((d),(k1),(k2),(k3)) |
|||
# define des_decrypt3(d,k1,k2,k3)\ |
|||
_ossl_old_des_decrypt3((d),(k1),(k2),(k3)) |
|||
# define des_xwhite_in2out(k,i,o)\ |
|||
_ossl_old_des_xwhite_in2out((k),(i),(o)) |
|||
# define des_enc_read(f,b,l,k,iv)\ |
|||
_ossl_old_des_enc_read((f),(b),(l),(k),(iv)) |
|||
# define des_enc_write(f,b,l,k,iv)\ |
|||
_ossl_old_des_enc_write((f),(b),(l),(k),(iv)) |
|||
# define des_fcrypt(b,s,r)\ |
|||
_ossl_old_des_fcrypt((b),(s),(r)) |
|||
# define des_crypt(b,s)\ |
|||
_ossl_old_des_crypt((b),(s)) |
|||
# if 0 |
|||
# define crypt(b,s)\ |
|||
_ossl_old_crypt((b),(s)) |
|||
# endif |
|||
# define des_ofb_encrypt(i,o,n,l,k,iv)\ |
|||
_ossl_old_des_ofb_encrypt((i),(o),(n),(l),(k),(iv)) |
|||
# define des_pcbc_encrypt(i,o,l,k,iv,e)\ |
|||
_ossl_old_des_pcbc_encrypt((i),(o),(l),(k),(iv),(e)) |
|||
# define des_quad_cksum(i,o,l,c,s)\ |
|||
_ossl_old_des_quad_cksum((i),(o),(l),(c),(s)) |
|||
# define des_random_seed(k)\ |
|||
_ossl_old_des_random_seed((k)) |
|||
# define des_random_key(r)\ |
|||
_ossl_old_des_random_key((r)) |
|||
# define des_read_password(k,p,v) \ |
|||
_ossl_old_des_read_password((k),(p),(v)) |
|||
# define des_read_2passwords(k1,k2,p,v) \ |
|||
_ossl_old_des_read_2passwords((k1),(k2),(p),(v)) |
|||
# define des_set_odd_parity(k)\ |
|||
_ossl_old_des_set_odd_parity((k)) |
|||
# define des_is_weak_key(k)\ |
|||
_ossl_old_des_is_weak_key((k)) |
|||
# define des_set_key(k,ks)\ |
|||
_ossl_old_des_set_key((k),(ks)) |
|||
# define des_key_sched(k,ks)\ |
|||
_ossl_old_des_key_sched((k),(ks)) |
|||
# define des_string_to_key(s,k)\ |
|||
_ossl_old_des_string_to_key((s),(k)) |
|||
# define des_string_to_2keys(s,k1,k2)\ |
|||
_ossl_old_des_string_to_2keys((s),(k1),(k2)) |
|||
# define des_cfb64_encrypt(i,o,l,ks,iv,n,e)\ |
|||
_ossl_old_des_cfb64_encrypt((i),(o),(l),(ks),(iv),(n),(e)) |
|||
# define des_ofb64_encrypt(i,o,l,ks,iv,n)\ |
|||
_ossl_old_des_ofb64_encrypt((i),(o),(l),(ks),(iv),(n)) |
|||
|
|||
# define des_ecb2_encrypt(i,o,k1,k2,e) \ |
|||
des_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) |
|||
|
|||
# define des_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ |
|||
des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) |
|||
|
|||
# define des_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ |
|||
des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) |
|||
|
|||
# define des_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ |
|||
des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) |
|||
|
|||
# define des_check_key DES_check_key |
|||
# define des_rw_mode DES_rw_mode |
|||
# endif |
|||
|
|||
const char *_ossl_old_des_options(void); |
|||
void _ossl_old_des_ecb3_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, |
|||
_ossl_old_des_key_schedule ks1, |
|||
_ossl_old_des_key_schedule ks2, |
|||
_ossl_old_des_key_schedule ks3, int enc); |
|||
DES_LONG _ossl_old_des_cbc_cksum(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec); |
|||
void _ossl_old_des_cbc_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, int enc); |
|||
void _ossl_old_des_ncbc_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, int enc); |
|||
void _ossl_old_des_xcbc_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, |
|||
_ossl_old_des_cblock *inw, |
|||
_ossl_old_des_cblock *outw, int enc); |
|||
void _ossl_old_des_cfb_encrypt(unsigned char *in, unsigned char *out, |
|||
int numbits, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, int enc); |
|||
void _ossl_old_des_ecb_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, |
|||
_ossl_old_des_key_schedule ks, int enc); |
|||
void _ossl_old_des_encrypt(DES_LONG *data, _ossl_old_des_key_schedule ks, |
|||
int enc); |
|||
void _ossl_old_des_encrypt2(DES_LONG *data, _ossl_old_des_key_schedule ks, |
|||
int enc); |
|||
void _ossl_old_des_encrypt3(DES_LONG *data, _ossl_old_des_key_schedule ks1, |
|||
_ossl_old_des_key_schedule ks2, |
|||
_ossl_old_des_key_schedule ks3); |
|||
void _ossl_old_des_decrypt3(DES_LONG *data, _ossl_old_des_key_schedule ks1, |
|||
_ossl_old_des_key_schedule ks2, |
|||
_ossl_old_des_key_schedule ks3); |
|||
void _ossl_old_des_ede3_cbc_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
_ossl_old_des_key_schedule ks1, |
|||
_ossl_old_des_key_schedule ks2, |
|||
_ossl_old_des_key_schedule ks3, |
|||
_ossl_old_des_cblock *ivec, int enc); |
|||
void _ossl_old_des_ede3_cfb64_encrypt(unsigned char *in, unsigned char *out, |
|||
long length, |
|||
_ossl_old_des_key_schedule ks1, |
|||
_ossl_old_des_key_schedule ks2, |
|||
_ossl_old_des_key_schedule ks3, |
|||
_ossl_old_des_cblock *ivec, int *num, |
|||
int enc); |
|||
void _ossl_old_des_ede3_ofb64_encrypt(unsigned char *in, unsigned char *out, |
|||
long length, |
|||
_ossl_old_des_key_schedule ks1, |
|||
_ossl_old_des_key_schedule ks2, |
|||
_ossl_old_des_key_schedule ks3, |
|||
_ossl_old_des_cblock *ivec, int *num); |
|||
# if 0 |
|||
void _ossl_old_des_xwhite_in2out(_ossl_old_des_cblock (*des_key), |
|||
_ossl_old_des_cblock (*in_white), |
|||
_ossl_old_des_cblock (*out_white)); |
|||
# endif |
|||
|
|||
int _ossl_old_des_enc_read(int fd, char *buf, int len, |
|||
_ossl_old_des_key_schedule sched, |
|||
_ossl_old_des_cblock *iv); |
|||
int _ossl_old_des_enc_write(int fd, char *buf, int len, |
|||
_ossl_old_des_key_schedule sched, |
|||
_ossl_old_des_cblock *iv); |
|||
char *_ossl_old_des_fcrypt(const char *buf, const char *salt, char *ret); |
|||
char *_ossl_old_des_crypt(const char *buf, const char *salt); |
|||
# if !defined(PERL5) && !defined(NeXT) |
|||
char *_ossl_old_crypt(const char *buf, const char *salt); |
|||
# endif |
|||
void _ossl_old_des_ofb_encrypt(unsigned char *in, unsigned char *out, |
|||
int numbits, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec); |
|||
void _ossl_old_des_pcbc_encrypt(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, int enc); |
|||
DES_LONG _ossl_old_des_quad_cksum(_ossl_old_des_cblock *input, |
|||
_ossl_old_des_cblock *output, long length, |
|||
int out_count, _ossl_old_des_cblock *seed); |
|||
void _ossl_old_des_random_seed(_ossl_old_des_cblock key); |
|||
void _ossl_old_des_random_key(_ossl_old_des_cblock ret); |
|||
int _ossl_old_des_read_password(_ossl_old_des_cblock *key, const char *prompt, |
|||
int verify); |
|||
int _ossl_old_des_read_2passwords(_ossl_old_des_cblock *key1, |
|||
_ossl_old_des_cblock *key2, |
|||
const char *prompt, int verify); |
|||
void _ossl_old_des_set_odd_parity(_ossl_old_des_cblock *key); |
|||
int _ossl_old_des_is_weak_key(_ossl_old_des_cblock *key); |
|||
int _ossl_old_des_set_key(_ossl_old_des_cblock *key, |
|||
_ossl_old_des_key_schedule schedule); |
|||
int _ossl_old_des_key_sched(_ossl_old_des_cblock *key, |
|||
_ossl_old_des_key_schedule schedule); |
|||
void _ossl_old_des_string_to_key(char *str, _ossl_old_des_cblock *key); |
|||
void _ossl_old_des_string_to_2keys(char *str, _ossl_old_des_cblock *key1, |
|||
_ossl_old_des_cblock *key2); |
|||
void _ossl_old_des_cfb64_encrypt(unsigned char *in, unsigned char *out, |
|||
long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, int *num, |
|||
int enc); |
|||
void _ossl_old_des_ofb64_encrypt(unsigned char *in, unsigned char *out, |
|||
long length, |
|||
_ossl_old_des_key_schedule schedule, |
|||
_ossl_old_des_cblock *ivec, int *num); |
|||
|
|||
void _ossl_096_des_random_seed(des_cblock *key); |
|||
|
|||
/*
|
|||
* The following definitions provide compatibility with the MIT Kerberos |
|||
* library. The _ossl_old_des_key_schedule structure is not binary |
|||
* compatible. |
|||
*/ |
|||
|
|||
# define _KERBEROS_DES_H |
|||
|
|||
# define KRBDES_ENCRYPT DES_ENCRYPT |
|||
# define KRBDES_DECRYPT DES_DECRYPT |
|||
|
|||
# ifdef KERBEROS |
|||
# define ENCRYPT DES_ENCRYPT |
|||
# define DECRYPT DES_DECRYPT |
|||
# endif |
|||
|
|||
# ifndef NCOMPAT |
|||
# define C_Block des_cblock |
|||
# define Key_schedule des_key_schedule |
|||
# define KEY_SZ DES_KEY_SZ |
|||
# define string_to_key des_string_to_key |
|||
# define read_pw_string des_read_pw_string |
|||
# define random_key des_random_key |
|||
# define pcbc_encrypt des_pcbc_encrypt |
|||
# define set_key des_set_key |
|||
# define key_sched des_key_sched |
|||
# define ecb_encrypt des_ecb_encrypt |
|||
# define cbc_encrypt des_cbc_encrypt |
|||
# define ncbc_encrypt des_ncbc_encrypt |
|||
# define xcbc_encrypt des_xcbc_encrypt |
|||
# define cbc_cksum des_cbc_cksum |
|||
# define quad_cksum des_quad_cksum |
|||
# define check_parity des_check_key_parity |
|||
# endif |
|||
|
|||
# define des_fixup_key_parity DES_fixup_key_parity |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
/* for DES_read_pw_string et al */ |
|||
# include <openssl/ui_compat.h> |
|||
|
|||
#endif |
|||
@ -1,287 +0,0 @@ |
|||
/* crypto/dh/dh.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_DH_H |
|||
# define HEADER_DH_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
# ifdef OPENSSL_NO_DH |
|||
# error DH is disabled. |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
# include <openssl/bio.h> |
|||
# endif |
|||
# include <openssl/ossl_typ.h> |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# include <openssl/bn.h> |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_DH_MAX_MODULUS_BITS |
|||
# define OPENSSL_DH_MAX_MODULUS_BITS 10000 |
|||
# endif |
|||
|
|||
# define DH_FLAG_CACHE_MONT_P 0x01 |
|||
|
|||
/*
|
|||
* new with 0.9.7h; the built-in DH |
|||
* implementation now uses constant time |
|||
* modular exponentiation for secret exponents |
|||
* by default. This flag causes the |
|||
* faster variable sliding window method to |
|||
* be used for all exponents. |
|||
*/ |
|||
# define DH_FLAG_NO_EXP_CONSTTIME 0x02 |
|||
|
|||
/*
|
|||
* If this flag is set the DH method is FIPS compliant and can be used in |
|||
* FIPS mode. This is set in the validated module method. If an application |
|||
* sets this flag in its own methods it is its reposibility to ensure the |
|||
* result is compliant. |
|||
*/ |
|||
|
|||
# define DH_FLAG_FIPS_METHOD 0x0400 |
|||
|
|||
/*
|
|||
* If this flag is set the operations normally disabled in FIPS mode are |
|||
* permitted it is then the applications responsibility to ensure that the |
|||
* usage is compliant. |
|||
*/ |
|||
|
|||
# define DH_FLAG_NON_FIPS_ALLOW 0x0400 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Already defined in ossl_typ.h */ |
|||
/* typedef struct dh_st DH; */ |
|||
/* typedef struct dh_method DH_METHOD; */ |
|||
|
|||
struct dh_method { |
|||
const char *name; |
|||
/* Methods here */ |
|||
int (*generate_key) (DH *dh); |
|||
int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh); |
|||
/* Can be null */ |
|||
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; |
|||
/* If this is non-NULL, it will be used to generate parameters */ |
|||
int (*generate_params) (DH *dh, int prime_len, int generator, |
|||
BN_GENCB *cb); |
|||
}; |
|||
|
|||
struct dh_st { |
|||
/*
|
|||
* This first argument is used to pick up errors when a DH is passed |
|||
* instead of a EVP_PKEY |
|||
*/ |
|||
int pad; |
|||
int version; |
|||
BIGNUM *p; |
|||
BIGNUM *g; |
|||
long length; /* optional */ |
|||
BIGNUM *pub_key; /* g^x */ |
|||
BIGNUM *priv_key; /* x */ |
|||
int flags; |
|||
BN_MONT_CTX *method_mont_p; |
|||
/* Place holders if we want to do X9.42 DH */ |
|||
BIGNUM *q; |
|||
BIGNUM *j; |
|||
unsigned char *seed; |
|||
int seedlen; |
|||
BIGNUM *counter; |
|||
int references; |
|||
CRYPTO_EX_DATA ex_data; |
|||
const DH_METHOD *meth; |
|||
ENGINE *engine; |
|||
}; |
|||
|
|||
# define DH_GENERATOR_2 2 |
|||
/* #define DH_GENERATOR_3 3 */ |
|||
# define DH_GENERATOR_5 5 |
|||
|
|||
/* DH_check error codes */ |
|||
# define DH_CHECK_P_NOT_PRIME 0x01 |
|||
# define DH_CHECK_P_NOT_SAFE_PRIME 0x02 |
|||
# define DH_UNABLE_TO_CHECK_GENERATOR 0x04 |
|||
# define DH_NOT_SUITABLE_GENERATOR 0x08 |
|||
|
|||
/* DH_check_pub_key error codes */ |
|||
# define DH_CHECK_PUBKEY_TOO_SMALL 0x01 |
|||
# define DH_CHECK_PUBKEY_TOO_LARGE 0x02 |
|||
|
|||
/*
|
|||
* primes p where (p-1)/2 is prime too are called "safe"; we define this for |
|||
* backward compatibility: |
|||
*/ |
|||
# define DH_CHECK_P_NOT_STRONG_PRIME DH_CHECK_P_NOT_SAFE_PRIME |
|||
|
|||
# define d2i_DHparams_fp(fp,x) (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ |
|||
(char *(*)())d2i_DHparams,(fp),(unsigned char **)(x)) |
|||
# define i2d_DHparams_fp(fp,x) ASN1_i2d_fp(i2d_DHparams,(fp), \ |
|||
(unsigned char *)(x)) |
|||
# define d2i_DHparams_bio(bp,x) ASN1_d2i_bio_of(DH,DH_new,d2i_DHparams,bp,x) |
|||
# define i2d_DHparams_bio(bp,x) ASN1_i2d_bio_of_const(DH,i2d_DHparams,bp,x) |
|||
|
|||
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_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); |
|||
|
|||
/* Deprecated version */ |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
DH *DH_generate_parameters(int prime_len, int generator, |
|||
void (*callback) (int, int, void *), void *cb_arg); |
|||
# endif /* !defined(OPENSSL_NO_DEPRECATED) */ |
|||
|
|||
/* New version */ |
|||
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); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
int DHparams_print_fp(FILE *fp, const DH *x); |
|||
# endif |
|||
# ifndef OPENSSL_NO_BIO |
|||
int DHparams_print(BIO *bp, const DH *x); |
|||
# else |
|||
int DHparams_print(char *bp, const DH *x); |
|||
# endif |
|||
|
|||
# define EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ |
|||
EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, len, NULL) |
|||
|
|||
# define EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, gen) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ |
|||
EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL) |
|||
|
|||
# define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN (EVP_PKEY_ALG_CTRL + 1) |
|||
# define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR (EVP_PKEY_ALG_CTRL + 2) |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_DH_strings(void); |
|||
|
|||
/* Error codes for the DH functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define DH_F_COMPUTE_KEY 102 |
|||
# define DH_F_DHPARAMS_PRINT_FP 101 |
|||
# define DH_F_DH_BUILTIN_GENPARAMS 106 |
|||
# define DH_F_DH_COMPUTE_KEY 114 |
|||
# define DH_F_DH_GENERATE_KEY 115 |
|||
# define DH_F_DH_GENERATE_PARAMETERS_EX 116 |
|||
# define DH_F_DH_NEW_METHOD 105 |
|||
# define DH_F_DH_PARAM_DECODE 107 |
|||
# define DH_F_DH_PRIV_DECODE 110 |
|||
# define DH_F_DH_PRIV_ENCODE 111 |
|||
# define DH_F_DH_PUB_DECODE 108 |
|||
# define DH_F_DH_PUB_ENCODE 109 |
|||
# define DH_F_DO_DH_PRINT 100 |
|||
# define DH_F_GENERATE_KEY 103 |
|||
# define DH_F_GENERATE_PARAMETERS 104 |
|||
# define DH_F_PKEY_DH_DERIVE 112 |
|||
# define DH_F_PKEY_DH_KEYGEN 113 |
|||
|
|||
/* Reason codes. */ |
|||
# define DH_R_BAD_GENERATOR 101 |
|||
# define DH_R_BN_DECODE_ERROR 109 |
|||
# define DH_R_BN_ERROR 106 |
|||
# define DH_R_DECODE_ERROR 104 |
|||
# define DH_R_INVALID_PUBKEY 102 |
|||
# define DH_R_KEYS_NOT_SET 108 |
|||
# define DH_R_KEY_SIZE_TOO_SMALL 110 |
|||
# define DH_R_MODULUS_TOO_LARGE 103 |
|||
# define DH_R_NON_FIPS_METHOD 111 |
|||
# define DH_R_NO_PARAMETERS_SET 107 |
|||
# define DH_R_NO_PRIVATE_VALUE 100 |
|||
# define DH_R_PARAMETER_ENCODING_ERROR 105 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,329 +0,0 @@ |
|||
/* crypto/dsa/dsa.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
/*
|
|||
* The DSS routines are based on patches supplied by |
|||
* Steven Schoch <schoch@sheba.arc.nasa.gov>. He basically did the |
|||
* work and I have just tweaked them a little to fit into my |
|||
* stylistic vision for SSLeay :-) */ |
|||
|
|||
#ifndef HEADER_DSA_H |
|||
# define HEADER_DSA_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
# ifdef OPENSSL_NO_DSA |
|||
# error DSA is disabled. |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
# include <openssl/bio.h> |
|||
# endif |
|||
# include <openssl/crypto.h> |
|||
# include <openssl/ossl_typ.h> |
|||
|
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# include <openssl/bn.h> |
|||
# ifndef OPENSSL_NO_DH |
|||
# include <openssl/dh.h> |
|||
# endif |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_DSA_MAX_MODULUS_BITS |
|||
# define OPENSSL_DSA_MAX_MODULUS_BITS 10000 |
|||
# endif |
|||
|
|||
# define DSA_FLAG_CACHE_MONT_P 0x01 |
|||
/*
|
|||
* new with 0.9.7h; the built-in DSA implementation now uses constant time |
|||
* modular exponentiation for secret exponents by default. This flag causes |
|||
* the faster variable sliding window method to be used for all exponents. |
|||
*/ |
|||
# define DSA_FLAG_NO_EXP_CONSTTIME 0x02 |
|||
|
|||
/*
|
|||
* If this flag is set the DSA method is FIPS compliant and can be used in |
|||
* FIPS mode. This is set in the validated module method. If an application |
|||
* sets this flag in its own methods it is its reposibility to ensure the |
|||
* result is compliant. |
|||
*/ |
|||
|
|||
# define DSA_FLAG_FIPS_METHOD 0x0400 |
|||
|
|||
/*
|
|||
* If this flag is set the operations normally disabled in FIPS mode are |
|||
* permitted it is then the applications responsibility to ensure that the |
|||
* usage is compliant. |
|||
*/ |
|||
|
|||
# define DSA_FLAG_NON_FIPS_ALLOW 0x0400 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Already defined in ossl_typ.h */ |
|||
/* typedef struct dsa_st DSA; */ |
|||
/* typedef struct dsa_method DSA_METHOD; */ |
|||
|
|||
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); |
|||
/* Can be null */ |
|||
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; |
|||
/* If this is non-NULL, it is used to generate DSA parameters */ |
|||
int (*dsa_paramgen) (DSA *dsa, int bits, |
|||
const unsigned char *seed, int seed_len, |
|||
int *counter_ret, unsigned long *h_ret, |
|||
BN_GENCB *cb); |
|||
/* If this is non-NULL, it is used to generate DSA keys */ |
|||
int (*dsa_keygen) (DSA *dsa); |
|||
}; |
|||
|
|||
struct dsa_st { |
|||
/*
|
|||
* This first variable is used to pick up errors where a DSA is passed |
|||
* instead of of a EVP_PKEY |
|||
*/ |
|||
int pad; |
|||
long version; |
|||
int write_params; |
|||
BIGNUM *p; |
|||
BIGNUM *q; /* == 20 */ |
|||
BIGNUM *g; |
|||
BIGNUM *pub_key; /* y public key */ |
|||
BIGNUM *priv_key; /* x private key */ |
|||
BIGNUM *kinv; /* Signing pre-calc */ |
|||
BIGNUM *r; /* Signing pre-calc */ |
|||
int flags; |
|||
/* Normally used to cache montgomery values */ |
|||
BN_MONT_CTX *method_mont_p; |
|||
int references; |
|||
CRYPTO_EX_DATA ex_data; |
|||
const DSA_METHOD *meth; |
|||
/* functional reference if 'meth' is ENGINE-provided */ |
|||
ENGINE *engine; |
|||
}; |
|||
|
|||
# define d2i_DSAparams_fp(fp,x) (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \ |
|||
(char *(*)())d2i_DSAparams,(fp),(unsigned char **)(x)) |
|||
# define i2d_DSAparams_fp(fp,x) ASN1_i2d_fp(i2d_DSAparams,(fp), \ |
|||
(unsigned char *)(x)) |
|||
# define d2i_DSAparams_bio(bp,x) ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSAparams,bp,x) |
|||
# define i2d_DSAparams_bio(bp,x) ASN1_i2d_bio_of_const(DSA,i2d_DSAparams,bp,x) |
|||
|
|||
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); |
|||
|
|||
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); |
|||
/* "up" the DSA object's reference count */ |
|||
int DSA_up_ref(DSA *r); |
|||
int DSA_size(const DSA *); |
|||
/* next 4 return -1 on error */ |
|||
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); |
|||
DSA *d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length); |
|||
DSA *d2i_DSAparams(DSA **a, const unsigned char **pp, long length); |
|||
|
|||
/* Deprecated version */ |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
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); |
|||
# endif /* !defined(OPENSSL_NO_DEPRECATED) */ |
|||
|
|||
/* New version */ |
|||
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 i2d_DSAPublicKey(const DSA *a, unsigned char **pp); |
|||
int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp); |
|||
int i2d_DSAparams(const DSA *a, unsigned char **pp); |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
int DSAparams_print(BIO *bp, const DSA *x); |
|||
int DSA_print(BIO *bp, const DSA *x, int off); |
|||
# endif |
|||
# ifndef OPENSSL_NO_FP_API |
|||
int DSAparams_print_fp(FILE *fp, const DSA *x); |
|||
int DSA_print_fp(FILE *bp, const DSA *x, int off); |
|||
# endif |
|||
|
|||
# define DSS_prime_checks 50 |
|||
/*
|
|||
* Primality test according to FIPS PUB 186[-1], Appendix 2.1: 50 rounds of |
|||
* Rabin-Miller |
|||
*/ |
|||
# define DSA_is_prime(n, callback, cb_arg) \ |
|||
BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg) |
|||
|
|||
# ifndef OPENSSL_NO_DH |
|||
/*
|
|||
* Convert DSA structure (key or just parameters) into DH structure (be |
|||
* careful to avoid small subgroup attacks when using this!) |
|||
*/ |
|||
DH *DSA_dup_DH(const DSA *r); |
|||
# endif |
|||
|
|||
# define EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, nbits) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ |
|||
EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, nbits, NULL) |
|||
|
|||
# define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS (EVP_PKEY_ALG_CTRL + 1) |
|||
# define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS (EVP_PKEY_ALG_CTRL + 2) |
|||
# define EVP_PKEY_CTRL_DSA_PARAMGEN_MD (EVP_PKEY_ALG_CTRL + 3) |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_DSA_strings(void); |
|||
|
|||
/* Error codes for the DSA functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define DSA_F_D2I_DSA_SIG 110 |
|||
# define DSA_F_DO_DSA_PRINT 104 |
|||
# define DSA_F_DSAPARAMS_PRINT 100 |
|||
# define DSA_F_DSAPARAMS_PRINT_FP 101 |
|||
# define DSA_F_DSA_DO_SIGN 112 |
|||
# define DSA_F_DSA_DO_VERIFY 113 |
|||
# define DSA_F_DSA_GENERATE_KEY 124 |
|||
# define DSA_F_DSA_GENERATE_PARAMETERS_EX 123 |
|||
# define DSA_F_DSA_NEW_METHOD 103 |
|||
# define DSA_F_DSA_PARAM_DECODE 119 |
|||
# define DSA_F_DSA_PRINT_FP 105 |
|||
# define DSA_F_DSA_PRIV_DECODE 115 |
|||
# define DSA_F_DSA_PRIV_ENCODE 116 |
|||
# define DSA_F_DSA_PUB_DECODE 117 |
|||
# define DSA_F_DSA_PUB_ENCODE 118 |
|||
# define DSA_F_DSA_SIGN 106 |
|||
# define DSA_F_DSA_SIGN_SETUP 107 |
|||
# define DSA_F_DSA_SIG_NEW 109 |
|||
# define DSA_F_DSA_SIG_PRINT 125 |
|||
# define DSA_F_DSA_VERIFY 108 |
|||
# define DSA_F_I2D_DSA_SIG 111 |
|||
# define DSA_F_OLD_DSA_PRIV_DECODE 122 |
|||
# define DSA_F_PKEY_DSA_CTRL 120 |
|||
# define DSA_F_PKEY_DSA_KEYGEN 121 |
|||
# define DSA_F_SIG_CB 114 |
|||
|
|||
/* Reason codes. */ |
|||
# define DSA_R_BAD_Q_VALUE 102 |
|||
# define DSA_R_BN_DECODE_ERROR 108 |
|||
# define DSA_R_BN_ERROR 109 |
|||
# define DSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 100 |
|||
# define DSA_R_DECODE_ERROR 104 |
|||
# define DSA_R_INVALID_DIGEST_TYPE 106 |
|||
# define DSA_R_MISSING_PARAMETERS 101 |
|||
# define DSA_R_MODULUS_TOO_LARGE 103 |
|||
# define DSA_R_NEED_NEW_SETUP_VALUES 110 |
|||
# define DSA_R_NON_FIPS_DSA_METHOD 111 |
|||
# define DSA_R_NO_PARAMETERS_SET 107 |
|||
# define DSA_R_PARAMETER_ENCODING_ERROR 105 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,451 +0,0 @@ |
|||
/* dso.h */ |
|||
/*
|
|||
* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project |
|||
* 2000. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2000 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_DSO_H |
|||
# define HEADER_DSO_H |
|||
|
|||
# include <openssl/crypto.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* These values are used as commands to DSO_ctrl() */ |
|||
# define DSO_CTRL_GET_FLAGS 1 |
|||
# define DSO_CTRL_SET_FLAGS 2 |
|||
# define DSO_CTRL_OR_FLAGS 3 |
|||
|
|||
/*
|
|||
* By default, DSO_load() will translate the provided filename into a form |
|||
* typical for the platform (more specifically the DSO_METHOD) using the |
|||
* dso_name_converter function of the method. Eg. win32 will transform "blah" |
|||
* into "blah.dll", and dlfcn will transform it into "libblah.so". The |
|||
* behaviour can be overriden by setting the name_converter callback in the |
|||
* DSO object (using DSO_set_name_converter()). This callback could even |
|||
* utilise the DSO_METHOD's converter too if it only wants to override |
|||
* behaviour for one or two possible DSO methods. However, the following flag |
|||
* can be set in a DSO to prevent *any* native name-translation at all - eg. |
|||
* if the caller has prompted the user for a path to a driver library so the |
|||
* filename should be interpreted as-is. |
|||
*/ |
|||
# define DSO_FLAG_NO_NAME_TRANSLATION 0x01 |
|||
/*
|
|||
* An extra flag to give if only the extension should be added as |
|||
* translation. This is obviously only of importance on Unix and other |
|||
* operating systems where the translation also may prefix the name with |
|||
* something, like 'lib', and ignored everywhere else. This flag is also |
|||
* ignored if DSO_FLAG_NO_NAME_TRANSLATION is used at the same time. |
|||
*/ |
|||
# define DSO_FLAG_NAME_TRANSLATION_EXT_ONLY 0x02 |
|||
|
|||
/*
|
|||
* The following flag controls the translation of symbol names to upper case. |
|||
* This is currently only being implemented for OpenVMS. |
|||
*/ |
|||
# define DSO_FLAG_UPCASE_SYMBOL 0x10 |
|||
|
|||
/*
|
|||
* This flag loads the library with public symbols. Meaning: The exported |
|||
* symbols of this library are public to all libraries loaded after this |
|||
* library. At the moment only implemented in unix. |
|||
*/ |
|||
# define DSO_FLAG_GLOBAL_SYMBOLS 0x20 |
|||
|
|||
typedef void (*DSO_FUNC_TYPE) (void); |
|||
|
|||
typedef struct dso_st DSO; |
|||
|
|||
/*
|
|||
* The function prototype used for method functions (or caller-provided |
|||
* callbacks) that transform filenames. They are passed a DSO structure |
|||
* pointer (or NULL if they are to be used independantly of a DSO object) and |
|||
* a filename to transform. They should either return NULL (if there is an |
|||
* error condition) or a newly allocated string containing the transformed |
|||
* form that the caller will need to free with OPENSSL_free() when done. |
|||
*/ |
|||
typedef char *(*DSO_NAME_CONVERTER_FUNC)(DSO *, const char *); |
|||
/*
|
|||
* The function prototype used for method functions (or caller-provided |
|||
* callbacks) that merge two file specifications. They are passed a DSO |
|||
* structure pointer (or NULL if they are to be used independantly of a DSO |
|||
* object) and two file specifications to merge. They should either return |
|||
* NULL (if there is an error condition) or a newly allocated string |
|||
* containing the result of merging that the caller will need to free with |
|||
* OPENSSL_free() when done. Here, merging means that bits and pieces are |
|||
* taken from each of the file specifications and added together in whatever |
|||
* fashion that is sensible for the DSO method in question. The only rule |
|||
* that really applies is that if the two specification contain pieces of the |
|||
* same type, the copy from the first string takes priority. One could see |
|||
* it as the first specification is the one given by the user and the second |
|||
* being a bunch of defaults to add on if they're missing in the first. |
|||
*/ |
|||
typedef char *(*DSO_MERGER_FUNC)(DSO *, const char *, const char *); |
|||
|
|||
typedef struct dso_meth_st { |
|||
const char *name; |
|||
/*
|
|||
* Loads a shared library, NB: new DSO_METHODs must ensure that a |
|||
* successful load populates the loaded_filename field, and likewise a |
|||
* successful unload OPENSSL_frees and NULLs it out. |
|||
*/ |
|||
int (*dso_load) (DSO *dso); |
|||
/* Unloads a shared library */ |
|||
int (*dso_unload) (DSO *dso); |
|||
/* Binds a variable */ |
|||
void *(*dso_bind_var) (DSO *dso, const char *symname); |
|||
/*
|
|||
* Binds a function - assumes a return type of DSO_FUNC_TYPE. This should |
|||
* be cast to the real function prototype by the caller. Platforms that |
|||
* don't have compatible representations for different prototypes (this |
|||
* is possible within ANSI C) are highly unlikely to have shared |
|||
* libraries at all, let alone a DSO_METHOD implemented for them. |
|||
*/ |
|||
DSO_FUNC_TYPE (*dso_bind_func) (DSO *dso, const char *symname); |
|||
/* I don't think this would actually be used in any circumstances. */ |
|||
# if 0 |
|||
/* Unbinds a variable */ |
|||
int (*dso_unbind_var) (DSO *dso, char *symname, void *symptr); |
|||
/* Unbinds a function */ |
|||
int (*dso_unbind_func) (DSO *dso, char *symname, DSO_FUNC_TYPE symptr); |
|||
# endif |
|||
/*
|
|||
* The generic (yuck) "ctrl()" function. NB: Negative return values |
|||
* (rather than zero) indicate errors. |
|||
*/ |
|||
long (*dso_ctrl) (DSO *dso, int cmd, long larg, void *parg); |
|||
/*
|
|||
* The default DSO_METHOD-specific function for converting filenames to a |
|||
* canonical native form. |
|||
*/ |
|||
DSO_NAME_CONVERTER_FUNC dso_name_converter; |
|||
/*
|
|||
* The default DSO_METHOD-specific function for converting filenames to a |
|||
* canonical native form. |
|||
*/ |
|||
DSO_MERGER_FUNC dso_merger; |
|||
/* [De]Initialisation handlers. */ |
|||
int (*init) (DSO *dso); |
|||
int (*finish) (DSO *dso); |
|||
/* Return pathname of the module containing location */ |
|||
int (*pathbyaddr) (void *addr, char *path, int sz); |
|||
/* Perform global symbol lookup, i.e. among *all* modules */ |
|||
void *(*globallookup) (const char *symname); |
|||
} DSO_METHOD; |
|||
|
|||
/**********************************************************************/ |
|||
/* The low-level handle type used to refer to a loaded shared library */ |
|||
|
|||
struct dso_st { |
|||
DSO_METHOD *meth; |
|||
/*
|
|||
* Standard dlopen uses a (void *). Win32 uses a HANDLE. VMS doesn't use |
|||
* anything but will need to cache the filename for use in the dso_bind |
|||
* handler. All in all, let each method control its own destiny. |
|||
* "Handles" and such go in a STACK. |
|||
*/ |
|||
STACK_OF(void) *meth_data; |
|||
int references; |
|||
int flags; |
|||
/*
|
|||
* For use by applications etc ... use this for your bits'n'pieces, don't |
|||
* touch meth_data! |
|||
*/ |
|||
CRYPTO_EX_DATA ex_data; |
|||
/*
|
|||
* If this callback function pointer is set to non-NULL, then it will be |
|||
* used in DSO_load() in place of meth->dso_name_converter. NB: This |
|||
* should normally set using DSO_set_name_converter(). |
|||
*/ |
|||
DSO_NAME_CONVERTER_FUNC name_converter; |
|||
/*
|
|||
* If this callback function pointer is set to non-NULL, then it will be |
|||
* used in DSO_load() in place of meth->dso_merger. NB: This should |
|||
* normally set using DSO_set_merger(). |
|||
*/ |
|||
DSO_MERGER_FUNC merger; |
|||
/*
|
|||
* This is populated with (a copy of) the platform-independant filename |
|||
* used for this DSO. |
|||
*/ |
|||
char *filename; |
|||
/*
|
|||
* This is populated with (a copy of) the translated filename by which |
|||
* the DSO was actually loaded. It is NULL iff the DSO is not currently |
|||
* loaded. NB: This is here because the filename translation process may |
|||
* involve a callback being invoked more than once not only to convert to |
|||
* a platform-specific form, but also to try different filenames in the |
|||
* process of trying to perform a load. As such, this variable can be |
|||
* used to indicate (a) whether this DSO structure corresponds to a |
|||
* loaded library or not, and (b) the filename with which it was actually |
|||
* loaded. |
|||
*/ |
|||
char *loaded_filename; |
|||
}; |
|||
|
|||
DSO *DSO_new(void); |
|||
DSO *DSO_new_method(DSO_METHOD *method); |
|||
int DSO_free(DSO *dso); |
|||
int DSO_flags(DSO *dso); |
|||
int DSO_up_ref(DSO *dso); |
|||
long DSO_ctrl(DSO *dso, int cmd, long larg, void *parg); |
|||
|
|||
/*
|
|||
* This function sets the DSO's name_converter callback. If it is non-NULL, |
|||
* then it will be used instead of the associated DSO_METHOD's function. If |
|||
* oldcb is non-NULL then it is set to the function pointer value being |
|||
* replaced. Return value is non-zero for success. |
|||
*/ |
|||
int DSO_set_name_converter(DSO *dso, DSO_NAME_CONVERTER_FUNC cb, |
|||
DSO_NAME_CONVERTER_FUNC *oldcb); |
|||
/*
|
|||
* These functions can be used to get/set the platform-independant filename |
|||
* used for a DSO. NB: set will fail if the DSO is already loaded. |
|||
*/ |
|||
const char *DSO_get_filename(DSO *dso); |
|||
int DSO_set_filename(DSO *dso, const char *filename); |
|||
/*
|
|||
* This function will invoke the DSO's name_converter callback to translate a |
|||
* filename, or if the callback isn't set it will instead use the DSO_METHOD's |
|||
* converter. If "filename" is NULL, the "filename" in the DSO itself will be |
|||
* used. If the DSO_FLAG_NO_NAME_TRANSLATION flag is set, then the filename is |
|||
* simply duplicated. NB: This function is usually called from within a |
|||
* DSO_METHOD during the processing of a DSO_load() call, and is exposed so |
|||
* that caller-created DSO_METHODs can do the same thing. A non-NULL return |
|||
* value will need to be OPENSSL_free()'d. |
|||
*/ |
|||
char *DSO_convert_filename(DSO *dso, const char *filename); |
|||
/*
|
|||
* This function will invoke the DSO's merger callback to merge two file |
|||
* specifications, or if the callback isn't set it will instead use the |
|||
* DSO_METHOD's merger. A non-NULL return value will need to be |
|||
* OPENSSL_free()'d. |
|||
*/ |
|||
char *DSO_merge(DSO *dso, const char *filespec1, const char *filespec2); |
|||
/*
|
|||
* If the DSO is currently loaded, this returns the filename that it was |
|||
* loaded under, otherwise it returns NULL. So it is also useful as a test as |
|||
* to whether the DSO is currently loaded. NB: This will not necessarily |
|||
* return the same value as DSO_convert_filename(dso, dso->filename), because |
|||
* the DSO_METHOD's load function may have tried a variety of filenames (with |
|||
* and/or without the aid of the converters) before settling on the one it |
|||
* actually loaded. |
|||
*/ |
|||
const char *DSO_get_loaded_filename(DSO *dso); |
|||
|
|||
void DSO_set_default_method(DSO_METHOD *meth); |
|||
DSO_METHOD *DSO_get_default_method(void); |
|||
DSO_METHOD *DSO_get_method(DSO *dso); |
|||
DSO_METHOD *DSO_set_method(DSO *dso, DSO_METHOD *meth); |
|||
|
|||
/*
|
|||
* The all-singing all-dancing load function, you normally pass NULL for the |
|||
* first and third parameters. Use DSO_up and DSO_free for subsequent |
|||
* reference count handling. Any flags passed in will be set in the |
|||
* constructed DSO after its init() function but before the load operation. |
|||
* If 'dso' is non-NULL, 'flags' is ignored. |
|||
*/ |
|||
DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags); |
|||
|
|||
/* This function binds to a variable inside a shared library. */ |
|||
void *DSO_bind_var(DSO *dso, const char *symname); |
|||
|
|||
/* This function binds to a function inside a shared library. */ |
|||
DSO_FUNC_TYPE DSO_bind_func(DSO *dso, const char *symname); |
|||
|
|||
/*
|
|||
* This method is the default, but will beg, borrow, or steal whatever method |
|||
* should be the default on any particular platform (including |
|||
* DSO_METH_null() if necessary). |
|||
*/ |
|||
DSO_METHOD *DSO_METHOD_openssl(void); |
|||
|
|||
/*
|
|||
* This method is defined for all platforms - if a platform has no DSO |
|||
* support then this will be the only method! |
|||
*/ |
|||
DSO_METHOD *DSO_METHOD_null(void); |
|||
|
|||
/*
|
|||
* If DSO_DLFCN is defined, the standard dlfcn.h-style functions (dlopen, |
|||
* dlclose, dlsym, etc) will be used and incorporated into this method. If |
|||
* not, this method will return NULL. |
|||
*/ |
|||
DSO_METHOD *DSO_METHOD_dlfcn(void); |
|||
|
|||
/*
|
|||
* If DSO_DL is defined, the standard dl.h-style functions (shl_load, |
|||
* shl_unload, shl_findsym, etc) will be used and incorporated into this |
|||
* method. If not, this method will return NULL. |
|||
*/ |
|||
DSO_METHOD *DSO_METHOD_dl(void); |
|||
|
|||
/* If WIN32 is defined, use DLLs. If not, return NULL. */ |
|||
DSO_METHOD *DSO_METHOD_win32(void); |
|||
|
|||
/* If VMS is defined, use shared images. If not, return NULL. */ |
|||
DSO_METHOD *DSO_METHOD_vms(void); |
|||
|
|||
/*
|
|||
* This function writes null-terminated pathname of DSO module containing |
|||
* 'addr' into 'sz' large caller-provided 'path' and returns the number of |
|||
* characters [including trailing zero] written to it. If 'sz' is 0 or |
|||
* negative, 'path' is ignored and required amount of charachers [including |
|||
* trailing zero] to accomodate pathname is returned. If 'addr' is NULL, then |
|||
* pathname of cryptolib itself is returned. Negative or zero return value |
|||
* denotes error. |
|||
*/ |
|||
int DSO_pathbyaddr(void *addr, char *path, int sz); |
|||
|
|||
/*
|
|||
* This function should be used with caution! It looks up symbols in *all* |
|||
* loaded modules and if module gets unloaded by somebody else attempt to |
|||
* dereference the pointer is doomed to have fatal consequences. Primary |
|||
* usage for this function is to probe *core* system functionality, e.g. |
|||
* check if getnameinfo(3) is available at run-time without bothering about |
|||
* OS-specific details such as libc.so.versioning or where does it actually |
|||
* reside: in libc itself or libsocket. |
|||
*/ |
|||
void *DSO_global_lookup(const char *name); |
|||
|
|||
/* If BeOS is defined, use shared images. If not, return NULL. */ |
|||
DSO_METHOD *DSO_METHOD_beos(void); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_DSO_strings(void); |
|||
|
|||
/* Error codes for the DSO functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define DSO_F_BEOS_BIND_FUNC 144 |
|||
# define DSO_F_BEOS_BIND_VAR 145 |
|||
# define DSO_F_BEOS_LOAD 146 |
|||
# define DSO_F_BEOS_NAME_CONVERTER 147 |
|||
# define DSO_F_BEOS_UNLOAD 148 |
|||
# define DSO_F_DLFCN_BIND_FUNC 100 |
|||
# define DSO_F_DLFCN_BIND_VAR 101 |
|||
# define DSO_F_DLFCN_LOAD 102 |
|||
# define DSO_F_DLFCN_MERGER 130 |
|||
# define DSO_F_DLFCN_NAME_CONVERTER 123 |
|||
# define DSO_F_DLFCN_UNLOAD 103 |
|||
# define DSO_F_DL_BIND_FUNC 104 |
|||
# define DSO_F_DL_BIND_VAR 105 |
|||
# define DSO_F_DL_LOAD 106 |
|||
# define DSO_F_DL_MERGER 131 |
|||
# define DSO_F_DL_NAME_CONVERTER 124 |
|||
# define DSO_F_DL_UNLOAD 107 |
|||
# define DSO_F_DSO_BIND_FUNC 108 |
|||
# define DSO_F_DSO_BIND_VAR 109 |
|||
# define DSO_F_DSO_CONVERT_FILENAME 126 |
|||
# define DSO_F_DSO_CTRL 110 |
|||
# define DSO_F_DSO_FREE 111 |
|||
# define DSO_F_DSO_GET_FILENAME 127 |
|||
# define DSO_F_DSO_GET_LOADED_FILENAME 128 |
|||
# define DSO_F_DSO_GLOBAL_LOOKUP 139 |
|||
# define DSO_F_DSO_LOAD 112 |
|||
# define DSO_F_DSO_MERGE 132 |
|||
# define DSO_F_DSO_NEW_METHOD 113 |
|||
# define DSO_F_DSO_PATHBYADDR 140 |
|||
# define DSO_F_DSO_SET_FILENAME 129 |
|||
# define DSO_F_DSO_SET_NAME_CONVERTER 122 |
|||
# define DSO_F_DSO_UP_REF 114 |
|||
# define DSO_F_GLOBAL_LOOKUP_FUNC 138 |
|||
# define DSO_F_PATHBYADDR 137 |
|||
# define DSO_F_VMS_BIND_SYM 115 |
|||
# define DSO_F_VMS_LOAD 116 |
|||
# define DSO_F_VMS_MERGER 133 |
|||
# define DSO_F_VMS_UNLOAD 117 |
|||
# define DSO_F_WIN32_BIND_FUNC 118 |
|||
# define DSO_F_WIN32_BIND_VAR 119 |
|||
# define DSO_F_WIN32_GLOBALLOOKUP 142 |
|||
# define DSO_F_WIN32_GLOBALLOOKUP_FUNC 143 |
|||
# define DSO_F_WIN32_JOINER 135 |
|||
# define DSO_F_WIN32_LOAD 120 |
|||
# define DSO_F_WIN32_MERGER 134 |
|||
# define DSO_F_WIN32_NAME_CONVERTER 125 |
|||
# define DSO_F_WIN32_PATHBYADDR 141 |
|||
# define DSO_F_WIN32_SPLITTER 136 |
|||
# define DSO_F_WIN32_UNLOAD 121 |
|||
|
|||
/* Reason codes. */ |
|||
# define DSO_R_CTRL_FAILED 100 |
|||
# define DSO_R_DSO_ALREADY_LOADED 110 |
|||
# define DSO_R_EMPTY_FILE_STRUCTURE 113 |
|||
# define DSO_R_FAILURE 114 |
|||
# define DSO_R_FILENAME_TOO_BIG 101 |
|||
# define DSO_R_FINISH_FAILED 102 |
|||
# define DSO_R_INCORRECT_FILE_SYNTAX 115 |
|||
# define DSO_R_LOAD_FAILED 103 |
|||
# define DSO_R_NAME_TRANSLATION_FAILED 109 |
|||
# define DSO_R_NO_FILENAME 111 |
|||
# define DSO_R_NO_FILE_SPECIFICATION 116 |
|||
# define DSO_R_NULL_HANDLE 104 |
|||
# define DSO_R_SET_FILENAME_FAILED 112 |
|||
# define DSO_R_STACK_ERROR 105 |
|||
# define DSO_R_SYM_FAILURE 106 |
|||
# define DSO_R_UNLOAD_FAILED 107 |
|||
# define DSO_R_UNSUPPORTED 108 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,268 +0,0 @@ |
|||
/* ssl/dtls1.h */ |
|||
/*
|
|||
* DTLS implementation written by Nagendra Modadugu |
|||
* (nagendra@cs.stanford.edu) for the OpenSSL project 2005. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_DTLS1_H |
|||
# define HEADER_DTLS1_H |
|||
|
|||
# include <openssl/buffer.h> |
|||
# include <openssl/pqueue.h> |
|||
# ifdef OPENSSL_SYS_VMS |
|||
# include <resource.h> |
|||
# include <sys/timeb.h> |
|||
# endif |
|||
# ifdef OPENSSL_SYS_WIN32 |
|||
/* Needed for struct timeval */ |
|||
# include <winsock.h> |
|||
# elif defined(OPENSSL_SYS_NETWARE) && !defined(_WINSOCK2API_) |
|||
# include <sys/timeval.h> |
|||
# else |
|||
# if defined(OPENSSL_SYS_VXWORKS) |
|||
# include <sys/times.h> |
|||
# else |
|||
# include <sys/time.h> |
|||
# endif |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# define DTLS1_VERSION 0xFEFF |
|||
# define DTLS_MAX_VERSION DTLS1_VERSION |
|||
# define DTLS1_VERSION_MAJOR 0xFE |
|||
|
|||
# define DTLS1_BAD_VER 0x0100 |
|||
|
|||
# if 0 |
|||
/* this alert description is not specified anywhere... */ |
|||
# define DTLS1_AD_MISSING_HANDSHAKE_MESSAGE 110 |
|||
# endif |
|||
|
|||
/* lengths of messages */ |
|||
# define DTLS1_COOKIE_LENGTH 256 |
|||
|
|||
# define DTLS1_RT_HEADER_LENGTH 13 |
|||
|
|||
# define DTLS1_HM_HEADER_LENGTH 12 |
|||
|
|||
# define DTLS1_HM_BAD_FRAGMENT -2 |
|||
# define DTLS1_HM_FRAGMENT_RETRY -3 |
|||
|
|||
# define DTLS1_CCS_HEADER_LENGTH 1 |
|||
|
|||
# ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE |
|||
# define DTLS1_AL_HEADER_LENGTH 7 |
|||
# else |
|||
# define DTLS1_AL_HEADER_LENGTH 2 |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_SSL_INTERN |
|||
|
|||
# ifndef OPENSSL_NO_SCTP |
|||
# define DTLS1_SCTP_AUTH_LABEL "EXPORTER_DTLS_OVER_SCTP" |
|||
# endif |
|||
|
|||
/* Max MTU overhead we know about so far is 40 for IPv6 + 8 for UDP */ |
|||
# define DTLS1_MAX_MTU_OVERHEAD 48 |
|||
|
|||
typedef struct dtls1_bitmap_st { |
|||
unsigned long map; /* track 32 packets on 32-bit systems and 64
|
|||
* - on 64-bit systems */ |
|||
unsigned char max_seq_num[8]; /* max record number seen so far, 64-bit
|
|||
* value in big-endian encoding */ |
|||
} DTLS1_BITMAP; |
|||
|
|||
struct dtls1_retransmit_state { |
|||
EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */ |
|||
EVP_MD_CTX *write_hash; /* used for mac generation */ |
|||
# ifndef OPENSSL_NO_COMP |
|||
COMP_CTX *compress; /* compression */ |
|||
# else |
|||
char *compress; |
|||
# endif |
|||
SSL_SESSION *session; |
|||
unsigned short epoch; |
|||
}; |
|||
|
|||
struct hm_header_st { |
|||
unsigned char type; |
|||
unsigned long msg_len; |
|||
unsigned short seq; |
|||
unsigned long frag_off; |
|||
unsigned long frag_len; |
|||
unsigned int is_ccs; |
|||
struct dtls1_retransmit_state saved_retransmit_state; |
|||
}; |
|||
|
|||
struct ccs_header_st { |
|||
unsigned char type; |
|||
unsigned short seq; |
|||
}; |
|||
|
|||
struct dtls1_timeout_st { |
|||
/* Number of read timeouts so far */ |
|||
unsigned int read_timeouts; |
|||
/* Number of write timeouts so far */ |
|||
unsigned int write_timeouts; |
|||
/* Number of alerts received so far */ |
|||
unsigned int num_alerts; |
|||
}; |
|||
|
|||
typedef struct record_pqueue_st { |
|||
unsigned short epoch; |
|||
pqueue q; |
|||
} record_pqueue; |
|||
|
|||
typedef struct hm_fragment_st { |
|||
struct hm_header_st msg_header; |
|||
unsigned char *fragment; |
|||
unsigned char *reassembly; |
|||
} hm_fragment; |
|||
|
|||
typedef struct dtls1_state_st { |
|||
unsigned int send_cookie; |
|||
unsigned char cookie[DTLS1_COOKIE_LENGTH]; |
|||
unsigned char rcvd_cookie[DTLS1_COOKIE_LENGTH]; |
|||
unsigned int cookie_len; |
|||
/*
|
|||
* The current data and handshake epoch. This is initially |
|||
* undefined, and starts at zero once the initial handshake is |
|||
* completed |
|||
*/ |
|||
unsigned short r_epoch; |
|||
unsigned short w_epoch; |
|||
/* records being received in the current epoch */ |
|||
DTLS1_BITMAP bitmap; |
|||
/* renegotiation starts a new set of sequence numbers */ |
|||
DTLS1_BITMAP next_bitmap; |
|||
/* handshake message numbers */ |
|||
unsigned short handshake_write_seq; |
|||
unsigned short next_handshake_write_seq; |
|||
unsigned short handshake_read_seq; |
|||
/* save last sequence number for retransmissions */ |
|||
unsigned char last_write_sequence[8]; |
|||
/* Received handshake records (processed and unprocessed) */ |
|||
record_pqueue unprocessed_rcds; |
|||
record_pqueue processed_rcds; |
|||
/* Buffered handshake messages */ |
|||
pqueue buffered_messages; |
|||
/* Buffered (sent) handshake records */ |
|||
pqueue sent_messages; |
|||
/*
|
|||
* Buffered application records. Only for records between CCS and |
|||
* Finished to prevent either protocol violation or unnecessary message |
|||
* loss. |
|||
*/ |
|||
record_pqueue buffered_app_data; |
|||
/* Is set when listening for new connections with dtls1_listen() */ |
|||
unsigned int listen; |
|||
unsigned int link_mtu; /* max on-the-wire DTLS packet size */ |
|||
unsigned int mtu; /* max DTLS packet size */ |
|||
struct hm_header_st w_msg_hdr; |
|||
struct hm_header_st r_msg_hdr; |
|||
struct dtls1_timeout_st timeout; |
|||
/*
|
|||
* Indicates when the last handshake msg or heartbeat sent will timeout |
|||
*/ |
|||
struct timeval next_timeout; |
|||
/* Timeout duration */ |
|||
unsigned short timeout_duration; |
|||
/*
|
|||
* storage for Alert/Handshake protocol data received but not yet |
|||
* processed by ssl3_read_bytes: |
|||
*/ |
|||
unsigned char alert_fragment[DTLS1_AL_HEADER_LENGTH]; |
|||
unsigned int alert_fragment_len; |
|||
unsigned char handshake_fragment[DTLS1_HM_HEADER_LENGTH]; |
|||
unsigned int handshake_fragment_len; |
|||
unsigned int retransmitting; |
|||
/*
|
|||
* Set when the handshake is ready to process peer's ChangeCipherSpec message. |
|||
* Cleared after the message has been processed. |
|||
*/ |
|||
unsigned int change_cipher_spec_ok; |
|||
# ifndef OPENSSL_NO_SCTP |
|||
/* used when SSL_ST_XX_FLUSH is entered */ |
|||
int next_state; |
|||
int shutdown_received; |
|||
# endif |
|||
} DTLS1_STATE; |
|||
|
|||
typedef struct dtls1_record_data_st { |
|||
unsigned char *packet; |
|||
unsigned int packet_length; |
|||
SSL3_BUFFER rbuf; |
|||
SSL3_RECORD rrec; |
|||
# ifndef OPENSSL_NO_SCTP |
|||
struct bio_dgram_sctp_rcvinfo recordinfo; |
|||
# endif |
|||
} DTLS1_RECORD_DATA; |
|||
|
|||
# endif |
|||
|
|||
/* Timeout multipliers (timeout slice is defined in apps/timeouts.h */ |
|||
# define DTLS1_TMO_READ_COUNT 2 |
|||
# define DTLS1_TMO_WRITE_COUNT 2 |
|||
|
|||
# define DTLS1_TMO_ALERT_COUNT 12 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,328 +0,0 @@ |
|||
/* e_os2.h */ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#include <openssl/opensslconf.h> |
|||
|
|||
#ifndef HEADER_E_OS2_H |
|||
# define HEADER_E_OS2_H |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/******************************************************************************
|
|||
* Detect operating systems. This probably needs completing. |
|||
* The result is that at least one OPENSSL_SYS_os macro should be defined. |
|||
* However, if none is defined, Unix is assumed. |
|||
**/ |
|||
|
|||
# define OPENSSL_SYS_UNIX |
|||
|
|||
/* ---------------------- Macintosh, before MacOS X ----------------------- */ |
|||
# if defined(__MWERKS__) && defined(macintosh) || defined(OPENSSL_SYSNAME_MAC) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_MACINTOSH_CLASSIC |
|||
# endif |
|||
|
|||
/* ---------------------- NetWare ----------------------------------------- */ |
|||
# if defined(NETWARE) || defined(OPENSSL_SYSNAME_NETWARE) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_NETWARE |
|||
# endif |
|||
|
|||
/* --------------------- Microsoft operating systems ---------------------- */ |
|||
|
|||
/*
|
|||
* Note that MSDOS actually denotes 32-bit environments running on top of |
|||
* MS-DOS, such as DJGPP one. |
|||
*/ |
|||
# if defined(OPENSSL_SYSNAME_MSDOS) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_MSDOS |
|||
# endif |
|||
|
|||
/*
|
|||
* For 32 bit environment, there seems to be the CygWin environment and then |
|||
* all the others that try to do the same thing Microsoft does... |
|||
*/ |
|||
# if defined(OPENSSL_SYSNAME_UWIN) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_WIN32_UWIN |
|||
# else |
|||
# if defined(__CYGWIN32__) || defined(OPENSSL_SYSNAME_CYGWIN32) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_WIN32_CYGWIN |
|||
# else |
|||
# if defined(_WIN32) || defined(OPENSSL_SYSNAME_WIN32) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_WIN32 |
|||
# endif |
|||
# if defined(_WIN64) || defined(OPENSSL_SYSNAME_WIN64) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# if !defined(OPENSSL_SYS_WIN64) |
|||
# define OPENSSL_SYS_WIN64 |
|||
# endif |
|||
# endif |
|||
# if defined(OPENSSL_SYSNAME_WINNT) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_WINNT |
|||
# endif |
|||
# if defined(OPENSSL_SYSNAME_WINCE) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_WINCE |
|||
# endif |
|||
# endif |
|||
# endif |
|||
|
|||
/* Anything that tries to look like Microsoft is "Windows" */ |
|||
# if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_WINDOWS |
|||
# ifndef OPENSSL_SYS_MSDOS |
|||
# define OPENSSL_SYS_MSDOS |
|||
# endif |
|||
# endif |
|||
|
|||
/*
|
|||
* DLL settings. This part is a bit tough, because it's up to the |
|||
* application implementor how he or she will link the application, so it |
|||
* requires some macro to be used. |
|||
*/ |
|||
# ifdef OPENSSL_SYS_WINDOWS |
|||
# ifndef OPENSSL_OPT_WINDLL |
|||
# if defined(_WINDLL) /* This is used when building OpenSSL to |
|||
* indicate that DLL linkage should be used */ |
|||
# define OPENSSL_OPT_WINDLL |
|||
# endif |
|||
# endif |
|||
# endif |
|||
|
|||
/* ------------------------------- OpenVMS -------------------------------- */ |
|||
# if defined(__VMS) || defined(VMS) || defined(OPENSSL_SYSNAME_VMS) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_VMS |
|||
# if defined(__DECC) |
|||
# define OPENSSL_SYS_VMS_DECC |
|||
# elif defined(__DECCXX) |
|||
# define OPENSSL_SYS_VMS_DECC |
|||
# define OPENSSL_SYS_VMS_DECCXX |
|||
# else |
|||
# define OPENSSL_SYS_VMS_NODECC |
|||
# endif |
|||
# endif |
|||
|
|||
/* -------------------------------- OS/2 ---------------------------------- */ |
|||
# if defined(__EMX__) || defined(__OS2__) |
|||
# undef OPENSSL_SYS_UNIX |
|||
# define OPENSSL_SYS_OS2 |
|||
# endif |
|||
|
|||
/* -------------------------------- Unix ---------------------------------- */ |
|||
# ifdef OPENSSL_SYS_UNIX |
|||
# if defined(linux) || defined(__linux__) || defined(OPENSSL_SYSNAME_LINUX) |
|||
# define OPENSSL_SYS_LINUX |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_MPE |
|||
# define OPENSSL_SYS_MPE |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_SNI |
|||
# define OPENSSL_SYS_SNI |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_ULTRASPARC |
|||
# define OPENSSL_SYS_ULTRASPARC |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_NEWS4 |
|||
# define OPENSSL_SYS_NEWS4 |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_MACOSX |
|||
# define OPENSSL_SYS_MACOSX |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_MACOSX_RHAPSODY |
|||
# define OPENSSL_SYS_MACOSX_RHAPSODY |
|||
# define OPENSSL_SYS_MACOSX |
|||
# endif |
|||
# ifdef OPENSSL_SYSNAME_SUNOS |
|||
# define OPENSSL_SYS_SUNOS |
|||
# endif |
|||
# if defined(_CRAY) || defined(OPENSSL_SYSNAME_CRAY) |
|||
# define OPENSSL_SYS_CRAY |
|||
# endif |
|||
# if defined(_AIX) || defined(OPENSSL_SYSNAME_AIX) |
|||
# define OPENSSL_SYS_AIX |
|||
# endif |
|||
# endif |
|||
|
|||
/* -------------------------------- VOS ----------------------------------- */ |
|||
# if defined(__VOS__) || defined(OPENSSL_SYSNAME_VOS) |
|||
# define OPENSSL_SYS_VOS |
|||
# ifdef __HPPA__ |
|||
# define OPENSSL_SYS_VOS_HPPA |
|||
# endif |
|||
# ifdef __IA32__ |
|||
# define OPENSSL_SYS_VOS_IA32 |
|||
# endif |
|||
# endif |
|||
|
|||
/* ------------------------------ VxWorks --------------------------------- */ |
|||
# ifdef OPENSSL_SYSNAME_VXWORKS |
|||
# define OPENSSL_SYS_VXWORKS |
|||
# endif |
|||
|
|||
/* -------------------------------- BeOS ---------------------------------- */ |
|||
# if defined(__BEOS__) |
|||
# define OPENSSL_SYS_BEOS |
|||
# include <sys/socket.h> |
|||
# if defined(BONE_VERSION) |
|||
# define OPENSSL_SYS_BEOS_BONE |
|||
# else |
|||
# define OPENSSL_SYS_BEOS_R5 |
|||
# endif |
|||
# endif |
|||
|
|||
/**
|
|||
* That's it for OS-specific stuff |
|||
*****************************************************************************/ |
|||
|
|||
/* Specials for I/O an exit */ |
|||
# ifdef OPENSSL_SYS_MSDOS |
|||
# define OPENSSL_UNISTD_IO <io.h> |
|||
# define OPENSSL_DECLARE_EXIT extern void exit(int); |
|||
# else |
|||
# define OPENSSL_UNISTD_IO OPENSSL_UNISTD |
|||
# define OPENSSL_DECLARE_EXIT /* declared in unistd.h */ |
|||
# endif |
|||
|
|||
/*-
|
|||
* Definitions of OPENSSL_GLOBAL and OPENSSL_EXTERN, to define and declare |
|||
* certain global symbols that, with some compilers under VMS, have to be |
|||
* defined and declared explicitely with globaldef and globalref. |
|||
* Definitions of OPENSSL_EXPORT and OPENSSL_IMPORT, to define and declare |
|||
* DLL exports and imports for compilers under Win32. These are a little |
|||
* more complicated to use. Basically, for any library that exports some |
|||
* global variables, the following code must be present in the header file |
|||
* that declares them, before OPENSSL_EXTERN is used: |
|||
* |
|||
* #ifdef SOME_BUILD_FLAG_MACRO |
|||
* # undef OPENSSL_EXTERN |
|||
* # define OPENSSL_EXTERN OPENSSL_EXPORT |
|||
* #endif |
|||
* |
|||
* The default is to have OPENSSL_EXPORT, OPENSSL_IMPORT and OPENSSL_GLOBAL |
|||
* have some generally sensible values, and for OPENSSL_EXTERN to have the |
|||
* value OPENSSL_IMPORT. |
|||
*/ |
|||
|
|||
# if defined(OPENSSL_SYS_VMS_NODECC) |
|||
# define OPENSSL_EXPORT globalref |
|||
# define OPENSSL_IMPORT globalref |
|||
# define OPENSSL_GLOBAL globaldef |
|||
# elif defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL) |
|||
# define OPENSSL_EXPORT extern __declspec(dllexport) |
|||
# define OPENSSL_IMPORT extern __declspec(dllimport) |
|||
# define OPENSSL_GLOBAL |
|||
# else |
|||
# define OPENSSL_EXPORT extern |
|||
# define OPENSSL_IMPORT extern |
|||
# define OPENSSL_GLOBAL |
|||
# endif |
|||
# define OPENSSL_EXTERN OPENSSL_IMPORT |
|||
|
|||
/*-
|
|||
* Macros to allow global variables to be reached through function calls when |
|||
* required (if a shared library version requires it, for example. |
|||
* The way it's done allows definitions like this: |
|||
* |
|||
* // in foobar.c
|
|||
* OPENSSL_IMPLEMENT_GLOBAL(int,foobar,0) |
|||
* // in foobar.h
|
|||
* OPENSSL_DECLARE_GLOBAL(int,foobar); |
|||
* #define foobar OPENSSL_GLOBAL_REF(foobar) |
|||
*/ |
|||
# ifdef OPENSSL_EXPORT_VAR_AS_FUNCTION |
|||
# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) \ |
|||
type *_shadow_##name(void) \ |
|||
{ static type _hide_##name=value; return &_hide_##name; } |
|||
# define OPENSSL_DECLARE_GLOBAL(type,name) type *_shadow_##name(void) |
|||
# define OPENSSL_GLOBAL_REF(name) (*(_shadow_##name())) |
|||
# else |
|||
# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) OPENSSL_GLOBAL type _shadow_##name=value; |
|||
# define OPENSSL_DECLARE_GLOBAL(type,name) OPENSSL_EXPORT type _shadow_##name |
|||
# define OPENSSL_GLOBAL_REF(name) _shadow_##name |
|||
# endif |
|||
|
|||
# if defined(OPENSSL_SYS_MACINTOSH_CLASSIC) && macintosh==1 && !defined(MAC_OS_GUSI_SOURCE) |
|||
# define ossl_ssize_t long |
|||
# endif |
|||
|
|||
# ifdef OPENSSL_SYS_MSDOS |
|||
# define ossl_ssize_t long |
|||
# endif |
|||
|
|||
# if defined(NeXT) || defined(OPENSSL_SYS_NEWS4) || defined(OPENSSL_SYS_SUNOS) |
|||
# define ssize_t int |
|||
# endif |
|||
|
|||
# if defined(__ultrix) && !defined(ssize_t) |
|||
# define ossl_ssize_t int |
|||
# endif |
|||
|
|||
# ifndef ossl_ssize_t |
|||
# define ossl_ssize_t ssize_t |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,26 +0,0 @@ |
|||
/* crypto/ebcdic.h */ |
|||
|
|||
#ifndef HEADER_EBCDIC_H |
|||
# define HEADER_EBCDIC_H |
|||
|
|||
# include <sys/types.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Avoid name clashes with other applications */ |
|||
# define os_toascii _openssl_os_toascii |
|||
# define os_toebcdic _openssl_os_toebcdic |
|||
# define ebcdic2ascii _openssl_ebcdic2ascii |
|||
# define ascii2ebcdic _openssl_ascii2ebcdic |
|||
|
|||
extern const unsigned char os_toascii[256]; |
|||
extern const unsigned char os_toebcdic[256]; |
|||
void *ebcdic2ascii(void *dest, const void *srce, size_t count); |
|||
void *ascii2ebcdic(void *dest, const void *srce, size_t count); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
File diff suppressed because it is too large
@ -1,127 +0,0 @@ |
|||
/* crypto/ecdh/ecdh.h */ |
|||
/* ====================================================================
|
|||
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. |
|||
* |
|||
* The Elliptic Curve Public-Key Crypto Library (ECC Code) included |
|||
* herein is developed by SUN MICROSYSTEMS, INC., and is contributed |
|||
* to the OpenSSL project. |
|||
* |
|||
* The ECC Code is licensed pursuant to the OpenSSL open source |
|||
* license provided below. |
|||
* |
|||
* The ECDH software is originally written by Douglas Stebila of |
|||
* Sun Microsystems Laboratories. |
|||
* |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2000-2002 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
#ifndef HEADER_ECDH_H |
|||
# define HEADER_ECDH_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_ECDH |
|||
# error ECDH is disabled. |
|||
# endif |
|||
|
|||
# include <openssl/ec.h> |
|||
# include <openssl/ossl_typ.h> |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# include <openssl/bn.h> |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
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_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); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_ECDH_strings(void); |
|||
|
|||
/* Error codes for the ECDH functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define ECDH_F_ECDH_CHECK 102 |
|||
# define ECDH_F_ECDH_COMPUTE_KEY 100 |
|||
# define ECDH_F_ECDH_DATA_NEW_METHOD 101 |
|||
|
|||
/* Reason codes. */ |
|||
# define ECDH_R_KDF_FAILED 102 |
|||
# define ECDH_R_NON_FIPS_METHOD 103 |
|||
# define ECDH_R_NO_PRIVATE_VALUE 100 |
|||
# define ECDH_R_POINT_ARITHMETIC_FAILURE 101 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,260 +0,0 @@ |
|||
/* crypto/ecdsa/ecdsa.h */ |
|||
/**
|
|||
* \file crypto/ecdsa/ecdsa.h Include file for the OpenSSL ECDSA functions |
|||
* \author Written by Nils Larsch for the OpenSSL project |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
#ifndef HEADER_ECDSA_H |
|||
# define HEADER_ECDSA_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_ECDSA |
|||
# error ECDSA is disabled. |
|||
# endif |
|||
|
|||
# include <openssl/ec.h> |
|||
# include <openssl/ossl_typ.h> |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# include <openssl/bn.h> |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct ECDSA_SIG_st { |
|||
BIGNUM *r; |
|||
BIGNUM *s; |
|||
} ECDSA_SIG; |
|||
|
|||
/** Allocates and initialize a ECDSA_SIG structure
|
|||
* \return pointer to a ECDSA_SIG structure or NULL if an error occurred |
|||
*/ |
|||
ECDSA_SIG *ECDSA_SIG_new(void); |
|||
|
|||
/** frees a ECDSA_SIG structure
|
|||
* \param sig pointer to the ECDSA_SIG structure |
|||
*/ |
|||
void ECDSA_SIG_free(ECDSA_SIG *sig); |
|||
|
|||
/** DER encode content of ECDSA_SIG object (note: this function modifies *pp
|
|||
* (*pp += length of the DER encoded signature)). |
|||
* \param sig pointer to the ECDSA_SIG object |
|||
* \param pp pointer to a unsigned char pointer for the output or NULL |
|||
* \return the length of the DER encoded ECDSA_SIG object or 0 |
|||
*/ |
|||
int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp); |
|||
|
|||
/** Decodes a DER encoded ECDSA signature (note: this function changes *pp
|
|||
* (*pp += len)). |
|||
* \param sig pointer to ECDSA_SIG pointer (may be NULL) |
|||
* \param pp memory buffer with the DER encoded signature |
|||
* \param len length of the buffer |
|||
* \return pointer to the decoded ECDSA_SIG structure (or NULL) |
|||
*/ |
|||
ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len); |
|||
|
|||
/** Computes the ECDSA signature of the given hash value using
|
|||
* the supplied private key and returns the created signature. |
|||
* \param dgst pointer to the hash value |
|||
* \param dgst_len length of the hash value |
|||
* \param eckey EC_KEY object containing a private EC key |
|||
* \return pointer to a ECDSA_SIG structure or NULL if an error occurred |
|||
*/ |
|||
ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len, |
|||
EC_KEY *eckey); |
|||
|
|||
/** Computes ECDSA signature of a given hash value using the supplied
|
|||
* private key (note: sig must point to ECDSA_size(eckey) bytes of memory). |
|||
* \param dgst pointer to the hash value to sign |
|||
* \param dgstlen length of the hash value |
|||
* \param kinv BIGNUM with a pre-computed inverse k (optional) |
|||
* \param rp BIGNUM with a pre-computed rp value (optioanl), |
|||
* see ECDSA_sign_setup |
|||
* \param eckey EC_KEY object containing a private EC key |
|||
* \return pointer to a ECDSA_SIG structure or NULL if an error occurred |
|||
*/ |
|||
ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen, |
|||
const BIGNUM *kinv, const BIGNUM *rp, |
|||
EC_KEY *eckey); |
|||
|
|||
/** Verifies that the supplied signature is a valid ECDSA
|
|||
* signature of the supplied hash value using the supplied public key. |
|||
* \param dgst pointer to the hash value |
|||
* \param dgst_len length of the hash value |
|||
* \param sig ECDSA_SIG structure |
|||
* \param eckey EC_KEY object containing a public EC key |
|||
* \return 1 if the signature is valid, 0 if the signature is invalid |
|||
* and -1 on error |
|||
*/ |
|||
int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, |
|||
const ECDSA_SIG *sig, EC_KEY *eckey); |
|||
|
|||
const ECDSA_METHOD *ECDSA_OpenSSL(void); |
|||
|
|||
/** Sets the default ECDSA method
|
|||
* \param meth new default ECDSA_METHOD |
|||
*/ |
|||
void ECDSA_set_default_method(const ECDSA_METHOD *meth); |
|||
|
|||
/** Returns the default ECDSA method
|
|||
* \return pointer to ECDSA_METHOD structure containing the default method |
|||
*/ |
|||
const ECDSA_METHOD *ECDSA_get_default_method(void); |
|||
|
|||
/** Sets method to be used for the ECDSA operations
|
|||
* \param eckey EC_KEY object |
|||
* \param meth new method |
|||
* \return 1 on success and 0 otherwise |
|||
*/ |
|||
int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth); |
|||
|
|||
/** Returns the maximum length of the DER encoded signature
|
|||
* \param eckey EC_KEY object |
|||
* \return numbers of bytes required for the DER encoded signature |
|||
*/ |
|||
int ECDSA_size(const EC_KEY *eckey); |
|||
|
|||
/** Precompute parts of the signing operation
|
|||
* \param eckey EC_KEY object containing a private EC key |
|||
* \param ctx BN_CTX object (optional) |
|||
* \param kinv BIGNUM pointer for the inverse of k |
|||
* \param rp BIGNUM pointer for x coordinate of k * generator |
|||
* \return 1 on success and 0 otherwise |
|||
*/ |
|||
int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp); |
|||
|
|||
/** Computes ECDSA signature of a given hash value using the supplied
|
|||
* private key (note: sig must point to ECDSA_size(eckey) bytes of memory). |
|||
* \param type this parameter is ignored |
|||
* \param dgst pointer to the hash value to sign |
|||
* \param dgstlen length of the hash value |
|||
* \param sig memory for the DER encoded created signature |
|||
* \param siglen pointer to the length of the returned signature |
|||
* \param eckey EC_KEY object containing a private EC key |
|||
* \return 1 on success and 0 otherwise |
|||
*/ |
|||
int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen, |
|||
unsigned char *sig, unsigned int *siglen, EC_KEY *eckey); |
|||
|
|||
/** Computes ECDSA signature of a given hash value using the supplied
|
|||
* private key (note: sig must point to ECDSA_size(eckey) bytes of memory). |
|||
* \param type this parameter is ignored |
|||
* \param dgst pointer to the hash value to sign |
|||
* \param dgstlen length of the hash value |
|||
* \param sig buffer to hold the DER encoded signature |
|||
* \param siglen pointer to the length of the returned signature |
|||
* \param kinv BIGNUM with a pre-computed inverse k (optional) |
|||
* \param rp BIGNUM with a pre-computed rp value (optioanl), |
|||
* see ECDSA_sign_setup |
|||
* \param eckey EC_KEY object containing a private EC key |
|||
* \return 1 on success and 0 otherwise |
|||
*/ |
|||
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); |
|||
|
|||
/** Verifies that the given signature is valid ECDSA signature
|
|||
* of the supplied hash value using the specified public key. |
|||
* \param type this parameter is ignored |
|||
* \param dgst pointer to the hash value |
|||
* \param dgstlen length of the hash value |
|||
* \param sig pointer to the DER encoded signature |
|||
* \param siglen length of the DER encoded signature |
|||
* \param eckey EC_KEY object containing a public EC key |
|||
* \return 1 if the signature is valid, 0 if the signature is invalid |
|||
* and -1 on error |
|||
*/ |
|||
int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen, |
|||
const unsigned char *sig, int siglen, EC_KEY *eckey); |
|||
|
|||
/* the standard ex_data functions */ |
|||
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); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_ECDSA_strings(void); |
|||
|
|||
/* Error codes for the ECDSA functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define ECDSA_F_ECDSA_CHECK 104 |
|||
# define ECDSA_F_ECDSA_DATA_NEW_METHOD 100 |
|||
# define ECDSA_F_ECDSA_DO_SIGN 101 |
|||
# define ECDSA_F_ECDSA_DO_VERIFY 102 |
|||
# define ECDSA_F_ECDSA_SIGN_SETUP 103 |
|||
|
|||
/* Reason codes. */ |
|||
# define ECDSA_R_BAD_SIGNATURE 100 |
|||
# define ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 101 |
|||
# define ECDSA_R_ERR_EC_LIB 102 |
|||
# define ECDSA_R_MISSING_PARAMETERS 103 |
|||
# define ECDSA_R_NEED_NEW_SETUP_VALUES 106 |
|||
# define ECDSA_R_NON_FIPS_METHOD 107 |
|||
# define ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED 104 |
|||
# define ECDSA_R_SIGNATURE_MALLOC_FAILED 105 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,961 +0,0 @@ |
|||
/* openssl/engine.h */ |
|||
/*
|
|||
* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project |
|||
* 2000. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1999-2004 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. |
|||
* ECDH support in OpenSSL originally developed by |
|||
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. |
|||
*/ |
|||
|
|||
#ifndef HEADER_ENGINE_H |
|||
# define HEADER_ENGINE_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_ENGINE |
|||
# error ENGINE is disabled. |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# include <openssl/bn.h> |
|||
# ifndef OPENSSL_NO_RSA |
|||
# include <openssl/rsa.h> |
|||
# endif |
|||
# ifndef OPENSSL_NO_DSA |
|||
# include <openssl/dsa.h> |
|||
# endif |
|||
# ifndef OPENSSL_NO_DH |
|||
# include <openssl/dh.h> |
|||
# endif |
|||
# ifndef OPENSSL_NO_ECDH |
|||
# include <openssl/ecdh.h> |
|||
# endif |
|||
# ifndef OPENSSL_NO_ECDSA |
|||
# include <openssl/ecdsa.h> |
|||
# endif |
|||
# include <openssl/rand.h> |
|||
# include <openssl/ui.h> |
|||
# include <openssl/err.h> |
|||
# endif |
|||
|
|||
# include <openssl/ossl_typ.h> |
|||
# include <openssl/symhacks.h> |
|||
|
|||
# include <openssl/x509.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/*
|
|||
* These flags are used to control combinations of algorithm (methods) by |
|||
* bitwise "OR"ing. |
|||
*/ |
|||
# define ENGINE_METHOD_RSA (unsigned int)0x0001 |
|||
# define ENGINE_METHOD_DSA (unsigned int)0x0002 |
|||
# define ENGINE_METHOD_DH (unsigned int)0x0004 |
|||
# define ENGINE_METHOD_RAND (unsigned int)0x0008 |
|||
# define ENGINE_METHOD_ECDH (unsigned int)0x0010 |
|||
# define ENGINE_METHOD_ECDSA (unsigned int)0x0020 |
|||
# define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 |
|||
# define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 |
|||
# define ENGINE_METHOD_STORE (unsigned int)0x0100 |
|||
# define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 |
|||
# define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 |
|||
/* Obvious all-or-nothing cases. */ |
|||
# define ENGINE_METHOD_ALL (unsigned int)0xFFFF |
|||
# define ENGINE_METHOD_NONE (unsigned int)0x0000 |
|||
|
|||
/*
|
|||
* This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used |
|||
* internally to control registration of ENGINE implementations, and can be |
|||
* set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to |
|||
* initialise registered ENGINEs if they are not already initialised. |
|||
*/ |
|||
# define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001 |
|||
|
|||
/* ENGINE flags that can be set by ENGINE_set_flags(). */ |
|||
/* Not used */ |
|||
/* #define ENGINE_FLAGS_MALLOCED 0x0001 */ |
|||
|
|||
/*
|
|||
* This flag is for ENGINEs that wish to handle the various 'CMD'-related |
|||
* control commands on their own. Without this flag, ENGINE_ctrl() handles |
|||
* these control commands on behalf of the ENGINE using their "cmd_defns" |
|||
* data. |
|||
*/ |
|||
# define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002 |
|||
|
|||
/*
|
|||
* This flag is for ENGINEs who return new duplicate structures when found |
|||
* via "ENGINE_by_id()". When an ENGINE must store state (eg. if |
|||
* ENGINE_ctrl() commands are called in sequence as part of some stateful |
|||
* process like key-generation setup and execution), it can set this flag - |
|||
* then each attempt to obtain the ENGINE will result in it being copied into |
|||
* a new structure. Normally, ENGINEs don't declare this flag so |
|||
* ENGINE_by_id() just increments the existing ENGINE's structural reference |
|||
* count. |
|||
*/ |
|||
# define ENGINE_FLAGS_BY_ID_COPY (int)0x0004 |
|||
|
|||
/*
|
|||
* This flag if for an ENGINE that does not want its methods registered as |
|||
* part of ENGINE_register_all_complete() for example if the methods are not |
|||
* usable as default methods. |
|||
*/ |
|||
|
|||
# define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008 |
|||
|
|||
/*
|
|||
* ENGINEs can support their own command types, and these flags are used in |
|||
* ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input |
|||
* each command expects. Currently only numeric and string input is |
|||
* supported. If a control command supports none of the _NUMERIC, _STRING, or |
|||
* _NO_INPUT options, then it is regarded as an "internal" control command - |
|||
* and not for use in config setting situations. As such, they're not |
|||
* available to the ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl() |
|||
* access. Changes to this list of 'command types' should be reflected |
|||
* carefully in ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string(). |
|||
*/ |
|||
|
|||
/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */ |
|||
# define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001 |
|||
/*
|
|||
* accepts string input (cast from 'void*' to 'const char *', 4th parameter |
|||
* to ENGINE_ctrl) |
|||
*/ |
|||
# define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002 |
|||
/*
|
|||
* Indicates that the control command takes *no* input. Ie. the control |
|||
* command is unparameterised. |
|||
*/ |
|||
# define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004 |
|||
/*
|
|||
* Indicates that the control command is internal. This control command won't |
|||
* be shown in any output, and is only usable through the ENGINE_ctrl_cmd() |
|||
* function. |
|||
*/ |
|||
# define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008 |
|||
|
|||
/*
|
|||
* NB: These 3 control commands are deprecated and should not be used. |
|||
* ENGINEs relying on these commands should compile conditional support for |
|||
* compatibility (eg. if these symbols are defined) but should also migrate |
|||
* the same functionality to their own ENGINE-specific control functions that |
|||
* can be "discovered" by calling applications. The fact these control |
|||
* commands wouldn't be "executable" (ie. usable by text-based config) |
|||
* doesn't change the fact that application code can find and use them |
|||
* without requiring per-ENGINE hacking. |
|||
*/ |
|||
|
|||
/*
|
|||
* These flags are used to tell the ctrl function what should be done. All |
|||
* command numbers are shared between all engines, even if some don't make |
|||
* sense to some engines. In such a case, they do nothing but return the |
|||
* error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. |
|||
*/ |
|||
# define ENGINE_CTRL_SET_LOGSTREAM 1 |
|||
# define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2 |
|||
# define ENGINE_CTRL_HUP 3/* Close and reinitialise |
|||
* any handles/connections |
|||
* etc. */ |
|||
# define ENGINE_CTRL_SET_USER_INTERFACE 4/* Alternative to callback */ |
|||
# define ENGINE_CTRL_SET_CALLBACK_DATA 5/* User-specific data, used |
|||
* when calling the password |
|||
* callback and the user |
|||
* interface */ |
|||
# define ENGINE_CTRL_LOAD_CONFIGURATION 6/* Load a configuration, |
|||
* given a string that |
|||
* represents a file name |
|||
* or so */ |
|||
# define ENGINE_CTRL_LOAD_SECTION 7/* Load data from a given |
|||
* section in the already |
|||
* loaded configuration */ |
|||
|
|||
/*
|
|||
* These control commands allow an application to deal with an arbitrary |
|||
* engine in a dynamic way. Warn: Negative return values indicate errors FOR |
|||
* THESE COMMANDS because zero is used to indicate 'end-of-list'. Other |
|||
* commands, including ENGINE-specific command types, return zero for an |
|||
* error. An ENGINE can choose to implement these ctrl functions, and can |
|||
* internally manage things however it chooses - it does so by setting the |
|||
* ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise |
|||
* the ENGINE_ctrl() code handles this on the ENGINE's behalf using the |
|||
* cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's |
|||
* ctrl() handler need only implement its own commands - the above "meta" |
|||
* commands will be taken care of. |
|||
*/ |
|||
|
|||
/*
|
|||
* Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not", |
|||
* then all the remaining control commands will return failure, so it is |
|||
* worth checking this first if the caller is trying to "discover" the |
|||
* engine's capabilities and doesn't want errors generated unnecessarily. |
|||
*/ |
|||
# define ENGINE_CTRL_HAS_CTRL_FUNCTION 10 |
|||
/*
|
|||
* Returns a positive command number for the first command supported by the |
|||
* engine. Returns zero if no ctrl commands are supported. |
|||
*/ |
|||
# define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11 |
|||
/*
|
|||
* The 'long' argument specifies a command implemented by the engine, and the |
|||
* return value is the next command supported, or zero if there are no more. |
|||
*/ |
|||
# define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12 |
|||
/*
|
|||
* The 'void*' argument is a command name (cast from 'const char *'), and the |
|||
* return value is the command that corresponds to it. |
|||
*/ |
|||
# define ENGINE_CTRL_GET_CMD_FROM_NAME 13 |
|||
/*
|
|||
* The next two allow a command to be converted into its corresponding string |
|||
* form. In each case, the 'long' argument supplies the command. In the |
|||
* NAME_LEN case, the return value is the length of the command name (not |
|||
* counting a trailing EOL). In the NAME case, the 'void*' argument must be a |
|||
* string buffer large enough, and it will be populated with the name of the |
|||
* command (WITH a trailing EOL). |
|||
*/ |
|||
# define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14 |
|||
# define ENGINE_CTRL_GET_NAME_FROM_CMD 15 |
|||
/* The next two are similar but give a "short description" of a command. */ |
|||
# define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16 |
|||
# define ENGINE_CTRL_GET_DESC_FROM_CMD 17 |
|||
/*
|
|||
* With this command, the return value is the OR'd combination of |
|||
* ENGINE_CMD_FLAG_*** values that indicate what kind of input a given |
|||
* engine-specific ctrl command expects. |
|||
*/ |
|||
# define ENGINE_CTRL_GET_CMD_FLAGS 18 |
|||
|
|||
/*
|
|||
* ENGINE implementations should start the numbering of their own control |
|||
* commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). |
|||
*/ |
|||
# define ENGINE_CMD_BASE 200 |
|||
|
|||
/*
|
|||
* NB: These 2 nCipher "chil" control commands are deprecated, and their |
|||
* functionality is now available through ENGINE-specific control commands |
|||
* (exposed through the above-mentioned 'CMD'-handling). Code using these 2 |
|||
* commands should be migrated to the more general command handling before |
|||
* these are removed. |
|||
*/ |
|||
|
|||
/* Flags specific to the nCipher "chil" engine */ |
|||
# define ENGINE_CTRL_CHIL_SET_FORKCHECK 100 |
|||
/*
|
|||
* Depending on the value of the (long)i argument, this sets or |
|||
* unsets the SimpleForkCheck flag in the CHIL API to enable or |
|||
* disable checking and workarounds for applications that fork(). |
|||
*/ |
|||
# define ENGINE_CTRL_CHIL_NO_LOCKING 101 |
|||
/*
|
|||
* This prevents the initialisation function from providing mutex |
|||
* callbacks to the nCipher library. |
|||
*/ |
|||
|
|||
/*
|
|||
* If an ENGINE supports its own specific control commands and wishes the |
|||
* framework to handle the above 'ENGINE_CMD_***'-manipulation commands on |
|||
* its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN |
|||
* entries to ENGINE_set_cmd_defns(). It should also implement a ctrl() |
|||
* handler that supports the stated commands (ie. the "cmd_num" entries as |
|||
* described by the array). NB: The array must be ordered in increasing order |
|||
* of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element |
|||
* has cmd_num set to zero and/or cmd_name set to NULL. |
|||
*/ |
|||
typedef struct ENGINE_CMD_DEFN_st { |
|||
unsigned int cmd_num; /* The command number */ |
|||
const char *cmd_name; /* The command name itself */ |
|||
const char *cmd_desc; /* A short description of the command */ |
|||
unsigned int cmd_flags; /* The input the command expects */ |
|||
} ENGINE_CMD_DEFN; |
|||
|
|||
/* Generic function pointer */ |
|||
typedef int (*ENGINE_GEN_FUNC_PTR) (void); |
|||
/* Generic function pointer taking no arguments */ |
|||
typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *); |
|||
/* Specific control function pointer */ |
|||
typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *, |
|||
void (*f) (void)); |
|||
/* Generic load_key function pointer */ |
|||
typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *, |
|||
UI_METHOD *ui_method, |
|||
void *callback_data); |
|||
typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl, |
|||
STACK_OF(X509_NAME) *ca_dn, |
|||
X509 **pcert, EVP_PKEY **pkey, |
|||
STACK_OF(X509) **pother, |
|||
UI_METHOD *ui_method, |
|||
void *callback_data); |
|||
/*-
|
|||
* These callback types are for an ENGINE's handler for cipher and digest logic. |
|||
* These handlers have these prototypes; |
|||
* int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid); |
|||
* int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid); |
|||
* Looking at how to implement these handlers in the case of cipher support, if |
|||
* the framework wants the EVP_CIPHER for 'nid', it will call; |
|||
* foo(e, &p_evp_cipher, NULL, nid); (return zero for failure) |
|||
* If the framework wants a list of supported 'nid's, it will call; |
|||
* foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error) |
|||
*/ |
|||
/*
|
|||
* Returns to a pointer to the array of supported cipher 'nid's. If the |
|||
* second parameter is non-NULL it is set to the size of the returned array. |
|||
*/ |
|||
typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **, |
|||
const int **, int); |
|||
typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **, |
|||
int); |
|||
typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **, |
|||
const int **, int); |
|||
typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **, |
|||
const int **, int); |
|||
/*
|
|||
* STRUCTURE functions ... all of these functions deal with pointers to |
|||
* ENGINE structures where the pointers have a "structural reference". This |
|||
* means that their reference is to allowed access to the structure but it |
|||
* does not imply that the structure is functional. To simply increment or |
|||
* decrement the structural reference count, use ENGINE_by_id and |
|||
* ENGINE_free. NB: This is not required when iterating using ENGINE_get_next |
|||
* as it will automatically decrement the structural reference count of the |
|||
* "current" ENGINE and increment the structural reference count of the |
|||
* ENGINE it returns (unless it is NULL). |
|||
*/ |
|||
|
|||
/* Get the first/last "ENGINE" type available. */ |
|||
ENGINE *ENGINE_get_first(void); |
|||
ENGINE *ENGINE_get_last(void); |
|||
/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */ |
|||
ENGINE *ENGINE_get_next(ENGINE *e); |
|||
ENGINE *ENGINE_get_prev(ENGINE *e); |
|||
/* Add another "ENGINE" type into the array. */ |
|||
int ENGINE_add(ENGINE *e); |
|||
/* Remove an existing "ENGINE" type from the array. */ |
|||
int ENGINE_remove(ENGINE *e); |
|||
/* Retrieve an engine from the list by its unique "id" value. */ |
|||
ENGINE *ENGINE_by_id(const char *id); |
|||
/* Add all the built-in engines. */ |
|||
void ENGINE_load_openssl(void); |
|||
void ENGINE_load_dynamic(void); |
|||
# ifndef OPENSSL_NO_STATIC_ENGINE |
|||
void ENGINE_load_4758cca(void); |
|||
void ENGINE_load_aep(void); |
|||
void ENGINE_load_atalla(void); |
|||
void ENGINE_load_chil(void); |
|||
void ENGINE_load_cswift(void); |
|||
void ENGINE_load_nuron(void); |
|||
void ENGINE_load_sureware(void); |
|||
void ENGINE_load_ubsec(void); |
|||
void ENGINE_load_padlock(void); |
|||
void ENGINE_load_capi(void); |
|||
# ifndef OPENSSL_NO_GMP |
|||
void ENGINE_load_gmp(void); |
|||
# endif |
|||
# ifndef OPENSSL_NO_GOST |
|||
void ENGINE_load_gost(void); |
|||
# endif |
|||
# endif |
|||
void ENGINE_load_cryptodev(void); |
|||
void ENGINE_load_rsax(void); |
|||
void ENGINE_load_rdrand(void); |
|||
void ENGINE_load_builtin_engines(void); |
|||
|
|||
/*
|
|||
* Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation |
|||
* "registry" handling. |
|||
*/ |
|||
unsigned int ENGINE_get_table_flags(void); |
|||
void ENGINE_set_table_flags(unsigned int flags); |
|||
|
|||
/*- Manage registration of ENGINEs per "table". For each type, there are 3
|
|||
* functions; |
|||
* ENGINE_register_***(e) - registers the implementation from 'e' (if it has one) |
|||
* ENGINE_unregister_***(e) - unregister the implementation from 'e' |
|||
* ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list |
|||
* Cleanup is automatically registered from each table when required, so |
|||
* ENGINE_cleanup() will reverse any "register" operations. |
|||
*/ |
|||
|
|||
int ENGINE_register_RSA(ENGINE *e); |
|||
void ENGINE_unregister_RSA(ENGINE *e); |
|||
void ENGINE_register_all_RSA(void); |
|||
|
|||
int ENGINE_register_DSA(ENGINE *e); |
|||
void ENGINE_unregister_DSA(ENGINE *e); |
|||
void ENGINE_register_all_DSA(void); |
|||
|
|||
int ENGINE_register_ECDH(ENGINE *e); |
|||
void ENGINE_unregister_ECDH(ENGINE *e); |
|||
void ENGINE_register_all_ECDH(void); |
|||
|
|||
int ENGINE_register_ECDSA(ENGINE *e); |
|||
void ENGINE_unregister_ECDSA(ENGINE *e); |
|||
void ENGINE_register_all_ECDSA(void); |
|||
|
|||
int ENGINE_register_DH(ENGINE *e); |
|||
void ENGINE_unregister_DH(ENGINE *e); |
|||
void ENGINE_register_all_DH(void); |
|||
|
|||
int ENGINE_register_RAND(ENGINE *e); |
|||
void ENGINE_unregister_RAND(ENGINE *e); |
|||
void ENGINE_register_all_RAND(void); |
|||
|
|||
int ENGINE_register_STORE(ENGINE *e); |
|||
void ENGINE_unregister_STORE(ENGINE *e); |
|||
void ENGINE_register_all_STORE(void); |
|||
|
|||
int ENGINE_register_ciphers(ENGINE *e); |
|||
void ENGINE_unregister_ciphers(ENGINE *e); |
|||
void ENGINE_register_all_ciphers(void); |
|||
|
|||
int ENGINE_register_digests(ENGINE *e); |
|||
void ENGINE_unregister_digests(ENGINE *e); |
|||
void ENGINE_register_all_digests(void); |
|||
|
|||
int ENGINE_register_pkey_meths(ENGINE *e); |
|||
void ENGINE_unregister_pkey_meths(ENGINE *e); |
|||
void ENGINE_register_all_pkey_meths(void); |
|||
|
|||
int ENGINE_register_pkey_asn1_meths(ENGINE *e); |
|||
void ENGINE_unregister_pkey_asn1_meths(ENGINE *e); |
|||
void ENGINE_register_all_pkey_asn1_meths(void); |
|||
|
|||
/*
|
|||
* These functions register all support from the above categories. Note, use |
|||
* of these functions can result in static linkage of code your application |
|||
* may not need. If you only need a subset of functionality, consider using |
|||
* more selective initialisation. |
|||
*/ |
|||
int ENGINE_register_complete(ENGINE *e); |
|||
int ENGINE_register_all_complete(void); |
|||
|
|||
/*
|
|||
* Send parametrised control commands to the engine. The possibilities to |
|||
* send down an integer, a pointer to data or a function pointer are |
|||
* provided. Any of the parameters may or may not be NULL, depending on the |
|||
* command number. In actuality, this function only requires a structural |
|||
* (rather than functional) reference to an engine, but many control commands |
|||
* may require the engine be functional. The caller should be aware of trying |
|||
* commands that require an operational ENGINE, and only use functional |
|||
* references in such situations. |
|||
*/ |
|||
int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)); |
|||
|
|||
/*
|
|||
* This function tests if an ENGINE-specific command is usable as a |
|||
* "setting". Eg. in an application's config file that gets processed through |
|||
* ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to |
|||
* ENGINE_ctrl_cmd_string(), only ENGINE_ctrl(). |
|||
*/ |
|||
int ENGINE_cmd_is_executable(ENGINE *e, int cmd); |
|||
|
|||
/*
|
|||
* This function works like ENGINE_ctrl() with the exception of taking a |
|||
* command name instead of a command number, and can handle optional |
|||
* commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation |
|||
* on how to use the cmd_name and cmd_optional. |
|||
*/ |
|||
int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name, |
|||
long i, void *p, void (*f) (void), int cmd_optional); |
|||
|
|||
/*
|
|||
* This function passes a command-name and argument to an ENGINE. The |
|||
* cmd_name is converted to a command number and the control command is |
|||
* called using 'arg' as an argument (unless the ENGINE doesn't support such |
|||
* a command, in which case no control command is called). The command is |
|||
* checked for input flags, and if necessary the argument will be converted |
|||
* to a numeric value. If cmd_optional is non-zero, then if the ENGINE |
|||
* doesn't support the given cmd_name the return value will be success |
|||
* anyway. This function is intended for applications to use so that users |
|||
* (or config files) can supply engine-specific config data to the ENGINE at |
|||
* run-time to control behaviour of specific engines. As such, it shouldn't |
|||
* be used for calling ENGINE_ctrl() functions that return data, deal with |
|||
* binary data, or that are otherwise supposed to be used directly through |
|||
* ENGINE_ctrl() in application code. Any "return" data from an ENGINE_ctrl() |
|||
* operation in this function will be lost - the return value is interpreted |
|||
* as failure if the return value is zero, success otherwise, and this |
|||
* function returns a boolean value as a result. In other words, vendors of |
|||
* 'ENGINE'-enabled devices should write ENGINE implementations with |
|||
* parameterisations that work in this scheme, so that compliant ENGINE-based |
|||
* applications can work consistently with the same configuration for the |
|||
* same ENGINE-enabled devices, across applications. |
|||
*/ |
|||
int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg, |
|||
int cmd_optional); |
|||
|
|||
/*
|
|||
* These functions are useful for manufacturing new ENGINE structures. They |
|||
* don't address reference counting at all - one uses them to populate an |
|||
* ENGINE structure with personalised implementations of things prior to |
|||
* using it directly or adding it to the builtin ENGINE list in OpenSSL. |
|||
* These are also here so that the ENGINE structure doesn't have to be |
|||
* exposed and break binary compatibility! |
|||
*/ |
|||
ENGINE *ENGINE_new(void); |
|||
int ENGINE_free(ENGINE *e); |
|||
int ENGINE_up_ref(ENGINE *e); |
|||
int ENGINE_set_id(ENGINE *e, const char *id); |
|||
int ENGINE_set_name(ENGINE *e, const char *name); |
|||
int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth); |
|||
int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth); |
|||
int ENGINE_set_ECDH(ENGINE *e, const ECDH_METHOD *ecdh_meth); |
|||
int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *ecdsa_meth); |
|||
int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); |
|||
int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); |
|||
int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *store_meth); |
|||
int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); |
|||
int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); |
|||
int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); |
|||
int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f); |
|||
int ENGINE_set_load_privkey_function(ENGINE *e, |
|||
ENGINE_LOAD_KEY_PTR loadpriv_f); |
|||
int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f); |
|||
int ENGINE_set_load_ssl_client_cert_function(ENGINE *e, |
|||
ENGINE_SSL_CLIENT_CERT_PTR |
|||
loadssl_f); |
|||
int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f); |
|||
int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f); |
|||
int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f); |
|||
int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f); |
|||
int ENGINE_set_flags(ENGINE *e, int flags); |
|||
int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns); |
|||
/* These functions allow control over any per-structure ENGINE data. */ |
|||
int ENGINE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, |
|||
CRYPTO_EX_dup *dup_func, |
|||
CRYPTO_EX_free *free_func); |
|||
int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg); |
|||
void *ENGINE_get_ex_data(const ENGINE *e, int idx); |
|||
|
|||
/*
|
|||
* This function cleans up anything that needs it. Eg. the ENGINE_add() |
|||
* function automatically ensures the list cleanup function is registered to |
|||
* be called from ENGINE_cleanup(). Similarly, all ENGINE_register_*** |
|||
* functions ensure ENGINE_cleanup() will clean up after them. |
|||
*/ |
|||
void ENGINE_cleanup(void); |
|||
|
|||
/*
|
|||
* These return values from within the ENGINE structure. These can be useful |
|||
* with functional references as well as structural references - it depends |
|||
* which you obtained. Using the result for functional purposes if you only |
|||
* obtained a structural reference may be problematic! |
|||
*/ |
|||
const char *ENGINE_get_id(const ENGINE *e); |
|||
const char *ENGINE_get_name(const ENGINE *e); |
|||
const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e); |
|||
const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e); |
|||
const ECDH_METHOD *ENGINE_get_ECDH(const ENGINE *e); |
|||
const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e); |
|||
const DH_METHOD *ENGINE_get_DH(const ENGINE *e); |
|||
const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); |
|||
const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e); |
|||
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); |
|||
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); |
|||
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); |
|||
ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e); |
|||
ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e); |
|||
ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e); |
|||
ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE |
|||
*e); |
|||
ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e); |
|||
ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e); |
|||
ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e); |
|||
ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e); |
|||
const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid); |
|||
const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid); |
|||
const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid); |
|||
const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid); |
|||
const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e, |
|||
const char *str, |
|||
int len); |
|||
const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe, |
|||
const char *str, |
|||
int len); |
|||
const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e); |
|||
int ENGINE_get_flags(const ENGINE *e); |
|||
|
|||
/*
|
|||
* FUNCTIONAL functions. These functions deal with ENGINE structures that |
|||
* have (or will) be initialised for use. Broadly speaking, the structural |
|||
* functions are useful for iterating the list of available engine types, |
|||
* creating new engine types, and other "list" operations. These functions |
|||
* actually deal with ENGINEs that are to be used. As such these functions |
|||
* can fail (if applicable) when particular engines are unavailable - eg. if |
|||
* a hardware accelerator is not attached or not functioning correctly. Each |
|||
* ENGINE has 2 reference counts; structural and functional. Every time a |
|||
* functional reference is obtained or released, a corresponding structural |
|||
* reference is automatically obtained or released too. |
|||
*/ |
|||
|
|||
/*
|
|||
* Initialise a engine type for use (or up its reference count if it's |
|||
* already in use). This will fail if the engine is not currently operational |
|||
* and cannot initialise. |
|||
*/ |
|||
int ENGINE_init(ENGINE *e); |
|||
/*
|
|||
* Free a functional reference to a engine type. This does not require a |
|||
* corresponding call to ENGINE_free as it also releases a structural |
|||
* reference. |
|||
*/ |
|||
int ENGINE_finish(ENGINE *e); |
|||
|
|||
/*
|
|||
* The following functions handle keys that are stored in some secondary |
|||
* location, handled by the engine. The storage may be on a card or |
|||
* whatever. |
|||
*/ |
|||
EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id, |
|||
UI_METHOD *ui_method, void *callback_data); |
|||
EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id, |
|||
UI_METHOD *ui_method, void *callback_data); |
|||
int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, |
|||
STACK_OF(X509_NAME) *ca_dn, X509 **pcert, |
|||
EVP_PKEY **ppkey, STACK_OF(X509) **pother, |
|||
UI_METHOD *ui_method, void *callback_data); |
|||
|
|||
/*
|
|||
* This returns a pointer for the current ENGINE structure that is (by |
|||
* default) performing any RSA operations. The value returned is an |
|||
* incremented reference, so it should be free'd (ENGINE_finish) before it is |
|||
* discarded. |
|||
*/ |
|||
ENGINE *ENGINE_get_default_RSA(void); |
|||
/* Same for the other "methods" */ |
|||
ENGINE *ENGINE_get_default_DSA(void); |
|||
ENGINE *ENGINE_get_default_ECDH(void); |
|||
ENGINE *ENGINE_get_default_ECDSA(void); |
|||
ENGINE *ENGINE_get_default_DH(void); |
|||
ENGINE *ENGINE_get_default_RAND(void); |
|||
/*
|
|||
* These functions can be used to get a functional reference to perform |
|||
* ciphering or digesting corresponding to "nid". |
|||
*/ |
|||
ENGINE *ENGINE_get_cipher_engine(int nid); |
|||
ENGINE *ENGINE_get_digest_engine(int nid); |
|||
ENGINE *ENGINE_get_pkey_meth_engine(int nid); |
|||
ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid); |
|||
|
|||
/*
|
|||
* This sets a new default ENGINE structure for performing RSA operations. If |
|||
* the result is non-zero (success) then the ENGINE structure will have had |
|||
* its reference count up'd so the caller should still free their own |
|||
* reference 'e'. |
|||
*/ |
|||
int ENGINE_set_default_RSA(ENGINE *e); |
|||
int ENGINE_set_default_string(ENGINE *e, const char *def_list); |
|||
/* Same for the other "methods" */ |
|||
int ENGINE_set_default_DSA(ENGINE *e); |
|||
int ENGINE_set_default_ECDH(ENGINE *e); |
|||
int ENGINE_set_default_ECDSA(ENGINE *e); |
|||
int ENGINE_set_default_DH(ENGINE *e); |
|||
int ENGINE_set_default_RAND(ENGINE *e); |
|||
int ENGINE_set_default_ciphers(ENGINE *e); |
|||
int ENGINE_set_default_digests(ENGINE *e); |
|||
int ENGINE_set_default_pkey_meths(ENGINE *e); |
|||
int ENGINE_set_default_pkey_asn1_meths(ENGINE *e); |
|||
|
|||
/*
|
|||
* The combination "set" - the flags are bitwise "OR"d from the |
|||
* ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()" |
|||
* function, this function can result in unnecessary static linkage. If your |
|||
* application requires only specific functionality, consider using more |
|||
* selective functions. |
|||
*/ |
|||
int ENGINE_set_default(ENGINE *e, unsigned int flags); |
|||
|
|||
void ENGINE_add_conf_module(void); |
|||
|
|||
/* Deprecated functions ... */ |
|||
/* int ENGINE_clear_defaults(void); */ |
|||
|
|||
/**************************/ |
|||
/* DYNAMIC ENGINE SUPPORT */ |
|||
/**************************/ |
|||
|
|||
/* Binary/behaviour compatibility levels */ |
|||
# define OSSL_DYNAMIC_VERSION (unsigned long)0x00020000 |
|||
/*
|
|||
* Binary versions older than this are too old for us (whether we're a loader |
|||
* or a loadee) |
|||
*/ |
|||
# define OSSL_DYNAMIC_OLDEST (unsigned long)0x00020000 |
|||
|
|||
/*
|
|||
* When compiling an ENGINE entirely as an external shared library, loadable |
|||
* by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' |
|||
* structure type provides the calling application's (or library's) error |
|||
* functionality and memory management function pointers to the loaded |
|||
* library. These should be used/set in the loaded library code so that the |
|||
* loading application's 'state' will be used/changed in all operations. The |
|||
* 'static_state' pointer allows the loaded library to know if it shares the |
|||
* same static data as the calling application (or library), and thus whether |
|||
* these callbacks need to be set or not. |
|||
*/ |
|||
typedef void *(*dyn_MEM_malloc_cb) (size_t); |
|||
typedef void *(*dyn_MEM_realloc_cb) (void *, size_t); |
|||
typedef void (*dyn_MEM_free_cb) (void *); |
|||
typedef struct st_dynamic_MEM_fns { |
|||
dyn_MEM_malloc_cb malloc_cb; |
|||
dyn_MEM_realloc_cb realloc_cb; |
|||
dyn_MEM_free_cb free_cb; |
|||
} dynamic_MEM_fns; |
|||
/*
|
|||
* FIXME: Perhaps the memory and locking code (crypto.h) should declare and |
|||
* use these types so we (and any other dependant code) can simplify a bit?? |
|||
*/ |
|||
typedef void (*dyn_lock_locking_cb) (int, int, const char *, int); |
|||
typedef int (*dyn_lock_add_lock_cb) (int *, int, int, const char *, int); |
|||
typedef struct CRYPTO_dynlock_value *(*dyn_dynlock_create_cb) (const char *, |
|||
int); |
|||
typedef void (*dyn_dynlock_lock_cb) (int, struct CRYPTO_dynlock_value *, |
|||
const char *, int); |
|||
typedef void (*dyn_dynlock_destroy_cb) (struct CRYPTO_dynlock_value *, |
|||
const char *, int); |
|||
typedef struct st_dynamic_LOCK_fns { |
|||
dyn_lock_locking_cb lock_locking_cb; |
|||
dyn_lock_add_lock_cb lock_add_lock_cb; |
|||
dyn_dynlock_create_cb dynlock_create_cb; |
|||
dyn_dynlock_lock_cb dynlock_lock_cb; |
|||
dyn_dynlock_destroy_cb dynlock_destroy_cb; |
|||
} dynamic_LOCK_fns; |
|||
/* The top-level structure */ |
|||
typedef struct st_dynamic_fns { |
|||
void *static_state; |
|||
const ERR_FNS *err_fns; |
|||
const CRYPTO_EX_DATA_IMPL *ex_data_fns; |
|||
dynamic_MEM_fns mem_fns; |
|||
dynamic_LOCK_fns lock_fns; |
|||
} dynamic_fns; |
|||
|
|||
/*
|
|||
* The version checking function should be of this prototype. NB: The |
|||
* ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading |
|||
* code. If this function returns zero, it indicates a (potential) version |
|||
* incompatibility and the loaded library doesn't believe it can proceed. |
|||
* Otherwise, the returned value is the (latest) version supported by the |
|||
* loading library. The loader may still decide that the loaded code's |
|||
* version is unsatisfactory and could veto the load. The function is |
|||
* expected to be implemented with the symbol name "v_check", and a default |
|||
* implementation can be fully instantiated with |
|||
* IMPLEMENT_DYNAMIC_CHECK_FN(). |
|||
*/ |
|||
typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version); |
|||
# define IMPLEMENT_DYNAMIC_CHECK_FN() \ |
|||
OPENSSL_EXPORT unsigned long v_check(unsigned long v); \ |
|||
OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \ |
|||
if(v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \ |
|||
return 0; } |
|||
|
|||
/*
|
|||
* This function is passed the ENGINE structure to initialise with its own |
|||
* function and command settings. It should not adjust the structural or |
|||
* functional reference counts. If this function returns zero, (a) the load |
|||
* will be aborted, (b) the previous ENGINE state will be memcpy'd back onto |
|||
* the structure, and (c) the shared library will be unloaded. So |
|||
* implementations should do their own internal cleanup in failure |
|||
* circumstances otherwise they could leak. The 'id' parameter, if non-NULL, |
|||
* represents the ENGINE id that the loader is looking for. If this is NULL, |
|||
* the shared library can choose to return failure or to initialise a |
|||
* 'default' ENGINE. If non-NULL, the shared library must initialise only an |
|||
* ENGINE matching the passed 'id'. The function is expected to be |
|||
* implemented with the symbol name "bind_engine". A standard implementation |
|||
* can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter |
|||
* 'fn' is a callback function that populates the ENGINE structure and |
|||
* returns an int value (zero for failure). 'fn' should have prototype; |
|||
* [static] int fn(ENGINE *e, const char *id); |
|||
*/ |
|||
typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id, |
|||
const dynamic_fns *fns); |
|||
# define IMPLEMENT_DYNAMIC_BIND_FN(fn) \ |
|||
OPENSSL_EXPORT \ |
|||
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \ |
|||
OPENSSL_EXPORT \ |
|||
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \ |
|||
if(ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \ |
|||
if(!CRYPTO_set_mem_functions(fns->mem_fns.malloc_cb, \ |
|||
fns->mem_fns.realloc_cb, fns->mem_fns.free_cb)) \ |
|||
return 0; \ |
|||
CRYPTO_set_locking_callback(fns->lock_fns.lock_locking_cb); \ |
|||
CRYPTO_set_add_lock_callback(fns->lock_fns.lock_add_lock_cb); \ |
|||
CRYPTO_set_dynlock_create_callback(fns->lock_fns.dynlock_create_cb); \ |
|||
CRYPTO_set_dynlock_lock_callback(fns->lock_fns.dynlock_lock_cb); \ |
|||
CRYPTO_set_dynlock_destroy_callback(fns->lock_fns.dynlock_destroy_cb); \ |
|||
if(!CRYPTO_set_ex_data_implementation(fns->ex_data_fns)) \ |
|||
return 0; \ |
|||
if(!ERR_set_implementation(fns->err_fns)) return 0; \ |
|||
skip_cbs: \ |
|||
if(!fn(e,id)) return 0; \ |
|||
return 1; } |
|||
|
|||
/*
|
|||
* If the loading application (or library) and the loaded ENGINE library |
|||
* share the same static data (eg. they're both dynamically linked to the |
|||
* same libcrypto.so) we need a way to avoid trying to set system callbacks - |
|||
* this would fail, and for the same reason that it's unnecessary to try. If |
|||
* the loaded ENGINE has (or gets from through the loader) its own copy of |
|||
* the libcrypto static data, we will need to set the callbacks. The easiest |
|||
* way to detect this is to have a function that returns a pointer to some |
|||
* static data and let the loading application and loaded ENGINE compare |
|||
* their respective values. |
|||
*/ |
|||
void *ENGINE_get_static_state(void); |
|||
|
|||
# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) |
|||
void ENGINE_setup_bsd_cryptodev(void); |
|||
# endif |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_ENGINE_strings(void); |
|||
|
|||
/* Error codes for the ENGINE functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define ENGINE_F_DYNAMIC_CTRL 180 |
|||
# define ENGINE_F_DYNAMIC_GET_DATA_CTX 181 |
|||
# define ENGINE_F_DYNAMIC_LOAD 182 |
|||
# define ENGINE_F_DYNAMIC_SET_DATA_CTX 183 |
|||
# define ENGINE_F_ENGINE_ADD 105 |
|||
# define ENGINE_F_ENGINE_BY_ID 106 |
|||
# define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 170 |
|||
# define ENGINE_F_ENGINE_CTRL 142 |
|||
# define ENGINE_F_ENGINE_CTRL_CMD 178 |
|||
# define ENGINE_F_ENGINE_CTRL_CMD_STRING 171 |
|||
# define ENGINE_F_ENGINE_FINISH 107 |
|||
# define ENGINE_F_ENGINE_FREE_UTIL 108 |
|||
# define ENGINE_F_ENGINE_GET_CIPHER 185 |
|||
# define ENGINE_F_ENGINE_GET_DEFAULT_TYPE 177 |
|||
# define ENGINE_F_ENGINE_GET_DIGEST 186 |
|||
# define ENGINE_F_ENGINE_GET_NEXT 115 |
|||
# define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 193 |
|||
# define ENGINE_F_ENGINE_GET_PKEY_METH 192 |
|||
# define ENGINE_F_ENGINE_GET_PREV 116 |
|||
# define ENGINE_F_ENGINE_INIT 119 |
|||
# define ENGINE_F_ENGINE_LIST_ADD 120 |
|||
# define ENGINE_F_ENGINE_LIST_REMOVE 121 |
|||
# define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 150 |
|||
# define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 151 |
|||
# define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 194 |
|||
# define ENGINE_F_ENGINE_NEW 122 |
|||
# define ENGINE_F_ENGINE_REMOVE 123 |
|||
# define ENGINE_F_ENGINE_SET_DEFAULT_STRING 189 |
|||
# define ENGINE_F_ENGINE_SET_DEFAULT_TYPE 126 |
|||
# define ENGINE_F_ENGINE_SET_ID 129 |
|||
# define ENGINE_F_ENGINE_SET_NAME 130 |
|||
# define ENGINE_F_ENGINE_TABLE_REGISTER 184 |
|||
# define ENGINE_F_ENGINE_UNLOAD_KEY 152 |
|||
# define ENGINE_F_ENGINE_UNLOCKED_FINISH 191 |
|||
# define ENGINE_F_ENGINE_UP_REF 190 |
|||
# define ENGINE_F_INT_CTRL_HELPER 172 |
|||
# define ENGINE_F_INT_ENGINE_CONFIGURE 188 |
|||
# define ENGINE_F_INT_ENGINE_MODULE_INIT 187 |
|||
# define ENGINE_F_LOG_MESSAGE 141 |
|||
|
|||
/* Reason codes. */ |
|||
# define ENGINE_R_ALREADY_LOADED 100 |
|||
# define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133 |
|||
# define ENGINE_R_CMD_NOT_EXECUTABLE 134 |
|||
# define ENGINE_R_COMMAND_TAKES_INPUT 135 |
|||
# define ENGINE_R_COMMAND_TAKES_NO_INPUT 136 |
|||
# define ENGINE_R_CONFLICTING_ENGINE_ID 103 |
|||
# define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119 |
|||
# define ENGINE_R_DH_NOT_IMPLEMENTED 139 |
|||
# define ENGINE_R_DSA_NOT_IMPLEMENTED 140 |
|||
# define ENGINE_R_DSO_FAILURE 104 |
|||
# define ENGINE_R_DSO_NOT_FOUND 132 |
|||
# define ENGINE_R_ENGINES_SECTION_ERROR 148 |
|||
# define ENGINE_R_ENGINE_CONFIGURATION_ERROR 102 |
|||
# define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105 |
|||
# define ENGINE_R_ENGINE_SECTION_ERROR 149 |
|||
# define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128 |
|||
# define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129 |
|||
# define ENGINE_R_FINISH_FAILED 106 |
|||
# define ENGINE_R_GET_HANDLE_FAILED 107 |
|||
# define ENGINE_R_ID_OR_NAME_MISSING 108 |
|||
# define ENGINE_R_INIT_FAILED 109 |
|||
# define ENGINE_R_INTERNAL_LIST_ERROR 110 |
|||
# define ENGINE_R_INVALID_ARGUMENT 143 |
|||
# define ENGINE_R_INVALID_CMD_NAME 137 |
|||
# define ENGINE_R_INVALID_CMD_NUMBER 138 |
|||
# define ENGINE_R_INVALID_INIT_VALUE 151 |
|||
# define ENGINE_R_INVALID_STRING 150 |
|||
# define ENGINE_R_NOT_INITIALISED 117 |
|||
# define ENGINE_R_NOT_LOADED 112 |
|||
# define ENGINE_R_NO_CONTROL_FUNCTION 120 |
|||
# define ENGINE_R_NO_INDEX 144 |
|||
# define ENGINE_R_NO_LOAD_FUNCTION 125 |
|||
# define ENGINE_R_NO_REFERENCE 130 |
|||
# define ENGINE_R_NO_SUCH_ENGINE 116 |
|||
# define ENGINE_R_NO_UNLOAD_FUNCTION 126 |
|||
# define ENGINE_R_PROVIDE_PARAMETERS 113 |
|||
# define ENGINE_R_RSA_NOT_IMPLEMENTED 141 |
|||
# define ENGINE_R_UNIMPLEMENTED_CIPHER 146 |
|||
# define ENGINE_R_UNIMPLEMENTED_DIGEST 147 |
|||
# define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101 |
|||
# define ENGINE_R_VERSION_INCOMPATIBILITY 145 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,389 +0,0 @@ |
|||
/* crypto/err/err.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_ERR_H |
|||
# define HEADER_ERR_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
# include <stdio.h> |
|||
# include <stdlib.h> |
|||
# endif |
|||
|
|||
# include <openssl/ossl_typ.h> |
|||
# ifndef OPENSSL_NO_BIO |
|||
# include <openssl/bio.h> |
|||
# endif |
|||
# ifndef OPENSSL_NO_LHASH |
|||
# include <openssl/lhash.h> |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifndef OPENSSL_NO_ERR |
|||
# define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,d,e) |
|||
# else |
|||
# define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,NULL,0) |
|||
# endif |
|||
|
|||
# include <errno.h> |
|||
|
|||
# define ERR_TXT_MALLOCED 0x01 |
|||
# define ERR_TXT_STRING 0x02 |
|||
|
|||
# define ERR_FLAG_MARK 0x01 |
|||
|
|||
# define ERR_NUM_ERRORS 16 |
|||
typedef struct err_state_st { |
|||
CRYPTO_THREADID tid; |
|||
int err_flags[ERR_NUM_ERRORS]; |
|||
unsigned long err_buffer[ERR_NUM_ERRORS]; |
|||
char *err_data[ERR_NUM_ERRORS]; |
|||
int err_data_flags[ERR_NUM_ERRORS]; |
|||
const char *err_file[ERR_NUM_ERRORS]; |
|||
int err_line[ERR_NUM_ERRORS]; |
|||
int top, bottom; |
|||
} ERR_STATE; |
|||
|
|||
/* library */ |
|||
# define ERR_LIB_NONE 1 |
|||
# define ERR_LIB_SYS 2 |
|||
# define ERR_LIB_BN 3 |
|||
# define ERR_LIB_RSA 4 |
|||
# define ERR_LIB_DH 5 |
|||
# define ERR_LIB_EVP 6 |
|||
# define ERR_LIB_BUF 7 |
|||
# define ERR_LIB_OBJ 8 |
|||
# define ERR_LIB_PEM 9 |
|||
# define ERR_LIB_DSA 10 |
|||
# define ERR_LIB_X509 11 |
|||
/* #define ERR_LIB_METH 12 */ |
|||
# define ERR_LIB_ASN1 13 |
|||
# define ERR_LIB_CONF 14 |
|||
# define ERR_LIB_CRYPTO 15 |
|||
# define ERR_LIB_EC 16 |
|||
# define ERR_LIB_SSL 20 |
|||
/* #define ERR_LIB_SSL23 21 */ |
|||
/* #define ERR_LIB_SSL2 22 */ |
|||
/* #define ERR_LIB_SSL3 23 */ |
|||
/* #define ERR_LIB_RSAREF 30 */ |
|||
/* #define ERR_LIB_PROXY 31 */ |
|||
# define ERR_LIB_BIO 32 |
|||
# define ERR_LIB_PKCS7 33 |
|||
# define ERR_LIB_X509V3 34 |
|||
# define ERR_LIB_PKCS12 35 |
|||
# define ERR_LIB_RAND 36 |
|||
# define ERR_LIB_DSO 37 |
|||
# define ERR_LIB_ENGINE 38 |
|||
# define ERR_LIB_OCSP 39 |
|||
# define ERR_LIB_UI 40 |
|||
# define ERR_LIB_COMP 41 |
|||
# define ERR_LIB_ECDSA 42 |
|||
# define ERR_LIB_ECDH 43 |
|||
# define ERR_LIB_STORE 44 |
|||
# define ERR_LIB_FIPS 45 |
|||
# define ERR_LIB_CMS 46 |
|||
# define ERR_LIB_TS 47 |
|||
# define ERR_LIB_HMAC 48 |
|||
# define ERR_LIB_JPAKE 49 |
|||
|
|||
# define ERR_LIB_USER 128 |
|||
|
|||
# define SYSerr(f,r) ERR_PUT_error(ERR_LIB_SYS,(f),(r),__FILE__,__LINE__) |
|||
# define BNerr(f,r) ERR_PUT_error(ERR_LIB_BN,(f),(r),__FILE__,__LINE__) |
|||
# define RSAerr(f,r) ERR_PUT_error(ERR_LIB_RSA,(f),(r),__FILE__,__LINE__) |
|||
# define DHerr(f,r) ERR_PUT_error(ERR_LIB_DH,(f),(r),__FILE__,__LINE__) |
|||
# define EVPerr(f,r) ERR_PUT_error(ERR_LIB_EVP,(f),(r),__FILE__,__LINE__) |
|||
# define BUFerr(f,r) ERR_PUT_error(ERR_LIB_BUF,(f),(r),__FILE__,__LINE__) |
|||
# define OBJerr(f,r) ERR_PUT_error(ERR_LIB_OBJ,(f),(r),__FILE__,__LINE__) |
|||
# define PEMerr(f,r) ERR_PUT_error(ERR_LIB_PEM,(f),(r),__FILE__,__LINE__) |
|||
# define DSAerr(f,r) ERR_PUT_error(ERR_LIB_DSA,(f),(r),__FILE__,__LINE__) |
|||
# define X509err(f,r) ERR_PUT_error(ERR_LIB_X509,(f),(r),__FILE__,__LINE__) |
|||
# define ASN1err(f,r) ERR_PUT_error(ERR_LIB_ASN1,(f),(r),__FILE__,__LINE__) |
|||
# define CONFerr(f,r) ERR_PUT_error(ERR_LIB_CONF,(f),(r),__FILE__,__LINE__) |
|||
# define CRYPTOerr(f,r) ERR_PUT_error(ERR_LIB_CRYPTO,(f),(r),__FILE__,__LINE__) |
|||
# define ECerr(f,r) ERR_PUT_error(ERR_LIB_EC,(f),(r),__FILE__,__LINE__) |
|||
# define SSLerr(f,r) ERR_PUT_error(ERR_LIB_SSL,(f),(r),__FILE__,__LINE__) |
|||
# define BIOerr(f,r) ERR_PUT_error(ERR_LIB_BIO,(f),(r),__FILE__,__LINE__) |
|||
# define PKCS7err(f,r) ERR_PUT_error(ERR_LIB_PKCS7,(f),(r),__FILE__,__LINE__) |
|||
# define X509V3err(f,r) ERR_PUT_error(ERR_LIB_X509V3,(f),(r),__FILE__,__LINE__) |
|||
# define PKCS12err(f,r) ERR_PUT_error(ERR_LIB_PKCS12,(f),(r),__FILE__,__LINE__) |
|||
# define RANDerr(f,r) ERR_PUT_error(ERR_LIB_RAND,(f),(r),__FILE__,__LINE__) |
|||
# define DSOerr(f,r) ERR_PUT_error(ERR_LIB_DSO,(f),(r),__FILE__,__LINE__) |
|||
# define ENGINEerr(f,r) ERR_PUT_error(ERR_LIB_ENGINE,(f),(r),__FILE__,__LINE__) |
|||
# define OCSPerr(f,r) ERR_PUT_error(ERR_LIB_OCSP,(f),(r),__FILE__,__LINE__) |
|||
# define UIerr(f,r) ERR_PUT_error(ERR_LIB_UI,(f),(r),__FILE__,__LINE__) |
|||
# define COMPerr(f,r) ERR_PUT_error(ERR_LIB_COMP,(f),(r),__FILE__,__LINE__) |
|||
# define ECDSAerr(f,r) ERR_PUT_error(ERR_LIB_ECDSA,(f),(r),__FILE__,__LINE__) |
|||
# define ECDHerr(f,r) ERR_PUT_error(ERR_LIB_ECDH,(f),(r),__FILE__,__LINE__) |
|||
# define STOREerr(f,r) ERR_PUT_error(ERR_LIB_STORE,(f),(r),__FILE__,__LINE__) |
|||
# define FIPSerr(f,r) ERR_PUT_error(ERR_LIB_FIPS,(f),(r),__FILE__,__LINE__) |
|||
# define CMSerr(f,r) ERR_PUT_error(ERR_LIB_CMS,(f),(r),__FILE__,__LINE__) |
|||
# define TSerr(f,r) ERR_PUT_error(ERR_LIB_TS,(f),(r),__FILE__,__LINE__) |
|||
# define HMACerr(f,r) ERR_PUT_error(ERR_LIB_HMAC,(f),(r),__FILE__,__LINE__) |
|||
# define JPAKEerr(f,r) ERR_PUT_error(ERR_LIB_JPAKE,(f),(r),__FILE__,__LINE__) |
|||
|
|||
/*
|
|||
* Borland C seems too stupid to be able to shift and do longs in the |
|||
* pre-processor :-( |
|||
*/ |
|||
# define ERR_PACK(l,f,r) (((((unsigned long)l)&0xffL)*0x1000000)| \ |
|||
((((unsigned long)f)&0xfffL)*0x1000)| \ |
|||
((((unsigned long)r)&0xfffL))) |
|||
# define ERR_GET_LIB(l) (int)((((unsigned long)l)>>24L)&0xffL) |
|||
# define ERR_GET_FUNC(l) (int)((((unsigned long)l)>>12L)&0xfffL) |
|||
# define ERR_GET_REASON(l) (int)((l)&0xfffL) |
|||
# define ERR_FATAL_ERROR(l) (int)((l)&ERR_R_FATAL) |
|||
|
|||
/* OS functions */ |
|||
# define SYS_F_FOPEN 1 |
|||
# define SYS_F_CONNECT 2 |
|||
# define SYS_F_GETSERVBYNAME 3 |
|||
# define SYS_F_SOCKET 4 |
|||
# define SYS_F_IOCTLSOCKET 5 |
|||
# define SYS_F_BIND 6 |
|||
# define SYS_F_LISTEN 7 |
|||
# define SYS_F_ACCEPT 8 |
|||
# define SYS_F_WSASTARTUP 9/* Winsock stuff */ |
|||
# define SYS_F_OPENDIR 10 |
|||
# define SYS_F_FREAD 11 |
|||
|
|||
/* reasons */ |
|||
# define ERR_R_SYS_LIB ERR_LIB_SYS/* 2 */ |
|||
# define ERR_R_BN_LIB ERR_LIB_BN/* 3 */ |
|||
# define ERR_R_RSA_LIB ERR_LIB_RSA/* 4 */ |
|||
# define ERR_R_DH_LIB ERR_LIB_DH/* 5 */ |
|||
# define ERR_R_EVP_LIB ERR_LIB_EVP/* 6 */ |
|||
# define ERR_R_BUF_LIB ERR_LIB_BUF/* 7 */ |
|||
# define ERR_R_OBJ_LIB ERR_LIB_OBJ/* 8 */ |
|||
# define ERR_R_PEM_LIB ERR_LIB_PEM/* 9 */ |
|||
# define ERR_R_DSA_LIB ERR_LIB_DSA/* 10 */ |
|||
# define ERR_R_X509_LIB ERR_LIB_X509/* 11 */ |
|||
# define ERR_R_ASN1_LIB ERR_LIB_ASN1/* 13 */ |
|||
# define ERR_R_CONF_LIB ERR_LIB_CONF/* 14 */ |
|||
# define ERR_R_CRYPTO_LIB ERR_LIB_CRYPTO/* 15 */ |
|||
# define ERR_R_EC_LIB ERR_LIB_EC/* 16 */ |
|||
# define ERR_R_SSL_LIB ERR_LIB_SSL/* 20 */ |
|||
# define ERR_R_BIO_LIB ERR_LIB_BIO/* 32 */ |
|||
# define ERR_R_PKCS7_LIB ERR_LIB_PKCS7/* 33 */ |
|||
# define ERR_R_X509V3_LIB ERR_LIB_X509V3/* 34 */ |
|||
# define ERR_R_PKCS12_LIB ERR_LIB_PKCS12/* 35 */ |
|||
# define ERR_R_RAND_LIB ERR_LIB_RAND/* 36 */ |
|||
# define ERR_R_DSO_LIB ERR_LIB_DSO/* 37 */ |
|||
# define ERR_R_ENGINE_LIB ERR_LIB_ENGINE/* 38 */ |
|||
# define ERR_R_OCSP_LIB ERR_LIB_OCSP/* 39 */ |
|||
# define ERR_R_UI_LIB ERR_LIB_UI/* 40 */ |
|||
# define ERR_R_COMP_LIB ERR_LIB_COMP/* 41 */ |
|||
# define ERR_R_ECDSA_LIB ERR_LIB_ECDSA/* 42 */ |
|||
# define ERR_R_ECDH_LIB ERR_LIB_ECDH/* 43 */ |
|||
# define ERR_R_STORE_LIB ERR_LIB_STORE/* 44 */ |
|||
# define ERR_R_TS_LIB ERR_LIB_TS/* 45 */ |
|||
|
|||
# define ERR_R_NESTED_ASN1_ERROR 58 |
|||
# define ERR_R_BAD_ASN1_OBJECT_HEADER 59 |
|||
# define ERR_R_BAD_GET_ASN1_OBJECT_CALL 60 |
|||
# define ERR_R_EXPECTING_AN_ASN1_SEQUENCE 61 |
|||
# define ERR_R_ASN1_LENGTH_MISMATCH 62 |
|||
# define ERR_R_MISSING_ASN1_EOS 63 |
|||
|
|||
/* fatal error */ |
|||
# define ERR_R_FATAL 64 |
|||
# define ERR_R_MALLOC_FAILURE (1|ERR_R_FATAL) |
|||
# define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED (2|ERR_R_FATAL) |
|||
# define ERR_R_PASSED_NULL_PARAMETER (3|ERR_R_FATAL) |
|||
# define ERR_R_INTERNAL_ERROR (4|ERR_R_FATAL) |
|||
# define ERR_R_DISABLED (5|ERR_R_FATAL) |
|||
|
|||
/*
|
|||
* 99 is the maximum possible ERR_R_... code, higher values are reserved for |
|||
* the individual libraries |
|||
*/ |
|||
|
|||
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); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
void ERR_print_errors_fp(FILE *fp); |
|||
# endif |
|||
# ifndef OPENSSL_NO_BIO |
|||
void ERR_print_errors(BIO *bp); |
|||
# endif |
|||
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); |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
void ERR_remove_state(unsigned long pid); /* if zero we look it up */ |
|||
# endif |
|||
ERR_STATE *ERR_get_state(void); |
|||
|
|||
# ifndef OPENSSL_NO_LHASH |
|||
LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void); |
|||
LHASH_OF(ERR_STATE) *ERR_get_err_state_table(void); |
|||
void ERR_release_err_state_table(LHASH_OF(ERR_STATE) **hash); |
|||
# endif |
|||
|
|||
int ERR_get_next_error_library(void); |
|||
|
|||
int ERR_set_mark(void); |
|||
int ERR_pop_to_mark(void); |
|||
|
|||
/* Already defined in ossl_typ.h */ |
|||
/* typedef struct st_ERR_FNS ERR_FNS; */ |
|||
/*
|
|||
* An application can use this function and provide the return value to |
|||
* loaded modules that should use the application's ERR state/functionality |
|||
*/ |
|||
const ERR_FNS *ERR_get_implementation(void); |
|||
/*
|
|||
* A loaded module should call this function prior to any ERR operations |
|||
* using the application's "ERR_FNS". |
|||
*/ |
|||
int ERR_set_implementation(const ERR_FNS *fns); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
File diff suppressed because it is too large
@ -1,109 +0,0 @@ |
|||
/* crypto/hmac/hmac.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
#ifndef HEADER_HMAC_H |
|||
# define HEADER_HMAC_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifdef OPENSSL_NO_HMAC |
|||
# error HMAC is disabled. |
|||
# endif |
|||
|
|||
# include <openssl/evp.h> |
|||
|
|||
# define HMAC_MAX_MD_CBLOCK 128/* largest known is SHA512 */ |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct hmac_ctx_st { |
|||
const EVP_MD *md; |
|||
EVP_MD_CTX md_ctx; |
|||
EVP_MD_CTX i_ctx; |
|||
EVP_MD_CTX o_ctx; |
|||
unsigned int key_length; |
|||
unsigned char key[HMAC_MAX_MD_CBLOCK]; |
|||
} HMAC_CTX; |
|||
|
|||
# define HMAC_size(e) (EVP_MD_size((e)->md)) |
|||
|
|||
void HMAC_CTX_init(HMAC_CTX *ctx); |
|||
void HMAC_CTX_cleanup(HMAC_CTX *ctx); |
|||
|
|||
/* deprecated */ |
|||
# define HMAC_cleanup(ctx) HMAC_CTX_cleanup(ctx) |
|||
|
|||
/* deprecated */ |
|||
int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md); |
|||
int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, |
|||
const EVP_MD *md, ENGINE *impl); |
|||
int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len); |
|||
int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len); |
|||
unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len, |
|||
const unsigned char *d, size_t n, unsigned char *md, |
|||
unsigned int *md_len); |
|||
int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx); |
|||
|
|||
void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,105 +0,0 @@ |
|||
/* crypto/idea/idea.h */ |
|||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_IDEA_H |
|||
# define HEADER_IDEA_H |
|||
|
|||
# include <openssl/opensslconf.h>/* IDEA_INT, OPENSSL_NO_IDEA */ |
|||
|
|||
# ifdef OPENSSL_NO_IDEA |
|||
# error IDEA is disabled. |
|||
# endif |
|||
|
|||
# define IDEA_ENCRYPT 1 |
|||
# define IDEA_DECRYPT 0 |
|||
|
|||
# define IDEA_BLOCK 8 |
|||
# define IDEA_KEY_LENGTH 16 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct idea_key_st { |
|||
IDEA_INT data[9][6]; |
|||
} IDEA_KEY_SCHEDULE; |
|||
|
|||
const char *idea_options(void); |
|||
void idea_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
IDEA_KEY_SCHEDULE *ks); |
|||
# ifdef OPENSSL_FIPS |
|||
void private_idea_set_encrypt_key(const unsigned char *key, |
|||
IDEA_KEY_SCHEDULE *ks); |
|||
# endif |
|||
void idea_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks); |
|||
void idea_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk); |
|||
void idea_cbc_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, |
|||
int enc); |
|||
void idea_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, |
|||
int *num, int enc); |
|||
void idea_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, |
|||
int *num); |
|||
void idea_encrypt(unsigned long *in, IDEA_KEY_SCHEDULE *ks); |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,240 +0,0 @@ |
|||
/* krb5_asn.h */ |
|||
/*
|
|||
* Written by Vern Staats <staatsvr@asc.hpc.mil> for the OpenSSL project, ** |
|||
* using ocsp/{*.h,*asn*.c} as a starting point |
|||
*/ |
|||
|
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_KRB5_ASN_H |
|||
# define HEADER_KRB5_ASN_H |
|||
|
|||
/*
|
|||
* #include <krb5.h> |
|||
*/ |
|||
# include <openssl/safestack.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/*
|
|||
* ASN.1 from Kerberos RFC 1510 |
|||
*/ |
|||
|
|||
/*- EncryptedData ::= SEQUENCE {
|
|||
* etype[0] INTEGER, -- EncryptionType |
|||
* kvno[1] INTEGER OPTIONAL, |
|||
* cipher[2] OCTET STRING -- ciphertext |
|||
* } |
|||
*/ |
|||
typedef struct krb5_encdata_st { |
|||
ASN1_INTEGER *etype; |
|||
ASN1_INTEGER *kvno; |
|||
ASN1_OCTET_STRING *cipher; |
|||
} KRB5_ENCDATA; |
|||
|
|||
DECLARE_STACK_OF(KRB5_ENCDATA) |
|||
|
|||
/*- PrincipalName ::= SEQUENCE {
|
|||
* name-type[0] INTEGER, |
|||
* name-string[1] SEQUENCE OF GeneralString |
|||
* } |
|||
*/ |
|||
typedef struct krb5_princname_st { |
|||
ASN1_INTEGER *nametype; |
|||
STACK_OF(ASN1_GENERALSTRING) *namestring; |
|||
} KRB5_PRINCNAME; |
|||
|
|||
DECLARE_STACK_OF(KRB5_PRINCNAME) |
|||
|
|||
/*- Ticket ::= [APPLICATION 1] SEQUENCE {
|
|||
* tkt-vno[0] INTEGER, |
|||
* realm[1] Realm, |
|||
* sname[2] PrincipalName, |
|||
* enc-part[3] EncryptedData |
|||
* } |
|||
*/ |
|||
typedef struct krb5_tktbody_st { |
|||
ASN1_INTEGER *tktvno; |
|||
ASN1_GENERALSTRING *realm; |
|||
KRB5_PRINCNAME *sname; |
|||
KRB5_ENCDATA *encdata; |
|||
} KRB5_TKTBODY; |
|||
|
|||
typedef STACK_OF(KRB5_TKTBODY) KRB5_TICKET; |
|||
DECLARE_STACK_OF(KRB5_TKTBODY) |
|||
|
|||
/*- AP-REQ ::= [APPLICATION 14] SEQUENCE {
|
|||
* pvno[0] INTEGER, |
|||
* msg-type[1] INTEGER, |
|||
* ap-options[2] APOptions, |
|||
* ticket[3] Ticket, |
|||
* authenticator[4] EncryptedData |
|||
* } |
|||
* |
|||
* APOptions ::= BIT STRING { |
|||
* reserved(0), use-session-key(1), mutual-required(2) } |
|||
*/ |
|||
typedef struct krb5_ap_req_st { |
|||
ASN1_INTEGER *pvno; |
|||
ASN1_INTEGER *msgtype; |
|||
ASN1_BIT_STRING *apoptions; |
|||
KRB5_TICKET *ticket; |
|||
KRB5_ENCDATA *authenticator; |
|||
} KRB5_APREQBODY; |
|||
|
|||
typedef STACK_OF(KRB5_APREQBODY) KRB5_APREQ; |
|||
DECLARE_STACK_OF(KRB5_APREQBODY) |
|||
|
|||
/* Authenticator Stuff */ |
|||
|
|||
/*- Checksum ::= SEQUENCE {
|
|||
* cksumtype[0] INTEGER, |
|||
* checksum[1] OCTET STRING |
|||
* } |
|||
*/ |
|||
typedef struct krb5_checksum_st { |
|||
ASN1_INTEGER *ctype; |
|||
ASN1_OCTET_STRING *checksum; |
|||
} KRB5_CHECKSUM; |
|||
|
|||
DECLARE_STACK_OF(KRB5_CHECKSUM) |
|||
|
|||
/*- EncryptionKey ::= SEQUENCE {
|
|||
* keytype[0] INTEGER, |
|||
* keyvalue[1] OCTET STRING |
|||
* } |
|||
*/ |
|||
typedef struct krb5_encryptionkey_st { |
|||
ASN1_INTEGER *ktype; |
|||
ASN1_OCTET_STRING *keyvalue; |
|||
} KRB5_ENCKEY; |
|||
|
|||
DECLARE_STACK_OF(KRB5_ENCKEY) |
|||
|
|||
/*- AuthorizationData ::= SEQUENCE OF SEQUENCE {
|
|||
* ad-type[0] INTEGER, |
|||
* ad-data[1] OCTET STRING |
|||
* } |
|||
*/ |
|||
typedef struct krb5_authorization_st { |
|||
ASN1_INTEGER *adtype; |
|||
ASN1_OCTET_STRING *addata; |
|||
} KRB5_AUTHDATA; |
|||
|
|||
DECLARE_STACK_OF(KRB5_AUTHDATA) |
|||
|
|||
/*- -- Unencrypted authenticator
|
|||
* Authenticator ::= [APPLICATION 2] SEQUENCE { |
|||
* authenticator-vno[0] INTEGER, |
|||
* crealm[1] Realm, |
|||
* cname[2] PrincipalName, |
|||
* cksum[3] Checksum OPTIONAL, |
|||
* cusec[4] INTEGER, |
|||
* ctime[5] KerberosTime, |
|||
* subkey[6] EncryptionKey OPTIONAL, |
|||
* seq-number[7] INTEGER OPTIONAL, |
|||
* authorization-data[8] AuthorizationData OPTIONAL |
|||
* } |
|||
*/ |
|||
typedef struct krb5_authenticator_st { |
|||
ASN1_INTEGER *avno; |
|||
ASN1_GENERALSTRING *crealm; |
|||
KRB5_PRINCNAME *cname; |
|||
KRB5_CHECKSUM *cksum; |
|||
ASN1_INTEGER *cusec; |
|||
ASN1_GENERALIZEDTIME *ctime; |
|||
KRB5_ENCKEY *subkey; |
|||
ASN1_INTEGER *seqnum; |
|||
KRB5_AUTHDATA *authorization; |
|||
} KRB5_AUTHENTBODY; |
|||
|
|||
typedef STACK_OF(KRB5_AUTHENTBODY) KRB5_AUTHENT; |
|||
DECLARE_STACK_OF(KRB5_AUTHENTBODY) |
|||
|
|||
/*- DECLARE_ASN1_FUNCTIONS(type) = DECLARE_ASN1_FUNCTIONS_name(type, type) =
|
|||
* type *name##_new(void); |
|||
* void name##_free(type *a); |
|||
* DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) = |
|||
* DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) = |
|||
* type *d2i_##name(type **a, const unsigned char **in, long len); |
|||
* int i2d_##name(type *a, unsigned char **out); |
|||
* DECLARE_ASN1_ITEM(itname) = OPENSSL_EXTERN const ASN1_ITEM itname##_it |
|||
*/ |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(KRB5_ENCDATA) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_PRINCNAME) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_TKTBODY) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_APREQBODY) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_TICKET) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_APREQ) |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(KRB5_CHECKSUM) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_ENCKEY) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_AUTHDATA) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_AUTHENTBODY) |
|||
DECLARE_ASN1_FUNCTIONS(KRB5_AUTHENT) |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,197 +0,0 @@ |
|||
/* ssl/kssl.h */ |
|||
/*
|
|||
* Written by Vern Staats <staatsvr@asc.hpc.mil> for the OpenSSL project |
|||
* 2000. project 2000. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2000 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
/*
|
|||
** 19990701 VRS Started. |
|||
*/ |
|||
|
|||
#ifndef KSSL_H |
|||
# define KSSL_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
|
|||
# ifndef OPENSSL_NO_KRB5 |
|||
|
|||
# include <stdio.h> |
|||
# include <ctype.h> |
|||
# include <krb5.h> |
|||
# ifdef OPENSSL_SYS_WIN32 |
|||
/*
|
|||
* These can sometimes get redefined indirectly by krb5 header files after |
|||
* they get undefed in ossl_typ.h |
|||
*/ |
|||
# undef X509_NAME |
|||
# undef X509_EXTENSIONS |
|||
# undef OCSP_REQUEST |
|||
# undef OCSP_RESPONSE |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/*
|
|||
* Depending on which KRB5 implementation used, some types from |
|||
* the other may be missing. Resolve that here and now |
|||
*/ |
|||
# ifdef KRB5_HEIMDAL |
|||
typedef unsigned char krb5_octet; |
|||
# define FAR |
|||
# else |
|||
|
|||
# ifndef FAR |
|||
# define FAR |
|||
# endif |
|||
|
|||
# endif |
|||
|
|||
/*-
|
|||
* Uncomment this to debug kssl problems or |
|||
* to trace usage of the Kerberos session key |
|||
* |
|||
* #define KSSL_DEBUG |
|||
*/ |
|||
|
|||
# ifndef KRB5SVC |
|||
# define KRB5SVC "host" |
|||
# endif |
|||
|
|||
# ifndef KRB5KEYTAB |
|||
# define KRB5KEYTAB "/etc/krb5.keytab" |
|||
# endif |
|||
|
|||
# ifndef KRB5SENDAUTH |
|||
# define KRB5SENDAUTH 1 |
|||
# endif |
|||
|
|||
# ifndef KRB5CHECKAUTH |
|||
# define KRB5CHECKAUTH 1 |
|||
# endif |
|||
|
|||
# ifndef KSSL_CLOCKSKEW |
|||
# define KSSL_CLOCKSKEW 300; |
|||
# endif |
|||
|
|||
# define KSSL_ERR_MAX 255 |
|||
typedef struct kssl_err_st { |
|||
int reason; |
|||
char text[KSSL_ERR_MAX + 1]; |
|||
} KSSL_ERR; |
|||
|
|||
/*- Context for passing
|
|||
* (1) Kerberos session key to SSL, and |
|||
* (2) Config data between application and SSL lib |
|||
*/ |
|||
typedef struct kssl_ctx_st { |
|||
/* used by: disposition: */ |
|||
char *service_name; /* C,S default ok (kssl) */ |
|||
char *service_host; /* C input, REQUIRED */ |
|||
char *client_princ; /* S output from krb5 ticket */ |
|||
char *keytab_file; /* S NULL (/etc/krb5.keytab) */ |
|||
char *cred_cache; /* C NULL (default) */ |
|||
krb5_enctype enctype; |
|||
int length; |
|||
krb5_octet FAR *key; |
|||
} KSSL_CTX; |
|||
|
|||
# define KSSL_CLIENT 1 |
|||
# define KSSL_SERVER 2 |
|||
# define KSSL_SERVICE 3 |
|||
# define KSSL_KEYTAB 4 |
|||
|
|||
# define KSSL_CTX_OK 0 |
|||
# define KSSL_CTX_ERR 1 |
|||
# define KSSL_NOMEM 2 |
|||
|
|||
/* Public (for use by applications that use OpenSSL with Kerberos 5 support */ |
|||
krb5_error_code kssl_ctx_setstring(KSSL_CTX *kssl_ctx, int which, char *text); |
|||
KSSL_CTX *kssl_ctx_new(void); |
|||
KSSL_CTX *kssl_ctx_free(KSSL_CTX *kssl_ctx); |
|||
void kssl_ctx_show(KSSL_CTX *kssl_ctx); |
|||
krb5_error_code kssl_ctx_setprinc(KSSL_CTX *kssl_ctx, int which, |
|||
krb5_data *realm, krb5_data *entity, |
|||
int nentities); |
|||
krb5_error_code kssl_cget_tkt(KSSL_CTX *kssl_ctx, krb5_data **enc_tktp, |
|||
krb5_data *authenp, KSSL_ERR *kssl_err); |
|||
krb5_error_code kssl_sget_tkt(KSSL_CTX *kssl_ctx, krb5_data *indata, |
|||
krb5_ticket_times *ttimes, KSSL_ERR *kssl_err); |
|||
krb5_error_code kssl_ctx_setkey(KSSL_CTX *kssl_ctx, krb5_keyblock *session); |
|||
void kssl_err_set(KSSL_ERR *kssl_err, int reason, char *text); |
|||
void kssl_krb5_free_data_contents(krb5_context context, krb5_data *data); |
|||
krb5_error_code kssl_build_principal_2(krb5_context context, |
|||
krb5_principal *princ, int rlen, |
|||
const char *realm, int slen, |
|||
const char *svc, int hlen, |
|||
const char *host); |
|||
krb5_error_code kssl_validate_times(krb5_timestamp atime, |
|||
krb5_ticket_times *ttimes); |
|||
krb5_error_code kssl_check_authent(KSSL_CTX *kssl_ctx, krb5_data *authentp, |
|||
krb5_timestamp *atimep, |
|||
KSSL_ERR *kssl_err); |
|||
unsigned char *kssl_skip_confound(krb5_enctype enctype, unsigned char *authn); |
|||
|
|||
void SSL_set0_kssl_ctx(SSL *s, KSSL_CTX *kctx); |
|||
KSSL_CTX *SSL_get0_kssl_ctx(SSL *s); |
|||
char *kssl_ctx_get0_client_princ(KSSL_CTX *kctx); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
# endif /* OPENSSL_NO_KRB5 */ |
|||
#endif /* KSSL_H */ |
|||
@ -1,240 +0,0 @@ |
|||
/* crypto/lhash/lhash.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
/*
|
|||
* Header for dynamic hash table routines Author - Eric Young |
|||
*/ |
|||
|
|||
#ifndef HEADER_LHASH_H |
|||
# define HEADER_LHASH_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
# ifndef OPENSSL_NO_FP_API |
|||
# include <stdio.h> |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
# include <openssl/bio.h> |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct lhash_node_st { |
|||
void *data; |
|||
struct lhash_node_st *next; |
|||
# ifndef OPENSSL_NO_HASH_COMP |
|||
unsigned long hash; |
|||
# endif |
|||
} 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 *); |
|||
|
|||
/*
|
|||
* Macros for declaring and implementing type-safe wrappers for LHASH |
|||
* callbacks. This way, callbacks can be provided to LHASH structures without |
|||
* function pointer casting and the macro-defined callbacks provide |
|||
* per-variable casting before deferring to the underlying type-specific |
|||
* callbacks. NB: It is possible to place a "static" in front of both the |
|||
* DECLARE and IMPLEMENT macros if the functions are strictly internal. |
|||
*/ |
|||
|
|||
/* First: "hash" functions */ |
|||
# define DECLARE_LHASH_HASH_FN(name, o_type) \ |
|||
unsigned long name##_LHASH_HASH(const void *); |
|||
# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \ |
|||
unsigned long name##_LHASH_HASH(const void *arg) { \ |
|||
const o_type *a = arg; \ |
|||
return name##_hash(a); } |
|||
# define LHASH_HASH_FN(name) name##_LHASH_HASH |
|||
|
|||
/* Second: "compare" functions */ |
|||
# define DECLARE_LHASH_COMP_FN(name, o_type) \ |
|||
int name##_LHASH_COMP(const void *, const void *); |
|||
# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \ |
|||
int name##_LHASH_COMP(const void *arg1, const void *arg2) { \ |
|||
const o_type *a = arg1; \ |
|||
const o_type *b = arg2; \ |
|||
return name##_cmp(a,b); } |
|||
# define LHASH_COMP_FN(name) name##_LHASH_COMP |
|||
|
|||
/* Third: "doall" functions */ |
|||
# define DECLARE_LHASH_DOALL_FN(name, o_type) \ |
|||
void name##_LHASH_DOALL(void *); |
|||
# define IMPLEMENT_LHASH_DOALL_FN(name, o_type) \ |
|||
void name##_LHASH_DOALL(void *arg) { \ |
|||
o_type *a = arg; \ |
|||
name##_doall(a); } |
|||
# define LHASH_DOALL_FN(name) name##_LHASH_DOALL |
|||
|
|||
/* Fourth: "doall_arg" functions */ |
|||
# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ |
|||
void name##_LHASH_DOALL_ARG(void *, void *); |
|||
# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ |
|||
void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \ |
|||
o_type *a = arg1; \ |
|||
a_type *b = arg2; \ |
|||
name##_doall_arg(a, b); } |
|||
# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG |
|||
|
|||
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; /* load times 256 */ |
|||
unsigned long down_load; /* load times 256 */ |
|||
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; /* Do not use _LHASH directly, use LHASH_OF
|
|||
* and friends */ |
|||
|
|||
# define LH_LOAD_MULT 256 |
|||
|
|||
/*
|
|||
* Indicates a malloc() error in the last call, this is only bad in |
|||
* lh_insert(). |
|||
*/ |
|||
# define lh_error(lh) ((lh)->error) |
|||
|
|||
_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); |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
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); |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
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); |
|||
# endif |
|||
|
|||
/* Type checking... */ |
|||
|
|||
# define LHASH_OF(type) struct lhash_st_##type |
|||
|
|||
# define DECLARE_LHASH_OF(type) LHASH_OF(type) { int dummy; } |
|||
|
|||
# define CHECKED_LHASH_OF(type,lh) \ |
|||
((_LHASH *)CHECKED_PTR_OF(LHASH_OF(type),lh)) |
|||
|
|||
/* Define wrapper functions. */ |
|||
# define LHM_lh_new(type, name) \ |
|||
((LHASH_OF(type) *)lh_new(LHASH_HASH_FN(name), LHASH_COMP_FN(name))) |
|||
# define LHM_lh_error(type, lh) \ |
|||
lh_error(CHECKED_LHASH_OF(type,lh)) |
|||
# define LHM_lh_insert(type, lh, inst) \ |
|||
((type *)lh_insert(CHECKED_LHASH_OF(type, lh), \ |
|||
CHECKED_PTR_OF(type, inst))) |
|||
# define LHM_lh_retrieve(type, lh, inst) \ |
|||
((type *)lh_retrieve(CHECKED_LHASH_OF(type, lh), \ |
|||
CHECKED_PTR_OF(type, inst))) |
|||
# define LHM_lh_delete(type, lh, inst) \ |
|||
((type *)lh_delete(CHECKED_LHASH_OF(type, lh), \ |
|||
CHECKED_PTR_OF(type, inst))) |
|||
# define LHM_lh_doall(type, lh,fn) lh_doall(CHECKED_LHASH_OF(type, lh), fn) |
|||
# define LHM_lh_doall_arg(type, lh, fn, arg_type, arg) \ |
|||
lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg)) |
|||
# define LHM_lh_num_items(type, lh) lh_num_items(CHECKED_LHASH_OF(type, lh)) |
|||
# define LHM_lh_down_load(type, lh) (CHECKED_LHASH_OF(type, lh)->down_load) |
|||
# define LHM_lh_node_stats_bio(type, lh, out) \ |
|||
lh_node_stats_bio(CHECKED_LHASH_OF(type, lh), out) |
|||
# define LHM_lh_node_usage_stats_bio(type, lh, out) \ |
|||
lh_node_usage_stats_bio(CHECKED_LHASH_OF(type, lh), out) |
|||
# define LHM_lh_stats_bio(type, lh, out) \ |
|||
lh_stats_bio(CHECKED_LHASH_OF(type, lh), out) |
|||
# define LHM_lh_free(type, lh) lh_free(CHECKED_LHASH_OF(type, lh)) |
|||
|
|||
DECLARE_LHASH_OF(OPENSSL_STRING); |
|||
DECLARE_LHASH_OF(OPENSSL_CSTRING); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,119 +0,0 @@ |
|||
/* crypto/md4/md4.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_MD4_H |
|||
# define HEADER_MD4_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
# include <stddef.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef OPENSSL_NO_MD4 |
|||
# error MD4 is disabled. |
|||
# endif |
|||
|
|||
/*-
|
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
* ! MD4_LONG has to be at least 32 bits wide. If it's wider, then ! |
|||
* ! MD4_LONG_LOG2 has to be defined along. ! |
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
*/ |
|||
|
|||
# if defined(__LP32__) |
|||
# define MD4_LONG unsigned long |
|||
# elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) |
|||
# define MD4_LONG unsigned long |
|||
# define MD4_LONG_LOG2 3 |
|||
/*
|
|||
* _CRAY note. I could declare short, but I have no idea what impact |
|||
* does it have on performance on none-T3E machines. I could declare |
|||
* int, but at least on C90 sizeof(int) can be chosen at compile time. |
|||
* So I've chosen long... |
|||
* <appro@fy.chalmers.se> |
|||
*/ |
|||
# else |
|||
# define MD4_LONG unsigned int |
|||
# endif |
|||
|
|||
# define MD4_CBLOCK 64 |
|||
# define MD4_LBLOCK (MD4_CBLOCK/4) |
|||
# define MD4_DIGEST_LENGTH 16 |
|||
|
|||
typedef struct MD4state_st { |
|||
MD4_LONG A, B, C, D; |
|||
MD4_LONG Nl, Nh; |
|||
MD4_LONG data[MD4_LBLOCK]; |
|||
unsigned int num; |
|||
} MD4_CTX; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
int private_MD4_Init(MD4_CTX *c); |
|||
# endif |
|||
int MD4_Init(MD4_CTX *c); |
|||
int MD4_Update(MD4_CTX *c, const void *data, size_t len); |
|||
int MD4_Final(unsigned char *md, MD4_CTX *c); |
|||
unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md); |
|||
void MD4_Transform(MD4_CTX *c, const unsigned char *b); |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,119 +0,0 @@ |
|||
/* crypto/md5/md5.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_MD5_H |
|||
# define HEADER_MD5_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
# include <stddef.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef OPENSSL_NO_MD5 |
|||
# error MD5 is disabled. |
|||
# endif |
|||
|
|||
/*
|
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
* ! MD5_LONG has to be at least 32 bits wide. If it's wider, then ! |
|||
* ! MD5_LONG_LOG2 has to be defined along. ! |
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
*/ |
|||
|
|||
# if defined(__LP32__) |
|||
# define MD5_LONG unsigned long |
|||
# elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) |
|||
# define MD5_LONG unsigned long |
|||
# define MD5_LONG_LOG2 3 |
|||
/*
|
|||
* _CRAY note. I could declare short, but I have no idea what impact |
|||
* does it have on performance on none-T3E machines. I could declare |
|||
* int, but at least on C90 sizeof(int) can be chosen at compile time. |
|||
* So I've chosen long... |
|||
* <appro@fy.chalmers.se> |
|||
*/ |
|||
# else |
|||
# define MD5_LONG unsigned int |
|||
# endif |
|||
|
|||
# define MD5_CBLOCK 64 |
|||
# define MD5_LBLOCK (MD5_CBLOCK/4) |
|||
# define MD5_DIGEST_LENGTH 16 |
|||
|
|||
typedef struct MD5state_st { |
|||
MD5_LONG A, B, C, D; |
|||
MD5_LONG Nl, Nh; |
|||
MD5_LONG data[MD5_LBLOCK]; |
|||
unsigned int num; |
|||
} MD5_CTX; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
int private_MD5_Init(MD5_CTX *c); |
|||
# endif |
|||
int MD5_Init(MD5_CTX *c); |
|||
int MD5_Update(MD5_CTX *c, const void *data, size_t len); |
|||
int MD5_Final(unsigned char *md, MD5_CTX *c); |
|||
unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md); |
|||
void MD5_Transform(MD5_CTX *c, const unsigned char *b); |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,94 +0,0 @@ |
|||
/* crypto/mdc2/mdc2.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_MDC2_H |
|||
# define HEADER_MDC2_H |
|||
|
|||
# include <openssl/des.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef OPENSSL_NO_MDC2 |
|||
# error MDC2 is disabled. |
|||
# endif |
|||
|
|||
# define MDC2_BLOCK 8 |
|||
# define MDC2_DIGEST_LENGTH 16 |
|||
|
|||
typedef struct mdc2_ctx_st { |
|||
unsigned int num; |
|||
unsigned char data[MDC2_BLOCK]; |
|||
DES_cblock h, hh; |
|||
int pad_type; /* either 1 or 2, default 1 */ |
|||
} MDC2_CTX; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
int private_MDC2_Init(MDC2_CTX *c); |
|||
# endif |
|||
int MDC2_Init(MDC2_CTX *c); |
|||
int MDC2_Update(MDC2_CTX *c, const unsigned char *data, size_t len); |
|||
int MDC2_Final(unsigned char *md, MDC2_CTX *c); |
|||
unsigned char *MDC2(const unsigned char *d, size_t n, unsigned char *md); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,153 +0,0 @@ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2008 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Rights for redistribution and usage in source and binary |
|||
* forms are granted according to the OpenSSL license. |
|||
*/ |
|||
|
|||
#include <stddef.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
typedef void (*block128_f) (const unsigned char in[16], |
|||
unsigned char out[16], const void *key); |
|||
|
|||
typedef void (*cbc128_f) (const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], int enc); |
|||
|
|||
typedef void (*ctr128_f) (const unsigned char *in, unsigned char *out, |
|||
size_t blocks, const void *key, |
|||
const unsigned char ivec[16]); |
|||
|
|||
typedef void (*ccm128_f) (const unsigned char *in, unsigned char *out, |
|||
size_t blocks, const void *key, |
|||
const unsigned char ivec[16], |
|||
unsigned char cmac[16]); |
|||
|
|||
void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], block128_f block); |
|||
void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], block128_f block); |
|||
|
|||
void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], |
|||
unsigned char ecount_buf[16], unsigned int *num, |
|||
block128_f block); |
|||
|
|||
void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], |
|||
unsigned char ecount_buf[16], |
|||
unsigned int *num, ctr128_f ctr); |
|||
|
|||
void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], int *num, |
|||
block128_f block); |
|||
|
|||
void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], int *num, |
|||
int enc, block128_f block); |
|||
void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t length, const void *key, |
|||
unsigned char ivec[16], int *num, |
|||
int enc, block128_f block); |
|||
void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t bits, const void *key, |
|||
unsigned char ivec[16], int *num, |
|||
int enc, block128_f block); |
|||
|
|||
size_t CRYPTO_cts128_encrypt_block(const unsigned char *in, |
|||
unsigned char *out, size_t len, |
|||
const void *key, unsigned char ivec[16], |
|||
block128_f block); |
|||
size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], cbc128_f cbc); |
|||
size_t CRYPTO_cts128_decrypt_block(const unsigned char *in, |
|||
unsigned char *out, size_t len, |
|||
const void *key, unsigned char ivec[16], |
|||
block128_f block); |
|||
size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], cbc128_f cbc); |
|||
|
|||
size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in, |
|||
unsigned char *out, size_t len, |
|||
const void *key, |
|||
unsigned char ivec[16], |
|||
block128_f block); |
|||
size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], cbc128_f cbc); |
|||
size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in, |
|||
unsigned char *out, size_t len, |
|||
const void *key, |
|||
unsigned char ivec[16], |
|||
block128_f block); |
|||
size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const void *key, |
|||
unsigned char ivec[16], cbc128_f cbc); |
|||
|
|||
typedef struct gcm128_context GCM128_CONTEXT; |
|||
|
|||
GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block); |
|||
void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block); |
|||
void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv, |
|||
size_t len); |
|||
int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad, |
|||
size_t len); |
|||
int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, |
|||
const unsigned char *in, unsigned char *out, |
|||
size_t len); |
|||
int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, |
|||
const unsigned char *in, unsigned char *out, |
|||
size_t len); |
|||
int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, |
|||
const unsigned char *in, unsigned char *out, |
|||
size_t len, ctr128_f stream); |
|||
int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, |
|||
const unsigned char *in, unsigned char *out, |
|||
size_t len, ctr128_f stream); |
|||
int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag, |
|||
size_t len); |
|||
void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len); |
|||
void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx); |
|||
|
|||
typedef struct ccm128_context CCM128_CONTEXT; |
|||
|
|||
void CRYPTO_ccm128_init(CCM128_CONTEXT *ctx, |
|||
unsigned int M, unsigned int L, void *key, |
|||
block128_f block); |
|||
int CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx, const unsigned char *nonce, |
|||
size_t nlen, size_t mlen); |
|||
void CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx, const unsigned char *aad, |
|||
size_t alen); |
|||
int CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx, const unsigned char *inp, |
|||
unsigned char *out, size_t len); |
|||
int CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx, const unsigned char *inp, |
|||
unsigned char *out, size_t len); |
|||
int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp, |
|||
unsigned char *out, size_t len, |
|||
ccm128_f stream); |
|||
int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp, |
|||
unsigned char *out, size_t len, |
|||
ccm128_f stream); |
|||
size_t CRYPTO_ccm128_tag(CCM128_CONTEXT *ctx, unsigned char *tag, size_t len); |
|||
|
|||
typedef struct xts128_context XTS128_CONTEXT; |
|||
|
|||
int CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx, |
|||
const unsigned char iv[16], |
|||
const unsigned char *inp, unsigned char *out, |
|||
size_t len, int enc); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -1,626 +0,0 @@ |
|||
/* ocsp.h */ |
|||
/*
|
|||
* Written by Tom Titchener <Tom_Titchener@groove.net> for the OpenSSL |
|||
* project. |
|||
*/ |
|||
|
|||
/*
|
|||
* History: This file was transfered to Richard Levitte from CertCo by Kathy |
|||
* Weinhold in mid-spring 2000 to be included in OpenSSL or released as a |
|||
* patch kit. |
|||
*/ |
|||
|
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_OCSP_H |
|||
# define HEADER_OCSP_H |
|||
|
|||
# include <openssl/ossl_typ.h> |
|||
# include <openssl/x509.h> |
|||
# include <openssl/x509v3.h> |
|||
# include <openssl/safestack.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Various flags and values */ |
|||
|
|||
# define OCSP_DEFAULT_NONCE_LENGTH 16 |
|||
|
|||
# define OCSP_NOCERTS 0x1 |
|||
# define OCSP_NOINTERN 0x2 |
|||
# define OCSP_NOSIGS 0x4 |
|||
# define OCSP_NOCHAIN 0x8 |
|||
# define OCSP_NOVERIFY 0x10 |
|||
# define OCSP_NOEXPLICIT 0x20 |
|||
# define OCSP_NOCASIGN 0x40 |
|||
# define OCSP_NODELEGATED 0x80 |
|||
# define OCSP_NOCHECKS 0x100 |
|||
# define OCSP_TRUSTOTHER 0x200 |
|||
# define OCSP_RESPID_KEY 0x400 |
|||
# define OCSP_NOTIME 0x800 |
|||
|
|||
/*- CertID ::= SEQUENCE {
|
|||
* hashAlgorithm AlgorithmIdentifier, |
|||
* issuerNameHash OCTET STRING, -- Hash of Issuer's DN |
|||
* issuerKeyHash OCTET STRING, -- Hash of Issuers public key (excluding the tag & length fields) |
|||
* serialNumber CertificateSerialNumber } |
|||
*/ |
|||
typedef struct ocsp_cert_id_st { |
|||
X509_ALGOR *hashAlgorithm; |
|||
ASN1_OCTET_STRING *issuerNameHash; |
|||
ASN1_OCTET_STRING *issuerKeyHash; |
|||
ASN1_INTEGER *serialNumber; |
|||
} OCSP_CERTID; |
|||
|
|||
DECLARE_STACK_OF(OCSP_CERTID) |
|||
|
|||
/*- Request ::= SEQUENCE {
|
|||
* reqCert CertID, |
|||
* singleRequestExtensions [0] EXPLICIT Extensions OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_one_request_st { |
|||
OCSP_CERTID *reqCert; |
|||
STACK_OF(X509_EXTENSION) *singleRequestExtensions; |
|||
} OCSP_ONEREQ; |
|||
|
|||
DECLARE_STACK_OF(OCSP_ONEREQ) |
|||
DECLARE_ASN1_SET_OF(OCSP_ONEREQ) |
|||
|
|||
/*- TBSRequest ::= SEQUENCE {
|
|||
* version [0] EXPLICIT Version DEFAULT v1, |
|||
* requestorName [1] EXPLICIT GeneralName OPTIONAL, |
|||
* requestList SEQUENCE OF Request, |
|||
* requestExtensions [2] EXPLICIT Extensions OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_req_info_st { |
|||
ASN1_INTEGER *version; |
|||
GENERAL_NAME *requestorName; |
|||
STACK_OF(OCSP_ONEREQ) *requestList; |
|||
STACK_OF(X509_EXTENSION) *requestExtensions; |
|||
} OCSP_REQINFO; |
|||
|
|||
/*- Signature ::= SEQUENCE {
|
|||
* signatureAlgorithm AlgorithmIdentifier, |
|||
* signature BIT STRING, |
|||
* certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_signature_st { |
|||
X509_ALGOR *signatureAlgorithm; |
|||
ASN1_BIT_STRING *signature; |
|||
STACK_OF(X509) *certs; |
|||
} OCSP_SIGNATURE; |
|||
|
|||
/*- OCSPRequest ::= SEQUENCE {
|
|||
* tbsRequest TBSRequest, |
|||
* optionalSignature [0] EXPLICIT Signature OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_request_st { |
|||
OCSP_REQINFO *tbsRequest; |
|||
OCSP_SIGNATURE *optionalSignature; /* OPTIONAL */ |
|||
} OCSP_REQUEST; |
|||
|
|||
/*- OCSPResponseStatus ::= ENUMERATED {
|
|||
* successful (0), --Response has valid confirmations |
|||
* malformedRequest (1), --Illegal confirmation request |
|||
* internalError (2), --Internal error in issuer |
|||
* tryLater (3), --Try again later |
|||
* --(4) is not used |
|||
* sigRequired (5), --Must sign the request |
|||
* unauthorized (6) --Request unauthorized |
|||
* } |
|||
*/ |
|||
# define OCSP_RESPONSE_STATUS_SUCCESSFUL 0 |
|||
# define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST 1 |
|||
# define OCSP_RESPONSE_STATUS_INTERNALERROR 2 |
|||
# define OCSP_RESPONSE_STATUS_TRYLATER 3 |
|||
# define OCSP_RESPONSE_STATUS_SIGREQUIRED 5 |
|||
# define OCSP_RESPONSE_STATUS_UNAUTHORIZED 6 |
|||
|
|||
/*- ResponseBytes ::= SEQUENCE {
|
|||
* responseType OBJECT IDENTIFIER, |
|||
* response OCTET STRING } |
|||
*/ |
|||
typedef struct ocsp_resp_bytes_st { |
|||
ASN1_OBJECT *responseType; |
|||
ASN1_OCTET_STRING *response; |
|||
} OCSP_RESPBYTES; |
|||
|
|||
/*- OCSPResponse ::= SEQUENCE {
|
|||
* responseStatus OCSPResponseStatus, |
|||
* responseBytes [0] EXPLICIT ResponseBytes OPTIONAL } |
|||
*/ |
|||
struct ocsp_response_st { |
|||
ASN1_ENUMERATED *responseStatus; |
|||
OCSP_RESPBYTES *responseBytes; |
|||
}; |
|||
|
|||
/*- ResponderID ::= CHOICE {
|
|||
* byName [1] Name, |
|||
* byKey [2] KeyHash } |
|||
*/ |
|||
# define V_OCSP_RESPID_NAME 0 |
|||
# define V_OCSP_RESPID_KEY 1 |
|||
struct ocsp_responder_id_st { |
|||
int type; |
|||
union { |
|||
X509_NAME *byName; |
|||
ASN1_OCTET_STRING *byKey; |
|||
} value; |
|||
}; |
|||
|
|||
DECLARE_STACK_OF(OCSP_RESPID) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_RESPID) |
|||
|
|||
/*- KeyHash ::= OCTET STRING --SHA-1 hash of responder's public key
|
|||
* --(excluding the tag and length fields) |
|||
*/ |
|||
|
|||
/*- RevokedInfo ::= SEQUENCE {
|
|||
* revocationTime GeneralizedTime, |
|||
* revocationReason [0] EXPLICIT CRLReason OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_revoked_info_st { |
|||
ASN1_GENERALIZEDTIME *revocationTime; |
|||
ASN1_ENUMERATED *revocationReason; |
|||
} OCSP_REVOKEDINFO; |
|||
|
|||
/*- CertStatus ::= CHOICE {
|
|||
* good [0] IMPLICIT NULL, |
|||
* revoked [1] IMPLICIT RevokedInfo, |
|||
* unknown [2] IMPLICIT UnknownInfo } |
|||
*/ |
|||
# define V_OCSP_CERTSTATUS_GOOD 0 |
|||
# define V_OCSP_CERTSTATUS_REVOKED 1 |
|||
# define V_OCSP_CERTSTATUS_UNKNOWN 2 |
|||
typedef struct ocsp_cert_status_st { |
|||
int type; |
|||
union { |
|||
ASN1_NULL *good; |
|||
OCSP_REVOKEDINFO *revoked; |
|||
ASN1_NULL *unknown; |
|||
} value; |
|||
} OCSP_CERTSTATUS; |
|||
|
|||
/*- SingleResponse ::= SEQUENCE {
|
|||
* certID CertID, |
|||
* certStatus CertStatus, |
|||
* thisUpdate GeneralizedTime, |
|||
* nextUpdate [0] EXPLICIT GeneralizedTime OPTIONAL, |
|||
* singleExtensions [1] EXPLICIT Extensions OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_single_response_st { |
|||
OCSP_CERTID *certId; |
|||
OCSP_CERTSTATUS *certStatus; |
|||
ASN1_GENERALIZEDTIME *thisUpdate; |
|||
ASN1_GENERALIZEDTIME *nextUpdate; |
|||
STACK_OF(X509_EXTENSION) *singleExtensions; |
|||
} OCSP_SINGLERESP; |
|||
|
|||
DECLARE_STACK_OF(OCSP_SINGLERESP) |
|||
DECLARE_ASN1_SET_OF(OCSP_SINGLERESP) |
|||
|
|||
/*- ResponseData ::= SEQUENCE {
|
|||
* version [0] EXPLICIT Version DEFAULT v1, |
|||
* responderID ResponderID, |
|||
* producedAt GeneralizedTime, |
|||
* responses SEQUENCE OF SingleResponse, |
|||
* responseExtensions [1] EXPLICIT Extensions OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_response_data_st { |
|||
ASN1_INTEGER *version; |
|||
OCSP_RESPID *responderId; |
|||
ASN1_GENERALIZEDTIME *producedAt; |
|||
STACK_OF(OCSP_SINGLERESP) *responses; |
|||
STACK_OF(X509_EXTENSION) *responseExtensions; |
|||
} OCSP_RESPDATA; |
|||
|
|||
/*- BasicOCSPResponse ::= SEQUENCE {
|
|||
* tbsResponseData ResponseData, |
|||
* signatureAlgorithm AlgorithmIdentifier, |
|||
* signature BIT STRING, |
|||
* certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL } |
|||
*/ |
|||
/*
|
|||
* Note 1: The value for "signature" is specified in the OCSP rfc2560 as |
|||
* follows: "The value for the signature SHALL be computed on the hash of |
|||
* the DER encoding ResponseData." This means that you must hash the |
|||
* DER-encoded tbsResponseData, and then run it through a crypto-signing |
|||
* function, which will (at least w/RSA) do a hash-'n'-private-encrypt |
|||
* operation. This seems a bit odd, but that's the spec. Also note that |
|||
* the data structures do not leave anywhere to independently specify the |
|||
* algorithm used for the initial hash. So, we look at the |
|||
* signature-specification algorithm, and try to do something intelligent. |
|||
* -- Kathy Weinhold, CertCo |
|||
*/ |
|||
/*
|
|||
* Note 2: It seems that the mentioned passage from RFC 2560 (section |
|||
* 4.2.1) is open for interpretation. I've done tests against another |
|||
* responder, and found that it doesn't do the double hashing that the RFC |
|||
* seems to say one should. Therefore, all relevant functions take a flag |
|||
* saying which variant should be used. -- Richard Levitte, OpenSSL team |
|||
* and CeloCom |
|||
*/ |
|||
typedef struct ocsp_basic_response_st { |
|||
OCSP_RESPDATA *tbsResponseData; |
|||
X509_ALGOR *signatureAlgorithm; |
|||
ASN1_BIT_STRING *signature; |
|||
STACK_OF(X509) *certs; |
|||
} OCSP_BASICRESP; |
|||
|
|||
/*-
|
|||
* CRLReason ::= ENUMERATED { |
|||
* unspecified (0), |
|||
* keyCompromise (1), |
|||
* cACompromise (2), |
|||
* affiliationChanged (3), |
|||
* superseded (4), |
|||
* cessationOfOperation (5), |
|||
* certificateHold (6), |
|||
* removeFromCRL (8) } |
|||
*/ |
|||
# define OCSP_REVOKED_STATUS_NOSTATUS -1 |
|||
# define OCSP_REVOKED_STATUS_UNSPECIFIED 0 |
|||
# define OCSP_REVOKED_STATUS_KEYCOMPROMISE 1 |
|||
# define OCSP_REVOKED_STATUS_CACOMPROMISE 2 |
|||
# define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED 3 |
|||
# define OCSP_REVOKED_STATUS_SUPERSEDED 4 |
|||
# define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION 5 |
|||
# define OCSP_REVOKED_STATUS_CERTIFICATEHOLD 6 |
|||
# define OCSP_REVOKED_STATUS_REMOVEFROMCRL 8 |
|||
|
|||
/*-
|
|||
* CrlID ::= SEQUENCE { |
|||
* crlUrl [0] EXPLICIT IA5String OPTIONAL, |
|||
* crlNum [1] EXPLICIT INTEGER OPTIONAL, |
|||
* crlTime [2] EXPLICIT GeneralizedTime OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_crl_id_st { |
|||
ASN1_IA5STRING *crlUrl; |
|||
ASN1_INTEGER *crlNum; |
|||
ASN1_GENERALIZEDTIME *crlTime; |
|||
} OCSP_CRLID; |
|||
|
|||
/*-
|
|||
* ServiceLocator ::= SEQUENCE { |
|||
* issuer Name, |
|||
* locator AuthorityInfoAccessSyntax OPTIONAL } |
|||
*/ |
|||
typedef struct ocsp_service_locator_st { |
|||
X509_NAME *issuer; |
|||
STACK_OF(ACCESS_DESCRIPTION) *locator; |
|||
} OCSP_SERVICELOC; |
|||
|
|||
# define PEM_STRING_OCSP_REQUEST "OCSP REQUEST" |
|||
# define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE" |
|||
|
|||
# define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p) |
|||
|
|||
# define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p) |
|||
|
|||
# define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \ |
|||
(char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,bp,(char **)x,cb,NULL) |
|||
|
|||
# define PEM_read_bio_OCSP_RESPONSE(bp,x,cb)(OCSP_RESPONSE *)PEM_ASN1_read_bio(\ |
|||
(char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,bp,(char **)x,cb,NULL) |
|||
|
|||
# define PEM_write_bio_OCSP_REQUEST(bp,o) \ |
|||
PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\ |
|||
bp,(char *)o, NULL,NULL,0,NULL,NULL) |
|||
|
|||
# define PEM_write_bio_OCSP_RESPONSE(bp,o) \ |
|||
PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\ |
|||
bp,(char *)o, NULL,NULL,0,NULL,NULL) |
|||
|
|||
# define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o) |
|||
|
|||
# define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o) |
|||
|
|||
# define OCSP_REQUEST_sign(o,pkey,md) \ |
|||
ASN1_item_sign(ASN1_ITEM_rptr(OCSP_REQINFO),\ |
|||
o->optionalSignature->signatureAlgorithm,NULL,\ |
|||
o->optionalSignature->signature,o->tbsRequest,pkey,md) |
|||
|
|||
# define OCSP_BASICRESP_sign(o,pkey,md,d) \ |
|||
ASN1_item_sign(ASN1_ITEM_rptr(OCSP_RESPDATA),o->signatureAlgorithm,NULL,\ |
|||
o->signature,o->tbsResponseData,pkey,md) |
|||
|
|||
# define OCSP_REQUEST_verify(a,r) ASN1_item_verify(ASN1_ITEM_rptr(OCSP_REQINFO),\ |
|||
a->optionalSignature->signatureAlgorithm,\ |
|||
a->optionalSignature->signature,a->tbsRequest,r) |
|||
|
|||
# define OCSP_BASICRESP_verify(a,r,d) ASN1_item_verify(ASN1_ITEM_rptr(OCSP_RESPDATA),\ |
|||
a->signatureAlgorithm,a->signature,a->tbsResponseData,r) |
|||
|
|||
# define ASN1_BIT_STRING_digest(data,type,md,len) \ |
|||
ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len) |
|||
|
|||
# define OCSP_CERTSTATUS_dup(cs)\ |
|||
(OCSP_CERTSTATUS*)ASN1_dup((int(*)())i2d_OCSP_CERTSTATUS,\ |
|||
(char *(*)())d2i_OCSP_CERTSTATUS,(char *)(cs)) |
|||
|
|||
OCSP_CERTID *OCSP_CERTID_dup(OCSP_CERTID *id); |
|||
|
|||
OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, char *path, OCSP_REQUEST *req); |
|||
OCSP_REQ_CTX *OCSP_sendreq_new(BIO *io, char *path, OCSP_REQUEST *req, |
|||
int maxline); |
|||
int OCSP_sendreq_nbio(OCSP_RESPONSE **presp, OCSP_REQ_CTX *rctx); |
|||
void OCSP_REQ_CTX_free(OCSP_REQ_CTX *rctx); |
|||
int OCSP_REQ_CTX_set1_req(OCSP_REQ_CTX *rctx, OCSP_REQUEST *req); |
|||
int OCSP_REQ_CTX_add1_header(OCSP_REQ_CTX *rctx, |
|||
const char *name, const char *value); |
|||
|
|||
OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, X509 *subject, X509 *issuer); |
|||
|
|||
OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst, |
|||
X509_NAME *issuerName, |
|||
ASN1_BIT_STRING *issuerKey, |
|||
ASN1_INTEGER *serialNumber); |
|||
|
|||
OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid); |
|||
|
|||
int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len); |
|||
int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len); |
|||
int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs); |
|||
int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req); |
|||
|
|||
int OCSP_request_set1_name(OCSP_REQUEST *req, X509_NAME *nm); |
|||
int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert); |
|||
|
|||
int OCSP_request_sign(OCSP_REQUEST *req, |
|||
X509 *signer, |
|||
EVP_PKEY *key, |
|||
const EVP_MD *dgst, |
|||
STACK_OF(X509) *certs, unsigned long flags); |
|||
|
|||
int OCSP_response_status(OCSP_RESPONSE *resp); |
|||
OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp); |
|||
|
|||
int OCSP_resp_count(OCSP_BASICRESP *bs); |
|||
OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx); |
|||
int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last); |
|||
int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason, |
|||
ASN1_GENERALIZEDTIME **revtime, |
|||
ASN1_GENERALIZEDTIME **thisupd, |
|||
ASN1_GENERALIZEDTIME **nextupd); |
|||
int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status, |
|||
int *reason, |
|||
ASN1_GENERALIZEDTIME **revtime, |
|||
ASN1_GENERALIZEDTIME **thisupd, |
|||
ASN1_GENERALIZEDTIME **nextupd); |
|||
int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd, |
|||
ASN1_GENERALIZEDTIME *nextupd, long sec, long maxsec); |
|||
|
|||
int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs, |
|||
X509_STORE *store, unsigned long flags); |
|||
|
|||
int OCSP_parse_url(char *url, char **phost, char **pport, char **ppath, |
|||
int *pssl); |
|||
|
|||
int OCSP_id_issuer_cmp(OCSP_CERTID *a, OCSP_CERTID *b); |
|||
int OCSP_id_cmp(OCSP_CERTID *a, OCSP_CERTID *b); |
|||
|
|||
int OCSP_request_onereq_count(OCSP_REQUEST *req); |
|||
OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i); |
|||
OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one); |
|||
int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd, |
|||
ASN1_OCTET_STRING **pikeyHash, |
|||
ASN1_INTEGER **pserial, OCSP_CERTID *cid); |
|||
int OCSP_request_is_signed(OCSP_REQUEST *req); |
|||
OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs); |
|||
OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp, |
|||
OCSP_CERTID *cid, |
|||
int status, int reason, |
|||
ASN1_TIME *revtime, |
|||
ASN1_TIME *thisupd, |
|||
ASN1_TIME *nextupd); |
|||
int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert); |
|||
int OCSP_basic_sign(OCSP_BASICRESP *brsp, |
|||
X509 *signer, EVP_PKEY *key, const EVP_MD *dgst, |
|||
STACK_OF(X509) *certs, unsigned long flags); |
|||
|
|||
X509_EXTENSION *OCSP_crlID_new(char *url, long *n, char *tim); |
|||
|
|||
X509_EXTENSION *OCSP_accept_responses_new(char **oids); |
|||
|
|||
X509_EXTENSION *OCSP_archive_cutoff_new(char *tim); |
|||
|
|||
X509_EXTENSION *OCSP_url_svcloc_new(X509_NAME *issuer, char **urls); |
|||
|
|||
int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x); |
|||
int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos); |
|||
int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, ASN1_OBJECT *obj, |
|||
int lastpos); |
|||
int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos); |
|||
X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc); |
|||
X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc); |
|||
void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit, |
|||
int *idx); |
|||
int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit, |
|||
unsigned long flags); |
|||
int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc); |
|||
|
|||
int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x); |
|||
int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos); |
|||
int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, ASN1_OBJECT *obj, int lastpos); |
|||
int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos); |
|||
X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc); |
|||
X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc); |
|||
void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx); |
|||
int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit, |
|||
unsigned long flags); |
|||
int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc); |
|||
|
|||
int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x); |
|||
int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos); |
|||
int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, ASN1_OBJECT *obj, |
|||
int lastpos); |
|||
int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit, |
|||
int lastpos); |
|||
X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc); |
|||
X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc); |
|||
void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit, |
|||
int *idx); |
|||
int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value, |
|||
int crit, unsigned long flags); |
|||
int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc); |
|||
|
|||
int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x); |
|||
int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos); |
|||
int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, ASN1_OBJECT *obj, |
|||
int lastpos); |
|||
int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit, |
|||
int lastpos); |
|||
X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc); |
|||
X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc); |
|||
void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit, |
|||
int *idx); |
|||
int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value, |
|||
int crit, unsigned long flags); |
|||
int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc); |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_RESPID) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_CERTID) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_CRLID) |
|||
DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC) |
|||
|
|||
const char *OCSP_response_status_str(long s); |
|||
const char *OCSP_cert_status_str(long s); |
|||
const char *OCSP_crl_reason_str(long s); |
|||
|
|||
int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST *a, unsigned long flags); |
|||
int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE *o, unsigned long flags); |
|||
|
|||
int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs, |
|||
X509_STORE *st, unsigned long flags); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_OCSP_strings(void); |
|||
|
|||
/* Error codes for the OCSP functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define OCSP_F_ASN1_STRING_ENCODE 100 |
|||
# define OCSP_F_D2I_OCSP_NONCE 102 |
|||
# define OCSP_F_OCSP_BASIC_ADD1_STATUS 103 |
|||
# define OCSP_F_OCSP_BASIC_SIGN 104 |
|||
# define OCSP_F_OCSP_BASIC_VERIFY 105 |
|||
# define OCSP_F_OCSP_CERT_ID_NEW 101 |
|||
# define OCSP_F_OCSP_CHECK_DELEGATED 106 |
|||
# define OCSP_F_OCSP_CHECK_IDS 107 |
|||
# define OCSP_F_OCSP_CHECK_ISSUER 108 |
|||
# define OCSP_F_OCSP_CHECK_VALIDITY 115 |
|||
# define OCSP_F_OCSP_MATCH_ISSUERID 109 |
|||
# define OCSP_F_OCSP_PARSE_URL 114 |
|||
# define OCSP_F_OCSP_REQUEST_SIGN 110 |
|||
# define OCSP_F_OCSP_REQUEST_VERIFY 116 |
|||
# define OCSP_F_OCSP_RESPONSE_GET1_BASIC 111 |
|||
# define OCSP_F_OCSP_SENDREQ_BIO 112 |
|||
# define OCSP_F_OCSP_SENDREQ_NBIO 117 |
|||
# define OCSP_F_PARSE_HTTP_LINE1 118 |
|||
# define OCSP_F_REQUEST_VERIFY 113 |
|||
|
|||
/* Reason codes. */ |
|||
# define OCSP_R_BAD_DATA 100 |
|||
# define OCSP_R_CERTIFICATE_VERIFY_ERROR 101 |
|||
# define OCSP_R_DIGEST_ERR 102 |
|||
# define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD 122 |
|||
# define OCSP_R_ERROR_IN_THISUPDATE_FIELD 123 |
|||
# define OCSP_R_ERROR_PARSING_URL 121 |
|||
# define OCSP_R_MISSING_OCSPSIGNING_USAGE 103 |
|||
# define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE 124 |
|||
# define OCSP_R_NOT_BASIC_RESPONSE 104 |
|||
# define OCSP_R_NO_CERTIFICATES_IN_CHAIN 105 |
|||
# define OCSP_R_NO_CONTENT 106 |
|||
# define OCSP_R_NO_PUBLIC_KEY 107 |
|||
# define OCSP_R_NO_RESPONSE_DATA 108 |
|||
# define OCSP_R_NO_REVOKED_TIME 109 |
|||
# define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 110 |
|||
# define OCSP_R_REQUEST_NOT_SIGNED 128 |
|||
# define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA 111 |
|||
# define OCSP_R_ROOT_CA_NOT_TRUSTED 112 |
|||
# define OCSP_R_SERVER_READ_ERROR 113 |
|||
# define OCSP_R_SERVER_RESPONSE_ERROR 114 |
|||
# define OCSP_R_SERVER_RESPONSE_PARSE_ERROR 115 |
|||
# define OCSP_R_SERVER_WRITE_ERROR 116 |
|||
# define OCSP_R_SIGNATURE_FAILURE 117 |
|||
# define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND 118 |
|||
# define OCSP_R_STATUS_EXPIRED 125 |
|||
# define OCSP_R_STATUS_NOT_YET_VALID 126 |
|||
# define OCSP_R_STATUS_TOO_OLD 127 |
|||
# define OCSP_R_UNKNOWN_MESSAGE_DIGEST 119 |
|||
# define OCSP_R_UNKNOWN_NID 120 |
|||
# define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE 129 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1 +0,0 @@ |
|||
#include "../../crypto/opensslconf.h" |
|||
@ -1,97 +0,0 @@ |
|||
#ifndef HEADER_OPENSSLV_H |
|||
# define HEADER_OPENSSLV_H |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/*-
|
|||
* Numeric release version identifier: |
|||
* MNNFFPPS: major minor fix patch status |
|||
* The status nibble has one of the values 0 for development, 1 to e for betas |
|||
* 1 to 14, and f for release. The patch level is exactly that. |
|||
* For example: |
|||
* 0.9.3-dev 0x00903000 |
|||
* 0.9.3-beta1 0x00903001 |
|||
* 0.9.3-beta2-dev 0x00903002 |
|||
* 0.9.3-beta2 0x00903002 (same as ...beta2-dev) |
|||
* 0.9.3 0x0090300f |
|||
* 0.9.3a 0x0090301f |
|||
* 0.9.4 0x0090400f |
|||
* 1.2.3z 0x102031af |
|||
* |
|||
* For continuity reasons (because 0.9.5 is already out, and is coded |
|||
* 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level |
|||
* part is slightly different, by setting the highest bit. This means |
|||
* that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start |
|||
* with 0x0090600S... |
|||
* |
|||
* (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.) |
|||
* (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for |
|||
* major minor fix final patch/beta) |
|||
*/ |
|||
# define OPENSSL_VERSION_NUMBER 0x1000113fL |
|||
# ifdef OPENSSL_FIPS |
|||
# define OPENSSL_VERSION_TEXT "OpenSSL 1.0.1s-fips 1 Mar 2016" |
|||
# else |
|||
# define OPENSSL_VERSION_TEXT "OpenSSL 1.0.1s 1 Mar 2016" |
|||
# endif |
|||
# define OPENSSL_VERSION_PTEXT " part of " OPENSSL_VERSION_TEXT |
|||
|
|||
/*-
|
|||
* The macros below are to be used for shared library (.so, .dll, ...) |
|||
* versioning. That kind of versioning works a bit differently between |
|||
* operating systems. The most usual scheme is to set a major and a minor |
|||
* number, and have the runtime loader check that the major number is equal |
|||
* to what it was at application link time, while the minor number has to |
|||
* be greater or equal to what it was at application link time. With this |
|||
* scheme, the version number is usually part of the file name, like this: |
|||
* |
|||
* libcrypto.so.0.9 |
|||
* |
|||
* Some unixen also make a softlink with the major verson number only: |
|||
* |
|||
* libcrypto.so.0 |
|||
* |
|||
* On Tru64 and IRIX 6.x it works a little bit differently. There, the |
|||
* shared library version is stored in the file, and is actually a series |
|||
* of versions, separated by colons. The rightmost version present in the |
|||
* library when linking an application is stored in the application to be |
|||
* matched at run time. When the application is run, a check is done to |
|||
* see if the library version stored in the application matches any of the |
|||
* versions in the version string of the library itself. |
|||
* This version string can be constructed in any way, depending on what |
|||
* kind of matching is desired. However, to implement the same scheme as |
|||
* the one used in the other unixen, all compatible versions, from lowest |
|||
* to highest, should be part of the string. Consecutive builds would |
|||
* give the following versions strings: |
|||
* |
|||
* 3.0 |
|||
* 3.0:3.1 |
|||
* 3.0:3.1:3.2 |
|||
* 4.0 |
|||
* 4.0:4.1 |
|||
* |
|||
* Notice how version 4 is completely incompatible with version, and |
|||
* therefore give the breach you can see. |
|||
* |
|||
* There may be other schemes as well that I haven't yet discovered. |
|||
* |
|||
* So, here's the way it works here: first of all, the library version |
|||
* number doesn't need at all to match the overall OpenSSL version. |
|||
* However, it's nice and more understandable if it actually does. |
|||
* The current library version is stored in the macro SHLIB_VERSION_NUMBER, |
|||
* which is just a piece of text in the format "M.m.e" (Major, minor, edit). |
|||
* For the sake of Tru64, IRIX, and any other OS that behaves in similar ways, |
|||
* we need to keep a history of version numbers, which is done in the |
|||
* macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and |
|||
* should only keep the versions that are binary compatible with the current. |
|||
*/ |
|||
# define SHLIB_VERSION_HISTORY "" |
|||
# define SHLIB_VERSION_NUMBER "1.0.0" |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif /* HEADER_OPENSSLV_H */ |
|||
@ -1,209 +0,0 @@ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_OPENSSL_TYPES_H |
|||
# define HEADER_OPENSSL_TYPES_H |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# include <openssl/e_os2.h> |
|||
|
|||
# ifdef NO_ASN1_TYPEDEFS |
|||
# define ASN1_INTEGER ASN1_STRING |
|||
# define ASN1_ENUMERATED ASN1_STRING |
|||
# define ASN1_BIT_STRING ASN1_STRING |
|||
# define ASN1_OCTET_STRING ASN1_STRING |
|||
# define ASN1_PRINTABLESTRING ASN1_STRING |
|||
# define ASN1_T61STRING ASN1_STRING |
|||
# define ASN1_IA5STRING ASN1_STRING |
|||
# define ASN1_UTCTIME ASN1_STRING |
|||
# define ASN1_GENERALIZEDTIME ASN1_STRING |
|||
# define ASN1_TIME ASN1_STRING |
|||
# define ASN1_GENERALSTRING ASN1_STRING |
|||
# define ASN1_UNIVERSALSTRING ASN1_STRING |
|||
# define ASN1_BMPSTRING ASN1_STRING |
|||
# define ASN1_VISIBLESTRING ASN1_STRING |
|||
# define ASN1_UTF8STRING ASN1_STRING |
|||
# define ASN1_BOOLEAN int |
|||
# define ASN1_NULL int |
|||
# else |
|||
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; |
|||
# endif |
|||
|
|||
typedef struct ASN1_ITEM_st ASN1_ITEM; |
|||
typedef struct asn1_pctx_st ASN1_PCTX; |
|||
|
|||
# ifdef OPENSSL_SYS_WIN32 |
|||
# undef X509_NAME |
|||
# undef X509_EXTENSIONS |
|||
# undef X509_CERT_PAIR |
|||
# undef PKCS7_ISSUER_AND_SERIAL |
|||
# undef OCSP_REQUEST |
|||
# undef OCSP_RESPONSE |
|||
# endif |
|||
|
|||
# ifdef BIGNUM |
|||
# undef BIGNUM |
|||
# endif |
|||
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; |
|||
|
|||
/* If placed in pkcs12.h, we end up with a circular depency with pkcs7.h */ |
|||
# define DECLARE_PKCS12_STACK_OF(type)/* Nothing */ |
|||
# define IMPLEMENT_PKCS12_STACK_OF(type)/* Nothing */ |
|||
|
|||
typedef struct crypto_ex_data_st CRYPTO_EX_DATA; |
|||
/* Callback types for crypto.h */ |
|||
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; |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif /* def HEADER_OPENSSL_TYPES_H */ |
|||
@ -1,611 +0,0 @@ |
|||
/* crypto/pem/pem.h */ |
|||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_PEM_H |
|||
# define HEADER_PEM_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
# ifndef OPENSSL_NO_BIO |
|||
# include <openssl/bio.h> |
|||
# endif |
|||
# ifndef OPENSSL_NO_STACK |
|||
# include <openssl/stack.h> |
|||
# endif |
|||
# include <openssl/evp.h> |
|||
# include <openssl/x509.h> |
|||
# include <openssl/pem2.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# define PEM_BUFSIZE 1024 |
|||
|
|||
# define PEM_OBJ_UNDEF 0 |
|||
# define PEM_OBJ_X509 1 |
|||
# define PEM_OBJ_X509_REQ 2 |
|||
# define PEM_OBJ_CRL 3 |
|||
# define PEM_OBJ_SSL_SESSION 4 |
|||
# define PEM_OBJ_PRIV_KEY 10 |
|||
# define PEM_OBJ_PRIV_RSA 11 |
|||
# define PEM_OBJ_PRIV_DSA 12 |
|||
# define PEM_OBJ_PRIV_DH 13 |
|||
# define PEM_OBJ_PUB_RSA 14 |
|||
# define PEM_OBJ_PUB_DSA 15 |
|||
# define PEM_OBJ_PUB_DH 16 |
|||
# define PEM_OBJ_DHPARAMS 17 |
|||
# define PEM_OBJ_DSAPARAMS 18 |
|||
# define PEM_OBJ_PRIV_RSA_PUBLIC 19 |
|||
# define PEM_OBJ_PRIV_ECDSA 20 |
|||
# define PEM_OBJ_PUB_ECDSA 21 |
|||
# define PEM_OBJ_ECPARAMETERS 22 |
|||
|
|||
# define PEM_ERROR 30 |
|||
# define PEM_DEK_DES_CBC 40 |
|||
# define PEM_DEK_IDEA_CBC 45 |
|||
# define PEM_DEK_DES_EDE 50 |
|||
# define PEM_DEK_DES_ECB 60 |
|||
# define PEM_DEK_RSA 70 |
|||
# define PEM_DEK_RSA_MD2 80 |
|||
# define PEM_DEK_RSA_MD5 90 |
|||
|
|||
# define PEM_MD_MD2 NID_md2 |
|||
# define PEM_MD_MD5 NID_md5 |
|||
# define PEM_MD_SHA NID_sha |
|||
# define PEM_MD_MD2_RSA NID_md2WithRSAEncryption |
|||
# define PEM_MD_MD5_RSA NID_md5WithRSAEncryption |
|||
# define PEM_MD_SHA_RSA NID_sha1WithRSAEncryption |
|||
|
|||
# define PEM_STRING_X509_OLD "X509 CERTIFICATE" |
|||
# define PEM_STRING_X509 "CERTIFICATE" |
|||
# define PEM_STRING_X509_PAIR "CERTIFICATE PAIR" |
|||
# define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE" |
|||
# define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST" |
|||
# define PEM_STRING_X509_REQ "CERTIFICATE REQUEST" |
|||
# define PEM_STRING_X509_CRL "X509 CRL" |
|||
# define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY" |
|||
# define PEM_STRING_PUBLIC "PUBLIC KEY" |
|||
# define PEM_STRING_RSA "RSA PRIVATE KEY" |
|||
# define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY" |
|||
# define PEM_STRING_DSA "DSA PRIVATE KEY" |
|||
# define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY" |
|||
# define PEM_STRING_PKCS7 "PKCS7" |
|||
# define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA" |
|||
# define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY" |
|||
# define PEM_STRING_PKCS8INF "PRIVATE KEY" |
|||
# define PEM_STRING_DHPARAMS "DH PARAMETERS" |
|||
# define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS" |
|||
# define PEM_STRING_DSAPARAMS "DSA PARAMETERS" |
|||
# define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY" |
|||
# define PEM_STRING_ECPARAMETERS "EC PARAMETERS" |
|||
# define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY" |
|||
# define PEM_STRING_PARAMETERS "PARAMETERS" |
|||
# define PEM_STRING_CMS "CMS" |
|||
|
|||
/*
|
|||
* Note that this structure is initialised by PEM_SealInit and cleaned up |
|||
* by PEM_SealFinal (at least for now) |
|||
*/ |
|||
typedef struct PEM_Encode_Seal_st { |
|||
EVP_ENCODE_CTX encode; |
|||
EVP_MD_CTX md; |
|||
EVP_CIPHER_CTX cipher; |
|||
} PEM_ENCODE_SEAL_CTX; |
|||
|
|||
/* enc_type is one off */ |
|||
# define PEM_TYPE_ENCRYPTED 10 |
|||
# define PEM_TYPE_MIC_ONLY 20 |
|||
# define PEM_TYPE_MIC_CLEAR 30 |
|||
# define PEM_TYPE_CLEAR 40 |
|||
|
|||
typedef struct pem_recip_st { |
|||
char *name; |
|||
X509_NAME *dn; |
|||
int cipher; |
|||
int key_enc; |
|||
/* char iv[8]; unused and wrong size */ |
|||
} PEM_USER; |
|||
|
|||
typedef struct pem_ctx_st { |
|||
int type; /* what type of object */ |
|||
struct { |
|||
int version; |
|||
int mode; |
|||
} proc_type; |
|||
|
|||
char *domain; |
|||
|
|||
struct { |
|||
int cipher; |
|||
/*-
|
|||
unused, and wrong size |
|||
unsigned char iv[8]; */ |
|||
} DEK_info; |
|||
|
|||
PEM_USER *originator; |
|||
|
|||
int num_recipient; |
|||
PEM_USER **recipient; |
|||
|
|||
/*-
|
|||
XXX(ben): don#t think this is used! |
|||
STACK *x509_chain; / * certificate chain */ |
|||
EVP_MD *md; /* signature type */ |
|||
|
|||
int md_enc; /* is the md encrypted or not? */ |
|||
int md_len; /* length of md_data */ |
|||
char *md_data; /* message digest, could be pkey encrypted */ |
|||
|
|||
EVP_CIPHER *dec; /* date encryption cipher */ |
|||
int key_len; /* key length */ |
|||
unsigned char *key; /* key */ |
|||
/*-
|
|||
unused, and wrong size |
|||
unsigned char iv[8]; */ |
|||
|
|||
int data_enc; /* is the data encrypted */ |
|||
int data_len; |
|||
unsigned char *data; |
|||
} PEM_CTX; |
|||
|
|||
/*
|
|||
* These macros make the PEM_read/PEM_write functions easier to maintain and |
|||
* write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or |
|||
* IMPLEMENT_PEM_rw_cb(...) |
|||
*/ |
|||
|
|||
# ifdef OPENSSL_NO_FP_API |
|||
|
|||
# define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/ |
|||
# define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/ |
|||
# define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/ |
|||
# define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/ |
|||
# define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/ |
|||
# else |
|||
|
|||
# define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \ |
|||
type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\ |
|||
{ \ |
|||
return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str,fp,(void **)x,cb,u); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \ |
|||
int PEM_write_##name(FILE *fp, type *x) \ |
|||
{ \ |
|||
return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \ |
|||
int PEM_write_##name(FILE *fp, const type *x) \ |
|||
{ \ |
|||
return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,(void *)x,NULL,NULL,0,NULL,NULL); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \ |
|||
int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ |
|||
unsigned char *kstr, int klen, pem_password_cb *cb, \ |
|||
void *u) \ |
|||
{ \ |
|||
return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \ |
|||
int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ |
|||
unsigned char *kstr, int klen, pem_password_cb *cb, \ |
|||
void *u) \ |
|||
{ \ |
|||
return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ |
|||
} |
|||
|
|||
# endif |
|||
|
|||
# define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ |
|||
type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\ |
|||
{ \ |
|||
return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str,bp,(void **)x,cb,u); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ |
|||
int PEM_write_bio_##name(BIO *bp, type *x) \ |
|||
{ \ |
|||
return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ |
|||
int PEM_write_bio_##name(BIO *bp, const type *x) \ |
|||
{ \ |
|||
return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,NULL,NULL,0,NULL,NULL); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ |
|||
int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ |
|||
unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ |
|||
{ \ |
|||
return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ |
|||
int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ |
|||
unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ |
|||
{ \ |
|||
return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,enc,kstr,klen,cb,u); \ |
|||
} |
|||
|
|||
# define IMPLEMENT_PEM_write(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_fp(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_write_const(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_read(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_read_fp(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_rw(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_read(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_read(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_const(name, type, str, asn1) |
|||
|
|||
# define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_read(name, type, str, asn1) \ |
|||
IMPLEMENT_PEM_write_cb(name, type, str, asn1) |
|||
|
|||
/* These are the same except they are for the declarations */ |
|||
|
|||
# if defined(OPENSSL_NO_FP_API) |
|||
|
|||
# define DECLARE_PEM_read_fp(name, type) /**/ |
|||
# define DECLARE_PEM_write_fp(name, type) /**/ |
|||
# define DECLARE_PEM_write_cb_fp(name, type) /**/ |
|||
# else |
|||
|
|||
# define DECLARE_PEM_read_fp(name, type) \ |
|||
type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u); |
|||
|
|||
# define DECLARE_PEM_write_fp(name, type) \ |
|||
int PEM_write_##name(FILE *fp, type *x); |
|||
|
|||
# define DECLARE_PEM_write_fp_const(name, type) \ |
|||
int PEM_write_##name(FILE *fp, const type *x); |
|||
|
|||
# define DECLARE_PEM_write_cb_fp(name, type) \ |
|||
int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ |
|||
unsigned char *kstr, int klen, pem_password_cb *cb, void *u); |
|||
|
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
# define DECLARE_PEM_read_bio(name, type) \ |
|||
type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u); |
|||
|
|||
# define DECLARE_PEM_write_bio(name, type) \ |
|||
int PEM_write_bio_##name(BIO *bp, type *x); |
|||
|
|||
# define DECLARE_PEM_write_bio_const(name, type) \ |
|||
int PEM_write_bio_##name(BIO *bp, const type *x); |
|||
|
|||
# define DECLARE_PEM_write_cb_bio(name, type) \ |
|||
int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ |
|||
unsigned char *kstr, int klen, pem_password_cb *cb, void *u); |
|||
|
|||
# else |
|||
|
|||
# define DECLARE_PEM_read_bio(name, type) /**/ |
|||
# define DECLARE_PEM_write_bio(name, type) /**/ |
|||
# define DECLARE_PEM_write_bio_const(name, type) /**/ |
|||
# define DECLARE_PEM_write_cb_bio(name, type) /**/ |
|||
# endif |
|||
# define DECLARE_PEM_write(name, type) \ |
|||
DECLARE_PEM_write_bio(name, type) \ |
|||
DECLARE_PEM_write_fp(name, type) |
|||
# define DECLARE_PEM_write_const(name, type) \ |
|||
DECLARE_PEM_write_bio_const(name, type) \ |
|||
DECLARE_PEM_write_fp_const(name, type) |
|||
# define DECLARE_PEM_write_cb(name, type) \ |
|||
DECLARE_PEM_write_cb_bio(name, type) \ |
|||
DECLARE_PEM_write_cb_fp(name, type) |
|||
# define DECLARE_PEM_read(name, type) \ |
|||
DECLARE_PEM_read_bio(name, type) \ |
|||
DECLARE_PEM_read_fp(name, type) |
|||
# define DECLARE_PEM_rw(name, type) \ |
|||
DECLARE_PEM_read(name, type) \ |
|||
DECLARE_PEM_write(name, type) |
|||
# define DECLARE_PEM_rw_const(name, type) \ |
|||
DECLARE_PEM_read(name, type) \ |
|||
DECLARE_PEM_write_const(name, type) |
|||
# define DECLARE_PEM_rw_cb(name, type) \ |
|||
DECLARE_PEM_read(name, type) \ |
|||
DECLARE_PEM_write_cb(name, type) |
|||
# if 1 |
|||
/* "userdata": new with OpenSSL 0.9.4 */ |
|||
typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata); |
|||
# else |
|||
/* OpenSSL 0.9.3, 0.9.3a */ |
|||
typedef int pem_password_cb (char *buf, int size, int rwflag); |
|||
# endif |
|||
|
|||
int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher); |
|||
int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len, |
|||
pem_password_cb *callback, void *u); |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
int PEM_read_bio(BIO *bp, char **name, char **header, |
|||
unsigned char **data, long *len); |
|||
int PEM_write_bio(BIO *bp, const char *name, char *hdr, unsigned char *data, |
|||
long len); |
|||
int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, |
|||
const char *name, BIO *bp, pem_password_cb *cb, |
|||
void *u); |
|||
void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x, |
|||
pem_password_cb *cb, void *u); |
|||
int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x, |
|||
const EVP_CIPHER *enc, unsigned char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
|
|||
STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, |
|||
pem_password_cb *cb, void *u); |
|||
int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc, |
|||
unsigned char *kstr, int klen, |
|||
pem_password_cb *cd, void *u); |
|||
# endif |
|||
|
|||
int PEM_read(FILE *fp, char **name, char **header, |
|||
unsigned char **data, long *len); |
|||
int PEM_write(FILE *fp, char *name, char *hdr, unsigned char *data, long len); |
|||
void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x, |
|||
pem_password_cb *cb, void *u); |
|||
int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, |
|||
void *x, const EVP_CIPHER *enc, unsigned char *kstr, |
|||
int klen, pem_password_cb *callback, void *u); |
|||
STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, |
|||
pem_password_cb *cb, void *u); |
|||
|
|||
int PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type, |
|||
EVP_MD *md_type, unsigned char **ek, int *ekl, |
|||
unsigned char *iv, EVP_PKEY **pubk, int npubk); |
|||
void PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl, |
|||
unsigned char *in, int inl); |
|||
int PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig, int *sigl, |
|||
unsigned char *out, int *outl, EVP_PKEY *priv); |
|||
|
|||
void PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type); |
|||
void PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *d, unsigned int cnt); |
|||
int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, |
|||
unsigned int *siglen, EVP_PKEY *pkey); |
|||
|
|||
int PEM_def_callback(char *buf, int num, int w, void *key); |
|||
void PEM_proc_type(char *buf, int type); |
|||
void PEM_dek_info(char *buf, const char *type, int len, char *str); |
|||
|
|||
# include <openssl/symhacks.h> |
|||
|
|||
DECLARE_PEM_rw(X509, X509) |
|||
DECLARE_PEM_rw(X509_AUX, X509) |
|||
DECLARE_PEM_rw(X509_CERT_PAIR, X509_CERT_PAIR) |
|||
DECLARE_PEM_rw(X509_REQ, X509_REQ) |
|||
DECLARE_PEM_write(X509_REQ_NEW, X509_REQ) |
|||
DECLARE_PEM_rw(X509_CRL, X509_CRL) |
|||
DECLARE_PEM_rw(PKCS7, PKCS7) |
|||
DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE) |
|||
DECLARE_PEM_rw(PKCS8, X509_SIG) |
|||
DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO) |
|||
# ifndef OPENSSL_NO_RSA |
|||
DECLARE_PEM_rw_cb(RSAPrivateKey, RSA) |
|||
DECLARE_PEM_rw_const(RSAPublicKey, RSA) |
|||
DECLARE_PEM_rw(RSA_PUBKEY, RSA) |
|||
# endif |
|||
# ifndef OPENSSL_NO_DSA |
|||
DECLARE_PEM_rw_cb(DSAPrivateKey, DSA) |
|||
DECLARE_PEM_rw(DSA_PUBKEY, DSA) |
|||
DECLARE_PEM_rw_const(DSAparams, DSA) |
|||
# endif |
|||
# ifndef OPENSSL_NO_EC |
|||
DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP) |
|||
DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY) |
|||
DECLARE_PEM_rw(EC_PUBKEY, EC_KEY) |
|||
# endif |
|||
# ifndef OPENSSL_NO_DH |
|||
DECLARE_PEM_rw_const(DHparams, DH) |
|||
# endif |
|||
DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY) |
|||
DECLARE_PEM_rw(PUBKEY, EVP_PKEY) |
|||
|
|||
int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid, |
|||
char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *, |
|||
char *, int, pem_password_cb *, void *); |
|||
int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc, |
|||
char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid, |
|||
char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, |
|||
void *u); |
|||
|
|||
int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, |
|||
char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid, |
|||
char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid, |
|||
char *kstr, int klen, |
|||
pem_password_cb *cb, void *u); |
|||
|
|||
EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, |
|||
void *u); |
|||
|
|||
int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, |
|||
char *kstr, int klen, pem_password_cb *cd, |
|||
void *u); |
|||
|
|||
EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x); |
|||
int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x); |
|||
|
|||
EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length); |
|||
EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length); |
|||
EVP_PKEY *b2i_PrivateKey_bio(BIO *in); |
|||
EVP_PKEY *b2i_PublicKey_bio(BIO *in); |
|||
int i2b_PrivateKey_bio(BIO *out, EVP_PKEY *pk); |
|||
int i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk); |
|||
# ifndef OPENSSL_NO_RC4 |
|||
EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u); |
|||
int i2b_PVK_bio(BIO *out, EVP_PKEY *pk, int enclevel, |
|||
pem_password_cb *cb, void *u); |
|||
# endif |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_PEM_strings(void); |
|||
|
|||
/* Error codes for the PEM functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define PEM_F_B2I_DSS 127 |
|||
# define PEM_F_B2I_PVK_BIO 128 |
|||
# define PEM_F_B2I_RSA 129 |
|||
# define PEM_F_CHECK_BITLEN_DSA 130 |
|||
# define PEM_F_CHECK_BITLEN_RSA 131 |
|||
# define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 120 |
|||
# define PEM_F_D2I_PKCS8PRIVATEKEY_FP 121 |
|||
# define PEM_F_DO_B2I 132 |
|||
# define PEM_F_DO_B2I_BIO 133 |
|||
# define PEM_F_DO_BLOB_HEADER 134 |
|||
# define PEM_F_DO_PK8PKEY 126 |
|||
# define PEM_F_DO_PK8PKEY_FP 125 |
|||
# define PEM_F_DO_PVK_BODY 135 |
|||
# define PEM_F_DO_PVK_HEADER 136 |
|||
# define PEM_F_I2B_PVK 137 |
|||
# define PEM_F_I2B_PVK_BIO 138 |
|||
# define PEM_F_LOAD_IV 101 |
|||
# define PEM_F_PEM_ASN1_READ 102 |
|||
# define PEM_F_PEM_ASN1_READ_BIO 103 |
|||
# define PEM_F_PEM_ASN1_WRITE 104 |
|||
# define PEM_F_PEM_ASN1_WRITE_BIO 105 |
|||
# define PEM_F_PEM_DEF_CALLBACK 100 |
|||
# define PEM_F_PEM_DO_HEADER 106 |
|||
# define PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY 118 |
|||
# define PEM_F_PEM_GET_EVP_CIPHER_INFO 107 |
|||
# define PEM_F_PEM_PK8PKEY 119 |
|||
# define PEM_F_PEM_READ 108 |
|||
# define PEM_F_PEM_READ_BIO 109 |
|||
# define PEM_F_PEM_READ_BIO_PARAMETERS 140 |
|||
# define PEM_F_PEM_READ_BIO_PRIVATEKEY 123 |
|||
# define PEM_F_PEM_READ_PRIVATEKEY 124 |
|||
# define PEM_F_PEM_SEALFINAL 110 |
|||
# define PEM_F_PEM_SEALINIT 111 |
|||
# define PEM_F_PEM_SIGNFINAL 112 |
|||
# define PEM_F_PEM_WRITE 113 |
|||
# define PEM_F_PEM_WRITE_BIO 114 |
|||
# define PEM_F_PEM_WRITE_PRIVATEKEY 139 |
|||
# define PEM_F_PEM_X509_INFO_READ 115 |
|||
# define PEM_F_PEM_X509_INFO_READ_BIO 116 |
|||
# define PEM_F_PEM_X509_INFO_WRITE_BIO 117 |
|||
|
|||
/* Reason codes. */ |
|||
# define PEM_R_BAD_BASE64_DECODE 100 |
|||
# define PEM_R_BAD_DECRYPT 101 |
|||
# define PEM_R_BAD_END_LINE 102 |
|||
# define PEM_R_BAD_IV_CHARS 103 |
|||
# define PEM_R_BAD_MAGIC_NUMBER 116 |
|||
# define PEM_R_BAD_PASSWORD_READ 104 |
|||
# define PEM_R_BAD_VERSION_NUMBER 117 |
|||
# define PEM_R_BIO_WRITE_FAILURE 118 |
|||
# define PEM_R_CIPHER_IS_NULL 127 |
|||
# define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115 |
|||
# define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119 |
|||
# define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120 |
|||
# define PEM_R_INCONSISTENT_HEADER 121 |
|||
# define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122 |
|||
# define PEM_R_KEYBLOB_TOO_SHORT 123 |
|||
# define PEM_R_NOT_DEK_INFO 105 |
|||
# define PEM_R_NOT_ENCRYPTED 106 |
|||
# define PEM_R_NOT_PROC_TYPE 107 |
|||
# define PEM_R_NO_START_LINE 108 |
|||
# define PEM_R_PROBLEMS_GETTING_PASSWORD 109 |
|||
# define PEM_R_PUBLIC_KEY_NO_RSA 110 |
|||
# define PEM_R_PVK_DATA_TOO_SHORT 124 |
|||
# define PEM_R_PVK_TOO_SHORT 125 |
|||
# define PEM_R_READ_KEY 111 |
|||
# define PEM_R_SHORT_HEADER 112 |
|||
# define PEM_R_UNSUPPORTED_CIPHER 113 |
|||
# define PEM_R_UNSUPPORTED_ENCRYPTION 114 |
|||
# define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,70 +0,0 @@ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1999 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
/*
|
|||
* This header only exists to break a circular dependency between pem and err |
|||
* Ben 30 Jan 1999. |
|||
*/ |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
#ifndef HEADER_PEM_H |
|||
void ERR_load_PEM_strings(void); |
|||
#endif |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
@ -1,342 +0,0 @@ |
|||
/* pkcs12.h */ |
|||
/*
|
|||
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project |
|||
* 1999. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1999 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_PKCS12_H |
|||
# define HEADER_PKCS12_H |
|||
|
|||
# include <openssl/bio.h> |
|||
# include <openssl/x509.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# define PKCS12_KEY_ID 1 |
|||
# define PKCS12_IV_ID 2 |
|||
# define PKCS12_MAC_ID 3 |
|||
|
|||
/* Default iteration count */ |
|||
# ifndef PKCS12_DEFAULT_ITER |
|||
# define PKCS12_DEFAULT_ITER PKCS5_DEFAULT_ITER |
|||
# endif |
|||
|
|||
# define PKCS12_MAC_KEY_LENGTH 20 |
|||
|
|||
# define PKCS12_SALT_LEN 8 |
|||
|
|||
/* Uncomment out next line for unicode password and names, otherwise ASCII */ |
|||
|
|||
/*
|
|||
* #define PBE_UNICODE |
|||
*/ |
|||
|
|||
# ifdef PBE_UNICODE |
|||
# define PKCS12_key_gen PKCS12_key_gen_uni |
|||
# define PKCS12_add_friendlyname PKCS12_add_friendlyname_uni |
|||
# else |
|||
# define PKCS12_key_gen PKCS12_key_gen_asc |
|||
# define PKCS12_add_friendlyname PKCS12_add_friendlyname_asc |
|||
# endif |
|||
|
|||
/* MS key usage constants */ |
|||
|
|||
# define KEY_EX 0x10 |
|||
# define KEY_SIG 0x80 |
|||
|
|||
typedef struct { |
|||
X509_SIG *dinfo; |
|||
ASN1_OCTET_STRING *salt; |
|||
ASN1_INTEGER *iter; /* defaults to 1 */ |
|||
} PKCS12_MAC_DATA; |
|||
|
|||
typedef struct { |
|||
ASN1_INTEGER *version; |
|||
PKCS12_MAC_DATA *mac; |
|||
PKCS7 *authsafes; |
|||
} PKCS12; |
|||
|
|||
typedef struct { |
|||
ASN1_OBJECT *type; |
|||
union { |
|||
struct pkcs12_bag_st *bag; /* secret, crl and certbag */ |
|||
struct pkcs8_priv_key_info_st *keybag; /* keybag */ |
|||
X509_SIG *shkeybag; /* shrouded key bag */ |
|||
STACK_OF(PKCS12_SAFEBAG) *safes; |
|||
ASN1_TYPE *other; |
|||
} value; |
|||
STACK_OF(X509_ATTRIBUTE) *attrib; |
|||
} PKCS12_SAFEBAG; |
|||
|
|||
DECLARE_STACK_OF(PKCS12_SAFEBAG) |
|||
DECLARE_ASN1_SET_OF(PKCS12_SAFEBAG) |
|||
DECLARE_PKCS12_STACK_OF(PKCS12_SAFEBAG) |
|||
|
|||
typedef struct pkcs12_bag_st { |
|||
ASN1_OBJECT *type; |
|||
union { |
|||
ASN1_OCTET_STRING *x509cert; |
|||
ASN1_OCTET_STRING *x509crl; |
|||
ASN1_OCTET_STRING *octet; |
|||
ASN1_IA5STRING *sdsicert; |
|||
ASN1_TYPE *other; /* Secret or other bag */ |
|||
} value; |
|||
} PKCS12_BAGS; |
|||
|
|||
# define PKCS12_ERROR 0 |
|||
# define PKCS12_OK 1 |
|||
|
|||
/* Compatibility macros */ |
|||
|
|||
# define M_PKCS12_x5092certbag PKCS12_x5092certbag |
|||
# define M_PKCS12_x509crl2certbag PKCS12_x509crl2certbag |
|||
|
|||
# define M_PKCS12_certbag2x509 PKCS12_certbag2x509 |
|||
# define M_PKCS12_certbag2x509crl PKCS12_certbag2x509crl |
|||
|
|||
# define M_PKCS12_unpack_p7data PKCS12_unpack_p7data |
|||
# define M_PKCS12_pack_authsafes PKCS12_pack_authsafes |
|||
# define M_PKCS12_unpack_authsafes PKCS12_unpack_authsafes |
|||
# define M_PKCS12_unpack_p7encdata PKCS12_unpack_p7encdata |
|||
|
|||
# define M_PKCS12_decrypt_skey PKCS12_decrypt_skey |
|||
# define M_PKCS8_decrypt PKCS8_decrypt |
|||
|
|||
# define M_PKCS12_bag_type(bg) OBJ_obj2nid((bg)->type) |
|||
# define M_PKCS12_cert_bag_type(bg) OBJ_obj2nid((bg)->value.bag->type) |
|||
# define M_PKCS12_crl_bag_type M_PKCS12_cert_bag_type |
|||
|
|||
# define PKCS12_get_attr(bag, attr_nid) \ |
|||
PKCS12_get_attr_gen(bag->attrib, attr_nid) |
|||
|
|||
# define PKCS8_get_attr(p8, attr_nid) \ |
|||
PKCS12_get_attr_gen(p8->attributes, attr_nid) |
|||
|
|||
# define PKCS12_mac_present(p12) ((p12)->mac ? 1 : 0) |
|||
|
|||
PKCS12_SAFEBAG *PKCS12_x5092certbag(X509 *x509); |
|||
PKCS12_SAFEBAG *PKCS12_x509crl2certbag(X509_CRL *crl); |
|||
X509 *PKCS12_certbag2x509(PKCS12_SAFEBAG *bag); |
|||
X509_CRL *PKCS12_certbag2x509crl(PKCS12_SAFEBAG *bag); |
|||
|
|||
PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it, |
|||
int nid1, int nid2); |
|||
PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG(PKCS8_PRIV_KEY_INFO *p8); |
|||
PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(X509_SIG *p8, const char *pass, |
|||
int passlen); |
|||
PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(PKCS12_SAFEBAG *bag, |
|||
const char *pass, int passlen); |
|||
X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher, |
|||
const char *pass, int passlen, unsigned char *salt, |
|||
int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8); |
|||
PKCS12_SAFEBAG *PKCS12_MAKE_SHKEYBAG(int pbe_nid, const char *pass, |
|||
int passlen, unsigned char *salt, |
|||
int saltlen, int iter, |
|||
PKCS8_PRIV_KEY_INFO *p8); |
|||
PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk); |
|||
STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7); |
|||
PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen, |
|||
unsigned char *salt, int saltlen, int iter, |
|||
STACK_OF(PKCS12_SAFEBAG) *bags); |
|||
STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, |
|||
int passlen); |
|||
|
|||
int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes); |
|||
STACK_OF(PKCS7) *PKCS12_unpack_authsafes(PKCS12 *p12); |
|||
|
|||
int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, |
|||
int namelen); |
|||
int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name, |
|||
int namelen); |
|||
int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, |
|||
int namelen); |
|||
int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag, |
|||
const unsigned char *name, int namelen); |
|||
int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage); |
|||
ASN1_TYPE *PKCS12_get_attr_gen(STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid); |
|||
char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag); |
|||
unsigned char *PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass, |
|||
int passlen, unsigned char *in, int inlen, |
|||
unsigned char **data, int *datalen, |
|||
int en_de); |
|||
void *PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it, |
|||
const char *pass, int passlen, |
|||
ASN1_OCTET_STRING *oct, int zbuf); |
|||
ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor, |
|||
const ASN1_ITEM *it, |
|||
const char *pass, int passlen, |
|||
void *obj, int zbuf); |
|||
PKCS12 *PKCS12_init(int mode); |
|||
int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt, |
|||
int saltlen, int id, int iter, int n, |
|||
unsigned char *out, const EVP_MD *md_type); |
|||
int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt, |
|||
int saltlen, int id, int iter, int n, |
|||
unsigned char *out, const EVP_MD *md_type); |
|||
int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, |
|||
ASN1_TYPE *param, const EVP_CIPHER *cipher, |
|||
const EVP_MD *md_type, int en_de); |
|||
int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen, |
|||
unsigned char *mac, unsigned int *maclen); |
|||
int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen); |
|||
int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, |
|||
unsigned char *salt, int saltlen, int iter, |
|||
const EVP_MD *md_type); |
|||
int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, |
|||
int saltlen, const EVP_MD *md_type); |
|||
unsigned char *OPENSSL_asc2uni(const char *asc, int asclen, |
|||
unsigned char **uni, int *unilen); |
|||
char *OPENSSL_uni2asc(unsigned char *uni, int unilen); |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(PKCS12) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS) |
|||
|
|||
DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS) |
|||
DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES) |
|||
|
|||
void PKCS12_PBE_add(void); |
|||
int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert, |
|||
STACK_OF(X509) **ca); |
|||
PKCS12 *PKCS12_create(char *pass, char *name, EVP_PKEY *pkey, X509 *cert, |
|||
STACK_OF(X509) *ca, int nid_key, int nid_cert, int iter, |
|||
int mac_iter, int keytype); |
|||
|
|||
PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert); |
|||
PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, |
|||
EVP_PKEY *key, int key_usage, int iter, |
|||
int key_nid, char *pass); |
|||
int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags, |
|||
int safe_nid, int iter, char *pass); |
|||
PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid); |
|||
|
|||
int i2d_PKCS12_bio(BIO *bp, PKCS12 *p12); |
|||
int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12); |
|||
PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12); |
|||
PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12); |
|||
int PKCS12_newpass(PKCS12 *p12, char *oldpass, char *newpass); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_PKCS12_strings(void); |
|||
|
|||
/* Error codes for the PKCS12 functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define PKCS12_F_PARSE_BAG 129 |
|||
# define PKCS12_F_PARSE_BAGS 103 |
|||
# define PKCS12_F_PKCS12_ADD_FRIENDLYNAME 100 |
|||
# define PKCS12_F_PKCS12_ADD_FRIENDLYNAME_ASC 127 |
|||
# define PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI 102 |
|||
# define PKCS12_F_PKCS12_ADD_LOCALKEYID 104 |
|||
# define PKCS12_F_PKCS12_CREATE 105 |
|||
# define PKCS12_F_PKCS12_GEN_MAC 107 |
|||
# define PKCS12_F_PKCS12_INIT 109 |
|||
# define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I 106 |
|||
# define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT 108 |
|||
# define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG 117 |
|||
# define PKCS12_F_PKCS12_KEY_GEN_ASC 110 |
|||
# define PKCS12_F_PKCS12_KEY_GEN_UNI 111 |
|||
# define PKCS12_F_PKCS12_MAKE_KEYBAG 112 |
|||
# define PKCS12_F_PKCS12_MAKE_SHKEYBAG 113 |
|||
# define PKCS12_F_PKCS12_NEWPASS 128 |
|||
# define PKCS12_F_PKCS12_PACK_P7DATA 114 |
|||
# define PKCS12_F_PKCS12_PACK_P7ENCDATA 115 |
|||
# define PKCS12_F_PKCS12_PARSE 118 |
|||
# define PKCS12_F_PKCS12_PBE_CRYPT 119 |
|||
# define PKCS12_F_PKCS12_PBE_KEYIVGEN 120 |
|||
# define PKCS12_F_PKCS12_SETUP_MAC 122 |
|||
# define PKCS12_F_PKCS12_SET_MAC 123 |
|||
# define PKCS12_F_PKCS12_UNPACK_AUTHSAFES 130 |
|||
# define PKCS12_F_PKCS12_UNPACK_P7DATA 131 |
|||
# define PKCS12_F_PKCS12_VERIFY_MAC 126 |
|||
# define PKCS12_F_PKCS8_ADD_KEYUSAGE 124 |
|||
# define PKCS12_F_PKCS8_ENCRYPT 125 |
|||
|
|||
/* Reason codes. */ |
|||
# define PKCS12_R_CANT_PACK_STRUCTURE 100 |
|||
# define PKCS12_R_CONTENT_TYPE_NOT_DATA 121 |
|||
# define PKCS12_R_DECODE_ERROR 101 |
|||
# define PKCS12_R_ENCODE_ERROR 102 |
|||
# define PKCS12_R_ENCRYPT_ERROR 103 |
|||
# define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE 120 |
|||
# define PKCS12_R_INVALID_NULL_ARGUMENT 104 |
|||
# define PKCS12_R_INVALID_NULL_PKCS12_POINTER 105 |
|||
# define PKCS12_R_IV_GEN_ERROR 106 |
|||
# define PKCS12_R_KEY_GEN_ERROR 107 |
|||
# define PKCS12_R_MAC_ABSENT 108 |
|||
# define PKCS12_R_MAC_GENERATION_ERROR 109 |
|||
# define PKCS12_R_MAC_SETUP_ERROR 110 |
|||
# define PKCS12_R_MAC_STRING_SET_ERROR 111 |
|||
# define PKCS12_R_MAC_VERIFY_ERROR 112 |
|||
# define PKCS12_R_MAC_VERIFY_FAILURE 113 |
|||
# define PKCS12_R_PARSE_ERROR 114 |
|||
# define PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR 115 |
|||
# define PKCS12_R_PKCS12_CIPHERFINAL_ERROR 116 |
|||
# define PKCS12_R_PKCS12_PBE_CRYPT_ERROR 117 |
|||
# define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM 118 |
|||
# define PKCS12_R_UNSUPPORTED_PKCS12_MODE 119 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,481 +0,0 @@ |
|||
/* crypto/pkcs7/pkcs7.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_PKCS7_H |
|||
# define HEADER_PKCS7_H |
|||
|
|||
# include <openssl/asn1.h> |
|||
# include <openssl/bio.h> |
|||
# include <openssl/e_os2.h> |
|||
|
|||
# include <openssl/symhacks.h> |
|||
# include <openssl/ossl_typ.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef OPENSSL_SYS_WIN32 |
|||
/* Under Win32 thes are defined in wincrypt.h */ |
|||
# undef PKCS7_ISSUER_AND_SERIAL |
|||
# undef PKCS7_SIGNER_INFO |
|||
# endif |
|||
|
|||
/*-
|
|||
Encryption_ID DES-CBC |
|||
Digest_ID MD5 |
|||
Digest_Encryption_ID rsaEncryption |
|||
Key_Encryption_ID rsaEncryption |
|||
*/ |
|||
|
|||
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; /* version 1 */ |
|||
PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; |
|||
X509_ALGOR *digest_alg; |
|||
STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */ |
|||
X509_ALGOR *digest_enc_alg; |
|||
ASN1_OCTET_STRING *enc_digest; |
|||
STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */ |
|||
/* The private key to sign with */ |
|||
EVP_PKEY *pkey; |
|||
} PKCS7_SIGNER_INFO; |
|||
|
|||
DECLARE_STACK_OF(PKCS7_SIGNER_INFO) |
|||
DECLARE_ASN1_SET_OF(PKCS7_SIGNER_INFO) |
|||
|
|||
typedef struct pkcs7_recip_info_st { |
|||
ASN1_INTEGER *version; /* version 0 */ |
|||
PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; |
|||
X509_ALGOR *key_enc_algor; |
|||
ASN1_OCTET_STRING *enc_key; |
|||
X509 *cert; /* get the pub-key from this */ |
|||
} PKCS7_RECIP_INFO; |
|||
|
|||
DECLARE_STACK_OF(PKCS7_RECIP_INFO) |
|||
DECLARE_ASN1_SET_OF(PKCS7_RECIP_INFO) |
|||
|
|||
typedef struct pkcs7_signed_st { |
|||
ASN1_INTEGER *version; /* version 1 */ |
|||
STACK_OF(X509_ALGOR) *md_algs; /* md used */ |
|||
STACK_OF(X509) *cert; /* [ 0 ] */ |
|||
STACK_OF(X509_CRL) *crl; /* [ 1 ] */ |
|||
STACK_OF(PKCS7_SIGNER_INFO) *signer_info; |
|||
struct pkcs7_st *contents; |
|||
} PKCS7_SIGNED; |
|||
/*
|
|||
* The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about |
|||
* merging the two |
|||
*/ |
|||
|
|||
typedef struct pkcs7_enc_content_st { |
|||
ASN1_OBJECT *content_type; |
|||
X509_ALGOR *algorithm; |
|||
ASN1_OCTET_STRING *enc_data; /* [ 0 ] */ |
|||
const EVP_CIPHER *cipher; |
|||
} PKCS7_ENC_CONTENT; |
|||
|
|||
typedef struct pkcs7_enveloped_st { |
|||
ASN1_INTEGER *version; /* version 0 */ |
|||
STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; |
|||
PKCS7_ENC_CONTENT *enc_data; |
|||
} PKCS7_ENVELOPE; |
|||
|
|||
typedef struct pkcs7_signedandenveloped_st { |
|||
ASN1_INTEGER *version; /* version 1 */ |
|||
STACK_OF(X509_ALGOR) *md_algs; /* md used */ |
|||
STACK_OF(X509) *cert; /* [ 0 ] */ |
|||
STACK_OF(X509_CRL) *crl; /* [ 1 ] */ |
|||
STACK_OF(PKCS7_SIGNER_INFO) *signer_info; |
|||
PKCS7_ENC_CONTENT *enc_data; |
|||
STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; |
|||
} PKCS7_SIGN_ENVELOPE; |
|||
|
|||
typedef struct pkcs7_digest_st { |
|||
ASN1_INTEGER *version; /* version 0 */ |
|||
X509_ALGOR *md; /* md used */ |
|||
struct pkcs7_st *contents; |
|||
ASN1_OCTET_STRING *digest; |
|||
} PKCS7_DIGEST; |
|||
|
|||
typedef struct pkcs7_encrypted_st { |
|||
ASN1_INTEGER *version; /* version 0 */ |
|||
PKCS7_ENC_CONTENT *enc_data; |
|||
} PKCS7_ENCRYPT; |
|||
|
|||
typedef struct pkcs7_st { |
|||
/*
|
|||
* The following is non NULL if it contains ASN1 encoding of this |
|||
* structure |
|||
*/ |
|||
unsigned char *asn1; |
|||
long length; |
|||
# define PKCS7_S_HEADER 0 |
|||
# define PKCS7_S_BODY 1 |
|||
# define PKCS7_S_TAIL 2 |
|||
int state; /* used during processing */ |
|||
int detached; |
|||
ASN1_OBJECT *type; |
|||
/* content as defined by the type */ |
|||
/*
|
|||
* all encryption/message digests are applied to the 'contents', leaving |
|||
* out the 'type' field. |
|||
*/ |
|||
union { |
|||
char *ptr; |
|||
/* NID_pkcs7_data */ |
|||
ASN1_OCTET_STRING *data; |
|||
/* NID_pkcs7_signed */ |
|||
PKCS7_SIGNED *sign; |
|||
/* NID_pkcs7_enveloped */ |
|||
PKCS7_ENVELOPE *enveloped; |
|||
/* NID_pkcs7_signedAndEnveloped */ |
|||
PKCS7_SIGN_ENVELOPE *signed_and_enveloped; |
|||
/* NID_pkcs7_digest */ |
|||
PKCS7_DIGEST *digest; |
|||
/* NID_pkcs7_encrypted */ |
|||
PKCS7_ENCRYPT *encrypted; |
|||
/* Anything else */ |
|||
ASN1_TYPE *other; |
|||
} d; |
|||
} PKCS7; |
|||
|
|||
DECLARE_STACK_OF(PKCS7) |
|||
DECLARE_ASN1_SET_OF(PKCS7) |
|||
DECLARE_PKCS12_STACK_OF(PKCS7) |
|||
|
|||
# define PKCS7_OP_SET_DETACHED_SIGNATURE 1 |
|||
# define PKCS7_OP_GET_DETACHED_SIGNATURE 2 |
|||
|
|||
# define PKCS7_get_signed_attributes(si) ((si)->auth_attr) |
|||
# define PKCS7_get_attributes(si) ((si)->unauth_attr) |
|||
|
|||
# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) |
|||
# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) |
|||
# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) |
|||
# define PKCS7_type_is_signedAndEnveloped(a) \ |
|||
(OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) |
|||
# define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) |
|||
# define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) |
|||
|
|||
# define PKCS7_set_detached(p,v) \ |
|||
PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) |
|||
# define PKCS7_get_detached(p) \ |
|||
PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) |
|||
|
|||
# define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) |
|||
|
|||
/* S/MIME related flags */ |
|||
|
|||
# define PKCS7_TEXT 0x1 |
|||
# define PKCS7_NOCERTS 0x2 |
|||
# define PKCS7_NOSIGS 0x4 |
|||
# define PKCS7_NOCHAIN 0x8 |
|||
# define PKCS7_NOINTERN 0x10 |
|||
# define PKCS7_NOVERIFY 0x20 |
|||
# define PKCS7_DETACHED 0x40 |
|||
# define PKCS7_BINARY 0x80 |
|||
# define PKCS7_NOATTR 0x100 |
|||
# define PKCS7_NOSMIMECAP 0x200 |
|||
# define PKCS7_NOOLDMIMETYPE 0x400 |
|||
# define PKCS7_CRLFEOL 0x800 |
|||
# define PKCS7_STREAM 0x1000 |
|||
# define PKCS7_NOCRL 0x2000 |
|||
# define PKCS7_PARTIAL 0x4000 |
|||
# define PKCS7_REUSE_DIGEST 0x8000 |
|||
|
|||
/* Flags: for compatibility with older code */ |
|||
|
|||
# define SMIME_TEXT PKCS7_TEXT |
|||
# define SMIME_NOCERTS PKCS7_NOCERTS |
|||
# define SMIME_NOSIGS PKCS7_NOSIGS |
|||
# define SMIME_NOCHAIN PKCS7_NOCHAIN |
|||
# define SMIME_NOINTERN PKCS7_NOINTERN |
|||
# define SMIME_NOVERIFY PKCS7_NOVERIFY |
|||
# define SMIME_DETACHED PKCS7_DETACHED |
|||
# define SMIME_BINARY PKCS7_BINARY |
|||
# define SMIME_NOATTR PKCS7_NOATTR |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) |
|||
|
|||
int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, |
|||
const EVP_MD *type, unsigned char *md, |
|||
unsigned int *len); |
|||
# ifndef OPENSSL_NO_FP_API |
|||
PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7); |
|||
int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7); |
|||
# endif |
|||
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); |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT) |
|||
DECLARE_ASN1_FUNCTIONS(PKCS7) |
|||
|
|||
DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN) |
|||
DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY) |
|||
|
|||
DECLARE_ASN1_NDEF_FUNCTION(PKCS7) |
|||
DECLARE_ASN1_PRINT_FUNCTION(PKCS7) |
|||
|
|||
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); |
|||
STACK_OF(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(STACK_OF(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, |
|||
STACK_OF(X509_ATTRIBUTE) *sk); |
|||
int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, |
|||
STACK_OF(X509_ATTRIBUTE) *sk); |
|||
|
|||
PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(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, STACK_OF(X509) *certs, X509_STORE *store, |
|||
BIO *indata, BIO *out, int flags); |
|||
STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, |
|||
int flags); |
|||
PKCS7 *PKCS7_encrypt(STACK_OF(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, |
|||
STACK_OF(X509_ALGOR) *cap); |
|||
STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si); |
|||
int PKCS7_simple_smimecap(STACK_OF(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); |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_PKCS7_strings(void); |
|||
|
|||
/* Error codes for the PKCS7 functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define PKCS7_F_B64_READ_PKCS7 120 |
|||
# define PKCS7_F_B64_WRITE_PKCS7 121 |
|||
# define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB 136 |
|||
# define PKCS7_F_I2D_PKCS7_BIO_STREAM 140 |
|||
# define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME 135 |
|||
# define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 118 |
|||
# define PKCS7_F_PKCS7_ADD_CERTIFICATE 100 |
|||
# define PKCS7_F_PKCS7_ADD_CRL 101 |
|||
# define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 102 |
|||
# define PKCS7_F_PKCS7_ADD_SIGNATURE 131 |
|||
# define PKCS7_F_PKCS7_ADD_SIGNER 103 |
|||
# define PKCS7_F_PKCS7_BIO_ADD_DIGEST 125 |
|||
# define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST 138 |
|||
# define PKCS7_F_PKCS7_CTRL 104 |
|||
# define PKCS7_F_PKCS7_DATADECODE 112 |
|||
# define PKCS7_F_PKCS7_DATAFINAL 128 |
|||
# define PKCS7_F_PKCS7_DATAINIT 105 |
|||
# define PKCS7_F_PKCS7_DATASIGN 106 |
|||
# define PKCS7_F_PKCS7_DATAVERIFY 107 |
|||
# define PKCS7_F_PKCS7_DECRYPT 114 |
|||
# define PKCS7_F_PKCS7_DECRYPT_RINFO 133 |
|||
# define PKCS7_F_PKCS7_ENCODE_RINFO 132 |
|||
# define PKCS7_F_PKCS7_ENCRYPT 115 |
|||
# define PKCS7_F_PKCS7_FINAL 134 |
|||
# define PKCS7_F_PKCS7_FIND_DIGEST 127 |
|||
# define PKCS7_F_PKCS7_GET0_SIGNERS 124 |
|||
# define PKCS7_F_PKCS7_RECIP_INFO_SET 130 |
|||
# define PKCS7_F_PKCS7_SET_CIPHER 108 |
|||
# define PKCS7_F_PKCS7_SET_CONTENT 109 |
|||
# define PKCS7_F_PKCS7_SET_DIGEST 126 |
|||
# define PKCS7_F_PKCS7_SET_TYPE 110 |
|||
# define PKCS7_F_PKCS7_SIGN 116 |
|||
# define PKCS7_F_PKCS7_SIGNATUREVERIFY 113 |
|||
# define PKCS7_F_PKCS7_SIGNER_INFO_SET 129 |
|||
# define PKCS7_F_PKCS7_SIGNER_INFO_SIGN 139 |
|||
# define PKCS7_F_PKCS7_SIGN_ADD_SIGNER 137 |
|||
# define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 119 |
|||
# define PKCS7_F_PKCS7_VERIFY 117 |
|||
# define PKCS7_F_SMIME_READ_PKCS7 122 |
|||
# define PKCS7_F_SMIME_TEXT 123 |
|||
|
|||
/* Reason codes. */ |
|||
# define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117 |
|||
# define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144 |
|||
# define PKCS7_R_CIPHER_NOT_INITIALIZED 116 |
|||
# define PKCS7_R_CONTENT_AND_DATA_PRESENT 118 |
|||
# define PKCS7_R_CTRL_ERROR 152 |
|||
# define PKCS7_R_DECODE_ERROR 130 |
|||
# define PKCS7_R_DECRYPTED_KEY_IS_WRONG_LENGTH 100 |
|||
# define PKCS7_R_DECRYPT_ERROR 119 |
|||
# define PKCS7_R_DIGEST_FAILURE 101 |
|||
# define PKCS7_R_ENCRYPTION_CTRL_FAILURE 149 |
|||
# define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150 |
|||
# define PKCS7_R_ERROR_ADDING_RECIPIENT 120 |
|||
# define PKCS7_R_ERROR_SETTING_CIPHER 121 |
|||
# define PKCS7_R_INVALID_MIME_TYPE 131 |
|||
# define PKCS7_R_INVALID_NULL_POINTER 143 |
|||
# define PKCS7_R_INVALID_SIGNED_DATA_TYPE 155 |
|||
# define PKCS7_R_MIME_NO_CONTENT_TYPE 132 |
|||
# define PKCS7_R_MIME_PARSE_ERROR 133 |
|||
# define PKCS7_R_MIME_SIG_PARSE_ERROR 134 |
|||
# define PKCS7_R_MISSING_CERIPEND_INFO 103 |
|||
# define PKCS7_R_NO_CONTENT 122 |
|||
# define PKCS7_R_NO_CONTENT_TYPE 135 |
|||
# define PKCS7_R_NO_DEFAULT_DIGEST 151 |
|||
# define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND 154 |
|||
# define PKCS7_R_NO_MULTIPART_BODY_FAILURE 136 |
|||
# define PKCS7_R_NO_MULTIPART_BOUNDARY 137 |
|||
# define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115 |
|||
# define PKCS7_R_NO_RECIPIENT_MATCHES_KEY 146 |
|||
# define PKCS7_R_NO_SIGNATURES_ON_DATA 123 |
|||
# define PKCS7_R_NO_SIGNERS 142 |
|||
# define PKCS7_R_NO_SIG_CONTENT_TYPE 138 |
|||
# define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104 |
|||
# define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124 |
|||
# define PKCS7_R_PKCS7_ADD_SIGNER_ERROR 153 |
|||
# define PKCS7_R_PKCS7_DATAFINAL 126 |
|||
# define PKCS7_R_PKCS7_DATAFINAL_ERROR 125 |
|||
# define PKCS7_R_PKCS7_DATASIGN 145 |
|||
# define PKCS7_R_PKCS7_PARSE_ERROR 139 |
|||
# define PKCS7_R_PKCS7_SIG_PARSE_ERROR 140 |
|||
# define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127 |
|||
# define PKCS7_R_SIGNATURE_FAILURE 105 |
|||
# define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128 |
|||
# define PKCS7_R_SIGNING_CTRL_FAILURE 147 |
|||
# define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 148 |
|||
# define PKCS7_R_SIG_INVALID_MIME_TYPE 141 |
|||
# define PKCS7_R_SMIME_TEXT_ERROR 129 |
|||
# define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106 |
|||
# define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107 |
|||
# define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108 |
|||
# define PKCS7_R_UNKNOWN_DIGEST_TYPE 109 |
|||
# define PKCS7_R_UNKNOWN_OPERATION 110 |
|||
# define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111 |
|||
# define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112 |
|||
# define PKCS7_R_WRONG_CONTENT_TYPE 113 |
|||
# define PKCS7_R_WRONG_PKCS7_TYPE 114 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,99 +0,0 @@ |
|||
/* crypto/pqueue/pqueue.h */ |
|||
/*
|
|||
* DTLS implementation written by Nagendra Modadugu |
|||
* (nagendra@cs.stanford.edu) for the OpenSSL project 2005. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_PQUEUE_H |
|||
# define HEADER_PQUEUE_H |
|||
|
|||
# include <stdio.h> |
|||
# include <stdlib.h> |
|||
# include <string.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
typedef struct _pqueue *pqueue; |
|||
|
|||
typedef struct _pitem { |
|||
unsigned char priority[8]; /* 64-bit value in big-endian encoding */ |
|||
void *data; |
|||
struct _pitem *next; |
|||
} pitem; |
|||
|
|||
typedef struct _pitem *piterator; |
|||
|
|||
pitem *pitem_new(unsigned char *prio64be, void *data); |
|||
void pitem_free(pitem *item); |
|||
|
|||
pqueue pqueue_new(void); |
|||
void pqueue_free(pqueue pq); |
|||
|
|||
pitem *pqueue_insert(pqueue pq, pitem *item); |
|||
pitem *pqueue_peek(pqueue pq); |
|||
pitem *pqueue_pop(pqueue pq); |
|||
pitem *pqueue_find(pqueue pq, unsigned char *prio64be); |
|||
pitem *pqueue_iterator(pqueue pq); |
|||
pitem *pqueue_next(piterator *iter); |
|||
|
|||
void pqueue_print(pqueue pq); |
|||
int pqueue_size(pqueue pq); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif /* ! HEADER_PQUEUE_H */ |
|||
@ -1,150 +0,0 @@ |
|||
/* crypto/rand/rand.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_RAND_H |
|||
# define HEADER_RAND_H |
|||
|
|||
# include <stdlib.h> |
|||
# include <openssl/ossl_typ.h> |
|||
# include <openssl/e_os2.h> |
|||
|
|||
# if defined(OPENSSL_SYS_WINDOWS) |
|||
# include <windows.h> |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# if defined(OPENSSL_FIPS) |
|||
# define FIPS_RAND_SIZE_T size_t |
|||
# endif |
|||
|
|||
/* Already defined in ossl_typ.h */ |
|||
/* typedef struct rand_meth_st RAND_METHOD; */ |
|||
|
|||
struct rand_meth_st { |
|||
void (*seed) (const void *buf, int num); |
|||
int (*bytes) (unsigned char *buf, int num); |
|||
void (*cleanup) (void); |
|||
void (*add) (const void *buf, int num, double entropy); |
|||
int (*pseudorand) (unsigned char *buf, int num); |
|||
int (*status) (void); |
|||
}; |
|||
|
|||
# ifdef BN_DEBUG |
|||
extern int rand_predictable; |
|||
# endif |
|||
|
|||
int RAND_set_rand_method(const RAND_METHOD *meth); |
|||
const RAND_METHOD *RAND_get_rand_method(void); |
|||
# ifndef OPENSSL_NO_ENGINE |
|||
int RAND_set_rand_engine(ENGINE *engine); |
|||
# endif |
|||
RAND_METHOD *RAND_SSLeay(void); |
|||
void RAND_cleanup(void); |
|||
int RAND_bytes(unsigned char *buf, int num); |
|||
int RAND_pseudo_bytes(unsigned char *buf, int num); |
|||
void RAND_seed(const void *buf, int num); |
|||
void RAND_add(const void *buf, int num, double entropy); |
|||
int RAND_load_file(const char *file, long max_bytes); |
|||
int RAND_write_file(const char *file); |
|||
const char *RAND_file_name(char *file, size_t num); |
|||
int RAND_status(void); |
|||
int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes); |
|||
int RAND_egd(const char *path); |
|||
int RAND_egd_bytes(const char *path, int bytes); |
|||
int RAND_poll(void); |
|||
|
|||
# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) |
|||
|
|||
void RAND_screen(void); |
|||
int RAND_event(UINT, WPARAM, LPARAM); |
|||
|
|||
# endif |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
void RAND_set_fips_drbg_type(int type, int flags); |
|||
int RAND_init_fips(void); |
|||
# endif |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_RAND_strings(void); |
|||
|
|||
/* Error codes for the RAND functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define RAND_F_RAND_GET_RAND_METHOD 101 |
|||
# define RAND_F_RAND_INIT_FIPS 102 |
|||
# define RAND_F_SSLEAY_RAND_BYTES 100 |
|||
|
|||
/* Reason codes. */ |
|||
# define RAND_R_DUAL_EC_DRBG_DISABLED 104 |
|||
# define RAND_R_ERROR_INITIALISING_DRBG 102 |
|||
# define RAND_R_ERROR_INSTANTIATING_DRBG 103 |
|||
# define RAND_R_NO_FIPS_RANDOM_METHOD_SET 101 |
|||
# define RAND_R_PRNG_NOT_SEEDED 100 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
@ -1,103 +0,0 @@ |
|||
/* crypto/rc2/rc2.h */ |
|||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_RC2_H |
|||
# define HEADER_RC2_H |
|||
|
|||
# include <openssl/opensslconf.h>/* OPENSSL_NO_RC2, RC2_INT */ |
|||
# ifdef OPENSSL_NO_RC2 |
|||
# error RC2 is disabled. |
|||
# endif |
|||
|
|||
# define RC2_ENCRYPT 1 |
|||
# define RC2_DECRYPT 0 |
|||
|
|||
# define RC2_BLOCK 8 |
|||
# define RC2_KEY_LENGTH 16 |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct rc2_key_st { |
|||
RC2_INT data[64]; |
|||
} RC2_KEY; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
void private_RC2_set_key(RC2_KEY *key, int len, const unsigned char *data, |
|||
int bits); |
|||
# endif |
|||
void RC2_set_key(RC2_KEY *key, int len, const unsigned char *data, int bits); |
|||
void RC2_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
RC2_KEY *key, int enc); |
|||
void RC2_encrypt(unsigned long *data, RC2_KEY *key); |
|||
void RC2_decrypt(unsigned long *data, RC2_KEY *key); |
|||
void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, |
|||
RC2_KEY *ks, unsigned char *iv, int enc); |
|||
void RC2_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, RC2_KEY *schedule, unsigned char *ivec, |
|||
int *num, int enc); |
|||
void RC2_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
|||
long length, RC2_KEY *schedule, unsigned char *ivec, |
|||
int *num); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,88 +0,0 @@ |
|||
/* crypto/rc4/rc4.h */ |
|||
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_RC4_H |
|||
# define HEADER_RC4_H |
|||
|
|||
# include <openssl/opensslconf.h>/* OPENSSL_NO_RC4, RC4_INT */ |
|||
# ifdef OPENSSL_NO_RC4 |
|||
# error RC4 is disabled. |
|||
# endif |
|||
|
|||
# include <stddef.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct rc4_key_st { |
|||
RC4_INT x, y; |
|||
RC4_INT data[256]; |
|||
} RC4_KEY; |
|||
|
|||
const char *RC4_options(void); |
|||
void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data); |
|||
void private_RC4_set_key(RC4_KEY *key, int len, const unsigned char *data); |
|||
void RC4(RC4_KEY *key, size_t len, const unsigned char *indata, |
|||
unsigned char *outdata); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,105 +0,0 @@ |
|||
/* crypto/ripemd/ripemd.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_RIPEMD_H |
|||
# define HEADER_RIPEMD_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
# include <stddef.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# ifdef OPENSSL_NO_RIPEMD |
|||
# error RIPEMD is disabled. |
|||
# endif |
|||
|
|||
# if defined(__LP32__) |
|||
# define RIPEMD160_LONG unsigned long |
|||
# elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) |
|||
# define RIPEMD160_LONG unsigned long |
|||
# define RIPEMD160_LONG_LOG2 3 |
|||
# else |
|||
# define RIPEMD160_LONG unsigned int |
|||
# endif |
|||
|
|||
# define RIPEMD160_CBLOCK 64 |
|||
# define RIPEMD160_LBLOCK (RIPEMD160_CBLOCK/4) |
|||
# define RIPEMD160_DIGEST_LENGTH 20 |
|||
|
|||
typedef struct RIPEMD160state_st { |
|||
RIPEMD160_LONG A, B, C, D, E; |
|||
RIPEMD160_LONG Nl, Nh; |
|||
RIPEMD160_LONG data[RIPEMD160_LBLOCK]; |
|||
unsigned int num; |
|||
} RIPEMD160_CTX; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
int private_RIPEMD160_Init(RIPEMD160_CTX *c); |
|||
# endif |
|||
int RIPEMD160_Init(RIPEMD160_CTX *c); |
|||
int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data, size_t len); |
|||
int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c); |
|||
unsigned char *RIPEMD160(const unsigned char *d, size_t n, unsigned char *md); |
|||
void RIPEMD160_Transform(RIPEMD160_CTX *c, const unsigned char *b); |
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,610 +0,0 @@ |
|||
/* crypto/rsa/rsa.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_RSA_H |
|||
# define HEADER_RSA_H |
|||
|
|||
# include <openssl/asn1.h> |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
# include <openssl/bio.h> |
|||
# endif |
|||
# include <openssl/crypto.h> |
|||
# include <openssl/ossl_typ.h> |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
# include <openssl/bn.h> |
|||
# endif |
|||
|
|||
# ifdef OPENSSL_NO_RSA |
|||
# error RSA is disabled. |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/* Declared already in ossl_typ.h */ |
|||
/* typedef struct rsa_st RSA; */ |
|||
/* typedef struct rsa_meth_st RSA_METHOD; */ |
|||
|
|||
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); |
|||
/* Can be null */ |
|||
int (*rsa_mod_exp) (BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx); |
|||
/* Can be null */ |
|||
int (*bn_mod_exp) (BIGNUM *r, const BIGNUM *a, const BIGNUM *p, |
|||
const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); |
|||
/* called at new */ |
|||
int (*init) (RSA *rsa); |
|||
/* called at free */ |
|||
int (*finish) (RSA *rsa); |
|||
/* RSA_METHOD_FLAG_* things */ |
|||
int flags; |
|||
/* may be needed! */ |
|||
char *app_data; |
|||
/*
|
|||
* New sign and verify functions: some libraries don't allow arbitrary |
|||
* data to be signed/verified: this allows them to be used. Note: for |
|||
* this to work the RSA_public_decrypt() and RSA_private_encrypt() should |
|||
* *NOT* be used RSA_sign(), RSA_verify() should be used instead. Note: |
|||
* for backwards compatibility this functionality is only enabled if the |
|||
* RSA_FLAG_SIGN_VER option is set in 'flags'. |
|||
*/ |
|||
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); |
|||
/*
|
|||
* If this callback is NULL, the builtin software RSA key-gen will be |
|||
* used. This is for behavioural compatibility whilst the code gets |
|||
* rewired, but one day it would be nice to assume there are no such |
|||
* things as "builtin software" implementations. |
|||
*/ |
|||
int (*rsa_keygen) (RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); |
|||
}; |
|||
|
|||
struct rsa_st { |
|||
/*
|
|||
* The first parameter is used to pickup errors where this is passed |
|||
* instead of aEVP_PKEY, it is set to 0 |
|||
*/ |
|||
int pad; |
|||
long version; |
|||
const RSA_METHOD *meth; |
|||
/* functional reference if 'meth' is ENGINE-provided */ |
|||
ENGINE *engine; |
|||
BIGNUM *n; |
|||
BIGNUM *e; |
|||
BIGNUM *d; |
|||
BIGNUM *p; |
|||
BIGNUM *q; |
|||
BIGNUM *dmp1; |
|||
BIGNUM *dmq1; |
|||
BIGNUM *iqmp; |
|||
/* be careful using this if the RSA structure is shared */ |
|||
CRYPTO_EX_DATA ex_data; |
|||
int references; |
|||
int flags; |
|||
/* Used to cache montgomery values */ |
|||
BN_MONT_CTX *_method_mod_n; |
|||
BN_MONT_CTX *_method_mod_p; |
|||
BN_MONT_CTX *_method_mod_q; |
|||
/*
|
|||
* all BIGNUM values are actually in the following data, if it is not |
|||
* NULL |
|||
*/ |
|||
char *bignum_data; |
|||
BN_BLINDING *blinding; |
|||
BN_BLINDING *mt_blinding; |
|||
}; |
|||
|
|||
# ifndef OPENSSL_RSA_MAX_MODULUS_BITS |
|||
# define OPENSSL_RSA_MAX_MODULUS_BITS 16384 |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_RSA_SMALL_MODULUS_BITS |
|||
# define OPENSSL_RSA_SMALL_MODULUS_BITS 3072 |
|||
# endif |
|||
# ifndef OPENSSL_RSA_MAX_PUBEXP_BITS |
|||
|
|||
/* exponent limit enforced for "large" modulus only */ |
|||
# define OPENSSL_RSA_MAX_PUBEXP_BITS 64 |
|||
# endif |
|||
|
|||
# define RSA_3 0x3L |
|||
# define RSA_F4 0x10001L |
|||
|
|||
# define RSA_METHOD_FLAG_NO_CHECK 0x0001/* don't check pub/private |
|||
* match */ |
|||
|
|||
# define RSA_FLAG_CACHE_PUBLIC 0x0002 |
|||
# define RSA_FLAG_CACHE_PRIVATE 0x0004 |
|||
# define RSA_FLAG_BLINDING 0x0008 |
|||
# define RSA_FLAG_THREAD_SAFE 0x0010 |
|||
/*
|
|||
* This flag means the private key operations will be handled by rsa_mod_exp |
|||
* and that they do not depend on the private key components being present: |
|||
* for example a key stored in external hardware. Without this flag |
|||
* bn_mod_exp gets called when private key components are absent. |
|||
*/ |
|||
# define RSA_FLAG_EXT_PKEY 0x0020 |
|||
|
|||
/*
|
|||
* This flag in the RSA_METHOD enables the new rsa_sign, rsa_verify |
|||
* functions. |
|||
*/ |
|||
# define RSA_FLAG_SIGN_VER 0x0040 |
|||
|
|||
/*
|
|||
* new with 0.9.6j and 0.9.7b; the built-in |
|||
* RSA implementation now uses blinding by |
|||
* default (ignoring RSA_FLAG_BLINDING), |
|||
* but other engines might not need it |
|||
*/ |
|||
# define RSA_FLAG_NO_BLINDING 0x0080 |
|||
/*
|
|||
* new with 0.9.8f; the built-in RSA |
|||
* implementation now uses constant time |
|||
* operations by default in private key operations, |
|||
* e.g., constant time modular exponentiation, |
|||
* modular inverse without leaking branches, |
|||
* division without leaking branches. This |
|||
* flag disables these constant time |
|||
* operations and results in faster RSA |
|||
* private key operations. |
|||
*/ |
|||
# define RSA_FLAG_NO_CONSTTIME 0x0100 |
|||
# ifdef OPENSSL_USE_DEPRECATED |
|||
/* deprecated name for the flag*/ |
|||
/*
|
|||
* new with 0.9.7h; the built-in RSA |
|||
* implementation now uses constant time |
|||
* modular exponentiation for secret exponents |
|||
* by default. This flag causes the |
|||
* faster variable sliding window method to |
|||
* be used for all exponents. |
|||
*/ |
|||
# define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME |
|||
# endif |
|||
|
|||
# define EVP_PKEY_CTX_set_rsa_padding(ctx, pad) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, EVP_PKEY_CTRL_RSA_PADDING, \ |
|||
pad, NULL) |
|||
|
|||
# define EVP_PKEY_CTX_get_rsa_padding(ctx, ppad) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, \ |
|||
EVP_PKEY_CTRL_GET_RSA_PADDING, 0, ppad) |
|||
|
|||
# define EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, len) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, \ |
|||
(EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ |
|||
EVP_PKEY_CTRL_RSA_PSS_SALTLEN, \ |
|||
len, NULL) |
|||
|
|||
# define EVP_PKEY_CTX_get_rsa_pss_saltlen(ctx, plen) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, \ |
|||
(EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ |
|||
EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, \ |
|||
0, plen) |
|||
|
|||
# define EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, bits) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN, \ |
|||
EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bits, NULL) |
|||
|
|||
# define EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN, \ |
|||
EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp) |
|||
|
|||
# define EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_SIG, \ |
|||
EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)md) |
|||
|
|||
# define EVP_PKEY_CTX_get_rsa_mgf1_md(ctx, pmd) \ |
|||
EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_SIG, \ |
|||
EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)pmd) |
|||
|
|||
# define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1) |
|||
# define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 2) |
|||
|
|||
# define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 3) |
|||
# define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4) |
|||
# define EVP_PKEY_CTRL_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 5) |
|||
|
|||
# define EVP_PKEY_CTRL_GET_RSA_PADDING (EVP_PKEY_ALG_CTRL + 6) |
|||
# define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 7) |
|||
# define EVP_PKEY_CTRL_GET_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 8) |
|||
|
|||
# define RSA_PKCS1_PADDING 1 |
|||
# define RSA_SSLV23_PADDING 2 |
|||
# define RSA_NO_PADDING 3 |
|||
# define RSA_PKCS1_OAEP_PADDING 4 |
|||
# define RSA_X931_PADDING 5 |
|||
/* EVP_PKEY_ only */ |
|||
# define RSA_PKCS1_PSS_PADDING 6 |
|||
|
|||
# define RSA_PKCS1_PADDING_SIZE 11 |
|||
|
|||
# define RSA_set_app_data(s,arg) RSA_set_ex_data(s,0,arg) |
|||
# define RSA_get_app_data(s) RSA_get_ex_data(s,0) |
|||
|
|||
RSA *RSA_new(void); |
|||
RSA *RSA_new_method(ENGINE *engine); |
|||
int RSA_size(const RSA *rsa); |
|||
|
|||
/* Deprecated version */ |
|||
# ifndef OPENSSL_NO_DEPRECATED |
|||
RSA *RSA_generate_key(int bits, unsigned long e, void |
|||
(*callback) (int, int, void *), void *cb_arg); |
|||
# endif /* !defined(OPENSSL_NO_DEPRECATED) */ |
|||
|
|||
/* New version */ |
|||
int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); |
|||
|
|||
int RSA_check_key(const RSA *); |
|||
/* next 4 return -1 on error */ |
|||
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); |
|||
/* "up" the RSA object's reference count */ |
|||
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); |
|||
|
|||
/* This function needs the memory locking malloc callbacks to be installed */ |
|||
int RSA_memory_lock(RSA *r); |
|||
|
|||
/* these are the actual SSLeay RSA functions */ |
|||
const RSA_METHOD *RSA_PKCS1_SSLeay(void); |
|||
|
|||
const RSA_METHOD *RSA_null_method(void); |
|||
|
|||
DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPublicKey) |
|||
DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPrivateKey) |
|||
|
|||
typedef struct rsa_pss_params_st { |
|||
X509_ALGOR *hashAlgorithm; |
|||
X509_ALGOR *maskGenAlgorithm; |
|||
ASN1_INTEGER *saltLength; |
|||
ASN1_INTEGER *trailerField; |
|||
} RSA_PSS_PARAMS; |
|||
|
|||
DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS) |
|||
|
|||
# ifndef OPENSSL_NO_FP_API |
|||
int RSA_print_fp(FILE *fp, const RSA *r, int offset); |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_BIO |
|||
int RSA_print(BIO *bp, const RSA *r, int offset); |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_RC4 |
|||
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)); |
|||
# endif |
|||
|
|||
/*
|
|||
* The following 2 functions sign and verify a X509_SIG ASN1 object inside |
|||
* PKCS#1 padded RSA encryption |
|||
*/ |
|||
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); |
|||
|
|||
/*
|
|||
* The following 2 function sign and verify a ASN1_OCTET_STRING object inside |
|||
* PKCS#1 padded RSA encryption |
|||
*/ |
|||
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_SSLv23(unsigned char *to, int tlen, |
|||
const unsigned char *f, int fl); |
|||
int RSA_padding_check_SSLv23(unsigned char *to, int tlen, |
|||
const unsigned char *f, int fl, int rsa_len); |
|||
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); |
|||
|
|||
RSA *RSAPublicKey_dup(RSA *rsa); |
|||
RSA *RSAPrivateKey_dup(RSA *rsa); |
|||
|
|||
/*
|
|||
* If this flag is set the RSA method is FIPS compliant and can be used in |
|||
* FIPS mode. This is set in the validated module method. If an application |
|||
* sets this flag in its own methods it is its responsibility to ensure the |
|||
* result is compliant. |
|||
*/ |
|||
|
|||
# define RSA_FLAG_FIPS_METHOD 0x0400 |
|||
|
|||
/*
|
|||
* If this flag is set the operations normally disabled in FIPS mode are |
|||
* permitted it is then the applications responsibility to ensure that the |
|||
* usage is compliant. |
|||
*/ |
|||
|
|||
# define RSA_FLAG_NON_FIPS_ALLOW 0x0400 |
|||
/*
|
|||
* Application has decided PRNG is good enough to generate a key: don't |
|||
* check. |
|||
*/ |
|||
# define RSA_FLAG_CHECKED 0x0800 |
|||
|
|||
/* BEGIN ERROR CODES */ |
|||
/*
|
|||
* The following lines are auto generated by the script mkerr.pl. Any changes |
|||
* made after this point may be overwritten when the script is next run. |
|||
*/ |
|||
void ERR_load_RSA_strings(void); |
|||
|
|||
/* Error codes for the RSA functions. */ |
|||
|
|||
/* Function codes. */ |
|||
# define RSA_F_CHECK_PADDING_MD 140 |
|||
# define RSA_F_DO_RSA_PRINT 146 |
|||
# define RSA_F_INT_RSA_VERIFY 145 |
|||
# define RSA_F_MEMORY_LOCK 100 |
|||
# define RSA_F_OLD_RSA_PRIV_DECODE 147 |
|||
# define RSA_F_PKEY_RSA_CTRL 143 |
|||
# define RSA_F_PKEY_RSA_CTRL_STR 144 |
|||
# define RSA_F_PKEY_RSA_SIGN 142 |
|||
# define RSA_F_PKEY_RSA_VERIFY 154 |
|||
# define RSA_F_PKEY_RSA_VERIFYRECOVER 141 |
|||
# define RSA_F_RSA_BUILTIN_KEYGEN 129 |
|||
# define RSA_F_RSA_CHECK_KEY 123 |
|||
# define RSA_F_RSA_EAY_PRIVATE_DECRYPT 101 |
|||
# define RSA_F_RSA_EAY_PRIVATE_ENCRYPT 102 |
|||
# define RSA_F_RSA_EAY_PUBLIC_DECRYPT 103 |
|||
# define RSA_F_RSA_EAY_PUBLIC_ENCRYPT 104 |
|||
# define RSA_F_RSA_GENERATE_KEY 105 |
|||
# define RSA_F_RSA_GENERATE_KEY_EX 155 |
|||
# define RSA_F_RSA_ITEM_VERIFY 156 |
|||
# define RSA_F_RSA_MEMORY_LOCK 130 |
|||
# define RSA_F_RSA_NEW_METHOD 106 |
|||
# define RSA_F_RSA_NULL 124 |
|||
# define RSA_F_RSA_NULL_MOD_EXP 131 |
|||
# define RSA_F_RSA_NULL_PRIVATE_DECRYPT 132 |
|||
# define RSA_F_RSA_NULL_PRIVATE_ENCRYPT 133 |
|||
# define RSA_F_RSA_NULL_PUBLIC_DECRYPT 134 |
|||
# define RSA_F_RSA_NULL_PUBLIC_ENCRYPT 135 |
|||
# define RSA_F_RSA_PADDING_ADD_NONE 107 |
|||
# define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP 121 |
|||
# define RSA_F_RSA_PADDING_ADD_PKCS1_PSS 125 |
|||
# define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1 148 |
|||
# define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 108 |
|||
# define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 109 |
|||
# define RSA_F_RSA_PADDING_ADD_SSLV23 110 |
|||
# define RSA_F_RSA_PADDING_ADD_X931 127 |
|||
# define RSA_F_RSA_PADDING_CHECK_NONE 111 |
|||
# define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP 122 |
|||
# define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 112 |
|||
# define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 113 |
|||
# define RSA_F_RSA_PADDING_CHECK_SSLV23 114 |
|||
# define RSA_F_RSA_PADDING_CHECK_X931 128 |
|||
# define RSA_F_RSA_PRINT 115 |
|||
# define RSA_F_RSA_PRINT_FP 116 |
|||
# define RSA_F_RSA_PRIVATE_DECRYPT 150 |
|||
# define RSA_F_RSA_PRIVATE_ENCRYPT 151 |
|||
# define RSA_F_RSA_PRIV_DECODE 137 |
|||
# define RSA_F_RSA_PRIV_ENCODE 138 |
|||
# define RSA_F_RSA_PUBLIC_DECRYPT 152 |
|||
# define RSA_F_RSA_PUBLIC_ENCRYPT 153 |
|||
# define RSA_F_RSA_PUB_DECODE 139 |
|||
# define RSA_F_RSA_SETUP_BLINDING 136 |
|||
# define RSA_F_RSA_SIGN 117 |
|||
# define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 118 |
|||
# define RSA_F_RSA_VERIFY 119 |
|||
# define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 120 |
|||
# define RSA_F_RSA_VERIFY_PKCS1_PSS 126 |
|||
# define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1 149 |
|||
|
|||
/* Reason codes. */ |
|||
# define RSA_R_ALGORITHM_MISMATCH 100 |
|||
# define RSA_R_BAD_E_VALUE 101 |
|||
# define RSA_R_BAD_FIXED_HEADER_DECRYPT 102 |
|||
# define RSA_R_BAD_PAD_BYTE_COUNT 103 |
|||
# define RSA_R_BAD_SIGNATURE 104 |
|||
# define RSA_R_BLOCK_TYPE_IS_NOT_01 106 |
|||
# define RSA_R_BLOCK_TYPE_IS_NOT_02 107 |
|||
# define RSA_R_DATA_GREATER_THAN_MOD_LEN 108 |
|||
# define RSA_R_DATA_TOO_LARGE 109 |
|||
# define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110 |
|||
# define RSA_R_DATA_TOO_LARGE_FOR_MODULUS 132 |
|||
# define RSA_R_DATA_TOO_SMALL 111 |
|||
# define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE 122 |
|||
# define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112 |
|||
# define RSA_R_DMP1_NOT_CONGRUENT_TO_D 124 |
|||
# define RSA_R_DMQ1_NOT_CONGRUENT_TO_D 125 |
|||
# define RSA_R_D_E_NOT_CONGRUENT_TO_1 123 |
|||
# define RSA_R_FIRST_OCTET_INVALID 133 |
|||
# define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 144 |
|||
# define RSA_R_INVALID_DIGEST_LENGTH 143 |
|||
# define RSA_R_INVALID_HEADER 137 |
|||
# define RSA_R_INVALID_KEYBITS 145 |
|||
# define RSA_R_INVALID_MESSAGE_LENGTH 131 |
|||
# define RSA_R_INVALID_MGF1_MD 156 |
|||
# define RSA_R_INVALID_PADDING 138 |
|||
# define RSA_R_INVALID_PADDING_MODE 141 |
|||
# define RSA_R_INVALID_PSS_PARAMETERS 149 |
|||
# define RSA_R_INVALID_PSS_SALTLEN 146 |
|||
# define RSA_R_INVALID_SALT_LENGTH 150 |
|||
# define RSA_R_INVALID_TRAILER 139 |
|||
# define RSA_R_INVALID_X931_DIGEST 142 |
|||
# define RSA_R_IQMP_NOT_INVERSE_OF_Q 126 |
|||
# define RSA_R_KEY_SIZE_TOO_SMALL 120 |
|||
# define RSA_R_LAST_OCTET_INVALID 134 |
|||
# define RSA_R_MODULUS_TOO_LARGE 105 |
|||
# define RSA_R_NON_FIPS_RSA_METHOD 157 |
|||
# define RSA_R_NO_PUBLIC_EXPONENT 140 |
|||
# define RSA_R_NULL_BEFORE_BLOCK_MISSING 113 |
|||
# define RSA_R_N_DOES_NOT_EQUAL_P_Q 127 |
|||
# define RSA_R_OAEP_DECODING_ERROR 121 |
|||
# define RSA_R_OPERATION_NOT_ALLOWED_IN_FIPS_MODE 158 |
|||
# define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 148 |
|||
# define RSA_R_PADDING_CHECK_FAILED 114 |
|||
# define RSA_R_PKCS_DECODING_ERROR 159 |
|||
# define RSA_R_P_NOT_PRIME 128 |
|||
# define RSA_R_Q_NOT_PRIME 129 |
|||
# define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED 130 |
|||
# define RSA_R_SLEN_CHECK_FAILED 136 |
|||
# define RSA_R_SLEN_RECOVERY_FAILED 135 |
|||
# define RSA_R_SSLV3_ROLLBACK_ATTACK 115 |
|||
# define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116 |
|||
# define RSA_R_UNKNOWN_ALGORITHM_TYPE 117 |
|||
# define RSA_R_UNKNOWN_MASK_DIGEST 151 |
|||
# define RSA_R_UNKNOWN_PADDING_TYPE 118 |
|||
# define RSA_R_UNKNOWN_PSS_DIGEST 152 |
|||
# define RSA_R_UNSUPPORTED_MASK_ALGORITHM 153 |
|||
# define RSA_R_UNSUPPORTED_MASK_PARAMETER 154 |
|||
# define RSA_R_UNSUPPORTED_SIGNATURE_TYPE 155 |
|||
# define RSA_R_VALUE_MISSING 147 |
|||
# define RSA_R_WRONG_SIGNATURE_LENGTH 119 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
#endif |
|||
File diff suppressed because it is too large
@ -1,149 +0,0 @@ |
|||
/*
|
|||
* Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Neither the name of author nor the names of its contributors may |
|||
* be used to endorse or promote products derived from this software |
|||
* without specific prior written permission. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
|
|||
#ifndef HEADER_SEED_H |
|||
# define HEADER_SEED_H |
|||
|
|||
# include <openssl/opensslconf.h> |
|||
# include <openssl/e_os2.h> |
|||
# include <openssl/crypto.h> |
|||
|
|||
# ifdef OPENSSL_NO_SEED |
|||
# error SEED is disabled. |
|||
# endif |
|||
|
|||
/* look whether we need 'long' to get 32 bits */ |
|||
# ifdef AES_LONG |
|||
# ifndef SEED_LONG |
|||
# define SEED_LONG 1 |
|||
# endif |
|||
# endif |
|||
|
|||
# if !defined(NO_SYS_TYPES_H) |
|||
# include <sys/types.h> |
|||
# endif |
|||
|
|||
# define SEED_BLOCK_SIZE 16 |
|||
# define SEED_KEY_LENGTH 16 |
|||
|
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
typedef struct seed_key_st { |
|||
# ifdef SEED_LONG |
|||
unsigned long data[32]; |
|||
# else |
|||
unsigned int data[32]; |
|||
# endif |
|||
} SEED_KEY_SCHEDULE; |
|||
|
|||
# ifdef OPENSSL_FIPS |
|||
void private_SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], |
|||
SEED_KEY_SCHEDULE *ks); |
|||
# endif |
|||
void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], |
|||
SEED_KEY_SCHEDULE *ks); |
|||
|
|||
void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE], |
|||
unsigned char d[SEED_BLOCK_SIZE], |
|||
const SEED_KEY_SCHEDULE *ks); |
|||
void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE], |
|||
unsigned char d[SEED_BLOCK_SIZE], |
|||
const SEED_KEY_SCHEDULE *ks); |
|||
|
|||
void SEED_ecb_encrypt(const unsigned char *in, unsigned char *out, |
|||
const SEED_KEY_SCHEDULE *ks, int enc); |
|||
void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t len, |
|||
const SEED_KEY_SCHEDULE *ks, |
|||
unsigned char ivec[SEED_BLOCK_SIZE], int enc); |
|||
void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const SEED_KEY_SCHEDULE *ks, |
|||
unsigned char ivec[SEED_BLOCK_SIZE], int *num, |
|||
int enc); |
|||
void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out, |
|||
size_t len, const SEED_KEY_SCHEDULE *ks, |
|||
unsigned char ivec[SEED_BLOCK_SIZE], int *num); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif /* HEADER_SEED_H */ |
|||
@ -1,214 +0,0 @@ |
|||
/* crypto/sha/sha.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
|
|||
#ifndef HEADER_SHA_H |
|||
# define HEADER_SHA_H |
|||
|
|||
# include <openssl/e_os2.h> |
|||
# include <stddef.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# if defined(OPENSSL_NO_SHA) || (defined(OPENSSL_NO_SHA0) && defined(OPENSSL_NO_SHA1)) |
|||
# error SHA is disabled. |
|||
# endif |
|||
|
|||
# if defined(OPENSSL_FIPS) |
|||
# define FIPS_SHA_SIZE_T size_t |
|||
# endif |
|||
|
|||
/*-
|
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
* ! SHA_LONG has to be at least 32 bits wide. If it's wider, then ! |
|||
* ! SHA_LONG_LOG2 has to be defined along. ! |
|||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
|||
*/ |
|||
|
|||
# if defined(__LP32__) |
|||
# define SHA_LONG unsigned long |
|||
# elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) |
|||
# define SHA_LONG unsigned long |
|||
# define SHA_LONG_LOG2 3 |
|||
# else |
|||
# define SHA_LONG unsigned int |
|||
# endif |
|||
|
|||
# define SHA_LBLOCK 16 |
|||
# define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a |
|||
* contiguous array of 32 bit wide |
|||
* big-endian values. */ |
|||
# define SHA_LAST_BLOCK (SHA_CBLOCK-8) |
|||
# define SHA_DIGEST_LENGTH 20 |
|||
|
|||
typedef struct SHAstate_st { |
|||
SHA_LONG h0, h1, h2, h3, h4; |
|||
SHA_LONG Nl, Nh; |
|||
SHA_LONG data[SHA_LBLOCK]; |
|||
unsigned int num; |
|||
} SHA_CTX; |
|||
|
|||
# ifndef OPENSSL_NO_SHA0 |
|||
# ifdef OPENSSL_FIPS |
|||
int private_SHA_Init(SHA_CTX *c); |
|||
# endif |
|||
int SHA_Init(SHA_CTX *c); |
|||
int SHA_Update(SHA_CTX *c, const void *data, size_t len); |
|||
int SHA_Final(unsigned char *md, SHA_CTX *c); |
|||
unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md); |
|||
void SHA_Transform(SHA_CTX *c, const unsigned char *data); |
|||
# endif |
|||
# ifndef OPENSSL_NO_SHA1 |
|||
# ifdef OPENSSL_FIPS |
|||
int private_SHA1_Init(SHA_CTX *c); |
|||
# endif |
|||
int SHA1_Init(SHA_CTX *c); |
|||
int SHA1_Update(SHA_CTX *c, const void *data, size_t len); |
|||
int SHA1_Final(unsigned char *md, SHA_CTX *c); |
|||
unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); |
|||
void SHA1_Transform(SHA_CTX *c, const unsigned char *data); |
|||
# endif |
|||
|
|||
# define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a |
|||
* contiguous array of 32 bit wide |
|||
* big-endian values. */ |
|||
# define SHA224_DIGEST_LENGTH 28 |
|||
# define SHA256_DIGEST_LENGTH 32 |
|||
|
|||
typedef struct SHA256state_st { |
|||
SHA_LONG h[8]; |
|||
SHA_LONG Nl, Nh; |
|||
SHA_LONG data[SHA_LBLOCK]; |
|||
unsigned int num, md_len; |
|||
} SHA256_CTX; |
|||
|
|||
# ifndef OPENSSL_NO_SHA256 |
|||
# ifdef OPENSSL_FIPS |
|||
int private_SHA224_Init(SHA256_CTX *c); |
|||
int private_SHA256_Init(SHA256_CTX *c); |
|||
# endif |
|||
int SHA224_Init(SHA256_CTX *c); |
|||
int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); |
|||
int SHA224_Final(unsigned char *md, SHA256_CTX *c); |
|||
unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); |
|||
int SHA256_Init(SHA256_CTX *c); |
|||
int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); |
|||
int SHA256_Final(unsigned char *md, SHA256_CTX *c); |
|||
unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md); |
|||
void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); |
|||
# endif |
|||
|
|||
# define SHA384_DIGEST_LENGTH 48 |
|||
# define SHA512_DIGEST_LENGTH 64 |
|||
|
|||
# ifndef OPENSSL_NO_SHA512 |
|||
/*
|
|||
* Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64 |
|||
* being exactly 64-bit wide. See Implementation Notes in sha512.c |
|||
* for further details. |
|||
*/ |
|||
/*
|
|||
* SHA-512 treats input data as a |
|||
* contiguous array of 64 bit |
|||
* wide big-endian values. |
|||
*/ |
|||
# define SHA512_CBLOCK (SHA_LBLOCK*8) |
|||
# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) |
|||
# define SHA_LONG64 unsigned __int64 |
|||
# define U64(C) C##UI64 |
|||
# elif defined(__arch64__) |
|||
# define SHA_LONG64 unsigned long |
|||
# define U64(C) C##UL |
|||
# else |
|||
# define SHA_LONG64 unsigned long long |
|||
# define U64(C) C##ULL |
|||
# endif |
|||
|
|||
typedef struct SHA512state_st { |
|||
SHA_LONG64 h[8]; |
|||
SHA_LONG64 Nl, Nh; |
|||
union { |
|||
SHA_LONG64 d[SHA_LBLOCK]; |
|||
unsigned char p[SHA512_CBLOCK]; |
|||
} u; |
|||
unsigned int num, md_len; |
|||
} SHA512_CTX; |
|||
# endif |
|||
|
|||
# ifndef OPENSSL_NO_SHA512 |
|||
# ifdef OPENSSL_FIPS |
|||
int private_SHA384_Init(SHA512_CTX *c); |
|||
int private_SHA512_Init(SHA512_CTX *c); |
|||
# endif |
|||
int SHA384_Init(SHA512_CTX *c); |
|||
int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); |
|||
int SHA384_Final(unsigned char *md, SHA512_CTX *c); |
|||
unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); |
|||
int SHA512_Init(SHA512_CTX *c); |
|||
int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); |
|||
int SHA512_Final(unsigned char *md, SHA512_CTX *c); |
|||
unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md); |
|||
void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); |
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -1,179 +0,0 @@ |
|||
/* crypto/srp/srp.h */ |
|||
/*
|
|||
* Written by Christophe Renou (christophe.renou@edelweb.fr) with the |
|||
* precious help of Peter Sylvester (peter.sylvester@edelweb.fr) for the |
|||
* EdelKey project and contributed to the OpenSSL project 2004. |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 2004 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* licensing@OpenSSL.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
#ifndef __SRP_H__ |
|||
# define __SRP_H__ |
|||
|
|||
# ifndef OPENSSL_NO_SRP |
|||
|
|||
# include <stdio.h> |
|||
# include <string.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# include <openssl/safestack.h> |
|||
# include <openssl/bn.h> |
|||
# include <openssl/crypto.h> |
|||
|
|||
typedef struct SRP_gN_cache_st { |
|||
char *b64_bn; |
|||
BIGNUM *bn; |
|||
} SRP_gN_cache; |
|||
|
|||
|
|||
DECLARE_STACK_OF(SRP_gN_cache) |
|||
|
|||
typedef struct SRP_user_pwd_st { |
|||
/* Owned by us. */ |
|||
char *id; |
|||
BIGNUM *s; |
|||
BIGNUM *v; |
|||
/* Not owned by us. */ |
|||
const BIGNUM *g; |
|||
const BIGNUM *N; |
|||
/* Owned by us. */ |
|||
char *info; |
|||
} SRP_user_pwd; |
|||
|
|||
DECLARE_STACK_OF(SRP_user_pwd) |
|||
|
|||
void SRP_user_pwd_free(SRP_user_pwd *user_pwd); |
|||
|
|||
typedef struct SRP_VBASE_st { |
|||
STACK_OF(SRP_user_pwd) *users_pwd; |
|||
STACK_OF(SRP_gN_cache) *gN_cache; |
|||
/* to simulate a user */ |
|||
char *seed_key; |
|||
BIGNUM *default_g; |
|||
BIGNUM *default_N; |
|||
} SRP_VBASE; |
|||
|
|||
/*
|
|||
* Structure interne pour retenir les couples N et g |
|||
*/ |
|||
typedef struct SRP_gN_st { |
|||
char *id; |
|||
BIGNUM *g; |
|||
BIGNUM *N; |
|||
} SRP_gN; |
|||
|
|||
DECLARE_STACK_OF(SRP_gN) |
|||
|
|||
SRP_VBASE *SRP_VBASE_new(char *seed_key); |
|||
int SRP_VBASE_free(SRP_VBASE *vb); |
|||
int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file); |
|||
|
|||
/* This method ignores the configured seed and fails for an unknown user. */ |
|||
SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username); |
|||
/* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/ |
|||
SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username); |
|||
|
|||
char *SRP_create_verifier(const char *user, const char *pass, char **salt, |
|||
char **verifier, const char *N, const char *g); |
|||
int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt, |
|||
BIGNUM **verifier, BIGNUM *N, BIGNUM *g); |
|||
|
|||
# define SRP_NO_ERROR 0 |
|||
# define SRP_ERR_VBASE_INCOMPLETE_FILE 1 |
|||
# define SRP_ERR_VBASE_BN_LIB 2 |
|||
# define SRP_ERR_OPEN_FILE 3 |
|||
# define SRP_ERR_MEMORY 4 |
|||
|
|||
# define DB_srptype 0 |
|||
# define DB_srpverifier 1 |
|||
# define DB_srpsalt 2 |
|||
# define DB_srpid 3 |
|||
# define DB_srpgN 4 |
|||
# define DB_srpinfo 5 |
|||
# undef DB_NUMBER |
|||
# define DB_NUMBER 6 |
|||
|
|||
# define DB_SRP_INDEX 'I' |
|||
# define DB_SRP_VALID 'V' |
|||
# define DB_SRP_REVOKED 'R' |
|||
# define DB_SRP_MODIF 'v' |
|||
|
|||
/* see srp.c */ |
|||
char *SRP_check_known_gN_param(BIGNUM *g, BIGNUM *N); |
|||
SRP_gN *SRP_get_default_gN(const char *id); |
|||
|
|||
/* server side .... */ |
|||
BIGNUM *SRP_Calc_server_key(BIGNUM *A, BIGNUM *v, BIGNUM *u, BIGNUM *b, |
|||
BIGNUM *N); |
|||
BIGNUM *SRP_Calc_B(BIGNUM *b, BIGNUM *N, BIGNUM *g, BIGNUM *v); |
|||
int SRP_Verify_A_mod_N(BIGNUM *A, BIGNUM *N); |
|||
BIGNUM *SRP_Calc_u(BIGNUM *A, BIGNUM *B, BIGNUM *N); |
|||
|
|||
/* client side .... */ |
|||
BIGNUM *SRP_Calc_x(BIGNUM *s, const char *user, const char *pass); |
|||
BIGNUM *SRP_Calc_A(BIGNUM *a, BIGNUM *N, BIGNUM *g); |
|||
BIGNUM *SRP_Calc_client_key(BIGNUM *N, BIGNUM *B, BIGNUM *g, BIGNUM *x, |
|||
BIGNUM *a, BIGNUM *u); |
|||
int SRP_Verify_B_mod_N(BIGNUM *B, BIGNUM *N); |
|||
|
|||
# define SRP_MINIMAL_N 1024 |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
# endif |
|||
#endif |
|||
@ -1,148 +0,0 @@ |
|||
/* ssl/srtp.h */ |
|||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
|||
* All rights reserved. |
|||
* |
|||
* This package is an SSL implementation written |
|||
* by Eric Young (eay@cryptsoft.com). |
|||
* The implementation was written so as to conform with Netscapes SSL. |
|||
* |
|||
* This library is free for commercial and non-commercial use as long as |
|||
* the following conditions are aheared to. The following conditions |
|||
* apply to all code found in this distribution, be it the RC4, RSA, |
|||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation |
|||
* included with this distribution is covered by the same copyright terms |
|||
* except that the holder is Tim Hudson (tjh@cryptsoft.com). |
|||
* |
|||
* Copyright remains Eric Young's, and as such any Copyright notices in |
|||
* the code are not to be removed. |
|||
* If this package is used in a product, Eric Young should be given attribution |
|||
* as the author of the parts of the library used. |
|||
* This can be in the form of a textual message at program startup or |
|||
* in documentation (online or textual) provided with the package. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. All advertising materials mentioning features or use of this software |
|||
* must display the following acknowledgement: |
|||
* "This product includes cryptographic software written by |
|||
* Eric Young (eay@cryptsoft.com)" |
|||
* The word 'cryptographic' can be left out if the rouines from the library |
|||
* being used are not cryptographic related :-). |
|||
* 4. If you include any Windows specific code (or a derivative thereof) from |
|||
* the apps directory (application code) you must include an acknowledgement: |
|||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
* |
|||
* The licence and distribution terms for any publically available version or |
|||
* derivative of this code cannot be changed. i.e. this code cannot simply be |
|||
* copied and put under another distribution licence |
|||
* [including the GNU Public Licence.] |
|||
*/ |
|||
/* ====================================================================
|
|||
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in |
|||
* the documentation and/or other materials provided with the |
|||
* distribution. |
|||
* |
|||
* 3. All advertising materials mentioning features or use of this |
|||
* software must display the following acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
|||
* |
|||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
|||
* endorse or promote products derived from this software without |
|||
* prior written permission. For written permission, please contact |
|||
* openssl-core@openssl.org. |
|||
* |
|||
* 5. Products derived from this software may not be called "OpenSSL" |
|||
* nor may "OpenSSL" appear in their names without prior written |
|||
* permission of the OpenSSL Project. |
|||
* |
|||
* 6. Redistributions of any form whatsoever must retain the following |
|||
* acknowledgment: |
|||
* "This product includes software developed by the OpenSSL Project |
|||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
|||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
|||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
|||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
|||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
* ==================================================================== |
|||
* |
|||
* This product includes cryptographic software written by Eric Young |
|||
* (eay@cryptsoft.com). This product includes software written by Tim |
|||
* Hudson (tjh@cryptsoft.com). |
|||
* |
|||
*/ |
|||
/*
|
|||
* DTLS code by Eric Rescorla <ekr@rtfm.com> |
|||
* |
|||
* Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc. |
|||
*/ |
|||
|
|||
#ifndef HEADER_D1_SRTP_H |
|||
# define HEADER_D1_SRTP_H |
|||
|
|||
# include <openssl/ssl.h> |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
# define SRTP_AES128_CM_SHA1_80 0x0001 |
|||
# define SRTP_AES128_CM_SHA1_32 0x0002 |
|||
# define SRTP_AES128_F8_SHA1_80 0x0003 |
|||
# define SRTP_AES128_F8_SHA1_32 0x0004 |
|||
# define SRTP_NULL_SHA1_80 0x0005 |
|||
# define SRTP_NULL_SHA1_32 0x0006 |
|||
|
|||
# ifndef OPENSSL_NO_SRTP |
|||
|
|||
int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles); |
|||
int SSL_set_tlsext_use_srtp(SSL *ctx, const char *profiles); |
|||
SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s); |
|||
|
|||
STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *ssl); |
|||
SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s); |
|||
|
|||
# endif |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
File diff suppressed because it is too large
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue