summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/asn1/x_name.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/asn1/x_name.c')
-rw-r--r--src/lib/libcrypto/asn1/x_name.c371
1 files changed, 174 insertions, 197 deletions
diff --git a/src/lib/libcrypto/asn1/x_name.c b/src/lib/libcrypto/asn1/x_name.c
index 28b9c34b58..caece0f158 100644
--- a/src/lib/libcrypto/asn1/x_name.c
+++ b/src/lib/libcrypto/asn1/x_name.c
@@ -58,228 +58,203 @@
58 58
59#include <stdio.h> 59#include <stdio.h>
60#include "cryptlib.h" 60#include "cryptlib.h"
61#include "objects.h" 61#include <openssl/asn1t.h>
62#include "asn1_mac.h" 62#include <openssl/x509.h>
63 63
64/* 64static int x509_name_ex_d2i(ASN1_VALUE **val, unsigned char **in, long len, const ASN1_ITEM *it,
65 * ASN1err(ASN1_F_D2I_X509_NAME,ASN1_R_LENGTH_MISMATCH); 65 int tag, int aclass, char opt, ASN1_TLC *ctx);
66 * ASN1err(ASN1_F_X509_NAME_NEW,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
67 * ASN1err(ASN1_F_D2I_X509_NAME_ENTRY,ASN1_R_LENGTH_MISMATCH);
68 * ASN1err(ASN1_F_X509_NAME_ENTRY_NEW,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
69 */
70
71#ifndef NOPROTO
72static int i2d_X509_NAME_entries(X509_NAME *a);
73#else
74static int i2d_X509_NAME_entries();
75#endif
76
77int i2d_X509_NAME_ENTRY(a,pp)
78X509_NAME_ENTRY *a;
79unsigned char **pp;
80 {
81 M_ASN1_I2D_vars(a);
82
83 M_ASN1_I2D_len(a->object,i2d_ASN1_OBJECT);
84 M_ASN1_I2D_len(a->value,i2d_ASN1_PRINTABLE);
85
86 M_ASN1_I2D_seq_total();
87
88 M_ASN1_I2D_put(a->object,i2d_ASN1_OBJECT);
89 M_ASN1_I2D_put(a->value,i2d_ASN1_PRINTABLE);
90
91 M_ASN1_I2D_finish();
92 }
93 66
94X509_NAME_ENTRY *d2i_X509_NAME_ENTRY(a,pp,length) 67static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass);
95X509_NAME_ENTRY **a; 68static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it);
96unsigned char **pp; 69static void x509_name_ex_free(ASN1_VALUE **val, const ASN1_ITEM *it);
97long length;
98 {
99 M_ASN1_D2I_vars(a,X509_NAME_ENTRY *,X509_NAME_ENTRY_new);
100 70
101 M_ASN1_D2I_Init(); 71static int x509_name_encode(X509_NAME *a);
102 M_ASN1_D2I_start_sequence();
103 M_ASN1_D2I_get(ret->object,d2i_ASN1_OBJECT);
104 M_ASN1_D2I_get(ret->value,d2i_ASN1_PRINTABLE);
105 ret->set=0;
106 M_ASN1_D2I_Finish(a,X509_NAME_ENTRY_free,ASN1_F_D2I_X509_NAME_ENTRY);
107 }
108 72
109int i2d_X509_NAME(a,pp) 73ASN1_SEQUENCE(X509_NAME_ENTRY) = {
110X509_NAME *a; 74 ASN1_SIMPLE(X509_NAME_ENTRY, object, ASN1_OBJECT),
111unsigned char **pp; 75 ASN1_SIMPLE(X509_NAME_ENTRY, value, ASN1_PRINTABLE)
112 { 76} ASN1_SEQUENCE_END(X509_NAME_ENTRY)
113 int ret;
114 77
115 if (a == NULL) return(0); 78IMPLEMENT_ASN1_FUNCTIONS(X509_NAME_ENTRY)
116 if (a->modified) 79IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME_ENTRY)
117 {
118 ret=i2d_X509_NAME_entries(a);
119 if (ret < 0) return(ret);
120 }
121 80
122 ret=a->bytes->length; 81/* For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY }
123 if (pp != NULL) 82 * so declare two template wrappers for this
124 { 83 */
125 memcpy(*pp,a->bytes->data,ret);
126 *pp+=ret;
127 }
128 return(ret);
129 }
130
131static int i2d_X509_NAME_entries(a)
132X509_NAME *a;
133 {
134 X509_NAME_ENTRY *ne,*fe=NULL;
135 STACK *sk;
136 BUF_MEM *buf=NULL;
137 int set=0,r,ret=0;
138 int i;
139 unsigned char *p;
140 int size=0;
141
142 sk=a->entries;
143 for (i=0; i<sk_num(sk); i++)
144 {
145 ne=(X509_NAME_ENTRY *)sk_value(sk,i);
146 if (fe == NULL)
147 {
148 fe=ne;
149 size=0;
150 }
151
152 if (ne->set != set)
153 {
154 ret+=ASN1_object_size(1,size,V_ASN1_SET);
155 fe->size=size;
156 fe=ne;
157 size=0;
158 set=ne->set;
159 }
160 size+=i2d_X509_NAME_ENTRY(ne,NULL);
161 }
162 84
163 ret+=ASN1_object_size(1,size,V_ASN1_SET); 85ASN1_ITEM_TEMPLATE(X509_NAME_ENTRIES) =
164 if (fe != NULL) 86 ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_OF, 0, RDNS, X509_NAME_ENTRY)
165 fe->size=size; 87ASN1_ITEM_TEMPLATE_END(X509_NAME_ENTRIES)
166 88
167 r=ASN1_object_size(1,ret,V_ASN1_SEQUENCE); 89ASN1_ITEM_TEMPLATE(X509_NAME_INTERNAL) =
90 ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, Name, X509_NAME_ENTRIES)
91ASN1_ITEM_TEMPLATE_END(X509_NAME_INTERNAL)
168 92
169 buf=a->bytes; 93/* Normally that's where it would end: we'd have two nested STACK structures
170 if (!BUF_MEM_grow(buf,r)) goto err; 94 * representing the ASN1. Unfortunately X509_NAME uses a completely different
171 p=(unsigned char *)buf->data; 95 * form and caches encodings so we have to process the internal form and convert
96 * to the external form.
97 */
172 98
173 ASN1_put_object(&p,1,ret,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL); 99const ASN1_EXTERN_FUNCS x509_name_ff = {
100 NULL,
101 x509_name_ex_new,
102 x509_name_ex_free,
103 0, /* Default clear behaviour is OK */
104 x509_name_ex_d2i,
105 x509_name_ex_i2d
106};
107
108IMPLEMENT_EXTERN_ASN1(X509_NAME, V_ASN1_SEQUENCE, x509_name_ff)
109
110IMPLEMENT_ASN1_FUNCTIONS(X509_NAME)
111IMPLEMENT_ASN1_DUP_FUNCTION(X509_NAME)
112
113static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it)
114{
115 X509_NAME *ret = NULL;
116 ret = OPENSSL_malloc(sizeof(X509_NAME));
117 if(!ret) goto memerr;
118 if ((ret->entries=sk_X509_NAME_ENTRY_new_null()) == NULL)
119 goto memerr;
120 if((ret->bytes = BUF_MEM_new()) == NULL) goto memerr;
121 ret->modified=1;
122 *val = (ASN1_VALUE *)ret;
123 return 1;
174 124
175 set= -1; 125 memerr:
176 for (i=0; i<sk_num(sk); i++) 126 ASN1err(ASN1_F_X509_NAME_NEW, ERR_R_MALLOC_FAILURE);
127 if (ret)
177 { 128 {
178 ne=(X509_NAME_ENTRY *)sk_value(sk,i); 129 if (ret->entries)
179 if (set != ne->set) 130 sk_X509_NAME_ENTRY_free(ret->entries);
180 { 131 OPENSSL_free(ret);
181 set=ne->set;
182 ASN1_put_object(&p,1,ne->size,
183 V_ASN1_SET,V_ASN1_UNIVERSAL);
184 }
185 i2d_X509_NAME_ENTRY(ne,&p);
186 } 132 }
187 a->modified=0; 133 return 0;
188 return(r); 134}
189err:
190 return(-1);
191 }
192 135
193X509_NAME *d2i_X509_NAME(a,pp,length) 136static void x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
194X509_NAME **a; 137{
195unsigned char **pp; 138 X509_NAME *a;
196long length; 139 if(!pval || !*pval)
197 { 140 return;
198 int set=0,i; 141 a = (X509_NAME *)*pval;
199 int idx=0;
200 unsigned char *orig;
201 M_ASN1_D2I_vars(a,X509_NAME *,X509_NAME_new);
202 142
203 orig= *pp; 143 BUF_MEM_free(a->bytes);
204 if (sk_num(ret->entries) > 0) 144 sk_X509_NAME_ENTRY_pop_free(a->entries,X509_NAME_ENTRY_free);
205 { 145 OPENSSL_free(a);
206 while (sk_num(ret->entries) > 0) 146 *pval = NULL;
207 X509_NAME_ENTRY_free((X509_NAME_ENTRY *) 147}
208 sk_pop(ret->entries)); 148
209 } 149/* Used with sk_pop_free() to free up the internal representation.
150 * NB: we only free the STACK and not its contents because it is
151 * already present in the X509_NAME structure.
152 */
210 153
211 M_ASN1_D2I_Init(); 154static void sk_internal_free(void *a)
212 M_ASN1_D2I_start_sequence(); 155{
213 for (;;) 156 sk_free(a);
214 { 157}
215 if (M_ASN1_D2I_end_sequence()) break; 158
216 M_ASN1_D2I_get_set(ret->entries,d2i_X509_NAME_ENTRY); 159static int x509_name_ex_d2i(ASN1_VALUE **val, unsigned char **in, long len, const ASN1_ITEM *it,
217 for (; idx < sk_num(ret->entries); idx++) 160 int tag, int aclass, char opt, ASN1_TLC *ctx)
218 { 161{
219 ((X509_NAME_ENTRY *)sk_value(ret->entries,idx))->set= 162 unsigned char *p = *in, *q;
220 set; 163 STACK *intname = NULL;
221 } 164 int i, j, ret;
222 set++; 165 X509_NAME *nm = NULL;
166 STACK_OF(X509_NAME_ENTRY) *entries;
167 X509_NAME_ENTRY *entry;
168 q = p;
169
170 /* Get internal representation of Name */
171 ret = ASN1_item_ex_d2i((ASN1_VALUE **)&intname, &p, len, ASN1_ITEM_rptr(X509_NAME_INTERNAL),
172 tag, aclass, opt, ctx);
173
174 if(ret <= 0) return ret;
175
176 if(*val) x509_name_ex_free(val, NULL);
177 if(!x509_name_ex_new((ASN1_VALUE **)&nm, NULL)) goto err;
178 /* We've decoded it: now cache encoding */
179 if(!BUF_MEM_grow(nm->bytes, p - q)) goto err;
180 memcpy(nm->bytes->data, q, p - q);
181
182 /* Convert internal representation to X509_NAME structure */
183 for(i = 0; i < sk_num(intname); i++) {
184 entries = (STACK_OF(X509_NAME_ENTRY) *)sk_value(intname, i);
185 for(j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) {
186 entry = sk_X509_NAME_ENTRY_value(entries, j);
187 entry->set = i;
188 if(!sk_X509_NAME_ENTRY_push(nm->entries, entry))
189 goto err;
223 } 190 }
224 191 sk_X509_NAME_ENTRY_free(entries);
225 i=(int)(c.p-orig);
226 if (!BUF_MEM_grow(ret->bytes,i)) goto err;
227 memcpy(ret->bytes->data,orig,i);
228 ret->bytes->length=i;
229 ret->modified=0;
230
231 M_ASN1_D2I_Finish(a,X509_NAME_free,ASN1_F_D2I_X509_NAME);
232 } 192 }
233 193 sk_free(intname);
234X509_NAME *X509_NAME_new() 194 nm->modified = 0;
235 { 195 *val = (ASN1_VALUE *)nm;
236 X509_NAME *ret=NULL; 196 *in = p;
237 197 return ret;
238 M_ASN1_New_Malloc(ret,X509_NAME); 198 err:
239 if ((ret->entries=sk_new(NULL)) == NULL) goto err2; 199 ASN1err(ASN1_F_D2I_X509_NAME, ERR_R_NESTED_ASN1_ERROR);
240 M_ASN1_New(ret->bytes,BUF_MEM_new); 200 return 0;
241 ret->modified=1; 201}
242 return(ret); 202
243 M_ASN1_New_Error(ASN1_F_X509_NAME_NEW); 203static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass)
204{
205 int ret;
206 X509_NAME *a = (X509_NAME *)*val;
207 if(a->modified) {
208 ret = x509_name_encode((X509_NAME *)a);
209 if(ret < 0) return ret;
244 } 210 }
245 211 ret = a->bytes->length;
246X509_NAME_ENTRY *X509_NAME_ENTRY_new() 212 if(out != NULL) {
247 { 213 memcpy(*out,a->bytes->data,ret);
248 X509_NAME_ENTRY *ret=NULL; 214 *out+=ret;
249
250 M_ASN1_New_Malloc(ret,X509_NAME_ENTRY);
251/* M_ASN1_New(ret->object,ASN1_OBJECT_new);*/
252 ret->object=NULL;
253 ret->set=0;
254 M_ASN1_New(ret->value,ASN1_STRING_new);
255 return(ret);
256 M_ASN1_New_Error(ASN1_F_X509_NAME_ENTRY_NEW);
257 } 215 }
216 return ret;
217}
258 218
259void X509_NAME_free(a) 219static int x509_name_encode(X509_NAME *a)
260X509_NAME *a; 220{
261 { 221 STACK *intname = NULL;
262 BUF_MEM_free(a->bytes); 222 int len;
263 sk_pop_free(a->entries,X509_NAME_ENTRY_free); 223 unsigned char *p;
264 Free((char *)a); 224 STACK_OF(X509_NAME_ENTRY) *entries = NULL;
265 } 225 X509_NAME_ENTRY *entry;
266 226 int i, set = -1;
267void X509_NAME_ENTRY_free(a) 227 intname = sk_new_null();
268X509_NAME_ENTRY *a; 228 if(!intname) goto memerr;
269 { 229 for(i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
270 if (a == NULL) return; 230 entry = sk_X509_NAME_ENTRY_value(a->entries, i);
271 ASN1_OBJECT_free(a->object); 231 if(entry->set != set) {
272 ASN1_BIT_STRING_free(a->value); 232 entries = sk_X509_NAME_ENTRY_new_null();
273 Free((char *)a); 233 if(!entries) goto memerr;
234 if(!sk_push(intname, (char *)entries)) goto memerr;
235 set = entry->set;
236 }
237 if(!sk_X509_NAME_ENTRY_push(entries, entry)) goto memerr;
274 } 238 }
275 239 len = ASN1_item_ex_i2d((ASN1_VALUE **)&intname, NULL, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
276int X509_NAME_set(xn,name) 240 if (!BUF_MEM_grow(a->bytes,len)) goto memerr;
277X509_NAME **xn; 241 p=(unsigned char *)a->bytes->data;
278X509_NAME *name; 242 ASN1_item_ex_i2d((ASN1_VALUE **)&intname, &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
243 sk_pop_free(intname, sk_internal_free);
244 a->modified = 0;
245 return len;
246 memerr:
247 sk_pop_free(intname, sk_internal_free);
248 ASN1err(ASN1_F_D2I_X509_NAME, ERR_R_MALLOC_FAILURE);
249 return -1;
250}
251
252
253int X509_NAME_set(X509_NAME **xn, X509_NAME *name)
279 { 254 {
280 X509_NAME *in; 255 X509_NAME *in;
281 256
282 if (*xn == NULL) return(0); 257 if (!xn || !name) return(0);
283 258
284 if (*xn != name) 259 if (*xn != name)
285 { 260 {
@@ -293,3 +268,5 @@ X509_NAME *name;
293 return(*xn != NULL); 268 return(*xn != NULL);
294 } 269 }
295 270
271IMPLEMENT_STACK_OF(X509_NAME_ENTRY)
272IMPLEMENT_ASN1_SET_OF(X509_NAME_ENTRY)
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-16 21:58:30 +0000