 @@ -1918,52 +1918,52 @@ lowlevel_rsa_public_check(const uint8_t
 		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_clear_free(encbn);
-	PGPV_BN_free(decbn);
+	PGPV_BN_clear_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 = PGPV_BN_dup(rsa->n);
 	pub.e = PGPV_BN_dup(rsa->e);
 	ret = lowlevel_rsa_public_check(enc, enclen, dec, &pub);
-	PGPV_BN_free(pub.n);
+	PGPV_BN_clear_free(pub.n);
-	PGPV_BN_free(pub.e);
+	PGPV_BN_clear_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;
 @@ -2036,32 +2036,32 @@ bignum_is_bad(PGPV_BIGNUM *bn)
+}
 #define BAD_BIGNUM(s, k)	\
 	(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)
+{
 	PGPV_BIGNUM	 *M;
 	PGPV_BIGNUM	 *W;
 	PGPV_BIGNUM	 *t1;
 	unsigned	  qbits;
 	uint8_t		  calcnum[128];
 	uint8_t		  signum[128];
 	PGPV_BIGNUM		 *M;
 	PGPV_BIGNUM		 *W;
 	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:
 @@ -2093,33 +2093,33 @@ verify_dsa_sig(uint8_t *calculated, unsi
 	    !PGPV_BN_mod_mul(W, sig[DSA_R].bn, W, pubkey->bn[DSA_Q].bn, NULL) ||
 	    !PGPV_BN_mod_exp(t1, pubkey->bn[DSA_G].bn, M, pubkey->bn[DSA_P].bn, NULL) ||
 	    !PGPV_BN_mod_exp(W, pubkey->bn[DSA_Y].bn, W, pubkey->bn[DSA_P].bn, NULL) ||
 	    !PGPV_BN_mod_mul(t1, t1, W, pubkey->bn[DSA_P].bn, NULL) ||
 	    !PGPV_BN_div(NULL, t1, t1, pubkey->bn[DSA_Q].bn, NULL)) {
 		goto done;
+	}
 	/* only compare the first q bits */
 	PGPV_BN_bn2bin(t1, calcnum);
 	PGPV_BN_bn2bin(sig[DSA_R].bn, signum);
 	ret = memcmp(calcnum, signum, BITS_TO_BYTES(qbits)) == 0;
 done:
 	if (M) {
-		PGPV_BN_free(M);
+		PGPV_BN_clear_free(M);
+	}
 	if (W) {
-		PGPV_BN_free(W);
+		PGPV_BN_clear_free(W);
+	}
 	if (t1) {
-		PGPV_BN_free(t1);
+		PGPV_BN_clear_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)
 @@ -2981,88 +2981,97 @@ nonnull_getenv(const char *key)
+{
 	char	*value;
 	return ((value = getenv(key)) == NULL) ? "" : value;
+}
 /* free an array of bignums */
 static void
 free_bn_array(pgpv_bignum_t *v, unsigned n)
+{
 	unsigned	i;
 	for (i = 0 ; i < n ; i++) {
-		PGPV_BN_free(v[i].bn);
+		PGPV_BN_clear_free(v[i].bn);
 		v[i].bn = NULL;
+	}
+}
 /************************************************************************/
 /* start of exported functions */
 /************************************************************************/
 /* close all stuff */
 int
 pgpv_close(pgpv_t *pgp)
+{
 	pgpv_primarykey_t	*primary;
 	pgpv_pkt_t		*pkt;
 	uint64_t		 n;
 	unsigned		 i;
 	unsigned		 j;
 	if (pgp == NULL) {
 		return 0;
+	}
 	for (i = 0 ; i < ARRAY_COUNT(pgp->areas) ; i++) {
 		if (ARRAY_ELEMENT(pgp->areas, i).size > 0) {
 			closemem(&ARRAY_ELEMENT(pgp->areas, i));
+		}
+	}
         ARRAY_FREE(pgp->areas);
         for (i = 0 ; i < ARRAY_COUNT(pgp->pkts) ; i++) {
                 pkt = &ARRAY_ELEMENT(pgp->pkts, i);
                 switch(pkt->tag) {
                 case SIGNATURE_PKT:
 			free_bn_array(pkt->u.sigpkt.sig.bn, PGPV_MAX_SIG_BN);
                         ARRAY_FREE(pkt->u.sigpkt.subpackets);
                         break;
                 case LITDATA_PKT:
 			if (pkt->u.litdata.filename.allocated) {
 				free(pkt->u.litdata.filename.data);
+			}
                         break;
 		case PUBKEY_PKT:
 			free_bn_array(pkt->u.pubkey.bn, PGPV_MAX_PUBKEY_BN);
 			break;
                 case USERID_PKT:
 			if (pkt->u.userid.allocated) {
 				free(pkt->u.userid.data);
+			}
                         break;
                 case USER_ATTRIBUTE_PKT:
                         ARRAY_FREE(pkt->u.userattr.subattrs);
                         break;
+                }
+        }
         ARRAY_FREE(pgp->pkts);
 	for (i = 0 ; i < ARRAY_COUNT(pgp->primaries) ; i++) {
 		primary = &ARRAY_ELEMENT(pgp->primaries, i);
 		free_bn_array(primary->primary.bn, PGPV_MAX_PUBKEY_BN);
 		ARRAY_FREE(primary->signatures);
 		for (j = 0 ; j < ARRAY_COUNT(primary->signed_userids) ; j++) {
 			n = ARRAY_ELEMENT(primary->signed_userids, j);
 			ARRAY_FREE(ARRAY_ELEMENT(pgp->signed_userids, n).signatures);
+		}
 		ARRAY_FREE(primary->signed_userids);
 		ARRAY_FREE(primary->signed_userattrs);
 		ARRAY_FREE(primary->signed_subkeys);
+	}
 	for (i = 0 ; i < ARRAY_COUNT(pgp->signatures) ; i++) {
 		free_bn_array(ARRAY_ELEMENT(pgp->signatures, i).bn, PGPV_MAX_SIG_BN);
+	}
 	for (i = 0 ; i < ARRAY_COUNT(pgp->signed_subkeys) ; i++) {
 		free_bn_array(ARRAY_ELEMENT(pgp->signed_subkeys, i).subkey.bn, PGPV_MAX_SIG_BN);
+	}
 	ARRAY_FREE(pgp->primaries);
 	ARRAY_FREE(pgp->datastarts);
 	ARRAY_FREE(pgp->signatures);
 	ARRAY_FREE(pgp->signed_userids);
 	ARRAY_FREE(pgp->signed_userattrs);
 	ARRAY_FREE(pgp->signed_subkeys);
 	ARRAY_FREE(pgp->subpkts);
 	return 1;
+}
 /* free resources attached to cursor */
 int
 pgpv_cursor_close(pgpv_cursor_t *cursor)

	@@ -5428,42 +5428,43 @@ PGPV_BN_bitop(PGPV_BIGNUM *r, const PGPV		@@ -5428,42 +5428,43 @@ PGPV_BN_bitop(PGPV_BIGNUM *r, const PGPV
5428	break;	5428	break;
5429	default:	5429	default:
5430	break;	5430	break;
5431	}	5431	}
5432	}	5432	}
5433	return 1;	5433	return 1;
5434	}	5434	}
5435		5435
5436	void	5436	void
5437	PGPV_BN_free(PGPV_BIGNUM *a)	5437	PGPV_BN_free(PGPV_BIGNUM *a)
5438	{	5438	{
5439	if (a) {	5439	if (a) {
5440	mp_clear(a);	5440	mp_clear(a);
		5441	free(a);
5441	}	5442	}
5442	}	5443	}
5443		5444
5444	void	5445	void
5445	PGPV_BN_clear(PGPV_BIGNUM *a)	5446	PGPV_BN_clear(PGPV_BIGNUM *a)
5446	{	5447	{
5447	if (a) {	5448	if (a) {
5448	mp_clear(a);	5449	mp_clear(a);
5449	}	5450	}
5450	free(a);
5451	}	5451	}
5452		5452
5453	void	5453	void
5454	PGPV_BN_clear_free(PGPV_BIGNUM *a)	5454	PGPV_BN_clear_free(PGPV_BIGNUM *a)
5455	{	5455	{
5456	PGPV_BN_clear(a);	5456	PGPV_BN_clear(a);
		5457	free(a);
5457	}	5458	}
5458		5459
5459	int	5460	int
5460	PGPV_BN_num_bytes(const PGPV_BIGNUM *a)	5461	PGPV_BN_num_bytes(const PGPV_BIGNUM *a)
5461	{	5462	{
5462	if (a == NULL) {	5463	if (a == NULL) {
5463	return MP_VAL;	5464	return MP_VAL;
5464	}	5465	}
5465	return mp_unsigned_bin_size(__UNCONST(a));	5466	return mp_unsigned_bin_size(__UNCONST(a));
5466	}	5467	}
5467		5468
5468	int	5469	int
5469	PGPV_BN_num_bits(const PGPV_BIGNUM *a)	5470	PGPV_BN_num_bits(const PGPV_BIGNUM *a)

 @@ -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_	20160707
+#define NETPGP_VERIFY_H_	20160708
-#define NETPGPVERIFY_VERSION	"netpgpverify portable 20160707"
+#define NETPGPVERIFY_VERSION	"netpgpverify portable 20160708"
 #include <sys/types.h>
 #include <inttypes.h>
 struct pgpv_t;
 typedef struct pgpv_t	pgpv_t;
 struct pgpv_cursor_t;
 typedef struct pgpv_cursor_t	pgpv_cursor_t;
 #ifndef __BEGIN_DECLS
 #  if defined(__cplusplus)