501 lines
23 KiB
C++
501 lines
23 KiB
C++
/*
|
|
* Copyright 2020 The Android Open Source Project
|
|
*
|
|
* 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
|
|
*
|
|
* http://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.
|
|
*/
|
|
|
|
#define LOG_TAG "AdbPairingConnectionTest"
|
|
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <mutex>
|
|
#include <thread>
|
|
|
|
#include <adb/pairing/pairing_server.h>
|
|
#include <android-base/logging.h>
|
|
#include <android-base/strings.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "../internal/constants.h"
|
|
#include "pairing_client.h"
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
namespace adb {
|
|
namespace pairing {
|
|
|
|
// Test X.509 certificates (RSA 2048)
|
|
static const std::string kTestRsa2048ServerCert =
|
|
"-----BEGIN CERTIFICATE-----\n"
|
|
"MIIDFzCCAf+gAwIBAgIBATANBgkqhkiG9w0BAQsFADAtMQswCQYDVQQGEwJVUzEQ\n"
|
|
"MA4GA1UECgwHQW5kcm9pZDEMMAoGA1UEAwwDQWRiMB4XDTIwMDEyMTIyMjU1NVoX\n"
|
|
"DTMwMDExODIyMjU1NVowLTELMAkGA1UEBhMCVVMxEDAOBgNVBAoMB0FuZHJvaWQx\n"
|
|
"DDAKBgNVBAMMA0FkYjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK8E\n"
|
|
"2Ck9TfuKlz7wqWdMfknjZ1luFDp2IHxAUZzh/F6jeI2dOFGAjpeloSnGOE86FIaT\n"
|
|
"d1EvpyTh7nBwbrLZAA6XFZTo7Bl6BdNOQdqb2d2+cLEN0inFxqUIycevRtohUE1Y\n"
|
|
"FHM9fg442X1jOTWXjDZWeiqFWo95paAPhzm6pWqfJK1+YKfT1LsWZpYqJGGQE5pi\n"
|
|
"C3qOBYYgFpoXMxTYJNoZo3uOYEdM6upc8/vh15nMgIxX/ymJxEY5BHPpZPPWjXLg\n"
|
|
"BfzVaV9fUfv0JT4HQ4t2WvxC3cD/UsjWp2a6p454uUp2ENrANa+jRdRJepepg9D2\n"
|
|
"DKsx9L8zjc5Obqexrt0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8B\n"
|
|
"Af8EBAMCAYYwHQYDVR0OBBYEFDFW+8GTErwoZN5Uu9KyY4QdGYKpMA0GCSqGSIb3\n"
|
|
"DQEBCwUAA4IBAQBCDEn6SHXGlq5TU7J8cg1kRPd9bsJW+0hDuKSq0REXDkl0PcBf\n"
|
|
"fy282Agg9enKPPKmnpeQjM1dmnxdM8tT8LIUbMl779i3fn6v9HJVB+yG4gmRFThW\n"
|
|
"c+AGlBnrIT820cX/gU3h3R3FTahfsq+1rrSJkEgHyuC0HYeRyveSckBdaEOLvx0S\n"
|
|
"toun+32JJl5hWydpUUZhE9Mbb3KHBRM2YYZZU9JeJ08Apjl+3lRUeMAUwI5fkAAu\n"
|
|
"z/1SqnuGL96bd8P5ixdkA1+rF8FPhodGcq9mQOuUGP9g5HOXjaNoJYvwVRUdLeGh\n"
|
|
"cP/ReOTwQIzM1K5a83p8cX8AGGYmM7dQp7ec\n"
|
|
"-----END CERTIFICATE-----\n";
|
|
|
|
static const std::string kTestRsa2048ServerPrivKey =
|
|
"-----BEGIN PRIVATE KEY-----\n"
|
|
"MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCvBNgpPU37ipc+\n"
|
|
"8KlnTH5J42dZbhQ6diB8QFGc4fxeo3iNnThRgI6XpaEpxjhPOhSGk3dRL6ck4e5w\n"
|
|
"cG6y2QAOlxWU6OwZegXTTkHam9ndvnCxDdIpxcalCMnHr0baIVBNWBRzPX4OONl9\n"
|
|
"Yzk1l4w2VnoqhVqPeaWgD4c5uqVqnyStfmCn09S7FmaWKiRhkBOaYgt6jgWGIBaa\n"
|
|
"FzMU2CTaGaN7jmBHTOrqXPP74deZzICMV/8picRGOQRz6WTz1o1y4AX81WlfX1H7\n"
|
|
"9CU+B0OLdlr8Qt3A/1LI1qdmuqeOeLlKdhDawDWvo0XUSXqXqYPQ9gyrMfS/M43O\n"
|
|
"Tm6nsa7dAgMBAAECggEAFCS2bPdUKIgjbzLgtHW+hT+J2hD20rcHdyAp+dNH/2vI\n"
|
|
"yLfDJHJA4chGMRondKA704oDw2bSJxxlG9t83326lB35yxPhye7cM8fqgWrK8PVl\n"
|
|
"tU22FhO1ZgeJvb9OeXWNxKZyDW9oOOJ8eazNXVMuEo+dFj7B6l3MXQyHJPL2mJDm\n"
|
|
"u9ofFLdypX+gJncVO0oW0FNJnEUn2MMwHDNlo7gc4WdQuidPkuZItKRGcB8TTGF3\n"
|
|
"Ka1/2taYdTQ4Aq//Z84LlFvE0zD3T4c8LwYYzOzD4gGGTXvft7vSHzIun1S8YLRS\n"
|
|
"dEKXdVjtaFhgH3uUe4j+1b/vMvSHeoGBNX/G88GD+wKBgQDWUYVlMVqc9HD2IeYi\n"
|
|
"EfBcNwAJFJkh51yAl5QbUBgFYgFJVkkS/EDxEGFPvEmI3/pAeQFHFY13BI466EPs\n"
|
|
"o8Z8UUwWDp+Z1MFHHKQKnFakbsZbZlbqjJ9VJsqpezbpWhMHTOmcG0dmE7rf0lyM\n"
|
|
"eQv9slBB8qp2NEUs5Of7f2C2bwKBgQDRDq4nUuMQF1hbjM05tGKSIwkobmGsLspv\n"
|
|
"TMhkM7fq4RpbFHmbNgsFqMhcqYZ8gY6/scv5KCuAZ4yHUkbqwf5h+QCwrJ4uJeUJ\n"
|
|
"ZgJfHus2mmcNSo8FwSkNoojIQtzcbJav7bs2K9VTuertk/i7IJLApU4FOZZ5pghN\n"
|
|
"EXu0CZF1cwKBgDWFGhjRIF29tU/h20R60llU6s9Zs3wB+NmsALJpZ/ZAKS4VPB5f\n"
|
|
"nCAXBRYSYRKrTCU5kpYbzb4BBzuysPOxWmnFK4j+keCqfrGxd02nCQP7HdHJVr8v\n"
|
|
"6sIq88UrHeVcNxBFprjzHvtgxfQK5k22FMZ/9wbhAKyQFQ5HA5+MiaxFAoGAIcZZ\n"
|
|
"ZIkDninnYIMS9OursShv5lRO+15j3i9tgKLKZ+wOMgDQ1L6acUOfezj4PU1BHr8+\n"
|
|
"0PYocQpJreMhCfRlgLaV4fVBaPs+UZJld7CrF5tCYudUy/01ALrtlk0XGZWBktK5\n"
|
|
"mDrksC4tQkzRtonAq9cJD9cJ9IVaefkFH0UcdvkCgYBpZj50VLeGhnHHBnkJRlV1\n"
|
|
"fV+/P6PAq6RtqjA6O9Qdaoj5V3w2d63aQcQXQLJjH2BBmtCIy47r04rFvZpbCxP7\n"
|
|
"NH/OnK9NHpk2ucRTe8TAnVbvF/TZzPJoIxAO/D3OWaW6df4R8en8u6GYzWFglAyT\n"
|
|
"sydGT8yfWD1FYUWgfrVRbg==\n"
|
|
"-----END PRIVATE KEY-----\n";
|
|
|
|
static const std::string kTestRsa2048ClientCert =
|
|
"-----BEGIN CERTIFICATE-----\n"
|
|
"MIIDFzCCAf+gAwIBAgIBATANBgkqhkiG9w0BAQsFADAtMQswCQYDVQQGEwJVUzEQ\n"
|
|
"MA4GA1UECgwHQW5kcm9pZDEMMAoGA1UEAwwDQWRiMB4XDTIwMDEyMTIyMjU1NloX\n"
|
|
"DTMwMDExODIyMjU1NlowLTELMAkGA1UEBhMCVVMxEDAOBgNVBAoMB0FuZHJvaWQx\n"
|
|
"DDAKBgNVBAMMA0FkYjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAI3a\n"
|
|
"EXh1S5FTbet7JVONswffRPaekdIK53cb8SnAbSO9X5OLA4zGwdkrBvDTsd96SKrp\n"
|
|
"JxmoNOE1DhbZh05KPlWAPkGKacjGWaz+S7biDOL0I6aaLbTlU/il1Ub9olPSBVUx\n"
|
|
"0nhdtEFgIOzddnP6/1KmyIIeRxS5lTKeg4avqUkZNXkz/wL1dHBFL7FNFf0SCcbo\n"
|
|
"tsub/deFbjZ27LTDN+SIBgFttTNqC5NTvoBAoMdyCOAgNYwaHO+fKiK3edfJieaw\n"
|
|
"7HD8qqmQxcpCtRlA8CUPj7GfR+WHiCJmlevhnkFXCo56R1BS0F4wuD4KPdSWt8gc\n"
|
|
"27ejH/9/z2cKo/6SLJMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8B\n"
|
|
"Af8EBAMCAYYwHQYDVR0OBBYEFO/Mr5ygqqpyU/EHM9v7RDvcqaOkMA0GCSqGSIb3\n"
|
|
"DQEBCwUAA4IBAQAH33KMouzF2DYbjg90KDrDQr4rq3WfNb6P743knxdUFuvb+40U\n"
|
|
"QjC2OJZHkSexH7wfG/y6ic7vfCfF4clNs3QvU1lEjOZC57St8Fk7mdNdsWLwxEMD\n"
|
|
"uePFz0dvclSxNUHyCVMqNxddzQYzxiDWQRmXWrUBliMduQqEQelcxW2yDtg8bj+s\n"
|
|
"aMpR1ra9scaD4jzIZIIxLoOS9zBMuNRbgP217sZrniyGMhzoI1pZ/izN4oXpyH7O\n"
|
|
"THuaCzzRT3ph2f8EgmHSodz3ttgSf2DHzi/Ez1xUkk7NOlgNtmsxEdrM47+cC5ae\n"
|
|
"fIf2V+1o1JW8J7D11RmRbNPh3vfisueB4f88\n"
|
|
"-----END CERTIFICATE-----\n";
|
|
|
|
static const std::string kTestRsa2048ClientPrivKey =
|
|
"-----BEGIN PRIVATE KEY-----\n"
|
|
"MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCN2hF4dUuRU23r\n"
|
|
"eyVTjbMH30T2npHSCud3G/EpwG0jvV+TiwOMxsHZKwbw07Hfekiq6ScZqDThNQ4W\n"
|
|
"2YdOSj5VgD5BimnIxlms/ku24gzi9COmmi205VP4pdVG/aJT0gVVMdJ4XbRBYCDs\n"
|
|
"3XZz+v9SpsiCHkcUuZUynoOGr6lJGTV5M/8C9XRwRS+xTRX9EgnG6LbLm/3XhW42\n"
|
|
"duy0wzfkiAYBbbUzaguTU76AQKDHcgjgIDWMGhzvnyoit3nXyYnmsOxw/KqpkMXK\n"
|
|
"QrUZQPAlD4+xn0flh4giZpXr4Z5BVwqOekdQUtBeMLg+Cj3UlrfIHNu3ox//f89n\n"
|
|
"CqP+kiyTAgMBAAECggEAAa64eP6ggCob1P3c73oayYPIbvRqiQdAFOrr7Vwu7zbr\n"
|
|
"z0rde+n6RU0mrpc+4NuzyPMtrOGQiatLbidJB5Cx3z8U00ovqbCl7PtcgorOhFKe\n"
|
|
"VEzihebCcYyQqbWQcKtpDMhOgBxRwFoXieJb6VGXfa96FAZalCWvXgOrTl7/BF2X\n"
|
|
"qMqIm9nJi+yS5tIO8VdOsOmrMWRH/b/ENUcef4WpLoxTXr0EEgyKWraeZ/hhXo1e\n"
|
|
"z29dZKqdr9wMsq11NPsRddwS94jnDkXTo+EQyWVTfB7gb6yyp07s8jysaDb21tVv\n"
|
|
"UXB9MRhDV1mOv0ncXfXZ4/+4A2UahmZaLDAVLaat4QKBgQDAVRredhGRGl2Nkic3\n"
|
|
"KvZCAfyxug788CgasBdEiouz19iCCwcgMIDwnq0s3/WM7h/laCamT2x38riYDnpq\n"
|
|
"rkYMfuVtU9CjEL9pTrdfwbIRhTwYNqADaPz2mXwQUhRXutE5TIdgxxC/a+ZTh0qN\n"
|
|
"S+vhTj/4hf0IZhMh5Nqj7IPExQKBgQC8zxEzhmSGjys0GuE6Wl6Doo2TpiR6vwvi\n"
|
|
"xPLU9lmIz5eca/Rd/eERioFQqeoIWDLzx52DXuz6rUoQhbJWz9hP3yqCwXD+pbNP\n"
|
|
"oDJqDDbCC4IMYEb0IK/PEPH+gIpnTjoFcW+ecKDFG7W5Lt05J8WsJsfOaJvMrOU+\n"
|
|
"dLXq3IgxdwKBgQC5RAFq0v6e8G+3hFaEHL0z3igkpt3zJf7rnj37hx2FMmDa+3Z0\n"
|
|
"umQp5B9af61PgL12xLmeMBmC/Wp1BlVDV/Yf6Uhk5Hyv5t0KuomHEtTNbbLyfAPs\n"
|
|
"5P/vJu/L5NS1oT4S3LX3MineyjgGs+bLbpub3z1dzutrYLADUSiPCK/xJQKBgBQt\n"
|
|
"nQ0Ao+Wtj1R2OvPdjJRM3wyUiPmFSWPm4HzaBx+T8AQLlYYmB9O0FbXlMtnJc0iS\n"
|
|
"YMcVcgYoVu4FG9YjSF7g3s4yljzgwJUV7c1fmMqMKE3iTDLy+1cJ3JLycdgwiArk\n"
|
|
"4KTyLHxkRbuQwpvFIF8RlfD9RQlOwQE3v+llwDhpAoGBAL6XG6Rp6mBoD2Ds5c9R\n"
|
|
"943yYgSUes3ji1SI9zFqeJtj8Ml/enuK1xu+8E/BxB0//+vgZsH6i3i8GFwygKey\n"
|
|
"CGJF8CbiHc3EJc3NQIIRXcni/CGacf0HwC6m+PGFDBIpA4H2iDpVvCSofxttQiq0\n"
|
|
"/Z7HXmXUvZHVyYi/QzX2Gahj\n"
|
|
"-----END PRIVATE KEY-----\n";
|
|
|
|
struct ServerDeleter {
|
|
void operator()(PairingServerCtx* p) { pairing_server_destroy(p); }
|
|
};
|
|
using ServerPtr = std::unique_ptr<PairingServerCtx, ServerDeleter>;
|
|
|
|
struct ResultWaiter {
|
|
std::mutex mutex_;
|
|
std::condition_variable cv_;
|
|
std::optional<bool> is_valid_;
|
|
PeerInfo peer_info_;
|
|
|
|
static void ResultCallback(const PeerInfo* peer_info, void* opaque) {
|
|
auto* p = reinterpret_cast<ResultWaiter*>(opaque);
|
|
{
|
|
std::unique_lock<std::mutex> lock(p->mutex_);
|
|
if (peer_info) {
|
|
memcpy(&(p->peer_info_), peer_info, sizeof(PeerInfo));
|
|
}
|
|
p->is_valid_ = (peer_info != nullptr);
|
|
}
|
|
p->cv_.notify_one();
|
|
}
|
|
};
|
|
|
|
class AdbPairingConnectionTest : public testing::Test {
|
|
protected:
|
|
virtual void SetUp() override {}
|
|
|
|
virtual void TearDown() override {}
|
|
|
|
void InitPairing(const std::vector<uint8_t>& server_pswd,
|
|
const std::vector<uint8_t>& client_pswd) {
|
|
server_ = CreateServer(server_pswd);
|
|
client_ = CreateClient(client_pswd);
|
|
}
|
|
|
|
ServerPtr CreateServer(const std::vector<uint8_t>& pswd) {
|
|
return CreateServer(pswd, &server_info_, kTestRsa2048ServerCert, kTestRsa2048ServerPrivKey,
|
|
0);
|
|
}
|
|
|
|
std::unique_ptr<PairingClient> CreateClient(const std::vector<uint8_t> pswd) {
|
|
std::vector<uint8_t> cert;
|
|
std::vector<uint8_t> key;
|
|
// Include the null-byte as well.
|
|
cert.assign(reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()) +
|
|
kTestRsa2048ClientCert.size() + 1);
|
|
key.assign(reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()) +
|
|
kTestRsa2048ClientPrivKey.size() + 1);
|
|
return PairingClient::Create(pswd, client_info_, cert, key);
|
|
}
|
|
|
|
static ServerPtr CreateServer(const std::vector<uint8_t>& pswd, const PeerInfo* peer_info,
|
|
const std::string_view cert, const std::string_view priv_key,
|
|
int port) {
|
|
return ServerPtr(pairing_server_new(
|
|
pswd.data(), pswd.size(), peer_info, reinterpret_cast<const uint8_t*>(cert.data()),
|
|
cert.size(), reinterpret_cast<const uint8_t*>(priv_key.data()), priv_key.size(),
|
|
port));
|
|
}
|
|
|
|
ServerPtr server_;
|
|
const PeerInfo server_info_ = {
|
|
.type = ADB_DEVICE_GUID,
|
|
.data = "my_server_info",
|
|
};
|
|
std::unique_ptr<PairingClient> client_;
|
|
const PeerInfo client_info_ = {
|
|
.type = ADB_RSA_PUB_KEY,
|
|
.data = "my_client_info",
|
|
};
|
|
std::string ip_addr_ = "127.0.0.1:";
|
|
};
|
|
|
|
TEST_F(AdbPairingConnectionTest, ServerCreation) {
|
|
// All parameters bad
|
|
ASSERT_DEATH({ auto server = CreateServer({}, nullptr, "", "", 0); }, "");
|
|
// Bad password
|
|
ASSERT_DEATH(
|
|
{
|
|
auto server = CreateServer({}, &server_info_, kTestRsa2048ServerCert,
|
|
kTestRsa2048ServerPrivKey, 0);
|
|
},
|
|
"");
|
|
// Bad peer_info
|
|
ASSERT_DEATH(
|
|
{
|
|
auto server = CreateServer({0x01}, nullptr, kTestRsa2048ServerCert,
|
|
kTestRsa2048ServerPrivKey, 0);
|
|
},
|
|
"");
|
|
// Bad certificate
|
|
ASSERT_DEATH(
|
|
{
|
|
auto server = CreateServer({0x01}, &server_info_, "", kTestRsa2048ServerPrivKey, 0);
|
|
},
|
|
"");
|
|
// Bad private key
|
|
ASSERT_DEATH(
|
|
{ auto server = CreateServer({0x01}, &server_info_, kTestRsa2048ServerCert, "", 0); },
|
|
"");
|
|
// Valid params
|
|
auto server = CreateServer({0x01}, &server_info_, kTestRsa2048ServerCert,
|
|
kTestRsa2048ServerPrivKey, 0);
|
|
EXPECT_NE(nullptr, server);
|
|
}
|
|
|
|
TEST_F(AdbPairingConnectionTest, ClientCreation) {
|
|
std::vector<uint8_t> pswd{0x01, 0x03, 0x05, 0x07};
|
|
// Bad password
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
nullptr, pswd.size(), &client_info_,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
kTestRsa2048ClientCert.size(),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
kTestRsa2048ClientPrivKey.size());
|
|
},
|
|
"");
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
pswd.data(), 0, &client_info_,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
kTestRsa2048ClientCert.size(),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
kTestRsa2048ClientPrivKey.size());
|
|
},
|
|
"");
|
|
|
|
// Bad peer_info
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
pswd.data(), pswd.size(), nullptr,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
kTestRsa2048ClientCert.size(),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
kTestRsa2048ClientPrivKey.size());
|
|
},
|
|
"");
|
|
|
|
// Bad certificate
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
pswd.data(), pswd.size(), &client_info_, nullptr,
|
|
kTestRsa2048ClientCert.size(),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
kTestRsa2048ClientPrivKey.size());
|
|
},
|
|
"");
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
pswd.data(), pswd.size(), &client_info_,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()), 0,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
kTestRsa2048ClientPrivKey.size());
|
|
},
|
|
"");
|
|
|
|
// Bad private key
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
pswd.data(), pswd.size(), &client_info_,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
kTestRsa2048ClientCert.size(), nullptr, kTestRsa2048ClientPrivKey.size());
|
|
},
|
|
"");
|
|
ASSERT_DEATH(
|
|
{
|
|
pairing_connection_client_new(
|
|
pswd.data(), pswd.size(), &client_info_,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
kTestRsa2048ClientCert.size(),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()), 0);
|
|
},
|
|
"");
|
|
|
|
// Valid params
|
|
auto client = pairing_connection_client_new(
|
|
pswd.data(), pswd.size(), &client_info_,
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientCert.data()),
|
|
kTestRsa2048ClientCert.size(),
|
|
reinterpret_cast<const uint8_t*>(kTestRsa2048ClientPrivKey.data()),
|
|
kTestRsa2048ClientPrivKey.size());
|
|
EXPECT_NE(nullptr, client);
|
|
}
|
|
|
|
TEST_F(AdbPairingConnectionTest, SmokeValidPairing) {
|
|
std::vector<uint8_t> pswd{0x01, 0x03, 0x05, 0x07};
|
|
InitPairing(pswd, pswd);
|
|
|
|
// Start the server
|
|
ResultWaiter server_waiter;
|
|
std::unique_lock<std::mutex> server_lock(server_waiter.mutex_);
|
|
auto port = pairing_server_start(server_.get(), server_waiter.ResultCallback, &server_waiter);
|
|
ASSERT_GT(port, 0);
|
|
ip_addr_ += std::to_string(port);
|
|
|
|
// Start the client
|
|
ResultWaiter client_waiter;
|
|
std::unique_lock<std::mutex> client_lock(client_waiter.mutex_);
|
|
ASSERT_TRUE(client_->Start(ip_addr_, client_waiter.ResultCallback, &client_waiter));
|
|
client_waiter.cv_.wait(client_lock, [&]() { return client_waiter.is_valid_.has_value(); });
|
|
ASSERT_TRUE(*(client_waiter.is_valid_));
|
|
ASSERT_EQ(strlen(reinterpret_cast<const char*>(client_waiter.peer_info_.data)),
|
|
strlen(reinterpret_cast<const char*>(server_info_.data)));
|
|
EXPECT_EQ(memcmp(client_waiter.peer_info_.data, server_info_.data, sizeof(server_info_.data)),
|
|
0);
|
|
|
|
// Kill server if the pairing failed, since server only shuts down when
|
|
// it gets a valid pairing.
|
|
if (!client_waiter.is_valid_) {
|
|
server_lock.unlock();
|
|
server_.reset();
|
|
} else {
|
|
server_waiter.cv_.wait(server_lock, [&]() { return server_waiter.is_valid_.has_value(); });
|
|
ASSERT_TRUE(*(server_waiter.is_valid_));
|
|
ASSERT_EQ(strlen(reinterpret_cast<const char*>(server_waiter.peer_info_.data)),
|
|
strlen(reinterpret_cast<const char*>(client_info_.data)));
|
|
EXPECT_EQ(
|
|
memcmp(server_waiter.peer_info_.data, client_info_.data, sizeof(client_info_.data)),
|
|
0);
|
|
}
|
|
}
|
|
|
|
TEST_F(AdbPairingConnectionTest, CancelPairing) {
|
|
std::vector<uint8_t> pswd{0x01, 0x03, 0x05, 0x07};
|
|
std::vector<uint8_t> pswd2{0x01, 0x03, 0x05, 0x06};
|
|
InitPairing(pswd, pswd2);
|
|
|
|
// Start the server
|
|
ResultWaiter server_waiter;
|
|
std::unique_lock<std::mutex> server_lock(server_waiter.mutex_);
|
|
auto port = pairing_server_start(server_.get(), server_waiter.ResultCallback, &server_waiter);
|
|
ASSERT_GT(port, 0);
|
|
ip_addr_ += std::to_string(port);
|
|
|
|
// Start the client. Client should fail to pair
|
|
ResultWaiter client_waiter;
|
|
std::unique_lock<std::mutex> client_lock(client_waiter.mutex_);
|
|
ASSERT_TRUE(client_->Start(ip_addr_, client_waiter.ResultCallback, &client_waiter));
|
|
client_waiter.cv_.wait(client_lock, [&]() { return client_waiter.is_valid_.has_value(); });
|
|
ASSERT_FALSE(*(client_waiter.is_valid_));
|
|
|
|
// Kill the server. We should still receive the callback with no valid
|
|
// pairing.
|
|
server_lock.unlock();
|
|
server_.reset();
|
|
server_lock.lock();
|
|
ASSERT_TRUE(server_waiter.is_valid_.has_value());
|
|
EXPECT_FALSE(*(server_waiter.is_valid_));
|
|
}
|
|
|
|
TEST_F(AdbPairingConnectionTest, MultipleClientsAllFail) {
|
|
std::vector<uint8_t> pswd{0x01, 0x03, 0x05, 0x07};
|
|
std::vector<uint8_t> pswd2{0x01, 0x03, 0x05, 0x06};
|
|
|
|
// Start the server
|
|
auto server = CreateServer(pswd);
|
|
ResultWaiter server_waiter;
|
|
std::unique_lock<std::mutex> server_lock(server_waiter.mutex_);
|
|
auto port = pairing_server_start(server.get(), server_waiter.ResultCallback, &server_waiter);
|
|
ASSERT_GT(port, 0);
|
|
ip_addr_ += std::to_string(port);
|
|
|
|
// Start multiple clients, all with bad passwords
|
|
int test_num_clients = 5;
|
|
int num_clients_done = 0;
|
|
std::mutex global_clients_mutex;
|
|
std::unique_lock<std::mutex> global_clients_lock(global_clients_mutex);
|
|
std::condition_variable global_cv_;
|
|
for (int i = 0; i < test_num_clients; ++i) {
|
|
std::thread([&]() {
|
|
auto client = CreateClient(pswd2);
|
|
ResultWaiter client_waiter;
|
|
std::unique_lock<std::mutex> client_lock(client_waiter.mutex_);
|
|
ASSERT_TRUE(client->Start(ip_addr_, client_waiter.ResultCallback, &client_waiter));
|
|
client_waiter.cv_.wait(client_lock,
|
|
[&]() { return client_waiter.is_valid_.has_value(); });
|
|
ASSERT_FALSE(*(client_waiter.is_valid_));
|
|
{
|
|
std::lock_guard<std::mutex> global_lock(global_clients_mutex);
|
|
++num_clients_done;
|
|
}
|
|
global_cv_.notify_one();
|
|
}).detach();
|
|
}
|
|
|
|
global_cv_.wait(global_clients_lock, [&]() { return num_clients_done == test_num_clients; });
|
|
server_lock.unlock();
|
|
server.reset();
|
|
server_lock.lock();
|
|
ASSERT_TRUE(server_waiter.is_valid_.has_value());
|
|
EXPECT_FALSE(*(server_waiter.is_valid_));
|
|
}
|
|
|
|
TEST_F(AdbPairingConnectionTest, DISABLED_MultipleClientsOnePass) {
|
|
// Send multiple clients with bad passwords, but send the last one with the
|
|
// correct password.
|
|
std::vector<uint8_t> pswd{0x01, 0x03, 0x05, 0x07};
|
|
std::vector<uint8_t> pswd2{0x01, 0x03, 0x05, 0x06};
|
|
|
|
// Start the server
|
|
auto server = CreateServer(pswd);
|
|
ResultWaiter server_waiter;
|
|
std::unique_lock<std::mutex> server_lock(server_waiter.mutex_);
|
|
auto port = pairing_server_start(server.get(), server_waiter.ResultCallback, &server_waiter);
|
|
ASSERT_GT(port, 0);
|
|
ip_addr_ += std::to_string(port);
|
|
|
|
// Start multiple clients, all with bad passwords
|
|
int test_num_clients = 5;
|
|
int num_clients_done = 0;
|
|
std::mutex global_clients_mutex;
|
|
std::unique_lock<std::mutex> global_clients_lock(global_clients_mutex);
|
|
std::condition_variable global_cv_;
|
|
for (int i = 0; i < test_num_clients; ++i) {
|
|
std::thread([&, i]() {
|
|
bool good_client = (i == (test_num_clients - 1));
|
|
auto client = CreateClient((good_client ? pswd : pswd2));
|
|
ResultWaiter client_waiter;
|
|
std::unique_lock<std::mutex> client_lock(client_waiter.mutex_);
|
|
ASSERT_TRUE(client->Start(ip_addr_, client_waiter.ResultCallback, &client_waiter));
|
|
client_waiter.cv_.wait(client_lock,
|
|
[&]() { return client_waiter.is_valid_.has_value(); });
|
|
if (good_client) {
|
|
ASSERT_TRUE(*(client_waiter.is_valid_));
|
|
ASSERT_EQ(strlen(reinterpret_cast<const char*>(client_waiter.peer_info_.data)),
|
|
strlen(reinterpret_cast<const char*>(server_info_.data)));
|
|
EXPECT_EQ(memcmp(client_waiter.peer_info_.data, server_info_.data,
|
|
sizeof(server_info_.data)),
|
|
0);
|
|
} else {
|
|
ASSERT_FALSE(*(client_waiter.is_valid_));
|
|
}
|
|
{
|
|
std::lock_guard<std::mutex> global_lock(global_clients_mutex);
|
|
++num_clients_done;
|
|
}
|
|
global_cv_.notify_one();
|
|
}).detach();
|
|
}
|
|
|
|
global_cv_.wait(global_clients_lock, [&]() { return num_clients_done == test_num_clients; });
|
|
server_waiter.cv_.wait(server_lock, [&]() { return server_waiter.is_valid_.has_value(); });
|
|
ASSERT_TRUE(*(server_waiter.is_valid_));
|
|
ASSERT_EQ(strlen(reinterpret_cast<const char*>(server_waiter.peer_info_.data)),
|
|
strlen(reinterpret_cast<const char*>(client_info_.data)));
|
|
EXPECT_EQ(memcmp(server_waiter.peer_info_.data, client_info_.data, sizeof(client_info_.data)),
|
|
0);
|
|
}
|
|
|
|
} // namespace pairing
|
|
} // namespace adb
|