diff options
Diffstat (limited to 'openssl/crypto/objects/obj_dat.c')
| -rw-r--r-- | openssl/crypto/objects/obj_dat.c | 810 |
1 files changed, 810 insertions, 0 deletions
diff --git a/openssl/crypto/objects/obj_dat.c b/openssl/crypto/objects/obj_dat.c new file mode 100644 index 00000000..8a342ba3 --- /dev/null +++ b/openssl/crypto/objects/obj_dat.c @@ -0,0 +1,810 @@ +/* crypto/objects/obj_dat.c */ +/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) + * All rights reserved. + * + * This package is an SSL implementation written + * by Eric Young (eay@cryptsoft.com). + * The implementation was written so as to conform with Netscapes SSL. + * + * This library is free for commercial and non-commercial use as long as + * the following conditions are aheared to. The following conditions + * apply to all code found in this distribution, be it the RC4, RSA, + * lhash, DES, etc., code; not just the SSL code. The SSL documentation + * included with this distribution is covered by the same copyright terms + * except that the holder is Tim Hudson (tjh@cryptsoft.com). + * + * Copyright remains Eric Young's, and as such any Copyright notices in + * the code are not to be removed. + * If this package is used in a product, Eric Young should be given attribution + * as the author of the parts of the library used. + * This can be in the form of a textual message at program startup or + * in documentation (online or textual) provided with the package. + * + * 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 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * "This product includes cryptographic software written by + * Eric Young (eay@cryptsoft.com)" + * The word 'cryptographic' can be left out if the rouines from the library + * being used are not cryptographic related :-). + * 4. If you include any Windows specific code (or a derivative thereof) from + * the apps directory (application code) you must include an acknowledgement: + * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" + * + * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 OR CONTRIBUTORS 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. + * + * The licence and distribution terms for any publically available version or + * derivative of this code cannot be changed. i.e. this code cannot simply be + * copied and put under another distribution licence + * [including the GNU Public Licence.] + */ + +#include <stdio.h> +#include <ctype.h> +#include <limits.h> +#include "cryptlib.h" +#include <openssl/lhash.h> +#include <openssl/asn1.h> +#include <openssl/objects.h> +#include <openssl/bn.h> + +/* obj_dat.h is generated from objects.h by obj_dat.pl */ +#ifndef OPENSSL_NO_OBJECT +#include "obj_dat.h" +#else +/* You will have to load all the objects needed manually in the application */ +#define NUM_NID 0 +#define NUM_SN 0 +#define NUM_LN 0 +#define NUM_OBJ 0 +static const unsigned char lvalues[1]; +static const ASN1_OBJECT nid_objs[1]; +static const unsigned int sn_objs[1]; +static const unsigned int ln_objs[1]; +static const unsigned int obj_objs[1]; +#endif + +DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn); +DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln); +DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj); + +#define ADDED_DATA 0 +#define ADDED_SNAME 1 +#define ADDED_LNAME 2 +#define ADDED_NID 3 + +typedef struct added_obj_st + { + int type; + ASN1_OBJECT *obj; + } ADDED_OBJ; +DECLARE_LHASH_OF(ADDED_OBJ); + +static int new_nid=NUM_NID; +static LHASH_OF(ADDED_OBJ) *added=NULL; + +static int sn_cmp(const ASN1_OBJECT * const *a, const unsigned int *b) + { return(strcmp((*a)->sn,nid_objs[*b].sn)); } + +IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn); + +static int ln_cmp(const ASN1_OBJECT * const *a, const unsigned int *b) + { return(strcmp((*a)->ln,nid_objs[*b].ln)); } + +IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln); + +static unsigned long added_obj_hash(const ADDED_OBJ *ca) + { + const ASN1_OBJECT *a; + int i; + unsigned long ret=0; + unsigned char *p; + + a=ca->obj; + switch (ca->type) + { + case ADDED_DATA: + ret=a->length<<20L; + p=(unsigned char *)a->data; + for (i=0; i<a->length; i++) + ret^=p[i]<<((i*3)%24); + break; + case ADDED_SNAME: + ret=lh_strhash(a->sn); + break; + case ADDED_LNAME: + ret=lh_strhash(a->ln); + break; + case ADDED_NID: + ret=a->nid; + break; + default: + /* abort(); */ + return 0; + } + ret&=0x3fffffffL; + ret|=ca->type<<30L; + return(ret); + } +static IMPLEMENT_LHASH_HASH_FN(added_obj, ADDED_OBJ) + +static int added_obj_cmp(const ADDED_OBJ *ca, const ADDED_OBJ *cb) + { + ASN1_OBJECT *a,*b; + int i; + + i=ca->type-cb->type; + if (i) return(i); + a=ca->obj; + b=cb->obj; + switch (ca->type) + { + case ADDED_DATA: + i=(a->length - b->length); + if (i) return(i); + return(memcmp(a->data,b->data,(size_t)a->length)); + case ADDED_SNAME: + if (a->sn == NULL) return(-1); + else if (b->sn == NULL) return(1); + else return(strcmp(a->sn,b->sn)); + case ADDED_LNAME: + if (a->ln == NULL) return(-1); + else if (b->ln == NULL) return(1); + else return(strcmp(a->ln,b->ln)); + case ADDED_NID: + return(a->nid-b->nid); + default: + /* abort(); */ + return 0; + } + } +static IMPLEMENT_LHASH_COMP_FN(added_obj, ADDED_OBJ) + +static int init_added(void) + { + if (added != NULL) return(1); + added=lh_ADDED_OBJ_new(); + return(added != NULL); + } + +static void cleanup1_doall(ADDED_OBJ *a) + { + a->obj->nid=0; + a->obj->flags|=ASN1_OBJECT_FLAG_DYNAMIC| + ASN1_OBJECT_FLAG_DYNAMIC_STRINGS| + ASN1_OBJECT_FLAG_DYNAMIC_DATA; + } + +static void cleanup2_doall(ADDED_OBJ *a) + { a->obj->nid++; } + +static void cleanup3_doall(ADDED_OBJ *a) + { + if (--a->obj->nid == 0) + ASN1_OBJECT_free(a->obj); + OPENSSL_free(a); + } + +static IMPLEMENT_LHASH_DOALL_FN(cleanup1, ADDED_OBJ) +static IMPLEMENT_LHASH_DOALL_FN(cleanup2, ADDED_OBJ) +static IMPLEMENT_LHASH_DOALL_FN(cleanup3, ADDED_OBJ) + +/* The purpose of obj_cleanup_defer is to avoid EVP_cleanup() attempting + * to use freed up OIDs. If neccessary the actual freeing up of OIDs is + * delayed. + */ + +int obj_cleanup_defer = 0; + +void check_defer(int nid) + { + if (!obj_cleanup_defer && nid >= NUM_NID) + obj_cleanup_defer = 1; + } + +void OBJ_cleanup(void) + { + if (obj_cleanup_defer) + { + obj_cleanup_defer = 2; + return ; + } + if (added == NULL) return; + lh_ADDED_OBJ_down_load(added) = 0; + lh_ADDED_OBJ_doall(added,LHASH_DOALL_FN(cleanup1)); /* zero counters */ + lh_ADDED_OBJ_doall(added,LHASH_DOALL_FN(cleanup2)); /* set counters */ + lh_ADDED_OBJ_doall(added,LHASH_DOALL_FN(cleanup3)); /* free objects */ + lh_ADDED_OBJ_free(added); + added=NULL; + } + +int OBJ_new_nid(int num) + { + int i; + + i=new_nid; + new_nid+=num; + return(i); + } + +int OBJ_add_object(const ASN1_OBJECT *obj) + { + ASN1_OBJECT *o; + ADDED_OBJ *ao[4]={NULL,NULL,NULL,NULL},*aop; + int i; + + if (added == NULL) + if (!init_added()) return(0); + if ((o=OBJ_dup(obj)) == NULL) goto err; + if (!(ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2; + if ((o->length != 0) && (obj->data != NULL)) + if (!(ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2; + if (o->sn != NULL) + if (!(ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2; + if (o->ln != NULL) + if (!(ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2; + + for (i=ADDED_DATA; i<=ADDED_NID; i++) + { + if (ao[i] != NULL) + { + ao[i]->type=i; + ao[i]->obj=o; + aop=lh_ADDED_OBJ_insert(added,ao[i]); + /* memory leak, buit should not normally matter */ + if (aop != NULL) + OPENSSL_free(aop); + } + } + o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS| + ASN1_OBJECT_FLAG_DYNAMIC_DATA); + + return(o->nid); +err2: + OBJerr(OBJ_F_OBJ_ADD_OBJECT,ERR_R_MALLOC_FAILURE); +err: + for (i=ADDED_DATA; i<=ADDED_NID; i++) + if (ao[i] != NULL) OPENSSL_free(ao[i]); + if (o != NULL) OPENSSL_free(o); + return(NID_undef); + } + +ASN1_OBJECT *OBJ_nid2obj(int n) + { + ADDED_OBJ ad,*adp; + ASN1_OBJECT ob; + + if ((n >= 0) && (n < NUM_NID)) + { + if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) + { + OBJerr(OBJ_F_OBJ_NID2OBJ,OBJ_R_UNKNOWN_NID); + return(NULL); + } + return((ASN1_OBJECT *)&(nid_objs[n])); + } + else if (added == NULL) + return(NULL); + else + { + ad.type=ADDED_NID; + ad.obj= &ob; + ob.nid=n; + adp=lh_ADDED_OBJ_retrieve(added,&ad); + if (adp != NULL) + return(adp->obj); + else + { + OBJerr(OBJ_F_OBJ_NID2OBJ,OBJ_R_UNKNOWN_NID); + return(NULL); + } + } + } + +const char *OBJ_nid2sn(int n) + { + ADDED_OBJ ad,*adp; + ASN1_OBJECT ob; + + if ((n >= 0) && (n < NUM_NID)) + { + if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) + { + OBJerr(OBJ_F_OBJ_NID2SN,OBJ_R_UNKNOWN_NID); + return(NULL); + } + return(nid_objs[n].sn); + } + else if (added == NULL) + return(NULL); + else + { + ad.type=ADDED_NID; + ad.obj= &ob; + ob.nid=n; + adp=lh_ADDED_OBJ_retrieve(added,&ad); + if (adp != NULL) + return(adp->obj->sn); + else + { + OBJerr(OBJ_F_OBJ_NID2SN,OBJ_R_UNKNOWN_NID); + return(NULL); + } + } + } + +const char *OBJ_nid2ln(int n) + { + ADDED_OBJ ad,*adp; + ASN1_OBJECT ob; + + if ((n >= 0) && (n < NUM_NID)) + { + if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) + { + OBJerr(OBJ_F_OBJ_NID2LN,OBJ_R_UNKNOWN_NID); + return(NULL); + } + return(nid_objs[n].ln); + } + else if (added == NULL) + return(NULL); + else + { + ad.type=ADDED_NID; + ad.obj= &ob; + ob.nid=n; + adp=lh_ADDED_OBJ_retrieve(added,&ad); + if (adp != NULL) + return(adp->obj->ln); + else + { + OBJerr(OBJ_F_OBJ_NID2LN,OBJ_R_UNKNOWN_NID); + return(NULL); + } + } + } + +static int obj_cmp(const ASN1_OBJECT * const *ap, const unsigned int *bp) + { + int j; + const ASN1_OBJECT *a= *ap; + const ASN1_OBJECT *b= &nid_objs[*bp]; + + j=(a->length - b->length); + if (j) return(j); + return(memcmp(a->data,b->data,a->length)); + } + +IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj); + +int OBJ_obj2nid(const ASN1_OBJECT *a) + { + const unsigned int *op; + ADDED_OBJ ad,*adp; + + if (a == NULL) + return(NID_undef); + if (a->nid != 0) + return(a->nid); + + if (added != NULL) + { + ad.type=ADDED_DATA; + ad.obj=(ASN1_OBJECT *)a; /* XXX: ugly but harmless */ + adp=lh_ADDED_OBJ_retrieve(added,&ad); + if (adp != NULL) return (adp->obj->nid); + } + op=OBJ_bsearch_obj(&a, obj_objs, NUM_OBJ); + if (op == NULL) + return(NID_undef); + return(nid_objs[*op].nid); + } + +/* Convert an object name into an ASN1_OBJECT + * if "noname" is not set then search for short and long names first. + * This will convert the "dotted" form into an object: unlike OBJ_txt2nid + * it can be used with any objects, not just registered ones. + */ + +ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name) + { + int nid = NID_undef; + ASN1_OBJECT *op=NULL; + unsigned char *buf; + unsigned char *p; + const unsigned char *cp; + int i, j; + + if(!no_name) { + if( ((nid = OBJ_sn2nid(s)) != NID_undef) || + ((nid = OBJ_ln2nid(s)) != NID_undef) ) + return OBJ_nid2obj(nid); + } + + /* Work out size of content octets */ + i=a2d_ASN1_OBJECT(NULL,0,s,-1); + if (i <= 0) { + /* Don't clear the error */ + /*ERR_clear_error();*/ + return NULL; + } + /* Work out total size */ + j = ASN1_object_size(0,i,V_ASN1_OBJECT); + + if((buf=(unsigned char *)OPENSSL_malloc(j)) == NULL) return NULL; + + p = buf; + /* Write out tag+length */ + ASN1_put_object(&p,0,i,V_ASN1_OBJECT,V_ASN1_UNIVERSAL); + /* Write out contents */ + a2d_ASN1_OBJECT(p,i,s,-1); + + cp=buf; + op=d2i_ASN1_OBJECT(NULL,&cp,j); + OPENSSL_free(buf); + return op; + } + +int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name) +{ + int i,n=0,len,nid, first, use_bn; + BIGNUM *bl; + unsigned long l; + const unsigned char *p; + char tbuf[DECIMAL_SIZE(i)+DECIMAL_SIZE(l)+2]; + + if ((a == NULL) || (a->data == NULL)) { + buf[0]='\0'; + return(0); + } + + + if (!no_name && (nid=OBJ_obj2nid(a)) != NID_undef) + { + const char *s; + s=OBJ_nid2ln(nid); + if (s == NULL) + s=OBJ_nid2sn(nid); + if (s) + { + if (buf) + BUF_strlcpy(buf,s,buf_len); + n=strlen(s); + return n; + } + } + + + len=a->length; + p=a->data; + + first = 1; + bl = NULL; + + while (len > 0) + { + l=0; + use_bn = 0; + for (;;) + { + unsigned char c = *p++; + len--; + if ((len == 0) && (c & 0x80)) + goto err; + if (use_bn) + { + if (!BN_add_word(bl, c & 0x7f)) + goto err; + } + else + l |= c & 0x7f; + if (!(c & 0x80)) + break; + if (!use_bn && (l > (ULONG_MAX >> 7L))) + { + if (!bl && !(bl = BN_new())) + goto err; + if (!BN_set_word(bl, l)) + goto err; + use_bn = 1; + } + if (use_bn) + { + if (!BN_lshift(bl, bl, 7)) + goto err; + } + else + l<<=7L; + } + + if (first) + { + first = 0; + if (l >= 80) + { + i = 2; + if (use_bn) + { + if (!BN_sub_word(bl, 80)) + goto err; + } + else + l -= 80; + } + else + { + i=(int)(l/40); + l-=(long)(i*40); + } + if (buf && (buf_len > 0)) + { + *buf++ = i + '0'; + buf_len--; + } + n++; + } + + if (use_bn) + { + char *bndec; + bndec = BN_bn2dec(bl); + if (!bndec) + goto err; + i = strlen(bndec); + if (buf) + { + if (buf_len > 0) + { + *buf++ = '.'; + buf_len--; + } + BUF_strlcpy(buf,bndec,buf_len); + if (i > buf_len) + { + buf += buf_len; + buf_len = 0; + } + else + { + buf+=i; + buf_len-=i; + } + } + n++; + n += i; + OPENSSL_free(bndec); + } + else + { + BIO_snprintf(tbuf,sizeof tbuf,".%lu",l); + i=strlen(tbuf); + if (buf && (buf_len > 0)) + { + BUF_strlcpy(buf,tbuf,buf_len); + if (i > buf_len) + { + buf += buf_len; + buf_len = 0; + } + else + { + buf+=i; + buf_len-=i; + } + } + n+=i; + l=0; + } + } + + if (bl) + BN_free(bl); + return n; + + err: + if (bl) + BN_free(bl); + return -1; +} + +int OBJ_txt2nid(const char *s) +{ + ASN1_OBJECT *obj; + int nid; + obj = OBJ_txt2obj(s, 0); + nid = OBJ_obj2nid(obj); + ASN1_OBJECT_free(obj); + return nid; +} + +int OBJ_ln2nid(const char *s) + { + ASN1_OBJECT o; + const ASN1_OBJECT *oo= &o; + ADDED_OBJ ad,*adp; + const unsigned int *op; + + o.ln=s; + if (added != NULL) + { + ad.type=ADDED_LNAME; + ad.obj= &o; + adp=lh_ADDED_OBJ_retrieve(added,&ad); + if (adp != NULL) return (adp->obj->nid); + } + op=OBJ_bsearch_ln(&oo, ln_objs, NUM_LN); + if (op == NULL) return(NID_undef); + return(nid_objs[*op].nid); + } + +int OBJ_sn2nid(const char *s) + { + ASN1_OBJECT o; + const ASN1_OBJECT *oo= &o; + ADDED_OBJ ad,*adp; + const unsigned int *op; + + o.sn=s; + if (added != NULL) + { + ad.type=ADDED_SNAME; + ad.obj= &o; + adp=lh_ADDED_OBJ_retrieve(added,&ad); + if (adp != NULL) return (adp->obj->nid); + } + op=OBJ_bsearch_sn(&oo, sn_objs, NUM_SN); + if (op == NULL) return(NID_undef); + return(nid_objs[*op].nid); + } + +const void *OBJ_bsearch_(const void *key, const void *base, int num, int size, + int (*cmp)(const void *, const void *)) + { + return OBJ_bsearch_ex_(key, base, num, size, cmp, 0); + } + +const void *OBJ_bsearch_ex_(const void *key, const void *base_, int num, + int size, + int (*cmp)(const void *, const void *), + int flags) + { + const char *base=base_; + int l,h,i=0,c=0; + const char *p = NULL; + + if (num == 0) return(NULL); + l=0; + h=num; + while (l < h) + { + i=(l+h)/2; + p= &(base[i*size]); + c=(*cmp)(key,p); + if (c < 0) + h=i; + else if (c > 0) + l=i+1; + else + break; + } +#ifdef CHARSET_EBCDIC +/* THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and + * I don't have perl (yet), we revert to a *LINEAR* search + * when the object wasn't found in the binary search. + */ + if (c != 0) + { + for (i=0; i<num; ++i) + { + p= &(base[i*size]); + c = (*cmp)(key,p); + if (c == 0 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH))) + return p; + } + } +#endif + if (c != 0 && !(flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)) + p = NULL; + else if (c == 0 && (flags & OBJ_BSEARCH_FIRST_VALUE_ON_MATCH)) + { + while(i > 0 && (*cmp)(key,&(base[(i-1)*size])) == 0) + i--; + p = &(base[i*size]); + } + return(p); + } + +int OBJ_create_objects(BIO *in) + { + MS_STATIC char buf[512]; + int i,num=0; + char *o,*s,*l=NULL; + + for (;;) + { + s=o=NULL; + i=BIO_gets(in,buf,512); + if (i <= 0) return(num); + buf[i-1]='\0'; + if (!isalnum((unsigned char)buf[0])) return(num); + o=s=buf; + while (isdigit((unsigned char)*s) || (*s == '.')) + s++; + if (*s != '\0') + { + *(s++)='\0'; + while (isspace((unsigned char)*s)) + s++; + if (*s == '\0') + s=NULL; + else + { + l=s; + while ((*l != '\0') && !isspace((unsigned char)*l)) + l++; + if (*l != '\0') + { + *(l++)='\0'; + while (isspace((unsigned char)*l)) + l++; + if (*l == '\0') l=NULL; + } + else + l=NULL; + } + } + else + s=NULL; + if ((o == NULL) || (*o == '\0')) return(num); + if (!OBJ_create(o,s,l)) return(num); + num++; + } + /* return(num); */ + } + +int OBJ_create(const char *oid, const char *sn, const char *ln) + { + int ok=0; + ASN1_OBJECT *op=NULL; + unsigned char *buf; + int i; + + i=a2d_ASN1_OBJECT(NULL,0,oid,-1); + if (i <= 0) return(0); + + if ((buf=(unsigned char *)OPENSSL_malloc(i)) == NULL) + { + OBJerr(OBJ_F_OBJ_CREATE,ERR_R_MALLOC_FAILURE); + return(0); + } + i=a2d_ASN1_OBJECT(buf,i,oid,-1); + if (i == 0) + goto err; + op=(ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1),buf,i,sn,ln); + if (op == NULL) + goto err; + ok=OBJ_add_object(op); +err: + ASN1_OBJECT_free(op); + OPENSSL_free(buf); + return(ok); + } + |