crypto/libressl/crypto/asn1/x_algor.c

   1 /* $OpenBSD: x_algor.c,v 1.20 2015/02/11 04:00:39 jsing Exp $ */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project 2000.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <stddef.h>
  60 #include <openssl/x509.h>
  61 #include <openssl/asn1.h>
  62 #include <openssl/asn1t.h>
  63
  64 static const ASN1_TEMPLATE X509_ALGOR_seq_tt[] = {
  65         {
  66                 .offset = offsetof(X509_ALGOR, algorithm),
  67                 .field_name = "algorithm",
  68                 .item = &ASN1_OBJECT_it,
  69         },
  70         {
  71                 .flags = ASN1_TFLG_OPTIONAL,
  72                 .offset = offsetof(X509_ALGOR, parameter),
  73                 .field_name = "parameter",
  74                 .item = &ASN1_ANY_it,
  75         },
  76 };
  77
  78 const ASN1_ITEM X509_ALGOR_it = {
  79         .itype = ASN1_ITYPE_SEQUENCE,
  80         .utype = V_ASN1_SEQUENCE,
  81         .templates = X509_ALGOR_seq_tt,
  82         .tcount = sizeof(X509_ALGOR_seq_tt) / sizeof(ASN1_TEMPLATE),
  83         .size = sizeof(X509_ALGOR),
  84         .sname = "X509_ALGOR",
  85 };
  86
  87 static const ASN1_TEMPLATE X509_ALGORS_item_tt = {
  88         .flags = ASN1_TFLG_SEQUENCE_OF,
  89         .tag = 0,
  90         .offset = 0,
  91         .field_name = "algorithms",
  92         .item = &X509_ALGOR_it,
  93 };
  94
  95 const ASN1_ITEM X509_ALGORS_it = {
  96         .itype = ASN1_ITYPE_PRIMITIVE,
  97         .utype = -1,
  98         .templates = &X509_ALGORS_item_tt,
  99         .tcount = 0,
 100         .funcs = NULL,
 101         .size = 0,
 102         .sname = "X509_ALGORS",
 103 };
 104
 105
 106 X509_ALGOR *
 107 d2i_X509_ALGOR(X509_ALGOR **a, const unsigned char **in, long len)
 108 {
 109         return (X509_ALGOR *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 110             &X509_ALGOR_it);
 111 }
 112
 113 int
 114 i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out)
 115 {
 116         return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGOR_it);
 117 }
 118
 119 X509_ALGOR *
 120 X509_ALGOR_new(void)
 121 {
 122         return (X509_ALGOR *)ASN1_item_new(&X509_ALGOR_it);
 123 }
 124
 125 void
 126 X509_ALGOR_free(X509_ALGOR *a)
 127 {
 128         ASN1_item_free((ASN1_VALUE *)a, &X509_ALGOR_it);
 129 }
 130
 131 X509_ALGORS *
 132 d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len)
 133 {
 134         return (X509_ALGORS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 135             &X509_ALGORS_it);
 136 }
 137
 138 int
 139 i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out)
 140 {
 141         return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGORS_it);
 142 }
 143
 144 X509_ALGOR *
 145 X509_ALGOR_dup(X509_ALGOR *x)
 146 {
 147         return ASN1_item_dup(&X509_ALGOR_it, x);
 148 }
 149
 150 int
 151 X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)
 152 {
 153         if (!alg)
 154                 return 0;
 155         if (ptype != V_ASN1_UNDEF) {
 156                 if (alg->parameter == NULL)
 157                         alg->parameter = ASN1_TYPE_new();
 158                 if (alg->parameter == NULL)
 159                         return 0;
 160         }
 161         if (alg) {
 162                 if (alg->algorithm)
 163                         ASN1_OBJECT_free(alg->algorithm);
 164                 alg->algorithm = aobj;
 165         }
 166         if (ptype == 0)
 167                 return 1;
 168         if (ptype == V_ASN1_UNDEF) {
 169                 if (alg->parameter) {
 170                         ASN1_TYPE_free(alg->parameter);
 171                         alg->parameter = NULL;
 172                 }
 173         } else
 174                 ASN1_TYPE_set(alg->parameter, ptype, pval);
 175         return 1;
 176 }
 177
 178 void
 179 X509_ALGOR_get0(ASN1_OBJECT **paobj, int *pptype, void **ppval,
 180     X509_ALGOR *algor)
 181 {
 182         if (paobj)
 183                 *paobj = algor->algorithm;
 184         if (pptype) {
 185                 if (algor->parameter == NULL) {
 186                         *pptype = V_ASN1_UNDEF;
 187                         return;
 188                 } else
 189                         *pptype = algor->parameter->type;
 190                 if (ppval)
 191                         *ppval = algor->parameter->value.ptr;
 192         }
 193 }
 194
 195 /* Set up an X509_ALGOR DigestAlgorithmIdentifier from an EVP_MD */
 196
 197 void
 198 X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md)
 199 {
 200         int param_type;
 201
 202         if (md->flags & EVP_MD_FLAG_DIGALGID_ABSENT)
 203                 param_type = V_ASN1_UNDEF;
 204         else
 205                 param_type = V_ASN1_NULL;
 206
 207         X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), param_type, NULL);
 208 }
 209
 210 /* Returns 0 if they are equal, != 0 otherwise. */
 211 int
 212 X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b)
 213 {
 214         int rv = OBJ_cmp(a->algorithm, b->algorithm);
 215         if (!rv) {
 216                 if (!a->parameter && !b->parameter)
 217                         rv = 0;
 218                 else
 219                         rv = ASN1_TYPE_cmp(a->parameter, b->parameter);
 220         }
 221         return(rv);
 222 }