OpenSSL 0.9.7 stable 2002 05 08 merge

author: beck <> 2002-05-15 02:29:21 +0000
committer: beck <> 2002-05-15 02:29:21 +0000
commit: b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9 (patch)
tree: fa27cf82a1250b64ed3bf5f4a18c7354d470bbcc /src/lib/libcrypto/pkcs12/p12_attr.c
parent: e471e1ea98d673597b182ea85f29e30c97cd08b5 (diff)
download: openbsd-b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9.tar.gz
openbsd-b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9.tar.bz2
openbsd-b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9.zip
1 files changed, 31 insertions, 124 deletions
diff --git a/src/lib/libcrypto/pkcs12/p12_attr.c b/src/lib/libcrypto/pkcs12/p12_attr.c
index a16a97d03d..026cf3826a 100644
--- a/src/lib/libcrypto/pkcs12/p12_attr.c
+++ b/src/lib/libcrypto/pkcs12/p12_attr.c
@@ -62,156 +62,63 @@
 /* Add a local keyid to a safebag */
-int PKCS12_add_localkeyid (PKCS12_SAFEBAG *bag, unsigned char *name,
+int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name,
             int namelen)
 {
-        X509_ATTRIBUTE *attrib;
+        if (X509at_add1_attr_by_NID(&bag->attrib, NID_localKeyID,
-        ASN1_BMPSTRING *oct;
+                                V_ASN1_OCTET_STRING, name, namelen))
-        ASN1_TYPE *keyid;
+                return 1;
-        if (!(keyid = ASN1_TYPE_new ())) {
+        else 
-                PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        keyid->type = V_ASN1_OCTET_STRING;
-        if (!(oct = M_ASN1_OCTET_STRING_new())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        if (!M_ASN1_OCTET_STRING_set(oct, name, namelen)) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        keyid->value.octet_string = oct;
-        if (!(attrib = X509_ATTRIBUTE_new ())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        attrib->object = OBJ_nid2obj(NID_localKeyID);
-        if (!(attrib->value.set = sk_ASN1_TYPE_new_null())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        sk_ASN1_TYPE_push (attrib->value.set,keyid);
-        attrib->set = 1;
-        if (!bag->attrib && !(bag->attrib = sk_X509_ATTRIBUTE_new_null ())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
                return 0;
-        }
-        sk_X509_ATTRIBUTE_push (bag->attrib, attrib);
-        return 1;
 }
 /* Add key usage to PKCS#8 structure */
-int PKCS8_add_keyusage (PKCS8_PRIV_KEY_INFO *p8, int usage)
+int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage)
 {
-        X509_ATTRIBUTE *attrib;
-        ASN1_BIT_STRING *bstr;
-        ASN1_TYPE *keyid;
        unsigned char us_val;
        us_val = (unsigned char) usage;
-        if (!(keyid = ASN1_TYPE_new ())) {
+        if (X509at_add1_attr_by_NID(&p8->attributes, NID_key_usage,
-                PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
+                                V_ASN1_BIT_STRING, &us_val, 1))
-                return 0;
+                return 1;
-        }
+        else
-        keyid->type = V_ASN1_BIT_STRING;
-        if (!(bstr = M_ASN1_BIT_STRING_new())) {
-                PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        if (!M_ASN1_BIT_STRING_set(bstr, &us_val, 1)) {
-                PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        keyid->value.bit_string = bstr;
-        if (!(attrib = X509_ATTRIBUTE_new ())) {
-                PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        attrib->object = OBJ_nid2obj(NID_key_usage);
-        if (!(attrib->value.set = sk_ASN1_TYPE_new_null())) {
-                PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
                return 0;
-        }
-        sk_ASN1_TYPE_push (attrib->value.set,keyid);
-        attrib->set = 1;
-        if (!p8->attributes
-            && !(p8->attributes = sk_X509_ATTRIBUTE_new_null ())) {
-                PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        sk_X509_ATTRIBUTE_push (p8->attributes, attrib);
-        return 1;
 }
 /* Add a friendlyname to a safebag */
-int PKCS12_add_friendlyname_asc (PKCS12_SAFEBAG *bag, const char *name,
+int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name,
                                 int namelen)
 {
-        unsigned char *uniname;
+        if (X509at_add1_attr_by_NID(&bag->attrib, NID_friendlyName,
-        int ret, unilen;
+                                MBSTRING_ASC, (unsigned char *)name, namelen))
-        if (!asc2uni(name, namelen, &uniname, &unilen)) {
+                return 1;
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_ASC,
+        else
-                                                        ERR_R_MALLOC_FAILURE);
                return 0;
-        }
-        ret = PKCS12_add_friendlyname_uni (bag, uniname, unilen);
-        OPENSSL_free(uniname);
-        return ret;
 }
-        
-int PKCS12_add_friendlyname_uni (PKCS12_SAFEBAG *bag,
+int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag,
                                 const unsigned char *name, int namelen)
 {
-        X509_ATTRIBUTE *attrib;
+        if (X509at_add1_attr_by_NID(&bag->attrib, NID_friendlyName,
-        ASN1_BMPSTRING *bmp;
+                                MBSTRING_BMP, name, namelen))
-        ASN1_TYPE *fname;
+                return 1;
-        /* Zap ending double null if included */
+        else
-        if(!name[namelen - 1] && !name[namelen - 2]) namelen -= 2;
-        if (!(fname = ASN1_TYPE_new ())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
-                                                        ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        fname->type = V_ASN1_BMPSTRING;
-        if (!(bmp = M_ASN1_BMPSTRING_new())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
-                                                        ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        if (!(bmp->data = OPENSSL_malloc (namelen))) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
-                                                        ERR_R_MALLOC_FAILURE);
                return 0;
-        }
+}
-        memcpy (bmp->data, name, namelen);
-        bmp->length = namelen;
+int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name,
-        fname->value.bmpstring = bmp;
+                                 int namelen)
-        if (!(attrib = X509_ATTRIBUTE_new ())) {
+{
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
+        if (X509at_add1_attr_by_NID(&bag->attrib, NID_ms_csp_name,
-                                                        ERR_R_MALLOC_FAILURE);
+                                MBSTRING_ASC, (unsigned char *)name, namelen))
-                return 0;
+                return 1;
-        }
+        else
-        attrib->object = OBJ_nid2obj(NID_friendlyName);
-        if (!(attrib->value.set = sk_ASN1_TYPE_new_null())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME,
-                                                        ERR_R_MALLOC_FAILURE);
-                return 0;
-        }
-        sk_ASN1_TYPE_push (attrib->value.set,fname);
-        attrib->set = 1;
-        if (!bag->attrib && !(bag->attrib = sk_X509_ATTRIBUTE_new_null ())) {
-                PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
-                                                        ERR_R_MALLOC_FAILURE);
                return 0;
-        }
-        sk_X509_ATTRIBUTE_push (bag->attrib, attrib);
-        return PKCS12_OK;
 }
-ASN1_TYPE *PKCS12_get_attr_gen (STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid)
+ASN1_TYPE *PKCS12_get_attr_gen(STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid)
 {
        X509_ATTRIBUTE *attrib;
        int i;
author	beck <>	2002-05-15 02:29:21 +0000
committer	beck <>	2002-05-15 02:29:21 +0000
commit	b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9 (patch)
tree	fa27cf82a1250b64ed3bf5f4a18c7354d470bbcc /src/lib/libcrypto/pkcs12/p12_attr.c
parent	e471e1ea98d673597b182ea85f29e30c97cd08b5 (diff)
download	openbsd-b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9.tar.gz openbsd-b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9.tar.bz2 openbsd-b64270d1e45fe7f3241e4c9b6ce60d5ac89bc2e9.zip

diff --git a/src/lib/libcrypto/pkcs12/p12_attr.c b/src/lib/libcrypto/pkcs12/p12_attr.c index a16a97d03d..026cf3826a 100644 --- a/src/lib/libcrypto/pkcs12/p12_attr.c +++ b/src/lib/libcrypto/pkcs12/p12_attr.c
@@ -62,156 +62,63 @@
62		62
63	/* Add a local keyid to a safebag */	63	/* Add a local keyid to a safebag */
64		64
65	int PKCS12_add_localkeyid (PKCS12_SAFEBAG bag, unsigned char name,	65	int PKCS12_add_localkeyid(PKCS12_SAFEBAG bag, unsigned char name,
66	int namelen)	66	int namelen)
67	{	67	{
68	X509_ATTRIBUTE *attrib;	68	if (X509at_add1_attr_by_NID(&bag->attrib, NID_localKeyID,
69	ASN1_BMPSTRING *oct;	69	V_ASN1_OCTET_STRING, name, namelen))
70	ASN1_TYPE *keyid;	70	return 1;
71	if (!(keyid = ASN1_TYPE_new ())) {	71	else
72	PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
73	return 0;
74	}
75	keyid->type = V_ASN1_OCTET_STRING;
76	if (!(oct = M_ASN1_OCTET_STRING_new())) {
77	PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
78	return 0;
79	}
80	if (!M_ASN1_OCTET_STRING_set(oct, name, namelen)) {
81	PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
82	return 0;
83	}
84	keyid->value.octet_string = oct;
85	if (!(attrib = X509_ATTRIBUTE_new ())) {
86	PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
87	return 0;
88	}
89	attrib->object = OBJ_nid2obj(NID_localKeyID);
90	if (!(attrib->value.set = sk_ASN1_TYPE_new_null())) {
91	PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
92	return 0;
93	}
94	sk_ASN1_TYPE_push (attrib->value.set,keyid);
95	attrib->set = 1;
96	if (!bag->attrib && !(bag->attrib = sk_X509_ATTRIBUTE_new_null ())) {
97	PKCS12err(PKCS12_F_PKCS12_ADD_LOCALKEYID, ERR_R_MALLOC_FAILURE);
98	return 0;	72	return 0;
99	}
100	sk_X509_ATTRIBUTE_push (bag->attrib, attrib);
101	return 1;
102	}	73	}
103		74
104	/* Add key usage to PKCS#8 structure */	75	/* Add key usage to PKCS#8 structure */
105		76
106	int PKCS8_add_keyusage (PKCS8_PRIV_KEY_INFO *p8, int usage)	77	int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage)
107	{	78	{
108	X509_ATTRIBUTE *attrib;
109	ASN1_BIT_STRING *bstr;
110	ASN1_TYPE *keyid;
111	unsigned char us_val;	79	unsigned char us_val;
112	us_val = (unsigned char) usage;	80	us_val = (unsigned char) usage;
113	if (!(keyid = ASN1_TYPE_new ())) {	81	if (X509at_add1_attr_by_NID(&p8->attributes, NID_key_usage,
114	PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);	82	V_ASN1_BIT_STRING, &us_val, 1))
115	return 0;	83	return 1;
116	}	84	else
117	keyid->type = V_ASN1_BIT_STRING;
118	if (!(bstr = M_ASN1_BIT_STRING_new())) {
119	PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
120	return 0;
121	}
122	if (!M_ASN1_BIT_STRING_set(bstr, &us_val, 1)) {
123	PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
124	return 0;
125	}
126	keyid->value.bit_string = bstr;
127	if (!(attrib = X509_ATTRIBUTE_new ())) {
128	PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
129	return 0;
130	}
131	attrib->object = OBJ_nid2obj(NID_key_usage);
132	if (!(attrib->value.set = sk_ASN1_TYPE_new_null())) {
133	PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
134	return 0;	85	return 0;
135	}
136	sk_ASN1_TYPE_push (attrib->value.set,keyid);
137	attrib->set = 1;
138	if (!p8->attributes
139	&& !(p8->attributes = sk_X509_ATTRIBUTE_new_null ())) {
140	PKCS12err(PKCS12_F_PKCS8_ADD_KEYUSAGE, ERR_R_MALLOC_FAILURE);
141	return 0;
142	}
143	sk_X509_ATTRIBUTE_push (p8->attributes, attrib);
144	return 1;
145	}	86	}
146		87
147	/* Add a friendlyname to a safebag */	88	/* Add a friendlyname to a safebag */
148		89
149	int PKCS12_add_friendlyname_asc (PKCS12_SAFEBAG bag, const char name,	90	int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG bag, const char name,
150	int namelen)	91	int namelen)
151	{	92	{
152	unsigned char *uniname;	93	if (X509at_add1_attr_by_NID(&bag->attrib, NID_friendlyName,
153	int ret, unilen;	94	MBSTRING_ASC, (unsigned char *)name, namelen))
154	if (!asc2uni(name, namelen, &uniname, &unilen)) {	95	return 1;
155	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_ASC,	96	else
156	ERR_R_MALLOC_FAILURE);
157	return 0;	97	return 0;
158	}
159	ret = PKCS12_add_friendlyname_uni (bag, uniname, unilen);
160	OPENSSL_free(uniname);
161	return ret;
162	}	98	}
163
164		99
165	int PKCS12_add_friendlyname_uni (PKCS12_SAFEBAG *bag,	100
		101	int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag,
166	const unsigned char *name, int namelen)	102	const unsigned char *name, int namelen)
167	{	103	{
168	X509_ATTRIBUTE *attrib;	104	if (X509at_add1_attr_by_NID(&bag->attrib, NID_friendlyName,
169	ASN1_BMPSTRING *bmp;	105	MBSTRING_BMP, name, namelen))
170	ASN1_TYPE *fname;	106	return 1;
171	/* Zap ending double null if included */	107	else
172	if(!name[namelen - 1] && !name[namelen - 2]) namelen -= 2;
173	if (!(fname = ASN1_TYPE_new ())) {
174	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
175	ERR_R_MALLOC_FAILURE);
176	return 0;
177	}
178	fname->type = V_ASN1_BMPSTRING;
179	if (!(bmp = M_ASN1_BMPSTRING_new())) {
180	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
181	ERR_R_MALLOC_FAILURE);
182	return 0;
183	}
184	if (!(bmp->data = OPENSSL_malloc (namelen))) {
185	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
186	ERR_R_MALLOC_FAILURE);
187	return 0;	108	return 0;
188	}	109	}
189	memcpy (bmp->data, name, namelen);	110
190	bmp->length = namelen;	111	int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG bag, const char name,
191	fname->value.bmpstring = bmp;	112	int namelen)
192	if (!(attrib = X509_ATTRIBUTE_new ())) {	113	{
193	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,	114	if (X509at_add1_attr_by_NID(&bag->attrib, NID_ms_csp_name,
194	ERR_R_MALLOC_FAILURE);	115	MBSTRING_ASC, (unsigned char *)name, namelen))
195	return 0;	116	return 1;
196	}	117	else
197	attrib->object = OBJ_nid2obj(NID_friendlyName);
198	if (!(attrib->value.set = sk_ASN1_TYPE_new_null())) {
199	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME,
200	ERR_R_MALLOC_FAILURE);
201	return 0;
202	}
203	sk_ASN1_TYPE_push (attrib->value.set,fname);
204	attrib->set = 1;
205	if (!bag->attrib && !(bag->attrib = sk_X509_ATTRIBUTE_new_null ())) {
206	PKCS12err(PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI,
207	ERR_R_MALLOC_FAILURE);
208	return 0;	118	return 0;
209	}
210	sk_X509_ATTRIBUTE_push (bag->attrib, attrib);
211	return PKCS12_OK;
212	}	119	}
213		120
214	ASN1_TYPE PKCS12_get_attr_gen (STACK_OF(X509_ATTRIBUTE) attrs, int attr_nid)	121	ASN1_TYPE PKCS12_get_attr_gen(STACK_OF(X509_ATTRIBUTE) attrs, int attr_nid)
215	{	122	{
216	X509_ATTRIBUTE *attrib;	123	X509_ATTRIBUTE *attrib;
217	int i;	124	int i;