Minix/pkgsrc-ng
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Import of pkgsrc-2015Q3

Browse Source
This commit is contained in:
Lionel Sambuc
2015-10-03 03:37:01 -07:00
committed by Lionel Sambuc
parent f641581404
commit 9d819b6d54
7578 changed files with 228314 additions and 80018 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
security/netpgpverify/Makefile
View File

@@ -1,6 +1,6 @@
# $NetBSD: Makefile,v 1.13 2015/02/05 00:21:57 agc Exp $
# $NetBSD: Makefile,v 1.16 2015/09/12 02:19:06 agc Exp $
DISTNAME= netpgpverify-20150205
DISTNAME= netpgpverify-20150911
CATEGORIES= security
MASTER_SITES= # empty
DISTFILES= # empty
@@ -13,6 +13,8 @@ LICENSE= modified-bsd
AUTO_MKDIRS= yes
GNU_CONFIGURE= yes
TEST_TARGET= tst
do-extract:
@${CP} -R ${FILESDIR} ${WRKSRC}

21
security/netpgpverify/files/Makefile.in
View File

@@ -1,4 +1,4 @@
# $NetBSD: Makefile.in,v 1.3 2014/03/05 04:51:37 agc Exp $
# $NetBSD: Makefile.in,v 1.4 2015/08/17 11:37:55 jperkin Exp $
PROG=netpgpverify
@@ -26,8 +26,23 @@ tst:
./${PROG} -k pubring.gpg NetBSD-6.0_RC1_hashes.asc
./${PROG} -k pubring.gpg NetBSD-6.0_RC1_hashes.gpg
./${PROG} -v
./${PROG} -S testkey.pub data.gpg
./${PROG} -S testkey.pub data.sig
./${PROG} -S sshtest-20140202.pub data.gpg
./${PROG} -S sshtest-20140202.pub data.sig
@echo "expected failure, to check bad signatures fail to verify"
-sed -e 's|A|B|' data.gpg | ./${PROG} -S sshtest-20140202.pub
@echo ""
@echo "expected failure, no valid key for verification"
-./${PROG} -k /dev/null NetBSD-6.0_RC1_hashes.gpg
@echo "dumping now"
./${PROG} -c dump -k pubring.gpg NetBSD-6.0_RC1_hashes.asc > /dev/null
@echo "dumping ssh now"
./${PROG} -c dump -S sshtest-20140202.pub data.gpg
@echo "testing pubring with one key"
uudecode 1keytest.gpg.uu
./${PROG} -k 1keypubring.gpg 1keytest.gpg
rm -f 1keytest.gpg
@echo "testing signing with a subkey"
./chk.sh -k joyent-pubring.gpg digest-20121220.tgz
clean:
rm -rf *.core ${OBJS} ${PROG}

245
security/netpgpverify/files/bignum.c
View File

