Commit 84c15db5 authored by Ben Laurie's avatar Ben Laurie
Browse files

Some constification and stacks that slipped through the cracks (how?).

parent ca570cfd

CHANGES

+4 −0
Original line number Diff line number Diff line
@@ -5,6 +5,10 @@ 


 Changes between 0.9.3a and 0.9.4



  *) Introduce some semblance of const correctness to BN. Shame C doesn't

     support mutable.

     [Ben Laurie]



  *) "linux-sparc64-gcc" configuration (ultrapenguin).

     [Ray Miller <ray.miller@oucs.ox.ac.uk>]

apps/pkcs12.c

+24 −24
Original line number Diff line number Diff line
@@ -76,15 +76,15 @@ EVP_CIPHER *enc; 
#define CLCERTS		0x8

#define CACERTS		0x10



int get_cert_chain(X509 *cert, STACK **chain);

int get_cert_chain(X509 *cert, STACK_OF(X509) **chain);

int dump_cert_text (BIO *out, X509 *x);

int dump_certs_keys_p12(BIO *out, PKCS12 *p12, char *pass, int passlen, int options);

int dump_certs_pkeys_bags(BIO *out, STACK *bags, char *pass, int passlen, int options);

int dump_certs_pkeys_bag(BIO *out, PKCS12_SAFEBAG *bags, char *pass, int passlen, int options);

int print_attribs(BIO *out, STACK *attrlst, char *name);

int print_attribs(BIO *out, STACK_OF(X509_ATTRIBUTE) *attrlst, char *name);

void hex_prin(BIO *out, unsigned char *buf, int len);

int alg_print(BIO *x, X509_ALGOR *alg);

int cert_load(BIO *in, STACK *sk);

int cert_load(BIO *in, STACK_OF(X509) *sk);

int MAIN(int argc, char **argv)

