Prevent integer overflow when (de)serializing BackoffEntry

net/base/backoff_entry.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 <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 
 namespace net {
 
 BackoffEntry::BackoffEntry(const BackoffEntry::Policy* const policy)
     : policy_(policy) {
   DCHECK(policy_);
   Reset();
 }
 
@@ skipping 83 matching lines @@
   // We leave exponential_backoff_release_time_ unset, meaning 0. We could
   // initialize to ImplGetTimeNow() but because it's a virtual method it's
   // not safe to call in the constructor (and the constructor calls Reset()).
   // The effects are the same, i.e. ShouldRejectRequest() will return false
   // right after Reset().
   exponential_backoff_release_time_ = base::TimeTicks();
 }
 
 scoped_ptr<base::ListValue> BackoffEntry::Serialize() const {
   scoped_ptr<base::ListValue> serialized(new base::ListValue());
+  const int64 time_ticks_now_us =
+      (ImplGetTimeNow() - base::TimeTicks()).InMicroseconds();
+  const int64 wall_clock_time_now_us =
+      (ImplGetWallClockTimeNow() - base::Time()).InMicroseconds();
+  // Do overflow checking in microseconds, the internal unit of TimeTicks, Time
+  // and TimeDelta.
+  base::internal::CheckedNumeric<int64> time_until_release_us =
+      (GetReleaseTime() - base::TimeTicks()).InMicroseconds();
+  time_until_release_us -= time_ticks_now_us;
+  base::internal::CheckedNumeric<int64> wall_clock_release_time_us =
+      time_until_release_us.ValueOrDefault(kint64min);
+  wall_clock_release_time_us += wall_clock_time_now_us;
+  serialized->AppendString(base::Int64ToString(
+      wall_clock_release_time_us.ValueOrDefault(kint64max)));
   serialized->AppendInteger(failure_count_);
-  base::Time absolute_release_time =
-      (GetReleaseTime() - ImplGetTimeNow()) + ImplGetWallClockTimeNow();
-  serialized->AppendDouble(absolute_release_time.ToDoubleT());
   return serialized;
 }
 
 bool BackoffEntry::Deserialize(const base::ListValue& serialized) {
   if (serialized.GetSize() != 2)
     return false;
+  std::string wall_clock_release_time_string;
+  if (!serialized.GetString(0, &wall_clock_release_time_string))
+    return false;
+  int64 wall_clock_release_time_us;
+  if (!base::StringToInt64(wall_clock_release_time_string,
+                           &wall_clock_release_time_us))
+    return false;
   int failure_count;
-  if (!serialized.GetInteger(0, &failure_count))
+  if (!serialized.GetInteger(1, &failure_count))
     return false;
-  double absolute_release_time_double;
-  if (!serialized.GetDouble(1, &absolute_release_time_double))
-    return false;
+  const int64 wall_clock_time_now_us =
+      (ImplGetWallClockTimeNow() - base::Time()).InMicroseconds();
+  base::internal::CheckedNumeric<int64> time_until_release_us =
+      wall_clock_release_time_us;
+  time_until_release_us -= wall_clock_time_now_us;
+  exponential_backoff_release_time_ =
+      TimeUntilReleaseToReleaseTime(base::TimeDelta::FromMicroseconds(
+          time_until_release_us.ValueOrDefault(kint64min)));
   failure_count_ = failure_count;
-  base::Time absolute_release_time =
-      base::Time::FromDoubleT(absolute_release_time_double);
-  base::TimeDelta time_until_release =
-      absolute_release_time - ImplGetWallClockTimeNow();
-  exponential_backoff_release_time_ =
-      TimeUntilReleaseToReleaseTime(time_until_release);
   return true;
 }
 
 base::TimeTicks BackoffEntry::ImplGetTimeNow() const {
   return base::TimeTicks::Now();
 }
 
 base::Time BackoffEntry::ImplGetWallClockTimeNow() const {
   return base::Time::Now();
 }
@@ skipping 56 matching lines @@
   // Decide between maximum release time and calculated release time, accounting
   // for overflow with both.
   int64 release_time_us = std::min(
       calculated_release_time_us.ValueOrDefault(kint64max),
       maximum_release_time_us.ValueOrDefault(kint64max));
 
   return base::TimeTicks() + base::TimeDelta::FromMicroseconds(release_time_us);
 }
 
 }  // namespace net