MOD-4822: Disable recursion limit on RDB load (RedisJSON#919)

gkorland · web-flow · commit 5f701d062ec1 · 2023-01-30T10:29:11.000+02:00
* disable recursion limit on RDB load
diff --git a/Cargo.toml b/Cargo.toml
@@ -27,7 +27,7 @@ bitflags = "1.3"
 log = "0.4"
 bson = "0.14"
 ijson = "0.1.3"
-serde_json = "1.0"
+serde_json = { version="1.0", features = ["unbounded_depth"]}
 serde = "1.0"
 libc = "0.2"
 redis-module = { version="1.0", features = ["experimental-api"]}
diff --git a/src/commands.rs b/src/commands.rs
@@ -606,7 +606,7 @@ pub fn json_set<M: Manager>(manager: M, ctx: &Context, args: Vec<RedisString>) -
     let mut redis_key = manager.open_key_write(ctx, key)?;
     let current = redis_key.get_value()?;
 
-    let val = manager.from_str(value, format)?;
+    let val = manager.from_str(value, format, true)?;
 
     match (current, set_option) {
         (Some(ref mut doc), ref op) => {
@@ -1334,7 +1334,7 @@ pub fn json_arr_append<M: Manager>(
         Vec::with_capacity(args.len()),
         |mut acc, arg| {
             let json = arg.try_as_str()?;
-            acc.push(manager.from_str(json, Format::JSON)?);
+            acc.push(manager.from_str(json, Format::JSON, true)?);
             Ok(acc)
         },
     )?;
@@ -1494,7 +1494,7 @@ pub fn json_arr_insert<M: Manager>(
         Vec::with_capacity(args.len()),
         |mut acc, arg| {
             let json = arg.try_as_str()?;
-            acc.push(manager.from_str(json, Format::JSON)?);
+            acc.push(manager.from_str(json, Format::JSON, true)?);
             Ok(acc)
         },
     )?;
diff --git a/src/ivalue_manager.rs b/src/ivalue_manager.rs
@@ -1,9 +1,9 @@
-/*
- * Copyright Redis Ltd. 2016 - present
- * Licensed under your choice of the Redis Source Available License 2.0 (RSALv2) or
- * the Server Side Public License v1 (SSPLv1).
- */
-
+/*
+ * Copyright Redis Ltd. 2016 - present
+ * Licensed under your choice of the Redis Source Available License 2.0 (RSALv2) or
+ * the Server Side Public License v1 (SSPLv1).
+ */
+
 use crate::error::Error;
 use crate::manager::{err_json, err_msg_json_expected, err_msg_json_path_doesnt_exist};
 use crate::manager::{Manager, ReadHolder, WriteHolder};
@@ -16,7 +16,7 @@ use redis_module::key::{verify_type, RedisKey, RedisKeyWritable};
 use redis_module::raw::{RedisModuleKey, Status};
 use redis_module::rediserror::RedisError;
 use redis_module::{Context, NotifyEvent, RedisString};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use serde_json::Number;
 use std::marker::PhantomData;
 use std::mem::size_of;
@@ -601,9 +601,15 @@ impl<'a> Manager for RedisIValueJsonKeyManager<'a> {
         })
     }
 
-    fn from_str(&self, val: &str, format: Format) -> Result<Self::O, Error> {
+    fn from_str(&self, val: &str, format: Format, limit_depth: bool) -> Result<Self::O, Error> {
         match format {
-            Format::JSON => Ok(serde_json::from_str(val)?),
+            Format::JSON => {
+                let mut deserializer = serde_json::Deserializer::from_str(val);
+                if !limit_depth {
+                    deserializer.disable_recursion_limit();
+                }
+                IValue::deserialize(&mut deserializer).map_err(|e| e.into())
+            }
             Format::BSON => decode_document(&mut Cursor::new(val.as_bytes())).map_or_else(
                 |e| Err(e.to_string().into()),
                 |docs| {
@@ -619,6 +625,7 @@ impl<'a> Manager for RedisIValueJsonKeyManager<'a> {
                                 self.from_str(
                                     &String::from_utf8(out.into_inner()).unwrap(),
                                     Format::JSON,
+                                    limit_depth,
                                 )
                                 .unwrap()
                             },
diff --git a/src/manager.rs b/src/manager.rs
@@ -80,7 +80,7 @@ pub trait Manager {
         key: RedisString,
     ) -> Result<Self::WriteHolder, RedisError>;
     #[allow(clippy::wrong_self_convention)]
-    fn from_str(&self, val: &str, format: Format) -> Result<Self::O, Error>;
+    fn from_str(&self, val: &str, format: Format, limit_depth: bool) -> Result<Self::O, Error>;
     fn get_memory(&self, v: &Self::V) -> Result<usize, RedisError>;
     fn is_json(&self, key: *mut RedisModuleKey) -> Result<bool, RedisError>;
 }
diff --git a/src/redisjson.rs b/src/redisjson.rs
@@ -148,7 +148,7 @@ pub mod type_methods {
                     let m = RedisJsonKeyManager {
                         phantom: PhantomData,
                     };
-                    let v = m.from_str(&json_string, Format::JSON);
+                    let v = m.from_str(&json_string, Format::JSON, false);
                     v.map_or(null_mut(), |res| {
                         Box::into_raw(Box::new(res)).cast::<libc::c_void>()
                     })
@@ -157,7 +157,7 @@ pub mod type_methods {
                     let m = RedisIValueJsonKeyManager {
                         phantom: PhantomData,
                     };
-                    let v = m.from_str(&json_string, Format::JSON);
+                    let v = m.from_str(&json_string, Format::JSON, false);
                     v.map_or(null_mut(), |res| {
                         Box::into_raw(Box::new(res)).cast::<libc::c_void>()
                     })
diff --git a/src/serde_value_manager.rs b/src/serde_value_manager.rs
@@ -5,6 +5,7 @@
  */
 
 use crate::jsonpath::select_value::SelectValue;
+use serde::Deserialize;
 use serde_json::map::Entry;
 use serde_json::{Number, Value};
 
@@ -478,9 +479,15 @@ impl<'a> Manager for RedisJsonKeyManager<'a> {
         })
     }
 
-    fn from_str(&self, val: &str, format: Format) -> Result<Value, Error> {
+    fn from_str(&self, val: &str, format: Format, limit_depth: bool) -> Result<Value, Error> {
         match format {
-            Format::JSON => Ok(serde_json::from_str(val)?),
+            Format::JSON => {
+                let mut deserializer = serde_json::Deserializer::from_str(val);
+                if !limit_depth {
+                    deserializer.disable_recursion_limit();
+                }
+                Value::deserialize(&mut deserializer).map_err(|e| e.into())
+            }
             Format::BSON => decode_document(&mut Cursor::new(val.as_bytes()))
                 .map(|docs| {
                     let v = if docs.is_empty() {
diff --git a/tests/pytest/test.py b/tests/pytest/test.py
@@ -8,7 +8,7 @@
 import json
 from RLTest import Env
 from includes import *
-
+from redis.client import NEVER_DECODE
 from RLTest import Defaults
 
 Defaults.decode_responses = True
@@ -1279,6 +1279,20 @@ def testFilterPrecedence(env):
     r.assertEqual(json.loads(res), [doc[0]])
     r.expect('JSON.GET', 'doc', '$[?(@.f==true || @.one==1 && @.t==false)]').equal('[]')
 
+def testRDBUnboundedDepth(env):
+    # Test RDB Unbounded Depth load
+    r = env
+    json_value = nest_object(128, 5, "__leaf", 42)
+    r.expect('JSON.SET', 'doc', '$', json_value).ok()
+
+    # concat the string_126 at the end of itself
+    json_value = nest_object(3, 5, "__deep_leaf", 420)
+    r.expect('JSON.SET', 'doc', '$..__leaf', json_value).ok()
+    
+    # RDB dump and restore the key 'doc' and check that the key is still valid
+    dump = env.execute_command('dump', 'doc', **{NEVER_DECODE: []})
+    r.expect('RESTORE', 'doc1', 0, dump).ok()
+    r.expect('JSON.GET', 'doc1', '$..__leaf..__deep_leaf').equal('[420]')
 
 # class CacheTestCase(BaseReJSONTest):
 #     @property

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ pub trait Manager {`
`80`	`80`	`key: RedisString,`
`81`	`81`	`) -> Result<Self::WriteHolder, RedisError>;`
`82`	`82`	`#[allow(clippy::wrong_self_convention)]`
`83`		`- fn from_str(&self, val: &str, format: Format) -> Result<Self::O, Error>;`
	`83`	`+ fn from_str(&self, val: &str, format: Format, limit_depth: bool) -> Result<Self::O, Error>;`
`84`	`84`	`fn get_memory(&self, v: &Self::V) -> Result<usize, RedisError>;`
`85`	`85`	`fn is_json(&self, key: *mut RedisModuleKey) -> Result<bool, RedisError>;`
`86`	`86`	`}`