Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/x509v3/v3_asid.c

 /*
  * Contributed to the OpenSSL Project by the American Registry for
  * Internet Numbers ("ARIN").
  */
 /* ====================================================================
  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 43 matching lines @@
  * (eay@cryptsoft.com).  This product includes software written by Tim
  * Hudson (tjh@cryptsoft.com).
  */
 
 /*
  * Implementation of RFC 3779 section 3.2.
  */
 
 #include <stdio.h>
 #include <string.h>
-#include <assert.h>
 #include "cryptlib.h"
 #include <openssl/conf.h>
 #include <openssl/asn1.h>
 #include <openssl/asn1t.h>
 #include <openssl/x509v3.h>
 #include <openssl/x509.h>
 #include <openssl/bn.h>
 
 #ifndef OPENSSL_NO_RFC3779
 
@@ skipping 70 matching lines @@
     break;
   default:
     return 0;
   }
   return 1;
 }
 
 /*
  * i2r method for an ASIdentifier extension.
  */
-static int i2r_ASIdentifiers(X509V3_EXT_METHOD *method,
+static int i2r_ASIdentifiers(const X509V3_EXT_METHOD *method,
                              void *ext,
                              BIO *out,
                              int indent)
 {
   ASIdentifiers *asid = ext;
   return (i2r_ASIdentifierChoice(out, asid->asnum, indent,
                                  "Autonomous System Numbers") &&
           i2r_ASIdentifierChoice(out, asid->rdi, indent,
                                  "Routing Domain Identifiers"));
 }
 
 /*
  * Sort comparision function for a sequence of ASIdOrRange elements.
  */
 static int ASIdOrRange_cmp(const ASIdOrRange * const *a_,
                            const ASIdOrRange * const *b_)
 {
   const ASIdOrRange *a = *a_, *b = *b_;
 
-  assert((a->type == ASIdOrRange_id && a->u.id != NULL) ||
+  OPENSSL_assert((a->type == ASIdOrRange_id && a->u.id != NULL) ||
          (a->type == ASIdOrRange_range && a->u.range != NULL &&
           a->u.range->min != NULL && a->u.range->max != NULL));
 
-  assert((b->type == ASIdOrRange_id && b->u.id != NULL) ||
+  OPENSSL_assert((b->type == ASIdOrRange_id && b->u.id != NULL) ||
          (b->type == ASIdOrRange_range && b->u.range != NULL &&
           b->u.range->min != NULL && b->u.range->max != NULL));
 
   if (a->type == ASIdOrRange_id && b->type == ASIdOrRange_id)
     return ASN1_INTEGER_cmp(a->u.id, b->u.id);
 
   if (a->type == ASIdOrRange_range && b->type == ASIdOrRange_range) {
     int r = ASN1_INTEGER_cmp(a->u.range->min, b->u.range->min);
     return r != 0 ? r : ASN1_INTEGER_cmp(a->u.range->max, b->u.range->max);
   }
@@ skipping 18 matching lines @@
     break;
   case V3_ASID_RDI:
     choice = &asid->rdi;
     break;
   default:
     return 0;
   }
   if (*choice == NULL) {
     if ((*choice = ASIdentifierChoice_new()) == NULL)
       return 0;
-    assert((*choice)->u.inherit == NULL);
+    OPENSSL_assert((*choice)->u.inherit == NULL);
     if (((*choice)->u.inherit = ASN1_NULL_new()) == NULL)
       return 0;
     (*choice)->type = ASIdentifierChoice_inherit;
   }
   return (*choice)->type == ASIdentifierChoice_inherit;
 }
 
 /*
  * Add an ID or range to an ASIdentifierChoice.
  */
@@ skipping 14 matching lines @@
     choice = &asid->rdi;
     break;
   default:
     return 0;
   }
   if (*choice != NULL && (*choice)->type == ASIdentifierChoice_inherit)
     return 0;
   if (*choice == NULL) {
     if ((*choice = ASIdentifierChoice_new()) == NULL)
       return 0;
-    assert((*choice)->u.asIdsOrRanges == NULL);
+    OPENSSL_assert((*choice)->u.asIdsOrRanges == NULL);
     (*choice)->u.asIdsOrRanges = sk_ASIdOrRange_new(ASIdOrRange_cmp);
     if ((*choice)->u.asIdsOrRanges == NULL)
       return 0;
     (*choice)->type = ASIdentifierChoice_asIdsOrRanges;
   }
   if ((aor = ASIdOrRange_new()) == NULL)
     return 0;
   if (max == NULL) {
     aor->type = ASIdOrRange_id;
     aor->u.id = min;
@@ skipping 15 matching lines @@
   return 0;
 }
 
 /*
  * Extract min and max values from an ASIdOrRange.
  */
 static void extract_min_max(ASIdOrRange *aor,
                             ASN1_INTEGER **min,
                             ASN1_INTEGER **max)
 {
-  assert(aor != NULL && min != NULL && max != NULL);
+  OPENSSL_assert(aor != NULL && min != NULL && max != NULL);
   switch (aor->type) {
   case ASIdOrRange_id:
     *min = aor->u.id;
     *max = aor->u.id;
     return;
   case ASIdOrRange_range:
     *min = aor->u.range->min;
     *max = aor->u.range->max;
     return;
   }
@@ skipping 66 matching lines @@
   BN_free(bn);
   return ret;
 }
 
 /*
  * Check whether an ASIdentifier extension is in canonical form.
  */
 int v3_asid_is_canonical(ASIdentifiers *asid)
 {
   return (asid == NULL ||
-          (ASIdentifierChoice_is_canonical(asid->asnum) ||
+          (ASIdentifierChoice_is_canonical(asid->asnum) &&
            ASIdentifierChoice_is_canonical(asid->rdi)));
 }
 
 /*
  * Whack an ASIdentifierChoice into canonical form.
  */
 static int ASIdentifierChoice_canonize(ASIdentifierChoice *choice)
 {
   ASN1_INTEGER *a_max_plus_one = NULL;
   BIGNUM *bn = NULL;
   int i, ret = 0;
 
   /*
    * Nothing to do for empty element or inheritance.
    */
   if (choice == NULL || choice->type == ASIdentifierChoice_inherit)
     return 1;
 
   /*
    * We have a list.  Sort it.
    */
-  assert(choice->type == ASIdentifierChoice_asIdsOrRanges);
+  OPENSSL_assert(choice->type == ASIdentifierChoice_asIdsOrRanges);
   sk_ASIdOrRange_sort(choice->u.asIdsOrRanges);
 
   /*
    * Now check for errors and suboptimal encoding, rejecting the
    * former and fixing the latter.
    */
   for (i = 0; i < sk_ASIdOrRange_num(choice->u.asIdsOrRanges) - 1; i++) {
     ASIdOrRange *a = sk_ASIdOrRange_value(choice->u.asIdsOrRanges, i);
     ASIdOrRange *b = sk_ASIdOrRange_value(choice->u.asIdsOrRanges, i + 1);
     ASN1_INTEGER *a_min, *a_max, *b_min, *b_max;
 
     extract_min_max(a, &a_min, &a_max);
     extract_min_max(b, &b_min, &b_max);
 
     /*
      * Make sure we're properly sorted (paranoia).
      */
-    assert(ASN1_INTEGER_cmp(a_min, b_min) <= 0);
+    OPENSSL_assert(ASN1_INTEGER_cmp(a_min, b_min) <= 0);
 
     /*
      * Check for overlaps.
      */
     if (ASN1_INTEGER_cmp(a_max, b_min) >= 0) {
       X509V3err(X509V3_F_ASIDENTIFIERCHOICE_CANONIZE,
                 X509V3_R_EXTENSION_VALUE_ERROR);
       goto done;
     }
 
@@ skipping 32 matching lines @@
       }
       switch (b->type) {
       case ASIdOrRange_id:
         b->u.id = NULL;
         break;
       case ASIdOrRange_range:
         b->u.range->max = NULL;
         break;
       }
       ASIdOrRange_free(b);
-      (void)sk_ASIdOrRange_delete(choice->u.asIdsOrRanges, i + 1);
+      sk_ASIdOrRange_delete(choice->u.asIdsOrRanges, i + 1);
       i--;
       continue;
     }
   }
 
-  assert(ASIdentifierChoice_is_canonical(choice)); /* Paranoia */
+  OPENSSL_assert(ASIdentifierChoice_is_canonical(choice)); /* Paranoia */
 
   ret = 1;
 
  done:
   ASN1_INTEGER_free(a_max_plus_one);
   BN_free(bn);
   return ret;
 }
 
 /*
  * Whack an ASIdentifier extension into canonical form.
  */
 int v3_asid_canonize(ASIdentifiers *asid)
 {
   return (asid == NULL ||
           (ASIdentifierChoice_canonize(asid->asnum) &&
            ASIdentifierChoice_canonize(asid->rdi)));
 }
 
 /*
  * v2i method for an ASIdentifier extension.
  */
