OEMCrypto v16.1 Documentation and Headers

This commit contains the updated v16.1 documentation dated Nov 12th,
as well has the headers and update ODK library.

Unit tests and reference code is partially implemented, but not yet
complete.

util/test/base64_test.cpp

@@ -0,0 +1,124 @@
+// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine Master
+// License Agreement.
+
+#include <utility>
+
+#include <gtest/gtest.h>
+
+#include "log.h"
+#include "string_conversions.h"
+
+namespace wvcdm {
+
+namespace {
+
+// Test vectors as suggested by http://tools.ietf.org/html/rfc4648#section-10
+const std::string kNullString("");
+const std::string kf("f");
+const std::string kfo("fo");
+const std::string kfoo("foo");
+const std::string kfoob("foob");
+const std::string kfooba("fooba");
+const std::string kfoobar("foobar");
+const std::string kfB64("Zg==");
+const std::string kfoB64("Zm8=");
+const std::string kfooB64("Zm9v");
+const std::string kfoobB64("Zm9vYg==");
+const std::string kfoobaB64("Zm9vYmE=");
+const std::string kfoobarB64("Zm9vYmFy");
+
+// Arbitrary clear test vectors
+const std::string kMultipleOf24BitsData("Good day!");
+const std::string kOneByteOverData("Hello Friend!");
+const std::string kTwoBytesOverData("Hello Friend!!");
+const std::string kTestData =
+    "\030\361\\\366\267> \331\210\360\\-\311:\324\256\376"
+    "\261\234\241\326d\326\177\346\346\223\333Y\305\214\330";
+
+// Arbitrary encoded test vectors
+const std::string kMultipleOf24BitsB64Data("R29vZCBkYXkh");
+const std::string kOneByteOverB64Data("SGVsbG8gRnJpZW5kIQ==");
+const std::string kTwoBytesOverB64Data("SGVsbG8gRnJpZW5kISE=");
+const std::string kB64TestData = "GPFc9rc+INmI8FwtyTrUrv6xnKHWZNZ/5uaT21nFjNg=";
+
+const std::pair<const std::string*, const std::string*> kBase64TestVectors[] = {
+    make_pair(&kNullString, &kNullString),
+    make_pair(&kf, &kfB64),
+    make_pair(&kfo, &kfoB64),
+    make_pair(&kfoo, &kfooB64),
+    make_pair(&kfoob, &kfoobB64),
+    make_pair(&kfooba, &kfoobaB64),
+    make_pair(&kfoobar, &kfoobarB64),
+    make_pair(&kMultipleOf24BitsData, &kMultipleOf24BitsB64Data),
+    make_pair(&kOneByteOverData, &kOneByteOverB64Data),
+    make_pair(&kTwoBytesOverData, &kTwoBytesOverB64Data),
+    make_pair(&kTestData, &kB64TestData)};
+
+const std::string kBase64ErrorVectors[] = {"Foo$sa", "Foo\x99\x23\xfa\02",
+                                           "Foo==Foo", "FooBa"};
+
+std::string ConvertToBase64WebSafe(const std::string& std_base64_string) {
+  std::string str(std_base64_string);
+  for (size_t i = 0; i < str.size(); ++i) {
+    if (str[i] == '+')
+      str[i] = '-';
+    else if (str[i] == '/')
+      str[i] = '_';
+  }
+  return str;
+}
+
+}  // namespace
+
+class Base64EncodeDecodeTest
+    : public ::testing::TestWithParam<
+          std::pair<const std::string*, const std::string*> > {};
+
+TEST_P(Base64EncodeDecodeTest, EncodeDecodeTest) {
+  std::pair<const std::string*, const std::string*> values = GetParam();
+  std::vector<uint8_t> decoded_vector = Base64Decode(values.second->data());
+  std::string decoded_string(decoded_vector.begin(), decoded_vector.end());
+  EXPECT_STREQ(values.first->data(), decoded_string.data());
+  std::string b64_string = Base64Encode(decoded_vector);
+  EXPECT_STREQ(values.second->data(), b64_string.data());
+}
+
+TEST_P(Base64EncodeDecodeTest, WebSafeEncodeDecodeTest) {
+  std::pair<const std::string*, const std::string*> values = GetParam();
+  std::string encoded_string = ConvertToBase64WebSafe(*(values.second));
+  std::vector<uint8_t> decoded_vector = Base64SafeDecode(encoded_string);
+  std::string decoded_string(decoded_vector.begin(), decoded_vector.end());
+  EXPECT_STREQ(values.first->data(), decoded_string.data());
+  std::string b64_string = Base64SafeEncode(decoded_vector);
+  EXPECT_STREQ(encoded_string.data(), b64_string.data());
+}
+
+class Base64ErrorDecodeTest : public ::testing::TestWithParam<std::string> {};
+
+TEST_P(Base64ErrorDecodeTest, EncoderErrors) {
+  std::vector<uint8_t> result = Base64Decode(GetParam());
+  EXPECT_EQ(0u, result.size());
+}
+
+INSTANTIATE_TEST_CASE_P(ExecutesBase64Test, Base64EncodeDecodeTest,
+                        ::testing::ValuesIn(kBase64TestVectors));
+
+INSTANTIATE_TEST_CASE_P(ExecutesBase64Test, Base64ErrorDecodeTest,
+                        ::testing::ValuesIn(kBase64ErrorVectors));
+
+class HtoNLL64Test : public ::testing::Test {};
+
+TEST_F(HtoNLL64Test, PositiveNumber) {
+  uint8_t data[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  int64_t* network_byte_order = reinterpret_cast<int64_t*>(data);
+  int64_t host_byte_order = htonll64(*network_byte_order);
+  EXPECT_EQ(0x0102030405060708, host_byte_order);
+}
+TEST_F(HtoNLL64Test, NegativeNumber) {
+  uint8_t data[8] = {0xfe, 2, 3, 4, 5, 6, 7, 8};
+  int64_t* network_byte_order = reinterpret_cast<int64_t*>(data);
+  int64_t host_byte_order = htonll64(*network_byte_order);
+  EXPECT_EQ(-0x01FdFcFbFaF9F8F8, host_byte_order);
+}
+}  // namespace wvcdm