{

    char *infile=NULL, *outfile=NULL, *keyname = NULL;
@@ -286,7 +286,7 @@ if (export_cert) { 
	PKCS8_PRIV_KEY_INFO *p8;

	PKCS7 *authsafe;

	X509 *cert, *ucert = NULL;

	STACK *certs;

	STACK_OF(X509) *certs;

	char *catmp;

	int i, pmatch = 0;

	unsigned char keyid[EVP_MAX_MD_SIZE];
@@ -300,7 +300,7 @@ if (export_cert) { 
		goto end;

	}



	certs = sk_new(NULL);

	certs = sk_X509_new(NULL);



	/* Load in all certs in input file */

	if(!cert_load(in, certs)) {
@@ -323,8 +323,8 @@ if (export_cert) { 


	/* Find certificate (if any) matching private key */



	for(i = 0; i < sk_num(certs); i++) {

			cert = (X509 *)sk_value(certs, i);

	for(i = 0; i < sk_X509_num(certs); i++) {

			cert = sk_X509_value(certs, i);

			if(X509_check_private_key(cert, key)) {

				ucert = cert;

				break;
@@ -339,7 +339,7 @@ if (export_cert) { 
	/* If chaining get chain from user cert */

	if (chain) {

        	int vret;

		STACK *chain2;

		STACK_OF(X509) *chain2;

			

		vret = get_cert_chain (ucert, &chain2);

		if (vret) {
@@ -348,15 +348,15 @@ if (export_cert) { 
			goto end;

		}

		/* Exclude verified certificate */

		for (i = 1; i < sk_num (chain2) ; i++) 

				 sk_push(certs, sk_value (chain2, i));

		sk_free(chain2);

		for (i = 1; i < sk_X509_num (chain2) ; i++) 

				 sk_X509_push(certs, sk_X509_value (chain2, i));

		sk_X509_free(chain2);

			

    	}



	/* We now have loads of certificates: include them all */

	for(i = 0; i < sk_num(certs); i++) {

		cert = (X509 *)sk_value(certs, i);

	for(i = 0; i < sk_X509_num(certs); i++) {

		cert = sk_X509_value(certs, i);

		bag = M_PKCS12_x5092certbag(cert);

		/* If it matches private key mark it */

		if(cert == ucert) {
@@ -586,11 +586,11 @@ int dump_certs_pkeys_bag (BIO *out, PKCS12_SAFEBAG *bag, char *pass, 


/* Hope this is OK .... */



int get_cert_chain (X509 *cert, STACK **chain)

int get_cert_chain (X509 *cert, STACK_OF(X509) **chain)

{

	X509_STORE *store;

	X509_STORE_CTX store_ctx;

	STACK *chn;

	STACK_OF(X509) *chn;

	int i;

	X509 *x;

	store = X509_STORE_new ();
@@ -600,9 +600,9 @@ int get_cert_chain (X509 *cert, STACK **chain) 
		i = X509_STORE_CTX_get_error (&store_ctx);

		goto err;

	}

	chn =  sk_dup(X509_STORE_CTX_get_chain (&store_ctx));

	for (i = 0; i < sk_num(chn); i++) {

		x = (X509 *)sk_value(chn, i);

	chn =  sk_X509_dup(X509_STORE_CTX_get_chain (&store_ctx));

	for (i = 0; i < sk_X509_num(chn); i++) {

		x = sk_X509_value(chn, i);

		CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);

	}

	i = 0;
@@ -628,14 +628,14 @@ int alg_print (BIO *x, X509_ALGOR *alg) 


/* Load all certificates from a given file */



int cert_load(BIO *in, STACK *sk)

int cert_load(BIO *in, STACK_OF(X509) *sk)

{

	int ret;

	X509 *cert;

	ret = 0;

	while((cert = PEM_read_bio_X509(in, NULL, NULL))) {

		ret = 1;

		sk_push(sk, (char *)cert);

		sk_X509_push(sk, cert);

	}

	if(ret) ERR_clear_error();

	return ret;
@@ -643,7 +643,7 @@ int cert_load(BIO *in, STACK *sk) 


/* Generalised attribute print: handle PKCS#8 and bag attributes */



int print_attribs (BIO *out, STACK *attrlst, char *name)

int print_attribs (BIO *out, STACK_OF(X509_ATTRIBUTE) *attrlst, char *name)

{

	X509_ATTRIBUTE *attr;

	ASN1_TYPE *av;
@@ -653,13 +653,13 @@ int print_attribs (BIO *out, STACK *attrlst, char *name) 
		BIO_printf(out, "%s: <No Attributes>\n", name);

		return 1;

	}

	if(!sk_num(attrlst)) {

	if(!sk_X509_ATTRIBUTE_num(attrlst)) {

		BIO_printf(out, "%s: <Empty Attributes>\n", name);

		return 1;

	}

	BIO_printf(out, "%s\n", name);

	for(i = 0; i < sk_num(attrlst); i++) {

		attr = (X509_ATTRIBUTE *) sk_value(attrlst, i);

	for(i = 0; i < sk_X509_ATTRIBUTE_num(attrlst); i++) {

		attr = sk_X509_ATTRIBUTE_value(attrlst, i);

		attr_nid = OBJ_obj2nid(attr->object);

		BIO_printf(out, "    ");

		if(attr_nid == NID_undef) {

crypto/asn1/asn1_mac.h

+5 −0
Original line number Diff line number Diff line
@@ -163,6 +163,11 @@ err:\ 
		V_ASN1_CONSTRUCTED|V_ASN1_SET)))\

		{ M_ASN1_D2I_get_set(r,func,free_func); }



#define M_ASN1_D2I_get_set_opt_type(type,r,func,free_func) \

	if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \

		V_ASN1_CONSTRUCTED|V_ASN1_SET)))\

		{ M_ASN1_D2I_get_set_type(type,r,func,free_func); }



#define M_ASN1_I2D_len_SET_opt(a,f) \

	if ((a != NULL) && (sk_num(a) != 0)) \

		M_ASN1_I2D_len_SET(a,f);

crypto/bn/bn.h

+24 −22
Original line number Diff line number Diff line
@@ -316,22 +316,23 @@ BN_CTX *BN_CTX_new(void); 
void	BN_CTX_init(BN_CTX *c);

void	BN_CTX_free(BN_CTX *c);

int     BN_rand(BIGNUM *rnd, int bits, int top,int bottom);

int	BN_num_bits(BIGNUM *a);

int	BN_num_bits(const BIGNUM *a);

int	BN_num_bits_word(BN_ULONG);

BIGNUM *BN_new(void);

void	BN_init(BIGNUM *);

void	BN_clear_free(BIGNUM *a);

BIGNUM *BN_copy(BIGNUM *a, BIGNUM *b);

BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);

BIGNUM *BN_bin2bn(const unsigned char *s,int len,BIGNUM *ret);

int	BN_bn2bin(BIGNUM *a, unsigned char *to);

BIGNUM *BN_mpi2bn(unsigned char *s,int len,BIGNUM *ret);

int	BN_bn2mpi(BIGNUM *a, unsigned char *to);

int	BN_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b);

int	BN_usub(BIGNUM *r, BIGNUM *a, BIGNUM *b);

int	BN_uadd(BIGNUM *r, BIGNUM *a, BIGNUM *b);

int	BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

int	BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

int	BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);

int	BN_add(BIGNUM *r, BIGNUM *a, BIGNUM *b);

int	BN_mod(BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx);

int	BN_div(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx);

int	BN_mod(BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);

int	BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,

	       BN_CTX *ctx);

int	BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b,BN_CTX *ctx);

int	BN_sqr(BIGNUM *r, BIGNUM *a,BN_CTX *ctx);

BN_ULONG BN_mod_word(BIGNUM *a, BN_ULONG w);
@@ -341,22 +342,22 @@ int BN_add_word(BIGNUM *a, BN_ULONG w); 
int	BN_sub_word(BIGNUM *a, BN_ULONG w);

int	BN_set_word(BIGNUM *a, BN_ULONG w);

BN_ULONG BN_get_word(BIGNUM *a);

int	BN_cmp(BIGNUM *a, BIGNUM *b);

int	BN_cmp(const BIGNUM *a, const BIGNUM *b);

void	BN_free(BIGNUM *a);

int	BN_is_bit_set(BIGNUM *a, int n);

int	BN_lshift(BIGNUM *r, BIGNUM *a, int n);

int	BN_is_bit_set(const BIGNUM *a, int n);

int	BN_lshift(BIGNUM *r, const BIGNUM *a, int n);

int	BN_lshift1(BIGNUM *r, BIGNUM *a);

int	BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p,BN_CTX *ctx);

int	BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,BN_CTX *ctx);

int	BN_mod_exp_mont(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,BN_CTX *ctx,

		BN_MONT_CTX *m_ctx);

int	BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p,

		   const BIGNUM *m,BN_CTX *ctx);

int	BN_mod_exp_mont(BIGNUM *r, BIGNUM *a, const BIGNUM *p,

			const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);

int	BN_mod_exp2_mont(BIGNUM *r, BIGNUM *a1, BIGNUM *p1,BIGNUM *a2,

		BIGNUM *p2,BIGNUM *m,BN_CTX *ctx,BN_MONT_CTX *m_ctx);

int	BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p,

	BIGNUM *m,BN_CTX *ctx);

int	BN_mask_bits(BIGNUM *a,int n);

int	BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, BIGNUM *m,

	BN_CTX *ctx);

int	BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);

#ifndef WIN16

int	BN_print_fp(FILE *fp, BIGNUM *a);

#endif
@@ -370,8 +371,8 @@ int BN_rshift(BIGNUM *r, BIGNUM *a, int n); 
int	BN_rshift1(BIGNUM *r, BIGNUM *a);

void	BN_clear(BIGNUM *a);

BIGNUM *bn_expand2(BIGNUM *b, int bits);

BIGNUM *BN_dup(BIGNUM *a);

int	BN_ucmp(BIGNUM *a, BIGNUM *b);

BIGNUM *BN_dup(const BIGNUM *a);

int	BN_ucmp(const BIGNUM *a, const BIGNUM *b);

int	BN_set_bit(BIGNUM *a, int n);

int	BN_clear_bit(BIGNUM *a, int n);

char *	BN_bn2hex(BIGNUM *a);
@@ -379,7 +380,7 @@ char * BN_bn2dec(BIGNUM *a); 
int 	BN_hex2bn(BIGNUM **a,char *str);

int 	BN_dec2bn(BIGNUM **a,char *str);

int	BN_gcd(BIGNUM *r,BIGNUM *in_a,BIGNUM *in_b,BN_CTX *ctx);

BIGNUM *BN_mod_inverse(BIGNUM *ret,BIGNUM *a, BIGNUM *n,BN_CTX *ctx);

BIGNUM *BN_mod_inverse(BIGNUM *ret,BIGNUM *a, const BIGNUM *n,BN_CTX *ctx);

BIGNUM *BN_generate_prime(BIGNUM *ret,int bits,int strong,BIGNUM *add,

		BIGNUM *rem,void (*callback)(int,int,void *),void *cb_arg);

int	BN_is_prime(BIGNUM *p,int nchecks,void (*callback)(int,int,void *),
@@ -399,7 +400,7 @@ int BN_mod_mul_montgomery(BIGNUM *r,BIGNUM *a,BIGNUM *b,BN_MONT_CTX *mont, 
			  BN_CTX *ctx);

int BN_from_montgomery(BIGNUM *r,BIGNUM *a,BN_MONT_CTX *mont,BN_CTX *ctx);

void BN_MONT_CTX_free(BN_MONT_CTX *mont);

int BN_MONT_CTX_set(BN_MONT_CTX *mont,BIGNUM *modulus,BN_CTX *ctx);

int BN_MONT_CTX_set(BN_MONT_CTX *mont,const BIGNUM *modulus,BN_CTX *ctx);

BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to,BN_MONT_CTX *from);



BN_BLINDING *BN_BLINDING_new(BIGNUM *A,BIGNUM *Ai,BIGNUM *mod);
@@ -414,10 +415,11 @@ int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */ 
void	BN_RECP_CTX_init(BN_RECP_CTX *recp);

BN_RECP_CTX *BN_RECP_CTX_new(void);

void	BN_RECP_CTX_free(BN_RECP_CTX *recp);

int	BN_RECP_CTX_set(BN_RECP_CTX *recp,BIGNUM *rdiv,BN_CTX *ctx);

int	BN_RECP_CTX_set(BN_RECP_CTX *recp,const BIGNUM *rdiv,BN_CTX *ctx);

int	BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *x, BIGNUM *y,

		BN_RECP_CTX *recp,BN_CTX *ctx);

