grpc 1.53.1 → 1.54.0

data/third_party/boringssl-with-bazel/src/crypto/asn1/a_type.c

@@ -64,76 +64,109 @@
 #include "internal.h"
 
 
-int ASN1_TYPE_get(const ASN1_TYPE *a)
-{
-    if (a->type == V_ASN1_BOOLEAN || a->type == V_ASN1_NULL ||
-        a->value.ptr != NULL) {
-        return a->type;
-    }
-    return 0;
+int ASN1_TYPE_get(const ASN1_TYPE *a) {
+  switch (a->type) {
+    case V_ASN1_NULL:
+    case V_ASN1_BOOLEAN:
+      return a->type;
+    case V_ASN1_OBJECT:
+      return a->value.object != NULL ? a->type : 0;
+    default:
+      return a->value.asn1_string != NULL ? a->type : 0;
+  }
 }
 
-const void *asn1_type_value_as_pointer(const ASN1_TYPE *a)
-{
-    if (a->type == V_ASN1_BOOLEAN) {
-        return a->value.boolean ? (void *)0xff : NULL;
-    }
-    if (a->type == V_ASN1_NULL) {
-        return NULL;
-    }
-    return a->value.ptr;
+const void *asn1_type_value_as_pointer(const ASN1_TYPE *a) {
+  switch (a->type) {
+    case V_ASN1_NULL:
+      return NULL;
+    case V_ASN1_BOOLEAN:
+      return a->value.boolean ? (void *)0xff : NULL;
+    case V_ASN1_OBJECT:
+      return a->value.object;
+    default:
+      return a->value.asn1_string;
+  }
 }
 
-void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value)
-{
-    ASN1_TYPE **tmp_a = &a;
-    ASN1_primitive_free((ASN1_VALUE **)tmp_a, NULL);
-    a->type = type;
-    if (type == V_ASN1_BOOLEAN)
-        a->value.boolean = value ? 0xff : 0;
-    else
-        a->value.ptr = value;
+void asn1_type_cleanup(ASN1_TYPE *a) {
+  switch (a->type) {
+    case V_ASN1_NULL:
+      a->value.ptr = NULL;
+      break;
+    case V_ASN1_BOOLEAN:
+      a->value.boolean = ASN1_BOOLEAN_NONE;
+      break;
+    case V_ASN1_OBJECT:
+      ASN1_OBJECT_free(a->value.object);
+      a->value.object = NULL;
+      break;
+    default:
+      ASN1_STRING_free(a->value.asn1_string);
+      a->value.asn1_string = NULL;
+      break;
+  }
 }
 
-int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value)
-{
-    if (!value || (type == V_ASN1_BOOLEAN)) {
-        void *p = (void *)value;
-        ASN1_TYPE_set(a, type, p);
-    } else if (type == V_ASN1_OBJECT) {
-        ASN1_OBJECT *odup;
-        odup = OBJ_dup(value);
-        if (!odup)
-            return 0;
-        ASN1_TYPE_set(a, type, odup);
-    } else {
-        ASN1_STRING *sdup;
-        sdup = ASN1_STRING_dup(value);
-        if (!sdup)
-            return 0;
-        ASN1_TYPE_set(a, type, sdup);
+void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value) {
+  asn1_type_cleanup(a);
+  a->type = type;
+  switch (type) {
+    case V_ASN1_NULL:
+      a->value.ptr = NULL;
+      break;
+    case V_ASN1_BOOLEAN:
+      a->value.boolean = value ? ASN1_BOOLEAN_TRUE : ASN1_BOOLEAN_FALSE;
+      break;
+    case V_ASN1_OBJECT:
+      a->value.object = value;
+      break;
+    default:
+      a->value.asn1_string = value;
+      break;
+  }
+}
+
+int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value) {
+  if (!value || (type == V_ASN1_BOOLEAN)) {
+    void *p = (void *)value;
+    ASN1_TYPE_set(a, type, p);
+  } else if (type == V_ASN1_OBJECT) {
+    ASN1_OBJECT *odup;
+    odup = OBJ_dup(value);
+    if (!odup) {
+      return 0;
     }
-    return 1;
+    ASN1_TYPE_set(a, type, odup);
+  } else {
+    ASN1_STRING *sdup;
+    sdup = ASN1_STRING_dup(value);
+    if (!sdup) {
+      return 0;
+    }
+    ASN1_TYPE_set(a, type, sdup);
+  }
+  return 1;
 }
 
-/* Returns 0 if they are equal, != 0 otherwise. */
-int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b)
-{
-    int result = -1;
+// Returns 0 if they are equal, != 0 otherwise.
+int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b) {
+  int result = -1;
 
-    if (!a || !b || a->type != b->type)
-        return -1;
+  if (!a || !b || a->type != b->type) {
+    return -1;
+  }
 
-    switch (a->type) {
+  switch (a->type) {
     case V_ASN1_OBJECT:
-        result = OBJ_cmp(a->value.object, b->value.object);
-        break;
+      result = OBJ_cmp(a->value.object, b->value.object);
+      break;
     case V_ASN1_NULL:
-        result = 0;             /* They do not have content. */
-        break;
+      result = 0;  // They do not have content.
+      break;
     case V_ASN1_BOOLEAN:
-        result = a->value.boolean - b->value.boolean;
-        break;
+      result = a->value.boolean - b->value.boolean;
+      break;
     case V_ASN1_INTEGER:
     case V_ASN1_ENUMERATED:
     case V_ASN1_BIT_STRING:
@@ -155,9 +188,9 @@ int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b)
     case V_ASN1_UTF8STRING:
     case V_ASN1_OTHER:
     default:
-        result = ASN1_STRING_cmp(a->value.asn1_string, b->value.asn1_string);
-        break;
-    }
+      result = ASN1_STRING_cmp(a->value.asn1_string, b->value.asn1_string);
+      break;
+  }
 
