 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.14 2015/08/17 11:37:55 jperkin Exp $
+# $NetBSD: Makefile,v 1.15 2015/09/01 19:38:42 agc Exp $
-DISTNAME=		netpgpverify-20150205
+DISTNAME=		netpgpverify-20150901
 CATEGORIES=		security
 MASTER_SITES=		# empty
 DISTFILES=		# empty
 MAINTAINER=		agc@NetBSD.org
 HOMEPAGE=		http://www.NetBSD.org/
 COMMENT=		Standalone PGP and ssh signature verification utility
 LICENSE=		modified-bsd
 AUTO_MKDIRS=		yes
 GNU_CONFIGURE=		yes
 TEST_TARGET=		tst

	@@ -211,27 +211,27 @@ trim_unused_digits(mp_int * a)		@@ -211,27 +211,27 @@ trim_unused_digits(mp_int * a)
211	* zero.	211	* zero.
212	*/	212	*/
213	while (a->used > 0 && a->dp[a->used - 1] == 0) {	213	while (a->used > 0 && a->dp[a->used - 1] == 0) {
214	a->used -= 1;	214	a->used -= 1;
215	}	215	}
216	/* reset the sign flag if used == 0 */	216	/* reset the sign flag if used == 0 */
217	if (a->used == 0) {	217	if (a->used == 0) {
218	a->sign = MP_ZPOS;	218	a->sign = MP_ZPOS;
219	}	219	}
220	}	220	}
221		221
222	/* copy, b = a */	222	/* copy, b = a */
223	static int	223	static int
224	mp_copy(BIGNUM a, BIGNUM b)	224	mp_copy(PGPV_BIGNUM a, PGPV_BIGNUM b)
225	{	225	{
226	int res;	226	int res;
227		227
228	/* if dst == src do nothing */	228	/* if dst == src do nothing */
229	if (a == b) {	229	if (a == b) {
230	return MP_OKAY;	230	return MP_OKAY;
231	}	231	}
232	if (a == NULL \|\| b == NULL) {	232	if (a == NULL \|\| b == NULL) {
233	return MP_VAL;	233	return MP_VAL;
234	}	234	}
235		235
236	/* grow dest */	236	/* grow dest */
237	if (b->alloc < a->used) {	237	if (b->alloc < a->used) {
	@@ -1328,51 +1328,51 @@ fast_modular_inverse(mp_int * a, mp_int		@@ -1328,51 +1328,51 @@ fast_modular_inverse(mp_int * a, mp_int
1328	}	1328	}
1329		1329
1330	/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */	1330	/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
1331	if ((res = mp_copy(&x, &u)) != MP_OKAY) {	1331	if ((res = mp_copy(&x, &u)) != MP_OKAY) {
1332	goto LBL_ERR;	1332	goto LBL_ERR;
1333	}	1333	}
1334	if ((res = mp_copy(&y, &v)) != MP_OKAY) {	1334	if ((res = mp_copy(&y, &v)) != MP_OKAY) {
1335	goto LBL_ERR;	1335	goto LBL_ERR;
1336	}	1336	}
1337	set_word(&D, 1);	1337	set_word(&D, 1);
1338		1338
1339	top:	1339	top:
1340	/* 4. while u is even do */	1340	/* 4. while u is even do */
1341	while (BN_is_even(&u) == 1) {	1341	while (PGPV_BN_is_even(&u) == 1) {
1342	/* 4.1 u = u/2 */	1342	/* 4.1 u = u/2 */
1343	if ((res = half(&u, &u)) != MP_OKAY) {	1343	if ((res = half(&u, &u)) != MP_OKAY) {
1344	goto LBL_ERR;	1344	goto LBL_ERR;
1345	}	1345	}
1346	/* 4.2 if B is odd then */	1346	/* 4.2 if B is odd then */
1347	if (BN_is_odd(&B) == 1) {	1347	if (PGPV_BN_is_odd(&B) == 1) {
1348	if ((res = signed_subtract(&B, &x, &B)) != MP_OKAY) {	1348	if ((res = signed_subtract(&B, &x, &B)) != MP_OKAY) {
1349	goto LBL_ERR;	1349	goto LBL_ERR;
1350	}	1350	}
1351	}	1351	}
1352	/* B = B/2 */	1352	/* B = B/2 */
1353	if ((res = half(&B, &B)) != MP_OKAY) {	1353	if ((res = half(&B, &B)) != MP_OKAY) {
1354	goto LBL_ERR;	1354	goto LBL_ERR;
1355	}	1355	}
1356	}	1356	}
1357		1357
1358	/* 5. while v is even do */	1358	/* 5. while v is even do */
1359	while (BN_is_even(&v) == 1) {	1359	while (PGPV_BN_is_even(&v) == 1) {
1360	/* 5.1 v = v/2 */	1360	/* 5.1 v = v/2 */
1361	if ((res = half(&v, &v)) != MP_OKAY) {	1361	if ((res = half(&v, &v)) != MP_OKAY) {
1362	goto LBL_ERR;	1362	goto LBL_ERR;
1363	}	1363	}
1364	/* 5.2 if D is odd then */	1364	/* 5.2 if D is odd then */
1365	if (BN_is_odd(&D) == 1) {	1365	if (PGPV_BN_is_odd(&D) == 1) {
1366	/* D = (D-x)/2 */	1366	/* D = (D-x)/2 */
1367	if ((res = signed_subtract(&D, &x, &D)) != MP_OKAY) {	1367	if ((res = signed_subtract(&D, &x, &D)) != MP_OKAY) {
1368	goto LBL_ERR;	1368	goto LBL_ERR;
1369	}	1369	}
1370	}	1370	}
1371	/* D = D/2 */	1371	/* D = D/2 */
1372	if ((res = half(&D, &D)) != MP_OKAY) {	1372	if ((res = half(&D, &D)) != MP_OKAY) {
1373	goto LBL_ERR;	1373	goto LBL_ERR;
1374	}	1374	}
1375	}	1375	}
1376		1376
1377	/* 6. if u >= v then */	1377	/* 6. if u >= v then */
1378	if (signed_compare(&u, &v) != MP_LT) {	1378	if (signed_compare(&u, &v) != MP_LT) {
	@@ -1441,75 +1441,75 @@ slow_modular_inverse(mp_int * a, mp_int		@@ -1441,75 +1441,75 @@ slow_modular_inverse(mp_int * a, mp_int
1441	&A, &B, &C, &D, NULL)) != MP_OKAY) {	1441	&A, &B, &C, &D, NULL)) != MP_OKAY) {
1442	return res;	1442	return res;
1443	}	1443	}
1444		1444
1445	/* x = a, y = b */	1445	/* x = a, y = b */
1446	if ((res = modulo(a, b, &x)) != MP_OKAY) {	1446	if ((res = modulo(a, b, &x)) != MP_OKAY) {
1447	goto LBL_ERR;	1447	goto LBL_ERR;
1448	}	1448	}
1449	if ((res = mp_copy(b, &y)) != MP_OKAY) {	1449	if ((res = mp_copy(b, &y)) != MP_OKAY) {
1450	goto LBL_ERR;	1450	goto LBL_ERR;
1451	}	1451	}
1452		1452
1453	/* 2. [modified] if x,y are both even then return an error! */	1453	/* 2. [modified] if x,y are both even then return an error! */
1454	if (BN_is_even(&x) == 1 && BN_is_even(&y) == 1) {	1454	if (PGPV_BN_is_even(&x) == 1 && PGPV_BN_is_even(&y) == 1) {
1455	res = MP_VAL;	1455	res = MP_VAL;
1456	goto LBL_ERR;	1456	goto LBL_ERR;
1457	}	1457	}
1458		1458
1459	/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */	1459	/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
1460	if ((res = mp_copy(&x, &u)) != MP_OKAY) {	1460	if ((res = mp_copy(&x, &u)) != MP_OKAY) {
1461	goto LBL_ERR;	1461	goto LBL_ERR;
1462	}	1462	}
1463	if ((res = mp_copy(&y, &v)) != MP_OKAY) {	1463	if ((res = mp_copy(&y, &v)) != MP_OKAY) {
1464	goto LBL_ERR;	1464	goto LBL_ERR;
1465	}	1465	}
1466	set_word(&A, 1);	1466	set_word(&A, 1);
1467	set_word(&D, 1);	1467	set_word(&D, 1);
1468		1468
1469	top:	1469	top:
1470	/* 4. while u is even do */	1470	/* 4. while u is even do */
1471	while (BN_is_even(&u) == 1) {	1471	while (PGPV_BN_is_even(&u) == 1) {
1472	/* 4.1 u = u/2 */	1472	/* 4.1 u = u/2 */
1473	if ((res = half(&u, &u)) != MP_OKAY) {	1473	if ((res = half(&u, &u)) != MP_OKAY) {
1474	goto LBL_ERR;	1474	goto LBL_ERR;
1475	}	1475	}
1476	/* 4.2 if A or B is odd then */	1476	/* 4.2 if A or B is odd then */
1477	if (BN_is_odd(&A) == 1 \|\| BN_is_odd(&B) == 1) {	1477	if (PGPV_BN_is_odd(&A) == 1 \|\| PGPV_BN_is_odd(&B) == 1) {
1478	/* A = (A+y)/2, B = (B-x)/2 */	1478	/* A = (A+y)/2, B = (B-x)/2 */
1479	if ((res = signed_add(&A, &y, &A)) != MP_OKAY) {	1479	if ((res = signed_add(&A, &y, &A)) != MP_OKAY) {
1480	goto LBL_ERR;	1480	goto LBL_ERR;
1481	}	1481	}
1482	if ((res = signed_subtract(&B, &x, &B)) != MP_OKAY) {	1482	if ((res = signed_subtract(&B, &x, &B)) != MP_OKAY) {
1483	goto LBL_ERR;	1483	goto LBL_ERR;
1484	}	1484	}
1485	}	1485	}
1486	/* A = A/2, B = B/2 */	1486	/* A = A/2, B = B/2 */
1487	if ((res = half(&A, &A)) != MP_OKAY) {	1487	if ((res = half(&A, &A)) != MP_OKAY) {
1488	goto LBL_ERR;	1488	goto LBL_ERR;
1489	}	1489	}
1490	if ((res = half(&B, &B)) != MP_OKAY) {	1490	if ((res = half(&B, &B)) != MP_OKAY) {
1491	goto LBL_ERR;	1491	goto LBL_ERR;
1492	}	1492	}
1493	}	1493	}
1494		1494
1495	/* 5. while v is even do */	1495	/* 5. while v is even do */
1496	while (BN_is_even(&v) == 1) {	1496	while (PGPV_BN_is_even(&v) == 1) {
1497	/* 5.1 v = v/2 */	1497	/* 5.1 v = v/2 */
1498	if ((res = half(&v, &v)) != MP_OKAY) {	1498	if ((res = half(&v, &v)) != MP_OKAY) {
1499	goto LBL_ERR;	1499	goto LBL_ERR;
1500	}	1500	}
1501	/* 5.2 if C or D is odd then */	1501	/* 5.2 if C or D is odd then */
1502	if (BN_is_odd(&C) == 1 \|\| BN_is_odd(&D) == 1) {	1502	if (PGPV_BN_is_odd(&C) == 1 \|\| PGPV_BN_is_odd(&D) == 1) {
1503	/* C = (C+y)/2, D = (D-x)/2 */	1503	/* C = (C+y)/2, D = (D-x)/2 */
1504	if ((res = signed_add(&C, &y, &C)) != MP_OKAY) {	1504	if ((res = signed_add(&C, &y, &C)) != MP_OKAY) {
1505	goto LBL_ERR;	1505	goto LBL_ERR;
1506	}	1506	}
1507	if ((res = signed_subtract(&D, &x, &D)) != MP_OKAY) {	1507	if ((res = signed_subtract(&D, &x, &D)) != MP_OKAY) {
1508	goto LBL_ERR;	1508	goto LBL_ERR;
1509	}	1509	}
1510	}	1510	}
1511	/* C = C/2, D = D/2 */	1511	/* C = C/2, D = D/2 */
1512	if ((res = half(&C, &C)) != MP_OKAY) {	1512	if ((res = half(&C, &C)) != MP_OKAY) {
1513	goto LBL_ERR;	1513	goto LBL_ERR;
1514	}	1514	}
1515	if ((res = half(&D, &D)) != MP_OKAY) {	1515	if ((res = half(&D, &D)) != MP_OKAY) {
	@@ -1537,27 +1537,27 @@ top:		@@ -1537,27 +1537,27 @@ top:
1537	goto LBL_ERR;	1537	goto LBL_ERR;
1538	}	1538	}
1539		1539
1540	if ((res = signed_subtract(&C, &A, &C)) != MP_OKAY) {	1540	if ((res = signed_subtract(&C, &A, &C)) != MP_OKAY) {
1541	goto LBL_ERR;	1541	goto LBL_ERR;
1542	}	1542	}
1543		1543
1544	if ((res = signed_subtract(&D, &B, &D)) != MP_OKAY) {	1544	if ((res = signed_subtract(&D, &B, &D)) != MP_OKAY) {
1545	goto LBL_ERR;	1545	goto LBL_ERR;
1546	}	1546	}
1547	}	1547	}
1548		1548
1549	/* if not zero goto step 4 */	1549	/* if not zero goto step 4 */
1550	if (BN_is_zero(&u) == 0) {	1550	if (PGPV_BN_is_zero(&u) == 0) {
1551	goto top;	1551	goto top;
1552	}	1552	}
1553	/* now a = C, b = D, gcd == gv /	1553	/* now a = C, b = D, gcd == gv /
1554		1554
1555	/* if v != 1 then there is no inverse */	1555	/* if v != 1 then there is no inverse */
1556	if (compare_digit(&v, 1) != MP_EQ) {	1556	if (compare_digit(&v, 1) != MP_EQ) {
1557	res = MP_VAL;	1557	res = MP_VAL;
1558	goto LBL_ERR;	1558	goto LBL_ERR;
1559	}	1559	}
1560		1560
1561	/* if its too low */	1561	/* if its too low */
1562	while (compare_digit(&C, 0) == MP_LT) {	1562	while (compare_digit(&C, 0) == MP_LT) {
1563	if ((res = signed_add(&C, b, &C)) != MP_OKAY) {	1563	if ((res = signed_add(&C, b, &C)) != MP_OKAY) {
	@@ -1579,27 +1579,27 @@ LBL_ERR:		@@ -1579,27 +1579,27 @@ LBL_ERR:
1579	mp_clear_multi(&x, &y, &u, &v, &A, &B, &C, &D, NULL);	1579	mp_clear_multi(&x, &y, &u, &v, &A, &B, &C, &D, NULL);
1580	return res;	1580	return res;
1581	}	1581	}
1582		1582
1583	static int	1583	static int
1584	modular_inverse(mp_int c, mp_int a, mp_int *b)	1584	modular_inverse(mp_int c, mp_int a, mp_int *b)
1585	{	1585	{
1586	/* b cannot be negative */	1586	/* b cannot be negative */
1587	if (b->sign == MP_NEG \|\| MP_ISZERO(b) == MP_YES) {	1587	if (b->sign == MP_NEG \|\| MP_ISZERO(b) == MP_YES) {
1588	return MP_VAL;	1588	return MP_VAL;
1589	}	1589	}
1590		1590
1591	/* if the modulus is odd we can use a faster routine instead */	1591	/* if the modulus is odd we can use a faster routine instead */
1592	if (BN_is_odd(b) == 1) {	1592	if (PGPV_BN_is_odd(b) == 1) {
1593	return fast_modular_inverse(a, b, c);	1593	return fast_modular_inverse(a, b, c);
1594	}	1594	}
1595	return slow_modular_inverse(a, b, c);	1595	return slow_modular_inverse(a, b, c);
1596	}	1596	}
1597		1597
1598	/* b = \|a\|	1598	/* b = \|a\|
1599	*	1599	*
1600	* Simple function copies the input and fixes the sign to positive	1600	* Simple function copies the input and fixes the sign to positive
1601	*/	1601	*/
1602	static int	1602	static int
1603	absolute(mp_int * a, mp_int * b)	1603	absolute(mp_int * a, mp_int * b)
1604	{	1604	{
1605	int res;	1605	int res;
	@@ -4346,27 +4346,27 @@ exponent_modulo(mp_int * G, mp_int * X,		@@ -4346,27 +4346,27 @@ exponent_modulo(mp_int * G, mp_int * X,
4346	if (mp_reduce_is_2k_l(P) == MP_YES) {	4346	if (mp_reduce_is_2k_l(P) == MP_YES) {
4347	return basic_exponent_mod(G, X, P, Y, 1);	4347	return basic_exponent_mod(G, X, P, Y, 1);
4348	}	4348	}
4349		4349
4350	/* is it a DR modulus? */	4350	/* is it a DR modulus? */
4351	diminished_radix = is_diminished_radix_modulus(P);	4351	diminished_radix = is_diminished_radix_modulus(P);
4352		4352
4353	/* if not, is it a unrestricted DR modulus? */	4353	/* if not, is it a unrestricted DR modulus? */
4354	if (!diminished_radix) {	4354	if (!diminished_radix) {
4355	diminished_radix = mp_reduce_is_2k(P) << 1;	4355	diminished_radix = mp_reduce_is_2k(P) << 1;
4356	}	4356	}
4357		4357
4358	/* if the modulus is odd or diminished_radix, use the montgomery method */	4358	/* if the modulus is odd or diminished_radix, use the montgomery method */
4359	if (BN_is_odd(P) == 1 \|\| diminished_radix) {	4359	if (PGPV_BN_is_odd(P) == 1 \|\| diminished_radix) {
4360	return fast_exponent_modulo(G, X, P, Y, diminished_radix);	4360	return fast_exponent_modulo(G, X, P, Y, diminished_radix);
4361	}	4361	}
4362	/* otherwise use the generic Barrett reduction technique */	4362	/* otherwise use the generic Barrett reduction technique */
4363	return basic_exponent_mod(G, X, P, Y, 0);	4363	return basic_exponent_mod(G, X, P, Y, 0);
4364	}	4364	}
4365		4365
4366	/* reverse an array, used for radix code */	4366	/* reverse an array, used for radix code */
4367	static void	4367	static void
4368	bn_reverse(unsigned char *s, int len)	4368	bn_reverse(unsigned char *s, int len)
4369	{	4369	{
4370	int ix, iy;	4370	int ix, iy;
4371	uint8_t t;	4371	uint8_t t;
4372		4372
	@@ -5014,27 +5014,27 @@ mp_toradix_n(mp_int * a, char *str, int		@@ -5014,27 +5014,27 @@ mp_toradix_n(mp_int * a, char *str, int
5014	/* reverse the digits of the string. In this case _s points	5014	/* reverse the digits of the string. In this case _s points
5015	* to the first digit [exluding the sign] of the number	5015	* to the first digit [exluding the sign] of the number
5016	*/	5016	*/
5017	bn_reverse((unsigned char *)_s, digs);	5017	bn_reverse((unsigned char *)_s, digs);
5018		5018
5019	/* append a NULL so the string is properly terminated */	5019	/* append a NULL so the string is properly terminated */
5020	*str = '\0';	5020	*str = '\0';
5021		5021
5022	mp_clear(&t);	5022	mp_clear(&t);
5023	return MP_OKAY;	5023	return MP_OKAY;
5024	}	5024	}
5025		5025
5026	static char *	5026	static char *
5027	formatbn(const BIGNUM *a, const int radix)	5027	formatbn(const PGPV_BIGNUM *a, const int radix)
5028	{	5028	{
5029	char *s;	5029	char *s;
5030	int len;	5030	int len;
5031		5031
5032	if (mp_radix_size(__UNCONST(a), radix, &len) != MP_OKAY) {	5032	if (mp_radix_size(__UNCONST(a), radix, &len) != MP_OKAY) {
5033	return NULL;	5033	return NULL;
5034	}	5034	}
5035	if ((s = allocate(1, (size_t)len)) != NULL) {	5035	if ((s = allocate(1, (size_t)len)) != NULL) {
5036	if (mp_toradix_n(__UNCONST(a), s, radix, len) != MP_OKAY) {	5036	if (mp_toradix_n(__UNCONST(a), s, radix, len) != MP_OKAY) {
5037	deallocate(s, (size_t)len);	5037	deallocate(s, (size_t)len);
5038	return NULL;	5038	return NULL;
5039	}	5039	}
5040	}	5040	}
	@@ -5076,31 +5076,31 @@ mp_getradix_num(mp_int *a, int radix, ch		@@ -5076,31 +5076,31 @@ mp_getradix_num(mp_int *a, int radix, ch
5076	return err;	5076	return err;
5077	}	5077	}
5078		5078
5079	ch = *s++;	5079	ch = *s++;
5080	}	5080	}
5081	if (compare_digit(a, 0) != MP_EQ) {	5081	if (compare_digit(a, 0) != MP_EQ) {
5082	a->sign = neg;	5082	a->sign = neg;
5083	}	5083	}
5084		5084
5085	return MP_OKAY;	5085	return MP_OKAY;
5086	}	5086	}
5087		5087
5088	static int	5088	static int
5089	getbn(BIGNUM *a, const char str, int radix)	5089	getbn(PGPV_BIGNUM *a, const char str, int radix)
5090	{	5090	{
5091	int len;	5091	int len;
5092		5092
5093	if (a == NULL \|\| str == NULL \|\| (*a = BN_new()) == NULL) {	5093	if (a == NULL \|\| str == NULL \|\| (*a = PGPV_BN_new()) == NULL) {
5094	return 0;	5094	return 0;
5095	}	5095	}
5096	if (mp_getradix_num(*a, radix, __UNCONST(str)) != MP_OKAY) {	5096	if (mp_getradix_num(*a, radix, __UNCONST(str)) != MP_OKAY) {
5097	return 0;	5097	return 0;
5098	}	5098	}
5099	mp_radix_size(__UNCONST(*a), radix, &len);	5099	mp_radix_size(__UNCONST(*a), radix, &len);
5100	return len - 1;	5100	return len - 1;
5101	}	5101	}
5102		5102
5103	/* d = a - b (mod c) */	5103	/* d = a - b (mod c) */
5104	static int	5104	static int
5105	subtract_modulo(mp_int a, mp_int b, mp_int c, mp_int d)	5105	subtract_modulo(mp_int a, mp_int b, mp_int c, mp_int d)
5106	{	5106	{
	@@ -5113,434 +5113,434 @@ subtract_modulo(mp_int a, mp_int b, mp		@@ -5113,434 +5113,434 @@ subtract_modulo(mp_int a, mp_int b, mp
5113	}	5113	}
5114		5114
5115	if ((res = signed_subtract(a, b, &t)) != MP_OKAY) {	5115	if ((res = signed_subtract(a, b, &t)) != MP_OKAY) {
5116	mp_clear(&t);	5116	mp_clear(&t);
5117	return res;	5117	return res;
5118	}	5118	}
5119	res = modulo(&t, c, d);	5119	res = modulo(&t, c, d);
5120	mp_clear(&t);	5120	mp_clear(&t);
5121	return res;	5121	return res;
5122	}	5122	}
5123		5123
5124	/**************************************************************************/	5124	/**************************************************************************/
5125		5125
5126	/* BIGNUM emulation layer */	5126	/* PGPV_BIGNUM emulation layer */
5127		5127
5128	/* essentiually, these are just wrappers around the libtommath functions */	5128	/* essentiually, these are just wrappers around the libtommath functions */
5129	/* usually the order of args changes */	5129	/* usually the order of args changes */
5130	/* the BIGNUM API tends to have more const poisoning */	5130	/* the PGPV_BIGNUM API tends to have more const poisoning */
5131	/* these wrappers also check the arguments passed for sanity */	5131	/* these wrappers also check the arguments passed for sanity */
5132		5132
5133	BIGNUM *	5133	PGPV_BIGNUM *
5134	BN_bin2bn(const uint8_t data, int len, BIGNUM ret)	5134	PGPV_BN_bin2bn(const uint8_t data, int len, PGPV_BIGNUM ret)
5135	{	5135	{
5136	if (data == NULL) {	5136	if (data == NULL) {
5137	return BN_new();	5137	return PGPV_BN_new();
5138	}	5138	}
5139	if (ret == NULL) {	5139	if (ret == NULL) {
5140	ret = BN_new();	5140	ret = PGPV_BN_new();
5141	}	5141	}
5142	return (mp_read_unsigned_bin(ret, data, len) == MP_OKAY) ? ret : NULL;	5142	return (mp_read_unsigned_bin(ret, data, len) == MP_OKAY) ? ret : NULL;
5143	}	5143	}
5144		5144
5145	/* store in unsigned [big endian] format */	5145	/* store in unsigned [big endian] format */
5146	int	5146	int
5147	BN_bn2bin(const BIGNUM a, unsigned char b)	5147	PGPV_BN_bn2bin(const PGPV_BIGNUM a, unsigned char b)
5148	{	5148	{
5149	BIGNUM t;	5149	PGPV_BIGNUM t;
5150	int x;	5150	int x;
5151		5151
5152	if (a == NULL \|\| b == NULL) {	5152	if (a == NULL \|\| b == NULL) {
5153	return -1;	5153	return -1;
5154	}	5154	}
5155	if (mp_init_copy (&t, __UNCONST(a)) != MP_OKAY) {	5155	if (mp_init_copy (&t, __UNCONST(a)) != MP_OKAY) {
5156	return -1;	5156	return -1;
5157	}	5157	}
5158	for (x = 0; !BN_is_zero(&t) ; ) {	5158	for (x = 0; !PGPV_BN_is_zero(&t) ; ) {
5159	b[x++] = (unsigned char) (t.dp[0] & 0xff);	5159	b[x++] = (unsigned char) (t.dp[0] & 0xff);
5160	if (rshift_bits(&t, 8, &t, NULL) != MP_OKAY) {	5160	if (rshift_bits(&t, 8, &t, NULL) != MP_OKAY) {
5161	mp_clear(&t);	5161	mp_clear(&t);
5162	return -1;	5162	return -1;
5163	}	5163	}
5164	}	5164	}
5165	bn_reverse(b, x);	5165	bn_reverse(b, x);
5166	mp_clear(&t);	5166	mp_clear(&t);
5167	return x;	5167	return x;
5168	}	5168	}
5169		5169
5170	void	5170	void
5171	BN_init(BIGNUM *a)	5171	PGPV_BN_init(PGPV_BIGNUM *a)
5172	{	5172	{
5173	if (a != NULL) {	5173	if (a != NULL) {
5174	mp_init(a);	5174	mp_init(a);
5175	}	5175	}
5176	}	5176	}
5177		5177
5178	BIGNUM *	5178	PGPV_BIGNUM *
5179	BN_new(void)	5179	PGPV_BN_new(void)
5180	{	5180	{
5181	BIGNUM *a;	5181	PGPV_BIGNUM *a;
5182		5182
5183	if ((a = allocate(1, sizeof(*a))) != NULL) {	5183	if ((a = allocate(1, sizeof(*a))) != NULL) {
5184	mp_init(a);	5184	mp_init(a);
5185	}	5185	}
5186	return a;	5186	return a;
5187	}	5187	}
5188		5188
5189	/* copy, b = a */	5189	/* copy, b = a */
5190	int	5190	int
5191	BN_copy(BIGNUM b, const BIGNUM a)	5191	PGPV_BN_copy(PGPV_BIGNUM b, const PGPV_BIGNUM a)
5192	{	5192	{
5193	if (a == NULL \|\| b == NULL) {	5193	if (a == NULL \|\| b == NULL) {
5194	return MP_VAL;	5194	return MP_VAL;
5195	}	5195	}
5196	return mp_copy(__UNCONST(a), b);	5196	return mp_copy(__UNCONST(a), b);
5197	}	5197	}
5198		5198
5199	BIGNUM *	5199	PGPV_BIGNUM *
5200	BN_dup(const BIGNUM *a)	5200	PGPV_BN_dup(const PGPV_BIGNUM *a)
5201	{	5201	{
5202	BIGNUM *ret;	5202	PGPV_BIGNUM *ret;
5203		5203
5204	if (a == NULL) {	5204	if (a == NULL) {
5205	return NULL;	5205	return NULL;
5206	}	5206	}
5207	if ((ret = BN_new()) != NULL) {	5207	if ((ret = PGPV_BN_new()) != NULL) {
5208	BN_copy(ret, a);	5208	PGPV_BN_copy(ret, a);
5209	}	5209	}
5210	return ret;	5210	return ret;
5211	}	5211	}
5212		5212
5213	void	5213	void
5214	BN_swap(BIGNUM a, BIGNUM b)	5214	PGPV_BN_swap(PGPV_BIGNUM a, PGPV_BIGNUM b)
5215	{	5215	{
5216	if (a && b) {	5216	if (a && b) {
5217	mp_exch(a, b);	5217	mp_exch(a, b);
5218	}	5218	}
5219	}	5219	}
5220		5220
5221	int	5221	int
5222	BN_lshift(BIGNUM r, const BIGNUM a, int n)	5222	PGPV_BN_lshift(PGPV_BIGNUM r, const PGPV_BIGNUM a, int n)
5223	{	5223	{
5224	if (r == NULL \|\| a == NULL \|\| n < 0) {	5224	if (r == NULL \|\| a == NULL \|\| n < 0) {
5225	return 0;	5225	return 0;
5226	}	5226	}
5227	BN_copy(r, a);	5227	PGPV_BN_copy(r, a);
5228	return lshift_digits(r, n) == MP_OKAY;	5228	return lshift_digits(r, n) == MP_OKAY;
5229	}	5229	}
5230		5230
5231	int	5231	int
5232	BN_lshift1(BIGNUM r, BIGNUM a)	5232	PGPV_BN_lshift1(PGPV_BIGNUM r, PGPV_BIGNUM a)
5233	{	5233	{
5234	if (r == NULL \|\| a == NULL) {	5234	if (r == NULL \|\| a == NULL) {
5235	return 0;	5235	return 0;
5236	}	5236	}
5237	BN_copy(r, a);	5237	PGPV_BN_copy(r, a);
5238	return lshift_digits(r, 1) == MP_OKAY;	5238	return lshift_digits(r, 1) == MP_OKAY;
5239	}	5239	}
5240		5240
5241	int	5241	int
5242	BN_rshift(BIGNUM r, const BIGNUM a, int n)	5242	PGPV_BN_rshift(PGPV_BIGNUM r, const PGPV_BIGNUM a, int n)
5243	{	5243	{
5244	if (r == NULL \|\| a == NULL \|\| n < 0) {	5244	if (r == NULL \|\| a == NULL \|\| n < 0) {
5245	return MP_VAL;	5245	return MP_VAL;
5246	}	5246	}
5247	BN_copy(r, a);	5247	PGPV_BN_copy(r, a);
5248	return rshift_digits(r, n) == MP_OKAY;	5248	return rshift_digits(r, n) == MP_OKAY;
5249	}	5249	}
5250		5250
5251	int	5251	int
5252	BN_rshift1(BIGNUM r, BIGNUM a)	5252	PGPV_BN_rshift1(PGPV_BIGNUM r, PGPV_BIGNUM a)
5253	{	5253	{
5254	if (r == NULL \|\| a == NULL) {	5254	if (r == NULL \|\| a == NULL) {
5255	return 0;	5255	return 0;
5256	}	5256	}
5257	BN_copy(r, a);	5257	PGPV_BN_copy(r, a);
5258	return rshift_digits(r, 1) == MP_OKAY;	5258	return rshift_digits(r, 1) == MP_OKAY;
5259	}	5259	}
5260		5260
5261	int	5261	int
5262	BN_set_word(BIGNUM *a, BN_ULONG w)	5262	PGPV_BN_set_word(PGPV_BIGNUM *a, PGPV_BN_ULONG w)
5263	{	5263	{
5264	if (a == NULL) {	5264	if (a == NULL) {
5265	return 0;	5265	return 0;
5266	}	5266	}
5267	set_word(a, w);	5267	set_word(a, w);
5268	return 1;	5268	return 1;
5269	}	5269	}
5270		5270
5271	int	5271	int
5272	BN_add(BIGNUM r, const BIGNUM a, const BIGNUM *b)	5272	PGPV_BN_add(PGPV_BIGNUM r, const PGPV_BIGNUM a, const PGPV_BIGNUM *b)
5273	{	5273	{
5274	if (a == NULL \|\| b == NULL \|\| r == NULL) {	5274	if (a == NULL \|\| b == NULL \|\| r == NULL) {
5275	return 0;	5275	return 0;
5276	}	5276	}
5277	return signed_add(__UNCONST(a), __UNCONST(b), r) == MP_OKAY;	5277	return signed_add(__UNCONST(a), __UNCONST(b), r) == MP_OKAY;
5278	}	5278	}
5279		5279
5280	int	5280	int
5281	BN_sub(BIGNUM r, const BIGNUM a, const BIGNUM *b)	5281	PGPV_BN_sub(PGPV_BIGNUM r, const PGPV_BIGNUM a, const PGPV_BIGNUM *b)
5282	{	5282	{
5283	if (a == NULL \|\| b == NULL \|\| r == NULL) {	5283	if (a == NULL \|\| b == NULL \|\| r == NULL) {
5284	return 0;	5284	return 0;
5285	}	5285	}
5286	return signed_subtract(__UNCONST(a), __UNCONST(b), r) == MP_OKAY;	5286	return signed_subtract(__UNCONST(a), __UNCONST(b), r) == MP_OKAY;
5287	}	5287	}
5288		5288
5289	int	5289	int
5290	BN_mul(BIGNUM r, const BIGNUM a, const BIGNUM b, BN_CTX ctx)	5290	PGPV_BN_mul(PGPV_BIGNUM r, const PGPV_BIGNUM a, const PGPV_BIGNUM b, PGPV_BN_CTX ctx)
5291	{	5291	{
5292	if (a == NULL \|\| b == NULL \|\| r == NULL) {	5292	if (a == NULL \|\| b == NULL \|\| r == NULL) {
5293	return 0;	5293	return 0;
5294	}	5294	}
5295	USE_ARG(ctx);	5295	USE_ARG(ctx);
5296	return signed_multiply(__UNCONST(a), __UNCONST(b), r) == MP_OKAY;	5296	return signed_multiply(__UNCONST(a), __UNCONST(b), r) == MP_OKAY;
5297	}	5297	}
5298		5298
5299	int	5299	int
5300	BN_div(BIGNUM dv, BIGNUM rem, const BIGNUM a, const BIGNUM d, BN_CTX *ctx)	5300	PGPV_BN_div(PGPV_BIGNUM dv, PGPV_BIGNUM rem, const PGPV_BIGNUM a, const PGPV_BIGNUM d, PGPV_BN_CTX *ctx)
5301	{	5301	{
5302	if ((dv == NULL && rem == NULL) \|\| a == NULL \|\| d == NULL) {	5302	if ((dv == NULL && rem == NULL) \|\| a == NULL \|\| d == NULL) {
5303	return 0;	5303	return 0;
5304	}	5304	}
5305	USE_ARG(ctx);	5305	USE_ARG(ctx);
5306	return signed_divide(dv, rem, __UNCONST(a), __UNCONST(d)) == MP_OKAY;	5306	return signed_divide(dv, rem, __UNCONST(a), __UNCONST(d)) == MP_OKAY;
5307	}	5307	}
5308		5308
5309	/* perform a bit operation on the 2 bignums */	5309	/* perform a bit operation on the 2 bignums */
5310	int	5310	int
5311	BN_bitop(BIGNUM r, const BIGNUM a, char op, const BIGNUM *b)	5311	PGPV_BN_bitop(PGPV_BIGNUM r, const PGPV_BIGNUM a, char op, const PGPV_BIGNUM *b)
5312	{	5312	{
5313	unsigned ndigits;	5313	unsigned ndigits;
5314	mp_digit ad;	5314	mp_digit ad;
5315	mp_digit bd;	5315	mp_digit bd;
5316	int i;	5316	int i;
5317		5317
5318	if (a == NULL \|\| b == NULL \|\| r == NULL) {	5318	if (a == NULL \|\| b == NULL \|\| r == NULL) {
5319	return 0;	5319	return 0;
5320	}	5320	}
5321	if (BN_cmp(__UNCONST(a), __UNCONST(b)) >= 0) {	5321	if (PGPV_BN_cmp(__UNCONST(a), __UNCONST(b)) >= 0) {
5322	BN_copy(r, a);	5322	PGPV_BN_copy(r, a);
5323	ndigits = a->used;	5323	ndigits = a->used;
5324	} else {	5324	} else {
5325	BN_copy(r, b);	5325	PGPV_BN_copy(r, b);
5326	ndigits = b->used;	5326	ndigits = b->used;
5327	}	5327	}
5328	for (i = 0 ; i < (int)ndigits ; i++) {	5328	for (i = 0 ; i < (int)ndigits ; i++) {
5329	ad = (i > a->used) ? 0 : a->dp[i];	5329	ad = (i > a->used) ? 0 : a->dp[i];
5330	bd = (i > b->used) ? 0 : b->dp[i];	5330	bd = (i > b->used) ? 0 : b->dp[i];
5331	switch(op) {	5331	switch(op) {
5332	case '&':	5332	case '&':
5333	r->dp[i] = (ad & bd);	5333	r->dp[i] = (ad & bd);
5334	break;	5334	break;
5335	case '\|':	5335	case '\|':
5336	r->dp[i] = (ad \| bd);	5336	r->dp[i] = (ad \| bd);
5337	break;	5337	break;
5338	case '^':	5338	case '^':
5339	r->dp[i] = (ad ^ bd);	5339	r->dp[i] = (ad ^ bd);
5340	break;	5340	break;
5341	default:	5341	default:
5342	break;	5342	break;
5343	}	5343	}
5344	}	5344	}
5345	return 1;	5345	return 1;
5346	}	5346	}
5347		5347
5348	void	5348	void
5349	BN_free(BIGNUM *a)	5349	PGPV_BN_free(PGPV_BIGNUM *a)
5350	{	5350	{
5351	if (a) {	5351	if (a) {
5352	mp_clear(a);	5352	mp_clear(a);
5353	}	5353	}
5354	}	5354	}
5355		5355
5356	void	5356	void
5357	BN_clear(BIGNUM *a)	5357	PGPV_BN_clear(PGPV_BIGNUM *a)
5358	{	5358	{
5359	if (a) {	5359	if (a) {
5360	mp_clear(a);	5360	mp_clear(a);
5361	}	5361	}
5362	}	5362	}
5363		5363
5364	void	5364	void
5365	BN_clear_free(BIGNUM *a)	5365	PGPV_BN_clear_free(PGPV_BIGNUM *a)
5366	{	5366	{
5367	if (a) {	5367	if (a) {
5368	mp_clear(a);	5368	mp_clear(a);
5369	}	5369	}
5370	}	5370	}
5371		5371
5372	int	5372	int
5373	BN_num_bytes(const BIGNUM *a)	5373	PGPV_BN_num_bytes(const PGPV_BIGNUM *a)
5374	{	5374	{
5375	if (a == NULL) {	5375	if (a == NULL) {
5376	return MP_VAL;	5376	return MP_VAL;
5377	}	5377	}
5378	return mp_unsigned_bin_size(__UNCONST(a));	5378	return mp_unsigned_bin_size(__UNCONST(a));
5379	}	5379	}
5380		5380
5381	int	5381	int
5382	BN_num_bits(const BIGNUM *a)	5382	PGPV_BN_num_bits(const PGPV_BIGNUM *a)
5383	{	5383	{
5384	if (a == NULL) {	5384	if (a == NULL) {
5385	return 0;	5385	return 0;
5386	}	5386	}
5387	return mp_count_bits(a);	5387	return mp_count_bits(a);
5388	}	5388	}
5389		5389
5390	void	5390	void
5391	BN_set_negative(BIGNUM *a, int n)	5391	PGPV_BN_set_negative(PGPV_BIGNUM *a, int n)
5392	{	5392	{
5393	if (a) {	5393	if (a) {
5394	a->sign = (n) ? MP_NEG : 0;	5394	a->sign = (n) ? MP_NEG : 0;
5395	}	5395	}
5396	}	5396	}
5397		5397
5398	int	5398	int
5399	BN_cmp(BIGNUM a, BIGNUM b)	5399	PGPV_BN_cmp(PGPV_BIGNUM a, PGPV_BIGNUM b)
5400	{	5400	{
5401	if (a == NULL \|\| b == NULL) {	5401	if (a == NULL \|\| b == NULL) {
5402	return MP_VAL;	5402	return MP_VAL;
5403	}	5403	}
5404	switch(signed_compare(a, b)) {	5404	switch(signed_compare(a, b)) {
5405	case MP_LT:	5405	case MP_LT:
5406	return -1;	5406	return -1;
5407	case MP_GT:	5407	case MP_GT:
5408	return 1;	5408	return 1;
5409	case MP_EQ:	5409	case MP_EQ:
5410	default:	5410	default:
5411	return 0;	5411	return 0;
5412	}	5412	}
5413	}	5413	}
5414		5414
5415	int	5415	int
5416	BN_mod_exp(BIGNUM Y, BIGNUM G, BIGNUM X, BIGNUM P, BN_CTX *ctx)	5416	PGPV_BN_mod_exp(PGPV_BIGNUM Y, PGPV_BIGNUM G, PGPV_BIGNUM X, PGPV_BIGNUM P, PGPV_BN_CTX *ctx)
5417	{	5417	{
5418	if (Y == NULL \|\| G == NULL \|\| X == NULL \|\| P == NULL) {	5418	if (Y == NULL \|\| G == NULL \|\| X == NULL \|\| P == NULL) {
5419	return MP_VAL;	5419	return MP_VAL;
5420	}	5420	}
5421	USE_ARG(ctx);	5421	USE_ARG(ctx);
5422	return exponent_modulo(G, X, P, Y) == MP_OKAY;	5422	return exponent_modulo(G, X, P, Y) == MP_OKAY;
5423	}	5423	}
5424		5424
5425	BIGNUM *	5425	PGPV_BIGNUM *
5426	BN_mod_inverse(BIGNUM r, BIGNUM a, const BIGNUM n, BN_CTX ctx)	5426	PGPV_BN_mod_inverse(PGPV_BIGNUM r, PGPV_BIGNUM a, const PGPV_BIGNUM n, PGPV_BN_CTX ctx)
5427	{	5427	{
5428	USE_ARG(ctx);	5428	USE_ARG(ctx);
5429	if (r == NULL \|\| a == NULL \|\| n == NULL) {	5429	if (r == NULL \|\| a == NULL \|\| n == NULL) {
5430	return NULL;	5430	return NULL;
5431	}	5431	}
5432	return (modular_inverse(r, a, __UNCONST(n)) == MP_OKAY) ? r : NULL;	5432	return (modular_inverse(r, a, __UNCONST(n)) == MP_OKAY) ? r : NULL;
5433	}	5433	}
5434		5434
5435	int	5435	int
5436	BN_mod_mul(BIGNUM ret, BIGNUM a, BIGNUM b, const BIGNUM m, BN_CTX *ctx)	5436	PGPV_BN_mod_mul(PGPV_BIGNUM ret, PGPV_BIGNUM a, PGPV_BIGNUM b, const PGPV_BIGNUM m, PGPV_BN_CTX *ctx)
5437	{	5437	{
5438	USE_ARG(ctx);	5438	USE_ARG(ctx);
5439	if (ret == NULL \|\| a == NULL \|\| b == NULL \|\| m == NULL) {	5439	if (ret == NULL \|\| a == NULL \|\| b == NULL \|\| m == NULL) {
5440	return 0;	5440	return 0;
5441	}	5441	}
5442	return multiply_modulo(ret, a, b, __UNCONST(m)) == MP_OKAY;	5442	return multiply_modulo(ret, a, b, __UNCONST(m)) == MP_OKAY;
5443	}	5443	}
5444		5444
5445	BN_CTX *	5445	PGPV_BN_CTX *
5446	BN_CTX_new(void)	5446	PGPV_BN_CTX_new(void)
5447	{	5447	{
5448	return allocate(1, sizeof(BN_CTX));	5448	return allocate(1, sizeof(PGPV_BN_CTX));
5449	}	5449	}
5450		5450
5451	void	5451	void
5452	BN_CTX_init(BN_CTX *c)	5452	PGPV_BN_CTX_init(PGPV_BN_CTX *c)
5453	{	5453	{
5454	if (c != NULL) {	5454	if (c != NULL) {
5455	c->arraysize = 15;	5455	c->arraysize = 15;
5456	if ((c->v = allocate(sizeof(*c->v), c->arraysize)) == NULL) {	5456	if ((c->v = allocate(sizeof(*c->v), c->arraysize)) == NULL) {
5457	c->arraysize = 0;	5457	c->arraysize = 0;
5458	}	5458	}
5459	}	5459	}
5460	}	5460	}
5461		5461
5462	BIGNUM *	5462	PGPV_BIGNUM *
5463	BN_CTX_get(BN_CTX *ctx)	5463	PGPV_BN_CTX_get(PGPV_BN_CTX *ctx)
5464	{	5464	{
5465	if (ctx == NULL \|\| ctx->v == NULL \|\| ctx->arraysize == 0 \|\| ctx->count == ctx->arraysize - 1) {	5465	if (ctx == NULL \|\| ctx->v == NULL \|\| ctx->arraysize == 0 \|\| ctx->count == ctx->arraysize - 1) {
5466	return NULL;	5466	return NULL;
5467	}	5467	}
5468	return ctx->v[ctx->count++] = BN_new();	5468	return ctx->v[ctx->count++] = PGPV_BN_new();
5469	}	5469	}
5470		5470
5471	void	5471	void
5472	BN_CTX_start(BN_CTX *ctx)	5472	PGPV_BN_CTX_start(PGPV_BN_CTX *ctx)
5473	{	5473	{
5474	BN_CTX_init(ctx);	5474	PGPV_BN_CTX_init(ctx);
5475	}	5475	}
5476		5476
5477	void	5477	void
5478	BN_CTX_free(BN_CTX *c)	5478	PGPV_BN_CTX_free(PGPV_BN_CTX *c)
5479	{	5479	{
5480	unsigned i;	5480	unsigned i;
5481		5481
5482	if (c != NULL && c->v != NULL) {	5482	if (c != NULL && c->v != NULL) {
5483	for (i = 0 ; i < c->count ; i++) {	5483	for (i = 0 ; i < c->count ; i++) {
5484	BN_clear_free(c->v[i]);	5484	PGPV_BN_clear_free(c->v[i]);
5485	}	5485	}
5486	deallocate(c->v, sizeof(c->v) c->arraysize);	5486	deallocate(c->v, sizeof(c->v) c->arraysize);
5487	}	5487	}
5488	}	5488	}
5489		5489
5490	void	5490	void
5491	BN_CTX_end(BN_CTX *ctx)	5491	PGPV_BN_CTX_end(PGPV_BN_CTX *ctx)
5492	{	5492	{
5493	BN_CTX_free(ctx);	5493	PGPV_BN_CTX_free(ctx);
5494	}	5494	}
5495		5495
5496	char *	5496	char *
5497	BN_bn2hex(const BIGNUM *a)	5497	PGPV_BN_bn2hex(const PGPV_BIGNUM *a)
5498	{	5498	{
5499	return (a == NULL) ? NULL : formatbn(a, 16);	5499	return (a == NULL) ? NULL : formatbn(a, 16);
5500	}	5500	}
5501		5501
5502	char *	5502	char *
5503	BN_bn2dec(const BIGNUM *a)	5503	PGPV_BN_bn2dec(const PGPV_BIGNUM *a)
5504	{	5504	{
5505	return (a == NULL) ? NULL : formatbn(a, 10);	5505	return (a == NULL) ? NULL : formatbn(a, 10);
5506	}	5506	}
5507		5507
5508	char *	5508	char *
5509	BN_bn2radix(const BIGNUM *a, unsigned radix)	5509	PGPV_BN_bn2radix(const PGPV_BIGNUM *a, unsigned radix)
5510	{	5510	{
5511	return (a == NULL) ? NULL : formatbn(a, (int)radix);	5511	return (a == NULL) ? NULL : formatbn(a, (int)radix);
5512	}	5512	}
5513		5513
5514	#ifndef _KERNEL	5514	#ifndef _KERNEL
5515	int	5515	int
5516	BN_print_fp(FILE fp, const BIGNUM a)	5516	PGPV_BN_print_fp(FILE fp, const PGPV_BIGNUM a)
5517	{	5517	{
5518	char *s;	5518	char *s;
5519	int ret;	5519	int ret;
5520		5520
5521	if (fp == NULL \|\| a == NULL) {	5521	if (fp == NULL \|\| a == NULL) {
5522	return 0;	5522	return 0;
5523	}	5523	}
5524	s = BN_bn2hex(a);	5524	s = PGPV_BN_bn2hex(a);
5525	ret = fprintf(fp, "%s", s);	5525	ret = fprintf(fp, "%s", s);
5526	deallocate(s, strlen(s) + 1);	5526	deallocate(s, strlen(s) + 1);
5527	return ret;	5527	return ret;
5528	}	5528	}
5529	#endif	5529	#endif
5530		5530
5531	#ifdef BN_RAND_NEEDED	5531	#ifdef PGPV_BN_RAND_NEEDED
5532	int	5532	int
5533	BN_rand(BIGNUM *rnd, int bits, int top, int bottom)	5533	PGPV_BN_rand(PGPV_BIGNUM *rnd, int bits, int top, int bottom)
5534	{	5534	{
5535	uint64_t r;	5535	uint64_t r;
5536	int digits;	5536	int digits;
5537	int i;	5537	int i;
5538		5538
5539	if (rnd == NULL) {	5539	if (rnd == NULL) {
5540	return 0;	5540	return 0;
5541	}	5541	}
5542	mp_init_size(rnd, digits = howmany(bits, DIGIT_BIT));	5542	mp_init_size(rnd, digits = howmany(bits, DIGIT_BIT));
5543	for (i = 0 ; i < digits ; i++) {	5543	for (i = 0 ; i < digits ; i++) {
5544	r = (uint64_t)arc4random();	5544	r = (uint64_t)arc4random();
5545	r <<= 32;	5545	r <<= 32;
5546	r \|= arc4random();	5546	r \|= arc4random();
	@@ -5550,134 +5550,134 @@ BN_rand(BIGNUM *rnd, int bits, int top,		@@ -5550,134 +5550,134 @@ BN_rand(BIGNUM *rnd, int bits, int top,
5550	rnd->dp[rnd->used - 1] \|= (((mp_digit)1)<<((mp_digit)DIGIT_BIT));	5550	rnd->dp[rnd->used - 1] \|= (((mp_digit)1)<<((mp_digit)DIGIT_BIT));
5551	}	5551	}
5552	if (top == 1) {	5552	if (top == 1) {
5553	rnd->dp[rnd->used - 1] \|= (((mp_digit)1)<<((mp_digit)DIGIT_BIT));	5553	rnd->dp[rnd->used - 1] \|= (((mp_digit)1)<<((mp_digit)DIGIT_BIT));
5554	rnd->dp[rnd->used - 1] \|= (((mp_digit)1)<<((mp_digit)(DIGIT_BIT - 1)));	5554	rnd->dp[rnd->used - 1] \|= (((mp_digit)1)<<((mp_digit)(DIGIT_BIT - 1)));
5555	}	5555	}
5556	if (bottom) {	5556	if (bottom) {
5557	rnd->dp[0] \|= 0x1;	5557	rnd->dp[0] \|= 0x1;
5558	}	5558	}
5559	return 1;	5559	return 1;
5560	}	5560	}
5561		5561
5562	int	5562	int
5563	BN_rand_range(BIGNUM rnd, BIGNUM range)	5563	PGPV_BN_rand_range(PGPV_BIGNUM rnd, PGPV_BIGNUM range)
5564	{	5564	{
5565	if (rnd == NULL \|\| range == NULL \|\| BN_is_zero(range)) {	5565	if (rnd == NULL \|\| range == NULL \|\| PGPV_BN_is_zero(range)) {
5566	return 0;	5566	return 0;
5567	}	5567	}
5568	BN_rand(rnd, BN_num_bits(range), 1, 0);	5568	PGPV_BN_rand(rnd, PGPV_BN_num_bits(range), 1, 0);
5569	return modulo(rnd, range, rnd) == MP_OKAY;	5569	return modulo(rnd, range, rnd) == MP_OKAY;
5570	}	5570	}
5571	#endif	5571	#endif
5572		5572
5573	int	5573	int
5574	BN_is_prime(const BIGNUM a, int checks, void (callback)(int, int, void ), BN_CTX ctx, void *cb_arg)	5574	PGPV_BN_is_prime(const PGPV_BIGNUM a, int checks, void (callback)(int, int, void ), PGPV_BN_CTX ctx, void *cb_arg)
5575	{	5575	{
5576	int primality;	5576	int primality;
5577		5577
5578	if (a == NULL) {	5578	if (a == NULL) {
5579	return 0;	5579	return 0;
5580	}	5580	}
5581	USE_ARG(ctx);	5581	USE_ARG(ctx);
5582	USE_ARG(cb_arg);	5582	USE_ARG(cb_arg);
5583	USE_ARG(callback);	5583	USE_ARG(callback);
5584	return (mp_prime_is_prime(__UNCONST(a), checks, &primality) == MP_OKAY) ? primality : 0;	5584	return (mp_prime_is_prime(__UNCONST(a), checks, &primality) == MP_OKAY) ? primality : 0;
5585	}	5585	}
5586		5586
5587	const BIGNUM *	5587	const PGPV_BIGNUM *
5588	BN_value_one(void)	5588	PGPV_BN_value_one(void)
5589	{	5589	{
5590	static mp_digit digit = 1UL;	5590	static mp_digit digit = 1UL;
5591	static const BIGNUM one = { &digit, 1, 1, 0 };	5591	static const PGPV_BIGNUM one = { &digit, 1, 1, 0 };
5592		5592
5593	return &one;	5593	return &one;
5594	}	5594	}
5595		5595
5596	int	5596	int
5597	BN_hex2bn(BIGNUM *a, const char str)	5597	PGPV_BN_hex2bn(PGPV_BIGNUM *a, const char str)
5598	{	5598	{
5599	return getbn(a, str, 16);	5599	return getbn(a, str, 16);
5600	}	5600	}
5601		5601
5602	int	5602	int
5603	BN_dec2bn(BIGNUM *a, const char str)	5603	PGPV_BN_dec2bn(PGPV_BIGNUM *a, const char str)
5604	{	5604	{
5605	return getbn(a, str, 10);	5605	return getbn(a, str, 10);
5606	}	5606	}
5607		5607
5608	int	5608	int
5609	BN_radix2bn(BIGNUM *a, const char str, unsigned radix)	5609	PGPV_BN_radix2bn(PGPV_BIGNUM *a, const char str, unsigned radix)
5610	{	5610	{
5611	return getbn(a, str, (int)radix);	5611	return getbn(a, str, (int)radix);
5612	}	5612	}
5613		5613
5614	int	5614	int
5615	BN_mod_sub(BIGNUM r, BIGNUM a, BIGNUM b, const BIGNUM m, BN_CTX *ctx)	5615	PGPV_BN_mod_sub(PGPV_BIGNUM r, PGPV_BIGNUM a, PGPV_BIGNUM b, const PGPV_BIGNUM m, PGPV_BN_CTX *ctx)
5616	{	5616	{
5617	USE_ARG(ctx);	5617	USE_ARG(ctx);
5618	if (r == NULL \|\| a == NULL \|\| b == NULL \|\| m == NULL) {	5618	if (r == NULL \|\| a == NULL \|\| b == NULL \|\| m == NULL) {
5619	return 0;	5619	return 0;
5620	}	5620	}
5621	return subtract_modulo(a, b, __UNCONST(m), r) == MP_OKAY;	5621	return subtract_modulo(a, b, __UNCONST(m), r) == MP_OKAY;
5622	}	5622	}
5623		5623
5624	int	5624	int
5625	BN_is_bit_set(const BIGNUM *a, int n)	5625	PGPV_BN_is_bit_set(const PGPV_BIGNUM *a, int n)
5626	{	5626	{
5627	if (a == NULL \|\| n < 0 \|\| n >= a->used * DIGIT_BIT) {	5627	if (a == NULL \|\| n < 0 \|\| n >= a->used * DIGIT_BIT) {
5628	return 0;	5628	return 0;
5629	}	5629	}
5630	return (a->dp[n / DIGIT_BIT] & (1 << (n % DIGIT_BIT))) ? 1 : 0;	5630	return (a->dp[n / DIGIT_BIT] & (1 << (n % DIGIT_BIT))) ? 1 : 0;
5631	}	5631	}
5632		5632
5633	/* raise 'a' to power of 'b' */	5633	/* raise 'a' to power of 'b' */
5634	int	5634	int
5635	BN_raise(BIGNUM res, BIGNUM a, BIGNUM *b)	5635	PGPV_BN_raise(PGPV_BIGNUM res, PGPV_BIGNUM a, PGPV_BIGNUM *b)
5636	{	5636	{
5637	uint64_t exponent;	5637	uint64_t exponent;
5638	BIGNUM *power;	5638	PGPV_BIGNUM *power;
5639	BIGNUM *temp;	5639	PGPV_BIGNUM *temp;
5640	char *t;	5640	char *t;
5641		5641
5642	t = BN_bn2dec(b);	5642	t = PGPV_BN_bn2dec(b);
5643	exponent = (uint64_t)strtoull(t, NULL, 10);	5643	exponent = (uint64_t)strtoull(t, NULL, 10);
5644	free(t);	5644	free(t);
5645	if (exponent == 0) {	5645	if (exponent == 0) {
5646	BN_copy(res, BN_value_one());	5646	PGPV_BN_copy(res, PGPV_BN_value_one());
5647	} else {	5647	} else {
5648	power = BN_dup(a);	5648	power = PGPV_BN_dup(a);
5649	for ( ; (exponent & 1) == 0 ; exponent >>= 1) {	5649	for ( ; (exponent & 1) == 0 ; exponent >>= 1) {
5650	BN_mul(power, power, power, NULL);	5650	PGPV_BN_mul(power, power, power, NULL);
5651	}	5651	}
5652	temp = BN_dup(power);	5652	temp = PGPV_BN_dup(power);
5653	for (exponent >>= 1 ; exponent > 0 ; exponent >>= 1) {	5653	for (exponent >>= 1 ; exponent > 0 ; exponent >>= 1) {
5654	BN_mul(power, power, power, NULL);	5654	PGPV_BN_mul(power, power, power, NULL);
5655	if (exponent & 1) {	5655	if (exponent & 1) {
5656	BN_mul(temp, power, temp, NULL);	5656	PGPV_BN_mul(temp, power, temp, NULL);
5657	}	5657	}
5658	}	5658	}
5659	BN_copy(res, temp);	5659	PGPV_BN_copy(res, temp);
5660	BN_free(power);	5660	PGPV_BN_free(power);
5661	BN_free(temp);	5661	PGPV_BN_free(temp);
5662	}	5662	}
5663	return 1;	5663	return 1;
5664	}	5664	}
5665		5665
5666	/* compute the factorial */	5666	/* compute the factorial */
5667	int	5667	int
5668	BN_factorial(BIGNUM res, BIGNUM f)	5668	PGPV_BN_factorial(PGPV_BIGNUM res, PGPV_BIGNUM f)
5669	{	5669	{
5670	BIGNUM *one;	5670	PGPV_BIGNUM *one;
5671	BIGNUM *i;	5671	PGPV_BIGNUM *i;
5672		5672
5673	i = BN_dup(f);	5673	i = PGPV_BN_dup(f);
5674	one = __UNCONST(BN_value_one());	5674	one = __UNCONST(PGPV_BN_value_one());
5675	BN_sub(i, i, one);	5675	PGPV_BN_sub(i, i, one);
5676	BN_copy(res, f);	5676	PGPV_BN_copy(res, f);
5677	while (BN_cmp(i, one) > 0) {	5677	while (PGPV_BN_cmp(i, one) > 0) {
5678	BN_mul(res, res, i, NULL);	5678	PGPV_BN_mul(res, res, i, NULL);
5679	BN_sub(i, i, one);	5679	PGPV_BN_sub(i, i, one);
5680	}	5680	}
5681	BN_free(i);	5681	PGPV_BN_free(i);
5682	return 1;	5682	return 1;
5683	}	5683	}

 @@ -46,107 +46,107 @@ __BEGIN_DECLS
 /* should be 32bit on ILP32, 64bit on LP64 */
 typedef unsigned long	mp_digit;
 typedef uint64_t	mp_word;
 /* multi-precision integer */
 typedef struct mp_int {
 	mp_digit	*dp;	/* array of digits */
 	int		 used;	/* # of digits used */
 	int		 alloc;	/* # of digits allocated */
 	int		 sign;	/* non-zero if negative */
 } mp_int;
-#define BIGNUM		mp_int
+#define PGPV_BIGNUM		mp_int
-#define BN_ULONG	mp_digit
+#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;
+	PGPV_BIGNUM	**v;
-} BN_CTX;
+} PGPV_BN_CTX;
 #define MP_LT		-1
 #define MP_EQ		0
 #define MP_GT		1
 #define MP_ZPOS		0
 #define MP_NEG		1
 #define MP_OKAY		0
 #define MP_MEM		-2
 #define MP_VAL		-3
 #define MP_RANGE	MP_VAL
 /*********************************/
-#define BN_is_negative(x)	((x)->sign == MP_NEG)
+#define PGPV_BN_is_negative(x)	((x)->sign == MP_NEG)
-#define BN_is_zero(a) 		(((a)->used == 0) ? 1 : 0)
+#define PGPV_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 PGPV_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_even(a) 		(((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? 1 : 0)
-BIGNUM *BN_new(void);
+PGPV_BIGNUM *PGPV_BN_new(void);
-BIGNUM *BN_dup(const BIGNUM */*a*/);
+PGPV_BIGNUM *PGPV_BN_dup(const PGPV_BIGNUM */*a*/);
-int BN_copy(BIGNUM */*b*/, const BIGNUM */*a*/);
+int PGPV_BN_copy(PGPV_BIGNUM */*b*/, const PGPV_BIGNUM */*a*/);
-void BN_init(BIGNUM */*a*/);
+void PGPV_BN_init(PGPV_BIGNUM */*a*/);
-void BN_free(BIGNUM */*a*/);
+void PGPV_BN_free(PGPV_BIGNUM */*a*/);
-void BN_clear(BIGNUM */*a*/);
+void PGPV_BN_clear(PGPV_BIGNUM */*a*/);
-void BN_clear_free(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*/);
+PGPV_BIGNUM *PGPV_BN_bin2bn(const uint8_t */*buf*/, int /*size*/, PGPV_BIGNUM */*bn*/);
-int BN_bn2bin(const BIGNUM */*a*/, unsigned char */*b*/);
+int PGPV_BN_bn2bin(const PGPV_BIGNUM */*a*/, unsigned char */*b*/);
-char *BN_bn2hex(const BIGNUM */*a*/);
+char *PGPV_BN_bn2hex(const PGPV_BIGNUM */*a*/);
-char *BN_bn2dec(const BIGNUM */*a*/);
+char *PGPV_BN_bn2dec(const PGPV_BIGNUM */*a*/);
-char *BN_bn2radix(const BIGNUM */*a*/, unsigned /*radix*/);
+char *PGPV_BN_bn2radix(const PGPV_BIGNUM */*a*/, unsigned /*radix*/);
-int BN_hex2bn(BIGNUM **/*a*/, const char */*str*/);
+int PGPV_BN_hex2bn(PGPV_BIGNUM **/*a*/, const char */*str*/);
-int BN_dec2bn(BIGNUM **/*a*/, const char */*str*/);
+int PGPV_BN_dec2bn(PGPV_BIGNUM **/*a*/, const char */*str*/);
-int BN_radix2bn(BIGNUM **/*a*/, const char */*str*/, unsigned /*radix*/);
+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 PGPV_BN_add(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/);
-int BN_sub(BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/);
+int PGPV_BN_sub(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/);
-int BN_mul(BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/, BN_CTX */*ctx*/);
+int PGPV_BN_mul(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*b*/, PGPV_BN_CTX */*ctx*/);
-int BN_div(BIGNUM */*q*/, BIGNUM */*r*/, const BIGNUM */*a*/, const BIGNUM */*b*/, 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 BN_swap(BIGNUM */*a*/, BIGNUM */*b*/);
+void PGPV_BN_swap(PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/);
-int BN_bitop(BIGNUM */*r*/, const BIGNUM */*a*/, char /*op*/, const BIGNUM */*b*/);
+int PGPV_BN_bitop(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, char /*op*/, const PGPV_BIGNUM */*b*/);
-int BN_lshift(BIGNUM */*r*/, const BIGNUM */*a*/, int /*n*/);
+int PGPV_BN_lshift(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, int /*n*/);
-int BN_lshift1(BIGNUM */*r*/, BIGNUM */*a*/);
+int PGPV_BN_lshift1(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/);
-int BN_rshift(BIGNUM */*r*/, const BIGNUM */*a*/, int /*n*/);
+int PGPV_BN_rshift(PGPV_BIGNUM */*r*/, const PGPV_BIGNUM */*a*/, int /*n*/);
-int BN_rshift1(BIGNUM */*r*/, BIGNUM */*a*/);
+int PGPV_BN_rshift1(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/);
-int BN_set_word(BIGNUM */*a*/, BN_ULONG /*w*/);
+int PGPV_BN_set_word(PGPV_BIGNUM */*a*/, PGPV_BN_ULONG /*w*/);
-void BN_set_negative(BIGNUM */*a*/, int /*n*/);
+void PGPV_BN_set_negative(PGPV_BIGNUM */*a*/, int /*n*/);
-int BN_num_bytes(const BIGNUM */*a*/);
+int PGPV_BN_num_bytes(const PGPV_BIGNUM */*a*/);
-int BN_num_bits(const 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*/);
+int PGPV_BN_mod_exp(PGPV_BIGNUM */*r*/, PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*p*/, PGPV_BIGNUM */*m*/, PGPV_BN_CTX */*ctx*/);
-BIGNUM *BN_mod_inverse(BIGNUM */*ret*/, BIGNUM */*a*/, const BIGNUM */*n*/, BN_CTX */*ctx*/);
+PGPV_BIGNUM *PGPV_BN_mod_inverse(PGPV_BIGNUM */*ret*/, PGPV_BIGNUM */*a*/, const PGPV_BIGNUM */*n*/, PGPV_BN_CTX */*ctx*/);
-int BN_mod_mul(BIGNUM */*ret*/, BIGNUM */*a*/, BIGNUM */*b*/, const BIGNUM */*m*/, 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 BN_mod_sub(BIGNUM */*r*/, BIGNUM */*a*/, BIGNUM */*b*/, const BIGNUM */*m*/, 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 PGPV_BN_raise(PGPV_BIGNUM */*res*/, PGPV_BIGNUM */*a*/, PGPV_BIGNUM */*b*/);
-int BN_factorial(BIGNUM */*fact*/, BIGNUM */*f*/);
+int PGPV_BN_factorial(PGPV_BIGNUM */*fact*/, PGPV_BIGNUM */*f*/);
-BN_CTX *BN_CTX_new(void);
+PGPV_BN_CTX *PGPV_BN_CTX_new(void);
-BIGNUM *BN_CTX_get(BN_CTX */*ctx*/);
+PGPV_BIGNUM *PGPV_BN_CTX_get(PGPV_BN_CTX */*ctx*/);
-void BN_CTX_start(BN_CTX */*ctx*/);
+void PGPV_BN_CTX_start(PGPV_BN_CTX */*ctx*/);
-void BN_CTX_end(BN_CTX */*ctx*/);
+void PGPV_BN_CTX_end(PGPV_BN_CTX */*ctx*/);
-void BN_CTX_init(BN_CTX */*c*/);
+void PGPV_BN_CTX_init(PGPV_BN_CTX */*c*/);
-void BN_CTX_free(BN_CTX */*c*/);
+void PGPV_BN_CTX_free(PGPV_BN_CTX */*c*/);
-int BN_rand(BIGNUM */*rnd*/, int /*bits*/, int /*top*/, int /*bottom*/);
+int PGPV_BN_rand(PGPV_BIGNUM */*rnd*/, int /*bits*/, int /*top*/, int /*bottom*/);
-int BN_rand_range(BIGNUM */*rnd*/, BIGNUM */*range*/);
+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);
+const PGPV_BIGNUM *PGPV_BN_value_one(void);
-int BN_is_bit_set(const BIGNUM */*a*/, int /*n*/);
+int PGPV_BN_is_bit_set(const PGPV_BIGNUM */*a*/, int /*n*/);
 __END_DECLS
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: md5.h,v 1.2 2015/08/17 11:37:55 jperkin 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
  * Algorithm and has been modified by Jason R. Thorpe <thorpej@NetBSD.org>
  * for portability and formatting.
  */
 /*
  * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  * rights reserved.
+ *
  * License to copy and use this software is granted provided that it
  * is identified as the "RSA Data Security, Inc. MD5 Message-Digest
 @@ -44,27 +44,27 @@
 #  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	netpgpv_MD5Init(NETPGPV_MD5_CTX *);
-void	MD5Update(MD5_CTX *, const unsigned char *, unsigned int);
+void	netpgpv_MD5Update(NETPGPV_MD5_CTX *, const unsigned char *, unsigned int);
-void	MD5Final(unsigned char[MD5_DIGEST_LENGTH], MD5_CTX *);
+void	netpgpv_MD5Final(unsigned char[MD5_DIGEST_LENGTH], NETPGPV_MD5_CTX *);
 #ifndef _KERNEL
-char	*MD5End(MD5_CTX *, char *);
+char	*netpgpv_MD5End(NETPGPV_MD5_CTX *, char *);
-char	*MD5File(const char *, char *);
+char	*netpgpv_MD5File(const char *, char *);
-char	*MD5Data(const unsigned char *, unsigned int, char *);
+char	*netpgpv_MD5Data(const unsigned char *, unsigned int, char *);
 #endif /* _KERNEL */
 __END_DECLS
 #endif /* _SYS_MD5_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: md5c.c,v 1.2 2015/08/17 11:37:55 jperkin 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
  * Algorithm and has been modified by Jason R. Thorpe <thorpej@NetBSD.org>
  * for portability and formatting.
  */
 /*
  * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  * rights reserved.
+ *
  * License to copy and use this software is granted provided that it
  * is identified as the "RSA Data Security, Inc. MD5 Message-Digest
 @@ -144,45 +144,45 @@ static const unsigned char PADDING[64] =
 	(a) += (b); \
+}
 #define II(a, b, c, d, x, s, ac) { \
 	(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
 	(a) = ROTATE_LEFT ((a), (s)); \
 	(a) += (b); \
+}
 /*
  * 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;
 	/* Load magic initialization constants. */
 	context->state[0] = 0x67452301;
 	context->state[1] = 0xefcdab89;
 	context->state[2] = 0x98badcfe;
 	context->state[3] = 0x10325476;
+}
 /*
  * MD5 block update operation.  Continues an MD5 message-digest
  * operation, processing another message block, and updating the
  * 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 */
+{
 	unsigned int i, idx, partLen;
 	/* Compute number of bytes mod 64 */
 	idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
 	/* Update number of bits */
 	if ((context->count[0] += ((UINT4)inputLen << 3))
 	    < ((UINT4)inputLen << 3))
 		context->count[1]++;
 	context->count[1] += ((UINT4)inputLen >> 29);
 @@ -200,42 +200,42 @@ MD5Update(MD5_CTX *context,
 		idx = 0;
 	} else
 		i = 0;
 	/* Buffer remaining input */
 	memcpy(&context->buffer[idx], &input[i], inputLen - i);
+}
 /*
  * MD5 finalization.  Ends an MD5 message-digest operation, writing the
  * message digest and zeroing the context.
  */
 void
-MD5Final(unsigned char digest[16],	/* message digest */
+netpgpv_MD5Final(unsigned char digest[16],	/* message digest */
-	MD5_CTX *context)		/* context */
+	NETPGPV_MD5_CTX *context)		/* context */
+{
 	unsigned char bits[8];
 	unsigned int idx, padLen;
 	/* Save number of bits */
 	Encode(bits, context->count, 8);
 	/* 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);
 	/* Zeroize sensitive information. */
 	ZEROIZE((POINTER)(void *)context, sizeof(*context));
+}
 /*
  * MD5 basic transformation. Transforms state based on block.
  */
 static void
 MD5Transform(UINT4 state[4], const unsigned char block[64])

 @@ -1,14 +1,14 @@
-/* 	$NetBSD: rmd160.c,v 1.2 2015/08/17 11:37:55 jperkin Exp $ */
+/* 	$NetBSD: rmd160.c,v 1.3 2015/09/01 19:38:42 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 $	*/
 /*
  * Copyright (c) 2001 Markus Friedl.  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.
 @@ -85,91 +85,91 @@
 		a = ROL(sj, a + Fj(b,c,d) + X(rj) + Kj) + e; \
 		c = ROL(10, c); \
 	} while(/*CONSTCOND*/0)
 #define X(i)	x[i]
 static const u_char PADDING[64] = {
 x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 void
-RMD160Init(RMD160_CTX *ctx)
+netpgpv_RMD160Init(NETPGPV_RMD160_CTX *ctx)
+{
 	ctx->count = 0;
 	ctx->state[0] = H0;
 	ctx->state[1] = H1;
 	ctx->state[2] = H2;
 	ctx->state[3] = H3;
 	ctx->state[4] = H4;
+}
 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;
 	have = (uint32_t)((ctx->count/8) % 64);
 	need = 64 - have;
 	ctx->count += 8 * len;
 	off = 0;
 	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;
+		}
+	}
 	if (off < len)
 		memcpy(ctx->buffer + have, input+off, (size_t)len-off);
+}
 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];
 	uint32_t padlen;
 	PUT_64BIT_LE(size, ctx->count);
 	/*
 	 * pad to 64 byte blocks, at least one byte from PADDING plus 8 bytes
 	 * for the size
 	 */
 	padlen = (uint32_t)(64 - ((ctx->count/8) % 64));
 	if (padlen < 1 + 8)
 		padlen += 64;
-	RMD160Update(ctx, PADDING, padlen - 8);		/* padlen - 8 <= 64 */
+	netpgpv_RMD160Update(ctx, PADDING, padlen - 8);		/* padlen - 8 <= 64 */
-	RMD160Update(ctx, size, 8);
+	netpgpv_RMD160Update(ctx, size, 8);
 	if (digest != NULL)
 		for (i = 0; i < 5; i++)
 			PUT_32BIT_LE(digest + i*4, ctx->state[i]);
 	memset(ctx, 0, sizeof (*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];
 #if BYTE_ORDER == LITTLE_ENDIAN
 	memcpy(x, block, (size_t)64);
 #else
 	int i;
 	for (i = 0; i < 16; i++)
 		x[i] = le32dec(block+i*4);
 #endif
 	a = state[0];

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rmd160.h,v 1.2 2015/08/17 11:37:55 jperkin 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 $	*/
 /*
  * Copyright (c) 2001 Markus Friedl.  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.
 @@ -39,29 +39,29 @@
 #  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	 netpgpv_RMD160Init(NETPGPV_RMD160_CTX *);
-void	 RMD160Transform(uint32_t [5], const u_char [64]);
+void	 netpgpv_RMD160Transform(uint32_t [5], const u_char [64]);
-void	 RMD160Update(RMD160_CTX *, const u_char *, uint32_t);
+void	 netpgpv_RMD160Update(NETPGPV_RMD160_CTX *, const u_char *, uint32_t);
-void	 RMD160Final(u_char [RMD160_DIGEST_LENGTH], RMD160_CTX *);
+void	 netpgpv_RMD160Final(u_char [RMD160_DIGEST_LENGTH], NETPGPV_RMD160_CTX *);
 #ifndef _KERNEL
-char	*RMD160End(RMD160_CTX *, char *);
+char	*netpgpv_RMD160End(NETPGPV_RMD160_CTX *, char *);
-char	*RMD160FileChunk(const char *, char *, off_t, off_t);
+char	*netpgpv_RMD160FileChunk(const char *, char *, off_t, off_t);
-char	*RMD160File(const char *, char *);
+char	*netpgpv_RMD160File(const char *, char *);
-char	*RMD160Data(const u_char *, size_t, char *);
+char	*netpgpv_RMD160Data(const u_char *, size_t, char *);
 #endif /* _KERNEL */
 __END_DECLS
 #endif  /* _RMD160_H */

 @@ -54,204 +54,204 @@ rsa_padding_check_none(uint8_t *to, int
 	USE_ARG(num);
 	if (flen > tlen) {
 		printf("r too large\n");
 		return -1;
+	}
 	(void) memset(to, 0x0, tlen - flen);
 	(void) memcpy(to + tlen - flen, from, flen);
 	return tlen;
+}
 static int
 lowlevel_rsa_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa)
+{
-	BIGNUM	*decbn;
+	PGPV_BIGNUM	*decbn;
-	BIGNUM	*signedbn;
+	PGPV_BIGNUM	*signedbn;
 	uint8_t	*decbuf;
 	int	 nbytes;
 	int	 signc;
 	int	 signedbytes;
 	int	 r;
 	decbuf = NULL;
 	r = -1;
-	decbn = BN_new();
+	decbn = PGPV_BN_new();
-	signedbn = BN_new();
+	signedbn = PGPV_BN_new();
-	nbytes = BN_num_bytes(rsa->n);
+	nbytes = PGPV_BN_num_bytes(rsa->n);
 	decbuf = netpgp_allocate(1, nbytes);
 	/* add no padding */
 	memcpy(decbuf, plain, plainc);
-	BN_bin2bn(decbuf, nbytes, decbn);
+	PGPV_BN_bin2bn(decbuf, nbytes, decbn);
-	if (BN_cmp(decbn, rsa->n) >= 0) {
+	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);
+	signedbytes = PGPV_BN_num_bytes(signedbn);
-	signc = BN_bn2bin(signedbn, &encbuf[nbytes - signedbytes]);
+	signc = PGPV_BN_bn2bin(signedbn, &encbuf[nbytes - signedbytes]);
 	memset(encbuf, 0x0, nbytes - signc);
 	r = nbytes;
 err:
 	netpgp_deallocate(decbuf, nbytes);
-	BN_clear_free(decbn);
+	PGPV_BN_clear_free(decbn);
-	BN_clear_free(signedbn);
+	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;
+	PGPV_BIGNUM	*decbn;
-	BIGNUM	*encbn;
+	PGPV_BIGNUM	*encbn;
 	uint8_t	*decbuf;
 	int	 nbytes;
 	int	 encc;
 	int	 r;
 	int	 i;
 	r = -1;
-	decbn = BN_new();
+	decbn = PGPV_BN_new();
-	encbn = BN_new();
+	encbn = PGPV_BN_new();
-	nbytes = BN_num_bytes(rsa->n);
+	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) {
+	if (PGPV_BN_cmp(decbn, rsa->n) >= 0) {
-		printf("BN_cmp failed\n");
+		printf("PGPV_BN_cmp failed\n");
 		goto err;
+	}
-	if (!BN_mod_exp(encbn, decbn, rsa->e, rsa->n, NULL)) {
+	if (!PGPV_BN_mod_exp(encbn, decbn, rsa->e, rsa->n, NULL)) {
-		printf("BN_mod_exp failed\n");
+		printf("PGPV_BN_mod_exp failed\n");
 		goto err;
+	}
-	encc = BN_num_bytes(encbn);
+	encc = PGPV_BN_num_bytes(encbn);
-	i = BN_bn2bin(encbn, &encbuf[nbytes - encc]);
+	i = PGPV_BN_bn2bin(encbn, &encbuf[nbytes - encc]);
 	(void) memset(encbuf, 0x0, nbytes - i);
 	r = nbytes;
 err:
 	if (decbuf) {
 		memset(decbuf, 0x0, nbytes);
 		netpgp_deallocate(decbuf, nbytes);
+	}
-	BN_clear_free(decbn);
+	PGPV_BN_clear_free(decbn);
-	BN_clear_free(encbn);
+	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;
+	PGPV_BIGNUM	*encbn;
-	BIGNUM	*decbn;
+	PGPV_BIGNUM	*decbn;
 	uint8_t	*buf;
 	int	 nbytes;
 	int	 j;
 	int	 r;
 	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();
+	encbn = PGPV_BN_new();
-	decbn = BN_new();
+	decbn = PGPV_BN_new();
-	nbytes = BN_num_bytes(rsa->n);
+	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);
+	PGPV_BN_bin2bn(encbuf, enclen, encbn);
-	if (BN_cmp(encbn, rsa->n) >= 0) {
+	if (PGPV_BN_cmp(encbn, rsa->n) >= 0) {
 		printf("bad encbn\n");
 		goto err;
+	}
-	BN_mod_exp(decbn, encbn, rsa->d, rsa->n, NULL);
+	PGPV_BN_mod_exp(decbn, encbn, rsa->d, rsa->n, NULL);
-	j = BN_bn2bin(decbn, buf);
+	j = PGPV_BN_bn2bin(decbn, buf);
 	r = rsa_padding_check_none(to, nbytes, buf, j, nbytes);
 err:
-	BN_clear_free(encbn);
+	PGPV_BN_clear_free(encbn);
-	BN_clear_free(decbn);
+	PGPV_BN_clear_free(decbn);
 	netpgp_deallocate(buf, nbytes);
 	return r;
+}
 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;
+	PGPV_BIGNUM		*decbn;
-	BIGNUM		*encbn;
+	PGPV_BIGNUM		*encbn;
 	int		 decbytes;
 	int		 nbytes;
 	int		 r;
 	nbytes = 0;
 	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 &&
+	if (PGPV_BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
-	    BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_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 ||
+	if ((encbn = PGPV_BN_new()) == NULL ||
-	    (decbn = BN_new()) == NULL ||
+	    (decbn = PGPV_BN_new()) == NULL ||
-	    (decbuf = netpgp_allocate(1, nbytes = BN_num_bytes(rsa->n))) == NULL) {
+	    (decbuf = netpgp_allocate(1, nbytes = PGPV_BN_num_bytes(rsa->n))) == NULL) {
 		printf("allocation failure\n");
 		goto err;
+	}
 	if (enclen > nbytes) {
 		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) {
+	if (PGPV_BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
-		printf("BN_mod_exp < 0\n");
+		printf("PGPV_BN_mod_exp < 0\n");
 		goto err;
+	}
-	decbytes = BN_num_bytes(decbn);
+	decbytes = PGPV_BN_num_bytes(decbn);
-	(void) BN_bn2bin(decbn, decbuf);
+	(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);
+	PGPV_BN_free(encbn);
-	BN_free(decbn);
+	PGPV_BN_free(decbn);
 	if (decbuf != NULL) {
 		(void) memset(decbuf, 0x0, nbytes);
 		netpgp_deallocate(decbuf, nbytes);
+	}
 	return r;
+}
 #if 0
 /**
   @file rsa_make_key.c
   RSA key generation, Tom St Denis
 */
 @@ -397,197 +397,197 @@ errkey:
 cleanup:
 	mp_clear_multi(tmp3, tmp2, tmp1, p, q, NULL);
 	return err;
+}
 #endif
 #define HASHBUF_LEN	512
 #define DSA_MAX_MODULUS_BITS	10000
 static int
 dsa_do_verify(const unsigned char *calculated, int dgst_len, const dsasig_t *sig, mpi_dsa_t *dsa)
+{
-	BIGNUM		 *M;
+	PGPV_BIGNUM		 *M;
-	BIGNUM		 *W;
+	PGPV_BIGNUM		 *W;
-	BIGNUM		 *t1;
+	PGPV_BIGNUM		 *t1;
 	int		 ret = -1;
 	int		 qbits;
 	if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL) {
 		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:
 	case 256:
 		/* openssl sources say these are the valid values */
 		/* according to FIPS 186-3 */
 		break;
 	default:
 		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;
+	}
 	/* no love for SHA512? */
 	if (dgst_len > SHA256_DIGEST_LENGTH) {
 		printf("dsa: digest too long\n");
 		return 0;
+	}
 	ret = 0;
-	if ((M = BN_new()) == NULL ||
+	if ((M = PGPV_BN_new()) == NULL ||
-	    (W = BN_new()) == NULL ||
+	    (W = PGPV_BN_new()) == NULL ||
-	    (t1 = BN_new()) == NULL) {
+	    (t1 = PGPV_BN_new()) == NULL) {
 		goto err;
+	}
-	if (BN_is_zero(sig->r) ||
+	if (PGPV_BN_is_zero(sig->r) ||
-	    BN_is_negative(sig->r) ||
+	    PGPV_BN_is_negative(sig->r) ||
-	    BN_cmp(sig->r, dsa->q) >= 0) {
+	    PGPV_BN_cmp(sig->r, dsa->q) >= 0) {
 		goto err;
+	}
-	if (BN_is_zero(sig->s) ||
+	if (PGPV_BN_is_zero(sig->s) ||
-	    BN_is_negative(sig->s) ||
+	    PGPV_BN_is_negative(sig->s) ||
-	    BN_cmp(sig->s, dsa->q) >= 0) {
+	    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;
+}
 /*************************************************************************/
 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
 dsa_verify(const signature_t *signature, const dsa_pubkey_t *pubdsa, const uint8_t *calculated, size_t hash_length)
+{
 	mpi_dsa_t	odsa;
 	dsasig_t	osig;
 	unsigned	qlen;
 	int             ret;
 	if (signature == NULL || pubdsa == NULL || calculated == NULL) {
 		return -1;
+	}
 	(void) memset(&osig, 0x0, sizeof(osig));
 	(void) memset(&odsa, 0x0, sizeof(odsa));
-	BN_copy(osig.r, signature->dsa.r);
+	PGPV_BN_copy(osig.r, signature->dsa.r);
-	BN_copy(osig.s, signature->dsa.s);
+	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);
+	PGPV_BN_free(odsa.p);
-	BN_free(odsa.q);
+	PGPV_BN_free(odsa.q);
-	BN_free(odsa.g);
+	PGPV_BN_free(odsa.g);
-	BN_free(odsa.pub_key);
+	PGPV_BN_free(odsa.pub_key);
 	odsa.p = odsa.q = odsa.g = odsa.pub_key = NULL;
-	BN_free(osig.r);
+	PGPV_BN_free(osig.r);
-	BN_free(osig.s);
+	PGPV_BN_free(osig.s);
 	osig.r = osig.s = NULL;
 	return (unsigned)ret;
+}
 RSA *
 RSA_new(void)
+{
 	return netpgp_allocate(1, sizeof(RSA));
+}
 void
 RSA_free(RSA *rsa)
+{
 	if (rsa) {
 		netpgp_deallocate(rsa, sizeof(*rsa));
+	}
+}
 int
 RSA_check_key(RSA *rsa)
+{
-	BIGNUM	*calcn;
+	PGPV_BIGNUM	*calcn;
 	int	 ret;
 	ret = 0;
 	if (rsa == NULL || rsa->p == NULL || rsa->q == NULL || rsa->n == NULL) {
 		return -1;
+	}
 	/* check that p and q are coprime, and that n = p*q. */
-	if (!BN_is_prime(rsa->p, 1, NULL, NULL, NULL) ||
+	if (!PGPV_BN_is_prime(rsa->p, 1, NULL, NULL, NULL) ||
-	    !BN_is_prime(rsa->q, 1, NULL, NULL, NULL)) {
+	    !PGPV_BN_is_prime(rsa->q, 1, NULL, NULL, NULL)) {
 		return 0;
+	}
-	calcn = BN_new();
+	calcn = PGPV_BN_new();
-        BN_mul(calcn, rsa->p, rsa->q, NULL);
+        PGPV_BN_mul(calcn, rsa->p, rsa->q, NULL);
-	if (BN_cmp(calcn, rsa->n) != 0) {
+	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;
+}
 RSA *
 RSA_generate_key(int num, unsigned long e, void (*callback)(int,int,void *), void *cb_arg)
+{
 	/* STUBBED */
 	USE_ARG(num);
 	USE_ARG(e);
 	USE_ARG(callback);
 	USE_ARG(cb_arg);
 	printf("RSA_generate_key stubbed\n");
 	return RSA_new();
 @@ -628,31 +628,31 @@ RSA_private_encrypt(int plainc, const un
 /* verify */
 int
 RSA_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, RSA *rsa, int padding)
+{
 	rsa_pubkey_t	pub;
 	int		ret;
 	if (enc == NULL || dec == NULL || rsa == NULL) {
 		return 0;
+	}
 	USE_ARG(padding);
 	(void) memset(&pub, 0x0, sizeof(pub));
-	pub.n = BN_dup(rsa->n);
+	pub.n = PGPV_BN_dup(rsa->n);
-	pub.e = BN_dup(rsa->e);
+	pub.e = PGPV_BN_dup(rsa->e);
 	ret = lowlevel_rsa_public_decrypt(enc, enclen, dec, &pub);
-	BN_free(pub.n);
+	PGPV_BN_free(pub.n);
-	BN_free(pub.e);
+	PGPV_BN_free(pub.e);
 	return ret;
+}
 /***********************************************************************/
 DSA *
 DSA_new(void)
+{
 	return netpgp_allocate(1, sizeof(DSA));
+}
 void
 DSA_free(DSA *dsa)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sha1.c,v 1.2 2015/08/17 11:37:55 jperkin 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 $	*/
 /*
  * SHA-1 in C
  * By Steve Reid <steve@edmweb.com>
  * 100% Public Domain
+ *
  * Test Vectors (from FIPS PUB 180-1)
  * "abc"
  *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
  * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
  * A million repetitions of "a"
 @@ -107,27 +107,27 @@ void
 do_R4(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *block)
+{
     nR4(a,b,c,d,e,60); nR4(e,a,b,c,d,61); nR4(d,e,a,b,c,62); nR4(c,d,e,a,b,63);
     nR4(b,c,d,e,a,64); nR4(a,b,c,d,e,65); nR4(e,a,b,c,d,66); nR4(d,e,a,b,c,67);
     nR4(c,d,e,a,b,68); nR4(b,c,d,e,a,69); nR4(a,b,c,d,e,70); nR4(e,a,b,c,d,71);
     nR4(d,e,a,b,c,72); nR4(c,d,e,a,b,73); nR4(b,c,d,e,a,74); nR4(a,b,c,d,e,75);
     nR4(e,a,b,c,d,76); nR4(d,e,a,b,c,77); nR4(c,d,e,a,b,78); nR4(b,c,d,e,a,79);
+}
 #endif
 /*
  * 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;
 #ifdef SHA1HANDSOFF
     CHAR64LONG16 workspace;
 #endif
 #ifdef SHA1HANDSOFF
     block = &workspace;
     (void)memcpy(block, buffer, 64);
 #else
     block = (CHAR64LONG16 *)(void *)buffer;
 @@ -174,75 +174,75 @@ void SHA1Transform(uint32_t state[5], co
     state[1] += b;
     state[2] += c;
     state[3] += d;
     state[4] += e;
     /* Wipe variables */
     a = b = c = d = e = 0;
+}
 /*
  * SHA1Init - Initialize new context
  */
-void SHA1Init(SHA1_CTX *context)
+void netpgpv_SHA1Init(NETPGPV_SHA1_CTX *context)
+{
     /* SHA1 initialization constants */
     context->state[0] = 0x67452301;
     context->state[1] = 0xEFCDAB89;
     context->state[2] = 0x98BADCFE;
     context->state[3] = 0x10325476;
     context->state[4] = 0xC3D2E1F0;
     context->count[0] = context->count[1] = 0;
+}
 /*
  * 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;
     j = context->count[0];
     if ((context->count[0] += len << 3) < j)
 	context->count[1] += (len>>29)+1;
     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;
+    }
     (void)memcpy(&context->buffer[j], &data[i], len - i);
+}
 /*
  * 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];
     for (i = 0; i < 8; i++) {
 	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);
+	netpgpv_SHA1Update(context, (const uint8_t *)"\0", 1);
-    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
+    netpgpv_SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
     if (digest) {
 	for (i = 0; i < 20; i++)
 	    digest[i] = (uint8_t)
 		((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+    }
+}
 #endif /* HAVE_SHA1_H */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sha1.h,v 1.2 2015/08/17 11:37:55 jperkin Exp $	*/
+/*	$NetBSD: sha1.h,v 1.3 2015/09/01 19:38:42 agc Exp $	*/
 /*
  * SHA-1 in C
  * By Steve Reid <steve@edmweb.com>
  * 100% Public Domain
  */
 #ifndef _SYS_SHA1_H_
 #define	_SYS_SHA1_H_
 #include <sys/types.h>
 #include <inttypes.h>
 @@ -20,29 +20,29 @@
 #  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	netpgpv_SHA1Transform(uint32_t[5], const uint8_t[64]);
-void	SHA1Init(SHA1_CTX *);
+void	netpgpv_SHA1Init(NETPGPV_SHA1_CTX *);
-void	SHA1Update(SHA1_CTX *, const uint8_t *, unsigned int);
+void	netpgpv_SHA1Update(NETPGPV_SHA1_CTX *, const uint8_t *, unsigned int);
-void	SHA1Final(uint8_t[SHA1_DIGEST_LENGTH], SHA1_CTX *);
+void	netpgpv_SHA1Final(uint8_t[SHA1_DIGEST_LENGTH], NETPGPV_SHA1_CTX *);
 #ifndef _KERNEL
-char	*SHA1End(SHA1_CTX *, char *);
+char	*netpgpv_SHA1End(NETPGPV_SHA1_CTX *, char *);
-char	*SHA1FileChunk(const char *, char *, off_t, off_t);
+char	*netpgpv_SHA1FileChunk(const char *, char *, off_t, off_t);
-char	*SHA1File(const char *, char *);
+char	*netpgpv_SHA1File(const char *, char *);
-char	*SHA1Data(const uint8_t *, size_t, char *);
+char	*netpgpv_SHA1Data(const uint8_t *, size_t, char *);
 #endif /* _KERNEL */
 __END_DECLS
 #endif /* _SYS_SHA1_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sha2.h,v 1.2 2015/08/17 11:37:55 jperkin Exp $	*/
+/*	$NetBSD: sha2.h,v 1.3 2015/09/01 19:38:42 agc Exp $	*/
 /*	$KAME: sha2.h,v 1.4 2003/07/20 00:28:38 itojun Exp $	*/
 /*
  * sha2.h
+ *
  * Version 1.0.0beta1
+ *
  * Written by Aaron D. Gifford <me@aarongifford.com>
+ *
  * Copyright 2000 Aaron D. Gifford.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -56,73 +56,73 @@
 #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 NETPGPV_SHA256_CTX NETPGPV_SHA224_CTX;
-typedef SHA512_CTX SHA384_CTX;
+typedef NETPGPV_SHA512_CTX NETPGPV_SHA384_CTX;
 /*** SHA-256/384/512 Function Prototypes ******************************/
 __BEGIN_DECLS
-int SHA224_Init(SHA224_CTX *);
+int netpgpv_SHA224_Init(NETPGPV_SHA224_CTX *);
-int SHA224_Update(SHA224_CTX*, const uint8_t*, size_t);
+int netpgpv_SHA224_Update(NETPGPV_SHA224_CTX*, const uint8_t*, size_t);
-int SHA224_Final(uint8_t[SHA224_DIGEST_LENGTH], SHA224_CTX*);
+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 *netpgpv_SHA224_End(NETPGPV_SHA224_CTX *, char[SHA224_DIGEST_STRING_LENGTH]);
-char *SHA224_FileChunk(const char *, char *, off_t, off_t);
+char *netpgpv_SHA224_FileChunk(const char *, char *, off_t, off_t);
-char *SHA224_File(const char *, char *);
+char *netpgpv_SHA224_File(const char *, char *);
-char *SHA224_Data(const uint8_t *, size_t, char[SHA224_DIGEST_STRING_LENGTH]);
+char *netpgpv_SHA224_Data(const uint8_t *, size_t, char[SHA224_DIGEST_STRING_LENGTH]);
 #endif /* !_KERNEL */
-int SHA256_Init(SHA256_CTX *);
+int netpgpv_SHA256_Init(NETPGPV_SHA256_CTX *);
-int SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
+int netpgpv_SHA256_Update(NETPGPV_SHA256_CTX*, const uint8_t*, size_t);
-int SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
+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 *netpgpv_SHA256_End(NETPGPV_SHA256_CTX *, char[SHA256_DIGEST_STRING_LENGTH]);
-char *SHA256_FileChunk(const char *, char *, off_t, off_t);
+char *netpgpv_SHA256_FileChunk(const char *, char *, off_t, off_t);
-char *SHA256_File(const char *, char *);
+char *netpgpv_SHA256_File(const char *, char *);
-char *SHA256_Data(const uint8_t *, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+char *netpgpv_SHA256_Data(const uint8_t *, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
 #endif /* !_KERNEL */
-int SHA384_Init(SHA384_CTX*);
+int netpgpv_SHA384_Init(NETPGPV_SHA384_CTX*);
-int SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
+int netpgpv_SHA384_Update(NETPGPV_SHA384_CTX*, const uint8_t*, size_t);
-int SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
+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 *netpgpv_SHA384_End(NETPGPV_SHA384_CTX *, char[SHA384_DIGEST_STRING_LENGTH]);
-char *SHA384_FileChunk(const char *, char *, off_t, off_t);
+char *netpgpv_SHA384_FileChunk(const char *, char *, off_t, off_t);
-char *SHA384_File(const char *, char *);
+char *netpgpv_SHA384_File(const char *, char *);
-char *SHA384_Data(const uint8_t *, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+char *netpgpv_SHA384_Data(const uint8_t *, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
 #endif /* !_KERNEL */
-int SHA512_Init(SHA512_CTX*);
+int netpgpv_SHA512_Init(NETPGPV_SHA512_CTX*);
-int SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
+int netpgpv_SHA512_Update(NETPGPV_SHA512_CTX*, const uint8_t*, size_t);
-int SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
+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 *netpgpv_SHA512_End(NETPGPV_SHA512_CTX *, char[SHA512_DIGEST_STRING_LENGTH]);
-char *SHA512_FileChunk(const char *, char *, off_t, off_t);
+char *netpgpv_SHA512_FileChunk(const char *, char *, off_t, off_t);
-char *SHA512_File(const char *, char *);
+char *netpgpv_SHA512_File(const char *, char *);
-char *SHA512_Data(const uint8_t *, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+char *netpgpv_SHA512_Data(const uint8_t *, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
 #endif /* !_KERNEL */
 __END_DECLS
 #endif /* __SHA2_H__ */

	@@ -709,75 +709,75 @@ sprint_uint64(char *buf, uint64_t val)		@@ -709,75 +709,75 @@ sprint_uint64(char *buf, uint64_t val)
709	for (i = 0; i < 8; ++i) {	709	for (i = 0; i < 8; ++i) {
710	if (IS_LITTLE_ENDIAN(indian)) {	710	if (IS_LITTLE_ENDIAN(indian)) {
711	buf[2 * (7 - i)] = hexdigits[(val >> (56 - 8 * i + 4)) & 15];	711	buf[2 * (7 - i)] = hexdigits[(val >> (56 - 8 * i + 4)) & 15];
712	buf[(2 * (7 - i)) + 1] = hexdigits[(val >> (56 - 8 * i)) & 15];	712	buf[(2 * (7 - i)) + 1] = hexdigits[(val >> (56 - 8 * i)) & 15];
713	} else {	713	} else {
714	buf[2 * i] = hexdigits[(val >> (56 - 8 * i + 4)) & 15];	714	buf[2 * i] = hexdigits[(val >> (56 - 8 * i + 4)) & 15];
715	buf[(2 * i) + 1] = hexdigits[(val >> (56 - 8 * i)) & 15];	715	buf[(2 * i) + 1] = hexdigits[(val >> (56 - 8 * i)) & 15];
716	}	716	}
717	}	717	}
718	}	718	}
719		719
720	/* common function to initialise context */	720	/* common function to initialise context */
721	static void	721	static void
722	initcontext(TIGER_CTX *ctx, uint8_t pad)	722	initcontext(NETPGPV_TIGER_CTX *ctx, uint8_t pad)
723	{	723	{
724	(void) memset(ctx, 0x0, sizeof(*ctx));	724	(void) memset(ctx, 0x0, sizeof(*ctx));
725	ctx->ctx[0] = 0x0123456789ABCDEFLL;	725	ctx->ctx[0] = 0x0123456789ABCDEFLL;
726	ctx->ctx[1] = 0xFEDCBA9876543210LL;	726	ctx->ctx[1] = 0xFEDCBA9876543210LL;
727	ctx->ctx[2] = 0xF096A5B4C3B2E187LL;	727	ctx->ctx[2] = 0xF096A5B4C3B2E187LL;
728	ctx->init = 1;	728	ctx->init = 1;
729	ctx->pad = pad;	729	ctx->pad = pad;
730	}	730	}
731		731
732	/* set the version number (0 is same as 1 for Tiger) */	732	/* set the version number (0 is same as 1 for Tiger) */
733	static int	733	static int
734	setversion(TIGER_CTX *ctx, int version)	734	setversion(NETPGPV_TIGER_CTX *ctx, int version)
735	{	735	{
736	switch(version) {	736	switch(version) {
737	case 0:	737	case 0:
738	case 1:	738	case 1:
739	initcontext(ctx, 0x01);	739	initcontext(ctx, 0x01);
740	break;	740	break;
741	case 2:	741	case 2:
742	initcontext(ctx, 0x80);	742	initcontext(ctx, 0x80);
743	break;	743	break;
744	default:	744	default:
745	(void) fprintf(stderr, "unknown version %d\n", version);	745	(void) fprintf(stderr, "unknown version %d\n", version);
746	return 0;	746	return 0;
747	}	747	}
748	return 1;	748	return 1;
749	}	749	}
750		750
751	/*****************************************************************************/	751	/*****************************************************************************/
752		752
753	void	753	void
754	TIGER_Init(TIGER_CTX *ctx)	754	netpgpv_TIGER_Init(NETPGPV_TIGER_CTX *ctx)
755	{	755	{
756	if (ctx) {	756	if (ctx) {
757	initcontext(ctx, 0x01);	757	initcontext(ctx, 0x01);
758	}	758	}
759	}	759	}
760		760
761	void	761	void
762	TIGER2_Init(TIGER_CTX *ctx)	762	netpgpv_TIGER2_Init(NETPGPV_TIGER_CTX *ctx)
763	{	763	{
764	if (ctx) {	764	if (ctx) {
765	initcontext(ctx, 0x80);	765	initcontext(ctx, 0x80);
766	}	766	}
767	}	767	}
768		768
769	void	769	void
770	TIGER_Update(TIGER_CTX ctx, const void data, size_t length)	770	netpgpv_TIGER_Update(NETPGPV_TIGER_CTX ctx, const void data, size_t length)
771	{	771	{
772	const uint64_t str = (const uint64_t )data;	772	const uint64_t str = (const uint64_t )data;
773	uint64_t i;	773	uint64_t i;
774	uint64_t j;	774	uint64_t j;
775	union {	775	union {
776	uint8_t temp8[64];	776	uint8_t temp8[64];
777	uint64_t temp64[8];	777	uint64_t temp64[8];
778	} u;	778	} u;
779	int indian = 1;	779	int indian = 1;
780		780
781	if (ctx == NULL \|\| data == NULL) {	781	if (ctx == NULL \|\| data == NULL) {
782	return;	782	return;
783	}	783	}
	@@ -814,93 +814,93 @@ TIGER_Update(TIGER_CTX *ctx, const void		@@ -814,93 +814,93 @@ TIGER_Update(TIGER_CTX *ctx, const void
814	u.temp8[j] = 0;	814	u.temp8[j] = 0;
815	}	815	}
816	tiger_compress(u.temp64, ctx->ctx);	816	tiger_compress(u.temp64, ctx->ctx);
817	j = 0;	817	j = 0;
818	}	818	}
819	for (; j < 56; j++) {	819	for (; j < 56; j++) {
820	u.temp8[j] = 0;	820	u.temp8[j] = 0;
821	}	821	}
822	u.temp64[7] = ((uint64_t)length) << 3;	822	u.temp64[7] = ((uint64_t)length) << 3;
823	tiger_compress(u.temp64, ctx->ctx);	823	tiger_compress(u.temp64, ctx->ctx);
824	}	824	}
825		825
826	void	826	void
827	TIGER_Final(uint8_t digest, TIGER_CTX ctx)	827	netpgpv_TIGER_Final(uint8_t digest, NETPGPV_TIGER_CTX ctx)
828	{	828	{
829	uint64_t le[3];	829	uint64_t le[3];
830	int indian = 1;	830	int indian = 1;
831	int i;	831	int i;
832		832
833	if (digest == NULL \|\| ctx == NULL) {	833	if (digest == NULL \|\| ctx == NULL) {
834	return;	834	return;
835	}	835	}
836	if (!ctx->init) {	836	if (!ctx->init) {
837	TIGER_Init(ctx);	837	netpgpv_TIGER_Init(ctx);
838	TIGER_Update(ctx, NULL, 0);	838	netpgpv_TIGER_Update(ctx, NULL, 0);
839	}	839	}
840	if (IS_LITTLE_ENDIAN(indian)) {	840	if (IS_LITTLE_ENDIAN(indian)) {
841	for (i = 0; i < 3; ++i) {	841	for (i = 0; i < 3; ++i) {
842	le[i] = (uint64_t)BSWAP64(ctx->ctx[i]);	842	le[i] = (uint64_t)BSWAP64(ctx->ctx[i]);
843	}	843	}
844	(void) memcpy(digest, le, 3 * sizeof(le[0]));	844	(void) memcpy(digest, le, 3 * sizeof(le[0]));
845	} else {	845	} else {
846	(void) memcpy(digest, ctx->ctx, 3 * sizeof(ctx->ctx[0]));	846	(void) memcpy(digest, ctx->ctx, 3 * sizeof(ctx->ctx[0]));
847	}	847	}
848	}	848	}
849		849
850	char *	850	char *
851	TIGER_End(TIGER_CTX ctx, char buf)	851	netpgpv_TIGER_End(NETPGPV_TIGER_CTX ctx, char buf)
852	{	852	{
853	int i;	853	int i;
854		854
855	if (ctx == NULL) {	855	if (ctx == NULL) {
856	return NULL;	856	return NULL;
857	}	857	}
858	if (buf == NULL && (buf = calloc(1, 49)) == NULL) {	858	if (buf == NULL && (buf = calloc(1, 49)) == NULL) {
859	return NULL;	859	return NULL;
860	}	860	}
861	if (!ctx->init) {	861	if (!ctx->init) {
862	TIGER_Init(ctx);	862	netpgpv_TIGER_Init(ctx);
863	TIGER_Update(ctx, NULL, 0);	863	netpgpv_TIGER_Update(ctx, NULL, 0);
864	}	864	}
865	for (i = 0; i < 3; ++i) {	865	for (i = 0; i < 3; ++i) {
866	sprint_uint64(buf + i * 16, ctx->ctx[i]);	866	sprint_uint64(buf + i * 16, ctx->ctx[i]);
867	}	867	}
868	buf[16 * i] = 0x0;	868	buf[16 * i] = 0x0;
869	return buf;	869	return buf;
870	}	870	}
871		871
872	char *	872	char *
873	TIGER_File(char filename, char buf, int version)	873	netpgpv_TIGER_File(char filename, char buf, int version)
874	{	874	{
875	TIGER_CTX ctx;	875	NETPGPV_TIGER_CTX ctx;
876	uint8_t buffer[BUFSIZ];	876	uint8_t buffer[BUFSIZ];
877	ssize_t num;	877	ssize_t num;
878	int fd;	878	int fd;
879	int oerrno;	879	int oerrno;
880		880
881	if (filename == NULL \|\| buf == NULL \|\| !setversion(&ctx, version)) {	881	if (filename == NULL \|\| buf == NULL \|\| !setversion(&ctx, version)) {
882	return NULL;	882	return NULL;
883	}	883	}
884	if ((fd = open(filename, O_RDONLY)) < 0) {	884	if ((fd = open(filename, O_RDONLY)) < 0) {
885	return NULL;	885	return NULL;
886	}	886	}
887	while ((num = read(fd, buffer, sizeof(buffer))) > 0) {	887	while ((num = read(fd, buffer, sizeof(buffer))) > 0) {
888	TIGER_Update(&ctx, buffer, (size_t)num);	888	netpgpv_TIGER_Update(&ctx, buffer, (size_t)num);
889	}	889	}
890	oerrno = errno;	890	oerrno = errno;
891	close(fd);	891	close(fd);
892	errno = oerrno;	892	errno = oerrno;
893	return (num < 0) ? NULL : TIGER_End(&ctx, buf);	893	return (num < 0) ? NULL : netpgpv_TIGER_End(&ctx, buf);
894	}	894	}
895		895
896	char *	896	char *
897	TIGER_Data(const uint8_t data, size_t len, char buf, int version)	897	netpgpv_TIGER_Data(const uint8_t data, size_t len, char buf, int version)
898	{	898	{
899	TIGER_CTX ctx;	899	NETPGPV_TIGER_CTX ctx;
900		900
901	if (data == NULL \|\| buf == NULL \|\| !setversion(&ctx, version)) {	901	if (data == NULL \|\| buf == NULL \|\| !setversion(&ctx, version)) {
902	return NULL;	902	return NULL;
903	}	903	}
904	TIGER_Update(&ctx, data, len);	904	netpgpv_TIGER_Update(&ctx, data, len);
905	return TIGER_End(&ctx, buf);	905	return netpgpv_TIGER_End(&ctx, buf);
906	}	906	}

 @@ -104,69 +104,69 @@ digest_alg_size(unsigned alg)
 		return 0;
+	}
+}
 /* initialise the hash structure */
 int
 digest_init(digest_t *hash, const uint32_t hashalg)
+{
 	if (hash == NULL) {
 		return 0;
+	}
 	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);
 		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);
 		hash->ctx = &hash->u.tigerctx;
 		return 1;
 	default:
 		printf("hash_any: bad algorithm\n");
 		return 0;
+	}
+}
 typedef struct rec_t {
 	const char	*s;
 @@ -196,74 +196,74 @@ digest_get_alg(const char *hashalg)
+		}
+	}
 	return 0;
+}
 int
 digest_update(digest_t *hash, const uint8_t *data, size_t length)
+{
 	if (hash == NULL || data == NULL) {
 		return 0;
+	}
 	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);
 		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");
 		return 0;
+	}
+}
 unsigned
 digest_final(uint8_t *out, digest_t *hash)
+{
 	if (hash == NULL || out == NULL) {
 		return 0;
+	}
 	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);
 		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");
 		return 0;
+	}
 	(void) memset(hash->ctx, 0x0, hash->size);
 	return (unsigned)hash->size;
