 @@ -1,306 +1,305 @@
 /*-
  * Copyright (c) 2012 Alistair Crooks <agc@NetBSD.org>
  * 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.
+ *
  * 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.
  */
 #include "config.h"
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <sys/syslog.h>
 #include <arpa/inet.h>
 #include <ctype.h>
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include "md5.h"
 #include "rmd160.h"
 #include "sha1.h"
 #include "sha2.h"
 #include "digest.h"
 static uint8_t prefix_md5[] = {
 x30, 0x20, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86, 0x48, 0x86,
 xF7, 0x0D, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10
 };
 static uint8_t prefix_sha1[] = {
 x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0E, 0x03, 0x02,
 x1A, 0x05, 0x00, 0x04, 0x14
 };
 static uint8_t prefix_sha256[] = {
 x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20
 };
 static uint64_t	prefix_tiger[] = {
 x0123456789ABCDEFLL,
 xFEDCBA9876543210LL,
 xF096A5B4C3B2E187LL
 };
 static uint8_t prefix_rmd160[] = {
 x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x24,
 x03, 0x02, 0x01, 0x05, 0x00, 0x04, 0x14
 };
 static uint8_t prefix_sha512[] = {
 x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
 x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40
 };
 #define V4_SIGNATURE		4
 /*************************************************************************/
 /* algorithm size (raw) */
 int
 digest_alg_size(unsigned alg)
+{
 	switch(alg) {
 	case MD5_HASH_ALG:
 		return 16;
 	case SHA1_HASH_ALG:
 		return 20;
 	case RIPEMD_HASH_ALG:
 		return RMD160_DIGEST_LENGTH;
 	case SHA256_HASH_ALG:
 		return 32;
 	case SHA512_HASH_ALG:
 		return 64;
 	case TIGER_HASH_ALG:
 	case TIGER2_HASH_ALG:
 		return TIGER_DIGEST_LENGTH;
 	default:
 		printf("hash_any: bad algorithm\n");
 		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:
 		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:
 		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:
 		netpgpv_RMD160Init(&hash->u.rmd160ctx);
 		hash->size = 20;
 		hash->prefix = prefix_rmd160;
 		hash->len = sizeof(prefix_rmd160);
 		hash->ctx = &hash->u.rmd160ctx;
 		return 1;
 	case SHA256_HASH_ALG:
 		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:
 		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:
 		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:
 		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;
 	const unsigned	 alg;
 } rec_t;
 static rec_t	hashalgs[] = {
 	{	"md5",		MD5_HASH_ALG	},
 	{	"sha1",		SHA1_HASH_ALG	},
 	{	"ripemd",	RIPEMD_HASH_ALG	},
 	{	"sha256",	SHA256_HASH_ALG	},
 	{	"sha512",	SHA512_HASH_ALG	},
 	{	"tiger",	TIGER_HASH_ALG	},
 	{	"tiger2",	TIGER2_HASH_ALG	},
 	{	NULL,		0		}
 };
 /* initialise by string alg name */
 unsigned
 digest_get_alg(const char *hashalg)
+{
 	rec_t	*r;
 	for (r = hashalgs ; hashalg && r->s ; r++) {
 		if (strcasecmp(r->s, hashalg) == 0) {
 			return r->alg;
+		}
+	}
 	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:
 		netpgpv_MD5Update(hash->ctx, data, (unsigned)length);
 		return 1;
 	case SHA1_HASH_ALG:
 		netpgpv_SHA1Update(hash->ctx, data, (unsigned)length);
 		return 1;
 	case RIPEMD_HASH_ALG:
 		netpgpv_RMD160Update(hash->ctx, data, (unsigned)length);
 		return 1;
 	case SHA256_HASH_ALG:
 		netpgpv_SHA256_Update(hash->ctx, data, length);
 		return 1;
 	case SHA512_HASH_ALG:
 		netpgpv_SHA512_Update(hash->ctx, data, length);
 		return 1;
 	case TIGER_HASH_ALG:
 	case TIGER2_HASH_ALG:
 		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:
 		netpgpv_MD5Final(out, hash->ctx);
 		break;
 	case SHA1_HASH_ALG:
 		netpgpv_SHA1Final(out, hash->ctx);
 		break;
 	case RIPEMD_HASH_ALG:
 		netpgpv_RMD160Final(out, hash->ctx);
 		break;
 	case SHA256_HASH_ALG:
 		netpgpv_SHA256_Final(out, hash->ctx);
 		break;
 	case SHA512_HASH_ALG:
 		netpgpv_SHA512_Final(out, hash->ctx);
 		break;
 	case TIGER_HASH_ALG:
 		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];
 	if (hash == NULL) {
 		return 0;
+	}
 	trailer[0] = V4_SIGNATURE;
 	trailer[1] = 0xFF;
 	trailer[2] = (uint8_t)((hashedlen >> 24) & 0xff);
 	trailer[3] = (uint8_t)((hashedlen >> 16) & 0xff);
 	trailer[4] = (uint8_t)((hashedlen >> 8) & 0xff);
 	trailer[5] = (uint8_t)(hashedlen & 0xff);
 	digest_update(hash, trailer, sizeof(trailer));
 	return 1;
+}
 unsigned
 digest_get_prefix(unsigned hashalg, uint8_t *prefix, size_t size)
