Prevent integer overflow when (de)serializing BackoffEntry

net/base/backoff_entry_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/backoff_entry.h"
 
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ skipping 309 matching lines @@
   for (int i = 0; i < 129; ++i) {
      custom.set_now(custom.ImplGetTimeNow() + custom.GetTimeUntilRelease());
      custom.InformOfRequest(false);
      ASSERT_TRUE(custom.ShouldRejectRequest());
   }
 
   // Max delay should still be respected.
   EXPECT_EQ(20000, custom.GetTimeUntilRelease().InMilliseconds());
 }
 
-TEST(BackoffEntryTest, SerializeTimeOffsets) {
+TEST(BackoffEntryTest, SerializationTimeOffsets) {
   TestBackoffEntry original(&base_policy);
   // 2 errors.
   original.InformOfRequest(false);
   original.InformOfRequest(false);
   scoped_ptr<base::ListValue> serialized = original.Serialize();
 
   {
-    // Test that immediate deserializeation round-trips.
+    // Test that immediate deserialization round-trips.
     TestBackoffEntry deserialized(&base_policy);
     EXPECT_TRUE(deserialized.Deserialize(*serialized));
     EXPECT_EQ(original.failure_count(), deserialized.failure_count());
     EXPECT_EQ(original.GetReleaseTime(), deserialized.GetReleaseTime());
   }
 
   {
     // Test deserialization when wall clock has advanced but TimeTicks haven't
     // (e.g. device was rebooted).
     TestBackoffEntry deserialized(&base_policy);
@@ skipping 49 matching lines @@
     deserialized.set_wall_clock_now(
         original.ImplGetWallClockTimeNow() - TimeDelta::FromDays(1));
     EXPECT_TRUE(deserialized.Deserialize(*serialized));
     EXPECT_EQ(original.failure_count(), deserialized.failure_count());
     // Deserialization should respect maximum_backoff_ms in such a situation.
     EXPECT_EQ(TimeDelta::FromMilliseconds(base_policy.maximum_backoff_ms),
               deserialized.GetTimeUntilRelease());
   }
 }
 
-TEST(BackoffEntryTest, SerializeNoFailures) {
+TEST(BackoffEntryTest, SerializationNoFailures) {
   TestBackoffEntry original(&base_policy);
   scoped_ptr<base::ListValue> serialized = original.Serialize();
 
   TestBackoffEntry deserialized(&base_policy);
   // 1 error, so that we can tell when Deserialize restores the values.
   deserialized.InformOfRequest(false);
   EXPECT_NE(original.failure_count(), deserialized.failure_count());
   EXPECT_NE(original.GetReleaseTime(), deserialized.GetReleaseTime());
 
   EXPECT_TRUE(deserialized.Deserialize(*serialized));
   EXPECT_EQ(original.failure_count(), deserialized.failure_count());
   EXPECT_EQ(original.GetReleaseTime(), deserialized.GetReleaseTime());
 }
 
+TEST(BackoffEntryTest, SerializationOverflowProtection) {
+  // Test that deserialization round-trips with extremely large positive and
+  // negative release times.
+  BackoffEntry::Policy no_maximum_policy = base_policy;
+  no_maximum_policy.maximum_backoff_ms = -1;
+
+  // Test that deserialization round-trips if ImplGetTimeNow and
+  // ImplGetWallClockTimeNow are zero throughout.
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64max - 1));
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(original.GetReleaseTime(), deserialized.GetReleaseTime());
+  }
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64min + 1));
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(original.GetReleaseTime(), deserialized.GetReleaseTime());
+  }
+
+
+  // These were the actual values when I wrote this test.
+  const TimeTicks realistic_time_ticks_now =
+      TimeTicks::FromInternalValue(304519400134);
+  const Time realistic_wall_clock_time_now =
+      Time::FromInternalValue(13071957275919685);
+
+  // Test overflow behavior, when ImplGetTimeNow and ImplGetWallClockTimeNow
+  // initially have realistic values but then decrease.
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64max - 1));
+    original.set_now(realistic_time_ticks_now);
+    original.set_wall_clock_now(realistic_wall_clock_time_now);
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(TimeTicks::FromInternalValue(kint64max),
+              deserialized.GetReleaseTime());
+  }
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64min + 1));
+    original.set_now(realistic_time_ticks_now);
+    original.set_wall_clock_now(realistic_wall_clock_time_now);
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(TimeTicks::FromInternalValue(kint64min)
+                  + (realistic_wall_clock_time_now - Time()),
+              deserialized.GetReleaseTime());
+  }
+
+  // Test overflow behavior, when ImplGetTimeNow and ImplGetWallClockTimeNow
+  // are initially zero, but then have realistic values.
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64max - 1));
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    deserialized.set_now(realistic_time_ticks_now);
+    deserialized.set_wall_clock_now(realistic_wall_clock_time_now);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(original.GetReleaseTime()
+                  - (realistic_wall_clock_time_now - Time())
+                  + (realistic_time_ticks_now - TimeTicks()),
+              deserialized.GetReleaseTime());
+  }
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64min + 1));
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    deserialized.set_now(realistic_time_ticks_now);
+    deserialized.set_wall_clock_now(realistic_wall_clock_time_now);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(TimeTicks::FromInternalValue(kint64min)
+                  + (realistic_time_ticks_now - TimeTicks()),
+              deserialized.GetReleaseTime());
+  }
+
+  // Test overflow behavior, when ImplGetTimeNow and ImplGetWallClockTimeNow
+  // have the same realistic values both before and after.
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64max - 1));
+    original.set_now(realistic_time_ticks_now);
+    original.set_wall_clock_now(realistic_wall_clock_time_now);
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    deserialized.set_now(realistic_time_ticks_now);
+    deserialized.set_wall_clock_now(realistic_wall_clock_time_now);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(TimeTicks::FromInternalValue(kint64max)
+                  - (realistic_wall_clock_time_now - Time())
+                  + (realistic_time_ticks_now - TimeTicks()),
+              deserialized.GetReleaseTime());
+  }
+  {
+    TestBackoffEntry original(&no_maximum_policy);
+    original.SetCustomReleaseTime(TimeTicks::FromInternalValue(kint64min + 1));
+    original.set_now(realistic_time_ticks_now);
+    original.set_wall_clock_now(realistic_wall_clock_time_now);
+    scoped_ptr<base::ListValue> serialized = original.Serialize();
+    TestBackoffEntry deserialized(&no_maximum_policy);
+    deserialized.set_now(realistic_time_ticks_now);
+    deserialized.set_wall_clock_now(realistic_wall_clock_time_now);
+    EXPECT_TRUE(deserialized.Deserialize(*serialized));
+    EXPECT_EQ(original.failure_count(), deserialized.failure_count());
+    EXPECT_EQ(TimeTicks::FromInternalValue(kint64min)
+              + (realistic_time_ticks_now - TimeTicks()),
+              deserialized.GetReleaseTime());
+  }
+}
+
 }  // namespace