upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-04-15 22:09:31 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove dnssafe, cylink, and the broken dst random generator.

Browse source
This commit is contained in:
Brian Wellington 2001-04-03 00:28:16 +00:00
parent 7b1ab9e210
commit 9bd186cd9a
206 changed files with 10 additions and 34542 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
lib/bind/Makefile.in
View file

@ -3,18 +3,8 @@ BSDOBJS= daemon.o putenv.o strcasecmp.o strsep.o ftruncate.o \
strerror.o utimes.o mktemp.o setitimer.o strpbrk.o \
writev.o
SUBDIRS = bsd cylink dnssafe dst include inet irs isc nameser resolv
OBJS= prand_conf.@O@
SRCS= prand_conf.c
SUBDIRS = bsd dst include inet irs isc nameser resolv
@BIND9_MAKE_RULES@
all depend: prand_conf.h
prand_conf.h: prand_conf
./prand_conf > $@
prand_conf: ${OBJS}
${CC} -o $@ ${OBJS}
all depend:

95
lib/bind/configure.in
View file

@ -18,7 +18,7 @@ AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)dnl
esyscmd([sed "s/^/# /" COPYRIGHT])dnl
AC_DIVERT_POP()dnl
AC_REVISION($Revision: 1.6 $)
AC_REVISION($Revision: 1.7 $)
AC_INIT(resolv/herror.c)
AC_PREREQ(2.13)
@ -304,97 +304,6 @@ AC_SUBST(WANT_IRS_NIS_OBJS)
AC_SUBST(WANT_IRS_NISGR_OBJS)
AC_SUBST(WANT_IRS_NISPW_OBJS)
#
# was --with-openssl specified?
#
AC_MSG_CHECKING(for compatible OpenSSL library)
AC_ARG_WITH(openssl,
[ --with-openssl=PATH Specify path for system-supplied openssl
(rather than using bind-9 internal openssl)],
use_openssl="$withval", use_openssl="no")
#
# If the user didn't specify where openssl is, and we didn't find or it
# is incompatible with our code, use our internal one.
#
# XXX This appears to assume that the user specified path is correct,
# and does no checking.
#
case "$use_openssl" in
no)
DST_PRIVATEOPENSSL='-DDST_USE_PRIVATE_OPENSSL'
dst_privateopenssl='openssl'
DST_OPENSSL_INC='-I${srcdir}/../openssl/include'
DST_OPENSSL_LIB=''
DST_OPENSSL_OBJS='${OPENSSLOBJS}'
AC_MSG_RESULT(using private library)
openssl_makefiles="lib/dns/sec/openssl/Makefile \
lib/dns/sec/openssl/include/Makefile \
lib/dns/sec/openssl/include/openssl/Makefile"
;;
yes)
AC_MSG_ERROR([--with-openssl must specify a path])
;;
*)
DST_PRIVATEOPENSSL=''
dst_privateopenssl=''
DST_OPENSSL_INC="-I$use_openssl/include"
DNS_OPENSSL_LIBS="-L$use_openssl/lib -lcrypto"
DST_OPENSSL_LIB=''
AC_MSG_RESULT(using openssl from $use_openssl/lib and $use_openssl/include)
openssl_makefiles=""
;;
esac
AC_SUBST(DST_PRIVATEOPENSSL)
AC_SUBST(dst_privateopenssl)
AC_SUBST(DST_OPENSSL_INC)
AC_SUBST(DST_OPENSSL_LIB)
AC_SUBST(DST_OPENSSL_OBJS)
#
# This would include the system openssl path (and linker options to use
# it as needed) if it is found.
#
AC_SUBST(DNS_OPENSSL_LIBS)
#
# was --with-gssapi specified?
#
#AC_MSG_CHECKING(for GSSAPI library)
#AC_ARG_WITH(gssapi,
#[ --with-gssapi=PATH Specify path for system-supplied GSSAPI],
# use_gssapi="$withval", use_gssapi="no")
#
#case "$use_gssapi" in
# no)
# USE_GSSAPI=''
# DST_GSSAPI_INC=''
# DNS_GSSAPI_LIBS=''
# AC_MSG_RESULT(not specified)
# ;;
# yes)
# AC_MSG_ERROR([--with-gssapi must specify a path])
# ;;
# *)
# USE_GSSAPI='-DGSSAPI'
# DST_GSSAPI_INC="-I$use_gssapi/include"
# DNS_GSSAPI_LIBS="-L$use_gssapi/lib -lgssapi_krb5"
# AC_MSG_RESULT(using gssapi from $use_gssapi/lib and $use_gssapi/include)
# ;;
#esac
USE_GSSAPI=''
DST_GSSAPI_INC=''
DNS_GSSAPI_LIBS=''
AC_SUBST(USE_GSSAPI)
AC_SUBST(DST_GSSAPI_INC)
AC_SUBST(DNS_GSSAPI_LIBS)
#
# was --with-randomdev specified?
#
@ -1822,8 +1731,6 @@ AC_OUTPUT(
make/includes
Makefile
bsd/Makefile
cylink/Makefile
dnssafe/Makefile
dst/Makefile
include/Makefile
inet/Makefile

12
lib/bind/cylink/Makefile.in
View file

@ -1,12 +0,0 @@
OBJS= bn.@O@ bn00.@O@ lbn00.@O@ lbnmem.@O@ legal.@O@ \
bits.@O@ dss.@O@ math.@O@ ctk_prime.@O@ rand.@O@ sha.@O@ swap.@O@
SRCS= bn.c bn00.c lbn00.c lbnmem.c legal.c \
bits.c dss.c math.c ctk_prime.c rand.c sha.c swap.c
TARGETS= ${OBJS}
CINCLUDES= -I.. -I../include
CWARNINGS= -Werror
@BIND9_MAKE_RULES@

359
lib/bind/cylink/bits.c
View file

@ -1,359 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: bit.c PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Bit Utility Functions
*
* PUBLIC FUNCTIONS:
*
*
* PRIVATE FUNCTIONS:
*
* REVISION HISTORY:
*
*
****************************************************************************/
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
/* bn files */
#include "port_before.h"
#include <sys/types.h>
#include "bn.h"
/* system files */
#ifdef VXD
#include <vtoolsc.h>
#else
#include <stdlib.h>
#include <string.h>
#endif
/* program files */
#include "cylink.h"
#include "ctk_endian.h"
#include "c_asm.h"
#include "port_after.h"
/****************************************************************************
* NAME: void RShiftL( ord *X,
* u_int32_t len_X,
* u_int32_t n_bit )
*
* DESCRIPTION: Shift array to the right by n_bit.
*
* INPUTS:
* PARAMETERS:
* ord *X Pointer to array
* u_int32_t len_X Length of array
* u_int32_t n_bit Number of bits
* OUTPUT:
* PARAMETERS:
* ord *X Pointer to array
*
* RETURN:
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void RShiftL_big( ord *X,
u_int32_t len_X,
u_int32_t n_bit )
{
struct BigNum dest;
bnInit();
bnBegin(&dest);
dest.ptr = X;
dest.size = len_X;
dest.allocated = len_X;
bnRShift(&dest,n_bit);
}
/****************************************************************************
* NAME: void LShiftL( ord *X,
* u_int32_t len_X,
* u_int32_t n_bit )
*
* DESCRIPTION: Shifts array to the left by n_bit.
*
* INPUTS:
* PARAMETERS:
* ord *X Pointer to array
* u_int32_t len_X Length of array
* u_int32_t n_bit Number of bits
* OUTPUT:
* PARAMETERS:
* ord *X Pointer to array
*
* RETURN:
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void LShiftL_big( ord *X,
u_int32_t len_X,
u_int32_t n_bit )
{
struct BigNum dest;
bnInit();
bnBegin(&dest);
dest.ptr = X;
dest.size = len_X;
dest.allocated = len_X;
bnLShift(&dest,n_bit);
}
/************9****************************************************************
* NAME: int RShiftMostBit( ord *a,
* u_int32_t len )
*
* DESCRIPTION: Find a least significant non zero bit
* and sfift array to the right
*
* INPUTS:
* PARAMETERS:
* ord *a Pointer to array
* u_int32_t len Number of elements in number
* OUTPUT:
*
* RETURN:
* Number of shifted bits
*
* REVISION HISTORY:
*
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
int RShiftMostBit( ord *a,
u_int32_t len )
{
struct BigNum n;
bnInit();
bnBegin(&n);
n.size = len;
n.ptr = a;
n.allocated = len;
return (bnMakeOdd(&n));
}
/****************************************************************************
* NAME: void ByteLong (uchar *X, u_int32_t X_bytes,
* u_int32_t *Y )
*
*
* DESCRIPTION: Transfer bytes to u_int32_t.
*
* INPUTS:
* PARAMETERS:
* uchar *X Pointer to byte array
* u_int32_t X_bytes Number of bytes in array
* OUTPUT:
* PARAMETERS:
* u_int32_t *Y Pointer to long arrray
*
* RETURN:
*
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void ByteLong( uchar *X,
u_int32_t X_bytes,
u_int32_t *Y )
{
u_int32_t i, j; /* counters */
for ( i = 0, j = 0; j < X_bytes; i++, j += 4)
{
Y[i] = ( (u_int32_t)X[j] ) | ( ((u_int32_t)X[j+1]) << 8 ) |
( ((u_int32_t)X[j+2]) << 16 ) | ( ((u_int32_t)X[j+3]) << 24 );
}
}
/****************************************************************************
* NAME: void ByteOrd (uchar *X, u_int32_t X_bytes,
* ord *Y )
*
*
* DESCRIPTION: Transfer bytes to ord.
*
* INPUTS:
* PARAMETERS:
* uchar *X Pointer to byte array
* u_int32_t X_bytes Number of bytes in array
* OUTPUT:
* PARAMETERS:
* ord *Y Pointer to long array
*
* RETURN:
*
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void ByteOrd( uchar *X,
u_int32_t X_bytes,
ord *Y )
{
u_int32_t i, j; /* counters */
for ( i = 0, j = 0; j < X_bytes; i++, j += sizeof(ord))
{
Y[i] = ( (ord)X[j] ) | ( ((ord)X[j+1]) << 8 )
#ifdef ORD_32
| ( ((ord)X[j+2]) << 16 ) | ( ((ord)X[j+3]) << 24 )
#endif
;
}
}
/****************************************************************************
* NAME: void OrdByte (ord *X, u_int32_t X_bytes,
* uchar *Y )
*
*
* DESCRIPTION: Transfer ord to bytes.
*
* INPUTS:
* PARAMETERS:
* ord *X Pointer to ord array
* u_int32_t X_bytes Number of bytes in array
* OUTPUT:
* PARAMETERS:
* uchar *Y Pointer to byte array
*
* RETURN:
*
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void OrdByte( ord *X,
u_int32_t X_bytes,
uchar *Y )
{
u_int32_t i, j; /* counters */
for ( i=0, j=0; j < X_bytes; i++, j += sizeof(ord))
{
Y[j] = (uchar ) ( X[i] & 0xff );
Y[j+1] = (uchar)( (X[i] >> 8) & 0xff );
#ifdef ORD_32
Y[j+2] = (uchar)( (X[i] >> 16) & 0xff );
Y[j+3] = (uchar)( (X[i] >> 24) & 0xff );
#endif
}
}
/****************************************************************************
* NAME: void LongByte( u_int32_t *X,
* u_int32_t X_bytes,
* uchar *Y )
*
* DESCRIPTION: Transfer u_int32_t to bytes.
*
* INPUTS:
* PARAMETERS:
* u_int32_t *X Pointer to long array
* u_int32_t X_bytes Number of longs in array
* OUTPUT:
* PARAMETERS:
* uchar *Y Pointer to bytes array
*
* RETURN:
*
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void LongByte( u_int32_t *X,
u_int32_t X_bytes,
uchar *Y )
{
u_int32_t i, j; /* counters */
for ( i=0, j=0; j < X_bytes; i++, j += 4)
{
Y[j] = (uchar ) ( X[i] & 0xff );
Y[j+1] = (uchar)( (X[i] >> 8) & 0xff );
Y[j+2] = (uchar)( (X[i] >> 16) & 0xff );
Y[j+3] = (uchar)( (X[i] >> 24) & 0xff );
}
}

131
lib/bind/cylink/bn.c
View file

@ -1,131 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn.c - the high-level bignum interface
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*/
#include "port_before.h"
#include "bn.h"
#include "port_after.h"
/* Functions */
void
bnBegin(struct BigNum *bn)
{
static int bninit = 0;
if (!bninit) {
bnInit();
bninit = 1;
}
bn->ptr = 0;
bn->size = 0;
bn->allocated = 0;
}
void
bnSwap(struct BigNum *a, struct BigNum *b)
{
void *p;
unsigned t;
p = a->ptr;
a->ptr = b->ptr;
b->ptr = p;
t = a->size;
a->size = b->size;
b->size = t;
t = a->allocated;
a->allocated = b->allocated;
b->allocated = t;
}
void (*bnEnd)(struct BigNum *bn);
int (*bnPrealloc)(struct BigNum *bn, unsigned bits);
int (*bnCopy)(struct BigNum *dest, struct BigNum const *src);
void (*bnNorm)(struct BigNum *bn);
void (*bnExtractBigBytes)(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned len);
int (*bnInsertBigBytes)(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
void (*bnExtractLittleBytes)(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned len);
int (*bnInsertLittleBytes)(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
unsigned (*bnLSWord)(struct BigNum const *src);
unsigned (*bnBits)(struct BigNum const *src);
int (*bnAdd)(struct BigNum *dest, struct BigNum const *src);
int (*bnSub)(struct BigNum *dest, struct BigNum const *src);
int (*bnCmpQ)(struct BigNum const *a, unsigned b);
int (*bnSetQ)(struct BigNum *dest, unsigned src);
int (*bnAddQ)(struct BigNum *dest, unsigned src);
int (*bnSubQ)(struct BigNum *dest, unsigned src);
int (*bnCmp)(struct BigNum const *a, struct BigNum const *b);
int (*bnSquare)(struct BigNum *dest, struct BigNum const *src);
int (*bnMul)(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
int (*bnMulQ)(struct BigNum *dest, struct BigNum const *a, unsigned b);
int (*bnDivMod)(struct BigNum *q, struct BigNum *r, struct BigNum const *n,
struct BigNum const *d);
int (*bnMod)(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *d);
unsigned (*bnModQ)(struct BigNum const *src, unsigned d);
int (*bnExpMod)(struct BigNum *result, struct BigNum const *n,
struct BigNum const *exp, struct BigNum const *mod);
int (*bnDoubleExpMod)(struct BigNum *dest,
struct BigNum const *n1, struct BigNum const *e1,
struct BigNum const *n2, struct BigNum const *e2,
struct BigNum const *mod);
int (*bnTwoExpMod)(struct BigNum *n, struct BigNum const *exp,
struct BigNum const *mod);
int (*bnGcd)(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
int (*bnInv)(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *mod);
int (*bnLShift)(struct BigNum *dest, unsigned amt);
void (*bnRShift)(struct BigNum *dest, unsigned amt);
unsigned (*bnMakeOdd)(struct BigNum *n);

221
lib/bind/cylink/bn.h
View file

@ -1,221 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn.h - the interface to the bignum routines.
* All functions which return ints can potentially allocate memory
* and return -1 if they are unable to. All "const" arguments
* are unmodified.
*
* This is not particularly asymmetric, as some operations are of the
* form a = b @ c, while others do a @= b. In general, outputs may not
* point to the same struct BigNums as inputs, except as specified
* below. This relationship is referred to as "being the same as".
* This is not numerical equivalence.
*
* The "Q" operations take "unsigned" inputs. Higher values of the
* extra input may work on some implementations, but 65535 is the
* highest portable value. Just because UNSIGNED_MAX is larger than
* that, or you know that the word size of the library is larger than that,
* that, does *not* mean it's allowed.
*/
#ifndef BN_H
#define BN_H
struct BigNum {
void *ptr;
unsigned size; /* Note: in (variable-sized) words */
unsigned allocated;
};
/* Functions */
/*
* You usually never have to call this function explicitly, as
* bnBegin() takes care of it. If the program jumps to address 0,
* this function has bot been called.
*/
void bnInit(void);
/*
* This initializes an empty struct BigNum to a zero value.
* Do not use this on a BigNum which has had a value stored in it!
*/
void bnBegin(struct BigNum *bn);
/* Swap two BigNums. Cheap. */
void bnSwap(struct BigNum *a, struct BigNum *b);
/* Reset an initialized bigNum to empty, pending deallocation. */
extern void (*bnEnd)(struct BigNum *bn);
/*
* If you know you'll need space in the number soon, you can use this function
* to ensure that there is room for at least "bits" bits. Optional.
* Returns <0 on out of memory, but the value is unaffected.
*/
extern int (*bnPrealloc)(struct BigNum *bn, unsigned bits);
/* Hopefully obvious. dest = src. dest may be the same as src. */
extern int (*bnCopy)(struct BigNum *dest, struct BigNum const *src);
/*
* Mostly done automatically, but this removes leading zero words from
* the internal representation of the BigNum. Use is unclear.
*/
extern void (*bnNorm)(struct BigNum *bn);
/*
* Move bytes between the given buffer and the given BigNum encoded in
* base 256. I.e. after either of these, the buffer will be equal to
* (bn / 256^lsbyte) % 256^len. The difference is which is altered to
* match the other!
*/
extern void (*bnExtractBigBytes)(struct BigNum const *bn,
unsigned char *dest, unsigned lsbyte, unsigned len);
extern int (*bnInsertBigBytes)(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
/* The same, but the buffer is little-endian. */
extern void (*bnExtractLittleBytes)(struct BigNum const *bn,
unsigned char *dest, unsigned lsbyte, unsigned len);
extern int (*bnInsertLittleBytes)(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
/* Return the least-significant bits (at least 16) of the BigNum */
extern unsigned (*bnLSWord)(struct BigNum const *src);
/*
* Return the number of significant bits in the BigNum.
* 0 or 1+floor(log2(src))
*/
extern unsigned (*bnBits)(struct BigNum const *src);
/*
* dest += src. dest and src may be the same. Guaranteed not to
* allocate memory unnecessarily, so if you're sure bnBits(dest)
* won't change, you don't need to check the return value.
*/
extern int (*bnAdd)(struct BigNum *dest, struct BigNum const *src);
/*
* dest -= src. dest and src may be the same, but bnSetQ(dest, 0) is faster.
* if dest < src, returns +1 and sets dest = src-dest.
*/
extern int (*bnSub)(struct BigNum *dest, struct BigNum const *src);
/* Return sign (-1, 0, +1) of a-b. a <=> b --> bnCmpQ(a, b) <=> 0 */
extern int (*bnCmpQ)(struct BigNum const *a, unsigned b);
/* dest = src, where 0 <= src < 2^16. */
extern int (*bnSetQ)(struct BigNum *dest, unsigned src);
/* dest += src, where 0 <= src < 2^16 */
extern int (*bnAddQ)(struct BigNum *dest, unsigned src);
/* dest -= src, where 0 <= src < 2^16 */
extern int (*bnSubQ)(struct BigNum *dest, unsigned src);
/* Return sign (-1, 0, +1) of a-b. a <=> b --> bnCmp(a, b) <=> 0 */
extern int (*bnCmp)(struct BigNum const *a, struct BigNum const *b);
/* dest = src^2. dest may be the same as src, but it costs time. */
extern int (*bnSquare)(struct BigNum *dest, struct BigNum const *src);
/* dest = a * b. dest may be the same as a or b, but it costs time. */
extern int (*bnMul)(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
/* dest = a * b, where 0 <= b < 2^16. dest and a may be the same. */
extern int (*bnMulQ)(struct BigNum *dest, struct BigNum const *a, unsigned b);
/*
* q = n/d, r = n%d. r may be the same as n, but not d,
* and q may not be the same as n or d.
* re-entrancy issue: this temporarily modifies d, but restores
* it for return.
*/
extern int (*bnDivMod)(struct BigNum *q, struct BigNum *r,
struct BigNum const *n, struct BigNum const *d);
/*
* dest = src % d. dest and src may be the same, but not dest and d.
* re-entrancy issue: this temporarily modifies d, but restores
* it for return.
*/
extern int (*bnMod)(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *d);
/* return src % d, where 0 <= d < 2^16. */
extern unsigned int (*bnModQ)(struct BigNum const *src, unsigned d);
/* n = n^exp, modulo "mod" "mod" *must* be odd */
extern int (*bnExpMod)(struct BigNum *result, struct BigNum const *n,
struct BigNum const *exp, struct BigNum const *mod);
/*
* dest = n1^e1 * n2^e2, modulo "mod". "mod" *must* be odd.
* dest may be the same as n1 or n2.
*/
extern int (*bnDoubleExpMod)(struct BigNum *dest,
struct BigNum const *n1, struct BigNum const *e1,
struct BigNum const *n2, struct BigNum const *e2,
struct BigNum const *mod);
/* n = 2^exp, modulo "mod" "mod" *must* be odd */
extern int (*bnTwoExpMod)(struct BigNum *n, struct BigNum const *exp,
struct BigNum const *mod);
/* dest = gcd(a, b). The inputs may overlap arbitrarily. */
extern int (*bnGcd)(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
/* dest = src^-1, modulo "mod". dest may be the same as src. */
extern int (*bnInv)(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *mod);
/* Shift dest left "amt" places */
extern int (*bnLShift)(struct BigNum *dest, unsigned amt);
/* Shift dest right "amt" places, discarding low-order bits */
extern void (*bnRShift)(struct BigNum *dest, unsigned amt);
/* For the largest 2^k that divides n, divide n by it and return k. */
extern unsigned (*bnMakeOdd)(struct BigNum *n);
#endif/* !BN_H */

68
lib/bind/cylink/bn00.c
View file

@ -1,68 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn00.c - auto-size-detecting bn??.c file.
*
* Written in 1995 by Colin Plumb.
*/
#include "port_before.h"
#include "bnsize00.h"
#if BNSIZE64
/* Include all of the C source file by reference */
#include "bn64.c"
#include "bninit64.c"
#elif BNSIZE32
/* Include all of the C source file by reference */
#include "bn32.c"
#include "bninit32.c"
#else /* BNSIZE16 */
/* Include all of the C source file by reference */
#include "bn16.c"
#include "bninit16.c"
#endif

949
lib/bind/cylink/bn16.c
View file

@ -1,949 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn16.c - the high-level bignum interface
*
* Like lbn16.c, this reserves the string "16" for textual replacement.
* The string must not appear anywhere unless it is intended to be replaced
* to generate other bignum interface functions.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*/
#ifndef HAVE_CONFIG_H
#define HAVE_CONFIG_H 0
#endif
#if HAVE_CONFIG_H
#include "config.h"
#endif
/*
* Some compilers complain about #if FOO if FOO isn't defined,
* so do the ANSI-mandated thing explicitly...
*/
#ifndef NO_ASSERT_H
#define NO_ASSERT_H 0
#endif
#ifndef NO_STRING_H
#define NO_STRING_H 0
#endif
#ifndef HAVE_STRINGS_H
#define HAVE_STRINGS_H 0
#endif
#ifndef NEED_MEMORY_H
#define NEED_MEMORY_H 0
#endif
#if !NO_ASSERT_H
#include <assert.h>
#else
#define assert(x) (void)0
#endif
#if !NO_STRING_H
#include <string.h> /* for memmove() in bnMakeOdd */
#elif HAVE_STRINGS_H
#include <strings.h>
#endif
#if NEED_MEMORY_H
#include <memory.h>
#endif
/*
* This was useful during debugging, so it's left in here.
* You can ignore it. DBMALLOC is generally undefined.
*/
#ifndef DBMALLOC
#define DBAMLLOC 0
#endif
#if DBMALLOC
#include "../dbmalloc/malloc.h"
#define MALLOCDB malloc_chain_check(1)
#else
#define MALLOCDB (void)0
#endif
#include "lbn.h"
#include "lbn16.h"
#include "lbnmem.h"
#include "bn16.h"
#include "bn.h"
/* Work-arounds for some particularly broken systems */
#include "kludge.h" /* For memmove() */
#include <port_after.h>
/* Functions */
void
bnInit_16(void)
{
bnEnd = bnEnd_16;
bnPrealloc = bnPrealloc_16;
bnCopy = bnCopy_16;
bnNorm = bnNorm_16;
bnExtractBigBytes = bnExtractBigBytes_16;
bnInsertBigBytes = bnInsertBigBytes_16;
bnExtractLittleBytes = bnExtractLittleBytes_16;
bnInsertLittleBytes = bnInsertLittleBytes_16;
bnLSWord = bnLSWord_16;
bnBits = bnBits_16;
bnAdd = bnAdd_16;
bnSub = bnSub_16;
bnCmpQ = bnCmpQ_16;
bnSetQ = bnSetQ_16;
bnAddQ = bnAddQ_16;
bnSubQ = bnSubQ_16;
bnCmp = bnCmp_16;
bnSquare = bnSquare_16;
bnMul = bnMul_16;
bnMulQ = bnMulQ_16;
bnDivMod = bnDivMod_16;
bnMod = bnMod_16;
bnModQ = bnModQ_16;
bnExpMod = bnExpMod_16;
bnDoubleExpMod = bnDoubleExpMod_16;
bnTwoExpMod = bnTwoExpMod_16;
bnGcd = bnGcd_16;
bnInv = bnInv_16;
bnLShift = bnLShift_16;
bnRShift = bnRShift_16;
bnMakeOdd = bnMakeOdd_16;
}
void
bnEnd_16(struct BigNum *bn)
{
if (bn->ptr) {
LBNFREE((BNWORD16 *)bn->ptr, bn->allocated);
bn->ptr = 0;
}
bn->size = 0;
bn->allocated = 0;
MALLOCDB;
}
/* Internal function. It operates in words. */
static int
bnResize_16(struct BigNum *bn, unsigned len)
{
void *p;
/* Round size up: most mallocs impose 8-byte granularity anyway */
len = (len + (8/sizeof(BNWORD16) - 1)) & ~(8/sizeof(BNWORD16) - 1);
p = LBNREALLOC((BNWORD16 *)bn->ptr, bn->allocated, len);
if (!p)
return -1;
bn->ptr = p;
bn->allocated = len;
MALLOCDB;
return 0;
}
#define bnSizeCheck(bn, size) \
if (bn->allocated < size && bnResize_16(bn, size) < 0) \
return -1
int
bnPrealloc_16(struct BigNum *bn, unsigned bits)
{
bits = (bits + 16-1)/16;
bnSizeCheck(bn, bits);
MALLOCDB;
return 0;
}
int
bnCopy_16(struct BigNum *dest, struct BigNum const *src)
{
bnSizeCheck(dest, src->size);
dest->size = src->size;
lbnCopy_16((BNWORD16 *)dest->ptr, (BNWORD16 *)src->ptr, src->size);
MALLOCDB;
return 0;
}
void
bnNorm_16(struct BigNum *bn)
{
bn->size = lbnNorm_16((BNWORD16 *)bn->ptr, bn->size);
}
/*
* Convert a bignum to big-endian bytes. Returns, in big-endian form, a
* substring of the bignum starting from lsbyte and "len" bytes long.
* Unused high-order (leading) bytes are filled with 0.
*/
void
bnExtractBigBytes_16(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size * (16 / 8);
/* Fill unused leading bytes with 0 */
while (s < lsbyte+len) {
*dest++ = 0;
len--;
}
if (len)
lbnExtractBigBytes_16((BNWORD16 *)bn->ptr, dest, lsbyte, len);
MALLOCDB;
}
int
bnInsertBigBytes_16(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size;
unsigned words = (len+lsbyte+sizeof(BNWORD16)-1) / sizeof(BNWORD16);
/* Pad with zeros as required */
bnSizeCheck(bn, words);
if (s < words) {
lbnZero_16((BNWORD16 *)bn->ptr BIGLITTLE(-s,+s), words-s);
s = words;
}
lbnInsertBigBytes_16((BNWORD16 *)bn->ptr, src, lsbyte, len);
bn->size = lbnNorm_16((BNWORD16 *)bn->ptr, s);
MALLOCDB;
return 0;
}
/*
* Convert a bignum to little-endian bytes. Returns, in little-endian form, a
* substring of the bignum starting from lsbyte and "len" bytes long.
* Unused high-order (trailing) bytes are filled with 0.
*/
void
bnExtractLittleBytes_16(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size * (16 / 8);
/* Fill unused leading bytes with 0 */
while (s < lsbyte+len)
dest[--len] = 0;
if (len)
lbnExtractLittleBytes_16((BNWORD16 *)bn->ptr, dest,
lsbyte, len);
MALLOCDB;
}
int
bnInsertLittleBytes_16(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size;
unsigned words = (len+lsbyte+sizeof(BNWORD16)-1) / sizeof(BNWORD16);
/* Pad with zeros as required */
bnSizeCheck(bn, words);
if (s < words) {
lbnZero_16((BNWORD16 *)bn->ptr BIGLITTLE(-s,+s), words-s);
s = words;
}
lbnInsertLittleBytes_16((BNWORD16 *)bn->ptr, src, lsbyte, len);
bn->size = lbnNorm_16((BNWORD16 *)bn->ptr, s);
MALLOCDB;
return 0;
}
/* Return the least-significant word of the input. */
unsigned
bnLSWord_16(struct BigNum const *src)
{
return src->size ? (unsigned)((BNWORD16 *)src->ptr)[BIGLITTLE(-1,0)]: 0;
}
unsigned
bnBits_16(struct BigNum const *src)
{
return lbnBits_16((BNWORD16 *)src->ptr, src->size);
}
int
bnAdd_16(struct BigNum *dest, struct BigNum const *src)
{
unsigned s = src->size, d = dest->size;
BNWORD16 t;
if (!s)
return 0;
bnSizeCheck(dest, s);
if (d < s) {
lbnZero_16((BNWORD16 *)dest->ptr BIGLITTLE(-d,+d), s-d);
dest->size = d = s;
MALLOCDB;
}
t = lbnAddN_16((BNWORD16 *)dest->ptr, (BNWORD16 *)src->ptr, s);
MALLOCDB;
if (t) {
if (d > s) {
t = lbnAdd1_16((BNWORD16 *)dest->ptr BIGLITTLE(-s,+s),
d-s, t);
MALLOCDB;
}
if (t) {
bnSizeCheck(dest, d+1);
((BNWORD16 *)dest->ptr)[BIGLITTLE(-1-d,d)] = t;
dest->size = d+1;
}
}
return 0;
}
/*
* dest -= src.
* If dest goes negative, this produces the absolute value of
* the difference (the negative of the true value) and returns 1.
* Otherwise, it returls 0.
*/
int
bnSub_16(struct BigNum *dest, struct BigNum const *src)
{
unsigned s = src->size, d = dest->size;
BNWORD16 t;
if (d < s && d < (s = lbnNorm_16((BNWORD16 *)src->ptr, s))) {
bnSizeCheck(dest, s);
lbnZero_16((BNWORD16 *)dest->ptr BIGLITTLE(-d,+d), s-d);
dest->size = d = s;
MALLOCDB;
}
if (!s)
return 0;
t = lbnSubN_16((BNWORD16 *)dest->ptr, (BNWORD16 *)src->ptr, s);
MALLOCDB;
if (t) {
if (d > s) {
t = lbnSub1_16((BNWORD16 *)dest->ptr BIGLITTLE(-s,+s),
d-s, t);
MALLOCDB;
}
if (t) {
lbnNeg_16((BNWORD16 *)dest->ptr, d);
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr,
dest->size);
MALLOCDB;
return 1;
}
}
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, dest->size);
return 0;
}
/*
* Compare the BigNum to the given value, which must be < 65536.
* Returns -1. 0 or 1 if a<b, a == b or a>b.
* a <=> b --> bnCmpQ(a,b) <=> 0
*/
int
bnCmpQ_16(struct BigNum const *a, unsigned b)
{
unsigned t;
BNWORD16 v;
t = lbnNorm_16((BNWORD16 *)a->ptr, a->size);
/* If a is more than one word long or zero, it's easy... */
if (t != 1)
return (t > 1) ? 1 : (b ? -1 : 0);
v = (unsigned)((BNWORD16 *)a->ptr)[BIGLITTLE(-1,0)];
return (v > b) ? 1 : ((v < b) ? -1 : 0);
}
int
bnSetQ_16(struct BigNum *dest, unsigned src)
{
if (src) {
bnSizeCheck(dest, 1);
((BNWORD16 *)dest->ptr)[BIGLITTLE(-1,0)] = (BNWORD16)src;
dest->size = 1;
} else {
dest->size = 0;
}
return 0;
}
int
bnAddQ_16(struct BigNum *dest, unsigned src)
{
BNWORD16 t;
if (!dest->size)
return bnSetQ(dest, src);
t = lbnAdd1_16((BNWORD16 *)dest->ptr, dest->size, (BNWORD16)src);
MALLOCDB;
if (t) {
src = dest->size;
bnSizeCheck(dest, src+1);
((BNWORD16 *)dest->ptr)[BIGLITTLE(-1-src,src)] = t;
dest->size = src+1;
}
return 0;
}
/*
* Return value as for bnSub: 1 if subtract underflowed, in which
* case the return is the negative of the computed value.
*/
int
bnSubQ_16(struct BigNum *dest, unsigned src)
{
BNWORD16 t;
if (!dest->size)
return bnSetQ(dest, src) < 0 ? -1 : (src != 0);
t = lbnSub1_16((BNWORD16 *)dest->ptr, dest->size, (BNWORD16)src);
MALLOCDB;
if (t) {
/* Underflow. <= 1 word, so do it simply. */
lbnNeg_16((BNWORD16 *)dest->ptr, 1);
dest->size = 1;
return 1;
}
/* Try to normalize? Needing this is going to be very rare. */
/* dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, dest->size); */
return 0;
}
/*
* Compare two BigNums. Returns -1. 0 or 1 if a<b, a == b or a>b.
* a <=> b --> bnCmp(a,b) <=> 0
*/
int
bnCmp_16(struct BigNum const *a, struct BigNum const *b)
{
unsigned s, t;
s = lbnNorm_16((BNWORD16 *)a->ptr, a->size);
t = lbnNorm_16((BNWORD16 *)b->ptr, b->size);
if (s != t)
return s > t ? 1 : -1;
return lbnCmp_16((BNWORD16 *)a->ptr, (BNWORD16 *)b->ptr, s);
}
int
bnSquare_16(struct BigNum *dest, struct BigNum const *src)
{
unsigned s;
BNWORD16 *srcbuf;
s = lbnNorm_16((BNWORD16 *)src->ptr, src->size);
if (!s) {
dest->size = 0;
return 0;
}
bnSizeCheck(dest, 2*s);
if (src == dest) {
LBNALLOC(srcbuf, s);
if (!srcbuf)
return -1;
lbnCopy_16(srcbuf, (BNWORD16 *)src->ptr, s);
lbnSquare_16((BNWORD16 *)dest->ptr, (BNWORD16 *)srcbuf, s);
LBNFREE(srcbuf, s);
} else {
lbnSquare_16((BNWORD16 *)dest->ptr, (BNWORD16 *)src->ptr, s);
}
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, 2*s);
MALLOCDB;
return 0;
}
int
bnMul_16(struct BigNum *dest, struct BigNum const *a, struct BigNum const *b)
{
unsigned s, t;
BNWORD16 *srcbuf;
s = lbnNorm_16((BNWORD16 *)a->ptr, a->size);
t = lbnNorm_16((BNWORD16 *)b->ptr, b->size);
if (!s || !t) {
dest->size = 0;
return 0;
}
if (a == b)
return bnSquare_16(dest, a);
bnSizeCheck(dest, s+t);
if (dest == a) {
LBNALLOC(srcbuf, s);
if (!srcbuf)
return -1;
lbnCopy_16(srcbuf, (BNWORD16 *)a->ptr, s);
lbnMul_16((BNWORD16 *)dest->ptr, srcbuf, s,
(BNWORD16 *)b->ptr, t);
LBNFREE(srcbuf, s);
} else if (dest == b) {
LBNALLOC(srcbuf, t);
if (!srcbuf)
return -1;
lbnCopy_16(srcbuf, (BNWORD16 *)b->ptr, t);
lbnMul_16((BNWORD16 *)dest->ptr, (BNWORD16 *)a->ptr, s,
srcbuf, t);
LBNFREE(srcbuf, t);
} else {
lbnMul_16((BNWORD16 *)dest->ptr, (BNWORD16 *)a->ptr, s,
(BNWORD16 *)b->ptr, t);
}
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, s+t);
MALLOCDB;
return 0;
}
int
bnMulQ_16(struct BigNum *dest, struct BigNum const *a, unsigned b)
{
unsigned s;
s = lbnNorm_16((BNWORD16 *)a->ptr, a->size);
if (!s || !b) {
dest->size = 0;
return 0;
}
if (b == 1)
return bnCopy_16(dest, a);
bnSizeCheck(dest, s+1);
lbnMulN1_16((BNWORD16 *)dest->ptr, (BNWORD16 *)a->ptr, s, (BNWORD16)b);
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, s+1);
MALLOCDB;
return 0;
}
int
bnDivMod_16(struct BigNum *q, struct BigNum *r, struct BigNum const *n,
struct BigNum const *d)
{
unsigned dsize, nsize;
BNWORD16 qhigh;
dsize = lbnNorm_16((BNWORD16 *)d->ptr, d->size);
nsize = lbnNorm_16((BNWORD16 *)n->ptr, n->size);
if (nsize < dsize) {
q->size = 0; /* No quotient */
r->size = nsize;
return 0; /* Success */
}
bnSizeCheck(q, nsize-dsize);
if (r != n) { /* You are allowed to reduce in place */
bnSizeCheck(r, nsize);
lbnCopy_16((BNWORD16 *)r->ptr, (BNWORD16 *)n->ptr, nsize);
}
qhigh = lbnDiv_16((BNWORD16 *)q->ptr, (BNWORD16 *)r->ptr, nsize,
(BNWORD16 *)d->ptr, dsize);
nsize -= dsize;
if (qhigh) {
bnSizeCheck(q, nsize+1);
*((BNWORD16 *)q->ptr BIGLITTLE(-nsize-1,+nsize)) = qhigh;
q->size = nsize+1;
} else {
q->size = lbnNorm_16((BNWORD16 *)q->ptr, nsize);
}
r->size = lbnNorm_16((BNWORD16 *)r->ptr, dsize);
MALLOCDB;
return 0;
}
int
bnMod_16(struct BigNum *dest, struct BigNum const *src, struct BigNum const *d)
{
unsigned dsize, nsize;
nsize = lbnNorm_16((BNWORD16 *)src->ptr, src->size);
dsize = lbnNorm_16((BNWORD16 *)d->ptr, d->size);
if (dest != src) {
bnSizeCheck(dest, nsize);
lbnCopy_16((BNWORD16 *)dest->ptr, (BNWORD16 *)src->ptr, nsize);
}
if (nsize < dsize) {
dest->size = nsize; /* No quotient */
return 0;
}
(void)lbnDiv_16((BNWORD16 *)dest->ptr BIGLITTLE(-dsize,+dsize),
(BNWORD16 *)dest->ptr, nsize,
(BNWORD16 *)d->ptr, dsize);
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, dsize);
MALLOCDB;
return 0;
}
unsigned
bnModQ_16(struct BigNum const *src, unsigned d)
{
unsigned s;
s = lbnNorm_16((BNWORD16 *)src->ptr, src->size);
if (!s)
return 0;
return lbnModQ_16((BNWORD16 *)src->ptr, s, d);
}
int
bnExpMod_16(struct BigNum *dest, struct BigNum const *n,
struct BigNum const *exp, struct BigNum const *mod)
{
unsigned nsize, esize, msize;
nsize = lbnNorm_16((BNWORD16 *)n->ptr, n->size);
esize = lbnNorm_16((BNWORD16 *)exp->ptr, exp->size);
msize = lbnNorm_16((BNWORD16 *)mod->ptr, mod->size);
if (!msize || (((BNWORD16 *)mod->ptr)[BIGLITTLE(-1,0)] & 1) == 0)
return -1; /* Illegal modulus! */
bnSizeCheck(dest, msize);
/* Special-case base of 2 */
if (nsize == 1 && ((BNWORD16 *)n->ptr)[BIGLITTLE(-1,0)] == 2) {
if (lbnTwoExpMod_16((BNWORD16 *)dest->ptr,
(BNWORD16 *)exp->ptr, esize,
(BNWORD16 *)mod->ptr, msize) < 0)
return -1;
} else {
if (lbnExpMod_16((BNWORD16 *)dest->ptr,
(BNWORD16 *)n->ptr, nsize,
(BNWORD16 *)exp->ptr, esize,
(BNWORD16 *)mod->ptr, msize) < 0)
return -1;
}
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, msize);
MALLOCDB;
return 0;
}
int
bnDoubleExpMod_16(struct BigNum *dest,
struct BigNum const *n1, struct BigNum const *e1,
struct BigNum const *n2, struct BigNum const *e2,
struct BigNum const *mod)
{
unsigned n1size, e1size, n2size, e2size, msize;
n1size = lbnNorm_16((BNWORD16 *)n1->ptr, n1->size);
e1size = lbnNorm_16((BNWORD16 *)e1->ptr, e1->size);
n2size = lbnNorm_16((BNWORD16 *)n2->ptr, n2->size);
e2size = lbnNorm_16((BNWORD16 *)e2->ptr, e2->size);
msize = lbnNorm_16((BNWORD16 *)mod->ptr, mod->size);
if (!msize || (((BNWORD16 *)mod->ptr)[BIGLITTLE(-1,0)] & 1) == 0)
return -1; /* Illegal modulus! */
bnSizeCheck(dest, msize);
if (lbnDoubleExpMod_16((BNWORD16 *)dest->ptr,
(BNWORD16 *)n1->ptr, n1size, (BNWORD16 *)e1->ptr, e1size,
(BNWORD16 *)n2->ptr, n2size, (BNWORD16 *)e2->ptr, e2size,
(BNWORD16 *)mod->ptr, msize) < 0)
return -1;
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, msize);
MALLOCDB;
return 0;
}
int
bnTwoExpMod_16(struct BigNum *n, struct BigNum const *exp,
struct BigNum const *mod)
{
unsigned esize, msize;
esize = lbnNorm_16((BNWORD16 *)exp->ptr, exp->size);
msize = lbnNorm_16((BNWORD16 *)mod->ptr, mod->size);
if (!msize || (((BNWORD16 *)mod->ptr)[BIGLITTLE(-1,0)] & 1) == 0)
return -1; /* Illegal modulus! */
bnSizeCheck(n, msize);
if (lbnTwoExpMod_16((BNWORD16 *)n->ptr, (BNWORD16 *)exp->ptr, esize,
(BNWORD16 *)mod->ptr, msize) < 0)
return -1;
n->size = lbnNorm_16((BNWORD16 *)n->ptr, msize);
MALLOCDB;
return 0;
}
int
bnGcd_16(struct BigNum *dest, struct BigNum const *a, struct BigNum const *b)
{
BNWORD16 *tmp;
unsigned asize, bsize;
int i;
/* Kind of silly, but we might as well permit it... */
if (a == b)
return dest == a ? 0 : bnCopy(dest, a);
/* Ensure a is not the same as "dest" */
if (a == dest) {
a = b;
b = dest;
}
asize = lbnNorm_16((BNWORD16 *)a->ptr, a->size);
bsize = lbnNorm_16((BNWORD16 *)b->ptr, b->size);
bnSizeCheck(dest, bsize+1);
/* Copy a to tmp */
LBNALLOC(tmp, asize+1);
if (!tmp)
return -1;
lbnCopy_16(tmp, (BNWORD16 *)a->ptr, asize);
/* Copy b to dest,if necessary */
if (dest != b)
lbnCopy_16((BNWORD16 *)dest->ptr,
(BNWORD16 *)b->ptr, bsize);
if (bsize > asize || (bsize == asize &&
lbnCmp_16((BNWORD16 *)b->ptr, (BNWORD16 *)a->ptr, asize) > 0))
{
i = lbnGcd_16((BNWORD16 *)dest->ptr, bsize, tmp, asize);
if (i >= 0) {
dest->size = (unsigned)i;
} else {
lbnCopy_16((BNWORD16 *)dest->ptr, tmp,
(unsigned)-i);
dest->size = (unsigned)-i;
}
} else {
i = lbnGcd_16(tmp, asize, (BNWORD16 *)dest->ptr, bsize);
if (i <= 0) {
dest->size = (unsigned)-i;
} else {
lbnCopy_16((BNWORD16 *)dest->ptr, tmp,
(unsigned)i);
dest->size = (unsigned)i;
}
}
LBNFREE(tmp, asize+1);
MALLOCDB;
return 0;
}
int
bnInv_16(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *mod)
{
unsigned s, m;
int i;
s = lbnNorm_16((BNWORD16 *)src->ptr, src->size);
m = lbnNorm_16((BNWORD16 *)mod->ptr, mod->size);
/* lbnInv_16 requires that the input be less than the modulus */
if (m < s ||
(m==s && lbnCmp_16((BNWORD16 *)src->ptr, (BNWORD16 *)mod->ptr, s)))
{
bnSizeCheck(dest, s + (m==s));
if (dest != src)
lbnCopy_16((BNWORD16 *)dest->ptr,
(BNWORD16 *)src->ptr, s);
/* Pre-reduce modulo the modulus */
(void)lbnDiv_16((BNWORD16 *)dest->ptr BIGLITTLE(-m,+m),
(BNWORD16 *)dest->ptr, s,
(BNWORD16 *)mod->ptr, m);
s = lbnNorm_16((BNWORD16 *)dest->ptr, m);
MALLOCDB;
} else {
bnSizeCheck(dest, m+1);
if (dest != src)
lbnCopy_16((BNWORD16 *)dest->ptr,
(BNWORD16 *)src->ptr, s);
}
i = lbnInv_16((BNWORD16 *)dest->ptr, s, (BNWORD16 *)mod->ptr, m);
if (i == 0)
dest->size = lbnNorm_16((BNWORD16 *)dest->ptr, m);
MALLOCDB;
return i;
}
/*
* Shift a bignum left the appropriate number of bits,
* multiplying by 2^amt.
*/
int
bnLShift_16(struct BigNum *dest, unsigned amt)
{
unsigned s = dest->size;
BNWORD16 carry;
if (amt % 16) {
carry = lbnLshift_16(dest->ptr, s, amt % 16);
if (carry) {
s++;
bnSizeCheck(dest, s);
((BNWORD16 *)dest->ptr)[BIGLITTLE(-s,s-1)] = carry;
}
}
amt /= 16;
if (amt) {
bnSizeCheck(dest, s+amt);
memmove((BNWORD16 *)dest->ptr BIGLITTLE(-s-amt, +amt),
(BNWORD16 *)dest->ptr BIG(-s),
s * sizeof(BNWORD16));
lbnZero_16((BNWORD16 *)dest->ptr, amt);
s += amt;
}
dest->size = s;
MALLOCDB;
return 0;
}
/*
* Shift a bignum right the appropriate number of bits,
* dividing by 2^amt.
*/
void bnRShift_16(struct BigNum *dest, unsigned amt)
{
unsigned s = dest->size;
if (amt >= 16) {
memmove(
(BNWORD16 *)dest->ptr BIG(-s+amt/16),
(BNWORD16 *)dest->ptr BIGLITTLE(-s, +amt/16),
s-amt/16 * sizeof(BNWORD16));
s -= amt/16;
amt %= 16;
}
if (amt)
(void)lbnRshift_16(dest->ptr, s, amt);
dest->size = lbnNorm_16(dest->ptr, s);
MALLOCDB;
}
/*
* Shift a bignum right until it is odd, and return the number of
* bits shifted. n = d * 2^s. Replaces n with d and returns s.
* Returns 0 when given 0. (Another valid answer is infinity.)
*/
unsigned
bnMakeOdd_16(struct BigNum *n)
{
unsigned size;
unsigned s; /* shift amount */
BNWORD16 *p;
BNWORD16 t;
p = (BNWORD16 *)n->ptr;
size = lbnNorm_16(p, n->size);
if (!size)
return 0;
t = BIGLITTLE(p[-1],p[0]);
s = 0;
/* See how many words we have to shift */
if (!t) {
/* Shift by words */
do {
s++;
BIGLITTLE(--p,p++);
} while ((t = BIGLITTLE(p[-1],p[0])) == 0);
size -= s;
s *= 16;
memmove((BNWORD16 *)n->ptr BIG(-size), p BIG(-size),
size * sizeof(BNWORD16));
p = (BNWORD16 *)n->ptr;
MALLOCDB;
}
assert(t);
/* Now count the bits */
while ((t & 1) == 0) {
t >>= 1;
s++;
}
/* Shift the bits */
if (s & (16-1)) {
lbnRshift_16(p, size, s & (16-1));
/* Renormalize */
if (BIGLITTLE(*(p-size),*(p+(size-1))) == 0)
--size;
}
n->size = size;
MALLOCDB;
return s;
}

92
lib/bind/cylink/bn16.h
View file

@ -1,92 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn16.h - interface to 16-bit bignum routines.
*/
struct BigNum;
void bnInit_16(void);
void bnEnd_16(struct BigNum *bn);
int bnPrealloc_16(struct BigNum *bn, unsigned bits);
int bnCopy_16(struct BigNum *dest, struct BigNum const *src);
int bnSwap_16(struct BigNum *a, struct BigNum *b);
void bnNorm_16(struct BigNum *bn);
void bnExtractBigBytes_16(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned dlen);
int bnInsertBigBytes_16(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
void bnExtractLittleBytes_16(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned dlen);
int bnInsertLittleBytes_16(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
unsigned bnLSWord_16(struct BigNum const *src);
unsigned bnBits_16(struct BigNum const *src);
int bnAdd_16(struct BigNum *dest, struct BigNum const *src);
int bnSub_16(struct BigNum *dest, struct BigNum const *src);
int bnCmpQ_16(struct BigNum const *a, unsigned b);
int bnSetQ_16(struct BigNum *dest, unsigned src);
int bnAddQ_16(struct BigNum *dest, unsigned src);
int bnSubQ_16(struct BigNum *dest, unsigned src);
int bnCmp_16(struct BigNum const *a, struct BigNum const *b);
int bnSquare_16(struct BigNum *dest, struct BigNum const *src);
int bnMul_16(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
int bnMulQ_16(struct BigNum *dest, struct BigNum const *a, unsigned b);
int bnDivMod_16(struct BigNum *q, struct BigNum *r, struct BigNum const *n,
struct BigNum const *d);
int bnMod_16(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *d);
unsigned bnModQ_16(struct BigNum const *src, unsigned d);
int bnExpMod_16(struct BigNum *dest, struct BigNum const *n,
struct BigNum const *exp, struct BigNum const *mod);
int bnDoubleExpMod_16(struct BigNum *dest,
struct BigNum const *n1, struct BigNum const *e1,
struct BigNum const *n2, struct BigNum const *e2,
struct BigNum const *mod);
int bnTwoExpMod_16(struct BigNum *n, struct BigNum const *exp,
struct BigNum const *mod);
int bnGcd_16(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
int bnInv_16(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *mod);
int bnLShift_16(struct BigNum *dest, unsigned amt);
void bnRShift_16(struct BigNum *dest, unsigned amt);
unsigned bnMakeOdd_16(struct BigNum *n);

949
lib/bind/cylink/bn32.c
View file

@ -1,949 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn32.c - the high-level bignum interface
*
* Like lbn32.c, this reserves the string "32" for textual replacement.
* The string must not appear anywhere unless it is intended to be replaced
* to generate other bignum interface functions.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*/
#ifndef HAVE_CONFIG_H
#define HAVE_CONFIG_H 0
#endif
#if HAVE_CONFIG_H
#include "config.h"
#endif
/*
* Some compilers complain about #if FOO if FOO isn't defined,
* so do the ANSI-mandated thing explicitly...
*/
#ifndef NO_ASSERT_H
#define NO_ASSERT_H 0
#endif
#ifndef NO_STRING_H
#define NO_STRING_H 0
#endif
#ifndef HAVE_STRINGS_H
#define HAVE_STRINGS_H 0
#endif
#ifndef NEED_MEMORY_H
#define NEED_MEMORY_H 0
#endif
#if !NO_ASSERT_H
#include <assert.h>
#else
#define assert(x) (void)0
#endif
#if !NO_STRING_H
#include <string.h> /* for memmove() in bnMakeOdd */
#elif HAVE_STRINGS_H
#include <strings.h>
#endif
#if NEED_MEMORY_H
#include <memory.h>
#endif
/*
* This was useful during debugging, so it's left in here.
* You can ignore it. DBMALLOC is generally undefined.
*/
#ifndef DBMALLOC
#define DBAMLLOC 0
#endif
#if DBMALLOC
#include "../dbmalloc/malloc.h"
#define MALLOCDB malloc_chain_check(1)
#else
#define MALLOCDB (void)0
#endif
#include "lbn.h"
#include "lbn32.h"
#include "lbnmem.h"
#include "bn32.h"
#include "bn.h"
/* Work-arounds for some particularly broken systems */
#include "kludge.h" /* For memmove() */
#include <port_after.h>
/* Functions */
void
bnInit_32(void)
{
bnEnd = bnEnd_32;
bnPrealloc = bnPrealloc_32;
bnCopy = bnCopy_32;
bnNorm = bnNorm_32;
bnExtractBigBytes = bnExtractBigBytes_32;
bnInsertBigBytes = bnInsertBigBytes_32;
bnExtractLittleBytes = bnExtractLittleBytes_32;
bnInsertLittleBytes = bnInsertLittleBytes_32;
bnLSWord = bnLSWord_32;
bnBits = bnBits_32;
bnAdd = bnAdd_32;
bnSub = bnSub_32;
bnCmpQ = bnCmpQ_32;
bnSetQ = bnSetQ_32;
bnAddQ = bnAddQ_32;
bnSubQ = bnSubQ_32;
bnCmp = bnCmp_32;
bnSquare = bnSquare_32;
bnMul = bnMul_32;
bnMulQ = bnMulQ_32;
bnDivMod = bnDivMod_32;
bnMod = bnMod_32;
bnModQ = bnModQ_32;
bnExpMod = bnExpMod_32;
bnDoubleExpMod = bnDoubleExpMod_32;
bnTwoExpMod = bnTwoExpMod_32;
bnGcd = bnGcd_32;
bnInv = bnInv_32;
bnLShift = bnLShift_32;
bnRShift = bnRShift_32;
bnMakeOdd = bnMakeOdd_32;
}
void
bnEnd_32(struct BigNum *bn)
{
if (bn->ptr) {
LBNFREE((BNWORD32 *)bn->ptr, bn->allocated);
bn->ptr = 0;
}
bn->size = 0;
bn->allocated = 0;
MALLOCDB;
}
/* Internal function. It operates in words. */
static int
bnResize_32(struct BigNum *bn, unsigned len)
{
void *p;
/* Round size up: most mallocs impose 8-byte granularity anyway */
len = (len + (8/sizeof(BNWORD32) - 1)) & ~(8/sizeof(BNWORD32) - 1);
p = LBNREALLOC((BNWORD32 *)bn->ptr, bn->allocated, len);
if (!p)
return -1;
bn->ptr = p;
bn->allocated = len;
MALLOCDB;
return 0;
}
#define bnSizeCheck(bn, size) \
if (bn->allocated < size && bnResize_32(bn, size) < 0) \
return -1
int
bnPrealloc_32(struct BigNum *bn, unsigned bits)
{
bits = (bits + 32-1)/32;
bnSizeCheck(bn, bits);
MALLOCDB;
return 0;
}
int
bnCopy_32(struct BigNum *dest, struct BigNum const *src)
{
bnSizeCheck(dest, src->size);
dest->size = src->size;
lbnCopy_32((BNWORD32 *)dest->ptr, (BNWORD32 *)src->ptr, src->size);
MALLOCDB;
return 0;
}
void
bnNorm_32(struct BigNum *bn)
{
bn->size = lbnNorm_32((BNWORD32 *)bn->ptr, bn->size);
}
/*
* Convert a bignum to big-endian bytes. Returns, in big-endian form, a
* substring of the bignum starting from lsbyte and "len" bytes long.
* Unused high-order (leading) bytes are filled with 0.
*/
void
bnExtractBigBytes_32(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size * (32 / 8);
/* Fill unused leading bytes with 0 */
while (s < lsbyte+len) {
*dest++ = 0;
len--;
}
if (len)
lbnExtractBigBytes_32((BNWORD32 *)bn->ptr, dest, lsbyte, len);
MALLOCDB;
}
int
bnInsertBigBytes_32(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size;
unsigned words = (len+lsbyte+sizeof(BNWORD32)-1) / sizeof(BNWORD32);
/* Pad with zeros as required */
bnSizeCheck(bn, words);
if (s < words) {
lbnZero_32((BNWORD32 *)bn->ptr BIGLITTLE(-s,+s), words-s);
s = words;
}
lbnInsertBigBytes_32((BNWORD32 *)bn->ptr, src, lsbyte, len);
bn->size = lbnNorm_32((BNWORD32 *)bn->ptr, s);
MALLOCDB;
return 0;
}
/*
* Convert a bignum to little-endian bytes. Returns, in little-endian form, a
* substring of the bignum starting from lsbyte and "len" bytes long.
* Unused high-order (trailing) bytes are filled with 0.
*/
void
bnExtractLittleBytes_32(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size * (32 / 8);
/* Fill unused leading bytes with 0 */
while (s < lsbyte+len)
dest[--len] = 0;
if (len)
lbnExtractLittleBytes_32((BNWORD32 *)bn->ptr, dest,
lsbyte, len);
MALLOCDB;
}
int
bnInsertLittleBytes_32(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len)
{
unsigned s = bn->size;
unsigned words = (len+lsbyte+sizeof(BNWORD32)-1) / sizeof(BNWORD32);
/* Pad with zeros as required */
bnSizeCheck(bn, words);
if (s < words) {
lbnZero_32((BNWORD32 *)bn->ptr BIGLITTLE(-s,+s), words-s);
s = words;
}
lbnInsertLittleBytes_32((BNWORD32 *)bn->ptr, src, lsbyte, len);
bn->size = lbnNorm_32((BNWORD32 *)bn->ptr, s);
MALLOCDB;
return 0;
}
/* Return the least-significant word of the input. */
unsigned
bnLSWord_32(struct BigNum const *src)
{
return src->size ? (unsigned)((BNWORD32 *)src->ptr)[BIGLITTLE(-1,0)]: 0;
}
unsigned
bnBits_32(struct BigNum const *src)
{
return lbnBits_32((BNWORD32 *)src->ptr, src->size);
}
int
bnAdd_32(struct BigNum *dest, struct BigNum const *src)
{
unsigned s = src->size, d = dest->size;
BNWORD32 t;
if (!s)
return 0;
bnSizeCheck(dest, s);
if (d < s) {
lbnZero_32((BNWORD32 *)dest->ptr BIGLITTLE(-d,+d), s-d);
dest->size = d = s;
MALLOCDB;
}
t = lbnAddN_32((BNWORD32 *)dest->ptr, (BNWORD32 *)src->ptr, s);
MALLOCDB;
if (t) {
if (d > s) {
t = lbnAdd1_32((BNWORD32 *)dest->ptr BIGLITTLE(-s,+s),
d-s, t);
MALLOCDB;
}
if (t) {
bnSizeCheck(dest, d+1);
((BNWORD32 *)dest->ptr)[BIGLITTLE(-1-d,d)] = t;
dest->size = d+1;
}
}
return 0;
}
/*
* dest -= src.
* If dest goes negative, this produces the absolute value of
* the difference (the negative of the true value) and returns 1.
* Otherwise, it returls 0.
*/
int
bnSub_32(struct BigNum *dest, struct BigNum const *src)
{
unsigned s = src->size, d = dest->size;
BNWORD32 t;
if (d < s && d < (s = lbnNorm_32((BNWORD32 *)src->ptr, s))) {
bnSizeCheck(dest, s);
lbnZero_32((BNWORD32 *)dest->ptr BIGLITTLE(-d,+d), s-d);
dest->size = d = s;
MALLOCDB;
}
if (!s)
return 0;
t = lbnSubN_32((BNWORD32 *)dest->ptr, (BNWORD32 *)src->ptr, s);
MALLOCDB;
if (t) {
if (d > s) {
t = lbnSub1_32((BNWORD32 *)dest->ptr BIGLITTLE(-s,+s),
d-s, t);
MALLOCDB;
}
if (t) {
lbnNeg_32((BNWORD32 *)dest->ptr, d);
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr,
dest->size);
MALLOCDB;
return 1;
}
}
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, dest->size);
return 0;
}
/*
* Compare the BigNum to the given value, which must be < 65536.
* Returns -1. 0 or 1 if a<b, a == b or a>b.
* a <=> b --> bnCmpQ(a,b) <=> 0
*/
int
bnCmpQ_32(struct BigNum const *a, unsigned b)
{
unsigned t;
BNWORD32 v;
t = lbnNorm_32((BNWORD32 *)a->ptr, a->size);
/* If a is more than one word long or zero, it's easy... */
if (t != 1)
return (t > 1) ? 1 : (b ? -1 : 0);
v = (unsigned)((BNWORD32 *)a->ptr)[BIGLITTLE(-1,0)];
return (v > b) ? 1 : ((v < b) ? -1 : 0);
}
int
bnSetQ_32(struct BigNum *dest, unsigned src)
{
if (src) {
bnSizeCheck(dest, 1);
((BNWORD32 *)dest->ptr)[BIGLITTLE(-1,0)] = (BNWORD32)src;
dest->size = 1;
} else {
dest->size = 0;
}
return 0;
}
int
bnAddQ_32(struct BigNum *dest, unsigned src)
{
BNWORD32 t;
if (!dest->size)
return bnSetQ(dest, src);
t = lbnAdd1_32((BNWORD32 *)dest->ptr, dest->size, (BNWORD32)src);
MALLOCDB;
if (t) {
src = dest->size;
bnSizeCheck(dest, src+1);
((BNWORD32 *)dest->ptr)[BIGLITTLE(-1-src,src)] = t;
dest->size = src+1;
}
return 0;
}
/*
* Return value as for bnSub: 1 if subtract underflowed, in which
* case the return is the negative of the computed value.
*/
int
bnSubQ_32(struct BigNum *dest, unsigned src)
{
BNWORD32 t;
if (!dest->size)
return bnSetQ(dest, src) < 0 ? -1 : (src != 0);
t = lbnSub1_32((BNWORD32 *)dest->ptr, dest->size, src);
MALLOCDB;
if (t) {
/* Underflow. <= 1 word, so do it simply. */
lbnNeg_32((BNWORD32 *)dest->ptr, 1);
dest->size = 1;
return 1;
}
/* Try to normalize? Needing this is going to be very rare. */
/* dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, dest->size); */
return 0;
}
/*
* Compare two BigNums. Returns -1. 0 or 1 if a<b, a == b or a>b.
* a <=> b --> bnCmp(a,b) <=> 0
*/
int
bnCmp_32(struct BigNum const *a, struct BigNum const *b)
{
unsigned s, t;
s = lbnNorm_32((BNWORD32 *)a->ptr, a->size);
t = lbnNorm_32((BNWORD32 *)b->ptr, b->size);
if (s != t)
return s > t ? 1 : -1;
return lbnCmp_32((BNWORD32 *)a->ptr, (BNWORD32 *)b->ptr, s);
}
int
bnSquare_32(struct BigNum *dest, struct BigNum const *src)
{
unsigned s;
BNWORD32 *srcbuf;
s = lbnNorm_32((BNWORD32 *)src->ptr, src->size);
if (!s) {
dest->size = 0;
return 0;
}
bnSizeCheck(dest, 2*s);
if (src == dest) {
LBNALLOC(srcbuf, s);
if (!srcbuf)
return -1;
lbnCopy_32(srcbuf, (BNWORD32 *)src->ptr, s);
lbnSquare_32((BNWORD32 *)dest->ptr, (BNWORD32 *)srcbuf, s);
LBNFREE(srcbuf, s);
} else {
lbnSquare_32((BNWORD32 *)dest->ptr, (BNWORD32 *)src->ptr, s);
}
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, 2*s);
MALLOCDB;
return 0;
}
int
bnMul_32(struct BigNum *dest, struct BigNum const *a, struct BigNum const *b)
{
unsigned s, t;
BNWORD32 *srcbuf;
s = lbnNorm_32((BNWORD32 *)a->ptr, a->size);
t = lbnNorm_32((BNWORD32 *)b->ptr, b->size);
if (!s || !t) {
dest->size = 0;
return 0;
}
if (a == b)
return bnSquare_32(dest, a);
bnSizeCheck(dest, s+t);
if (dest == a) {
LBNALLOC(srcbuf, s);
if (!srcbuf)
return -1;
lbnCopy_32(srcbuf, (BNWORD32 *)a->ptr, s);
lbnMul_32((BNWORD32 *)dest->ptr, srcbuf, s,
(BNWORD32 *)b->ptr, t);
LBNFREE(srcbuf, s);
} else if (dest == b) {
LBNALLOC(srcbuf, t);
if (!srcbuf)
return -1;
lbnCopy_32(srcbuf, (BNWORD32 *)b->ptr, t);
lbnMul_32((BNWORD32 *)dest->ptr, (BNWORD32 *)a->ptr, s,
srcbuf, t);
LBNFREE(srcbuf, t);
} else {
lbnMul_32((BNWORD32 *)dest->ptr, (BNWORD32 *)a->ptr, s,
(BNWORD32 *)b->ptr, t);
}
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, s+t);
MALLOCDB;
return 0;
}
int
bnMulQ_32(struct BigNum *dest, struct BigNum const *a, unsigned b)
{
unsigned s;
s = lbnNorm_32((BNWORD32 *)a->ptr, a->size);
if (!s || !b) {
dest->size = 0;
return 0;
}
if (b == 1)
return bnCopy_32(dest, a);
bnSizeCheck(dest, s+1);
lbnMulN1_32((BNWORD32 *)dest->ptr, (BNWORD32 *)a->ptr, s, b);
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, s+1);
MALLOCDB;
return 0;
}
int
bnDivMod_32(struct BigNum *q, struct BigNum *r, struct BigNum const *n,
struct BigNum const *d)
{
unsigned dsize, nsize;
BNWORD32 qhigh;
dsize = lbnNorm_32((BNWORD32 *)d->ptr, d->size);
nsize = lbnNorm_32((BNWORD32 *)n->ptr, n->size);
if (nsize < dsize) {
q->size = 0; /* No quotient */
r->size = nsize;
return 0; /* Success */
}
bnSizeCheck(q, nsize-dsize);
if (r != n) { /* You are allowed to reduce in place */
bnSizeCheck(r, nsize);
lbnCopy_32((BNWORD32 *)r->ptr, (BNWORD32 *)n->ptr, nsize);
}
qhigh = lbnDiv_32((BNWORD32 *)q->ptr, (BNWORD32 *)r->ptr, nsize,
(BNWORD32 *)d->ptr, dsize);
nsize -= dsize;
if (qhigh) {
bnSizeCheck(q, nsize+1);
*((BNWORD32 *)q->ptr BIGLITTLE(-nsize-1,+nsize)) = qhigh;
q->size = nsize+1;
} else {
q->size = lbnNorm_32((BNWORD32 *)q->ptr, nsize);
}
r->size = lbnNorm_32((BNWORD32 *)r->ptr, dsize);
MALLOCDB;
return 0;
}
int
bnMod_32(struct BigNum *dest, struct BigNum const *src, struct BigNum const *d)
{
unsigned dsize, nsize;
nsize = lbnNorm_32((BNWORD32 *)src->ptr, src->size);
dsize = lbnNorm_32((BNWORD32 *)d->ptr, d->size);
if (dest != src) {
bnSizeCheck(dest, nsize);
lbnCopy_32((BNWORD32 *)dest->ptr, (BNWORD32 *)src->ptr, nsize);
}
if (nsize < dsize) {
dest->size = nsize; /* No quotient */
return 0;
}
(void)lbnDiv_32((BNWORD32 *)dest->ptr BIGLITTLE(-dsize,+dsize),
(BNWORD32 *)dest->ptr, nsize,
(BNWORD32 *)d->ptr, dsize);
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, dsize);
MALLOCDB;
return 0;
}
unsigned
bnModQ_32(struct BigNum const *src, unsigned d)
{
unsigned s;
s = lbnNorm_32((BNWORD32 *)src->ptr, src->size);
if (!s)
return 0;
return lbnModQ_32((BNWORD32 *)src->ptr, s, d);
}
int
bnExpMod_32(struct BigNum *dest, struct BigNum const *n,
struct BigNum const *exp, struct BigNum const *mod)
{
unsigned nsize, esize, msize;
nsize = lbnNorm_32((BNWORD32 *)n->ptr, n->size);
esize = lbnNorm_32((BNWORD32 *)exp->ptr, exp->size);
msize = lbnNorm_32((BNWORD32 *)mod->ptr, mod->size);
if (!msize || (((BNWORD32 *)mod->ptr)[BIGLITTLE(-1,0)] & 1) == 0)
return -1; /* Illegal modulus! */
bnSizeCheck(dest, msize);
/* Special-case base of 2 */
if (nsize == 1 && ((BNWORD32 *)n->ptr)[BIGLITTLE(-1,0)] == 2) {
if (lbnTwoExpMod_32((BNWORD32 *)dest->ptr,
(BNWORD32 *)exp->ptr, esize,
(BNWORD32 *)mod->ptr, msize) < 0)
return -1;
} else {
if (lbnExpMod_32((BNWORD32 *)dest->ptr,
(BNWORD32 *)n->ptr, nsize,
(BNWORD32 *)exp->ptr, esize,
(BNWORD32 *)mod->ptr, msize) < 0)
return -1;
}
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, msize);
MALLOCDB;
return 0;
}
int
bnDoubleExpMod_32(struct BigNum *dest,
struct BigNum const *n1, struct BigNum const *e1,
struct BigNum const *n2, struct BigNum const *e2,
struct BigNum const *mod)
{
unsigned n1size, e1size, n2size, e2size, msize;
n1size = lbnNorm_32((BNWORD32 *)n1->ptr, n1->size);
e1size = lbnNorm_32((BNWORD32 *)e1->ptr, e1->size);
n2size = lbnNorm_32((BNWORD32 *)n2->ptr, n2->size);
e2size = lbnNorm_32((BNWORD32 *)e2->ptr, e2->size);
msize = lbnNorm_32((BNWORD32 *)mod->ptr, mod->size);
if (!msize || (((BNWORD32 *)mod->ptr)[BIGLITTLE(-1,0)] & 1) == 0)
return -1; /* Illegal modulus! */
bnSizeCheck(dest, msize);
if (lbnDoubleExpMod_32((BNWORD32 *)dest->ptr,
(BNWORD32 *)n1->ptr, n1size, (BNWORD32 *)e1->ptr, e1size,
(BNWORD32 *)n2->ptr, n2size, (BNWORD32 *)e2->ptr, e2size,
(BNWORD32 *)mod->ptr, msize) < 0)
return -1;
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, msize);
MALLOCDB;
return 0;
}
int
bnTwoExpMod_32(struct BigNum *n, struct BigNum const *exp,
struct BigNum const *mod)
{
unsigned esize, msize;
esize = lbnNorm_32((BNWORD32 *)exp->ptr, exp->size);
msize = lbnNorm_32((BNWORD32 *)mod->ptr, mod->size);
if (!msize || (((BNWORD32 *)mod->ptr)[BIGLITTLE(-1,0)] & 1) == 0)
return -1; /* Illegal modulus! */
bnSizeCheck(n, msize);
if (lbnTwoExpMod_32((BNWORD32 *)n->ptr, (BNWORD32 *)exp->ptr, esize,
(BNWORD32 *)mod->ptr, msize) < 0)
return -1;
n->size = lbnNorm_32((BNWORD32 *)n->ptr, msize);
MALLOCDB;
return 0;
}
int
bnGcd_32(struct BigNum *dest, struct BigNum const *a, struct BigNum const *b)
{
BNWORD32 *tmp;
unsigned asize, bsize;
int i;
/* Kind of silly, but we might as well permit it... */
if (a == b)
return dest == a ? 0 : bnCopy(dest, a);
/* Ensure a is not the same as "dest" */
if (a == dest) {
a = b;
b = dest;
}
asize = lbnNorm_32((BNWORD32 *)a->ptr, a->size);
bsize = lbnNorm_32((BNWORD32 *)b->ptr, b->size);
bnSizeCheck(dest, bsize+1);
/* Copy a to tmp */
LBNALLOC(tmp, asize+1);
if (!tmp)
return -1;
lbnCopy_32(tmp, (BNWORD32 *)a->ptr, asize);
/* Copy b to dest,if necessary */
if (dest != b)
lbnCopy_32((BNWORD32 *)dest->ptr,
(BNWORD32 *)b->ptr, bsize);
if (bsize > asize || (bsize == asize &&
lbnCmp_32((BNWORD32 *)b->ptr, (BNWORD32 *)a->ptr, asize) > 0))
{
i = lbnGcd_32((BNWORD32 *)dest->ptr, bsize, tmp, asize);
if (i >= 0) {
dest->size = (unsigned)i;
} else {
lbnCopy_32((BNWORD32 *)dest->ptr, tmp,
(unsigned)-i);
dest->size = (unsigned)-i;
}
} else {
i = lbnGcd_32(tmp, asize, (BNWORD32 *)dest->ptr, bsize);
if (i <= 0) {
dest->size = (unsigned)-i;
} else {
lbnCopy_32((BNWORD32 *)dest->ptr, tmp,
(unsigned)i);
dest->size = (unsigned)i;
}
}
LBNFREE(tmp, asize+1);
MALLOCDB;
return 0;
}
int
bnInv_32(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *mod)
{
unsigned s, m;
int i;
s = lbnNorm_32((BNWORD32 *)src->ptr, src->size);
m = lbnNorm_32((BNWORD32 *)mod->ptr, mod->size);
/* lbnInv_32 requires that the input be less than the modulus */
if (m < s ||
(m==s && lbnCmp_32((BNWORD32 *)src->ptr, (BNWORD32 *)mod->ptr, s)))
{
bnSizeCheck(dest, s + (m==s));
if (dest != src)
lbnCopy_32((BNWORD32 *)dest->ptr,
(BNWORD32 *)src->ptr, s);
/* Pre-reduce modulo the modulus */
(void)lbnDiv_32((BNWORD32 *)dest->ptr BIGLITTLE(-m,+m),
(BNWORD32 *)dest->ptr, s,
(BNWORD32 *)mod->ptr, m);
s = lbnNorm_32((BNWORD32 *)dest->ptr, m);
MALLOCDB;
} else {
bnSizeCheck(dest, m+1);
if (dest != src)
lbnCopy_32((BNWORD32 *)dest->ptr,
(BNWORD32 *)src->ptr, s);
}
i = lbnInv_32((BNWORD32 *)dest->ptr, s, (BNWORD32 *)mod->ptr, m);
if (i == 0)
dest->size = lbnNorm_32((BNWORD32 *)dest->ptr, m);
MALLOCDB;
return i;
}
/*
* Shift a bignum left the appropriate number of bits,
* multiplying by 2^amt.
*/
int
bnLShift_32(struct BigNum *dest, unsigned amt)
{
unsigned s = dest->size;
BNWORD32 carry;
if (amt % 32) {
carry = lbnLshift_32(dest->ptr, s, amt % 32);
if (carry) {
s++;
bnSizeCheck(dest, s);
((BNWORD32 *)dest->ptr)[BIGLITTLE(-s,s-1)] = carry;
}
}
amt /= 32;
if (amt) {
bnSizeCheck(dest, s+amt);
memmove((BNWORD32 *)dest->ptr BIGLITTLE(-s-amt, +amt),
(BNWORD32 *)dest->ptr BIG(-s),
s * sizeof(BNWORD32));
lbnZero_32((BNWORD32 *)dest->ptr, amt);
s += amt;
}
dest->size = s;
MALLOCDB;
return 0;
}
/*
* Shift a bignum right the appropriate number of bits,
* dividing by 2^amt.
*/
void bnRShift_32(struct BigNum *dest, unsigned amt)
{
unsigned s = dest->size;
if (amt >= 32) {
memmove(
(BNWORD32 *)dest->ptr BIG(-s+amt/32),
(BNWORD32 *)dest->ptr BIGLITTLE(-s, +amt/32),
s-amt/32 * sizeof(BNWORD32));
s -= amt/32;
amt %= 32;
}
if (amt)
(void)lbnRshift_32(dest->ptr, s, amt);
dest->size = lbnNorm_32(dest->ptr, s);
MALLOCDB;
}
/*
* Shift a bignum right until it is odd, and return the number of
* bits shifted. n = d * 2^s. Replaces n with d and returns s.
* Returns 0 when given 0. (Another valid answer is infinity.)
*/
unsigned
bnMakeOdd_32(struct BigNum *n)
{
unsigned size;
unsigned s; /* shift amount */
BNWORD32 *p;
BNWORD32 t;
p = (BNWORD32 *)n->ptr;
size = lbnNorm_32(p, n->size);
if (!size)
return 0;
t = BIGLITTLE(p[-1],p[0]);
s = 0;
/* See how many words we have to shift */
if (!t) {
/* Shift by words */
do {
s++;
BIGLITTLE(--p,p++);
} while ((t = BIGLITTLE(p[-1],p[0])) == 0);
size -= s;
s *= 32;
memmove((BNWORD32 *)n->ptr BIG(-size), p BIG(-size),
size * sizeof(BNWORD32));
p = (BNWORD32 *)n->ptr;
MALLOCDB;
}
assert(t);
/* Now count the bits */
while ((t & 1) == 0) {
t >>= 1;
s++;
}
/* Shift the bits */
if (s & (32-1)) {
lbnRshift_32(p, size, s & (32-1));
/* Renormalize */
if (BIGLITTLE(*(p-size),*(p+(size-1))) == 0)
--size;
}
n->size = size;
MALLOCDB;
return s;
}

92
lib/bind/cylink/bn32.h
View file

@ -1,92 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn32.h - interface to 32-bit bignum routines.
*/
struct BigNum;
void bnInit_32(void);
void bnEnd_32(struct BigNum *bn);
int bnPrealloc_32(struct BigNum *bn, unsigned bits);
int bnCopy_32(struct BigNum *dest, struct BigNum const *src);
int bnSwap_32(struct BigNum *a, struct BigNum *b);
void bnNorm_32(struct BigNum *bn);
void bnExtractBigBytes_32(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned dlen);
int bnInsertBigBytes_32(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
void bnExtractLittleBytes_32(struct BigNum const *bn, unsigned char *dest,
unsigned lsbyte, unsigned dlen);
int bnInsertLittleBytes_32(struct BigNum *bn, unsigned char const *src,
unsigned lsbyte, unsigned len);
unsigned bnLSWord_32(struct BigNum const *src);
unsigned bnBits_32(struct BigNum const *src);
int bnAdd_32(struct BigNum *dest, struct BigNum const *src);
int bnSub_32(struct BigNum *dest, struct BigNum const *src);
int bnCmpQ_32(struct BigNum const *a, unsigned b);
int bnSetQ_32(struct BigNum *dest, unsigned src);
int bnAddQ_32(struct BigNum *dest, unsigned src);
int bnSubQ_32(struct BigNum *dest, unsigned src);
int bnCmp_32(struct BigNum const *a, struct BigNum const *b);
int bnSquare_32(struct BigNum *dest, struct BigNum const *src);
int bnMul_32(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
int bnMulQ_32(struct BigNum *dest, struct BigNum const *a, unsigned b);
int bnDivMod_32(struct BigNum *q, struct BigNum *r, struct BigNum const *n,
struct BigNum const *d);
int bnMod_32(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *d);
unsigned bnModQ_32(struct BigNum const *src, unsigned d);
int bnExpMod_32(struct BigNum *dest, struct BigNum const *n,
struct BigNum const *exp, struct BigNum const *mod);
int bnDoubleExpMod_32(struct BigNum *dest,
struct BigNum const *n1, struct BigNum const *e1,
struct BigNum const *n2, struct BigNum const *e2,
struct BigNum const *mod);
int bnTwoExpMod_32(struct BigNum *n, struct BigNum const *exp,
struct BigNum const *mod);
int bnGcd_32(struct BigNum *dest, struct BigNum const *a,
struct BigNum const *b);
int bnInv_32(struct BigNum *dest, struct BigNum const *src,
struct BigNum const *mod);
int bnLShift_32(struct BigNum *dest, unsigned amt);
void bnRShift_32(struct BigNum *dest, unsigned amt);
unsigned bnMakeOdd_32(struct BigNum *n);

62
lib/bind/cylink/bn68000.c
View file

@ -1,62 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn68000.c - bnInit() for Motorola 680x0 family, 16 or 32-bit.
*
* Written in 1995 by Colin Plumb.
*/
#include "lbn.h"
#include "bn16.h"
#include "bn32.h"
#ifndef BNINCLUDE
#error You must define BNINCLUDE to lbn68000.h to use assembly primitives.
#endif
void
bnInit(void)
{
if (is68020())
bnInit_32();
else
bnInit_16();
}

62
lib/bind/cylink/bn8086.c
View file

@ -1,62 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bn8086.c - bnInit() for Intel x86 family in 16-bit mode.
*
* Written in 1995 by Colin Plumb.
*/
#include "lbn.h"
#include "bn16.h"
#include "bn32.h"
#ifndef BNINCLUDE
#error You must define BNINCLUDE to lbn8086.h to use assembly primitives.
#endif
void
bnInit(void)
{
/* if (not386())
bnInit_16();
else */
bnInit_32();
}

56
lib/bind/cylink/bninit16.c
View file

@ -1,56 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bninit16.c - Provide an init function that sets things up for 16-bit
* operation. This is a seaparate tiny file so you can compile two bn
* packages into the library and write a custom init routine.
*
* Written in 1995 by Colin Plumb.
*/
#include "bn.h"
#include "bn16.h"
void
bnInit(void)
{
bnInit_16();
}

56
lib/bind/cylink/bninit32.c
View file

@ -1,56 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bninit32.c - Provide an init function that sets things up for 32-bit
* operation. This is a seaparate tiny file so you can compile two bn
* packages into the library and write a custom init routine.
*
* Written in 1995 by Colin Plumb.
*/
#include "bn.h"
#include "bn32.h"
void
bnInit(void)
{
bnInit_32();
}

75
lib/bind/cylink/bnsize00.h
View file

@ -1,75 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* bnsize00.h - pick the correct machine word size to use.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*/
#include "lbn.h" /* Get basic information */
#if !BNSIZE64 && !BNSIZE32 && !BNSIZE16 && defined(BNWORD64)
# if defined(BNWORD128) || (defined(lbnMulAdd1_64) && defined(lbnMulSub1_64))
# define BNSIZE64 1
# elif defined(mul64_ppmm) || defined(mul64_ppmma) || defined(mul64_ppmmaa)
# define BNSIZE64 1
# endif
#endif
#if !BNSIZE64 && !BNSIZE32 && !BNSIZE16 && defined(BNWORD32)
# if defined(BNWORD64) || (defined(lbnMulAdd1_32) && defined(lbnMulSub1_32))
# define BNSIZE32 1
# elif defined(mul32_ppmm) || defined(mul32_ppmma) || defined(mul32_ppmmaa)
# define BNSIZE32 1
# endif
#endif
#if !BNSIZE64 && !BNSIZE32 && !BNSIZE16 && defined(BNWORD16)
# if defined(BNWORD32) || (defined(lbnMulAdd1_16) && defined(lbnMulSub1_16))
# define BNSIZE16 1
# elif defined(mul16_ppmm) || defined(mul16_ppmma) || defined(mul16_ppmmaa)
# define BNSIZE16 1
# endif
#endif
#if !BNSIZE64 && !BNSIZE32 && !BNSIZE16
#error Unable to find a viable word size to compile bignum library.
#endif

133
lib/bind/cylink/c_asm.h
View file

@ -1,133 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: c_asm.h PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: C / ASM Header File
*
* USAGE: File should be included to use Toolkit Functions
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
* 14 Oct 94 GKL For Second version (big endian support)
* 26 Oct 94 GKL (alignment for big endian support )
*
****************************************************************************/
#if !defined( C_ASM_H )
#define C_ASM_H
#include <sys/types.h>
#include "cylink.h"
#include "ctk_endian.h"
#ifdef __cplusplus
extern "C" {
#endif
int Sum_big (ord *X,
ord *Y,
ord *Z,
int len_X );
int Sum (ord *X, ord *Y, ushort len_X );
int Sub_big (ord *X,
ord *Y,
ord *Z,
int len_X );
/*
void Mul_big( ord *X, ord *Y,ord *XY,
ushort lx, ushort ly,
ushort elements_in_X,
ushort elements_in_Y);*/
void Mul_big( ord *X, ord *Y,ord *XY,
ushort lx, ushort ly);
void PReLo_big( ord *X, ord *P,
ushort len_X, ushort el);
void Div_big( ord *X, ord *P,
ushort len_X, ushort el,
ord *div);
int LeftMostBit_big ( ord X );
int LeftMostEl_big( ord *X, ushort len_X );
void RShiftL_big( ord *X, u_int32_t len_X, u_int32_t n_bit );
void LShiftL_big( ord *X, u_int32_t len_X, u_int32_t n_bit );
int RShiftMostBit(ord *a, u_int32_t len);
void ByteLong(uchar *X, u_int32_t X_bytes, u_int32_t *Y);
void ByteOrd(uchar *X, u_int32_t X_bytes, ord *Y);
void OrdByte(ord *X, u_int32_t X_bytes, uchar *Y);
void LongByte(u_int32_t *X, u_int32_t X_bytes, uchar *Y);
int BitValue_big( ord *X, ushort n_bits );
int BitsValue_big( ord *X, ushort n_bits, ushort bit_count );
void ByteSwap32_big( uchar *X, ushort X_len );
void Complement_big( ord *X, ushort X_longs);
void Diagonal_big (ord *X, ushort X_len, ord *X2);
void Square_big( ord *X, ushort X_len, ord *X2);
void Mul_big_1( ord X, ord *Y, ord *XY, ushort ly );
int Sum_Q(ord *X, ushort src, ushort len_X );
/* In-place DES encryption */
void DES_encrypt(uchar *keybuf, uchar *block);
/* In-place DES decryption */
void DES_decrypt(uchar *keybuf, uchar *block);
/* In-place KAPPA encryption */
void KAPPA_encrypt(uchar *a, uchar *k, ushort r);
/* In-place KAPPA decryption */
void KAPPA_decrypt(uchar *a, uchar *k, ushort r);
#ifdef __cplusplus
}
#endif
#endif /*C_ASM_H*/

255
lib/bind/cylink/cencrint.h
View file

@ -1,255 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: cencrint.h PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Cryptographic Toolkit Internal Functions Header File
*
* USAGE: File should be included to use Toolkit Functions
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
* 23 Aug 94 KPZ Initial release
* 24 Sep 94 KPZ Added prototypes of internal functions
* 14 Oct 94 GKL Second version (big endian support)
* 08 Dec 94 GKL Added YIELD_context to Expo, VerPrime and GenPrime
*
****************************************************************************/
#ifndef CENCRINT_H /* Prevent multiple inclusions of same header file */
#define CENCRINT_H
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
/* system files */
#include <sys/types.h>
#include "cylink.h"
#include "ctk_endian.h"
#include "toolkit.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Compute a modulo */
int PartReduct( u_int16_t X_bytes, ord *X,
u_int16_t P_bytes, ord *P,
ord *Z );
/* Compute a modulo product */
int Mul( u_int16_t X_bytes, ord *X,
u_int16_t Y_bytes, ord *Y,
u_int16_t P_bytes, ord *P,
ord *Z );
/*Compute a modulo squaring*/
int Mul_Squr( u_int16_t X_bytes, ord *X,
u_int16_t P_bytes, ord *P,
ord *Z );
int Square( u_int16_t X_bytes,
ord *X,
u_int16_t P_bytes,
ord *P,
ord *Z );
/*Compare two array*/
int Comp_Mont ( ord *X, ord *P, u_int16_t P_longs );
/*Compute invers element*/
ord Inv_Mont ( ord x );
/*Modulo by the Mongomery*/
void PartReduct_Mont( ord *X, u_int16_t P_bytes, ord *P, ord inv );
/*Computes squaring by the Mongomery modulo*/
int Mul_Squr_Mont(ord *X, u_int16_t P_bytes,
ord *P, ord *Z,
ord inv );
/*Computes multiply by the montgomery modulo*/
int Mul_Mont( ord *X, ord *Y,
u_int16_t P_bytes, ord *P,
ord *Z, ord inv );
/* Compute a modulo exponent */
int Expo( u_int16_t X_bytes, ord *X,
u_int16_t Y_bytes, ord *Y,
u_int16_t P_bytes, ord *P,
ord *Z );
/*Compute double exponent */
int DoubleExpo( u_int16_t X1_bytes,ord *X1,
u_int16_t Y1_bytes,ord *Y1,
u_int16_t X2_bytes,ord *X2,
u_int16_t Y2_bytes,ord *Y2,
u_int16_t P_bytes,ord *P,
ord *Z);
/* Compute a modulo inverse element */
int Inverse( u_int16_t X_bytes, ord *X,
u_int16_t P_bytes, ord *P,
ord *Z );
/* Verify Pseudo Prime number */
int VerPrime( u_int16_t P_bytes, ord *P,
u_int16_t k, ord *RVAL,
YIELD_context *yield_cont ); /*TKL00601*/
/* Generate Random Pseudo Prime number */
int GenPrime( u_int16_t P_bytes, ord *P,
u_int16_t k, ord *RVAL,
YIELD_context *yield_cont ); /*TKL00601*/
/* Transfer bytes to u_int32_t */
void ByteLong( uchar *X,
u_int16_t X_bytes,
u_int32_t *Y );
/* Transfer u_int32_t to bytes */
void LongByte( u_int32_t *X,
u_int16_t X_bytes,
uchar *Y );
/* Transfer bytes to ord */
void ByteOrd( uchar *X,
u_int16_t X_bytes,
ord *Y );
/* Transfer ord to bytes */
void OrdByte( ord *X,
u_int16_t X_bytes,
uchar *Y );
/* Find the left most non zero bit */
int LeftMostBit ( ord X );
/* Find the left most element */
int LeftMostEl( ord *X,
u_int16_t len_X );
/* Shift array to rigth by n_bit */
void RShiftL( ord *X,
u_int16_t len_X,
u_int16_t n_bit );
/* Shifts array to left by n_bit */
void LShiftL( ord *X,
u_int16_t len_X,
u_int16_t n_bit );
/* Find the value of bit */
int BitValue( ord *X,
u_int16_t n_bits );
/* Perform byte reversal on an array of ordinar type (longword or shortword) */
void ByteSwap( uchar *X,
u_int16_t X_len );
/* Perform byte reversal on an array from LSB to MSB */
void BigSwap( uchar *X,
u_int16_t X_len );
/* Perform byte reversal on an array of longword */
void ByteSwap32( uchar *X,
u_int16_t X_len );
/* Perform short reversal on an array of longword */
void WordSwap( uchar *X,
u_int16_t X_len );
/* Perform SHS transformation */
void shaTransform( u_int32_t *state,
const uchar *block );
/* Compute modulo addition
int Add( ord *X,
ord *Y,
u_int16_t P_len,
ord *P,
ord *Z );
*/
int Add( ord *X,
ord *Y,
u_int16_t P_len,
ord *P );
/* Initialize Secure Hash Function for generate
random number for DSS */
void SHAInitK( SHA_context *hash_context );
/* Set parity bits */
void SetKeyParity( uchar *key );
/* Find a least significant non zero bit
and sfift array to right */
int RShiftMostBit( ord *a, u_int16_t len );
/*Compute great common divisor */
int SteinGCD( ord *m, ord *b, u_int16_t len );
/* Compute a modulo and divisor */
int DivRem( u_int16_t X_bytes, ord *X,
u_int16_t P_bytes, ord *P,
ord *Z, ord *D );
/* Generate random number */
int MyGenRand( u_int16_t A_bytes, ord *A,
ord *RVAL);
/* Compute a Secure Hash Function */
int MySHA( uchar *message,
u_int16_t message_bytes,
uchar *hash_result );
/* Finalize Secure Hash Function */
int MySHAFinal( SHA_context *hash_context,
uchar *hash_result );
void shaTransform_new( u_int32_t *state,
uchar *block );
#ifdef __cplusplus
}
#endif
#endif /* CENCRINT_H */

212
lib/bind/cylink/ctk_endian.h
View file

@ -1,212 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/**********************************************************************\
* FILENAME: ctk_endian.h PRODUCT NAME:
*
* DESCRIPTION: header file of defines
*
* USAGE: Platform-dependend compilation modes header
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
\**********************************************************************/
#ifndef CTK_ENDIAN_H /* Prevent multiple inclusions of same header file */
#define CTK_ENDIAN_H
#include <sys/types.h>
#include <ctype.h>
#include <arpa/nameser_compat.h>
#include "lbn.h"
#if (defined(BIG_ENDIAN) || defined(_BIG_ENDIAN)) && !(defined(LITTLE_ENDIAN) || defined(_LITTLE_ENDIAN))
# undef BIG_ENDIAN
# undef _BIG_ENDIAN
# define BIG_ENDIAN 4321
# define LITTLE_ENDIAN 1234
# define BYTE_ORDER BIG_ENDIAN
#elif !(defined(BIG_ENDIAN) || defined(_BIG_ENDIAN)) && (defined(LITTLE_ENDIAN) || defined(_LITTLE_ENDIAN))
# undef LITTLE_ENDIAN
# undef _LITTLE_ENDIAN
# define BIG_ENDIAN 4321
# define LITTLE_ENDIAN 1234
# define BYTE_ORDER LITTLE_ENDIAN
#endif
#if !defined(BYTE_ORDER) || \
(BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN)
/* you must determine what the correct bit order is for
* your compiler - the next line is an intentional error
* which will force your compiles to bomb until you fix
* the above macros.
*/
# if !defined(CTK_LITTLE_ENDIAN) && !defined(CTK_BIG_ENDIAN)
# error "Undefined or invalid BYTE_ORDER";
# endif
#endif
#if !defined(CTK_BIG_ENDIAN) && !defined(CTK_LITTLE_ENDIAN)
# ifdef BYTE_ORDER
# if (BYTE_ORDER == LITTLE_ENDIAN)
# define CTK_LITTLE_ENDIAN
# elif (BYTE_ORDER == BIG_ENDIAN)
# define CTK_BIG_ENDIAN
# else
# error CAN NOT determine ENDIAN with BYTE_ORDER
# endif
# elif defined(_LITTLE_ENDIAN)
# define CTK_LITTLE_ENDIAN
# elif defined(_BIG_ENDIAN)
# define CTK_BIG_ENDIAN
# else
# error CAN NOT determine ENDIAN
# endif
#endif
#if !defined(CTK_BIG_ENDIAN) && !defined(CTK_LITTLE_ENDIAN)
# error NO CTK_???_ENDIAN defined
#endif
#if defined( CTK_LITTLE_ENDIAN ) && defined( CTK_BIG_ENDIAN )
# error Use only one define CPU type CTK_LITTLE or BIG ENDIAN.
#endif
#if !defined( ORD_32 ) && !defined( ORD_16 )
# ifdef BNSIZE64
# error BNSIZE64 do not know how to do this
# elif defined(BNSIZE32)
# define ORD_32
# elif defined(BNSIZE16)
# define ORD_16
# elif !defined( UINT_MAX) /* No <limits.h> */
# define ORD_16 /* default */
# else
# if ULONG_MAX == 0xffffffff
# define ORD_16
# else
# define ORD_32
# endif
# endif
#endif
#if !defined( ORD_32 ) && !defined( ORD_16 )
#error Not defined basic word type ORD_32 or ORD_16.
#endif
#if defined( ORD_32 ) && defined( ORD_16 )
#error Use only one define basic word type ORD_32 or ORD_16.
#endif
#ifdef ORD_16
/* typedef unsigned short ord; deleted by ogud@tis.com 1998/9/14 */
typedef u_int16_t ord;
#define BITS_COUNT 16
#define MAXDIGIT (ord)(0xFFFF)
#endif
#ifdef ORD_32
/* typedef unsigned long ord; deleted by ogud@tis.com 1998/9/14 */
typedef u_int32_t ord;
#define BITS_COUNT 32
#define MAXDIGIT (ord)(0xFFFFFFFF)
#endif /* ORD_32 */
#define CALLOC(var,type,len) \
var=(type *)calloc(len,1); \
if (var==NULL) \
status=ERR_ALLOC
#ifdef CTK_BIG_ENDIAN
#define ALIGN_CALLOC(i,o,l) \
CALLOC(o,ord,l)
#define ALIGN_CALLOC_COPY(i,o,l) \
CALLOC(o,ord,l); \
if (o) ByteOrd(i,l,o)
#define ALIGN_CALLOC_MOVE(i,o,l) \
CALLOC(o,ord,l); \
if (o) memcpy(o,i,l)
#define ALIGN_FREE(o) \
free ( o )
#define ALIGN_COPY_FREE(o,i,l) \
if ((o) && (status==SUCCESS)) \
OrdByte(o,l,i); \
free (o)
#define ALIGN_MOVE_FREE(o,i,l) \
if ((o) && (status==SUCCESS)) \
memcpy(i,o,l); \
memset(o,0,l); \
free (o)
#else
#define ALIGN_CALLOC(i,o,l) o=(ord *)i
#define ALIGN_CALLOC_COPY(i,o,l) o=(ord *)i
#define ALIGN_CALLOC_MOVE(i,o,l) o=(ord *)i
#define ALIGN_FREE(o) ;
#define ALIGN_COPY_FREE(o,i,l) ;
#define ALIGN_MOVE_FREE(o,i,l) ;
#endif
#define DSS_P_ALIGN_CALLOC_COPY(i,o,l) \
if (i) \
{ ALIGN_CALLOC_COPY(i,o,l);} \
else \
o = &DSS_P_NUMBERS[DSS_NUM_INDEX[(l-DSS_LENGTH_MIN)/LENGTH_STEP]]
#define DSS_G_ALIGN_CALLOC_COPY(i,o,l) \
if (i) \
{ ALIGN_CALLOC_COPY(i,o,l);} \
else \
o = &DSS_G_NUMBERS[DSS_NUM_INDEX[(l-DSS_LENGTH_MIN)/LENGTH_STEP]]
#define DSS_Q_ALIGN_CALLOC_COPY(i,o,l) \
if (i) \
{ ALIGN_CALLOC_COPY(i,o,l);} \
else \
o = DSS_Q_NUMBER
#define DSS_ALIGN_FREE(o,i) \
if (i) \
{ ALIGN_FREE(o);}
#endif /* CTK_ENDIAN_H */

435
lib/bind/cylink/ctk_prime.c
View file

@ -1,435 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: prime.c PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Cryptographic Toolkit Internal Functions File
* Prime Number functions
* PRIVATE FUNCTIONS:
*
* int VerPrime( u_int16_t P_bytes, ord *P,
* u_int16_t k, ord *RVAL,
* YIELD_context *yield_cont )
* int GenPrime( u_int16_t P_bytes, ord *P,
* u_int16_t k, ord *RVAL,
* YIELD_context *yield_cont )
* Copyright (c) Cylink Corporation 1996. All rights reserved.
*
* REVISION HISTORY:
*
*
****************************************************************************/
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
#include "port_before.h"
#include <sys/types.h>
#include "cylink.h"
#include "ctk_endian.h"
/* system files */
#ifdef VXD
#include <vtoolsc.h>
#else
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#endif
/* program files */
#include "cylink.h"
#include "ctk_endian.h"
#include "toolkit.h"
#include "cencrint.h"
#include "port_after.h"
/****************************************************************************
* PRIVATE FUNCTIONS DEFINITIONS
****************************************************************************/
/****************************************************************************
* NAME: int VerPrime( u_int16_t P_bytes,
* ord *P,
* u_int16_t k,
* ord *RVAL,
* YIELD_context *yield_cont )
*
* DESCRIPTION: Verify Pseudo Prime number
*
* INPUTS:
* PARAMETERS:
* u_int16_t P_bytes Number of bytes in array
* u_int16_t k Number of testing
* ord *RVAL Pointer to random number generator value
* YIELD_context *yield_cont Pointer to yield_cont structure (NULL if not used)
* OUTPUT:
* PARAMETERS:
* ord *P Pointer to prime number
* ord *RVAL Pointer to updated value
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data(zero bytes)
* ERR_PRIME Number is not prime
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
* 08 Dec 94 GKL Added YIELD_context
*
****************************************************************************/
int VerPrime( u_int16_t P_bytes,
ord *P,
u_int16_t k,
ord *RVAL,
YIELD_context *yield_cont ) /*TKL00601*/
{
int status = SUCCESS; /*function return status*/
ord *b, *n, *c, *pp; /*pointers to working buffers */
ord *m, *buf, *P_buf;
u_int16_t max_bytes; /*number of maximum bytes*/
u_int16_t P_longs; /*number of longs in Y*/
u_int16_t i, j, s, k_b; /*counters*/
u_int16_t exit ; /*flag for exit*/
/* product of prime numbers from 3 to 379 (512-bit number) */
#ifdef ORD_32
ord b1[DSS_LENGTH_MIN/sizeof(ord)]={
0x2e30c48fL, 0x0decece9L, 0xbada8f98L, 0x9f7ecb29L,
0xa4a11de4L, 0x6ef04659L, 0xcbc38405L, 0x233db117L,
0x03e81187L, 0xc1b631a2L, 0x238bfb99L, 0x077ec3baL,
0xc5d5f09fL, 0xb0813c28L, 0x7646fa6eL, 0x106aa9fbL };
#else
ord b1[DSS_LENGTH_MIN/sizeof(ord)]={
0xc48f, 0x2e30, 0xece9, 0x0dec, 0x8f98, 0xbada, 0xcb29, 0x9f7e,
0x1de4, 0xa4a1, 0x4659, 0x6ef0, 0x8405, 0xcbc3, 0xb117, 0x233d,
0x1187, 0x03e8, 0x31a2, 0xc1b6, 0xfb99, 0x238b, 0xc3ba, 0x077e,
0xf09f, 0xc5d5, 0x3c28, 0xb081, 0xfa6e, 0x7646, 0xa9fb, 0x106a };
#endif
if ( P_bytes % sizeof(ord) != 0 ) /* not multiple 4 (32 bit) */
{
status = ERR_INPUT_LEN; /* invalid length for input data */
return status;
}
if ( P_bytes <= DSS_LENGTH_MIN )
{
max_bytes = DSS_LENGTH_MIN;
}
else
{
max_bytes = P_bytes;
}
buf = (ord *)calloc( max_bytes / sizeof(ord), sizeof(ord) );
P_buf = (ord *)calloc( max_bytes / sizeof(ord), sizeof(ord));
if( !buf || !P_buf )
{
if ( buf )
free( buf );
if( P_buf )
free( P_buf );
return ERR_ALLOC;
}
memcpy( buf, b1, DSS_LENGTH_MIN );
memcpy( P_buf, P, P_bytes );
if ( (P_buf[0] & 0x1) == 0 )
{
#ifdef DEBUG1
printf ("\n P is not pseudoprime");
#endif
status = ERR_PRIME;
free ( buf );
free( P_buf );
return status;
}
P_longs = (u_int16_t) (P_bytes / sizeof(ord));
b = (ord *)calloc( P_longs, sizeof(ord) );
m = (ord *)malloc( P_longs * sizeof(ord) );
n = (ord *)calloc( P_longs, sizeof(ord) );
c = (ord *)calloc( P_longs, sizeof(ord) );
pp = (ord *)malloc( P_longs * sizeof(ord) );
if( !b || !m || !n || !c || !pp )
{
if( b )
free( b );
if( m )
free( m );
if( n )
free( n );
if( c )
free( c );
if( pp )
free ( pp );
}
memcpy( m, P, P_bytes );
memcpy( pp, P, P_bytes );
/* Compute great common divisor(gcd) */
if ( SteinGCD( P_buf, buf, (u_int16_t)(max_bytes / sizeof(ord)) ) == 0 )
{
pp[0] = pp[0] - 1; /* Initialized work buffer */
m[0] = m[0] - 1;
s = (u_int16_t) RShiftMostBit( m, (u_int16_t)(P_bytes / sizeof(ord)) ); /* Right shift by number of*/
exit = 0; /* zero bits at rigth */
k_b = 0;
while( k_b != k )
{
MyGenRand( 4, b, RVAL ); /* generate random number */
if ( SteinGCD( P_buf, b , (u_int16_t)(P_bytes / sizeof(ord)) ) ) /* check gcd */
{
#ifdef DEBUG1
printf ("\n P is not pseudoprime");
#endif
status = ERR_PRIME;
break;
}
k_b++; /* increment counter */
if ( ( status = Expo ( 4, b, P_bytes, m,
P_bytes, P, c ) ) != SUCCESS ) /* c=b^m mod(P) */ /*TKL00601*/
{
free( b );
free( m );
free( n );
free( c );
free( pp );
free (buf );
free( P_buf );
return status;
}
if ( c[0] == 1 ) /* if c==1 number is pseudo prime */
{
for ( i = 1; i < P_bytes / sizeof(ord); i++ )
{
if ( c[i] != 0 )
{
break;
}
}
if ( i == P_bytes / sizeof(ord) )
{
if (yield_cont) /*TKL00601*/
#ifdef VXD
if ( VXD_Yield (yield_cont->yield_proc) )
#else
if ( yield_cont->yield_proc(0xFFFF) )
#endif
{
status = ERR_CANCEL;
free( b );
free( m );
free( n );
free( c );
free( pp );
free( P_buf );
free (buf );
return status;
}
#ifdef DEBUG1
printf ("\n P is a pseudoprime %d",k_b);
#endif
if ( k_b == k )
{
break;
}
}
}
else
{
for ( j = 1; j <= s; j++ )
{
for ( i = 0; i < P_bytes / sizeof(ord); i++ ) /* if c==pp number is pseudo prime */
{
if ( c[i] != pp[i] )
{
break;
}
}
if ( i == P_bytes / sizeof(ord) )
{
if (yield_cont) /*TKL00601*/
#ifdef VXD
if ( VXD_Yield (yield_cont->yield_proc) )
#else
if ( yield_cont->yield_proc(0xFFFF) )
#endif
{
status = ERR_CANCEL;
free( b );
free( m );
free( n );
free( c );
free( pp );
free( P_buf );
free (buf );
return status;
}
#ifdef DEBUG1
printf ("\n P is a pseudoprime %d",k_b);
#endif
break;
}
if ( j == s )
{
#ifdef DEBUG1
printf ("\n P is not pseudoprime");
#endif
status = ERR_PRIME;
exit = 1;
break;
}
else
{
if ( (status = Square(P_bytes, c, /*P_bytes,
c,*/ P_bytes, P, c) )
!= SUCCESS ) /* c=c^2mod(p) */
{
free( b );
free( m );
free( n );
free( c );
free( pp );
free( P_buf );
free (buf );
return status;
}
}
}
}
if ( exit == 1 ) /* Exit */
{
break;
}
}
}
else
{
if (yield_cont) /*TKL00601*/
#ifdef VXD
if ( VXD_Yield (yield_cont->yield_proc) )
#else
if ( yield_cont->yield_proc(0xFFFF) )
#endif
{
status = ERR_CANCEL;
free( b );
free( m );
free( n );
free( c );
free( pp );
free( P_buf );
free (buf );
return status;
}
#ifdef DEBUG1
printf ("\n P is not pseudoprime");
#endif
status = ERR_PRIME;
}
free( b );
free( m );
free( n );
free( c );
free( pp );
free( P_buf );
free (buf );
return status;
}
/****************************************************************************
* NAME: int GenPrime( u_int16_t P_bytes,
* ord *P,
* u_int16_t k,
* ord *RVAL,
* YIELD_context *yield_cont )
*
* DESCRIPTION: Generate Random Pseudo Prime number
*
* INPUTS:
* PARAMETERS:
* u_int16_t P_bytes Number of bytes in array
* u_int16_t k Number of testing
* ord *RVAL Pointer to random number generator value
* YIELD_context *yield_cont Pointer to yield_cont structure (NULL if not used)
* OUTPUT:
* PARAMETERS:
* ord *P Pointer to prime number
* ord *RVAL Pointer to updated value
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data(zero bytes)
* ERR_PRIME Number is not prime
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
* 08 Dec 94 GKL Added YIELD_context
*
****************************************************************************/
int GenPrime( u_int16_t P_bytes,
ord *P,
u_int16_t k,
ord *RVAL,
YIELD_context *yield_cont ) /*TKL00601*/
{
int status = SUCCESS; /* function return status */
if ( P_bytes % sizeof(ord) != 0 ) /* not multiple 4 (32 bit) */
{
status = ERR_INPUT_LEN; /* invalid length for input data */
return status;
}
do
{
MyGenRand( P_bytes, P, RVAL ); /* generate random number */
P[0] |= 1;
P[(P_bytes/sizeof(ord))-1] |= ((ord)1 << (BITS_COUNT-1));
status = VerPrime( P_bytes, P, k, RVAL, yield_cont); /*TKL00601*/
} while ((status != SUCCESS) && (status != ERR_CANCEL)); /*TKL00601*/
return status;
}

82
lib/bind/cylink/cylink.h
View file

@ -1,82 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/**********************************************************************\
* FILENAME: cylink.h PRODUCT NAME:
*
* DESCRIPTION: Company standard include file
*
* USAGE: File should be #included
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
\**********************************************************************/
#ifndef CYLINK_H /* Prevent multiple inclusions of same header file */
#define CYLINK_H
#include <sys/param.h>
#if (!defined(BSD)) || (BSD < 199306)
# include <sys/bitypes.h>
#else
# include <sys/types.h>
#endif
#if ! ( defined(__alpha) && defined(__osf__) ) /* in sys/types.h */
#if !defined(_H_INTTYPES) && !defined (_H_TYPES) /* AIX puts this in inttypes.h */
typedef unsigned char uchar;
#endif /* _H_INTTYPES */
#endif
typedef u_int16_t USHORT;
typedef u_int32_t ULONG;
#define FALSE 0
#define TRUE 1
/*-- ANSI-recommended NULL Pointer definition --*/
#ifndef NULL
edefine NULL (void *) 0
#endif
#endif /* CYLINK_H */

1202
lib/bind/cylink/dss.c
View file

File diff suppressed because it is too large Load diff

724
lib/bind/cylink/dssnum.h
View file

@ -1,724 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/**********************************************************************\
* FILENAME: DSSNum.h PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* DESCRIPTION: Standard Cylink DSS numbers (P Q G) support.
*
* USAGE: File should be included to get access to
* Cylink DSS numbers
*
*
* Copyright (c) Cylink Corporation 1995. All rights reserved.
*
* REVISION HISTORY:
* 10 APR 95 GKL Initial release
*
\**********************************************************************/
#ifndef DSSNUMBER_H /* Prevent multiple inclusions */
#define DSSNUMBER_H
#include "ctk_endian.h"
#define LENGTH_MULT_TO_64
#define F0 0
#define F1 (F0 + 1)
#define F2 (F1 + 2)
#define F3 (F2 + 3)
#define F4 (F3 + 4)
#define F5 (F4 + 5)
#define F6 (F5 + 6)
#define F7 (F6 + 7)
#define F8 (F7 + 8)
#define F9 (F8 + 9)
#define F10 (F9 + 10)
#define F11 (F10 + 11)
#define F12 (F11 + 12)
#define F13 (F12 + 13)
#define F14 (F13 + 14)
#define F15 (F14 + 15)
#ifdef LENGTH_MULT_TO_64
#define LENGTH_STEP 8U
#define LAST_F F8
#endif
#ifdef LENGTH_MULT_TO_32
#define LENGTH_STEP 4U
#define LAST_F (F15 + 16)
#endif
#define DSS_LENS_NUMBER (int) (1 + ( DSS_LENGTH_MAX - DSS_LENGTH_MIN )/LENGTH_STEP)
#define DSS_LAST_INDEX (DSS_LENGTH_MIN*DSS_LENS_NUMBER + LENGTH_STEP*LAST_F)/sizeof(ord)
#ifndef INITIALIZ_PQG
extern ushort DSS_NUM_INDEX[ DSS_LENS_NUMBER ];
extern ord DSS_Q_NUMBER[SHA_LENGTH/sizeof(ord)];
extern ord DSS_P_NUMBERS[DSS_LAST_INDEX];
extern ord DSS_G_NUMBERS[DSS_LAST_INDEX];
#else
ushort DSS_NUM_INDEX[ DSS_LENS_NUMBER ] =
{
(DSS_LENGTH_MIN*0 + LENGTH_STEP*0 )/sizeof(ord),
(DSS_LENGTH_MIN*1 + LENGTH_STEP*F0 )/sizeof(ord),
(DSS_LENGTH_MIN*2 + LENGTH_STEP*F1 )/sizeof(ord),
(DSS_LENGTH_MIN*3 + LENGTH_STEP*F2 )/sizeof(ord),
(DSS_LENGTH_MIN*4 + LENGTH_STEP*F3 )/sizeof(ord),
(DSS_LENGTH_MIN*5 + LENGTH_STEP*F4 )/sizeof(ord),
(DSS_LENGTH_MIN*6 + LENGTH_STEP*F5 )/sizeof(ord),
(DSS_LENGTH_MIN*7 + LENGTH_STEP*F6 )/sizeof(ord),
(DSS_LENGTH_MIN*8 + LENGTH_STEP*F7 )/sizeof(ord)
#ifdef LENGTH_MULT_TO_32
,
(DSS_LENGTH_MIN*9 + LENGTH_STEP*F8 )/sizeof(ord),
(DSS_LENGTH_MIN*10 + LENGTH_STEP*F9 )/sizeof(ord),
(DSS_LENGTH_MIN*11 + LENGTH_STEP*F10)/sizeof(ord),
(DSS_LENGTH_MIN*12 + LENGTH_STEP*F11)/sizeof(ord),
(DSS_LENGTH_MIN*13 + LENGTH_STEP*F12)/sizeof(ord),
(DSS_LENGTH_MIN*14 + LENGTH_STEP*F13)/sizeof(ord),
(DSS_LENGTH_MIN*15 + LENGTH_STEP*F14)/sizeof(ord),
(DSS_LENGTH_MIN*16 + LENGTH_STEP*F15)/sizeof(ord)
#endif
};
ord DSS_Q_NUMBER[SHA_LENGTH/sizeof(ord)] =
#ifdef ORD_16
{
0x8fb7, 0x81f0, 0x6b9e, 0x122a, 0x4dc4, 0x03ca, 0xc896, 0x8d0e, 0xbe3b, 0xed4b
};
#else
{
0x81f08fb7L, 0x122a6b9eL, 0x03ca4dc4L, 0x8d0ec896L, 0xed4bbe3bL
};
#endif
ord DSS_P_NUMBERS[DSS_LAST_INDEX] =
#ifdef ORD_16
{
/* dss_p length = 512*/
0x92b7, 0xbd96, 0x9aab, 0x584c, 0xd617, 0xf2f0, 0xda85, 0xd370,
0xcc82, 0x273e, 0x6b04, 0xc171, 0x5c32, 0xd3ff, 0x352e, 0xf2f8,
0x4fc2, 0x20bc, 0xbdec, 0xe96e, 0x3503, 0x4d89, 0xe92d, 0xeb7d,
0x9c1a, 0x7852, 0xfe2a, 0x0a25, 0x4446, 0xce18, 0x7829, 0x95d8,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 544*/
0x12db, 0x0d31, 0x9950, 0x16c9, 0x3045, 0x0acb, 0x3c46, 0x3c5c,
0x6c94, 0x2458, 0x0736, 0x13da, 0xa0af, 0x790f, 0xb177, 0xa6ae,
0xd111, 0x2bda, 0x697c, 0x49a2, 0xe3e5, 0x6f27, 0x02f5, 0x9bc9,
0xd4da, 0x7d9b, 0x89c6, 0x63bc, 0x0b6d, 0xfe2d, 0xc7a1, 0x435f,
0x7fad, 0x9e40,
#endif
/* dss_p length = 576*/
0x626b, 0x41b5, 0xd218, 0x25bf, 0x1825, 0x42b3, 0x9eb0, 0xc244,
0x96ce, 0x22ac, 0x3ac6, 0x713f, 0x321d, 0x398c, 0x3022, 0xbc49,
0xdd03, 0x52d5, 0x29f8, 0x2a57, 0x8fa1, 0x2173, 0xee7d, 0xb90d,
0xcc64, 0x5fae, 0xaa81, 0xe3d0, 0x648f, 0xfa6e, 0xdc6c, 0x039f,
0x2cd6, 0xc552, 0xe2dc, 0xebec,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 608*/
0x35f5, 0xb2af, 0x27d0, 0x398b, 0x493d, 0x6f2e, 0xbe27, 0xe5b5,
0x972c, 0x3470, 0x9638, 0xe90e, 0xf7b7, 0x98ad, 0xd091, 0xb4ca,
0x3f43, 0x5f58, 0xb6c5, 0xd014, 0x25ee, 0x414d, 0xe2c1, 0x6fd6,
0xd737, 0x9be6, 0x66ca, 0xe241, 0x1897, 0xf740, 0xe5df, 0xceb0,
0xdb38, 0xabc8, 0x8af8, 0xc58b, 0xc6a0, 0x9a04,
#endif
/* dss_p length = 640*/
0x4095, 0xf6bf, 0x7568, 0x4032, 0x5c0f, 0x64f2, 0x5aae, 0xb099,
0x346f, 0x0e81, 0x357a, 0x7aeb, 0x0291, 0xfd0a, 0x8d54, 0xce80,
0x0c05, 0xbea3, 0x889f, 0x8a1b, 0xf1c1, 0x6049, 0x214a, 0x8ec3,
0xb926, 0xdde1, 0x61b4, 0x384e, 0x404b, 0xb6d7, 0x2e2d, 0x4584,
0xae6a, 0xcc7a, 0x7bfa, 0x9eb0, 0x3a26, 0x3904, 0x8cac, 0xc036,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 672*/
0x0abb, 0xaea3, 0xc749, 0x757c, 0x3035, 0x29d0, 0x46bd, 0xd56c,
0xf49d, 0xa355, 0x1297, 0x8dcb, 0x9802, 0xc58c, 0xf1ec, 0x8aac,
0x55dd, 0xb107, 0x0140, 0x26d1, 0x8a5d, 0x8a90, 0xf33e, 0xde0b,
0xb844, 0xb429, 0x4db2, 0x9806, 0xf629, 0x4c3b, 0xcd76, 0x2f23,
0x6c68, 0x7bf4, 0x2a7e, 0xd982, 0xc89f, 0x16a2, 0xfe84, 0x953c,
0x3e4a, 0x8de8,
#endif
/* dss_p length = 704*/
0x0113, 0x1535, 0xca0b, 0x8faf, 0xa327, 0x989c, 0x12c8, 0xe512,
0x796f, 0x1229, 0x12bf, 0x62c8, 0xa50a, 0x2b99, 0xc93b, 0x450c,
0x71ad, 0x0826, 0xf4c6, 0x3913, 0x9b6e, 0x96da, 0xa08d, 0xbc5e,
0xd4d3, 0x7b26, 0xf9fd, 0xdd76, 0x4e82, 0x2f06, 0x1f96, 0xbf47,
0xcadf, 0x3610, 0x917b, 0x4e94, 0xe2e8, 0x0eaf, 0x1cb9, 0x6b90,
0xb917, 0x6d6f, 0x92b9, 0xb329,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 736*/
0x6dad, 0xd878, 0xc913, 0xe61e, 0x87d9, 0xe275, 0xad24, 0xf090,
0xe12b, 0xfdfe, 0x39a3, 0xc9a1, 0x8330, 0x138a, 0x4bed, 0xc319,
0x8094, 0x88ba, 0x4b80, 0x1325, 0x7852, 0x67e2, 0x715e, 0x7313,
0x3b4e, 0x7727, 0x9870, 0x5c6e, 0xe0ce, 0xc67a, 0xd057, 0xf3c5,
0x55ea, 0x98ba, 0x6ea0, 0xaee7, 0x31e8, 0x3cd6, 0x0e28, 0x42d1,
0x8946, 0xc395, 0x34fc, 0x1b9d, 0x19d1, 0x86f9,
#endif
/* dss_p length = 768*/
0xe293, 0xea08, 0xcdd0, 0xf668, 0x8b2a, 0x06db, 0x7c71, 0xadb2,
0x943d, 0x6721, 0x54f5, 0xbc44, 0xf7ca, 0x3345, 0x1bf6, 0x0b90,
0xb475, 0xd3c4, 0xbdb6, 0x7caa, 0xa45f, 0xe9b4, 0x6e0e, 0x0c1a,
0xb5c3, 0x9760, 0x851a, 0x53af, 0x96b7, 0x4979, 0xf162, 0xe951,
0x6a54, 0xd020, 0x9ded, 0xdecb, 0xfc81, 0x7d74, 0x5e92, 0x2aee,
0x0946, 0x0eb5, 0x3700, 0x9bce, 0x845a, 0xa7a3, 0x157a, 0x8618,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 800*/
0xb0a1, 0xac27, 0xec4e, 0xf623, 0x55e2, 0x2cb6, 0x288b, 0x4b28,
0xd74e, 0xbbe6, 0xfdf7, 0xaecd, 0x5758, 0xe251, 0x9074, 0x1aee,
0xe6ed, 0x4d5e, 0x01d9, 0x529e, 0xf736, 0x0091, 0x0212, 0xc725,
0x60ce, 0x966f, 0x851d, 0x5c4b, 0x80de, 0x34df, 0x1c88, 0x0636,
0xbb71, 0x32ce, 0x45cb, 0x86da, 0x4d0e, 0x13e0, 0x7d7d, 0x544b,
0x1272, 0x747f, 0xd6a7, 0xfa3b, 0xcb86, 0x6b43, 0x66f5, 0xd012,
0xfe7a, 0xa0cb,
#endif
/* dss_p length = 832*/
0xed2d, 0x84dd, 0xf274, 0xdd8f, 0xcd5f, 0x7928, 0xbfc6, 0xa522,
0xe4e4, 0x50f0, 0xcddf, 0x5842, 0xbb29, 0x7c4d, 0xeef4, 0x6946,
0x87f6, 0xe486, 0x61b5, 0xc1b6, 0xadef, 0x575a, 0x360f, 0x724f,
0xcb29, 0x591b, 0x9a4c, 0xf7bc, 0x309e, 0xa348, 0x0ff5, 0x94f3,
0x932f, 0x9dc6, 0x992c, 0xc6d7, 0x12f6, 0xc2d7, 0x38aa, 0x8c01,
0x5dca, 0x74f4, 0xfcfd, 0x4cf4, 0x588a, 0x7837, 0x097e, 0xd2e2,
0x6eac, 0x8869, 0xe92f, 0xec62,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 864*/
0x7c21, 0x931e, 0x553d, 0x00f2, 0xa860, 0x940f, 0x411e, 0x7d20,
0xb168, 0x52a3, 0x69ee, 0x166e, 0xb9e6, 0x1b23, 0xd5e0, 0xef64,
0x2850, 0x724c, 0xc1fe, 0xea73, 0xda8c, 0xe342, 0x1d7b, 0xd256,
0x359b, 0x180f, 0xd7f5, 0xca77, 0x06ac, 0x2162, 0xa977, 0x78bb,
0x5018, 0x5de2, 0x6061, 0xe217, 0x4d42, 0xfed1, 0x3929, 0xd50f,
0xc946, 0x2433, 0x15f8, 0x361b, 0xbf51, 0x3ff0, 0x3efa, 0x3157,
0x7350, 0x53a0, 0xd1a4, 0x261b, 0xde5b, 0x9236,
#endif
/* dss_p length = 896*/
0x8e21, 0x0364, 0x86d2, 0xe58c, 0x2274, 0x780a, 0x9ffc, 0x4951,
0x3f99, 0xbc96, 0x9e60, 0x5a7e, 0x010a, 0x23d4, 0x54d1, 0x48e9,
0xfd6b, 0x979c, 0x5202, 0x8af3, 0x5d87, 0xfe8f, 0x3e3c, 0x1e0c,
0xe294, 0xcc52, 0xa8d6, 0x480e, 0xa898, 0xd4ce, 0x5949, 0xd341,
0xe325, 0xf41b, 0x72d6, 0x6a90, 0x7a8b, 0x6f14, 0x3e2b, 0x6636,
0x3748, 0x4eea, 0xa590, 0x03e4, 0x0524, 0x9c32, 0xeb53, 0x02af,
0xca71, 0x6792, 0xd673, 0xedf8, 0x6448, 0x59c3, 0x7319, 0x883f,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 928*/
0xc17d, 0xa4e8, 0xea08, 0x8ff8, 0x2cb0, 0x73f5, 0xd7ba, 0xc027,
0xb9c8, 0x989d, 0xe5fe, 0xe3a1, 0xf324, 0x39d3, 0xf142, 0x5ba8,
0xe6cb, 0x3708, 0xa0b7, 0xed9a, 0xb6b3, 0xe314, 0xf80a, 0x6778,
0x4d27, 0x7107, 0x6ee8, 0xb9c2, 0xc6af, 0xab70, 0x53be, 0xc445,
0x7926, 0x34bb, 0x5191, 0xe11d, 0x67f1, 0xcc3a, 0x5354, 0xd34d,
0xa1ac, 0x08ba, 0x32d4, 0x068a, 0x7c3b, 0x415f, 0xbce0, 0xb549,
0x0ecf, 0x538f, 0xb5d0, 0x22a3, 0x1d47, 0xe837, 0x14c0, 0x69dd,
0xa02d, 0xce91,
#endif
/* dss_p length = 960*/
0x1ff3, 0xf77e, 0xae7a, 0x5a28, 0x43b1, 0xe187, 0x2e04, 0xb3ea,
0x7394, 0xa3e8, 0x4985, 0xc9bc, 0x7b7d, 0x1e1c, 0xd99c, 0x55f8,
0x447b, 0x5704, 0xd758, 0xbed1, 0xe698, 0x2a5e, 0x5c19, 0xc206,
0x6d38, 0x1f88, 0x2ea4, 0x5f15, 0xebfd, 0xd716, 0x8a2a, 0xf960,
0x83ac, 0xc493, 0xb966, 0x8f13, 0x4778, 0x9682, 0x4712, 0x84cd,
0xbb4e, 0xe567, 0x644f, 0x0780, 0x133d, 0x0b0a, 0xe42e, 0x06e8,
0xa4cc, 0x3131, 0x39d9, 0xfaf8, 0x12a3, 0x5550, 0x43b1, 0xb8a9,
0xb0eb, 0x0fad, 0x986f, 0xd427,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 992*/
0xbcfd, 0x363f, 0x050a, 0x18f0, 0x78d8, 0xcac9, 0x423a, 0xf31e,
0x198f, 0xd0c3, 0xb319, 0x5d1b, 0x917a, 0xc0b0, 0x8d1b, 0x6b91,
0xea69, 0xa9d1, 0x02ce, 0x5345, 0x2c80, 0x6992, 0x4dad, 0x7a28,
0xbb75, 0xd46d, 0x0faa, 0x5612, 0x6878, 0x8a0e, 0x63b4, 0x46ab,
0xaca0, 0x5381, 0xb90a, 0x3e70, 0x19c4, 0xb639, 0xf778, 0xe751,
0x5974, 0xb726, 0x589f, 0x8679, 0xeb04, 0xc0b5, 0xdffd, 0x2b32,
0x4b51, 0xc632, 0xd8c6, 0x9501, 0x4f94, 0x2026, 0x253a, 0x0d27,
0x07bb, 0x0838, 0x2725, 0xa3eb, 0x3c4e, 0x89b6,
#endif
/* dss_p length = 1024*/
0xa141, 0xecf7, 0xc6d6, 0x867d, 0xefa3, 0x1cdd, 0x6c9d, 0x6ca5,
0x2e2f, 0x68af, 0x90e1, 0x1d3e, 0xd75f, 0x0c2a, 0x844b, 0x36c7,
0x3420, 0xfd1a, 0xb9ee, 0xf6e5, 0x5fde, 0xc8ed, 0x0c90, 0xd353,
0x6faa, 0x80a4, 0x5bbd, 0xa59d, 0x9e72, 0x3223, 0x8f59, 0xf33d,
0x10eb, 0xeccd, 0x184e, 0x3e2a, 0x4c07, 0x564b, 0x4c0a, 0x3263,
0xc535, 0x8aeb, 0xf982, 0x2be2, 0xe475, 0x9b87, 0xcca0, 0x4d08,
0x3adf, 0x0484, 0xd528, 0x7acd, 0x304d, 0x55a0, 0x70ae, 0x8298,
0x6a7a, 0x2298, 0x15c0, 0x7a86, 0x7fc5, 0x654a, 0x14ad, 0xd0aa
};
#else
{
/* dss_p length = 512*/
0xbd9692b7L, 0x584c9aabL, 0xf2f0d617L, 0xd370da85L,
0x273ecc82L, 0xc1716b04L, 0xd3ff5c32L, 0xf2f8352eL,
0x20bc4fc2L, 0xe96ebdecL, 0x4d893503L, 0xeb7de92dL,
0x78529c1aL, 0x0a25fe2aL, 0xce184446L, 0x95d87829L,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 544*/
0x0d3112dbL, 0x16c99950L, 0x0acb3045L, 0x3c5c3c46L,
0x24586c94L, 0x13da0736L, 0x790fa0afL, 0xa6aeb177L,
0x2bdad111L, 0x49a2697cL, 0x6f27e3e5L, 0x9bc902f5L,
0x7d9bd4daL, 0x63bc89c6L, 0xfe2d0b6dL, 0x435fc7a1L,
0x9e407fadL,
#endif
/* dss_p length = 576*/
0x41b5626bL, 0x25bfd218L, 0x42b31825L, 0xc2449eb0L,
0x22ac96ceL, 0x713f3ac6L, 0x398c321dL, 0xbc493022L,
0x52d5dd03L, 0x2a5729f8L, 0x21738fa1L, 0xb90dee7dL,
0x5faecc64L, 0xe3d0aa81L, 0xfa6e648fL, 0x039fdc6cL,
0xc5522cd6L, 0xebece2dcL,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 608*/
0xb2af35f5L, 0x398b27d0L, 0x6f2e493dL, 0xe5b5be27L,
0x3470972cL, 0xe90e9638L, 0x98adf7b7L, 0xb4cad091L,
0x5f583f43L, 0xd014b6c5L, 0x414d25eeL, 0x6fd6e2c1L,
0x9be6d737L, 0xe24166caL, 0xf7401897L, 0xceb0e5dfL,
0xabc8db38L, 0xc58b8af8L, 0x9a04c6a0L,
#endif
/* dss_p length = 640*/
0xf6bf4095L, 0x40327568L, 0x64f25c0fL, 0xb0995aaeL,
0x0e81346fL, 0x7aeb357aL, 0xfd0a0291L, 0xce808d54L,
0xbea30c05L, 0x8a1b889fL, 0x6049f1c1L, 0x8ec3214aL,
0xdde1b926L, 0x384e61b4L, 0xb6d7404bL, 0x45842e2dL,
0xcc7aae6aL, 0x9eb07bfaL, 0x39043a26L, 0xc0368cacL,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 672*/
0xaea30abbL, 0x757cc749L, 0x29d03035L, 0xd56c46bdL,
0xa355f49dL, 0x8dcb1297L, 0xc58c9802L, 0x8aacf1ecL,
0xb10755ddL, 0x26d10140L, 0x8a908a5dL, 0xde0bf33eL,
0xb429b844L, 0x98064db2L, 0x4c3bf629L, 0x2f23cd76L,
0x7bf46c68L, 0xd9822a7eL, 0x16a2c89fL, 0x953cfe84L,
0x8de83e4aL,
#endif
/* dss_p length = 704*/
0x15350113L, 0x8fafca0bL, 0x989ca327L, 0xe51212c8L,
0x1229796fL, 0x62c812bfL, 0x2b99a50aL, 0x450cc93bL,
0x082671adL, 0x3913f4c6L, 0x96da9b6eL, 0xbc5ea08dL,
0x7b26d4d3L, 0xdd76f9fdL, 0x2f064e82L, 0xbf471f96L,
0x3610cadfL, 0x4e94917bL, 0x0eafe2e8L, 0x6b901cb9L,
0x6d6fb917L, 0xb32992b9L,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 736*/
0xd8786dadL, 0xe61ec913L, 0xe27587d9L, 0xf090ad24L,
0xfdfee12bL, 0xc9a139a3L, 0x138a8330L, 0xc3194bedL,
0x88ba8094L, 0x13254b80L, 0x67e27852L, 0x7313715eL,
0x77273b4eL, 0x5c6e9870L, 0xc67ae0ceL, 0xf3c5d057L,
0x98ba55eaL, 0xaee76ea0L, 0x3cd631e8L, 0x42d10e28L,
0xc3958946L, 0x1b9d34fcL, 0x86f919d1L,
#endif
/* dss_p length = 768*/
0xea08e293L, 0xf668cdd0L, 0x06db8b2aL, 0xadb27c71L,
0x6721943dL, 0xbc4454f5L, 0x3345f7caL, 0x0b901bf6L,
0xd3c4b475L, 0x7caabdb6L, 0xe9b4a45fL, 0x0c1a6e0eL,
0x9760b5c3L, 0x53af851aL, 0x497996b7L, 0xe951f162L,
0xd0206a54L, 0xdecb9dedL, 0x7d74fc81L, 0x2aee5e92L,
0x0eb50946L, 0x9bce3700L, 0xa7a3845aL, 0x8618157aL,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 800*/
0xac27b0a1L, 0xf623ec4eL, 0x2cb655e2L, 0x4b28288bL,
0xbbe6d74eL, 0xaecdfdf7L, 0xe2515758L, 0x1aee9074L,
0x4d5ee6edL, 0x529e01d9L, 0x0091f736L, 0xc7250212L,
0x966f60ceL, 0x5c4b851dL, 0x34df80deL, 0x06361c88L,
0x32cebb71L, 0x86da45cbL, 0x13e04d0eL, 0x544b7d7dL,
0x747f1272L, 0xfa3bd6a7L, 0x6b43cb86L, 0xd01266f5L,
0xa0cbfe7aL,
#endif
/* dss_p length = 832*/
0x84dded2dL, 0xdd8ff274L, 0x7928cd5fL, 0xa522bfc6L,
0x50f0e4e4L, 0x5842cddfL, 0x7c4dbb29L, 0x6946eef4L,
0xe48687f6L, 0xc1b661b5L, 0x575aadefL, 0x724f360fL,
0x591bcb29L, 0xf7bc9a4cL, 0xa348309eL, 0x94f30ff5L,
0x9dc6932fL, 0xc6d7992cL, 0xc2d712f6L, 0x8c0138aaL,
0x74f45dcaL, 0x4cf4fcfdL, 0x7837588aL, 0xd2e2097eL,
0x88696eacL, 0xec62e92fL,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 864*/
0x931e7c21L, 0x00f2553dL, 0x940fa860L, 0x7d20411eL,
0x52a3b168L, 0x166e69eeL, 0x1b23b9e6L, 0xef64d5e0L,
0x724c2850L, 0xea73c1feL, 0xe342da8cL, 0xd2561d7bL,
0x180f359bL, 0xca77d7f5L, 0x216206acL, 0x78bba977L,
0x5de25018L, 0xe2176061L, 0xfed14d42L, 0xd50f3929L,
0x2433c946L, 0x361b15f8L, 0x3ff0bf51L, 0x31573efaL,
0x53a07350L, 0x261bd1a4L, 0x9236de5bL,
#endif
/* dss_p length = 896*/
0x03648e21L, 0xe58c86d2L, 0x780a2274L, 0x49519ffcL,
0xbc963f99L, 0x5a7e9e60L, 0x23d4010aL, 0x48e954d1L,
0x979cfd6bL, 0x8af35202L, 0xfe8f5d87L, 0x1e0c3e3cL,
0xcc52e294L, 0x480ea8d6L, 0xd4cea898L, 0xd3415949L,
0xf41be325L, 0x6a9072d6L, 0x6f147a8bL, 0x66363e2bL,
0x4eea3748L, 0x03e4a590L, 0x9c320524L, 0x02afeb53L,
0x6792ca71L, 0xedf8d673L, 0x59c36448L, 0x883f7319L,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 928*/
0xa4e8c17dL, 0x8ff8ea08L, 0x73f52cb0L, 0xc027d7baL,
0x989db9c8L, 0xe3a1e5feL, 0x39d3f324L, 0x5ba8f142L,
0x3708e6cbL, 0xed9aa0b7L, 0xe314b6b3L, 0x6778f80aL,
0x71074d27L, 0xb9c26ee8L, 0xab70c6afL, 0xc44553beL,
0x34bb7926L, 0xe11d5191L, 0xcc3a67f1L, 0xd34d5354L,
0x08baa1acL, 0x068a32d4L, 0x415f7c3bL, 0xb549bce0L,
0x538f0ecfL, 0x22a3b5d0L, 0xe8371d47L, 0x69dd14c0L,
0xce91a02dL,
#endif
/* dss_p length = 960*/
0xf77e1ff3L, 0x5a28ae7aL, 0xe18743b1L, 0xb3ea2e04L,
0xa3e87394L, 0xc9bc4985L, 0x1e1c7b7dL, 0x55f8d99cL,
0x5704447bL, 0xbed1d758L, 0x2a5ee698L, 0xc2065c19L,
0x1f886d38L, 0x5f152ea4L, 0xd716ebfdL, 0xf9608a2aL,
0xc49383acL, 0x8f13b966L, 0x96824778L, 0x84cd4712L,
0xe567bb4eL, 0x0780644fL, 0x0b0a133dL, 0x06e8e42eL,
0x3131a4ccL, 0xfaf839d9L, 0x555012a3L, 0xb8a943b1L,
0x0fadb0ebL, 0xd427986fL,
#ifdef LENGTH_MULT_TO_32
/* dss_p length = 992*/
0x363fbcfdL, 0x18f0050aL, 0xcac978d8L, 0xf31e423aL,
0xd0c3198fL, 0x5d1bb319L, 0xc0b0917aL, 0x6b918d1bL,
0xa9d1ea69L, 0x534502ceL, 0x69922c80L, 0x7a284dadL,
0xd46dbb75L, 0x56120faaL, 0x8a0e6878L, 0x46ab63b4L,
0x5381aca0L, 0x3e70b90aL, 0xb63919c4L, 0xe751f778L,
0xb7265974L, 0x8679589fL, 0xc0b5eb04L, 0x2b32dffdL,
0xc6324b51L, 0x9501d8c6L, 0x20264f94L, 0x0d27253aL,
0x083807bbL, 0xa3eb2725L, 0x89b63c4eL,
#endif
/* dss_p length = 1024*/
0xecf7a141L, 0x867dc6d6L, 0x1cddefa3L, 0x6ca56c9dL,
0x68af2e2fL, 0x1d3e90e1L, 0x0c2ad75fL, 0x36c7844bL,
0xfd1a3420L, 0xf6e5b9eeL, 0xc8ed5fdeL, 0xd3530c90L,
0x80a46faaL, 0xa59d5bbdL, 0x32239e72L, 0xf33d8f59L,
0xeccd10ebL, 0x3e2a184eL, 0x564b4c07L, 0x32634c0aL,
0x8aebc535L, 0x2be2f982L, 0x9b87e475L, 0x4d08cca0L,
0x04843adfL, 0x7acdd528L, 0x55a0304dL, 0x829870aeL,
0x22986a7aL, 0x7a8615c0L, 0x654a7fc5L, 0xd0aa14adL
};
#endif
ord DSS_G_NUMBERS[DSS_LAST_INDEX] =
#ifdef ORD_16
{
/* dss_g length = 512*/
0x8b1a, 0xedfe, 0xef16, 0xdb26, 0xeae0, 0x1f1d, 0xaf3a, 0x3e30,
0x2bd6, 0x25ec, 0xa451, 0x6255, 0xbc75, 0x499c, 0x4071, 0x5da2,
0x1149, 0xc7fc, 0x1402, 0x9b69, 0xc168, 0xb0ea, 0xaf92, 0x6a33,
0xf45f, 0xd93a, 0x75a6, 0x263c, 0xb820, 0x7eb1, 0x5f5b, 0x4bd7,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 544*/
0x2772, 0xe0e6, 0xce97, 0x605b, 0x4aa8, 0x2586, 0x095a, 0xb83f,
0x8b01, 0xfe53, 0x9250, 0x74ef, 0x74d4, 0xd9fa, 0xb78b, 0xa714,
0x106f, 0x03a6, 0xb406, 0xc549, 0xc44d, 0xd559, 0x8100, 0xfef4,
0x34a4, 0x1f4c, 0x3c6b, 0x4ae0, 0xe770, 0x158b, 0x3f8d, 0xf73d,
0x0cc5, 0x61b7,
#endif
/* dss_g length = 576*/
0x3dde, 0x64fd, 0x2b69, 0x03c3, 0xad1d, 0x1751, 0x11dc, 0xfe67,
0x6379, 0x76de, 0xe333, 0x3b8f, 0x242f, 0x27d8, 0x5f33, 0x3597,
0xb98c, 0x11dc, 0x718c, 0xe3b5, 0xa3d4, 0x58f2, 0x71fa, 0x2675,
0x49f9, 0xf2c7, 0x510e, 0xa4e1, 0xeca4, 0x7c64, 0x243b, 0x78fc,
0x2ce2, 0x7017, 0x0095, 0x23b6,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 608*/
0xdad8, 0x1e27, 0x41f5, 0xd536, 0x528f, 0x7047, 0x028a, 0x56f5,
0xe55f, 0xe20d, 0x612c, 0x520f, 0xebfd, 0x8c86, 0x0924, 0x562a,
0x2185, 0xe5ac, 0xa113, 0x4b8c, 0x87da, 0xfa4c, 0x8788, 0x9d8d,
0x41c0, 0x9d25, 0x9c77, 0xff33, 0x6861, 0xd10a, 0xc734, 0x8454,
0xf803, 0x55ce, 0xfeac, 0x6580, 0x6cd2, 0x482b,
#endif
/* dss_g length = 640*/
0x4ff7, 0x2829, 0x8ab0, 0xa0bd, 0x7b1c, 0xf544, 0xe633, 0x6e7b,
0x9824, 0x494a, 0xfb7f, 0xc8ad, 0x45b6, 0x956e, 0x0574, 0x5b0d,
0xd40c, 0xf807, 0x7372, 0x56fd, 0xdd12, 0x8960, 0x255c, 0x019e,
0xfc39, 0x06b3, 0x9f8e, 0x4cd9, 0xe714, 0x77f6, 0x76f7, 0xb573,
0x010e, 0x9b52, 0x04d2, 0xe269, 0xd4bb, 0xbdec, 0x089d, 0x7f88,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 672*/
0x3d36, 0xb22d, 0x2144, 0xfda0, 0x1d4a, 0xc144, 0xef8f, 0x70e8,
0xfd0f, 0xcbf9, 0x7433, 0xbf29, 0x1657, 0x757b, 0x011d, 0x5c7e,
0xa0d3, 0xec5a, 0xd45d, 0xacd6, 0x136a, 0x9454, 0x61fd, 0xc3f6,
0x3758, 0x5c89, 0xe4df, 0xd3c9, 0x6f99, 0xa113, 0x0992, 0x16b2,
0xf92f, 0xfb67, 0x3f34, 0x57e6, 0xb224, 0xdfd1, 0x43c4, 0x639a,
0xccf5, 0x86c4,
#endif
/* dss_g length = 704*/
0x1621, 0x8313, 0x216e, 0xcb3b, 0xde00, 0xa11b, 0xf27f, 0xd5d4,
0x6d2e, 0xc870, 0x1c47, 0x2e21, 0x780b, 0x1db6, 0x8adf, 0xe5c6,
0x837d, 0x7dba, 0x9c8c, 0x28b5, 0xd309, 0xf3fa, 0x6c65, 0xe37f,
0x6a1e, 0x2601, 0xbb92, 0x56aa, 0x9c0e, 0x9db1, 0xb782, 0x642b,
0x6cc9, 0xb9fb, 0x6a3c, 0x97b9, 0xf1a8, 0xd8a2, 0xfe6b, 0xcb93,
0x59ee, 0x32a4, 0x0aa1, 0x58ad,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 736*/
0x648c, 0xa15c, 0x27b2, 0x8137, 0xefb3, 0x0e81, 0x258e, 0xabe0,
0x9f2f, 0x6c67, 0xbed6, 0xd201, 0x3647, 0xbe9a, 0x0091, 0xba9a,
0x4df1, 0xdc8c, 0x5b15, 0x5a37, 0xb5b1, 0x50f8, 0xdfe6, 0x081b,
0x48d7, 0xd40b, 0x7c51, 0x0417, 0x97c7, 0x2565, 0xf960, 0x89b2,
0xa1f0, 0x7aac, 0xed6f, 0x20fe, 0x1d98, 0x0eee, 0x48b8, 0xb062,
0x70e7, 0xa3f3, 0xbe3f, 0x9183, 0x76ae, 0x6cbc,
#endif
/* dss_g length = 768*/
0x6216, 0x4b90, 0xc254, 0x7ab6, 0x7a04, 0xf90f, 0x42dd, 0x58c7,
0xd015, 0x904d, 0xfbf7, 0x624a, 0x5010, 0x627f, 0x696c, 0x1a32,
0xe0bc, 0xcdfd, 0xe32f, 0xb081, 0x1377, 0x1913, 0x5f96, 0x86c6,
0x864a, 0x8429, 0x4bb9, 0xd0c6, 0x3361, 0xbc7d, 0xbd8d, 0xa3b2,
0x47d5, 0x5086, 0xed0b, 0x3bb6, 0xdba6, 0x6f2c, 0x707a, 0x434b,
0xd4cc, 0x7b10, 0x8ef0, 0x3466, 0x4737, 0x8f27, 0x3399, 0x3716,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 800*/
0x99a7, 0xa90c, 0xdf8e, 0xba50, 0x83b5, 0x7ea0, 0x1d8a, 0xe5bb,
0x34c9, 0x8c4d, 0xb151, 0x3aba, 0xee2f, 0x76c8, 0xeebf, 0x3db9,
0xc1e0, 0x2b9a, 0x774f, 0xb476, 0x9b93, 0x53b5, 0xc008, 0xed2c,
0x0ad4, 0x8af4, 0xc0e6, 0x0e98, 0x2d7b, 0xdb37, 0x7b59, 0x8a31,
0x0667, 0x1225, 0xb882, 0x0355, 0x58ba, 0xf079, 0x80d7, 0x8033,
0x54bc, 0xf9cd, 0x461e, 0xc70a, 0x9170, 0x1dba, 0xc447, 0xd3e5,
0xaf18, 0x04c4,
#endif
/* dss_g length = 832*/
0xd1b5, 0x3d20, 0xfbdb, 0xa0b6, 0x0505, 0x4e88, 0xa781, 0x7c65,
0xd381, 0x5b6e, 0xfd1e, 0xbb71, 0xe085, 0x855d, 0x6d0b, 0x650a,
0xa248, 0x82d0, 0xd4dd, 0x7ea0, 0x16d1, 0x6937, 0x2cc2, 0x2dec,
0x5e07, 0x97b4, 0x0c5a, 0xcf21, 0x0299, 0x9b96, 0x4acf, 0xc732,
0xfbcf, 0xeefb, 0x0032, 0x40bb, 0xc86e, 0xeacb, 0xae2b, 0x8adb,
0x39aa, 0xbb47, 0xaf3a, 0xfd36, 0xf859, 0x97fc, 0x5535, 0x0d3d,
0x627a, 0x3f62, 0x1f90, 0x5490,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 864*/
0xbf83, 0x8b52, 0xc2b1, 0x0808, 0x4a3e, 0x6ccb, 0x8aa8, 0xcfdd,
0xb046, 0x4948, 0xcdf4, 0x9881, 0x13d8, 0x85b0, 0xa22a, 0x3786,
0xe9db, 0xcb8a, 0x89ad, 0x5e27, 0xd925, 0x1fcb, 0x3855, 0x4afd,
0x7f67, 0x83be, 0xb092, 0xe061, 0x6703, 0xf21f, 0x403e, 0x4c6a,
0xa8bd, 0x536a, 0x89b6, 0xb25e, 0xe165, 0xd259, 0xb765, 0xd7f3,
0xc474, 0xd8bc, 0x617d, 0x1a0a, 0xa054, 0x8c28, 0x9fb0, 0x9595,
0x6f2d, 0x6254, 0xe1c2, 0xb450, 0xef81, 0x277f,
#endif
/* dss_g length = 896*/
0x7490, 0x2aea, 0xd005, 0xa3cc, 0x9211, 0x235a, 0x7b6d, 0xacec,
0xfca5, 0x5407, 0x8515, 0x5bc1, 0x8b2a, 0x9388, 0x8ff9, 0xed56,
0xf4e9, 0xf31e, 0x7e05, 0x172a, 0x6e2a, 0x8165, 0x7a24, 0x975b,
0x1f6e, 0xd4d1, 0x8232, 0xd6ff, 0x2363, 0x4072, 0xa1f1, 0xd18b,
0xe574, 0xb032, 0xc330, 0x81b6, 0x6033, 0x07d5, 0x5107, 0xb7cc,
0x2c10, 0xbd8e, 0xc6a3, 0xe731, 0xfcd6, 0xe567, 0x3440, 0xbcde,
0x1976, 0xdbb3, 0xd15a, 0x4e39, 0xc282, 0x4b0b, 0x82b3, 0x286b,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 928*/
0x9f66, 0xd0e5, 0xd7d2, 0xe875, 0x0707, 0x2dca, 0xa5a2, 0x266d,
0x80c2, 0x6d20, 0x69b3, 0x759c, 0x497f, 0x74b4, 0x0f56, 0x4b63,
0xa294, 0x4995, 0x3eda, 0xf5c4, 0x7951, 0x3a3d, 0x22e9, 0x617f,
0x1906, 0xd45d, 0x047f, 0x2726, 0x27be, 0x660e, 0xc1d3, 0xa588,
0xceb2, 0xe300, 0xca06, 0x8620, 0x1110, 0x76ae, 0xf7b8, 0xe368,
0x89a7, 0x2ded, 0x2756, 0x3ed6, 0x5449, 0x4bd8, 0xb73d, 0xb406,
0x25ec, 0x32f7, 0x989c, 0x6623, 0x6b1f, 0xf7f0, 0x4807, 0x0954,
0x51e6, 0x97d0,
#endif
/* dss_g length = 960*/
0x4118, 0xe87c, 0x809a, 0x1287, 0x2a0f, 0x51d6, 0x7fc8, 0xdad8,
0x8dc6, 0xddce, 0xd27c, 0x898a, 0x96a9, 0xaee1, 0xe44c, 0xd322,
0x9d58, 0x3a34, 0xcebd, 0x322a, 0x5b48, 0x9c21, 0x6d04, 0x2d77,
0x41f1, 0x5123, 0xaa5f, 0x2192, 0x8175, 0x5cac, 0xf547, 0xdc08,
0xb0d9, 0x4f11, 0x85c9, 0xb5bf, 0x7147, 0x9fbf, 0x3c20, 0x7f7a,
0xdd8a, 0xa163, 0x0ae4, 0xfcb2, 0x8251, 0x8162, 0xb96e, 0x84f9,
0xd652, 0x94ba, 0xbb90, 0x9559, 0xac51, 0x6418, 0xdb54, 0x4739,
0x3ec0, 0x9b7c, 0xae96, 0x3e14,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 992*/
0x4eff, 0x399a, 0x5da9, 0x1e5a, 0x9040, 0x4bad, 0xc85d, 0x5b9a,
0x825b, 0x5464, 0x7538, 0xe2ea, 0xb957, 0x5def, 0xbfa6, 0x4916,
0x89be, 0x93fe, 0xe5da, 0x919f, 0x791c, 0xe7a8, 0xef86, 0xc186,
0xbf63, 0xa881, 0x1e38, 0x9abe, 0x8b58, 0x70b4, 0x9dfd, 0x0719,
0x85e5, 0xc60a, 0xab36, 0xe07d, 0x0c49, 0xd6fe, 0xfdb4, 0x6619,
0xe55d, 0x997e, 0x5f38, 0x824f, 0x47ff, 0xf800, 0xb137, 0x839d,
0x2dae, 0xe0db, 0x2a74, 0x2f58, 0x6fb3, 0x1bab, 0x62ed, 0x0e02,
0xbef2, 0xd7f1, 0xe566, 0xa9ae, 0xbc35, 0x6357,
#endif
/* dss_g length = 1024*/
0x914d, 0x76b2, 0xfee4, 0x9cf7, 0xa136, 0x07a1, 0x3808, 0x1857,
0x8f96, 0x870c, 0x1f3c, 0x59f2, 0x6f01, 0x4d4d, 0x580e, 0xafc6,
0x99af, 0xff1b, 0xc019, 0x6c1f, 0xe449, 0x1698, 0x4787, 0x0aa2,
0x6e68, 0x768d, 0x5ff0, 0x27dc, 0xca9e, 0x630f, 0x01ae, 0x9981,
0x688d, 0xf278, 0x7f3d, 0x17ad, 0x48aa, 0x65d6, 0x181f, 0x1802,
0x647c, 0x9ef5, 0x7081, 0x5843, 0x1f0d, 0x9364, 0xebe9, 0x6330,
0x033a, 0x5d2a, 0xb68a, 0x5639, 0xfa7c, 0xd77e, 0x4bdc, 0x4a62,
0x5c6d, 0xfed5, 0xa8aa, 0x5eff, 0x1138, 0xae4a, 0xe993, 0x3a73
};
#else
{
/* dss_g length = 512*/
0xedfe8b1aL, 0xdb26ef16L, 0x1f1deae0L, 0x3e30af3aL,
0x25ec2bd6L, 0x6255a451L, 0x499cbc75L, 0x5da24071L,
0xc7fc1149L, 0x9b691402L, 0xb0eac168L, 0x6a33af92L,
0xd93af45fL, 0x263c75a6L, 0x7eb1b820L, 0x4bd75f5bL,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 544*/
0xe0e62772L, 0x605bce97L, 0x25864aa8L, 0xb83f095aL,
0xfe538b01L, 0x74ef9250L, 0xd9fa74d4L, 0xa714b78bL,
0x03a6106fL, 0xc549b406L, 0xd559c44dL, 0xfef48100L,
0x1f4c34a4L, 0x4ae03c6bL, 0x158be770L, 0xf73d3f8dL,
0x61b70cc5L,
#endif
/* dss_g length = 576*/
0x64fd3ddeL, 0x03c32b69L, 0x1751ad1dL, 0xfe6711dcL,
0x76de6379L, 0x3b8fe333L, 0x27d8242fL, 0x35975f33L,
0x11dcb98cL, 0xe3b5718cL, 0x58f2a3d4L, 0x267571faL,
0xf2c749f9L, 0xa4e1510eL, 0x7c64eca4L, 0x78fc243bL,
0x70172ce2L, 0x23b60095L,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 608*/
0x1e27dad8L, 0xd53641f5L, 0x7047528fL, 0x56f5028aL,
0xe20de55fL, 0x520f612cL, 0x8c86ebfdL, 0x562a0924L,
0xe5ac2185L, 0x4b8ca113L, 0xfa4c87daL, 0x9d8d8788L,
0x9d2541c0L, 0xff339c77L, 0xd10a6861L, 0x8454c734L,
0x55cef803L, 0x6580feacL, 0x482b6cd2L,
#endif
/* dss_g length = 640*/
0x28294ff7L, 0xa0bd8ab0L, 0xf5447b1cL, 0x6e7be633L,
0x494a9824L, 0xc8adfb7fL, 0x956e45b6L, 0x5b0d0574L,
0xf807d40cL, 0x56fd7372L, 0x8960dd12L, 0x019e255cL,
0x06b3fc39L, 0x4cd99f8eL, 0x77f6e714L, 0xb57376f7L,
0x9b52010eL, 0xe26904d2L, 0xbdecd4bbL, 0x7f88089dL,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 672*/
0xb22d3d36L, 0xfda02144L, 0xc1441d4aL, 0x70e8ef8fL,
0xcbf9fd0fL, 0xbf297433L, 0x757b1657L, 0x5c7e011dL,
0xec5aa0d3L, 0xacd6d45dL, 0x9454136aL, 0xc3f661fdL,
0x5c893758L, 0xd3c9e4dfL, 0xa1136f99L, 0x16b20992L,
0xfb67f92fL, 0x57e63f34L, 0xdfd1b224L, 0x639a43c4L,
0x86c4ccf5L,
#endif
/* dss_g length = 704*/
0x83131621L, 0xcb3b216eL, 0xa11bde00L, 0xd5d4f27fL,
0xc8706d2eL, 0x2e211c47L, 0x1db6780bL, 0xe5c68adfL,
0x7dba837dL, 0x28b59c8cL, 0xf3fad309L, 0xe37f6c65L,
0x26016a1eL, 0x56aabb92L, 0x9db19c0eL, 0x642bb782L,
0xb9fb6cc9L, 0x97b96a3cL, 0xd8a2f1a8L, 0xcb93fe6bL,
0x32a459eeL, 0x58ad0aa1L,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 736*/
0xa15c648cL, 0x813727b2L, 0x0e81efb3L, 0xabe0258eL,
0x6c679f2fL, 0xd201bed6L, 0xbe9a3647L, 0xba9a0091L,
0xdc8c4df1L, 0x5a375b15L, 0x50f8b5b1L, 0x081bdfe6L,
0xd40b48d7L, 0x04177c51L, 0x256597c7L, 0x89b2f960L,
0x7aaca1f0L, 0x20feed6fL, 0x0eee1d98L, 0xb06248b8L,
0xa3f370e7L, 0x9183be3fL, 0x6cbc76aeL,
#endif
/* dss_g length = 768*/
0x4b906216L, 0x7ab6c254L, 0xf90f7a04L, 0x58c742ddL,
0x904dd015L, 0x624afbf7L, 0x627f5010L, 0x1a32696cL,
0xcdfde0bcL, 0xb081e32fL, 0x19131377L, 0x86c65f96L,
0x8429864aL, 0xd0c64bb9L, 0xbc7d3361L, 0xa3b2bd8dL,
0x508647d5L, 0x3bb6ed0bL, 0x6f2cdba6L, 0x434b707aL,
0x7b10d4ccL, 0x34668ef0L, 0x8f274737L, 0x37163399L,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 800*/
0xa90c99a7L, 0xba50df8eL, 0x7ea083b5L, 0xe5bb1d8aL,
0x8c4d34c9L, 0x3abab151L, 0x76c8ee2fL, 0x3db9eebfL,
0x2b9ac1e0L, 0xb476774fL, 0x53b59b93L, 0xed2cc008L,
0x8af40ad4L, 0x0e98c0e6L, 0xdb372d7bL, 0x8a317b59L,
0x12250667L, 0x0355b882L, 0xf07958baL, 0x803380d7L,
0xf9cd54bcL, 0xc70a461eL, 0x1dba9170L, 0xd3e5c447L,
0x04c4af18L,
#endif
/* dss_g length = 832*/
0x3d20d1b5L, 0xa0b6fbdbL, 0x4e880505L, 0x7c65a781L,
0x5b6ed381L, 0xbb71fd1eL, 0x855de085L, 0x650a6d0bL,
0x82d0a248L, 0x7ea0d4ddL, 0x693716d1L, 0x2dec2cc2L,
0x97b45e07L, 0xcf210c5aL, 0x9b960299L, 0xc7324acfL,
0xeefbfbcfL, 0x40bb0032L, 0xeacbc86eL, 0x8adbae2bL,
0xbb4739aaL, 0xfd36af3aL, 0x97fcf859L, 0x0d3d5535L,
0x3f62627aL, 0x54901f90L,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 864*/
0x8b52bf83L, 0x0808c2b1L, 0x6ccb4a3eL, 0xcfdd8aa8L,
0x4948b046L, 0x9881cdf4L, 0x85b013d8L, 0x3786a22aL,
0xcb8ae9dbL, 0x5e2789adL, 0x1fcbd925L, 0x4afd3855L,
0x83be7f67L, 0xe061b092L, 0xf21f6703L, 0x4c6a403eL,
0x536aa8bdL, 0xb25e89b6L, 0xd259e165L, 0xd7f3b765L,
0xd8bcc474L, 0x1a0a617dL, 0x8c28a054L, 0x95959fb0L,
0x62546f2dL, 0xb450e1c2L, 0x277fef81L,
#endif
/* dss_g length = 896*/
0x2aea7490L, 0xa3ccd005L, 0x235a9211L, 0xacec7b6dL,
0x5407fca5L, 0x5bc18515L, 0x93888b2aL, 0xed568ff9L,
0xf31ef4e9L, 0x172a7e05L, 0x81656e2aL, 0x975b7a24L,
0xd4d11f6eL, 0xd6ff8232L, 0x40722363L, 0xd18ba1f1L,
0xb032e574L, 0x81b6c330L, 0x07d56033L, 0xb7cc5107L,
0xbd8e2c10L, 0xe731c6a3L, 0xe567fcd6L, 0xbcde3440L,
0xdbb31976L, 0x4e39d15aL, 0x4b0bc282L, 0x286b82b3L,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 928*/
0xd0e59f66L, 0xe875d7d2L, 0x2dca0707L, 0x266da5a2L,
0x6d2080c2L, 0x759c69b3L, 0x74b4497fL, 0x4b630f56L,
0x4995a294L, 0xf5c43edaL, 0x3a3d7951L, 0x617f22e9L,
0xd45d1906L, 0x2726047fL, 0x660e27beL, 0xa588c1d3L,
0xe300ceb2L, 0x8620ca06L, 0x76ae1110L, 0xe368f7b8L,
0x2ded89a7L, 0x3ed62756L, 0x4bd85449L, 0xb406b73dL,
0x32f725ecL, 0x6623989cL, 0xf7f06b1fL, 0x09544807L,
0x97d051e6L,
#endif
/* dss_g length = 960*/
0xe87c4118L, 0x1287809aL, 0x51d62a0fL, 0xdad87fc8L,
0xddce8dc6L, 0x898ad27cL, 0xaee196a9L, 0xd322e44cL,
0x3a349d58L, 0x322acebdL, 0x9c215b48L, 0x2d776d04L,
0x512341f1L, 0x2192aa5fL, 0x5cac8175L, 0xdc08f547L,
0x4f11b0d9L, 0xb5bf85c9L, 0x9fbf7147L, 0x7f7a3c20L,
0xa163dd8aL, 0xfcb20ae4L, 0x81628251L, 0x84f9b96eL,
0x94bad652L, 0x9559bb90L, 0x6418ac51L, 0x4739db54L,
0x9b7c3ec0L, 0x3e14ae96L,
#ifdef LENGTH_MULT_TO_32
/* dss_g length = 992*/
0x399a4effL, 0x1e5a5da9L, 0x4bad9040L, 0x5b9ac85dL,
0x5464825bL, 0xe2ea7538L, 0x5defb957L, 0x4916bfa6L,
0x93fe89beL, 0x919fe5daL, 0xe7a8791cL, 0xc186ef86L,
0xa881bf63L, 0x9abe1e38L, 0x70b48b58L, 0x07199dfdL,
0xc60a85e5L, 0xe07dab36L, 0xd6fe0c49L, 0x6619fdb4L,
0x997ee55dL, 0x824f5f38L, 0xf80047ffL, 0x839db137L,
0xe0db2daeL, 0x2f582a74L, 0x1bab6fb3L, 0x0e0262edL,
0xd7f1bef2L, 0xa9aee566L, 0x6357bc35L,
#endif
/* dss_g length = 1024*/
0x76b2914dL, 0x9cf7fee4L, 0x07a1a136L, 0x18573808L,
0x870c8f96L, 0x59f21f3cL, 0x4d4d6f01L, 0xafc6580eL,
0xff1b99afL, 0x6c1fc019L, 0x1698e449L, 0x0aa24787L,
0x768d6e68L, 0x27dc5ff0L, 0x630fca9eL, 0x998101aeL,
0xf278688dL, 0x17ad7f3dL, 0x65d648aaL, 0x1802181fL,
0x9ef5647cL, 0x58437081L, 0x93641f0dL, 0x6330ebe9L,
0x5d2a033aL, 0x5639b68aL, 0xd77efa7cL, 0x4a624bdcL,
0xfed55c6dL, 0x5effa8aaL, 0xae4a1138L, 0x3a73e993L
};
#endif
#endif /*INITIALIZ_PQG*/
#endif /*DSSNUMBER_H*/

7
lib/bind/cylink/funcs.h
View file

@ -1,7 +0,0 @@
void RShiftL_big(ord *X, u_int32_t len_X, u_int32_t n_bit);
void LShiftL_big(ord *X, u_int32_t len_X, u_int32_t n_bit);
int RShiftMostBit(ord *a, u_int32_t len);
void ByteLong(uchar *X, u_int32_t X_bytes, u_int32_t *Y);
void ByteOrd(uchar *X, u_int32_t X_bytes, ord *Y);
void OrdByte(ord *X, u_int32_t X_bytes, uchar *Y);
void LongByte(u_int32_t *X, u_int32_t X_bytes, uchar *Y);

158
lib/bind/cylink/kludge.h
View file

@ -1,158 +0,0 @@
#ifndef KLUDGE_H
#define KLUDGE_H
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* Kludges for not-quite-ANSI systems.
* This should always be the last file included, because it may
* mess up some system header files.
*/
/*
* Some compilers complain about #if FOO if FOO isn't defined,
* so do the ANSI-mandated thing explicitly...
*/
#ifndef ASSERT_NEEDS_STDIO
#define ASSERT_NEEDS_STDIO 0
#endif
#ifndef ASSERT_NEEDS_STDLIB
#define ASSERT_NEEDS_STDLIB 0
#endif
#ifndef NO_STDLIB_H
#define NO_STDLIB_H 0
#endif
/* SunOS 4.1.x <assert.h> needs "stderr" defined, and "exit" declared... */
#ifdef assert
#if ASSERT_NEEDS_STDIO
#include <stdio.h>
#endif
#if ASSERT_NEEDS_STDLIB
#if !NO_STDLIB_H
#include <stdlib.h>
#endif
#endif
#endif
#ifndef NO_MEMMOVE
#define NO_MEMMOVE 0
#endif
#if NO_MEMMOVE /* memove() not in libraries */
#define memmove(dest,src,len) bcopy(src,dest,len)
#endif
#ifndef NO_MEMCPY
#define NO_MEMCPY 0
#endif
#if NO_MEMCPY /* memcpy() not in libraries */
#define memcpy(dest,src,len) bcopy(src,dest,len)
#endif
#ifndef MEM_PROTOS_BROKEN
#define MEM_PROTOS_BROKEN 0
#endif
#if MEM_PROTOS_BROKEN
#define memcpy(d,s,l) memcpy((void *)(d), (void const *)(s), l)
#define memmove(d,s,l) memmove((void *)(d), (void const *)(s), l)
#define memcmp(d,s,l) memcmp((void const *)(d), (void const *)(s), l)
#define memset(d,v,l) memset((void *)(d), v, l)
#endif
/*
* If there are no prototypes for the stdio functions, use these to
* reduce compiler warnings. Uses EOF as a giveaway to indicate
* that <stdio.h> was #included.
*/
#ifndef NO_STDIO_PROTOS
#define NO_STDIO_PROTOS 0
#endif
#if NO_STDIO_PROTOS /* Missing prototypes for "simple" functions */
#ifdef EOF
#ifdef __cplusplus
extern "C" {
#endif
int (puts)(char const *);
int (fputs)(char const *, FILE *);
int (fflush)(FILE *);
int (printf)(char const *, ...);
int (fprintf)(FILE *, char const *, ...);
/* If we have a sufficiently old-fashioned stdio, it probably uses these... */
int (_flsbuf)(int, FILE *);
int (_filbuf)(FILE *);
#ifdef __cplusplus
}
#endif
#endif /* EOF */
#endif /* NO_STDIO_PROTOS */
/*
* Borland C seems to think that it's a bad idea to decleare a
* structure tag and not declare the contents. I happen to think
* it's a *good* idea to use such "opaque" structures wherever
* possible. So shut up.
*/
#ifdef __BORLANDC__
#pragma warn -stu
#ifndef MSDOS
#define MSDOS 1
#endif
#endif
/* Turn off warning about negation of unsigned values */
#ifdef _MSC_VER
#pragma warning(disable:4146)
#endif
/* Cope with people forgetting to define the OS, if possible... */
#ifndef MSDOS
#ifdef __MSDOS
#define MSDOS 1
#endif
#endif
#ifndef MSDOS
#ifdef __MSDOS__
#define MSDOS 1
#endif
#endif
#endif /* KLUDGE_H */

186
lib/bind/cylink/lbn.h
View file

@ -1,186 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn.h - Low-level bignum header.
* Defines various word sizes and useful macros.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*/
#ifndef LBN_H
#define LBN_H
#ifndef HAVE_CONFIG_H
#define HAVE_CONFIG_H 0
#endif
#if HAVE_CONFIG_H
#include "config.h"
#endif
/*
* Some compilers complain about #if FOO if FOO isn't defined,
* so do the ANSI-mandated thing explicitly...
*/
#ifndef NO_LIMITS_H
#define NO_LIMITS_H 0
#endif
/* Make sure we have 8-bit bytes */
#if !NO_LIMITS_H
#include <limits.h>
#if UCHAR_MAX != 0xff || CHAR_BIT != 8
#error The bignum library requires 8-bit unsigned characters.
#endif
#endif /* !NO_LIMITS_H */
#ifdef BNINCLUDE /* If this is defined as, say, foo.h */
#define STR(x) #x /* STR(BNINCLUDE) -> "BNINCLUDE" */
#define XSTR(x) STR(x) /* XSTR(BNINCLUDE) -> STR(foo.h) -> "foo.h" */
#include XSTR(BNINCLUDE) /* #include "foo.h" */
#undef XSTR
#undef STR
#endif
/* Figure out the endianness */
/* Error if more than one is defined */
#if BN_BIG_ENDIAN && BN_LITTLE_ENDIAN
#error Only one of BN_BIG_ENDIAN or BN_LITTLE_ENDIAN may be defined
#endif
/*
* If no preference is stated, little-endian C code is slightly more
* efficient, so prefer that. (The endianness here does NOT have to
* match the machine's native byte sex; the library's C code will work
* either way. The flexibility is allowed for assembly routines
* that do care.
*/
#if !defined(BN_BIG_ENDIAN) && !defined(BN_LITTLE_ENDIAN)
#define BN_LITTLE_ENDIAN 1
#endif /* !BN_BIG_ENDIAN && !BN_LITTLE_ENDIAN */
/* Macros to choose between big and little endian */
#if BN_BIG_ENDIAN
#define BIG(b) b
#define LITTLE(l) /*nothing*/
#define BIGLITTLE(b,l) b
#elif BN_LITTLE_ENDIAN
#define BIG(b) /*nothing*/
#define LITTLE(l) l
#define BIGLITTLE(b,l) l
#else
#error One of BN_BIG_ENDIAN or BN_LITTLE_ENDIAN must be defined as 1
#endif
/*
* Find a 16-bit unsigned type.
* Unsigned short is preferred over unsigned int to make the type chosen
* by this file more stable on platforms (such as many 68000 compilers)
* which support both 16- and 32-bit ints.
*/
#ifndef BNWORD16
#ifndef USHRT_MAX /* No <limits.h> available - guess */
typedef unsigned short bnword16;
#define BNWORD16 bnword16
#elif USHRT_MAX == 0xffff
typedef unsigned short bnword16;
#define BNWORD16 bnword16
#elif UINT_MAX == 0xffff
typedef unsigned bnword16;
#define BNWORD16 bnword16
#endif
#endif /* BNWORD16 */
/*
* Find a 32-bit unsigned type.
* Unsigned long is preferred over unsigned int to make the type chosen
* by this file more stable on platforms (such as many 68000 compilers)
* which support both 16- and 32-bit ints.
*/
#ifndef BNWORD32
#ifndef ULONG_MAX /* No <limits.h> available - guess */
typedef unsigned long bnword32;
#define BNWORD32 bnword32
#elif ULONG_MAX == 0xfffffffful
typedef unsigned long bnword32;
#define BNWORD32 bnword32
#elif UINT_MAX == 0xffffffff
typedef unsigned bnword32;
#define BNWORD32 bnword32
#elif USHRT_MAX == 0xffffffff
typedef unsigned short bnword32;
#define BNWORD32 bnword32
#endif
#endif /* BNWORD16 */
/*
* Find a 64-bit unsigned type.
* The conditions here are more complicated to avoid using numbers that
* will choke lesser preprocessors (like 0xffffffffffffffff) unless
* we're reasonably certain that they'll be acceptable.
*/
#if !defined(BNWORD64) && ULONG_MAX > 0xfffffffful
#if ULONG_MAX == 0xffffffffffffffff
typedef unsigned long bnword64;
#define BNWORD64 bnword64
#endif
#endif
#if 0
/*
* I would test the value of unsigned long long, but some *preprocessors*
* don't constants that long even if the compiler can accept them, so it
* doesn't work reliably. So cross our fingers and hope that it's a 64-bit
* type.
*
* GCC uses ULONG_LONG_MAX. Solaris uses ULLONG_MAX. IRIX uses ULONGLONG_MAX.
* Are there any other names for this?
*/
#if !defined(BNWORD64) && \
(defined(ULONG_LONG_MAX) || defined (ULLONG_MAX) || defined(ULONGLONG_MAX))
typedef unsigned long long bnword64;
#define BNWORD64 bnword64
#endif
#endif
/* We don't even try to find a 128-bit type at the moment */
#endif /* !LBN_H */

65
lib/bind/cylink/lbn00.c
View file

@ -1,65 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn00.c - auto-size-detecting lbn??.c file.
*
* Written in 1995 by Colin Plumb.
*/
#include "port_before.h"
#include "bnsize00.h"
#if BNSIZE64
/* Include all of the C source file by reference */
#include "lbn64.c"
#elif BNSIZE32
/* Include all of the C source file by reference */
#include "lbn32.c"
#else /* BNSIZE16 */
/* Include all of the C source file by reference */
#include "lbn16.c"
#endif

3644
lib/bind/cylink/lbn16.c
View file

File diff suppressed because it is too large Load diff

181
lib/bind/cylink/lbn16.h
View file

@ -1,181 +0,0 @@
#ifndef LBN16_H
#define LBN16_H
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
#include "lbn.h"
#ifndef BNWORD16
#error 16-bit bignum library requires a 16-bit data type
#endif
#ifndef lbnCopy_16
void lbnCopy_16(BNWORD16 *dest, BNWORD16 const *src, unsigned len);
#endif
#ifndef lbnZero_16
void lbnZero_16(BNWORD16 *num, unsigned len);
#endif
#ifndef lbnNeg_16
void lbnNeg_16(BNWORD16 *num, unsigned len);
#endif
#ifndef lbnAdd1_16
BNWORD16 lbnAdd1_16(BNWORD16 *num, unsigned len, BNWORD16 carry);
#endif
#ifndef lbnSub1_16
BNWORD16 lbnSub1_16(BNWORD16 *num, unsigned len, BNWORD16 borrow);
#endif
#ifndef lbnAddN_16
BNWORD16 lbnAddN_16(BNWORD16 *num1, BNWORD16 const *num2, unsigned len);
#endif
#ifndef lbnSubN_16
BNWORD16 lbnSubN_16(BNWORD16 *num1, BNWORD16 const *num2, unsigned len);
#endif
#ifndef lbnCmp_16
int lbnCmp_16(BNWORD16 const *num1, BNWORD16 const *num2, unsigned len);
#endif
#ifndef lbnMulN1_16
void lbnMulN1_16(BNWORD16 *out, BNWORD16 const *in, unsigned len, BNWORD16 k);
#endif
#ifndef lbnMulAdd1_16
BNWORD16
lbnMulAdd1_16(BNWORD16 *out, BNWORD16 const *in, unsigned len, BNWORD16 k);
#endif
#ifndef lbnMulSub1_16
BNWORD16 lbnMulSub1_16(BNWORD16 *out, BNWORD16 const *in, unsigned len, BNWORD16 k);
#endif
#ifndef lbnLshift_16
BNWORD16 lbnLshift_16(BNWORD16 *num, unsigned len, unsigned shift);
#endif
#ifndef lbnDouble_16
BNWORD16 lbnDouble_16(BNWORD16 *num, unsigned len);
#endif
#ifndef lbnRshift_16
BNWORD16 lbnRshift_16(BNWORD16 *num, unsigned len, unsigned shift);
#endif
#ifndef lbnMul_16
void lbnMul_16(BNWORD16 *prod, BNWORD16 const *num1, unsigned len1,
BNWORD16 const *num2, unsigned len2);
#endif
#ifndef lbnSquare_16
void lbnSquare_16(BNWORD16 *prod, BNWORD16 const *num, unsigned len);
#endif
#ifndef lbnNorm_16
unsigned lbnNorm_16(BNWORD16 const *num, unsigned len);
#endif
#ifndef lbnBits_16
unsigned lbnBits_16(BNWORD16 const *num, unsigned len);
#endif
#ifndef lbnExtractBigBytes_16
void lbnExtractBigBytes_16(BNWORD16 const *bn, unsigned char *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnInsertBigytes_16
void lbnInsertBigBytes_16(BNWORD16 *n, unsigned char const *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnExtractLittleBytes_16
void lbnExtractLittleBytes_16(BNWORD16 const *bn, unsigned char *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnInsertLittleBytes_16
void lbnInsertLittleBytes_16(BNWORD16 *n, unsigned char const *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnDiv21_16
BNWORD16 lbnDiv21_16(BNWORD16 *q, BNWORD16 nh, BNWORD16 nl, BNWORD16 d);
#endif
#ifndef lbnDiv1_16
BNWORD16 lbnDiv1_16(BNWORD16 *q, BNWORD16 *rem,
BNWORD16 const *n, unsigned len, BNWORD16 d);
#endif
#ifndef lbnModQ_16
unsigned lbnModQ_16(BNWORD16 const *n, unsigned len, unsigned d);
#endif
#ifndef lbnDiv_16
BNWORD16
lbnDiv_16(BNWORD16 *q, BNWORD16 *n, unsigned nlen, BNWORD16 *d, unsigned dlen);
#endif
#ifndef lbnMontInv1_16
BNWORD16 lbnMontInv1_16(BNWORD16 const x);
#endif
#ifndef lbnMontReduce_16
void lbnMontReduce_16(BNWORD16 *n, BNWORD16 const *mod, unsigned const mlen,
BNWORD16 inv);
#endif
#ifndef lbnToMont_16
void lbnToMont_16(BNWORD16 *n, unsigned nlen, BNWORD16 *mod, unsigned mlen);
#endif
#ifndef lbnFromMont_16
void lbnFromMont_16(BNWORD16 *n, BNWORD16 *mod, unsigned len);
#endif
#ifndef lbnExpMod_16
int lbnExpMod_16(BNWORD16 *result, BNWORD16 const *n, unsigned nlen,
BNWORD16 const *exp, unsigned elen, BNWORD16 *mod, unsigned mlen);
#endif
#ifndef lbnDoubleExpMod_16
int lbnDoubleExpMod_16(BNWORD16 *result,
BNWORD16 const *n1, unsigned n1len, BNWORD16 const *e1, unsigned e1len,
BNWORD16 const *n2, unsigned n2len, BNWORD16 const *e2, unsigned e2len,
BNWORD16 *mod, unsigned mlen);
#endif
#ifndef lbnTwoExpMod_16
int lbnTwoExpMod_16(BNWORD16 *n, BNWORD16 const *exp, unsigned elen,
BNWORD16 *mod, unsigned mlen);
#endif
#ifndef lbnGcd_16
int lbnGcd_16(BNWORD16 *a, unsigned alen, BNWORD16 *b, unsigned blen);
#endif
#ifndef lbnInv_16
int lbnInv_16(BNWORD16 *a, unsigned alen, BNWORD16 const *mod, unsigned mlen);
#endif
#endif /* LBN16_H */

3643
lib/bind/cylink/lbn32.c
View file

File diff suppressed because it is too large Load diff

181
lib/bind/cylink/lbn32.h
View file

@ -1,181 +0,0 @@
#ifndef LBN32_H
#define LBN32_H
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
#include "lbn.h"
#ifndef BNWORD32
#error 32-bit bignum library requires a 32-bit data type
#endif
#ifndef lbnCopy_32
void lbnCopy_32(BNWORD32 *dest, BNWORD32 const *src, unsigned len);
#endif
#ifndef lbnZero_32
void lbnZero_32(BNWORD32 *num, unsigned len);
#endif
#ifndef lbnNeg_32
void lbnNeg_32(BNWORD32 *num, unsigned len);
#endif
#ifndef lbnAdd1_32
BNWORD32 lbnAdd1_32(BNWORD32 *num, unsigned len, BNWORD32 carry);
#endif
#ifndef lbnSub1_32
BNWORD32 lbnSub1_32(BNWORD32 *num, unsigned len, BNWORD32 borrow);
#endif
#ifndef lbnAddN_32
BNWORD32 lbnAddN_32(BNWORD32 *num1, BNWORD32 const *num2, unsigned len);
#endif
#ifndef lbnSubN_32
BNWORD32 lbnSubN_32(BNWORD32 *num1, BNWORD32 const *num2, unsigned len);
#endif
#ifndef lbnCmp_32
int lbnCmp_32(BNWORD32 const *num1, BNWORD32 const *num2, unsigned len);
#endif
#ifndef lbnMulN1_32
void lbnMulN1_32(BNWORD32 *out, BNWORD32 const *in, unsigned len, BNWORD32 k);
#endif
#ifndef lbnMulAdd1_32
BNWORD32
lbnMulAdd1_32(BNWORD32 *out, BNWORD32 const *in, unsigned len, BNWORD32 k);
#endif
#ifndef lbnMulSub1_32
BNWORD32 lbnMulSub1_32(BNWORD32 *out, BNWORD32 const *in, unsigned len, BNWORD32 k);
#endif
#ifndef lbnLshift_32
BNWORD32 lbnLshift_32(BNWORD32 *num, unsigned len, unsigned shift);
#endif
#ifndef lbnDouble_32
BNWORD32 lbnDouble_32(BNWORD32 *num, unsigned len);
#endif
#ifndef lbnRshift_32
BNWORD32 lbnRshift_32(BNWORD32 *num, unsigned len, unsigned shift);
#endif
#ifndef lbnMul_32
void lbnMul_32(BNWORD32 *prod, BNWORD32 const *num1, unsigned len1,
BNWORD32 const *num2, unsigned len2);
#endif
#ifndef lbnSquare_32
void lbnSquare_32(BNWORD32 *prod, BNWORD32 const *num, unsigned len);
#endif
#ifndef lbnNorm_32
unsigned lbnNorm_32(BNWORD32 const *num, unsigned len);
#endif
#ifndef lbnBits_32
unsigned lbnBits_32(BNWORD32 const *num, unsigned len);
#endif
#ifndef lbnExtractBigBytes_32
void lbnExtractBigBytes_32(BNWORD32 const *bn, unsigned char *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnInsertBigytes_32
void lbnInsertBigBytes_32(BNWORD32 *n, unsigned char const *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnExtractLittleBytes_32
void lbnExtractLittleBytes_32(BNWORD32 const *bn, unsigned char *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnInsertLittleBytes_32
void lbnInsertLittleBytes_32(BNWORD32 *n, unsigned char const *buf,
unsigned lsbyte, unsigned buflen);
#endif
#ifndef lbnDiv21_32
BNWORD32 lbnDiv21_32(BNWORD32 *q, BNWORD32 nh, BNWORD32 nl, BNWORD32 d);
#endif
#ifndef lbnDiv1_32
BNWORD32 lbnDiv1_32(BNWORD32 *q, BNWORD32 *rem,
BNWORD32 const *n, unsigned len, BNWORD32 d);
#endif
#ifndef lbnModQ_32
unsigned lbnModQ_32(BNWORD32 const *n, unsigned len, unsigned d);
#endif
#ifndef lbnDiv_32
BNWORD32
lbnDiv_32(BNWORD32 *q, BNWORD32 *n, unsigned nlen, BNWORD32 *d, unsigned dlen);
#endif
#ifndef lbnMontInv1_32
BNWORD32 lbnMontInv1_32(BNWORD32 const x);
#endif
#ifndef lbnMontReduce_32
void lbnMontReduce_32(BNWORD32 *n, BNWORD32 const *mod, unsigned const mlen,
BNWORD32 inv);
#endif
#ifndef lbnToMont_32
void lbnToMont_32(BNWORD32 *n, unsigned nlen, BNWORD32 *mod, unsigned mlen);
#endif
#ifndef lbnFromMont_32
void lbnFromMont_32(BNWORD32 *n, BNWORD32 *mod, unsigned len);
#endif
#ifndef lbnExpMod_32
int lbnExpMod_32(BNWORD32 *result, BNWORD32 const *n, unsigned nlen,
BNWORD32 const *exp, unsigned elen, BNWORD32 *mod, unsigned mlen);
#endif
#ifndef lbnDoubleExpMod_32
int lbnDoubleExpMod_32(BNWORD32 *result,
BNWORD32 const *n1, unsigned n1len, BNWORD32 const *e1, unsigned e1len,
BNWORD32 const *n2, unsigned n2len, BNWORD32 const *e2, unsigned e2len,
BNWORD32 *mod, unsigned mlen);
#endif
#ifndef lbnTwoExpMod_32
int lbnTwoExpMod_32(BNWORD32 *n, BNWORD32 const *exp, unsigned elen,
BNWORD32 *mod, unsigned mlen);
#endif
#ifndef lbnGcd_32
int lbnGcd_32(BNWORD32 *a, unsigned alen, BNWORD32 *b, unsigned blen);
#endif
#ifndef lbnInv_32
int lbnInv_32(BNWORD32 *a, unsigned alen, BNWORD32 const *mod, unsigned mlen);
#endif
#endif /* LBN32_H */

500
lib/bind/cylink/lbn68000.c
View file

@ -1,500 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn68000.c - 16-bit bignum primitives for the 68000 (or 68010) processors.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*
* This was written for Metrowerks C, and while it should be reasonably
* portable, NOTE that Metrowerks lets a callee trash a0, a1, d0, d1, and d2.
* Some 680x0 compilers make d2 callee-save, so instructions to save it
* will have to be added.
*
* This code supports 16 or 32-bit ints, based on UINT_MAX.
* Regardless of UINT_MAX, only bignums up to 64K words (1 million bits)
* are supported. (68k hackers will recognize this as a consequence of
* using dbra.)
*
* These primitives use little-endian word order.
* (The order of bytes within words is irrelevant to this issue.)
*/
#include <limits.h>
#include "lbn.h" /* Should include lbn68000.h */
/*
* The Metrowerks C compiler (1.2.2) produces bad 68k code for the
* following input, which happens to be the inner loop of lbnSub1,
* so a few less than critical routines have been recoded in assembly
* to avoid the bug. (Optimizer on or off does not matter.)
*
* unsigned
* decrement(unsigned *num, unsigned len)
* {
* do {
* if ((*num++)-- != 0)
* return 0;
* } while (--len);
* return 1;
* }
*/
asm BNWORD16
lbnSub1_16(BNWORD16 *num, unsigned len, BNWORD16 borrow)
{
movea.l 4(sp),a0 /* num */
#if UINT_MAX == 0xffff
move.w 10(sp),d0 /* borrow */
#else
move.w 12(sp),d0 /* borrow */
#endif
sub.w d0,(a0)+
bcc done
#if UINT_MAX == 0xffff
move.w 8(sp),d0 /* len */
#else
move.w 10(sp),d0 /* len */
#endif
subq.w #2,d0
bcs done
loop:
subq.w #1,(a0)+
dbcc d0,loop
done:
moveq.l #0,d0
addx.w d0,d0
rts
}
asm BNWORD16
lbnAdd1_16(BNWORD16 *num, unsigned len, BNWORD16 carry)
{
movea.l 4(sp),a0 /* num */
#if UINT_MAX == 0xffff
move.w 10(sp),d0 /* carry */
#else
move.w 12(sp),d0 /* carry */
#endif
add.w d0,(a0)+
bcc done
#if UINT_MAX == 0xffff
move.w 8(sp),d0 /* len */
#else
move.w 10(sp),d0 /* len */
#endif
subq.w #2,d0
bcs done
loop:
addq.w #1,(a0)+
dbcc d0,loop
done:
moveq.l #0,d0
addx.w d0,d0
rts
}
asm void
lbnMulN1_16(BNWORD16 *out, BNWORD16 const *in, unsigned len, BNWORD16 k)
{
move.w d3,-(sp) /* 2 bytes of stack frame */
move.l 2+4(sp),a1 /* out */
move.l 2+8(sp),a0 /* in */
#if UINT_MAX == 0xffff
move.w 2+12(sp),d3 /* len */
move.w 2+14(sp),d2 /* k */
#else
move.w 2+14(sp),d3 /* len (low 16 bits) */
move.w 2+16(sp),d2 /* k */
#endif
move.w (a0)+,d1 /* First multiply */
mulu.w d2,d1
move.w d1,(a1)+
clr.w d1
swap d1
subq.w #1,d3 /* Setup for loop unrolling */
lsr.w #1,d3
bcs.s m16_even
beq.s m16_short
subq.w #1,d3 /* Set up software pipeline properly */
move.l d1,d0
m16_loop:
move.w (a0)+,d1
mulu.w d2,d1
add.l d0,d1
move.w d1,(a1)+
clr.w d1
swap d1
m16_even:
move.w (a0)+,d0
mulu.w d2,d0
add.l d1,d0
move.w d0,(a1)+
clr.w d0
swap d0
dbra d3,m16_loop
move.w d0,(a1)
move.w (sp)+,d3
rts
m16_short:
move.w d1,(a1)
move.w (sp)+,d3
rts
}
asm BNWORD16
lbnMulAdd1_16(BNWORD16 *out, BNWORD16 const *in, unsigned len, BNWORD16 k)
{
move.w d4,-(sp)
clr.w d4
move.w d3,-(sp) /* 4 bytes of stack frame */
move.l 4+4(sp),a1 /* out */
move.l 4+8(sp),a0 /* in */
#if UINT_MAX == 0xffff
move.w 4+12(sp),d3 /* len */
move.w 4+14(sp),d2 /* k */
#else
move.w 4+14(sp),d3 /* len (low 16 bits) */
move.w 4+16(sp),d2 /* k */
#endif
move.w (a0)+,d1 /* First multiply */
mulu.w d2,d1
add.w d1,(a1)+
clr.w d1
swap d1
addx.w d4,d1
subq.w #1,d3 /* Setup for loop unrolling */
lsr.w #1,d3
bcs.s ma16_even
beq.s ma16_short
subq.w #1,d3 /* Set up software pipeline properly */
move.l d1,d0
ma16_loop:
move.w (a0)+,d1
mulu.w d2,d1
add.l d0,d1
add.w d1,(a1)+
clr.w d1
swap d1
addx.w d4,d1
ma16_even:
move.w (a0)+,d0
mulu.w d2,d0
add.l d1,d0
add.w d0,(a1)+
clr.w d0
swap d0
addx.w d4,d0
dbra d3,ma16_loop
move.w (sp)+,d3
move.w (sp)+,d4
rts
ma16_short:
move.w (sp)+,d3
move.l d1,d0
move.w (sp)+,d4
rts
}
asm BNWORD16
lbnMulSub1_16(BNWORD16 *out, BNWORD16 const *in, unsigned len, BNWORD16 k)
{
move.w d4,-(sp)
clr.w d4
move.w d3,-(sp) /* 4 bytes of stack frame */
move.l 4+4(sp),a1 /* out */
move.l 4+8(sp),a0 /* in */
#if UINT_MAX == 0xffff
move.w 4+12(sp),d3 /* len */
move.w 4+14(sp),d2 /* k */
#else
move.w 4+14(sp),d3 /* len (low 16 bits) */
move.w 4+16(sp),d2 /* k */
#endif
move.w (a0)+,d1 /* First multiply */
mulu.w d2,d1
sub.w d1,(a1)+
clr.w d1
swap d1
addx.w d4,d1
subq.w #1,d3 /* Setup for loop unrolling */
lsr.w #1,d3
bcs.s ms16_even
beq.s ms16_short
subq.w #1,d3 /* Set up software pipeline properly */
move.l d1,d0
ms16_loop:
move.w (a0)+,d1
mulu.w d2,d1
add.l d0,d1
sub.w d1,(a1)+
clr.w d1
swap d1
addx.w d4,d1
ms16_even:
move.w (a0)+,d0
mulu.w d2,d0
add.l d1,d0
sub.w d0,(a1)+
clr.w d0
swap d0
addx.w d4,d0
dbra d3,ms16_loop
move.w (sp)+,d3
move.w (sp)+,d4
rts
ms16_short:
move.w (sp)+,d3
move.l d1,d0
move.w (sp)+,d4
rts
}
/* The generic long/short divide doesn't know that nh < d */
asm BNWORD16
lbnDiv21_16(BNWORD16 *q, BNWORD16 nh, BNWORD16 nl, BNWORD16 d)
{
move.l 8(sp),d0 /* nh *and* nl */
divu.w 12(sp),d0
move.l 4(sp),a0
move.w d0,(a0)
clr.w d0
swap d0
rts
}
asm unsigned
lbnModQ_16(BNWORD16 const *n, unsigned len, BNWORD16 d)
{
move.l 4(sp),a0 /* n */
moveq.l #0,d1
#if UINT_MAX == 0xffff
move.w 8(sp),d1 /* len */
move.w 10(sp),d2 /* d */
#else
move.w 10(sp),d1 /* len (low 16 bits) */
move.w 12(sp),d2 /* d */
#endif
add.l d1,a0
add.l d1,a0 /* n += len */
moveq.l #0,d0
subq.w #1,d1
mq16_loop:
move.w -(a0),d0 /* Assemble remainder and new word */
divu.w d2,d0 /* Put remainder in high half of d0 */
dbra d1,mq16_loop
mq16_done:
clr.w d0
swap d0
rts
}
/*
* Detect if this is a 32-bit processor (68020+ *or* CPU32).
* Both the 68020+ and CPU32 processors (which have 32x32->64-bit
* multiply, what the 32-bit math library wants) support scaled indexed
* addressing. The 68000 and 68010 ignore the scale selection
* bits, treating it as *1 all the time. So a 32-bit processor
* will evaluate -2(a0,a0.w*2) as 1+1*2-2 = 1.
* A 16-bit processor will compute 1+1-2 = 0.
*
* Thus, the return value will indicate whether the chip this is
* running on supports 32x32->64-bit multiply (mulu.l).
*/
asm int
is68020(void)
{
machine 68020
lea 1,a0
#if 0
lea -2(a0,a0.w*2),a0 /* Metrowerks won't assemble this, arrgh */
#else
dc.w 0x41f0, 0x82fe
#endif
move.l a0,d0
rts
}
/*
* Since I had to hand-assemble that fancy addressing mode, I had to study
* up on 680x0 addressing modes.
* A summary of 680x0 addressing modes.
* A 68000 effective address specifies an operand on an instruction, which
* may be a register or in memory. It is made up of a 3-bit mode and a
* 3-bit register specifier. The meanings of the various modes are:
*
* 000 reg - Dn, n specified by "reg"
* 001 reg - An, n specified by "reg"
* 010 reg - (An)
* 011 reg - (An)+
* 100 reg - -(An)
* 101 reg - d16(An), one 16-bit displacement word follows, sign-extended
* 110 reg - Fancy addressing mode off of An, see extension word below
* 111 000 - abs.W, one 16-bit signed absolute address follows
* 111 001 - abs.L, one 32-bit absolute address follows
* 111 010 - d16(PC), one 16-bit displacemnt word follows, sign-extended
* 111 011 - Fancy addressing mode off of PC, see extension word below
* 111 100 - #immediate, followed by 16 or 32 bits of immediate value
* 111 101 - unused, reserved
* 111 110 - unused, reserved
* 111 111 - unused, reserved
*
* Memory references are to data space, except that PC-relative references
* are to program space, and are read-only.
*
* Fancy addressing modes are followed by a 16-bit extension word, and come
* in "brief" and "full" forms.
* The "brief" form looks like this. Bit 8 is 0 to indicate this form:
*
* 1 1 1 1 1 1 1
* 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
* |A/D| register |L/W| scale | 0 | 8-bit signed displacement |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*
* The basic effective address specifies a 32-bit base register - A0 through
* A7 or PC (the address of the following instruction).
* The A/D and register fields specify an index register. A/D is 1 for
* address registers, and 0 for data registers. L/W specifies the length
* of the index register, 1 for 32 bits, and 0 for 16 bits (sign-extended).
* The scale field is a left shift amount (0 to 3 bits) to apply to the
* sign-extended index register. The final address is d8(An,Rn.X*SCALE),
* also written (d8,An,Rn.X*SCALE). X is "W" or "L", SCALE is 1, 2, 4 or 8.
* "*1" may be omitted, as may a d8 of 0.
*
* The 68000 supports this form, but only with a scale field of 0.
* It does NOT (says the MC68030 User's Manual MC68030UM/AD, section 2.7)
* decode the scale field and the following format bit. They are treated
* as 0.
* I recall (I don't have the data book handy) that the CPU32 processor
* core used in the 683xx series processors supports variable scales,
* but only the brief extension word form. I suspect it decodes the
* format bit and traps if it is not zero, but I don't recall.
*
* The "full" form (680x0, x >= 2 processors only) looks like this:
*
* 1 1 1 1 1 1 1
* 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
* |A/D| register |L/W| scale | 1 | BS| IS|BD size| 0 | P |OD size|
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*
* The first 8 bits are interpreted the same way as in the brief form,
* except that bit 8 is set to 1 to indicate the full form.
* BS, Base Suppress, if set, causes a value of 0 to be used in place of
* the base register value. If this is set, the base register
* specified is irrelevant, except that if it is the PC, the fetch is
* still done from program space. The specifier "ZPC" can be used in
* place of "PC" in the effective address mnemonic to represent this
* case.
* IS, Index Suppress, if set, causes a value of 0 to be used in place
* of the scaled index register. In this case, the first 7 bits of the
* extension word are irrelevant.
* BD size specifies the base displacement size. A value of 00
* in this field is illegal, while 01, 10 and 11 indicate that the
* extension word is followed by 0, 1 or 2 16-bit words of base displacement
* (zero, sign-extended to 32 bits, and most-significant word first,
* respectively) to add to the base register value.
* Bit 3 is unused.
* The P bit is the pre/post indexing bit, and only applies if an outer
* displacement is used. This is explained later.
* OD size specifies the size of an outer displacement. In the simple
* case, this field is set to 00 and the effective address is
* (disp,An,Rn.X*SCALE) or (disp,PC,Rn.X*SCALE).
* In this case the P bit must be 0. Any of those compnents may be
* suppressed, with a BD size of 01, the BS bit, or the IS bit.
* If the OD size is not 00, it encodes an outer displacement in the same
* manner as the BD size, and 0, 1 or 2 16-bit words of outer displacement
* follow the base displacement in the instruction stream. In this case,
* this is a double-indirect addressing mode. The base, base displacement,
* and possibly the index, specify a 32-bit memory word which holds a value
* which is fetched, and the outer displacement and possibly the index are
* added to produce the address of the operand.
* If the P bit is 0, this is pre-indexed, and the index value is added
* before the fetch of the indirect word, producing an effective address
* of ([disp,An,Rn.X*SCALE],disp). If the P bit is 1, the post-indexed case,
* the memory word is fectched from base+base displacement, then the index
* and outer displacement are added to compute the address of the operand.
* This effective address is written ([disp,An],Rn.X*SCALE,disp).
* (In both cases, "An" may also be "PC" or "ZPC".)
* Any of the components may be omitted. If the index is omitted (using the
* IS bit), the P bit is irrelevant, but must be written as 0.
* Thus, legal combinations of IS, P and OD size are:
* 0 0 00 - (disp,An,Rn.X*SCALE), also written disp(An,Rn.X*SCALE)
* 0 0 01 - ([disp,An,Rn.X*SCALE])
* 0 0 10 - ([disp,An,Rn.X*SCALE],d16)
* 0 0 11 - ([disp,An,Rn.X*SCALE],d32)
* 0 1 01 - ([disp,An],Rn.X*SCALE)
* 0 1 10 - ([disp,An],Rn.X*SCALE,d16)
* 0 1 11 - ([disp,An],Rn.X*SCALE,d32)
* 1 0 00 - (disp,An), also written disp(An)
* 1 0 01 - ([disp,An])
* 1 0 10 - ([disp,An],d16)
* 1 0 11 - ([disp,An],d32)
*/
/* 45678901234567890123456789012345678901234567890123456789012345678901234567 */

74
lib/bind/cylink/lbn68000.h
View file

@ -1,74 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn68000.h - 16-bit bignum primitives for the 68000 (or 68010) processors.
*
* These primitives use little-endian word order.
* (The order of bytes within words is irrelevant.)
*/
#define BN_LITTLE_ENDIAN 1
typedef unsigned short bnword16
#define BNWORD16 bnword16
bnword16 lbnSub1_16(bnword16 *num, unsigned len, bnword16 borrow);
bnword16 lbnAdd1_16(bnword16 *num, unsigned len, bnword16 carry);
void lbnMulN1_16(bnword16 *out, bnword16 const *in, unsigned len, bnword16 k);
bnword16
lbnMulAdd1_16(bnword16 *out, bnword16 const *in, unsigned len, bnword16 k);
bnword16
lbnMulSub1_16(bnword16 *out, bnword16 const *in, unsigned len, bnword16 k);
bnword16 lbnDiv21_16(bnword16 *q, bnword16 nh, bnword16 nl, bnword16 d);
unsigned lbnModQ_16(bnword16 const *n, unsigned len, bnword16 d);
int is68020(void);
/* #define the values to exclude the C versions */
#define lbnSub1_16 lbnSub1_16
#define lbnAdd1_16 lbnAdd1_16
#define lbnMulN1_16 lbnMulN1_16
#define lbnMulAdd1_16 lbnMulAdd1_16
#define lbnMulSub1_16 lbnMulSub1_16
#define lbnDiv21_16 lbnDiv21_16
#define lbnModQ_16 lbnModQ_16
/* Also include the 68020 definitions for 16/32 bit switching versions. */
#include <lbn68020.h>

349
lib/bind/cylink/lbn68020.c
View file

@ -1,349 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn68020.c - 32-bit bignum primitives for the 68020+ (0r 683xx) processors.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*
* This was written for Metrowerks C, and while it should be reasonably
* portable, NOTE that Metrowerks lets a callee trash a0, a1, d0, d1, and d2.
* Some 680x0 compilers make d2 callee-save, so instructions to save it
* will have to be added.
*
* This code supports 16 or 32-bit ints, based on UINT_MAX.
* Regardless of UINT_MAX, only bignums up to 64K words (2 million bits)
* are supported. (68k hackers will recognize this as a consequence of
* using dbra.)
*
* These primitives use little-endian word order.
* (The order of bytes within words is irrelevant to this issue.)
*
* TODO: Schedule this for the 68040's pipeline. (When I get a 68040 manual.)
*/
#include <limits.h>
#include "lbn.h" /* Should include lbn68020.h */
/*
* The Metrowerks C compiler (1.2.2) produces bad 68k code for the
* following input, which happens to be the inner loop of lbnSub1,
* so a few less than critical routines have been recoded in assembly
* to avoid the bug. (Optimizer on or off does not matter.)
*
* unsigned
* decrement(unsigned *num, unsigned len)
* {
* do {
* if ((*num++)-- != 0)
* return 0;
* } while (--len);
* return 1;
* }
*/
asm BNWORD32
lbnSub1_32(BNWORD32 *num, unsigned len, BNWORD32 borrow)
{
movea.l 4(sp),a0 /* num */
#if UINT_MAX == 0xffff
move.l 10(sp),d0 /* borrow */
#else
move.l 12(sp),d0 /* borrow */
#endif
sub.l d0,(a0)+
bcc done
#if UINT_MAX == 0xffff
move.w 8(sp),d0 /* len */
#else
move.w 10(sp),d0 /* len */
#endif
subq.w #2,d0
bcs done
loop:
subq.l #1,(a0)+
dbcc d0,loop
done:
moveq.l #0,d0
addx.w d0,d0
rts
}
asm BNWORD32
lbnAdd1_32(BNWORD32 *num, unsigned len, BNWORD32 carry)
{
movea.l 4(sp),a0 /* num */
#if UINT_MAX == 0xffff
move.l 10(sp),d0 /* carry */
#else
move.l 12(sp),d0 /* carry */
#endif
add.l d0,(a0)+
bcc done
#if UINT_MAX == 0xffff
move.w 8(sp),d0 /* len */
#else
move.w 10(sp),d0 /* len */
#endif
subq.w #2,d0
bcs done
loop:
addq.l #1,(a0)+
dbcc d0,loop
done:
moveq.l #0,d0
addx.w d0,d0
rts
}
asm void
lbnMulN1_32(BNWORD32 *out, BNWORD32 const *in, unsigned len, BNWORD32 k)
{
machine 68020
movem.l d3-d5,-(sp) /* 12 bytes of extra data */
moveq.l #0,d4
move.l 16(sp),a1 /* out */
move.l 20(sp),a0 /* in */
#if UINT_MAX == 0xffff
move.w 24(sp),d5 /* len */
move.l 26(sp),d2 /* k */
#else
move.w 26(sp),d5 /* len */
move.l 28(sp),d2 /* k */
#endif
move.l (a0)+,d3 /* First multiply */
mulu.l d2,d1:d3 /* dc.w 0x4c02, 0x3401 */
move.l d3,(a1)+
subq.w #1,d5 /* Setup for loop unrolling */
lsr.w #1,d5
bcs.s m32_even
beq.s m32_short
subq.w #1,d5 /* Set up software pipeline properly */
move.l d1,d0
m32_loop:
move.l (a0)+,d3
mulu.l d2,d1:d3 /* dc.w 0x4c02, 0x3401 */
add.l d0,d3
addx.l d4,d1
move.l d3,(a1)+
m32_even:
move.l (a0)+,d3
mulu.l d2,d0:d3 /* dc.w 0x4c02, 0x3400 */
add.l d1,d3
addx.l d4,d0
move.l d3,(a1)+
dbra d5,m32_loop
move.l d0,(a1)
movem.l (sp)+,d3-d5
rts
m32_short:
move.l d1,(a1)
movem.l (sp)+,d3-d5
rts
}
asm BNWORD32
lbnMulAdd1_32(BNWORD32 *out, BNWORD32 const *in, unsigned len, BNWORD32 k)
{
machine 68020
movem.l d3-d5,-(sp) /* 12 bytes of extra data */
moveq.l #0,d4
move.l 16(sp),a1 /* out */
move.l 20(sp),a0 /* in */
#if UINT_MAX == 0xffff
move.w 24(sp),d5 /* len */
move.l 26(sp),d2 /* k */
#else
move.w 26(sp),d5 /* len */
move.l 28(sp),d2 /* k */
#endif
move.l (a0)+,d3 /* First multiply */
mulu.l d2,d1:d3 /* dc.w 0x4c02, 0x3401 */
add.l d3,(a1)+
addx.l d4,d1
subq.w #1,d5 /* Setup for loop unrolling */
lsr.w #1,d5
bcs.s ma32_even
beq.s ma32_short
subq.w #1,d5 /* Set up software pipeline properly */
move.l d1,d0
ma32_loop:
move.l (a0)+,d3
mulu.l d2,d1:d3 /* dc.w 0x4c02, 0x3401 */
add.l d0,d3
addx.l d4,d1
add.l d3,(a1)+
addx.l d4,d1
ma32_even:
move.l (a0)+,d3
mulu.l d2,d0:d3 /* dc.w 0x4c02, 0x3400 */
add.l d1,d3
addx.l d4,d0
add.l d3,(a1)+
addx.l d4,d0
dbra d5,ma32_loop
movem.l (sp)+,d3-d5
rts
ma32_short:
move.l d1,d0
movem.l (sp)+,d3-d5
rts
}
asm BNWORD32
lbnMulSub1_32(BNWORD32 *out, BNWORD32 const *in, unsigned len, BNWORD32 k)
{
machine 68020
movem.l d3-d5,-(sp) /* 12 bytes of extra data */
moveq.l #0,d4
move.l 16(sp),a1 /* out */
move.l 20(sp),a0 /* in */
#if UINT_MAX == 0xffff
move.w 24(sp),d5 /* len */
move.l 26(sp),d2 /* k */
#else
move.w 26(sp),d5 /* len */
move.l 28(sp),d2 /* k */
#endif
move.l (a0)+,d3 /* First multiply */
mulu.l d2,d1:d3 /* dc.w 0x4c02, 0x3401 */
sub.l d3,(a1)+
addx.l d4,d1
subq.w #1,d5 /* Setup for loop unrolling */
lsr.w #1,d5
bcs.s ms32_even
beq.s ms32_short
subq.w #1,d5 /* Set up software pipeline properly */
move.l d1,d0
ms32_loop:
move.l (a0)+,d3
mulu.l d2,d1:d3 /* dc.w 0x4c02, 0x3401 */
add.l d0,d3
addx.l d4,d1
sub.l d3,(a1)+
addx.l d4,d1
ms32_even:
move.l (a0)+,d3
mulu.l d2,d0:d3 /* dc.w 0x4c02, 0x3400 */
add.l d1,d3
addx.l d4,d0
sub.l d3,(a1)+
addx.l d4,d0
dbra d5,ms32_loop
movem.l (sp)+,d3-d5
rts
ms32_short:
move.l d1,d0
movem.l (sp)+,d3-d5
rts
}
asm BNWORD32
lbnDiv21_32(BNWORD32 *q, BNWORD32 nh, BNWORD32 nl, BNWORD32 d)
{
machine 68020
move.l 8(sp),d0
move.l 12(sp),d1
move.l 4(sp),a0
divu.l 16(sp),d0:d1 /* dc.w 0x4c6f, 0x1400, 16 */
move.l d1,(a0)
rts
}
asm unsigned
lbnModQ_32(BNWORD32 const *n, unsigned len, unsigned d)
{
machine 68020
move.l 4(sp),a0 /* n */
move.l d3,a1
#if UINT_MAX == 0xffff
moveq.l #0,d2
move.w 8(sp),d1 /* len */
move.w 10(sp),d2 /* d */
#else
move.w 10(sp),d1 /* len */
move.l 12(sp),d2 /* d */
#endif
dc.w 0x41f0, 0x1cfc /* lea -4(a0,d1.L*4),a0 */
/* First time, divide 32/32 - may be faster than 64/32 */
move.l (a0),d3
divul.l d2,d0:d3 /* dc.w 0x4c02, 0x3000 */
subq.w #2,d1
bmi mq32_done
mq32_loop:
move.l -(a0),d3
divu.l d2,d0:d3 /* dc.w 0x4c02,0x3400 */
dbra d1,mq32_loop
mq32_done:
move.l a1,d3
rts
}
/* 45678901234567890123456789012345678901234567890123456789012345678901234567 */

69
lib/bind/cylink/lbn68020.h
View file

@ -1,69 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn68020.h - 32-bit bignum primitives for the 68020 (or 683xx) processors.
*
* These primitives use little-endian word order.
* (The order of bytes within words is irrelevant.)
*/
#define BN_LITTLE_ENDIAN 1
typedef unsigned long bnword32
#define BNWORD32 bnword32
bnword32 lbnSub1_32(bnword32 *num, unsigned len, bnword32 borrow);
bnword32 lbnAdd1_32(bnword32 *num, unsigned len, bnword32 carry);
void lbnMulN1_32(bnword32 *out, bnword32 const *in, unsigned len, bnword32 k);
bnword32
lbnMulAdd1_32(bnword32 *out, bnword32 const *in, unsigned len, bnword32 k);
bnword32
lbnMulSub1_32(bnword32 *out, bnword32 const *in, unsigned len, bnword32 k);
bnword32 lbnDiv21_32(bnword32 *q, bnword32 nh, bnword32 nl, bnword32 d);
unsigned lbnModQ_32(bnword32 const *n, unsigned len, unsigned d);
/* #define the values to exclude the C versions */
#define lbnSub1_32 lbnSub1_32
#define lbnAdd1_32 lbnAdd1_32
#define lbnMulN1_32 lbnMulN1_32
#define lbnMulAdd1_32 lbnMulAdd1_32
#define lbnMulSub1_32 lbnMulSub1_32
#define lbnDiv21_32 lbnDiv21_32
#define lbnModQ_32 lbnModQ_32

169
lib/bind/cylink/lbn80386.h
View file

@ -1,169 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn80386.h - This file defines the interfaces to the 80386
* assembly primitives. It is intended to be included in "lbn.h"
* via the "#include BNINCLUDE" mechanism.
*/
#define BN_LITTLE_ENDIAN 1
typedef unsigned long bnword32;
#define BNWORD32 bnword32
/* MS-DOS needs the calling convention described to it. */
#ifndef MSDOS
#ifdef __MSDOS__
#define MSDOS 1
#endif
#endif
#ifdef MSDOS
#define CDECL __cdecl
#else
#define CDECL /*nothing*/
#endif
#ifdef __cplusplus
/* These assembly-language primitives use C names */
extern "C" {
#endif
/* Function prototypes for the asm routines */
void CDECL
lbnMulN1_32(bnword32 *out, bnword32 const *in, unsigned len, bnword32 k);
#define lbnMulN1_32 lbnMulN1_32
bnword32 CDECL
lbnMulAdd1_32(bnword32 *out, bnword32 const *in, unsigned len, bnword32 k);
#define lbnMulAdd1_32 lbnMulAdd1_32
bnword32 CDECL
lbnMulSub1_32(bnword32 *out, bnword32 const *in, unsigned len, bnword32 k);
#define lbnMulSub1_32 lbnMulSub1_32
bnword32 CDECL
lbnDiv21_32(bnword32 *q, bnword32 nh, bnword32 nl, bnword32 d);
#define lbnDiv21_32 lbnDiv21_32
unsigned CDECL
lbnModQ_32(bnword32 const *n, unsigned len, bnword32 d);
#define lbnModQ_32 lbnModQ_32
#ifdef __cplusplus
}
#endif
#if __GNUC__
/*
* Use the (massively cool) GNU inline-assembler extension to define
* inline expansions for various operations.
*
* The massively cool part is that the assembler can have inputs
* and outputs, and you specify the operands and which effective
* addresses are legal and they get substituted into the code.
* (For example, some of the code requires a zero. Rather than
* specify an immediate constant, the expansion specifies an operand
* of zero which can be in various places. This lets GCC use an
* immediate zero, or a register which contains zero if it's available.)
*
* The syntax is asm("asm_code" : outputs : inputs : trashed)
* %0, %1 and so on in the asm code are substituted by the operands
* in left-to-right order (outputs, then inputs).
* The operands contain constraint strings and values to use.
* Outputs must be lvalues, inputs may be rvalues. In the constraints:
* "a" means that the operand must be in eax.
* "d" means that the operand must be in edx.
* "g" means that the operand may be any effective address.
* "=" means that the operand is assigned to.
* "%" means that this operand and the following one may be
* interchanged if desirable.
* "bcDSmn" means that the operand must be in ebx, ecx, esi, edi, memory,
* or an immediate constant. (This is almost the same as "g"
* but allowing it in eax wouldn't help because x is already
* assigned there, and it must not be in edx, since edx is
* overwritten by the multiply before a and b are read.)
*
* Note that GCC uses AT&T assembler syntax, which is rather
* different from Intel syntax. The length (b, w or l) of the
* operation is appended to the opcode, and the *second* operand
* is the destination, not the first. Finally, the register names
* are all preceded with "%". (Doubled here because % is a
* magic character.)
*/
/* (ph<<32) + pl = x*y */
#define mul32_ppmm(ph,pl,x,y) \
__asm__("mull %3" : "=d"(ph), "=a"(pl) : "%a"(x), "g"(y))
/* (ph<<32) + pl = x*y + a */
#define mul32_ppmma(ph,pl,x,y,a) \
__asm__("mull %3\n\t" \
"addl %4,%%eax\n\t" \
"adcl %5,%%edx" \
: "=&d"(ph), "=a"(pl) \
: "%a"(x), "g"(y), "bcDSmn"(a), "bcDSmn"(0))
/* (ph<<32) + pl = x*y + a + b */
#define mul32_ppmmaa(ph,pl,x,y,a,b) \
__asm__("mull %3\n\t" \
"addl %4,%%eax\n\t" \
"adcl %6,%%edx\n\t" \
"addl %5,%%eax\n\t" \
"adcl %6,%%edx" \
: "=&d"(ph), "=a"(pl) \
: "%a"(x), "g"(y), "%bcDSmn"(a), "bcDSmn"(b), "bcDSmn"(0))
/* q = ((nh<<32) + nl) / d, return remainder. nh guaranteed < d. */
#undef lbnDiv21_32
#define lbnDiv21_32(q,nh,nl,d) \
({unsigned _; \
__asm__("divl %4" : "=d"(_), "=a"(*q) : "d"(nh), "a"(nl), "g"(d)); \
_;})
/* No quotient, just return remainder ((nh<<32) + nl) % d */
#define lbnMod21_32(nh,nl,d) \
({unsigned _; \
__asm__("divl %3" : "=d"(_) : "d"(nh), "a"(nl), "g"(d) : "ax"); \
_;})
#endif /* __GNUC__ */

113
lib/bind/cylink/lbn8086.h
View file

@ -1,113 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbn8086.h - This file defines the interfaces to the 8086
* assembly primitives for 16-bit MS-DOS environments.
* It is intended to be included in "lbn.h"
* via the "#include BNINCLUDE" mechanism.
*/
#define BN_LITTLE_ENDIAN 1
#ifdef __cplusplus
/* These assembly-language primitives use C names */
extern "C" {
#endif
/* Set up the appropriate types */
typedef unsigned short bnword16;
#define BNWORD16 bnword16
typedef unsigned long bnword32;
#define BNWORD32 bnword32
void __cdecl __far
lbnMulN1_16(bnword16 __far *out, bnword16 const __far *in,
unsigned len, bnword16 k);
#define lbnMulN1_16 lbnMulN1_16
bnword16 __cdecl __far
lbnMulAdd1_16(bnword16 __far *out, bnword16 const __far *in,
unsigned len, bnword16 k);
#define lbnMulAdd1_16 lbnMulAdd1_16
bnword16 __cdecl __far
lbnMulSub1_16(bnword16 __far *out, bnword16 const __far *in,
unsigned len, bnword16 k);
#define lbnMulSub1_16 lbnMulSub1_16
bnword16 __cdecl __far
lbnDiv21_16(bnword16 __far *q, bnword16 nh, bnword16 nl, bnword16 d);
#define lbnDiv21_16 lbnDiv21_16
bnword16 __cdecl __far
lbnModQ_16(bnword16 const __far *n, unsigned len, bnword16 d);
#define lbnModQ_16 lbnModQ_16
void __cdecl __far
lbnMulN1_32(bnword32 __far *out, bnword32 const __far *in,
unsigned len, bnword32 k);
#define lbnMulN1_32 lbnMulN1_32
bnword32 __cdecl __far
lbnMulAdd1_32(bnword32 __far *out, bnword32 const __far *in,
unsigned len, bnword32 k);
#define lbnMulAdd1_32 lbnMulAdd1_32
bnword32 __cdecl __far
lbnMulSub1_32(bnword32 __far *out, bnword32 const __far *in,
unsigned len, bnword32 k);
#define lbnMulSub1_32 lbnMulSub1_32
bnword32 __cdecl __far
lbnDiv21_32(bnword32 __far *q, bnword32 nh, bnword32 nl, bnword32 d);
#define lbnDiv21_32 lbnDiv21_32
bnword16 __cdecl __far
lbnModQ_32(bnword32 const __far *n, unsigned len, bnword32 d);
#define lbnModQ_32 lbnModQ_32
int __cdecl __far not386(void);
#ifdef __cplusplus
}
#endif

195
lib/bind/cylink/lbnmem.c
View file

@ -1,195 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* lbnmem.c - low-level bignum memory handling.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c.
*
* Note that in all cases, the pointers passed around
* are pointers to the *least* significant end of the word.
* On big-endian machines, these are pointers to the *end*
* of the allocated range.
*
* BNSECURE is a simple level of security; for more security
* change these function to use locked unswappable memory.
*/
#include "port_before.h"
#ifndef HAVE_CONFIG_H
#define HAVE_CONFIG_H 0
#endif
#if HAVE_CONFIG_H
#include "config.h"
#endif
/*
* Some compilers complain about #if FOO if FOO isn't defined,
* so do the ANSI-mandated thing explicitly...
*/
#ifndef NO_STDLIB_H
#define NO_STDLIB_H 0
#endif
#ifndef NO_STRING_H
#define NO_STRING_H 0
#endif
#ifndef HAVE_STRINGS_H
#define HAVE_STRINGS_H 0
#endif
#ifndef NEED_MEMORY_H
#define NEED_MEMORY_H 0
#endif
#if !NO_STDLIB_H
#include <stdlib.h> /* For malloc() & co. */
#else
void *malloc();
void *realloc();
void free();
#endif
#if !NO_STRING_H
#include <string.h> /* For memset */
#elif HAVE_STRINGS_H
#include <strings.h>
#endif
#if NEED_MEMORY_H
#include <memory.h>
#endif
#ifndef DBMALLOC
#define DBMALLOC 0
#endif
#if DBMALLOC
/* Development debugging */
#include "../dbmalloc/malloc.h"
#endif
#include "lbn.h"
#include "lbnmem.h"
#include "kludge.h"
#ifndef lbnMemWipe
void
lbnMemWipe(void *ptr, unsigned bytes)
{
memset(ptr, 0, bytes);
}
#define lbnMemWipe(ptr, bytes) memset(ptr, 0, bytes)
#endif
#ifndef lbnMemAlloc
void *
lbnMemAlloc(unsigned bytes)
{
return malloc(bytes);
}
#define lbnMemAlloc(bytes) malloc(bytes)
#endif
#ifndef lbnMemFree
void
lbnMemFree(void *ptr, unsigned bytes)
{
lbnMemWipe(ptr, bytes);
free(ptr);
}
#endif
#ifndef lbnRealloc
#if defined(lbnMemRealloc) || !BNSECURE
void *
lbnRealloc(void *ptr, unsigned oldbytes, unsigned newbytes)
{
if (ptr) {
BIG(ptr = (char *)ptr - oldbytes;)
if (newbytes < oldbytes)
memmove(ptr, (char *)ptr + oldbytes-newbytes, oldbytes);
}
#ifdef lbnMemRealloc
ptr = lbnMemRealloc(ptr, oldbytes, newbytes);
#else
ptr = realloc(ptr, newbytes);
#endif
if (ptr) {
if (newbytes > oldbytes)
memmove((char *)ptr + newbytes-oldbytes, ptr, oldbytes);
BIG(ptr = (char *)ptr + newbytes;)
}
return ptr;
}
#else /* BNSECURE */
void *
lbnRealloc(void *oldptr, unsigned oldbytes, unsigned newbytes)
{
void *newptr = lbnMemAlloc(newbytes);
if (!newptr)
return newptr;
if (!oldptr)
return BIGLITTLE((char *)newptr+newbytes, newptr);
/*
* The following copies are a bit non-obvious in the big-endian case
* because one of the pointers points to the *end* of allocated memory.
*/
if (newbytes > oldbytes) { /* Copy all of old into part of new */
BIG(newptr = (char *)newptr + newbytes;)
BIG(oldptr = (char *)oldptr - oldbytes;)
memcpy(BIGLITTLE((char *)newptr-oldbytes, newptr), oldptr,
oldbytes);
} else { /* Copy part of old into all of new */
memcpy(newptr, BIGLITTLE((char *)oldptr-newbytes, oldptr),
newbytes);
BIG(newptr = (char *)newptr + newbytes;)
BIG(oldptr = (char *)oldptr - oldbytes;)
}
lbnMemFree(oldptr, oldbytes);
return newptr;
}
#endif /* BNSECURE */
#endif /* !lbnRealloc */

102
lib/bind/cylink/lbnmem.h
View file

@ -1,102 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* Operations on the usual buffers of bytes
*/
#ifndef BNSECURE
#define BNSECURE 1
#endif
/*
* These operations act on buffers of memory, just like malloc & free.
* One exception: it is not legal to pass a NULL pointer to lbnMemFree.
*/
#ifndef lbnMemAlloc
void *lbnMemAlloc(unsigned bytes);
#endif
#ifndef lbnMemFree
void lbnMemFree(void *ptr, unsigned bytes);
#endif
/* This wipes out a buffer of bytes if necessary needed. */
#ifndef lbnMemWipe
#if BNSECURE
void lbnMemWipe(void *ptr, unsigned bytes);
#else
#define lbnMemWipe(ptr, bytes) (void)(ptr,bytes)
#endif
#endif /* !lbnMemWipe */
/*
* lbnRealloc is NOT like realloc(); it's endian-sensitive!
* If lbnMemRealloc is #defined, lbnRealloc will be defined in terms of it.
* It is legal to pass a NULL pointer to lbnRealloc, although oldbytes
* will always be sero.
*/
#ifndef lbnRealloc
void *lbnRealloc(void *ptr, unsigned oldbytes, unsigned newbytes);
#endif
/*
* These macros are the ones actually used most often in the math library.
* They take and return pointers to the *end* of the given buffer, and
* take sizes in terms of words, not bytes.
*
* Note that LBNALLOC takes the pointer as an argument instead of returning
* the value.
*
* Note also that these macros are only useable if you have included
* lbn.h (for the BIG and BIGLITTLE macros), which this file does NOT include.
*/
#define LBNALLOC(p,words) BIGLITTLE( \
if ( ((p) = lbnMemAlloc((words)*sizeof*(p))) != 0) (p) += (words), \
(p) = lbnMemAlloc((words) * sizeof*(p)) \
)
#define LBNFREE(p,words) lbnMemFree((p) BIG(-(words)), (words) * sizeof*(p))
#define LBNREALLOC(p,old,new) \
lbnRealloc(p, (old) * sizeof*(p), (new) * sizeof*(p))
#define LBNWIPE(p,words) lbnMemWipe((p) BIG(-(words)), (words) * sizeof*(p))

358
lib/bind/cylink/lbnppc.c
View file

@ -1,358 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
#include "lbnppc.h"
/*
* lbnppc.c - Assembly primitives for the bignum library, PowerPC version.
*
* Copyright (c) 1995 Colin Plumb. All rights reserved.
* For licensing and other legal details, see the file legal.c
*
* Register usage during function calls is:
* r0 - volatile
* r1 - stack pointer, preserved
* r2 - TOC pointer, preserved
* r3 - First argument and return value register
* r4-r10 - More argument registers, volatile
* r11-r12 - Volatile
* r13-r31 - Preserved
* LR, CTR, XER and MQ are all volatile.
* LR holds return address on entry.
*
* On the PPC 601, unrolling the loops more doesn't seem to speed things
* up at all. I'd be curious if other chips differed.
*/
#if __MWERKS__ < 0x800
#include "ppcasm.h" /* PowerPC assembler */
/*
* MulN1 expects (*out, *in, len, k), count >= 1
* r3 r4 r5 r6
*/
static const unsigned mulN1[] = {
PPC_LWZ(7,4,0), /* Load first word of in in r7 */
PPC_MULLW(8,7,6), /* Low half of multiply in r8 */
PPC_MTCTR(5), /* Move len into CTR */
PPC_ADDIC(0,0,0), /* Clear carry bit for loop */
PPC_MULHWU(5,7,6), /* High half of multiply in r5 */
PPC_STW(8,3,0),
PPC_BC(18,31,7), /* Branch to Label if --ctr == 0 */
/* Loop: */
PPC_LWZU(7,4,4), /* r7 = *++in */
PPC_MULLW(8,7,6), /* r8 = low word of product */
PPC_ADDE(8,8,5), /* Add carry word r5 and bit CF to r8 */
PPC_STWU(8,3,4), /* *++out = r8 */
PPC_MULHWU(5,7,6), /* r5 is high word of product, for carry word */
PPC_BC(16,31,-5), /* Branch to Loop if --ctr != 0 */
/* Label: */
PPC_ADDZE(5,5), /* Add carry flag to r5 */
PPC_STW(5,3,4), /* out[1] = r5 */
PPC_BLR()
};
/*
* MulAdd1 expects (*out, *in, len, k), count >= 1
* r3 r4 r5 r6
*/
static unsigned const mulAdd1[] = {
PPC_LWZ(7,4,0), /* Load first word of in in r7 */
PPC_LWZ(0,3,0), /* Load first word of out into r0 */
PPC_MULLW(8,7,6), /* Low half of multiply in r8 */
PPC_MTCTR(5), /* Move len into CTR */
PPC_MULHWU(5,7,6), /* High half of multiply in r5 */
PPC_ADDC(8,8,0), /* r8 = r8 + r0 */
PPC_STW(8,3,0), /* Store result to memory */
PPC_BC(18,31,10), /* Branch to Label if --ctr == 0 */
/* Loop: */
PPC_LWZU(7,4,4), /* r7 = *++in */
PPC_LWZU(0,3,4), /* r0 = *++out */
PPC_MULLW(8,7,6), /* r8 = low word of product */
PPC_ADDE(8,8,5), /* Add carry word r5 and carry bit CF to r8 */
PPC_MULHWU(5,7,6), /* r5 is high word of product, for carry word */
PPC_ADDZE(5,5), /* Add carry bit from low add to r5 */
PPC_ADDC(8,8,0), /* r8 = r8 + r0 */
PPC_STW(8,3,0), /* *out = r8 */
PPC_BC(16,31,-8), /* Branch to Loop if --ctr != 0 */
/* Label: */
PPC_ADDZE(3,5), /* Add carry flag to r5 and move to r3 */
PPC_BLR()
};
/*
* MulSub1 expects (*out, *in, len, k), count >= 1
* r3 r4 r5 r6
*
* Multiply and subtract is rather a pain. If the subtract of the
* low word of the product from out[i] generates a borrow, we want to
* increment the carry word (initially in the range 0..0xfffffffe).
* However, the PPC's carry bit CF is *clear* after a subtract, so
* we want to add (1-CF) to the carry word. This is done using two
* instructions:
*
* SUBFME, subtract from minus one extended. This computes
* rD = ~rS + 0xffffffff + CF. Since rS is from 0 to 0xfffffffe,
* ~rS is from 1 through 0xffffffff, and the sum with 0xffffffff+CF is
* from 0 through 0xfffffffff, setting the carry flag unconditionally, and
* NOR, which is used as a bitwise invert NOT instruction.
*
* The SUBFME performs the computation rD = ~rS + 0xffffffff + CF,
* = (-rS - 1) + (CF - 1) = -(rS - CF + 1) - 1 = ~(rS + 1-CF),
* which is the bitwise complement of the value we want.
* We want to add the complement of that result to the low word of the
* product, which is just what a subtract would do, if only we could get
* the carry flag clear. But it's always set, except for SUBFE, and the
* operation we just performed unconditionally *sets* the carry flag. Ugh.
* So find the complement in a separate instruction.
*/
static unsigned const mulSub1[] = {
PPC_LWZ(7,4,0), /* Load first word of in in r7 */
PPC_LWZ(0,3,0), /* Load first word of out into r0 */
PPC_MTCTR(5), /* Move len into CTR */
PPC_MULLW(8,7,6), /* Low half of multiply in r8 */
PPC_MULHWU(5,7,6), /* High half of multiply in r5 */
PPC_SUBFC(8,8,0), /* r8 = r0 - r8, setting CF */
PPC_STW(8,3,0), /* Store result to memory */
PPC_SUBFME(5,5), /* First of two insns to add (1-CF) to r5 */
PPC_BC(18,31,12), /* Branch to Label if --ctr == 0 */
/* Loop: */
PPC_LWZU(7,4,4), /* r7 = *++in */
PPC_LWZU(0,3,4), /* r0 = *++out */
PPC_NOR(5,5,5), /* Second of two insns to add (1-CF) to r5 */
PPC_MULLW(8,7,6), /* r8 = low word of product */
PPC_ADDC(8,8,5), /* Add carry word r5 to r8 */
PPC_MULHWU(5,7,6), /* r5 is high word of product, for carry word */
PPC_ADDZE(5,5), /* Add carry bit from low add to r5 */
PPC_SUBFC(8,8,0), /* r8 = r0 - r8, setting CF */
PPC_STW(8,3,0), /* *out = r8 */
PPC_SUBFME(5,5), /* First of two insns to add (1-CF) to r5 */
PPC_BC(16,31,-10), /* Branch to Loop if --ctr != 0 */
/* Label: */
PPC_NOR(3,5,5), /* Finish adding (1-CF) to r5, store in r3 */
PPC_BLR()
};
#if 0
/*
* Args: BNWORD32 *n, BNWORD32 const *mod, unsigned mlen, BNWORD32 inv)
* r3 r4 r5 r6
* r7, r8 and r9 are the triple-width accumulator.
* r0 and r10 are temporary registers.
* r11 and r12 are temporary pointers into n and mod, respectively.
* r2 (!) is another temporary register.
*/
static unsigned const montReduce[] = {
PPC_MTCTR(5), /* ??? */
PPC_LWZ(7,3,0), /* Load low word of n into r7 */
PPC_LWZ(10,4,0), /* Fetch low word of mod */
PPC_MULLW(0,7,6), /* Invert r7 into r0 */
PPC_STW(0,3,0), /* Store back for future use */
PPC_MULHWU(8,10,7), /* Get high word of whatnot */
PPC_MULLW(10,10,7), /* Get low word of it */
PPC_ADDC(7,7,10), /* Add low word of product to r7 */
PPC_ADDZE(8,8), /* Add carry to high word */
PPC_
PPC_MULHW(8,7,6),
PPC_ADDC(7,7,0), /* Add inverse back to r7 */
PPC_ADDZE(8,8),
PPC_
PPC_LWZU(
/* Loop: */
PPC_LWZU(0,11,4),
PPC_LWZU(10,23,-4),
PPC_MULLW(2,0,10),
PPC_ADDC(7,7,2),
PPC_MULHWU(0,0,10),
PPC_ADDE(8,8,0),
PPC_ADDZE(9,9),
PPC_BC(16,31,-7), /* Branch to Loop if --ctr != 0 */
PPC_ADDIC_(count,-1),
PPC_LWZU(0,x,4),
PPC_ADDC(0,7,0),
PPC_STW(0,x,0),
PPC_ADDZE(7,8),
PPC_ADDZE(8,9),
PPC_LI(9,0),
PPC_BC(xx,2,yy),
};
#endif
/*
* Three overlapped transition vectors for three functions.
* A PowerPC transition vector for a (potentially) inter-module
* jump or call consists of two words, an instruction address
* and a Table Of Contents (TOC) pointer, which is loaded into
* r1. Since none of the routines here have global variables,
* they don't need a TOC pointer, so the value is unimportant.
* This array places an unintersting 32-bit value after each address.
*/
unsigned const * const lbnPPC_tv[] = {
mulN1,
mulAdd1,
mulSub1,
0
};
#else /* __MWERKS >= 0x800 */
/*
* MulN1 expects (*out, *in, len, k), count >= 1
* r3 r4 r5 r6
*/
asm void
lbnMulN1_32(register unsigned *out, register unsigned const *in,
register unsigned len, register unsigned k)
{
lwz r7,0(in) /* Load first word of in in r7 */
mtctr len /* Move len into CTR */
mullw r8,r7,k /* Low half of multiply in r8 */
addic r0,r0,0 /* Clear carry bit for loop */
mulhwu len,r7,k /* High half of multiply in len */
stw r8,0(out) /* *out = r8 */
mulhwu len,r7,k /* len is high word of product, for carry */
bdz- label /* Branch to Label if --ctr == 0 */
loop:
lwzu r7,4(in) /* r7 = *++in */
mullw r8,r7,k /* Low half of multiply in r8 */
adde r8,r8,len /* Add carry word len and bit CF to r8 */
stwu r8,4(out) /* *++out = r8 */
mulhwu len,r7,k /* len is high word of product, for carry */
bdnz+ loop /* Branch to Loop if --ctr != 0 */
label:
addze len,len /* Add carry flag to carry word */
stw len,4(out)
blr
}
/*
* MulAdd1 expects (*out, *in, len, k), count >= 1
* r3 r4 r5 r6
*/
asm unsigned
lbnMulAdd1_32(register unsigned *out, register unsigned const *in,
register unsigned len, register unsigned k)
{
lwz r7,0(in) /* Load first word of in in r7 */
lwz r0,0(out) /* Load first word of out into r0 */
mullw r8,r7,k /* Low half of multiply in r8 */
mtctr len /* Move len into CTR */
mulhwu len,r7,k /* High half of multiply in len */
addc r8,r8,r0 /* r8 = r8 + r0 */
stw r8,0(out) /* Store result to memory */
bdz- label /* Branch to Label if --ctr == 0 */
loop:
lwzu r7,4(in) /* r7 = *++in */
lwzu r0,4(out) /* r0 = *++out */
mullw r8,r7,k /* r8 = low word of product */
adde r8,r8,len /* Add carry word len and carry bit CF to r8 */
mulhwu len,r7,k /* len is high word of product, for carry */
addze len,len /* Add carry bit from low add to r5 */
addc r8,r8,r0 /* r8 = r8 + r0 */
stw r8,0(out) /* *out = r8 */
bdnz+ loop /* Branch to Loop if --ctr != 0 */
label:
addze r3,r5 /* Add carry flag to r5 and move to r3 */
blr
}
/*
* MulSub1 expects (*out, *in, len, k), count >= 1
* r3 r4 r5 r6
*
* Multiply and subtract is rather a pain. If the subtract of the
* low word of the product from out[i] generates a borrow, we want to
* increment the carry word (initially in the range 0..0xfffffffe).
* However, the PPC's carry bit CF is *clear* after a subtract, so
* we want to add (1-CF) to the carry word. This is done using two
* instructions:
*
* SUBFME, subtract from minus one extended. This computes
* rD = ~rS + 0xffffffff + CF. Since rS is from 0 to 0xfffffffe,
* ~rS is from 1 through 0xffffffff, and the sum with 0xffffffff+CF is
* from 0 through 0xfffffffff, setting the carry flag unconditionally, and
* NOR, which is used as a bitwise invert NOT instruction.
*
* The SUBFME performs the computation rD = ~rS + 0xffffffff + CF,
* = (-rS - 1) + (CF - 1) = -(rS - CF + 1) - 1 = ~(rS + 1-CF),
* which is the bitwise complement of the value we want.
* We want to add the complement of that result to the low word of the
* product, which is just what a subtract would do, if only we could get
* the carry flag clear. But it's always set, except for SUBFE, and the
* operation we just performed unconditionally *sets* the carry flag. Ugh.
* So find the complement in a separate instruction.
*/
asm unsigned
lbnMulSub1_32(register unsigned *out, register unsigned const *in,
register unsigned len, register unsigned k)
{
lwz r7,0(in) /* Load first word of in in r7 */
lwz r0,0(out) /* Load first word of out into r0 */
mtctr len /* Move len into CTR */
mullw r8,r7,k /* Low half of multiply in r8 */
mulhwu len,r7,k /* High half of multiply in len */
subfc r8,r8,r0 /* r8 = r0 - r8, setting CF */
stw r8,0(out) /* Store result to memory */
subfme len,len /* First of two insns to add (1-CF) to len */
bdz- label /* Branch to Label if --ctr == 0 */
loop:
lwzu r7,4(in) /* r7 = *++in */
lwzu r0,4(out) /* r0 = *++out */
nor len,len,len /* Second of two insns to add (1-CF) to len */
mullw r8,r7,k /* r8 = low word of product */
addc r8,r8,len /* Add carry word len to r8 */
mulhwu len,r7,k /* len is high word of product, for carry */
addze len,len /* Add carry bit from low add to len */
subfc r8,r8,r0 /* r8 = r0 - r8 */
stw r8,0(out) /* *out = r8 */
subfme len,len /* First of two insns to add (1-CF) to len */
bdnz+ loop /* Branch to Loop if --ctr != 0 */
label:
nor r3,r5,r5 /* Finish adding (1-CF) to len, store in r3 */
blr
}
#endif /* __MWERKS >= 0x800 */
/* 45678901234567890123456789012345678901234567890123456789012345678901234567 */

98
lib/bind/cylink/lbnppc.h
View file

@ -1,98 +0,0 @@
#ifndef LBNPPC_H
#define LBNPPC_H
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* Assembly-language routines for the Power PC processor.
* Annoyingly, the Power PC does not have 64/32->32 bit divide,
* so the C code should be reasonably fast. But it does have
* 32x32->64-bit multiplies, and these routines provide access
* to that.
*
* In versions of CodeWarrior before 8.0, there was no PPC assembler,
* so a kludged-up one in CPP is used. This requires casting an
* array of unsigneds to function pointer type, and a function pointer
* is not a pointer to the code, but rather a pointer to a (code,TOC)
* pointer pair which we fake up.
*
* CodeWarrior 8.0 supports PCC assembly, which is used directly.
*/
/*
* Bignums are stored in arrays of 32-bit words, and the least
* significant 32-bit word has the lowest address, thus "little-endian".
* The C code is slightly more efficient this way, so unless the
* processor cares (the PowerPC, like most RISCs, doesn't), it is
* best to use BN_LITTLE_ENDIAN.
* Note that this has NOTHING to do with the order of bytes within a 32-bit
* word; the math library is insensitive to that.
*/
#define BN_LITTLE_ENDIAN 1
typedef unsigned bnword32;
#define BNWORD32 bnword32
#if __MWERKS__ < 0x800
/* Shared transition vector array */
extern unsigned const * const lbnPPC_tv[];
/* A function pointer on the PowerPC is a pointer to a transition vector */
#define lbnMulN1_32 \
((void (*)(bnword32 *, bnword32 const *, unsigned, bnword32))(lbnPPC_tv+0))
#define lbnMulAdd1_32 \
((bnword32 (*)(bnword32 *, bnword32 const *, unsigned, bnword32))(lbnPPC_tv+1))
#define lbnMulSub1_32 \
((bnword32 (*)(bnword32 *, bnword32 const *, unsigned, bnword32))(lbnPPC_tv+2))
#else /* __MWERKS__ >= 0x800 */
void lbnMulN1_32(bnword32 *, bnword32 const *, unsigned, bnword32);
#define lbnMulN1_32 lbnMulN1_32
bnword32 lbnMulAdd1_32(bnword32 *, bnword32 const *, unsigned, bnword32);
#define lbnMulAdd1_32 lbnMulAdd1_32
bnword32 lbnMulSub1_32(bnword32 *, bnword32 const *, unsigned, bnword32);
#define lbnMulSub1_32 lbnMulSub1_32
#endif /* __MWERKS__ >= 0x800 */
#endif /* LBNPPC_H */

45
lib/bind/cylink/legal.c
View file

@ -1,45 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/* Force inclusion of this... */
#include "legal.h"
volatile const char bnCopyright[] =
"bnlib 1.0.1 Copyright (c) 1995,1996 Colin Plumb.";

47
lib/bind/cylink/legal.h
View file

@ -1,47 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* ANSI C standard, section 3.5.3: "An object that has volatile-qualified
* type may be modified in ways unknown to the implementation or have
* other unknown side effects." Yes, we can't expect a compiler to
* understand law...
*/
extern volatile const char bnCopyright[];

1151
lib/bind/cylink/math.c
View file

File diff suppressed because it is too large Load diff

575
lib/bind/cylink/ppcasm.h
View file

@ -1,575 +0,0 @@
#ifndef PPCASM_H
#define PPCASM_H
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/*
* A PowerPC assembler in the C preprocessor.
* This assumes that ints are 32 bits, and uses them for the values.
*
* An assembly-language routine is simply an array of unsigned ints,
* initialized with the macros defined here.
*
* In the PowerPC, a generic function pointer does *not* point to the
* first word of code, but to a two (or possibly more) word "transition
* vector." The first word of the TV points to the function's code.
* The second word is the function's TOC (Table Of Contents) pointer,
* which is loaded into r2. The function's global variables are
* accessed via the TOC pointed to by r2. TOC pointers are changed,
* for example, when a dynamically linked library is called, so the
* library can have private global variables.
*
* Saving r2 and reloading r2 each function call is a hassle that
* I'd really rather avoid, since a lot of useful assembly language routines
* can be written without global variables at all, so they don't need a TOC
* pointer. But I haven't figured out how to persuade CodeWarrior 7 to
* generate an intra-TOC call to an array. (CodeWarrior 8 supports
* PowerPC asm, which obviates the need to do the cast-to-function-pointer
* trick, which obviates the need for cross-TOC calls.)
*
* The basic PowerPC calling conventions for integers are:
* r0 - scratch. May be modified by function calls.
* r1 - stack pointer. Must be preserved across function calls.
* See IMPORTANT notes on stack frame format below.
* This must *ALWAYS*, at every instruction boundary, be 16-byte
* aligned and point to a valid stack frame. If a procedure
* needs to create a stack frame, the recommended way is to do:
* stwu r1,-frame_size(r1)
* and on exit, recover with one of:
* addi r1,r1,frame_size, OR
* lwz r1,0(r1)
* r2 - TOC pointer. Points to the current table of contents.
* Must be preserved across function calls.
* r3 - First argument register and return value register.
* Arguments are passed in r3 through r10, and values returned in
* r3 through r6, as needed. (Usually only r3 for single word.)
* r4-r10 - More argument registers
* r11 - Scratch, may be modified by function calls.
* On entry to indirect function calls, this points to the
* transition vector, and additional words may be loaded
* at offsets from it. Some conventions use r12 instead.
* r12 - Scratch, may be modified by function calls.
* r13-r31 - Callee-save registers, may not be modified by function
* calls.
* The LR, CTR and XER may be modified by function calls, as may the MQ
* register, on those processors for which it is implemented.
* CR fields 0, 1, 5, 6 and 7 are scratch and may be modified by function
* calls. CR fields 2, 3 and 4 must be preserved across function calls.
*
* Stack frame format - READ
*
* r1 points to a stack frame, which must *ALWAYS*, meaning after each and
* every instruction, without excpetion, point to a valid 16-byte-aligned
* stack frame, defined as follows:
* - The 296 bytes below r1 (from -296(r1) to -1(r1)) are the so-called Red
* Zone reserved for leaf procedures, which may use it without allocating
* a stack frame and without decrementing r1. The size comes from the room
* needed to store all the callee-save registers: 19 64-bit integer registers
* and 18 64-bit floating-point registers. (18+19)*8 = 296. So any
* procedure can save all the registers it needs to save before creating
* a stack frame and moving r1.
* The bytes at -297(r1) and below may be used by interrupt and exception
* handlers *at any time*. Anything placed there may disappear before
* the next instruction.
* The word at 0(r1) is the previous r1, and so on in a linked list.
* This is the minimum needed to be a valid stack frame, but some other
* offsets from r1 are preallocated by the calling procedure for the called
* procedure's use. These are:
* Offset 0: Link to previous stack frame - saved r1, if the called
* procedure alters it.
* Offset 4: Saved CR, if the called procedure alters the callee-save
* fields. There's no important reason to save it here,
* but the space is reserved and you might as well use it
* for its intended purpose unless you have good reason to
* do otherwise. (This may help some debuggers.)
* Offset 8: Saved LR, if the called procedure needs to save it for
* later function return. Saving the LR here helps a debugger
* track the chain of return addresses on the stack.
* Note that a called procedure does not need to preserve the
* LR for it's caller's sake, but it uually wants to preserve
* the value for its own sake until it finishes and it's
* time to return. At that point, this is usually loaded
* back into the LR and the branch accomplished with BLR.
* However, if you want to be preverse, you could load it
* into the CTR and use BCTR instead.
* Offset 12: Reserved to compiler. I can't find what this is for.
* Offset 16: Reserved to compiler. I can't find what this is for.
* Offset 20: Saved TOC pointer. In a cross-TOC call, the old TOC (r2)
* is saved here before r2 is loaded with the new TOC value.
* Again, it's not important to use this slot for this, but
* you might as well.
* Beginning at offset 24 is the argument area. This area is at least 8 words
* (32 bytes; I don't know what happens with 64 bits) long, and may be longer,
* up to the length of the longest argument list in a function called by
* the function which allocated this stack frame. Generally, arguments
* to functions are passed in registers, but if those functions notice
* the address of the arguments being taken, the registers are stored
* into the space reserved for them in this area and then used from memory.
* Additional arguments that will not fit into registers are also stored
* here. Variadic functions (like printf) generally start by saving
* all the integer argument registers from the "..." onwards to this space.
* For that reason, the space must be large enough to store all the argument
* registers, even if they're never used.
* (It could probably be safely shrunk if you're not calling any variadic
* functions, but be careful!)
*
* Offsets above that are private to the calling function and shouldn't
* be messed with. Generally, what appears there is locals, then saved
* registers.
*
*
* The floating-point instruction set isn't implemented yet (I'm too
* lazy, as I don't need it yet), but for when it is, the register
* usage convention is:
* FPSCR - Scratch, except for floating point exception enable fields,
* which should only be modified by functions defined to do so.
* fr0 - scratch
* fr1 - first floating point parameter and return value, scratch
* fr2 - second floating point parameter and return value (if needed), scratch
* fr3 - third floating point parameter and return value (if needed), scratch
* fr4 - fourth floating point parameter and return value (if needed), scratch
* fr5-fr13 - More floating point argument registers, scratch
* fr14-fr31 - Callee-save registers, may not be modified across a function call
*
* Complex values store the real part in the lower-numberd register of a pair.
* When mixing floating-point and integer arguments, reserve space (one register
* for single-precision, two for double-precision values) in the integer
* argument list for the floating-point values. Those integer registers
* generally have undefined values, UNLESS there is no prototype for the call,
* in which case they should contain a copy of the floating-point value's
* bit pattern to cope with wierd software.
* If the floating point arguments go past the end of the integer registers,
* they are stored in the argument area as well as being passed in here.
*
* After the argument area comes the calling function's private storage.
* Typically, there are locals, followed by saved GP rgisters, followed
* by saved FP registers.
*
* Suggested instruction for allocating a stack frame:
* stwu r1,-frame_size(r1)
* Suggested instructions for deallocating a stack frame:
* addi r1,r1,frame_size
* or
* lwz r1,0(r1)
* If frame_size is too big, you'll have to load the offset into a temp
* register, but be sure that r1 is updated atomically.
*
*
* Basic PowerPC instructions look like this:
*
* 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Opcode | | | | | | | | | | | | | | | | | | | | | | | | | | |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* Branch instructions look like this:
*
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Opcode | Branch offset |A|L|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* The L, or LK, or Link bit indicates that the return address for the
* branch should be copied to the link register (LR).
* The A, or AA, or absolute address bit, indicates that the address
* of the current instruction (NOTE: not next instruction!) should NOT
* be added to the branch offset; it is relative to address 0.
*
* Conditional branches looks like this:
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Opcode | BO | BI | Branch offset |A|L|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* The BI field specifies the condition bit of interest (from the CR).
* The BO field specifies what's interesting. You can branch on a
* combination of a bit of the condition register and --ctr, the CTR
* register. Two bits encode the branch condition to use:
* BRANCH IF
* 00--- = Bit BI is 0
* 01--- = Bit BI is 1
* 1z--- = don't care about bit BI (always true)
* AND
* --00- = --ctr != 0
* --01- = --ctr == 0
* --1z- = don't decrement ctr (always true)
* The last bit us used as a branch prediction bit. If set, it reverses
* the usual backward-branch-taken heuristic.
*
* y = branch prediction bit. z = unused, must be 0
* 0000y - branch if --ctr != 0 && BI == 0
* don't branch if --ctr == 0 || BI != 0
* 0001y - branch if --ctr == 0 && BI == 0
* don't branch if --ctr != 0 || BI != 0
* 001zy - branch if BI == 0
* don't branch if BI != 0
* 0100y - branch if --ctr != 0 && BI != 0
* don't branch if --ctr == 0 || BI == 0
* 0101y - branch if --ctr == 0 && BI != 0
* don't branch if --ctr != 0 || BI == 0
* 011zy - branch if BI != 0
* don't branch if BI == 0
* 1z00y - branch if --ctr != 0
* don't branch if --ctr == 0
* 1z01y - branch if --ctr == 0
* don't branch if --ctr != 0
* 1z1zz - branch always
* If y is 1, the usual branch prediction (usually not taken, taken for
* backwards branches with immediate offsets) is reversed.
*
* Instructions with 2 operands and a 16-bit immediate field look like this:
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Opcode | D | A | 16-bit immediate value |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* Now, there are three variations of note. In some instructions, the 16-bit
* value is sign-extended. In others, it's zero-extended. These are noted
* below as "simm" (signed immediate) and "uimm", respectively. Also, which
* field is the destination and which is the source sometimes switches.
* Sometimes it's d = a OP imm, and sometimes it's a = s OP imm. In the
* latter cases, the "d" field is referred to as "s" ("source" instead of
* "destination". These are logical and shift instructions. (Store also
* refers to the s register, but that's the source of the value to be stored.)
* The assembly mnemonics, however, always lists the destination first,
* swapping the order in the instruction if necessary.
* Third, quite often, if r0 is specified for the source a, then the constant
* value 0 is used instead. Thus, r0 is of limited use - it can be used for
* some things, but not all.
*
* Instructions with three register operands look like this:
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | Opcode | D | A | B | Subopcode |C|
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*
* For most of the instructions of interest the Opcode is 31 and the subopcode
* determines what the instruction does. For a few instructions (mostly loads
* and stores), if the A field is 0, the constant 0 is used. The "C"
* bit (also known as the "RC" bit) controls whether or not the condition
* codes are updated. If it is set (indicated by a "." suffix on the official
* PowerPC opcodes, and a "_" suffix on these macros), condition code register
* field 0 (for integer instructions; field 1 for floating point) is updated
* to reflect the result of the operation.
* Some arithmetic instructions use the most significant bit of the subopcode
* field as an overflow enable bit (o suffix).
*
* Then there are the rotate and mask instructions, which have 5 operands, and
* fill the subopcode field with 2 more 5-bit fields. See below for them.
*
* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
* These macros fully parenthesize their arguments, but are not themselves
* fully parenthesized. They are intended to be used for initializer lists,
* and if you want to do tricks with their numeric values, wrap them in
* parentheses.
*/
#define PPC_MAJOR(x) ((x)<<26) /* Major opcode (0..63) */
#define PPC_MINOR(x) ((x)<<1) /* Minor opcode (0..1023) */
#define PPC_RC 1 /* Record carry (. suffix, represented as _) */
#define PPC_OE 1024 /* Overflow enable (o suffix) */
#define PPC_DEST(reg) ((reg)<<21) /* Dest register field */
#define PPC_SRCA(reg) ((reg)<<16) /* First source register field */
#define PPC_SRCB(reg) ((reg)<<11) /* Second source register field */
#define PPC_AA 2 /* Branch is absolute, relative to address 0 */
#define PPC_LK 1 /* Branch with link (L suffix) */
/* Unconditional branch (dest is 26 bits, +/- 2^25 bytes) */
#define PPC_B(dest) PPC_MAJOR(18)|(((dest)<<2) & 0x03fffffc)
#define PPC_BA(dest) PPC_B(dest)|PPC_AA
#define PPC_BL(dest) PPC_B(dest)|PPC_LK
#define PPC_BLA(dest) PPC_B(dest)|PPC_AA|PPC_LK
/* Three-operand instructions */
#define PPC_TYPE31(minor,d,a,b) \
PPC_MAJOR(31)|PPC_DEST(d)|PPC_SRCA(a)|PPC_SRCB(b)|PPC_MINOR(minor)
#define PPC_ADD(d,a,b) PPC_TYPE31(266,d,a,b)
#define PPC_ADD_(d,a,b) PPC_TYPE31(266,d,a,b)|PPC_RC
#define PPC_ADDO(d,a,b) PPC_TYPE31(266,d,a,b)|PPC_OE
#define PPC_ADDO_(d,a,b) PPC_TYPE31(266,d,a,b)|PPC_OE|PPC_RC
#define PPC_ADDC(d,a,b) PPC_TYPE31(10,d,a,b)
#define PPC_ADDC_(d,a,b) PPC_TYPE31(10,d,a,b)|PPC_RC
#define PPC_ADDCO(d,a,b) PPC_TYPE31(10,d,a,b)|PPC_OE
#define PPC_ADDCO_(d,a,b) PPC_TYPE31(10,d,a,b)|PPC_OE|PPC_RC
#define PPC_ADDE(d,a,b) PPC_TYPE31(138,d,a,b)
#define PPC_ADDE_(d,a,b) PPC_TYPE31(138,d,a,b)|PPC_RC
#define PPC_ADDEO(d,a,b) PPC_TYPE31(138,d,a,b)|PPC_OE
#define PPC_ADDEO_(d,a,b) PPC_TYPE31(138,d,a,b)|PPC_OE|PPC_RC
#define PPC_ADDME(d,a) PPC_TYPE31(234,d,a,0)
#define PPC_ADDME_(d,a) PPC_TYPE31(234,d,a,0)|PPC_RC
#define PPC_ADDMEO(d,a) PPC_TYPE31(234,d,a,0)|PPC_OE
#define PPC_ADDMEO_(d,a) PPC_TYPE31(234,d,a,0)|PPC_OE|PPC_RC
#define PPC_ADDZE(d,a) PPC_TYPE31(202,d,a,0)
#define PPC_ADDZE_(d,a) PPC_TYPE31(202,d,a,0)|PPC_RC
#define PPC_ADDZEO(d,a) PPC_TYPE31(202,d,a,0)|PPC_OE
#define PPC_ADDZEO_(d,a) PPC_TYPE31(202,d,a,0)|PPC_OE|PPC_RC
#define PPC_AND(a,s,b) PPC_TYPE31(28,s,a,b)
#define PPC_AND_(a,s,b) PPC_TYPE31(28,s,a,b)|PPC_RC
#define PPC_ANDC(a,s,b) PPC_TYPE31(60,s,a,b)
#define PPC_ANDC_(a,s,b) PPC_TYPE31(60,s,a,b)|PPC_RC
#define PPC_CMP(cr,a,b) PPC_TYPE31(0,(cr)<<2,a,b)
#define PPC_CMPL(cr,a,b) PPC_TYPE31(32,(cr)<<2,a,b)
#define PPC_CNTLZW(a,s) PPC_TYPE31(26,s,a,0)
#define PPC_CNTLZW_(a,s) PPC_TYPE31(26,s,a,0)|PPC_RC
#define PPC_DCBF(a,b) PPC_TYPE31(86,0,a,b)
#define PPC_DCBI(a,b) PPC_TYPE31(470,0,a,b)
#define PPC_DCBST(a,b) PPC_TYPE31(54,0,a,b)
#define PPC_DCBT(a,b) PPC_TYPE31(278,0,a,b)
#define PPC_DCBTST(a,b) PPC_TYPE31(246,0,a,b)
#define PPC_DCBZ(a,b) PPC_TYPE31(1014,0,a,b)
#define PPC_DIVW(d,a,b) PPC_TYPE31(491,d,a,b)
#define PPC_DIVW_(d,a,b) PPC_TYPE31(491,d,a,b)|PPC_RC
#define PPC_DIVWO(d,a,b) PPC_TYPE31(491,d,a,b)|PPC_OE
#define PPC_DIVWO_(d,a,b) PPC_TYPE31(491,d,a,b)|PPC_OE|PPC_RC
#define PPC_DIVWU(d,a,b) PPC_TYPE31(459,d,a,b)
#define PPC_DIVWU_(d,a,b) PPC_TYPE31(459,d,a,b)|PPC_RC
#define PPC_DIVWUO(d,a,b) PPC_TYPE31(459,d,a,b)|PPC_OE
#define PPC_DIVWUO_(d,a,b) PPC_TYPE31(459,d,a,b)|PPC_OE|PPC_RC
#define PPC_EIEIO() PPC_TYPE31(854,0,0,0)
#define PPC_EQV(a,s,b) PPC_TYPE31(284,s,a,b)
#define PPC_EQV_(a,s,b) PPC_TYPE31(284,s,a,b)|PPC_RC
#define PPC_EXTSB(a,s,b) PPC_TYPE31(954,s,a,b)
#define PPC_EXTSB_(a,s,b) PPC_TYPE31(954,s,a,b)|PPC_RC
#define PPC_EXTSH(a,s,b) PPC_TYPE31(922,s,a,b)
#define PPC_EXTSH_(a,s,b) PPC_TYPE31(922,s,a,b)|PPC_RC
#define PPC_ICBI(a,b) PPC_TYPE31(982,0,a,b)
#define PPC_ISYNC() PPC_TYPE31(150,0,0,0)
#define PPC_LBZUX(d,a,b) PPC_TYPE31(119,d,a,b)
#define PPC_LBZX(d,a,b) PPC_TYPE31(87,d,a,b)
#define PPC_LHAUX(d,a,b) PPC_TYPE31(375,d,a,b)
#define PPC_LHAX(d,a,b) PPC_TYPE31(343,d,a,b)
#define PPC_LHBRX(d,a,b) PPC_TYPE31(790,d,a,b)
#define PPC_LHZUX(d,a,b) PPC_TYPE31(311,d,a,b)
#define PPC_LHZX(d,a,b) PPC_TYPE31(279,d,a,b)
#define PPC_LSWI(d,a,nb) PPC_TYPE31(597,d,a,nb)
#define PPC_LSWX(d,a,b) PPC_TYPE31(533,d,a,b)
#define PPC_LSARX(d,a,b) PPC_TYPE31(20,d,a,b)
#define PPC_LSBRX(d,a,b) PPC_TYPE31(534,d,a,b)
#define PPC_MCRXR(crd) PPC_TYPE31(512,(crd)<<2,0,0)
#define PPC_MFCR(d) PPC_TYPE31(19,d,0,0)
#define PPC_MFSPR(d,spr) PPC_TYPE31(339,d,(spr)&31,(spr)>>5)
#define PPC_MFTB(d) PPC_TYPE31(371,d,12,8)
#define PPC_MFTBU(d) PPC_TYPE31(371,d,13,8)
#define PPC_MTCRF(mask,s) PPC_TYPE31(144,s,0,(mask)&0xff)
#define PPC_MTSPR(s,spr) PPC_TYPE31(467,s,(spr)&31,(spr)>>5)
#define PPC_MULHW(d,a,b) PPC_TYPE31(75,d,a,b)
#define PPC_MULHW_(d,a,b) PPC_TYPE31(75,d,a,b)|PPC_RC
#define PPC_MULHWU(d,a,b) PPC_TYPE31(11,d,a,b)
#define PPC_MULHWU_(d,a,b) PPC_TYPE31(11,d,a,b)|PPC_RC
#define PPC_MULLW(d,a,b) PPC_TYPE31(235,d,a,b)
#define PPC_MULLW_(d,a,b) PPC_TYPE31(235,d,a,b)|PPC_RC
#define PPC_MULLWO(d,a,b) PPC_TYPE31(235,d,a,b)|PPC_OE
#define PPC_MULLWO_(d,a,b) PPC_TYPE31(235,d,a,b)|PPC_OE|PPC_RC
#define PPC_NAND(a,s,b) PPC_TYPE31(476,s,a,b)
#define PPC_NAND_(a,s,b) PPC_TYPE31(476,s,a,b)|PPC_RC
#define PPC_NEG(d,a) PPC_TYPE31(104,d,a,b)
#define PPC_NEG_(d,a) PPC_TYPE31(104,d,a,b)|PPC_RC
#define PPC_NEGO(d,a) PPC_TYPE31(104,d,a,b)|PPC_OE
#define PPC_NEGO_(d,a) PPC_TYPE31(104,d,a,b)|PPC_OE|PPC_RC
#define PPC_NOR(a,s,b) PPC_TYPE31(124,s,a,b)
#define PPC_NOR_(a,s,b) PPC_TYPE31(124,s,a,b)|PPC_RC
#define PPC_OR(a,s,b) PPC_TYPE31(444,s,a,b)
#define PPC_OR_(a,s,b) PPC_TYPE31(444,s,a,b)|PPC_RC
#define PPC_ORC(a,s,b) PPC_TYPE31(412,s,a,b)
#define PPC_ORC_(a,s,b) PPC_TYPE31(412,s,a,b)|PPC_RC
#define PPC_SLW(a,s,b) PPC_TYPE31(24,s,a,b)
#define PPC_SLW_(a,s,b) PPC_TYPE31(24,s,a,b)|PPC_RC
#define PPC_SRAW(a,s,b) PPC_TYPE31(792,s,a,b)
#define PPC_SRAW_(a,s,b) PPC_TYPE31(792,s,a,b)|PPC_RC
#define PPC_SRAWI(a,s,sh) PPC_TYPE31(824,s,a,sh)
#define PPC_SRAWI_(a,s,sh) PPC_TYPE31(824,s,a,sh)|PPC_RC
#define PPC_SRW(a,s,b) PPC_TYPE31(536,s,a,b)
#define PPC_SRW_(a,s,b) PPC_TYPE31(536,s,a,b)|PPC_RC
#define PPC_STBUX(s,a,b) PPC_TYPE31(247,s,a,b)
#define PPC_STBX(s,a,b) PPC_TYPE31(215,s,a,b)
#define PPC_STHBRX(s,a,b) PPC_TYPE31(918,s,a,b)
#define PPC_STHUX(s,a,b) PPC_TYPE31(439,s,a,b)
#define PPC_STHX(s,a,b) PPC_TYPE31(407,s,a,b)
#define PPC_STSWI(s,a,nb) PPC_TYPE31(725,s,a,nb)
#define PPC_STSWX(s,a,b) PPC_TYPE31(661,s,a,b)
#define PPC_STWBRX(s,a,b) PPC_TYPE31(662,s,a,b)
#define PPC_STWCX_(s,a,b) PPC_TYPE31(150,s,a,b)|PPC_RC
#define PPC_STWUX(s,a,b) PPC_TYPE31(183,s,a,b)
#define PPC_STWX(s,a,b) PPC_TYPE31(151,s,a,b)
#define PPC_SUBF(d,a,b) PPC_TYPE31(40,d,a,b)
#define PPC_SUBF_(d,a,b) PPC_TYPE31(40,d,a,b)|PPC_RC
#define PPC_SUBFO(d,a,b) PPC_TYPE31(40,d,a,b)|PPC_OE
#define PPC_SUBFO_(d,a,b) PPC_TYPE31(40,d,a,b)|PPC_OE|PPC_RC
#define PPC_SUB(d,b,a) PPC_SUBF(d,a,b)
#define PPC_SUB_(d,b,a) PPC_SUBF_(d,a,b)
#define PPC_SUBO(d,b,a) PPC_SUBFO(d,a,b)
#define PPC_SUBO_(d,b,a) PPC_SUBFO_(d,a,b)
#define PPC_SUBFC(d,a,b) PPC_TYPE31(8,d,a,b)
#define PPC_SUBFC_(d,a,b) PPC_TYPE31(8,d,a,b)|PPC_RC
#define PPC_SUBFCO(d,a,b) PPC_TYPE31(8,d,a,b)|PPC_OE
#define PPC_SUBFCO_(d,a,b) PPC_TYPE31(8,d,a,b)|PPC_OE|PPC_RC
#define PPC_SUBFE(d,a,b) PPC_TYPE31(136,d,a,b)
#define PPC_SUBFE_(d,a,b) PPC_TYPE31(136,d,a,b)|PPC_RC
#define PPC_SUBFEO(d,a,b) PPC_TYPE31(136,d,a,b)|PPC_OE
#define PPC_SUBFEO_(d,a,b) PPC_TYPE31(136,d,a,b)|PPC_OE|PPC_RC
#define PPC_SUBFME(d,a) PPC_TYPE31(232,d,a,0)
#define PPC_SUBFME_(d,a) PPC_TYPE31(232,d,a,0)|PPC_RC
#define PPC_SUBFMEO(d,a) PPC_TYPE31(232,d,a,0)|PPC_OE
#define PPC_SUBFMEO_(d,a) PPC_TYPE31(232,d,a,0)|PPC_OE|PPC_RC
#define PPC_SUBFZE(d,a) PPC_TYPE31(200,d,a,0)
#define PPC_SUBFZE_(d,a) PPC_TYPE31(200,d,a,0)|PPC_RC
#define PPC_SUBFZEO(d,a) PPC_TYPE31(200,d,a,0)|PPC_OE
#define PPC_SUBFZEO_(d,a) PPC_TYPE31(200,d,a,0)|PPC_OE|PPC_RC
#define PPC_SYNC() PPC_TYPE31(598,0,0,0)
#define PPC_TW(to,a,b) PPC_TYPE31(4,to,a,b)
#define PPC_XOR(a,s,b) PPC_TYPE31(316,s,a,b)
/* Immediate-operand instructions. Take a 16-bit immediate operand */
#define PPC_IMM(major,d,a,imm) \
PPC_MAJOR(major)|PPC_DEST(d)|PPC_SRCA(a)|((imm)&0xffff)
/* Trap word immediate */
#define PPV_TWI(to,a,simm) PPC_IMM(3,to,a,simm)
/* Integer arithmetic */
#define PPC_MULLI(d,a,simm) PPC_IMM(7,d,a,simm)
#define PPC_SUBFIC(s,a,simm) PPC_IMM(8,s,a,simm)
#define PPC_CMPLI(cr,a,uimm) PPC_IMM(10,(cr)<<2,a,uimm)
#define PPC_CMPI(cr,a,simm) PPC_IMM(11,(cr)<<2,a,simm)
#define PPC_ADDIC(d,a,simm) PPC_IMM(12,d,a,simm)
#define PPC_ADDIC_(d,a,simm) PPC_IMM(13,d,a,simm)
#define PPC_ADDI(d,a,simm) PPC_IMM(14,d,a,simm)
#define PPC_ADDIS(d,a,simm) PPC_IMM(15,d,a,simm)
/* Conditional branch (dest is 16 bits, +/- 2^15 bytes) */
#define PPC_BC(bo,bi,dest) PPC_IMM(16,bo,bi,((dest)<<2)&0xfffc)
#define PPC_BCA(bo,bi,dest) PPC_BC(bo,bi,dest)|PPC_AA
#define PPC_BCL(bo,bi,dest) PPC_BC(bo,bi,dest)|PPC_LK
#define PPC_BCLA(bo,bi,dest) PPC_BC(bo,bi,dest)|PPC_AA|PPC_LK
/* Logical operations */
#define PPC_ORI(a,s,uimm) PPC_IMM(24,s,a,uimm)
#define PPC_ORIS(a,s,uimm) PPC_IMM(25,s,a,uimm)
#define PPC_XORI(a,s,uimm) PPC_IMM(26,s,a,uimm)
#define PPC_XORIS(a,s,uimm) PPC_IMM(27,s,a,uimm)
#define PPC_ANDI_(a,s,uimm) PPC_IMM(28,s,a,uimm)
#define PPC_ANDIS(a,s,uimm) PPC_IMM(29,s,a,uimm)
/* Load/store */
#define PPC_LWZ(d,a,simm) PPC_IMM(32,d,a,simm)
#define PPC_LWZU(d,a,simm) PPC_IMM(33,d,a,simm)
#define PPC_LBZ(d,a,simm) PPC_IMM(34,d,a,simm)
#define PPC_LBZU(d,a,simm) PPC_IMM(35,d,a,simm)
#define PPC_STW(s,a,simm) PPC_IMM(36,s,a,simm)
#define PPC_STWU(s,a,simm) PPC_IMM(37,s,a,simm)
#define PPC_STB(s,a,simm) PPC_IMM(38,s,a,simm)
#define PPC_STBU(s,a,simm) PPC_IMM(39,s,a,simm)
#define PPC_LHZ(d,a,simm) PPC_IMM(40,d,a,simm)
#define PPC_LHZU(d,a,simm) PPC_IMM(41,d,a,simm)
#define PPC_LHA(d,a,simm) PPC_IMM(42,d,a,simm)
#define PPC_STH(s,a,simm) PPC_IMM(44,s,a,simm)
#define PPC_STHU(s,a,simm) PPC_IMM(45,s,a,simm)
#define PPC_LHAU(d,a,simm) PPC_IMM(43,d,a,simm)
#define PPC_LMW(d,a,simm) PPC_IMM(46,d,a,simm)
#define PPC_STMW(s,a,simm) PPC_IMM(47,s,a,simm)
/* Major number = 19 - condition register operations. d, a and b are CR bits */
#define PPC_TYPE19(minor,d,a,b) \
PPC_MAJOR(19)|PPC_DEST(d)|PPC_SRCA(a)|PPC_SRCB(b)|PPC_MINOR(minor)
#define PPC_MCRF(d,s) PPC_TYPE19(0,(d)<<2,(s)<<2,0)
#define PPC_CRNOR(d,a,b) PPC_TYPE19(33,d,a,b)
#define PPC_CRANDC(d,a,b) PPC_TYPE19(129,d,a,b)
#define PPC_CRXOR(d,a,b) PPC_TYPE19(193,d,a,b)
#define PPC_CRNAND(d,a,b) PPC_TYPE19(225,d,a,b)
#define PPC_CRAND(d,a,b) PPC_TYPE19(257,d,a,b)
#define PPC_CREQV(d,a,b) PPC_TYPE19(289,d,a,b)
#define PPC_CRORC(d,a,b) PPC_TYPE19(417,d,a,b)
#define PPC_CROR(d,a,b) PPC_TYPE19(449,d,a,b)
/* Indirect conditional branch */
#define PPC_BCLR(bo,bi) PPC_TYPE19(16,bo,bi,0)
#define PPC_BCLRL(bo,bi) PPC_TYPE19(16,bo,bi,0)|PPC_LK
#define PPC_BCCTR(bo,bi) PPC_TYPE19(528,bo,bi,0)
#define PPC_BCCTRL(bo,bi) PPC_TYPE19(528,bo,bi,0)|PPC_LK
#define PPC_BLR() PPC_BCLR(20,31)
#define PPC_BCTR() PPC_BCCTR(20,31)
/* Other */
#define PPC_RLWIMI(a,s,sh,mb,me) \
PPC_MAJOR(20)|PPC_DEST(s)|PPC_SRCA(A)|PPC_SRCB(sh)|(mb)<<6|(me)<<1
#define PPC_RLWIMI_(a,s,sh,mb,me) PPC_RLWIMI(a,s,sh,mb,me)|PPC_RC
#define PPC_RLWINM(a,s,sh,mb,me) \
PPC_MAJOR(21)|PPC_DEST(s)|PPC_SRCA(A)|PPC_SRCB(sh)|(mb)<<6|(me)<<1
#define PPC_RLWINM_(a,s,sh,mb,me) PPC_RLWINM(a,s,sh,mb,me)|PPC_RC
#define PPC_RLWNM(a,s,b,mb,me) \
PPC_MAJOR(23)|PPC_DEST(s)|PPC_SRCA(A)|PPC_SRCB(b)|(mb)<<6|(me)<<1
#define PPC_RLWNM_(a,s,b,mb,me) PPC_RLWNM(a,s,b,mb,me)|PPC_RC
#define PPC_SC() PPC_MAJOR(17)|2
/* Major number = 63 Floating-point operations (not implemented for now) */
/* Simplified Mnemonics */
/* Fabricate immediate subtract out of add negative */
#define PPC_SUBI(d,a,simm) PPC_ADDI(d,a,-(simm))
#define PPC_SUBIS(d,a,simm) PPC_ADDIS(d,a,-(simm))
#define PPC_SUBIC(d,a,simm) PPC_ADDIC(d,a,-(simm))
#define PPC_SUBIC_(d,a,simm) PPC_ADDIC_(d,a,-(simm))
/* Fabricate subtract out of subtract from */
#define PPC_SUBC(d,b,a) PPC_SUBFC(d,a,b)
#define PPC_SUBC_(d,b,a) PPC_SUBFC_(d,a,b)
#define PPC_SUBCO(d,b,a) PPC_SUBFCO(d,a,b)
#define PPC_SUBCO_(d,b,a) PPC_SUBFCO_(d,a,b)
/* Messy compare bits omitted */
/* Shift and rotate omitted */
/* Branch coding omitted */
#define PPC_CRSET(d) PPC_CREQV(d,d,d)
#define PPC_CRCLR(d) PPC_CRXOR(d,d,d)
#define PPC_CRMOVE(d,s) PPC_CROR(d,s,s)
#define PPC_CRNOT(d,s) PPC_CRNOR(d,s,s)
/* Trap menmonics omitted */
/* Menmonics for user-accessible SPRs */
#define PPC_MFXER(d) PPC_MFSPR(d,1)
#define PPC_MFLR(d) PPC_MFSPR(d,8)
#define PPC_MFCTR(d) PPC_MFSPR(d,9)
#define PPC_MTXER(s) PPC_MTSPR(s,1)
#define PPC_MTLR(s) PPC_MTSPR(s,8)
#define PPC_MTCTR(s) PPC_MTSPR(s,9)
/* Recommended mnemonics */
#define PPC_NOP() PPC_ORI(0,0,0)
#define PPC_LI(d,simm) PPC_ADDI(d,0,simm)
#define PPC_LIS(d,simm) PPC_ADDIS(d,0,simm)
#define PPC_LA(d,a,simm) PPC_ADDI(d,a,simm)
#define PPC_MR(d,s) PPC_OR(d,s,s)
#define PPC_NOT(d,s) PPC_NOR(d,s,s)
#define PPC_MTCR(s) PPC_MTCRF(0xff,s)
#endif /* PPCASM_H */
/* 45678901234567890123456789012345678901234567890123456789012345678901234567 */

333
lib/bind/cylink/rand.c
View file

@ -1,333 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: rand.c PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Cryptographic Toolkit Functions File
* Random Number Generation Files
* PUBLIC FUNCTIONS:
* int InitRand( u_int16_t SEED_bytes, uchar *SEED,
* uchar *RVAL )
* int GenRand( u_int16_t A_bytes, uchar *A,
* uchar *RVAL )
* int MyGenRand( u_int16_t A_bytes,
* ord *A,
* ord *RVAL )
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 10 Oct 94 KPZ Added Shamir Key Sharing functions
* 10 Oct 94 KPZ Modified SHA functions for arbitrary message length
* 12 Oct 94 KPZ Modified SHA functions (new standard)
* 14 Oct 94 GKL Second version (big endian support)
* 26 Oct 94 GKL (alignment for big endian support & ERR_ALLOC)
*
****************************************************************************/
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
#include "port_before.h"
/* system files */
#ifdef VXD
#include <vtoolsc.h>
#else
#include <stdlib.h>
#include <string.h>
#endif
/* program files */
#ifdef VXD
#include "tkvxd.h"
#endif
#include "cylink.h"
#include "ctk_endian.h"
#include "toolkit.h"
#include "cencrint.h"
#include "sha.h"
#include "port_after.h"
extern u_int16_t DataOrder;
/****************************************************************************
* PUBLIC FUNCTIONS DEFINITIONS
****************************************************************************/
/****************************************************************************
* NAME: int InitRand( u_int16_t SEED_bytes,
* uchar *SEED,
* uchar *RVAL)
*
* DESCRIPTION: Initialize Random number Generator
*
* INPUTS:
* PARAMETERS:
* u_int16_t SEED_bytes Length of SEED
* uchar *SEED Pointer to SEED value
*
* OUTPUT:
* PARAMETERS:
* uchar *RVAL Pointer to RVAL
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data
* ERR_DATA Generic data error
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
*
****************************************************************************/
int InitRand( u_int16_t SEED_bytes,
uchar *SEED,
uchar *RVAL )
{
int status = SUCCESS; /* function return status */
if ( SEED_bytes == 0 )
{
status = ERR_INPUT_LEN;
return status;
}
if ( SEED_bytes < SHA_LENGTH )
{
status = ERR_DATA;
return status;
}
memcpy( RVAL, SEED, SHA_LENGTH);
return status;
}
/****************************************************************************
* NAME: int GenRand( u_int16_t A_bytes,
* uchar *A,
* uchar *RVAL)
*
* DESCRIPTION: Generate random number.
*
* INPUTS:
* PARAMETERS:
* u_int16_t A_bytes Length of A
* uchar *A Pointer to A value
*
* OUTPUT:
* PARAMETERS:
* uchar *RVAL Pointer to RVAL
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data
* ERR_DATA Generic data error
* ERR_ALLOC Insufficient memory
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
* 26 Oct 94 GKL (alignment for big endian support & ERR_ALLOC)
*
****************************************************************************/
int GenRand( u_int16_t A_bytes,
uchar *A,
uchar *RVAL )
{
int status = SUCCESS; /* function return status */
ord *RVAL_a;
SHA_context hash_context; /* SHA context structure */
uchar M[DSS_LENGTH_MIN]; /* message block */
uchar hash_result[SHA_LENGTH];
u_int16_t i;
u_int16_t sha_block; /* number of sha blocks */
u_int16_t sha_rem; /* size of last block */
if ( A_bytes == 0 )
{
status = ERR_INPUT_LEN;
return status;
}
sha_block = (u_int16_t) (A_bytes / SHA_LENGTH); /* number of sha blocks */
sha_rem = (u_int16_t) (A_bytes % SHA_LENGTH); /* size of last block */
if ( sha_rem == 0 ) /* last block = SHA_LENGTH */
{
sha_block--;
}
for ( i = 0; i <= sha_block; i++)
{
SHAInit ( &hash_context );
memcpy( M, RVAL, SHA_LENGTH);
memset( M + SHA_LENGTH, 0, DSS_LENGTH_MIN - SHA_LENGTH );
if ( (status = SHAUpdate( &hash_context, M, DSS_LENGTH_MIN ))
!= SUCCESS )
{
return status; /* error */
}
if ( (status=MySHAFinal (&hash_context, hash_result )) != SUCCESS )
{
return status; /* error */
}
BigSwap(RVAL, SHA_LENGTH);
ALIGN_CALLOC_COPY(RVAL, RVAL_a, SHA_LENGTH);
if ( status != SUCCESS )
{
ALIGN_COPY_FREE(RVAL_a,RVAL,SHA_LENGTH);
BigSwap(RVAL, SHA_LENGTH);
return status; /* ERR_ALLOC insufficient memory */
}
Sum_Q( RVAL_a, 1, SHA_LENGTH / sizeof(ord) );
Sum_big( RVAL_a, /* RVAL=RVAL+hash_result*/
(ord *)hash_result,
RVAL_a, SHA_LENGTH / sizeof(ord) );
ALIGN_COPY_FREE(RVAL_a,RVAL,SHA_LENGTH);
BigSwap(RVAL, SHA_LENGTH);
#ifdef CTK_BIG_ENDIAN
ByteSwap(hash_result,SHA_LENGTH);
#endif
BigSwap(hash_result, SHA_LENGTH);
if ( i == sha_block && sha_rem != 0 ) /* last block < SHA_LENGTH*/
{
memcpy( A + i * SHA_LENGTH, hash_result,
sha_rem * sizeof (uchar));
}
else /* last block = SHA_LENGTH*/
{
memcpy( A + i * SHA_LENGTH, hash_result,
SHA_LENGTH * sizeof (uchar));
}
}
return status;
}
/****************************************************************************
* NAME: int MyGenRand( u_int16_t A_bytes,
* ord *A,
* ord *RVAL)
*
* DESCRIPTION: Generate random number.
*
* INPUTS:
* PARAMETERS:
* u_int16_t A_bytes Length of A
* ord *A Pointer to A value
*
* OUTPUT:
* PARAMETERS:
* ord *RVAL Pointer to RVAL
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data
* ERR_DATA Generic data error
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
int MyGenRand( u_int16_t A_bytes,
ord *A,
ord *RVAL )
{
int status = SUCCESS; /* function return status */
SHA_context hash_context; /* SHA context structure */
uchar M[DSS_LENGTH_MIN]; /* message block */
uchar hash_result[SHA_LENGTH];
u_int16_t i;
u_int16_t sha_block; /* number of sha blocks */
u_int16_t sha_rem; /* size of last block */
if ( A_bytes == 0 )
{
status = ERR_INPUT_LEN;
return status;
}
sha_block = (u_int16_t) (A_bytes / SHA_LENGTH); /* number of sha blocks */
sha_rem = (u_int16_t) (A_bytes % SHA_LENGTH); /* size of last block */
if ( sha_rem == 0 ) /* last block = SHA_LENGTH */
{
sha_block--;
}
for ( i = 0; i <= sha_block; i++)
{
SHAInit ( &hash_context );
memcpy( M, RVAL, SHA_LENGTH);
memset( M + SHA_LENGTH, 0, DSS_LENGTH_MIN - SHA_LENGTH );
if ( (status = SHAUpdate( &hash_context, M, DSS_LENGTH_MIN ))
!= SUCCESS )
{
return status; /* error */
}
if ( (status=MySHAFinal (&hash_context, hash_result )) != SUCCESS )
{
return status; /* error */
}
#ifdef CTK_BIG_ENDIAN
ByteSwap((uchar*)RVAL,SHA_LENGTH);
#endif
BigSwap((uchar*)RVAL, SHA_LENGTH);
Sum_Q(RVAL, 1,SHA_LENGTH / sizeof(ord));
Sum_big( RVAL, /* RVAL=RVAL+hash_result*/
(ord*)hash_result,
RVAL, SHA_LENGTH / sizeof(ord) );
BigSwap((uchar*)RVAL, SHA_LENGTH);
#ifdef CTK_BIG_ENDIAN
ByteSwap((uchar*)RVAL,SHA_LENGTH);
#endif
if ( i == sha_block && sha_rem != 0 ) /* last block < SHA_LENGTH*/
{
memcpy( &A[ i*SHA_LENGTH / sizeof(ord)], hash_result,
sha_rem * sizeof (uchar));
}
else /* last block = SHA_LENGTH*/
{
memcpy( &A[ i*SHA_LENGTH / sizeof(ord)], hash_result,
SHA_LENGTH * sizeof (uchar));
}
}
return status;
}

698
lib/bind/cylink/sha.c
View file

@ -1,698 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: cencrint.c PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Cryptographic Toolkit Internal Functions File
*
* PRIVATE FUNCTIONS:
*
*
* void shaTransform( u_int32_t *state, uchar *block )
* void SHAInitK( SHA_context *hash_context )
* int MySHA( uchar *message, u_int16_t message_bytes,
* uchar *hash_result )
* int MySHAFinal( SHA_context *hash_context, uchar *hash_result )
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
*
* 24 Sep 94 KPZ Initial release
* 10 Oct 94 KPZ Fixed bugs in Add(), DivRem()
* 12 Oct 94 KPZ Modified shaTransform()
* 14 Oct 94 GKL Second version (big endian support)
* 26 Oct 94 GKL (alignment for big endian support & ERR_ALLOC)
* 08 Nov 94 GKL Added input parameters check to Inverse
* 08 Dec 94 GKL Added YIELD_context to Expo, VerPrime and GenPrime
*
****************************************************************************/
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
#include "port_before.h"
#include <sys/types.h>
/* system files */
#ifdef VXD
#include <vtoolsc.h>
#else
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#endif
/* program files */
#include "cylink.h"
#include "ctk_endian.h"
#include "toolkit.h"
#include "cencrint.h"
#include "sha.h"
#include "port_after.h"
extern u_int16_t DataOrder;
/****************************************************************************
* NAME: int SHA( uchar *message,
* u_int16_t message_bytes,
* uchar *hash_result )
*
* DESCRIPTION: Compute a Secure Hash Function.
*
* INPUTS:
* PARAMETERS:
* uchar *message Pointer to message
* u_int16_t message_bytes Number of bytes in message
* uchar *hash_result Pointer to message digest
*
* OUTPUT:
* PARAMETERS:
* uchar *hash_result Message digest
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data(zero bytes)
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
*
****************************************************************************/
int SHA( uchar *message,
u_int16_t message_bytes,
uchar *hash_result )
{
SHA_context hash_context; /* SHA context structure */
int status = SUCCESS; /* function return status */
if (message_bytes == 0 )
{
status = ERR_INPUT_LEN;
return status; /* invalid length for input data */
}
SHAInit ( &hash_context ); /* initialize SHA */
if ( (status = SHAUpdate( &hash_context, message, message_bytes ))
!= SUCCESS )
{
return status; /* error */
}
if ((status=SHAFinal (&hash_context, hash_result)) != SUCCESS )
{
return status; /* error */
}
return status;
}
/****************************************************************************
* PRIVATE FUNCTIONS DEFINITIONS
****************************************************************************/
/****************************************************************************
* NAME: void shaTransform( u_int32_t *state,
* uchar *block )
*
* DESCRIPTION: Perform SHS transformation.
*
* INPUTS:
* PARAMETERS:
* SHA_context *hash_context Pointer to SHA_context structure
* OUTPUT:
*
* SHA_context *hash_context Pointer to SHA_context structure
* (updated)
* REVISION HISTORY:
*
* 24 sep 94 KPZ Initial release
* 12 Oct 94 KPZ Modified buffers copy
* 14 Oct 94 GKL Second version (big endian support)
* 1 Sep 95 AAB Speedup the function
****************************************************************************/
void shaTransform( u_int32_t *state,
const uchar *block )
{
u_int32_t W[80];
u_int32_t A,B,C,D,E; /*,temp;*/
memcpy( W, block, 64); /*TKL00201*/
#ifdef CTK_LITTLE_ENDIAN /*TKL00201*/
ByteSwap32( (uchar *)W, 64); /*TKL00201*/
#endif /*TKL00201*/
/* Expand the 16 words into 80 words */
expand(16);expand(17);expand(18);expand(19);expand(20);expand(21);
expand(22);expand(23);expand(24);expand(25);expand(26);expand(27);
expand(28);expand(29);expand(30);expand(31);expand(32);expand(33);
expand(34);expand(35);expand(36);expand(37);expand(38);expand(39);
expand(40);expand(41);expand(42);expand(43);expand(44);expand(45);
expand(46);expand(47);expand(48);expand(49);expand(50);expand(51);
expand(52);expand(53);expand(54);expand(55);expand(56);expand(57);
expand(58);expand(59);expand(60);expand(61);expand(62);expand(63);
expand(64);expand(65);expand(66);expand(67);expand(68);expand(69);
expand(70);expand(71);expand(72);expand(73);expand(74);expand(75);
expand(76);expand(77);expand(78);expand(79);
/*Set up first buffer*/
A = state[0];
B = state[1];
C = state[2];
D = state[3];
E = state[4];
/* Heavy mangling, in 4 sub-rounds of 20 iterations each. */
subRound( A, B, C, D, E, f1, k1SHA, W[ 0] );
subRound( E, A, B, C, D, f1, k1SHA, W[ 1] );
subRound( D, E, A, B, C, f1, k1SHA, W[ 2] );
subRound( C, D, E, A, B, f1, k1SHA, W[ 3] );
subRound( B, C, D, E, A, f1, k1SHA, W[ 4] );
subRound( A, B, C, D, E, f1, k1SHA, W[ 5] );
subRound( E, A, B, C, D, f1, k1SHA, W[ 6] );
subRound( D, E, A, B, C, f1, k1SHA, W[ 7] );
subRound( C, D, E, A, B, f1, k1SHA, W[ 8] );
subRound( B, C, D, E, A, f1, k1SHA, W[ 9] );
subRound( A, B, C, D, E, f1, k1SHA, W[10] );
subRound( E, A, B, C, D, f1, k1SHA, W[11] );
subRound( D, E, A, B, C, f1, k1SHA, W[12] );
subRound( C, D, E, A, B, f1, k1SHA, W[13] );
subRound( B, C, D, E, A, f1, k1SHA, W[14] );
subRound( A, B, C, D, E, f1, k1SHA, W[15] );
subRound( E, A, B, C, D, f1, k1SHA, W[16] );
subRound( D, E, A, B, C, f1, k1SHA, W[17] );
subRound( C, D, E, A, B, f1, k1SHA, W[18] );
subRound( B, C, D, E, A, f1, k1SHA, W[19] );
subRound( A, B, C, D, E, f2, k2SHA, W[20]);
subRound( E, A, B, C, D, f2, k2SHA, W[21]);
subRound( D, E, A, B, C, f2, k2SHA, W[22]);
subRound( C, D, E, A, B, f2, k2SHA, W[23]);
subRound( B, C, D, E, A, f2, k2SHA, W[24]);
subRound( A, B, C, D, E, f2, k2SHA, W[25]);
subRound( E, A, B, C, D, f2, k2SHA, W[26]);
subRound( D, E, A, B, C, f2, k2SHA, W[27]);
subRound( C, D, E, A, B, f2, k2SHA, W[28]);
subRound( B, C, D, E, A, f2, k2SHA, W[29]);
subRound( A, B, C, D, E, f2, k2SHA, W[30]);
subRound( E, A, B, C, D, f2, k2SHA, W[31]);
subRound( D, E, A, B, C, f2, k2SHA, W[32]);
subRound( C, D, E, A, B, f2, k2SHA, W[33]);
subRound( B, C, D, E, A, f2, k2SHA, W[34]);
subRound( A, B, C, D, E, f2, k2SHA, W[35]);
subRound( E, A, B, C, D, f2, k2SHA, W[36]);
subRound( D, E, A, B, C, f2, k2SHA, W[37]);
subRound( C, D, E, A, B, f2, k2SHA, W[38]);
subRound( B, C, D, E, A, f2, k2SHA, W[39]);
subRound( A, B, C, D, E, f3, k3SHA, W[40]);
subRound( E, A, B, C, D, f3, k3SHA, W[41]);
subRound( D, E, A, B, C, f3, k3SHA, W[42]);
subRound( C, D, E, A, B, f3, k3SHA, W[43]);
subRound( B, C, D, E, A, f3, k3SHA, W[44]);
subRound( A, B, C, D, E, f3, k3SHA, W[45]);
subRound( E, A, B, C, D, f3, k3SHA, W[46]);
subRound( D, E, A, B, C, f3, k3SHA, W[47]);
subRound( C, D, E, A, B, f3, k3SHA, W[48]);
subRound( B, C, D, E, A, f3, k3SHA, W[49]);
subRound( A, B, C, D, E, f3, k3SHA, W[50]);
subRound( E, A, B, C, D, f3, k3SHA, W[51]);
subRound( D, E, A, B, C, f3, k3SHA, W[52]);
subRound( C, D, E, A, B, f3, k3SHA, W[53]);
subRound( B, C, D, E, A, f3, k3SHA, W[54]);
subRound( A, B, C, D, E, f3, k3SHA, W[55]);
subRound( E, A, B, C, D, f3, k3SHA, W[56]);
subRound( D, E, A, B, C, f3, k3SHA, W[57]);
subRound( C, D, E, A, B, f3, k3SHA, W[58]);
subRound( B, C, D, E, A, f3, k3SHA, W[59]);
subRound( A, B, C, D, E, f4, k4SHA, W[60]);
subRound( E, A, B, C, D, f4, k4SHA, W[61]);
subRound( D, E, A, B, C, f4, k4SHA, W[62]);
subRound( C, D, E, A, B, f4, k4SHA, W[63]);
subRound( B, C, D, E, A, f4, k4SHA, W[64]);
subRound( A, B, C, D, E, f4, k4SHA, W[65]);
subRound( E, A, B, C, D, f4, k4SHA, W[66]);
subRound( D, E, A, B, C, f4, k4SHA, W[67]);
subRound( C, D, E, A, B, f4, k4SHA, W[68]);
subRound( B, C, D, E, A, f4, k4SHA, W[69]);
subRound( A, B, C, D, E, f4, k4SHA, W[70]);
subRound( E, A, B, C, D, f4, k4SHA, W[71]);
subRound( D, E, A, B, C, f4, k4SHA, W[72]);
subRound( C, D, E, A, B, f4, k4SHA, W[73]);
subRound( B, C, D, E, A, f4, k4SHA, W[74]);
subRound( A, B, C, D, E, f4, k4SHA, W[75]);
subRound( E, A, B, C, D, f4, k4SHA, W[76]);
subRound( D, E, A, B, C, f4, k4SHA, W[77]);
subRound( C, D, E, A, B, f4, k4SHA, W[78]);
subRound( B, C, D, E, A, f4, k4SHA, W[79]);
state[0] += A;
state[1] += B;
state[2] += C;
state[3] += D;
state[4] += E;
}
/****************************************************************************
* NAME: void SHAInitK( SHA_context *hash_context )
*
* DESCRIPTION: Initialize Secure Hash Function for generate
* random number for DSS.
*
* INPUTS:
* PARAMETERS:
* SHA_context *hash_context SHA context structure
* OUTPUT:
* PARAMETERS:
* SHA_context *hash_context Initialized SHA context structure
*
* RETURN:
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void SHAInitK( SHA_context *hash_context )
{
/*Set up first buffer*/
hash_context->state[0] = 0xEFCDAB89L;
hash_context->state[1] = 0x98BADCFEL;
hash_context->state[2] = 0x10325476L;
hash_context->state[3] = 0xC3D2E1F0L;
hash_context->state[4] = 0x67452301L;
/*Initialise buffer */
memset( hash_context->buffer, 0, sizeof(hash_context->buffer));
memset( hash_context->count, 0, sizeof(hash_context->count));
}
/****************************************************************************
* NAME: int MySHA( uchar *message,
* u_int16_t message_bytes,
* uchar *hash_result )
*
* DESCRIPTION: Compute a Secure Hash Function.
*
* INPUTS:
* PARAMETERS:
* uchar *message Pointer to message
* u_int16_t message_bytes Number of bytes in message
* uchar *hash_result Pointer to message digest
*
* OUTPUT:
* PARAMETERS:
* uchar *hash_result Message digest
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data(zero bytes)
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
*
****************************************************************************/
int MySHA( uchar *message,
u_int16_t message_bytes,
uchar *hash_result )
{
SHA_context hash_context; /* SHA context structure */
int status = SUCCESS; /* function return status */
if (message_bytes == 0 )
{
status = ERR_INPUT_LEN;
return status; /* invalid length for input data */
}
SHAInit ( &hash_context ); /* initialize SHA */
#ifdef CTK_BIG_ENDIAN
ByteSwap(message,message_bytes);
#endif
status = SHAUpdate( &hash_context, message, message_bytes );
#ifdef CTK_BIG_ENDIAN
ByteSwap(message,message_bytes);
#endif
if ( status != SUCCESS )
{
return status; /* error */
}
if ((status=MySHAFinal (&hash_context, hash_result)) != SUCCESS )
{
return status; /* error */
}
return status;
}
/****************************************************************************
* NAME: int MySHAFinal( SHA_context *hash_context,
* uchar *hash_result )
* DESCRIPTION: Finalize Secure Hash Function
*
* INPUTS:
* PARAMETERS:
* SHA_context *hash_context SHA context structure
* uchar *hash_result Pointer to hash
* OUTPUT:
* PARAMETERS:
* uchar *hash_result Final value
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data (zero bytes)
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 10 Oct 94 KPZ Modified for arbitrary message length
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
int MySHAFinal( SHA_context *hash_context,
uchar *hash_result )
{
int status = SUCCESS; /* function return status */
uchar bits[8];
u_int16_t index, padLen;
u_int32_t ex;
uchar PADDING[64] = { /* padding string */
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
if ( hash_context->count[0] == 0 && hash_context->count[1] == 0 )
{
status= ERR_INPUT_LEN;
return status;
}
/* Save number of bits */
LongByte( &hash_context->count[1] , 4, bits );
LongByte( &hash_context->count[0] , 4, bits + 4 );
ByteSwap32( bits, 8 );
/* Pad out to 56 mod 64.*/
index = (u_int16_t )((hash_context->count[0] >> 3) & 0x3f);
padLen = (u_int16_t) ((index < 56) ? (56 - index) : (120 - index));
SHAUpdate( hash_context, PADDING, padLen );
/* Append length (before padding) */
SHAUpdate (hash_context, bits, 8);
/* Set order of hash_context */
ex = hash_context->state[0];
hash_context->state[0] = hash_context->state[4];
hash_context->state[4] = ex;
ex = hash_context->state[1];
hash_context->state[1] = hash_context->state[3];
hash_context->state[3] = ex;
/* Store state in digest */
memcpy(hash_result,hash_context->state,SHA_LENGTH);
/* Zeroize sensitive information.*/
memset( hash_context, 0, sizeof(hash_context) );
#if defined ( ORD_16 ) && defined( CTK_BIG_ENDIAN )
WordSwap(hash_result,SHA_LENGTH);
#endif
return status;
}
/****************************************************************************
* NAME: int SHAUpdate( SHA_context *hash_context,
* uchar *message,
* u_int16_t message_bytes )
* DESCRIPTION: Update Secure Hash Function
*
* INPUTS:
* PARAMETERS:
* SHA_context *hash_context SHA context structure
* uchar *message Pointer to message
* u_int16_t message_bytes Number of bytes
* OUTPUT:
* PARAMETERS:
* SHA_context *hash_context Updated SHA context structure
*
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data (zero bytes)
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 10 Oct 94 KPZ Modified for arbitrary message length
*
****************************************************************************/
int SHAUpdate( SHA_context *hash_context,
const uchar *message,
u_int16_t message_bytes )
{
int status = SUCCESS; /* function return status */
u_int16_t i, index, partLen;
if ( message_bytes == 0 )
{
status = ERR_INPUT_LEN; /*invalid length for input data (zero bytes)*/
return status;
}
/* Compute number of bytes mod 64 */
index = (u_int16_t)((hash_context->count[0] >> 3) & 0x3F);
/* Update number of bits */
if ( (hash_context->count[0] += ((u_int32_t )message_bytes << 3))
< ((u_int32_t )message_bytes << 3) )
{
hash_context->count[1]++;
}
hash_context->count[1] += ((u_int32_t )message_bytes >> 29);
partLen = (u_int16_t) (64 - index);
/* Transform as many times as possible.*/
if ( message_bytes >= partLen )
{
memcpy( &hash_context->buffer[index], message, partLen );
shaTransform( hash_context->state, hash_context->buffer );
for ( i = partLen; (u_int16_t)(i + 63) < message_bytes; i += 64 )
{
shaTransform ( hash_context->state, &message[i] );
}
index = 0;
}
else
{
i = 0;
}
/* Buffer remaining input */
memcpy( &hash_context->buffer[index], &message[i],
message_bytes - i );
return status;
}
/****************************************************************************
* NAME: void SHAInit( SHA_context *hash_context )
*
* DESCRIPTION: Initialize Secure Hash Function
*
* INPUTS:
* PARAMETERS:
* SHA_context *hash_context SHA context structure
* OUTPUT:
* PARAMETERS:
* SHA_context *hash_context Initialized SHA context structure
*
* RETURN:
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
*
****************************************************************************/
void SHAInit( SHA_context *hash_context )
{
/*Set up first buffer*/
hash_context->state[0] = h0SHA;
hash_context->state[1] = h1SHA;
hash_context->state[2] = h2SHA;
hash_context->state[3] = h3SHA;
hash_context->state[4] = h4SHA;
/* Initialise buffer */
memset( hash_context->buffer, 0, sizeof(hash_context->buffer));
/*Initialize bit count*/
hash_context->count[0] = hash_context->count[1] = 0;
}
/****************************************************************************
* NAME: int SHAFinal( SHA_context *hash_context,
* uchar *hash_result )
* DESCRIPTION: Finalize Secure Hash Function
*
* INPUTS:
* PARAMETERS:
* SHA_context *hash_context SHA context structure
* uchar *hash_result Pointer to hash
* OUTPUT:
* PARAMETERS:
* uchar *hash_result Final value
* RETURN:
* SUCCESS No errors
* ERR_INPUT_LEN Invalid length for input data (zero bytes)
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 10 Oct 94 KPZ Modified for arbitrary message length
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
int SHAFinal( SHA_context *hash_context,
uchar *hash_result )
{
int status = SUCCESS; /* function return status */
status = MySHAFinal( hash_context, hash_result );
#ifdef CTK_BIG_ENDIAN
if (status == SUCCESS)
{
ByteSwap(hash_result, SHA_LENGTH);
}
#endif
if (DataOrder)
{
BigSwap(hash_result, SHA_LENGTH);
}
return status;
}
/****************************************************************************
* NAME: int GetPasswordKeySHA( u_int16_t Password_bytes,
* uchar *Password,
* uchar *salt,
* u_int16_t Count,
* uchar *K,
* uchar *IV )
*
* DESCRIPTION: Get Password-Based DES/KAPPA Key by SHA
*
* INPUTS:
* PARAMETERS:
* u_int16_t Password_bytes Number of bytes in password
* uchar *Password Pointer to password
* uchar *salt Pointer to salt(8-byte)
* u_int16_t Count Number of iteration
* OUTPUT:
* PARAMETERS:
* uchar *K Pointer to DES/KAPPA key
* uchar *IV Pointer to initialization vector
* RETURN:
* SUCCESS No errors
* ERR_COUNT Invalid iteration count (zero)
* ERR_INPUT_LEN Invalid length for input data(zero bytes)
* ERR_ALLOC Insufficient memory
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 26 Oct 94 GKL (ERR_ALLOC)
*
****************************************************************************/
int GetPasswordKeySHA( u_int16_t Password_bytes,
uchar *Password,
uchar *salt,
u_int16_t Count,
uchar *K,
uchar *IV )
{
int status = SUCCESS; /* function return status */
uchar digest[SHA_LENGTH];
uchar *buf;
if ( Count == 0 ) /* invalid iteration count (zero) */
{
status = ERR_COUNT;
return status;
}
CALLOC(buf,uchar,Password_bytes + 8);
if ( status != SUCCESS )
{
return status; /* ERR_ALLOC insufficient memory */
}
if ( Password_bytes != 0 ) /* if number of bytes password non equals zero */
{
memcpy( buf, Password, Password_bytes );
}
memcpy( buf + Password_bytes, salt, 8);
/* Compute message digest */
status = SHA( buf, (u_int16_t)(Password_bytes + 8), digest);
if (!DataOrder)
{
BigSwap(digest, SHA_LENGTH);
}
if ( status != SUCCESS )
{
free ( buf );
return status;
}
Count --; /* decrement Count */
/* Count times compute message digest */
while ( Count != 0 )
{
if ( (status = SHA( digest, SHA_LENGTH, digest)) != SUCCESS )
{
free ( buf );
return status;
}
if (!DataOrder)
{
BigSwap(digest, SHA_LENGTH);
}
Count --;
}
memcpy( K, digest, 8 );
memcpy( IV, digest + SHA_LENGTH -8, 8 );
free ( buf );
return status;
}

148
lib/bind/cylink/sha.h
View file

@ -1,148 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: sha.h PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Cryptographic Toolkit Internal Functions Header File
*
* USAGE: File should be included in Toolkit functions files
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
*
****************************************************************************/
#ifndef SHA_H
#define SHA_H
#include "cylink.h"
#define SHS_BLOCKSIZE 64
/*
#define FSHA(x,y,z) ( ( x & y ) | ( ~x & z ) )
#define GSHA(x,y,z) ( x ^ y ^ z )
#define HSHA(x,y,z) ( ( x & y ) | ( x & z ) | ( y & z ) )
#define ISHA(x,y,z) (x ^ y ^ z)
*/
/*#define f1(x,y,z) ( (x & y) | (~x & z) ) // Rounds 0-19 */
#define f1(x,y,z) ( z ^ (x & (y ^ z) ) ) /* Rounds 0-19 */
#define f2(x,y,z) ( x ^ y ^ z ) /* Rounds 20-39 */
/*#define f3(x,y,z) ( (x & y) | (x & z) | (y & z) ) // Rounds 40-59 */
#define f3(x,y,z) ( (x & y) | (z & (x | y) ) ) /* Rounds 40-59 */
#define f4(x,y,z) ( x ^ y ^ z ) /* Rounds 60-79 */
#define RotateLeft(x,n) (( x << n )|( x >> (32-n) ) ) /*Circular left shift operation*/
/*SHS Constants */
#define k1SHA 0x5a827999L
#define k2SHA 0x6ed9eba1L
#define k3SHA 0x8f1bbcdcL
#define k4SHA 0xca62c1d6L
/*SHS initial value */
#define h0SHA 0x67452301L
#define h1SHA 0xefcdab89L
#define h2SHA 0x98badcfeL
#define h3SHA 0x10325476L
#define h4SHA 0xc3d2e1f0L
/*The initial expanding function*/
#define expand(count) \
{\
W[count] = W[count-3] ^ W[count-8] ^ W[count-14] ^ W[count-16];\
W[count] = RotateLeft( W[count], 1 );\
}
/*New variant */
#define subRound(a, b, c, d, e, f, k, data) \
( e += RotateLeft(a,5) + f(b, c, d) + k + data, b = RotateLeft( b,30) )
/*The four sub_rounds*/
/*
#define subR1(count) \
{\
temp=RotateLeft(A,5) + FSHA(B,C,D) + E +W[count] +k1SHA;\
E = D; \
D = C; \
C = RotateLeft(B,30); \
B = A; \
A = temp; \
}
#define subR2(count) \
{\
temp=RotateLeft(A,5) + GSHA(B,C,D) + E +W[count] +k2SHA;\
E = D; \
D = C; \
C = RotateLeft(B,30);\
B = A; \
A = temp; \
}
#define subR3(count) \
{\
temp=RotateLeft(A,5) + HSHA(B,C,D) + E +W[count] +k3SHA;\
E = D; \
D = C; \
C = RotateLeft(B,30);\
B = A; \
A = temp; \
}
#define subR4(count) \
{\
temp=RotateLeft(A,5) + ISHA(B,C,D) + E + W[count] +k4SHA;\
E = D; \
D = C; \
C = RotateLeft(B,30);\
B = A; \
A = temp; \
}
*/
#endif /* SHA_H */

51
lib/bind/cylink/sizetest.c
View file

@ -1,51 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
#include "bnsize00.h"
#if BNSIZE16
#error Using 16-bit math library
#elif BNSIZE32
#error Using 32-bit math library
#elif BNSIZE64
#error Using 64-bit math library
#else
#error No math library size defined
#endif

211
lib/bind/cylink/swap.c
View file

@ -1,211 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: swap.c PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Byte and Word Swap functions
*
* PUBLIC FUNCTIONS:
*
*
* PRIVATE FUNCTIONS:
*
* REVISION HISTORY:
*
* 14 Oct 94 GKL Initial release
* 26 Oct 94 GKL (alignment for big endian support )
*
****************************************************************************/
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
/* system files */
#include "port_before.h"
#ifdef VXD
#include <vtoolsc.h>
#else
#include <stdlib.h>
#include <string.h>
#endif
/* program files */
#include "cylink.h"
#include "ctk_endian.h"
#include "toolkit.h"
#include "port_after.h"
u_int16_t DataOrder = 0;
/*Reset bytes in long*/
/*extern void ByteSwap32_asm( uchar *X, u_int16_t X_len );*/ /*kz*/
/****************************************************************************
* NAME: void ByteSwap32 (uchar *array,
* u_int16_t X_len )
*
* DESCRIPTION: Perform byte reversal on an array of longword.
*
* INPUTS:
* PARAMETERS:
* uchar *X Pointer to array
* u_int16_t X_len Number of bytes
* OUTPUT:
* uchar *X Pointer to array
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void ByteSwap32( uchar *X, u_int16_t X_len )
{
u_int16_t i; /*counter*/
uchar a; /*temporary char*/
for ( i = 0; i < X_len; i += 4)
{
a = X[i];
X[i] = X[i+3];
X[i+3] = a;
a = X[i+1];
X[i+1] = X[i+2];
X[i+2] = a;
}
/*#endif*/ /*kz*/
}
/****************************************************************************
* NAME: void ByteSwap (uchar *array,
* u_int16_t X_len )
*
* DESCRIPTION: Perform byte reversal on an array of longword or shortword.
*
* INPUTS:
* PARAMETERS:
* uchar *X Pointer to array
* u_int16_t X_len Number of bytes
* OUTPUT:
* uchar *X Pointer to array
*
* REVISION HISTORY:
*
* 24 Sep 94 KPZ Initial release
* 14 Oct 94 GKL Second version (big endian support)
*
****************************************************************************/
void ByteSwap( uchar *X,
u_int16_t X_len )
{
#ifdef ORD_16
u_int16_t i; /*counter*/
uchar a; /*tempriory char for revers*/
for ( i = 0; i < X_len; i += 2)
{
a = X[i];
X[i] = X[i+1];
X[i+1] = a;
}
#endif
#ifdef ORD_32
ByteSwap32(X,X_len);
#endif
}
/*kz longbyte deleted */
/****************************************************************************
* NAME: void WordSwap (uchar *array,
* u_int16_t X_len )
*
* DESCRIPTION: Perform short reversal on an array of longword.
*
* INPUTS:
* PARAMETERS:
* uchar *X Pointer to array
* u_int16_t X_len Number of bytes
* OUTPUT:
* uchar *X Pointer to array
*
* REVISION HISTORY:
*
* 14 Oct 94 GKL Initial release
*
****************************************************************************/
void WordSwap( uchar *X,
u_int16_t X_len )
{
u_int16_t i; /*counter*/
u_int16_t a; /*tempriory u_int16_t*/
for ( i = 0; i < X_len; i += 4)
{
a = *(u_int16_t*)(&X[i]);
*(u_int16_t*)(&X[i])=*(u_int16_t*)(&X[i+2]);
*(u_int16_t*)(&X[i+2])=a;
}
}
void BigSwap( uchar *buffer,
u_int16_t bufferLength)
{
uchar temp;
u_int16_t i;
for (i = 0; i < (u_int16_t)(bufferLength/2); i++)
{
temp = buffer[i];
buffer[i] = buffer[bufferLength - 1 - i];
buffer[bufferLength - 1 - i] = temp;
}
}
void SetDataOrder ( u_int16_t dataOrder)
{
DataOrder = dataOrder;
}

393
lib/bind/cylink/toolkit.h
View file

@ -1,393 +0,0 @@
/*
* Cylink Corporation © 1998
*
* This software is licensed by Cylink to the Internet Software Consortium to
* promote implementation of royalty free public key cryptography within IETF
* standards. Cylink wishes to expressly thank the contributions of Dr.
* Martin Hellman, Whitfield Diffie, Ralph Merkle and Stanford University for
* their contributions to Internet Security. In accordance with the terms of
* this license, ISC is authorized to distribute and sublicense this software
* for the practice of IETF standards.
*
* The software includes BigNum, written by Colin Plumb and licensed by Philip
* R. Zimmermann for royalty free use and distribution with Cylink's
* software. Use of BigNum as a stand alone product or component is
* specifically prohibited.
*
* Disclaimer of All Warranties. THIS SOFTWARE IS BEING PROVIDED "AS IS",
* WITHOUT ANY EXPRESSED OR IMPLIED WARRANTY OF ANY KIND WHATSOEVER. IN
* PARTICULAR, WITHOUT LIMITATION ON THE GENERALITY OF THE FOREGOING, CYLINK
* MAKES NO REPRESENTATION OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
* PURPOSE.
*
* Cylink or its representatives shall not be liable for tort, indirect,
* special or consequential damages such as loss of profits or loss of
* goodwill from the use or inability to use the software for any purpose or
* for any reason whatsoever.
*
* EXPORT LAW: Export of the Foundations Suite may be subject to compliance
* with the rules and regulations promulgated from time to time by the Bureau
* of Export Administration, United States Department of Commerce, which
* restrict the export and re-export of certain products and technical data.
* If the export of the Foundations Suite is controlled under such rules and
* regulations, then the Foundations Suite shall not be exported or
* re-exported, directly or indirectly, (a) without all export or re-export
* licenses and governmental approvals required by any applicable laws, or (b)
* in violation of any applicable prohibition against the export or re-export
* of any part of the Foundations Suite. All export licenses for software
* containing the Foundations Suite are the sole responsibility of the licensee.
*/
/****************************************************************************
* FILENAME: toolkit.h PRODUCT NAME: CRYPTOGRAPHIC TOOLKIT
*
* FILE STATUS:
*
* DESCRIPTION: Cryptographic Toolkit Functions Header File
*
* USAGE: File should be included to use Toolkit Functions
*
*
* Copyright (c) Cylink Corporation 1994. All rights reserved.
*
* REVISION HISTORY:
*
* 23 Aug 94 KPZ Initial release
* 24 Sep 94 KPZ Added prototypes of Toolkit functions
* 14 Oct 94 GKL Second version (big endian support)
* 08 Dec 94 GKL Added YIELD_context to GenDSSParameters
*
****************************************************************************/
#ifndef TOOLKIT_H /* Prevent multiple inclusions of same header file */
#define TOOLKIT_H
/* Error types */
#define SUCCESS 0 /* no errors */
#define ERR_DATA -1 /* generic data error */
#define ERR_ALLOC -2 /* insufficient memory */
#define ERR_INPUT_LEN -3 /* invalid length for input data (zero bytes) */
#define ERR_DSS_LEN -4 /* invalid length for dss_p */
#define ERR_DH_LEN -5 /* invalid length for DH_modulus */
#define ERR_BLOCK_LEN -7 /* invalid length for input block for ECB/CBC */
#define ERR_HASH_LEN -8 /* invalid length for hash_result */
#define ERR_MODE -9 /* invalid value of encryption mode */
#define ERR_NUMBER -10 /* invalid number of testings (zero) */
#define ERR_POSITION -11 /* invalid value of triplet_position */
#define ERR_COUNT -12 /* invalid iteration count (zero) */
#define ERR_SIGNATURE -21 /* signature is not valid */
#define ERR_PRIME -22 /* number is not prime */
#define ERR_WEAK -23 /* weak key */
#define ERR_INPUT_VALUE -24 /* invalid input value */
/* additional error types for CEPA */
#define ERR_KEY_LENGTH -25 /* invalid value of key length */
#define ERR_ROUNDS -26 /* invalid value of rounds number */
#define ERR_CANCEL -30 /* canceled by user */
#define ERR_MODULUS_ZERO -31 /* invalid modulo */
#define ERR_UNSUPPORTED -40 /* unsupported crypto method */
#define ERR_OP_CODE -41 /*invalid operation code*/
/* Lengths of variables */
#define DH_LENGTH_MIN 64 /* 512-bit minimal length for DH functions */
#define DSS_LENGTH_MIN 64 /* 512-bit minimal length for DSS functions */
#define DSS_LENGTH_MAX 128 /* 1024-bit maximal length for DSS functions */
#define SHA_LENGTH 20 /* 160-bit length for SHA hash result */
/* Number of random bases for Miller test */
#define TEST_COUNT 40
#define LITTLE_ORDER 0
#define BIG_ORDER 1
/* Key lengths */ /* add to toolkit.h */
#define KEY_40BIT 40 /* 40-bit key */
#define KEY_64BIT 64 /* 64-bit key */
#define KEY_128BIT 128 /* 128-bit key */
#define CEPA_MAX_ROUNDS 12
/* Operation codes for MultiPrecArithm() */
#define EXPO 0x21
#define MUL 0x22
/*#define ADD 0x23*/
/****************************************************************************
* INCLUDE FILES
****************************************************************************/
/* system files */
#include "cylink.h"
#include "ctk_endian.h"
/* callback function */
#ifdef VXD
typedef int (* YIELD_PROC)( void );
#else
typedef int (* YIELD_PROC)(int ); /*TKL00601*/
#endif
typedef struct { /*TKL00601*/
YIELD_PROC yield_proc;
void * handle; /* Application specific information */
}YIELD_context;
/* Secure Hash Algorithm structure */
typedef struct
{
u_int32_t state[ 5 ]; /* state */
u_int32_t count[ 2 ]; /* number of bits */
uchar buffer[ 64 ]; /* input buffer */
} SHA_context;
#ifdef __cplusplus
extern "C" {
#endif
/* Copy Cylink DSS Common Parameters */ /*TKL01201*/
int GetDSSPQG(u_int16_t dss_p_bytes,
uchar *dss_p,
uchar *dss_q,
uchar *dss_g);
/* Compute a Secure Hash Function */
int SHA( uchar *message, u_int16_t message_bytes,
uchar *hash_result );
/* Initialize Secure Hash Function */
void SHAInit( SHA_context *hash_context );
/* Update Secure Hash Function */
int SHAUpdate( SHA_context *hash_context,
const uchar *message,
u_int16_t message_bytes );
/* Finalize Secure Hash Function */
int SHAFinal( SHA_context *hash_context,
uchar *hash_result );
/* Compute a DSS Signature */
int GenDSSSignature( u_int16_t dss_p_bytes, uchar *dss_p,
uchar *dss_q, uchar *dss_g,
uchar *dss_x, uchar *dss_k,
uchar *r, uchar *s,
uchar *hash_result );
/* Verify a DSS Signature */
int VerDSSSignature( u_int16_t dss_p_bytes, uchar *dss_p,
uchar *dss_q, uchar *dss_g,
uchar *dss_y, uchar *r,
uchar *s, uchar *hash_result);
/* Initialize Random number Generator */
int InitRand( u_int16_t SEED_bytes, uchar *SEED,
uchar *RVAL );
/* Generate random number */
int GenRand( u_int16_t A_bytes, uchar *A,
uchar *RVAL );
/* Compute DSS public/secret number pair */
int GenDSSKey( u_int16_t dss_p_bytes, uchar *dss_p,
uchar *dss_q, uchar *dss_g,
uchar *dss_x, uchar *dss_y,
uchar *XKEY );
/* Generate secret number */
int GenDSSNumber( uchar *dss_k, uchar *dss_q,
uchar *KKEY );
/* Compute a Diffie-Hellman Shared number */
int GetDHSharedNumber( u_int16_t DH_modulus_bytes, uchar *DH_secret,
uchar *DH_public, uchar *DH_shared,
uchar *DH_modulus );
/* Set Key by Diffie_Hellman shared number */
int SetDESKAPPAKey( u_int16_t DH_modulus_bytes, uchar *DH_shared,
uchar *K );
/* Expand DES key */
void DESKeyExpand( uchar *key, uchar *K1 );
/* Encrypt a block of data with single DES */
int DESEncrypt( uchar *des_iv, uchar *des_key,
u_int16_t des_mode, uchar *input_array,
uchar *output_array, u_int16_t input_array_bytes );
/* Decrypt a block of data with single DES */
int DESDecrypt( uchar *des_iv, uchar *des_key,
u_int16_t des_mode, uchar *data_array,
u_int16_t data_array_bytes );
/* One-Time-Pad Signature with a Diffie-Hellman shared number */
int DHOneTimePad( u_int16_t DH_modulus_bytes, uchar *DH_shared,
uchar *X, uchar *Y );
/* Compute a Diffie-Hellman pair */
int GenDHPair( u_int16_t DH_modulus_bytes, uchar *DH_secret,
uchar *DH_public, uchar *DH_base,
uchar *DH_modulus, uchar *RVAL );
int GetPasswordKeySHA( u_int16_t Password_bytes, uchar *Password,
uchar *salt, u_int16_t Count,
uchar *K, uchar *IV );
/* Generate DSS Common Parameters */
int GenDSSParameters( u_int16_t dss_p_bytes, uchar *dss_p,
uchar *dss_q, uchar *dss_g,
uchar *RVAL, YIELD_context *yield_cont ); /*TKL00701*/
/* Produce a Shamir Key-Sharing Triplet for Secret Number */
int GenShamirTriplet( u_int16_t SecretNumber_bytes, uchar *SecretNumber,
uchar *first_value, uchar *second_value,
uchar *third_value, uchar *RVAL );
/* Reconstract a Secret Number from Shamir Key-Sharing Duplex */
int GetNumberShamirDuplex( u_int16_t SecretNumber_bytes,
uchar *value_A,
u_int16_t A_position, uchar *value_B,
u_int16_t B_position,
uchar *SecretNumber );
int SFDHEncrypt( u_int16_t DH_modulus_bytes,
uchar *DH_modulus,
uchar *DH_base,
uchar *DH_public,
uchar *DH_random_public,
uchar *DH_shared,
uchar *RVAL );
int SFDHDecrypt( u_int16_t DH_modulus_bytes,
uchar *DH_modulus,
uchar *DH_secret,
uchar *DH_random_public,
uchar *DH_shared );
/* Check DES key weakness */
int CheckDESKeyWeakness( uchar *key );
int SetCipherKey( u_int16_t DH_shared_bytes,
uchar *DH_shared,
uchar *Key,
u_int16_t cryptoMethod );
/* Non-Pipelined Triple DES encrypt*/
int TDESEncrypt( uchar *des_iv,
uchar *des_key1,uchar *des_key2, uchar *des_key3,
u_int16_t des_mode,
uchar *input_array,
uchar *output_array,
u_int16_t input_array_bytes );
/* Non-Pipelined Triple DES decrypt*/
int TDESDecrypt( uchar *des_iv,
uchar *des_key1,uchar *des_key2, uchar *des_key3,
u_int16_t des_mode,
uchar *data_array,
u_int16_t data_array_bytes );
/*Pipeline Triple DES encrypt*/
int PTDESEncrypt( uchar *iv1, uchar *iv2, uchar *iv3,
uchar *des_key1,uchar *des_key2, uchar *des_key3,
u_int16_t des_mode,
uchar *input_array,
uchar *output_array,
u_int16_t input_array_bytes );
/*Pipeline Triple DES decrypt*/
int PTDESDecrypt( uchar *iv1, uchar *iv2, uchar *iv3,
uchar *des_key1,uchar *des_key2, uchar *des_key3,
u_int16_t des_mode,
uchar *data_array,
u_int16_t input_array_bytes );
int PCBC1Encrypt( uchar *iv1, uchar *iv2, uchar *iv3,
uchar *des_key1,uchar *des_key2, uchar *des_key3,
uchar *msg1,uchar *msg2, uchar *msg3,
uchar *out1,uchar *out2, uchar *out3,
u_int16_t input_array_bytes );
int PCBC1Decrypt( uchar *iv1, uchar *iv2, uchar *iv3,
uchar *des_key1,uchar *des_key2, uchar *des_key3,
uchar *out1,uchar *out2, uchar *out3,
u_int16_t input_array_bytes );
/*CEPA enc/dec */
int CepaKeyExpand( uchar *key,
u_int16_t key_length,
u_int16_t number_of_rounds,
uchar *expanded_key );
int CepaCsp( u_int16_t key_length,
uchar *csp);
int CepaEncrypt( uchar *iv,
uchar *key,
u_int16_t mode,
uchar *csp,
u_int16_t r,
uchar *input_array,
uchar *output_array,
u_int16_t input_array_bytes );
int CepaDecrypt( uchar *iv,
uchar *key,
u_int16_t mode,
uchar *csp,
u_int16_t r,
uchar *data_array,
u_int16_t data_array_bytes );
void BigNumInit(void);
void SetDataOrder ( u_int16_t dataOrder);
int GetDHSecretShared( u_int16_t DH_modulus_bytes, u_int16_t DH_secret_bytes, uchar *DH_secret,
uchar *DH_public, uchar *DH_shared,
uchar *DH_modulus);
int GenDHKey( u_int16_t DH_modulus_bytes, u_int16_t DH_secret_bytes, uchar *DH_secret,
uchar *DH_public, uchar *DH_base,
uchar *DH_modulus, uchar *RVAL );
int SFDHInitiate( u_int16_t DH_modulus_bytes, u_int16_t DH_secret_bytes,
uchar *DH_modulus, uchar *DH_base,
uchar *DH_public, uchar *DH_random_public,
uchar *DH_shared, uchar *RVAL );
int SFDHComplete( u_int16_t DH_modulus_bytes, u_int16_t DH_secret_bytes,
uchar *DH_modulus,
uchar *DH_secret, uchar *DH_random_public,
uchar *DH_shared );
int SplitKey( u_int16_t Secretnumber_bytes, uchar *SecretNumber,
uchar *first_value, uchar *second_value,
uchar *third_value, uchar *RVAL );
int UnsplitKey( u_int16_t Secretnumber_bytes, uchar *value_A,
u_int16_t A_position, uchar *value_B,
u_int16_t B_position, uchar *SecretNumber );
int SAFERKeyExpand( uchar *key, u_int16_t key_length,
uchar *expanded_key );
int SAFEREncrypt( uchar *iv, uchar *key, u_int16_t mode, u_int16_t key_length,
uchar *input_array, uchar *output_array, u_int16_t input_array_bytes );
int SAFERDecrypt( uchar *iv, uchar *key, u_int16_t mode, u_int16_t r_length,
uchar *data_array, u_int16_t data_array_bytes );
void ByteSwap( uchar *X, u_int16_t X_len);
void ByteSwap32( uchar *X, u_int16_t X_len);
void WordSwap( uchar *X, u_int16_t X_len);
void BigSwap( uchar *buffer, u_int16_t bufferLength);
int Sum_big (ord *X, ord *Y, ord *Z, u_int16_t len_X);
int Sum_Q(ord *X, u_int16_t src, u_int16_t len_X);
void LShiftL_big( ord *X, u_int32_t len_X, u_int32_t n_bit );
int Sub_big (ord *X, ord *Y, ord *Z, u_int16_t len_X);
int DivRem( u_int16_t X_bytes, ord *X, u_int16_t P_bytes, ord *P,
ord *Z, ord *D);
int SteinGCD (ord *m, ord *n, u_int16_t len);
int Add( ord *X, ord *Y, u_int16_t P_len, ord *P);
int Inverse(u_int16_t X_bytes, ord *X, u_int16_t P_bytes, ord *P,
ord *Z);
int DoubleExpo(u_int16_t X1_bytes, ord *X1, u_int16_t Y1_bytes,
ord *Y1, u_int16_t X2_bytes, ord *X2,
u_int16_t Y2_bytes, ord *Y2, u_int16_t P_bytes,
ord *P, ord *Z);
int Sum (ord *X, ord *Y, u_int16_t len_X);
void Mul_big_1( ord X, ord *Y, ord *XY, u_int16_t ly);
int Mul( u_int16_t X_bytes, ord *X, u_int16_t Y_bytes, ord *Y,
u_int16_t P_bytes, ord *P, ord *Z );
int Square(u_int16_t X_bytes, ord *X, u_int16_t P_bytes, ord *P,
ord *Z);
int PartReduct(u_int16_t X_bytes, ord *X, u_int16_t P_bytes, ord *P,
ord *Z);
int Expo(u_int16_t X_bytes, ord *X, u_int16_t Y_bytes, ord *Y,
u_int16_t P_bytes, ord *P, ord *Z);
#ifdef __cplusplus
}
#endif
#endif /* TOOLKIT_H */

41
lib/bind/dnssafe/Makefile.in
View file

@ -1,41 +0,0 @@
OBJS= ahcbcpad.@O@ ahchdig.@O@ ahchencr.@O@ ahchgen.@O@ ahchrand.@O@ \
ahdigest.@O@ ahencryp.@O@ ahgen.@O@ ahrandom.@O@ ahrsaenc.@O@ \
ahrsaepr.@O@ ahrsaepu.@O@ aichdig.@O@ aichenc8.@O@ aichencn.@O@ \
aichencr.@O@ aichgen.@O@ aichrand.@O@ aimd5.@O@ aimd5ran.@O@ \
ainfotyp.@O@ ainull.@O@ airsaepr.@O@ airsaepu.@O@ airsakgn.@O@ \
airsaprv.@O@ airsapub.@O@ algchoic.@O@ algobj.@O@ amcrte.@O@ \
ammd5.@O@ ammd5r.@O@ amrkg.@O@ amrsae.@O@ balg.@O@ bgclrbit.c \
bgmdmpyx.@O@ bgmdsqx.@O@ bgmodexp.@O@ bgpegcd.@O@ big2exp.@O@ \
bigabs.@O@ bigacc.@O@ bigarith.@O@ bigcmp.@O@ bigconst.@O@ \
biginv.@O@ biglen.@O@ bigmodx.@O@ bigmpy.@O@ bigpdiv.@O@ \
bigpmpy.@O@ bigpmpyh.@O@ bigpmpyl.@O@ bigpsq.@O@ bigqrx.@O@ \
bigsmod.@O@ bigtocan.@O@ bigu.@O@ bigunexp.@O@ binfocsh.@O@ \
bkey.@O@ bmempool.@O@ cantobig.@O@ crt2.@O@ digest.@O@ \
digrand.@O@ encrypt.@O@ generate.@O@ intbits.@O@ intitem.@O@ \
keyobj.@O@ ki8byte.@O@ kifulprv.@O@ kiitem.@O@ kinfotyp.@O@ \
kipkcrpr.@O@ kirsacrt.@O@ kirsapub.@O@ md5.@O@ md5rand.@O@ \
prime.@O@ random.@O@ rsa.@O@ rsakeygn.@O@ seccbcd.@O@ \
seccbce.@O@ surrendr.@O@
SRCS= ahcbcpad.c ahchdig.c ahchencr.c ahchgen.c ahchrand.c ahdigest.c \
ahencryp.c ahgen.c ahrandom.c ahrsaenc.c ahrsaepr.c ahrsaepu.c \
aichdig.c aichenc8.c aichencn.c aichencr.c aichgen.c aichrand.c \
aimd5.c aimd5ran.c ainfotyp.c ainull.c airsaepr.c airsaepu.c \
airsakgn.c airsaprv.c airsapub.c algchoic.c algobj.c amcrte.c \
ammd5.c ammd5r.c amrkg.c amrsae.c balg.c bgclrbit.c bgmdmpyx.c \
bgmdsqx.c bgmodexp.c bgpegcd.c big2exp.c bigabs.c bigacc.c \
bigarith.c bigcmp.c bigconst.c biginv.c biglen.c bigmodx.c \
bigmpy.c bigpdiv.c bigpmpy.c bigpmpyh.c bigpmpyl.c bigpsq.c \
bigqrx.c bigsmod.c bigtocan.c bigu.c bigunexp.c binfocsh.c \
bkey.c bmempool.c cantobig.c crt2.c digest.c digrand.c encrypt.c \
generate.c intbits.c intitem.c keyobj.c ki8byte.c kifulprv.c \
kiitem.c kinfotyp.c kipkcrpr.c kirsacrt.c kirsapub.c md5.c \
md5rand.c prime.c random.c rsa.c rsakeygn.c seccbcd.c seccbce.c \
surrendr.c
TARGETS= ${OBJS}
CINCLUDES= -I.. -I../include
CWARNINGS= -Werror
@BIND9_MAKE_RULES@

176
lib/bind/dnssafe/ahcbcpad.c
View file

@ -1,176 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AHSecretCBCPad;
#define THIS_ENCRYPT_DECRYPT struct AHSecretCBCPad
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahcbcpad.h"
#include "port_after.h"
#define GENERATE_BREAK(type) { \
status = type; \
break; \
}
/* Inherit the base class destructor, block size,
and decrypt init and update routines.
*/
static AHEncryptDecryptVTable V_TABLE = {
AHChooseEncryptDestructor, AHChooseEncryptGetBlockLen,
AHSecretCBCPadEncryptInit, AHChooseEncryptDecryptInit,
AHSecretCBCPadEncryptUpdate, AHChooseEncryptDecryptUpdate,
AHSecretCBCPadEncryptFinal, AHSecretCBCPadDecryptFinal
};
AHSecretCBCPad *AHSecretCBCPadConstructor2 (handler, infoType, info)
AHSecretCBCPad *handler;
struct B_AlgorithmInfoType *infoType;
POINTER info;
{
if (handler == (AHSecretCBCPad *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AHSecretCBCPad *)T_malloc (sizeof (*handler)))
== (AHSecretCBCPad *)NULL_PTR)
return (handler);
}
/* Construct base class with the infoType and info. */
AHChooseEncryptConstructor2
(&handler->chooseEncryptDecrypt, infoType, info);
handler->chooseEncryptDecrypt.encryptDecrypt.vTable = &V_TABLE;
return (handler);
}
int AHSecretCBCPadEncryptInit (handler, key, chooser, surrenderContext)
AHSecretCBCPad *handler;
B_Key *key;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
/* For encryption, we need to track the input length */
handler->_inputRemainder = 0;
return (AHChooseEncryptEncryptInit
(handler, key, chooser, surrenderContext));
}
int AHSecretCBCPadEncryptUpdate
(handler, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext)
AHSecretCBCPad *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
const unsigned char *partIn;
unsigned int partInLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
/* For encryption, we need to track the input length */
handler->_inputRemainder = (handler->_inputRemainder + partInLen) % 8;
return (AHChooseEncryptEncryptUpdate
(handler, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext));
}
int AHSecretCBCPadEncryptFinal
(handler, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
AHSecretCBCPad *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned char finalBuffer[8];
unsigned int padLen, dummyPartOutLen;
padLen = 8 - handler->_inputRemainder;
T_memset ((POINTER)finalBuffer, padLen, padLen);
/* Add the pad bytes. This should force the output of the final block.
*/
if ((status = AHChooseEncryptEncryptUpdate
(handler, partOut, partOutLen, maxPartOutLen, finalBuffer, padLen,
randomAlgorithm, surrenderContext)) != 0)
return (status);
/* The encrypt final operation should have no output. */
if ((status = AHChooseEncryptEncryptFinal
(handler, (unsigned char *)NULL_PTR, &dummyPartOutLen, 0,
(B_Algorithm *)NULL_PTR, (A_SURRENDER_CTX *)NULL_PTR)) != 0)
return (status);
/* Restart the context. */
handler->_inputRemainder = 0;
/* No need to zeroize the finalBuffer since it only contains pad bytes. */
return (0);
}
int AHSecretCBCPadDecryptFinal
(handler, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
AHSecretCBCPad *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned char finalBuffer[16], *padBuffer;
unsigned int padLen, localPartOutLen, i;
do {
/* For now, the DecrypyFinal operations is set to output 16 bytes.
*/
if ((status = AHChooseEncryptDecryptFinal
(handler, finalBuffer, &localPartOutLen, sizeof (finalBuffer),
randomAlgorithm, surrenderContext)) != 0)
break;
if (localPartOutLen == 8)
padBuffer = finalBuffer;
else if (localPartOutLen == 16)
padBuffer = finalBuffer + 8;
else
GENERATE_BREAK (BE_INPUT_LEN);
/* Check that padding is one 1 to eight 8's.
*/
if ((padLen = (unsigned int)padBuffer[7]) == 0 || padLen > 8)
GENERATE_BREAK (BE_INPUT_DATA);
for (i = 8 - padLen; i < 8; i++) {
if ((unsigned int)padBuffer[i] != padLen)
GENERATE_BREAK (BE_INPUT_DATA);
}
if ((*partOutLen = localPartOutLen - padLen) > maxPartOutLen)
GENERATE_BREAK (BE_OUTPUT_LEN);
T_memcpy
((POINTER)partOut, (POINTER)finalBuffer, *partOutLen);
} while (0);
T_memset ((POINTER)finalBuffer, 0, sizeof (finalBuffer));
return (status);
}

37
lib/bind/dnssafe/ahcbcpad.h
View file

@ -1,37 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHCBCPAD_H_
#define _AHCBCPAD_H_
#include "ahchencr.h"
typedef struct AHSecretCBCPad {
AHChooseEncryptDecrypt chooseEncryptDecrypt; /* base class */
unsigned int _inputRemainder; /* Used for encrypt to compute pad length */
} AHSecretCBCPad;
AHSecretCBCPad *AHSecretCBCPadConstructor2 PROTO_LIST
((AHSecretCBCPad *, struct B_AlgorithmInfoType *, POINTER));
int AHSecretCBCPadEncryptInit PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int AHSecretCBCPadEncryptUpdate PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, const unsigned char *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *));
int AHSecretCBCPadEncryptFinal PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
int AHSecretCBCPadDecryptFinal PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
#endif

132
lib/bind/dnssafe/ahchdig.c
View file

@ -1,132 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AHChooseDigest;
#define THIS_DIGEST struct AHChooseDigest
#include "port_before.h"
#include "global.h"
#include "algae.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "balgmeth.h"
#include "ahchdig.h"
#include "amdigest.h"
#include "port_after.h"
static int InitDigestAlga PROTO_LIST
((AlgaChoice *, POINTER, B_ALGORITHM_METHOD *, A_SURRENDER_CTX *));
static AHDigestVTable V_TABLE = {
AHChooseDigestDestructor, AHChooseDigestInit, AHChooseDigestUpdate,
AHChooseDigestFinal
};
AHChooseDigest *AHChooseDigestConstructor2 (handler, infoType, info)
AHChooseDigest *handler;
struct B_AlgorithmInfoType *infoType;
POINTER info;
{
if (handler == (AHChooseDigest *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AHChooseDigest *)T_malloc (sizeof (*handler)))
== (AHChooseDigest *)NULL_PTR)
return (handler);
}
/* Construct base class */
AHDigestConstructor (&handler->digest);
ALGA_CHOICE_Constructor (&handler->algaChoice, InitDigestAlga);
handler->algaChoice._algorithmInfoType = infoType;
handler->algaChoice._algorithmInfo = info;
handler->digest.vTable = &V_TABLE;
return (handler);
}
void AHChooseDigestDestructor (handler)
AHChooseDigest *handler;
{
ALGA_CHOICE_Destructor (&handler->algaChoice);
/* There is no desructor to call for the base class. */
}
int AHChooseDigestInit (handler, key, chooser, surrenderContext)
AHChooseDigest *handler;
B_Key *key;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
return (AlgaChoiceChoose
(&handler->algaChoice, 0, key, chooser, surrenderContext));
}
int AHChooseDigestUpdate (handler, partIn, partInLen, surrenderContext)
AHChooseDigest *handler;
const unsigned char *partIn;
unsigned int partInLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = (*((A_DIGEST_ALGA *)handler->algaChoice._alga)->Update)
(handler->algaChoice.context.z.context, partIn, partInLen,
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
int AHChooseDigestFinal
(handler, partOut, partOutLen, maxPartOutLen, surrenderContext)
AHChooseDigest *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = (*((A_DIGEST_ALGA *)handler->algaChoice._alga)->Final)
(handler->algaChoice.context.z.context, partOut, partOutLen,
maxPartOutLen, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
static int InitDigestAlga
(algaChoice, keyInfo, algorithmMethod, surrenderContext)
AlgaChoice *algaChoice;
POINTER keyInfo;
B_ALGORITHM_METHOD *algorithmMethod;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned int contextSize;
UNUSED_ARG (keyInfo)
if ((status = (*((A_DIGEST_ALGA *)algorithmMethod->alga)->Query)
(&contextSize, algaChoice->_algorithmInfo)) != 0)
return (ConvertAlgaeError (status));
if ((status = ResizeContextMakeNewContext
(&algaChoice->context, contextSize)) != 0)
return (status);
if ((status = (*((A_DIGEST_ALGA *)algorithmMethod->alga)->Init)
(algaChoice->context.z.context, algaChoice->_algorithmInfo,
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}

32
lib/bind/dnssafe/ahchdig.h
View file

@ -1,32 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHCHDIG_H_
#define _AHCHDIG_H_ 1
#include "ahdigest.h"
#include "algchoic.h"
typedef struct AHChooseDigest {
AHDigest digest; /* base class */
AlgaChoice algaChoice;
} AHChooseDigest;
AHChooseDigest *AHChooseDigestConstructor2 PROTO_LIST
((AHChooseDigest *, struct B_AlgorithmInfoType *, POINTER));
void AHChooseDigestDestructor PROTO_LIST ((THIS_DIGEST *));
int AHChooseDigestInit PROTO_LIST
((THIS_DIGEST *, B_Key *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *));
int AHChooseDigestUpdate PROTO_LIST
((THIS_DIGEST *, const unsigned char *, unsigned int, A_SURRENDER_CTX *));
int AHChooseDigestFinal PROTO_LIST
((THIS_DIGEST *, unsigned char *, unsigned int *, unsigned int,
A_SURRENDER_CTX *));
#endif

268
lib/bind/dnssafe/ahchencr.c
View file

@ -1,268 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AHChooseEncryptDecrypt;
#define THIS_ENCRYPT_DECRYPT struct AHChooseEncryptDecrypt
#include "port_before.h"
#include "global.h"
#include "algae.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "balgmeth.h"
#include "ahchencr.h"
#include "amencdec.h"
#include "port_after.h"
static int InitEncryptDecryptAlga PROTO_LIST
((AlgaChoice *, POINTER, B_ALGORITHM_METHOD *, A_SURRENDER_CTX *));
static AHEncryptDecryptVTable V_TABLE = {
AHChooseEncryptDestructor, AHChooseEncryptGetBlockLen,
AHChooseEncryptEncryptInit, AHChooseEncryptDecryptInit,
AHChooseEncryptEncryptUpdate, AHChooseEncryptDecryptUpdate,
AHChooseEncryptEncryptFinal, AHChooseEncryptDecryptFinal
};
/* In C++:
AHChooseEncryptDecrypt::AHChooseEncryptDecrypt
(B_AlgorithmInfoType *infoType, POINTER info)
: algaChoice (InitEncryptDecryptAlga)
{
algaChoice.setAlgorithmInfoType (infoType);
algaChoice.setAlgorithmInfo (info);
}
*/
AHChooseEncryptDecrypt *AHChooseEncryptConstructor2 (handler, infoType, info)
AHChooseEncryptDecrypt *handler;
struct B_AlgorithmInfoType *infoType;
POINTER info;
{
if (handler == (AHChooseEncryptDecrypt *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AHChooseEncryptDecrypt *)T_malloc (sizeof (*handler)))
== (AHChooseEncryptDecrypt *)NULL_PTR)
return (handler);
}
/* Construct base class */
AHEncryptDecryptConstructor (&handler->encryptDecrypt);
ALGA_CHOICE_Constructor (&handler->algaChoice, InitEncryptDecryptAlga);
handler->algaChoice._algorithmInfoType = infoType;
handler->algaChoice._algorithmInfo = info;
handler->encryptDecrypt.vTable = &V_TABLE;
return (handler);
}
void AHChooseEncryptDestructor (handler)
AHChooseEncryptDecrypt *handler;
{
ALGA_CHOICE_Destructor (&handler->algaChoice);
/* There is no desructor to call for the base class. */
}
int AHChooseEncryptGetBlockLen (handler, blockLen)
AHChooseEncryptDecrypt *handler;
unsigned int *blockLen;
{
int status;
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)handler->algaChoice._alga)->
GetBlockLen)
(handler->algaChoice.context.z.context, blockLen)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
/* In C++:
int AHChooseEncryptDecrypt::encryptInit
(B_Key *key, B_ALGORITHM_CHOOSER chooser, A_SURRENDER_CTX *surrenderContext)
{
return (algaChoice.choose (1, key, chooser, surrenderContext));
}
*/
int AHChooseEncryptEncryptInit (handler, key, chooser, surrenderContext)
AHChooseEncryptDecrypt *handler;
B_Key *key;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
return (AlgaChoiceChoose
(&handler->algaChoice, 1, key, chooser, surrenderContext));
}
int AHChooseEncryptDecryptInit (handler, key, chooser, surrenderContext)
AHChooseEncryptDecrypt *handler;
B_Key *key;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
return (AlgaChoiceChoose
(&handler->algaChoice, 0, key, chooser, surrenderContext));
}
/* In C++:
int AHChooseEncryptDecrypt::encryptUpdate
(unsigned char *partOut, unsigned int *partOutLen,
unsigned int maxPartOutLen, unsigned char *partIn, unsigned int partInLen,
B_Algorithm *randomAlgorithm, A_SURRENDER_CTX *surrenderContext)
{
int status;
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)algaChoice.alga ()) ->Update)
(algaChoice.context (), partOut, partOutLen, maxPartOutLen,
partIn, partInLen, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
*/
int AHChooseEncryptEncryptUpdate
(handler, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext)
AHChooseEncryptDecrypt *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
const unsigned char *partIn;
unsigned int partInLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
UNUSED_ARG (randomAlgorithm)
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)handler->algaChoice._alga)->
Update)
(handler->algaChoice.context.z.context, partOut, partOutLen,
maxPartOutLen, partIn, partInLen, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
int AHChooseEncryptDecryptUpdate
(handler, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext)
AHChooseEncryptDecrypt *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
const unsigned char *partIn;
unsigned int partInLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
UNUSED_ARG (randomAlgorithm)
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)handler->algaChoice._alga)->
Update)
(handler->algaChoice.context.z.context, partOut, partOutLen,
maxPartOutLen, partIn, partInLen, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
int AHChooseEncryptEncryptFinal
(handler, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
AHChooseEncryptDecrypt *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
UNUSED_ARG (randomAlgorithm)
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)handler->algaChoice._alga)->Final)
(handler->algaChoice.context.z.context, partOut, partOutLen,
maxPartOutLen, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
int AHChooseEncryptDecryptFinal
(handler, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
AHChooseEncryptDecrypt *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
UNUSED_ARG (randomAlgorithm)
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)handler->algaChoice._alga)->Final)
(handler->algaChoice.context.z.context, partOut, partOutLen,
maxPartOutLen, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
/* In C++:
static int InitEncryptDecryptAlga
(AlgaChoice *algaChoice, POINTER keyInfo, POINTER alga,
A_SURRENDER_CTX *surrenderContext)
{
int status;
unsigned int contextSize;
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)alga)->Query)
(&contextSize, keyInfo, algaChoice->algorithmInfo ())) != 0)
return (ConvertAlgaeError (status));
if ((status = algaChoice->makeNewContext (contextSize)) != 0)
return (status);
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)alga)->Init)
(algaChoice->context (), keyInfo, algaChoice->algorithmInfo (),
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
*/
static int InitEncryptDecryptAlga
(algaChoice, keyInfo, algorithmMethod, surrenderContext)
AlgaChoice *algaChoice;
POINTER keyInfo;
B_ALGORITHM_METHOD *algorithmMethod;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned int contextSize;
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)algorithmMethod->alga)->Query)
(&contextSize, keyInfo, algaChoice->_algorithmInfo)) != 0)
return (ConvertAlgaeError (status));
if ((status = ResizeContextMakeNewContext
(&algaChoice->context, contextSize)) != 0)
return (status);
if ((status = (*((A_ENCRYPT_DECRYPT_ALGA *)algorithmMethod->alga)->Init)
(algaChoice->context.z.context, keyInfo, algaChoice->_algorithmInfo,
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}

74
lib/bind/dnssafe/ahchencr.h
View file

@ -1,74 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHCHENCR_H_
#define _AHCHENCR_H_ 1
#include "ahencryp.h"
#include "algchoic.h"
/* In C++:
class AHChooseEncryptDecrypt : public AHEncryptDecrypt {
public:
AHChooseEncryptDecrypt (B_AlgorithmInfoType *, POINTER);
virtual ~AHChooseEncryptDecrypt () {};
virtual int getBlockLen (unsigned int *);
virtual int encryptInit (B_Key *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *);
virtual int decryptInit (B_Key *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *);
virtual int encryptUpdate
(unsigned char *, unsigned int *, unsigned int, unsigned char *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *);
virtual int decryptUpdate
(unsigned char *, unsigned int *, unsigned int, unsigned char *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *);
virtual int encryptFinal
(unsigned char *, unsigned int *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *);
virtual int decryptFinal
(unsigned char *, unsigned int *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *);
private:
AlgaChoice algaChoice;
};
*/
typedef struct AHChooseEncryptDecrypt {
AHEncryptDecrypt encryptDecrypt; /* base class */
AlgaChoice algaChoice;
} AHChooseEncryptDecrypt;
AHChooseEncryptDecrypt *AHChooseEncryptConstructor2 PROTO_LIST
((AHChooseEncryptDecrypt *, struct B_AlgorithmInfoType *, POINTER));
void AHChooseEncryptDestructor PROTO_LIST ((THIS_ENCRYPT_DECRYPT *));
int AHChooseEncryptGetBlockLen PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned int *));
int AHChooseEncryptEncryptInit PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int AHChooseEncryptDecryptInit PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int AHChooseEncryptEncryptUpdate PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, const unsigned char *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *));
int AHChooseEncryptDecryptUpdate PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, const unsigned char *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *));
int AHChooseEncryptEncryptFinal PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
int AHChooseEncryptDecryptFinal PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
#endif

218
lib/bind/dnssafe/ahchgen.c
View file

@ -1,218 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AHChooseGenerate;
#define THIS_GENERATE struct AHChooseGenerate
/* Define this so that the type of the AlgaChoice pointer in the
INIT_ALGA functions will be correct for this derived class.
*/
struct GenerateAlgaChoice;
#define THIS_ALGA_CHOICE struct GenerateAlgaChoice
#include "port_before.h"
#include "global.h"
#include "algae.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "balgmeth.h"
#include "ahchgen.h"
#include "amgen.h"
#include "port_after.h"
static int InitGenerateAlga PROTO_LIST
((GenerateAlgaChoice *, POINTER, B_ALGORITHM_METHOD *, A_SURRENDER_CTX *));
static int GenerateResult PROTO_LIST
((GenerateAlgaChoice *, POINTER *, B_Algorithm *, A_SURRENDER_CTX *));
static AHGenerateVTable V_TABLE = {
AHChooseGenerateDestructor, AHChooseGenerateInit, AHChooseGenerateKeypair,
AHChooseGenerateParameters
};
AHChooseGenerate *AHChooseGenerateConstructor2 (handler, infoType, info)
AHChooseGenerate *handler;
struct B_AlgorithmInfoType *infoType;
POINTER info;
{
if (handler == (AHChooseGenerate *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AHChooseGenerate *)T_malloc (sizeof (*handler)))
== (AHChooseGenerate *)NULL_PTR)
return (handler);
}
/* Construct base class */
AHGenerateConstructor (&handler->generate);
ALGA_CHOICE_Constructor
(&handler->generateAlgaChoice.algaChoice, InitGenerateAlga);
ResizeContextConstructor (&handler->generateAlgaChoice.secondContext);
ResizeContextConstructor (&handler->generateAlgaChoice.randomBlock);
/* Set algaChoice.
*/
handler->generateAlgaChoice.algaChoice._algorithmInfoType = infoType;
handler->generateAlgaChoice.algaChoice._algorithmInfo = info;
handler->generate.vTable = &V_TABLE;
return (handler);
}
void AHChooseGenerateDestructor (handler)
AHChooseGenerate *handler;
{
ResizeContextDestructor (&handler->generateAlgaChoice.secondContext);
ResizeContextDestructor (&handler->generateAlgaChoice.randomBlock);
ALGA_CHOICE_Destructor (&handler->generateAlgaChoice.algaChoice);
/* There is no desructor to call for the base class. */
}
int AHChooseGenerateInit (handler, chooser, surrenderContext)
AHChooseGenerate *handler;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
return (AlgaChoiceChoose
(&handler->generateAlgaChoice.algaChoice, 0, (B_Key *)NULL_PTR,
chooser, surrenderContext));
}
int AHChooseGenerateKeypair
(handler, publicKey, privateKey, randomAlgorithm, surrenderContext)
AHChooseGenerate *handler;
B_Key *publicKey;
B_Key *privateKey;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
POINTER result;
int status;
if ((status = GenerateResult
(&handler->generateAlgaChoice, &result, randomAlgorithm,
surrenderContext)) != 0)
return (status);
if ((status = B_KeySetInfo
(publicKey, handler->generateAlgaChoice._resultInfoType, result)) != 0)
return (status);
return (B_KeySetInfo
(privateKey, handler->generateAlgaChoice._resultInfoType, result));
}
int AHChooseGenerateParameters
(handler, resultAlgorithm, randomAlgorithm, surrenderContext)
AHChooseGenerate *handler;
B_Algorithm *resultAlgorithm;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
POINTER result;
int status;
if ((status = GenerateResult
(&handler->generateAlgaChoice, &result, randomAlgorithm,
surrenderContext)) != 0)
return (status);
/* Force the resultInfoType into a B_AlgorithmInfoType since it is
supplied in the chooser as a B_KeyInfoType. */
return (B_AlgorithmSetInfo
(resultAlgorithm, (struct B_AlgorithmInfoType *)
handler->generateAlgaChoice._resultInfoType, result));
}
static int InitGenerateAlga
(generateAlgaChoice, keyInfo, algorithmMethod, surrenderContext)
GenerateAlgaChoice *generateAlgaChoice;
POINTER keyInfo;
B_ALGORITHM_METHOD *algorithmMethod;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned int contextSize, secondContextSize;
UNUSED_ARG (keyInfo)
/* Note that this also gets the resultInfoType which will be used later
by GenerateResult. */
if ((status = (*((A_GENERATE_ALGA *)algorithmMethod->alga)->Query)
(&contextSize, &secondContextSize, &generateAlgaChoice->_randomBlockLen,
&generateAlgaChoice->_resultInfoType,
generateAlgaChoice->algaChoice._algorithmInfo)) != 0)
return (ConvertAlgaeError (status));
/* Create the context.
*/
if ((status = ResizeContextMakeNewContext
(&generateAlgaChoice->algaChoice.context, contextSize)) != 0)
return (status);
/* Create the second context which is only passed during Init, but
must persist for all operations. */
if ((status = ResizeContextMakeNewContext
(&generateAlgaChoice->secondContext, secondContextSize)) != 0)
return (status);
/* Create randomBlock which will be filled in during GenerateResult. */
if ((status = ResizeContextMakeNewContext
(&generateAlgaChoice->randomBlock, generateAlgaChoice->_randomBlockLen))
!= 0)
return (status);
if ((status = (*((A_GENERATE_ALGA *)algorithmMethod->alga)->Init)
(generateAlgaChoice->algaChoice.context.z.context,
generateAlgaChoice->secondContext.z.context,
generateAlgaChoice->algaChoice._algorithmInfo, surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
/* Call the generate procedure repeatedly with a new random block
until it succeeds.
*/
static int GenerateResult
(generateAlgaChoice, result, randomAlgorithm, surrenderContext)
GenerateAlgaChoice *generateAlgaChoice;
POINTER *result;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
/* Fill in the random block and try generating as long as the
the generate operation returns BE_NEED_RANDOM.
*/
while (1) {
if ((status = B_AlgorithmGenerateRandomBytes
(randomAlgorithm,
(unsigned char *)generateAlgaChoice->randomBlock.z.context,
generateAlgaChoice->_randomBlockLen, surrenderContext)) != 0)
return (status);
if ((status = (*((A_GENERATE_ALGA *)
generateAlgaChoice->algaChoice._alga)->Generate)
(generateAlgaChoice->algaChoice.context.z.context, result,
(unsigned char *)generateAlgaChoice->randomBlock.z.context,
surrenderContext)) != 0) {
if (status != AE_NEED_RANDOM)
return (ConvertAlgaeError (status));
/* Else continue and try again */
}
else
/* Success, so return */
return (0);
}
}

44
lib/bind/dnssafe/ahchgen.h
View file

@ -1,44 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHCHGEN_H_
#define _AHCHGEN_H_ 1
#include "ahgen.h"
#include "algchoic.h"
/* Make a new class derived from an AlgaChoice which records the
result algorithm info type and needed randomBlockLen.
*/
typedef struct GenerateAlgaChoice {
AlgaChoice algaChoice; /* base class */
struct B_KeyInfoType *_resultInfoType;
ResizeContext secondContext; /* used for scratch */
ResizeContext randomBlock;
unsigned int _randomBlockLen;
} GenerateAlgaChoice;
typedef struct AHChooseGenerate {
AHGenerate generate; /* base class */
GenerateAlgaChoice generateAlgaChoice;
} AHChooseGenerate;
AHChooseGenerate *AHChooseGenerateConstructor2 PROTO_LIST
((AHChooseGenerate *, struct B_AlgorithmInfoType *, POINTER));
void AHChooseGenerateDestructor PROTO_LIST ((THIS_GENERATE *));
int AHChooseGenerateInit PROTO_LIST
((THIS_GENERATE *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *));
int AHChooseGenerateKeypair PROTO_LIST
((THIS_GENERATE *, B_Key *, B_Key *, B_Algorithm *, A_SURRENDER_CTX *));
int AHChooseGenerateParameters PROTO_LIST
((THIS_GENERATE *, B_Algorithm *, B_Algorithm *, A_SURRENDER_CTX *));
#endif

130
lib/bind/dnssafe/ahchrand.c
View file

@ -1,130 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AHChooseRandom;
#define THIS_RANDOM struct AHChooseRandom
#include "port_before.h"
#include "global.h"
#include "algae.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "balgmeth.h"
#include "ahchrand.h"
#include "amrandom.h"
#include "port_after.h"
static int InitRandomAlga PROTO_LIST
((AlgaChoice *, POINTER, B_ALGORITHM_METHOD *, A_SURRENDER_CTX *));
static AHRandomVTable V_TABLE = {
AHChooseRandomDestructor, AHChooseRandomInit, AHChooseRandomUpdate,
AHChooseRandomGenerateBytes
};
AHChooseRandom *AHChooseRandomConstructor2 (handler, infoType, info)
AHChooseRandom *handler;
struct B_AlgorithmInfoType *infoType;
POINTER info;
{
if (handler == (AHChooseRandom *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AHChooseRandom *)T_malloc (sizeof (*handler)))
== (AHChooseRandom *)NULL_PTR)
return (handler);
}
/* Construct base class */
AHRandomConstructor (&handler->random);
ALGA_CHOICE_Constructor (&handler->algaChoice, InitRandomAlga);
handler->algaChoice._algorithmInfoType = infoType;
handler->algaChoice._algorithmInfo = info;
handler->random.vTable = &V_TABLE;
return (handler);
}
void AHChooseRandomDestructor (handler)
AHChooseRandom *handler;
{
ALGA_CHOICE_Destructor (&handler->algaChoice);
/* There is no desructor to call for the base class. */
}
int AHChooseRandomInit (handler, chooser, surrenderContext)
AHChooseRandom *handler;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
return (AlgaChoiceChoose
(&handler->algaChoice, 0, (B_Key *)NULL_PTR, chooser,
surrenderContext));
}
int AHChooseRandomUpdate (handler, input, inputLen, surrenderContext)
AHChooseRandom *handler;
unsigned char *input;
unsigned int inputLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = (*((A_RANDOM_ALGA *)handler->algaChoice._alga)->Update)
(handler->algaChoice.context.z.context, input, inputLen,
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
int AHChooseRandomGenerateBytes (handler, output, outputLen, surrenderContext)
AHChooseRandom *handler;
unsigned char *output;
unsigned int outputLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = (*((A_RANDOM_ALGA *)handler->algaChoice._alga)->Generate)
(handler->algaChoice.context.z.context, output, outputLen,
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}
static int InitRandomAlga
(algaChoice, keyInfo, algorithmMethod, surrenderContext)
AlgaChoice *algaChoice;
POINTER keyInfo;
B_ALGORITHM_METHOD *algorithmMethod;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned int contextSize;
UNUSED_ARG (keyInfo)
if ((status = (*((A_RANDOM_ALGA *)algorithmMethod->alga)->Query)
(&contextSize, algaChoice->_algorithmInfo)) != 0)
return (ConvertAlgaeError (status));
if ((status = ResizeContextMakeNewContext
(&algaChoice->context, contextSize)) != 0)
return (status);
if ((status = (*((A_RANDOM_ALGA *)algorithmMethod->alga)->Init)
(algaChoice->context.z.context, algaChoice->_algorithmInfo,
surrenderContext)) != 0)
return (ConvertAlgaeError (status));
return (0);
}

31
lib/bind/dnssafe/ahchrand.h
View file

@ -1,31 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHCHRAND_H_
#define _AHCHRAND_H_ 1
#include "ahrandom.h"
#include "algchoic.h"
typedef struct AHChooseRandom {
AHRandom random; /* base class */
AlgaChoice algaChoice;
} AHChooseRandom;
AHChooseRandom *AHChooseRandomConstructor2 PROTO_LIST
((AHChooseRandom *, struct B_AlgorithmInfoType *, POINTER));
void AHChooseRandomDestructor PROTO_LIST ((THIS_RANDOM *));
int AHChooseRandomInit PROTO_LIST
((THIS_RANDOM *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *));
int AHChooseRandomUpdate PROTO_LIST
((THIS_RANDOM *, unsigned char *, unsigned int, A_SURRENDER_CTX *));
int AHChooseRandomGenerateBytes PROTO_LIST
((THIS_RANDOM *, unsigned char *, unsigned int, A_SURRENDER_CTX *));
#endif

93
lib/bind/dnssafe/ahdigest.c
View file

@ -1,93 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahdigest.h"
#include "port_after.h"
static void TypedAHDigestDestructor PROTO_LIST ((B_TypeCheck *));
void AHDigestConstructor (handler)
AHDigest *handler;
{
/* Construct base class, setting type tag. */
B_TYPE_CHECK_Constructor
(&handler->typeCheck, TypedAHDigestDestructor);
/* Don't set vTable since this is a pure virtual base class. */
}
int B_AlgorithmDigestInit
(algorithm, key, algorithmChooser, surrenderContext)
B_Algorithm *algorithm;
B_Key *key;
B_ALGORITHM_CHOOSER algorithmChooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckType
(algorithm, TypedAHDigestDestructor)) != 0)
return (status);
if ((status =
(*((AHDigest *)algorithm->z.handler)->vTable->DigestInit)
((AHDigest *)algorithm->z.handler, key, algorithmChooser,
surrenderContext)) != 0)
return (status);
algorithm->z.initFlag = 1;
return (0);
}
int B_AlgorithmDigestUpdate (algorithm, partIn, partInLen, surrenderContext)
B_Algorithm *algorithm;
const unsigned char *partIn;
unsigned int partInLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHDigestDestructor)) != 0)
return (status);
return ((*((AHDigest *)algorithm->z.handler)->vTable->DigestUpdate)
((AHDigest *)algorithm->z.handler, partIn, partInLen,
surrenderContext));
}
int B_AlgorithmDigestFinal
(algorithm, partOut, partOutLen, maxPartOutLen, surrenderContext)
B_Algorithm *algorithm;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHDigestDestructor)) != 0)
return (status);
return ((*((AHDigest *)algorithm->z.handler)->vTable->DigestFinal)
((AHDigest *)algorithm->z.handler, partOut, partOutLen,
maxPartOutLen, surrenderContext));
}
static void TypedAHDigestDestructor (typeCheck)
B_TypeCheck *typeCheck;
{
(*((AHDigest *)typeCheck)->vTable->Destructor) ((AHDigest *)typeCheck);
}

48
lib/bind/dnssafe/ahdigest.h
View file

@ -1,48 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHDIGEST_H_
#define _AHDIGEST_H_ 1
#include "btypechk.h"
/* Use the THIS_DIGEST macro to define the type of object in the
virtual function prototype. It defaults to the most base class, but
derived modules may define the macro to a more derived class before
including this header file.
*/
#ifndef THIS_DIGEST
#define THIS_DIGEST struct AHDigest
#endif
struct AHDigest;
typedef struct {
void (*Destructor) PROTO_LIST ((THIS_DIGEST *));
int (*DigestInit) PROTO_LIST
((THIS_DIGEST *, B_Key *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *));
int (*DigestUpdate) PROTO_LIST
((THIS_DIGEST *, const unsigned char *, unsigned int, A_SURRENDER_CTX *));
int (*DigestFinal) PROTO_LIST
((THIS_DIGEST *, unsigned char *, unsigned int *, unsigned int,
A_SURRENDER_CTX *));
} AHDigestVTable;
typedef struct AHDigest {
B_TypeCheck typeCheck; /* inherited */
AHDigestVTable *vTable; /* pure virtual */
} AHDigest;
/* The constructor does not set the vTable since this is a pure base class.
*/
void AHDigestConstructor PROTO_LIST ((AHDigest *));
/* No destructor because it is pure virtual. Also, do not call destructor
for B_TypeCheck, since this will just re-invoke this virtual
destructor. */
#endif

171
lib/bind/dnssafe/ahencryp.c
View file

@ -1,171 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahencryp.h"
#include "port_after.h"
static void TypedAHEncryptDecryptDestructor PROTO_LIST ((B_TypeCheck *));
void AHEncryptDecryptConstructor (handler)
AHEncryptDecrypt *handler;
{
/* Construct base class, setting type tag. */
B_TYPE_CHECK_Constructor
(&handler->typeCheck, TypedAHEncryptDecryptDestructor);
/* Don't set vTable since this is a pure virtual base class. */
}
int B_AlgorithmEncryptInit
(algorithm, key, algorithmChooser, surrenderContext)
B_Algorithm *algorithm;
B_Key *key;
B_ALGORITHM_CHOOSER algorithmChooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckType
(algorithm, TypedAHEncryptDecryptDestructor)) != 0)
return (status);
if ((status =
(*((AHEncryptDecrypt *)algorithm->z.handler)->vTable->EncryptInit)
((AHEncryptDecrypt *)algorithm->z.handler, key, algorithmChooser,
surrenderContext)) != 0)
return (status);
algorithm->z.initFlag = 1;
return (0);
}
int B_AlgorithmDecryptInit
(algorithm, key, algorithmChooser, surrenderContext)
B_Algorithm *algorithm;
B_Key *key;
B_ALGORITHM_CHOOSER algorithmChooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckType
(algorithm, TypedAHEncryptDecryptDestructor)) != 0)
return (status);
if ((status =
(*((AHEncryptDecrypt *)algorithm->z.handler)->vTable->DecryptInit)
((AHEncryptDecrypt *)algorithm->z.handler, key, algorithmChooser,
surrenderContext)) != 0)
return (status);
algorithm->z.initFlag = 1;
return (0);
}
int B_AlgorithmEncryptUpdate
(algorithm, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext)
B_Algorithm *algorithm;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
unsigned char *partIn;
unsigned int partInLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHEncryptDecryptDestructor)) != 0)
return (status);
return ((*((AHEncryptDecrypt *)algorithm->z.handler)->vTable->EncryptUpdate)
((AHEncryptDecrypt *)algorithm->z.handler, partOut, partOutLen,
maxPartOutLen, partIn, partInLen, randomAlgorithm,
surrenderContext));
}
int B_AlgorithmDecryptUpdate
(algorithm, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext)
B_Algorithm *algorithm;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
const unsigned char *partIn;
unsigned int partInLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHEncryptDecryptDestructor)) != 0)
return (status);
return ((*((AHEncryptDecrypt *)algorithm->z.handler)->vTable->DecryptUpdate)
((AHEncryptDecrypt *)algorithm->z.handler, partOut, partOutLen,
maxPartOutLen, partIn, partInLen, randomAlgorithm,
surrenderContext));
}
int B_AlgorithmEncryptFinal
(algorithm, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
B_Algorithm *algorithm;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHEncryptDecryptDestructor)) != 0)
return (status);
return ((*((AHEncryptDecrypt *)algorithm->z.handler)->vTable->EncryptFinal)
((AHEncryptDecrypt *)algorithm->z.handler, partOut, partOutLen,
maxPartOutLen, randomAlgorithm, surrenderContext));
}
int B_AlgorithmDecryptFinal
(algorithm, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
B_Algorithm *algorithm;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHEncryptDecryptDestructor)) != 0)
return (status);
return ((*((AHEncryptDecrypt *)algorithm->z.handler)->vTable->DecryptFinal)
((AHEncryptDecrypt *)algorithm->z.handler, partOut, partOutLen,
maxPartOutLen, randomAlgorithm, surrenderContext));
}
static void TypedAHEncryptDecryptDestructor (typeCheck)
B_TypeCheck *typeCheck;
{
(*((AHEncryptDecrypt *)typeCheck)->vTable->Destructor)
((AHEncryptDecrypt *)typeCheck);
}

85
lib/bind/dnssafe/ahencryp.h
View file

@ -1,85 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHENCRYP_H_
#define _AHENCRYP_H_ 1
#include "btypechk.h"
/* In C++:
class AHEncryptDecrypt : public B_TypeCheck {
AHEncryptDecrypt ();
virtual ~AHEncryptDecrypt () = 0;
virtual int getBlockLen (unsigned int *) = 0;
virtual int encryptInit
(B_Key *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *) = 0;
virtual int decryptInit
(B_Key *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *) = 0;
virtual int encryptUpdate
(unsigned char *, unsigned int *, unsigned int, unsigned char *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *) = 0;
virtual int decryptUpdate
(unsigned char *, unsigned int *, unsigned int, unsigned char *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *) = 0;
virtual int encryptFinal
(unsigned char *, unsigned int *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *) = 0;
virtual int decryptFinal
(unsigned char *, unsigned int *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *) = 0;
};
*/
/* Use the THIS_ENCRYPT_DECRYPT macro to define the type of object in the
virtual function prototype. It defaults to the most base class, but
derived modules may define the macro to a more derived class before
including this header file.
*/
#ifndef THIS_ENCRYPT_DECRYPT
#define THIS_ENCRYPT_DECRYPT struct AHEncryptDecrypt
#endif
struct AHEncryptDecrypt;
typedef struct {
void (*Destructor) PROTO_LIST ((THIS_ENCRYPT_DECRYPT *));
int (*GetBlockLen) PROTO_LIST ((THIS_ENCRYPT_DECRYPT *, unsigned int *));
int (*EncryptInit) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int (*DecryptInit) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int (*EncryptUpdate) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *, unsigned int,
const unsigned char *, unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
int (*DecryptUpdate) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *, unsigned int,
const unsigned char *, unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
int (*EncryptFinal) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *, unsigned int,
B_Algorithm *, A_SURRENDER_CTX *));
int (*DecryptFinal) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *, unsigned int,
B_Algorithm *, A_SURRENDER_CTX *));
} AHEncryptDecryptVTable;
typedef struct AHEncryptDecrypt {
B_TypeCheck typeCheck; /* inherited */
AHEncryptDecryptVTable *vTable; /* pure virtual */
} AHEncryptDecrypt;
/* The constructor does not set the vTable since this is a pure base class.
*/
void AHEncryptDecryptConstructor PROTO_LIST ((AHEncryptDecrypt *));
/* No destructor because it is pure virtual. Also, do not call destructor
for B_TypeCheck, since this will just re-invoke this virtual
destructor. */
#endif

92
lib/bind/dnssafe/ahgen.c
View file

@ -1,92 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahgen.h"
#include "port_after.h"
static void TypedAHGenerateDestructor PROTO_LIST ((B_TypeCheck *));
void AHGenerateConstructor (handler)
AHGenerate *handler;
{
/* Construct base class, setting type tag. */
B_TYPE_CHECK_Constructor
(&handler->typeCheck, TypedAHGenerateDestructor);
/* Don't set vTable since this is a pure virtual base class. */
}
int B_AlgorithmGenerateInit (algorithm, algorithmChooser, surrenderContext)
B_Algorithm *algorithm;
B_ALGORITHM_CHOOSER algorithmChooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckType
(algorithm, TypedAHGenerateDestructor)) != 0)
return (status);
if ((status =
(*((AHGenerate *)algorithm->z.handler)->vTable->GenerateInit)
((AHGenerate *)algorithm->z.handler, algorithmChooser,
surrenderContext)) != 0)
return (status);
algorithm->z.initFlag = 1;
return (0);
}
int B_AlgorithmGenerateKeypair
(algorithm, publicKey, privateKey, randomAlgorithm, surrenderContext)
B_Algorithm *algorithm;
B_Key *publicKey;
B_Key *privateKey;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHGenerateDestructor)) != 0)
return (status);
return ((*((AHGenerate *)algorithm->z.handler)->vTable->GenerateKeypair)
((AHGenerate *)algorithm->z.handler, publicKey, privateKey,
randomAlgorithm, surrenderContext));
}
int B_AlgorithmGenerateParameters
(algorithm, resultAlgorithm, randomAlgorithm, surrenderContext)
B_Algorithm *algorithm;
B_Algorithm *resultAlgorithm;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHGenerateDestructor)) != 0)
return (status);
return ((*((AHGenerate *)algorithm->z.handler)->vTable->GenerateParameters)
((AHGenerate *)algorithm->z.handler, resultAlgorithm,
randomAlgorithm, surrenderContext));
}
static void TypedAHGenerateDestructor (typeCheck)
B_TypeCheck *typeCheck;
{
(*((AHGenerate *)typeCheck)->vTable->Destructor) ((AHGenerate *)typeCheck);
}

47
lib/bind/dnssafe/ahgen.h
View file

@ -1,47 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHGEN_H_
#define _AHGEN_H_ 1
#include "btypechk.h"
/* Use the THIS_GENERATE macro to define the type of object in the
virtual function prototype. It defaults to the most base class, but
derived modules may define the macro to a more derived class before
including this header file.
*/
#ifndef THIS_GENERATE
#define THIS_GENERATE struct AHGenerate
#endif
struct AHGenerate;
typedef struct {
void (*Destructor) PROTO_LIST ((THIS_GENERATE *));
int (*GenerateInit) PROTO_LIST
((THIS_GENERATE *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *));
int (*GenerateKeypair) PROTO_LIST
((THIS_GENERATE *, B_Key *, B_Key *, B_Algorithm *, A_SURRENDER_CTX *));
int (*GenerateParameters) PROTO_LIST
((THIS_GENERATE *, B_Algorithm *, B_Algorithm *, A_SURRENDER_CTX *));
} AHGenerateVTable;
typedef struct AHGenerate {
B_TypeCheck typeCheck; /* inherited */
AHGenerateVTable *vTable; /* pure virtual */
} AHGenerate;
/* The constructor does not set the vTable since this is a pure base class.
*/
void AHGenerateConstructor PROTO_LIST ((AHGenerate *));
/* No destructor because it is pure virtual. Also, do not call destructor
for B_TypeCheck, since this will just re-invoke this virtual
destructor. */
#endif

99
lib/bind/dnssafe/ahrandom.c
View file

@ -1,99 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahrandom.h"
#include "port_after.h"
static void TypedAHRandomDestructor PROTO_LIST ((B_TypeCheck *));
void AHRandomConstructor (handler)
AHRandom *handler;
{
/* Construct base class, setting type tag. */
B_TYPE_CHECK_Constructor
(&handler->typeCheck, TypedAHRandomDestructor);
/* Don't set vTable since this is a pure virtual base class. */
}
int B_AlgorithmRandomInit (algorithm, algorithmChooser, surrenderContext)
B_Algorithm *algorithm;
B_ALGORITHM_CHOOSER algorithmChooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckType (algorithm, TypedAHRandomDestructor))
!= 0)
return (status);
if ((status =
(*((AHRandom *)algorithm->z.handler)->vTable->RandomInit)
((AHRandom *)algorithm->z.handler, algorithmChooser, surrenderContext))
!= 0)
return (status);
algorithm->z.initFlag = 1;
return (0);
}
int B_AlgorithmRandomUpdate (algorithm, input, inputLen, surrenderContext)
B_Algorithm *algorithm;
unsigned char *input;
unsigned int inputLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHRandomDestructor)) != 0)
return (status == BE_ALGORITHM_NOT_INITIALIZED ?
BE_RANDOM_NOT_INITIALIZED : status);
return ((*((AHRandom *)algorithm->z.handler)->vTable->RandomUpdate)
((AHRandom *)algorithm->z.handler, input, inputLen,
surrenderContext));
}
int B_AlgorithmGenerateRandomBytes
(algorithm, output, outputLen, surrenderContext)
B_Algorithm *algorithm;
unsigned char *output;
unsigned int outputLen;
A_SURRENDER_CTX *surrenderContext;
{
int status;
/* As a special case, check here for a null this pointer when the object
is actually being used since many routines take a "dummy" null
random algorithm.
*/
if (algorithm == (B_Algorithm *)NULL_PTR)
return (BE_RANDOM_OBJ);
if ((status = B_AlgorithmCheckTypeAndInitFlag
(algorithm, TypedAHRandomDestructor)) != 0)
return (status == BE_ALGORITHM_NOT_INITIALIZED ?
BE_RANDOM_NOT_INITIALIZED : status);
return ((*((AHRandom *)algorithm->z.handler)->vTable->GenerateBytes)
((AHRandom *)algorithm->z.handler, output, outputLen,
surrenderContext));
}
static void TypedAHRandomDestructor (typeCheck)
B_TypeCheck *typeCheck;
{
(*((AHRandom *)typeCheck)->vTable->Destructor) ((AHRandom *)typeCheck);
}

47
lib/bind/dnssafe/ahrandom.h
View file

@ -1,47 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHRANDOM_H_
#define _AHRANDOM_H_ 1
#include "btypechk.h"
/* Use the THIS_RANDOM macro to define the type of object in the
virtual function prototype. It defaults to the most base class, but
derived modules may define the macro to a more derived class before
including this header file.
*/
#ifndef THIS_RANDOM
#define THIS_RANDOM struct AHRandom
#endif
struct AHRandom;
typedef struct {
void (*Destructor) PROTO_LIST ((THIS_RANDOM *));
int (*RandomInit) PROTO_LIST
((THIS_RANDOM *, B_ALGORITHM_CHOOSER, A_SURRENDER_CTX *));
int (*RandomUpdate) PROTO_LIST
((THIS_RANDOM *, unsigned char *, unsigned int, A_SURRENDER_CTX *));
int (*GenerateBytes) PROTO_LIST
((THIS_RANDOM *, unsigned char *, unsigned int, A_SURRENDER_CTX *));
} AHRandomVTable;
typedef struct AHRandom {
B_TypeCheck typeCheck; /* inherited */
AHRandomVTable *vTable; /* pure virtual */
} AHRandom;
/* The constructor does not set the vTable since this is a pure base class.
*/
void AHRandomConstructor PROTO_LIST ((AHRandom *));
/* No destructor because it is pure virtual. Also, do not call destructor
for B_TypeCheck, since this will just re-invoke this virtual
destructor. */
#endif

244
lib/bind/dnssafe/ahrsaenc.c
View file

@ -1,244 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AH_RSAEncryption;
#define THIS_ENCRYPT_DECRYPT struct AH_RSAEncryption
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahrsaenc.h"
#include "port_after.h"
static int AH_RSAEncryptionInitHelper PROTO_LIST ((AH_RSAEncryption *, int));
static AHEncryptDecryptVTable V_TABLE = {
AH_RSAEncryptionDestructor, AH_RSAEncryptionGetBlockLen,
AH_RSAEncryptionEncryptInit, AH_RSAEncryptionDecryptInit,
AH_RSAEncryptionUpdate,
AH_RSAEncryptionUpdate,
AH_RSAEncryptionEncryptFinal, AH_RSAEncryptionDecryptFinal
};
void AH_RSAEncryptionConstructor1 (handler, infoType)
AH_RSAEncryption *handler;
struct B_AlgorithmInfoType *infoType;
{
/* Construct base class with the infoType. Assume info is NULL_PTR. */
AHChooseEncryptConstructor2
(&handler->chooseEncryptDecrypt, infoType, NULL_PTR);
T_memset ((POINTER)&handler->z, 0, sizeof (handler->z));
/* Set the AHEncryptDecrypt vTable, but don't set the RSAEncryption vTable
since it is pure virtual. */
handler->chooseEncryptDecrypt.encryptDecrypt.vTable = &V_TABLE;
}
void AH_RSAEncryptionDestructor (handler)
AH_RSAEncryption *handler;
{
T_memset ((POINTER)handler->z.block, 0, handler->z.blockLen);
T_free ((POINTER)handler->z.block);
/* Call base class destructor */
AHChooseEncryptDestructor (handler);
}
int AH_RSAEncryptionGetBlockLen (handler, blockLen)
AH_RSAEncryption *handler;
unsigned int *blockLen;
{
UNUSED_ARG (handler)
UNUSED_ARG (blockLen)
return (BE_NOT_SUPPORTED);
}
int AH_RSAEncryptionEncryptInit (handler, key, chooser, surrenderContext)
AH_RSAEncryption *handler;
B_Key *key;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = AHChooseEncryptEncryptInit
(handler, key, chooser, surrenderContext)) != 0)
return (status);
return (AH_RSAEncryptionInitHelper (handler, 1));
}
int AH_RSAEncryptionDecryptInit (handler, key, chooser, surrenderContext)
AH_RSAEncryption *handler;
B_Key *key;
B_ALGORITHM_CHOOSER chooser;
A_SURRENDER_CTX *surrenderContext;
{
int status;
if ((status = AHChooseEncryptDecryptInit
(handler, key, chooser, surrenderContext)) != 0)
return (status);
return (AH_RSAEncryptionInitHelper (handler, 0));
}
/* Accumulate into the z.block.
*/
int AH_RSAEncryptionUpdate
(handler, partOut, partOutLen, maxPartOutLen, partIn, partInLen,
randomAlgorithm, surrenderContext)
AH_RSAEncryption *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
const unsigned char *partIn;
unsigned int partInLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
UNUSED_ARG (partOut)
UNUSED_ARG (maxPartOutLen)
UNUSED_ARG (randomAlgorithm)
UNUSED_ARG (surrenderContext)
*partOutLen = 0;
if (handler->_inputLen + partInLen > handler->_maxInputLen)
return (BE_INPUT_LEN);
T_memcpy
((POINTER)(handler->z.block + handler->_inputLen), (CPOINTER)partIn,
partInLen);
handler->_inputLen += partInLen;
return (0);
}
int AH_RSAEncryptionEncryptFinal
(handler, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
AH_RSAEncryption *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned int dummyPartOutLen;
/* Encode methodContext in place. */
if ((status = (*handler->vTable->EncodeBlock)
(handler, randomAlgorithm, surrenderContext)) != 0)
return (status);
/* This should not return BE_INPUT_DATA since it is well-formatted. */
if ((status = AHChooseEncryptEncryptUpdate
(handler, partOut, partOutLen, maxPartOutLen, handler->z.block,
handler->z.blockLen, (B_Algorithm *)NULL_PTR, surrenderContext)) != 0)
return (status);
/* Expect final to return zero bytes. */
if ((status = AHChooseEncryptEncryptFinal
(handler, (unsigned char *)NULL_PTR, &dummyPartOutLen, 0,
(B_Algorithm *)NULL_PTR, surrenderContext)) != 0)
return (status);
/* Restart the handle for new input. */
handler->_inputLen = 0;
return (0);
}
int AH_RSAEncryptionDecryptFinal
(handler, partOut, partOutLen, maxPartOutLen, randomAlgorithm,
surrenderContext)
AH_RSAEncryption *handler;
unsigned char *partOut;
unsigned int *partOutLen;
unsigned int maxPartOutLen;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
ITEM output;
int status;
unsigned int decryptedLen, dummyPartOutLen;
UNUSED_ARG (randomAlgorithm)
/* Decrypt block in place. The block lenghts are already within limits.
*/
if ((status = AHChooseEncryptDecryptUpdate
(handler, handler->z.block, &decryptedLen, handler->z.blockLen,
handler->z.block, handler->_inputLen, (B_Algorithm *)NULL_PTR,
surrenderContext)) != 0)
return (status);
/* Expect final to return zero bytes. */
if ((status = AHChooseEncryptDecryptFinal
(handler, (unsigned char *)NULL_PTR, &dummyPartOutLen, 0,
(B_Algorithm *)NULL_PTR, surrenderContext)) != 0)
return (status);
/* Restart the handle for new input. */
handler->_inputLen = 0;
/* Now decode the block and copy the result to the partOut.
*/
if ((status = (*handler->vTable->DecodeBlock)
(handler, &output, decryptedLen)) != 0)
return (status);
if (output.len > handler->z.blockLen - 11)
/* This implies that the block was encrypted with less than
8 bytes of padding */
return (BE_INPUT_DATA);
if ((*partOutLen = output.len) > maxPartOutLen)
return (BE_OUTPUT_LEN);
T_memcpy ((POINTER)partOut, (POINTER)output.data, output.len);
return (0);
}
static int AH_RSAEncryptionInitHelper (handler, encryptFlag)
AH_RSAEncryption *handler;
int encryptFlag;
{
int status;
unsigned int newBlockLen;
if ((status = AHChooseEncryptGetBlockLen (handler, &newBlockLen)) != 0)
return (status);
if (newBlockLen < 12)
/* PKCS Requires at least 12 bytes of modulus */
return (BE_NOT_SUPPORTED);
/* During encrypt, this will ensure that there are 8 bytes of padding.
During decrypt, the DecodeBlock procedure must check that the block
was encrypted with 8 bytes of padding.
*/
handler->_maxInputLen = encryptFlag ? (newBlockLen - 11) : newBlockLen;
handler->_inputLen = 0;
/* Zeroize old block and realloc to new size.
*/
T_memset ((POINTER)handler->z.block, 0, handler->z.blockLen);
if ((handler->z.block = (unsigned char *)T_realloc
((POINTER)handler->z.block, newBlockLen))
== (unsigned char *)NULL_PTR) {
handler->z.blockLen = 0;
return (BE_ALLOC);
}
handler->z.blockLen = newBlockLen;
return (0);
}

68
lib/bind/dnssafe/ahrsaenc.h
View file

@ -1,68 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHRSAENC_H_
#define _AHRSAENC_H_
#include "ahchencr.h"
struct AH_RSAEncryption;
/* For EncodeBlock, the block to encode is left justified in the
z.block with length given by z._inputLen. EncodeBlock encodes the block
in place to fill it out to z.blockLen.
For DecodeBlock, return the contents in the given ITEM by decoding
the z.block value which has length given by decryptedLen. This
procedure must also ensure that the block was encrypted with 8 bytes
of padding.
*/
typedef struct {
int (*EncodeBlock) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Algorithm * /* randomAlgorithm */,
A_SURRENDER_CTX *));
int (*DecodeBlock) PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, ITEM *, unsigned int /* decryptedLen */));
} AH_RSAEncryptionVTable;
typedef struct AH_RSAEncryption {
AHChooseEncryptDecrypt chooseEncryptDecrypt; /* base class */
struct {
unsigned char *block;
unsigned int blockLen;
} z; /* Zeroized by constructor */
unsigned int _inputLen; /* Length of data accumulated by Update */
unsigned int _maxInputLen; /* used during update to check for overflow */
AH_RSAEncryptionVTable *vTable; /* pure virtual */
} AH_RSAEncryption;
void AH_RSAEncryptionConstructor1 PROTO_LIST
((AH_RSAEncryption *, struct B_AlgorithmInfoType *));
void AH_RSAEncryptionDestructor PROTO_LIST ((AH_RSAEncryption *));
int AH_RSAEncryptionGetBlockLen PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned int *));
int AH_RSAEncryptionEncryptInit PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int AH_RSAEncryptionDecryptInit PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, B_Key *, B_ALGORITHM_CHOOSER,
A_SURRENDER_CTX *));
int AH_RSAEncryptionUpdate PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, const unsigned char *, unsigned int, B_Algorithm *,
A_SURRENDER_CTX *));
int AH_RSAEncryptionEncryptFinal PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
int AH_RSAEncryptionDecryptFinal PROTO_LIST
((THIS_ENCRYPT_DECRYPT *, unsigned char *, unsigned int *,
unsigned int, B_Algorithm *, A_SURRENDER_CTX *));
#endif

101
lib/bind/dnssafe/ahrsaepr.c
View file

@ -1,101 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AH_RSAEncryption;
#define THIS_ENCRYPT_DECRYPT struct AH_RSAEncryption
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahrsaepr.h"
#include "port_after.h"
static int EncodeBlock1 PROTO_LIST
((AH_RSAEncryptionPrivate *, B_Algorithm *, A_SURRENDER_CTX *));
static int DecodeBlock2 PROTO_LIST
((AH_RSAEncryptionPrivate *, ITEM *, unsigned int));
static AH_RSAEncryptionVTable ENCRYPTION_V_TABLE =
{EncodeBlock1, DecodeBlock2};
extern struct B_AlgorithmInfoType AIT_RSAPrivate;
AH_RSAEncryptionPrivate *AH_RSAEncrypPrivateConstructor (handler)
AH_RSAEncryptionPrivate *handler;
{
if (handler == (AH_RSAEncryptionPrivate *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AH_RSAEncryptionPrivate *)T_malloc (sizeof (*handler)))
== (AH_RSAEncryptionPrivate *)NULL_PTR)
return (handler);
}
/* Construct base class */
AH_RSAEncryptionConstructor1 (handler, &AIT_RSAPrivate);
handler->vTable = &ENCRYPTION_V_TABLE;
return (handler);
}
/* block1 starts out with the input bytes of length inputLen left-justified.
Returns 0, BE_INPUT_LEN.
*/
static int EncodeBlock1 (handler, randomAlgorithm, surrenderContext)
AH_RSAEncryptionPrivate *handler;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
unsigned int padLen;
UNUSED_ARG (randomAlgorithm)
UNUSED_ARG (surrenderContext)
if ((handler->_inputLen + 3) > handler->z.blockLen)
/* input is too large to make a block 1 */
return (BE_INPUT_LEN);
padLen = handler->z.blockLen - (handler->_inputLen + 3);
T_memmove
((POINTER)(handler->z.block + padLen + 3), (POINTER)handler->z.block,
handler->_inputLen);
handler->z.block[0] = 0;
handler->z.block[1] = 1;
T_memset ((POINTER)(handler->z.block + 2), 0xff, padLen);
handler->z.block[2 + padLen] = 0;
return (0);
}
static int DecodeBlock2 (handler, output, block2Len)
AH_RSAEncryptionPrivate *handler;
ITEM *output;
unsigned int block2Len;
{
unsigned int i;
if ((handler->z.block[0] != 0) || (handler->z.block[1] != 2))
return (BE_INPUT_DATA);
/* Should be able to find the data after the first zero byte following
the random bytes. */
for (i = 2; i < block2Len && handler->z.block[i] != 0; i++);
i++;
if (i > block2Len)
/* The data is not zero terminated. */
return (BE_INPUT_DATA);
output->len = block2Len - i;
output->data = handler->z.block + i;
return (0);
}

20
lib/bind/dnssafe/ahrsaepr.h
View file

@ -1,20 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHRSAEPR_H_
#define _AHRSAEPR_H_
#include "ahrsaenc.h"
/* structure is identical to base class, so just re-typedef. */
typedef AH_RSAEncryption AH_RSAEncryptionPrivate;
AH_RSAEncryptionPrivate *AH_RSAEncrypPrivateConstructor PROTO_LIST
((AH_RSAEncryptionPrivate *));
#endif

114
lib/bind/dnssafe/ahrsaepu.c
View file

@ -1,114 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
/* Define this so that the type of the 'this' pointer in the
virtual functions will be correct for this derived class.
*/
struct AH_RSAEncryption;
#define THIS_ENCRYPT_DECRYPT struct AH_RSAEncryption
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahrsaepu.h"
#include "port_after.h"
static int EncodeBlock2 PROTO_LIST
((AH_RSAEncryptionPublic *, B_Algorithm *, A_SURRENDER_CTX *));
static int DecodeBlock1 PROTO_LIST
((AH_RSAEncryptionPublic *, ITEM *, unsigned int));
static AH_RSAEncryptionVTable ENCRYPTION_V_TABLE =
{EncodeBlock2, DecodeBlock1};
extern struct B_AlgorithmInfoType AIT_RSAPublic;
AH_RSAEncryptionPublic *AH_RSAEncrypPublicConstructor (handler)
AH_RSAEncryptionPublic *handler;
{
if (handler == (AH_RSAEncryptionPublic *)NULL_PTR) {
/* This constructor is being used to do a new */
if ((handler = (AH_RSAEncryptionPublic *)T_malloc (sizeof (*handler)))
== (AH_RSAEncryptionPublic *)NULL_PTR)
return (handler);
}
/* Construct base class */
AH_RSAEncryptionConstructor1 (handler, &AIT_RSAPublic);
handler->vTable = &ENCRYPTION_V_TABLE;
return (handler);
}
/* block starts out with the input bytes of length inputLen left-justified.
*/
static int EncodeBlock2 (handler, randomAlgorithm, surrenderContext)
AH_RSAEncryptionPublic *handler;
B_Algorithm *randomAlgorithm;
A_SURRENDER_CTX *surrenderContext;
{
int status;
unsigned char randomByte;
unsigned int padLen, i;
if ((handler->_inputLen + 3) > handler->z.blockLen)
/* input is too large to make a block 2 */
return (BE_INPUT_LEN);
padLen = handler->z.blockLen - (handler->_inputLen + 3);
T_memmove
((POINTER)(handler->z.block + padLen + 3), (POINTER)handler->z.block,
handler->_inputLen);
handler->z.block[0] = 0;
handler->z.block[1] = 2;
/* Pad out with random bytes, making sure that none of the bytes is zero.
*/
for (i = 2; i < (padLen + 2); i++) {
do {
if ((status = B_AlgorithmGenerateRandomBytes
(randomAlgorithm, &randomByte, 1, surrenderContext)) != 0)
return (status);
} while (randomByte == 0);
handler->z.block[i] = randomByte;
}
handler->z.block[2 + padLen] = 0;
return (0);
}
static int DecodeBlock1 (handler, output, block1Len)
AH_RSAEncryptionPublic *handler;
ITEM *output;
unsigned int block1Len;
{
unsigned int i;
/* Locate the digestInfo within the PKCS block 1.
*/
if (handler->z.block[0] != 0 || handler->z.block[1] != 1)
return (BE_INPUT_DATA);
/* Should be able to find the data after the first zero byte following
the 0xff. */
for (i = 2; i < block1Len && handler->z.block[i] == 0xff; i++);
i++;
if (i > block1Len || handler->z.block[i - 1] != 0)
/* The data is not zero terminated, or a byte other than 0xff. */
return (BE_INPUT_DATA);
output->len = block1Len - i;
output->data = handler->z.block + i;
return (0);
}

20
lib/bind/dnssafe/ahrsaepu.h
View file

@ -1,20 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AHRSAEPU_H_
#define _AHRSAEPU_H_
#include "ahrsaenc.h"
/* structure is identical to base class, so just re-typedef. */
typedef AH_RSAEncryption AH_RSAEncryptionPublic;
AH_RSAEncryptionPublic *AH_RSAEncrypPublicConstructor PROTO_LIST
((AH_RSAEncryptionPublic *));
#endif

38
lib/bind/dnssafe/aichdig.c
View file

@ -1,38 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahchdig.h"
#include "aichdig.h"
#include "port_after.h"
B_TypeCheck *AITChooseDigestNullNewHandler PROTO_LIST
((B_AlgorithmInfoType *, B_Algorithm *));
B_AlgorithmInfoTypeVTable AITChooseDigestNull_V_TABLE =
{AITNullAddInfo, AITChooseDigestNullNewHandler,
B_AlgorithmInfoTypeMakeError};
/* This always uses NULL_PTR for the info.
*/
B_TypeCheck *AITChooseDigestNullNewHandler (infoType, algorithm)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
{
UNUSED_ARG (algorithm)
/* Pass in NULL_PTR so that constructor will allocate.
*/
return ((B_TypeCheck *)AHChooseDigestConstructor2
((AHChooseDigest *)NULL_PTR, infoType, NULL_PTR));
}

17
lib/bind/dnssafe/aichdig.h
View file

@ -1,17 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AICHDIG_H_
#define _AICHDIG_H_ 1
#include "ainfotyp.h"
#include "ainull.h"
extern B_AlgorithmInfoTypeVTable AITChooseDigestNull_V_TABLE;
#endif

35
lib/bind/dnssafe/aichenc8.c
View file

@ -1,35 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "aichenc8.h"
#include "port_after.h"
B_AlgorithmInfoTypeVTable AITChooseEncrypt8_V_TABLE =
{AIT_8AddInfo, AITChooseEncryptNewHandler, B_AlgorithmInfoTypeMakeError};
int AIT_8AddInfo (infoType, algorithm, info)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
POINTER info;
{
POINTER newInfo;
int status;
if ((status = B_MemoryPoolAllocAndCopy
(&algorithm->infoCache.memoryPool, &newInfo, info, 8)) != 0)
return (status);
return (B_InfoCacheAddInfo
(&algorithm->infoCache, (POINTER)infoType, newInfo));
}

19
lib/bind/dnssafe/aichenc8.h
View file

@ -1,19 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AICHENC8_H_
#define _AICHENC8_H_ 1
#include "aichencr.h"
extern B_AlgorithmInfoTypeVTable AITChooseEncrypt8_V_TABLE;
int AIT_8AddInfo PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, B_Algorithm *, POINTER));
#endif

19
lib/bind/dnssafe/aichencn.c
View file

@ -1,19 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "aichencn.h"
#include "port_after.h"
B_AlgorithmInfoTypeVTable AITChooseEncryptNull_V_TABLE =
{AITNullAddInfo, AITChooseEncryptNewHandler, B_AlgorithmInfoTypeMakeError};

17
lib/bind/dnssafe/aichencn.h
View file

@ -1,17 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AICHENCN_H_
#define _AICHENCN_H_ 1
#include "aichencr.h"
#include "ainull.h"
extern B_AlgorithmInfoTypeVTable AITChooseEncryptNull_V_TABLE;
#endif

33
lib/bind/dnssafe/aichencr.c
View file

@ -1,33 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahchencr.h"
#include "aichencr.h"
#include "port_after.h"
B_TypeCheck *AITChooseEncryptNewHandler (infoType, algorithm)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
{
POINTER info;
if (B_InfoCacheFindInfo (&algorithm->infoCache, &info, (POINTER)infoType)
!= 0)
/* This really shouldn't happen since the info was just added. */
return ((B_TypeCheck *)NULL_PTR);
/* Pass in NULL_PTR so that constructor will allocate. */
return ((B_TypeCheck *)AHChooseEncryptConstructor2
((AHChooseEncryptDecrypt *)NULL_PTR, infoType, info));
}

17
lib/bind/dnssafe/aichencr.h
View file

@ -1,17 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AICHENCR_H_
#define _AICHENCR_H_ 1
#include "ainfotyp.h"
struct B_TypeCheck *AITChooseEncryptNewHandler PROTO_LIST
((B_AlgorithmInfoType *, B_Algorithm *));
#endif

33
lib/bind/dnssafe/aichgen.c
View file

@ -1,33 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahchgen.h"
#include "aichgen.h"
#include "port_after.h"
B_TypeCheck *AITChooseGenerateNewHandler (infoType, algorithm)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
{
POINTER info;
if (B_InfoCacheFindInfo (&algorithm->infoCache, &info, (POINTER)infoType)
!= 0)
/* This really shouldn't happen since the info was just added. */
return ((B_TypeCheck *)NULL_PTR);
/* Pass in NULL_PTR so that constructor will allocate. */
return ((B_TypeCheck *)AHChooseGenerateConstructor2
((AHChooseGenerate *)NULL_PTR, infoType, info));
}

17
lib/bind/dnssafe/aichgen.h
View file

@ -1,17 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AICHGEN_H_
#define _AICHGEN_H_ 1
#include "ainfotyp.h"
struct B_TypeCheck *AITChooseGenerateNewHandler PROTO_LIST
((B_AlgorithmInfoType *, B_Algorithm *));
#endif

38
lib/bind/dnssafe/aichrand.c
View file

@ -1,38 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ahchrand.h"
#include "aichrand.h"
#include "port_after.h"
B_TypeCheck *AITChooseRandomNullNewHandler PROTO_LIST
((B_AlgorithmInfoType *, B_Algorithm *));
B_AlgorithmInfoTypeVTable AITChooseRandomNull_V_TABLE =
{AITNullAddInfo, AITChooseRandomNullNewHandler,
B_AlgorithmInfoTypeMakeError};
/* This always uses NULL_PTR for the info.
*/
B_TypeCheck *AITChooseRandomNullNewHandler (infoType, algorithm)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
{
UNUSED_ARG (algorithm)
/* Pass in NULL_PTR so that constructor will allocate.
*/
return ((B_TypeCheck *)AHChooseRandomConstructor2
((AHChooseRandom *)NULL_PTR, infoType, NULL_PTR));
}

17
lib/bind/dnssafe/aichrand.h
View file

@ -1,17 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AICHRAND_H_
#define _AICHRAND_H_ 1
#include "ainfotyp.h"
#include "ainull.h"
extern B_AlgorithmInfoTypeVTable AITChooseRandomNull_V_TABLE;
#endif

27
lib/bind/dnssafe/aimd5.c
View file

@ -1,27 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "aichdig.h"
#include "port_after.h"
B_AlgorithmInfoType AIT_MD5 = {&AITChooseDigestNull_V_TABLE};
int AI_MD5 (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_MD5;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}

27
lib/bind/dnssafe/aimd5ran.c
View file

@ -1,27 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "aichrand.h"
#include "port_after.h"
B_AlgorithmInfoType AIT_MD5Random = {&AITChooseRandomNull_V_TABLE};
int AI_MD5Random (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_MD5Random;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}

32
lib/bind/dnssafe/ainfotyp.c
View file

@ -1,32 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ainfotyp.h"
#include "port_after.h"
/* This is the default routine which algorithm info types point MakeInfo to
if not redefined by a derived class.
*/
int B_AlgorithmInfoTypeMakeError (infoType, info, algorithm)
B_AlgorithmInfoType *infoType;
POINTER *info;
B_Algorithm *algorithm;
{
UNUSED_ARG (infoType)
UNUSED_ARG (info)
UNUSED_ARG (algorithm)
/* Should already have been found in the cache. */
return (BE_WRONG_ALGORITHM_INFO);
}

39
lib/bind/dnssafe/ainfotyp.h
View file

@ -1,39 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _AINFOTYP_H_
#define _AINFOTYP_H_ 1
/* Use the THIS_ALGORITHM_INFO_TYPE macro to define the type of object in the
virtual function prototype. It defaults to the most base class, but
derived modules may define the macro to a more derived class before
including this header file.
*/
#ifndef THIS_ALGORITHM_INFO_TYPE
#define THIS_ALGORITHM_INFO_TYPE struct B_AlgorithmInfoType
#endif
struct B_AlgorithmInfoType;
typedef struct {
int (*AddInfo) PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, B_Algorithm *, POINTER));
struct B_TypeCheck * (*NewHandler) PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, B_Algorithm *));
int (*MakeInfo) PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, POINTER *, B_Algorithm *));
} B_AlgorithmInfoTypeVTable;
typedef struct B_AlgorithmInfoType {
B_AlgorithmInfoTypeVTable *vTable;
} B_AlgorithmInfoType;
int B_AlgorithmInfoTypeMakeError PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, POINTER *, B_Algorithm *));
#endif

28
lib/bind/dnssafe/ainull.c
View file

@ -1,28 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ainfotyp.h"
#include "ainull.h"
#include "port_after.h"
int AITNullAddInfo (infoType, algorithm, info)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
POINTER info;
{
UNUSED_ARG (info)
/* Cache null parameters. */
return (B_InfoCacheAddInfo
(&algorithm->infoCache, (POINTER)infoType, NULL_PTR));
}

10
lib/bind/dnssafe/ainull.h
View file

@ -1,10 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
int AITNullAddInfo PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, B_Algorithm *, POINTER));

47
lib/bind/dnssafe/airsaepr.c
View file

@ -1,47 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ainfotyp.h"
#include "ainull.h"
#include "ahrsaepr.h"
#include "port_after.h"
B_TypeCheck *AIT_PKCS_RSAPrivateNewHandler PROTO_LIST
((B_AlgorithmInfoType *, B_Algorithm *));
static B_AlgorithmInfoTypeVTable V_TABLE =
{AITNullAddInfo, AIT_PKCS_RSAPrivateNewHandler,
B_AlgorithmInfoTypeMakeError};
B_AlgorithmInfoType AIT_PKCS_RSAPrivate = {&V_TABLE};
int AI_PKCS_RSAPrivate (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_PKCS_RSAPrivate;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}
B_TypeCheck *AIT_PKCS_RSAPrivateNewHandler (infoType, algorithm)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
{
UNUSED_ARG (infoType)
UNUSED_ARG (algorithm)
/* Pass in NULL_PTR so that constructor will allocate. */
return ((B_TypeCheck *)AH_RSAEncrypPrivateConstructor
((AH_RSAEncryptionPrivate *)NULL_PTR));
}

47
lib/bind/dnssafe/airsaepu.c
View file

@ -1,47 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1993, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "ainfotyp.h"
#include "ainull.h"
#include "ahrsaepu.h"
#include "port_after.h"
B_TypeCheck *AIT_PKCS_RSAPublicNewHandler PROTO_LIST
((B_AlgorithmInfoType *, B_Algorithm *));
static B_AlgorithmInfoTypeVTable V_TABLE =
{AITNullAddInfo, AIT_PKCS_RSAPublicNewHandler,
B_AlgorithmInfoTypeMakeError};
B_AlgorithmInfoType AIT_PKCS_RSAPublic = {&V_TABLE};
int AI_PKCS_RSAPublic (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_PKCS_RSAPublic;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}
B_TypeCheck *AIT_PKCS_RSAPublicNewHandler (infoType, algorithm)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
{
UNUSED_ARG (infoType)
UNUSED_ARG (algorithm)
/* Pass in NULL_PTR so that constructor will allocate. */
return ((B_TypeCheck *)AH_RSAEncrypPublicConstructor
((AH_RSAEncryptionPublic *)NULL_PTR));
}

62
lib/bind/dnssafe/airsakgn.c
View file

@ -1,62 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "intitem.h"
#include "aichgen.h"
#include "port_after.h"
int AIT_RSAKeyGenAddInfo PROTO_LIST
((THIS_ALGORITHM_INFO_TYPE *, B_Algorithm *, POINTER));
static A_RSA_KEY_GEN_PARAMS STATIC_KEY_GEN_PARAMS;
static ITEM *KEY_GEN_PARAMS_ITEMS[] = {&STATIC_KEY_GEN_PARAMS.publicExponent};
static B_AlgorithmInfoTypeVTable V_TABLE =
{AIT_RSAKeyGenAddInfo, AITChooseGenerateNewHandler,
B_AlgorithmInfoTypeMakeError};
B_AlgorithmInfoType AIT_RSAKeyGen = {&V_TABLE};
int AI_RSAKeyGen (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_RSAKeyGen;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}
int AIT_RSAKeyGenAddInfo (infoType, algorithm, info)
B_AlgorithmInfoType *infoType;
B_Algorithm *algorithm;
POINTER info;
{
A_RSA_KEY_GEN_PARAMS *newInfo;
int status;
if ((status = B_MemoryPoolAlloc
(&algorithm->infoCache.memoryPool, (POINTER *)&newInfo,
sizeof (A_RSA_KEY_GEN_PARAMS))) != 0)
return (status);
if ((status = AllocAndCopyIntegerItems
((POINTER)newInfo, info, (POINTER)&STATIC_KEY_GEN_PARAMS,
KEY_GEN_PARAMS_ITEMS,
sizeof (KEY_GEN_PARAMS_ITEMS) / sizeof (KEY_GEN_PARAMS_ITEMS[0]),
&algorithm->infoCache.memoryPool)) != 0)
return (status);
newInfo->modulusBits = ((A_RSA_KEY_GEN_PARAMS *)info)->modulusBits;
return (B_InfoCacheAddInfo
(&algorithm->infoCache, (POINTER)infoType, (POINTER)newInfo));
}

27
lib/bind/dnssafe/airsaprv.c
View file

@ -1,27 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "aichencn.h"
#include "port_after.h"
B_AlgorithmInfoType AIT_RSAPrivate = {&AITChooseEncryptNull_V_TABLE};
int AI_RSAPrivate (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_RSAPrivate;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}

27
lib/bind/dnssafe/airsapub.c
View file

@ -1,27 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1990, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#include "port_before.h"
#include "global.h"
#include "bsafe2.h"
#include "bkey.h"
#include "balg.h"
#include "aichencn.h"
#include "port_after.h"
B_AlgorithmInfoType AIT_RSAPublic = {&AITChooseEncryptNull_V_TABLE};
int AI_RSAPublic (infoType)
POINTER *infoType;
{
*infoType = (POINTER)&AIT_RSAPublic;
/* Return 0 to indicate a B_AlgorithmInfoType, not a B_KeyInfoType */
return (0);
}

66
lib/bind/dnssafe/algae.h
View file

@ -1,66 +0,0 @@
/* Copyright (C) RSA Data Security, Inc. created 1992, 1996. This is an
unpublished work protected as such under copyright law. This work
contains proprietary, confidential, and trade secret information of
RSA Data Security, Inc. Use, disclosure or reproduction without the
express written authorization of RSA Data Security, Inc. is
prohibited.
*/
#ifndef _ALGAE_H_
#define _ALGAE_H_ 1
#ifndef T_CALL
#define T_CALL
#endif
/* Used to reduce the stack size in routines with big scratch buffers.
If set to 1, this will make ALGAE allocate these buffers on the heap.
*/
#ifndef USE_ALLOCED_FRAME
#define USE_ALLOCED_FRAME 1
#endif
#include "atypes.h"
#ifdef __cplusplus
extern "C" {
#endif
#define AE_CANCEL 0x0001
#define AE_DATA 0x0002
#define AE_EXPONENT_EVEN 0x0003
#define AE_EXPONENT_LEN 0x0004
#define AE_INPUT_DATA 0x0005
#define AE_INPUT_LEN 0x0006
#define AE_MODULUS_LEN 0x0007
#define AE_NEED_RANDOM 0x0008
#define AE_NOT_SUPPORTED 0x0009
#define AE_OUTPUT_LEN 0x000a
#define AE_NOT_INITIALIZED 0x000b
#define AE_KEY_LEN 0x000c
#define AE_KEY_INFO 0x000d
#define AE_SEQUENCE 0x000e
#define AE_PARAMS 0x000f
#if USE_ALLOCED_FRAME
/* Needed only for big number code heap allocation of scratch arrays.
*/
#define AE_ALLOC 0x0080
POINTER T_malloc PROTO_LIST ((unsigned int));
void T_free PROTO_LIST ((POINTER));
#endif
/* Routines supplied by the implementor.
*/
void T_memset PROTO_LIST ((POINTER, int, unsigned int));
void T_memcpy PROTO_LIST ((POINTER, CPOINTER, unsigned int));
void T_memmove PROTO_LIST ((POINTER, POINTER, unsigned int));
int T_memcmp PROTO_LIST ((CPOINTER, CPOINTER, unsigned int));
unsigned int A_IntegerBits PROTO_LIST ((const unsigned char *, unsigned int));
#ifdef __cplusplus
}
#endif
#endif

Some files were not shown because too many files have changed in this diff Show more