crypto/x509/x509_att.c

   1 /*
   2  * Copyright 1995-2017 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 <openssl/x509v3.h>
  18 #include "x509_local.h"
  19
  20 int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
  21 {
  22     return sk_X509_ATTRIBUTE_num(x);
  23 }
  24
  25 int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
  26                            int lastpos)
  27 {
  28     const ASN1_OBJECT *obj = OBJ_nid2obj(nid);
  29
  30     if (obj == NULL)
  31         return -2;
  32     return X509at_get_attr_by_OBJ(x, obj, lastpos);
  33 }
  34
  35 int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
  36                            const ASN1_OBJECT *obj, int lastpos)
  37 {
  38     int n;
  39     X509_ATTRIBUTE *ex;
  40
  41     if (sk == NULL)
  42         return -1;
  43     lastpos++;
  44     if (lastpos < 0)
  45         lastpos = 0;
  46     n = sk_X509_ATTRIBUTE_num(sk);
  47     for (; lastpos < n; lastpos++) {
  48         ex = sk_X509_ATTRIBUTE_value(sk, lastpos);
  49         if (OBJ_cmp(ex->object, obj) == 0)
  50             return lastpos;
  51     }
  52     return -1;
  53 }
  54
  55 X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
  56 {
  57     if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
  58         return NULL;
  59
  60     return sk_X509_ATTRIBUTE_value(x, loc);
  61 }
  62
  63 X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
  64 {
  65     X509_ATTRIBUTE *ret;
  66
  67     if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
  68         return NULL;
  69     ret = sk_X509_ATTRIBUTE_delete(x, loc);
  70     return ret;
  71 }
  72
  73 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
  74                                            X509_ATTRIBUTE *attr)
  75 {
  76     X509_ATTRIBUTE *new_attr = NULL;
  77     STACK_OF(X509_ATTRIBUTE) *sk = NULL;
  78
  79     if (x == NULL) {
  80         X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
  81         goto err2;
  82     }
  83
  84     if (*x == NULL) {
  85         if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
  86             goto err;
  87     } else
  88         sk = *x;
  89
  90     if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
  91         goto err2;
  92     if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
  93         goto err;
  94     if (*x == NULL)
  95         *x = sk;
  96     return sk;
  97  err:
  98     X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE);
  99  err2:
 100     X509_ATTRIBUTE_free(new_attr);
 101     sk_X509_ATTRIBUTE_free(sk);
 102     return NULL;
 103 }
 104
 105 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
 106                                                   **x, const ASN1_OBJECT *obj,
 107                                                   int type,
 108                                                   const unsigned char *bytes,
 109                                                   int len)
 110 {
 111     X509_ATTRIBUTE *attr;
 112     STACK_OF(X509_ATTRIBUTE) *ret;
 113     attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
 114     if (!attr)
 115         return 0;
 116     ret = X509at_add1_attr(x, attr);
 117     X509_ATTRIBUTE_free(attr);
 118     return ret;
 119 }
 120
 121 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
 122                                                   **x, int nid, int type,
 123                                                   const unsigned char *bytes,
 124                                                   int len)
 125 {
 126     X509_ATTRIBUTE *attr;
 127     STACK_OF(X509_ATTRIBUTE) *ret;
 128     attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
 129     if (!attr)
 130         return 0;
 131     ret = X509at_add1_attr(x, attr);
 132     X509_ATTRIBUTE_free(attr);
 133     return ret;
 134 }
 135
 136 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
 137                                                   **x, const char *attrname,
 138                                                   int type,
 139                                                   const unsigned char *bytes,
 140                                                   int len)
 141 {
 142     X509_ATTRIBUTE *attr;
 143     STACK_OF(X509_ATTRIBUTE) *ret;
 144     attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
 145     if (!attr)
 146         return 0;
 147     ret = X509at_add1_attr(x, attr);
 148     X509_ATTRIBUTE_free(attr);
 149     return ret;
 150 }
 151
 152 void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
 153                               const ASN1_OBJECT *obj, int lastpos, int type)
 154 {
 155     int i;
 156     X509_ATTRIBUTE *at;
 157     i = X509at_get_attr_by_OBJ(x, obj, lastpos);
 158     if (i == -1)
 159         return NULL;
 160     if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
 161         return NULL;
 162     at = X509at_get_attr(x, i);
 163     if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
 164         return NULL;
 165     return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
 166 }
 167
 168 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
 169                                              int atrtype, const void *data,
 170                                              int len)
 171 {
 172     ASN1_OBJECT *obj;
 173     X509_ATTRIBUTE *ret;
 174
 175     obj = OBJ_nid2obj(nid);
 176     if (obj == NULL) {
 177         X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID, X509_R_UNKNOWN_NID);
 178         return NULL;
 179     }
 180     ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len);
 181     if (ret == NULL)
 182         ASN1_OBJECT_free(obj);
 183     return ret;
 184 }
 185
 186 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
 187                                              const ASN1_OBJECT *obj,
 188                                              int atrtype, const void *data,
 189                                              int len)
 190 {
 191     X509_ATTRIBUTE *ret;
 192
 193     if ((attr == NULL) || (*attr == NULL)) {
 194         if ((ret = X509_ATTRIBUTE_new()) == NULL) {
 195             X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,
 196                     ERR_R_MALLOC_FAILURE);
 197             return NULL;
 198         }
 199     } else
 200         ret = *attr;
 201
 202     if (!X509_ATTRIBUTE_set1_object(ret, obj))
 203         goto err;
 204     if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len))
 205         goto err;
 206
 207     if ((attr != NULL) && (*attr == NULL))
 208         *attr = ret;
 209     return ret;
 210  err:
 211     if ((attr == NULL) || (ret != *attr))
 212         X509_ATTRIBUTE_free(ret);
 213     return NULL;
 214 }
 215
 216 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
 217                                              const char *atrname, int type,
 218                                              const unsigned char *bytes,
 219                                              int len)
 220 {
 221     ASN1_OBJECT *obj;
 222     X509_ATTRIBUTE *nattr;
 223
 224     obj = OBJ_txt2obj(atrname, 0);
 225     if (obj == NULL) {
 226         X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
 227                 X509_R_INVALID_FIELD_NAME);
 228         ERR_add_error_data(2, "name=", atrname);
 229         return NULL;
 230     }
 231     nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len);
 232     ASN1_OBJECT_free(obj);
 233     return nattr;
 234 }
 235
 236 int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
 237 {
 238     if ((attr == NULL) || (obj == NULL))
 239         return 0;
 240     ASN1_OBJECT_free(attr->object);
 241     attr->object = OBJ_dup(obj);
 242     return attr->object != NULL;
 243 }
 244
 245 int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
 246                              const void *data, int len)
 247 {
 248     ASN1_TYPE *ttmp = NULL;
 249     ASN1_STRING *stmp = NULL;
 250     int atype = 0;
 251     if (!attr)
 252         return 0;
 253     if (attrtype & MBSTRING_FLAG) {
 254         stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
 255                                       OBJ_obj2nid(attr->object));
 256         if (!stmp) {
 257             X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB);
 258             return 0;
 259         }
 260         atype = stmp->type;
 261     } else if (len != -1) {
 262         if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
 263             goto err;
 264         if (!ASN1_STRING_set(stmp, data, len))
 265             goto err;
 266         atype = attrtype;
 267     }
 268     /*
 269      * This is a bit naughty because the attribute should really have at
 270      * least one value but some types use and zero length SET and require
 271      * this.
 272      */
 273     if (attrtype == 0) {
 274         ASN1_STRING_free(stmp);
 275         return 1;
 276     }
 277     if ((ttmp = ASN1_TYPE_new()) == NULL)
 278         goto err;
 279     if ((len == -1) && !(attrtype & MBSTRING_FLAG)) {
 280         if (!ASN1_TYPE_set1(ttmp, attrtype, data))
 281             goto err;
 282     } else {
 283         ASN1_TYPE_set(ttmp, atype, stmp);
 284         stmp = NULL;
 285     }
 286     if (!sk_ASN1_TYPE_push(attr->set, ttmp))
 287         goto err;
 288     return 1;
 289  err:
 290     X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
 291     ASN1_TYPE_free(ttmp);
 292     ASN1_STRING_free(stmp);
 293     return 0;
 294 }
 295
 296 int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
 297 {
 298     if (attr == NULL)
 299         return 0;
 300     return sk_ASN1_TYPE_num(attr->set);
 301 }
 302
 303 ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
 304 {
 305     if (attr == NULL)
 306         return NULL;
 307     return attr->object;
 308 }
 309
 310 void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
 311                                int atrtype, void *data)
 312 {
 313     ASN1_TYPE *ttmp;
 314     ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
 315     if (!ttmp)
 316         return NULL;
 317     if (atrtype == V_ASN1_BOOLEAN
 318             || atrtype == V_ASN1_NULL
 319             || atrtype != ASN1_TYPE_get(ttmp)) {
 320         X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
 321         return NULL;
 322     }
 323     return ttmp->value.ptr;
 324 }
 325
 326 ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
 327 {
 328     if (attr == NULL)
 329         return NULL;
 330     return sk_ASN1_TYPE_value(attr->set, idx);
 331 }