libweave: Copy data_encoding.cc into libweave It's reducing dependency on libchromeos. BUG=brillo:1257 TEST=`FEATURES=test emerge-gizmo libweave buffet` Change-Id: I8356302accb368e717777fd578caa2ba018a29dd Reviewed-on: https://chromium-review.googlesource.com/293631 Reviewed-by: Alex Vakulenko <avakulenko@chromium.org> Commit-Queue: Vitaly Buka <vitalybuka@chromium.org> Trybot-Ready: Vitaly Buka <vitalybuka@chromium.org> Tested-by: Vitaly Buka <vitalybuka@chromium.org>
diff --git a/libweave/libweave.gyp b/libweave/libweave.gyp index badd394..8903b28 100644 --- a/libweave/libweave.gyp +++ b/libweave/libweave.gyp
@@ -17,10 +17,14 @@ { 'target_name': 'libweave_external', 'type': 'static_library', + 'include_dirs': [ + '../libweave/third_party/modp_b64/modp_b64/', + ], 'sources': [ 'external/crypto/p224.cc', 'external/crypto/p224_spake.cc', 'external/crypto/sha2.cc', + 'third_party/modp_b64/modp_b64.cc', ], }, { @@ -43,6 +47,7 @@ 'src/commands/schema_constants.cc', 'src/commands/schema_utils.cc', 'src/commands/user_role.cc', + 'src/data_encoding.cc', 'src/device_manager.cc', 'src/device_registration_info.cc', 'src/http_constants.cc', @@ -132,6 +137,7 @@ 'src/commands/command_queue_unittest.cc', 'src/commands/object_schema_unittest.cc', 'src/commands/schema_utils_unittest.cc', + 'src/data_encoding_unittest.cc', 'src/device_registration_info_unittest.cc', 'src/notification/notification_parser_unittest.cc', 'src/notification/xml_node_unittest.cc',
diff --git a/libweave/src/data_encoding.cc b/libweave/src/data_encoding.cc new file mode 100644 index 0000000..817cbfc --- /dev/null +++ b/libweave/src/data_encoding.cc
@@ -0,0 +1,150 @@ +// Copyright 2014 The Chromium OS 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 "libweave/src/data_encoding.h" + +#include <memory> + +#include <base/logging.h> +#include <base/strings/string_util.h> +#include <base/strings/stringprintf.h> +#include <chromeos/strings/string_utils.h> + +#include "libweave/third_party/modp_b64/modp_b64/modp_b64.h" + +namespace weave { + +namespace { + +inline int HexToDec(int hex) { + int dec = -1; + if (hex >= '0' && hex <= '9') { + dec = hex - '0'; + } else if (hex >= 'A' && hex <= 'F') { + dec = hex - 'A' + 10; + } else if (hex >= 'a' && hex <= 'f') { + dec = hex - 'a' + 10; + } + return dec; +} + +// Helper for Base64Encode() and Base64EncodeWrapLines(). +std::string Base64EncodeHelper(const void* data, size_t size) { + std::vector<char> buffer; + buffer.resize(modp_b64_encode_len(size)); + size_t out_size = + modp_b64_encode(buffer.data(), static_cast<const char*>(data), size); + return std::string{buffer.begin(), buffer.begin() + out_size}; +} + +} // namespace + +std::string UrlEncode(const char* data, bool encodeSpaceAsPlus) { + std::string result; + + while (*data) { + char c = *data++; + // According to RFC3986 (http://www.faqs.org/rfcs/rfc3986.html), + // section 2.3. - Unreserved Characters + if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || + (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || + c == '~') { + result += c; + } else if (c == ' ' && encodeSpaceAsPlus) { + // For historical reasons, some URLs have spaces encoded as '+', + // this also applies to form data encoded as + // 'application/x-www-form-urlencoded' + result += '+'; + } else { + base::StringAppendF(&result, "%%%02X", + static_cast<unsigned char>(c)); // Encode as %NN + } + } + return result; +} + +std::string UrlDecode(const char* data) { + std::string result; + while (*data) { + char c = *data++; + int part1 = 0, part2 = 0; + // HexToDec would return -1 even for character 0 (end of string), + // so it is safe to access data[0] and data[1] without overrunning the buf. + if (c == '%' && (part1 = HexToDec(data[0])) >= 0 && + (part2 = HexToDec(data[1])) >= 0) { + c = static_cast<char>((part1 << 4) | part2); + data += 2; + } else if (c == '+') { + c = ' '; + } + result += c; + } + return result; +} + +std::string WebParamsEncode(const WebParamList& params, + bool encodeSpaceAsPlus) { + std::vector<std::string> pairs; + pairs.reserve(params.size()); + for (const auto& p : params) { + std::string key = UrlEncode(p.first.c_str(), encodeSpaceAsPlus); + std::string value = UrlEncode(p.second.c_str(), encodeSpaceAsPlus); + pairs.push_back(chromeos::string_utils::Join("=", key, value)); + } + + return chromeos::string_utils::Join("&", pairs); +} + +WebParamList WebParamsDecode(const std::string& data) { + WebParamList result; + std::vector<std::string> params = chromeos::string_utils::Split(data, "&"); + for (const auto& p : params) { + auto pair = chromeos::string_utils::SplitAtFirst(p, "="); + result.emplace_back(UrlDecode(pair.first.c_str()), + UrlDecode(pair.second.c_str())); + } + return result; +} + +std::string Base64Encode(const void* data, size_t size) { + return Base64EncodeHelper(data, size); +} + +std::string Base64EncodeWrapLines(const void* data, size_t size) { + std::string unwrapped = Base64EncodeHelper(data, size); + std::string wrapped; + + for (size_t i = 0; i < unwrapped.size(); i += 64) { + wrapped.append(unwrapped, i, 64); + wrapped.append("\n"); + } + return wrapped; +} + +bool Base64Decode(const std::string& input, chromeos::Blob* output) { + std::string temp_buffer; + const std::string* data = &input; + if (input.find_first_of("\r\n") != std::string::npos) { + base::ReplaceChars(input, "\n", "", &temp_buffer); + base::ReplaceChars(temp_buffer, "\r", "", &temp_buffer); + data = &temp_buffer; + } + // base64 decoded data has 25% fewer bytes than the original (since every + // 3 source octets are encoded as 4 characters in base64). + // modp_b64_decode_len provides an upper estimate of the size of the output + // data. + output->resize(modp_b64_decode_len(data->size())); + + size_t size_read = modp_b64_decode(reinterpret_cast<char*>(output->data()), + data->data(), data->size()); + if (size_read == MODP_B64_ERROR) { + output->resize(0); + return false; + } + output->resize(size_read); + + return true; +} + +} // namespace weave
diff --git a/libweave/src/data_encoding.h b/libweave/src/data_encoding.h new file mode 100644 index 0000000..ff6973d --- /dev/null +++ b/libweave/src/data_encoding.h
@@ -0,0 +1,78 @@ +// Copyright 2014 The Chromium OS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef LIBWEAVE_SRC_DATA_ENCODING_H_ +#define LIBWEAVE_SRC_DATA_ENCODING_H_ + +#include <string> +#include <utility> +#include <vector> + +#include <chromeos/secure_blob.h> + +namespace weave { + +using WebParamList = std::vector<std::pair<std::string, std::string>>; + +// Encode/escape string to be used in the query portion of a URL. +// If |encodeSpaceAsPlus| is set to true, spaces are encoded as '+' instead +// of "%20" +std::string UrlEncode(const char* data, bool encodeSpaceAsPlus); + +inline std::string UrlEncode(const char* data) { + return UrlEncode(data, true); +} + +// Decodes/unescapes a URL. Replaces all %XX sequences with actual characters. +// Also replaces '+' with spaces. +std::string UrlDecode(const char* data); + +// Converts a list of key-value pairs into a string compatible with +// 'application/x-www-form-urlencoded' content encoding. +std::string WebParamsEncode(const WebParamList& params, bool encodeSpaceAsPlus); + +inline std::string WebParamsEncode(const WebParamList& params) { + return WebParamsEncode(params, true); +} + +// Parses a string of '&'-delimited key-value pairs (separated by '=') and +// encoded in a way compatible with 'application/x-www-form-urlencoded' +// content encoding. +WebParamList WebParamsDecode(const std::string& data); + +// Encodes binary data using base64-encoding. +std::string Base64Encode(const void* data, size_t size); + +// Encodes binary data using base64-encoding and wraps lines at 64 character +// boundary using LF as required by PEM (RFC 1421) specification. +std::string Base64EncodeWrapLines(const void* data, size_t size); + +// Decodes the input string from Base64. +bool Base64Decode(const std::string& input, chromeos::Blob* output); + +// Helper wrappers to use std::string and chromeos::Blob as binary data +// containers. +inline std::string Base64Encode(const chromeos::Blob& input) { + return Base64Encode(input.data(), input.size()); +} +inline std::string Base64EncodeWrapLines(const chromeos::Blob& input) { + return Base64EncodeWrapLines(input.data(), input.size()); +} +inline std::string Base64Encode(const std::string& input) { + return Base64Encode(input.data(), input.size()); +} +inline std::string Base64EncodeWrapLines(const std::string& input) { + return Base64EncodeWrapLines(input.data(), input.size()); +} +inline bool Base64Decode(const std::string& input, std::string* output) { + chromeos::Blob blob; + if (!Base64Decode(input, &blob)) + return false; + *output = std::string{blob.begin(), blob.end()}; + return true; +} + +} // namespace weave + +#endif // LIBWEAVE_SRC_DATA_ENCODING_H_
diff --git a/libweave/src/data_encoding_unittest.cc b/libweave/src/data_encoding_unittest.cc new file mode 100644 index 0000000..28d6b85 --- /dev/null +++ b/libweave/src/data_encoding_unittest.cc
@@ -0,0 +1,145 @@ +// Copyright (c) 2011 The Chromium OS 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 "libweave/src/data_encoding.h" + +#include <algorithm> +#include <numeric> + +#include <gtest/gtest.h> + +namespace weave { + +TEST(data_encoding, UrlEncoding) { + std::string test = "\"http://sample/path/0014.html \""; + std::string encoded = UrlEncode(test.c_str()); + EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html+%22", encoded); + EXPECT_EQ(test, UrlDecode(encoded.c_str())); + + test = "\"http://sample/path/0014.html \""; + encoded = UrlEncode(test.c_str(), false); + EXPECT_EQ("%22http%3A%2F%2Fsample%2Fpath%2F0014.html%20%22", encoded); + EXPECT_EQ(test, UrlDecode(encoded.c_str())); +} + +TEST(data_encoding, WebParamsEncoding) { + std::string encoded = + WebParamsEncode({{"q", "test"}, {"path", "/usr/bin"}, {"#", "%"}}); + EXPECT_EQ("q=test&path=%2Fusr%2Fbin&%23=%25", encoded); + + auto params = WebParamsDecode(encoded); + EXPECT_EQ(3, params.size()); + EXPECT_EQ("q", params[0].first); + EXPECT_EQ("test", params[0].second); + EXPECT_EQ("path", params[1].first); + EXPECT_EQ("/usr/bin", params[1].second); + EXPECT_EQ("#", params[2].first); + EXPECT_EQ("%", params[2].second); +} + +TEST(data_encoding, Base64Encode) { + const std::string text1 = "hello world"; + const std::string encoded1 = "aGVsbG8gd29ybGQ="; + + const std::string text2 = + "Lorem ipsum dolor sit amet, facilisis erat nec aliquam, scelerisque " + "molestie commodo. Viverra tincidunt integer erat ipsum, integer " + "molestie, arcu in, sit mauris ac a sed sit etiam."; + const std::string encoded2 = + "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGZhY2lsaXNpcyBlcmF0IG5lYyBhbGlxdWF" + "tLCBzY2VsZXJpc3F1ZSBtb2xlc3RpZSBjb21tb2RvLiBWaXZlcnJhIHRpbmNpZHVudCBpbn" + "RlZ2VyIGVyYXQgaXBzdW0sIGludGVnZXIgbW9sZXN0aWUsIGFyY3UgaW4sIHNpdCBtYXVya" + "XMgYWMgYSBzZWQgc2l0IGV0aWFtLg=="; + + chromeos::Blob data3(256); + std::iota(data3.begin(), data3.end(), 0); // Fills the buffer with 0x00-0xFF. + const std::string encoded3 = + "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ" + "1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaW" + "prbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en" + "6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU" + "1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=="; + + EXPECT_EQ(encoded1, Base64Encode(text1)); + EXPECT_EQ(encoded2, Base64Encode(text2)); + EXPECT_EQ(encoded3, Base64Encode(data3)); +} + +TEST(data_encoding, Base64EncodeWrapLines) { + const std::string text1 = "hello world"; + const std::string encoded1 = "aGVsbG8gd29ybGQ=\n"; + + const std::string text2 = + "Lorem ipsum dolor sit amet, facilisis erat nec aliquam, scelerisque " + "molestie commodo. Viverra tincidunt integer erat ipsum, integer " + "molestie, arcu in, sit mauris ac a sed sit etiam."; + const std::string encoded2 = + "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGZhY2lsaXNpcyBlcmF0IG5lYyBh\n" + "bGlxdWFtLCBzY2VsZXJpc3F1ZSBtb2xlc3RpZSBjb21tb2RvLiBWaXZlcnJhIHRp\n" + "bmNpZHVudCBpbnRlZ2VyIGVyYXQgaXBzdW0sIGludGVnZXIgbW9sZXN0aWUsIGFy\n" + "Y3UgaW4sIHNpdCBtYXVyaXMgYWMgYSBzZWQgc2l0IGV0aWFtLg==\n"; + + chromeos::Blob data3(256); + std::iota(data3.begin(), data3.end(), 0); // Fills the buffer with 0x00-0xFF. + const std::string encoded3 = + "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4v\n" + "MDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5f\n" + "YGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6P\n" + "kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/\n" + "wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v\n" + "8PHy8/T19vf4+fr7/P3+/w==\n"; + + EXPECT_EQ(encoded1, Base64EncodeWrapLines(text1)); + EXPECT_EQ(encoded2, Base64EncodeWrapLines(text2)); + EXPECT_EQ(encoded3, Base64EncodeWrapLines(data3)); +} + +TEST(data_encoding, Base64Decode) { + const std::string encoded1 = "dGVzdCBzdHJpbmc="; + + const std::string encoded2 = + "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGZhY2lsaXNpcyBlcmF0IG5lYyBh\n" + "bGlxdWFtLCBzY2VsZXJpc3F1ZSBtb2xlc3RpZSBjb21tb2RvLiBWaXZlcnJhIHRp\r\n" + "bmNpZHVudCBpbnRlZ2VyIGVyYXQgaXBzdW0sIGludGVnZXIgbW9sZXN0aWUsIGFy\r" + "Y3UgaW4sIHNpdCBtYXVyaXMgYWMgYSBzZWQgc2l0IGV0aWFt\n" + "Lg==\n\n\n"; + const std::string decoded2 = + "Lorem ipsum dolor sit amet, facilisis erat nec aliquam, scelerisque " + "molestie commodo. Viverra tincidunt integer erat ipsum, integer " + "molestie, arcu in, sit mauris ac a sed sit etiam."; + + const std::string encoded3 = + "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ" + "1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaW" + "prbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en" + "6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU" + "1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=="; + chromeos::Blob decoded3(256); + std::iota(decoded3.begin(), decoded3.end(), 0); // Fill with 0x00..0xFF. + + std::string decoded; + EXPECT_TRUE(Base64Decode(encoded1, &decoded)); + EXPECT_EQ("test string", decoded); + + EXPECT_TRUE(Base64Decode(encoded2, &decoded)); + EXPECT_EQ(decoded2, decoded); + + chromeos::Blob decoded_blob; + EXPECT_TRUE(Base64Decode(encoded3, &decoded_blob)); + EXPECT_EQ(decoded3, decoded_blob); + + EXPECT_FALSE(Base64Decode("A", &decoded_blob)); + EXPECT_TRUE(decoded_blob.empty()); + + EXPECT_TRUE(Base64Decode("/w==", &decoded_blob)); + EXPECT_EQ((chromeos::Blob{0xFF}), decoded_blob); + + EXPECT_TRUE(Base64Decode("//8=", &decoded_blob)); + EXPECT_EQ((chromeos::Blob{0xFF, 0xFF}), decoded_blob); + + EXPECT_FALSE(Base64Decode("AAECAwQFB,cI", &decoded_blob)); + EXPECT_TRUE(decoded_blob.empty()); +} + +} // namespace weave
diff --git a/libweave/src/device_registration_info.cc b/libweave/src/device_registration_info.cc index 6696134..0b155a4 100644 --- a/libweave/src/device_registration_info.cc +++ b/libweave/src/device_registration_info.cc
@@ -18,7 +18,6 @@ #include <chromeos/bind_lambda.h> #include <chromeos/key_value_store.h> #include <chromeos/strings/string_utils.h> -#include <chromeos/data_encoding.h> #include <weave/http_client.h> #include <weave/network.h> #include <weave/task_runner.h> @@ -27,6 +26,7 @@ #include "libweave/src/commands/command_definition.h" #include "libweave/src/commands/command_manager.h" #include "libweave/src/commands/schema_constants.h" +#include "libweave/src/data_encoding.h" #include "libweave/src/http_constants.h" #include "libweave/src/json_error_codes.h" #include "libweave/src/notification/xmpp_channel.h" @@ -75,18 +75,17 @@ } } -std::string AppendQueryParams( - const std::string& url, - const chromeos::data_encoding::WebParamList& params) { +std::string AppendQueryParams(const std::string& url, + const WebParamList& params) { CHECK_EQ(std::string::npos, url.find_first_of("?#")); if (params.empty()) return url; - return url + '?' + chromeos::data_encoding::WebParamsEncode(params); + return url + '?' + WebParamsEncode(params); } std::string BuildURL(const std::string& url, const std::string& subpath, - const chromeos::data_encoding::WebParamList& params) { + const WebParamList& params) { std::string result = url; if (!result.empty() && result.back() != '/' && !subpath.empty()) { CHECK_NE('/', subpath.front()); @@ -142,8 +141,7 @@ void SetFormData( const std::vector<std::pair<std::string, std::string>>& data) { - SetData(chromeos::data_encoding::WebParamsEncode(data), - http::kWwwFormUrlEncoded); + SetData(WebParamsEncode(data), http::kWwwFormUrlEncoded); } void SetJsonData(const base::Value& json) { @@ -256,13 +254,13 @@ std::string DeviceRegistrationInfo::GetServiceURL( const std::string& subpath, - const chromeos::data_encoding::WebParamList& params) const { + const WebParamList& params) const { return BuildURL(config_->service_url(), subpath, params); } std::string DeviceRegistrationInfo::GetDeviceURL( const std::string& subpath, - const chromeos::data_encoding::WebParamList& params) const { + const WebParamList& params) const { CHECK(!config_->device_id().empty()) << "Must have a valid device ID"; return BuildURL(config_->service_url(), "devices/" + config_->device_id() + "/" + subpath, params); @@ -270,7 +268,7 @@ std::string DeviceRegistrationInfo::GetOAuthURL( const std::string& subpath, - const chromeos::data_encoding::WebParamList& params) const { + const WebParamList& params) const { return BuildURL(config_->oauth_url(), subpath, params); }
diff --git a/libweave/src/device_registration_info.h b/libweave/src/device_registration_info.h index f162ee4..e0515a9 100644 --- a/libweave/src/device_registration_info.h +++ b/libweave/src/device_registration_info.h
@@ -18,7 +18,6 @@ #include <base/single_thread_task_runner.h> #include <base/time/time.h> #include <base/timer/timer.h> -#include <chromeos/data_encoding.h> #include <chromeos/errors/error.h> #include <weave/cloud.h> #include <weave/config.h> @@ -28,6 +27,7 @@ #include "libweave/src/buffet_config.h" #include "libweave/src/commands/cloud_command_update_interface.h" #include "libweave/src/commands/command_manager.h" +#include "libweave/src/data_encoding.h" #include "libweave/src/notification/notification_channel.h" #include "libweave/src/notification/notification_delegate.h" #include "libweave/src/notification/pull_channel.h" @@ -102,28 +102,25 @@ // appended to the base URL which is normally // https://www.googleapis.com/clouddevices/v1/". // If |params| are specified, each key-value pair is formatted using - // chromeos::data_encoding::WebParamsEncode() and appended to URL as a query + // WebParamsEncode() and appended to URL as a query // string. // So, calling: // GetServiceURL("ticket", {{"key","apiKey"}}) // will return something like: // https://www.googleapis.com/clouddevices/v1/ticket?key=apiKey - std::string GetServiceURL( - const std::string& subpath = {}, - const chromeos::data_encoding::WebParamList& params = {}) const; + std::string GetServiceURL(const std::string& subpath = {}, + const WebParamList& params = {}) const; // Returns a service URL to access the registered device on GCD server. // The base URL used to construct the full URL looks like this: // https://www.googleapis.com/clouddevices/v1/devices/<device_id>/ - std::string GetDeviceURL( - const std::string& subpath = {}, - const chromeos::data_encoding::WebParamList& params = {}) const; + std::string GetDeviceURL(const std::string& subpath = {}, + const WebParamList& params = {}) const; // Similar to GetServiceURL, GetOAuthURL() returns a URL of OAuth 2.0 server. // The base URL used is https://accounts.google.com/o/oauth2/. - std::string GetOAuthURL( - const std::string& subpath = {}, - const chromeos::data_encoding::WebParamList& params = {}) const; + std::string GetOAuthURL(const std::string& subpath = {}, + const WebParamList& params = {}) const; // Starts GCD device if credentials available. void Start();
diff --git a/libweave/src/device_registration_info_unittest.cc b/libweave/src/device_registration_info_unittest.cc index 711755d..5e368d3 100644 --- a/libweave/src/device_registration_info_unittest.cc +++ b/libweave/src/device_registration_info_unittest.cc
@@ -75,7 +75,7 @@ std::string GetFormField(const std::string& data, const std::string& name) { EXPECT_FALSE(data.empty()); - for (const auto& i : chromeos::data_encoding::WebParamsDecode(data)) { + for (const auto& i : WebParamsDecode(data)) { if (i.first == name) return i.second; }
diff --git a/libweave/src/notification/xmpp_channel.cc b/libweave/src/notification/xmpp_channel.cc index 13a3565..2715dd9 100644 --- a/libweave/src/notification/xmpp_channel.cc +++ b/libweave/src/notification/xmpp_channel.cc
@@ -7,11 +7,11 @@ #include <string> #include <base/bind.h> -#include <chromeos/data_encoding.h> #include <weave/network.h> #include <weave/task_runner.h> #include "libweave/src/backoff_entry.h" +#include "libweave/src/data_encoding.h" #include "libweave/src/notification/notification_delegate.h" #include "libweave/src/notification/notification_parser.h" #include "libweave/src/notification/xml_node.h" @@ -40,7 +40,7 @@ "auth:allow-non-google-login='true' " "auth:client-uses-full-bind-result='true' " "xmlns:auth='http://www.google.com/talk/protocol/auth'>" + - chromeos::data_encoding::Base64Encode(credentials) + "</auth>"; + Base64Encode(credentials) + "</auth>"; return msg; } @@ -278,7 +278,7 @@ } std::string data = node->text(); std::string json_data; - if (!chromeos::data_encoding::Base64Decode(data, &json_data)) { + if (!Base64Decode(data, &json_data)) { LOG(WARNING) << "Failed to decode base64-encoded message payload: " << data; return; }
diff --git a/libweave/src/privet/security_manager.cc b/libweave/src/privet/security_manager.cc index cc5f64a..5888b41 100644 --- a/libweave/src/privet/security_manager.cc +++ b/libweave/src/privet/security_manager.cc
@@ -17,12 +17,12 @@ #include <base/strings/string_number_conversions.h> #include <base/strings/stringprintf.h> #include <base/time/time.h> -#include <chromeos/data_encoding.h> #include <chromeos/key_value_store.h> #include <chromeos/strings/string_utils.h> #include <weave/task_runner.h> #include "libweave/external/crypto/p224_spake.h" +#include "libweave/src/data_encoding.h" #include "libweave/src/privet/constants.h" #include "libweave/src/privet/openssl_utils.h" @@ -159,7 +159,7 @@ const base::Time& time) { chromeos::SecureBlob data(CreateTokenData(user_info, time)); chromeos::Blob hash(HmacSha256(secret_, data)); - return chromeos::data_encoding::Base64Encode(chromeos::SecureBlob::Combine( + return Base64Encode(chromeos::SecureBlob::Combine( chromeos::SecureBlob(hash.begin(), hash.end()), data)); } @@ -167,8 +167,7 @@ UserInfo SecurityManager::ParseAccessToken(const std::string& token, base::Time* time) const { chromeos::Blob decoded; - if (!chromeos::data_encoding::Base64Decode(token, &decoded) || - decoded.size() <= kSha256OutputSize) { + if (!Base64Decode(token, &decoded) || decoded.size() <= kSha256OutputSize) { return UserInfo{}; } chromeos::SecureBlob data(decoded.begin() + kSha256OutputSize, decoded.end()); @@ -193,7 +192,7 @@ if (is_security_disabled_) return true; chromeos::Blob auth_decoded; - if (!chromeos::data_encoding::Base64Decode(auth_code, &auth_decoded)) + if (!Base64Decode(auth_code, &auth_decoded)) return false; for (const auto& session : confirmed_sessions_) { if (auth_decoded == @@ -292,7 +291,7 @@ base::TimeDelta::FromMinutes(kPairingExpirationTimeMinutes)); *session_id = session; - *device_commitment = chromeos::data_encoding::Base64Encode(commitment); + *device_commitment = Base64Encode(commitment); LOG(INFO) << "Pairing code for session " << *session_id << " is " << code; // TODO(vitalybuka): Handle case when device can't start multiple pairing // simultaneously and implement throttling to avoid brute force attack. @@ -319,7 +318,7 @@ CHECK(!certificate_fingerprint_.empty()); chromeos::Blob commitment; - if (!chromeos::data_encoding::Base64Decode(client_commitment, &commitment)) { + if (!Base64Decode(client_commitment, &commitment)) { ClosePendingSession(session_id); chromeos::Error::AddToPrintf( error, FROM_HERE, errors::kDomain, errors::kInvalidFormat, @@ -339,12 +338,11 @@ std::string key = session->second->GetKey(); VLOG(3) << "KEY " << base::HexEncode(key.data(), key.size()); - *fingerprint = - chromeos::data_encoding::Base64Encode(certificate_fingerprint_); + *fingerprint = Base64Encode(certificate_fingerprint_); chromeos::Blob cert_hmac = HmacSha256(chromeos::SecureBlob(session->second->GetKey()), certificate_fingerprint_); - *signature = chromeos::data_encoding::Base64Encode(cert_hmac); + *signature = Base64Encode(cert_hmac); confirmed_sessions_.emplace(session->first, std::move(session->second)); task_runner_->PostDelayedTask( FROM_HERE,
diff --git a/libweave/src/privet/security_manager_unittest.cc b/libweave/src/privet/security_manager_unittest.cc index c2024c2..44e01cf 100644 --- a/libweave/src/privet/security_manager_unittest.cc +++ b/libweave/src/privet/security_manager_unittest.cc
@@ -18,7 +18,6 @@ #include <base/rand_util.h> #include <base/strings/string_number_conversions.h> #include <base/strings/string_util.h> -#include <chromeos/data_encoding.h> #include <chromeos/key_value_store.h> #include <chromeos/strings/string_utils.h> #include "libweave/external/crypto/p224_spake.h" @@ -26,6 +25,7 @@ #include <gtest/gtest.h> #include <weave/mock_task_runner.h> +#include "libweave/src/data_encoding.h" #include "libweave/src/privet/openssl_utils.h" using testing::Eq; @@ -92,8 +92,7 @@ crypto::P224EncryptedKeyExchange spake{ crypto::P224EncryptedKeyExchange::kPeerTypeClient, "1234"}; - std::string client_commitment_base64{ - chromeos::data_encoding::Base64Encode(spake.GetNextMessage())}; + std::string client_commitment_base64{Base64Encode(spake.GetNextMessage())}; EXPECT_TRUE(security_.ConfirmPairing(session_id, client_commitment_base64, fingerprint, signature, nullptr)); @@ -101,8 +100,7 @@ EXPECT_TRUE(IsBase64(*signature)); chromeos::Blob device_commitment; - ASSERT_TRUE(chromeos::data_encoding::Base64Decode(device_commitment_base64, - &device_commitment)); + ASSERT_TRUE(Base64Decode(device_commitment_base64, &device_commitment)); spake.ProcessMessage( chromeos::string_utils::GetBytesAsString(device_commitment)); @@ -110,8 +108,7 @@ HmacSha256(chromeos::SecureBlob{spake.GetUnverifiedKey()}, chromeos::SecureBlob{session_id})}; - std::string auth_code_base64{ - chromeos::data_encoding::Base64Encode(auth_code)}; + std::string auth_code_base64{Base64Encode(auth_code)}; EXPECT_TRUE(security_.IsValidPairingCode(auth_code_base64)); } @@ -223,8 +220,7 @@ EXPECT_CALL(callbacks, OnPairingEnd(Eq(session_id))); crypto::P224EncryptedKeyExchange spake{ crypto::P224EncryptedKeyExchange::kPeerTypeServer, "1234"}; - std::string client_commitment = - chromeos::data_encoding::Base64Encode(spake.GetNextMessage()); + std::string client_commitment = Base64Encode(spake.GetNextMessage()); std::string fingerprint, signature; // Regardless of whether the commitment is valid or not, we should get a // callback indicating that the pairing session is gone.