-static void *v2i_ASIdentifiers(struct v3_ext_method *method,
+static void *v2i_ASIdentifiers(const struct v3_ext_method *method,
                                struct v3_ext_ctx *ctx,
                                STACK_OF(CONF_VALUE) *values)
 {
   ASIdentifiers *asid = NULL;
   int i;
 
   if ((asid = ASIdentifiers_new()) == NULL) {
     X509V3err(X509V3_F_V2I_ASIDENTIFIERS, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
@@ skipping 191 matching lines @@
 
 /*
  * Core code for RFC 3779 3.3 path validation.
  */
 static int v3_asid_validate_path_internal(X509_STORE_CTX *ctx,
                                           STACK_OF(X509) *chain,
                                           ASIdentifiers *ext)
 {
   ASIdOrRanges *child_as = NULL, *child_rdi = NULL;
   int i, ret = 1, inherit_as = 0, inherit_rdi = 0;
-  X509 *x = NULL;
+  X509 *x;
 
-  assert(chain != NULL && sk_X509_num(chain) > 0);
-  assert(ctx != NULL || ext != NULL);
-  assert(ctx == NULL || ctx->verify_cb != NULL);
+  OPENSSL_assert(chain != NULL && sk_X509_num(chain) > 0);
+  OPENSSL_assert(ctx != NULL || ext != NULL);
+  OPENSSL_assert(ctx == NULL || ctx->verify_cb != NULL);
 
   /*
    * Figure out where to start.  If we don't have an extension to
    * check, we're done.  Otherwise, check canonical form and
    * set up for walking up the chain.
    */
   if (ext != NULL) {
     i = -1;
+    x = NULL;
   } else {
     i = 0;
     x = sk_X509_value(chain, i);
-    assert(x != NULL);
+    OPENSSL_assert(x != NULL);
     if ((ext = x->rfc3779_asid) == NULL)
       goto done;
   }
   if (!v3_asid_is_canonical(ext))
     validation_err(X509_V_ERR_INVALID_EXTENSION);
   if (ext->asnum != NULL)  {
     switch (ext->asnum->type) {
     case ASIdentifierChoice_inherit:
       inherit_as = 1;
       break;
@@ skipping 12 matching lines @@
       break;
     }
   }
 
   /*
    * Now walk up the chain.  Extensions must be in canonical form, no
    * cert may list resources that its parent doesn't list.
    */
   for (i++; i < sk_X509_num(chain); i++) {
     x = sk_X509_value(chain, i);
-    assert(x != NULL);
+    OPENSSL_assert(x != NULL);
     if (x->rfc3779_asid == NULL) {
       if (child_as != NULL || child_rdi != NULL)
         validation_err(X509_V_ERR_UNNESTED_RESOURCE);
       continue;
     }
     if (!v3_asid_is_canonical(x->rfc3779_asid))
       validation_err(X509_V_ERR_INVALID_EXTENSION);
     if (x->rfc3779_asid->asnum == NULL && child_as != NULL) {
       validation_err(X509_V_ERR_UNNESTED_RESOURCE);
       child_as = NULL;
@@ skipping 22 matching lines @@
         inherit_rdi = 0;
       } else {
         validation_err(X509_V_ERR_UNNESTED_RESOURCE);
       }
     }
   }
 
   /*
    * Trust anchor can't inherit.
    */
+  OPENSSL_assert(x != NULL);
   if (x->rfc3779_asid != NULL) {
     if (x->rfc3779_asid->asnum != NULL &&
         x->rfc3779_asid->asnum->type == ASIdentifierChoice_inherit)
       validation_err(X509_V_ERR_UNNESTED_RESOURCE);
     if (x->rfc3779_asid->rdi != NULL &&
         x->rfc3779_asid->rdi->type == ASIdentifierChoice_inherit)
       validation_err(X509_V_ERR_UNNESTED_RESOURCE);
   }
 
  done:
@@ skipping 21 matching lines @@
   if (ext == NULL)
     return 1;
   if (chain == NULL || sk_X509_num(chain) == 0)
     return 0;
   if (!allow_inheritance && v3_asid_inherits(ext))
     return 0;
   return v3_asid_validate_path_internal(NULL, chain, ext);
 }
 
 #endif /* OPENSSL_NO_RFC3779 */