ox 2.14.26 → 2.14.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '028d3be16e23f546d40a021dc76fe2a9a506f9f140f673e9e2aef60ab481fb5b'
-  data.tar.gz: 98efdca44712e1095cfaea485f66b46918649261fc0855794a6bf943d1a86e37
+  metadata.gz: 55a1d3d6cf3b51d434dc27e11ac62c93b2eab2b08426daf03c13f295b43cdd5e
+  data.tar.gz: 17b62fcfb67d670bf3693b6863d3906cd52a5f61b0344d5aa5fd1ed8dda26584
 SHA512:
-  metadata.gz: c1158647c428da2193d3de8c8a564077dc3e7854890dd9b31d79747e65dc14595a381ab079aaa3b9471d2b0de30d96c4b8698d1b82e2e53d34bfa6ff116a35cd
-  data.tar.gz: 43fcda76ed7d4d5febf5dc67e228278af4b16fcff4ff221ef4a3b39dbf0451d1da3f2ff25524079026ed482d14f0ae3d74af2019cb88f5296e6ebc340e4091b7
+  metadata.gz: c063a565a7dc1f1edd042377fbf195d53533a8a3d1585f3a29455beefb9cc7d4c6e9e4911c4632ee48c45f67b4a16b34c8cde7fbcb5aa5c63db74240e7d72230
+  data.tar.gz: 4338c45e7ea8c81948d0dc44af7244593fd0594b9c6c38ffddd1bd247baaa1369e856b8604e09419f8c035cc36478a633d50c005c171ecc4d054c2def302d53a

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All changes to the Ox gem are documented here. Releases follow semantic versioning.
 
+## [2.14.28] - 2026-06-28
+
+### Fixed
+
+- Parsing an excessively long DOCTYPE now raises and error instead of
+  waiting for a stack too deep system error.
+
+## [2.14.27] - 2026-06-18
+
+### Fixed
+
+- Fixed stack overflow issue in the parser that occurred when reading
+  special character sequences.
+
+- Set a limit of 1000 as the maximum nesting depth of elements to
+  avoid stack exhaustion.
+
+- Added a note on the symbolize_keys option indicating it should not
+  be used on unregulated input where the symbol table could grow
+  indefinitely.
+
 ## [2.14.26] - 2026-05-09
 
 ### Fixed

data/ext/ox/base64.c

@@ -11,7 +11,7 @@
 static char digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 /* invalid or terminating characters are set to 'X' or \x58 */
-static uchar s_digits[256] = "\
+static uchar s_digits[257] = "\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
 \x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x3E\x58\x58\x58\x3F\

data/ext/ox/ox.c