@@ -45,6 +45,7 @@
# include <sys/kmem.h>
#else
# include <arpa/inet.h>
# include <limits.h>
# include <stdarg.h>
# include <stdio.h>
# include <stdlib.h>
@@ -88,6 +89,10 @@
#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
#endif
#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif
#define MP_ISZERO(a) (((a)->used == 0) ? MP_YES : MP_NO)
typedef int mp_err;
@@ -216,7 +221,7 @@ trim_unused_digits(mp_int * a)
/* copy, b = a */
static int
mp_copy(BIGNUM *a, BIGNUM *b)
mp_copy(PGPV_BIGNUM *a, PGPV_BIGNUM *b)
{
int res;
@@ -1333,13 +1338,13 @@ fast_modular_inverse(mp_int * a, mp_int * b, mp_int * c)
top:
/* 4. while u is even do */
while (BN_is_even(&u) == 1) {
while (PGPV_BN_is_even(&u) == 1) {
/* 4.1 u = u/2 */
if ((res = half(&u, &u)) != MP_OKAY) {
goto LBL_ERR;
}
/* 4.2 if B is odd then */
if (BN_is_odd(&B) == 1) {
if (PGPV_BN_is_odd(&B) == 1) {
if ((res = signed_subtract(&B, &x, &B)) != MP_OKAY) {
goto LBL_ERR;
}
@@ -1351,13 +1356,13 @@ top:
}
/* 5. while v is even do */
while (BN_is_even(&v) == 1) {
while (PGPV_BN_is_even(&v) == 1) {
/* 5.1 v = v/2 */
if ((res = half(&v, &v)) != MP_OKAY) {
goto LBL_ERR;
}
/* 5.2 if D is odd then */
if (BN_is_odd(&D) == 1) {
if (PGPV_BN_is_odd(&D) == 1) {
/* D = (D-x)/2 */
if ((res = signed_subtract(&D, &x, &D)) != MP_OKAY) {
goto LBL_ERR;
@@ -1446,7 +1451,7 @@ slow_modular_inverse(mp_int * a, mp_int * b, mp_int * c)
}
/* 2. [modified] if x,y are both even then return an error! */
if (BN_is_even(&x) == 1 && BN_is_even(&y) == 1) {
if (PGPV_BN_is_even(&x) == 1 && PGPV_BN_is_even(&y) == 1) {
res = MP_VAL;
goto LBL_ERR;
}
@@ -1463,13 +1468,13 @@ slow_modular_inverse(mp_int * a, mp_int * b, mp_int * c)
top:
/* 4. while u is even do */
while (BN_is_even(&u) == 1) {
while (PGPV_BN_is_even(&u) == 1) {
/* 4.1 u = u/2 */
if ((res = half(&u, &u)) != MP_OKAY) {
goto LBL_ERR;
}
/* 4.2 if A or B is odd then */
if (BN_is_odd(&A) == 1 || BN_is_odd(&B) == 1) {
if (PGPV_BN_is_odd(&A) == 1 || PGPV_BN_is_odd(&B) == 1) {
/* A = (A+y)/2, B = (B-x)/2 */
if ((res = signed_add(&A, &y, &A)) != MP_OKAY) {
goto LBL_ERR;
@@ -1488,13 +1493,13 @@ top:
}
/* 5. while v is even do */
while (BN_is_even(&v) == 1) {
while (PGPV_BN_is_even(&v) == 1) {
/* 5.1 v = v/2 */
if ((res = half(&v, &v)) != MP_OKAY) {
goto LBL_ERR;
}
/* 5.2 if C or D is odd then */
if (BN_is_odd(&C) == 1 || BN_is_odd(&D) == 1) {
if (PGPV_BN_is_odd(&C) == 1 || PGPV_BN_is_odd(&D) == 1) {
/* C = (C+y)/2, D = (D-x)/2 */
if ((res = signed_add(&C, &y, &C)) != MP_OKAY) {
goto LBL_ERR;
@@ -1542,7 +1547,7 @@ top:
}
/* if not zero goto step 4 */
if (BN_is_zero(&u) == 0) {
if (PGPV_BN_is_zero(&u) == 0) {
goto top;
}
/* now a = C, b = D, gcd == g*v */
@@ -1584,7 +1589,7 @@ modular_inverse(mp_int *c, mp_int *a, mp_int *b)
}
/* if the modulus is odd we can use a faster routine instead */
if (BN_is_odd(b) == 1) {
if (PGPV_BN_is_odd(b) == 1) {
return fast_modular_inverse(a, b, c);
}
return slow_modular_inverse(a, b, c);
@@ -4351,7 +4356,7 @@ exponent_modulo(mp_int * G, mp_int * X, mp_int * P, mp_int *Y)
}
/* if the modulus is odd or diminished_radix, use the montgomery method */
if (BN_is_odd(P) == 1 || diminished_radix) {
if (PGPV_BN_is_odd(P) == 1 || diminished_radix) {
return fast_exponent_modulo(G, X, P, Y, diminished_radix);
}
/* otherwise use the generic Barrett reduction technique */
@@ -5019,7 +5024,7 @@ mp_toradix_n(mp_int * a, char *str, int radix, int maxlen)
}
static char *
formatbn(const BIGNUM *a, const int radix)
formatbn(const PGPV_BIGNUM *a, const int radix)
{
char *s;
int len;
@@ -5081,11 +5086,11 @@ mp_getradix_num(mp_int *a, int radix, char *s)
}
static int
getbn(BIGNUM **a, const char *str, int radix)
getbn(PGPV_BIGNUM **a, const char *str, int radix)
{
int len;
if (a == NULL || str == NULL || (*a = BN_new()) == NULL) {
if (a == NULL || str == NULL || (*a = PGPV_BN_new()) == NULL) {
return 0;
}
if (mp_getradix_num(*a, radix, __UNCONST(str)) != MP_OKAY) {
@@ -5118,30 +5123,30 @@ subtract_modulo(mp_int *a, mp_int *b, mp_int *c, mp_int *d)
/**************************************************************************/
/* BIGNUM emulation layer */
/* PGPV_BIGNUM emulation layer */
/* essentiually, these are just wrappers around the libtommath functions */
/* usually the order of args changes */
/* the BIGNUM API tends to have more const poisoning */
/* the PGPV_BIGNUM API tends to have more const poisoning */
/* these wrappers also check the arguments passed for sanity */
BIGNUM *
BN_bin2bn(const uint8_t *data, int len, BIGNUM *ret)
PGPV_BIGNUM *
PGPV_BN_bin2bn(const uint8_t *data, int len, PGPV_BIGNUM *ret)
{
if (data == NULL) {
return BN_new();
return PGPV_BN_new();
}
if (ret == NULL) {
ret = BN_new();
ret = PGPV_BN_new();
}
return (mp_read_unsigned_bin(ret, data, len) == MP_OKAY) ? ret : NULL;
}
/* store in unsigned [big endian] format */
int
BN_bn2bin(const BIGNUM *a, unsigned char *b)
PGPV_BN_bn2bin(const PGPV_BIGNUM *a, unsigned char *b)
{
BIGNUM t;
PGPV_BIGNUM t;
int x;
if (a == NULL || b == NULL) {
@@ -5150,7 +5155,7 @@ BN_bn2bin(const BIGNUM *a, unsigned char *b)
if (mp_init_copy (&t, __UNCONST(a)) != MP_OKAY) {
return -1;
}
for (x = 0; !BN_is_zero(&t) ; ) {
for (x = 0; !PGPV_BN_is_zero(&t) ; ) {
b[x++] = (unsigned char) (t.dp[0] & 0xff);
if (rshift_bits(&t, 8, &t, NULL) != MP_OKAY) {
mp_clear(&t);
@@ -5163,17 +5168,17 @@ BN_bn2bin(const BIGNUM *a, unsigned char *b)
}
void
BN_init(BIGNUM *a)
PGPV_BN_init(PGPV_BIGNUM *a)
{
if (a != NULL) {
mp_init(a);
}
}
BIGNUM *
BN_new(void)
PGPV_BIGNUM *
PGPV_BN_new(void)
{
BIGNUM *a;
PGPV_BIGNUM *a;
if ((a = allocate(1, sizeof(*a))) != NULL) {
mp_init(a);
@@ -5183,7 +5188,7 @@ BN_new(void)
/* copy, b = a */
int
BN_copy(BIGNUM *b, const BIGNUM *a)
PGPV_BN_copy(PGPV_BIGNUM *b, const PGPV_BIGNUM *a)
{
if (a == NULL || b == NULL) {
return MP_VAL;
@@ -5191,22 +5196,22 @@ BN_copy(BIGNUM *b, const BIGNUM *a)
return mp_copy(__UNCONST(a), b);
}
BIGNUM *
BN_dup(const BIGNUM *a)
PGPV_BIGNUM *
PGPV_BN_dup(const PGPV_BIGNUM *a)
{
BIGNUM *ret;
PGPV_BIGNUM *ret;
if (a == NULL) {
return NULL;
}
if ((ret = BN_new()) != NULL) {
BN_copy(ret, a);
if ((ret = PGPV_BN_new()) != NULL) {
PGPV_BN_copy(ret, a);
}
return ret;
}
void
BN_swap(BIGNUM *a, BIGNUM *b)
PGPV_BN_swap(PGPV_BIGNUM *a, PGPV_BIGNUM *b)
{
if (a && b) {
mp_exch(a, b);
@@ -5214,47 +5219,47 @@ BN_swap(BIGNUM *a, BIGNUM *b)
}
int
BN_lshift(BIGNUM *r, const BIGNUM *a, int n)
PGPV_BN_lshift(PGPV_BIGNUM *r, const PGPV_BIGNUM *a, int n)
{
if (r == NULL || a == NULL || n < 0) {
return 0;
}
BN_copy(r, a);
PGPV_BN_copy(r, a);
return lshift_digits(r, n) == MP_OKAY;
}
int
BN_lshift1(BIGNUM *r, BIGNUM *a)
PGPV_BN_lshift1(PGPV_BIGNUM *r, PGPV_BIGNUM *a)
{
if (r == NULL || a == NULL) {
return 0;
}
BN_copy(r, a);
PGPV_BN_copy(r, a);
return lshift_digits(r, 1) == MP_OKAY;
}
int
BN_rshift(BIGNUM *r, const BIGNUM *a, int n)
PGPV_BN_rshift(PGPV_BIGNUM *r, const PGPV_BIGNUM *a, int n)
{
if (r == NULL || a == NULL || n < 0) {
return MP_VAL;
}
BN_copy(r, a);
PGPV_BN_copy(r, a);
return rshift_digits(r, n) == MP_OKAY;
}
int
BN_rshift1(BIGNUM *r, BIGNUM *a)
PGPV_BN_rshift1(PGPV_BIGNUM *r, PGPV_BIGNUM *a)
{
if (r == NULL || a == NULL) {
return 0;
}
BN_copy(r, a);
PGPV_BN_copy(r, a);
return rshift_digits(r, 1) == MP_OKAY;
}
int
BN_set_word(BIGNUM *a, BN_ULONG w)
PGPV_BN_set_word(PGPV_BIGNUM *a, PGPV_BN_ULONG w)
{
if (a == NULL) {
return 0;
@@ -5264,7 +5269,7 @@ BN_set_word(BIGNUM *a, BN_ULONG w)
}
int
BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
PGPV_BN_add(PGPV_BIGNUM *r, const PGPV_BIGNUM *a, const PGPV_BIGNUM *b)
{
if (a == NULL || b == NULL || r == NULL) {
return 0;
@@ -5273,7 +5278,7 @@ BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
}
int
BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
PGPV_BN_sub(PGPV_BIGNUM *r, const PGPV_BIGNUM *a, const PGPV_BIGNUM *b)
{
if (a == NULL || b == NULL || r == NULL) {
return 0;
@@ -5282,7 +5287,7 @@ BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
}
int
BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
PGPV_BN_mul(PGPV_BIGNUM *r, const PGPV_BIGNUM *a, const PGPV_BIGNUM *b, PGPV_BN_CTX *ctx)
{
if (a == NULL || b == NULL || r == NULL) {
return 0;
@@ -5292,7 +5297,7 @@ BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
}
int
BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d, BN_CTX *ctx)
PGPV_BN_div(PGPV_BIGNUM *dv, PGPV_BIGNUM *rem, const PGPV_BIGNUM *a, const PGPV_BIGNUM *d, PGPV_BN_CTX *ctx)
{
if ((dv == NULL && rem == NULL) || a == NULL || d == NULL) {
return 0;
@@ -5303,7 +5308,7 @@ BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d, BN_CTX *ctx)
/* perform a bit operation on the 2 bignums */
int
BN_bitop(BIGNUM *r, const BIGNUM *a, char op, const BIGNUM *b)
PGPV_BN_bitop(PGPV_BIGNUM *r, const PGPV_BIGNUM *a, char op, const PGPV_BIGNUM *b)
{
unsigned ndigits;
mp_digit ad;
@@ -5313,11 +5318,11 @@ BN_bitop(BIGNUM *r, const BIGNUM *a, char op, const BIGNUM *b)
if (a == NULL || b == NULL || r == NULL) {
return 0;
}
if (BN_cmp(__UNCONST(a), __UNCONST(b)) >= 0) {
BN_copy(r, a);
if (PGPV_BN_cmp(__UNCONST(a), __UNCONST(b)) >= 0) {
PGPV_BN_copy(r, a);
ndigits = a->used;
} else {
BN_copy(r, b);
PGPV_BN_copy(r, b);
ndigits = b->used;
}
for (i = 0 ; i < (int)ndigits ; i++) {
@@ -5341,7 +5346,7 @@ BN_bitop(BIGNUM *r, const BIGNUM *a, char op, const BIGNUM *b)
}
void
BN_free(BIGNUM *a)
PGPV_BN_free(PGPV_BIGNUM *a)
{
if (a) {
mp_clear(a);
@@ -5349,7 +5354,7 @@ BN_free(BIGNUM *a)
}
void
BN_clear(BIGNUM *a)
PGPV_BN_clear(PGPV_BIGNUM *a)
{
if (a) {
mp_clear(a);
@@ -5357,7 +5362,7 @@ BN_clear(BIGNUM *a)
}
void
BN_clear_free(BIGNUM *a)
PGPV_BN_clear_free(PGPV_BIGNUM *a)
{
if (a) {
mp_clear(a);
@@ -5365,7 +5370,7 @@ BN_clear_free(BIGNUM *a)
}
int
BN_num_bytes(const BIGNUM *a)
PGPV_BN_num_bytes(const PGPV_BIGNUM *a)
{
if (a == NULL) {
return MP_VAL;
@@ -5374,7 +5379,7 @@ BN_num_bytes(const BIGNUM *a)
}
int
BN_num_bits(const BIGNUM *a)
PGPV_BN_num_bits(const PGPV_BIGNUM *a)
{
if (a == NULL) {
return 0;
@@ -5383,7 +5388,7 @@ BN_num_bits(const BIGNUM *a)
}
void
BN_set_negative(BIGNUM *a, int n)
PGPV_BN_set_negative(PGPV_BIGNUM *a, int n)
{
if (a) {
a->sign = (n) ? MP_NEG : 0;
@@ -5391,7 +5396,7 @@ BN_set_negative(BIGNUM *a, int n)
}
int
BN_cmp(BIGNUM *a, BIGNUM *b)
PGPV_BN_cmp(PGPV_BIGNUM *a, PGPV_BIGNUM *b)
{
if (a == NULL || b == NULL) {
return MP_VAL;
@@ -5408,7 +5413,7 @@ BN_cmp(BIGNUM *a, BIGNUM *b)
}
int
BN_mod_exp(BIGNUM *Y, BIGNUM *G, BIGNUM *X, BIGNUM *P, BN_CTX *ctx)
PGPV_BN_mod_exp(PGPV_BIGNUM *Y, PGPV_BIGNUM *G, PGPV_BIGNUM *X, PGPV_BIGNUM *P, PGPV_BN_CTX *ctx)
{
if (Y == NULL || G == NULL || X == NULL || P == NULL) {
return MP_VAL;
@@ -5417,8 +5422,8 @@ BN_mod_exp(BIGNUM *Y, BIGNUM *G, BIGNUM *X, BIGNUM *P, BN_CTX *ctx)
return exponent_modulo(G, X, P, Y) == MP_OKAY;
}
BIGNUM *
BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
PGPV_BIGNUM *
PGPV_BN_mod_inverse(PGPV_BIGNUM *r, PGPV_BIGNUM *a, const PGPV_BIGNUM *n, PGPV_BN_CTX *ctx)
{
USE_ARG(ctx);
if (r == NULL || a == NULL || n == NULL) {
@@ -5428,7 +5433,7 @@ BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
}
int
BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
PGPV_BN_mod_mul(PGPV_BIGNUM *ret, PGPV_BIGNUM *a, PGPV_BIGNUM *b, const PGPV_BIGNUM *m, PGPV_BN_CTX *ctx)
{
USE_ARG(ctx);
if (ret == NULL || a == NULL || b == NULL || m == NULL) {
@@ -5437,14 +5442,14 @@ BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
return multiply_modulo(ret, a, b, __UNCONST(m)) == MP_OKAY;
}
BN_CTX *
BN_CTX_new(void)
PGPV_BN_CTX *
PGPV_BN_CTX_new(void)
{
return allocate(1, sizeof(BN_CTX));
return allocate(1, sizeof(PGPV_BN_CTX));
}
void
BN_CTX_init(BN_CTX *c)
PGPV_BN_CTX_init(PGPV_BN_CTX *c)
{
if (c != NULL) {
c->arraysize = 15;
@@ -5454,61 +5459,61 @@ BN_CTX_init(BN_CTX *c)
}
}
BIGNUM *
BN_CTX_get(BN_CTX *ctx)
PGPV_BIGNUM *
PGPV_BN_CTX_get(PGPV_BN_CTX *ctx)
{
if (ctx == NULL || ctx->v == NULL || ctx->arraysize == 0 || ctx->count == ctx->arraysize - 1) {
return NULL;
}
return ctx->v[ctx->count++] = BN_new();
return ctx->v[ctx->count++] = PGPV_BN_new();
}
void
BN_CTX_start(BN_CTX *ctx)
PGPV_BN_CTX_start(PGPV_BN_CTX *ctx)
{
BN_CTX_init(ctx);
PGPV_BN_CTX_init(ctx);
}
void
BN_CTX_free(BN_CTX *c)
PGPV_BN_CTX_free(PGPV_BN_CTX *c)
{
unsigned i;
if (c != NULL && c->v != NULL) {
for (i = 0 ; i < c->count ; i++) {
BN_clear_free(c->v[i]);
PGPV_BN_clear_free(c->v[i]);
}
deallocate(c->v, sizeof(*c->v) * c->arraysize);
}
}
void
BN_CTX_end(BN_CTX *ctx)
PGPV_BN_CTX_end(PGPV_BN_CTX *ctx)
{
BN_CTX_free(ctx);
PGPV_BN_CTX_free(ctx);
}
char *
BN_bn2hex(const BIGNUM *a)
PGPV_BN_bn2hex(const PGPV_BIGNUM *a)
{
return (a == NULL) ? NULL : formatbn(a, 16);
}
char *
BN_bn2dec(const BIGNUM *a)
PGPV_BN_bn2dec(const PGPV_BIGNUM *a)
{
return (a == NULL) ? NULL : formatbn(a, 10);
}
char *
BN_bn2radix(const BIGNUM *a, unsigned radix)
PGPV_BN_bn2radix(const PGPV_BIGNUM *a, unsigned radix)
{
return (a == NULL) ? NULL : formatbn(a, (int)radix);
}
#ifndef _KERNEL
int
BN_print_fp(FILE *fp, const BIGNUM *a)
PGPV_BN_print_fp(FILE *fp, const PGPV_BIGNUM *a)
{
char *s;
int ret;
@@ -5516,16 +5521,16 @@ BN_print_fp(FILE *fp, const BIGNUM *a)
if (fp == NULL || a == NULL) {
return 0;
}
s = BN_bn2hex(a);
s = PGPV_BN_bn2hex(a);
ret = fprintf(fp, "%s", s);
deallocate(s, strlen(s) + 1);
return ret;
}
#endif
#ifdef BN_RAND_NEEDED
#ifdef PGPV_BN_RAND_NEEDED
int
BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
PGPV_BN_rand(PGPV_BIGNUM *rnd, int bits, int top, int bottom)
{
uint64_t r;
int digits;
@@ -5555,18 +5560,18 @@ BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
}
int
BN_rand_range(BIGNUM *rnd, BIGNUM *range)
PGPV_BN_rand_range(PGPV_BIGNUM *rnd, PGPV_BIGNUM *range)
{
if (rnd == NULL || range == NULL || BN_is_zero(range)) {
if (rnd == NULL || range == NULL || PGPV_BN_is_zero(range)) {
return 0;
}
BN_rand(rnd, BN_num_bits(range), 1, 0);
PGPV_BN_rand(rnd, PGPV_BN_num_bits(range), 1, 0);
return modulo(rnd, range, rnd) == MP_OKAY;
}
#endif
int
BN_is_prime(const BIGNUM *a, int checks, void (*callback)(int, int, void *), BN_CTX *ctx, void *cb_arg)
PGPV_BN_is_prime(const PGPV_BIGNUM *a, int checks, void (*callback)(int, int, void *), PGPV_BN_CTX *ctx, void *cb_arg)
{
int primality;
@@ -5579,35 +5584,35 @@ BN_is_prime(const BIGNUM *a, int checks, void (*callback)(int, int, void *), BN_
return (mp_prime_is_prime(__UNCONST(a), checks, &primality) == MP_OKAY) ? primality : 0;
}
const BIGNUM *
BN_value_one(void)
const PGPV_BIGNUM *
PGPV_BN_value_one(void)
{
static mp_digit digit = 1UL;
static const BIGNUM one = { &digit, 1, 1, 0 };
static const PGPV_BIGNUM one = { &digit, 1, 1, 0 };
return &one;
}
int
BN_hex2bn(BIGNUM **a, const char *str)
PGPV_BN_hex2bn(PGPV_BIGNUM **a, const char *str)
{
return getbn(a, str, 16);
}
int
BN_dec2bn(BIGNUM **a, const char *str)
PGPV_BN_dec2bn(PGPV_BIGNUM **a, const char *str)
{
return getbn(a, str, 10);
}
int
BN_radix2bn(BIGNUM **a, const char *str, unsigned radix)
PGPV_BN_radix2bn(PGPV_BIGNUM **a, const char *str, unsigned radix)
{
return getbn(a, str, (int)radix);
}
int
BN_mod_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
PGPV_BN_mod_sub(PGPV_BIGNUM *r, PGPV_BIGNUM *a, PGPV_BIGNUM *b, const PGPV_BIGNUM *m, PGPV_BN_CTX *ctx)
{
USE_ARG(ctx);
if (r == NULL || a == NULL || b == NULL || m == NULL) {
@@ -5617,7 +5622,7 @@ BN_mod_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
}
int
BN_is_bit_set(const BIGNUM *a, int n)
PGPV_BN_is_bit_set(const PGPV_BIGNUM *a, int n)
{
if (a == NULL || n < 0 || n >= a->used * DIGIT_BIT) {
return 0;
@@ -5627,52 +5632,52 @@ BN_is_bit_set(const BIGNUM *a, int n)
/* raise 'a' to power of 'b' */
int
BN_raise(BIGNUM *res, BIGNUM *a, BIGNUM *b)
PGPV_BN_raise(PGPV_BIGNUM *res, PGPV_BIGNUM *a, PGPV_BIGNUM *b)
{
uint64_t exponent;
BIGNUM *power;
BIGNUM *temp;
PGPV_BIGNUM *power;
PGPV_BIGNUM *temp;
char *t;
t = BN_bn2dec(b);
t = PGPV_BN_bn2dec(b);
exponent = (uint64_t)strtoull(t, NULL, 10);
free(t);
if (exponent == 0) {
BN_copy(res, BN_value_one());
PGPV_BN_copy(res, PGPV_BN_value_one());
} else {
power = BN_dup(a);
power = PGPV_BN_dup(a);
for ( ; (exponent & 1) == 0 ; exponent >>= 1) {
BN_mul(power, power, power, NULL);
PGPV_BN_mul(power, power, power, NULL);
}
temp = BN_dup(power);
temp = PGPV_BN_dup(power);
for (exponent >>= 1 ; exponent > 0 ; exponent >>= 1) {
BN_mul(power, power, power, NULL);
PGPV_BN_mul(power, power, power, NULL);
if (exponent & 1) {
BN_mul(temp, power, temp, NULL);
PGPV_BN_mul(temp, power, temp, NULL);
}
}
BN_copy(res, temp);
BN_free(power);
BN_free(temp);
PGPV_BN_copy(res, temp);
PGPV_BN_free(power);
PGPV_BN_free(temp);
}
return 1;
}
/* compute the factorial */
int
BN_factorial(BIGNUM *res, BIGNUM *f)
PGPV_BN_factorial(PGPV_BIGNUM *res, PGPV_BIGNUM *f)
{
BIGNUM *one;
BIGNUM *i;
PGPV_BIGNUM *one;
PGPV_BIGNUM *i;
i = BN_dup(f);
one = __UNCONST(BN_value_one());
BN_sub(i, i, one);
BN_copy(res, f);
while (BN_cmp(i, one) > 0) {
BN_mul(res, res, i, NULL);
BN_sub(i, i, one);
i = PGPV_BN_dup(f);
one = __UNCONST(PGPV_BN_value_one());
PGPV_BN_sub(i, i, one);
PGPV_BN_copy(res, f);
while (PGPV_BN_cmp(i, one) > 0) {
PGPV_BN_mul(res, res, i, NULL);
PGPV_BN_sub(i, i, one);
}
BN_free(i);
PGPV_BN_free(i);
return 1;
}

112
security/netpgpverify/files/bn.h
View File

@@ -56,15 +56,15 @@ typedef struct mp_int {
int sign; /* non-zero if negative */
} mp_int;
#define BIGNUM mp_int
#define BN_ULONG mp_digit
#define PGPV_BIGNUM mp_int
#define PGPV_BN_ULONG mp_digit
/* a "context" of mp integers - never really used */
typedef struct bn_ctx_t {
size_t count;
size_t arraysize;
BIGNUM **v;
} BN_CTX;
PGPV_BIGNUM **v;
} PGPV_BN_CTX;
#define MP_LT -1
#define MP_EQ 0
@@ -80,72 +80,72 @@ typedef struct bn_ctx_t {
/*********************************/
#define BN_is_negative(x) ((x)->sign == MP_NEG)
#define BN_is_zero(a) (((a)->used == 0) ? 1 : 0)
#define BN_is_odd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? 1 : 0)
#define BN_is_even(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? 1 : 0)
#define PGPV_BN_is_negative(x) ((x)->sign == MP_NEG)
#define PGPV_BN_is_zero(a) (((a)->used == 0) ? 1 : 0)
#define PGPV_BN_is_odd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? 1 : 0)
#define PGPV_BN_is_even(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? 1 : 0)
BIGNUM *BN_new(void);
BIGNUM *BN_dup(const BIGNUM */*a*/);
int BN_copy(BIGNUM */*b*/, const BIGNUM */*a*/);
PGPV_BIGNUM *PGPV_BN_new(void);
PGPV_BIGNUM *PGPV_BN_dup(const PGPV_BIGNUM */*a*/);
int PGPV_BN_copy(PGPV_BIGNUM */*b*/, const PGPV_BIGNUM */*a*/);
void BN_init(BIGNUM */*a*/);
void BN_free(BIGNUM */*a*/);
void BN_clear(BIGNUM */*a*/);
void BN_clear_free(BIGNUM */*a*/);
void PGPV_BN_init(PGPV_BIGNUM */*a*/);
void PGPV_BN_free(PGPV_BIGNUM */*a*/);
void PGPV_BN_clear(PGPV_BIGNUM */*a*/);
void PGPV_BN_clear_free(PGPV_BIGNUM */*a*/);
int BN_cmp(BIGNUM */*a*/, BIGNUM */*b*/);
int PGPV_BN_cmp(PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/);
BIGNUM *BN_bin2bn(const uint8_t */*buf*/, int /*size*/, BIGNUM */*bn*/);
int BN_bn2bin(const BIGNUM */*a*/, unsigned char */*b*/);
char *BN_bn2hex(const BIGNUM */*a*/);
char *BN_bn2dec(const BIGNUM */*a*/);
char *BN_bn2radix(const BIGNUM */*a*/, unsigned /*radix*/);
int BN_hex2bn(BIGNUM **/*a*/, const char */*str*/);
int BN_dec2bn(BIGNUM **/*a*/, const char */*str*/);
int BN_radix2bn(BIGNUM **/*a*/, const char */*str*/, unsigned /*radix*/);
PGPV_BIGNUM *PGPV_BN_bin2bn(const uint8_t */*buf*/, int /*size*/, PGPV_BIGNUM */*bn*/);
int PGPV_BN_bn2bin(const PGPV_BIGNUM */*a*/, unsigned char */*b*/);
char *PGPV_BN_bn2hex(const PGPV_BIGNUM */*a*/);
char *PGPV_BN_bn2dec(const PGPV_BIGNUM */*a*/);
char *PGPV_BN_bn2radix(const PGPV_BIGNUM */*a*/, unsigned /*radix*/);
int PGPV_BN_hex2bn(PGPV_BIGNUM **/*a*/, const char */*str*/);
int PGPV_BN_dec2bn(PGPV_BIGNUM **/*a*/, const char */*str*/);
int PGPV_BN_radix2bn(PGPV_BIGNUM **/*a*/, const char */*str*/, unsigned /*radix*/);
#ifndef _KERNEL
int BN_print_fp(FILE */*fp*/, const BIGNUM */*a*/);
int PGPV_BN_print_fp(FILE */*fp*/, const PGPV_BIGNUM */*a*/);
#endif
int BN_add(BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/);
int BN_sub(BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/);
int BN_mul(BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/, BN_CTX */*ctx*/);
int BN_div(BIGNUM */*q*/, BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/, BN_CTX */*ctx*/);
void BN_swap(BIGNUM */*a*/, BIGNUM */*b*/);
int BN_bitop(BIGNUM */*r*/, const BIGNUM */*a*/, char /*op*/, const BIGNUM */*b*/);
int BN_lshift(BIGNUM */*r*/, const BIGNUM */*a*/, int /*n*/);
int BN_lshift1(BIGNUM */*r*/, BIGNUM */*a*/);
int BN_rshift(BIGNUM */*r*/, const BIGNUM */*a*/, int /*n*/);
int BN_rshift1(BIGNUM */*r*/, BIGNUM */*a*/);
int BN_set_word(BIGNUM */*a*/, BN_ULONG /*w*/);
void BN_set_negative(BIGNUM */*a*/, int /*n*/);
int PGPV_BN_add(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/);
int PGPV_BN_sub(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/);
int PGPV_BN_mul(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/, PGPV_BN_CTX */*ctx*/);
int PGPV_BN_div(PGPV_BIGNUM */*q*/, PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/, PGPV_BN_CTX */*ctx*/);
void PGPV_BN_swap(PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/);
int PGPV_BN_bitop(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, char /*op*/, const PGPV_BIGNUM */*b*/);
int PGPV_BN_lshift(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, int /*n*/);
int PGPV_BN_lshift1(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/);
int PGPV_BN_rshift(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, int /*n*/);
int PGPV_BN_rshift1(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/);
int PGPV_BN_set_word(PGPV_BIGNUM */*a*/, PGPV_BN_ULONG /*w*/);
void PGPV_BN_set_negative(PGPV_BIGNUM */*a*/, int /*n*/);
int BN_num_bytes(const BIGNUM */*a*/);
int BN_num_bits(const BIGNUM */*a*/);
int PGPV_BN_num_bytes(const PGPV_BIGNUM */*a*/);
int PGPV_BN_num_bits(const PGPV_BIGNUM */*a*/);
int BN_mod_exp(BIGNUM */*r*/, BIGNUM */*a*/, BIGNUM */*p*/, BIGNUM */*m*/, BN_CTX */*ctx*/);
BIGNUM *BN_mod_inverse(BIGNUM */*ret*/, BIGNUM */*a*/, const BIGNUM */*n*/, BN_CTX */*ctx*/);
int BN_mod_mul(BIGNUM */*ret*/, BIGNUM */*a*/, BIGNUM */*b*/, const BIGNUM */*m*/, BN_CTX */*ctx*/);
int BN_mod_sub(BIGNUM */*r*/, BIGNUM */*a*/, BIGNUM */*b*/, const BIGNUM */*m*/, BN_CTX */*ctx*/);
int PGPV_BN_mod_exp(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*p*/, PGPV_BIGNUM */*m*/, PGPV_BN_CTX */*ctx*/);
PGPV_BIGNUM *PGPV_BN_mod_inverse(PGPV_BIGNUM */*ret*/, PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*n*/, PGPV_BN_CTX */*ctx*/);
int PGPV_BN_mod_mul(PGPV_BIGNUM */*ret*/, PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/, const PGPV_BIGNUM */*m*/, PGPV_BN_CTX */*ctx*/);
int PGPV_BN_mod_sub(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/, const PGPV_BIGNUM */*m*/, PGPV_BN_CTX */*ctx*/);
int BN_raise(BIGNUM */*res*/, BIGNUM */*a*/, BIGNUM */*b*/);
int BN_factorial(BIGNUM */*fact*/, BIGNUM */*f*/);
int PGPV_BN_raise(PGPV_BIGNUM */*res*/, PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/);
int PGPV_BN_factorial(PGPV_BIGNUM */*fact*/, PGPV_BIGNUM */*f*/);
BN_CTX *BN_CTX_new(void);
BIGNUM *BN_CTX_get(BN_CTX */*ctx*/);
void BN_CTX_start(BN_CTX */*ctx*/);
void BN_CTX_end(BN_CTX */*ctx*/);
void BN_CTX_init(BN_CTX */*c*/);
void BN_CTX_free(BN_CTX */*c*/);
PGPV_BN_CTX *PGPV_BN_CTX_new(void);
PGPV_BIGNUM *PGPV_BN_CTX_get(PGPV_BN_CTX */*ctx*/);
void PGPV_BN_CTX_start(PGPV_BN_CTX */*ctx*/);
void PGPV_BN_CTX_end(PGPV_BN_CTX */*ctx*/);
void PGPV_BN_CTX_init(PGPV_BN_CTX */*c*/);
void PGPV_BN_CTX_free(PGPV_BN_CTX */*c*/);
int BN_rand(BIGNUM */*rnd*/, int /*bits*/, int /*top*/, int /*bottom*/);
int BN_rand_range(BIGNUM */*rnd*/, BIGNUM */*range*/);
int PGPV_BN_rand(PGPV_BIGNUM */*rnd*/, int /*bits*/, int /*top*/, int /*bottom*/);
int PGPV_BN_rand_range(PGPV_BIGNUM */*rnd*/, PGPV_BIGNUM */*range*/);
int BN_is_prime(const BIGNUM */*a*/, int /*checks*/, void (*callback)(int, int, void *), BN_CTX */*ctx*/, void */*cb_arg*/);
int PGPV_BN_is_prime(const PGPV_BIGNUM */*a*/, int /*checks*/, void (*callback)(int, int, void *), PGPV_BN_CTX */*ctx*/, void */*cb_arg*/);
const BIGNUM *BN_value_one(void);
int BN_is_bit_set(const BIGNUM */*a*/, int /*n*/);
const PGPV_BIGNUM *PGPV_BN_value_one(void);
int PGPV_BN_is_bit_set(const PGPV_BIGNUM */*a*/, int /*n*/);
__END_DECLS

38
security/netpgpverify/files/digest.c
View File

@@ -114,49 +114,49 @@ digest_init(digest_t *hash, const uint32_t hashalg)
}
switch(hash->alg = hashalg) {
case MD5_HASH_ALG:
MD5Init(&hash->u.md5ctx);
netpgpv_MD5Init(&hash->u.md5ctx);
hash->size = 16;
hash->prefix = prefix_md5;
hash->len = sizeof(prefix_md5);
hash->ctx = &hash->u.md5ctx;
return 1;
case SHA1_HASH_ALG:
SHA1Init(&hash->u.sha1ctx);
netpgpv_SHA1Init(&hash->u.sha1ctx);
hash->size = 20;
hash->prefix = prefix_sha1;
hash->len = sizeof(prefix_sha1);
hash->ctx = &hash->u.sha1ctx;
return 1;
case RIPEMD_HASH_ALG:
RMD160Init(&hash->u.rmd160ctx);
netpgpv_RMD160Init(&hash->u.rmd160ctx);
hash->size = 20;
hash->prefix = prefix_rmd160;
hash->len = sizeof(prefix_rmd160);
hash->ctx = &hash->u.rmd160ctx;
return 1;
case SHA256_HASH_ALG:
SHA256_Init(&hash->u.sha256ctx);
netpgpv_SHA256_Init(&hash->u.sha256ctx);
hash->size = 32;
hash->prefix = prefix_sha256;
hash->len = sizeof(prefix_sha256);
hash->ctx = &hash->u.sha256ctx;
return 1;
case SHA512_HASH_ALG:
SHA512_Init(&hash->u.sha512ctx);
netpgpv_SHA512_Init(&hash->u.sha512ctx);
hash->size = 64;
hash->prefix = prefix_sha512;
hash->len = sizeof(prefix_sha512);
hash->ctx = &hash->u.sha512ctx;
return 1;
case TIGER_HASH_ALG:
TIGER_Init(&hash->u.tigerctx);
netpgpv_TIGER_Init(&hash->u.tigerctx);
hash->size = TIGER_DIGEST_LENGTH;
hash->prefix = prefix_tiger;
hash->len = sizeof(prefix_tiger);
hash->ctx = &hash->u.tigerctx;
return 1;
case TIGER2_HASH_ALG:
TIGER2_Init(&hash->u.tigerctx);
netpgpv_TIGER2_Init(&hash->u.tigerctx);
hash->size = TIGER_DIGEST_LENGTH;
hash->prefix = prefix_tiger;
hash->len = sizeof(prefix_tiger);
@@ -206,23 +206,23 @@ digest_update(digest_t *hash, const uint8_t *data, size_t length)
}
switch(hash->alg) {
case MD5_HASH_ALG:
MD5Update(hash->ctx, data, (unsigned)length);
netpgpv_MD5Update(hash->ctx, data, (unsigned)length);
return 1;
case SHA1_HASH_ALG:
SHA1Update(hash->ctx, data, (unsigned)length);
netpgpv_SHA1Update(hash->ctx, data, (unsigned)length);
return 1;
case RIPEMD_HASH_ALG:
RMD160Update(hash->ctx, data, (unsigned)length);
netpgpv_RMD160Update(hash->ctx, data, (unsigned)length);
return 1;
case SHA256_HASH_ALG:
SHA256_Update(hash->ctx, data, length);
netpgpv_SHA256_Update(hash->ctx, data, length);
return 1;
case SHA512_HASH_ALG:
SHA512_Update(hash->ctx, data, length);
netpgpv_SHA512_Update(hash->ctx, data, length);
return 1;
case TIGER_HASH_ALG:
case TIGER2_HASH_ALG:
TIGER_Update(hash->ctx, data, length);
netpgpv_TIGER_Update(hash->ctx, data, length);
return 1;
default:
printf("hash_any: bad algorithm\n");
@@ -238,22 +238,22 @@ digest_final(uint8_t *out, digest_t *hash)
}
switch(hash->alg) {
case MD5_HASH_ALG:
MD5Final(out, hash->ctx);
netpgpv_MD5Final(out, hash->ctx);
break;
case SHA1_HASH_ALG:
SHA1Final(out, hash->ctx);
netpgpv_SHA1Final(out, hash->ctx);
break;
case RIPEMD_HASH_ALG:
RMD160Final(out, hash->ctx);
netpgpv_RMD160Final(out, hash->ctx);
break;
case SHA256_HASH_ALG:
SHA256_Final(out, hash->ctx);
netpgpv_SHA256_Final(out, hash->ctx);
break;
case SHA512_HASH_ALG:
SHA512_Final(out, hash->ctx);
netpgpv_SHA512_Final(out, hash->ctx);
break;
case TIGER_HASH_ALG:
TIGER_Final(out, hash->ctx);
netpgpv_TIGER_Final(out, hash->ctx);
break;
default:
printf("hash_any: bad algorithm\n");

12
security/netpgpverify/files/digest.h
View File

@@ -62,12 +62,12 @@ typedef struct digest_t {
uint32_t alg; /* algorithm */
size_t size; /* size */
union {
MD5_CTX md5ctx; /* MD5 */
SHA1_CTX sha1ctx; /* SHA1 */
RMD160_CTX rmd160ctx; /* RIPEMD */
SHA256_CTX sha256ctx; /* SHA256 */
SHA512_CTX sha512ctx; /* SHA512 */
TIGER_CTX tigerctx; /* TIGER/TIGER2 */
NETPGPV_MD5_CTX md5ctx; /* MD5 */
NETPGPV_SHA1_CTX sha1ctx; /* SHA1 */
NETPGPV_RMD160_CTX rmd160ctx; /* RIPEMD */
NETPGPV_SHA256_CTX sha256ctx; /* SHA256 */
NETPGPV_SHA512_CTX sha512ctx; /* SHA512 */
NETPGPV_TIGER_CTX tigerctx; /* TIGER/TIGER2 */
} u;
void *prefix; /* points to specific prefix */
uint32_t len; /* prefix length */

105
security/netpgpverify/files/libverify.c
View File

@@ -32,6 +32,7 @@
#include <arpa/inet.h>
#include <inttypes.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
@@ -64,6 +65,10 @@
#define __printflike(n, m) __attribute__((format(printf,n,m)))
#endif
#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif
#define BITS_TO_BYTES(b) (((b) + (CHAR_BIT - 1)) / CHAR_BIT)
/* packet types */
@@ -426,20 +431,20 @@ static unsigned
fmt_binary_mpi(pgpv_bignum_t *mpi, uint8_t *p, size_t size)
{
unsigned bytes;
BIGNUM *bn;
PGPV_BIGNUM *bn;
bytes = BITS_TO_BYTES(mpi->bits);
if ((size_t)bytes + 2 + 1 > size) {
fprintf(stderr, "truncated mpi");
return 0;
}
bn = (BIGNUM *)mpi->bn;
if (bn == NULL || BN_is_zero(bn)) {
bn = (PGPV_BIGNUM *)mpi->bn;
if (bn == NULL || PGPV_BN_is_zero(bn)) {
fmt_32(p, 0);
return 2 + 1;
}
fmt_16(p, mpi->bits);
BN_bn2bin(bn, &p[2]);
PGPV_BN_bn2bin(bn, &p[2]);
return bytes + 2;
}
@@ -454,7 +459,7 @@ fmt_mpi(char *s, size_t size, pgpv_bignum_t *bn, const char *name, int pbits)
if (pbits) {
cc += snprintf(&s[cc], size - cc, "[%u bits] ", bn->bits);
}
buf = BN_bn2hex(bn->bn);
buf = PGPV_BN_bn2hex(bn->bn);
cc += snprintf(&s[cc], size - cc, "%s\n", buf);
free(buf);
return cc;
@@ -728,7 +733,7 @@ get_mpi(pgpv_bignum_t *mpi, uint8_t *p, size_t pktlen, size_t *off)
return 0;
}
*off += sizeof(mpi->bits);
mpi->bn = BN_bin2bn(&p[sizeof(mpi->bits)], (int)bytes, NULL);
mpi->bn = PGPV_BN_bin2bn(&p[sizeof(mpi->bits)], (int)bytes, NULL);
*off += bytes;
return 1;
}
@@ -1528,8 +1533,8 @@ static int
lowlevel_rsa_public_check(const uint8_t *encbuf, int enclen, uint8_t *dec, const rsa_pubkey_t *rsa)
{
uint8_t *decbuf;
BIGNUM *decbn;
BIGNUM *encbn;
PGPV_BIGNUM *decbn;
PGPV_BIGNUM *encbn;
int decbytes;
int nbytes;
int r;
@@ -1538,22 +1543,22 @@ lowlevel_rsa_public_check(const uint8_t *encbuf, int enclen, uint8_t *dec, const
r = -1;
decbuf = NULL;
decbn = encbn = NULL;
if (BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
if (PGPV_BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
printf("rsa r modulus too large\n");
goto err;
}
if (BN_cmp(rsa->n, rsa->e) <= 0) {
if (PGPV_BN_cmp(rsa->n, rsa->e) <= 0) {
printf("rsa r bad n value\n");
goto err;
}
if (BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_BITS) {
if (PGPV_BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
PGPV_BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_BITS) {
printf("rsa r bad exponent limit\n");
goto err;
}
nbytes = BN_num_bytes(rsa->n);
if ((encbn = BN_new()) == NULL ||
(decbn = BN_new()) == NULL ||
nbytes = PGPV_BN_num_bytes(rsa->n);
if ((encbn = PGPV_BN_new()) == NULL ||
(decbn = PGPV_BN_new()) == NULL ||
(decbuf = calloc(1, (size_t)nbytes)) == NULL) {
printf("allocation failure\n");
goto err;
@@ -1562,26 +1567,26 @@ lowlevel_rsa_public_check(const uint8_t *encbuf, int enclen, uint8_t *dec, const
printf("rsa r > mod len\n");
goto err;
}
if (BN_bin2bn(encbuf, enclen, encbn) == NULL) {
if (PGPV_BN_bin2bn(encbuf, enclen, encbn) == NULL) {
printf("null encrypted BN\n");
goto err;
}
if (BN_cmp(encbn, rsa->n) >= 0) {
if (PGPV_BN_cmp(encbn, rsa->n) >= 0) {
printf("rsa r data too large for modulus\n");
goto err;
}
if (BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
printf("BN_mod_exp < 0\n");
if (PGPV_BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
printf("PGPV_BN_mod_exp < 0\n");
goto err;
}
decbytes = BN_num_bytes(decbn);
(void) BN_bn2bin(decbn, decbuf);
decbytes = PGPV_BN_num_bytes(decbn);
(void) PGPV_BN_bn2bin(decbn, decbuf);
if ((r = rsa_padding_check_none(dec, nbytes, decbuf, decbytes, 0)) < 0) {
printf("rsa r padding check failed\n");
}
err:
BN_free(encbn);
BN_free(decbn);
PGPV_BN_free(encbn);
PGPV_BN_free(decbn);
if (decbuf != NULL) {
(void) memset(decbuf, 0x0, nbytes);
free(decbuf);
@@ -1601,11 +1606,11 @@ rsa_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, RSA
}
USE_ARG(padding);
(void) memset(&pub, 0x0, sizeof(pub));
pub.n = BN_dup(rsa->n);
pub.e = BN_dup(rsa->e);
pub.n = PGPV_BN_dup(rsa->n);
pub.e = PGPV_BN_dup(rsa->e);
ret = lowlevel_rsa_public_check(enc, enclen, dec, &pub);
BN_free(pub.n);
BN_free(pub.e);
PGPV_BN_free(pub.n);
PGPV_BN_free(pub.e);
return ret;
}
@@ -1656,7 +1661,7 @@ rsa_verify(uint8_t *calculated, unsigned calclen, uint8_t hashalg, pgpv_bignum_t
size_t keysize;
keysize = BITS_TO_BYTES(pubkey->bn[RSA_N].bits);
BN_bn2bin(bn[RSA_SIG].bn, sigbn);
PGPV_BN_bn2bin(bn[RSA_SIG].bn, sigbn);
decryptc = pgpv_rsa_public_decrypt(decrypted, sigbn, BITS_TO_BYTES(bn[RSA_SIG].bits), pubkey);
if (decryptc != keysize || (decrypted[0] != 0 || decrypted[1] != 1)) {
return 0;
@@ -1682,13 +1687,13 @@ rsa_verify(uint8_t *calculated, unsigned calclen, uint8_t hashalg, pgpv_bignum_t
/* return 1 if bn <= 0 */
static int
bignum_is_bad(BIGNUM *bn)
bignum_is_bad(PGPV_BIGNUM *bn)
{
return BN_is_zero(bn) || BN_is_negative(bn);
return PGPV_BN_is_zero(bn) || PGPV_BN_is_negative(bn);
}
#define BAD_BIGNUM(s, k) \
(bignum_is_bad((s)->bn) || BN_cmp((s)->bn, (k)->bn) >= 0)
(bignum_is_bad((s)->bn) || PGPV_BN_cmp((s)->bn, (k)->bn) >= 0)
#ifndef DSA_MAX_MODULUS_BITS
#define DSA_MAX_MODULUS_BITS 10000
@@ -1701,9 +1706,9 @@ verify_dsa_sig(uint8_t *calculated, unsigned calclen, pgpv_bignum_t *sig, pgpv_p
unsigned qbits;
uint8_t calcnum[128];
uint8_t signum[128];
BIGNUM *M;
BIGNUM *W;
BIGNUM *t1;
PGPV_BIGNUM *M;
PGPV_BIGNUM *W;
PGPV_BIGNUM *t1;
int ret;
if (pubkey->bn[DSA_P].bn == NULL ||
@@ -1731,37 +1736,37 @@ verify_dsa_sig(uint8_t *calculated, unsigned calclen, pgpv_bignum_t *sig, pgpv_p
return 0;
}
ret = 0;
if ((M = BN_new()) == NULL || (W = BN_new()) == NULL || (t1 = BN_new()) == NULL ||
if ((M = PGPV_BN_new()) == NULL || (W = PGPV_BN_new()) == NULL || (t1 = PGPV_BN_new()) == NULL ||
BAD_BIGNUM(&sig[DSA_R], &pubkey->bn[DSA_Q]) ||
BAD_BIGNUM(&sig[DSA_S], &pubkey->bn[DSA_Q]) ||
BN_mod_inverse(W, sig[DSA_S].bn, pubkey->bn[DSA_Q].bn, NULL) == NULL) {
PGPV_BN_mod_inverse(W, sig[DSA_S].bn, pubkey->bn[DSA_Q].bn, NULL) == NULL) {
goto done;
}
if (calclen > qbits / 8) {
calclen = qbits / 8;
}
if (BN_bin2bn(calculated, (int)calclen, M) == NULL ||
!BN_mod_mul(M, M, W, pubkey->bn[DSA_Q].bn, NULL) ||
!BN_mod_mul(W, sig[DSA_R].bn, W, pubkey->bn[DSA_Q].bn, NULL) ||
!BN_mod_exp(t1, pubkey->bn[DSA_G].bn, M, pubkey->bn[DSA_P].bn, NULL) ||
!BN_mod_exp(W, pubkey->bn[DSA_Y].bn, W, pubkey->bn[DSA_P].bn, NULL) ||
!BN_mod_mul(t1, t1, W, pubkey->bn[DSA_P].bn, NULL) ||
!BN_div(NULL, t1, t1, pubkey->bn[DSA_Q].bn, NULL)) {
if (PGPV_BN_bin2bn(calculated, (int)calclen, M) == NULL ||
!PGPV_BN_mod_mul(M, M, W, pubkey->bn[DSA_Q].bn, NULL) ||
!PGPV_BN_mod_mul(W, sig[DSA_R].bn, W, pubkey->bn[DSA_Q].bn, NULL) ||
!PGPV_BN_mod_exp(t1, pubkey->bn[DSA_G].bn, M, pubkey->bn[DSA_P].bn, NULL) ||
!PGPV_BN_mod_exp(W, pubkey->bn[DSA_Y].bn, W, pubkey->bn[DSA_P].bn, NULL) ||
!PGPV_BN_mod_mul(t1, t1, W, pubkey->bn[DSA_P].bn, NULL) ||
!PGPV_BN_div(NULL, t1, t1, pubkey->bn[DSA_Q].bn, NULL)) {
goto done;
}
/* only compare the first q bits */
BN_bn2bin(t1, calcnum);
BN_bn2bin(sig[DSA_R].bn, signum);
PGPV_BN_bn2bin(t1, calcnum);
PGPV_BN_bn2bin(sig[DSA_R].bn, signum);
ret = memcmp(calcnum, signum, BITS_TO_BYTES(qbits)) == 0;
done:
if (M) {
BN_free(M);
PGPV_BN_free(M);
}
if (W) {
BN_free(W);
PGPV_BN_free(W);
}
if (t1) {
BN_free(t1);
PGPV_BN_free(t1);
}
return ret;
}
@@ -2197,8 +2202,8 @@ getbignum(pgpv_bignum_t *bignum, bufgap_t *bg, char *buf, const char *header)
len = pgp_ntoh32(len);
(void) bufgap_seek(bg, sizeof(len), BGFromHere, BGByte);
(void) bufgap_getbin(bg, buf, len);
bignum->bn = BN_bin2bn((const uint8_t *)buf, (int)len, NULL);
bignum->bits = BN_num_bits(bignum->bn);
bignum->bn = PGPV_BN_bin2bn((const uint8_t *)buf, (int)len, NULL);
bignum->bits = PGPV_BN_num_bits(bignum->bn);
(void) bufgap_seek(bg, len, BGFromHere, BGByte);
return 1;
}

26
security/netpgpverify/files/md5.h
View File

@@ -1,4 +1,4 @@
/* $NetBSD: md5.h,v 1.1 2013/03/16 07:32:34 agc Exp $ */
/* $NetBSD: md5.h,v 1.3 2015/09/01 19:38:42 agc Exp $ */
/*
* This file is derived from the RSA Data Security, Inc. MD5 Message-Digest
@@ -39,21 +39,31 @@
#define MD5_DIGEST_LENGTH 16
#define MD5_DIGEST_STRING_LENGTH 33
#ifndef __BEGIN_DECLS
# if defined(__cplusplus)
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
# else
# define __BEGIN_DECLS
# define __END_DECLS
# endif
#endif
/* MD5 context. */
typedef struct MD5Context {
uint32_t state[4]; /* state (ABCD) */
uint32_t count[2]; /* number of bits, modulo 2^64 (lsb first) */
unsigned char buffer[64]; /* input buffer */
} MD5_CTX;
} NETPGPV_MD5_CTX;
__BEGIN_DECLS
void MD5Init(MD5_CTX *);
void MD5Update(MD5_CTX *, const unsigned char *, unsigned int);
void MD5Final(unsigned char[MD5_DIGEST_LENGTH], MD5_CTX *);
void netpgpv_MD5Init(NETPGPV_MD5_CTX *);
void netpgpv_MD5Update(NETPGPV_MD5_CTX *, const unsigned char *, unsigned int);
void netpgpv_MD5Final(unsigned char[MD5_DIGEST_LENGTH], NETPGPV_MD5_CTX *);
#ifndef _KERNEL
char *MD5End(MD5_CTX *, char *);
char *MD5File(const char *, char *);
char *MD5Data(const unsigned char *, unsigned int, char *);
char *netpgpv_MD5End(NETPGPV_MD5_CTX *, char *);
char *netpgpv_MD5File(const char *, char *);
char *netpgpv_MD5Data(const unsigned char *, unsigned int, char *);
#endif /* _KERNEL */
__END_DECLS

15
security/netpgpverify/files/md5c.c
View File

@@ -1,4 +1,4 @@
/* $NetBSD: md5c.c,v 1.1 2013/03/16 07:32:34 agc Exp $ */
/* $NetBSD: md5c.c,v 1.3 2015/09/01 19:38:42 agc Exp $ */
/*
* This file is derived from the RSA Data Security, Inc. MD5 Message-Digest
@@ -29,7 +29,6 @@
* documentation and/or software.
*/
#include <sys/cdefs.h>
#include <sys/types.h>
#include <assert.h>
#include <string.h>
@@ -155,7 +154,7 @@ static const unsigned char PADDING[64] = {
* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
void
MD5Init(MD5_CTX *context)
netpgpv_MD5Init(NETPGPV_MD5_CTX *context)
{
context->count[0] = context->count[1] = 0;
@@ -173,7 +172,7 @@ MD5Init(MD5_CTX *context)
* context.
*/
void
MD5Update(MD5_CTX *context,
netpgpv_MD5Update(NETPGPV_MD5_CTX *context,
const unsigned char *input, /* input block */
unsigned int inputLen) /* length of input block */
{
@@ -211,8 +210,8 @@ MD5Update(MD5_CTX *context,
* message digest and zeroing the context.
*/
void
MD5Final(unsigned char digest[16], /* message digest */
MD5_CTX *context) /* context */
netpgpv_MD5Final(unsigned char digest[16], /* message digest */
NETPGPV_MD5_CTX *context) /* context */
{
unsigned char bits[8];
unsigned int idx, padLen;
@@ -223,10 +222,10 @@ MD5Final(unsigned char digest[16], /* message digest */
/* Pad out to 56 mod 64. */
idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (idx < 56) ? (56 - idx) : (120 - idx);
MD5Update (context, PADDING, padLen);
netpgpv_MD5Update (context, PADDING, padLen);
/* Append length (before padding) */
MD5Update(context, bits, 8);
netpgpv_MD5Update(context, bits, 8);
/* Store state in digest */
Encode(digest, context->state, 16);

3
security/netpgpverify/files/pgpsum.c
View File

@@ -41,6 +41,9 @@
#define USE_ARG(x) /*LINTED*/(void)&(x)
#endif
#undef swap16
#undef swap32
/* add the ascii armor line endings (except for last line) */
static size_t
don_armor(digest_t *hash, uint8_t *in, size_t insize, int doarmor)

29
security/netpgpverify/files/rmd160.c
View File

@@ -1,4 +1,4 @@
/* $NetBSD: rmd160.c,v 1.1 2013/03/16 07:32:35 agc Exp $ */
/* $NetBSD: rmd160.c,v 1.4 2015/09/12 02:19:06 agc Exp $ */
/* $KAME: rmd160.c,v 1.2 2003/07/25 09:37:55 itojun Exp $ */
/* $OpenBSD: rmd160.c,v 1.3 2001/09/26 21:40:13 markus Exp $ */
/*
@@ -30,8 +30,6 @@
* ftp://ftp.rsasecurity.com/pub/cryptobytes/crypto3n2.pdf
*/
#include <sys/cdefs.h>
#include <string.h>
#include <sys/types.h>
@@ -97,7 +95,7 @@ static const u_char PADDING[64] = {
};
void
RMD160Init(RMD160_CTX *ctx)
netpgpv_RMD160Init(NETPGPV_RMD160_CTX *ctx)
{
ctx->count = 0;
ctx->state[0] = H0;
@@ -108,7 +106,7 @@ RMD160Init(RMD160_CTX *ctx)
}
void
RMD160Update(RMD160_CTX *ctx, const u_char *input, uint32_t len)
netpgpv_RMD160Update(NETPGPV_RMD160_CTX *ctx, const u_char *input, uint32_t len)
{
uint32_t have, off, need;
@@ -120,13 +118,13 @@ RMD160Update(RMD160_CTX *ctx, const u_char *input, uint32_t len)
if (len >= need) {
if (have) {
memcpy(ctx->buffer + have, input, (size_t)need);
RMD160Transform(ctx->state, ctx->buffer);
netpgpv_RMD160Transform(ctx->state, ctx->buffer);
off = need;
have = 0;
}
/* now the buffer is empty */
while (off + 64 <= len) {
RMD160Transform(ctx->state, input+off);
netpgpv_RMD160Transform(ctx->state, input+off);
off += 64;
}
}
@@ -135,7 +133,7 @@ RMD160Update(RMD160_CTX *ctx, const u_char *input, uint32_t len)
}
void
RMD160Final(u_char digest[20], RMD160_CTX *ctx)
netpgpv_RMD160Final(u_char digest[20], NETPGPV_RMD160_CTX *ctx)
{
int i;
u_char size[8];
@@ -150,8 +148,8 @@ RMD160Final(u_char digest[20], RMD160_CTX *ctx)
padlen = (uint32_t)(64 - ((ctx->count/8) % 64));
if (padlen < 1 + 8)
padlen += 64;
RMD160Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */
RMD160Update(ctx, size, 8);
netpgpv_RMD160Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */
netpgpv_RMD160Update(ctx, size, 8);
if (digest != NULL)
for (i = 0; i < 5; i++)
@@ -161,7 +159,7 @@ RMD160Final(u_char digest[20], RMD160_CTX *ctx)
}
void
RMD160Transform(uint32_t state[5], const u_char block[64])
netpgpv_RMD160Transform(uint32_t state[5], const u_char block[64])
{
uint32_t a, b, c, d, e, aa, bb, cc, dd, ee, t, x[16];
@@ -170,8 +168,13 @@ RMD160Transform(uint32_t state[5], const u_char block[64])
#else
int i;
for (i = 0; i < 16; i++)
x[i] = le32dec(block+i*4);
for (i = 0; i < 16; i++) {
x[i] = (uint32_t)(
(uint32_t)(block[i*4 + 0]) |
(uint32_t)(block[i*4 + 1]) << 8 |
(uint32_t)(block[i*4 + 2]) << 16 |
(uint32_t)(block[i*4 + 3]) << 24);
}
#endif
a = state[0];

31
security/netpgpverify/files/rmd160.h
View File

@@ -1,4 +1,4 @@
/* $NetBSD: rmd160.h,v 1.1 2013/03/16 07:32:35 agc Exp $ */
/* $NetBSD: rmd160.h,v 1.3 2015/09/01 19:38:42 agc Exp $ */
/* $KAME: rmd160.h,v 1.2 2003/07/25 09:37:55 itojun Exp $ */
/* $OpenBSD: rmd160.h,v 1.3 2002/03/14 01:26:51 millert Exp $ */
/*
@@ -27,7 +27,6 @@
#ifndef _RMD160_H
#define _RMD160_H
#include <sys/cdefs.h>
#include <sys/types.h>
#include <inttypes.h>
@@ -35,23 +34,33 @@
#define RMD160_DIGEST_LENGTH 20
#define RMD160_DIGEST_STRING_LENGTH 41
#ifndef __BEGIN_DECLS
# if defined(__cplusplus)
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
# else
# define __BEGIN_DECLS
# define __END_DECLS
# endif
#endif
/* RMD160 context. */
typedef struct RMD160Context {
uint32_t state[5]; /* state */
uint64_t count; /* number of bits, modulo 2^64 */
u_char buffer[64]; /* input buffer */
} RMD160_CTX;
} NETPGPV_RMD160_CTX;
__BEGIN_DECLS
void RMD160Init(RMD160_CTX *);
void RMD160Transform(uint32_t [5], const u_char [64]);
void RMD160Update(RMD160_CTX *, const u_char *, uint32_t);
void RMD160Final(u_char [RMD160_DIGEST_LENGTH], RMD160_CTX *);
void netpgpv_RMD160Init(NETPGPV_RMD160_CTX *);
void netpgpv_RMD160Transform(uint32_t [5], const u_char [64]);
void netpgpv_RMD160Update(NETPGPV_RMD160_CTX *, const u_char *, uint32_t);
void netpgpv_RMD160Final(u_char [RMD160_DIGEST_LENGTH], NETPGPV_RMD160_CTX *);
#ifndef _KERNEL
char *RMD160End(RMD160_CTX *, char *);
char *RMD160FileChunk(const char *, char *, off_t, off_t);
char *RMD160File(const char *, char *);
char *RMD160Data(const u_char *, size_t, char *);
char *netpgpv_RMD160End(NETPGPV_RMD160_CTX *, char *);
char *netpgpv_RMD160FileChunk(const char *, char *, off_t, off_t);
char *netpgpv_RMD160File(const char *, char *);
char *netpgpv_RMD160Data(const u_char *, size_t, char *);
#endif /* _KERNEL */
__END_DECLS

204
security/netpgpverify/files/rsa.c
View File

@@ -64,8 +64,8 @@ rsa_padding_check_none(uint8_t *to, int tlen, const uint8_t *from, int flen, int
static int
lowlevel_rsa_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa)
{
BIGNUM *decbn;
BIGNUM *signedbn;
PGPV_BIGNUM *decbn;
PGPV_BIGNUM *signedbn;
uint8_t *decbuf;
int nbytes;
int signc;
@@ -74,37 +74,37 @@ lowlevel_rsa_private_encrypt(int plainc, const unsigned char *plain, unsigned ch
decbuf = NULL;
r = -1;
decbn = BN_new();
signedbn = BN_new();
nbytes = BN_num_bytes(rsa->n);
decbn = PGPV_BN_new();
signedbn = PGPV_BN_new();
nbytes = PGPV_BN_num_bytes(rsa->n);
decbuf = netpgp_allocate(1, nbytes);
/* add no padding */
memcpy(decbuf, plain, plainc);
BN_bin2bn(decbuf, nbytes, decbn);
if (BN_cmp(decbn, rsa->n) >= 0) {
PGPV_BN_bin2bn(decbuf, nbytes, decbn);
if (PGPV_BN_cmp(decbn, rsa->n) >= 0) {
printf("decbn too big\n");
goto err;
}
if (!BN_mod_exp(signedbn, decbn, rsa->d, rsa->n, NULL)) {
if (!PGPV_BN_mod_exp(signedbn, decbn, rsa->d, rsa->n, NULL)) {
printf("bad mod_exp\n");
goto err;
}
signedbytes = BN_num_bytes(signedbn);
signc = BN_bn2bin(signedbn, &encbuf[nbytes - signedbytes]);
signedbytes = PGPV_BN_num_bytes(signedbn);
signc = PGPV_BN_bn2bin(signedbn, &encbuf[nbytes - signedbytes]);
memset(encbuf, 0x0, nbytes - signc);
r = nbytes;
err:
netpgp_deallocate(decbuf, nbytes);
BN_clear_free(decbn);
BN_clear_free(signedbn);
PGPV_BN_clear_free(decbn);
PGPV_BN_clear_free(signedbn);
return r;
}
static int
lowlevel_rsa_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa)
{
BIGNUM *decbn;
BIGNUM *encbn;
PGPV_BIGNUM *decbn;
PGPV_BIGNUM *encbn;
uint8_t *decbuf;
int nbytes;
int encc;
@@ -112,25 +112,25 @@ lowlevel_rsa_public_encrypt(int plainc, const unsigned char *plain, unsigned cha
int i;
r = -1;
decbn = BN_new();
encbn = BN_new();
nbytes = BN_num_bytes(rsa->n);
decbn = PGPV_BN_new();
encbn = PGPV_BN_new();
nbytes = PGPV_BN_num_bytes(rsa->n);
decbuf = netpgp_allocate(1, nbytes);
(void) memcpy(decbuf, plain, plainc);
if (BN_bin2bn(decbuf, nbytes, decbn) == NULL) {
if (PGPV_BN_bin2bn(decbuf, nbytes, decbn) == NULL) {
printf("bin2bn failed\n");
goto err;
}
if (BN_cmp(decbn, rsa->n) >= 0) {
printf("BN_cmp failed\n");
if (PGPV_BN_cmp(decbn, rsa->n) >= 0) {
printf("PGPV_BN_cmp failed\n");
goto err;
}
if (!BN_mod_exp(encbn, decbn, rsa->e, rsa->n, NULL)) {
printf("BN_mod_exp failed\n");
if (!PGPV_BN_mod_exp(encbn, decbn, rsa->e, rsa->n, NULL)) {
printf("PGPV_BN_mod_exp failed\n");
goto err;
}
encc = BN_num_bytes(encbn);
i = BN_bn2bin(encbn, &encbuf[nbytes - encc]);
encc = PGPV_BN_num_bytes(encbn);
i = PGPV_BN_bn2bin(encbn, &encbuf[nbytes - encc]);
(void) memset(encbuf, 0x0, nbytes - i);
r = nbytes;
err:
@@ -138,16 +138,16 @@ err:
memset(decbuf, 0x0, nbytes);
netpgp_deallocate(decbuf, nbytes);
}
BN_clear_free(decbn);
BN_clear_free(encbn);
PGPV_BN_clear_free(decbn);
PGPV_BN_clear_free(encbn);
return r;
}
static int
lowlevel_rsa_private_decrypt(int enclen, const unsigned char *encbuf, unsigned char *to, RSA *rsa)
{
BIGNUM *encbn;
BIGNUM *decbn;
PGPV_BIGNUM *encbn;
PGPV_BIGNUM *decbn;
uint8_t *buf;
int nbytes;
int j;
@@ -156,31 +156,31 @@ lowlevel_rsa_private_decrypt(int enclen, const unsigned char *encbuf, unsigned c
r = -1;
decbn = encbn = NULL;
buf = NULL;
if (BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
if (PGPV_BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
return -1;
}
if (BN_cmp(rsa->n, rsa->e) <= 0) {
if (PGPV_BN_cmp(rsa->n, rsa->e) <= 0) {
return -1;
}
encbn = BN_new();
decbn = BN_new();
nbytes = BN_num_bytes(rsa->n);
encbn = PGPV_BN_new();
decbn = PGPV_BN_new();
nbytes = PGPV_BN_num_bytes(rsa->n);
buf = netpgp_allocate(1, nbytes);
if (enclen > nbytes) {
printf("bad enclen\n");
goto err;
}
BN_bin2bn(encbuf, enclen, encbn);
if (BN_cmp(encbn, rsa->n) >= 0) {
PGPV_BN_bin2bn(encbuf, enclen, encbn);
if (PGPV_BN_cmp(encbn, rsa->n) >= 0) {
printf("bad encbn\n");
goto err;
}
BN_mod_exp(decbn, encbn, rsa->d, rsa->n, NULL);
j = BN_bn2bin(decbn, buf);
PGPV_BN_mod_exp(decbn, encbn, rsa->d, rsa->n, NULL);
j = PGPV_BN_bn2bin(decbn, buf);
r = rsa_padding_check_none(to, nbytes, buf, j, nbytes);
err:
BN_clear_free(encbn);
BN_clear_free(decbn);
PGPV_BN_clear_free(encbn);
PGPV_BN_clear_free(decbn);
netpgp_deallocate(buf, nbytes);
return r;
}
@@ -189,8 +189,8 @@ static int
lowlevel_rsa_public_decrypt(const uint8_t *encbuf, int enclen, uint8_t *dec, const rsa_pubkey_t *rsa)
{
uint8_t *decbuf;
BIGNUM *decbn;
BIGNUM *encbn;
PGPV_BIGNUM *decbn;
PGPV_BIGNUM *encbn;
int decbytes;
int nbytes;
int r;
@@ -199,22 +199,22 @@ lowlevel_rsa_public_decrypt(const uint8_t *encbuf, int enclen, uint8_t *dec, con
r = -1;
decbuf = NULL;
decbn = encbn = NULL;
if (BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
if (PGPV_BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
printf("rsa r modulus too large\n");
goto err;
}
if (BN_cmp(rsa->n, rsa->e) <= 0) {
if (PGPV_BN_cmp(rsa->n, rsa->e) <= 0) {
printf("rsa r bad n value\n");
goto err;
}
if (BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_BITS) {
if (PGPV_BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
PGPV_BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_BITS) {
printf("rsa r bad exponent limit\n");
goto err;
}
if ((encbn = BN_new()) == NULL ||
(decbn = BN_new()) == NULL ||
(decbuf = netpgp_allocate(1, nbytes = BN_num_bytes(rsa->n))) == NULL) {
if ((encbn = PGPV_BN_new()) == NULL ||
(decbn = PGPV_BN_new()) == NULL ||
(decbuf = netpgp_allocate(1, nbytes = PGPV_BN_num_bytes(rsa->n))) == NULL) {
printf("allocation failure\n");
goto err;
}
@@ -222,26 +222,26 @@ lowlevel_rsa_public_decrypt(const uint8_t *encbuf, int enclen, uint8_t *dec, con
printf("rsa r > mod len\n");
goto err;
}
if (BN_bin2bn(encbuf, enclen, encbn) == NULL) {
if (PGPV_BN_bin2bn(encbuf, enclen, encbn) == NULL) {
printf("null encrypted BN\n");
goto err;
}
if (BN_cmp(encbn, rsa->n) >= 0) {
if (PGPV_BN_cmp(encbn, rsa->n) >= 0) {
printf("rsa r data too large for modulus\n");
goto err;
}
if (BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
printf("BN_mod_exp < 0\n");
if (PGPV_BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
printf("PGPV_BN_mod_exp < 0\n");
goto err;
}
decbytes = BN_num_bytes(decbn);
(void) BN_bn2bin(decbn, decbuf);
decbytes = PGPV_BN_num_bytes(decbn);
(void) PGPV_BN_bn2bin(decbn, decbuf);
if ((r = rsa_padding_check_none(dec, nbytes, decbuf, decbytes, 0)) < 0) {
printf("rsa r padding check failed\n");
}
err:
BN_free(encbn);
BN_free(decbn);
PGPV_BN_free(encbn);
PGPV_BN_free(decbn);
if (decbuf != NULL) {
(void) memset(decbuf, 0x0, nbytes);
netpgp_deallocate(decbuf, nbytes);
@@ -407,9 +407,9 @@ cleanup:
static int
dsa_do_verify(const unsigned char *calculated, int dgst_len, const dsasig_t *sig, mpi_dsa_t *dsa)
{
BIGNUM *M;
BIGNUM *W;
BIGNUM *t1;
PGPV_BIGNUM *M;
PGPV_BIGNUM *W;
PGPV_BIGNUM *t1;
int ret = -1;
int qbits;
@@ -417,7 +417,7 @@ dsa_do_verify(const unsigned char *calculated, int dgst_len, const dsasig_t *sig
return 0;
}
M = W = t1 = NULL;
qbits = BN_num_bits(dsa->q);
qbits = PGPV_BN_num_bits(dsa->q);
switch(qbits) {
case 160:
case 224:
@@ -429,7 +429,7 @@ dsa_do_verify(const unsigned char *calculated, int dgst_len, const dsasig_t *sig
printf("dsa: bad # of Q bits\n");
return 0;
}
if (BN_num_bits(dsa->p) > DSA_MAX_MODULUS_BITS) {
if (PGPV_BN_num_bits(dsa->p) > DSA_MAX_MODULUS_BITS) {
printf("dsa: p too large\n");
return 0;
}
@@ -439,52 +439,52 @@ dsa_do_verify(const unsigned char *calculated, int dgst_len, const dsasig_t *sig
return 0;
}
ret = 0;
if ((M = BN_new()) == NULL ||
(W = BN_new()) == NULL ||
(t1 = BN_new()) == NULL) {
if ((M = PGPV_BN_new()) == NULL ||
(W = PGPV_BN_new()) == NULL ||
(t1 = PGPV_BN_new()) == NULL) {
goto err;
}
if (BN_is_zero(sig->r) ||
BN_is_negative(sig->r) ||
BN_cmp(sig->r, dsa->q) >= 0) {
if (PGPV_BN_is_zero(sig->r) ||
PGPV_BN_is_negative(sig->r) ||
PGPV_BN_cmp(sig->r, dsa->q) >= 0) {
goto err;
}
if (BN_is_zero(sig->s) ||
BN_is_negative(sig->s) ||
BN_cmp(sig->s, dsa->q) >= 0) {
if (PGPV_BN_is_zero(sig->s) ||
PGPV_BN_is_negative(sig->s) ||
PGPV_BN_cmp(sig->s, dsa->q) >= 0) {
goto err;
}
if (BN_mod_inverse(W, sig->s, dsa->q, NULL) != MP_OKAY) {
if (PGPV_BN_mod_inverse(W, sig->s, dsa->q, NULL) != MP_OKAY) {
goto err;
}
if (dgst_len > qbits / 8) {
dgst_len = qbits / 8;
}
if (BN_bin2bn(calculated, dgst_len, M) == NULL) {
if (PGPV_BN_bin2bn(calculated, dgst_len, M) == NULL) {
goto err;
}
if (!BN_mod_mul(M, M, W, dsa->q, NULL)) {
if (!PGPV_BN_mod_mul(M, M, W, dsa->q, NULL)) {
goto err;
}
if (!BN_mod_mul(W, sig->r, W, dsa->q, NULL)) {
if (!PGPV_BN_mod_mul(W, sig->r, W, dsa->q, NULL)) {
goto err;
}
if (!BN_mod_exp(dsa->p, t1, dsa->g, M, NULL)) {
if (!PGPV_BN_mod_exp(dsa->p, t1, dsa->g, M, NULL)) {
goto err;
}
if (!BN_div(NULL, M, t1, dsa->q, NULL)) {
if (!PGPV_BN_div(NULL, M, t1, dsa->q, NULL)) {
goto err;
}
ret = (BN_cmp(M, sig->r) == 0);
ret = (PGPV_BN_cmp(M, sig->r) == 0);
err:
if (M) {
BN_free(M);
PGPV_BN_free(M);
}
if (W) {
BN_free(W);
PGPV_BN_free(W);
}
if (t1) {
BN_free(t1);
PGPV_BN_free(t1);
}
return ret;
}
@@ -494,13 +494,13 @@ err:
int
RSA_size(const RSA *rsa)
{
return (rsa == NULL) ? 0 : BN_num_bits(rsa->n);
return (rsa == NULL) ? 0 : PGPV_BN_num_bits(rsa->n);
}
int
DSA_size(const DSA *dsa)
{
return (dsa == NULL) ? 0 : BN_num_bits(dsa->p);
return (dsa == NULL) ? 0 : PGPV_BN_num_bits(dsa->p);
}
unsigned
@@ -516,26 +516,26 @@ dsa_verify(const signature_t *signature, const dsa_pubkey_t *pubdsa, const uint8
}
(void) memset(&osig, 0x0, sizeof(osig));
(void) memset(&odsa, 0x0, sizeof(odsa));
BN_copy(osig.r, signature->dsa.r);
BN_copy(osig.s, signature->dsa.s);
PGPV_BN_copy(osig.r, signature->dsa.r);
PGPV_BN_copy(osig.s, signature->dsa.s);
odsa.p = pubdsa->p;
odsa.q = pubdsa->q;
odsa.g = pubdsa->g;
odsa.pub_key = pubdsa->y;
if ((qlen = BN_num_bytes(odsa.q)) < hash_length) {
if ((qlen = PGPV_BN_num_bytes(odsa.q)) < hash_length) {
hash_length = qlen;
}
ret = dsa_do_verify(calculated, (int)hash_length, &signature->dsa, &odsa);
if (ret < 0) {
return 0;
}
BN_free(odsa.p);
BN_free(odsa.q);
BN_free(odsa.g);
BN_free(odsa.pub_key);
PGPV_BN_free(odsa.p);
PGPV_BN_free(odsa.q);
PGPV_BN_free(odsa.g);
PGPV_BN_free(odsa.pub_key);
odsa.p = odsa.q = odsa.g = odsa.pub_key = NULL;
BN_free(osig.r);
BN_free(osig.s);
PGPV_BN_free(osig.r);
PGPV_BN_free(osig.s);
osig.r = osig.s = NULL;
return (unsigned)ret;
}
@@ -557,7 +557,7 @@ RSA_free(RSA *rsa)
int
RSA_check_key(RSA *rsa)
{
BIGNUM *calcn;
PGPV_BIGNUM *calcn;
int ret;
ret = 0;
@@ -565,19 +565,19 @@ RSA_check_key(RSA *rsa)
return -1;
}
/* check that p and q are coprime, and that n = p*q. */
if (!BN_is_prime(rsa->p, 1, NULL, NULL, NULL) ||
!BN_is_prime(rsa->q, 1, NULL, NULL, NULL)) {
if (!PGPV_BN_is_prime(rsa->p, 1, NULL, NULL, NULL) ||
!PGPV_BN_is_prime(rsa->q, 1, NULL, NULL, NULL)) {
return 0;
}
calcn = BN_new();
BN_mul(calcn, rsa->p, rsa->q, NULL);
if (BN_cmp(calcn, rsa->n) != 0) {
calcn = PGPV_BN_new();
PGPV_BN_mul(calcn, rsa->p, rsa->q, NULL);
if (PGPV_BN_cmp(calcn, rsa->n) != 0) {
goto errout;
}
/* XXX - check that d*e = 1 mod (p-1*q-1) */
ret = 1;
errout:
BN_clear_free(calcn);
PGPV_BN_clear_free(calcn);
return ret;
}
@@ -638,11 +638,11 @@ RSA_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, RSA
}
USE_ARG(padding);
(void) memset(&pub, 0x0, sizeof(pub));
pub.n = BN_dup(rsa->n);
pub.e = BN_dup(rsa->e);
pub.n = PGPV_BN_dup(rsa->n);
pub.e = PGPV_BN_dup(rsa->e);
ret = lowlevel_rsa_public_decrypt(enc, enclen, dec, &pub);
BN_free(pub.n);
BN_free(pub.e);
PGPV_BN_free(pub.n);
PGPV_BN_free(pub.e);
return ret;
}

48
security/netpgpverify/files/rsa.h
View File

@@ -40,8 +40,8 @@
__BEGIN_DECLS
typedef struct rsa_pubkey_t {
BIGNUM *n; /* RSA public modulus n */
BIGNUM *e; /* RSA public encryption exponent e */
PGPV_BIGNUM *n; /* RSA public modulus n */
PGPV_BIGNUM *e; /* RSA public encryption exponent e */
} rsa_pubkey_t;
typedef struct mpi_rsa_t {
@@ -49,44 +49,44 @@ typedef struct mpi_rsa_t {
long f2; /* openssl version */
const void *f3; /* openssl method */
void *f4; /* openssl engine */
BIGNUM *n;
BIGNUM *e;
BIGNUM *d;
BIGNUM *p;
BIGNUM *q;
BIGNUM *dmp1;
BIGNUM *dmq1;
BIGNUM *iqmp;
PGPV_BIGNUM *n;
PGPV_BIGNUM *e;
PGPV_BIGNUM *d;
PGPV_BIGNUM *p;
PGPV_BIGNUM *q;
PGPV_BIGNUM *dmp1;
PGPV_BIGNUM *dmq1;
PGPV_BIGNUM *iqmp;
} mpi_rsa_t;
#define RSA mpi_rsa_t
typedef struct dsa_pubkey_t {
BIGNUM *p; /* DSA public modulus n */
BIGNUM *q; /* DSA public encryption exponent e */
BIGNUM *g;
BIGNUM *y;
PGPV_BIGNUM *p; /* DSA public modulus n */
PGPV_BIGNUM *q; /* DSA public encryption exponent e */
PGPV_BIGNUM *g;
PGPV_BIGNUM *y;
} dsa_pubkey_t;
typedef struct mpi_dsa_t {
BIGNUM *p;
BIGNUM *q;
BIGNUM *g;
BIGNUM *y;
BIGNUM *x;
BIGNUM *pub_key;
BIGNUM *priv_key;
PGPV_BIGNUM *p;
PGPV_BIGNUM *q;
PGPV_BIGNUM *g;
PGPV_BIGNUM *y;
PGPV_BIGNUM *x;
PGPV_BIGNUM *pub_key;
PGPV_BIGNUM *priv_key;
} mpi_dsa_t;
#define DSA mpi_dsa_t
typedef struct rsasig_t {
BIGNUM *sig; /* mpi which is actual signature */
PGPV_BIGNUM *sig; /* mpi which is actual signature */
} rsasig_t;
typedef struct dsasig_t {
BIGNUM *r; /* mpi which is actual signature */
BIGNUM *s; /* mpi which is actual signature */
PGPV_BIGNUM *r; /* mpi which is actual signature */
PGPV_BIGNUM *s; /* mpi which is actual signature */
} dsasig_t;
#define DSA_SIG dsasig_t

22
security/netpgpverify/files/sha1.c
View File

@@ -1,4 +1,4 @@
/* $NetBSD: sha1.c,v 1.1 2013/03/16 07:32:35 agc Exp $ */
/* $NetBSD: sha1.c,v 1.3 2015/09/01 19:38:42 agc Exp $ */
/* $OpenBSD: sha1.c,v 1.9 1997/07/23 21:12:32 kstailey Exp $ */
/*
@@ -17,8 +17,6 @@
#define SHA1HANDSOFF /* Copies data before messing with it. */
#include <sys/cdefs.h>
#include <string.h>
#include <sys/types.h>
@@ -119,7 +117,7 @@ do_R4(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LON
/*
* Hash a single 512-bit block. This is the core of the algorithm.
*/
void SHA1Transform(uint32_t state[5], const uint8_t buffer[64])
void netpgpv_SHA1Transform(uint32_t state[5], const uint8_t buffer[64])
{
uint32_t a, b, c, d, e;
CHAR64LONG16 *block;
@@ -186,7 +184,7 @@ void SHA1Transform(uint32_t state[5], const uint8_t buffer[64])
/*
* SHA1Init - Initialize new context
*/
void SHA1Init(SHA1_CTX *context)
void netpgpv_SHA1Init(NETPGPV_SHA1_CTX *context)
{
/* SHA1 initialization constants */
@@ -202,7 +200,7 @@ void SHA1Init(SHA1_CTX *context)
/*
* Run your data through this.
*/
void SHA1Update(SHA1_CTX *context, const uint8_t *data, unsigned int len)
void netpgpv_SHA1Update(NETPGPV_SHA1_CTX *context, const uint8_t *data, unsigned int len)
{
unsigned int i, j;
@@ -212,9 +210,9 @@ void SHA1Update(SHA1_CTX *context, const uint8_t *data, unsigned int len)
j = (j >> 3) & 63;
if ((j + len) > 63) {
(void)memcpy(&context->buffer[j], data, (i = 64-j));
SHA1Transform(context->state, context->buffer);
netpgpv_SHA1Transform(context->state, context->buffer);
for ( ; i + 63 < len; i += 64)
SHA1Transform(context->state, &data[i]);
netpgpv_SHA1Transform(context->state, &data[i]);
j = 0;
} else {
i = 0;
@@ -226,7 +224,7 @@ void SHA1Update(SHA1_CTX *context, const uint8_t *data, unsigned int len)
/*
* Add padding and return the message digest.
*/
void SHA1Final(uint8_t digest[20], SHA1_CTX *context)
void netpgpv_SHA1Final(uint8_t digest[20], NETPGPV_SHA1_CTX *context)
{
unsigned int i;
uint8_t finalcount[8];
@@ -235,10 +233,10 @@ void SHA1Final(uint8_t digest[20], SHA1_CTX *context)
finalcount[i] = (uint8_t)((context->count[(i >= 4 ? 0 : 1)]
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
}
SHA1Update(context, (const uint8_t *)"\200", 1);
netpgpv_SHA1Update(context, (const uint8_t *)"\200", 1);
while ((context->count[0] & 504) != 448)
SHA1Update(context, (const uint8_t *)"\0", 1);
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
netpgpv_SHA1Update(context, (const uint8_t *)"\0", 1);
netpgpv_SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
if (digest) {
for (i = 0; i < 20; i++)

31
security/netpgpverify/files/sha1.h
View File

@@ -1,4 +1,4 @@
/* $NetBSD: sha1.h,v 1.1 2013/03/16 07:32:35 agc Exp $ */
/* $NetBSD: sha1.h,v 1.3 2015/09/01 19:38:42 agc Exp $ */
/*
* SHA-1 in C
@@ -9,7 +9,6 @@
#ifndef _SYS_SHA1_H_
#define _SYS_SHA1_H_
#include <sys/cdefs.h>
#include <sys/types.h>
#include <inttypes.h>
@@ -17,22 +16,32 @@
#define SHA1_DIGEST_LENGTH 20
#define SHA1_DIGEST_STRING_LENGTH 41
#ifndef __BEGIN_DECLS
# if defined(__cplusplus)
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
# else
# define __BEGIN_DECLS
# define __END_DECLS
# endif
#endif
typedef struct {
uint32_t state[5];
uint32_t count[2];
uint8_t buffer[64];
} SHA1_CTX;
} NETPGPV_SHA1_CTX;
__BEGIN_DECLS
void SHA1Transform(uint32_t[5], const uint8_t[64]);
void SHA1Init(SHA1_CTX *);
void SHA1Update(SHA1_CTX *, const uint8_t *, unsigned int);
void SHA1Final(uint8_t[SHA1_DIGEST_LENGTH], SHA1_CTX *);
void netpgpv_SHA1Transform(uint32_t[5], const uint8_t[64]);
void netpgpv_SHA1Init(NETPGPV_SHA1_CTX *);
void netpgpv_SHA1Update(NETPGPV_SHA1_CTX *, const uint8_t *, unsigned int);
void netpgpv_SHA1Final(uint8_t[SHA1_DIGEST_LENGTH], NETPGPV_SHA1_CTX *);
#ifndef _KERNEL
char *SHA1End(SHA1_CTX *, char *);
char *SHA1FileChunk(const char *, char *, off_t, off_t);
char *SHA1File(const char *, char *);
char *SHA1Data(const uint8_t *, size_t, char *);
char *netpgpv_SHA1End(NETPGPV_SHA1_CTX *, char *);
char *netpgpv_SHA1FileChunk(const char *, char *, off_t, off_t);
char *netpgpv_SHA1File(const char *, char *);
char *netpgpv_SHA1Data(const uint8_t *, size_t, char *);
#endif /* _KERNEL */
__END_DECLS

90
security/netpgpverify/files/sha2.c
View File

@@ -1,4 +1,4 @@
/* $NetBSD: sha2.c,v 1.2 2013/03/24 16:48:17 joerg Exp $ */
/* $NetBSD: sha2.c,v 1.5 2015/09/02 17:15:09 jperkin Exp $ */
/* $KAME: sha2.c,v 1.9 2003/07/20 00:28:38 itojun Exp $ */
/*
@@ -36,8 +36,6 @@
*
*/
#include <sys/cdefs.h>
#include <sys/types.h>
#include <inttypes.h>
@@ -161,11 +159,11 @@ be64toh(uint64_t x)
* library -- they are intended for private internal visibility/use
* only.
*/
static void SHA512_Last(SHA512_CTX *);
void SHA224_Transform(SHA224_CTX *, const uint32_t*);
void SHA256_Transform(SHA256_CTX *, const uint32_t*);
void SHA384_Transform(SHA384_CTX *, const uint64_t*);
void SHA512_Transform(SHA512_CTX *, const uint64_t*);
static void netpgpv_SHA512_Last(NETPGPV_SHA512_CTX *);
void netpgpv_SHA224_Transform(NETPGPV_SHA224_CTX *, const uint32_t*);
void netpgpv_SHA256_Transform(NETPGPV_SHA256_CTX *, const uint32_t*);
void netpgpv_SHA384_Transform(NETPGPV_SHA384_CTX *, const uint64_t*);
void netpgpv_SHA512_Transform(NETPGPV_SHA512_CTX *, const uint64_t*);
/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
@@ -283,7 +281,7 @@ static const uint64_t sha512_initial_hash_value[8] = {
/*** SHA-256: *********************************************************/
int
SHA256_Init(SHA256_CTX *context)
netpgpv_SHA256_Init(NETPGPV_SHA256_CTX *context)
{
if (context == NULL)
return 1;
@@ -321,7 +319,7 @@ SHA256_Init(SHA256_CTX *context)
j++
void
SHA256_Transform(SHA256_CTX *context, const uint32_t *data)
netpgpv_SHA256_Transform(NETPGPV_SHA256_CTX *context, const uint32_t *data)
{
uint32_t a, b, c, d, e, f, g, h, s0, s1;
uint32_t T1, *W256;
@@ -381,7 +379,7 @@ SHA256_Transform(SHA256_CTX *context, const uint32_t *data)
#else /* SHA2_UNROLL_TRANSFORM */
void
SHA256_Transform(SHA256_CTX *context, const uint32_t *data)
netpgpv_SHA256_Transform(NETPGPV_SHA256_CTX *context, const uint32_t *data)
{
uint32_t a, b, c, d, e, f, g, h, s0, s1;
uint32_t T1, T2, *W256;
@@ -458,7 +456,7 @@ SHA256_Transform(SHA256_CTX *context, const uint32_t *data)
#endif /* SHA2_UNROLL_TRANSFORM */
int
SHA256_Update(SHA256_CTX *context, const uint8_t *data, size_t len)
netpgpv_SHA256_Update(NETPGPV_SHA256_CTX *context, const uint8_t *data, size_t len)
{
unsigned int freespace, usedspace;
@@ -480,7 +478,7 @@ SHA256_Update(SHA256_CTX *context, const uint8_t *data, size_t len)
context->bitcount += freespace << 3;
len -= freespace;
data += freespace;
SHA256_Transform(context,
netpgpv_SHA256_Transform(context,
(uint32_t *)(void *)context->buffer);
} else {
/* The buffer is not yet full */
@@ -500,7 +498,7 @@ SHA256_Update(SHA256_CTX *context, const uint8_t *data, size_t len)
*/
if ((uintptr_t)data % 4 == 0) {
while (len >= SHA256_BLOCK_LENGTH) {
SHA256_Transform(context,
netpgpv_SHA256_Transform(context,
(const uint32_t *)(const void *)data);
context->bitcount += SHA256_BLOCK_LENGTH << 3;
len -= SHA256_BLOCK_LENGTH;
@@ -509,7 +507,7 @@ SHA256_Update(SHA256_CTX *context, const uint8_t *data, size_t len)
} else {
while (len >= SHA256_BLOCK_LENGTH) {
memcpy(context->buffer, data, SHA256_BLOCK_LENGTH);
SHA256_Transform(context,
netpgpv_SHA256_Transform(context,
(const uint32_t *)(const void *)context->buffer);
context->bitcount += SHA256_BLOCK_LENGTH << 3;
len -= SHA256_BLOCK_LENGTH;
@@ -528,7 +526,7 @@ SHA256_Update(SHA256_CTX *context, const uint8_t *data, size_t len)
}
static int
SHA224_256_Final(uint8_t digest[], SHA256_CTX *context, size_t len)
netpgpv_SHA224_256_Final(uint8_t digest[], NETPGPV_SHA256_CTX *context, size_t len)
{
unsigned int usedspace;
size_t i;
@@ -554,7 +552,7 @@ SHA224_256_Final(uint8_t digest[], SHA256_CTX *context, size_t len)
usedspace));
}
/* Do second-to-last transform: */
SHA256_Transform(context,
netpgpv_SHA256_Transform(context,
(uint32_t *)(void *)context->buffer);
/* And set-up for the last transform: */
@@ -574,7 +572,7 @@ SHA224_256_Final(uint8_t digest[], SHA256_CTX *context, size_t len)
&context->bitcount, sizeof(context->bitcount));
/* Final transform: */
SHA256_Transform(context, (uint32_t *)(void *)context->buffer);
netpgpv_SHA256_Transform(context, (uint32_t *)(void *)context->buffer);
for (i = 0; i < len / 4; i++)
be32encode(digest + 4 * i, context->state[i]);
@@ -588,14 +586,14 @@ SHA224_256_Final(uint8_t digest[], SHA256_CTX *context, size_t len)
}
int
SHA256_Final(uint8_t digest[], SHA256_CTX *context)
netpgpv_SHA256_Final(uint8_t digest[], NETPGPV_SHA256_CTX *context)
{
return SHA224_256_Final(digest, context, SHA256_DIGEST_LENGTH);
return netpgpv_SHA224_256_Final(digest, context, SHA256_DIGEST_LENGTH);
}
/*** SHA-224: *********************************************************/
int
SHA224_Init(SHA224_CTX *context)
netpgpv_SHA224_Init(NETPGPV_SHA224_CTX *context)
{
if (context == NULL)
return 1;
@@ -610,27 +608,27 @@ SHA224_Init(SHA224_CTX *context)
}
int
SHA224_Update(SHA224_CTX *context, const uint8_t *data, size_t len)
netpgpv_SHA224_Update(NETPGPV_SHA224_CTX *context, const uint8_t *data, size_t len)
{
return SHA256_Update((SHA256_CTX *)context, data, len);
return netpgpv_SHA256_Update((NETPGPV_SHA256_CTX *)context, data, len);
}
void
SHA224_Transform(SHA224_CTX *context, const uint32_t *data)
netpgpv_SHA224_Transform(NETPGPV_SHA224_CTX *context, const uint32_t *data)
{
SHA256_Transform((SHA256_CTX *)context, data);
netpgpv_SHA256_Transform((NETPGPV_SHA256_CTX *)context, data);
}
int
SHA224_Final(uint8_t digest[], SHA224_CTX *context)
netpgpv_SHA224_Final(uint8_t digest[], NETPGPV_SHA224_CTX *context)
{
return SHA224_256_Final(digest, (SHA256_CTX *)context,
return netpgpv_SHA224_256_Final(digest, (NETPGPV_SHA256_CTX *)context,
SHA224_DIGEST_LENGTH);
}
/*** SHA-512: *********************************************************/
int
SHA512_Init(SHA512_CTX *context)
netpgpv_SHA512_Init(NETPGPV_SHA512_CTX *context)
{
if (context == NULL)
return 1;
@@ -667,7 +665,7 @@ SHA512_Init(SHA512_CTX *context)
j++
void
SHA512_Transform(SHA512_CTX *context, const uint64_t *data)
netpgpv_SHA512_Transform(NETPGPV_SHA512_CTX *context, const uint64_t *data)
{
uint64_t a, b, c, d, e, f, g, h, s0, s1;
uint64_t T1, *W512 = (uint64_t *)context->buffer;
@@ -724,7 +722,7 @@ SHA512_Transform(SHA512_CTX *context, const uint64_t *data)
#else /* SHA2_UNROLL_TRANSFORM */
void
SHA512_Transform(SHA512_CTX *context, const uint64_t *data)
netpgpv_SHA512_Transform(NETPGPV_SHA512_CTX *context, const uint64_t *data)
{
uint64_t a, b, c, d, e, f, g, h, s0, s1;
uint64_t T1, T2, *W512 = (void *)context->buffer;
@@ -799,7 +797,7 @@ SHA512_Transform(SHA512_CTX *context, const uint64_t *data)
#endif /* SHA2_UNROLL_TRANSFORM */
int
SHA512_Update(SHA512_CTX *context, const uint8_t *data, size_t len)
netpgpv_SHA512_Update(NETPGPV_SHA512_CTX *context, const uint8_t *data, size_t len)
{
unsigned int freespace, usedspace;
@@ -821,7 +819,7 @@ SHA512_Update(SHA512_CTX *context, const uint8_t *data, size_t len)
ADDINC128(context->bitcount, freespace << 3);
len -= freespace;
data += freespace;
SHA512_Transform(context,
netpgpv_SHA512_Transform(context,
(uint64_t *)(void *)context->buffer);
} else {
/* The buffer is not yet full */
@@ -841,7 +839,7 @@ SHA512_Update(SHA512_CTX *context, const uint8_t *data, size_t len)
*/
if ((uintptr_t)data % 8 == 0) {
while (len >= SHA512_BLOCK_LENGTH) {
SHA512_Transform(context,
netpgpv_SHA512_Transform(context,
(const uint64_t*)(const void *)data);
ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
len -= SHA512_BLOCK_LENGTH;
@@ -850,7 +848,7 @@ SHA512_Update(SHA512_CTX *context, const uint8_t *data, size_t len)
} else {
while (len >= SHA512_BLOCK_LENGTH) {
memcpy(context->buffer, data, SHA512_BLOCK_LENGTH);
SHA512_Transform(context,
netpgpv_SHA512_Transform(context,
(const void *)context->buffer);
ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
len -= SHA512_BLOCK_LENGTH;
@@ -869,7 +867,7 @@ SHA512_Update(SHA512_CTX *context, const uint8_t *data, size_t len)
}
static void
SHA512_Last(SHA512_CTX *context)
netpgpv_SHA512_Last(NETPGPV_SHA512_CTX *context)
{
unsigned int usedspace;
@@ -890,7 +888,7 @@ SHA512_Last(SHA512_CTX *context)
(size_t)(SHA512_BLOCK_LENGTH - usedspace));
}
/* Do second-to-last transform: */
SHA512_Transform(context,
netpgpv_SHA512_Transform(context,
(uint64_t *)(void *)context->buffer);
/* And set-up for the last transform: */
@@ -911,17 +909,17 @@ SHA512_Last(SHA512_CTX *context)
&context->bitcount[0], sizeof(context->bitcount[0]));
/* Final transform: */
SHA512_Transform(context, (uint64_t *)(void *)context->buffer);
netpgpv_SHA512_Transform(context, (uint64_t *)(void *)context->buffer);
}
int
SHA512_Final(uint8_t digest[], SHA512_CTX *context)
netpgpv_SHA512_Final(uint8_t digest[], NETPGPV_SHA512_CTX *context)
{
size_t i;
/* If no digest buffer is passed, we don't bother doing this: */
if (digest != NULL) {
SHA512_Last(context);
netpgpv_SHA512_Last(context);
/* Save the hash data for output: */
for (i = 0; i < 8; ++i)
@@ -936,7 +934,7 @@ SHA512_Final(uint8_t digest[], SHA512_CTX *context)
/*** SHA-384: *********************************************************/
int
SHA384_Init(SHA384_CTX *context)
netpgpv_SHA384_Init(NETPGPV_SHA384_CTX *context)
{
if (context == NULL)
return 1;
@@ -950,25 +948,25 @@ SHA384_Init(SHA384_CTX *context)
}
int
SHA384_Update(SHA384_CTX *context, const uint8_t *data, size_t len)
netpgpv_SHA384_Update(NETPGPV_SHA384_CTX *context, const uint8_t *data, size_t len)
{
return SHA512_Update((SHA512_CTX *)context, data, len);
return netpgpv_SHA512_Update((NETPGPV_SHA512_CTX *)context, data, len);
}
void
SHA384_Transform(SHA512_CTX *context, const uint64_t *data)
netpgpv_SHA384_Transform(NETPGPV_SHA512_CTX *context, const uint64_t *data)
{
SHA512_Transform((SHA512_CTX *)context, data);
netpgpv_SHA512_Transform((NETPGPV_SHA512_CTX *)context, data);
}
int
SHA384_Final(uint8_t digest[], SHA384_CTX *context)
netpgpv_SHA384_Final(uint8_t digest[], NETPGPV_SHA384_CTX *context)
{
size_t i;
/* If no digest buffer is passed, we don't bother doing this: */
if (digest != NULL) {
SHA512_Last((SHA512_CTX *)context);
netpgpv_SHA512_Last((NETPGPV_SHA512_CTX *)context);
/* Save the hash data for output: */
for (i = 0; i < 6; ++i)

80
security/netpgpverify/files/sha2.h
View File

@@ -1,4 +1,4 @@
/* $NetBSD: sha2.h,v 1.1 2013/03/16 07:32:35 agc Exp $ */
/* $NetBSD: sha2.h,v 1.4 2015/09/06 21:25:19 jperkin Exp $ */
/* $KAME: sha2.h,v 1.4 2003/07/20 00:28:38 itojun Exp $ */
/*
@@ -40,7 +40,6 @@
#define __SHA2_H__
#include <sys/types.h>
#include <sys/cdefs.h>
/*** SHA-224/256/384/512 Various Length Definitions ***********************/
#define SHA224_BLOCK_LENGTH 64
@@ -56,64 +55,73 @@
#define SHA512_DIGEST_LENGTH 64
#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
#ifndef __BEGIN_DECLS
# if defined(__cplusplus)
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
# else
# define __BEGIN_DECLS
# define __END_DECLS
# endif
#endif
/*** SHA-256/384/512 Context Structures *******************************/
typedef struct _SHA256_CTX {
typedef struct _NETPGPV_SHA256_CTX {
uint32_t state[8];
uint64_t bitcount;
uint8_t buffer[SHA256_BLOCK_LENGTH];
} SHA256_CTX;
} NETPGPV_SHA256_CTX;
typedef struct _SHA512_CTX {
typedef struct _NETPGPV_SHA512_CTX {
uint64_t state[8];
uint64_t bitcount[2];
uint8_t buffer[SHA512_BLOCK_LENGTH];
} SHA512_CTX;
} NETPGPV_SHA512_CTX;
typedef SHA256_CTX SHA224_CTX;
typedef SHA512_CTX SHA384_CTX;
typedef NETPGPV_SHA256_CTX NETPGPV_SHA224_CTX;
typedef NETPGPV_SHA512_CTX NETPGPV_SHA384_CTX;
/*** SHA-256/384/512 Function Prototypes ******************************/
__BEGIN_DECLS
int SHA224_Init(SHA224_CTX *);
int SHA224_Update(SHA224_CTX*, const uint8_t*, size_t);
int SHA224_Final(uint8_t[SHA224_DIGEST_LENGTH], SHA224_CTX*);
int netpgpv_SHA224_Init(NETPGPV_SHA224_CTX *);
int netpgpv_SHA224_Update(NETPGPV_SHA224_CTX*, const uint8_t*, size_t);
int netpgpv_SHA224_Final(uint8_t[SHA224_DIGEST_LENGTH], NETPGPV_SHA224_CTX*);
#ifndef _KERNEL
char *SHA224_End(SHA224_CTX *, char[SHA224_DIGEST_STRING_LENGTH]);
char *SHA224_FileChunk(const char *, char *, off_t, off_t);
char *SHA224_File(const char *, char *);
char *SHA224_Data(const uint8_t *, size_t, char[SHA224_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA224_End(NETPGPV_SHA224_CTX *, char[SHA224_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA224_FileChunk(const char *, char *, off_t, off_t);
char *netpgpv_SHA224_File(const char *, char *);
char *netpgpv_SHA224_Data(const uint8_t *, size_t, char[SHA224_DIGEST_STRING_LENGTH]);
#endif /* !_KERNEL */
int SHA256_Init(SHA256_CTX *);
int SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
int SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
int netpgpv_SHA256_Init(NETPGPV_SHA256_CTX *);
int netpgpv_SHA256_Update(NETPGPV_SHA256_CTX*, const uint8_t*, size_t);
int netpgpv_SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], NETPGPV_SHA256_CTX*);
#ifndef _KERNEL
char *SHA256_End(SHA256_CTX *, char[SHA256_DIGEST_STRING_LENGTH]);
char *SHA256_FileChunk(const char *, char *, off_t, off_t);
char *SHA256_File(const char *, char *);
char *SHA256_Data(const uint8_t *, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA256_End(NETPGPV_SHA256_CTX *, char[SHA256_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA256_FileChunk(const char *, char *, off_t, off_t);
char *netpgpv_SHA256_File(const char *, char *);
char *netpgpv_SHA256_Data(const uint8_t *, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
#endif /* !_KERNEL */
int SHA384_Init(SHA384_CTX*);
int SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
int SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
int netpgpv_SHA384_Init(NETPGPV_SHA384_CTX*);
int netpgpv_SHA384_Update(NETPGPV_SHA384_CTX*, const uint8_t*, size_t);
int netpgpv_SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], NETPGPV_SHA384_CTX*);
#ifndef _KERNEL
char *SHA384_End(SHA384_CTX *, char[SHA384_DIGEST_STRING_LENGTH]);
char *SHA384_FileChunk(const char *, char *, off_t, off_t);
char *SHA384_File(const char *, char *);
char *SHA384_Data(const uint8_t *, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA384_End(NETPGPV_SHA384_CTX *, char[SHA384_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA384_FileChunk(const char *, char *, off_t, off_t);
char *netpgpv_SHA384_File(const char *, char *);
char *netpgpv_SHA384_Data(const uint8_t *, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
#endif /* !_KERNEL */
int SHA512_Init(SHA512_CTX*);
int SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
int SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
int netpgpv_SHA512_Init(NETPGPV_SHA512_CTX*);
int netpgpv_SHA512_Update(NETPGPV_SHA512_CTX*, const uint8_t*, size_t);
int netpgpv_SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], NETPGPV_SHA512_CTX*);
#ifndef _KERNEL
char *SHA512_End(SHA512_CTX *, char[SHA512_DIGEST_STRING_LENGTH]);
char *SHA512_FileChunk(const char *, char *, off_t, off_t);
char *SHA512_File(const char *, char *);
char *SHA512_Data(const uint8_t *, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA512_End(NETPGPV_SHA512_CTX *, char[SHA512_DIGEST_STRING_LENGTH]);
char *netpgpv_SHA512_FileChunk(const char *, char *, off_t, off_t);
char *netpgpv_SHA512_File(const char *, char *);
char *netpgpv_SHA512_Data(const uint8_t *, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#endif /* !_KERNEL */
__END_DECLS

38
security/netpgpverify/files/tiger.c
View File

@@ -719,7 +719,7 @@ sprint_uint64(char *buf, uint64_t val)
/* common function to initialise context */
static void
initcontext(TIGER_CTX *ctx, uint8_t pad)
initcontext(NETPGPV_TIGER_CTX *ctx, uint8_t pad)
{
(void) memset(ctx, 0x0, sizeof(*ctx));
ctx->ctx[0] = 0x0123456789ABCDEFLL;
@@ -731,7 +731,7 @@ initcontext(TIGER_CTX *ctx, uint8_t pad)
/* set the version number (0 is same as 1 for Tiger) */
static int
setversion(TIGER_CTX *ctx, int version)
setversion(NETPGPV_TIGER_CTX *ctx, int version)
{
switch(version) {
case 0:
@@ -751,7 +751,7 @@ setversion(TIGER_CTX *ctx, int version)
/*****************************************************************************/
void
TIGER_Init(TIGER_CTX *ctx)
netpgpv_TIGER_Init(NETPGPV_TIGER_CTX *ctx)
{
if (ctx) {
initcontext(ctx, 0x01);
@@ -759,7 +759,7 @@ TIGER_Init(TIGER_CTX *ctx)
}
void
TIGER2_Init(TIGER_CTX *ctx)
netpgpv_TIGER2_Init(NETPGPV_TIGER_CTX *ctx)
{
if (ctx) {
initcontext(ctx, 0x80);
@@ -767,7 +767,7 @@ TIGER2_Init(TIGER_CTX *ctx)
}
void
TIGER_Update(TIGER_CTX *ctx, const void *data, size_t length)
netpgpv_TIGER_Update(NETPGPV_TIGER_CTX *ctx, const void *data, size_t length)
{
const uint64_t *str = (const uint64_t *)data;
uint64_t i;
@@ -824,7 +824,7 @@ TIGER_Update(TIGER_CTX *ctx, const void *data, size_t length)
}
void
TIGER_Final(uint8_t *digest, TIGER_CTX *ctx)
netpgpv_TIGER_Final(uint8_t *digest, NETPGPV_TIGER_CTX *ctx)
{
uint64_t le[3];
int indian = 1;
@@ -834,8 +834,8 @@ TIGER_Final(uint8_t *digest, TIGER_CTX *ctx)
return;
}
if (!ctx->init) {
TIGER_Init(ctx);
TIGER_Update(ctx, NULL, 0);
netpgpv_TIGER_Init(ctx);
netpgpv_TIGER_Update(ctx, NULL, 0);
}
if (IS_LITTLE_ENDIAN(indian)) {
for (i = 0; i < 3; ++i) {
@@ -848,7 +848,7 @@ TIGER_Final(uint8_t *digest, TIGER_CTX *ctx)
}
char *
TIGER_End(TIGER_CTX *ctx, char *buf)
netpgpv_TIGER_End(NETPGPV_TIGER_CTX *ctx, char *buf)
{
int i;
@@ -859,8 +859,8 @@ TIGER_End(TIGER_CTX *ctx, char *buf)
return NULL;
}
if (!ctx->init) {
TIGER_Init(ctx);
TIGER_Update(ctx, NULL, 0);
netpgpv_TIGER_Init(ctx);
netpgpv_TIGER_Update(ctx, NULL, 0);
}
for (i = 0; i < 3; ++i) {
sprint_uint64(buf + i * 16, ctx->ctx[i]);
@@ -870,9 +870,9 @@ TIGER_End(TIGER_CTX *ctx, char *buf)
}
char *
TIGER_File(char *filename, char *buf, int version)
netpgpv_TIGER_File(char *filename, char *buf, int version)
{
TIGER_CTX ctx;
NETPGPV_TIGER_CTX ctx;
uint8_t buffer[BUFSIZ];
ssize_t num;
int fd;
@@ -885,22 +885,22 @@ TIGER_File(char *filename, char *buf, int version)
return NULL;
}
while ((num = read(fd, buffer, sizeof(buffer))) > 0) {
TIGER_Update(&ctx, buffer, (size_t)num);
netpgpv_TIGER_Update(&ctx, buffer, (size_t)num);
}
oerrno = errno;
close(fd);
errno = oerrno;
return (num < 0) ? NULL : TIGER_End(&ctx, buf);
return (num < 0) ? NULL : netpgpv_TIGER_End(&ctx, buf);
}
char *
TIGER_Data(const uint8_t *data, size_t len, char *buf, int version)
netpgpv_TIGER_Data(const uint8_t *data, size_t len, char *buf, int version)
{
TIGER_CTX ctx;
NETPGPV_TIGER_CTX ctx;
if (data == NULL || buf == NULL || !setversion(&ctx, version)) {
return NULL;
}
TIGER_Update(&ctx, data, len);
return TIGER_End(&ctx, buf);
netpgpv_TIGER_Update(&ctx, data, len);
return netpgpv_TIGER_End(&ctx, buf);
}

18
security/netpgpverify/files/tiger.h
View File

@@ -44,21 +44,21 @@ __BEGIN_DECLS
#define TIGER_DIGEST_LENGTH 24
#define TIGER_DIGEST_STRING_LENGTH ((TIGER_DIGEST_LENGTH * 2) + 1)
typedef struct TIGER_CTX {
typedef struct NETPGPV_TIGER_CTX {
uint64_t ctx[3];
int init;
uint8_t pad;
} TIGER_CTX;
} NETPGPV_TIGER_CTX;
void TIGER_Init(TIGER_CTX *);
void TIGER2_Init(TIGER_CTX *);
void TIGER_Update(TIGER_CTX *, const void *, size_t);
void TIGER_Final(uint8_t *, TIGER_CTX *);
void netpgpv_TIGER_Init(NETPGPV_TIGER_CTX *);
void netpgpv_TIGER2_Init(NETPGPV_TIGER_CTX *);
void netpgpv_TIGER_Update(NETPGPV_TIGER_CTX *, const void *, size_t);
void netpgpv_TIGER_Final(uint8_t *, NETPGPV_TIGER_CTX *);
char *TIGER_End(TIGER_CTX *, char *);
char *netpgpv_TIGER_End(NETPGPV_TIGER_CTX *, char *);
char *TIGER_File(char *, char *, int);
char *TIGER_Data(const uint8_t *, size_t, char *, int);
char *netpgpv_TIGER_File(char *, char *, int);
char *netpgpv_TIGER_Data(const uint8_t *, size_t, char *, int);
__END_DECLS

4
security/netpgpverify/files/verify.h
View File

@@ -23,9 +23,9 @@
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef NETPGP_VERIFY_H_
#define NETPGP_VERIFY_H_ 20150205
#define NETPGP_VERIFY_H_ 20150911
#define NETPGPVERIFY_VERSION "netpgpverify portable 20150205"
#define NETPGPVERIFY_VERSION "netpgpverify portable 20150901"
#include <sys/types.h>