crypto/x509/x509_set.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 "internal/cryptlib.h"
  12 #include <openssl/asn1.h>
  13 #include <openssl/objects.h>
  14 #include <openssl/evp.h>
  15 #include <openssl/x509.h>
  16 #include <openssl/x509v3.h>
  17 #include "internal/asn1_int.h"
  18 #include "internal/x509_int.h"
  19 #include "x509_lcl.h"
  20
  21 int X509_set_version(X509 *x, long version)
  22 {
  23     if (x == NULL)
  24         return (0);
  25     if (version == 0) {
  26         ASN1_INTEGER_free(x->cert_info.version);
  27         x->cert_info.version = NULL;
  28         return (1);
  29     }
  30     if (x->cert_info.version == NULL) {
  31         if ((x->cert_info.version = ASN1_INTEGER_new()) == NULL)
  32             return (0);
  33     }
  34     return (ASN1_INTEGER_set(x->cert_info.version, version));
  35 }
  36
  37 int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
  38 {
  39     ASN1_INTEGER *in;
  40
  41     if (x == NULL)
  42         return 0;
  43     in = &x->cert_info.serialNumber;
  44     if (in != serial)
  45         return ASN1_STRING_copy(in, serial);
  46     return 1;
  47 }
  48
  49 int X509_set_issuer_name(X509 *x, X509_NAME *name)
  50 {
  51     if (x == NULL)
  52         return (0);
  53     return (X509_NAME_set(&x->cert_info.issuer, name));
  54 }
  55
  56 int X509_set_subject_name(X509 *x, X509_NAME *name)
  57 {
  58     if (x == NULL)
  59         return (0);
  60     return (X509_NAME_set(&x->cert_info.subject, name));
  61 }
  62
  63 int x509_set1_time(ASN1_TIME **ptm, const ASN1_TIME *tm)
  64 {
  65     ASN1_TIME *in;
  66     in = *ptm;
  67     if (in != tm) {
  68         in = ASN1_STRING_dup(tm);
  69         if (in != NULL) {
  70             ASN1_TIME_free(*ptm);
  71             *ptm = in;
  72         }
  73     }
  74     return (in != NULL);
  75 }
  76
  77 int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm)
  78 {
  79     if (x == NULL)
  80         return 0;
  81     return x509_set1_time(&x->cert_info.validity.notBefore, tm);
  82 }
  83
  84 int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm)
  85 {
  86     if (x == NULL)
  87         return 0;
  88     return x509_set1_time(&x->cert_info.validity.notAfter, tm);
  89 }
  90
  91 int X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
  92 {
  93     if (x == NULL)
  94         return (0);
  95     return (X509_PUBKEY_set(&(x->cert_info.key), pkey));
  96 }
  97
  98 int X509_up_ref(X509 *x)
  99 {
 100     int i;
 101
 102     if (CRYPTO_UP_REF(&x->references, &i, x->lock) <= 0)
 103         return 0;
 104
 105     REF_PRINT_COUNT("X509", x);
 106     REF_ASSERT_ISNT(i < 2);
 107     return ((i > 1) ? 1 : 0);
 108 }
 109
 110 long X509_get_version(const X509 *x)
 111 {
 112     return ASN1_INTEGER_get(x->cert_info.version);
 113 }
 114
 115 const ASN1_TIME *X509_get0_notBefore(const X509 *x)
 116 {
 117     return x->cert_info.validity.notBefore;
 118 }
 119
 120 const ASN1_TIME *X509_get0_notAfter(const X509 *x)
 121 {
 122     return x->cert_info.validity.notAfter;
 123 }
 124
 125 ASN1_TIME *X509_getm_notBefore(const X509 *x)
 126 {
 127     return x->cert_info.validity.notBefore;
 128 }
 129
 130 ASN1_TIME *X509_getm_notAfter(const X509 *x)
 131 {
 132     return x->cert_info.validity.notAfter;
 133 }
 134
 135 int X509_get_signature_type(const X509 *x)
 136 {
 137     return EVP_PKEY_type(OBJ_obj2nid(x->sig_alg.algorithm));
 138 }
 139
 140 X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x)
 141 {
 142     return x->cert_info.key;
 143 }
 144
 145 const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x)
 146 {
 147     return x->cert_info.extensions;
 148 }
 149
 150 void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid,
 151                     const ASN1_BIT_STRING **psuid)
 152 {
 153     if (piuid != NULL)
 154         *piuid = x->cert_info.issuerUID;
 155     if (psuid != NULL)
 156         *psuid = x->cert_info.subjectUID;
 157 }
 158
 159 const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x)
 160 {
 161     return &x->cert_info.signature;
 162 }
 163
 164 int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid,
 165                       int *secbits, uint32_t *flags)
 166 {
 167     if (mdnid != NULL)
 168         *mdnid = siginf->mdnid;
 169     if (pknid != NULL)
 170         *pknid = siginf->pknid;
 171     if (secbits != NULL)
 172         *secbits = siginf->secbits;
 173     if (flags != NULL)
 174         *flags = siginf->flags;
 175     return (siginf->flags & X509_SIG_INFO_VALID) != 0;
 176 }
 177
 178 void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid,
 179                        int secbits, uint32_t flags)
 180 {
 181     siginf->mdnid = mdnid;
 182     siginf->pknid = pknid;
 183     siginf->secbits = secbits;
 184     siginf->flags = flags;
 185 }
 186
 187 int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits,
 188                             uint32_t *flags)
 189 {
 190     X509_check_purpose(x, -1, -1);
 191     return X509_SIG_INFO_get(&x->siginf, mdnid, pknid, secbits, flags);
 192 }
 193
 194 static void x509_sig_info_init(X509_SIG_INFO *siginf, const X509_ALGOR *alg,
 195                                const ASN1_STRING *sig)
 196 {
 197     int pknid, mdnid;
 198     const EVP_MD *md;
 199
 200     siginf->mdnid = NID_undef;
 201     siginf->pknid = NID_undef;
 202     siginf->secbits = -1;
 203     siginf->flags = 0;
 204     if (!OBJ_find_sigid_algs(OBJ_obj2nid(alg->algorithm), &mdnid, &pknid)
 205             || pknid == NID_undef)
 206         return;
 207     siginf->pknid = pknid;
 208     if (mdnid == NID_undef) {
 209         /* If we have one, use a custom handler for this algorithm */
 210         const EVP_PKEY_ASN1_METHOD *ameth = EVP_PKEY_asn1_find(NULL, pknid);
 211         if (ameth == NULL || ameth->siginf_set == NULL
 212                 || ameth->siginf_set(siginf, alg, sig) == 0)
 213             return;
 214         siginf->flags |= X509_SIG_INFO_VALID;
 215         return;
 216     }
 217     siginf->flags |= X509_SIG_INFO_VALID;
 218     siginf->mdnid = mdnid;
 219     md = EVP_get_digestbynid(mdnid);
 220     if (md == NULL)
 221         return;
 222     /* Security bits: half number of bits in digest */
 223     siginf->secbits = EVP_MD_size(md) * 4;
 224     switch (mdnid) {
 225         case NID_sha1:
 226         case NID_sha256:
 227         case NID_sha384:
 228         case NID_sha512:
 229         siginf->flags |= X509_SIG_INFO_TLS;
 230     }
 231 }
 232
 233 void x509_init_sig_info(X509 *x)
 234 {
 235     x509_sig_info_init(&x->siginf, &x->sig_alg, &x->signature);
 236 }