crypto/libressl/crypto/x509/pcy_node.c

   1 /* $OpenBSD: pcy_node.c,v 1.1 2020/06/04 15:19:31 jsing Exp $ */
   2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project 2004.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2004 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 <openssl/asn1.h>
  60 #include <openssl/x509.h>
  61 #include <openssl/x509v3.h>
  62
  63 #include "pcy_int.h"
  64
  65 static int
  66 node_cmp(const X509_POLICY_NODE * const *a, const X509_POLICY_NODE * const *b)
  67 {
  68         return OBJ_cmp((*a)->data->valid_policy, (*b)->data->valid_policy);
  69 }
  70
  71 STACK_OF(X509_POLICY_NODE) *
  72 policy_node_cmp_new(void)
  73 {
  74         return sk_X509_POLICY_NODE_new(node_cmp);
  75 }
  76
  77 X509_POLICY_NODE *
  78 tree_find_sk(STACK_OF(X509_POLICY_NODE) *nodes, const ASN1_OBJECT *id)
  79 {
  80         X509_POLICY_DATA n;
  81         X509_POLICY_NODE l;
  82         int idx;
  83
  84         n.valid_policy = (ASN1_OBJECT *)id;
  85         l.data = &n;
  86
  87         idx = sk_X509_POLICY_NODE_find(nodes, &l);
  88         if (idx == -1)
  89                 return NULL;
  90
  91         return sk_X509_POLICY_NODE_value(nodes, idx);
  92 }
  93
  94 X509_POLICY_NODE *
  95 level_find_node(const X509_POLICY_LEVEL *level, const X509_POLICY_NODE *parent,
  96     const ASN1_OBJECT *id)
  97 {
  98         X509_POLICY_NODE *node;
  99         int i;
 100
 101         for (i = 0; i < sk_X509_POLICY_NODE_num(level->nodes); i++) {
 102                 node = sk_X509_POLICY_NODE_value(level->nodes, i);
 103                 if (node->parent == parent) {
 104                         if (!OBJ_cmp(node->data->valid_policy, id))
 105                                 return node;
 106                 }
 107         }
 108         return NULL;
 109 }
 110
 111
 112 int
 113 level_add_node(X509_POLICY_LEVEL *level, const X509_POLICY_DATA *data,
 114     X509_POLICY_NODE *parent, X509_POLICY_TREE *tree, X509_POLICY_NODE **nodep)
 115 {
 116         X509_POLICY_NODE *node = NULL;
 117
 118         if (level) {
 119                 node = malloc(sizeof(X509_POLICY_NODE));
 120                 if (!node)
 121                         goto node_error;
 122                 node->data = data;
 123                 node->parent = parent;
 124                 node->nchild = 0;
 125                 if (OBJ_obj2nid(data->valid_policy) == NID_any_policy) {
 126                         if (level->anyPolicy)
 127                                 goto node_error;
 128                         level->anyPolicy = node;
 129                         if (parent)
 130                                 parent->nchild++;
 131                 } else {
 132
 133                         if (!level->nodes)
 134                                 level->nodes = policy_node_cmp_new();
 135                         if (!level->nodes)
 136                                 goto node_error;
 137                         if (!sk_X509_POLICY_NODE_push(level->nodes, node))
 138                                 goto node_error;
 139                         if (parent)
 140                                 parent->nchild++;
 141                 }
 142         }
 143
 144         if (tree) {
 145                 if (!tree->extra_data)
 146                         tree->extra_data = sk_X509_POLICY_DATA_new_null();
 147                 if (!tree->extra_data)
 148                         goto node_error_cond;
 149                 if (!sk_X509_POLICY_DATA_push(tree->extra_data, data))
 150                         goto node_error_cond;
 151         }
 152
 153         if (nodep)
 154                 *nodep = node;
 155
 156         return 1;
 157
 158 node_error_cond:
 159         if (level)
 160                 node = NULL;
 161 node_error:
 162         policy_node_free(node);
 163         node = NULL;
 164         if (nodep)
 165                 *nodep = node;
 166         return 0;
 167 }
 168
 169 void
 170 policy_node_free(X509_POLICY_NODE *node)
 171 {
 172         free(node);
 173 }
 174
 175 /* See if a policy node matches a policy OID. If mapping enabled look through
 176  * expected policy set otherwise just valid policy.
 177  */
 178
 179 int
 180 policy_node_match(const X509_POLICY_LEVEL *lvl, const X509_POLICY_NODE *node,
 181     const ASN1_OBJECT *oid)
 182 {
 183         int i;
 184         ASN1_OBJECT *policy_oid;
 185         const X509_POLICY_DATA *x = node->data;
 186
 187         if ((lvl->flags & X509_V_FLAG_INHIBIT_MAP) ||
 188             !(x->flags & POLICY_DATA_FLAG_MAP_MASK)) {
 189                 if (!OBJ_cmp(x->valid_policy, oid))
 190                         return 1;
 191                 return 0;
 192         }
 193
 194         for (i = 0; i < sk_ASN1_OBJECT_num(x->expected_policy_set); i++) {
 195                 policy_oid = sk_ASN1_OBJECT_value(x->expected_policy_set, i);
 196                 if (!OBJ_cmp(policy_oid, oid))
 197                         return 1;
 198         }
 199         return 0;
 200 }