crypto/x509/x509_v3.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 <openssl/stack.h>
  12 #include "internal/cryptlib.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_lcl.h"
  19
  20 int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x)
  21 {
  22     if (x == NULL)
  23         return (0);
  24     return (sk_X509_EXTENSION_num(x));
  25 }
  26
  27 int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid,
  28                           int lastpos)
  29 {
  30     ASN1_OBJECT *obj;
  31
  32     obj = OBJ_nid2obj(nid);
  33     if (obj == NULL)
  34         return (-2);
  35     return (X509v3_get_ext_by_OBJ(x, obj, lastpos));
  36 }
  37
  38 int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
  39                           ASN1_OBJECT *obj, int lastpos)
  40 {
  41     int n;
  42     X509_EXTENSION *ex;
  43
  44     if (sk == NULL)
  45         return (-1);
  46     lastpos++;
  47     if (lastpos < 0)
  48         lastpos = 0;
  49     n = sk_X509_EXTENSION_num(sk);
  50     for (; lastpos < n; lastpos++) {
  51         ex = sk_X509_EXTENSION_value(sk, lastpos);
  52         if (OBJ_cmp(ex->object, obj) == 0)
  53             return (lastpos);
  54     }
  55     return (-1);
  56 }
  57
  58 int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
  59                                int lastpos)
  60 {
  61     int n;
  62     X509_EXTENSION *ex;
  63
  64     if (sk == NULL)
  65         return (-1);
  66     lastpos++;
  67     if (lastpos < 0)
  68         lastpos = 0;
  69     n = sk_X509_EXTENSION_num(sk);
  70     for (; lastpos < n; lastpos++) {
  71         ex = sk_X509_EXTENSION_value(sk, lastpos);
  72         if (((ex->critical > 0) && crit) || ((ex->critical <= 0) && !crit))
  73             return (lastpos);
  74     }
  75     return (-1);
  76 }
  77
  78 X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc)
  79 {
  80     if (x == NULL || sk_X509_EXTENSION_num(x) <= loc || loc < 0)
  81         return NULL;
  82     else
  83         return sk_X509_EXTENSION_value(x, loc);
  84 }
  85
  86 X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc)
  87 {
  88     X509_EXTENSION *ret;
  89
  90     if (x == NULL || sk_X509_EXTENSION_num(x) <= loc || loc < 0)
  91         return (NULL);
  92     ret = sk_X509_EXTENSION_delete(x, loc);
  93     return (ret);
  94 }
  95
  96 STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
  97                                          X509_EXTENSION *ex, int loc)
  98 {
  99     X509_EXTENSION *new_ex = NULL;
 100     int n;
 101     STACK_OF(X509_EXTENSION) *sk = NULL;
 102
 103     if (x == NULL) {
 104         X509err(X509_F_X509V3_ADD_EXT, ERR_R_PASSED_NULL_PARAMETER);
 105         goto err2;
 106     }
 107
 108     if (*x == NULL) {
 109         if ((sk = sk_X509_EXTENSION_new_null()) == NULL)
 110             goto err;
 111     } else
 112         sk = *x;
 113
 114     n = sk_X509_EXTENSION_num(sk);
 115     if (loc > n)
 116         loc = n;
 117     else if (loc < 0)
 118         loc = n;
 119
 120     if ((new_ex = X509_EXTENSION_dup(ex)) == NULL)
 121         goto err2;
 122     if (!sk_X509_EXTENSION_insert(sk, new_ex, loc))
 123         goto err;
 124     if (*x == NULL)
 125         *x = sk;
 126     return (sk);
 127  err:
 128     X509err(X509_F_X509V3_ADD_EXT, ERR_R_MALLOC_FAILURE);
 129  err2:
 130     X509_EXTENSION_free(new_ex);
 131     sk_X509_EXTENSION_free(sk);
 132     return (NULL);
 133 }
 134
 135 X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid,
 136                                              int crit,
 137                                              ASN1_OCTET_STRING *data)
 138 {
 139     ASN1_OBJECT *obj;
 140     X509_EXTENSION *ret;
 141
 142     obj = OBJ_nid2obj(nid);
 143     if (obj == NULL) {
 144         X509err(X509_F_X509_EXTENSION_CREATE_BY_NID, X509_R_UNKNOWN_NID);
 145         return (NULL);
 146     }
 147     ret = X509_EXTENSION_create_by_OBJ(ex, obj, crit, data);
 148     if (ret == NULL)
 149         ASN1_OBJECT_free(obj);
 150     return (ret);
 151 }
 152
 153 X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
 154                                              ASN1_OBJECT *obj, int crit,
 155                                              ASN1_OCTET_STRING *data)
 156 {
 157     X509_EXTENSION *ret;
 158
 159     if ((ex == NULL) || (*ex == NULL)) {
 160         if ((ret = X509_EXTENSION_new()) == NULL) {
 161             X509err(X509_F_X509_EXTENSION_CREATE_BY_OBJ,
 162                     ERR_R_MALLOC_FAILURE);
 163             return (NULL);
 164         }
 165     } else
 166         ret = *ex;
 167
 168     if (!X509_EXTENSION_set_object(ret, obj))
 169         goto err;
 170     if (!X509_EXTENSION_set_critical(ret, crit))
 171         goto err;
 172     if (!X509_EXTENSION_set_data(ret, data))
 173         goto err;
 174
 175     if ((ex != NULL) && (*ex == NULL))
 176         *ex = ret;
 177     return (ret);
 178  err:
 179     if ((ex == NULL) || (ret != *ex))
 180         X509_EXTENSION_free(ret);
 181     return (NULL);
 182 }
 183
 184 int X509_EXTENSION_set_object(X509_EXTENSION *ex, ASN1_OBJECT *obj)
 185 {
 186     if ((ex == NULL) || (obj == NULL))
 187         return (0);
 188     ASN1_OBJECT_free(ex->object);
 189     ex->object = OBJ_dup(obj);
 190     return ex->object != NULL;
 191 }
 192
 193 int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
 194 {
 195     if (ex == NULL)
 196         return (0);
 197     ex->critical = (crit) ? 0xFF : -1;
 198     return (1);
 199 }
 200
 201 int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
 202 {
 203     int i;
 204
 205     if (ex == NULL)
 206         return (0);
 207     i = ASN1_OCTET_STRING_set(&ex->value, data->data, data->length);
 208     if (!i)
 209         return (0);
 210     return (1);
 211 }
 212
 213 ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex)
 214 {
 215     if (ex == NULL)
 216         return (NULL);
 217     return (ex->object);
 218 }
 219
 220 ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ex)
 221 {
 222     if (ex == NULL)
 223         return (NULL);
 224     return &ex->value;
 225 }
 226
 227 int X509_EXTENSION_get_critical(X509_EXTENSION *ex)
 228 {
 229     if (ex == NULL)
 230         return (0);
 231     if (ex->critical > 0)
 232         return 1;
 233     return 0;
 234 }