crypto/x509/x_x509a.c

   1 /*
   2  * Copyright 1999-2021 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/evp.h>
  13 #include <openssl/asn1t.h>
  14 #include <openssl/x509.h>
  15 #include "crypto/x509.h"
  16
  17 /*
  18  * X509_CERT_AUX routines. These are used to encode additional user
  19  * modifiable data about a certificate. This data is appended to the X509
  20  * encoding when the *_X509_AUX routines are used. This means that the
  21  * "traditional" X509 routines will simply ignore the extra data.
  22  */
  23
  24 static X509_CERT_AUX *aux_get(X509 *x);
  25
  26 ASN1_SEQUENCE(X509_CERT_AUX) = {
  27         ASN1_SEQUENCE_OF_OPT(X509_CERT_AUX, trust, ASN1_OBJECT),
  28         ASN1_IMP_SEQUENCE_OF_OPT(X509_CERT_AUX, reject, ASN1_OBJECT, 0),
  29         ASN1_OPT(X509_CERT_AUX, alias, ASN1_UTF8STRING),
  30         ASN1_OPT(X509_CERT_AUX, keyid, ASN1_OCTET_STRING),
  31         ASN1_IMP_SEQUENCE_OF_OPT(X509_CERT_AUX, other, X509_ALGOR, 1)
  32 } ASN1_SEQUENCE_END(X509_CERT_AUX)
  33
  34 IMPLEMENT_ASN1_FUNCTIONS(X509_CERT_AUX)
  35
  36 int X509_trusted(const X509 *x)
  37 {
  38     return x->aux ? 1 : 0;
  39 }
  40
  41 static X509_CERT_AUX *aux_get(X509 *x)
  42 {
  43     if (x == NULL)
  44         return NULL;
  45     if (x->aux == NULL && (x->aux = X509_CERT_AUX_new()) == NULL)
  46         return NULL;
  47     return x->aux;
  48 }
  49
  50 int X509_alias_set1(X509 *x, const unsigned char *name, int len)
  51 {
  52     X509_CERT_AUX *aux;
  53     if (!name) {
  54         if (!x || !x->aux || !x->aux->alias)
  55             return 1;
  56         ASN1_UTF8STRING_free(x->aux->alias);
  57         x->aux->alias = NULL;
  58         return 1;
  59     }
  60     if ((aux = aux_get(x)) == NULL)
  61         return 0;
  62     if (aux->alias == NULL && (aux->alias = ASN1_UTF8STRING_new()) == NULL)
  63         return 0;
  64     return ASN1_STRING_set(aux->alias, name, len);
  65 }
  66
  67 int X509_keyid_set1(X509 *x, const unsigned char *id, int len)
  68 {
  69     X509_CERT_AUX *aux;
  70     if (!id) {
  71         if (!x || !x->aux || !x->aux->keyid)
  72             return 1;
  73         ASN1_OCTET_STRING_free(x->aux->keyid);
  74         x->aux->keyid = NULL;
  75         return 1;
  76     }
  77     if ((aux = aux_get(x)) == NULL)
  78         return 0;
  79     if (aux->keyid == NULL
  80         && (aux->keyid = ASN1_OCTET_STRING_new()) == NULL)
  81         return 0;
  82     return ASN1_STRING_set(aux->keyid, id, len);
  83 }
  84
  85 unsigned char *X509_alias_get0(X509 *x, int *len)
  86 {
  87     if (!x->aux || !x->aux->alias)
  88         return NULL;
  89     if (len)
  90         *len = x->aux->alias->length;
  91     return x->aux->alias->data;
  92 }
  93
  94 unsigned char *X509_keyid_get0(X509 *x, int *len)
  95 {
  96     if (!x->aux || !x->aux->keyid)
  97         return NULL;
  98     if (len)
  99         *len = x->aux->keyid->length;
 100     return x->aux->keyid->data;
 101 }
 102
 103 int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj)
 104 {
 105     X509_CERT_AUX *aux;
 106     ASN1_OBJECT *objtmp = NULL;
 107     if (obj) {
 108         objtmp = OBJ_dup(obj);
 109         if (!objtmp)
 110             return 0;
 111     }
 112     if ((aux = aux_get(x)) == NULL)
 113         goto err;
 114     if (aux->trust == NULL
 115         && (aux->trust = sk_ASN1_OBJECT_new_null()) == NULL)
 116         goto err;
 117     if (!objtmp || sk_ASN1_OBJECT_push(aux->trust, objtmp))
 118         return 1;
 119  err:
 120     ASN1_OBJECT_free(objtmp);
 121     return 0;
 122 }
 123
 124 int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj)
 125 {
 126     X509_CERT_AUX *aux;
 127     ASN1_OBJECT *objtmp;
 128     int res = 0;
 129
 130     if ((objtmp = OBJ_dup(obj)) == NULL)
 131         return 0;
 132     if ((aux = aux_get(x)) == NULL)
 133         goto err;
 134     if (aux->reject == NULL
 135         && (aux->reject = sk_ASN1_OBJECT_new_null()) == NULL)
 136         goto err;
 137     if (sk_ASN1_OBJECT_push(aux->reject, objtmp) > 0)
 138         res = 1;
 139
 140  err:
 141     if (!res)
 142         ASN1_OBJECT_free(objtmp);
 143     return res;
 144 }
 145
 146 void X509_trust_clear(X509 *x)
 147 {
 148     if (x->aux) {
 149         sk_ASN1_OBJECT_pop_free(x->aux->trust, ASN1_OBJECT_free);
 150         x->aux->trust = NULL;
 151     }
 152 }
 153
 154 void X509_reject_clear(X509 *x)
 155 {
 156     if (x->aux) {
 157         sk_ASN1_OBJECT_pop_free(x->aux->reject, ASN1_OBJECT_free);
 158         x->aux->reject = NULL;
 159     }
 160 }
 161
 162 STACK_OF(ASN1_OBJECT) *X509_get0_trust_objects(X509 *x)
 163 {
 164     if (x->aux != NULL)
 165         return x->aux->trust;
 166     return NULL;
 167 }
 168
 169 STACK_OF(ASN1_OBJECT) *X509_get0_reject_objects(X509 *x)
 170 {
 171     if (x->aux != NULL)
 172         return x->aux->reject;
 173     return NULL;
 174 }