grpc 1.53.1 → 1.54.0

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

@@ -55,212 +55,93 @@
  * [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_generalizedtime_to_tm(struct tm *tm, const ASN1_GENERALIZEDTIME *d)
-{
-    static const int min[9] = { 0, 0, 1, 1, 0, 0, 0, 0, 0 };
-    static const int max[9] = { 99, 99, 12, 31, 23, 59, 59, 12, 59 };
-    char *a;
-    int n, i, l, o;
-
-    if (d->type != V_ASN1_GENERALIZEDTIME)
-        return (0);
-    l = d->length;
-    a = (char *)d->data;
-    o = 0;
-    /*
-     * GENERALIZEDTIME is similar to UTCTIME except the year is represented
-     * as YYYY. This stuff treats everything as a two digit field so make
-     * first two fields 00 to 99
-     */
-    if (l < 13)
-        goto err;
-    for (i = 0; i < 7; i++) {
-        if ((i == 6) && ((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 * 100 - 1900;
-                break;
-            case 1:
-                tm->tm_year += n;
-                break;
-            case 2:
-                tm->tm_mon = n - 1;
-                break;
-            case 3:
-                tm->tm_mday = n;
-                break;
-            case 4:
-                tm->tm_hour = n;
-                break;
-            case 5:
-                tm->tm_min = n;
-                break;
-            case 6:
-                tm->tm_sec = n;
-                break;
-            }
-        }
-    }
-    /*
-     * Optional fractional seconds: decimal point followed by one or more
-     * digits.
-     */
-    if (a[o] == '.') {
-        if (++o > l)
-            goto err;
-        i = o;
-        while ((a[o] >= '0') && (a[o] <= '9') && (o <= l))
-            o++;
-        /* Must have at least one digit after decimal point */
-        if (i == o)
-            goto err;
-    }
-
-    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 = 7; i < 9; 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 == 7)
-                    offset = n * 3600;
-                else if (i == 8)
-                    offset += n * 60;
-            }
-            o++;
-        }
-        if (offset && !OPENSSL_gmtime_adj(tm, 0, offset * offsign))
-            return 0;
-    } else if (a[o]) {
-        /* Missing time zone information. */
-        goto err;
-    }
-    return (o == l);
- err:
-    return (0);
+int asn1_generalizedtime_to_tm(struct tm *tm, const ASN1_GENERALIZEDTIME *d) {
+  if (d->type != V_ASN1_GENERALIZEDTIME) {
+    return 0;
+  }
+  CBS cbs;
+  CBS_init(&cbs, d->data, (size_t)d->length);
+  if (!CBS_parse_generalized_time(&cbs, tm, /*allow_timezone_offset=*/0)) {
+    return 0;
+  }
+  return 1;
 }
 
-int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
-{
-    return asn1_generalizedtime_to_tm(NULL, d);
+int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d) {
+  return asn1_generalizedtime_to_tm(NULL, d);
 }
 
-int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
-{
-    ASN1_GENERALIZEDTIME t;
-
-    t.type = V_ASN1_GENERALIZEDTIME;
-    t.length = strlen(str);
-    t.data = (unsigned char *)str;
-    if (ASN1_GENERALIZEDTIME_check(&t)) {
-        if (s != NULL) {
-            if (!ASN1_STRING_set((ASN1_STRING *)s,
-                                 (unsigned char *)str, t.length))
-                return 0;
-            s->type = V_ASN1_GENERALIZEDTIME;
-        }
-        return (1);
-    } else
-        return (0);
+int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str) {
+  size_t len = strlen(str);
+  CBS cbs;
+  CBS_init(&cbs, (const uint8_t *)str, len);
+  if (!CBS_parse_generalized_time(&cbs, /*out_tm=*/NULL,
+                                  /*allow_timezone_offset=*/0)) {
+    return 0;
+  }
+  if (s != NULL) {
+    if (!ASN1_STRING_set(s, str, len)) {
+      return 0;
+    }
+    s->type = V_ASN1_GENERALIZEDTIME;
+  }
+  return 1;
 }
 
 ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
-                                               time_t t)
-{
-    return ASN1_GENERALIZEDTIME_adj(s, t, 0, 0);
+                                               int64_t posix_time) {
+  return ASN1_GENERALIZEDTIME_adj(s, posix_time, 0, 0);
 }
 
 ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