+{
 	USE_ARG(size);
 	if (prefix == NULL) {
 		return 0;
+	}
 	switch (hashalg) {
 	case MD5_HASH_ALG:
 		memcpy(prefix, prefix_md5, sizeof(prefix_md5));
 		return sizeof(prefix_md5);
 	case SHA1_HASH_ALG:
 		memcpy(prefix, prefix_sha1, sizeof(prefix_sha1));
 		return sizeof(prefix_sha1);
 	case SHA256_HASH_ALG:
 		memcpy(prefix, prefix_sha256, sizeof(prefix_sha256));
 		return sizeof(prefix_sha256);
 	default:
 		printf("digest_get_prefix: unknown hash algorithm: %d\n", hashalg);
 		return 0;
+	}
+}

 @@ -1,697 +1,696 @@
 /*-
  * Copyright (c) 2012 Alistair Crooks <agc@NetBSD.org>
  * 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.
+ *
  * 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.
  */
 #include "config.h"
 #include <sys/types.h>
 #include <sys/syslog.h>
 #ifdef _KERNEL
 # include <sys/kmem.h>
 #else
 # include <stdio.h>
 # include <stdlib.h>
 # include <string.h>
 # include <unistd.h>
 #endif
 #include "misc.h"
 #include "digest.h"
 #include "rsa.h"
 #ifndef USE_ARG
 #define USE_ARG(x)	/*LINTED*/(void)&(x)
 #endif
 #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 */
 static int
 rsa_padding_check_none(uint8_t *to, int tlen, const uint8_t *from, int flen, int num)
+{
 	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)
+{
 	PGPV_BIGNUM	*decbn;
 	PGPV_BIGNUM	*signedbn;
 	uint8_t	*decbuf;
 	int	 nbytes;
 	int	 signc;
 	int	 signedbytes;
 	int	 r;
 	decbuf = NULL;
 	r = -1;
 	decbn = PGPV_BN_new();
 	signedbn = PGPV_BN_new();
 	nbytes = PGPV_BN_num_bytes(rsa->n);
 	decbuf = netpgp_allocate(1, nbytes);
 	/* add no padding */
 	memcpy(decbuf, plain, plainc);
 	PGPV_BN_bin2bn(decbuf, nbytes, decbn);
 	if (PGPV_BN_cmp(decbn, rsa->n) >= 0) {
 		printf("decbn too big\n");
 		goto err;
+	}
 	if (!PGPV_BN_mod_exp(signedbn, decbn, rsa->d, rsa->n, NULL)) {
 		printf("bad mod_exp\n");
 		goto err;
+	}
 	signedbytes = PGPV_BN_num_bytes(signedbn);
 	signc = PGPV_BN_bn2bin(signedbn, &encbuf[nbytes - signedbytes]);
 	memset(encbuf, 0x0, nbytes - signc);
 	r = nbytes;
 err:
 	netpgp_deallocate(decbuf, nbytes);
 	PGPV_BN_clear_free(decbn);
 	PGPV_BN_clear_free(signedbn);
 	return r;
+}
 static int
 lowlevel_rsa_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa)
