Tweak CryptauthDeviceManager to store fetched BeaconSeed data in Base64URL encoding, and retrieve i…

components/cryptauth/cryptauth_device_manager.cc

 // Copyright 2015 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 "components/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.h>
 #include <stdexcept>
 #include <utility>
 
@@ skipping 50 matching lines @@
         || !seed.has_start_time_millis()
         || !seed.has_end_time_millis()) {
       PA_LOG(WARNING) << "Unable to serialize BeaconSeed due to missing data; "
           << "skipping.";
       continue;
     }
 
     std::unique_ptr<base::DictionaryValue> beacon_seed_value(
         new base::DictionaryValue());
 
-    // Note: Seed data is already base-64 encoded, so there is no need to
-    // convert it.
-    beacon_seed_value->SetString(kExternalDeviceKeyBeaconSeedData, seed.data());
+    // Note that the |BeaconSeed|s' data is stored in Base64Url encoding because
+    // dictionary values must be valid UTF8 strings.
+    std::string seed_data_b64;
+    base::Base64UrlEncode(seed.data(),
+                          base::Base64UrlEncodePolicy::INCLUDE_PADDING,
+                          &seed_data_b64);
+    beacon_seed_value->SetString(kExternalDeviceKeyBeaconSeedData,
+                                 seed_data_b64);
 
     // Set the timestamps as string representations of their numeric value
     // since there is no notion of a base::LongValue.
     beacon_seed_value->SetString(
         kExternalDeviceKeyBeaconSeedStartMs,
         std::to_string(seed.start_time_millis()));
     beacon_seed_value->SetString(
         kExternalDeviceKeyBeaconSeedEndMs,
         std::to_string(seed.end_time_millis()));
 
@@ skipping 77 matching lines @@
     const base::ListValue& beacon_seeds,
     cryptauth::ExternalDeviceInfo& external_device) {
   for (size_t i = 0; i < beacon_seeds.GetSize(); i++) {
     const base::DictionaryValue* seed_dictionary = nullptr;
     if (!beacon_seeds.GetDictionary(i, &seed_dictionary)) {
       PA_LOG(WARNING) << "Unable to retrieve BeaconSeed dictionary; "
           << "skipping.";
       continue;
     }
 
-    std::string data, start_time_millis_str, end_time_millis_str;
-    if (!seed_dictionary->GetString(kExternalDeviceKeyBeaconSeedData, &data)
-        || !seed_dictionary->GetString(
-            kExternalDeviceKeyBeaconSeedStartMs,
-            &start_time_millis_str)
-        || !seed_dictionary->GetString(
-            kExternalDeviceKeyBeaconSeedEndMs,
-            &end_time_millis_str)) {
+    std::string seed_data_b64, start_time_millis_str, end_time_millis_str;
+    if (!seed_dictionary->GetString(kExternalDeviceKeyBeaconSeedData,
+                                    &seed_data_b64) ||
+        !seed_dictionary->GetString(kExternalDeviceKeyBeaconSeedStartMs,
+                                    &start_time_millis_str) ||
+        !seed_dictionary->GetString(kExternalDeviceKeyBeaconSeedEndMs,
+                                    &end_time_millis_str)) {
       PA_LOG(WARNING) << "Unable to deserialize BeaconSeed due to missing "
           << "data; skipping.";
       continue;
     }
 
+    // Seed data is returned as raw data, not in Base64 encoding.
+    std::string seed_data;
+    if (!base::Base64UrlDecode(seed_data_b64,
+                               base::Base64UrlDecodePolicy::REQUIRE_PADDING,
+                               &seed_data)) {
+      PA_LOG(WARNING) << "Decoding seed data failed.";
+      continue;
+    }
+
     int64_t start_time_millis, end_time_millis;
     if (!base::StringToInt64(start_time_millis_str, &start_time_millis)
         || !base::StringToInt64(end_time_millis_str, &end_time_millis)) {
       PA_LOG(WARNING) << "Unable to convert stored timestamp to int64_t: "
           << start_time_millis_str << " or " << end_time_millis_str;
       continue;
     }
 
     cryptauth::BeaconSeed* seed = external_device.add_beacon_seeds();
-    seed->set_data(data);
+    seed->set_data(seed_data);
     seed->set_start_time_millis(start_time_millis);
     seed->set_end_time_millis(end_time_millis);
   }
 }
 
 // Converts an unlock key dictionary stored in user prefs to an
 // ExternalDeviceInfo proto. Returns true if the dictionary is valid, and the
 // parsed proto is written to |external_device|.
 bool DictionaryToUnlockKey(const base::DictionaryValue& dictionary,
                            cryptauth::ExternalDeviceInfo* external_device) {
@@ skipping 303 matching lines @@
   request.set_invocation_reason(invocation_reason);
   request.set_allow_stale_read(is_sync_speculative);
   cryptauth_client_->GetMyDevices(
       request, base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesSuccess,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesFailure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace cryptauth