implement enough glue to support OpenSSLs EVP, RSA, DSA, DH, HMAC and ENGINE interfaces for use in hx509. rename all symbols to start with hc_ to avoid clobbering namespaces. contains no RSA/DH/DSA code, just glue to support using dynamic ENGINE. hx509 supports this via pkcs11 and there is a gmp ENGINE module supporting RSA
git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@16480 ec53bebd-3082-4978-b11e-865c3cabbd6b
This commit is contained in:
Love Hörnquist Åstrand
@@ -4,12 +4,41 @@ include $(top_srcdir)/Makefile.am.common
|
||||
|
||||
lib_LTLIBRARIES = libdes.la
|
||||
libdes_la_LDFLAGS = -version-info 3:1:0
|
||||
libdes_la_LIBADD = \
|
||||
$(top_builddir)/lib/asn1/libasn1.la \
|
||||
$(LIB_roken)
|
||||
|
||||
include_HEADERS = des.h md4.h md5.h sha.h rc2.h rc4.h aes.h
|
||||
include_HEADERS = \
|
||||
aes.h \
|
||||
bn.h \
|
||||
des.h \
|
||||
dh.h \
|
||||
dsa.h \
|
||||
evp.h \
|
||||
engine.h \
|
||||
hmac.h \
|
||||
md2.h \
|
||||
md4.h \
|
||||
md5.h \
|
||||
rand.h \
|
||||
rc2.h \
|
||||
rc4.h \
|
||||
rsa.h \
|
||||
sha.h \
|
||||
ui.h
|
||||
|
||||
build_HEADERZ = $(include_HEADERS)
|
||||
|
||||
check_PROGRAMS = destest mdtest rctest rc2test #md5crypt_test
|
||||
noinst_PROGRAMS = test_engine_dso
|
||||
|
||||
check_PROGRAMS = \
|
||||
destest \
|
||||
mdtest \
|
||||
rc2test \
|
||||
rctest \
|
||||
test_bn
|
||||
|
||||
# md5crypt_test
|
||||
|
||||
TESTS = $(check_PROGRAMS)
|
||||
|
||||
@@ -18,19 +47,38 @@ LDADD = $(lib_LTLIBRARIES) $(LIB_roken)
|
||||
libdes_la_SOURCES = \
|
||||
aes.c \
|
||||
aes.h \
|
||||
bn.c \
|
||||
bn.h \
|
||||
des.c \
|
||||
des.h \
|
||||
dh.c \
|
||||
dh.h \
|
||||
dsa.c \
|
||||
dsa.h \
|
||||
evp.c \
|
||||
evp.h \
|
||||
engine.h \
|
||||
engine.c \
|
||||
hmac.c \
|
||||
hmac.h \
|
||||
md2.c \
|
||||
md2.h \
|
||||
md4.c \
|
||||
md4.h \
|
||||
md5.c \
|
||||
md5.h \
|
||||
rand.h \
|
||||
rand.c \
|
||||
rc2.c \
|
||||
rc2.h \
|
||||
rc4.c \
|
||||
rc4.h \
|
||||
rsa.c \
|
||||
rsa.h \
|
||||
rijndael-alg-fst.c \
|
||||
rijndael-alg-fst.h \
|
||||
rnd_keys.c \
|
||||
sha.c \
|
||||
sha.h \
|
||||
ui.c
|
||||
ui.c \
|
||||
ui.h
|
||||
|
||||
@@ -36,6 +36,17 @@
|
||||
#ifndef HEIM_AES_H
|
||||
#define HEIM_AES_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define AES_set_encrypt_key hc_AES_set_encrypt_key
|
||||
#define AES_set_decrypt_key hc_AES_decrypt_key
|
||||
#define AES_encrypt hc_AES_encrypt
|
||||
#define AES_decrypt hc_AES_decrypt
|
||||
#define AES_cbc_encrypt hc_AES_cbc_encrypt
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define AES_BLOCK_SIZE 16
|
||||
#define AES_MAXNR 14
|
||||
|
||||
|
||||
382
lib/des/bn.c
Normal file
382
lib/des/bn.c
Normal file
@@ -0,0 +1,382 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
RCSID("$Id$");
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <krb5-types.h>
|
||||
#include <heim_asn1.h>
|
||||
#include <rfc2459_asn1.h> /* XXX */
|
||||
#include <der.h>
|
||||
|
||||
#include <bn.h>
|
||||
#include <rand.h>
|
||||
#include <hex.h>
|
||||
|
||||
BIGNUM *
|
||||
BN_new(void)
|
||||
{
|
||||
heim_integer *hi;
|
||||
hi = calloc(1, sizeof(*hi));
|
||||
return (BIGNUM *)hi;
|
||||
}
|
||||
|
||||
void
|
||||
BN_free(BIGNUM *bn)
|
||||
{
|
||||
BN_clear(bn);
|
||||
free(bn);
|
||||
}
|
||||
|
||||
void
|
||||
BN_clear(BIGNUM *bn)
|
||||
{
|
||||
heim_integer *hi = (heim_integer *)bn;
|
||||
if (hi->data) {
|
||||
memset(hi->data, 0, hi->length);
|
||||
free(hi->data);
|
||||
}
|
||||
memset(hi, 0, sizeof(*hi));
|
||||
}
|
||||
|
||||
void
|
||||
BN_clear_free(BIGNUM *bn)
|
||||
{
|
||||
BN_free(bn);
|
||||
}
|
||||
|
||||
BIGNUM *
|
||||
BN_dup(const BIGNUM *bn)
|
||||
{
|
||||
BIGNUM *b = BN_new();
|
||||
if (copy_heim_integer((const heim_integer *)bn, (heim_integer *)b)) {
|
||||
BN_free(b);
|
||||
return NULL;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the caller really want to know the number of bits used, subtract
|
||||
* one from the length, multiply by 8, and then lookup in the table
|
||||
* how many bits the hightest byte uses.
|
||||
*/
|
||||
int
|
||||
BN_num_bits(const BIGNUM *bn)
|
||||
{
|
||||
static unsigned char num2bits[256] = {
|
||||
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4, 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
|
||||
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
||||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
};
|
||||
const heim_integer *i = (const void *)bn;
|
||||
if (i->length == 0)
|
||||
return 0;
|
||||
return (i->length - 1) * 8 + num2bits[((unsigned char *)i->data)[0]];
|
||||
}
|
||||
|
||||
int
|
||||
BN_num_bytes(const BIGNUM *bn)
|
||||
{
|
||||
return ((const heim_integer *)bn)->length;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ignore negative flag.
|
||||
*/
|
||||
|
||||
BIGNUM *
|
||||
BN_bin2bn(const void *s, int len, BIGNUM *bn)
|
||||
{
|
||||
heim_integer *hi = (void *)bn;
|
||||
|
||||
if (len < 0)
|
||||
return NULL;
|
||||
|
||||
if (hi == NULL) {
|
||||
hi = (heim_integer *)BN_new();
|
||||
if (hi == NULL)
|
||||
return NULL;
|
||||
}
|
||||
if (hi->data)
|
||||
BN_clear((BIGNUM *)hi);
|
||||
hi->negative = 0;
|
||||
hi->data = malloc(len);
|
||||
if (hi->data == NULL && len != 0) {
|
||||
if (bn == NULL)
|
||||
BN_free((BIGNUM *)hi);
|
||||
return NULL;
|
||||
}
|
||||
hi->length = len;
|
||||
memcpy(hi->data, s, len);
|
||||
return (BIGNUM *)hi;
|
||||
}
|
||||
|
||||
int
|
||||
BN_bn2bin(const BIGNUM *bn, void *to)
|
||||
{
|
||||
const heim_integer *hi = (const void *)bn;
|
||||
memcpy(to, hi->data, hi->length);
|
||||
return hi->length;
|
||||
}
|
||||
|
||||
int
|
||||
BN_hex2bn(BIGNUM **bnp, const char *in)
|
||||
{
|
||||
int negative;
|
||||
ssize_t ret;
|
||||
size_t len;
|
||||
void *data;
|
||||
|
||||
len = strlen(in);
|
||||
data = malloc(len);
|
||||
if (data == NULL)
|
||||
return 0;
|
||||
|
||||
if (*in == '-') {
|
||||
negative = 1;
|
||||
in++;
|
||||
} else
|
||||
negative = 0;
|
||||
|
||||
ret = hex_decode(in, data, len);
|
||||
if (ret < 0) {
|
||||
free(data);
|
||||
return 0;
|
||||
}
|
||||
|
||||
*bnp = BN_bin2bn(data, ret, NULL);
|
||||
free(data);
|
||||
if (*bnp == NULL)
|
||||
return 0;
|
||||
BN_set_negative(*bnp, negative);
|
||||
return 1;
|
||||
}
|
||||
|
||||
char *
|
||||
BN_bn2hex(const BIGNUM *bn)
|
||||
{
|
||||
ssize_t ret;
|
||||
size_t len;
|
||||
void *data;
|
||||
char *str;
|
||||
|
||||
len = BN_num_bytes(bn);
|
||||
data = malloc(len);
|
||||
if (data == NULL)
|
||||
return 0;
|
||||
|
||||
len = BN_bn2bin(bn, data);
|
||||
|
||||
ret = hex_encode(data, len, &str);
|
||||
free(data);
|
||||
if (ret < 0)
|
||||
return 0;
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
int
|
||||
BN_cmp(const BIGNUM *bn1, const BIGNUM *bn2)
|
||||
{
|
||||
return heim_integer_cmp((const heim_integer *)bn1,
|
||||
(const heim_integer *)bn2);
|
||||
}
|
||||
|
||||
void
|
||||
BN_set_negative(BIGNUM *bn, int flag)
|
||||
{
|
||||
((heim_integer *)bn)->negative = (flag ? 1 : 0);
|
||||
}
|
||||
|
||||
int
|
||||
BN_get_negative(BIGNUM *bn)
|
||||
{
|
||||
return ((heim_integer *)bn)->negative ? 1 : 0;
|
||||
}
|
||||
|
||||
static const unsigned char is_set[8] = { 1, 2, 4, 8, 16, 32, 64, 128 };
|
||||
|
||||
int
|
||||
BN_is_bit_set(const BIGNUM *bn, int bit)
|
||||
{
|
||||
heim_integer *hi = (heim_integer *)bn;
|
||||
unsigned char *p = hi->data;
|
||||
|
||||
if ((bit / 8) > hi->length || hi->length == 0)
|
||||
return 0;
|
||||
|
||||
return p[hi->length - 1 - (bit / 8)] & is_set[bit % 8];
|
||||
}
|
||||
|
||||
int
|
||||
BN_set_bit(BIGNUM *bn, int bit)
|
||||
{
|
||||
heim_integer *hi = (heim_integer *)bn;
|
||||
unsigned char *p;
|
||||
|
||||
if ((bit / 8) > hi->length || hi->length == 0) {
|
||||
size_t len = (bit + 7) / 8;
|
||||
void *d = realloc(hi->data, len);
|
||||
if (d == NULL)
|
||||
return 0;
|
||||
hi->data = d;
|
||||
p = hi->data;
|
||||
memset(&p[hi->length], 0, len);
|
||||
hi->length = len;
|
||||
} else
|
||||
p = hi->data;
|
||||
|
||||
p[hi->length - 1 - (bit / 8)] |= is_set[bit % 8];
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
BN_clear_bit(BIGNUM *bn, int bit)
|
||||
{
|
||||
heim_integer *hi = (heim_integer *)bn;
|
||||
unsigned char *p = hi->data;
|
||||
|
||||
if ((bit / 8) > hi->length || hi->length == 0)
|
||||
return 0;
|
||||
|
||||
p[hi->length - 1 - (bit / 8)] &= (unsigned char)(~(is_set[bit % 8]));
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
BN_set_word(BIGNUM *bn, unsigned long num)
|
||||
{
|
||||
unsigned char p[sizeof(num)];
|
||||
unsigned long num2;
|
||||
int i, len;
|
||||
|
||||
for (num2 = num, i = 0; num2 > 0; i++)
|
||||
num2 = num2 >> 8;
|
||||
|
||||
len = i - 1;
|
||||
for (; i > 0; i--) {
|
||||
p[i - 1] = (num & 0xff);
|
||||
num = num >> 8;
|
||||
}
|
||||
|
||||
bn = BN_bin2bn(p, len + 1, bn);
|
||||
return bn != NULL;
|
||||
}
|
||||
|
||||
unsigned long
|
||||
BN_get_word(const BIGNUM *bn)
|
||||
{
|
||||
heim_integer *hi = (heim_integer *)bn;
|
||||
unsigned long num = 0;
|
||||
int i;
|
||||
|
||||
if (hi->negative || hi->length > sizeof(num))
|
||||
return ULONG_MAX;
|
||||
|
||||
for (i = 0; i < hi->length; i++)
|
||||
num = ((unsigned char *)hi->data)[i] | (num << 8);
|
||||
return num;
|
||||
}
|
||||
|
||||
int
|
||||
BN_rand(BIGNUM *bn, int bits, int top, int bottom)
|
||||
{
|
||||
size_t len = (bits + 7) / 8;
|
||||
heim_integer *i = (heim_integer *)bn;
|
||||
|
||||
BN_clear(bn);
|
||||
|
||||
i->negative = 0;
|
||||
i->data = malloc(len);
|
||||
if (i->data == NULL)
|
||||
return 0;
|
||||
i->length = len;
|
||||
|
||||
RAND_bytes(i->data, i->length);
|
||||
|
||||
if (top == -1) {
|
||||
;
|
||||
} else if (top == 0 && bits > 0) {
|
||||
BN_set_bit(bn, bits - 1);
|
||||
} else if (top == 1 && bits > 1) {
|
||||
BN_set_bit(bn, bits - 1);
|
||||
BN_set_bit(bn, bits - 2);
|
||||
} else
|
||||
return 0;
|
||||
|
||||
if (bottom && bits > 0)
|
||||
BN_set_bit(bn, 0);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Callback when doing slow generation of numbers, like primes.
|
||||
*/
|
||||
|
||||
void
|
||||
BN_GENCB_set(BN_GENCB *gencb, int (*cb_2)(int, int, BN_GENCB *), void *ctx)
|
||||
{
|
||||
gencb->ver = 2;
|
||||
gencb->cb.cb_2 = cb_2;
|
||||
gencb->arg = ctx;
|
||||
}
|
||||
|
||||
int
|
||||
BN_GENCB_call(BN_GENCB *cb, int a, int b)
|
||||
{
|
||||
if (cb == NULL || cb->cb.cb_2 == NULL)
|
||||
return 1;
|
||||
return cb->cb.cb_2(a, b, cb);
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#if 0
|
||||
#endif
|
||||
118
lib/des/bn.h
Normal file
118
lib/des/bn.h
Normal file
@@ -0,0 +1,118 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef _HEIM_BN_H
|
||||
#define _HEIM_BN_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define BN_GENCB_call hc_BN_GENCB_call
|
||||
#define BN_GENCB_set hc_BN_GENCB_set
|
||||
#define BN_bin2bn hc_BN_bin2bn
|
||||
#define BN_bn2bin hc_BN_bn2bin
|
||||
#define BN_bn2hex hc_BN_bn2hex
|
||||
#define BN_clear hc_BN_clear
|
||||
#define BN_clear_bit hc_BN_clear_bit
|
||||
#define BN_clear_free hc_BN_clear_free
|
||||
#define BN_cmp hc_BN_cmp
|
||||
#define BN_dup hc_BN_dup
|
||||
#define BN_free hc_BN_free
|
||||
#define BN_get_negative hc_BN_get_negative
|
||||
#define BN_get_word hc_BN_get_word
|
||||
#define BN_hex2bn hc_BN_hex2bn
|
||||
#define BN_is_bit_set hc_BN_is_bit_set
|
||||
#define BN_new hc_BN_new
|
||||
#define BN_num_bits hc_BN_num_bits
|
||||
#define BN_num_bytes hc_BN_num_bytes
|
||||
#define BN_rand hc_BN_rand
|
||||
#define BN_set_bit hc_BN_set_bit
|
||||
#define BN_set_negative hc_BN_set_negative
|
||||
#define BN_set_word hc_BN_set_word
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
typedef void BIGNUM;
|
||||
typedef struct BN_GENCB BN_GENCB;
|
||||
typedef void BN_CTX;
|
||||
typedef void BN_MONT_CTX;
|
||||
typedef void BN_BLINDING;
|
||||
|
||||
struct BN_GENCB {
|
||||
unsigned int ver;
|
||||
void *arg;
|
||||
union {
|
||||
int (*cb_2)(int, int, BN_GENCB *);
|
||||
} cb;
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
BIGNUM *BN_new(void);
|
||||
void BN_free(BIGNUM *);
|
||||
void BN_clear_free(BIGNUM *);
|
||||
void BN_clear(BIGNUM *);
|
||||
BIGNUM *BN_dup(const BIGNUM *);
|
||||
|
||||
int BN_num_bits(const BIGNUM *);
|
||||
int BN_num_bytes(const BIGNUM *);
|
||||
|
||||
int BN_cmp(const BIGNUM *, const BIGNUM *);
|
||||
|
||||
void BN_set_negative(BIGNUM *, int);
|
||||
int BN_get_negative(BIGNUM *);
|
||||
|
||||
int BN_is_bit_set(const BIGNUM *, int);
|
||||
int BN_set_bit(BIGNUM *, int);
|
||||
int BN_clear_bit(BIGNUM *, int);
|
||||
|
||||
int BN_set_word(BIGNUM *, unsigned long);
|
||||
unsigned long BN_get_word(const BIGNUM *);
|
||||
|
||||
BIGNUM *BN_bin2bn(const void *,int len,BIGNUM *);
|
||||
int BN_bn2bin(const BIGNUM *, void *);
|
||||
int BN_hex2bn(BIGNUM **, const char *);
|
||||
char * BN_bn2hex(const BIGNUM *);
|
||||
|
||||
int BN_rand(BIGNUM *, int, int, int);
|
||||
|
||||
void BN_GENCB_set(BN_GENCB *, int (*)(int, int, BN_GENCB *), void *);
|
||||
int BN_GENCB_call(BN_GENCB *, int, int);
|
||||
|
||||
#endif
|
||||
@@ -54,6 +54,7 @@ RCSID("$Id$");
|
||||
#include <krb5-types.h>
|
||||
|
||||
#include "des.h"
|
||||
#include "ui.h"
|
||||
|
||||
static void desx(uint32_t [2], DES_key_schedule *, int);
|
||||
static void IP(uint32_t [2]);
|
||||
|
||||
@@ -36,6 +36,36 @@
|
||||
#ifndef _DESperate_H
|
||||
#define _DESperate_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define DES_set_odd_parity hc_DES_set_odd_parity
|
||||
#define DES_is_weak_key hc_DES_is_weak_key
|
||||
#define DES_key_sched hc_DES_key_sched
|
||||
#define DES_set_key hc_DES_set_key
|
||||
#define DES_set_key_checked hc_DES_set_key_checked
|
||||
#define DES_set_key_sched hc_DES_set_key_sched
|
||||
#define DES_new_random_key hc_DES_new_random_key
|
||||
#define DES_string_to_key hc_DES_string_to_key
|
||||
#define DES_read_password hc_DES_read_password
|
||||
#define DES_rand_data hc_DES_rand_data
|
||||
#define DES_set_random_generator_seed hc_DES_set_random_generator_seed
|
||||
#define DES_generate_random_block hc_DES_generate_random_block
|
||||
#define DES_set_sequence_number hc_DES_set_sequence_number
|
||||
#define DES_init_random_number_generator hc_DES_init_random_number_generator
|
||||
#define DES_random_key hc_DES_random_key
|
||||
#define DES_encrypt hc_DES_encrypt
|
||||
#define DES_ecb_encrypt hc_DES_ecb_encrypt
|
||||
#define DES_ecb3_encrypt hc_DES_ecb3_encrypt
|
||||
#define DES_pcbc_encrypt hc_DES_pcbc_encrypt
|
||||
#define DES_cbc_encrypt hc_DES_cbc_encrypt
|
||||
#define DES_cbc_cksum hc_DES_cbc_cksum
|
||||
#define DES_ede3_cbc_encrypt hc_DES_ede3_cbc_encrypt
|
||||
#define DES_cfb64_encrypt hc_DES_cfb64_encrypt
|
||||
#define _DES_ipfp_test _hc_DES_ipfp_test
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define DES_CBLOCK_LEN 8
|
||||
#define DES_KEY_SZ 8
|
||||
|
||||
@@ -48,6 +78,10 @@ typedef struct DES_key_schedule
|
||||
uint32_t ks[32];
|
||||
} DES_key_schedule;
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
int DES_set_odd_parity(DES_cblock *);
|
||||
int DES_is_weak_key(DES_cblock *);
|
||||
int DES_set_key(DES_cblock *, DES_key_schedule *);
|
||||
@@ -57,8 +91,6 @@ int DES_new_random_key(DES_cblock *);
|
||||
void DES_string_to_key(const char *, DES_cblock *);
|
||||
int DES_read_password(DES_cblock *, char *, int);
|
||||
|
||||
int UI_UTIL_read_pw_string(char *, int, const char *, int); /* XXX */
|
||||
|
||||
void DES_rand_data(void *, int);
|
||||
void DES_set_random_generator_seed(DES_cblock *);
|
||||
void DES_generate_random_block(DES_cblock *);
|
||||
|
||||
213
lib/des/dh.c
Normal file
213
lib/des/dh.c
Normal file
@@ -0,0 +1,213 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
RCSID("$Id$");
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <dh.h>
|
||||
|
||||
#include <roken.h>
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
DH *
|
||||
DH_new(void)
|
||||
{
|
||||
DH *dh;
|
||||
|
||||
dh = calloc(1, sizeof(*dh));
|
||||
if (dh == NULL)
|
||||
return NULL;
|
||||
dh->meth = rk_UNCONST(DH_get_default_method());
|
||||
dh->references = 1;
|
||||
return dh;
|
||||
}
|
||||
|
||||
void
|
||||
DH_free(DH *dh)
|
||||
{
|
||||
if (dh->references <= 0)
|
||||
abort();
|
||||
|
||||
if (--dh->references > 0)
|
||||
return;
|
||||
|
||||
(*dh->meth->finish)(dh);
|
||||
|
||||
#define free_if(f) if (f) { BN_free(f); }
|
||||
free_if(dh->p);
|
||||
free_if(dh->g);
|
||||
free_if(dh->pub_key);
|
||||
free_if(dh->priv_key);
|
||||
free_if(dh->q);
|
||||
free_if(dh->j);
|
||||
free_if(dh->counter);
|
||||
#undef free_if
|
||||
|
||||
memset(dh, 0, sizeof(*dh));
|
||||
free(dh);
|
||||
}
|
||||
|
||||
int
|
||||
DH_up_ref(DH *dh)
|
||||
{
|
||||
return ++dh->references;
|
||||
}
|
||||
|
||||
int
|
||||
DH_size(const DH *dh)
|
||||
{
|
||||
return BN_num_bytes(dh->p);
|
||||
}
|
||||
|
||||
int
|
||||
DH_set_ex_data(DH *dh, int idx, void *data)
|
||||
{
|
||||
dh->ex_data.sk = data;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void *
|
||||
DH_get_ex_data(DH *dh, int idx)
|
||||
{
|
||||
return dh->ex_data.sk;
|
||||
}
|
||||
|
||||
int
|
||||
DH_generate_parameters_ex(DH *dh, int prime_len, int generator, BN_GENCB *cb)
|
||||
{
|
||||
if (dh->meth->generate_params)
|
||||
return dh->meth->generate_params(dh, prime_len, generator, cb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
DH_check(const DH *dh, int *num)
|
||||
{
|
||||
return 1; /* XXX */
|
||||
}
|
||||
|
||||
int
|
||||
DH_generate_key(DH *dh)
|
||||
{
|
||||
return dh->meth->generate_key(dh);
|
||||
}
|
||||
|
||||
int
|
||||
DH_compute_key(unsigned char *shared_key,
|
||||
const BIGNUM *peer_pub_key, DH *dh)
|
||||
{
|
||||
return dh->meth->compute_key(shared_key, peer_pub_key, dh);
|
||||
}
|
||||
|
||||
int
|
||||
DH_set_method(DH *dh, const DH_METHOD *method)
|
||||
{
|
||||
(*dh->meth->finish)(dh);
|
||||
dh->meth = method;
|
||||
(*dh->meth->init)(dh);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static int
|
||||
dh_null_generate_key(DH *dh)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
dh_null_compute_key(unsigned char *shared,const BIGNUM *pub, DH *dh)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
dh_null_init(DH *dh)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
dh_null_finish(DH *dh)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
dh_null_generate_params(DH *dh, int prime_num, int len, BN_GENCB *cb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const DH_METHOD dh_null_method = {
|
||||
"hx509 null DH",
|
||||
dh_null_generate_key,
|
||||
dh_null_compute_key,
|
||||
NULL,
|
||||
dh_null_init,
|
||||
dh_null_finish,
|
||||
0,
|
||||
NULL,
|
||||
dh_null_generate_params
|
||||
};
|
||||
|
||||
static const DH_METHOD *dh_default_method = &dh_null_method;
|
||||
|
||||
const DH_METHOD *DH_null_method(void)
|
||||
{
|
||||
return &dh_null_method;
|
||||
}
|
||||
|
||||
void
|
||||
DH_set_default_method(const DH_METHOD *meth)
|
||||
{
|
||||
dh_default_method = meth;
|
||||
}
|
||||
|
||||
const DH_METHOD *
|
||||
DH_get_default_method(void)
|
||||
{
|
||||
return dh_default_method;
|
||||
}
|
||||
|
||||
132
lib/des/dh.h
Normal file
132
lib/des/dh.h
Normal file
@@ -0,0 +1,132 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef _HEIM_DH_H
|
||||
#define _HEIM_DH_H 1
|
||||
|
||||
#include <bn.h>
|
||||
|
||||
/* symbol renaming */
|
||||
#define DH_null_method hc_DH_null_method
|
||||
#define DH_new hc_DH_new
|
||||
#define DH_free hc_DH_free
|
||||
#define DH_up_ref hc_DH_up_ref
|
||||
#define DH_size hc_DH_size
|
||||
#define DH_set_default_method hc_DH_set_default_method
|
||||
#define DH_get_default_method hc_DH_get_default_method
|
||||
#define DH_set_method hc_DH_set_method
|
||||
#define DH_get_method hc_DH_get_method
|
||||
#define DH_set_ex_data hc_DH_set_ex_data
|
||||
#define DH_get_ex_data hc_DH_get_ex_data
|
||||
#define DH_generate_parameters_ex hc_DH_generate_parameters_ex
|
||||
#define DH_check hc_DH_check
|
||||
#define DH_generate_key hc_DH_generate_key
|
||||
#define DH_compute_key hc_DH_compute_key
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
typedef struct DH DH;
|
||||
typedef struct DH_METHOD DH_METHOD;
|
||||
|
||||
struct DH_METHOD {
|
||||
const char *name;
|
||||
int (*generate_key)(DH *);
|
||||
int (*compute_key)(unsigned char *,const BIGNUM *,DH *);
|
||||
int (*bn_mod_exp)(const DH *, BIGNUM *, const BIGNUM *,
|
||||
const BIGNUM *, const BIGNUM *, BN_CTX *,
|
||||
BN_MONT_CTX *);
|
||||
int (*init)(DH *);
|
||||
int (*finish)(DH *);
|
||||
int flags;
|
||||
void *app_data;
|
||||
int (*generate_params)(DH *, int, int, BN_GENCB *);
|
||||
};
|
||||
|
||||
struct DH {
|
||||
int pad;
|
||||
int version;
|
||||
BIGNUM *p;
|
||||
BIGNUM *g;
|
||||
long length;
|
||||
BIGNUM *pub_key;
|
||||
BIGNUM *priv_key;
|
||||
int flags;
|
||||
void *method_mont_p;
|
||||
BIGNUM *q;
|
||||
BIGNUM *j;
|
||||
void *seed;
|
||||
int seedlen;
|
||||
BIGNUM *counter;
|
||||
int references;
|
||||
struct CRYPTO_EX_DATA {
|
||||
void *sk;
|
||||
int dummy;
|
||||
} ex_data;
|
||||
const DH_METHOD *meth;
|
||||
void *engine;
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
const DH_METHOD *DH_null_method(void);
|
||||
|
||||
DH * DH_new(void);
|
||||
void DH_free(DH *);
|
||||
int DH_up_ref(DH *);
|
||||
|
||||
int DH_size(const DH *);
|
||||
|
||||
|
||||
void DH_set_default_method(const DH_METHOD *);
|
||||
const DH_METHOD *
|
||||
DH_get_default_method(void);
|
||||
int DH_set_method(DH *, const DH_METHOD *);
|
||||
|
||||
int DH_set_ex_data(DH *, int, void *);
|
||||
void * DH_get_ex_data(DH *, int);
|
||||
|
||||
int DH_generate_parameters_ex(DH *, int, int, BN_GENCB *);
|
||||
int DH_check(const DH *,int *);
|
||||
int DH_generate_key(DH *);
|
||||
int DH_compute_key(unsigned char *,const BIGNUM *,DH *);
|
||||
|
||||
#endif /* _HEIM_DH_H */
|
||||
|
||||
125
lib/des/dsa.c
Normal file
125
lib/des/dsa.c
Normal file
@@ -0,0 +1,125 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
RCSID("$Id$");
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <dsa.h>
|
||||
|
||||
#include <roken.h>
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
DSA *
|
||||
DSA_new(void)
|
||||
{
|
||||
DSA *dsa = calloc(1, sizeof(*dsa));
|
||||
dsa->meth = rk_UNCONST(DSA_get_default_method());
|
||||
dsa->references = 1;
|
||||
return dsa;
|
||||
}
|
||||
|
||||
void
|
||||
DSA_free(DSA *dsa)
|
||||
{
|
||||
if (dsa->references <= 0)
|
||||
abort();
|
||||
|
||||
if (--dsa->references > 0)
|
||||
return;
|
||||
|
||||
(*dsa->meth->finish)(dsa);
|
||||
|
||||
#define free_if(f) if (f) { BN_free(f); }
|
||||
free_if(dsa->p);
|
||||
free_if(dsa->q);
|
||||
free_if(dsa->g);
|
||||
free_if(dsa->pub_key);
|
||||
free_if(dsa->priv_key);
|
||||
free_if(dsa->kinv);
|
||||
free_if(dsa->r);
|
||||
#undef free_if
|
||||
|
||||
memset(dsa, 0, sizeof(*dsa));
|
||||
free(dsa);
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
DSA_up_ref(DSA *dsa)
|
||||
{
|
||||
return ++dsa->references;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static const DSA_METHOD dsa_null_method = {
|
||||
"hx509 null DSA"
|
||||
};
|
||||
|
||||
const DSA_METHOD *
|
||||
DSA_null_method(void)
|
||||
{
|
||||
return &dsa_null_method;
|
||||
}
|
||||
|
||||
|
||||
const DSA_METHOD *dsa_default_mech = &dsa_null_method;
|
||||
|
||||
void
|
||||
DSA_set_default_method(const DSA_METHOD *mech)
|
||||
{
|
||||
dsa_default_mech = mech;
|
||||
}
|
||||
|
||||
const DSA_METHOD *
|
||||
DSA_get_default_method(void)
|
||||
{
|
||||
return dsa_default_mech;
|
||||
}
|
||||
|
||||
int
|
||||
DSA_verify(int type, const unsigned char * digest, int digest_len,
|
||||
const unsigned char *sig, int sig_len, DSA *dsa)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
140
lib/des/dsa.h
Normal file
140
lib/des/dsa.h
Normal file
@@ -0,0 +1,140 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef _HEIM_DSA_H
|
||||
#define _HEIM_DSA_H 1
|
||||
|
||||
#include <bn.h>
|
||||
|
||||
/* symbol renaming */
|
||||
#define DSA_null_method hc_DSA_null_method
|
||||
#define DSA_new hc_DSA_new
|
||||
#define DSA_free hc_DSA_free
|
||||
#define DSA_up_ref hc_DSA_up_ref
|
||||
#define DSA_set_default_method hc_DSA_set_default_method
|
||||
#define DSA_get_default_method hc_DSA_get_default_method
|
||||
#define DSA_set_method hc_DSA_set_method
|
||||
#define DSA_get_method hc_DSA_get_method
|
||||
#define DSA_set_app_data hc_DSA_set_app_data
|
||||
#define DSA_get_app_data hc_DSA_get_app_data
|
||||
#define DSA_size hc_DSA_size
|
||||
#define DSA_verify hc_DSA_verify
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
typedef struct DSA DSA;
|
||||
typedef struct DSA_METHOD DSA_METHOD;
|
||||
typedef struct DSA_SIG DSA_SIG;
|
||||
|
||||
struct DSA_SIG {
|
||||
BIGNUM *r;
|
||||
BIGNUM *s;
|
||||
};
|
||||
|
||||
struct DSA_METHOD {
|
||||
const char *name;
|
||||
DSA_SIG * (*dsa_do_sign)(const unsigned char *, int, DSA *);
|
||||
int (*dsa_sign_setup)(DSA *, BN_CTX *, BIGNUM **, BIGNUM **);
|
||||
int (*dsa_do_verify)(const unsigned char *, int, DSA_SIG *, DSA *);
|
||||
int (*dsa_mod_exp)(DSA *, BIGNUM *, BIGNUM *, BIGNUM *,
|
||||
BIGNUM *, BIGNUM *, BIGNUM *, BN_CTX *,
|
||||
BN_MONT_CTX *);
|
||||
int (*bn_mod_exp)(DSA *, BIGNUM *, BIGNUM *, const BIGNUM *,
|
||||
const BIGNUM *, BN_CTX *,
|
||||
BN_MONT_CTX *);
|
||||
int (*init)(DSA *);
|
||||
int (*finish)(DSA *);
|
||||
int flags;
|
||||
void *app_data;
|
||||
};
|
||||
|
||||
struct DSA {
|
||||
int pad;
|
||||
long version;
|
||||
int write_params;
|
||||
BIGNUM *p;
|
||||
BIGNUM *q;
|
||||
BIGNUM *g;
|
||||
|
||||
BIGNUM *pub_key;
|
||||
BIGNUM *priv_key;
|
||||
|
||||
BIGNUM *kinv;
|
||||
BIGNUM *r;
|
||||
int flags;
|
||||
void *method_mont_p;
|
||||
int references;
|
||||
struct dsa_CRYPTO_EX_DATA {
|
||||
void *sk;
|
||||
int dummy;
|
||||
} ex_data;
|
||||
const DSA_METHOD *meth;
|
||||
void *engine;
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
const DSA_METHOD *DSA_null_method(void);
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
DSA * DSA_new(void);
|
||||
void DSA_free(DSA *);
|
||||
int DSA_up_ref(DSA *);
|
||||
|
||||
void DSA_set_default_method(const DSA_METHOD *);
|
||||
const DSA_METHOD * DSA_get_default_method(void);
|
||||
|
||||
const DSA_METHOD * DSA_get_method(const DSA *);
|
||||
int DSA_set_method(DSA *, const DSA_METHOD *);
|
||||
|
||||
void DSA_set_app_data(DSA *, void *arg);
|
||||
void * DSA_get_app_data(DSA *);
|
||||
|
||||
int DSA_size(const DSA *);
|
||||
|
||||
int DSA_verify(int, const unsigned char *, int,
|
||||
const unsigned char *, int, DSA *);
|
||||
|
||||
#endif /* _HEIM_DSA_H */
|
||||
311
lib/des/engine.c
Normal file
311
lib/des/engine.c
Normal file
@@ -0,0 +1,311 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
RCSID("$Id$");
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <engine.h>
|
||||
|
||||
#ifdef HAVE_DLFCN_H
|
||||
#include <dlfcn.h>
|
||||
#ifndef RTLD_NOW
|
||||
#define RTLD_NOW 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
struct hc_engine {
|
||||
int references;
|
||||
char *name;
|
||||
char *id;
|
||||
void (*destroy)(ENGINE *);
|
||||
const RSA_METHOD *rsa;
|
||||
const DH_METHOD *dh;
|
||||
};
|
||||
|
||||
int
|
||||
ENGINE_finish(ENGINE *engine)
|
||||
{
|
||||
if (engine->references-- <= 0)
|
||||
abort();
|
||||
if (engine->references > 0)
|
||||
return 1;
|
||||
|
||||
if (engine->name)
|
||||
free(engine->name);
|
||||
if (engine->id)
|
||||
free(engine->id);
|
||||
if(engine->destroy)
|
||||
(*engine->destroy)(engine);
|
||||
|
||||
memset(engine, 0, sizeof(engine));
|
||||
engine->references = -1;
|
||||
|
||||
|
||||
free(engine);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
ENGINE_up_ref(ENGINE *engine)
|
||||
{
|
||||
if (engine->references < 0)
|
||||
abort();
|
||||
engine->references++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
ENGINE_set_id(ENGINE *engine, const char *id)
|
||||
{
|
||||
engine->id = strdup(id);
|
||||
return (engine->id == NULL) ? 0 : 1;
|
||||
}
|
||||
|
||||
int
|
||||
ENGINE_set_name(ENGINE *engine, const char *name)
|
||||
{
|
||||
engine->name = strdup(name);
|
||||
return (engine->name == NULL) ? 0 : 1;
|
||||
}
|
||||
|
||||
int
|
||||
ENGINE_set_RSA(ENGINE *engine, const RSA_METHOD *method)
|
||||
{
|
||||
engine->rsa = method;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
ENGINE_set_DH(ENGINE *engine, const DH_METHOD *method)
|
||||
{
|
||||
engine->dh = method;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
ENGINE_set_destroy_function(ENGINE *e, void (*destroy)(ENGINE *))
|
||||
{
|
||||
e->destroy = destroy;
|
||||
return 1;
|
||||
}
|
||||
|
||||
const char *
|
||||
ENGINE_get_id(const ENGINE *engine)
|
||||
{
|
||||
return engine->id;
|
||||
}
|
||||
|
||||
const char *
|
||||
ENGINE_get_name(const ENGINE *engine)
|
||||
{
|
||||
return engine->name;
|
||||
}
|
||||
|
||||
const RSA_METHOD *
|
||||
ENGINE_get_RSA(const ENGINE *engine)
|
||||
{
|
||||
return engine->rsa;
|
||||
}
|
||||
|
||||
const DH_METHOD *
|
||||
ENGINE_get_DH(const ENGINE *engine)
|
||||
{
|
||||
return engine->dh;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static ENGINE *RSA_engine;
|
||||
|
||||
int
|
||||
ENGINE_set_default_RSA(ENGINE *engine)
|
||||
{
|
||||
if (RSA_engine)
|
||||
ENGINE_finish(RSA_engine);
|
||||
RSA_engine = engine;
|
||||
if (RSA_engine)
|
||||
ENGINE_up_ref(RSA_engine);
|
||||
return 1;
|
||||
}
|
||||
|
||||
ENGINE *
|
||||
ENGINE_get_default_RSA(void)
|
||||
{
|
||||
if (RSA_engine)
|
||||
ENGINE_up_ref(RSA_engine);
|
||||
return RSA_engine;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static ENGINE **engines;
|
||||
static unsigned int num_engines;
|
||||
|
||||
static int
|
||||
add_engine(ENGINE *engine)
|
||||
{
|
||||
ENGINE **d, *dup;
|
||||
|
||||
dup = ENGINE_by_id(engine->id);
|
||||
if (dup) {
|
||||
ENGINE_finish(dup);
|
||||
return 0;
|
||||
}
|
||||
|
||||
d = realloc(engines, (num_engines + 1) * sizeof(*engines));
|
||||
if (d == NULL)
|
||||
return 1;
|
||||
d[num_engines++] = engine;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
ENGINE_load_builtin_engines(void)
|
||||
{
|
||||
}
|
||||
|
||||
ENGINE *
|
||||
ENGINE_by_dso(const char *path, const char *id)
|
||||
{
|
||||
#ifdef HAVE_DLOPEN
|
||||
ENGINE *engine;
|
||||
void *handle;
|
||||
int ret;
|
||||
|
||||
engine = calloc(1, sizeof(*engine));
|
||||
if (engine == NULL)
|
||||
return NULL;
|
||||
|
||||
handle = dlopen(path, RTLD_NOW);
|
||||
if (handle == NULL) {
|
||||
printf("error: %s\n", dlerror());
|
||||
free(engine);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
{
|
||||
unsigned long version;
|
||||
openssl_v_check v_check;
|
||||
|
||||
v_check = dlsym(handle, "v_check");
|
||||
if (v_check == NULL) {
|
||||
dlclose(handle);
|
||||
free(engine);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
version = (*v_check)(OPENSSL_DYNAMIC_VERSION);
|
||||
if (version == 0) {
|
||||
dlclose(handle);
|
||||
free(engine);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
openssl_bind_engine bind_engine;
|
||||
|
||||
bind_engine = dlsym(handle, "bind_engine");
|
||||
if (bind_engine == NULL) {
|
||||
dlclose(handle);
|
||||
free(engine);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret = (*bind_engine)(engine, id, NULL); /* XXX fix third arg */
|
||||
if (ret != 1) {
|
||||
dlclose(handle);
|
||||
free(engine);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
ENGINE_up_ref(engine);
|
||||
|
||||
ret = add_engine(engine);
|
||||
if (ret != 1) {
|
||||
dlclose(handle);
|
||||
ENGINE_finish(engine);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return engine;
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
ENGINE *
|
||||
ENGINE_by_id(const char *id)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < num_engines; i++) {
|
||||
if (strcmp(id, engines[i]->id) == 0) {
|
||||
ENGINE_up_ref(engines[i]);
|
||||
return engines[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
ENGINE_add_conf_module(void)
|
||||
{
|
||||
ENGINE *engine;
|
||||
|
||||
/*
|
||||
* XXX Parse configuration file instead
|
||||
*/
|
||||
|
||||
engine = ENGINE_by_dso("/usr/heimdal/lib/hc-modules/hc-gmp.so", NULL);
|
||||
if (engine) {
|
||||
const RSA_METHOD *rsamethod = ENGINE_get_RSA(engine);
|
||||
if (rsamethod)
|
||||
RSA_set_default_method(rsamethod);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
92
lib/des/engine.h
Normal file
92
lib/des/engine.h
Normal file
@@ -0,0 +1,92 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef _HEIM_ENGINE_H
|
||||
#define _HEIM_ENGINE_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define ENGINE_add_conf_module hc_ENGINE_add_conf_module
|
||||
#define ENGINE_by_dso hc_ENGINE_by_dso
|
||||
#define ENGINE_by_id hc_ENGINE_by_id
|
||||
#define ENGINE_finish hc_ENGINE_finish
|
||||
#define ENGINE_get_DH hc_ENGINE_get_DH
|
||||
#define ENGINE_get_RSA hc_ENGINE_get_RSA
|
||||
#define ENGINE_get_id hc_ENGINE_get_id
|
||||
#define ENGINE_get_name hc_ENGINE_get_name
|
||||
#define ENGINE_load_builtin_engines hc_ENGINE_load_builtin_engines
|
||||
#define ENGINE_set_DH hc_ENGINE_set_DH
|
||||
#define ENGINE_set_RSA hc_ENGINE_set_RSA
|
||||
#define ENGINE_set_id hc_ENGINE_set_id
|
||||
#define ENGINE_set_name hc_ENGINE_set_name
|
||||
#define ENGINE_set_destroy_function hc_ENGINE_set_destroy_function
|
||||
#define ENGINE_up_ref hc_ENGINE_up_ref
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
typedef struct hc_engine ENGINE;
|
||||
|
||||
#include <rsa.h>
|
||||
#include <dh.h>
|
||||
|
||||
#define OPENSSL_DYNAMIC_VERSION (unsigned long)0x00020000
|
||||
|
||||
typedef int (*openssl_bind_engine)(ENGINE *, const char *, const void *);
|
||||
typedef unsigned long (*openssl_v_check)(unsigned long);
|
||||
|
||||
void ENGINE_add_conf_module(void);
|
||||
void ENGINE_load_builtin_engines(void);
|
||||
ENGINE *ENGINE_by_id(const char *);
|
||||
ENGINE *ENGINE_by_dso(const char *, const char *);
|
||||
int ENGINE_finish(ENGINE *);
|
||||
int ENGINE_up_ref(ENGINE *);
|
||||
int ENGINE_set_id(ENGINE *, const char *);
|
||||
int ENGINE_set_name(ENGINE *, const char *);
|
||||
int ENGINE_set_RSA(ENGINE *, const RSA_METHOD *);
|
||||
int ENGINE_set_DH(ENGINE *, const DH_METHOD *);
|
||||
int ENGINE_set_destroy_function(ENGINE *, void (*)(ENGINE *));
|
||||
|
||||
const char * ENGINE_get_id(const ENGINE *);
|
||||
const char * ENGINE_get_name(const ENGINE *);
|
||||
const RSA_METHOD * ENGINE_get_RSA(const ENGINE *);
|
||||
const DH_METHOD * ENGINE_get_DH(const ENGINE *);
|
||||
|
||||
int ENGINE_set_default_RSA(ENGINE *);
|
||||
ENGINE * ENGINE_get_default_RSA(void);
|
||||
|
||||
#endif /* _HEIM_ENGINE_H */
|
||||
728
lib/des/evp.c
Normal file
728
lib/des/evp.c
Normal file
@@ -0,0 +1,728 @@
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include <evp.h>
|
||||
|
||||
#include <krb5-types.h>
|
||||
|
||||
#include <aes.h>
|
||||
#include <des.h>
|
||||
#include <sha.h>
|
||||
#include <rc2.h>
|
||||
#include <rc4.h>
|
||||
#include <md2.h>
|
||||
#include <md4.h>
|
||||
#include <md5.h>
|
||||
|
||||
struct hc_evp_md {
|
||||
int hash_size;
|
||||
int block_size;
|
||||
int ctx_size;
|
||||
int (*init)(EVP_MD_CTX *);
|
||||
int (*update)(EVP_MD_CTX *,const void *, size_t );
|
||||
int (*final)(void *, EVP_MD_CTX *);
|
||||
int (*cleanup)(EVP_MD_CTX *);
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
size_t
|
||||
EVP_MD_size(const EVP_MD *md)
|
||||
{
|
||||
return md->hash_size;
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_MD_block_size(const EVP_MD *md)
|
||||
{
|
||||
return md->block_size;
|
||||
}
|
||||
|
||||
EVP_MD_CTX *
|
||||
EVP_MD_CTX_create(void)
|
||||
{
|
||||
return calloc(1, sizeof(EVP_MD_CTX));
|
||||
}
|
||||
|
||||
void
|
||||
EVP_MD_CTX_init(EVP_MD_CTX *ctx)
|
||||
{
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
}
|
||||
|
||||
void
|
||||
EVP_MD_CTX_destroy(EVP_MD_CTX *ctx)
|
||||
{
|
||||
EVP_MD_CTX_cleanup(ctx);
|
||||
free(ctx);
|
||||
}
|
||||
|
||||
int
|
||||
EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx)
|
||||
{
|
||||
if (ctx->md && ctx->md->cleanup)
|
||||
(ctx->md->cleanup)(ctx);
|
||||
ctx->md = NULL;
|
||||
ctx->engine = NULL;
|
||||
free(ctx->ptr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
const EVP_MD *
|
||||
EVP_MD_CTX_md(EVP_MD_CTX *ctx)
|
||||
{
|
||||
return ctx->md;
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_MD_CTX_size(EVP_MD_CTX *ctx)
|
||||
{
|
||||
return EVP_MD_size(ctx->md);
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_MD_CTX_block_size(EVP_MD_CTX *ctx)
|
||||
{
|
||||
return EVP_MD_block_size(ctx->md);
|
||||
}
|
||||
|
||||
int
|
||||
EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *engine)
|
||||
{
|
||||
if (ctx->md != md || ctx->engine != engine) {
|
||||
EVP_MD_CTX_cleanup(ctx);
|
||||
ctx->md = md;
|
||||
ctx->engine = engine;
|
||||
|
||||
ctx->ptr = calloc(1, md->ctx_size);
|
||||
if (ctx->ptr == NULL)
|
||||
return 0;
|
||||
}
|
||||
(ctx->md->init)(ctx->ptr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t size)
|
||||
{
|
||||
(ctx->md->update)(ctx->ptr, data, size);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_DigestFinal_ex(EVP_MD_CTX *ctx, void *hash, unsigned int *size)
|
||||
{
|
||||
(ctx->md->final)(hash, ctx->ptr);
|
||||
if (size)
|
||||
*size = ctx->md->hash_size;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_Digest(const void *data, size_t dsize, void *hash, unsigned int *hsize,
|
||||
const EVP_MD *md, ENGINE *engine)
|
||||
{
|
||||
EVP_MD_CTX *ctx;
|
||||
int ret;
|
||||
|
||||
ctx = EVP_MD_CTX_create();
|
||||
if (ctx == NULL)
|
||||
return 0;
|
||||
ret = EVP_DigestInit_ex(ctx, md, engine);
|
||||
if (ret != 1)
|
||||
return ret;
|
||||
ret = EVP_DigestUpdate(ctx, data, dsize);
|
||||
if (ret != 1)
|
||||
return ret;
|
||||
ret = EVP_DigestFinal_ex(ctx, hash, hsize);
|
||||
if (ret != 1)
|
||||
return ret;
|
||||
EVP_MD_CTX_destroy(ctx);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static const struct hc_evp_md sha1 = {
|
||||
20,
|
||||
1,
|
||||
sizeof(SHA_CTX),
|
||||
(void *)SHA1_Init,
|
||||
(void *)SHA1_Update,
|
||||
(void *)SHA1_Final,
|
||||
NULL
|
||||
};
|
||||
|
||||
const EVP_MD *
|
||||
EVP_sha1(void)
|
||||
{
|
||||
return &sha1;
|
||||
}
|
||||
|
||||
const EVP_MD *
|
||||
EVP_sha(void)
|
||||
{
|
||||
return &sha1;
|
||||
}
|
||||
|
||||
const EVP_MD *
|
||||
EVP_md5(void)
|
||||
{
|
||||
static const struct hc_evp_md md5 = {
|
||||
16,
|
||||
1,
|
||||
sizeof(MD5_CTX),
|
||||
(void *)MD5_Init,
|
||||
(void *)MD5_Update,
|
||||
(void *)MD5_Final,
|
||||
NULL
|
||||
};
|
||||
return &md5;
|
||||
}
|
||||
|
||||
const EVP_MD *
|
||||
EVP_md4(void)
|
||||
{
|
||||
static const struct hc_evp_md md4 = {
|
||||
16,
|
||||
1,
|
||||
sizeof(MD4_CTX),
|
||||
(void *)MD4_Init,
|
||||
(void *)MD4_Update,
|
||||
(void *)MD4_Final,
|
||||
NULL
|
||||
};
|
||||
return &md4;
|
||||
}
|
||||
|
||||
const EVP_MD *
|
||||
EVP_md2(void)
|
||||
{
|
||||
static const struct hc_evp_md md2 = {
|
||||
16,
|
||||
1,
|
||||
sizeof(MD2_CTX),
|
||||
(void *)MD2_Init,
|
||||
(void *)MD2_Update,
|
||||
(void *)MD2_Final,
|
||||
NULL
|
||||
};
|
||||
return &md2;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static void
|
||||
null_Init (void *m)
|
||||
{
|
||||
}
|
||||
static void
|
||||
null_Update (void *m, const void * data, size_t size)
|
||||
{
|
||||
}
|
||||
static void
|
||||
null_Final(void *res, struct md5 *m)
|
||||
{
|
||||
}
|
||||
|
||||
const EVP_MD *
|
||||
EVP_md_null(void)
|
||||
{
|
||||
static const struct hc_evp_md null = {
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
(void *)null_Init,
|
||||
(void *)null_Update,
|
||||
(void *)null_Final,
|
||||
NULL
|
||||
};
|
||||
return &null;
|
||||
}
|
||||
|
||||
#if 0
|
||||
void EVP_MD_CTX_init(EVP_MD_CTX *ctx);
|
||||
int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
|
||||
int EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s);
|
||||
int EVP_SignFinal(EVP_MD_CTX *, void *, size_t *, EVP_PKEY *);
|
||||
int EVP_VerifyFinal(EVP_MD_CTX *, const void *, size_t, EVP_PKEY *);
|
||||
#endif
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
size_t
|
||||
EVP_CIPHER_block_size(const EVP_CIPHER *c)
|
||||
{
|
||||
return c->block_size;
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_CIPHER_key_length(const EVP_CIPHER *c)
|
||||
{
|
||||
return c->key_len;
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_CIPHER_iv_length(const EVP_CIPHER *c)
|
||||
{
|
||||
return c->iv_len;
|
||||
}
|
||||
|
||||
void
|
||||
EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *c)
|
||||
{
|
||||
memset(c, 0, sizeof(*c));
|
||||
}
|
||||
|
||||
int
|
||||
EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
|
||||
{
|
||||
if (c->cipher && c->cipher->cleanup)
|
||||
c->cipher->cleanup(c);
|
||||
if (c->cipher_data)
|
||||
free(c->cipher_data);
|
||||
memset(c, 0, sizeof(*c));
|
||||
return 1;
|
||||
}
|
||||
|
||||
#if 0
|
||||
int
|
||||
EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int length)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return ctx->cipher;
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return EVP_CIPHER_block_size(ctx->cipher);
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return EVP_CIPHER_key_length(ctx->cipher);
|
||||
}
|
||||
|
||||
size_t
|
||||
EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return EVP_CIPHER_iv_length(ctx->cipher);
|
||||
}
|
||||
|
||||
unsigned long
|
||||
EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return ctx->cipher->flags;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_MODE;
|
||||
}
|
||||
|
||||
void *
|
||||
EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return ctx->app_data;
|
||||
}
|
||||
|
||||
void
|
||||
EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
|
||||
{
|
||||
ctx->app_data = data;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *c, ENGINE *engine,
|
||||
const void *key, const void *iv, int encp)
|
||||
{
|
||||
if (encp == -1)
|
||||
encp = ctx->encrypt;
|
||||
else
|
||||
ctx->encrypt = (encp ? 1 : 0);
|
||||
|
||||
if (c && (c != ctx->cipher)) {
|
||||
EVP_CIPHER_CTX_cleanup(ctx);
|
||||
ctx->cipher = c;
|
||||
ctx->key_len = c->key_len;
|
||||
|
||||
ctx->cipher_data = malloc(c->ctx_size);
|
||||
if (ctx->cipher_data == NULL && c->ctx_size != 0)
|
||||
return 0;
|
||||
|
||||
} else if (ctx->cipher == NULL) {
|
||||
/* reuse of cipher, but not any cipher ever set! */
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (EVP_CIPHER_CTX_flags(ctx)) {
|
||||
case EVP_CIPH_CBC_MODE:
|
||||
|
||||
assert(EVP_CIPHER_CTX_iv_length(ctx) <= sizeof(ctx->iv));
|
||||
|
||||
if (iv)
|
||||
memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
|
||||
memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT))
|
||||
ctx->cipher->init(ctx, key, iv, encp);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
EVP_Cipher(EVP_CIPHER_CTX *ctx, void *out, const void *in,size_t size)
|
||||
{
|
||||
return ctx->cipher->do_cipher(ctx, out, in, size);
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static int
|
||||
enc_null_init(EVP_CIPHER_CTX *ctx,
|
||||
const unsigned char * key,
|
||||
const unsigned char * iv,
|
||||
int encp)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
enc_null_do_cipher(EVP_CIPHER_CTX *ctx,
|
||||
unsigned char *out,
|
||||
const unsigned char *in,
|
||||
unsigned int size)
|
||||
{
|
||||
memmove(out, in, size);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
enc_null_cleanup(EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_enc_null(void)
|
||||
{
|
||||
static const EVP_CIPHER enc_null = {
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
enc_null_init,
|
||||
enc_null_do_cipher,
|
||||
enc_null_cleanup,
|
||||
0,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &enc_null;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
struct rc2_cbc {
|
||||
unsigned int maximum_effective_key;
|
||||
RC2_KEY key;
|
||||
};
|
||||
|
||||
static int
|
||||
rc2_init(EVP_CIPHER_CTX *ctx,
|
||||
const unsigned char * key,
|
||||
const unsigned char * iv,
|
||||
int encp)
|
||||
{
|
||||
struct rc2_cbc *k = ctx->cipher_data;
|
||||
k->maximum_effective_key = EVP_CIPHER_CTX_key_length(ctx) * 8;
|
||||
RC2_set_key(&k->key,
|
||||
EVP_CIPHER_CTX_key_length(ctx),
|
||||
key,
|
||||
k->maximum_effective_key);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
rc2_do_cipher(EVP_CIPHER_CTX *ctx,
|
||||
unsigned char *out,
|
||||
const unsigned char *in,
|
||||
unsigned int size)
|
||||
{
|
||||
struct rc2_cbc *k = ctx->cipher_data;
|
||||
RC2_cbc_encrypt(in, out, size, &k->key, ctx->iv, ctx->encrypt);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
rc2_cleanup(EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
memset(ctx->cipher_data, 0, sizeof(struct rc2_cbc));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_rc2_cbc(void)
|
||||
{
|
||||
static const EVP_CIPHER rc2_cbc = {
|
||||
0,
|
||||
RC2_BLOCK_SIZE,
|
||||
RC2_KEY_LENGTH,
|
||||
RC2_BLOCK_SIZE,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
rc2_init,
|
||||
rc2_do_cipher,
|
||||
rc2_cleanup,
|
||||
sizeof(struct rc2_cbc),
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &rc2_cbc;
|
||||
}
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_rc2_40_cbc(void)
|
||||
{
|
||||
/* XXX */
|
||||
static const EVP_CIPHER rc2_cbc = {
|
||||
0,
|
||||
RC2_BLOCK_SIZE,
|
||||
5,
|
||||
RC2_BLOCK_SIZE,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
rc2_init,
|
||||
rc2_do_cipher,
|
||||
rc2_cleanup,
|
||||
sizeof(struct rc2_cbc),
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &rc2_cbc;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_rc4(void)
|
||||
{
|
||||
printf("evp rc4\n");
|
||||
abort();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_rc4_40(void)
|
||||
{
|
||||
printf("evp rc4_40\n");
|
||||
abort();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
struct des_ede3_cbc {
|
||||
DES_key_schedule ks[3];
|
||||
};
|
||||
|
||||
static int
|
||||
des_ede3_cbc_init(EVP_CIPHER_CTX *ctx,
|
||||
const unsigned char * key,
|
||||
const unsigned char * iv,
|
||||
int encp)
|
||||
{
|
||||
struct des_ede3_cbc *k = ctx->cipher_data;
|
||||
|
||||
DES_key_sched((DES_cblock *)key, &k->ks[0]);
|
||||
DES_key_sched((DES_cblock *)key + 8, &k->ks[1]);
|
||||
DES_key_sched((DES_cblock *)key + 16, &k->ks[2]);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
des_ede3_cbc_do_cipher(EVP_CIPHER_CTX *ctx,
|
||||
unsigned char *out,
|
||||
const unsigned char *in,
|
||||
unsigned int size)
|
||||
{
|
||||
struct des_ede3_cbc *k = ctx->cipher_data;
|
||||
DES_ede3_cbc_encrypt(in, out, size,
|
||||
&k->ks[0], &k->ks[1], &k->ks[2],
|
||||
(DES_cblock *)ctx->iv, ctx->encrypt);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
des_ede3_cbc_cleanup(EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
memset(ctx->cipher_data, 0, sizeof(struct des_ede3_cbc));
|
||||
return 1;
|
||||
}
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_des_ede3_cbc(void)
|
||||
{
|
||||
static const EVP_CIPHER des_ede3_cbc = {
|
||||
0,
|
||||
8,
|
||||
24,
|
||||
8,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
des_ede3_cbc_init,
|
||||
des_ede3_cbc_do_cipher,
|
||||
des_ede3_cbc_cleanup,
|
||||
sizeof(struct des_ede3_cbc),
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &des_ede3_cbc;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static int
|
||||
aes_init(EVP_CIPHER_CTX *ctx,
|
||||
const unsigned char * key,
|
||||
const unsigned char * iv,
|
||||
int encp)
|
||||
{
|
||||
AES_KEY *k = ctx->cipher_data;
|
||||
if (ctx->encrypt)
|
||||
AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
|
||||
else
|
||||
AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
aes_do_cipher(EVP_CIPHER_CTX *ctx,
|
||||
unsigned char *out,
|
||||
const unsigned char *in,
|
||||
unsigned int size)
|
||||
{
|
||||
AES_KEY *k = ctx->cipher_data;
|
||||
AES_cbc_encrypt(in, out, size, k, ctx->iv, ctx->encrypt);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
aes_cleanup(EVP_CIPHER_CTX *ctx)
|
||||
{
|
||||
memset(ctx->cipher_data, 0, sizeof(AES_KEY));
|
||||
return 1;
|
||||
}
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_aes_128_cbc(void)
|
||||
{
|
||||
static const EVP_CIPHER aes_128_cbc = {
|
||||
0,
|
||||
16,
|
||||
16,
|
||||
16,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
aes_init,
|
||||
aes_do_cipher,
|
||||
aes_cleanup,
|
||||
sizeof(AES_KEY),
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &aes_128_cbc;
|
||||
}
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_aes_192_cbc(void)
|
||||
{
|
||||
static const EVP_CIPHER aes_192_cbc = {
|
||||
0,
|
||||
16,
|
||||
24,
|
||||
16,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
aes_init,
|
||||
aes_do_cipher,
|
||||
aes_cleanup,
|
||||
sizeof(AES_KEY),
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &aes_192_cbc;
|
||||
}
|
||||
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_aes_256_cbc(void)
|
||||
{
|
||||
static const EVP_CIPHER aes_256_cbc = {
|
||||
0,
|
||||
16,
|
||||
32,
|
||||
16,
|
||||
EVP_CIPH_CBC_MODE,
|
||||
aes_init,
|
||||
aes_do_cipher,
|
||||
aes_cleanup,
|
||||
sizeof(AES_KEY),
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
return &aes_256_cbc;
|
||||
}
|
||||
228
lib/des/evp.h
Normal file
228
lib/des/evp.h
Normal file
@@ -0,0 +1,228 @@
|
||||
/*
|
||||
* Copyright (c) 2005 - 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
#ifndef HEIM_EVP_H
|
||||
#define HEIM_EVP_H 1
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <engine.h>
|
||||
|
||||
/* symbol renaming */
|
||||
#define EVP_CIPHER_CTX_block_size hc_EVP_CIPHER_CTX_block_size
|
||||
#define EVP_CIPHER_CTX_cipher hc_EVP_CIPHER_CTX_cipher
|
||||
#define EVP_CIPHER_CTX_cleanup hc_EVP_CIPHER_CTX_cleanup
|
||||
#define EVP_CIPHER_CTX_flags hc_EVP_CIPHER_CTX_flags
|
||||
#define EVP_CIPHER_CTX_get_app_data hc_EVP_CIPHER_CTX_get_app_data
|
||||
#define EVP_CIPHER_CTX_init hc_EVP_CIPHER_CTX_init
|
||||
#define EVP_CIPHER_CTX_iv_length hc_EVP_CIPHER_CTX_iv_length
|
||||
#define EVP_CIPHER_CTX_key_length hc_EVP_CIPHER_CTX_key_length
|
||||
#define EVP_CIPHER_CTX_mode hc_EVP_CIPHER_CTX_mode
|
||||
#define EVP_CIPHER_CTX_set_app_data hc_EVP_CIPHER_CTX_set_app_data
|
||||
#define EVP_CIPHER_CTX_set_key_length hc_EVP_CIPHER_CTX_set_key_length
|
||||
#define EVP_CIPHER_CTX_set_padding hc_EVP_CIPHER_CTX_set_padding
|
||||
#define EVP_CIPHER_block_size hc_EVP_CIPHER_block_size
|
||||
#define EVP_CIPHER_iv_length hc_EVP_CIPHER_iv_length
|
||||
#define EVP_CIPHER_key_length hc_EVP_CIPHER_key_length
|
||||
#define EVP_Cipher hc_EVP_Cipher
|
||||
#define EVP_CipherInit_ex hc_EVP_CipherInit_ex
|
||||
#define EVP_Digest hc_EVP_Digest
|
||||
#define EVP_DigestFinal_ex hc_EVP_DigestFinal_ex
|
||||
#define EVP_DigestInit_ex hc_EVP_DigestInit_ex
|
||||
#define EVP_DigestUpdate hc_EVP_DigestUpdate
|
||||
#define EVP_MD_CTX_block_size hc_EVP_MD_CTX_block_size
|
||||
#define EVP_MD_CTX_cleanup hc_EVP_MD_CTX_cleanup
|
||||
#define EVP_MD_CTX_create hc_EVP_MD_CTX_create
|
||||
#define EVP_MD_CTX_init hc_EVP_MD_CTX_init
|
||||
#define EVP_MD_CTX_destroy hc_EVP_MD_CTX_destroy
|
||||
#define EVP_MD_CTX_md hc_EVP_MD_CTX_md
|
||||
#define EVP_MD_CTX_size hc_EVP_MD_CTX_size
|
||||
#define EVP_MD_block_size hc_EVP_MD_block_size
|
||||
#define EVP_MD_size hc_EVP_MD_size
|
||||
#define EVP_aes_128_cbc hc_EVP_aes_128_cbc
|
||||
#define EVP_aes_192_cbc hc_EVP_aes_192_cbc
|
||||
#define EVP_aes_256_cbc hc_EVP_aes_256_cbc
|
||||
#define EVP_des_ede3_cbc hc_EVP_des_ede3_cbc
|
||||
#define EVP_enc_null hc_EVP_enc_null
|
||||
#define EVP_md2 hc_EVP_md2
|
||||
#define EVP_md4 hc_EVP_md4
|
||||
#define EVP_md5 hc_EVP_md5
|
||||
#define EVP_md_null hc_EVP_md_null
|
||||
#define EVP_rc2_40_cbc hc_EVP_rc2_40_cbc
|
||||
#define EVP_rc2_cbc hc_EVP_rc2_cbc
|
||||
#define EVP_rc4 hc_EVP_rc4
|
||||
#define EVP_rc4_40 hc_EVP_rc4_40
|
||||
#define EVP_sha hc_EVP_sha
|
||||
#define EVP_sha1 hc_EVP_sha1
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
typedef struct hc_EVP_MD_CTX EVP_MD_CTX;
|
||||
typedef struct hc_evp_pkey EVP_PKEY;
|
||||
typedef struct hc_evp_md EVP_MD;
|
||||
typedef struct hc_CIPHER EVP_CIPHER;
|
||||
typedef struct hc_CIPHER_CTX EVP_CIPHER_CTX;
|
||||
|
||||
#define EVP_MAX_IV_LENGTH 16
|
||||
#define EVP_MAX_BLOCK_LENGTH 32
|
||||
|
||||
#define EVP_MAX_MD_SIZE 64
|
||||
|
||||
struct hc_CIPHER {
|
||||
int nid;
|
||||
int block_size;
|
||||
int key_len;
|
||||
int iv_len;
|
||||
unsigned long flags;
|
||||
/* The lowest 3 bits is used as integer field for the mode the
|
||||
* cipher is used in (use EVP_CIPHER.._mode() to extract the
|
||||
* mode). The rest of the flag field is a bitfield.
|
||||
*/
|
||||
#define EVP_CIPH_CBC_MODE 2
|
||||
#define EVP_CIPH_MODE 0x7
|
||||
|
||||
#define EVP_CIPH_ALWAYS_CALL_INIT 0x20
|
||||
|
||||
int (*init)(EVP_CIPHER_CTX*,const unsigned char*,const unsigned char*,int);
|
||||
int (*do_cipher)(EVP_CIPHER_CTX *, unsigned char *,
|
||||
const unsigned char *, unsigned int);
|
||||
int (*cleanup)(EVP_CIPHER_CTX *);
|
||||
int ctx_size;
|
||||
void *set_asn1_parameters;
|
||||
void *get_asn1_parameters;
|
||||
void *ctrl;
|
||||
void *app_data;
|
||||
};
|
||||
|
||||
struct hc_CIPHER_CTX {
|
||||
const EVP_CIPHER *cipher;
|
||||
ENGINE *engine;
|
||||
int encrypt;
|
||||
int buf_len;
|
||||
unsigned char oiv[EVP_MAX_IV_LENGTH];
|
||||
unsigned char iv[EVP_MAX_IV_LENGTH];
|
||||
unsigned char buf[EVP_MAX_BLOCK_LENGTH];
|
||||
int num;
|
||||
void *app_data;
|
||||
int key_len;
|
||||
unsigned long flags;
|
||||
void *cipher_data;
|
||||
int final_used;
|
||||
int block_mask;
|
||||
unsigned char final[EVP_MAX_BLOCK_LENGTH];
|
||||
};
|
||||
|
||||
struct hc_EVP_MD_CTX {
|
||||
const EVP_MD *md;
|
||||
ENGINE *engine;
|
||||
void *ptr;
|
||||
};
|
||||
|
||||
/*
|
||||
* Avaible crypto algs
|
||||
*/
|
||||
|
||||
const EVP_MD *EVP_md_null(void);
|
||||
const EVP_MD *EVP_md2(void);
|
||||
const EVP_MD *EVP_md4(void);
|
||||
const EVP_MD *EVP_md5(void);
|
||||
const EVP_MD *EVP_sha(void);
|
||||
const EVP_MD *EVP_sha1(void);
|
||||
|
||||
const EVP_CIPHER * EVP_aes_128_cbc(void);
|
||||
const EVP_CIPHER * EVP_aes_192_cbc(void);
|
||||
const EVP_CIPHER * EVP_aes_256_cbc(void);
|
||||
const EVP_CIPHER * EVP_des_ede3_cbc(void);
|
||||
const EVP_CIPHER * EVP_enc_null(void);
|
||||
const EVP_CIPHER * EVP_rc2_40_cbc(void);
|
||||
const EVP_CIPHER * EVP_rc2_cbc(void);
|
||||
const EVP_CIPHER * EVP_rc4(void);
|
||||
const EVP_CIPHER * EVP_rc4_40(void);
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
size_t EVP_MD_size(const EVP_MD *);
|
||||
size_t EVP_MD_block_size(const EVP_MD *);
|
||||
|
||||
const EVP_MD *
|
||||
EVP_MD_CTX_md(EVP_MD_CTX *);
|
||||
size_t EVP_MD_CTX_size(EVP_MD_CTX *);
|
||||
size_t EVP_MD_CTX_block_size(EVP_MD_CTX *);
|
||||
|
||||
EVP_MD_CTX *
|
||||
EVP_MD_CTX_create(void);
|
||||
void EVP_MD_CTX_init(EVP_MD_CTX *);
|
||||
void EVP_MD_CTX_destroy(EVP_MD_CTX *);
|
||||
int EVP_MD_CTX_cleanup(EVP_MD_CTX *);
|
||||
|
||||
int EVP_DigestInit_ex(EVP_MD_CTX *, const EVP_MD *, ENGINE *);
|
||||
int EVP_DigestUpdate(EVP_MD_CTX *,const void *, size_t);
|
||||
int EVP_DigestFinal_ex(EVP_MD_CTX *, void *, unsigned int *);
|
||||
int EVP_Digest(const void *, size_t, void *, unsigned int *,
|
||||
const EVP_MD *, ENGINE *);
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
size_t EVP_CIPHER_block_size(const EVP_CIPHER *);
|
||||
size_t EVP_CIPHER_key_length(const EVP_CIPHER *);
|
||||
size_t EVP_CIPHER_iv_length(const EVP_CIPHER *);
|
||||
|
||||
void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *);
|
||||
int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *);
|
||||
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *, int);
|
||||
int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *, int);
|
||||
unsigned long
|
||||
EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *);
|
||||
int EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *);
|
||||
|
||||
const EVP_CIPHER *
|
||||
EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *);
|
||||
size_t EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *);
|
||||
size_t EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *);
|
||||
size_t EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *);
|
||||
void * EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *);
|
||||
void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *, void *);
|
||||
|
||||
int EVP_CipherInit_ex(EVP_CIPHER_CTX *,const EVP_CIPHER *, ENGINE *,
|
||||
const void *, const void *, int);
|
||||
|
||||
int EVP_Cipher(EVP_CIPHER_CTX *,void *,const void *,size_t);
|
||||
|
||||
|
||||
#endif /* HEIM_EVP_H */
|
||||
127
lib/des/hmac.c
Normal file
127
lib/des/hmac.c
Normal file
@@ -0,0 +1,127 @@
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <hmac.h>
|
||||
|
||||
HMAC_CTX *
|
||||
HMAC_CTX_create(void)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
HMAC_CTX_destroy(HMAC_CTX *ctx)
|
||||
{
|
||||
HMAC_CTX_cleanup(ctx);
|
||||
if (ctx->buf) {
|
||||
free(ctx->buf);
|
||||
ctx->buf = NULL;
|
||||
}
|
||||
if (ctx->opad) {
|
||||
free(ctx->opad);
|
||||
ctx->opad = NULL;
|
||||
}
|
||||
if (ctx->ipad) {
|
||||
free(ctx->ipad);
|
||||
ctx->ipad = NULL;
|
||||
}
|
||||
free(ctx);
|
||||
}
|
||||
|
||||
void
|
||||
HMAC_CTX_init(HMAC_CTX *ctx)
|
||||
{
|
||||
memset(ctx, 0, sizeof(*ctx));
|
||||
}
|
||||
|
||||
void
|
||||
HMAC_CTX_cleanup(HMAC_CTX *ctx)
|
||||
{
|
||||
EVP_MD_CTX_cleanup(ctx->ctx);
|
||||
}
|
||||
|
||||
size_t
|
||||
HMAC_size(const HMAC_CTX *ctx)
|
||||
{
|
||||
return EVP_MD_size(ctx->md);
|
||||
}
|
||||
|
||||
void
|
||||
HMAC_Init_ex(HMAC_CTX *ctx,
|
||||
const void *key,
|
||||
size_t len,
|
||||
const EVP_MD *md,
|
||||
ENGINE *engine)
|
||||
{
|
||||
unsigned char *p;
|
||||
size_t i;
|
||||
|
||||
if (ctx->md != md) {
|
||||
ctx->md = md;
|
||||
if (ctx->buf)
|
||||
free (ctx->buf);
|
||||
ctx->buf = malloc(EVP_MD_size(ctx->md));
|
||||
}
|
||||
ctx->engine = engine;
|
||||
|
||||
if (len < EVP_MD_size(ctx->md)) {
|
||||
key = ctx->buf;
|
||||
EVP_Digest(key, len, ctx->buf, NULL, ctx->md, engine);
|
||||
len = EVP_MD_size(ctx->md);
|
||||
}
|
||||
|
||||
if (ctx->opad)
|
||||
free(ctx->opad);
|
||||
if (ctx->ipad)
|
||||
free(ctx->ipad);
|
||||
|
||||
ctx->opad = malloc(len);
|
||||
ctx->ipad = malloc(len);
|
||||
ctx->key_length = len;
|
||||
|
||||
for (i = 0, p = ctx->opad; i < len; i++)
|
||||
p[i] = ((const unsigned char *)key)[i] ^ 0x36;
|
||||
for (i = 0, p = ctx->ipad; i < len; i++)
|
||||
p[i] = ((const unsigned char *)key)[i] ^ 0x5c;
|
||||
|
||||
ctx->ctx = EVP_MD_CTX_create();
|
||||
|
||||
EVP_DigestInit_ex(ctx->ctx, ctx->md, ctx->engine);
|
||||
EVP_DigestUpdate(ctx->ctx, ctx->ipad, ctx->key_length);
|
||||
}
|
||||
|
||||
void
|
||||
HMAC_Update(HMAC_CTX *ctx, const void *data, size_t len)
|
||||
{
|
||||
EVP_DigestUpdate(ctx->ctx, data, len);
|
||||
}
|
||||
|
||||
void
|
||||
HMAC_Final(HMAC_CTX *ctx, void *md, unsigned int *len)
|
||||
{
|
||||
EVP_DigestFinal_ex(ctx->ctx, ctx->buf, NULL);
|
||||
|
||||
EVP_DigestInit_ex(ctx->ctx, ctx->md, ctx->engine);
|
||||
EVP_DigestUpdate(ctx->ctx, ctx->opad, ctx->key_length);
|
||||
EVP_DigestUpdate(ctx->ctx, ctx->buf, EVP_MD_size(ctx->md));
|
||||
EVP_DigestFinal_ex(ctx->ctx, md, len);
|
||||
}
|
||||
|
||||
void *
|
||||
HMAC(const EVP_MD *md,
|
||||
const void *key, size_t key_size,
|
||||
const void *data, size_t data_size,
|
||||
void *hash, unsigned int *hash_len)
|
||||
{
|
||||
HMAC_CTX *ctx;
|
||||
|
||||
ctx = HMAC_CTX_create();
|
||||
if (ctx == NULL)
|
||||
return NULL;
|
||||
HMAC_Init_ex(ctx, key, key_size, md, NULL);
|
||||
HMAC_Update(ctx, data, data_size);
|
||||
HMAC_Final(ctx, hash, hash_len);
|
||||
HMAC_CTX_destroy(ctx);
|
||||
return hash;
|
||||
}
|
||||
87
lib/des/hmac.h
Normal file
87
lib/des/hmac.h
Normal file
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Copyright (c) 2005 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
#ifndef HEIM_HMAC_H
|
||||
#define HEIM_HMAC_H 1
|
||||
|
||||
#include <evp.h>
|
||||
|
||||
/* symbol renaming */
|
||||
#define HMAC_CTX_create hc_HMAC_CTX_create
|
||||
#define HMAC_CTX_destroy hc_HMAC_CTX_destroy
|
||||
#define HMAC_CTX_init hc_HMAC_CTX_init
|
||||
#define HMAC_CTX_cleanup hc_HMAC_CTX_cleanup
|
||||
#define HMAC_size hc_HMAC_size
|
||||
#define HMAC_Init_ex hc_HMAC_Init_ex
|
||||
#define HMAC_Update hc_HMAC_Update
|
||||
#define HMAC_Final hc_HMAC_Final
|
||||
#define HMAC hc_HMAC
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define HMAC_MAX_MD_CBLOCK 64
|
||||
|
||||
typedef struct hc_HMAC_CTX HMAC_CTX;
|
||||
|
||||
struct hc_HMAC_CTX {
|
||||
const EVP_MD *md;
|
||||
ENGINE *engine;
|
||||
EVP_MD_CTX *ctx;
|
||||
size_t key_length;
|
||||
void *opad;
|
||||
void *ipad;
|
||||
void *buf;
|
||||
};
|
||||
|
||||
|
||||
HMAC_CTX *
|
||||
HMAC_CTX_create(void);
|
||||
void HMAC_CTX_destroy(HMAC_CTX *);
|
||||
void HMAC_CTX_init(HMAC_CTX *);
|
||||
void HMAC_CTX_cleanup(HMAC_CTX *ctx);
|
||||
|
||||
size_t HMAC_size(const HMAC_CTX *ctx);
|
||||
|
||||
void HMAC_Init_ex(HMAC_CTX *, const void *, size_t,
|
||||
const EVP_MD *, ENGINE *);
|
||||
void HMAC_Update(HMAC_CTX *ctx, const void *data, size_t len);
|
||||
void HMAC_Final(HMAC_CTX *ctx, void *md, unsigned int *len);
|
||||
|
||||
void * HMAC(const EVP_MD *evp_md, const void *key, size_t key_len,
|
||||
const void *data, size_t n, void *md, unsigned int *md_len);
|
||||
|
||||
#endif /* HEIM_HMAC_H */
|
||||
138
lib/des/md2.c
Normal file
138
lib/des/md2.c
Normal file
@@ -0,0 +1,138 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
|
||||
RCSID("$Id$");
|
||||
#endif
|
||||
|
||||
#include "hash.h"
|
||||
#include "md2.h"
|
||||
|
||||
static const unsigned char subst[256] = {
|
||||
41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
|
||||
19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
|
||||
76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
|
||||
138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
|
||||
245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
|
||||
148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
|
||||
39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
|
||||
181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
|
||||
150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
|
||||
112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
|
||||
96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
|
||||
85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
|
||||
234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
|
||||
129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
|
||||
8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
|
||||
203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
|
||||
166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
|
||||
31, 26, 219, 153, 141, 51, 159, 17, 131, 20
|
||||
};
|
||||
|
||||
void
|
||||
MD2_Init (struct md2 *m)
|
||||
{
|
||||
memset(m, 0, sizeof(*m));
|
||||
}
|
||||
|
||||
static void
|
||||
calc(struct md2 *m, const void *v)
|
||||
{
|
||||
unsigned char x[48], L;
|
||||
const unsigned char *p = v;
|
||||
int i, j, t;
|
||||
|
||||
L = m->checksum[15];
|
||||
for (i = 0; i < 16; i++)
|
||||
L = m->checksum[i] ^= subst[p[i] ^ L];
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
x[i] = m->state[i];
|
||||
x[i + 16] = p[i];
|
||||
x[i + 32] = x[i] ^ p[i];
|
||||
}
|
||||
|
||||
t = 0;
|
||||
for (i = 0; i < 18; i++) {
|
||||
for (j = 0; j < 48; j++)
|
||||
t = x[j] ^= subst[t];
|
||||
t = (t + i) & 0xff;
|
||||
}
|
||||
|
||||
memcpy(m->state, x, 16);
|
||||
memset(x, 0, sizeof(x));
|
||||
}
|
||||
|
||||
void
|
||||
MD2_Update (struct md2 *m, const void *v, size_t len)
|
||||
{
|
||||
size_t idx = m->len & 0xf;
|
||||
const unsigned char *p = v;
|
||||
|
||||
m->len += len;
|
||||
if (len + idx >= 16) {
|
||||
if (idx) {
|
||||
memcpy(m->data + idx, p, 16 - idx);
|
||||
calc(m, m->data);
|
||||
p += 16;
|
||||
len -= 16 - idx;
|
||||
}
|
||||
while (len >= 16) {
|
||||
calc(m, p);
|
||||
p += 16;
|
||||
len -= 16;
|
||||
}
|
||||
idx = 0;
|
||||
}
|
||||
|
||||
memcpy(m->data + idx, p, len);
|
||||
}
|
||||
|
||||
void
|
||||
MD2_Final (void *res, struct md2 *m)
|
||||
{
|
||||
unsigned char pad[16];
|
||||
size_t padlen;
|
||||
|
||||
padlen = 16 - (m->len % 16);
|
||||
memset(pad, padlen, padlen);
|
||||
|
||||
MD2_Update(m, pad, padlen);
|
||||
memcpy(pad, m->checksum, 16);
|
||||
MD2_Update(m, pad, 16);
|
||||
|
||||
memcpy(res, m->state, MD2_DIGEST_LENGTH);
|
||||
memset(m, 0, sizeof(m));
|
||||
}
|
||||
63
lib/des/md2.h
Normal file
63
lib/des/md2.h
Normal file
@@ -0,0 +1,63 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
#ifndef HEIM_MD2_H
|
||||
#define HEIM_MD2_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define MD2_Init hc_MD2_Init
|
||||
#define MD2_Update hc_MD2_Update
|
||||
#define MD2_Final hc_MD2_Final
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define MD2_DIGEST_LENGTH 16
|
||||
|
||||
struct md2 {
|
||||
size_t len;
|
||||
unsigned char data[16]; /* stored unalligned data between Update's */
|
||||
unsigned char checksum[16];
|
||||
unsigned char state[16]; /* lower 16 bytes of X */
|
||||
};
|
||||
|
||||
typedef struct md2 MD2_CTX;
|
||||
|
||||
void MD2_Init (struct md2 *m);
|
||||
void MD2_Update (struct md2 *m, const void *p, size_t len);
|
||||
void MD2_Final (void *res, struct md2 *m);
|
||||
|
||||
#endif /* HEIM_MD2_H */
|
||||
@@ -36,6 +36,17 @@
|
||||
#ifndef HEIM_MD4_H
|
||||
#define HEIM_MD4_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define MD4_Init hc_MD4_Init
|
||||
#define MD4_Update hc_MD4_Update
|
||||
#define MD4_Final hc_MD4_Final
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define MD4_DIGEST_LENGTH 16
|
||||
|
||||
struct md4 {
|
||||
unsigned int sz[2];
|
||||
u_int32_t counter[4];
|
||||
|
||||
@@ -36,6 +36,17 @@
|
||||
#ifndef HEIM_MD5_H
|
||||
#define HEIM_MD5_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define MD5_Init hc_MD5_Init
|
||||
#define MD5_Update hc_MD5_Update
|
||||
#define MD5_Final hc_MD5_Final
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define MD5_DIGEST_LENGTH 16
|
||||
|
||||
struct md5 {
|
||||
unsigned int sz[2];
|
||||
u_int32_t counter[4];
|
||||
|
||||
@@ -44,9 +44,11 @@ RCSID("$Id$");
|
||||
#ifdef KRB5
|
||||
#include <krb5-types.h>
|
||||
#endif
|
||||
#include <md2.h>
|
||||
#include <md4.h>
|
||||
#include <md5.h>
|
||||
#include <sha.h>
|
||||
#include <evp.h>
|
||||
|
||||
#define ONE_MILLION_A "one million a's"
|
||||
|
||||
@@ -57,27 +59,39 @@ struct hash_foo {
|
||||
void (*init)(void*);
|
||||
void (*update)(void*, const void*, size_t);
|
||||
void (*final)(void*, void*);
|
||||
} md4 = {
|
||||
const EVP_MD * (*evp)(void);
|
||||
} md2 = {
|
||||
"MD2",
|
||||
sizeof(MD2_CTX),
|
||||
16,
|
||||
(void (*)(void*))MD2_Init,
|
||||
(void (*)(void*,const void*, size_t))MD2_Update,
|
||||
(void (*)(void*, void*))MD2_Final,
|
||||
EVP_md2
|
||||
}, md4 = {
|
||||
"MD4",
|
||||
sizeof(MD4_CTX),
|
||||
16,
|
||||
(void (*)(void*))MD4_Init,
|
||||
(void (*)(void*,const void*, size_t))MD4_Update,
|
||||
(void (*)(void*, void*))MD4_Final
|
||||
(void (*)(void*, void*))MD4_Final,
|
||||
EVP_md4
|
||||
}, md5 = {
|
||||
"MD5",
|
||||
sizeof(MD5_CTX),
|
||||
16,
|
||||
(void (*)(void*))MD5_Init,
|
||||
(void (*)(void*,const void*, size_t))MD5_Update,
|
||||
(void (*)(void*, void*))MD5_Final
|
||||
(void (*)(void*, void*))MD5_Final,
|
||||
EVP_md5
|
||||
}, sha1 = {
|
||||
"SHA-1",
|
||||
sizeof(struct sha),
|
||||
20,
|
||||
(void (*)(void*))SHA1_Init,
|
||||
(void (*)(void*,const void*, size_t))SHA1_Update,
|
||||
(void (*)(void*, void*))SHA1_Final
|
||||
(void (*)(void*, void*))SHA1_Final,
|
||||
EVP_sha1
|
||||
};
|
||||
#ifdef HAVE_SHA256
|
||||
struct hash_foo sha256 = {
|
||||
@@ -115,6 +129,24 @@ struct test {
|
||||
unsigned char hash[64];
|
||||
};
|
||||
|
||||
struct test md2_tests[] = {
|
||||
{"",
|
||||
"\x83\x50\xe5\xa3\xe2\x4c\x15\x3d\xf2\x27\x5c\x9f\x80\x69\x27\x73" },
|
||||
{"a",
|
||||
"\x32\xec\x01\xec\x4a\x6d\xac\x72\xc0\xab\x96\xfb\x34\xc0\xb5\xd1" },
|
||||
{"abc",
|
||||
"\xda\x85\x3b\x0d\x3f\x88\xd9\x9b\x30\x28\x3a\x69\xe6\xde\xd6\xbb" },
|
||||
{"message digest",
|
||||
"\xab\x4f\x49\x6b\xfb\x2a\x53\x0b\x21\x9f\xf3\x30\x31\xfe\x06\xb0" },
|
||||
{"abcdefghijklmnopqrstuvwxyz",
|
||||
"\x4e\x8d\xdf\xf3\x65\x02\x92\xab\x5a\x41\x08\xc3\xaa\x47\x94\x0b" },
|
||||
{"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
|
||||
"\xda\x33\xde\xf2\xa4\x2d\xf1\x39\x75\x35\x28\x46\xc3\x03\x38\xcd" },
|
||||
{"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
|
||||
"\xd5\x97\x6f\x79\xd8\x3d\x3a\x0d\xc9\x80\x6c\x3c\x66\xf3\xef\xd8" },
|
||||
{NULL }
|
||||
};
|
||||
|
||||
struct test md4_tests[] = {
|
||||
{"",
|
||||
{0x31, 0xd6, 0xcf, 0xe0, 0xd1, 0x6a, 0xe9, 0x31, 0xb7, 0x3c, 0x59,
|
||||
@@ -244,6 +276,8 @@ static int
|
||||
hash_test (struct hash_foo *hash, struct test *tests)
|
||||
{
|
||||
struct test *t;
|
||||
EVP_MD_CTX ectx;
|
||||
unsigned int esize;
|
||||
void *ctx = malloc(hash->psize);
|
||||
unsigned char *res = malloc(hash->hsize);
|
||||
|
||||
@@ -251,14 +285,22 @@ hash_test (struct hash_foo *hash, struct test *tests)
|
||||
for (t = tests; t->str; ++t) {
|
||||
char buf[1000];
|
||||
|
||||
EVP_MD_CTX_init(&ectx);
|
||||
EVP_DigestInit_ex(&ectx, hash->evp(), NULL);
|
||||
|
||||
(*hash->init)(ctx);
|
||||
if(strcmp(t->str, ONE_MILLION_A) == 0) {
|
||||
int i;
|
||||
memset(buf, 'a', sizeof(buf));
|
||||
for(i = 0; i < 1000; i++)
|
||||
for(i = 0; i < 1000; i++) {
|
||||
(*hash->update)(ctx, buf, sizeof(buf));
|
||||
} else
|
||||
EVP_DigestUpdate(&ectx, buf, sizeof(buf));
|
||||
}
|
||||
} else {
|
||||
(*hash->update)(ctx, (unsigned char *)t->str, strlen(t->str));
|
||||
EVP_DigestUpdate(&ectx, t->str, strlen(t->str));
|
||||
}
|
||||
|
||||
(*hash->final) (res, ctx);
|
||||
if (memcmp (res, t->hash, hash->hsize) != 0) {
|
||||
int i;
|
||||
@@ -279,6 +321,20 @@ hash_test (struct hash_foo *hash, struct test *tests)
|
||||
printf("\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
EVP_DigestFinal_ex(&ectx, res, &esize);
|
||||
EVP_MD_CTX_cleanup(&ectx);
|
||||
|
||||
if (hash->hsize != esize) {
|
||||
printf("EVP %s returned wrong hash size\n", hash->name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (memcmp (res, t->hash, hash->hsize) != 0) {
|
||||
printf("EVP %s failed here old function where successful!\n",
|
||||
hash->name);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
printf ("success\n");
|
||||
return 0;
|
||||
@@ -287,7 +343,9 @@ hash_test (struct hash_foo *hash, struct test *tests)
|
||||
int
|
||||
main (void)
|
||||
{
|
||||
return hash_test(&md4, md4_tests) +
|
||||
return
|
||||
hash_test(&md2, md2_tests) +
|
||||
hash_test(&md4, md4_tests) +
|
||||
hash_test(&md5, md5_tests) +
|
||||
hash_test(&sha1, sha1_tests)
|
||||
#ifdef HAVE_SHA256
|
||||
|
||||
76
lib/des/rand.c
Normal file
76
lib/des/rand.c
Normal file
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
RCSID("$Id$");
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <rand.h>
|
||||
|
||||
#include <roken.h>
|
||||
|
||||
int
|
||||
RAND_bytes(void *outdata, size_t size)
|
||||
{
|
||||
static const char *rnd_devices[] = {
|
||||
"/dev/random",
|
||||
"/dev/srandom",
|
||||
"/dev/urandom",
|
||||
"/dev/arandom",
|
||||
NULL
|
||||
};
|
||||
const char **p;
|
||||
|
||||
for(p = rnd_devices; *p; p++) {
|
||||
int fd = open(*p, O_RDONLY | O_NDELAY);
|
||||
|
||||
if(fd >= 0 && read(fd, outdata, size) == size) {
|
||||
close(fd);
|
||||
return 1;
|
||||
}
|
||||
close(fd);
|
||||
}
|
||||
|
||||
abort();
|
||||
}
|
||||
|
||||
int
|
||||
RAND_pseudo_bytes(void *outdata, size_t num)
|
||||
{
|
||||
return RAND_bytes(outdata, num);
|
||||
}
|
||||
|
||||
54
lib/des/rand.h
Normal file
54
lib/des/rand.h
Normal file
@@ -0,0 +1,54 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef _HEIM_RAND_H
|
||||
#define _HEIM_RAND_H 1
|
||||
|
||||
#include <bn.h>
|
||||
|
||||
/* symbol renaming */
|
||||
#define RAND_bytes hc_RAND_bytes
|
||||
#define RAND_pseudo_bytes hc_RAND_pseudo_bytes
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
int RAND_bytes(void *, size_t num);
|
||||
int RAND_pseudo_bytes(void *, size_t);
|
||||
|
||||
#endif /* _HEIM_RAND_H */
|
||||
@@ -33,6 +33,16 @@
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
/* symbol renaming */
|
||||
#define RC2_set_key hc_RC2_set_key
|
||||
#define RC2_encryptc hc_RC2_encryptc
|
||||
#define RC2_decryptc hc_RC2_decryptc
|
||||
#define RC2_cbc_encrypt hc_RC2_cbc_encrypt
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define RC2_ENCRYPT 1
|
||||
#define RC2_DECRYPT 0
|
||||
|
||||
|
||||
@@ -33,6 +33,10 @@
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
/* symbol renaming */
|
||||
#define RC4_set_key hc_RC4_set_key
|
||||
#define RC4 hc_RC4
|
||||
|
||||
typedef struct rc4_key {
|
||||
unsigned int x, y;
|
||||
unsigned int state[256];
|
||||
|
||||
@@ -28,6 +28,12 @@
|
||||
#ifndef __RIJNDAEL_ALG_FST_H
|
||||
#define __RIJNDAEL_ALG_FST_H
|
||||
|
||||
/* symbol renaming */
|
||||
#define rijndaelKeySetupEnc _hc_rijndaelKeySetupEnc
|
||||
#define rijndaelKeySetupDec _hc_rijndaelKeySetupDec
|
||||
#define rijndaelEncrypt _hc_rijndaelEncrypt
|
||||
#define rijndaelDecrypt _hc_rijndaelDecrypt
|
||||
|
||||
#define RIJNDAEL_MAXKC (256/32)
|
||||
#define RIJNDAEL_MAXKB (256/8)
|
||||
#define RIJNDAEL_MAXNR 14
|
||||
|
||||
@@ -324,6 +324,8 @@ DES_generate_random_block(DES_cblock *block)
|
||||
DES_rand_data((unsigned char *)block, sizeof(*block));
|
||||
}
|
||||
|
||||
#define DES_rand_data_key hc_DES_rand_data_key
|
||||
|
||||
void
|
||||
DES_rand_data_key(DES_cblock *key);
|
||||
|
||||
@@ -353,6 +355,9 @@ DES_rand_data_key(DES_cblock *key)
|
||||
* It's neccessary to be root to run it. Returns -1 if there were any
|
||||
* problems with permissions.
|
||||
*/
|
||||
|
||||
#define DES_mem_rand8 hc_DES_mem_rand8
|
||||
|
||||
int
|
||||
DES_mem_rand8(unsigned char *data);
|
||||
|
||||
|
||||
337
lib/des/rsa.c
Normal file
337
lib/des/rsa.c
Normal file
@@ -0,0 +1,337 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
RCSID("$Id$");
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <krb5-types.h>
|
||||
#include <heim_asn1.h>
|
||||
#include <rfc2459_asn1.h>
|
||||
|
||||
#include <rsa.h>
|
||||
|
||||
#include <roken.h>
|
||||
|
||||
RSA *
|
||||
RSA_new(void)
|
||||
{
|
||||
return RSA_new_method(NULL);
|
||||
}
|
||||
|
||||
RSA *
|
||||
RSA_new_method(ENGINE *engine)
|
||||
{
|
||||
RSA *rsa;
|
||||
|
||||
rsa = calloc(1, sizeof(*rsa));
|
||||
if (rsa == NULL)
|
||||
return NULL;
|
||||
|
||||
rsa->references = 1;
|
||||
|
||||
if (engine) {
|
||||
ENGINE_up_ref(engine);
|
||||
rsa->engine = engine;
|
||||
} else {
|
||||
rsa->engine = ENGINE_get_default_RSA();
|
||||
}
|
||||
|
||||
if (rsa->engine) {
|
||||
rsa->meth = ENGINE_get_RSA(rsa->engine);
|
||||
if (rsa->meth == NULL) {
|
||||
ENGINE_finish(engine);
|
||||
free(rsa);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (rsa->meth == NULL)
|
||||
rsa->meth = rk_UNCONST(RSA_get_default_method());
|
||||
|
||||
(*rsa->meth->init)(rsa);
|
||||
|
||||
return rsa;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
RSA_free(RSA *rsa)
|
||||
{
|
||||
if (rsa->references <= 0)
|
||||
abort();
|
||||
|
||||
if (--rsa->references > 0)
|
||||
return;
|
||||
|
||||
if (rsa->engine)
|
||||
ENGINE_finish(rsa->engine);
|
||||
|
||||
(*rsa->meth->finish)(rsa);
|
||||
|
||||
#define free_if(f) if (f) { BN_free(f); }
|
||||
free_if(rsa->n);
|
||||
free_if(rsa->e);
|
||||
free_if(rsa->d);
|
||||
free_if(rsa->p);
|
||||
free_if(rsa->q);
|
||||
#undef free_if
|
||||
|
||||
memset(rsa, 0, sizeof(*rsa));
|
||||
free(rsa);
|
||||
}
|
||||
|
||||
int
|
||||
RSA_up_ref(RSA *rsa)
|
||||
{
|
||||
return ++rsa->references;
|
||||
}
|
||||
|
||||
const RSA_METHOD *
|
||||
RSA_get_method(const RSA *rsa)
|
||||
{
|
||||
return rsa->meth;
|
||||
}
|
||||
|
||||
int
|
||||
RSA_set_method(RSA *rsa, const RSA_METHOD *method)
|
||||
{
|
||||
(*rsa->meth->finish)(rsa);
|
||||
|
||||
if (rsa->engine) {
|
||||
ENGINE_finish(rsa->engine);
|
||||
rsa->engine = NULL;
|
||||
}
|
||||
|
||||
rsa->meth = method;
|
||||
(*rsa->meth->init)(rsa);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
RSA_set_app_data(RSA *rsa, void *arg)
|
||||
{
|
||||
rsa->ex_data.sk = arg;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void *
|
||||
RSA_get_app_data(RSA *rsa)
|
||||
{
|
||||
return rsa->ex_data.sk;
|
||||
}
|
||||
|
||||
int
|
||||
RSA_check_key(const RSA *key)
|
||||
{
|
||||
static const unsigned char inbuf[] = "hello, world!";
|
||||
RSA *rsa = rk_UNCONST(key);
|
||||
void *buffer;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* XXX I have no clue how to implement this w/o a bignum library.
|
||||
* Well, when we have a RSA key pair, we can try to encrypt/sign
|
||||
* and then decrypt/verify.
|
||||
*/
|
||||
|
||||
buffer = malloc(RSA_size(rsa));
|
||||
if (buffer == NULL)
|
||||
return 0;
|
||||
|
||||
ret = RSA_public_encrypt(sizeof(inbuf), inbuf, buffer,
|
||||
rsa, RSA_PKCS1_PADDING);
|
||||
if (ret == -1) {
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ret = RSA_private_decrypt(ret, buffer, buffer,
|
||||
rsa, RSA_PKCS1_PADDING);
|
||||
if (ret == -1) {
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (ret == sizeof(inbuf) && memcmp(buffer, inbuf, sizeof(inbuf)) == 0) {
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
RSA_size(const RSA *rsa)
|
||||
{
|
||||
return BN_num_bytes(rsa->n);
|
||||
}
|
||||
|
||||
#define RSAFUNC(name, body) \
|
||||
int \
|
||||
name(int flen,const unsigned char* f, unsigned char* t, RSA* r, int p){\
|
||||
return body; \
|
||||
}
|
||||
|
||||
RSAFUNC(RSA_public_encrypt, (r)->meth->rsa_pub_enc(flen, f, t, r, p));
|
||||
RSAFUNC(RSA_public_decrypt, (r)->meth->rsa_pub_dec(flen, f, t, r, p));
|
||||
RSAFUNC(RSA_private_encrypt, (r)->meth->rsa_priv_enc(flen, f, t, r, p));
|
||||
RSAFUNC(RSA_private_decrypt, (r)->meth->rsa_priv_dec(flen, f, t, r, p));
|
||||
|
||||
/* XXX */
|
||||
int
|
||||
RSA_sign(int type, const unsigned char *from, unsigned int flen,
|
||||
unsigned char *to, unsigned int *tlen, RSA *rsa)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
RSA_verify(int type, const unsigned char *from, unsigned int flen,
|
||||
unsigned char *to, unsigned int tlen, RSA *rsa)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* A NULL RSA_METHOD that returns failure for all operations. This is
|
||||
* used as the default RSA method is we don't have any native
|
||||
* support.
|
||||
*/
|
||||
|
||||
static RSAFUNC(null_rsa_public_encrypt, -1);
|
||||
static RSAFUNC(null_rsa_public_decrypt, -1);
|
||||
static RSAFUNC(null_rsa_private_encrypt, -1);
|
||||
static RSAFUNC(null_rsa_private_decrypt, -1);
|
||||
|
||||
static int
|
||||
null_rsa_init(RSA *rsa)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
null_rsa_finish(RSA *rsa)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const RSA_METHOD rsa_null_method = {
|
||||
"hx509 null RSA",
|
||||
null_rsa_public_encrypt,
|
||||
null_rsa_public_decrypt,
|
||||
null_rsa_private_encrypt,
|
||||
null_rsa_private_decrypt,
|
||||
NULL,
|
||||
NULL,
|
||||
null_rsa_init,
|
||||
null_rsa_finish,
|
||||
0,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
const RSA_METHOD *
|
||||
RSA_null_method(void)
|
||||
{
|
||||
return &rsa_null_method;
|
||||
}
|
||||
|
||||
static const RSA_METHOD *default_rsa_method = &rsa_null_method;
|
||||
|
||||
const RSA_METHOD *
|
||||
RSA_get_default_method(void)
|
||||
{
|
||||
return default_rsa_method;
|
||||
}
|
||||
|
||||
void
|
||||
RSA_set_default_method(const RSA_METHOD *meth)
|
||||
{
|
||||
default_rsa_method = meth;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
static BIGNUM *
|
||||
heim_int2BN(const heim_integer *i)
|
||||
{
|
||||
BIGNUM *bn;
|
||||
|
||||
bn = BN_bin2bn(i->data, i->length, NULL);
|
||||
BN_set_negative(bn, i->negative);
|
||||
return bn;
|
||||
}
|
||||
|
||||
|
||||
RSA *
|
||||
d2i_RSAPrivateKey(RSA *rsa, const unsigned char **pp, size_t len)
|
||||
{
|
||||
RSAPrivateKey data;
|
||||
RSA *k = rsa;
|
||||
size_t size;
|
||||
int ret;
|
||||
|
||||
ret = decode_RSAPrivateKey(*pp, len, &data, &size);
|
||||
if (ret)
|
||||
return 0;
|
||||
|
||||
*pp += size;
|
||||
|
||||
if (k == NULL) {
|
||||
k = RSA_new();
|
||||
if (k == NULL) {
|
||||
free_RSAPrivateKey(&data);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
k->n = heim_int2BN(&data.modulus);
|
||||
k->e = heim_int2BN(&data.publicExponent);
|
||||
k->d = heim_int2BN(&data.privateExponent);
|
||||
k->p = heim_int2BN(&data.prime1);
|
||||
k->q = heim_int2BN(&data.prime2);
|
||||
k->dmp1 = heim_int2BN(&data.exponent1);
|
||||
k->dmq1 = heim_int2BN(&data.exponent2);
|
||||
|
||||
free_RSAPrivateKey(&data);
|
||||
return k;
|
||||
}
|
||||
164
lib/des/rsa.h
Normal file
164
lib/des/rsa.h
Normal file
@@ -0,0 +1,164 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef _HEIM_RSA_H
|
||||
#define _HEIM_RSA_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define RSA_null_method hc_RSA_null_method
|
||||
#define RSA_new hc_RSA_new
|
||||
#define RSA_new_method hc_RSA_new_method
|
||||
#define RSA_free hc_RSA_free
|
||||
#define RSA_up_ref hc_RSA_up_ref
|
||||
#define RSA_set_default_method hc_RSA_set_default_method
|
||||
#define RSA_get_default_method hc_RSA_get_default_method
|
||||
#define RSA_set_method hc_RSA_set_method
|
||||
#define RSA_get_method hc_RSA_get_method
|
||||
#define RSA_set_app_data hc_RSA_set_app_data
|
||||
#define RSA_get_app_data hc_RSA_get_app_data
|
||||
#define RSA_check_key hc_RSA_check_key
|
||||
#define RSA_size hc_RSA_size
|
||||
#define RSA_public_encrypt hc_RSA_public_encrypt
|
||||
#define RSA_public_decrypt hc_RSA_public_decrypt
|
||||
#define RSA_private_encrypt hc_RSA_private_encrypt
|
||||
#define RSA_private_decrypt hc_RSA_private_decrypt
|
||||
#define RSA_sign hc_RSA_sign
|
||||
#define RSA_verify hc_RSA_verify
|
||||
#define d2i_RSAPrivateKey hc_d2i_RSAPrivateKey
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
typedef struct RSA RSA;
|
||||
typedef struct RSA_METHOD RSA_METHOD;
|
||||
|
||||
#include <bn.h>
|
||||
#include <engine.h>
|
||||
|
||||
struct RSA_METHOD {
|
||||
const char *name;
|
||||
int (*rsa_pub_enc)(int,const unsigned char *, unsigned char *, RSA *,int);
|
||||
int (*rsa_pub_dec)(int,const unsigned char *, unsigned char *, RSA *,int);
|
||||
int (*rsa_priv_enc)(int,const unsigned char *, unsigned char *, RSA *,int);
|
||||
int (*rsa_priv_dec)(int,const unsigned char *, unsigned char *, RSA *,int);
|
||||
void *rsa_mod_exp;
|
||||
void *bn_mod_exp;
|
||||
int (*init)(RSA *rsa);
|
||||
int (*finish)(RSA *rsa);
|
||||
int flags;
|
||||
char *app_data;
|
||||
int (*rsa_sign)(int, const unsigned char *, unsigned int,
|
||||
unsigned char *, unsigned int *, const RSA *);
|
||||
int (*rsa_verify)(int, const unsigned char *, unsigned int,
|
||||
unsigned char *, unsigned int, const RSA *);
|
||||
int (*rsa_keygen)(RSA *, int, BIGNUM *, BN_GENCB *);
|
||||
};
|
||||
|
||||
struct RSA {
|
||||
int pad;
|
||||
long version;
|
||||
const RSA_METHOD *meth;
|
||||
void *engine;
|
||||
BIGNUM *n;
|
||||
BIGNUM *e;
|
||||
BIGNUM *d;
|
||||
BIGNUM *p;
|
||||
BIGNUM *q;
|
||||
BIGNUM *dmp1;
|
||||
BIGNUM *dmq1;
|
||||
BIGNUM *iqmp;
|
||||
struct rsa_CRYPTO_EX_DATA {
|
||||
void *sk;
|
||||
int dummy;
|
||||
} ex_data;
|
||||
int references;
|
||||
int flags;
|
||||
void *_method_mod_n;
|
||||
void *_method_mod_p;
|
||||
void *_method_mod_q;
|
||||
|
||||
char *bignum_data;
|
||||
void *blinding;
|
||||
void *mt_blinding;
|
||||
};
|
||||
|
||||
#define RSA_FLAG_SIGN_VER 0x40
|
||||
|
||||
#define RSA_PKCS1_PADDING 1
|
||||
#define RSA_PKCS1_PADDING_SIZE 11
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
const RSA_METHOD *RSA_null_method(void);
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
RSA * RSA_new(void);
|
||||
RSA * RSA_new_method(ENGINE *);
|
||||
void RSA_free(RSA *);
|
||||
int RSA_up_ref(RSA *);
|
||||
|
||||
void RSA_set_default_method(const RSA_METHOD *);
|
||||
const RSA_METHOD * RSA_get_default_method(void);
|
||||
|
||||
const RSA_METHOD * RSA_get_method(const RSA *);
|
||||
int RSA_set_method(RSA *, const RSA_METHOD *);
|
||||
|
||||
int RSA_set_app_data(RSA *, void *arg);
|
||||
void * RSA_get_app_data(RSA *);
|
||||
|
||||
int RSA_check_key(const RSA *);
|
||||
int RSA_size(const RSA *);
|
||||
|
||||
int RSA_public_encrypt(int,const unsigned char*,unsigned char*,RSA *,int);
|
||||
int RSA_private_encrypt(int,const unsigned char*,unsigned char*,RSA *,int);
|
||||
int RSA_public_decrypt(int,const unsigned char*,unsigned char*,RSA *,int);
|
||||
int RSA_private_decrypt(int,const unsigned char*,unsigned char*,RSA *,int);
|
||||
|
||||
int RSA_sign(int, const unsigned char *, unsigned int,
|
||||
unsigned char *, unsigned int *, RSA *);
|
||||
int RSA_verify(int, const unsigned char *, unsigned int,
|
||||
unsigned char *, unsigned int, RSA *);
|
||||
|
||||
RSA * d2i_RSAPrivateKey(RSA *, const unsigned char **, size_t);
|
||||
|
||||
#endif /* _HEIM_RSA_H */
|
||||
@@ -36,6 +36,17 @@
|
||||
#ifndef HEIM_SHA_H
|
||||
#define HEIM_SHA_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define SHA1_Init hc_SHA1_Init
|
||||
#define SHA1_Update hc_SHA1_Update
|
||||
#define SHA1_Final hc_SHA1_Final
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
#define SHA_DIGEST_LENGTH 20
|
||||
|
||||
struct sha {
|
||||
unsigned int sz[2];
|
||||
u_int32_t counter[5];
|
||||
|
||||
207
lib/des/test_bn.c
Normal file
207
lib/des/test_bn.c
Normal file
@@ -0,0 +1,207 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#ifdef RCSID
|
||||
RCSID("$Id$");
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <bn.h>
|
||||
|
||||
static int
|
||||
set_get(unsigned long num)
|
||||
{
|
||||
BIGNUM *bn;
|
||||
|
||||
bn = BN_new();
|
||||
if (!BN_set_word(bn, num))
|
||||
return 1;
|
||||
|
||||
if (BN_get_word(bn) != num)
|
||||
return 1;
|
||||
|
||||
BN_free(bn);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define CHECK(x) do { ret += x; } while(0)
|
||||
|
||||
static int
|
||||
test_BN_set_get(void)
|
||||
{
|
||||
int ret = 0;
|
||||
CHECK(set_get(0));
|
||||
CHECK(set_get(1));
|
||||
CHECK(set_get(0xff));
|
||||
CHECK(set_get(0x1ff));
|
||||
CHECK(set_get(0xffff));
|
||||
CHECK(set_get(0xf000));
|
||||
CHECK(set_get(ULONG_MAX / 2));
|
||||
CHECK(set_get(ULONG_MAX - 1));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
test_BN_bit(void)
|
||||
{
|
||||
BIGNUM *bn;
|
||||
int ret = 0;
|
||||
|
||||
bn = BN_new();
|
||||
|
||||
/* test setting and getting of "word" */
|
||||
if (!BN_set_word(bn, 1))
|
||||
return 1;
|
||||
if (!BN_is_bit_set(bn, 0))
|
||||
ret += 1;
|
||||
if (!BN_is_bit_set(bn, 0))
|
||||
ret += 1;
|
||||
|
||||
if (!BN_set_word(bn, 2))
|
||||
return 1;
|
||||
if (!BN_is_bit_set(bn, 1))
|
||||
ret += 1;
|
||||
|
||||
if (!BN_set_word(bn, 3))
|
||||
return 1;
|
||||
if (!BN_is_bit_set(bn, 0))
|
||||
ret += 1;
|
||||
if (!BN_is_bit_set(bn, 1))
|
||||
ret += 1;
|
||||
|
||||
if (!BN_set_word(bn, 0x100))
|
||||
return 1;
|
||||
if (!BN_is_bit_set(bn, 8))
|
||||
ret += 1;
|
||||
|
||||
if (!BN_set_word(bn, 0x1000))
|
||||
return 1;
|
||||
if (!BN_is_bit_set(bn, 12))
|
||||
ret += 1;
|
||||
|
||||
/* test bitsetting */
|
||||
if (!BN_set_word(bn, 1))
|
||||
return 1;
|
||||
if (!BN_set_bit(bn, 1))
|
||||
return 1;
|
||||
if (BN_get_word(bn) != 3)
|
||||
return 1;
|
||||
if (!BN_clear_bit(bn, 0))
|
||||
return 1;
|
||||
if (BN_get_word(bn) != 2)
|
||||
return 1;
|
||||
|
||||
/* test bitsetting past end of current end */
|
||||
BN_clear(bn);
|
||||
if (!BN_set_bit(bn, 12))
|
||||
return 1;
|
||||
if (BN_get_word(bn) != 0x1000)
|
||||
return 1;
|
||||
|
||||
/* test bit and byte counting functions */
|
||||
if (BN_num_bits(bn) != 13)
|
||||
return 1;
|
||||
if (BN_num_bytes(bn) != 2)
|
||||
return 1;
|
||||
|
||||
BN_free(bn);
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct ietest {
|
||||
char *data;
|
||||
size_t len;
|
||||
unsigned long num;
|
||||
} ietests[] = {
|
||||
{ "", 0, 0 },
|
||||
{ "\x01", 1, 1 },
|
||||
{ "\x02", 1, 2 },
|
||||
{ "\xf2", 1, 0xf2 },
|
||||
{ "\x01\x00", 2, 256 }
|
||||
};
|
||||
|
||||
static int
|
||||
test_BN_import_export(void)
|
||||
{
|
||||
BIGNUM *bn;
|
||||
int ret = 0;
|
||||
int i;
|
||||
|
||||
bn = BN_new();
|
||||
|
||||
for (i = 0; i < sizeof(ietests)/sizeof(ietests[0]); i++) {
|
||||
size_t len;
|
||||
unsigned char *p;
|
||||
if (!BN_bin2bn((unsigned char*)ietests[i].data, ietests[i].len, bn))
|
||||
return 1;
|
||||
if (BN_get_word(bn) != ietests[i].num)
|
||||
return 1;
|
||||
len = BN_num_bytes(bn);
|
||||
if (len != ietests[i].len)
|
||||
return 1;
|
||||
p = malloc(len + 1);
|
||||
p[len] = 0xf4;
|
||||
BN_bn2bin(bn, p);
|
||||
if (p[len] != 0xf4)
|
||||
return 1;
|
||||
if (memcmp(p, ietests[i].data, ietests[i].len) != 0)
|
||||
return 1;
|
||||
free(p);
|
||||
}
|
||||
|
||||
BN_free(bn);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
ret += test_BN_set_get();
|
||||
ret += test_BN_bit();
|
||||
ret += test_BN_import_export();
|
||||
|
||||
return ret;
|
||||
}
|
||||
109
lib/des/test_engine_dso.c
Normal file
109
lib/des/test_engine_dso.c
Normal file
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
* Copyright (c) 2006 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#ifdef RCSID
|
||||
RCSID("$Id$");
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <roken.h>
|
||||
#include <getarg.h>
|
||||
|
||||
#include <engine.h>
|
||||
|
||||
static int version_flag = 0;
|
||||
static int help_flag = 0;
|
||||
static char *id_flag = 0;
|
||||
|
||||
static struct getargs args[] = {
|
||||
{ "id", 0, arg_string, &id_flag,
|
||||
"id", NULL },
|
||||
{ "version", 0, arg_flag, &version_flag,
|
||||
"print version", NULL },
|
||||
{ "help", 0, arg_flag, &help_flag,
|
||||
NULL, NULL }
|
||||
};
|
||||
|
||||
static void
|
||||
usage (int ret)
|
||||
{
|
||||
arg_printusage (args,
|
||||
sizeof(args)/sizeof(*args),
|
||||
NULL,
|
||||
"filename.so");
|
||||
exit (ret);
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
ENGINE *engine;
|
||||
int idx = 0;
|
||||
|
||||
setprogname(argv[0]);
|
||||
|
||||
if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &idx))
|
||||
usage(1);
|
||||
|
||||
if (help_flag)
|
||||
usage(0);
|
||||
|
||||
if(version_flag){
|
||||
print_version(NULL);
|
||||
exit(0);
|
||||
}
|
||||
|
||||
argc -= idx;
|
||||
argv += idx;
|
||||
|
||||
if (argc == 0)
|
||||
usage(1);
|
||||
|
||||
engine = ENGINE_by_dso(argv[0], id_flag);
|
||||
if (engine == NULL)
|
||||
errx(1, "ENGINE_by_dso failed");
|
||||
|
||||
printf("name: %s\n", ENGINE_get_name(engine));
|
||||
printf("id: %s\n", ENGINE_get_id(engine));
|
||||
printf("RSA: %s\n", ENGINE_get_RSA(engine) ? "yes" : "no");
|
||||
printf("DH: %s\n", ENGINE_get_DH(engine) ? "yes" : "no");
|
||||
|
||||
ENGINE_finish(engine);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -43,7 +43,7 @@ RCSID("$Id$");
|
||||
#include <termios.h>
|
||||
#include <roken.h>
|
||||
|
||||
#include <des.h>
|
||||
#include <ui.h>
|
||||
|
||||
static sig_atomic_t intr_flag;
|
||||
|
||||
|
||||
45
lib/des/ui.h
Normal file
45
lib/des/ui.h
Normal file
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* Copyright (c) 2005 Kungliga Tekniska H<>gskolan
|
||||
* (Royal Institute of Technology, Stockholm, Sweden).
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the Institute nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
#ifndef _HEIM_UI_H
|
||||
#define _HEIM_UI_H 1
|
||||
|
||||
/* symbol renaming */
|
||||
#define UI_UTIL_read_pw_string hc_UI_UTIL_read_pw_string
|
||||
|
||||
int UI_UTIL_read_pw_string(char *, int, const char *, int); /* XXX */
|
||||
|
||||
#endif /* _HEIM_UI_H */
|
||||
|
||||
Reference in New Issue
Block a user