grpc 1.69.0 → 1.71.0

data/third_party/boringssl-with-bazel/src/crypto/x509/{x509_vfy.c → x509_vfy.cc}

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <ctype.h>
 #include <limits.h>
@@ -180,261 +138,265 @@ int X509_verify_cert(X509_STORE_CTX *ctx) {
   int j, retry, trust;
   STACK_OF(X509) *sktmp = NULL;
 
-  if (ctx->cert == NULL) {
-    OPENSSL_PUT_ERROR(X509, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
-    ctx->error = X509_V_ERR_INVALID_CALL;
-    return 0;
-  }
-
-  if (ctx->chain != NULL) {
-    // This X509_STORE_CTX has already been used to verify a cert. We
-    // cannot do another one.
-    OPENSSL_PUT_ERROR(X509, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-    ctx->error = X509_V_ERR_INVALID_CALL;
-    return 0;
-  }
-
-  if (ctx->param->flags &
-      (X509_V_FLAG_EXTENDED_CRL_SUPPORT | X509_V_FLAG_USE_DELTAS)) {
-    // We do not support indirect or delta CRLs. The flags still exist for
-    // compatibility with bindings libraries, but to ensure we do not
-    // inadvertently skip a CRL check that the caller expects, fail closed.
-    OPENSSL_PUT_ERROR(X509, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-    ctx->error = X509_V_ERR_INVALID_CALL;
-    return 0;
-  }
-
-  // first we make sure the chain we are going to build is present and that
-  // the first entry is in place
-  ctx->chain = sk_X509_new_null();
-  if (ctx->chain == NULL || !sk_X509_push(ctx->chain, ctx->cert)) {
-    ctx->error = X509_V_ERR_OUT_OF_MEM;
-    goto end;
-  }
-  X509_up_ref(ctx->cert);
-  ctx->last_untrusted = 1;
-
-  // We use a temporary STACK so we can chop and hack at it.
-  if (ctx->untrusted != NULL && (sktmp = sk_X509_dup(ctx->untrusted)) == NULL) {
-    ctx->error = X509_V_ERR_OUT_OF_MEM;
-    goto end;
-  }
-
-  int num = (int)sk_X509_num(ctx->chain);
-  X509 *x = sk_X509_value(ctx->chain, num - 1);
-  // |param->depth| does not include the leaf certificate or the trust anchor,
-  // so the maximum size is 2 more.
-  int max_chain = param->depth >= INT_MAX - 2 ? INT_MAX : param->depth + 2;
-
-  for (;;) {
-    if (num >= max_chain) {
-      // FIXME: If this happens, we should take note of it and, if appropriate,
-      // use the X509_V_ERR_CERT_CHAIN_TOO_LONG error code later.
-      break;
+  {
+    if (ctx->cert == NULL) {
+      OPENSSL_PUT_ERROR(X509, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
+      ctx->error = X509_V_ERR_INVALID_CALL;
+      return 0;
     }
 
-    int is_self_signed;
-    if (!cert_self_signed(x, &is_self_signed)) {
-      ctx->error = X509_V_ERR_INVALID_EXTENSION;
-      goto end;
+    if (ctx->chain != NULL) {
+      // This X509_STORE_CTX has already been used to verify a cert. We
+      // cannot do another one.
+      OPENSSL_PUT_ERROR(X509, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+      ctx->error = X509_V_ERR_INVALID_CALL;
+      return 0;
     }
 
-    // If we are self signed, we break
-    if (is_self_signed) {
-      break;
-    }
-    // If asked see if we can find issuer in trusted store first
-    if (ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) {
-      X509 *issuer = get_trusted_issuer(ctx, x);
-      if (issuer != NULL) {
-        // Free the certificate. It will be picked up again later.
-        X509_free(issuer);
-        break;
-      }
+    if (ctx->param->flags &
+        (X509_V_FLAG_EXTENDED_CRL_SUPPORT | X509_V_FLAG_USE_DELTAS)) {
+      // We do not support indirect or delta CRLs. The flags still exist for
+      // compatibility with bindings libraries, but to ensure we do not
+      // inadvertently skip a CRL check that the caller expects, fail closed.
+      OPENSSL_PUT_ERROR(X509, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+      ctx->error = X509_V_ERR_INVALID_CALL;
+      return 0;
     }
 
-    // If we were passed a cert chain, use it first
-    if (sktmp != NULL) {
-      X509 *issuer = find_issuer(ctx, sktmp, x);
-      if (issuer != NULL) {
-        if (!sk_X509_push(ctx->chain, issuer)) {
-          ctx->error = X509_V_ERR_OUT_OF_MEM;
-          goto end;
-        }
-        X509_up_ref(issuer);
-        (void)sk_X509_delete_ptr(sktmp, issuer);
-        ctx->last_untrusted++;
-        x = issuer;
-        num++;
-        // reparse the full chain for the next one
-        continue;
-      }
+    // first we make sure the chain we are going to build is present and that
+    // the first entry is in place
+    ctx->chain = sk_X509_new_null();
+    if (ctx->chain == NULL || !sk_X509_push(ctx->chain, ctx->cert)) {
+      ctx->error = X509_V_ERR_OUT_OF_MEM;
+      goto end;
     }
-    break;
-  }
+    X509_up_ref(ctx->cert);
+    ctx->last_untrusted = 1;
 
-  // Remember how many untrusted certs we have
-  j = num;
-  // at this point, chain should contain a list of untrusted certificates.
-  // We now need to add at least one trusted one, if possible, otherwise we
-  // complain.
-
-  do {
-    // Examine last certificate in chain and see if it is self signed.
-    i = (int)sk_X509_num(ctx->chain);
-    x = sk_X509_value(ctx->chain, i - 1);
-
-    int is_self_signed;
-    if (!cert_self_signed(x, &is_self_signed)) {
-      ctx->error = X509_V_ERR_INVALID_EXTENSION;
+    // We use a temporary STACK so we can chop and hack at it.
+    if (ctx->untrusted != NULL &&
+        (sktmp = sk_X509_dup(ctx->untrusted)) == NULL) {
+      ctx->error = X509_V_ERR_OUT_OF_MEM;
       goto end;
     }
 
-    if (is_self_signed) {
-      // we have a self signed certificate
-      if (sk_X509_num(ctx->chain) == 1) {
-        // We have a single self signed certificate: see if we can
-        // find it in the store. We must have an exact match to avoid
-        // possible impersonation.
-        X509 *issuer = get_trusted_issuer(ctx, x);
-        if (issuer == NULL || X509_cmp(x, issuer) != 0) {
-          X509_free(issuer);
-          ctx->error = X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;
-          ctx->current_cert = x;
-          ctx->error_depth = i - 1;
-          bad_chain = 1;
-          if (!call_verify_cb(0, ctx)) {
-            goto end;
-          }
-        } else {
-          // We have a match: replace certificate with store
-          // version so we get any trust settings.
-          X509_free(x);
-          x = issuer;
-          (void)sk_X509_set(ctx->chain, i - 1, x);
-          ctx->last_untrusted = 0;
-        }
-      } else {
-        // extract and save self signed certificate for later use
-        chain_ss = sk_X509_pop(ctx->chain);
-        ctx->last_untrusted--;
-        num--;
-        j--;
-        x = sk_X509_value(ctx->chain, num - 1);
-      }
-    }
-    // We now lookup certs from the certificate store
+    int num = (int)sk_X509_num(ctx->chain);
+    X509 *x = sk_X509_value(ctx->chain, num - 1);
+    // |param->depth| does not include the leaf certificate or the trust anchor,
+    // so the maximum size is 2 more.
+    int max_chain = param->depth >= INT_MAX - 2 ? INT_MAX : param->depth + 2;
+
     for (;;) {
       if (num >= max_chain) {
         // FIXME: If this happens, we should take note of it and, if
         // appropriate, use the X509_V_ERR_CERT_CHAIN_TOO_LONG error code later.
         break;
       }
+
+      int is_self_signed;
       if (!cert_self_signed(x, &is_self_signed)) {
         ctx->error = X509_V_ERR_INVALID_EXTENSION;
         goto end;
       }
+
       // If we are self signed, we break
       if (is_self_signed) {
         break;
       }
-      X509 *issuer = get_trusted_issuer(ctx, x);
-      if (issuer == NULL) {
-        break;
+      // If asked see if we can find issuer in trusted store first
+      if (ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) {
+        X509 *issuer = get_trusted_issuer(ctx, x);
+        if (issuer != NULL) {
+          // Free the certificate. It will be picked up again later.
+          X509_free(issuer);
+          break;
+        }
       }
-      x = issuer;
-      if (!sk_X509_push(ctx->chain, x)) {
-        X509_free(issuer);
-        ctx->error = X509_V_ERR_OUT_OF_MEM;
-        goto end;
+
+      // If we were passed a cert chain, use it first
+      if (sktmp != NULL) {
+        X509 *issuer = find_issuer(ctx, sktmp, x);
+        if (issuer != NULL) {
+          if (!sk_X509_push(ctx->chain, issuer)) {
+            ctx->error = X509_V_ERR_OUT_OF_MEM;
+            goto end;
+          }
+          X509_up_ref(issuer);
+          (void)sk_X509_delete_ptr(sktmp, issuer);
+          ctx->last_untrusted++;
+          x = issuer;
+          num++;
+          // reparse the full chain for the next one
+          continue;
+        }
       }
-      num++;
+      break;
     }
 
-    // we now have our chain, lets check it...
-    trust = check_trust(ctx);
+    // Remember how many untrusted certs we have
+    j = num;
+    // at this point, chain should contain a list of untrusted certificates.
+    // We now need to add at least one trusted one, if possible, otherwise we
+    // complain.
 
-    // If explicitly rejected error
-    if (trust == X509_TRUST_REJECTED) {
-      goto end;
-    }
-    // If it's not explicitly trusted then check if there is an alternative
-    // chain that could be used. We only do this if we haven't already
-    // checked via TRUSTED_FIRST and the user hasn't switched off alternate
-    // chain checking
-    retry = 0;
-    if (trust != X509_TRUST_TRUSTED &&
-        !(ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) &&
-        !(ctx->param->flags & X509_V_FLAG_NO_ALT_CHAINS)) {
-      while (j-- > 1) {
-        X509 *issuer =
-            get_trusted_issuer(ctx, sk_X509_value(ctx->chain, j - 1));
-        // Check if we found an alternate chain
-        if (issuer != NULL) {
-          // Free up the found cert we'll add it again later
-          X509_free(issuer);
+    do {
+      // Examine last certificate in chain and see if it is self signed.
+      i = (int)sk_X509_num(ctx->chain);
+      x = sk_X509_value(ctx->chain, i - 1);
+
+      int is_self_signed;
+      if (!cert_self_signed(x, &is_self_signed)) {
+        ctx->error = X509_V_ERR_INVALID_EXTENSION;
+        goto end;
+      }
 
-          // Dump all the certs above this point - we've found an
-          // alternate chain
-          while (num > j) {
-            X509_free(sk_X509_pop(ctx->chain));
-            num--;
+      if (is_self_signed) {
+        // we have a self signed certificate
+        if (sk_X509_num(ctx->chain) == 1) {
+          // We have a single self signed certificate: see if we can
+          // find it in the store. We must have an exact match to avoid
+          // possible impersonation.
+          X509 *issuer = get_trusted_issuer(ctx, x);
+          if (issuer == NULL || X509_cmp(x, issuer) != 0) {
+            X509_free(issuer);
+            ctx->error = X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;
+            ctx->current_cert = x;
+            ctx->error_depth = i - 1;
+            bad_chain = 1;
+            if (!call_verify_cb(0, ctx)) {
+              goto end;
+            }
+          } else {
+            // We have a match: replace certificate with store
+            // version so we get any trust settings.
+            X509_free(x);
+            x = issuer;
+            (void)sk_X509_set(ctx->chain, i - 1, x);
+            ctx->last_untrusted = 0;
           }
-          ctx->last_untrusted = (int)sk_X509_num(ctx->chain);
-          retry = 1;
+        } else {
+          // extract and save self signed certificate for later use
+          chain_ss = sk_X509_pop(ctx->chain);
+          ctx->last_untrusted--;
+          num--;
+          j--;
+          x = sk_X509_value(ctx->chain, num - 1);
+        }
+      }
+      // We now lookup certs from the certificate store
+      for (;;) {
+        if (num >= max_chain) {
+          // FIXME: If this happens, we should take note of it and, if
+          // appropriate, use the X509_V_ERR_CERT_CHAIN_TOO_LONG error code
+          // later.
           break;
         }
+        if (!cert_self_signed(x, &is_self_signed)) {
+          ctx->error = X509_V_ERR_INVALID_EXTENSION;
+          goto end;
+        }
+        // If we are self signed, we break
+        if (is_self_signed) {
+          break;
+        }
+        X509 *issuer = get_trusted_issuer(ctx, x);
+        if (issuer == NULL) {
+          break;
+        }
+        x = issuer;
+        if (!sk_X509_push(ctx->chain, x)) {
+          X509_free(issuer);
+          ctx->error = X509_V_ERR_OUT_OF_MEM;
+          goto end;
+        }
+        num++;
       }
-    }
-  } while (retry);
 
-  // If not explicitly trusted then indicate error unless it's a single
-  // self signed certificate in which case we've indicated an error already
-  // and set bad_chain == 1
-  if (trust != X509_TRUST_TRUSTED && !bad_chain) {
-    if (chain_ss == NULL ||
-        !x509_check_issued_with_callback(ctx, x, chain_ss)) {
-      if (ctx->last_untrusted >= num) {
-        ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;
+      // we now have our chain, lets check it...
+      trust = check_trust(ctx);
+
+      // If explicitly rejected error
+      if (trust == X509_TRUST_REJECTED) {
+        goto end;
+      }
+      // If it's not explicitly trusted then check if there is an alternative
+      // chain that could be used. We only do this if we haven't already
+      // checked via TRUSTED_FIRST and the user hasn't switched off alternate
+      // chain checking
+      retry = 0;
+      if (trust != X509_TRUST_TRUSTED &&
+          !(ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) &&
+          !(ctx->param->flags & X509_V_FLAG_NO_ALT_CHAINS)) {
+        while (j-- > 1) {
+          X509 *issuer =
+              get_trusted_issuer(ctx, sk_X509_value(ctx->chain, j - 1));
+          // Check if we found an alternate chain
+          if (issuer != NULL) {
+            // Free up the found cert we'll add it again later
+            X509_free(issuer);
+
+            // Dump all the certs above this point - we've found an
+            // alternate chain
+            while (num > j) {
+              X509_free(sk_X509_pop(ctx->chain));
+              num--;
+            }
+            ctx->last_untrusted = (int)sk_X509_num(ctx->chain);
+            retry = 1;
+            break;
+          }
+        }
+      }
+    } while (retry);
+
+    // If not explicitly trusted then indicate error unless it's a single
+    // self signed certificate in which case we've indicated an error already
+    // and set bad_chain == 1
+    if (trust != X509_TRUST_TRUSTED && !bad_chain) {
+      if (chain_ss == NULL ||
+          !x509_check_issued_with_callback(ctx, x, chain_ss)) {
+        if (ctx->last_untrusted >= num) {
+          ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;
+        } else {
+          ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
+        }
+        ctx->current_cert = x;
       } else {
-        ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;
+        if (!sk_X509_push(ctx->chain, chain_ss)) {
+          ctx->error = X509_V_ERR_OUT_OF_MEM;
+          goto end;
+        }
+        num++;
+        ctx->last_untrusted = num;
+        ctx->current_cert = chain_ss;
+        ctx->error = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
+        chain_ss = NULL;
       }
-      ctx->current_cert = x;
-    } else {
-      if (!sk_X509_push(ctx->chain, chain_ss)) {
-        ctx->error = X509_V_ERR_OUT_OF_MEM;
+
+      ctx->error_depth = num - 1;
+      bad_chain = 1;
+      if (!call_verify_cb(0, ctx)) {
         goto end;
       }
-      num++;
-      ctx->last_untrusted = num;
-      ctx->current_cert = chain_ss;
-      ctx->error = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
-      chain_ss = NULL;
     }
 
-    ctx->error_depth = num - 1;
-    bad_chain = 1;
-    if (!call_verify_cb(0, ctx)) {
+    // We have the chain complete: now we need to check its purpose
+    if (!check_chain_extensions(ctx) ||  //
+        !check_id(ctx) ||
+        // We check revocation status after copying parameters because they may
+        // be needed for CRL signature verification.
+        !check_revocation(ctx) ||  //
+        !internal_verify(ctx) ||   //
+        !check_name_constraints(ctx) ||
+        // TODO(davidben): Does |check_policy| still need to be conditioned on
+        // |!bad_chain|? DoS concerns have been resolved.
+        (!bad_chain && !check_policy(ctx))) {
       goto end;
     }
-  }
 
-  // We have the chain complete: now we need to check its purpose
-  if (!check_chain_extensions(ctx) ||  //
-      !check_id(ctx) ||
-      // We check revocation status after copying parameters because they may be
-      // needed for CRL signature verification.
-      !check_revocation(ctx) ||  //
-      !internal_verify(ctx) ||   //
-      !check_name_constraints(ctx) ||
-      // TODO(davidben): Does |check_policy| still need to be conditioned on
-      // |!bad_chain|? DoS concerns have been resolved.
-      (!bad_chain && !check_policy(ctx))) {
-    goto end;
+    ok = 1;
   }
 
-  ok = 1;
-
 end:
   sk_X509_free(sktmp);
   X509_free(chain_ss);
@@ -1099,13 +1061,13 @@ static int get_crl(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509 *x) {
   X509 *issuer = NULL;
   int crl_score = 0;
   X509_CRL *crl = NULL;
+  STACK_OF(X509_CRL) *skcrl = NULL;
   if (get_crl_sk(ctx, &crl, &issuer, &crl_score, ctx->crls)) {
     goto done;
   }
 
   // Lookup CRLs from store
-  STACK_OF(X509_CRL) *skcrl =
-      X509_STORE_CTX_get1_crls(ctx, X509_get_issuer_name(x));
+  skcrl = X509_STORE_CTX_get1_crls(ctx, X509_get_issuer_name(x));
 
   // If no CRLs found and a near match from get_crl_sk use that
   if (!skcrl && crl) {
@@ -1117,7 +1079,6 @@ static int get_crl(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509 *x) {
   sk_X509_CRL_pop_free(skcrl, X509_CRL_free);
 
 done:
-
   // If we got any kind of CRL use it and return success
   if (crl) {
     ctx->current_crl_issuer = issuer;
@@ -1515,7 +1476,8 @@ int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust) {
 }
 
 X509_STORE_CTX *X509_STORE_CTX_new(void) {
-  return OPENSSL_zalloc(sizeof(X509_STORE_CTX));
+  return reinterpret_cast<X509_STORE_CTX *>(
+      OPENSSL_zalloc(sizeof(X509_STORE_CTX)));
 }
 
 void X509_STORE_CTX_free(X509_STORE_CTX *ctx) {