crypto/cmp/cmp_hdr.c

   1 /*
   2  * Copyright 2007-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright Nokia 2007-2019
   4  * Copyright Siemens AG 2015-2019
   5  *
   6  * Licensed under the Apache License 2.0 (the "License").  You may not use
   7  * this file except in compliance with the License.  You can obtain a copy
   8  * in the file LICENSE in the source distribution or at
   9  * https://www.openssl.org/source/license.html
  10  */
  11
  12 /* CMP functions for PKIHeader handling */
  13
  14 #include "cmp_local.h"
  15
  16 #include <openssl/rand.h>
  17
  18 /* explicit #includes not strictly needed since implied by the above: */
  19 #include <openssl/asn1t.h>
  20 #include <openssl/cmp.h>
  21 #include <openssl/err.h>
  22
  23 DEFINE_STACK_OF(ASN1_UTF8STRING)
  24 DEFINE_STACK_OF(OSSL_CMP_ITAV)
  25
  26 int ossl_cmp_hdr_set_pvno(OSSL_CMP_PKIHEADER *hdr, int pvno)
  27 {
  28     if (!ossl_assert(hdr != NULL))
  29         return 0;
  30     return ASN1_INTEGER_set(hdr->pvno, pvno);
  31 }
  32
  33 int ossl_cmp_hdr_get_pvno(const OSSL_CMP_PKIHEADER *hdr)
  34 {
  35     int64_t pvno;
  36
  37     if (!ossl_assert(hdr != NULL))
  38         return -1;
  39     if (!ASN1_INTEGER_get_int64(&pvno, hdr->pvno) || pvno < 0 || pvno > INT_MAX)
  40         return -1;
  41     return (int)pvno;
  42 }
  43
  44 int ossl_cmp_hdr_get_protection_nid(const OSSL_CMP_PKIHEADER *hdr)
  45 {
  46     if (!ossl_assert(hdr != NULL)
  47             || hdr->protectionAlg == NULL)
  48         return NID_undef;
  49     return OBJ_obj2nid(hdr->protectionAlg->algorithm);
  50 }
  51
  52 ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_transactionID(const
  53                                                    OSSL_CMP_PKIHEADER *hdr)
  54 {
  55     if (hdr == NULL) {
  56         CMPerr(0, CMP_R_NULL_ARGUMENT);
  57         return NULL;
  58     }
  59     return hdr->transactionID;
  60 }
  61
  62 ASN1_OCTET_STRING *ossl_cmp_hdr_get0_senderNonce(const OSSL_CMP_PKIHEADER *hdr)
  63 {
  64     if (!ossl_assert(hdr != NULL))
  65         return NULL;
  66     return hdr->senderNonce;
  67 }
  68
  69 ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER *hdr)
  70 {
  71     if (hdr == NULL) {
  72         CMPerr(0, CMP_R_NULL_ARGUMENT);
  73         return NULL;
  74     }
  75     return hdr->recipNonce;
  76 }
  77
  78 int ossl_cmp_general_name_is_NULL_DN(GENERAL_NAME *name)
  79 {
  80     X509_NAME *null = X509_NAME_new();
  81     int res = name == NULL || null == NULL
  82         || (name->type == GEN_DIRNAME
  83                 && X509_NAME_cmp(name->d.directoryName, null) == 0);
  84
  85     X509_NAME_free(null);
  86     return res;
  87 }
  88
  89 /* assign to *tgt a copy of src (which may be NULL to indicate an empty DN) */
  90 static int set1_general_name(GENERAL_NAME **tgt, const X509_NAME *src)
  91 {
  92     GENERAL_NAME *name;
  93
  94     if (!ossl_assert(tgt != NULL))
  95         return 0;
  96     if ((name = GENERAL_NAME_new()) == NULL)
  97         goto err;
  98     name->type = GEN_DIRNAME;
  99
 100     if (src == NULL) { /* NULL-DN */
 101         if ((name->d.directoryName = X509_NAME_new()) == NULL)
 102             goto err;
 103     } else if (!X509_NAME_set(&name->d.directoryName, src)) {
 104         goto err;
 105     }
 106
 107     GENERAL_NAME_free(*tgt);
 108     *tgt = name;
 109
 110     return 1;
 111
 112  err:
 113     GENERAL_NAME_free(name);
 114     return 0;
 115 }
 116
 117 /*
 118  * Set the sender name in PKIHeader.
 119  * when nm is NULL, sender is set to an empty string
 120  * returns 1 on success, 0 on error
 121  */
 122 int ossl_cmp_hdr_set1_sender(OSSL_CMP_PKIHEADER *hdr, const X509_NAME *nm)
 123 {
 124     if (!ossl_assert(hdr != NULL))
 125         return 0;
 126     return set1_general_name(&hdr->sender, nm);
 127 }
 128
 129 int ossl_cmp_hdr_set1_recipient(OSSL_CMP_PKIHEADER *hdr, const X509_NAME *nm)
 130 {
 131     if (!ossl_assert(hdr != NULL))
 132         return 0;
 133     return set1_general_name(&hdr->recipient, nm);
 134 }
 135
 136 int ossl_cmp_hdr_update_messageTime(OSSL_CMP_PKIHEADER *hdr)
 137 {
 138     if (!ossl_assert(hdr != NULL))
 139         return 0;
 140     if (hdr->messageTime == NULL
 141             && (hdr->messageTime = ASN1_GENERALIZEDTIME_new()) == NULL)
 142         return 0;
 143     return ASN1_GENERALIZEDTIME_set(hdr->messageTime, time(NULL)) != NULL;
 144 }
 145
 146 /* assign to *tgt a copy of src (or if NULL a random byte array of given len) */
 147 static int set1_aostr_else_random(ASN1_OCTET_STRING **tgt,
 148                                   const ASN1_OCTET_STRING *src, size_t len)
 149 {
 150     unsigned char *bytes = NULL;
 151     int res = 0;
 152
 153     if (src == NULL) { /* generate a random value if src == NULL */
 154         if ((bytes = OPENSSL_malloc(len)) == NULL)
 155             goto err;
 156         if (RAND_bytes(bytes, len) <= 0) {
 157             CMPerr(0, CMP_R_FAILURE_OBTAINING_RANDOM);
 158             goto err;
 159         }
 160         res = ossl_cmp_asn1_octet_string_set1_bytes(tgt, bytes, len);
 161     } else {
 162         res = ossl_cmp_asn1_octet_string_set1(tgt, src);
 163     }
 164
 165  err:
 166     OPENSSL_free(bytes);
 167     return res;
 168 }
 169
 170 int ossl_cmp_hdr_set1_senderKID(OSSL_CMP_PKIHEADER *hdr,
 171                                 const ASN1_OCTET_STRING *senderKID)
 172 {
 173     if (!ossl_assert(hdr != NULL))
 174         return 0;
 175     return ossl_cmp_asn1_octet_string_set1(&hdr->senderKID, senderKID);
 176 }
 177
 178 /* push the given text string to the given PKIFREETEXT ft */
 179 int ossl_cmp_hdr_push0_freeText(OSSL_CMP_PKIHEADER *hdr, ASN1_UTF8STRING *text)
 180 {
 181     if (!ossl_assert(hdr != NULL && text != NULL))
 182         return 0;
 183
 184     if (hdr->freeText == NULL
 185             && (hdr->freeText = sk_ASN1_UTF8STRING_new_null()) == NULL)
 186         return 0;
 187
 188     return sk_ASN1_UTF8STRING_push(hdr->freeText, text);
 189 }
 190
 191 int ossl_cmp_hdr_push1_freeText(OSSL_CMP_PKIHEADER *hdr, ASN1_UTF8STRING *text)
 192 {
 193     if (!ossl_assert(hdr != NULL && text != NULL))
 194         return 0;
 195
 196     if (hdr->freeText == NULL
 197             && (hdr->freeText = sk_ASN1_UTF8STRING_new_null()) == NULL)
 198         return 0;
 199
 200     return
 201         ossl_cmp_sk_ASN1_UTF8STRING_push_str(hdr->freeText, (char *)text->data);
 202 }
 203
 204 int ossl_cmp_hdr_generalInfo_push0_item(OSSL_CMP_PKIHEADER *hdr,
 205                                         OSSL_CMP_ITAV *itav)
 206 {
 207     if (!ossl_assert(hdr != NULL && itav != NULL))
 208         return 0;
 209     return OSSL_CMP_ITAV_push0_stack_item(&hdr->generalInfo, itav);
 210 }
 211
 212 int ossl_cmp_hdr_generalInfo_push1_items(OSSL_CMP_PKIHEADER *hdr,
 213                                          const STACK_OF(OSSL_CMP_ITAV) *itavs)
 214 {
 215     int i;
 216     OSSL_CMP_ITAV *itav;
 217
 218     if (!ossl_assert(hdr != NULL))
 219         return 0;
 220
 221     for (i = 0; i < sk_OSSL_CMP_ITAV_num(itavs); i++) {
 222         itav = OSSL_CMP_ITAV_dup(sk_OSSL_CMP_ITAV_value(itavs, i));
 223         if (itav == NULL)
 224             return 0;
 225
 226         if (!ossl_cmp_hdr_generalInfo_push0_item(hdr, itav)) {
 227             OSSL_CMP_ITAV_free(itav);
 228             return 0;
 229         }
 230     }
 231     return 1;
 232 }
 233
 234 int ossl_cmp_hdr_set_implicitConfirm(OSSL_CMP_PKIHEADER *hdr)
 235 {
 236     OSSL_CMP_ITAV *itav;
 237     ASN1_TYPE *asn1null;
 238
 239     if (!ossl_assert(hdr != NULL))
 240         return 0;
 241     asn1null = (ASN1_TYPE *)ASN1_NULL_new();
 242     if (asn1null == NULL)
 243         return 0;
 244     if ((itav = OSSL_CMP_ITAV_create(OBJ_nid2obj(NID_id_it_implicitConfirm),
 245                                      asn1null)) == NULL)
 246         goto err;
 247     if (!ossl_cmp_hdr_generalInfo_push0_item(hdr, itav))
 248         goto err;
 249     return 1;
 250
 251  err:
 252     ASN1_TYPE_free(asn1null);
 253     OSSL_CMP_ITAV_free(itav);
 254     return 0;
 255 }
 256
 257 /* return 1 if implicitConfirm in the generalInfo field of the header is set */
 258 int ossl_cmp_hdr_has_implicitConfirm(const OSSL_CMP_PKIHEADER *hdr)
 259 {
 260     int itavCount;
 261     int i;
 262     OSSL_CMP_ITAV *itav;
 263
 264     if (!ossl_assert(hdr != NULL))
 265         return 0;
 266
 267     itavCount = sk_OSSL_CMP_ITAV_num(hdr->generalInfo);
 268     for (i = 0; i < itavCount; i++) {
 269         itav = sk_OSSL_CMP_ITAV_value(hdr->generalInfo, i);
 270         if (itav != NULL
 271                 && OBJ_obj2nid(itav->infoType) == NID_id_it_implicitConfirm)
 272             return 1;
 273     }
 274
 275     return 0;
 276 }
 277
 278 /*
 279  * set ctx->transactionID in CMP header
 280  * if ctx->transactionID is NULL, a random one is created with 128 bit
 281  * according to section 5.1.1:
 282  *
 283  * It is RECOMMENDED that the clients fill the transactionID field with
 284  * 128 bits of (pseudo-) random data for the start of a transaction to
 285  * reduce the probability of having the transactionID in use at the server.
 286  */
 287 int ossl_cmp_hdr_set_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_PKIHEADER *hdr)
 288 {
 289     if (ctx->transactionID == NULL
 290             && !set1_aostr_else_random(&ctx->transactionID, NULL,
 291                                        OSSL_CMP_TRANSACTIONID_LENGTH))
 292         return 0;
 293     return ossl_cmp_asn1_octet_string_set1(&hdr->transactionID,
 294                                            ctx->transactionID);
 295 }
 296
 297 /* fill in all fields of the hdr according to the info given in ctx */
 298 int ossl_cmp_hdr_init(OSSL_CMP_CTX *ctx, OSSL_CMP_PKIHEADER *hdr)
 299 {
 300     const X509_NAME *sender;
 301     const X509_NAME *rcp = NULL;
 302
 303     if (!ossl_assert(ctx != NULL && hdr != NULL))
 304         return 0;
 305
 306     /* set the CMP version */
 307     if (!ossl_cmp_hdr_set_pvno(hdr, OSSL_CMP_PVNO))
 308         return 0;
 309
 310     /*
 311      * If neither protection cert nor oldCert nor subject are given,
 312      * sender name is not known to the client and thus set to NULL-DN
 313      */
 314     sender = ctx->cert != NULL ? X509_get_subject_name(ctx->cert) :
 315         ctx->oldCert != NULL ? X509_get_subject_name(ctx->oldCert) :
 316         ctx->subjectName;
 317     if (!ossl_cmp_hdr_set1_sender(hdr, sender))
 318         return 0;
 319
 320     /* determine recipient entry in PKIHeader */
 321     if (ctx->recipient != NULL)
 322         rcp = ctx->recipient;
 323     else if (ctx->srvCert != NULL)
 324         rcp = X509_get_subject_name(ctx->srvCert);
 325     else if (ctx->issuer != NULL)
 326         rcp = ctx->issuer;
 327     else if (ctx->oldCert != NULL)
 328         rcp = X509_get_issuer_name(ctx->oldCert);
 329     else if (ctx->cert != NULL)
 330         rcp = X509_get_issuer_name(ctx->cert);
 331     if (!ossl_cmp_hdr_set1_recipient(hdr, rcp))
 332         return 0;
 333
 334     /* set current time as message time */
 335     if (!ossl_cmp_hdr_update_messageTime(hdr))
 336         return 0;
 337
 338     if (ctx->recipNonce != NULL
 339             && !ossl_cmp_asn1_octet_string_set1(&hdr->recipNonce,
 340                                                 ctx->recipNonce))
 341         return 0;
 342
 343     if (!ossl_cmp_hdr_set_transactionID(ctx, hdr))
 344         return 0;
 345
 346     /*-
 347      * set random senderNonce
 348      * according to section 5.1.1:
 349      *
 350      * senderNonce                  present
 351      *         -- 128 (pseudo-)random bits
 352      * The senderNonce and recipNonce fields protect the PKIMessage against
 353      * replay attacks. The senderNonce will typically be 128 bits of
 354      * (pseudo-) random data generated by the sender, whereas the recipNonce
 355      * is copied from the senderNonce of the previous message in the
 356      * transaction.
 357      */
 358     if (!set1_aostr_else_random(&hdr->senderNonce, NULL,
 359                                 OSSL_CMP_SENDERNONCE_LENGTH))
 360         return 0;
 361
 362     /* store senderNonce - for cmp with recipNonce in next outgoing msg */
 363     if (!OSSL_CMP_CTX_set1_senderNonce(ctx, hdr->senderNonce))
 364         return 0;
 365
 366     /*-
 367      * freeText                [7] PKIFreeText OPTIONAL,
 368      * -- this may be used to indicate context-specific instructions
 369      * -- (this field is intended for human consumption)
 370      */
 371     if (ctx->freeText != NULL
 372             && !ossl_cmp_hdr_push1_freeText(hdr, ctx->freeText))
 373         return 0;
 374
 375     return 1;
 376 }