yeptris 0.6.31.2-arm-linux-eabihf → 0.6.33.1-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/parse/engine.h

@@ -36,6 +36,9 @@ int yep_engine_run(yep_engine* e, const char* buf, size_t len, const yep_sink* s
  * from the stream's '&' occurrences (every anchor definition carries
  * exactly one, so the count never undershoots). */
 void yep_engine_prepare(yep_engine* e, const yep_text_stats* st);
+/* the caller already BOM-sniffed/transcoded the bytes (parse.c,
+ * values.c): the engine must not re-strip a content U+FEFF */
+void yep_engine_front_done(yep_engine* e);
 
 /* Resumable stepping (TODO.impl/07): chunks accumulate; every feed
  * parses the complete DOCUMENTS received so far (cut at `---` / `...`

data/vendor/libyeptris/src/yeptris/parse/numbers.c

@@ -5,6 +5,7 @@
  * strtod cross-checks. */
 
 #include <errno.h>
+#include <limits.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
@@ -160,9 +161,20 @@ int yep_num_i64(const char* p, uint32_t len, int64_t* out) {
         }
         long long v = 0;
         while (*q >= '0' && *q <= '9') {
-            v = v * 10 + (*q - '0');
+            int d = *q - '0';
+            /* the ERANGE law, spelled out: the plain path rejects
+             * unrepresentable values via strtoll, so the fold must
+             * too (UBSan: 2222222222222222222 * 10 overflowed, the
+             * nightly's round on the combined build) */
+            if (v > (LLONG_MAX - (long long)d) / 10) {
+                return 1;
+            }
+            v = v * 10 + d;
             q++;
         }
+        if (v > LLONG_MAX / 3600) {
+            return 1;
+        }
         v *= 3600; /* e0 weight */
         if (sign < 0)
             v = -v;
