Fail on primitive type overflow during JsonElement deserialization

Fixes #1300
Kotlin · Jan 20, 2021 · b334fb9 · b334fb9
1 parent 5eb6fa8
commit b334fb9
Show file tree

Hide file tree

Showing 2 changed files with 71 additions and 7 deletions.
diff --git a/formats/json/commonMain/src/kotlinx/serialization/json/internal/TreeJsonDecoder.kt b/formats/json/commonMain/src/kotlinx/serialization/json/internal/TreeJsonDecoder.kt
@@ -102,8 +102,18 @@ private sealed class AbstractJsonTreeDecoder(
         }
     }
 
-    override fun decodeTaggedByte(tag: String) = getValue(tag).primitive("byte") { int.toByte() }
-    override fun decodeTaggedShort(tag: String) = getValue(tag).primitive("short") { int.toShort() }
+    override fun decodeTaggedByte(tag: String) = getValue(tag).primitive("byte") {
+        val result = int
+        if (result in Byte.MIN_VALUE..Byte.MAX_VALUE) result.toByte()
+        else null
+    }
+
+    override fun decodeTaggedShort(tag: String) = getValue(tag).primitive("short") {
+        val result = int
+        if (result in Short.MIN_VALUE..Short.MAX_VALUE) result.toShort()
+        else null
+    }
+
     override fun decodeTaggedInt(tag: String) = getValue(tag).primitive("int") { int }
     override fun decodeTaggedLong(tag: String) = getValue(tag).primitive("long") { long }
 
@@ -123,14 +133,18 @@ private sealed class AbstractJsonTreeDecoder(
 
     override fun decodeTaggedChar(tag: String): Char = getValue(tag).primitive("char") { content.single() }
 
-    private inline fun <T: Any> JsonPrimitive.primitive(primitive: String, block: JsonPrimitive.() -> T): T {
+    private inline fun <T: Any> JsonPrimitive.primitive(primitive: String, block: JsonPrimitive.() -> T?): T {
         try {
-            return block()
+            return block() ?: unparsedPrimitive(primitive)
         } catch (e: IllegalArgumentException) {
-            throw JsonDecodingException(-1, "Failed to parse '$primitive'", currentObject().toString())
+            unparsedPrimitive(primitive)
         }
     }
 
+    private fun unparsedPrimitive(primitive: String): Nothing {
+        throw JsonDecodingException(-1, "Failed to parse '$primitive'", currentObject().toString())
+    }
+
     override fun decodeTaggedString(tag: String): String {
         val value = getValue(tag)
         if (!json.configuration.isLenient) {

diff --git a/formats/json/commonTest/src/kotlinx/serialization/json/JsonParserFailureModesTest.kt b/formats/json/commonTest/src/kotlinx/serialization/json/JsonParserFailureModesTest.kt
@@ -54,6 +54,14 @@ class JsonParserFailureModesTest : JsonTestBase() {
                     it
                 )
             }
+            // 9223372036854775807 is Long.MAX_VALUE
+            assertFailsWith<JsonDecodingException> {
+                default.decodeFromString(
+                    Holder.serializer(),
+                    """{"id":922337203685477580700}""",
+                    it
+                )
+            }
             assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"id"}""", it) }
             assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"id}""", it) }
             assertFailsWith<JsonDecodingException> { default.decodeFromString(Holder.serializer(), """{"i}""", it) }
@@ -70,7 +78,49 @@ class JsonParserFailureModesTest : JsonTestBase() {
 
     @Test
     fun testBoolean() = parametrizedTest {
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(BooleanHolder.serializer(), """{"b": fals}""", it) }
-        assertFailsWith<JsonDecodingException> { default.decodeFromString(BooleanHolder.serializer(), """{"b": 123}""", it) }
+        assertFailsWith<JsonDecodingException> {
+            default.decodeFromString(
+                BooleanHolder.serializer(),
+                """{"b": fals}""",
+                it
+            )
+        }
+        assertFailsWith<JsonDecodingException> {
+            default.decodeFromString(
+                BooleanHolder.serializer(),
+                """{"b": 123}""",
+                it
+            )
+        }
+    }
+
+    @Serializable
+    class PrimitiveHolder(
+        val b: Byte = 0, val s: Short = 0, val i: Int = 0
+    )
+
+    @Test
+    fun testOverflow() = parametrizedTest {
+        // Byte overflow
+        assertFailsWith<JsonDecodingException> { default.decodeFromString<PrimitiveHolder>("""{"b": 128}""", it) }
+        // Short overflow
+        assertFailsWith<JsonDecodingException> { default.decodeFromString<PrimitiveHolder>("""{"s": 32768}""", it) }
+        // Int overflow
+        assertFailsWith<JsonDecodingException> {
+            default.decodeFromString<PrimitiveHolder>(
+                """{"i": 2147483648}""",
+                it
+            )
+        }
+    }
+
+    @Test
+    fun testNoOverflow() = parametrizedTest {
+        default.decodeFromString<PrimitiveHolder>("""{"b": ${Byte.MAX_VALUE}}""", it)
+        default.decodeFromString<PrimitiveHolder>("""{"b": ${Byte.MIN_VALUE}}""", it)
+        default.decodeFromString<PrimitiveHolder>("""{"s": ${Short.MAX_VALUE}}""", it)
+        default.decodeFromString<PrimitiveHolder>("""{"s": ${Short.MIN_VALUE}}""", it)
+        default.decodeFromString<PrimitiveHolder>("""{"i": ${Int.MAX_VALUE}}""", it)
+        default.decodeFromString<PrimitiveHolder>("""{"i": ${Int.MIN_VALUE}}""", it)
     }
 }