mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-15 15:16:12 -04:00
123 lines
4.7 KiB
C++
123 lines
4.7 KiB
C++
// Copyright 2022 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
#include "presence/implementation/ldt.h"
|
|
|
|
#include <string>
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "protobuf-matchers/protocol-buffer-matchers.h"
|
|
#include "gtest/gtest.h"
|
|
#include "absl/strings/escaping.h"
|
|
#include "internal/platform/byte_array.h"
|
|
#include "internal/proto/credential.pb.h"
|
|
|
|
namespace nearby {
|
|
namespace presence {
|
|
|
|
namespace {
|
|
using ::nearby::ByteArray;
|
|
using ::nearby::internal::SharedCredential;
|
|
|
|
#ifdef USE_RUST_LDT
|
|
|
|
// Test data from Android tests.
|
|
constexpr absl::string_view kKeySeedBase16 =
|
|
"BAF3C12E1BBBB3E4367BBD40986D0D7CD158DF6D662AAE6312FE67634B5D4547";
|
|
constexpr absl::string_view kKnownMacBase16 =
|
|
"CDDA7C6CF56882D74364F8BE9874A78D7C961BFF9800A40D83F6652E6CF5D1A7";
|
|
constexpr absl::string_view kSharedCredentialBase16 =
|
|
"1220BAF3C12E1BBBB3E4367BBD40986D0D7CD158DF6D662AAE6312FE67634B5D45473220"
|
|
"CDDA7C6CF56882D74364F8BE9874A78D7C961BFF9800A40D83F6652E6CF5D1A7";
|
|
constexpr absl::string_view kPlainTextBase16 =
|
|
"205BF1D88FF539EC740CCC2EC2DE19353EF30F01054C3E24";
|
|
constexpr absl::string_view kCipherTextBase16 =
|
|
"FDABC09D6F8028D4E5E585C62E9A0DB5003F19FEBDF92524";
|
|
constexpr absl::string_view kSaltBase16 = "874C";
|
|
|
|
TEST(Ldt, EncryptAndDecrypt) {
|
|
// Test data copied from NP LDT tests
|
|
ByteArray seed({204, 219, 36, 137, 233, 252, 172, 66, 179, 147, 72,
|
|
184, 148, 30, 209, 154, 29, 54, 14, 117, 224, 152,
|
|
200, 193, 94, 107, 28, 194, 182, 32, 205, 57});
|
|
ByteArray known_mac({223, 185, 10, 31, 155, 31, 226, 141, 24, 187, 204,
|
|
165, 34, 64, 181, 204, 44, 203, 95, 141, 82, 137,
|
|
163, 203, 100, 235, 53, 65, 202, 97, 75, 180});
|
|
ByteArray test_data({205, 104, 63, 225, 161, 209, 248, 70, 84, 61,
|
|
10, 19, 212, 174, 164, 0, 64, 200, 214, 123});
|
|
ByteArray salt({12, 15});
|
|
|
|
absl::StatusOr<LdtEncryptor> encryptor =
|
|
LdtEncryptor::Create(seed.AsStringView(), known_mac.AsStringView());
|
|
ASSERT_OK(encryptor);
|
|
absl::StatusOr<std::string> encrypted =
|
|
encryptor->Encrypt(test_data.AsStringView(), salt.AsStringView());
|
|
ASSERT_OK(encrypted);
|
|
absl::StatusOr<std::string> decrypted =
|
|
encryptor->DecryptAndVerify(*encrypted, salt.AsStringView());
|
|
ASSERT_OK(decrypted);
|
|
EXPECT_EQ(*decrypted, test_data.AsStringView());
|
|
}
|
|
|
|
TEST(Ldt, EncryptAndroidData) {
|
|
absl::StatusOr<LdtEncryptor> encryptor =
|
|
LdtEncryptor::Create(absl::HexStringToBytes(kKeySeedBase16),
|
|
absl::HexStringToBytes(kKnownMacBase16));
|
|
ASSERT_OK(encryptor);
|
|
|
|
absl::StatusOr<std::string> encrypted =
|
|
encryptor->Encrypt(absl::HexStringToBytes(kPlainTextBase16),
|
|
absl::HexStringToBytes(kSaltBase16));
|
|
|
|
ASSERT_OK(encrypted);
|
|
EXPECT_EQ(*encrypted, absl::HexStringToBytes(kCipherTextBase16));
|
|
}
|
|
|
|
TEST(Ldt, DecryptAndroidData) {
|
|
SharedCredential shared_credential;
|
|
ASSERT_TRUE(shared_credential.ParseFromString(
|
|
absl::HexStringToBytes(kSharedCredentialBase16)));
|
|
absl::StatusOr<LdtEncryptor> encryptor = LdtEncryptor::Create(
|
|
shared_credential.key_seed(),
|
|
shared_credential.metadata_encryption_key_unsigned_adv_tag());
|
|
ASSERT_OK(encryptor);
|
|
|
|
absl::StatusOr<std::string> decrypted =
|
|
encryptor->DecryptAndVerify(absl::HexStringToBytes(kCipherTextBase16),
|
|
absl::HexStringToBytes(kSaltBase16));
|
|
|
|
ASSERT_OK(decrypted);
|
|
EXPECT_EQ(*decrypted, absl::HexStringToBytes(kPlainTextBase16));
|
|
}
|
|
|
|
#else
|
|
TEST(Ldt, LdtUnvailable) {
|
|
ByteArray seed({204, 219, 36, 137, 233, 252, 172, 66, 179, 147, 72,
|
|
184, 148, 30, 209, 154, 29, 54, 14, 117, 224, 152,
|
|
200, 193, 94, 107, 28, 194, 182, 32, 205, 57});
|
|
ByteArray known_mac({223, 185, 10, 31, 155, 31, 226, 141, 24, 187, 204,
|
|
165, 34, 64, 181, 204, 44, 203, 95, 141, 82, 137,
|
|
163, 203, 100, 235, 53, 65, 202, 97, 75, 180});
|
|
|
|
absl::StatusOr<LdtEncryptor> encryptor =
|
|
LdtEncryptor::Create(seed.AsStringView(), known_mac.AsStringView());
|
|
|
|
EXPECT_THAT(encryptor.status(),
|
|
absl::UnavailableError("Failed to create LDT encryptor"));
|
|
}
|
|
#endif
|
|
|
|
} // namespace
|
|
} // namespace presence
|
|
} // namespace nearby
|