@@ -172,14 +184,27 @@ int yep_num_i64(const char* p, uint32_t len, int64_t* out) {
             long long g = 0;
             int d = 0;
             while (*q >= '0' && *q <= '9') {
-                g = g * 10 + (*q - '0');
+                int dg = *q - '0';
+                /* the group component rides the same ERANGE law as
+                 * the first component -- the catch-124 fix guarded
+                 * the hours loop but left this one raw (UBSan:
+                 * 999999999999999999 * 10, the nightly's run
+                 * 39049702014) */
+                if (g > (LLONG_MAX - (long long)dg) / 10) {
+                    return 1;
+                }
+                g = g * 10 + dg;
                 q++;
                 d++;
             }
             if (d == 0) {
                 return 1;
             }
-            v += g * (groups == 0 ? 60 : 1); /* e1 then e2 */
+            long long w = groups == 0 ? 60 : 1; /* e1 then e2 */
+            if (g > LLONG_MAX / w || v > LLONG_MAX - g * w) {
+                return 1;
+            }
+            v += g * w;
             groups++;
         }
         if (groups == 0 || *q != '\0') {

data/vendor/libyeptris/src/yeptris/parse/scalars.h

@@ -19,6 +19,18 @@
 extern "C" {
 #endif
 
+/* libyaml's simple-key budget counts characters, not bytes: a
+ * multibyte code point costs one (the round-108 fuzz shrink carries a
+ * 2-byte char at byte delta 1025). Shared by the engine scanners, the
+ * DOM JSON builder, and the tape key checker. */
+static inline int yep_simple_key_chars(const char* p, size_t n) {
+    int chars = 0;
+    for (size_t i = 0; i < n; i++) {
+        chars += ((((unsigned char)p[i]) & 0xC0) != 0x80);
+    }
+    return chars;
+}
+
 /* Finishes a double-quoted content span: escape sequences (\n \t \\ \" \x
  * \u \U …), backslash-at-EOL continuation, and multi-line folding.
  * Returns a pool-owned buffer of out_len bytes. */

data/vendor/libyeptris/src/yeptris/parse.c

@@ -156,10 +156,14 @@ YEPTRIS_API YeptrisDocument yeptris_parse_json(const char* buf, size_t len, Yept
                 st = YEPTRIS_ERROR_MEMORY;
                 goto jfail;
             }
-            if (yep_tape_walk_lenient_fused(buf, len, off, t, 1, 1, 0) == YEPTRIS_OK) {
+            if (yep_tape_walk_lenient_fused(buf, len, off, t, 1, 1, 0) == YEPTRIS_OK &&
+                !yep_tape_long_simple_key(t)) {
                 /* strict_nums=1: the arms validated the numbers at
                  * record time — the settle pass is gone (the profile's
-                 * 10% lane; the spans were cache-warm in the walk) */
+                 * 10% lane; the spans were cache-warm in the walk).
+                 * The simple-key law: a >1024 flow key cannot
+                 * re-serialize — the engine's clean error decides (run
+                 * 38143486175) */
                 YeptrisDocument h = yep_json_doc_wrap(NULL, buf, len, sys, status);
                 if (h != NULL) {
                     ((yeptris_document*)h)->lazy_tape = t;
@@ -366,8 +370,11 @@ engine_enter:
          * entirely — no anchors exist (the profile's 4.4% memchr
          * lane on the json corpora). */
         yep_text_stats amp_only = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-        const char* q = data;
-        const char* end = data + data_len;
+        /* (NULL, 0) passes the arg guard: NULL + 0 is UB, not an
+         * empty range (UBSan, the first nightly under the combined
+         * fuzz build) */
+        const char* q = data == NULL ? "" : data;
+        const char* end = q + data_len;
         if (q != NULL) {
             while ((q = memchr(q, '&', (size_t)(end - q))) != NULL) {
                 amp_only.amp++;
@@ -421,6 +428,7 @@ engine_enter:
         if (have_tape) {
             ytap_reset(&yt);
         }
+        yep_engine_front_done(eng);
         rc = yep_engine_run(eng, data, data_len, &sink);
     }
     if (rc != 0) {

data/vendor/libyeptris/src/yeptris/scan/scan.c

@@ -29,6 +29,15 @@ void yep_scan_advance_line(const char* p, size_t* from, size_t to, uint32_t* lin
         if (p[i] == '\n') {
             (*line)++;
             *line_start = i + 1;
+        } else if (p[i] == '\r' && i + 1 < to && p[i + 1] != '\n') {
+            /* a lone \r is a break too (the engine's break rule):
+             * the JSON fast path's walk missed it and marked every
+             * event after the \r one line low while the general
+             * kernel (which walks \r) marked them correctly — whole
+             * vs chunked diverged on `\r`-containing JSON-class flow
+             * (the nightly's run 38549939326) */
+            (*line)++;
+            *line_start = i + 1;
         }
     }
     *from = to;
@@ -151,6 +160,39 @@ size_t yep_scan_prop_end(const char* p, size_t len, size_t pos) {
     return pos;
 }
 
+int yep_scan_tag_char(unsigned char c) {
+    if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
+        return 1;
+    }
+    if (c >= 0x80) {
+        return 1; /* UTF-8 suffix bytes pass through */
+    }
+    switch (c) {
+    case '-':
+    case '_':
+    case ';':
+    case '/':
+    case '?':
+    case ':':
+    case '@':
+    case '&':
+    case '=':
+    case '+':
+    case '$':
+    case '.':
+    case '!':
+    case '~':
+    case '*':
+    case '\'':
+    case '(':
+    case ')':
+    case '%':
+        return 1;
+    default:
+        return 0;
+    }
+}
+
 /* ---- line-shape classification (TODO.restructure/49) ---- */
 
 /* blank/EOL/EOF directly after p[at] (the dash / explicit-key rule). */

data/vendor/libyeptris/src/yeptris/scan/scan.h

@@ -98,6 +98,13 @@ int yep_scan_prop_char(unsigned char c);
 /* First offset at/after pos that cannot continue an anchor/alias name. */
 size_t yep_scan_prop_end(const char* p, size_t len, size_t pos);
 
+/* Tag-shorthand suffix byte: libyaml's URI set (";/?:@&=+$,_.!~*'()%"
+ * plus alphanumerics; flow indicators and ',' terminate instead).
+ * Stray non-set bytes stay visible as the props follower, which
+ * e_props rejects ("did not find expected whitespace or line break
+ * while scanning a tag"). */
+int yep_scan_tag_char(unsigned char c);
+
 /* Scans a plain scalar starting at pos (must be content, not a comment).
  * flow != 0 adds flow stop characters; in flow, ':' terminates when
  * followed by blank/EOL/flow indicator. Leading whitespace is NOT

data/vendor/libyeptris/src/yeptris/tape.c

@@ -34,6 +34,7 @@
 #include "common/simd_text.h"
 #include "encoding/encoding.h"
 #include "memory/allocator.h"
+#include "parse/scalars.h"
 #include "scan/json.h"
 
 typedef struct {
@@ -685,6 +686,67 @@ static TAPE_NUM_OK_INLINE int tape_num_ok(const char* p, size_t len) {
     return k == len;
 }
 
+/* The >1024 simple-key law for the LENIENT walk's tape — the same
+ * verdict yt_flow_scan reads for the record walk: a STR at a map's
+ * key slot with a raw span past the limit (the law counts the RAW
+ * token, so a quoted key's two quotes add back). The DOM route must
+ * reject it BEFORE wrapping (strict JSON itself has no limit — the
+ * tape API keeps accepting; only the YAML serialization cannot carry
+ * a long simple key, so the fast parse defers to the engine's clean
+ * error — the nightly's run 38143486175). */
+int yep_tape_long_simple_key(const yeptris_json_tape* s) {
+    struct {
+        uint8_t map;
+        uint8_t key_next;
+    } st[257];
+    int d = 0;
+    st[0].map = 0;
+    st[0].key_next = 0;
+    for (uint32_t i = 1; i < s->count; i++) { /* recs[0] is the DOC */
+        uint64_t r = s->recs[i];
+        uint8_t kind = (uint8_t)(r & 0xFFu);
+        if (kind == YEP_T_MAP_OPEN || kind == YEP_T_SEQ_OPEN) {
+            if (d >= 256) {
+                return 1; /* deeper than the scratch stack: over by
+                           * definition, the engine's depth law decides */
+            }
+            /* the container consumes the parent frame's pending slot;
+             * after it closes the OTHER slot is next (yt_flow_scan's
+             * round-108 lesson: a pinned key_next hid every key that
+             * followed a container value) */
+            if (d > 0 && st[d].map) {
+                st[d].key_next = (uint8_t)!st[d].key_next;
+            }
+            d++;
+            st[d].map = (uint8_t)(kind == YEP_T_MAP_OPEN);
+            st[d].key_next = 0;
+            continue;
+        }
+        if (kind == YEP_T_CLOSE) {
+            if (d > 0) {
+                d--;
+            }
+            continue;
+        }
+        if (st[d].map && st[d].key_next == 0) {
+            uint32_t mlen = (uint32_t)(r >> 8) & 0xFFFFFFu;
+            if (kind == YEP_T_STR && mlen + 2u > 1024u &&
+                yep_simple_key_chars((const char*)s->_src + (size_t)((uint32_t)(r >> 32)), mlen) +
+                        2 >
+                    1024) {
+                /* the budget counts characters, not bytes (the round-108
+                 * shrink: a 2-byte code point at byte delta 1025 is
+                 * legal); _src rides the walk that produced the tape */
+                return 1;
+            }
+            st[d].key_next = 1;
+        } else if (st[d].map) {
+            st[d].key_next = 0;
+        }
+    }
+    return 0;
+}
+
 YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
                                           yeptris_json_tape* t, int strict_nums, int clean_only,
                                           int reuse_block) {
@@ -1194,6 +1256,17 @@ ldone:
         goto lreject;
     }
 }
+    /* a col-0 tab-led continuation line inside the span is the suite's
+     * Y79Y#4 error: defer to the engine, whose e_flow_ws owns the law
+     * -- the walk's whitespace loops treat the tab as separation, which
+     * accepted exactly the span the marshal drain's engine rejected,
+     * splitting parseable from marshalable (the nightly's round 120) */
+    for (size_t k = open + 1; k < len; k++) {
+        if (p[k] == '\n' && k + 1 < len && p[k + 1] == '\t') {
+            yeptris_tape_free(t);
+            return YEPTRIS_ERROR_PARSE;
+        }
+    }
     t->count = count;
     t->_src = p;
     t->_srclen = len;
@@ -2013,7 +2086,21 @@ YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, si
          * 1.65x, json-users 2.2x — the ledger's #85 scoping), and
          * this exact call already carried the route's verdicts as the
          * escape/C0 fallback, so acceptance is unchanged. */
-        return yep_tape_walk_lenient_fused(source, len, at, tape, 0, 0, 0);
+        int rc = yep_tape_walk_lenient_fused(source, len, at, tape, 0, 0, 0);
+        if (rc != YEPTRIS_OK) {
+            return rc;
+        }
+        /* the YAML simple-key law rides the fused route too: a key
+         * whose raw span crosses 1024 defers to the engine's clean
+         * error — the JSON-class walk has no YAML laws, and the other
+         * routes (engine_run, the marshal drains) reject the same
+         * span, so acceptance here broke whole/chunked marshal parity
+         * (the nightly's round 108) */
+        if (yep_tape_long_simple_key(tape)) {
+            yep_error_set(yep_error_tls(), YEP_ERR_KEY_TOO_LONG, 1, (uint32_t)(at + 1), at, NULL);
+            return YEPTRIS_ERROR_PARSE;
+        }
+        return YEPTRIS_OK;
     }
 
     /* scalar root: one record, same deferred split for numbers */

data/vendor/libyeptris/src/yeptris/tape_in.h

@@ -14,6 +14,8 @@
 #include <yeptris/tape.h>
 
 /* tape.c (was tape_walk_lnt_fused) */
+int yep_tape_long_simple_key(const yeptris_json_tape* t);
+
 YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
                                           yeptris_json_tape* t, int strict_nums, int clean_only,
                                           int reuse_block);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.31.2
+  version: 0.6.33.1
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.