oj 3.16.17 → 3.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cea6645d77bacff66ea8a69d5c5211aa2e9366decc1e8dec909cc83f08933af
-  data.tar.gz: d286d46148ef014003a9a23a87cf33da532e09a6ce0228f4e5b47eff963d985f
+  metadata.gz: e7458dcdf494ef6b1b283ca86d51fba0b3102ecf5cec13f43682878c01708c80
+  data.tar.gz: ab8099b8b275aa5acab45a012bbc96ef0c860e041be2c4ae7d6f7cd331da1755
 SHA512:
-  metadata.gz: a66845146062e764671ed0556076590ecc6507f04e21613ed5514df9e19e35c5e48b2fe9095cd7376fd82376a9b055aa8fc9e17e74c2bfaaa80ba1cebef0ddfe
-  data.tar.gz: 8b4af7c9cc6fadf664ff643c081783921e05f793d03c512bcf178e47173fc0e620f851382cb423c99769f01fd6080ad376c663a781faa14249cfc66009a182d2
+  metadata.gz: 60d445fd27bbea120359c21d0c1b0ac1d4fbbd678c8fd28efe620706d382a2f0cc434645967c9bac0b6d08d1065fe99dc4b15e2623d98ca0e15a61eb591a993b
+  data.tar.gz: b7736fd3a7b27f98ef3e4df05464000849403ff33a3f82ecd6d8c51b40d0c2753d23ed14c078eb26506d504de991e35ebe68e5703225c80aab6ebbd28b7a80dc

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # CHANGELOG
 
+## 3.17.3 - 2026-06-04
+
+- Fixed issue in intern.c and fast.c.
+
+## 3.17.2 - 2026-05-27
+
+- Fixed multiple issues related to extreme sizes.
+
+## 3.17.1 - 2026-05-15
+
+- Fixed "quoted string not terminated" error.
+
+## 3.17.0 - 2026-04-19
+
+- A "safe" parser has been added as a variation of the Oj:Parser thanks to @meinac.
+
 ## 3.16.17 - 2026-04-12
 
 - Rails optimize for Hash and Array now overrides `as_json` for those

data/README.md

@@ -46,11 +46,6 @@ gem 'oj'
 
 See the Quickstart sections of the [Rails](pages/Rails.md) and [json](pages/JsonGem.md) docs.
 
-## multi_json
-
-Code which uses [multi_json](https://github.com/intridea/multi_json)
-will automatically prefer Oj if it is installed.
-
 ## Support
 
 [Get supported Oj with a Tidelift Subscription.](https://tidelift.com/subscription/pkg/rubygems-oj?utm_source=rubygems-oj&utm_medium=referral&utm_campaign=readme) Security updates are [supported](https://tidelift.com/security).
@@ -83,17 +78,6 @@ See [{file:CHANGELOG.md}](CHANGELOG.md) and [{file:RELEASE_NOTES.md}](RELEASE_NO
 
 - *RubyGems* *repo*: https://rubygems.org/gems/oj
 
-Follow [@peterohler on Twitter](http://twitter.com/peterohler) for announcements and news about the Oj gem.
-
-#### Performance Comparisons
-
- - [Oj Strict Mode Performance](http://www.ohler.com/dev/oj_misc/performance_strict.html) compares Oj strict mode parser performance to other JSON parsers.
-
- - [Oj Compat Mode Performance](http://www.ohler.com/dev/oj_misc/performance_compat.html) compares Oj compat mode parser performance to other JSON parsers.
-
- - [Oj Object Mode Performance](http://www.ohler.com/dev/oj_misc/performance_object.html) compares Oj object mode parser performance to other marshallers.
-
- - [Oj Callback Performance](http://www.ohler.com/dev/oj_misc/performance_callback.html) compares Oj callback parser performance to other JSON parsers.
 
 #### Links of Interest
 

data/ext/oj/compat.c

@@ -27,7 +27,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
             if (Qnil != clas) {
                 rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
@@ -84,7 +84,7 @@ static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
             pi->stack.head->val = rb_funcall(clas, oj_json_create_id, 1, rstr);
@@ -155,7 +155,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
             rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));

data/ext/oj/custom.c

@@ -915,7 +915,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
             if (Qnil != clas) {
                 rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
@@ -1020,7 +1020,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rstr = rb_utf8_str_new(str, len);
 
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
             rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));

data/ext/oj/dump.c

@@ -40,7 +40,7 @@ static size_t ascii_friendly_size(const uint8_t *str, size_t len);
 static const char hex_chars[17] = "0123456789abcdef";
 
 // JSON standard except newlines are no escaped
-static char newline_friendly_chars[256] = "\
+static char newline_friendly_chars[257] = "\
 66666666221622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -51,7 +51,7 @@ static char newline_friendly_chars[256] = "\
 11111111111111111111111111111111";
 
 // JSON standard
-static char hibit_friendly_chars[256] = "\
+static char hibit_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -62,7 +62,7 @@ static char hibit_friendly_chars[256] = "\
 11111111111111111111111111111111";
 
 // JSON standard but escape forward slashes `/`
-static char slash_friendly_chars[256] = "\
+static char slash_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111121111111111111111\
 11111111111111111111111111112111\
@@ -74,7 +74,7 @@ static char slash_friendly_chars[256] = "\
 
 // High bit set characters are always encoded as unicode. Worse case is 3
 // bytes per character in the output. That makes this conservative.
-static char ascii_friendly_chars[256] = "\
+static char ascii_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -85,7 +85,7 @@ static char ascii_friendly_chars[256] = "\
 33333333333333333333333333333333";
 
 // XSS safe mode
-static char xss_friendly_chars[256] = "\
+static char xss_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211161111111121111111111116161\
 11111111111111111111111111112111\
@@ -96,7 +96,7 @@ static char xss_friendly_chars[256] = "\
 33333333333333333333333333333333";
 
 // JSON XSS combo
-static char hixss_friendly_chars[256] = "\
+static char hixss_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -107,7 +107,7 @@ static char hixss_friendly_chars[256] = "\
 11611111111111111111111111111111";
 
 // Rails XSS combo
-static char rails_xss_friendly_chars[256] = "\
+static char rails_xss_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211161111111111111111111116161\
 11111111111111111111111111112111\
@@ -118,7 +118,7 @@ static char rails_xss_friendly_chars[256] = "\
 11611111111111111111111111111111";
 
 // Rails HTML non-escape
-static char rails_friendly_chars[256] = "\
+static char rails_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\

data/ext/oj/fast.c

@@ -80,21 +80,10 @@ static void  each_leaf(Doc doc, VALUE self);
 static int   move_step(Doc doc, const char *path, int loc);
 static Leaf  get_doc_leaf(Doc doc, const char *path);
 static Leaf  get_leaf(Leaf *stack, Leaf *lp, const char *path);
-static void  each_value(Doc doc, Leaf leaf);
+static void  each_value(Doc doc, Leaf leaf, VALUE self);
 
 VALUE oj_doc_class = Qundef;
 
-// This is only for CentOS 5.4 with Ruby 1.9.3-p0.
-#ifndef HAVE_STPCPY
-char *stpcpy(char *dest, const char *src) {
-    size_t cnt = strlen(src);
-
-    strcpy(dest, src);
-
-    return dest + cnt;
-}
-#endif
-
 inline static void next_non_white(ParseInfo pi) {
     for (; 1; pi->s++) {
         switch (*pi->s) {
@@ -246,6 +235,19 @@ static void skip_comment(ParseInfo pi) {
 #define NUM_MAX (FIXNUM_MAX >> 8)
 #endif
 
+static void validate_integer_size(size_t limit, char *head, char *tail) {
+    size_t total       = (size_t)(tail - head);
+    bool   has_sign    = (head[0] == '-' || head[0] == '+');
+    size_t digit_count = total - (has_sign ? 1 : 0);
+
+    if (digit_count > limit) {
+        rb_raise(oj_parse_error_class,
+                 "integer exceeds :max_integer_digits (%lu > %lu)",
+                 (unsigned long)digit_count,
+                 (unsigned long)limit);
+    }
+}
+
 static void leaf_fixnum_value(Leaf leaf) {
     char   *s   = leaf->str;
     int64_t n   = 0;
@@ -265,7 +267,12 @@ static void leaf_fixnum_value(Leaf leaf) {
         }
     }
     if (big) {
-        char c = *s;
+        size_t limit = oj_default_options.max_integer_digits;
+        char   c     = *s;
+
+        if (0 < limit) {
+            validate_integer_size(limit, leaf->str, s);
+        }
 
         *s          = '\0';
         leaf->value = rb_cstr_to_inum(leaf->str, 10, 0);
@@ -950,6 +957,9 @@ static void each_leaf(Doc doc, VALUE self) {
         }
     } else {
         rb_yield(self);
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
@@ -1043,19 +1053,22 @@ static int move_step(Doc doc, const char *path, int loc) {
     return loc;
 }
 
-static void each_value(Doc doc, Leaf leaf) {
+static void each_value(Doc doc, Leaf leaf, VALUE self) {
     if (COL_VAL == leaf->value_type) {
         if (0 != leaf->elements) {
             Leaf first = leaf->elements->next;
             Leaf e     = first;
 
             do {
-                each_value(doc, e);
+                each_value(doc, e, self);
                 e = e->next;
             } while (e != first);
         }
     } else {
         rb_yield(leaf_value(doc, leaf));
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
@@ -1491,12 +1504,19 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
             Leaf first = (*doc->where)->elements->next;
             Leaf e     = first;
 
+            if (MAX_STACK <= (doc->where + 1) - doc->where_path) {
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
+            }
             doc->where++;
             do {
                 *doc->where = e;
                 rb_yield(self);
+                if (NULL == DATA_PTR(self)) {
+                    rb_raise(rb_eIOError, "Document closed.");
+                }
                 e = e->next;
             } while (e != first);
+            doc->where--;
         }
         if (0 < wlen) {
             memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
@@ -1540,7 +1560,7 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
             path = StringValuePtr(*argv);
         }
         if (0 != (leaf = get_doc_leaf(doc, path))) {
-            each_value(doc, leaf);
+            each_value(doc, leaf, self);
         }
     }
     return Qnil;

data/ext/oj/intern.c

@@ -69,7 +69,7 @@ static VALUE form_attr(const char *str, size_t len) {
             memcpy(b + 1, str, len);
             b[len + 1] = '\0';
         }
-        id = rb_intern3(buf, len + 1, oj_utf8_encoding);
+        id = rb_intern3(b, len + 1, oj_utf8_encoding);
         OJ_R_FREE(b);
         return id;
     }

data/ext/oj/mimic_json.c

@@ -711,6 +711,7 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        0,              // cache_str
                                                        0,              // int_range_min
                                                        0,              // int_range_max
+                                                       0,              // max_integer_digits
                                                        oj_json_class,  // create_id
                                                        10,             // create_id_len
                                                        3,              // sec_prec

data/ext/oj/oj.c

@@ -20,6 +20,8 @@
 #include "rails.h"
 #include "simd.h"
 
+#define MAX_INDENT 16
+
 typedef struct _yesNoOpt {
     VALUE sym;
     char *attr;
@@ -122,6 +124,7 @@ static VALUE empty_string_sym;
 static VALUE escape_mode_sym;
 static VALUE except_sym;
 static VALUE integer_range_sym;
+static VALUE max_integer_digits_sym;
 static VALUE fast_sym;
 static VALUE float_prec_sym;
 static VALUE float_format_sym;
@@ -206,6 +209,7 @@ struct _options oj_default_options = {
     0,              // cache_str
     0,              // int_range_min
     0,              // int_range_max
+    0,              // max_integer_digits
     oj_json_class,  // create_id
     10,             // create_id_len
     9,              // sec_prec
@@ -334,6 +338,11 @@ static VALUE only_array_from_string(const char *str) {
  * - *:cache_str* [_Fixnum_] maximum string value length to cache (strings less
  *   than this are cached)
  * - *:integer_range* [_Range_] Dump integers outside range as strings.
+ * - *:max_integer_digits* [_Fixnum_] Maximum number of decimal digits allowed in a
+ *   parsed integer. When the limit is exceeded a parse error is raised. 0 (the
+ *   default) disables the limit. Setting a reasonable limit is recommended when
+ *   parsing untrusted input to mitigate CPU-DoS attacks. Only applies to the
+ *   legacy parsers (Oj.load, Oj::Doc, JSON.parse mimic); Oj::Parser is unaffected.
  * - *:trace* [_true,_|_false_] Trace all load and dump calls, default is false
  *   (trace is off)
  * - *:safe* [_true,_|_false_] Safe mimic breaks JSON mimic to be safer, default
@@ -448,6 +457,7 @@ static VALUE get_def_opts(VALUE self) {
     } else {
         rb_hash_aset(opts, integer_range_sym, Qnil);
     }
+    rb_hash_aset(opts, max_integer_digits_sym, LONG2NUM((long)oj_default_options.max_integer_digits));
     switch (oj_default_options.escape_mode) {
     case NLEsc: rb_hash_aset(opts, escape_mode_sym, newline_sym); break;
     case JSONEsc: rb_hash_aset(opts, escape_mode_sym, json_sym); break;
@@ -591,6 +601,8 @@ static VALUE get_def_opts(VALUE self) {
  *   - *:cache_keys* [_Boolean_] if true then hash keys are cached
  *   - *:cache_str* [_Fixnum_] maximum string value length to cache (strings less than this are cached)
  *   - *:integer_range* [_Range_] Dump integers outside range as strings.
+ *   - *:max_integer_digits* [_Fixnum_] Maximum decimal digits in a parsed integer
+ *     (0 = unlimited). Use to mitigate CPU-DoS via huge integer values in JSON.
  *   - *:trace* [_Boolean_] turn trace on or off.
  *   - *:safe* [_Boolean_] turn safe mimic on or off.
  */
@@ -756,7 +768,10 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         case T_FIXNUM:
             copts->dump_opts.indent_size = 0;
             *copts->dump_opts.indent_str = '\0';
-            copts->indent                = FIX2INT(v);
+            if (MAX_INDENT < FIX2INT(v)) {
+                rb_raise(rb_eArgError, "indent is limited to %d characters.", MAX_INDENT);
+            }
+            copts->indent = FIX2INT(v);
             break;
         case T_STRING:
             if (sizeof(copts->dump_opts.indent_str) <= (len = RSTRING_LEN(v))) {
@@ -1071,6 +1086,20 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         } else if (Qfalse != v) {
             rb_raise(rb_eArgError, ":integer_range must be a range of Fixnum.");
         }
+    } else if (max_integer_digits_sym == k) {
+        if (Qnil == v || Qfalse == v) {
+            copts->max_integer_digits = 0;
+        } else if (T_FIXNUM == rb_type(v)) {
+            long n = FIX2LONG(v);
+
+            if (n < 0) {
+                rb_raise(rb_eArgError, ":max_integer_digits must be >= 0.");
+            }
+
+            copts->max_integer_digits = (size_t)n;
+        } else {
+            rb_raise(rb_eArgError, ":max_integer_digits must be a non-negative Integer.");
+        }
     } else if (symbol_keys_sym == k || oj_symbolize_names_sym == k) {
         if (Qnil == v) {
             return ST_CONTINUE;
@@ -2153,6 +2182,8 @@ void Init_oj(void) {
     rb_gc_register_address(&escape_mode_sym);
     integer_range_sym = ID2SYM(rb_intern("integer_range"));
     rb_gc_register_address(&integer_range_sym);
+    max_integer_digits_sym = ID2SYM(rb_intern("max_integer_digits"));
+    rb_gc_register_address(&max_integer_digits_sym);
     fast_sym = ID2SYM(rb_intern("fast"));
     rb_gc_register_address(&fast_sym);
     float_format_sym = ID2SYM(rb_intern("float_format"));

data/ext/oj/oj.h

@@ -124,43 +124,44 @@ typedef struct _dumpOpts {
 } *DumpOpts;
 
 typedef struct _options {
-    int              indent;         // indention for dump, default 2
-    char             circular;       // YesNo
-    char             auto_define;    // YesNo
-    char             sym_key;        // YesNo
-    char             escape_mode;    // Escape_Mode
-    char             mode;           // Mode
-    char             class_cache;    // YesNo
-    char             time_format;    // TimeFormat
-    char             bigdec_as_num;  // YesNo
-    char             bigdec_load;    // BigLoad
-    char             compat_bigdec;  // boolean (0 or 1)
-    char             to_hash;        // YesNo
-    char             to_json;        // YesNo
-    char             as_json;        // YesNo
-    char             raw_json;       // YesNo
-    char             nilnil;         // YesNo
-    char             empty_string;   // YesNo
-    char             allow_gc;       // allow GC during parse
-    char             quirks_mode;    // allow single JSON values instead of documents
-    char             allow_invalid;  // YesNo - allow invalid unicode
-    char             create_ok;      // YesNo allow create_id
-    char             allow_nan;      // YesNo for parsing only
-    char             trace;          // YesNo
-    char             safe;           // YesNo
-    char             sec_prec_set;   // boolean (0 or 1)
-    char             ignore_under;   // YesNo - ignore attrs starting with _ if true in object and custom modes
-    char             cache_keys;     // YesNo
-    char             cache_str;      // string short than or equal to this are cache
-    int64_t          int_range_min;  // dump numbers below as string
-    int64_t          int_range_max;  // dump numbers above as string
-    const char      *create_id;      // 0 or string
-    size_t           create_id_len;  // length of create_id
-    int              sec_prec;       // second precision when dumping time
-    char             float_prec;     // float precision, linked to float_fmt
-    char             float_fmt[7];   // float format for dumping, if empty use Ruby
-    VALUE            hash_class;     // class to use in place of Hash on load
-    VALUE            array_class;    // class to use in place of Array on load
+    int              indent;              // indention for dump, default 2
+    char             circular;            // YesNo
+    char             auto_define;         // YesNo
+    char             sym_key;             // YesNo
+    char             escape_mode;         // Escape_Mode
+    char             mode;                // Mode
+    char             class_cache;         // YesNo
+    char             time_format;         // TimeFormat
+    char             bigdec_as_num;       // YesNo
+    char             bigdec_load;         // BigLoad
+    char             compat_bigdec;       // boolean (0 or 1)
+    char             to_hash;             // YesNo
+    char             to_json;             // YesNo
+    char             as_json;             // YesNo
+    char             raw_json;            // YesNo
+    char             nilnil;              // YesNo
+    char             empty_string;        // YesNo
+    char             allow_gc;            // allow GC during parse
+    char             quirks_mode;         // allow single JSON values instead of documents
+    char             allow_invalid;       // YesNo - allow invalid unicode
+    char             create_ok;           // YesNo allow create_id
+    char             allow_nan;           // YesNo for parsing only
+    char             trace;               // YesNo
+    char             safe;                // YesNo
+    char             sec_prec_set;        // boolean (0 or 1)
+    char             ignore_under;        // YesNo - ignore attrs starting with _ if true in object and custom modes
+    char             cache_keys;          // YesNo
+    char             cache_str;           // string short than or equal to this are cache
+    int64_t          int_range_min;       // dump numbers below as string
+    int64_t          int_range_max;       // dump numbers above as string
+    size_t           max_integer_digits;  // 0 = unlimited; max decimal digits for parsed integers
+    const char      *create_id;           // 0 or string
+    size_t           create_id_len;       // length of create_id
+    int              sec_prec;            // second precision when dumping time
+    char             float_prec;          // float precision, linked to float_fmt
+    char             float_fmt[7];        // float format for dumping, if empty use Ruby
+    VALUE            hash_class;          // class to use in place of Hash on load
+    VALUE            array_class;         // class to use in place of Array on load
     struct _dumpOpts dump_opts;
     struct _rxClass  str_rx;
     VALUE           *ignore;  // Qnil terminated array of classes or NULL

data/ext/oj/parse.c

@@ -394,7 +394,7 @@ void oj_scanner_init(void) {
 static void read_escaped_str(ParseInfo pi, const char *start) {
     struct _buf buf;
     const char *s;
-    int         cnt = (int)(pi->cur - start);
+    size_t      cnt = pi->cur - start;
     uint32_t    code;
     Val         parent = stack_peek(&pi->stack);
 
@@ -669,7 +669,7 @@ static void read_num(ParseInfo pi) {
             // A trailing . is not a valid decimal but if encountered allow it
             // except when mimicking the JSON gem or in strict mode.
             if (StrictMode == pi->options.mode || CompatMode == pi->options.mode) {
-                int pos = (int)(pi->cur - ni.str);
+                size_t pos = pi->cur - ni.str;
 
                 if (1 == pos || (2 == pos && ni.neg)) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
@@ -971,6 +971,20 @@ static long double exp_plus[] = {
     1.0e39, 1.0e40, 1.0e41, 1.0e42, 1.0e43, 1.0e44, 1.0e45, 1.0e46, 1.0e47, 1.0e48, 1.0e49,
 };
 
+static void validate_integer_size(size_t limit, NumInfo ni) {
+    size_t digit_count = ni->len - (ni->neg ? 1 : 0);
+
+    if (digit_count > limit) {
+        oj_set_error_at(ni->pi,
+                        (Qnil != ni->pi->err_class) ? ni->pi->err_class : oj_parse_error_class,
+                        __FILE__,
+                        __LINE__,
+                        "integer exceeds :max_integer_digits (%lu > %lu)",
+                        (unsigned long)digit_count,
+                        (unsigned long)limit);
+    }
+}
+
 VALUE
 oj_num_as_value(NumInfo ni) {
     VALUE rnum = Qnil;
@@ -984,6 +998,12 @@ oj_num_as_value(NumInfo ni) {
     } else if (ni->nan) {
         rnum = rb_float_new(0.0 / 0.0);
     } else if (1 == ni->div && 0 == ni->exp && !ni->has_exp) {  // fixnum
+        size_t limit = (NULL != ni->pi) ? ni->pi->options.max_integer_digits : 0;
+
+        if (0 < limit) {
+            validate_integer_size(limit, ni);
+        }
+
         if (ni->big) {
             if (256 > ni->len) {
                 char buf[256];