int	BN_mod_exp_recp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,BN_CTX *ctx);

int	BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,

			const BIGNUM *m, BN_CTX *ctx);

int	BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m,

		BN_RECP_CTX *recp, BN_CTX *ctx);

crypto/bn/bn_add.c

+5 −5
Original line number Diff line number Diff line
@@ -104,12 +104,12 @@ int BN_add(BIGNUM *r, BIGNUM *a, BIGNUM *b) 
	}



/* unsigned add of b to a, r must be large enough */

int BN_uadd(BIGNUM *r, BIGNUM *a, BIGNUM *b)

int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)

	{

	register int i;

	int max,min;

	BN_ULONG *ap,*bp,*rp,carry,t1;

	BIGNUM *tmp;

	const BIGNUM *tmp;



	bn_check_top(a);

	bn_check_top(b);
@@ -164,7 +164,7 @@ int BN_uadd(BIGNUM *r, BIGNUM *a, BIGNUM *b) 
	}



/* unsigned subtraction of b from a, a must be larger than b. */

int BN_usub(BIGNUM *r, BIGNUM *a, BIGNUM *b)

int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)

	{

	int max,min;

	register BN_ULONG t1,t2,*ap,*bp,*rp;
@@ -255,11 +255,11 @@ int BN_usub(BIGNUM *r, BIGNUM *a, BIGNUM *b) 
	return(1);

	}



int BN_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b)

int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)

	{

	int max;

	int add=0,neg=0;

	BIGNUM *tmp;

	const BIGNUM *tmp;



	bn_check_top(a);

	bn_check_top(b);