-                                               time_t t, int offset_day,
-                                               long offset_sec)
-{
-    char *p;
-    struct tm *ts;
-    struct tm data;
-    size_t len = 20;
-    ASN1_GENERALIZEDTIME *tmps = NULL;
-
-    if (s == NULL)
-        tmps = ASN1_GENERALIZEDTIME_new();
-    else
-        tmps = s;
-    if (tmps == NULL)
-        return NULL;
-
-    ts = OPENSSL_gmtime(&t, &data);
-    if (ts == NULL)
-        goto err;
+                                               int64_t posix_time, int offset_day,
+                                               long offset_sec) {
+  struct tm data;
+  if (!OPENSSL_posix_to_tm(posix_time, &data)) {
+    return NULL;
+  }
 
-    if (offset_day || offset_sec) {
-        if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec))
-            goto err;
+  if (offset_day || offset_sec) {
+    if (!OPENSSL_gmtime_adj(&data, offset_day, offset_sec)) {
+      return NULL;
     }
+  }
 
-    if (ts->tm_year < 0 - 1900 || ts->tm_year > 9999 - 1900) {
-        OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_TIME_VALUE);
-        goto err;
+  if (data.tm_year < 0 - 1900 || data.tm_year > 9999 - 1900) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_TIME_VALUE);
+    return NULL;
+  }
+
+  char buf[16];
+  BIO_snprintf(buf, sizeof(buf), "%04d%02d%02d%02d%02d%02dZ",
+               data.tm_year + 1900, data.tm_mon + 1, data.tm_mday, data.tm_hour,
+               data.tm_min, data.tm_sec);
+
+  int free_s = 0;
+  if (s == NULL) {
+    free_s = 1;
+    s = ASN1_UTCTIME_new();
+    if (s == NULL) {
+      return NULL;
     }
+  }
 
-    p = (char *)tmps->data;
-    if ((p == NULL) || ((size_t)tmps->length < len)) {
-        p = OPENSSL_malloc(len);
-        if (p == NULL) {
-            OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-            goto err;
-        }
-        OPENSSL_free(tmps->data);
-        tmps->data = (unsigned char *)p;
+  if (!ASN1_STRING_set(s, buf, strlen(buf))) {
+    if (free_s) {
+      ASN1_UTCTIME_free(s);
     }
-
-    BIO_snprintf(p, len, "%04d%02d%02d%02d%02d%02dZ", ts->tm_year + 1900,
-                 ts->tm_mon + 1, ts->tm_mday, ts->tm_hour, ts->tm_min,
-                 ts->tm_sec);
-    tmps->length = strlen(p);
-    tmps->type = V_ASN1_GENERALIZEDTIME;
-    return tmps;
- err:
-    if (s == NULL)
-        ASN1_GENERALIZEDTIME_free(tmps);
     return NULL;
+  }
+  s->type = V_ASN1_GENERALIZEDTIME;
+  return s;
 }

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

@@ -61,28 +61,25 @@
 #include <openssl/mem.h>
 
 
-int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x)
-{
-    BIO *b = BIO_new_fp(out, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(ASN1, ERR_R_BUF_LIB);
-        return 0;
-    }
-    int ret = ASN1_item_i2d_bio(it, b, x);
-    BIO_free(b);
-    return ret;
+int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x) {
+  BIO *b = BIO_new_fp(out, BIO_NOCLOSE);
+  if (b == NULL) {
+    OPENSSL_PUT_ERROR(ASN1, ERR_R_BUF_LIB);
+    return 0;
+  }
+  int ret = ASN1_item_i2d_bio(it, b, x);
+  BIO_free(b);
+  return ret;
 }
 
-int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x)
-{
-    unsigned char *b = NULL;
-    int n = ASN1_item_i2d(x, &b, it);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
-        return 0;
-    }
+int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x) {
+  unsigned char *b = NULL;
+  int n = ASN1_item_i2d(x, &b, it);
+  if (b == NULL) {
+    return 0;
+  }
 
-    int ret = BIO_write_all(out, b, n);
-    OPENSSL_free(b);
-    return ret;
+  int ret = BIO_write_all(out, b, n);
+  OPENSSL_free(b);
+  return ret;
 }