+{
 	PGPV_BIGNUM	*decbn;
 	PGPV_BIGNUM	*encbn;
 	uint8_t	*decbuf;
 	int	 nbytes;
 	int	 encc;
 	int	 r;
 	int	 i;
 	r = -1;
 	decbn = PGPV_BN_new();
 	encbn = PGPV_BN_new();
 	nbytes = PGPV_BN_num_bytes(rsa->n);
 	decbuf = netpgp_allocate(1, nbytes);
 	(void) memcpy(decbuf, plain, plainc);
 	if (PGPV_BN_bin2bn(decbuf, nbytes, decbn) == NULL) {
 		printf("bin2bn failed\n");
 		goto err;
+	}
 	if (PGPV_BN_cmp(decbn, rsa->n) >= 0) {
 		printf("PGPV_BN_cmp failed\n");
 		goto err;
+	}
 	if (!PGPV_BN_mod_exp(encbn, decbn, rsa->e, rsa->n, NULL)) {
 		printf("PGPV_BN_mod_exp failed\n");
 		goto err;
+	}
 	encc = PGPV_BN_num_bytes(encbn);
 	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);
+	}
 	PGPV_BN_clear_free(decbn);
 	PGPV_BN_clear_free(encbn);
 	return r;
+}
 static int
 lowlevel_rsa_private_decrypt(int enclen, const unsigned char *encbuf, unsigned char *to, RSA *rsa)
