Validate timestamps when encoding JSON

Closes #437.

Author: whatyouhide

conformance/exemptions.txt

@@ -12,15 +12,10 @@ Required.Proto2.ProtobufInput.BadTag_OverlongVarint
 Required.Proto2.ProtobufInput.MessageSetEncoding.UnknownExtension.ProtobufOutput
 Required.Proto2.ProtobufInput.ValidMessageSetEncoding.OutOfOrderGroupsEntries.ProtobufOutput
 Required.Proto2.ProtobufInput.ValidMessageSetEncoding.ProtobufOutput
-Required.Proto3.DurationProtoNanosTooLarge.JsonOutput
-Required.Proto3.DurationProtoNanosTooSmall.JsonOutput
-Required.Proto3.DurationProtoNanosWrongSign.JsonOutput
-Required.Proto3.DurationProtoNanosWrongSignNegativeSecs.JsonOutput
 Required.Proto3.JsonInput.AnyEmpty.JsonOutput
 Required.Proto3.JsonInput.AnyWithNoType.JsonOutput
 Required.Proto3.JsonInput.AnyWktRepresentationWithBadType
 Required.Proto3.JsonInput.AnyWktRepresentationWithEmptyTypeAndValue
 Required.Proto3.ProtobufInput.BadTag_FieldNumberSlightlyTooHigh
 Required.Proto3.ProtobufInput.BadTag_FieldNumberTooHigh
 Required.Proto3.ProtobufInput.BadTag_OverlongVarint
-Required.Proto3.TimestampProtoNegativeNanos.JsonOutput

lib/protobuf/json/encode.ex

@@ -17,6 +17,8 @@ defmodule Protobuf.JSON.Encode do
             safe_enum_key: 2}
 
   @duration_seconds_range -315_576_000_000..315_576_000_000
+  @nanos_range -999_999_999..999_999_999
+  @timestamp_nanos_range 0..999_999_999
 
   @built_in_google_messages [
     Google.Protobuf.FieldMask,
@@ -51,6 +53,13 @@ defmodule Protobuf.JSON.Encode do
       %{seconds: seconds} when seconds not in @duration_seconds_range ->
         throw({:bad_duration, :seconds_outside_of_range, seconds})
 
+      %{nanos: nanos} when nanos not in @nanos_range ->
+        throw({:bad_duration, :nanos_outside_of_range, nanos})
+
+      %{seconds: seconds, nanos: nanos}
+      when (seconds > 0 and nanos < 0) or (seconds < 0 and nanos > 0) ->
+        throw({:bad_duration, :seconds_and_nanos_different_signs, {seconds, nanos}})
+
       %{seconds: seconds, nanos: 0} ->
         Integer.to_string(seconds) <> "s"
 
@@ -63,6 +72,10 @@ defmodule Protobuf.JSON.Encode do
   def encodable(%mod{} = struct, _opts) when mod == Google.Protobuf.Timestamp do
     %{seconds: seconds, nanos: nanos} = struct
 
+    if nanos not in @timestamp_nanos_range do
+      throw({:invalid_timestamp, struct, "nanos outside of allowed range 0..999999999"})
+    end
+
     case Protobuf.JSON.RFC3339.encode(seconds, nanos) do
       {:ok, string} -> string
       {:error, reason} -> throw({:invalid_timestamp, struct, reason})

lib/protobuf/json/encode_error.ex

@@ -17,6 +17,21 @@ defmodule Protobuf.JSON.EncodeError do
     }
   end
 
+  def new({:bad_duration, :nanos_outside_of_range, nanos}) do
+    %__MODULE__{
+      message:
+        "invalid Google.Protobuf.Duration, nanos must be in -999999999..999999999, got: #{nanos}"
+    }
+  end
+
+  def new({:bad_duration, :seconds_and_nanos_different_signs, {seconds, nanos}}) do
+    %__MODULE__{
+      message:
+        "invalid Google.Protobuf.Duration, seconds and nanos must have the same sign, " <>
+          "got seconds #{seconds} and nanos #{nanos}"
+    }
+  end
+
   def new({:invalid_timestamp, timestamp, reason}) do
     %__MODULE__{
       message:

test/protobuf/json/encode_test.exs

@@ -414,6 +414,42 @@ defmodule Protobuf.JSON.EncodeTest do
       assert catch_throw(encode(message)) ==
                {:bad_duration, :seconds_outside_of_range, -max_duration - 1}
     end
+
+    test "returns an error if the nanos of the duration are too large" do
+      message = %TestAllTypesProto3{
+        optional_duration: %Google.Protobuf.Duration{seconds: 1, nanos: 1_000_000_000}
+      }
+
+      assert catch_throw(encode(message)) ==
+               {:bad_duration, :nanos_outside_of_range, 1_000_000_000}
+    end
+
+    test "returns an error if the nanos of the duration are too small" do
+      message = %TestAllTypesProto3{
+        optional_duration: %Google.Protobuf.Duration{seconds: -1, nanos: -1_000_000_000}
+      }
+
+      assert catch_throw(encode(message)) ==
+               {:bad_duration, :nanos_outside_of_range, -1_000_000_000}
+    end
+
+    test "returns an error if the seconds and nanos have different signs (positive seconds)" do
+      message = %TestAllTypesProto3{
+        optional_duration: %Google.Protobuf.Duration{seconds: 1, nanos: -1}
+      }
+
+      assert catch_throw(encode(message)) ==
+               {:bad_duration, :seconds_and_nanos_different_signs, {1, -1}}
+    end
+
+    test "returns an error if the seconds and nanos have different signs (negative seconds)" do
+      message = %TestAllTypesProto3{
+        optional_duration: %Google.Protobuf.Duration{seconds: -1, nanos: 1}
+      }
+
+      assert catch_throw(encode(message)) ==
+               {:bad_duration, :seconds_and_nanos_different_signs, {-1, 1}}
+    end
   end
 
   describe "Google.Protobuf.Timestamp" do
@@ -437,6 +473,22 @@ defmodule Protobuf.JSON.EncodeTest do
       assert catch_throw(encode(message)) ==
                {:invalid_timestamp, timestamp, "timestamp is outside of allowed range"}
     end
+
+    test "returns an error if the nanos of the timestamp are negative" do
+      timestamp = %Google.Protobuf.Timestamp{seconds: 0, nanos: -1}
+      message = %TestAllTypesProto3{optional_timestamp: timestamp}
+
+      assert catch_throw(encode(message)) ==
+               {:invalid_timestamp, timestamp, "nanos outside of allowed range 0..999999999"}
+    end
+
+    test "returns an error if the nanos of the timestamp are too large" do
+      timestamp = %Google.Protobuf.Timestamp{seconds: 0, nanos: 1_000_000_000}
+      message = %TestAllTypesProto3{optional_timestamp: timestamp}
+
+      assert catch_throw(encode(message)) ==
+               {:invalid_timestamp, timestamp, "nanos outside of allowed range 0..999999999"}
+    end
   end
 
   describe "Google.Protobuf.Value" do