+}
 int
 digest_length(digest_t *hash, unsigned hashedlen)
+{
 	uint8_t		 trailer[6];

 @@ -52,32 +52,32 @@ __BEGIN_DECLS
 #define RIPEMD_HASH_ALG		3
 #define TIGER_HASH_ALG		6	/* from rfc2440 */
 #define SHA256_HASH_ALG		8
 #define SHA384_HASH_ALG		9
 #define SHA512_HASH_ALG		10
 #define SHA224_HASH_ALG		11
 #define TIGER2_HASH_ALG		100	/* private/experimental from rfc4880 */
 /* structure to describe digest methods */
 typedef struct digest_t {
 	uint32_t		 alg;		/* algorithm */
 	size_t			 size;		/* size */
 	union {
-		MD5_CTX		 md5ctx;	/* MD5 */
+		NETPGPV_MD5_CTX		 md5ctx;	/* MD5 */
-		SHA1_CTX	 sha1ctx;	/* SHA1 */
+		NETPGPV_SHA1_CTX	 sha1ctx;	/* SHA1 */
-		RMD160_CTX	 rmd160ctx;	/* RIPEMD */
+		NETPGPV_RMD160_CTX	 rmd160ctx;	/* RIPEMD */
-		SHA256_CTX	 sha256ctx;	/* SHA256 */
+		NETPGPV_SHA256_CTX	 sha256ctx;	/* SHA256 */
-		SHA512_CTX	 sha512ctx;	/* SHA512 */
+		NETPGPV_SHA512_CTX	 sha512ctx;	/* SHA512 */
-		TIGER_CTX	 tigerctx;	/* TIGER/TIGER2 */
+		NETPGPV_TIGER_CTX	 tigerctx;	/* TIGER/TIGER2 */
 	} u;
 	void			*prefix;	/* points to specific prefix */
 	uint32_t		 len;		/* prefix length */
 	void			*ctx;		/* pointer to context array */
 } digest_t;
 unsigned digest_get_alg(const char */*hashalg*/);
 int digest_init(digest_t */*digest*/, const uint32_t /*hashalg*/);
 int digest_update(digest_t */*digest*/, const uint8_t */*data*/, size_t /*size*/);
 unsigned digest_final(uint8_t */*out*/, digest_t */*digest*/);
 int digest_alg_size(unsigned /*alg*/);

 @@ -30,73 +30,73 @@
 #ifndef __BEGIN_DECLS
 #  if defined(__cplusplus)
 #  define __BEGIN_DECLS           extern "C" {
 #  define __END_DECLS             }
 #  else
 #  define __BEGIN_DECLS
 #  define __END_DECLS
 #  endif
 #endif
 __BEGIN_DECLS
 typedef struct rsa_pubkey_t {
-	BIGNUM		*n;	/* RSA public modulus n */
+	PGPV_BIGNUM		*n;	/* RSA public modulus n */
-	BIGNUM		*e;	/* RSA public encryption exponent e */
+	PGPV_BIGNUM		*e;	/* RSA public encryption exponent e */
 } rsa_pubkey_t;
 typedef struct mpi_rsa_t {
 	int		 f1;	/* openssl pad */
 	long		 f2;	/* openssl version */
 	const void	*f3;	/* openssl method */
 	void		*f4;	/* openssl engine */
-	BIGNUM		*n;
+	PGPV_BIGNUM		*n;
-	BIGNUM		*e;
+	PGPV_BIGNUM		*e;
-	BIGNUM		*d;
+	PGPV_BIGNUM		*d;
-	BIGNUM		*p;
+	PGPV_BIGNUM		*p;
-	BIGNUM		*q;
+	PGPV_BIGNUM		*q;
-	BIGNUM		*dmp1;
+	PGPV_BIGNUM		*dmp1;
-	BIGNUM		*dmq1;
+	PGPV_BIGNUM		*dmq1;
-	BIGNUM		*iqmp;
+	PGPV_BIGNUM		*iqmp;
 } mpi_rsa_t;
 #define RSA	mpi_rsa_t
 typedef struct dsa_pubkey_t {
-	BIGNUM		*p;	/* DSA public modulus n */
+	PGPV_BIGNUM		*p;	/* DSA public modulus n */
-	BIGNUM		*q;	/* DSA public encryption exponent e */
+	PGPV_BIGNUM		*q;	/* DSA public encryption exponent e */
-	BIGNUM		*g;
+	PGPV_BIGNUM		*g;
-	BIGNUM		*y;
+	PGPV_BIGNUM		*y;
 } dsa_pubkey_t;
 typedef struct mpi_dsa_t {
-	BIGNUM		*p;
+	PGPV_BIGNUM		*p;
-	BIGNUM		*q;
+	PGPV_BIGNUM		*q;
-	BIGNUM		*g;
+	PGPV_BIGNUM		*g;
-	BIGNUM		*y;
+	PGPV_BIGNUM		*y;
-	BIGNUM		*x;
+	PGPV_BIGNUM		*x;
-	BIGNUM		*pub_key;
+	PGPV_BIGNUM		*pub_key;
-	BIGNUM		*priv_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 */
+	PGPV_BIGNUM		*r;			/* mpi which is actual signature */
-	BIGNUM		*s;			/* mpi which is actual signature */
+	PGPV_BIGNUM		*s;			/* mpi which is actual signature */
 } dsasig_t;
 #define DSA_SIG		dsasig_t
 /* misc defs */
 #define RSA_NO_PADDING			3
 #define SIGNETBSD_ID_SIZE		8
 #define SIGNETBSD_NAME_SIZE		128
 #define RSA_PUBKEY_ALG			1
 #define DSA_PUBKEY_ALG			17

 @@ -34,32 +34,32 @@
 #  define __BEGIN_DECLS           extern "C" {
 #  define __END_DECLS             }
 #  else
 #  define __BEGIN_DECLS
 #  define __END_DECLS
 #  endif
 #endif
 __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 netpgpv_TIGER_Init(NETPGPV_TIGER_CTX *);
-void TIGER2_Init(TIGER_CTX *);
+void netpgpv_TIGER2_Init(NETPGPV_TIGER_CTX *);
-void TIGER_Update(TIGER_CTX *, const void *, size_t);
+void netpgpv_TIGER_Update(NETPGPV_TIGER_CTX *, const void *, size_t);
-void TIGER_Final(uint8_t *, TIGER_CTX *);
+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 *netpgpv_TIGER_File(char *, char *, int);
-char *TIGER_Data(const uint8_t *, size_t, char *, int);
+char *netpgpv_TIGER_Data(const uint8_t *, size_t, char *, int);
 __END_DECLS
 #endif

 @@ -421,55 +421,55 @@ fmt_binary(char *s, size_t size, const u
 	size_t		cc;
 	for (cc = 0, i = 0 ; i < len && cc < size ; i++) {
 		cc += snprintf(&s[cc], size - cc, "%02x", bin[i]);
+	}
 	return cc;
+}
 /* format an mpi into memory */
 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;
+	bn = (PGPV_BIGNUM *)mpi->bn;
-	if (bn == NULL || BN_is_zero(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;
+}
 /* dump an mpi value onto stdout */
 static size_t
 fmt_mpi(char *s, size_t size, pgpv_bignum_t *bn, const char *name, int pbits)
+{
 	size_t	 cc;
 	char	*buf;
 	cc = snprintf(s, size, "%s=", name);
 	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;
+}
 #define ALG_IS_RSA(alg)	(((alg) == PUBKEY_RSA_ENCRYPT_OR_SIGN) ||	\
 			 ((alg) == PUBKEY_RSA_ENCRYPT) ||		\
 			 ((alg) == PUBKEY_RSA_SIGN))
 #define ALG_IS_DSA(alg)	((alg) == PUBKEY_DSA)
 /* format key mpis into memory */
 static unsigned
 @@ -723,27 +723,27 @@ print_key_mpis(pgpv_bignum_t *v, uint8_t
+}
 /* get an mpi, including 2 byte length */
 static int
 get_mpi(pgpv_bignum_t *mpi, uint8_t *p, size_t pktlen, size_t *off)
+{
 	size_t	bytes;
 	mpi->bits = get_16(p);
 	if ((bytes = (size_t)BITS_TO_BYTES(mpi->bits)) > pktlen) {
 		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;
+}
 /* read mpis in signature */
 static int
 read_signature_mpis(pgpv_sigpkt_t *sigpkt, uint8_t *p, size_t pktlen)
+{
 	size_t	off;
 	off = 0;
 	switch(sigpkt->sig.keyalg) {
 	case PUBKEY_RSA_ENCRYPT_OR_SIGN:
 @@ -1523,104 +1523,104 @@ rsa_padding_check_none(uint8_t *to, int
 	(void) memcpy(to + tlen - flen, from, (size_t)flen);
 	return tlen;
+}
 #define RSA_MAX_MODULUS_BITS	16384
 #define RSA_SMALL_MODULUS_BITS	3072
 #define RSA_MAX_PUBEXP_BITS	64 /* exponent limit enforced for "large" modulus only */
 /* check against the exponent/moudulo operation */
 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;
+	PGPV_BIGNUM		*decbn;
-	BIGNUM		*encbn;
+	PGPV_BIGNUM		*encbn;
 	int		 decbytes;
 	int		 nbytes;
 	int		 r;
 	nbytes = 0;
 	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 &&
+	if (PGPV_BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
-	    BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_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);
+	nbytes = PGPV_BN_num_bytes(rsa->n);
-	if ((encbn = BN_new()) == NULL ||
+	if ((encbn = PGPV_BN_new()) == NULL ||
-	    (decbn = BN_new()) == NULL ||
+	    (decbn = PGPV_BN_new()) == NULL ||
 	    (decbuf = calloc(1, (size_t)nbytes)) == NULL) {
 		printf("allocation failure\n");
 		goto err;
+	}
 	if (enclen > nbytes) {
 		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) {
+	if (PGPV_BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
-		printf("BN_mod_exp < 0\n");
+		printf("PGPV_BN_mod_exp < 0\n");
 		goto err;
+	}
-	decbytes = BN_num_bytes(decbn);
+	decbytes = PGPV_BN_num_bytes(decbn);
-	(void) BN_bn2bin(decbn, decbuf);
+	(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);
+	PGPV_BN_free(encbn);
-	BN_free(decbn);
+	PGPV_BN_free(decbn);
 	if (decbuf != NULL) {
 		(void) memset(decbuf, 0x0, nbytes);
 		free(decbuf);
+	}
 	return r;
+}
 /* verify */
 static int
 rsa_public_decrypt(int enclen, const unsigned char *enc, unsigned char *dec, RSA *rsa, int padding)
+{
 	rsa_pubkey_t	pub;
 	int		ret;
 	if (enc == NULL || dec == NULL || rsa == NULL) {
 		return 0;
+	}
 	USE_ARG(padding);
 	(void) memset(&pub, 0x0, sizeof(pub));
-	pub.n = BN_dup(rsa->n);
+	pub.n = PGPV_BN_dup(rsa->n);
-	pub.e = BN_dup(rsa->e);
+	pub.e = PGPV_BN_dup(rsa->e);
 	ret = lowlevel_rsa_public_check(enc, enclen, dec, &pub);
-	BN_free(pub.n);
+	PGPV_BN_free(pub.n);
-	BN_free(pub.e);
+	PGPV_BN_free(pub.e);
 	return ret;
+}
 #define SUBKEY_LEN(x)	(80 + 80)
 #define SIG_LEN		80
 #define UID_LEN		80
 /* return worst case number of bytes needed to format a primary key */
 static size_t
 estimate_primarykey_size(pgpv_primarykey_t *primary)
+{
 	size_t		cc;
 @@ -1651,74 +1651,74 @@ pgpv_rsa_public_decrypt(uint8_t *out, co
 /* verify rsa signature */
 static int
 rsa_verify(uint8_t *calculated, unsigned calclen, uint8_t hashalg, pgpv_bignum_t *bn, pgpv_pubkey_t *pubkey)
+{
 	unsigned	 prefixlen;
 	unsigned	 decryptc;
 	unsigned	 i;
 	uint8_t		 decrypted[8192];
 	uint8_t		 sigbn[8192];
 	uint8_t		 prefix[64];
 	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;
+	}
 	if ((prefixlen = digest_get_prefix((unsigned)hashalg, prefix, sizeof(prefix))) == 0) {
 		printf("rsa_verify: unknown hash algorithm: %d\n", hashalg);
 		return 0;
+	}
 	for (i = 2 ; i < keysize - prefixlen - calclen - 1 ; i++) {
 		if (decrypted[i] != 0xff) {
 			return 0;
+		}
+	}
 	if (decrypted[i++] != 0x0) {
 		return 0;
+	}
 	if (memcmp(&decrypted[i], prefix, prefixlen) != 0) {
 		printf("rsa_verify: wrong hash algorithm\n");
 		return 0;
+	}
 	return memcmp(&decrypted[i + prefixlen], calculated, calclen) == 0;
+}
 /* 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
 #endif
 /* verify DSA signature */
 static int
 verify_dsa_sig(uint8_t *calculated, unsigned calclen, pgpv_bignum_t *sig, pgpv_pubkey_t *pubkey)
+{
 	unsigned	  qbits;
 	uint8_t		  calcnum[128];
 	uint8_t		  signum[128];
-	BIGNUM		 *M;
+	PGPV_BIGNUM		 *M;
-	BIGNUM		 *W;
+	PGPV_BIGNUM		 *W;
-	BIGNUM		 *t1;
+	PGPV_BIGNUM		 *t1;
 	int		  ret;
 	if (pubkey->bn[DSA_P].bn == NULL ||
 	    pubkey->bn[DSA_Q].bn == NULL ||
 	    pubkey->bn[DSA_G].bn == NULL) {
 		return 0;
+	}
 	M = W = t1 = NULL;
 	qbits = pubkey->bn[DSA_Q].bits;
 	switch(qbits) {
 	case 160:
 	case 224:
 	case 256:
 @@ -1726,57 +1726,57 @@ verify_dsa_sig(uint8_t *calculated, unsi
 	default:
 		printf("dsa: bad # of Q bits\n");
 		return 0;
+	}
 	if (pubkey->bn[DSA_P].bits > DSA_MAX_MODULUS_BITS) {
 		printf("dsa: p too large\n");
 		return 0;
+	}
 	if (calclen > SHA256_DIGEST_LENGTH) {
 		printf("dsa: digest too long\n");
 		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 ||
+	if (PGPV_BN_bin2bn(calculated, (int)calclen, M) == NULL ||
-	    !BN_mod_mul(M, M, W, pubkey->bn[DSA_Q].bn, NULL) ||
+	    !PGPV_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) ||
+	    !PGPV_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) ||
+	    !PGPV_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) ||
+	    !PGPV_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) ||
+	    !PGPV_BN_mod_mul(t1, t1, W, pubkey->bn[DSA_P].bn, NULL) ||
-	    !BN_div(NULL, t1, t1, pubkey->bn[DSA_Q].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);
+	PGPV_BN_bn2bin(t1, calcnum);
-	BN_bn2bin(sig[DSA_R].bn, signum);
+	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;
+}
 #define TIME_SNPRINTF(_cc, _buf, _size, _fmt, _val)	do {		\
 	time_t	 _t;							\
 	char	*_s;							\
+									\
 	_t = _val;							\
 	_s = ctime(&_t);						\
 	_cc += snprintf(_buf, _size, _fmt, _s);				\
 } while(/*CONSTCOND*/0)
 @@ -2192,28 +2192,28 @@ read_binary_file(pgpv_t *pgp, const char
+}
 /* get a bignum from the buffer gap */
 static int
 getbignum(pgpv_bignum_t *bignum, bufgap_t *bg, char *buf, const char *header)
+{
 	uint32_t	 len;
 	USE_ARG(header);
 	(void) bufgap_getbin(bg, &len, sizeof(len));
 	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->bn = PGPV_BN_bin2bn((const uint8_t *)buf, (int)len, NULL);
-	bignum->bits = BN_num_bits(bignum->bn);
+	bignum->bits = PGPV_BN_num_bits(bignum->bn);
 	(void) bufgap_seek(bg, len, BGFromHere, BGByte);
 	return 1;
+}
 /* structure for searching for constant strings */
 typedef struct str_t {
 	const char	*s;		/* string */
 	size_t		 len;		/* its length */
 	int		 type;		/* return type */
 } str_t;
 static str_t	pkatypes[] = {
 	{	"ssh-rsa",	7,	PUBKEY_RSA_SIGN	},

 @@ -1,14 +1,14 @@
-/* $NetBSD: sha2.c,v 1.3 2015/08/17 11:37:55 jperkin Exp $ */
+/* $NetBSD: sha2.c,v 1.4 2015/09/01 19:38:42 agc Exp $ */
 /*	$KAME: sha2.c,v 1.9 2003/07/20 00:28:38 itojun Exp $	*/
 /*
  * sha2.c
+ *
  * Version 1.0.0beta1
+ *
  * Written by Aaron D. Gifford <me@aarongifford.com>
+ *
  * Copyright 2000 Aaron D. Gifford.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -149,31 +149,31 @@ be64toh(uint64_t x)
 #define sigma1_256(x)	(S32(17, (x)) ^ S32(19, (x)) ^ R(10,   (x)))
 /* Four of six logical functions used in SHA-384 and SHA-512: */
 #define Sigma0_512(x)	(S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
 #define Sigma1_512(x)	(S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
 #define sigma0_512(x)	(S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7,   (x)))
 #define sigma1_512(x)	(S64(19, (x)) ^ S64(61, (x)) ^ R( 6,   (x)))
 /*** INTERNAL FUNCTION PROTOTYPES *************************************/
 /* NOTE: These should not be accessed directly from outside this
  * library -- they are intended for private internal visibility/use
  * only.
  */
-static void SHA512_Last(SHA512_CTX *);
+static void netpgpv_SHA512_Last(NETPGPV_SHA512_CTX *);
-void SHA224_Transform(SHA224_CTX *, const uint32_t*);
+void netpgpv_SHA224_Transform(NETPGPV_SHA224_CTX *, const uint32_t*);
-void SHA256_Transform(SHA256_CTX *, const uint32_t*);
+void netpgpv_SHA256_Transform(NETPGPV_SHA256_CTX *, const uint32_t*);
-void SHA384_Transform(SHA384_CTX *, const uint64_t*);
+void netpgpv_SHA384_Transform(NETPGPV_SHA384_CTX *, const uint64_t*);
-void SHA512_Transform(SHA512_CTX *, const uint64_t*);
+void netpgpv_SHA512_Transform(NETPGPV_SHA512_CTX *, const uint64_t*);
 /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
 /* Hash constant words K for SHA-256: */
 static const uint32_t K256[64] = {
 x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
 x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
 xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
 x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
 xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
 x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
 x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
 xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
 @@ -271,27 +271,27 @@ static const uint64_t sha384_initial_has
 static const uint64_t sha512_initial_hash_value[8] = {
 x6a09e667f3bcc908ULL,
 xbb67ae8584caa73bULL,
 x3c6ef372fe94f82bULL,
 xa54ff53a5f1d36f1ULL,
 x510e527fade682d1ULL,
 x9b05688c2b3e6c1fULL,
 x1f83d9abfb41bd6bULL,
 x5be0cd19137e2179ULL
 };
 /*** SHA-256: *********************************************************/
 int
-SHA256_Init(SHA256_CTX *context)
+netpgpv_SHA256_Init(NETPGPV_SHA256_CTX *context)
+{
 	if (context == NULL)
 		return 1;
 	memcpy(context->state, sha256_initial_hash_value,
 	    (size_t)(SHA256_DIGEST_LENGTH));
 	memset(context->buffer, 0, (size_t)(SHA256_BLOCK_LENGTH));
 	context->bitcount = 0;
 	return 1;
+}
 #ifdef SHA2_UNROLL_TRANSFORM
 @@ -309,27 +309,27 @@ SHA256_Init(SHA256_CTX *context)
 #define ROUND256(a,b,c,d,e,f,g,h)	\
 	s0 = W256[(j+1)&0x0f]; \
 	s0 = sigma0_256(s0); \
 	s1 = W256[(j+14)&0x0f]; \
 	s1 = sigma1_256(s1); \
 	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
 	     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
 	(d) += T1; \
 	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
 	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;
 	int		j;
 	W256 = (uint32_t *)context->buffer;
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
 	b = context->state[1];
 	c = context->state[2];
 	d = context->state[3];
 	e = context->state[4];
 @@ -369,27 +369,27 @@ SHA256_Transform(SHA256_CTX *context, co
 	context->state[3] += d;
 	context->state[4] += e;
 	context->state[5] += f;
 	context->state[6] += g;
 	context->state[7] += h;
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = 0;
+}
 #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;
 	int		j;
 	W256 = (uint32_t *)(void *)context->buffer;
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
 	b = context->state[1];
 	c = context->state[2];
 	d = context->state[3];
 	e = context->state[4];
 @@ -446,27 +446,27 @@ SHA256_Transform(SHA256_CTX *context, co
 	context->state[3] += d;
 	context->state[4] += e;
 	context->state[5] += f;
 	context->state[6] += g;
 	context->state[7] += h;
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = T2 = 0;
+}
 #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;
 	if (len == 0) {
 		/* Calling with no data is valid - we do nothing */
 		return 1;
+	}
 	usedspace = (unsigned int)((context->bitcount >> 3) %
 				    SHA256_BLOCK_LENGTH);
 	if (usedspace > 0) {
 		/* Calculate how much free space is available in the buffer */
 		freespace = SHA256_BLOCK_LENGTH - usedspace;
 @@ -516,27 +516,27 @@ SHA256_Update(SHA256_CTX *context, const
+	}
 	if (len > 0) {
 		/* There's left-overs, so save 'em */
 		memcpy(context->buffer, data, len);
 		context->bitcount += len << 3;
+	}
 	/* Clean up: */
 	usedspace = freespace = 0;
 	return 1;
+}
 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;
 	/* If no digest buffer is passed, we don't bother doing this: */
 	if (digest != NULL) {
 		usedspace = (unsigned int)((context->bitcount >> 3) %
 		    SHA256_BLOCK_LENGTH);
 		context->bitcount = htobe64(context->bitcount);
 		if (usedspace > 0) {
 			/* Begin padding with a 1 bit: */
 			context->buffer[usedspace++] = 0x80;
 @@ -576,69 +576,69 @@ SHA224_256_Final(uint8_t digest[], SHA25
 		for (i = 0; i < len / 4; i++)
 			be32encode(digest + 4 * i, context->state[i]);
+	}
 	/* Clean up state data: */
 	memset(context, 0, sizeof(*context));
 	usedspace = 0;
 	return 1;
+}
 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;
 	/* The state and buffer size are driven by SHA256, not by SHA224. */
 	memcpy(context->state, sha224_initial_hash_value,
 	    (size_t)(SHA256_DIGEST_LENGTH));
 	memset(context->buffer, 0, (size_t)(SHA256_BLOCK_LENGTH));
 	context->bitcount = 0;
 	return 1;
+}
 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 SHA256_Update((NETPGPV_SHA256_CTX *)context, data, len);
+}
 void
-SHA224_Transform(SHA224_CTX *context, const uint32_t *data)
+SHA224_Transform(NETPGPV_SHA224_CTX *context, const uint32_t *data)
+{
-	SHA256_Transform((SHA256_CTX *)context, data);
+	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;
 	memcpy(context->state, sha512_initial_hash_value,
 	    (size_t)(SHA512_DIGEST_LENGTH));
 	memset(context->buffer, 0, (size_t)(SHA512_BLOCK_LENGTH));
 	context->bitcount[0] = context->bitcount[1] =  0;
 	return 1;
+}
 #ifdef SHA2_UNROLL_TRANSFORM
 @@ -655,27 +655,27 @@ SHA512_Init(SHA512_CTX *context)
 #define ROUND512(a,b,c,d,e,f,g,h)	\
 	s0 = W512[(j+1)&0x0f]; \
 	s0 = sigma0_512(s0); \
 	s1 = W512[(j+14)&0x0f]; \
 	s1 = sigma1_512(s1); \
 	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
              (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
 	(d) += T1; \
 	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
 	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;
 	int		j;
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
 	b = context->state[1];
 	c = context->state[2];
 	d = context->state[3];
 	e = context->state[4];
 	f = context->state[5];
 	g = context->state[6];
 @@ -712,27 +712,27 @@ SHA512_Transform(SHA512_CTX *context, co
 	context->state[3] += d;
 	context->state[4] += e;
 	context->state[5] += f;
 	context->state[6] += g;
 	context->state[7] += h;
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = 0;
+}
 #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;
 	int		j;
 	/* Initialize registers with the prev. intermediate value */
 	a = context->state[0];
 	b = context->state[1];
 	c = context->state[2];
 	d = context->state[3];
 	e = context->state[4];
 	f = context->state[5];
 	g = context->state[6];
 @@ -787,27 +787,27 @@ SHA512_Transform(SHA512_CTX *context, co
 	context->state[3] += d;
 	context->state[4] += e;
 	context->state[5] += f;
 	context->state[6] += g;
 	context->state[7] += h;
 	/* Clean up */
 	a = b = c = d = e = f = g = h = T1 = T2 = 0;
+}
 #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;
 	if (len == 0) {
 		/* Calling with no data is valid - we do nothing */
 		return 1;
+	}
 	usedspace = (unsigned int)((context->bitcount[0] >> 3) %
 	    SHA512_BLOCK_LENGTH);
 	if (usedspace > 0) {
 		/* Calculate how much free space is available in the buffer */
 		freespace = SHA512_BLOCK_LENGTH - usedspace;
 @@ -857,27 +857,27 @@ SHA512_Update(SHA512_CTX *context, const
+	}
 	if (len > 0) {
 		/* There's left-overs, so save 'em */
 		memcpy(context->buffer, data, len);
 		ADDINC128(context->bitcount, len << 3);
+	}
 	/* Clean up: */
 	usedspace = freespace = 0;
 	return 1;
+}
 static void
-SHA512_Last(SHA512_CTX *context)
+netpgpv_SHA512_Last(NETPGPV_SHA512_CTX *context)
+{
 	unsigned int	usedspace;
 	usedspace = (unsigned int)((context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH);
 	context->bitcount[0] = htobe64(context->bitcount[0]);
 	context->bitcount[1] = htobe64(context->bitcount[1]);
 	if (usedspace > 0) {
 		/* Begin padding with a 1 bit: */
 		context->buffer[usedspace++] = 0x80;
 		if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
 			/* Set-up for the last transform: */
 			memset(&context->buffer[usedspace], 0,
 @@ -903,78 +903,78 @@ SHA512_Last(SHA512_CTX *context)
 		*context->buffer = 0x80;
+	}
 	/* Store the length of input data (in bits): */
 	memcpy(&context->buffer[SHA512_SHORT_BLOCK_LENGTH],
 	    &context->bitcount[1], sizeof(context->bitcount[1]));
 	memcpy(&context->buffer[SHA512_SHORT_BLOCK_LENGTH + 8],
 	    &context->bitcount[0], sizeof(context->bitcount[0]));
 	/* Final transform: */
 	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)
 			be64encode(digest + 8 * i, context->state[i]);
+	}
 	/* Zero out state data */
 	memset(context, 0, sizeof(*context));
 	return 1;
+}
 /*** SHA-384: *********************************************************/
 int
-SHA384_Init(SHA384_CTX *context)
+netpgpv_SHA384_Init(NETPGPV_SHA384_CTX *context)
+{
 	if (context == NULL)
 		return 1;
 	memcpy(context->state, sha384_initial_hash_value,
 	    (size_t)(SHA512_DIGEST_LENGTH));
 	memset(context->buffer, 0, (size_t)(SHA384_BLOCK_LENGTH));
 	context->bitcount[0] = context->bitcount[1] = 0;
 	return 1;
+}
 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 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);
+	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)
 			be64encode(digest + 8 * i, context->state[i]);
+	}
 	/* Zero out state data */
 	memset(context, 0, sizeof(*context));
 	return 1;
+}

 @@ -13,29 +13,29 @@
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef NETPGP_VERIFY_H_
-#define NETPGP_VERIFY_H_	20150205
+#define NETPGP_VERIFY_H_	20150901
-#define NETPGPVERIFY_VERSION	"netpgpverify portable 20150205"
+#define NETPGPVERIFY_VERSION	"netpgpverify portable 20150901"
 #include <sys/types.h>
 #include <inttypes.h>
 #ifndef PGPV_ARRAY
 /* creates 2 unsigned vars called "name"c and "name"size in current scope */
 /* also creates an array called "name"s in current scope */
 #define PGPV_ARRAY(type, name)						\
 	unsigned name##c; unsigned name##vsize; type *name##s
 #endif
 /* 64bit key ids */