@@ -274,7 +274,9 @@ static VALUE hints_to_overlay(Hints hints) {
  * - _:xsd_date_ [true|false|nil] use XSD date format instead of decimal format
  * - _:mode_ [:object|:generic|:limited|:hash|:hash_no_attrs|nil] load method to use for XML
  * - _:effort_ [:strict|:tolerant|:auto_define] set the tolerance level for loading
- * - _:symbolize_keys_ [true|false|nil] symbolize element attribute keys or leave as Strings
+ * - _:symbolize_keys_ [true|false|nil] symbolize element attribute keys or leave as Strings.
+ * Note that symbolized keys are more efficient but for uncontrolled input it can lead to unlimited
+ * growth of the symbol (intern) table.
  * - _:element_key_mod_ [Proc|nil] converts element keys on parse if not nil
  * - _:attr_key_mod_ [Proc|nil] converts attribute keys on parse if not nil
  * - _:skip_ [:skip_none|:skip_return|:skip_white|:skip_off] determines how to handle white space in text

data/ext/ox/parse.c

@@ -18,11 +18,16 @@
 #include "ruby.h"
 #include "special.h"
 
+#define MAX_ELEMENT_DEPTH 1000
+// Anything even close to the max prolog length is most likely someone trying
+// to break something.
+#define MAX_PROLOG 32767
+
 static void  mark_pi_cb(void *ptr);
 static void  read_instruction(PInfo pi);
 static void  read_doctype(PInfo pi);
 static void  read_comment(PInfo pi);
-static char *read_element(PInfo pi);
+static char *read_element(PInfo pi, int depth);
 static void  read_text(PInfo pi);
 /*static void	  read_reduced_text(PInfo pi); */
 static void  read_cdata(PInfo pi);
@@ -216,7 +221,7 @@ ox_parse(char *xml, size_t len, ParseCallbacks pcb, char **endp, Options options
             helper_stack_cleanup(&pi.helpers);
             return Qnil;
         default:
-            read_element(&pi);
+            read_element(&pi, 0);
             body_read = 1;
             break;
         }
@@ -380,6 +385,11 @@ static void read_delimited(PInfo pi, char end) {
             if (end == c) {
                 return;
             }
+            if (MAX_PROLOG < (pi->s - pi->str)) {
+                pi->s--;
+                set_error(&pi->err, "prolog (doctype) too long", pi->str, pi->s);
+                return;
+            }
             switch (c) {
             case '\0':
                 pi->s--;
@@ -452,7 +462,7 @@ static void read_comment(PInfo pi) {
 
 // Entered after the '<' and the first character after that. Returns stat
 // code.
-static char *read_element(PInfo pi) {
+static char *read_element(PInfo pi, int depth) {
     struct _attrStack attrs;
     const char       *attr_name;
     const char       *attr_value;
@@ -464,6 +474,10 @@ static char *read_element(PInfo pi) {
     int               hasChildren = 0;
     int               done        = 0;
 
+    if (MAX_ELEMENT_DEPTH < depth) {
+        set_error(&pi->err, "element nested too deeply, limit is 1000", pi->str, pi->s);
+        return 0;
+    }
     attr_stack_init(&attrs);
     if (0 == (ename = read_name_token(pi))) {
         return 0;
@@ -684,7 +698,7 @@ static char *read_element(PInfo pi) {
                     first = 0;
                     /* a child element */
                     // Child closed with mismatched name.
-                    if (0 != (name = read_element(pi))) {
+                    if (0 != (name = read_element(pi, depth + 1))) {
                         attr_stack_cleanup(&attrs);
 
                         if (0 ==
@@ -1056,7 +1070,8 @@ static char *read_coded_chars(PInfo pi, char *text) {
             break;
         }
     }
-    if (b > end) {
+    if (b >= end) {
+        // No terminating ; found in the first 31 bytes after an &.
         *text++ = '&';
     } else if ('#' == *buf) {
         uint64_t u = 0;

data/lib/ox/version.rb

@@ -1,4 +1,4 @@
 module Ox
   # Current version of the module.
-  VERSION = '2.14.26'
+  VERSION = '2.14.28'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.14.26
+  version: 2.14.28
 platform: ruby
 authors:
 - Peter Ohler
@@ -51,7 +51,6 @@ files:
 - ext/ox/err.c
 - ext/ox/err.h
 - ext/ox/extconf.rb
-- ext/ox/foo.h
 - ext/ox/gen_load.c
 - ext/ox/hash_load.c
 - ext/ox/helper.h
@@ -123,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A fast XML parser and object serializer.
 test_files: []

data/ext/ox/foo.h

@@ -1,204 +0,0 @@
-/* sax_buf.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
-
-#ifndef OX_SAX_BUF_H
-#define OX_SAX_BUF_H
-
-#include <stdio.h>
-
-typedef struct _buf {
-    char  base[0x00001000];
-    char *head;
-    char *end;
-    char *tail;
-    char *read_end; /* one past last character read */
-    char *pro;      /* protection start, buffer can not slide past this point */
-    char *str;      /* start of current string being read */
-    off_t pos;
-    off_t line;
-    off_t col;
-    off_t pro_pos;
-    off_t pro_line;
-    off_t pro_col;
-    int (*read_func)(struct _buf *buf);
-    union {
-        int         fd;
-        VALUE       io;
-        const char *str;
-    } in;
-    struct _saxDrive *dr;
-} *Buf;
-
-typedef struct _checkPt {
-    off_t pro_dif;
-    off_t pos;
-    off_t line;
-    off_t col;
-    char  c;
-} *CheckPt;
-
-#define CHECK_PT_INIT {-1, 0, 0, 0, '\0'}
-
-extern void ox_sax_buf_init(Buf buf, VALUE io);
-extern int  ox_sax_buf_read(Buf buf);
-
-static inline char buf_get(Buf buf) {
-    // printf("*** drive get from '%s'  from start: %ld  buf: %p  from read_end: %ld\n", buf->tail, buf->tail -
-    // buf->head, buf->head, buf->read_end - buf->tail);
-    if (buf->read_end <= buf->tail) {
-        if (0 != ox_sax_buf_read(buf)) {
-            return '\0';
-        }
-    }
-    if ('\n' == *buf->tail) {
-        buf->line++;
-        buf->col = 0;
-    } else {
-        buf->col++;
-    }
-    buf->pos++;
-
-    return *buf->tail++;
-}
-
-static inline void buf_backup(Buf buf) {
-    buf->tail--;
-    buf->col--;
-    buf->pos--;
-    if (0 >= buf->col) {
-        buf->line--;
-        // allow col to be negative since we never backup twice in a row
-    }
-}
-
-static inline void buf_protect(Buf buf) {
-    buf->pro      = buf->tail;
-    buf->str      = buf->tail;  // can't have str before pro
-    buf->pro_pos  = buf->pos;
-    buf->pro_line = buf->line;
-    buf->pro_col  = buf->col;
-}
-
-static inline void buf_reset(Buf buf) {
-    buf->tail = buf->pro;
-    buf->pos  = buf->pro_pos;
-    buf->line = buf->pro_line;
-    buf->col  = buf->pro_col;
-}
-
-/* Starts by reading a character so it is safe to use with an empty or
- * compacted buffer.
- */
-static inline char buf_next_non_white(Buf buf) {
-    char c;
-
-    while ('\0' != (c = buf_get(buf))) {
-        switch (c) {
-        case ' ':
-        case '\t':
-        case '\f':
-        case '\n':
-        case '\r': break;
-        default: return c;
-        }
-    }
-    return '\0';
-}
-
-/* Starts by reading a character so it is safe to use with an empty or
- * compacted buffer.
- */
-static inline char buf_next_white(Buf buf) {
-    char c;
-
-    while ('\0' != (c = buf_get(buf))) {
-        switch (c) {
-        case ' ':
-        case '\t':
-        case '\f':
-        case '\n':
-        case '\r':
-        case '\0': return c;
-        default: break;
-        }
-    }
-    return '\0';
-}
-
-static inline void buf_cleanup(Buf buf) {
-    if (buf->base != buf->head && 0 != buf->head) {
-        xfree(buf->head);
-        buf->head = 0;
-    }
-}
-
-static inline int is_white(char c) {
-    switch (c) {
-    case ' ':
-    case '\t':
-    case '\f':
-    case '\n':
-    case '\r': return 1;
-    default: break;
-    }
-    return 0;
-}
-
-static inline void buf_checkpoint(Buf buf, CheckPt cp) {
-    cp->pro_dif = (int)(buf->tail - buf->pro);
-    cp->pos     = buf->pos;
-    cp->line    = buf->line;
-    cp->col     = buf->col;
-    cp->c       = *(buf->tail - 1);
-}
-
-static inline int buf_checkset(CheckPt cp) {
-    return (0 <= cp->pro_dif);
-}
-
-static inline char buf_checkback(Buf buf, CheckPt cp) {
-    buf->tail = buf->pro + cp->pro_dif;
-    buf->pos  = cp->pos;
-    buf->line = cp->line;
-    buf->col  = cp->col;
-    return cp->c;
-}
-
-static inline void buf_collapse_return(char *str) {
-    char *s    = str;
-    char *back = str;
-
-    for (; '\0' != *s; s++) {
-        if (back != str && '\n' == *s && '\r' == *(back - 1)) {
-            *(back - 1) = '\n';
-        } else {
-            *back++ = *s;
-        }
-    }
-    *back = '\0';
-}
-
-static inline void buf_collapse_white(char *str) {
-    char *s    = str;
-    char *back = str;
-
-    for (; '\0' != *s; s++) {
-        switch (*s) {
-        case ' ':
-        case '\t':
-        case '\f':
-        case '\n':
-        case '\r':
-            if (back == str || ' ' != *(back - 1)) {
-                *back++ = ' ';
-            }
-            break;
-        default: *back++ = *s; break;
-        }
-    }
-    *back = '\0';
-}
-
-#endif /* OX_SAX_BUF_H */