-    return result;
+  return result;
 }

data/third_party/boringssl-with-bazel/src/crypto/asn1/a_utctm.c

@@ -55,210 +55,122 @@
  * [including the GNU Public Licence.] */
 
 #include <openssl/asn1.h>
+#include <openssl/bytestring.h>
+#include <openssl/err.h>
+#include <openssl/mem.h>
+#include <openssl/time.h>
 
 #include <string.h>
 #include <time.h>
 
-#include <openssl/err.h>
-#include <openssl/mem.h>
-
 #include "internal.h"
 
-
-int asn1_utctime_to_tm(struct tm *tm, const ASN1_UTCTIME *d)
-{
-    static const int min[8] = { 0, 1, 1, 0, 0, 0, 0, 0 };
-    static const int max[8] = { 99, 12, 31, 23, 59, 59, 12, 59 };
-    char *a;
-    int n, i, l, o;
-
-    if (d->type != V_ASN1_UTCTIME)
-        return (0);
-    l = d->length;
-    a = (char *)d->data;
-    o = 0;
-
-    if (l < 11)
-        goto err;
-    for (i = 0; i < 6; i++) {
-        if ((i == 5) && ((a[o] == 'Z') || (a[o] == '+') || (a[o] == '-'))) {
-            i++;
-            if (tm)
-                tm->tm_sec = 0;
-            break;
-        }
-        if ((a[o] < '0') || (a[o] > '9'))
-            goto err;
-        n = a[o] - '0';
-        if (++o > l)
-            goto err;
-
-        if ((a[o] < '0') || (a[o] > '9'))
-            goto err;
-        n = (n * 10) + a[o] - '0';
-        if (++o > l)
-            goto err;
-
-        if ((n < min[i]) || (n > max[i]))
-            goto err;
-        if (tm) {
-            switch (i) {
-            case 0:
-                tm->tm_year = n < 50 ? n + 100 : n;
-                break;
-            case 1:
-                tm->tm_mon = n - 1;
-                break;
-            case 2:
-                tm->tm_mday = n;
-                break;
-            case 3:
-                tm->tm_hour = n;
-                break;
-            case 4:
-                tm->tm_min = n;
-                break;
-            case 5:
-                tm->tm_sec = n;
-                break;
-            }
-        }
-    }
-    if (a[o] == 'Z')
-        o++;
-    else if ((a[o] == '+') || (a[o] == '-')) {
-        int offsign = a[o] == '-' ? 1 : -1, offset = 0;
-        o++;
-        if (o + 4 > l)
-            goto err;
-        for (i = 6; i < 8; i++) {
-            if ((a[o] < '0') || (a[o] > '9'))
-                goto err;
-            n = a[o] - '0';
-            o++;
-            if ((a[o] < '0') || (a[o] > '9'))
-                goto err;
-            n = (n * 10) + a[o] - '0';
-            if ((n < min[i]) || (n > max[i]))
-                goto err;
-            if (tm) {
-                if (i == 6)
-                    offset = n * 3600;
-                else if (i == 7)
-                    offset += n * 60;
-            }
-            o++;
-        }
-        if (offset && !OPENSSL_gmtime_adj(tm, 0, offset * offsign))
-            return 0;
-    }
-    return o == l;
- err:
+int asn1_utctime_to_tm(struct tm *tm, const ASN1_UTCTIME *d,
+                       int allow_timezone_offset) {
+  if (d->type != V_ASN1_UTCTIME) {
     return 0;
+  }
+  CBS cbs;
+  CBS_init(&cbs, d->data, (size_t)d->length);
+  if (!CBS_parse_utc_time(&cbs, tm, allow_timezone_offset)) {
+    return 0;
+  }
+  return 1;
 }
 
-int ASN1_UTCTIME_check(const ASN1_UTCTIME *d)
-{
-    return asn1_utctime_to_tm(NULL, d);
+int ASN1_UTCTIME_check(const ASN1_UTCTIME *d) {
+  return asn1_utctime_to_tm(NULL, d, /*allow_timezone_offset=*/1);
 }
 
-int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)
-{
-    ASN1_UTCTIME t;
-
-    t.type = V_ASN1_UTCTIME;
-    t.length = strlen(str);
-    t.data = (unsigned char *)str;
-    if (ASN1_UTCTIME_check(&t)) {
-        if (s != NULL) {
-            if (!ASN1_STRING_set((ASN1_STRING *)s,
-                                 (unsigned char *)str, t.length))
-                return 0;
-            s->type = V_ASN1_UTCTIME;
-        }
-        return (1);
-    } else
-        return (0);
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str) {
+  size_t len = strlen(str);
+  CBS cbs;
+  CBS_init(&cbs, (const uint8_t *)str, len);
+  if (!CBS_parse_utc_time(&cbs, /*out_tm=*/NULL,
+                          /*allow_timezone_offset=*/1)) {
+    return 0;
+  }
+  if (s != NULL) {
+    if (!ASN1_STRING_set(s, str, len)) {
+      return 0;
+    }
+    s->type = V_ASN1_UTCTIME;
+  }
+  return 1;
 }
 
-ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
-{
-    return ASN1_UTCTIME_adj(s, t, 0, 0);
+ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, int64_t posix_time) {
+  return ASN1_UTCTIME_adj(s, posix_time, 0, 0);
 }
 
-ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
-                               int offset_day, long offset_sec)
-{
-    char *p;
-    struct tm *ts;
-    struct tm data;
-    size_t len = 20;
-    int free_s = 0;
+ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, int64_t posix_time, int offset_day,
+                               long offset_sec) {
+  struct tm data;
+  if (!OPENSSL_posix_to_tm(posix_time, &data)) {
+    return NULL;
+  }
 
-    if (s == NULL) {
-        free_s = 1;
-        s = ASN1_UTCTIME_new();
+  if (offset_day || offset_sec) {
+    if (!OPENSSL_gmtime_adj(&data, offset_day, offset_sec)) {
+      return NULL;
     }
-    if (s == NULL)
-        goto err;
+  }
 
-    ts = OPENSSL_gmtime(&t, &data);
-    if (ts == NULL)
-        goto err;
-
-    if (offset_day || offset_sec) {
-        if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
-            goto err;
-    }
+  if (data.tm_year < 50 || data.tm_year >= 150) {
+    return NULL;
+  }
 
-    if ((ts->tm_year < 50) || (ts->tm_year >= 150))
-        goto err;
+  char buf[14];
+  BIO_snprintf(buf, sizeof(buf), "%02d%02d%02d%02d%02d%02dZ",
+               data.tm_year % 100, data.tm_mon + 1, data.tm_mday, data.tm_hour,
+               data.tm_min, data.tm_sec);
 
-    p = (char *)s->data;
-    if ((p == NULL) || ((size_t)s->length < len)) {
-        p = OPENSSL_malloc(len);
-        if (p == NULL) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            goto err;
-        }
-        if (s->data != NULL)
-            OPENSSL_free(s->data);
-        s->data = (unsigned char *)p;
+  int free_s = 0;
+  if (s == NULL) {
+    free_s = 1;
+    s = ASN1_UTCTIME_new();
+    if (s == NULL) {
+      return NULL;
     }
+  }
 
-    BIO_snprintf(p, len, "%02d%02d%02d%02d%02d%02dZ", ts->tm_year % 100,
-                 ts->tm_mon + 1, ts->tm_mday, ts->tm_hour, ts->tm_min,
-                 ts->tm_sec);
-    s->length = strlen(p);
-    s->type = V_ASN1_UTCTIME;
-    return (s);
- err:
-    if (free_s && s)
-        ASN1_UTCTIME_free(s);
+  if (!ASN1_STRING_set(s, buf, strlen(buf))) {
+    if (free_s) {
+      ASN1_UTCTIME_free(s);
+    }
     return NULL;
+  }
+  s->type = V_ASN1_UTCTIME;
+  return s;
 }
 
-int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
-{
-    struct tm stm, ttm;
-    int day, sec;
-
-    if (!asn1_utctime_to_tm(&stm, s))
-        return -2;
-
-    if (!OPENSSL_gmtime(&t, &ttm))
-        return -2;
-
-    if (!OPENSSL_gmtime_diff(&day, &sec, &ttm, &stm))
-        return -2;
-
-    if (day > 0)
-        return 1;
-    if (day < 0)
-        return -1;
-    if (sec > 0)
-        return 1;
-    if (sec < 0)
-        return -1;
-    return 0;
+int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t) {
+  struct tm stm, ttm;
+  int day, sec;
+
+  if (!asn1_utctime_to_tm(&stm, s, /*allow_timezone_offset=*/1)) {
+    return -2;
+  }
+
+  if (!OPENSSL_posix_to_tm(t, &ttm)) {
+    return -2;
+  }
+
+  if (!OPENSSL_gmtime_diff(&day, &sec, &ttm, &stm)) {
+    return -2;
+  }
+
+  if (day > 0) {
+    return 1;
+  }
+  if (day < 0) {
+    return -1;
+  }
+  if (sec > 0) {
+    return 1;
+  }
+  if (sec < 0) {
+    return -1;
+  }
+  return 0;
 }