+{
 	PGPV_BIGNUM	*encbn;
 	PGPV_BIGNUM	*decbn;
 	uint8_t	*buf;
 	int	 nbytes;
 	int	 j;
 	int	 r;
 	r = -1;
 	decbn = encbn = NULL;
 	buf = NULL;
 	if (PGPV_BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
 		return -1;
+	}
 	if (PGPV_BN_cmp(rsa->n, rsa->e) <= 0) {
 		return -1;
+	}
 	encbn = PGPV_BN_new();
 	decbn = PGPV_BN_new();
 	nbytes = PGPV_BN_num_bytes(rsa->n);
 	buf = netpgp_allocate(1, nbytes);
 	if (enclen > nbytes) {
 		printf("bad enclen\n");
 		goto err;
+	}
 	PGPV_BN_bin2bn(encbuf, enclen, encbn);
 	if (PGPV_BN_cmp(encbn, rsa->n) >= 0) {
 		printf("bad encbn\n");
 		goto err;
+	}
 	PGPV_BN_mod_exp(decbn, encbn, rsa->d, rsa->n, NULL);
 	j = PGPV_BN_bn2bin(decbn, buf);
 	r = rsa_padding_check_none(to, nbytes, buf, j, nbytes);
 err:
 	PGPV_BN_clear_free(encbn);
 	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;
 	PGPV_BIGNUM		*decbn;
 	PGPV_BIGNUM		*encbn;
 	int		 decbytes;
 	int		 nbytes;
 	int		 r;
 	nbytes = 0;
 	r = -1;
 	decbuf = NULL;
 	decbn = encbn = NULL;
 	if (PGPV_BN_num_bits(rsa->n) > RSA_MAX_MODULUS_BITS) {
 		printf("rsa r modulus too large\n");
 		goto err;
+	}
 	if (PGPV_BN_cmp(rsa->n, rsa->e) <= 0) {
 		printf("rsa r bad n value\n");
 		goto err;
+	}
 	if (PGPV_BN_num_bits(rsa->n) > RSA_SMALL_MODULUS_BITS &&
 	    PGPV_BN_num_bits(rsa->e) > RSA_MAX_PUBEXP_BITS) {
 		printf("rsa r bad exponent limit\n");
 		goto err;
+	}
 	if ((encbn = PGPV_BN_new()) == NULL ||
 	    (decbn = PGPV_BN_new()) == NULL ||
 	    (decbuf = netpgp_allocate(1, nbytes = PGPV_BN_num_bytes(rsa->n))) == NULL) {
 		printf("allocation failure\n");
 		goto err;
+	}
 	if (enclen > nbytes) {
 		printf("rsa r > mod len\n");
 		goto err;
+	}
 	if (PGPV_BN_bin2bn(encbuf, enclen, encbn) == NULL) {
 		printf("null encrypted BN\n");
 		goto err;
+	}
 	if (PGPV_BN_cmp(encbn, rsa->n) >= 0) {
 		printf("rsa r data too large for modulus\n");
 		goto err;
+	}
 	if (PGPV_BN_mod_exp(decbn, encbn, rsa->e, rsa->n, NULL) < 0) {
 		printf("PGPV_BN_mod_exp < 0\n");
 		goto err;
+	}
 	decbytes = PGPV_BN_num_bytes(decbn);
 	(void) PGPV_BN_bn2bin(decbn, decbuf);
 	if ((r = rsa_padding_check_none(dec, nbytes, decbuf, decbytes, 0)) < 0) {
 		printf("rsa r padding check failed\n");
+	}
 err:
 	PGPV_BN_free(encbn);
 	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
 */
 /**
    Create an RSA key
    @param prng     An active PRNG state
    @param wprng    The index of the PRNG desired
    @param size     The size of the modulus (key size) desired (octets)
    @param e        The "e" value (public key).  e==65537 is a good choice
    @param key      [out] Destination of a newly created private key pair
    @return CRYPT_OK if successful, upon error all allocated ram is freed
 */
 static int
 rsa_make_key(prng_state *prng, int wprng, int size, long e, rsa_key *key)
+{
 	void *p, *q, *tmp1, *tmp2, *tmp3;
 	int    err;
 	LTC_ARGCHK(ltc_mp.name != NULL);
 	LTC_ARGCHK(key         != NULL);
 	if ((size < (MIN_RSA_SIZE/8)) || (size > (MAX_RSA_SIZE/8))) {
 		return CRYPT_INVALID_KEYSIZE;
+	}
 	if ((e < 3) || ((e & 1) == 0)) {
 		return CRYPT_INVALID_ARG;
+	}
 	if ((err = prng_is_valid(wprng)) != CRYPT_OK) {
 		return err;
+	}
 	if ((err = mp_init_multi(&p, &q, &tmp1, &tmp2, &tmp3, NULL)) != CRYPT_OK) {
 		return err;
+	}
 	/* make primes p and q (optimization provided by Wayne Scott) */
 		/* tmp3 = e */
 	if ((err = mp_set_int(tmp3, e)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* make prime "p" */
 	do {
 		if ((err = rand_prime( p, size/2, prng, wprng)) != CRYPT_OK) {
 			goto errkey;
+		}
 		/* tmp1 = p-1 */
 		if ((err = mp_sub_d( p, 1,  tmp1)) != CRYPT_OK) {
 			goto errkey;
+		}
 		/* tmp2 = gcd(p-1, e) */
 		if ((err = mp_gcd( tmp1,  tmp3,  tmp2)) != CRYPT_OK) {
 			goto errkey;
+		}
 	} while (mp_cmp_d( tmp2, 1) != 0);
 	/* while e divides p-1 */
 	/* make prime "q" */
 	do {
 		if ((err = rand_prime( q, size/2, prng, wprng)) != CRYPT_OK) {
 			goto errkey;
+		}
 		/* tmp1 = q-1 */
 		if ((err = mp_sub_d( q, 1,  tmp1)) != CRYPT_OK) {
 			goto errkey;
+		}
 		/* tmp2 = gcd(q-1, e) */
 		if ((err = mp_gcd( tmp1,  tmp3,  tmp2)) != CRYPT_OK) {
 			goto errkey;
+		}
 	} while (mp_cmp_d( tmp2, 1) != 0);
 	/* while e divides q-1 */
 	/* tmp1 = lcm(p-1, q-1) */
 		/* tmp2 = p-1 */
 	if ((err = mp_sub_d( p, 1,  tmp2)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* tmp1 = q-1 (previous do/while loop) */
 		/* tmp1 = lcm(p-1, q-1) */
 	if ((err = mp_lcm( tmp1,  tmp2,  tmp1)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* make key */
 	if ((err = mp_init_multi(&key->e, &key->d, &key->N, &key->dQ, &key->dP, &key->qP, &key->p, &key->q, NULL)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* key->e =  e */
 	if ((err = mp_set_int( key->e, e)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* key->d = 1/e mod lcm(p-1,q-1) */
 	if ((err = mp_invmod( key->e,  tmp1,  key->d)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* key->N = pq */
 	if ((err = mp_mul( p,  q,  key->N)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* optimize for CRT now */
 	/* find d mod q-1 and d mod p-1 */
 	/* tmp1 = q-1 */
 	if ((err = mp_sub_d( p, 1,  tmp1)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* tmp2 = p-1 */
 	if ((err = mp_sub_d( q, 1,  tmp2)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* dP = d mod p-1 */
 	if ((err = mp_mod( key->d,  tmp1,  key->dP)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* dQ = d mod q-1 */
 	if ((err = mp_mod( key->d,  tmp2,  key->dQ)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* qP = 1/q mod p */
 	if ((err = mp_invmod( q,  p,  key->qP)) != CRYPT_OK) {
 		got oerrkey;
+	}
 	if ((err = mp_copy( p,  key->p)) != CRYPT_OK) {
 		goto errkey;
+		}
 	if ((err = mp_copy( q,  key->q)) != CRYPT_OK) {
 		goto errkey;
+	}
 	/* set key type (in this case it's CRT optimized) */
 	key->type = PK_PRIVATE;
 	/* return ok and free temps */
 	err = CRYPT_OK;
 	goto cleanup;
 errkey:
 	mp_clear_multi(key->d, key->e, key->N, key->dQ, key->dP, key->qP, key->p, key->q, NULL);
 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)
+{
 	PGPV_BIGNUM		 *M;
 	PGPV_BIGNUM		 *W;
 	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 = 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 (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 = PGPV_BN_new()) == NULL ||
 	    (W = PGPV_BN_new()) == NULL ||
 	    (t1 = PGPV_BN_new()) == NULL) {
 		goto err;
+	}
 	if (PGPV_BN_is_zero(sig->r) ||
 	    PGPV_BN_is_negative(sig->r) ||
 	    PGPV_BN_cmp(sig->r, dsa->q) >= 0) {
 		goto err;
+	}
 	if (PGPV_BN_is_zero(sig->s) ||
 	    PGPV_BN_is_negative(sig->s) ||
 	    PGPV_BN_cmp(sig->s, dsa->q) >= 0) {
 		goto err;
+	}
 	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 (PGPV_BN_bin2bn(calculated, dgst_len, M) == NULL) {
 		goto err;
+	}
 	if (!PGPV_BN_mod_mul(M, M, W, dsa->q, NULL)) {
 		goto err;
+	}
 	if (!PGPV_BN_mod_mul(W, sig->r, W, dsa->q, NULL)) {
 		goto err;
+	}
 	if (!PGPV_BN_mod_exp(dsa->p, t1, dsa->g, M, NULL)) {
 		goto err;
+	}
 	if (!PGPV_BN_div(NULL, M, t1, dsa->q, NULL)) {
 		goto err;
+	}
 	ret = (PGPV_BN_cmp(M, sig->r) == 0);
 err:
 	if (M) {
 		PGPV_BN_free(M);
+	}
 	if (W) {
 		PGPV_BN_free(W);
+	}
 	if (t1) {
 		PGPV_BN_free(t1);
+	}
 	return ret;
+}
 /*************************************************************************/
 int
 RSA_size(const RSA *rsa)
+{
 	return (rsa == NULL) ? 0 : PGPV_BN_num_bits(rsa->n);
+}
 int
 DSA_size(const DSA *dsa)
+{
 	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));
 	PGPV_BN_copy(osig.r, signature->dsa.r);
 	PGPV_BN_copy(osig.s, signature->dsa.s);
 	odsa.p = pubdsa->p;
 	odsa.q = pubdsa->q;
 	odsa.g = pubdsa->g;
 	odsa.pub_key = pubdsa->y;
 	if ((qlen = 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;
+	}
 	PGPV_BN_free(odsa.p);
 	PGPV_BN_free(odsa.q);
 	PGPV_BN_free(odsa.g);
 	PGPV_BN_free(odsa.pub_key);
 	odsa.p = odsa.q = odsa.g = odsa.pub_key = NULL;
 	PGPV_BN_free(osig.r);
 	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)
+{
 	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 (!PGPV_BN_is_prime(rsa->p, 1, NULL, NULL, NULL) ||
 	    !PGPV_BN_is_prime(rsa->q, 1, NULL, NULL, NULL)) {
 		return 0;
+	}
 	calcn = PGPV_BN_new();
         PGPV_BN_mul(calcn, rsa->p, rsa->q, NULL);
 	if (PGPV_BN_cmp(calcn, rsa->n) != 0) {
 		goto errout;
+	}
 	/* XXX - check that d*e = 1 mod (p-1*q-1) */
 	ret = 1;
 errout:
 	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();
+}
 /* encrypt */
 int
 RSA_public_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa, int padding)
+{
 	USE_ARG(padding);
 	if (plain == NULL || encbuf == NULL || rsa == NULL) {
 		return -1;
+	}
 	return lowlevel_rsa_public_encrypt(plainc, plain, encbuf, rsa);
+}
 /* decrypt */
 int
 RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding)
+{
 	USE_ARG(padding);
 	if (from == NULL || to == NULL || rsa == NULL) {
 		return -1;
+	}
 	return lowlevel_rsa_private_decrypt(flen, from, to, rsa);
+}
 /* sign */
 int
 RSA_private_encrypt(int plainc, const unsigned char *plain, unsigned char *encbuf, RSA *rsa, int padding)
+{
 	USE_ARG(padding);
 	if (plain == NULL || encbuf == NULL || rsa == NULL) {
 		return -1;
+	}
 	return lowlevel_rsa_private_encrypt(plainc, plain, encbuf, rsa);
+}
 /* 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 = PGPV_BN_dup(rsa->n);
 	pub.e = PGPV_BN_dup(rsa->e);
 	ret = lowlevel_rsa_public_decrypt(enc, enclen, dec, &pub);
 	PGPV_BN_free(pub.n);
 	PGPV_BN_free(pub.e);
 	return ret;
+}
 /***********************************************************************/
 DSA *
 DSA_new(void)
+{
 	return netpgp_allocate(1, sizeof(DSA));
+}
 void
 DSA_free(DSA *dsa)
+{
 	if (dsa) {
 		netpgp_deallocate(dsa, sizeof(*dsa));
+	}
+}
 DSA_SIG *
 DSA_SIG_new(void)
+{
 	return netpgp_allocate(1, sizeof(DSA_SIG));
+}
 void
 DSA_SIG_free(DSA_SIG *sig)
+{
 	if (sig) {
 		netpgp_deallocate(sig, sizeof(*sig));
+	}
+}
 DSA_SIG *
 DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
+{
 	/* STUBBED */
 	USE_ARG(dgst);
 	USE_ARG(dlen);
 	USE_ARG(dsa);
 	printf("DSA_do_sign stubbed\n");
 	return DSA_SIG_new();
+}
 int
 DSA_do_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa)
+{
 	if (dgst == NULL || dgst_len == 0 || sig == NULL || dsa == NULL) {
 		return -1;
+	}
 	return dsa_do_verify(dgst, dgst_len, sig, dsa);
+}

 @@ -1,298 +1,298 @@
 /*-
  * Copyright (c) 2012,2013,2014,2015 Alistair Crooks <agc@NetBSD.org>
  * 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.
+ *
  * 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_	20150911
+#define NETPGP_VERIFY_H_	20150919
-#define NETPGPVERIFY_VERSION	"netpgpverify portable 20150901"
+#define NETPGPVERIFY_VERSION	"netpgpverify portable 20150919"
 #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 */
 #define PGPV_KEYID_LEN		8
 #define PGPV_STR_KEYID_LEN	(PGPV_KEYID_LEN + PGPV_KEYID_LEN + 1)
 /* bignum structure */
 typedef struct pgpv_bignum_t {
 	void			*bn;	/* hide the implementation details */
 	uint16_t		 bits;	/* cached number of bits */
 } pgpv_bignum_t;
 /* right now, our max binary digest length is 20 bytes */
 #define PGPV_MAX_HASH_LEN	64
 /* fingerprint */
 typedef struct pgpv_fingerprint_t {
 	uint8_t			hashalg;	/* algorithm for digest */
 	uint8_t			v[PGPV_MAX_HASH_LEN];	/* the digest */
 	uint32_t		len;		/* its length */
 } pgpv_fingerprint_t;
 /* specify size for array of bignums */
 #define PGPV_MAX_PUBKEY_BN	4
 /* public key */
 typedef struct pgpv_pubkey_t {
 	pgpv_fingerprint_t	 fingerprint;	/* key fingerprint i.e. digest */
 	uint8_t			 keyid[PGPV_KEYID_LEN];	/* last 8 bytes of v4 keys */
 	int64_t		 	 birth;		/* creation time */
 	int64_t			 expiry;	/* expiry time */
 	pgpv_bignum_t		 bn[PGPV_MAX_PUBKEY_BN];	/* bignums */
 	uint8_t			 keyalg;	/* key algorithm */
 	uint8_t			 hashalg;	/* hash algorithm */
 	uint8_t			 version;	/* key version */
 } pgpv_pubkey_t;
 #define PGPV_MAX_SESSKEY_BN	2
 /* a (size, byte array) string */
 typedef struct pgpv_string_t {
 	size_t			 size;
 	uint8_t			*data;
 } pgpv_string_t;
 typedef struct pgpv_ref_t {
 	void			*vp;
 	size_t			 offset;
 	unsigned		 mem;
 } pgpv_ref_t;
 #define PGPV_MAX_SECKEY_BN	4
 typedef struct pgpv_compress_t {
 	pgpv_string_t		 s;
 	uint8_t			 compalg;
 } pgpv_compress_t;
 /* a packet dealing with trust */
 typedef struct pgpv_trust_t {
 	uint8_t			level;
 	uint8_t			amount;
 } pgpv_trust_t;
 /* a signature sub packet */
 typedef struct pgpv_sigsubpkt_t {
 	pgpv_string_t		 s;
 	uint8_t			 tag;
 	uint8_t			 critical;
 } pgpv_sigsubpkt_t;
 #define PGPV_MAX_SIG_BN		2
 typedef struct pgpv_signature_t {
 	uint8_t			*signer;		/* key id of signer */
 	pgpv_ref_t		 hashstart;
 	uint8_t			*hash2;
 	uint8_t			*mpi;
 	int64_t			 birth;
 	int64_t			 keyexpiry;
 	int64_t			 expiry;
 	uint32_t		 hashlen;
 	uint8_t			 version;
 	uint8_t			 type;
 	uint8_t			 keyalg;
 	uint8_t			 hashalg;
 	uint8_t			 trustlevel;
 	uint8_t			 trustamount;
 	pgpv_bignum_t		 bn[PGPV_MAX_SIG_BN];
 	char			*regexp;
 	char			*pref_key_server;
 	char			*policy;
 	char			*features;
 	char			*why_revoked;
 	uint8_t			*revoke_fingerprint;
 	uint8_t			 revoke_alg;
 	uint8_t			 revoke_sensitive;
 	uint8_t			 trustsig;
 	uint8_t			 revocable;
 	uint8_t			 pref_symm_alg;
 	uint8_t			 pref_hash_alg;
 	uint8_t			 pref_compress_alg;
 	uint8_t			 key_server_modify;
 	uint8_t			 notation;
 	uint8_t			 type_key;
 	uint8_t			 primary_userid;
 	uint8_t			 revoked;	/* subtract 1 to get real reason, 0 == not revoked */
 } pgpv_signature_t;
 /* a signature packet */
 typedef struct pgpv_sigpkt_t {
 	pgpv_signature_t	 sig;
 	uint16_t		 subslen;
 	uint16_t		 unhashlen;
 	PGPV_ARRAY(pgpv_sigsubpkt_t, subpkts);
 } pgpv_sigpkt_t;
 /* a one-pass signature packet */
 typedef struct pgpv_onepass_t {
 	uint8_t			 keyid[PGPV_KEYID_LEN];
 	uint8_t			 version;
 	uint8_t			 type;
 	uint8_t			 hashalg;
 	uint8_t			 keyalg;
 	uint8_t			 nested;
 } pgpv_onepass_t;
 /* a literal data packet */
 typedef struct pgpv_litdata_t {
 	uint8_t			*filename;
 	pgpv_string_t		 s;
 	uint32_t		 secs;
 	uint8_t			 namelen;
 	char			 format;
 	unsigned		 mem;
 	size_t			 offset;
 	size_t			 len;
 } pgpv_litdata_t;
 /* user attributes - images */
 typedef struct pgpv_userattr_t {
 	size_t 			 len;
 	PGPV_ARRAY(pgpv_string_t, subattrs);
 } pgpv_userattr_t;
 /* a general PGP packet */
 typedef struct pgpv_pkt_t {
 	uint8_t			 tag;
 	uint8_t			 newfmt;
 	uint8_t			 allocated;
 	uint8_t			 mement;
 	size_t			 offset;
 	pgpv_string_t		 s;
 	union {
 		pgpv_sigpkt_t	sigpkt;
 		pgpv_onepass_t	onepass;
 		pgpv_litdata_t	litdata;
 		pgpv_compress_t	compressed;
 		pgpv_trust_t	trust;
 		pgpv_pubkey_t	pubkey;
 		pgpv_string_t	userid;
 		pgpv_userattr_t	userattr;
 	} u;
 } pgpv_pkt_t;
 /* a memory structure */
 typedef struct pgpv_mem_t {
 	size_t			 size;
 	size_t			 cc;
 	uint8_t			*mem;
 	FILE			*fp;
 	uint8_t			 dealloc;
 	const char		*allowed;	/* the types of packet that are allowed */
 } pgpv_mem_t;
 /* packet parser */
 typedef struct pgpv_signed_userid_t {
 	pgpv_string_t	 	 userid;
 	PGPV_ARRAY(pgpv_signature_t, sigs);
 	uint8_t			 primary_userid;
 	uint8_t			 revoked;
 } pgpv_signed_userid_t;
 typedef struct pgpv_signed_userattr_t {
 	pgpv_userattr_t	 	 userattr;
 	PGPV_ARRAY(pgpv_signature_t, sigs);
 	uint8_t			 revoked;
 } pgpv_signed_userattr_t;
 typedef struct pgpv_signed_subkey_t {
 	pgpv_pubkey_t	 	 subkey;
 	pgpv_signature_t 	 revoc_self_sig;
 	PGPV_ARRAY(pgpv_signature_t, sigs);
 } pgpv_signed_subkey_t;
 typedef struct pgpv_primarykey_t {
 	pgpv_pubkey_t 		 primary;
 	pgpv_signature_t 	 revoc_self_sig;
 	PGPV_ARRAY(pgpv_signature_t, direct_sigs);
 	PGPV_ARRAY(pgpv_signed_userid_t, signed_userids);
 	PGPV_ARRAY(pgpv_signed_userattr_t, signed_userattrs);
 	PGPV_ARRAY(pgpv_signed_subkey_t, signed_subkeys);
 	size_t			 fmtsize;
 	uint8_t			 primary_userid;
 } pgpv_primarykey_t;
 /* everything stems from this structure */
 typedef struct pgpv_t {
 	PGPV_ARRAY(pgpv_pkt_t, 	 pkts);		/* packet array */
 	PGPV_ARRAY(pgpv_primarykey_t,	 primaries);	/* array of primary keys */
 	PGPV_ARRAY(pgpv_mem_t,	 areas);	/* areas we read packets from */
 	PGPV_ARRAY(size_t,	 datastarts);	/* starts of data packets */
 	size_t		 	 pkt;		/* when parsing, current pkt number */
 	const char		*op;		/* the operation we're doing */
 	unsigned		 ssh;		/* using ssh keys */
 } pgpv_t;
 #define PGPV_REASON_LEN		128
 /* when searching, we define a cursor, and fill in an array of subscripts */
 typedef struct pgpv_cursor_t {
 	pgpv_t			*pgp;			/* pointer to pgp tree */
 	char			*field;			/* field we're searching on */
 	char			*op;			/* operation we're doing */
 	char			*value;			/* value we're searching for */
 	void			*ptr;			/* for regexps etc */
 	PGPV_ARRAY(uint32_t,	 found);		/* array of matched pimary key subscripts */
 	PGPV_ARRAY(size_t,	 datacookies);		/* cookies to retrieve matched data */
 	int64_t			 sigtime;		/* time of signature */
 	char			 why[PGPV_REASON_LEN];	/* reason for bad signature */
 } pgpv_cursor_t;
 #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
 int pgpv_read_pubring(pgpv_t */*pgp*/, const void */*keyringfile/mem*/, ssize_t /*size*/);
 int pgpv_read_ssh_pubkeys(pgpv_t */*pgp*/, const void */*keyring*/, ssize_t /*size*/);
 size_t pgpv_verify(pgpv_cursor_t */*cursor*/, pgpv_t */*pgp*/, const void */*mem/file*/, ssize_t /*size*/);
 size_t pgpv_get_verified(pgpv_cursor_t */*cursor*/, size_t /*cookie*/, char **/*ret*/);
 int pgpv_get_cursor_element(pgpv_cursor_t */*cursor*/, size_t /*element*/);
 size_t pgpv_dump(pgpv_t */*pgp*/, char **/*data*/);
 size_t pgpv_get_entry(pgpv_t */*pgp*/, unsigned /*ent*/, char **/*ret*/, const char */*modifiers*/);
 int pgpv_close(pgpv_t */*pgp*/);
 __END_DECLS
 #endif

 @@ -1,21 +1,21 @@
-# $NetBSD: Makefile,v 1.16 2015/09/12 02:19:06 agc Exp $
+# $NetBSD: Makefile,v 1.16.2.1 2015/09/26 06:04:13 ryoon Exp $
-DISTNAME=		netpgpverify-20150911
+DISTNAME=		netpgpverify-20150919
 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
 do-extract:
 	@${CP} -R ${FILESDIR} ${WRKSRC}
 .include "../../mk/bsd.pkg.mk"