mirror of https://github.com/lukechilds/node.git
Browse Source
This just replaces all sources of openssl-1.0.1u.tar.gz into deps/openssl/openssl. PR-URL: https://github.com/nodejs/node/pull/8718 Reviewed-By: Fedor Indutny <fedor@indutny.com> Reviewed-By: Myles Borins <mborins@us.ibm.com>v0.10
Shigeki Ohtsu
8 years ago
committed by
Rod Vagg
177 changed files with 1651 additions and 38121 deletions
@ -1,38 +1,75 @@ |
|||
HOW TO CONTRIBUTE TO OpenSSL |
|||
---------------------------- |
|||
HOW TO CONTRIBUTE TO PATCHES OpenSSL |
|||
------------------------------------ |
|||
|
|||
Development is coordinated on the openssl-dev mailing list (see |
|||
http://www.openssl.org for information on subscribing). If you |
|||
would like to submit a patch, send it to rt@openssl.org with |
|||
the string "[PATCH]" in the subject. Please be sure to include a |
|||
textual explanation of what your patch does. |
|||
|
|||
You can also make GitHub pull requests. If you do this, please also send |
|||
mail to rt@openssl.org with a brief description and a link to the PR so |
|||
that we can more easily keep track of it. |
|||
(Please visit https://www.openssl.org/community/getting-started.html for |
|||
other ideas about how to contribute.) |
|||
|
|||
Development is coordinated on the openssl-dev mailing list (see the |
|||
above link or https://mta.openssl.org for information on subscribing). |
|||
If you are unsure as to whether a feature will be useful for the general |
|||
OpenSSL community please discuss it on the openssl-dev mailing list first. |
|||
Someone may be already working on the same thing or there may be a good |
|||
reason as to why that feature isn't implemented. |
|||
|
|||
Patches should be as up to date as possible, preferably relative to the |
|||
current Git or the last snapshot. They should follow our coding style |
|||
(see https://www.openssl.org/policies/codingstyle.html) and compile without |
|||
warnings using the --strict-warnings flag. OpenSSL compiles on many varied |
|||
platforms: try to ensure you only use portable features. |
|||
OpenSSL community you might want to discuss it on the openssl-dev mailing |
|||
list first. Someone may be already working on the same thing or there |
|||
may be a good reason as to why that feature isn't implemented. |
|||
|
|||
Our preferred format for patch files is "git format-patch" output. For example |
|||
to provide a patch file containing the last commit in your local git repository |
|||
use the following command: |
|||
The best way to submit a patch is to make a pull request on GitHub. |
|||
(It is not necessary to send mail to rt@openssl.org to open a ticket!) |
|||
If you think the patch could use feedback from the community, please |
|||
start a thread on openssl-dev. |
|||
|
|||
# git format-patch --stdout HEAD^ >mydiffs.patch |
|||
You can also submit patches by sending it as mail to rt@openssl.org. |
|||
Please include the word "PATCH" and an explanation of what the patch |
|||
does in the subject line. If you do this, our preferred format is "git |
|||
format-patch" output. For example to provide a patch file containing the |
|||
last commit in your local git repository use the following command: |
|||
|
|||
% git format-patch --stdout HEAD^ >mydiffs.patch |
|||
|
|||
Another method of creating an acceptable patch file without using git is as |
|||
follows: |
|||
|
|||
# cd openssl-work |
|||
# [your changes] |
|||
# ./Configure dist; make clean |
|||
# cd .. |
|||
# diff -ur openssl-orig openssl-work > mydiffs.patch |
|||
% cd openssl-work |
|||
...make your changes... |
|||
% ./Configure dist; make clean |
|||
% cd .. |
|||
% diff -ur openssl-orig openssl-work >mydiffs.patch |
|||
|
|||
Note that pull requests are generally easier for the team, and community, to |
|||
work with. Pull requests benefit from all of the standard GitHub features, |
|||
including code review tools, simpler integration, and CI build support. |
|||
|
|||
No matter how a patch is submitted, the following items will help make |
|||
the acceptance and review process faster: |
|||
|
|||
1. Anything other than trivial contributions will require a contributor |
|||
licensing agreement, giving us permission to use your code. See |
|||
https://www.openssl.org/policies/cla.html for details. |
|||
|
|||
2. All source files should start with the following text (with |
|||
appropriate comment characters at the start of each line and the |
|||
year(s) updated): |
|||
|
|||
Copyright 20xx-20yy The OpenSSL Project Authors. All Rights Reserved. |
|||
|
|||
Licensed under the OpenSSL license (the "License"). You may not use |
|||
this file except in compliance with the License. You can obtain a copy |
|||
in the file LICENSE in the source distribution or at |
|||
https://www.openssl.org/source/license.html |
|||
|
|||
3. Patches should be as current as possible. When using GitHub, please |
|||
expect to have to rebase and update often. Note that we do not accept merge |
|||
commits. You will be asked to remove them before a patch is considered |
|||
acceptable. |
|||
|
|||
4. Patches should follow our coding style (see |
|||
https://www.openssl.org/policies/codingstyle.html) and compile without |
|||
warnings. Where gcc or clang is availble you should use the |
|||
--strict-warnings Configure option. OpenSSL compiles on many varied |
|||
platforms: try to ensure you only use portable features. |
|||
|
|||
5. When at all possible, patches should include tests. These can either be |
|||
added to an existing test, or completely new. Please see test/README |
|||
for information on the test framework. |
|||
|
|||
6. New features or changed functionality must include documentation. Please |
|||
look at the "pod" files in doc/apps, doc/crypto and doc/ssl for examples of |
|||
our style. |
|||
|
@ -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,59 @@ |
|||
=pod |
|||
|
|||
=head1 NAME |
|||
|
|||
d2i_Private_key, d2i_AutoPrivateKey, i2d_PrivateKey - decode and encode |
|||
functions for reading and saving EVP_PKEY structures. |
|||
|
|||
=head1 SYNOPSIS |
|||
|
|||
#include <openssl/evp.h> |
|||
|
|||
EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, |
|||
long length); |
|||
EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, |
|||
long length); |
|||
int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp); |
|||
|
|||
=head1 DESCRIPTION |
|||
|
|||
d2i_PrivateKey() decodes a private key using algorithm B<type>. It attempts to |
|||
use any key specific format or PKCS#8 unencrypted PrivateKeyInfo format. The |
|||
B<type> parameter should be a public key algorithm constant such as |
|||
B<EVP_PKEY_RSA>. An error occurs if the decoded key does not match B<type>. |
|||
|
|||
d2i_AutoPrivateKey() is similar to d2i_PrivateKey() except it attempts to |
|||
automatically detect the private key format. |
|||
|
|||
i2d_PrivateKey() encodes B<key>. It uses a key specific format or, if none is |
|||
defined for that key type, PKCS#8 unencrypted PrivateKeyInfo format. |
|||
|
|||
These functions are similar to the d2i_X509() functions, and you should refer to |
|||
that page for a detailed description (see L<d2i_X509(3)>). |
|||
|
|||
=head1 NOTES |
|||
|
|||
All these functions use DER format and unencrypted keys. Applications wishing |
|||
to encrypt or decrypt private keys should use other functions such as |
|||
d2i_PKC8PrivateKey() instead. |
|||
|
|||
If the B<*a> is not NULL when calling d2i_PrivateKey() or d2i_AutoPrivateKey() |
|||
(i.e. an existing structure is being reused) and the key format is PKCS#8 |
|||
then B<*a> will be freed and replaced on a successful call. |
|||
|
|||
=head1 RETURN VALUES |
|||
|
|||
d2i_PrivateKey() and d2i_AutoPrivateKey() return a valid B<EVP_KEY> structure |
|||
or B<NULL> if an error occurs. The error code can be obtained by calling |
|||
L<ERR_get_error(3)>. |
|||
|
|||
i2d_PrivateKey() returns the number of bytes successfully encoded or a |
|||
negative value if an error occurs. The error code can be obtained by calling |
|||
L<ERR_get_error(3)>. |
|||
|
|||
=head1 SEE ALSO |
|||
|
|||
L<crypto(3)>, |
|||
L<d2i_PKCS8PrivateKey(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,83 +0,0 @@ |
|||
|
|||
#ifndef HEADER_COMP_H |
|||
# define HEADER_COMP_H |
|||
|
|||
# include <openssl/crypto.h> |
|||
|
|||
# ifdef OPENSSL_NO_COMP |
|||
# error COMP is disabled. |
|||
# endif |
|||
|
|||
#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 |
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue