oj-safe 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9f56ad20587a945f6a54301e5749d0ac55b83ed1d7d0c34d942b63fc38a68c8
-  data.tar.gz: c5d2bf06a6d8b4a401fd852bccf982033b475eee6b409f0b0952741a68339070
+  metadata.gz: 5db75d52595ff977025eb4746986c3e640f865fb0e022dc979cad6a1ebbf4c59
+  data.tar.gz: fffe75b048a7b2f9a583517b038c3d4f14d592f8d860a880f851a7c3cc352f30
 SHA512:
-  metadata.gz: 583f5fac8e1a572e3e6cd7452b70faa186d8d40a5f3c6407381968de668bcd2ea3eb7e930af1a55c502e74db67db71871504f7fafc2a2fadb34ab117aea6f883
-  data.tar.gz: bb21ee9811f5ad1ea2705c2717d3cd65047f59e1d79b2e42b5fafd4640f7921812692065b6edb9329fcc904753ff5a51e0d71dd2abe4b0157d775e3014158db8
+  metadata.gz: 989dae91a64a063661d2a761b72bd5f0e7b593a157123131ab06ead18092098801b21b22031cc3f8a483206d06edeb530d1d28892df31562d12f8b791be3e4eb
+  data.tar.gz: 9d9b2c822fbce6dad86f969f653217462af714f79e1a757cbde2fb14cfb062977b436ff844ea81cf31b50ba66a1c90e43795a16878a4d59cc9941d8c2ce3c5d1

data/README.md

@@ -1,38 +1,89 @@
 # Oj::Safe
 
-TODO: Delete this and the text below, and describe your gem
+`oj-safe` is a safe JSON parser built on top of [`Oj`](https://github.com/ohler55/oj).
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/oj/safe`. To experiment with that code, run `bin/console` for an interactive prompt.
+`Oj::Safe` lets you parse JSON while enforcing configurable limits on the input size and structure, helping protect applications from excessively large or deeply nested payloads.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this to your Gemfile:
 
-Install the gem and add to the application's Gemfile by executing:
+```ruby
+gem "oj-safe"
+```
+
+Or install it directly:
+
+```sh
+gem install oj-safe
+```
+
+## Available configuration options
+
+##### `max_hash_size`
 
-```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+Maximum number of key/value pairs allowed in a JSON object.
+
+```ruby
+parser = Oj::Safe.new(max_hash_size: 2)
+
+parser.parse('{ "foo": 1, "bar": 2 }') # => { "foo" => 1, "bar" => 2 }
+parser.parse('{ "foo": 1, "bar": 2, "baz": 3 }') # => Raises `Oj::Safe::ValidationError`.
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+##### `max_array_size`
+
+Maximum number of items allowed in a JSON array.
 
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```ruby
+parser = Oj::Safe.new(max_array_size: 2)
+
+parser.parse('[1, 2]') # => [1, 2]
+parser.parse('[1, 2, 3]') # => Raises `Oj::Safe::ValidationError`.
 ```
 
-## Usage
+##### `max_depth`
+
+Maximum nesting depth allowed.
+
+```ruby
+parser = Oj::Safe.new(max_depth: 2)
 
-TODO: Write usage instructions here
+parser.parse('[[]]') # => [[]]
+parser.parse('[[[]]]]') # => Raises `Oj::Safe::ValidationError`.
+```
+
+##### `max_total_elements`
+
+Maximum total number of parsed elements.
+
+```ruby
+parser = Oj::Safe.new(max_total_elements: 2)
+
+parser.parse('[true]') # => [true]
+parser.parse('[true, false]') # => Raises `Oj::Safe::ValidationError`.
+```
+
+##### `max_json_size_bytes`
+
+Maximum size of the input JSON string in bytes.
+
+```ruby
+parser = Oj::Safe.new(max_json_size_bytes: 2)
+
+parser.parse('12') # => 12
+parser.parse('123') # => Raises `Oj::Safe::ValidationError`.
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to compile and run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/oj-safe. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/oj-safe/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and merge requests are welcome on GitLab at https://gitlab.com/minac/oj-safe. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://gitlab.com/minac/oj-safe/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -40,4 +91,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Oj::Safe project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/oj-safe/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Oj::Safe project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://gitlab.com/minac/oj-safe/blob/master/CODE_OF_CONDUCT.md).

data/ext/oj-safe/safe.c

@@ -3,6 +3,462 @@
 #include "parser.h"
 #include "usual.h"
 
-void Init_safe_ext() {
+#define SET_CONFIG(config_name)                                                  \
+  do {                                                                           \
+    VALUE rb_##config_name = rb_hash_aref(options, config_name##_sym);           \
+                                                                                 \
+    if(RB_INTEGER_TYPE_P(rb_##config_name)) {                                    \
+      safe->config_name = NUM2LONG(rb_##config_name);                            \
+    } else if (!NIL_P(rb_##config_name)){                                        \
+      rb_raise(rb_eArgError, "Incorrect value provided for `" #config_name "`"); \
+    }                                                                            \
+  } while(0);
 
+static VALUE max_hash_size_sym,
+             max_array_size_sym,
+             max_depth_sym,
+             max_total_elements_sym,
+             max_json_size_bytes_sym,
+             validation_error_class;
+
+static ID parser_ivar_id,
+          parse_id,
+          bytesize_id;
+
+typedef struct _safe_S {
+  struct _usual usual;
+
+  long int max_hash_size;
+  long int max_array_size;
+  long int max_depth;
+  long int max_total_elements;
+  long int max_json_size_bytes;
+
+  long int current_hash_size;
+  long int current_array_size;
+  long int current_elements_count;
+
+  void (*delegated_start_func)(struct _ojParser *p);
+
+  // Array functions
+  void (*delegated_open_object_func)(struct _ojParser *p);
+  void (*delegated_open_array_func)(struct _ojParser *p);
+  void (*delegated_add_null_func)(struct _ojParser *p);
+  void (*delegated_add_true_func)(struct _ojParser *p);
+  void (*delegated_add_false_func)(struct _ojParser *p);
+  void (*delegated_add_int_func)(struct _ojParser *p);
+  void (*delegated_add_float_func)(struct _ojParser *p);
+  void (*delegated_add_big_func)(struct _ojParser *p);
+  void (*delegated_add_str_func)(struct _ojParser *p);
+
+  // Object functions
+  void (*delegated_open_object_key_func)(struct _ojParser *p);
+  void (*delegated_open_array_key_func)(struct _ojParser *p);
+  void (*delegated_add_null_key_func)(struct _ojParser *p);
+  void (*delegated_add_true_key_func)(struct _ojParser *p);
+  void (*delegated_add_false_key_func)(struct _ojParser *p);
+  void (*delegated_add_int_key_func)(struct _ojParser *p);
+  void (*delegated_add_float_key_func)(struct _ojParser *p);
+  void (*delegated_add_big_key_func)(struct _ojParser *p);
+  void (*delegated_add_str_key_func)(struct _ojParser *p);
+} * safe_T;
+
+static void check_object_size(safe_T safe) {
+  if(safe->max_hash_size == 0) return;
+
+  struct _usual usual = safe->usual;
+  Col current_object_location = usual.ctail - 1;
+
+  long int number_of_items_in_stack = usual.vtail - usual.vhead;
+  long int number_of_items_in_hash = (number_of_items_in_stack - current_object_location->vi - 1) / 2;
+
+  if(safe->max_hash_size > number_of_items_in_hash) return;
+
+  rb_raise(validation_error_class, "Too many object items!");
+}
+
+static void check_array_size(safe_T safe) {
+  if(safe->max_array_size == 0) return;
+
+  struct _usual usual = safe->usual;
+  Col current_object_location = usual.ctail - 1;
+
+  long int number_of_items_in_stack = usual.vtail - usual.vhead;
+  long int number_of_items_in_array = number_of_items_in_stack - current_object_location->vi - 1;
+
+  if(safe->max_array_size > number_of_items_in_array) return;
+
+  rb_raise(validation_error_class, "Too many array items!");
+}
+
+static void check_max_depth(safe_T safe, ojParser p) {
+  if(safe->max_depth == 0 || safe->max_depth >= (p->depth + 1)) return;
+
+  rb_raise(validation_error_class, "JSON is too deep!");
+}
+
+static void check_max_total_elements(safe_T safe) {
+  /*
+  * We check if `max_total_elements` is greater than `current_elements_count`
+  * (instead of greater than or equal) because top-level elements (e.g., [],
+  * null, true) are not counted. As a result, `current_elements_count`
+  * always holds one less than the actual total.
+  */
+  if(safe->max_total_elements == 0 || safe->max_total_elements > safe->current_elements_count) return;
+
+  rb_raise(validation_error_class, "Too many elements!");
+}
+
+static void check_json_size(VALUE parser, VALUE json) {
+  struct _ojParser *p;
+  TypedData_Get_Struct(parser, struct _ojParser, &oj_parser_type, p);
+
+  safe_T safe = (safe_T)p->ctx;
+  VALUE rb_json_byte_size = rb_funcall(json, bytesize_id, 0);
+  long int json_byte_size = NUM2LONG(rb_json_byte_size);
+
+  if(safe->max_json_size_bytes == 0 || safe->max_json_size_bytes >= json_byte_size) return;
+
+  rb_raise(validation_error_class, "JSON payload is too big!");
+}
+
+static void safe_start(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size = 0;
+    safe->current_array_size = 0;
+    safe->current_elements_count = 0;
+
+    safe->delegated_start_func(p);
+}
+
+static void safe_open_object(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_hash_size++;
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_depth(safe, p);
+  check_max_total_elements(safe);
+
+  safe->delegated_open_object_func(p);
+}
+
+static void safe_open_array(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_array_size++;
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_depth(safe, p);
+  check_max_total_elements(safe);
+
+  safe->delegated_open_array_func(p);
+}
+
+static void safe_add_null(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_null_func(p);
+}
+static void safe_add_true(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_true_func(p);
+}
+static void safe_add_false(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_false_func(p);
+}
+static void safe_add_int(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_int_func(p);
+}
+static void safe_add_float(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_float_func(p);
+}
+static void safe_add_big(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_big_func(p);
+}
+static void safe_add_str(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count++;
+
+  check_array_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_str_func(p);
+}
+
+static void safe_open_object_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_hash_size++;
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_depth(safe, p);
+  check_max_total_elements(safe);
+
+  safe->delegated_open_object_key_func(p);
+}
+
+static void safe_open_array_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_array_size++;
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_depth(safe, p);
+  check_max_total_elements(safe);
+
+  safe->delegated_open_array_key_func(p);
+}
+
+static void safe_add_null_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_null_key_func(p);
+}
+
+static void safe_add_true_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_true_key_func(p);
+}
+
+static void safe_add_false_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_false_key_func(p);
+}
+
+static void safe_add_int_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_int_key_func(p);
+}
+
+static void safe_add_float_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_float_key_func(p);
+}
+
+static void safe_add_big_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_big_key_func(p);
+}
+
+static void safe_add_str_key(ojParser p) {
+  safe_T safe = (safe_T)p->ctx;
+
+  safe->current_elements_count += 2;
+
+  check_object_size(safe);
+  check_max_total_elements(safe);
+
+  safe->delegated_add_str_key_func(p);
+}
+
+static void init_safe_parser(struct _ojParser *p, VALUE options) {
+  safe_T safe = ALLOC(struct _safe_S);
+
+  oj_init_usual(p, &safe->usual);
+
+  safe->delegated_start_func = p->start;
+  p->start = safe_start;
+
+  Funcs f;
+
+  // Array parser functions
+  f = &p->funcs[ARRAY_FUN];
+  safe->delegated_open_object_func = f->open_object;
+  f->open_object = safe_open_object;
+  safe->delegated_open_array_func = f->open_array;
+  f->open_array = safe_open_array;
+  // The following overrides are done for counting objects
+  safe->delegated_add_null_func = f->add_null;
+  f->add_null = safe_add_null;
+  safe->delegated_add_true_func = f->add_true;
+  f->add_true = safe_add_true;
+  safe->delegated_add_false_func = f->add_false;
+  f->add_false = safe_add_false;
+  safe->delegated_add_int_func = f->add_int;
+  f->add_int = safe_add_int;
+  safe->delegated_add_float_func = f->add_float;
+  f->add_float = safe_add_float;
+  safe->delegated_add_big_func = f->add_big;
+  f->add_big = safe_add_big;
+  safe->delegated_add_str_func = f->add_str;
+  f->add_str = safe_add_str;
+
+  // Object parser functions
+  f = &p->funcs[OBJECT_FUN];
+  safe->delegated_open_object_key_func = f->open_object;
+  f->open_object = safe_open_object_key;
+  safe->delegated_open_array_key_func = f->open_array;
+  f->open_array = safe_open_array_key;
+  // The following overrides are done for counting objects
+  safe->delegated_add_null_key_func = f->add_null;
+  f->add_null = safe_add_null_key;
+  safe->delegated_add_true_key_func = f->add_true;
+  f->add_true = safe_add_true_key;
+  safe->delegated_add_false_key_func = f->add_false;
+  f->add_false = safe_add_false_key;
+  safe->delegated_add_int_key_func = f->add_int;
+  f->add_int = safe_add_int_key;
+  safe->delegated_add_float_key_func = f->add_float;
+  f->add_float = safe_add_float_key;
+  safe->delegated_add_big_key_func = f->add_big;
+  f->add_big = safe_add_big_key;
+  safe->delegated_add_str_key_func = f->add_str;
+  f->add_str = safe_add_str_key;
+
+  // Set options
+  safe->max_hash_size = 0;
+  safe->max_array_size = 0;
+  safe->max_depth = 0;
+  safe->max_total_elements = 0;
+
+  SET_CONFIG(max_hash_size);
+  SET_CONFIG(max_array_size);
+  SET_CONFIG(max_depth);
+  SET_CONFIG(max_total_elements);
+  SET_CONFIG(max_json_size_bytes);
+}
+
+static VALUE rb_new_safe_parser(int argc, VALUE *argv, VALUE self) {
+  rb_check_arity(argc, 0, 1);
+
+  VALUE options;
+
+  if(argc == 1) {
+    options = argv[0];
+
+    Check_Type(options, T_HASH);
+  } else {
+    options = rb_hash_new();
+  }
+
+  VALUE oj_parser = oj_parser_new();
+  struct _ojParser *p;
+  TypedData_Get_Struct(oj_parser, struct _ojParser, &oj_parser_type, p);
+
+  init_safe_parser(p, options);
+
+  return oj_parser;
+}
+
+static VALUE rb_safe_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE parser = rb_new_safe_parser(argc, argv, self);
+
+  rb_ivar_set(self, parser_ivar_id, parser);
+
+  return self;
+}
+
+static VALUE rb_safe_parse(VALUE self, VALUE json) {
+  VALUE parser = rb_ivar_get(self, parser_ivar_id);
+
+  check_json_size(parser, json);
+
+  return rb_funcall(parser, parse_id, 1, json);;
+}
+
+void Init_safe_ext(void) {
+  VALUE oj_module = rb_const_get(rb_cObject, rb_intern("Oj"));
+  VALUE safe_parser_class = rb_define_class_under(oj_module, "Safe", rb_cObject);
+  validation_error_class = rb_define_class_under(safe_parser_class, "ValidationError", rb_eRuntimeError);
+  rb_gc_register_address(&validation_error_class);
+
+  max_hash_size_sym = ID2SYM(rb_intern("max_hash_size"));
+  max_array_size_sym = ID2SYM(rb_intern("max_array_size"));
+  max_depth_sym = ID2SYM(rb_intern("max_depth"));
+  max_total_elements_sym = ID2SYM(rb_intern("max_total_elements"));
+  max_json_size_bytes_sym = ID2SYM(rb_intern("max_json_size_bytes"));
+
+  parser_ivar_id = rb_intern("_parser");
+  parse_id = rb_intern("parse");
+  bytesize_id = rb_intern("bytesize");
+
+  rb_gc_register_address(&max_hash_size_sym);
+  rb_gc_register_address(&max_array_size_sym);
+  rb_gc_register_address(&max_depth_sym);
+  rb_gc_register_address(&max_total_elements_sym);
+  rb_gc_register_address(&max_json_size_bytes_sym);
+
+  rb_define_method(safe_parser_class, "initialize", rb_safe_initialize, -1);
+  rb_define_method(safe_parser_class, "parse", rb_safe_parse, 1);
 }

data/lib/oj/safe/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Oj
-  module Safe
-    VERSION = "0.1.0"
+  class Safe
+    VERSION = "0.2.0"
   end
 end

data/lib/oj/safe.rb

@@ -6,6 +6,6 @@ require_relative "safe/version"
 require_relative "safe/safe_ext"
 
 module Oj
-  module Safe
+  class Safe
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oj-safe
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mehmet Emin INAC
@@ -23,7 +23,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.16.10
-description: Parses the given JSON content if it doesn't exceed the limits.
+description: A JSON parser that enforces configurable limits on input size and structure
+  to prevent excessive resource usage.
 email:
 - mehmetemininac@gmail.com
 executables: []
@@ -31,6 +32,7 @@ extensions:
 - ext/oj-safe/extconf.rb
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
@@ -62,5 +64,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.7
 specification_version: 4
-summary: Parses given JSON content safely.
+summary: Safe JSON parser with configurable limits.
 test_files: []