crypto/x509/x509name.c

   1 /*
   2  * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/safestack.h>
  13 #include <openssl/asn1.h>
  14 #include <openssl/objects.h>
  15 #include <openssl/evp.h>
  16 #include <openssl/x509.h>
  17 #include "crypto/x509.h"
  18
  19 int X509_NAME_get_text_by_NID(const X509_NAME *name, int nid,
  20                               char *buf, int len)
  21 {
  22     ASN1_OBJECT *obj;
  23
  24     obj = OBJ_nid2obj(nid);
  25     if (obj == NULL)
  26         return -1;
  27     return X509_NAME_get_text_by_OBJ(name, obj, buf, len);
  28 }
  29
  30 int X509_NAME_get_text_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
  31                               char *buf, int len)
  32 {
  33     int i;
  34     const ASN1_STRING *data;
  35
  36     i = X509_NAME_get_index_by_OBJ(name, obj, -1);
  37     if (i < 0)
  38         return -1;
  39     data = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, i));
  40     if (buf == NULL)
  41         return data->length;
  42     if (len <= 0)
  43         return 0;
  44     i = (data->length > (len - 1)) ? (len - 1) : data->length;
  45     memcpy(buf, data->data, i);
  46     buf[i] = '\0';
  47     return i;
  48 }
  49
  50 int X509_NAME_entry_count(const X509_NAME *name)
  51 {
  52     if (name == NULL)
  53         return 0;
  54     return sk_X509_NAME_ENTRY_num(name->entries);
  55 }
  56
  57 int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos)
  58 {
  59     ASN1_OBJECT *obj;
  60
  61     obj = OBJ_nid2obj(nid);
  62     if (obj == NULL)
  63         return -2;
  64     return X509_NAME_get_index_by_OBJ(name, obj, lastpos);
  65 }
  66
  67 /* NOTE: you should be passing -1, not 0 as lastpos */
  68 int X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
  69                                int lastpos)
  70 {
  71     int n;
  72     X509_NAME_ENTRY *ne;
  73     STACK_OF(X509_NAME_ENTRY) *sk;
  74
  75     if (name == NULL)
  76         return -1;
  77     if (lastpos < 0)
  78         lastpos = -1;
  79     sk = name->entries;
  80     n = sk_X509_NAME_ENTRY_num(sk);
  81     for (lastpos++; lastpos < n; lastpos++) {
  82         ne = sk_X509_NAME_ENTRY_value(sk, lastpos);
  83         if (OBJ_cmp(ne->object, obj) == 0)
  84             return lastpos;
  85     }
  86     return -1;
  87 }
  88
  89 X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc)
  90 {
  91     if (name == NULL || sk_X509_NAME_ENTRY_num(name->entries) <= loc
  92         || loc < 0)
  93         return NULL;
  94
  95     return sk_X509_NAME_ENTRY_value(name->entries, loc);
  96 }
  97
  98 X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc)
  99 {
 100     X509_NAME_ENTRY *ret;
 101     int i, n, set_prev, set_next;
 102     STACK_OF(X509_NAME_ENTRY) *sk;
 103
 104     if (name == NULL || sk_X509_NAME_ENTRY_num(name->entries) <= loc
 105         || loc < 0)
 106         return NULL;
 107
 108     sk = name->entries;
 109     ret = sk_X509_NAME_ENTRY_delete(sk, loc);
 110     n = sk_X509_NAME_ENTRY_num(sk);
 111     name->modified = 1;
 112     if (loc == n)
 113         return ret;
 114
 115     /* else we need to fixup the set field */
 116     if (loc != 0)
 117         set_prev = (sk_X509_NAME_ENTRY_value(sk, loc - 1))->set;
 118     else
 119         set_prev = ret->set - 1;
 120     set_next = sk_X509_NAME_ENTRY_value(sk, loc)->set;
 121
 122     /*-
 123      * set_prev is the previous set
 124      * set is the current set
 125      * set_next is the following
 126      * prev  1 1    1 1     1 1     1 1
 127      * set   1      1       2       2
 128      * next  1 1    2 2     2 2     3 2
 129      * so basically only if prev and next differ by 2, then
 130      * re-number down by 1
 131      */
 132     if (set_prev + 1 < set_next)
 133         for (i = loc; i < n; i++)
 134             sk_X509_NAME_ENTRY_value(sk, i)->set--;
 135     return ret;
 136 }
 137
 138 int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
 139                                const unsigned char *bytes, int len, int loc,
 140                                int set)
 141 {
 142     X509_NAME_ENTRY *ne;
 143     int ret;
 144
 145     ne = X509_NAME_ENTRY_create_by_OBJ(NULL, obj, type, bytes, len);
 146     if (!ne)
 147         return 0;
 148     ret = X509_NAME_add_entry(name, ne, loc, set);
 149     X509_NAME_ENTRY_free(ne);
 150     return ret;
 151 }
 152
 153 int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
 154                                const unsigned char *bytes, int len, int loc,
 155                                int set)
 156 {
 157     X509_NAME_ENTRY *ne;
 158     int ret;
 159     ne = X509_NAME_ENTRY_create_by_NID(NULL, nid, type, bytes, len);
 160     if (!ne)
 161         return 0;
 162     ret = X509_NAME_add_entry(name, ne, loc, set);
 163     X509_NAME_ENTRY_free(ne);
 164     return ret;
 165 }
 166
 167 int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
 168                                const unsigned char *bytes, int len, int loc,
 169                                int set)
 170 {
 171     X509_NAME_ENTRY *ne;
 172     int ret;
 173     ne = X509_NAME_ENTRY_create_by_txt(NULL, field, type, bytes, len);
 174     if (!ne)
 175         return 0;
 176     ret = X509_NAME_add_entry(name, ne, loc, set);
 177     X509_NAME_ENTRY_free(ne);
 178     return ret;
 179 }
 180
 181 /*
 182  * if set is -1, append to previous set, 0 'a new one', and 1, prepend to the
 183  * guy we are about to stomp on.
 184  */
 185 int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne, int loc,
 186                         int set)
 187 {
 188     X509_NAME_ENTRY *new_name = NULL;
 189     int n, i, inc;
 190     STACK_OF(X509_NAME_ENTRY) *sk;
 191
 192     if (name == NULL)
 193         return 0;
 194     sk = name->entries;
 195     n = sk_X509_NAME_ENTRY_num(sk);
 196     if (loc > n)
 197         loc = n;
 198     else if (loc < 0)
 199         loc = n;
 200     inc = (set == 0);
 201     name->modified = 1;
 202
 203     if (set == -1) {
 204         if (loc == 0) {
 205             set = 0;
 206             inc = 1;
 207         } else {
 208             set = sk_X509_NAME_ENTRY_value(sk, loc - 1)->set;
 209         }
 210     } else {                    /* if (set >= 0) */
 211
 212         if (loc >= n) {
 213             if (loc != 0)
 214                 set = sk_X509_NAME_ENTRY_value(sk, loc - 1)->set + 1;
 215             else
 216                 set = 0;
 217         } else
 218             set = sk_X509_NAME_ENTRY_value(sk, loc)->set;
 219     }
 220
 221     if ((new_name = X509_NAME_ENTRY_dup(ne)) == NULL)
 222         goto err;
 223     new_name->set = set;
 224     if (!sk_X509_NAME_ENTRY_insert(sk, new_name, loc)) {
 225         ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
 226         goto err;
 227     }
 228     if (inc) {
 229         n = sk_X509_NAME_ENTRY_num(sk);
 230         for (i = loc + 1; i < n; i++)
 231             sk_X509_NAME_ENTRY_value(sk, i)->set += 1;
 232     }
 233     return 1;
 234  err:
 235     X509_NAME_ENTRY_free(new_name);
 236     return 0;
 237 }
 238
 239 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
 240                                                const char *field, int type,
 241                                                const unsigned char *bytes,
 242                                                int len)
 243 {
 244     ASN1_OBJECT *obj;
 245     X509_NAME_ENTRY *nentry;
 246
 247     obj = OBJ_txt2obj(field, 0);
 248     if (obj == NULL) {
 249         ERR_raise(ERR_LIB_X509,
 250                 X509_R_INVALID_FIELD_NAME);
 251         ERR_add_error_data(2, "name=", field);
 252         return NULL;
 253     }
 254     nentry = X509_NAME_ENTRY_create_by_OBJ(ne, obj, type, bytes, len);
 255     ASN1_OBJECT_free(obj);
 256     return nentry;
 257 }
 258
 259 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
 260                                                int type,
 261                                                const unsigned char *bytes,
 262                                                int len)
 263 {
 264     ASN1_OBJECT *obj;
 265     X509_NAME_ENTRY *nentry;
 266
 267     obj = OBJ_nid2obj(nid);
 268     if (obj == NULL) {
 269         ERR_raise(ERR_LIB_X509, X509_R_UNKNOWN_NID);
 270         return NULL;
 271     }
 272     nentry = X509_NAME_ENTRY_create_by_OBJ(ne, obj, type, bytes, len);
 273     ASN1_OBJECT_free(obj);
 274     return nentry;
 275 }
 276
 277 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
 278                                                const ASN1_OBJECT *obj, int type,
 279                                                const unsigned char *bytes,
 280                                                int len)
 281 {
 282     X509_NAME_ENTRY *ret;
 283
 284     if ((ne == NULL) || (*ne == NULL)) {
 285         if ((ret = X509_NAME_ENTRY_new()) == NULL)
 286             return NULL;
 287     } else
 288         ret = *ne;
 289
 290     if (!X509_NAME_ENTRY_set_object(ret, obj))
 291         goto err;
 292     if (!X509_NAME_ENTRY_set_data(ret, type, bytes, len))
 293         goto err;
 294
 295     if ((ne != NULL) && (*ne == NULL))
 296         *ne = ret;
 297     return ret;
 298  err:
 299     if ((ne == NULL) || (ret != *ne))
 300         X509_NAME_ENTRY_free(ret);
 301     return NULL;
 302 }
 303
 304 int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj)
 305 {
 306     if ((ne == NULL) || (obj == NULL)) {
 307         ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER);
 308         return 0;
 309     }
 310     ASN1_OBJECT_free(ne->object);
 311     ne->object = OBJ_dup(obj);
 312     return ((ne->object == NULL) ? 0 : 1);
 313 }
 314
 315 int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
 316                              const unsigned char *bytes, int len)
 317 {
 318     int i;
 319
 320     if ((ne == NULL) || ((bytes == NULL) && (len != 0)))
 321         return 0;
 322     if ((type > 0) && (type & MBSTRING_FLAG))
 323         return ASN1_STRING_set_by_NID(&ne->value, bytes,
 324                                       len, type,
 325                                       OBJ_obj2nid(ne->object)) ? 1 : 0;
 326     if (len < 0)
 327         len = strlen((const char *)bytes);
 328     i = ASN1_STRING_set(ne->value, bytes, len);
 329     if (!i)
 330         return 0;
 331     if (type != V_ASN1_UNDEF) {
 332         if (type == V_ASN1_APP_CHOOSE)
 333             ne->value->type = ASN1_PRINTABLE_type(bytes, len);
 334         else
 335             ne->value->type = type;
 336     }
 337     return 1;
 338 }
 339
 340 ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne)
 341 {
 342     if (ne == NULL)
 343         return NULL;
 344     return ne->object;
 345 }
 346
 347 ASN1_STRING *X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne)
 348 {
 349     if (ne == NULL)
 350         return NULL;
 351     return ne->value;
 352 }
 353
 354 int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)
 355 {
 356     return ne->set;
 357 }