Skip to content

GitLab

T
tangled
Commit 1710f5ad authored by Jun Choi's avatar Jun Choi Committed by Commit Bot
Browse files
Options

Rename prefix for BLE related classes to FIDO 

U2F and CTAP share same BLE GATT service UUID and service
characteristics. Furthermore, BLE transport specification for CTAP is a
strict superset of U2F BLE transport specifications. All transport
specifications including fragmentation, request, and response
structure are the same. CTAP protocol simply  adds cancel command to the
list of commands. Rename all Ble related objects to have Fido as prefix.

Bug: 814474
Change-Id: I1978e4b536337e97311cb8c651a8d95256a75c6e
Reviewed-on: https://chromium-review.googlesource.com/929805
Commit-Queue: Jun Choi <hongjunchoi@chromium.org>
Reviewed-by: default avatarJan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#543829}
parent 1963d5c6
Hide whitespace changes
Inline Side-by-side
Showing with 534 additions and 469 deletions
device/BUILD.gn
View file @ 1710f5ad
......@@ -67,12 +67,12 @@ test("device_unittests") {
"fido/ctap_request_unittest.cc",
"fido/ctap_response_unittest.cc",
"fido/fake_fido_discovery_unittest.cc",
"fido/fido_ble_connection_unittest.cc",
"fido/fido_ble_device_unittest.cc",
"fido/fido_ble_frames_unittest.cc",
"fido/fido_discovery_unittest.cc",
"fido/fido_hid_message_unittest.cc",
"fido/test_callback_receiver_unittest.cc",
"fido/u2f_ble_connection_unittest.cc",
"fido/u2f_ble_device_unittest.cc",
"fido/u2f_ble_frames_unittest.cc",
"fido/u2f_register_unittest.cc",
"fido/u2f_request_unittest.cc",
"fido/u2f_sign_unittest.cc",
......@@ -218,7 +218,7 @@ test("device_unittests") {
# BLE discovery: works on Linux.
if (is_linux) {
sources += [ "fido/u2f_ble_discovery_unittest.cc" ]
sources += [ "fido/fido_ble_discovery_unittest.cc" ]
}
if (is_mac) {
......
device/fido/BUILD.gn
View file @ 1710f5ad
......@@ -35,6 +35,16 @@ component("fido") {
"ec_public_key.h",
"fido_attestation_statement.cc",
"fido_attestation_statement.h",
"fido_ble_connection.cc",
"fido_ble_connection.h",
"fido_ble_device.cc",
"fido_ble_device.h",
"fido_ble_discovery.cc",
"fido_ble_discovery.h",
"fido_ble_frames.cc",
"fido_ble_frames.h",
"fido_ble_transaction.cc",
"fido_ble_transaction.h",
"fido_ble_uuids.cc",
"fido_ble_uuids.h",
"fido_constants.cc",
......@@ -63,16 +73,6 @@ component("fido") {
"response_data.h",
"sign_response_data.cc",
"sign_response_data.h",
"u2f_ble_connection.cc",
"u2f_ble_connection.h",
"u2f_ble_device.cc",
"u2f_ble_device.h",
"u2f_ble_discovery.cc",
"u2f_ble_discovery.h",
"u2f_ble_frames.cc",
"u2f_ble_frames.h",
"u2f_ble_transaction.cc",
"u2f_ble_transaction.h",
"u2f_parsing_utils.cc",
"u2f_parsing_utils.h",
"u2f_register.cc",
......@@ -125,12 +125,12 @@ source_set("mocks") {
testonly = true
sources = [
"mock_fido_ble_connection.cc",
"mock_fido_ble_connection.h",
"mock_fido_device.cc",
"mock_fido_device.h",
"mock_fido_discovery_observer.cc",
"mock_fido_discovery_observer.h",
"mock_u2f_ble_connection.cc",
"mock_u2f_ble_connection.h",
]
deps = [
......@@ -152,9 +152,9 @@ fuzzer_test("fido_hid_message_fuzzer") {
libfuzzer_options = [ "max_len=2048" ]
}
fuzzer_test("u2f_ble_frames_fuzzer") {
fuzzer_test("fido_ble_frames_fuzzer") {
sources = [
"u2f_ble_frames_fuzzer.cc",
"fido_ble_frames_fuzzer.cc",
]
deps = [
":fido",
......
device/fido/u2f_ble_connection.cc → device/fido/fido_ble_connection.cc
View file @ 1710f5ad
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_connection.h"
#include "device/fido/fido_ble_connection.h"
#include <utility>
......@@ -72,10 +72,10 @@ constexpr const char* ToString(BluetoothGattService::GattErrorCode error_code) {
} // namespace
U2fBleConnection::U2fBleConnection(std::string device_address)
FidoBleConnection::FidoBleConnection(std::string device_address)
: address_(std::move(device_address)), weak_factory_(this) {}
U2fBleConnection::U2fBleConnection(
FidoBleConnection::FidoBleConnection(
std::string device_address,
ConnectionStatusCallback connection_status_callback,
ReadCallback read_callback)
......@@ -86,19 +86,19 @@ U2fBleConnection::U2fBleConnection(
DCHECK(!address_.empty());
}
U2fBleConnection::~U2fBleConnection() {
FidoBleConnection::~FidoBleConnection() {
if (adapter_)
adapter_->RemoveObserver(this);
}
void U2fBleConnection::Connect() {
void FidoBleConnection::Connect() {
BluetoothAdapterFactory::GetAdapter(
base::Bind(&U2fBleConnection::OnGetAdapter, weak_factory_.GetWeakPtr()));
base::Bind(&FidoBleConnection::OnGetAdapter, weak_factory_.GetWeakPtr()));
}
void U2fBleConnection::ReadControlPointLength(
void FidoBleConnection::ReadControlPointLength(
ControlPointLengthCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
const BluetoothRemoteGattService* u2f_service = GetFidoService();
if (!u2f_service) {
std::move(callback).Run(base::nullopt);
return;
......@@ -118,8 +118,9 @@ void U2fBleConnection::ReadControlPointLength(
base::Bind(OnReadControlPointLengthError, copyable_callback));
}
void U2fBleConnection::ReadServiceRevisions(ServiceRevisionsCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
void FidoBleConnection::ReadServiceRevisions(
ServiceRevisionsCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetFidoService();
if (!u2f_service) {
std::move(callback).Run({});
return;
......@@ -151,16 +152,16 @@ void U2fBleConnection::ReadServiceRevisions(ServiceRevisionsCallback callback) {
// the individually supported service revisions, hence the indirection to
// ReturnServiceRevisions() is introduced.
base::Closure copyable_callback = base::AdaptCallbackForRepeating(
base::BindOnce(&U2fBleConnection::ReturnServiceRevisions,
base::BindOnce(&FidoBleConnection::ReturnServiceRevisions,
weak_factory_.GetWeakPtr(), std::move(callback)));
// If the Service Revision Bitfield characteristic is not present, only
// attempt to read the Service Revision characteristic.
if (!service_revision_bitfield) {
service_revision->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevision,
base::Bind(&FidoBleConnection::OnReadServiceRevision,
weak_factory_.GetWeakPtr(), copyable_callback),
base::Bind(&U2fBleConnection::OnReadServiceRevisionError,
base::Bind(&FidoBleConnection::OnReadServiceRevisionError,
weak_factory_.GetWeakPtr(), copyable_callback));
return;
}
......@@ -169,9 +170,9 @@ void U2fBleConnection::ReadServiceRevisions(ServiceRevisionsCallback callback) {
// attempt to read the Service Revision Bitfield characteristic.
if (!service_revision) {
service_revision_bitfield->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfield,
base::Bind(&FidoBleConnection::OnReadServiceRevisionBitfield,
weak_factory_.GetWeakPtr(), copyable_callback),
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfieldError,
base::Bind(&FidoBleConnection::OnReadServiceRevisionBitfieldError,
weak_factory_.GetWeakPtr(), copyable_callback));
return;
}
......@@ -184,21 +185,21 @@ void U2fBleConnection::ReadServiceRevisions(ServiceRevisionsCallback callback) {
base::BarrierClosure(2, copyable_callback);
service_revision->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevision,
base::Bind(&FidoBleConnection::OnReadServiceRevision,
weak_factory_.GetWeakPtr(), barrier_closure),
base::Bind(&U2fBleConnection::OnReadServiceRevisionError,
base::Bind(&FidoBleConnection::OnReadServiceRevisionError,
weak_factory_.GetWeakPtr(), barrier_closure));
service_revision_bitfield->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfield,
base::Bind(&FidoBleConnection::OnReadServiceRevisionBitfield,
weak_factory_.GetWeakPtr(), barrier_closure),
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfieldError,
base::Bind(&FidoBleConnection::OnReadServiceRevisionBitfieldError,
weak_factory_.GetWeakPtr(), barrier_closure));
}
void U2fBleConnection::WriteControlPoint(const std::vector<uint8_t>& data,
WriteCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
void FidoBleConnection::WriteControlPoint(const std::vector<uint8_t>& data,
WriteCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetFidoService();
if (!u2f_service) {
std::move(callback).Run(false);
return;
......@@ -218,9 +219,9 @@ void U2fBleConnection::WriteControlPoint(const std::vector<uint8_t>& data,
base::Bind(OnWriteError, copyable_callback));
}
void U2fBleConnection::WriteServiceRevision(ServiceRevision service_revision,
WriteCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
void FidoBleConnection::WriteServiceRevision(ServiceRevision service_revision,
WriteCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetFidoService();
if (!u2f_service) {
std::move(callback).Run(false);
return;
......@@ -255,7 +256,7 @@ void U2fBleConnection::WriteServiceRevision(ServiceRevision service_revision,
base::Bind(OnWriteError, copyable_callback));
}
void U2fBleConnection::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
void FidoBleConnection::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
if (!adapter) {
DLOG(ERROR) << "Failed to get Adapter.";
OnConnectionError();
......@@ -268,7 +269,7 @@ void U2fBleConnection::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
CreateGattConnection();
}
void U2fBleConnection::CreateGattConnection() {
void FidoBleConnection::CreateGattConnection() {
BluetoothDevice* device = adapter_->GetDevice(address_);
if (!device) {
DLOG(ERROR) << "Failed to get Device.";
......@@ -277,13 +278,13 @@ void U2fBleConnection::CreateGattConnection() {
}
device->CreateGattConnection(
base::Bind(&U2fBleConnection::OnCreateGattConnection,
base::Bind(&FidoBleConnection::OnCreateGattConnection,
weak_factory_.GetWeakPtr()),
base::Bind(&U2fBleConnection::OnCreateGattConnectionError,
base::Bind(&FidoBleConnection::OnCreateGattConnectionError,
weak_factory_.GetWeakPtr()));
}
void U2fBleConnection::OnCreateGattConnection(
void FidoBleConnection::OnCreateGattConnection(
std::unique_ptr<BluetoothGattConnection> connection) {
connection_ = std::move(connection);
......@@ -298,13 +299,13 @@ void U2fBleConnection::OnCreateGattConnection(
ConnectToU2fService();
}
void U2fBleConnection::OnCreateGattConnectionError(
void FidoBleConnection::OnCreateGattConnectionError(
BluetoothDevice::ConnectErrorCode error_code) {
DLOG(ERROR) << "CreateGattConnection() failed: " << ToString(error_code);
OnConnectionError();
}
void U2fBleConnection::ConnectToU2fService() {
void FidoBleConnection::ConnectToU2fService() {
BluetoothDevice* device = adapter_->GetDevice(address_);
if (!device) {
DLOG(ERROR) << "Failed to get Device.";
......@@ -362,26 +363,26 @@ void U2fBleConnection::ConnectToU2fService() {
u2f_service->GetCharacteristic(*status_id_)
->StartNotifySession(
base::Bind(&U2fBleConnection::OnStartNotifySession,
base::Bind(&FidoBleConnection::OnStartNotifySession,
weak_factory_.GetWeakPtr()),
base::Bind(&U2fBleConnection::OnStartNotifySessionError,
base::Bind(&FidoBleConnection::OnStartNotifySessionError,
weak_factory_.GetWeakPtr()));
}
void U2fBleConnection::OnStartNotifySession(
void FidoBleConnection::OnStartNotifySession(
std::unique_ptr<BluetoothGattNotifySession> notify_session) {
notify_session_ = std::move(notify_session);
DVLOG(2) << "Created notification session. Connection established.";
connection_status_callback_.Run(true);
}
void U2fBleConnection::OnStartNotifySessionError(
void FidoBleConnection::OnStartNotifySessionError(
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "StartNotifySession() failed: " << ToString(error_code);
OnConnectionError();
}
void U2fBleConnection::OnConnectionError() {
void FidoBleConnection::OnConnectionError() {
connection_status_callback_.Run(false);
connection_.reset();
......@@ -395,7 +396,7 @@ void U2fBleConnection::OnConnectionError() {
service_revision_bitfield_id_.reset();
}
const BluetoothRemoteGattService* U2fBleConnection::GetU2fService() const {
const BluetoothRemoteGattService* FidoBleConnection::GetFidoService() const {
if (!adapter_) {
DLOG(ERROR) << "No adapter present.";
return nullptr;
......@@ -422,23 +423,23 @@ const BluetoothRemoteGattService* U2fBleConnection::GetU2fService() const {
return u2f_service;
}
void U2fBleConnection::DeviceAdded(BluetoothAdapter* adapter,
BluetoothDevice* device) {
void FidoBleConnection::DeviceAdded(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (adapter != adapter_ || device->GetAddress() != address_)
return;
CreateGattConnection();
}
void U2fBleConnection::DeviceAddressChanged(BluetoothAdapter* adapter,
BluetoothDevice* device,
const std::string& old_address) {
void FidoBleConnection::DeviceAddressChanged(BluetoothAdapter* adapter,
BluetoothDevice* device,
const std::string& old_address) {
if (adapter != adapter_ || old_address != address_)
return;
address_ = device->GetAddress();
}
void U2fBleConnection::DeviceChanged(BluetoothAdapter* adapter,
BluetoothDevice* device) {
void FidoBleConnection::DeviceChanged(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (adapter != adapter_ || device->GetAddress() != address_)
return;
if (connection_ && !device->IsGattConnected()) {
......@@ -447,7 +448,7 @@ void U2fBleConnection::DeviceChanged(BluetoothAdapter* adapter,
}
}
void U2fBleConnection::GattCharacteristicValueChanged(
void FidoBleConnection::GattCharacteristicValueChanged(
BluetoothAdapter* adapter,
BluetoothRemoteGattCharacteristic* characteristic,
const std::vector<uint8_t>& value) {
......@@ -457,15 +458,15 @@ void U2fBleConnection::GattCharacteristicValueChanged(
read_callback_.Run(value);
}
void U2fBleConnection::GattServicesDiscovered(BluetoothAdapter* adapter,
BluetoothDevice* device) {
void FidoBleConnection::GattServicesDiscovered(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (adapter != adapter_ || device->GetAddress() != address_)
return;
ConnectToU2fService();
}
// static
void U2fBleConnection::OnReadControlPointLength(
void FidoBleConnection::OnReadControlPointLength(
ControlPointLengthCallback callback,
const std::vector<uint8_t>& value) {
if (value.size() != 2) {
......@@ -480,14 +481,14 @@ void U2fBleConnection::OnReadControlPointLength(
}
// static
void U2fBleConnection::OnReadControlPointLengthError(
void FidoBleConnection::OnReadControlPointLengthError(
ControlPointLengthCallback callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Error reading Control Point Length: " << ToString(error_code);
std::move(callback).Run(base::nullopt);
}
void U2fBleConnection::OnReadServiceRevision(
void FidoBleConnection::OnReadServiceRevision(
base::OnceClosure callback,
const std::vector<uint8_t>& value) {
std::string service_revision(value.begin(), value.end());
......@@ -508,14 +509,14 @@ void U2fBleConnection::OnReadServiceRevision(
std::move(callback).Run();
}
void U2fBleConnection::OnReadServiceRevisionError(
void FidoBleConnection::OnReadServiceRevisionError(
base::OnceClosure callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Error reading Service Revision: " << ToString(error_code);
std::move(callback).Run();
}
void U2fBleConnection::OnReadServiceRevisionBitfield(
void FidoBleConnection::OnReadServiceRevisionBitfield(
base::OnceClosure callback,
const std::vector<uint8_t>& value) {
if (value.empty()) {
......@@ -549,7 +550,7 @@ void U2fBleConnection::OnReadServiceRevisionBitfield(
std::move(callback).Run();
}
void U2fBleConnection::OnReadServiceRevisionBitfieldError(
void FidoBleConnection::OnReadServiceRevisionBitfieldError(
base::OnceClosure callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Error reading Service Revision Bitfield: "
......@@ -557,19 +558,19 @@ void U2fBleConnection::OnReadServiceRevisionBitfieldError(
std::move(callback).Run();
}
void U2fBleConnection::ReturnServiceRevisions(
void FidoBleConnection::ReturnServiceRevisions(
ServiceRevisionsCallback callback) {
std::move(callback).Run(std::move(service_revisions_));
}
// static
void U2fBleConnection::OnWrite(WriteCallback callback) {
void FidoBleConnection::OnWrite(WriteCallback callback) {
DVLOG(2) << "Write succeeded.";
std::move(callback).Run(true);
}
// static
void U2fBleConnection::OnWriteError(
void FidoBleConnection::OnWriteError(
WriteCallback callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Write Failed: " << ToString(error_code);
......
device/fido/u2f_ble_connection.h → device/fido/fido_ble_connection.h
View file @ 1710f5ad
......@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_FIDO_U2F_BLE_CONNECTION_H_
#define DEVICE_FIDO_U2F_BLE_CONNECTION_H_
#ifndef DEVICE_FIDO_FIDO_BLE_CONNECTION_H_
#define DEVICE_FIDO_FIDO_BLE_CONNECTION_H_
#include <stdint.h>
......@@ -41,7 +41,7 @@ class BluetoothRemoteGattService;
//
// TODO(crbug.com/763303): Add support for pairing from within this class and
// provide users with an option to manually specify a PIN code.
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleConnection
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleConnection
: public BluetoothAdapter::Observer {
public:
enum class ServiceRevision {
......@@ -62,10 +62,10 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleConnection
using ServiceRevisionsCallback =
base::OnceCallback<void(std::set<ServiceRevision>)>;
U2fBleConnection(std::string device_address,
ConnectionStatusCallback connection_status_callback,
ReadCallback read_callback);
~U2fBleConnection() override;
FidoBleConnection(std::string device_address,
ConnectionStatusCallback connection_status_callback,
ReadCallback read_callback);
~FidoBleConnection() override;
const std::string& address() const { return address_; }
......@@ -78,7 +78,7 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleConnection
WriteCallback callback);
protected:
explicit U2fBleConnection(std::string device_address);
explicit FidoBleConnection(std::string device_address);
private:
// BluetoothAdapter::Observer:
......@@ -112,7 +112,7 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleConnection
void OnConnectionError();
const BluetoothRemoteGattService* GetU2fService() const;
const BluetoothRemoteGattService* GetFidoService() const;
static void OnReadControlPointLength(ControlPointLengthCallback callback,
const std::vector<uint8_t>& value);
......@@ -154,11 +154,11 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleConnection
std::set<ServiceRevision> service_revisions_;
base::WeakPtrFactory<U2fBleConnection> weak_factory_;
base::WeakPtrFactory<FidoBleConnection> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(U2fBleConnection);
DISALLOW_COPY_AND_ASSIGN(FidoBleConnection);
};
} // namespace device
#endif // DEVICE_FIDO_U2F_BLE_CONNECTION_H_
#endif // DEVICE_FIDO_FIDO_BLE_CONNECTION_H_
device/fido/u2f_ble_connection_unittest.cc → device/fido/fido_ble_connection_unittest.cc
View file @ 1710f5ad
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_connection.h"
#include "device/fido/fido_ble_connection.h"
#include <utility>
......@@ -81,7 +81,7 @@ class TestConnectionStatusCallback {
return status_;
}
U2fBleConnection::ConnectionStatusCallback GetCallback() {
FidoBleConnection::ConnectionStatusCallback GetCallback() {
return base::BindRepeating(&TestConnectionStatusCallback::OnStatus,
base::Unretained(this));
}
......@@ -104,7 +104,7 @@ class TestReadCallback {
return value_;
}
U2fBleConnection::ReadCallback GetCallback() {
FidoBleConnection::ReadCallback GetCallback() {
return base::BindRepeating(&TestReadCallback::OnRead,
base::Unretained(this));
}
......@@ -127,7 +127,7 @@ class TestReadControlPointLengthCallback {
return value_;
}
U2fBleConnection::ControlPointLengthCallback GetCallback() {
FidoBleConnection::ControlPointLengthCallback GetCallback() {
return base::BindOnce(
&TestReadControlPointLengthCallback::OnReadControlPointLength,
base::Unretained(this));
......@@ -141,25 +141,25 @@ class TestReadControlPointLengthCallback {
class TestReadServiceRevisionsCallback {
public:
void OnReadServiceRevisions(
std::set<U2fBleConnection::ServiceRevision> revisions) {
std::set<FidoBleConnection::ServiceRevision> revisions) {
revisions_ = std::move(revisions);
run_loop_->Quit();
}
const std::set<U2fBleConnection::ServiceRevision>& WaitForResult() {
const std::set<FidoBleConnection::ServiceRevision>& WaitForResult() {
run_loop_->Run();
run_loop_.emplace();
return revisions_;
}
U2fBleConnection::ServiceRevisionsCallback GetCallback() {
FidoBleConnection::ServiceRevisionsCallback GetCallback() {
return base::BindOnce(
&TestReadServiceRevisionsCallback::OnReadServiceRevisions,
base::Unretained(this));
}
private:
std::set<U2fBleConnection::ServiceRevision> revisions_;
std::set<FidoBleConnection::ServiceRevision> revisions_;
base::Optional<base::RunLoop> run_loop_{base::in_place};
};
......@@ -176,7 +176,7 @@ class TestWriteCallback {
return success_;
}
U2fBleConnection::WriteCallback GetCallback() {
FidoBleConnection::WriteCallback GetCallback() {
return base::BindOnce(&TestWriteCallback::OnWrite, base::Unretained(this));
}
......@@ -187,9 +187,9 @@ class TestWriteCallback {
} // namespace
class U2fBleConnectionTest : public ::testing::Test {
class FidoBleConnectionTest : public ::testing::Test {
public:
U2fBleConnectionTest() {
FidoBleConnectionTest() {
ON_CALL(*adapter_, GetDevice(_))
.WillByDefault(Invoke([this](const std::string& address) {
return GetMockDevice(adapter_.get(), address);
......@@ -424,14 +424,14 @@ class U2fBleConnectionTest : public ::testing::Test {
MockBluetoothGattNotifySession* notify_session_;
};
TEST_F(U2fBleConnectionTest, Address) {
TEST_F(FidoBleConnectionTest, Address) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
auto connect_do_nothing = [](bool) {};
auto read_do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
base::BindRepeating(connect_do_nothing),
base::BindRepeating(read_do_nothing));
FidoBleConnection connection(device_address,
base::BindRepeating(connect_do_nothing),
base::BindRepeating(read_do_nothing));
connection.Connect();
EXPECT_EQ(device_address, connection.address());
AddU2Device(device_address);
......@@ -440,40 +440,40 @@ TEST_F(U2fBleConnectionTest, Address) {
EXPECT_EQ("new_device_address", connection.address());
}
TEST_F(U2fBleConnectionTest, DeviceNotPresent) {
TEST_F(FidoBleConnectionTest, DeviceNotPresent) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
auto do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
connection.Connect();
bool result = connection_status_callback.WaitForResult();
EXPECT_FALSE(result);
}
TEST_F(U2fBleConnectionTest, PreConnected) {
TEST_F(FidoBleConnectionTest, PreConnected) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
connection.Connect();
EXPECT_TRUE(connection_status_callback.WaitForResult());
}
TEST_F(U2fBleConnectionTest, PostConnected) {
TEST_F(FidoBleConnectionTest, PostConnected) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
auto do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
connection.Connect();
bool result = connection_status_callback.WaitForResult();
EXPECT_FALSE(result);
......@@ -484,16 +484,16 @@ TEST_F(U2fBleConnectionTest, PostConnected) {
EXPECT_TRUE(connection_status_callback.WaitForResult());
}
TEST_F(U2fBleConnectionTest, DeviceDisconnect) {
TEST_F(FidoBleConnectionTest, DeviceDisconnect) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
connection.Connect();
bool result = connection_status_callback.WaitForResult();
EXPECT_TRUE(result);
......@@ -503,16 +503,16 @@ TEST_F(U2fBleConnectionTest, DeviceDisconnect) {
EXPECT_FALSE(result);
}
TEST_F(U2fBleConnectionTest, ReadStatusNotifications) {
TEST_F(FidoBleConnectionTest, ReadStatusNotifications) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
TestReadCallback read_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
read_callback.GetCallback());
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
read_callback.GetCallback());
connection.Connect();
EXPECT_TRUE(connection_status_callback.WaitForResult());
......@@ -525,16 +525,16 @@ TEST_F(U2fBleConnectionTest, ReadStatusNotifications) {
EXPECT_EQ(payload, read_callback.WaitForResult());
}
TEST_F(U2fBleConnectionTest, ReadControlPointLength) {
TEST_F(FidoBleConnectionTest, ReadControlPointLength) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto read_do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
connection.Connect();
EXPECT_TRUE(connection_status_callback.WaitForResult());
......@@ -562,16 +562,16 @@ TEST_F(U2fBleConnectionTest, ReadControlPointLength) {
EXPECT_EQ(base::nullopt, length_callback.WaitForResult());
}
TEST_F(U2fBleConnectionTest, ReadServiceRevisions) {
TEST_F(FidoBleConnectionTest, ReadServiceRevisions) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto read_do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
connection.Connect();
EXPECT_TRUE(connection_status_callback.WaitForResult());
......@@ -590,19 +590,19 @@ TEST_F(U2fBleConnectionTest, ReadServiceRevisions) {
SetNextReadServiceRevisionBitfieldResponse(false, {});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_0));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_0));
SetNextReadServiceRevisionResponse(true, ToByteVector("1.1"));
SetNextReadServiceRevisionBitfieldResponse(false, {});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_1));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1));
SetNextReadServiceRevisionResponse(true, ToByteVector("1.2"));
SetNextReadServiceRevisionBitfieldResponse(false, {});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_2));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_2));
// Version 1.3 currently does not exist, so this should be treated as an
// error.
......@@ -620,36 +620,36 @@ TEST_F(U2fBleConnectionTest, ReadServiceRevisions) {
SetNextReadServiceRevisionBitfieldResponse(true, {0x80});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_1));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1));
SetNextReadServiceRevisionResponse(false, {});
SetNextReadServiceRevisionBitfieldResponse(true, {0x40});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_2));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_2));
SetNextReadServiceRevisionResponse(false, {});
SetNextReadServiceRevisionBitfieldResponse(true, {0xC0});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_1,
U2fBleConnection::ServiceRevision::VERSION_1_2));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_2));
// All bits except the first two should be ignored.
SetNextReadServiceRevisionResponse(false, {});
SetNextReadServiceRevisionBitfieldResponse(true, {0xFF});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_1,
U2fBleConnection::ServiceRevision::VERSION_1_2));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_2));
// All bytes except the first one should be ignored.
SetNextReadServiceRevisionResponse(false, {});
SetNextReadServiceRevisionBitfieldResponse(true, {0xC0, 0xFF});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_1,
U2fBleConnection::ServiceRevision::VERSION_1_2));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_2));
// The combination of a service revision string and bitfield should be
// supported as well.
......@@ -657,21 +657,21 @@ TEST_F(U2fBleConnectionTest, ReadServiceRevisions) {
SetNextReadServiceRevisionBitfieldResponse(true, {0xC0});
connection.ReadServiceRevisions(revisions_callback.GetCallback());
EXPECT_THAT(revisions_callback.WaitForResult(),
ElementsAre(U2fBleConnection::ServiceRevision::VERSION_1_0,
U2fBleConnection::ServiceRevision::VERSION_1_1,
U2fBleConnection::ServiceRevision::VERSION_1_2));
ElementsAre(FidoBleConnection::ServiceRevision::VERSION_1_0,
FidoBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_2));
}
TEST_F(U2fBleConnectionTest, WriteControlPoint) {
TEST_F(FidoBleConnectionTest, WriteControlPoint) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto read_do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
connection.Connect();
bool result = connection_status_callback.WaitForResult();
EXPECT_TRUE(result);
......@@ -688,16 +688,16 @@ TEST_F(U2fBleConnectionTest, WriteControlPoint) {
EXPECT_TRUE(result);
}
TEST_F(U2fBleConnectionTest, WriteServiceRevision) {
TEST_F(FidoBleConnectionTest, WriteServiceRevision) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto read_do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(read_do_nothing));
connection.Connect();
bool result = connection_status_callback.WaitForResult();
EXPECT_TRUE(result);
......@@ -706,7 +706,7 @@ TEST_F(U2fBleConnectionTest, WriteServiceRevision) {
TestWriteCallback write_callback;
SetNextWriteServiceRevisionResponse(false);
connection.WriteServiceRevision(
U2fBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_1,
write_callback.GetCallback());
result = write_callback.WaitForResult();
EXPECT_FALSE(result);
......@@ -714,7 +714,7 @@ TEST_F(U2fBleConnectionTest, WriteServiceRevision) {
// Expect a successful write of version 1.1.
SetNextWriteServiceRevisionResponse(true);
connection.WriteServiceRevision(
U2fBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_1,
write_callback.GetCallback());
result = write_callback.WaitForResult();
EXPECT_TRUE(result);
......@@ -722,29 +722,29 @@ TEST_F(U2fBleConnectionTest, WriteServiceRevision) {
// Expect a successful write of version 1.2.
SetNextWriteServiceRevisionResponse(true);
connection.WriteServiceRevision(
U2fBleConnection::ServiceRevision::VERSION_1_2,
FidoBleConnection::ServiceRevision::VERSION_1_2,
write_callback.GetCallback());
result = write_callback.WaitForResult();
EXPECT_TRUE(result);
// Writing version 1.0 to the bitfield is not intended, so this should fail.
connection.WriteServiceRevision(
U2fBleConnection::ServiceRevision::VERSION_1_0,
FidoBleConnection::ServiceRevision::VERSION_1_0,
write_callback.GetCallback());
result = write_callback.WaitForResult();
EXPECT_FALSE(result);
}
TEST_F(U2fBleConnectionTest, ReadsAndWriteFailWhenDisconnected) {
TEST_F(FidoBleConnectionTest, ReadsAndWriteFailWhenDisconnected) {
const std::string device_address = BluetoothTest::kTestDeviceAddress1;
TestConnectionStatusCallback connection_status_callback;
AddU2Device(device_address);
SetupConnectingU2fDevice(device_address);
auto do_nothing = [](std::vector<uint8_t>) {};
U2fBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
FidoBleConnection connection(device_address,
connection_status_callback.GetCallback(),
base::BindRepeating(do_nothing));
connection.Connect();
bool result = connection_status_callback.WaitForResult();
EXPECT_TRUE(result);
......@@ -765,7 +765,7 @@ TEST_F(U2fBleConnectionTest, ReadsAndWriteFailWhenDisconnected) {
// Writes should always fail on a disconnected device.
TestWriteCallback write_callback;
connection.WriteServiceRevision(
U2fBleConnection::ServiceRevision::VERSION_1_1,
FidoBleConnection::ServiceRevision::VERSION_1_1,
write_callback.GetCallback());
result = write_callback.WaitForResult();
EXPECT_FALSE(result);
......
device/fido/u2f_ble_device.cc → device/fido/fido_ble_device.cc
View file @ 1710f5ad
......@@ -2,32 +2,31 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_device.h"
#include "device/fido/fido_ble_device.h"
#include "base/bind.h"
#include "base/strings/string_piece.h"
#include "components/apdu/apdu_response.h"
#include "device/fido/fido_ble_frames.h"
#include "device/fido/fido_constants.h"
#include "device/fido/u2f_ble_frames.h"
#include "device/fido/u2f_ble_transaction.h"
namespace device {
U2fBleDevice::U2fBleDevice(std::string address) : weak_factory_(this) {
connection_ = std::make_unique<U2fBleConnection>(
FidoBleDevice::FidoBleDevice(std::string address) : weak_factory_(this) {
connection_ = std::make_unique<FidoBleConnection>(
std::move(address),
base::BindRepeating(&U2fBleDevice::OnConnectionStatus,
base::BindRepeating(&FidoBleDevice::OnConnectionStatus,
base::Unretained(this)),
base::BindRepeating(&U2fBleDevice::OnStatusMessage,
base::BindRepeating(&FidoBleDevice::OnStatusMessage,
base::Unretained(this)));
}
U2fBleDevice::U2fBleDevice(std::unique_ptr<U2fBleConnection> connection)
FidoBleDevice::FidoBleDevice(std::unique_ptr<FidoBleConnection> connection)
: connection_(std::move(connection)), weak_factory_(this) {}
U2fBleDevice::~U2fBleDevice() = default;
FidoBleDevice::~FidoBleDevice() = default;
void U2fBleDevice::Connect() {
void FidoBleDevice::Connect() {
if (state_ != State::kInit)
return;
......@@ -36,12 +35,12 @@ void U2fBleDevice::Connect() {
connection_->Connect();
}
void U2fBleDevice::SendPing(std::vector<uint8_t> data,
DeviceCallback callback) {
void FidoBleDevice::SendPing(std::vector<uint8_t> data,
DeviceCallback callback) {
pending_frames_.emplace(
U2fBleFrame(FidoBleDeviceCommand::kPing, std::move(data)),
FidoBleFrame(FidoBleDeviceCommand::kPing, std::move(data)),
base::BindOnce(
[](DeviceCallback callback, base::Optional<U2fBleFrame> frame) {
[](DeviceCallback callback, base::Optional<FidoBleFrame> frame) {
std::move(callback).Run(frame ? base::make_optional(frame->data())
: base::nullopt);
},
......@@ -50,36 +49,36 @@ void U2fBleDevice::SendPing(std::vector<uint8_t> data,
}
// static
std::string U2fBleDevice::GetId(base::StringPiece address) {
std::string FidoBleDevice::GetId(base::StringPiece address) {
return std::string("ble:").append(address.begin(), address.end());
}
void U2fBleDevice::TryWink(WinkCallback callback) {
void FidoBleDevice::TryWink(WinkCallback callback) {
// U2F over BLE does not support winking.
std::move(callback).Run();
}
std::string U2fBleDevice::GetId() const {
std::string FidoBleDevice::GetId() const {
return GetId(connection_->address());
}
U2fBleConnection::ConnectionStatusCallback
U2fBleDevice::GetConnectionStatusCallbackForTesting() {
return base::BindRepeating(&U2fBleDevice::OnConnectionStatus,
FidoBleConnection::ConnectionStatusCallback
FidoBleDevice::GetConnectionStatusCallbackForTesting() {
return base::BindRepeating(&FidoBleDevice::OnConnectionStatus,
base::Unretained(this));
}
U2fBleConnection::ReadCallback U2fBleDevice::GetReadCallbackForTesting() {
return base::BindRepeating(&U2fBleDevice::OnStatusMessage,
FidoBleConnection::ReadCallback FidoBleDevice::GetReadCallbackForTesting() {
return base::BindRepeating(&FidoBleDevice::OnStatusMessage,
base::Unretained(this));
}
void U2fBleDevice::DeviceTransact(std::vector<uint8_t> command,
DeviceCallback callback) {
void FidoBleDevice::DeviceTransact(std::vector<uint8_t> command,
DeviceCallback callback) {
pending_frames_.emplace(
U2fBleFrame(FidoBleDeviceCommand::kMsg, std::move(command)),
FidoBleFrame(FidoBleDeviceCommand::kMsg, std::move(command)),
base::BindOnce(
[](DeviceCallback callback, base::Optional<U2fBleFrame> frame) {
[](DeviceCallback callback, base::Optional<FidoBleFrame> frame) {
std::move(callback).Run(frame ? base::make_optional(frame->data())
: base::nullopt);
},
......@@ -87,11 +86,11 @@ void U2fBleDevice::DeviceTransact(std::vector<uint8_t> command,
Transition();
}
base::WeakPtr<FidoDevice> U2fBleDevice::GetWeakPtr() {
base::WeakPtr<FidoDevice> FidoBleDevice::GetWeakPtr() {
return weak_factory_.GetWeakPtr();
}
void U2fBleDevice::Transition() {
void FidoBleDevice::Transition() {
switch (state_) {
case State::kInit:
Connect();
......@@ -100,11 +99,11 @@ void U2fBleDevice::Transition() {
StartTimeout();
state_ = State::kBusy;
connection_->ReadControlPointLength(base::BindOnce(
&U2fBleDevice::OnReadControlPointLength, base::Unretained(this)));
&FidoBleDevice::OnReadControlPointLength, base::Unretained(this)));
break;
case State::kReady:
if (!pending_frames_.empty()) {
U2fBleFrame frame;
FidoBleFrame frame;
FrameCallback callback;
std::tie(frame, callback) = std::move(pending_frames_.front());
pending_frames_.pop();
......@@ -126,13 +125,13 @@ void U2fBleDevice::Transition() {
}
}
void U2fBleDevice::OnConnectionStatus(bool success) {
void FidoBleDevice::OnConnectionStatus(bool success) {
StopTimeout();
state_ = success ? State::kConnected : State::kDeviceError;
Transition();
}
void U2fBleDevice::OnReadControlPointLength(base::Optional<uint16_t> length) {
void FidoBleDevice::OnReadControlPointLength(base::Optional<uint16_t> length) {
StopTimeout();
if (length) {
transaction_.emplace(connection_.get(), *length);
......@@ -143,21 +142,22 @@ void U2fBleDevice::OnReadControlPointLength(base::Optional<uint16_t> length) {
Transition();
}
void U2fBleDevice::OnStatusMessage(std::vector<uint8_t> data) {
void FidoBleDevice::OnStatusMessage(std::vector<uint8_t> data) {
if (transaction_)
transaction_->OnResponseFragment(std::move(data));
}
void U2fBleDevice::SendRequestFrame(U2fBleFrame frame, FrameCallback callback) {
void FidoBleDevice::SendRequestFrame(FidoBleFrame frame,
FrameCallback callback) {
state_ = State::kBusy;
transaction_->WriteRequestFrame(
std::move(frame),
base::BindOnce(&U2fBleDevice::OnResponseFrame, base::Unretained(this),
base::BindOnce(&FidoBleDevice::OnResponseFrame, base::Unretained(this),
std::move(callback)));
}
void U2fBleDevice::OnResponseFrame(FrameCallback callback,
base::Optional<U2fBleFrame> frame) {
void FidoBleDevice::OnResponseFrame(FrameCallback callback,
base::Optional<FidoBleFrame> frame) {
state_ = frame ? State::kReady : State::kDeviceError;
auto self = GetWeakPtr();
std::move(callback).Run(std::move(frame));
......@@ -166,15 +166,15 @@ void U2fBleDevice::OnResponseFrame(FrameCallback callback,
Transition();
}
void U2fBleDevice::StartTimeout() {
timer_.Start(FROM_HERE, kDeviceTimeout, this, &U2fBleDevice::OnTimeout);
void FidoBleDevice::StartTimeout() {
timer_.Start(FROM_HERE, kDeviceTimeout, this, &FidoBleDevice::OnTimeout);
}
void U2fBleDevice::StopTimeout() {
void FidoBleDevice::StopTimeout() {
timer_.Stop();
}
void U2fBleDevice::OnTimeout() {
void FidoBleDevice::OnTimeout() {
state_ = State::kDeviceError;
}
......
device/fido/u2f_ble_device.h → device/fido/fido_ble_device.h
View file @ 1710f5ad
......@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_FIDO_U2F_BLE_DEVICE_H_
#define DEVICE_FIDO_U2F_BLE_DEVICE_H_
#ifndef DEVICE_FIDO_FIDO_BLE_DEVICE_H_
#define DEVICE_FIDO_FIDO_BLE_DEVICE_H_
#include <memory>
#include <string>
......@@ -17,21 +17,21 @@
#include "base/optional.h"
#include "base/strings/string_piece.h"
#include "base/timer/timer.h"
#include "device/fido/fido_ble_connection.h"
#include "device/fido/fido_ble_transaction.h"
#include "device/fido/fido_constants.h"
#include "device/fido/fido_device.h"
#include "device/fido/u2f_ble_connection.h"
#include "device/fido/u2f_ble_transaction.h"
namespace device {
class U2fBleFrame;
class FidoBleFrame;
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDevice : public FidoDevice {
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleDevice : public FidoDevice {
public:
using FrameCallback = U2fBleTransaction::FrameCallback;
explicit U2fBleDevice(std::string address);
explicit U2fBleDevice(std::unique_ptr<U2fBleConnection> connection);
~U2fBleDevice() override;
using FrameCallback = FidoBleTransaction::FrameCallback;
explicit FidoBleDevice(std::string address);
explicit FidoBleDevice(std::unique_ptr<FidoBleConnection> connection);
~FidoBleDevice() override;
void Connect();
void SendPing(std::vector<uint8_t> data, DeviceCallback callback);
......@@ -41,9 +41,9 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDevice : public FidoDevice {
void TryWink(WinkCallback callback) override;
std::string GetId() const override;
U2fBleConnection::ConnectionStatusCallback
FidoBleConnection::ConnectionStatusCallback
GetConnectionStatusCallbackForTesting();
U2fBleConnection::ReadCallback GetReadCallbackForTesting();
FidoBleConnection::ReadCallback GetReadCallbackForTesting();
protected:
// FidoDevice:
......@@ -61,9 +61,9 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDevice : public FidoDevice {
void OnReadControlPointLength(base::Optional<uint16_t> length);
void SendPendingRequestFrame();
void SendRequestFrame(U2fBleFrame frame, FrameCallback callback);
void SendRequestFrame(FidoBleFrame frame, FrameCallback callback);
void OnResponseFrame(FrameCallback callback,
base::Optional<U2fBleFrame> frame);
base::Optional<FidoBleFrame> frame);
void StartTimeout();
void StopTimeout();
......@@ -72,17 +72,17 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDevice : public FidoDevice {
State state_ = State::kInit;
base::OneShotTimer timer_;
std::unique_ptr<U2fBleConnection> connection_;
std::unique_ptr<FidoBleConnection> connection_;
uint16_t control_point_length_ = 0;
base::queue<std::pair<U2fBleFrame, FrameCallback>> pending_frames_;
base::Optional<U2fBleTransaction> transaction_;
base::queue<std::pair<FidoBleFrame, FrameCallback>> pending_frames_;
base::Optional<FidoBleTransaction> transaction_;
base::WeakPtrFactory<U2fBleDevice> weak_factory_;
base::WeakPtrFactory<FidoBleDevice> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(U2fBleDevice);
DISALLOW_COPY_AND_ASSIGN(FidoBleDevice);
};
} // namespace device
#endif // DEVICE_FIDO_U2F_BLE_DEVICE_H_
#endif // DEVICE_FIDO_FIDO_BLE_DEVICE_H_
device/fido/u2f_ble_device_unittest.cc → device/fido/fido_ble_device_unittest.cc
View file @ 1710f5ad
......@@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_device.h"
#include "device/fido/fido_ble_device.h"
#include "base/optional.h"
#include "base/test/scoped_task_environment.h"
#include "device/bluetooth/test/bluetooth_test.h"
#include "device/fido/fido_constants.h"
#include "device/fido/mock_u2f_ble_connection.h"
#include "device/fido/mock_fido_ble_connection.h"
#include "device/fido/test_callback_receiver.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
......@@ -24,20 +24,20 @@ using TestDeviceCallbackReceiver =
} // namespace
class U2fBleDeviceTest : public Test {
class FidoBleDeviceTest : public Test {
public:
U2fBleDeviceTest() {
auto connection = std::make_unique<MockU2fBleConnection>(
FidoBleDeviceTest() {
auto connection = std::make_unique<MockFidoBleConnection>(
BluetoothTestBase::kTestDeviceAddress1);
connection_ = connection.get();
device_ = std::make_unique<U2fBleDevice>(std::move(connection));
device_ = std::make_unique<FidoBleDevice>(std::move(connection));
connection_->connection_status_callback() =
device_->GetConnectionStatusCallbackForTesting();
connection_->read_callback() = device_->GetReadCallbackForTesting();
}
U2fBleDevice* device() { return device_.get(); }
MockU2fBleConnection* connection() { return connection_; }
FidoBleDevice* device() { return device_.get(); }
MockFidoBleConnection* connection() { return connection_; }
void ConnectWithLength(uint16_t length) {
EXPECT_CALL(*connection(), Connect()).WillOnce(Invoke([this] {
......@@ -55,18 +55,18 @@ class U2fBleDeviceTest : public Test {
base::test::ScopedTaskEnvironment::MainThreadType::MOCK_TIME};
private:
MockU2fBleConnection* connection_;
std::unique_ptr<U2fBleDevice> device_;
MockFidoBleConnection* connection_;
std::unique_ptr<FidoBleDevice> device_;
};
TEST_F(U2fBleDeviceTest, ConnectionFailureTest) {
TEST_F(FidoBleDeviceTest, ConnectionFailureTest) {
EXPECT_CALL(*connection(), Connect()).WillOnce(Invoke([this] {
connection()->connection_status_callback().Run(false);
}));
device()->Connect();
}
TEST_F(U2fBleDeviceTest, SendPingTest_Failure_Callback) {
TEST_F(FidoBleDeviceTest, SendPingTest_Failure_Callback) {
ConnectWithLength(20);
EXPECT_CALL(*connection(), WriteControlPointPtr(_, _))
......@@ -80,7 +80,7 @@ TEST_F(U2fBleDeviceTest, SendPingTest_Failure_Callback) {
EXPECT_FALSE(std::get<0>(*callback_receiver.result()));
}
TEST_F(U2fBleDeviceTest, SendPingTest_Failure_Timeout) {
TEST_F(FidoBleDeviceTest, SendPingTest_Failure_Timeout) {
ConnectWithLength(20);
EXPECT_CALL(*connection(), WriteControlPointPtr(_, _))
......@@ -95,7 +95,7 @@ TEST_F(U2fBleDeviceTest, SendPingTest_Failure_Timeout) {
EXPECT_FALSE(std::get<0>(*callback_receiver.result()));
}
TEST_F(U2fBleDeviceTest, SendPingTest) {
TEST_F(FidoBleDeviceTest, SendPingTest) {
ConnectWithLength(20);
const std::vector<uint8_t> ping_data = {'T', 'E', 'S', 'T'};
......@@ -117,18 +117,18 @@ TEST_F(U2fBleDeviceTest, SendPingTest) {
EXPECT_EQ(ping_data, *result);
}
TEST_F(U2fBleDeviceTest, StaticGetIdTest) {
TEST_F(FidoBleDeviceTest, StaticGetIdTest) {
std::string address = BluetoothTestBase::kTestDeviceAddress1;
EXPECT_EQ("ble:" + address, U2fBleDevice::GetId(address));
EXPECT_EQ("ble:" + address, FidoBleDevice::GetId(address));
}
TEST_F(U2fBleDeviceTest, TryWinkTest) {
TEST_F(FidoBleDeviceTest, TryWinkTest) {
test::TestCallbackReceiver<> closure_receiver;
device()->TryWink(closure_receiver.callback());
closure_receiver.WaitForCallback();
}
TEST_F(U2fBleDeviceTest, GetIdTest) {
TEST_F(FidoBleDeviceTest, GetIdTest) {
EXPECT_EQ(std::string("ble:") + BluetoothTestBase::kTestDeviceAddress1,
device()->GetId());
}
......
device/fido/u2f_ble_discovery.cc → device/fido/fido_ble_discovery.cc
View file @ 1710f5ad
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_discovery.h"
#include "device/fido/fido_ble_discovery.h"
#include <string>
#include <utility>
......@@ -15,14 +15,14 @@
#include "device/bluetooth/bluetooth_discovery_filter.h"
#include "device/bluetooth/bluetooth_discovery_session.h"
#include "device/bluetooth/bluetooth_uuid.h"
#include "device/fido/fido_ble_device.h"
#include "device/fido/fido_ble_uuids.h"
#include "device/fido/u2f_ble_device.h"
namespace device {
U2fBleDiscovery::U2fBleDiscovery() : weak_factory_(this) {}
FidoBleDiscovery::FidoBleDiscovery() : weak_factory_(this) {}
U2fBleDiscovery::~U2fBleDiscovery() {
FidoBleDiscovery::~FidoBleDiscovery() {
if (adapter_)
adapter_->RemoveObserver(this);
......@@ -32,34 +32,34 @@ U2fBleDiscovery::~U2fBleDiscovery() {
OnStopped(true);
}
U2fTransportProtocol U2fBleDiscovery::GetTransportProtocol() const {
U2fTransportProtocol FidoBleDiscovery::GetTransportProtocol() const {
return U2fTransportProtocol::kBluetoothLowEnergy;
}
void U2fBleDiscovery::Start() {
void FidoBleDiscovery::Start() {
auto& factory = BluetoothAdapterFactory::Get();
factory.GetAdapter(
base::Bind(&U2fBleDiscovery::OnGetAdapter, weak_factory_.GetWeakPtr()));
base::Bind(&FidoBleDiscovery::OnGetAdapter, weak_factory_.GetWeakPtr()));
}
void U2fBleDiscovery::Stop() {
void FidoBleDiscovery::Stop() {
DCHECK(adapter_);
adapter_->RemoveObserver(this);
DCHECK(discovery_session_);
discovery_session_->Stop(
base::Bind(&U2fBleDiscovery::OnStopped, weak_factory_.GetWeakPtr(), true),
base::Bind(&U2fBleDiscovery::OnStopped, weak_factory_.GetWeakPtr(),
false));
discovery_session_->Stop(base::Bind(&FidoBleDiscovery::OnStopped,
weak_factory_.GetWeakPtr(), true),
base::Bind(&FidoBleDiscovery::OnStopped,
weak_factory_.GetWeakPtr(), false));
}
// static
const BluetoothUUID& U2fBleDiscovery::U2fServiceUUID() {
const BluetoothUUID& FidoBleDiscovery::FidoServiceUUID() {
static const BluetoothUUID service_uuid(kFidoServiceUUID);
return service_uuid;
}
void U2fBleDiscovery::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
void FidoBleDiscovery::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
DCHECK(!adapter_);
adapter_ = std::move(adapter);
DCHECK(adapter_);
......@@ -71,79 +71,79 @@ void U2fBleDiscovery::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
} else {
adapter_->SetPowered(
true,
base::Bind(&U2fBleDiscovery::OnSetPowered, weak_factory_.GetWeakPtr()),
base::Bind(&U2fBleDiscovery::OnSetPoweredError,
base::Bind(&FidoBleDiscovery::OnSetPowered, weak_factory_.GetWeakPtr()),
base::Bind(&FidoBleDiscovery::OnSetPoweredError,
weak_factory_.GetWeakPtr()));
}
}
void U2fBleDiscovery::OnSetPowered() {
void FidoBleDiscovery::OnSetPowered() {
DCHECK(adapter_);
VLOG(2) << "Adapter " << adapter_->GetAddress() << " is powered on.";
for (BluetoothDevice* device : adapter_->GetDevices()) {
if (base::ContainsKey(device->GetUUIDs(), U2fServiceUUID())) {
if (base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
VLOG(2) << "U2F BLE device: " << device->GetAddress();
AddDevice(std::make_unique<U2fBleDevice>(device->GetAddress()));
AddDevice(std::make_unique<FidoBleDevice>(device->GetAddress()));
}
}
auto filter = std::make_unique<BluetoothDiscoveryFilter>(
BluetoothTransport::BLUETOOTH_TRANSPORT_LE);
filter->AddUUID(U2fServiceUUID());
filter->AddUUID(FidoServiceUUID());
adapter_->StartDiscoverySessionWithFilter(
std::move(filter),
base::Bind(&U2fBleDiscovery::OnStartDiscoverySessionWithFilter,
base::Bind(&FidoBleDiscovery::OnStartDiscoverySessionWithFilter,
weak_factory_.GetWeakPtr()),
base::Bind(&U2fBleDiscovery::OnStartDiscoverySessionWithFilterError,
base::Bind(&FidoBleDiscovery::OnStartDiscoverySessionWithFilterError,
weak_factory_.GetWeakPtr()));
}
void U2fBleDiscovery::OnSetPoweredError() {
void FidoBleDiscovery::OnSetPoweredError() {
DLOG(ERROR) << "Failed to power on the adapter.";
NotifyDiscoveryStarted(false);
}
void U2fBleDiscovery::OnStartDiscoverySessionWithFilter(
void FidoBleDiscovery::OnStartDiscoverySessionWithFilter(
std::unique_ptr<BluetoothDiscoverySession> session) {
discovery_session_ = std::move(session);
DVLOG(2) << "Discovery session started.";
NotifyDiscoveryStarted(true);
}
void U2fBleDiscovery::OnStartDiscoverySessionWithFilterError() {
void FidoBleDiscovery::OnStartDiscoverySessionWithFilterError() {
DLOG(ERROR) << "Discovery session not started.";
NotifyDiscoveryStarted(false);
}
void U2fBleDiscovery::DeviceAdded(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (base::ContainsKey(device->GetUUIDs(), U2fServiceUUID())) {
void FidoBleDiscovery::DeviceAdded(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
VLOG(2) << "Discovered U2F BLE device: " << device->GetAddress();
AddDevice(std::make_unique<U2fBleDevice>(device->GetAddress()));
AddDevice(std::make_unique<FidoBleDevice>(device->GetAddress()));
}
}
void U2fBleDiscovery::DeviceChanged(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (base::ContainsKey(device->GetUUIDs(), U2fServiceUUID()) &&
!GetDevice(U2fBleDevice::GetId(device->GetAddress()))) {
void FidoBleDiscovery::DeviceChanged(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (base::ContainsKey(device->GetUUIDs(), FidoServiceUUID()) &&
!GetDevice(FidoBleDevice::GetId(device->GetAddress()))) {
VLOG(2) << "Discovered U2F service on existing BLE device: "
<< device->GetAddress();
AddDevice(std::make_unique<U2fBleDevice>(device->GetAddress()));
AddDevice(std::make_unique<FidoBleDevice>(device->GetAddress()));
}
}
void U2fBleDiscovery::DeviceRemoved(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (base::ContainsKey(device->GetUUIDs(), U2fServiceUUID())) {
void FidoBleDiscovery::DeviceRemoved(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (base::ContainsKey(device->GetUUIDs(), FidoServiceUUID())) {
VLOG(2) << "U2F BLE device removed: " << device->GetAddress();
RemoveDevice(U2fBleDevice::GetId(device->GetAddress()));
RemoveDevice(FidoBleDevice::GetId(device->GetAddress()));
}
}
void U2fBleDiscovery::OnStopped(bool success) {
void FidoBleDiscovery::OnStopped(bool success) {
discovery_session_.reset();
NotifyDiscoveryStopped(success);
}
......
device/fido/u2f_ble_discovery.h → device/fido/fido_ble_discovery.h
View file @ 1710f5ad
......@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_FIDO_U2F_BLE_DISCOVERY_H_
#define DEVICE_FIDO_U2F_BLE_DISCOVERY_H_
#ifndef DEVICE_FIDO_FIDO_BLE_DISCOVERY_H_
#define DEVICE_FIDO_FIDO_BLE_DISCOVERY_H_
#include <memory>
......@@ -20,12 +20,12 @@ class BluetoothDevice;
class BluetoothDiscoverySession;
class BluetoothUUID;
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDiscovery
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleDiscovery
: public FidoDiscovery,
BluetoothAdapter::Observer {
public:
U2fBleDiscovery();
~U2fBleDiscovery() override;
FidoBleDiscovery();
~FidoBleDiscovery() override;
// FidoDiscovery:
U2fTransportProtocol GetTransportProtocol() const override;
......@@ -33,7 +33,7 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDiscovery
void Stop() override;
private:
static const BluetoothUUID& U2fServiceUUID();
static const BluetoothUUID& FidoServiceUUID();
void OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter);
void OnSetPowered();
......@@ -53,11 +53,11 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleDiscovery
scoped_refptr<BluetoothAdapter> adapter_;
std::unique_ptr<BluetoothDiscoverySession> discovery_session_;
base::WeakPtrFactory<U2fBleDiscovery> weak_factory_;
base::WeakPtrFactory<FidoBleDiscovery> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(U2fBleDiscovery);
DISALLOW_COPY_AND_ASSIGN(FidoBleDiscovery);
};
} // namespace device
#endif // DEVICE_FIDO_U2F_BLE_DISCOVERY_H_
#endif // DEVICE_FIDO_FIDO_BLE_DISCOVERY_H_
device/fido/u2f_ble_discovery_unittest.cc → device/fido/fido_ble_discovery_unittest.cc
View file @ 1710f5ad
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_discovery.h"
#include "device/fido/fido_ble_discovery.h"
#include <string>
......@@ -10,8 +10,8 @@
#include "base/run_loop.h"
#include "build/build_config.h"
#include "device/bluetooth/test/bluetooth_test.h"
#include "device/fido/fido_ble_device.h"
#include "device/fido/mock_fido_discovery_observer.h"
#include "device/fido/u2f_ble_device.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
......@@ -37,11 +37,11 @@ MATCHER_P(IdMatches, id, "") {
return arg->GetId() == std::string("ble:") + id;
}
TEST_F(BluetoothTest, U2fBleDiscoveryNoAdapter) {
TEST_F(BluetoothTest, FidoBleDiscoveryNoAdapter) {
// We purposefully construct a temporary and provide no fake adapter,
// simulating cases where the discovery is destroyed before obtaining a handle
// to an adapter. This should be handled gracefully and not result in a crash.
U2fBleDiscovery discovery;
FidoBleDiscovery discovery;
// We don't expect any calls to the notification methods.
MockFidoDiscoveryObserver observer;
......@@ -52,7 +52,7 @@ TEST_F(BluetoothTest, U2fBleDiscoveryNoAdapter) {
EXPECT_CALL(observer, DeviceRemoved(&discovery, _)).Times(0);
}
TEST_F(BluetoothTest, U2fBleDiscoveryFindsKnownDevice) {
TEST_F(BluetoothTest, FidoBleDiscoveryFindsKnownDevice) {
if (!PlatformSupportsLowEnergy()) {
LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
return;
......@@ -62,7 +62,7 @@ TEST_F(BluetoothTest, U2fBleDiscoveryFindsKnownDevice) {
SimulateLowEnergyDevice(4); // This device should be ignored.
SimulateLowEnergyDevice(7);
U2fBleDiscovery discovery;
FidoBleDiscovery discovery;
MockFidoDiscoveryObserver observer;
discovery.AddObserver(&observer);
......@@ -93,14 +93,14 @@ TEST_F(BluetoothTest, U2fBleDiscoveryFindsKnownDevice) {
}
}
TEST_F(BluetoothTest, U2fBleDiscoveryFindsNewDevice) {
TEST_F(BluetoothTest, FidoBleDiscoveryFindsNewDevice) {
if (!PlatformSupportsLowEnergy()) {
LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
return;
}
InitWithFakeAdapter();
U2fBleDiscovery discovery;
FidoBleDiscovery discovery;
MockFidoDiscoveryObserver observer;
discovery.AddObserver(&observer);
......@@ -142,10 +142,10 @@ TEST_F(BluetoothTest, U2fBleDiscoveryFindsNewDevice) {
// Simulate the scenario where the BLE device is already known at start-up time,
// but no service advertisements have been received from the device yet, so we
// do not know if it is a U2F device or not. As soon as it is discovered that
// the device supports the U2F service, the observer should be notified of a new
// U2fBleDevice.
TEST_F(BluetoothTest, U2fBleDiscoveryFindsUpdatedDevice) {
// do not know if it is a CTAP2/U2F device or not. As soon as it is discovered
// that the device supports the FIDO service, the observer should be notified of
// a new FidoBleDevice.
TEST_F(BluetoothTest, FidoBleDiscoveryFindsUpdatedDevice) {
if (!PlatformSupportsLowEnergy()) {
LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
return;
......@@ -154,7 +154,7 @@ TEST_F(BluetoothTest, U2fBleDiscoveryFindsUpdatedDevice) {
SimulateLowEnergyDevice(3);
U2fBleDiscovery discovery;
FidoBleDiscovery discovery;
MockFidoDiscoveryObserver observer;
discovery.AddObserver(&observer);
......@@ -185,7 +185,7 @@ TEST_F(BluetoothTest, U2fBleDiscoveryFindsUpdatedDevice) {
const auto devices = discovery.GetDevices();
ASSERT_THAT(devices, ::testing::SizeIs(1u));
EXPECT_EQ(U2fBleDevice::GetId(BluetoothTestBase::kTestDeviceAddress1),
EXPECT_EQ(FidoBleDevice::GetId(BluetoothTestBase::kTestDeviceAddress1),
devices[0]->GetId());
}
......
device/fido/u2f_ble_frames.cc → device/fido/fido_ble_frames.cc
View file @ 1710f5ad
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_frames.h"
#include "device/fido/fido_ble_frames.h"
#include <algorithm>
#include <limits>
......@@ -13,18 +13,18 @@
namespace device {
U2fBleFrame::U2fBleFrame() = default;
FidoBleFrame::FidoBleFrame() = default;
U2fBleFrame::U2fBleFrame(FidoBleDeviceCommand command,
std::vector<uint8_t> data)
FidoBleFrame::FidoBleFrame(FidoBleDeviceCommand command,
std::vector<uint8_t> data)
: command_(command), data_(std::move(data)) {}
U2fBleFrame::U2fBleFrame(U2fBleFrame&&) = default;
U2fBleFrame& U2fBleFrame::operator=(U2fBleFrame&&) = default;
FidoBleFrame::FidoBleFrame(FidoBleFrame&&) = default;
FidoBleFrame& FidoBleFrame::operator=(FidoBleFrame&&) = default;
U2fBleFrame::~U2fBleFrame() = default;
FidoBleFrame::~FidoBleFrame() = default;
bool U2fBleFrame::IsValid() const {
bool FidoBleFrame::IsValid() const {
switch (command_) {
case FidoBleDeviceCommand::kPing:
case FidoBleDeviceCommand::kMsg:
......@@ -38,21 +38,21 @@ bool U2fBleFrame::IsValid() const {
return false;
}
U2fBleFrame::KeepaliveCode U2fBleFrame::GetKeepaliveCode() const {
FidoBleFrame::KeepaliveCode FidoBleFrame::GetKeepaliveCode() const {
DCHECK_EQ(command_, FidoBleDeviceCommand::kKeepAlive);
DCHECK_EQ(data_.size(), 1u);
return static_cast<KeepaliveCode>(data_[0]);
}
U2fBleFrame::ErrorCode U2fBleFrame::GetErrorCode() const {
FidoBleFrame::ErrorCode FidoBleFrame::GetErrorCode() const {
DCHECK_EQ(command_, FidoBleDeviceCommand::kError);
DCHECK_EQ(data_.size(), 1u);
return static_cast<ErrorCode>(data_[0]);
}
std::pair<U2fBleFrameInitializationFragment,
base::queue<U2fBleFrameContinuationFragment>>
U2fBleFrame::ToFragments(size_t max_fragment_size) const {
std::pair<FidoBleFrameInitializationFragment,
base::queue<FidoBleFrameContinuationFragment>>
FidoBleFrame::ToFragments(size_t max_fragment_size) const {
DCHECK_LE(data_.size(), std::numeric_limits<uint16_t>::max());
DCHECK_GE(max_fragment_size, 3u);
......@@ -64,10 +64,10 @@ U2fBleFrame::ToFragments(size_t max_fragment_size) const {
const size_t init_fragment_size =
std::min(max_fragment_size - 3, data_view.size());
U2fBleFrameInitializationFragment initial_fragment(
FidoBleFrameInitializationFragment initial_fragment(
command_, data_view.size(), data_view.first(init_fragment_size));
base::queue<U2fBleFrameContinuationFragment> other_fragments;
base::queue<FidoBleFrameContinuationFragment> other_fragments;
data_view = data_view.subspan(init_fragment_size);
while (!data_view.empty()) {
......@@ -84,18 +84,18 @@ U2fBleFrame::ToFragments(size_t max_fragment_size) const {
return {initial_fragment, std::move(other_fragments)};
}
U2fBleFrameFragment::U2fBleFrameFragment() = default;
FidoBleFrameFragment::FidoBleFrameFragment() = default;
U2fBleFrameFragment::U2fBleFrameFragment(const U2fBleFrameFragment& frame) =
FidoBleFrameFragment::FidoBleFrameFragment(const FidoBleFrameFragment& frame) =
default;
U2fBleFrameFragment::~U2fBleFrameFragment() = default;
FidoBleFrameFragment::~FidoBleFrameFragment() = default;
U2fBleFrameFragment::U2fBleFrameFragment(base::span<const uint8_t> fragment)
FidoBleFrameFragment::FidoBleFrameFragment(base::span<const uint8_t> fragment)
: fragment_(fragment) {}
bool U2fBleFrameInitializationFragment::Parse(
bool FidoBleFrameInitializationFragment::Parse(
base::span<const uint8_t> data,
U2fBleFrameInitializationFragment* fragment) {
FidoBleFrameInitializationFragment* fragment) {
if (data.size() < 3)
return false;
......@@ -105,11 +105,11 @@ bool U2fBleFrameInitializationFragment::Parse(
return false;
*fragment =
U2fBleFrameInitializationFragment(command, data_length, data.subspan(3));
FidoBleFrameInitializationFragment(command, data_length, data.subspan(3));
return true;
}
size_t U2fBleFrameInitializationFragment::Serialize(
size_t FidoBleFrameInitializationFragment::Serialize(
std::vector<uint8_t>* buffer) const {
buffer->push_back(static_cast<uint8_t>(command_));
buffer->push_back((data_length_ >> 8) & 0xFF);
......@@ -118,32 +118,32 @@ size_t U2fBleFrameInitializationFragment::Serialize(
return fragment().size() + 3;
}
bool U2fBleFrameContinuationFragment::Parse(
bool FidoBleFrameContinuationFragment::Parse(
base::span<const uint8_t> data,
U2fBleFrameContinuationFragment* fragment) {
FidoBleFrameContinuationFragment* fragment) {
if (data.empty())
return false;
const uint8_t sequence = data[0];
*fragment = U2fBleFrameContinuationFragment(data.subspan(1), sequence);
*fragment = FidoBleFrameContinuationFragment(data.subspan(1), sequence);
return true;
}
size_t U2fBleFrameContinuationFragment::Serialize(
size_t FidoBleFrameContinuationFragment::Serialize(
std::vector<uint8_t>* buffer) const {
buffer->push_back(sequence_);
buffer->insert(buffer->end(), fragment().begin(), fragment().end());
return fragment().size() + 1;
}
U2fBleFrameAssembler::U2fBleFrameAssembler(
const U2fBleFrameInitializationFragment& fragment)
FidoBleFrameAssembler::FidoBleFrameAssembler(
const FidoBleFrameInitializationFragment& fragment)
: data_length_(fragment.data_length()),
frame_(fragment.command(),
std::vector<uint8_t>(fragment.fragment().begin(),
fragment.fragment().end())) {}
bool U2fBleFrameAssembler::AddFragment(
const U2fBleFrameContinuationFragment& fragment) {
bool FidoBleFrameAssembler::AddFragment(
const FidoBleFrameContinuationFragment& fragment) {
if (fragment.sequence() != sequence_number_)
return false;
sequence_number_ = (sequence_number_ + 1) & 0x7F;
......@@ -158,14 +158,14 @@ bool U2fBleFrameAssembler::AddFragment(
return true;
}
bool U2fBleFrameAssembler::IsDone() const {
bool FidoBleFrameAssembler::IsDone() const {
return frame_.data().size() == data_length_;
}
U2fBleFrame* U2fBleFrameAssembler::GetFrame() {
FidoBleFrame* FidoBleFrameAssembler::GetFrame() {
return IsDone() ? &frame_ : nullptr;
}
U2fBleFrameAssembler::~U2fBleFrameAssembler() = default;
FidoBleFrameAssembler::~FidoBleFrameAssembler() = default;
} // namespace device
device/fido/u2f_ble_frames.h → device/fido/fido_ble_frames.h
View file @ 1710f5ad
......@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_FIDO_U2F_BLE_FRAMES_H_
#define DEVICE_FIDO_U2F_BLE_FRAMES_H_
#ifndef DEVICE_FIDO_FIDO_BLE_FRAMES_H_
#define DEVICE_FIDO_FIDO_BLE_FRAMES_H_
#include <stdint.h>
......@@ -18,18 +18,18 @@
namespace device {
class U2fBleFrameInitializationFragment;
class U2fBleFrameContinuationFragment;
class FidoBleFrameInitializationFragment;
class FidoBleFrameContinuationFragment;
// Encapsulates a frame, i.e., a single request to or response from a U2F
// authenticator, designed to be transported via BLE. The frame is further split
// into fragments (see U2fBleFrameFragment class).
// Encapsulates a frame, i.e., a single request to or response from a FIDO
// compliant authenticator, designed to be transported via BLE. The frame is
// further split into fragments (see FidoBleFrameFragment class).
//
// The specification of what constitues a frame can be found here:
// https://fidoalliance.org/specs/fido-u2f-v1.2-ps-20170411/fido-u2f-bt-protocol-v1.2-ps-20170411.html#h2_framing
//
// TODO(crbug/763303): Consider refactoring U2fMessage to support BLE frames.
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrame {
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleFrame {
public:
// The values which can be carried in the |data| section of a KEEPALIVE
// message sent from an authenticator.
......@@ -55,13 +55,13 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrame {
OTHER = 0x7F, // Other, unspecified error.
};
U2fBleFrame();
U2fBleFrame(FidoBleDeviceCommand command, std::vector<uint8_t> data);
FidoBleFrame();
FidoBleFrame(FidoBleDeviceCommand command, std::vector<uint8_t> data);
U2fBleFrame(U2fBleFrame&&);
U2fBleFrame& operator=(U2fBleFrame&&);
FidoBleFrame(FidoBleFrame&&);
FidoBleFrame& operator=(FidoBleFrame&&);
~U2fBleFrame();
~FidoBleFrame();
FidoBleDeviceCommand command() const { return command_; }
......@@ -78,15 +78,15 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrame {
//
// The |max_fragment_size| parameter ought to be at least 3. The resulting
// fragments' binary sizes will not exceed this value.
std::pair<U2fBleFrameInitializationFragment,
base::queue<U2fBleFrameContinuationFragment>>
std::pair<FidoBleFrameInitializationFragment,
base::queue<FidoBleFrameContinuationFragment>>
ToFragments(size_t max_fragment_size) const;
private:
FidoBleDeviceCommand command_ = FidoBleDeviceCommand::kMsg;
std::vector<uint8_t> data_;
DISALLOW_COPY_AND_ASSIGN(U2fBleFrame);
DISALLOW_COPY_AND_ASSIGN(FidoBleFrame);
};
// A single frame sent over BLE may be split over multiple writes and
......@@ -98,33 +98,33 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrame {
// https://fidoalliance.org/specs/fido-u2f-v1.2-ps-20170411/fido-u2f-bt-protocol-v1.2-ps-20170411.html#h2_framing-fragmentation
//
// Note: This class and its subclasses don't own the |data|.
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrameFragment {
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleFrameFragment {
public:
base::span<const uint8_t> fragment() const { return fragment_; }
virtual size_t Serialize(std::vector<uint8_t>* buffer) const = 0;
protected:
U2fBleFrameFragment();
explicit U2fBleFrameFragment(base::span<const uint8_t> fragment);
U2fBleFrameFragment(const U2fBleFrameFragment& frame);
virtual ~U2fBleFrameFragment();
FidoBleFrameFragment();
explicit FidoBleFrameFragment(base::span<const uint8_t> fragment);
FidoBleFrameFragment(const FidoBleFrameFragment& frame);
virtual ~FidoBleFrameFragment();
private:
base::span<const uint8_t> fragment_;
};
// An initialization fragment of a frame.
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrameInitializationFragment
: public U2fBleFrameFragment {
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleFrameInitializationFragment
: public FidoBleFrameFragment {
public:
static bool Parse(base::span<const uint8_t> data,
U2fBleFrameInitializationFragment* fragment);
FidoBleFrameInitializationFragment* fragment);
U2fBleFrameInitializationFragment() = default;
U2fBleFrameInitializationFragment(FidoBleDeviceCommand command,
uint16_t data_length,
base::span<const uint8_t> fragment)
: U2fBleFrameFragment(fragment),
FidoBleFrameInitializationFragment() = default;
FidoBleFrameInitializationFragment(FidoBleDeviceCommand command,
uint16_t data_length,
base::span<const uint8_t> fragment)
: FidoBleFrameFragment(fragment),
command_(command),
data_length_(data_length) {}
......@@ -139,16 +139,16 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrameInitializationFragment
};
// A continuation fragment of a frame.
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrameContinuationFragment
: public U2fBleFrameFragment {
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleFrameContinuationFragment
: public FidoBleFrameFragment {
public:
static bool Parse(base::span<const uint8_t> data,
U2fBleFrameContinuationFragment* fragment);
FidoBleFrameContinuationFragment* fragment);
U2fBleFrameContinuationFragment() = default;
U2fBleFrameContinuationFragment(base::span<const uint8_t> fragment,
uint8_t sequence)
: U2fBleFrameFragment(fragment), sequence_(sequence) {}
FidoBleFrameContinuationFragment() = default;
FidoBleFrameContinuationFragment(base::span<const uint8_t> fragment,
uint8_t sequence)
: FidoBleFrameFragment(fragment), sequence_(sequence) {}
uint8_t sequence() const { return sequence_; }
......@@ -158,26 +158,26 @@ class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrameContinuationFragment
uint8_t sequence_ = 0;
};
// The helper used to construct a U2fBleFrame from a sequence of its fragments.
class COMPONENT_EXPORT(DEVICE_FIDO) U2fBleFrameAssembler {
// The helper used to construct a FidoBleFrame from a sequence of its fragments.
class COMPONENT_EXPORT(DEVICE_FIDO) FidoBleFrameAssembler {
public:
explicit U2fBleFrameAssembler(
const U2fBleFrameInitializationFragment& fragment);
~U2fBleFrameAssembler();
explicit FidoBleFrameAssembler(
const FidoBleFrameInitializationFragment& fragment);
~FidoBleFrameAssembler();
bool IsDone() const;
bool AddFragment(const U2fBleFrameContinuationFragment& fragment);
U2fBleFrame* GetFrame();
bool AddFragment(const FidoBleFrameContinuationFragment& fragment);
FidoBleFrame* GetFrame();
private:
uint16_t data_length_ = 0;
uint8_t sequence_number_ = 0;
U2fBleFrame frame_;
FidoBleFrame frame_;
DISALLOW_COPY_AND_ASSIGN(U2fBleFrameAssembler);
DISALLOW_COPY_AND_ASSIGN(FidoBleFrameAssembler);
};
} // namespace device
#endif // DEVICE_FIDO_U2F_BLE_FRAMES_H_
#endif // DEVICE_FIDO_FIDO_BLE_FRAMES_H_
device/fido/u2f_ble_frames_fuzzer.cc → device/fido/fido_ble_frames_fuzzer.cc
View file @ 1710f5ad
......@@ -7,45 +7,45 @@
#include <vector>
#include "device/fido/fido_ble_frames.h"
#include "device/fido/fido_constants.h"
#include "device/fido/u2f_ble_frames.h"
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* raw_data, size_t size) {
auto data_span = base::make_span(raw_data, size);
std::vector<uint8_t> data(data_span.begin(), data_span.end());
{
device::U2fBleFrameInitializationFragment fragment(
device::FidoBleFrameInitializationFragment fragment(
device::FidoBleDeviceCommand::kMsg, 21123, data_span);
std::vector<uint8_t> buffer;
fragment.Serialize(&buffer);
device::U2fBleFrameInitializationFragment parsed_fragment;
device::U2fBleFrameInitializationFragment::Parse(data, &parsed_fragment);
device::U2fBleFrameInitializationFragment::Parse(buffer, &parsed_fragment);
device::FidoBleFrameInitializationFragment parsed_fragment;
device::FidoBleFrameInitializationFragment::Parse(data, &parsed_fragment);
device::FidoBleFrameInitializationFragment::Parse(buffer, &parsed_fragment);
buffer.clear();
parsed_fragment.Serialize(&buffer);
}
{
device::U2fBleFrameContinuationFragment fragment(data_span, 61);
device::FidoBleFrameContinuationFragment fragment(data_span, 61);
std::vector<uint8_t> buffer;
fragment.Serialize(&buffer);
device::U2fBleFrameContinuationFragment parsed_fragment;
device::U2fBleFrameContinuationFragment::Parse(data, &parsed_fragment);
device::U2fBleFrameContinuationFragment::Parse(buffer, &parsed_fragment);
device::FidoBleFrameContinuationFragment parsed_fragment;
device::FidoBleFrameContinuationFragment::Parse(data, &parsed_fragment);
device::FidoBleFrameContinuationFragment::Parse(buffer, &parsed_fragment);
buffer.clear();
parsed_fragment.Serialize(&buffer);
}
{
device::U2fBleFrame frame(device::FidoBleDeviceCommand::kPing, data);
device::FidoBleFrame frame(device::FidoBleDeviceCommand::kPing, data);
auto fragments = frame.ToFragments(20);
device::U2fBleFrameAssembler assembler(fragments.first);
device::FidoBleFrameAssembler assembler(fragments.first);
while (!fragments.second.empty()) {
assembler.AddFragment(fragments.second.front());
fragments.second.pop();
......
device/fido/u2f_ble_frames_unittest.cc → device/fido/fido_ble_frames_unittest.cc
View file @ 1710f5ad
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_frames.h"
#include "device/fido/fido_ble_frames.h"
#include <vector>
......@@ -21,33 +21,32 @@ std::vector<uint8_t> GetSomeData(size_t size) {
namespace device {
TEST(U2fBleFramesTest, InitializationFragment) {
TEST(FidoBleFramesTest, InitializationFragment) {
const std::vector<uint8_t> data = GetSomeData(25);
constexpr uint16_t kDataLength = 21123;
U2fBleFrameInitializationFragment fragment(
FidoBleFrameInitializationFragment fragment(
FidoBleDeviceCommand::kMsg, kDataLength, base::make_span(data));
std::vector<uint8_t> buffer;
const size_t binary_size = fragment.Serialize(&buffer);
EXPECT_EQ(buffer.size(), binary_size);
EXPECT_EQ(data.size() + 3, binary_size);
U2fBleFrameInitializationFragment parsed_fragment;
FidoBleFrameInitializationFragment parsed_fragment;
ASSERT_TRUE(
U2fBleFrameInitializationFragment::Parse(buffer, &parsed_fragment));
FidoBleFrameInitializationFragment::Parse(buffer, &parsed_fragment));
EXPECT_EQ(kDataLength, parsed_fragment.data_length());
EXPECT_EQ(base::make_span(data), parsed_fragment.fragment());
EXPECT_EQ(FidoBleDeviceCommand::kMsg, parsed_fragment.command());
}
TEST(U2fBleFramesTest, ContinuationFragment) {
TEST(FidoBleFramesTest, ContinuationFragment) {
const auto data = GetSomeData(25);
constexpr uint8_t kSequence = 61;
U2fBleFrameContinuationFragment fragment(base::make_span(data), kSequence);
FidoBleFrameContinuationFragment fragment(base::make_span(data), kSequence);
std::vector<uint8_t> buffer;
const size_t binary_size = fragment.Serialize(&buffer);
......@@ -55,19 +54,20 @@ TEST(U2fBleFramesTest, ContinuationFragment) {
EXPECT_EQ(data.size() + 1, binary_size);
U2fBleFrameContinuationFragment parsed_fragment;
ASSERT_TRUE(U2fBleFrameContinuationFragment::Parse(buffer, &parsed_fragment));
FidoBleFrameContinuationFragment parsed_fragment;
ASSERT_TRUE(
FidoBleFrameContinuationFragment::Parse(buffer, &parsed_fragment));
EXPECT_EQ(base::make_span(data), parsed_fragment.fragment());
EXPECT_EQ(kSequence, parsed_fragment.sequence());
}
TEST(U2fBleFramesTest, SplitAndAssemble) {
TEST(FidoBleFramesTest, SplitAndAssemble) {
for (size_t size : {0, 1, 16, 17, 18, 20, 21, 22, 35, 36,
37, 39, 40, 41, 54, 55, 56, 60, 100, 65535}) {
SCOPED_TRACE(size);
U2fBleFrame frame(FidoBleDeviceCommand::kPing, GetSomeData(size));
FidoBleFrame frame(FidoBleDeviceCommand::kPing, GetSomeData(size));
auto fragments = frame.ToFragments(20);
......@@ -75,7 +75,7 @@ TEST(U2fBleFramesTest, SplitAndAssemble) {
EXPECT_EQ(frame.data().size(),
static_cast<size_t>(fragments.first.data_length()));
U2fBleFrameAssembler assembler(fragments.first);
FidoBleFrameAssembler assembler(fragments.first);
while (!fragments.second.empty()) {
ASSERT_TRUE(assembler.AddFragment(fragments.second.front()));
fragments.second.pop();
......@@ -90,16 +90,16 @@ TEST(U2fBleFramesTest, SplitAndAssemble) {
}
}
TEST(U2fBleFramesTest, FrameAssemblerError) {
U2fBleFrame frame(FidoBleDeviceCommand::kPing, GetSomeData(30));
TEST(FidoBleFramesTest, FrameAssemblerError) {
FidoBleFrame frame(FidoBleDeviceCommand::kPing, GetSomeData(30));
auto fragments = frame.ToFragments(20);
ASSERT_EQ(1u, fragments.second.size());
fragments.second.front() =
U2fBleFrameContinuationFragment(fragments.second.front().fragment(), 51);
FidoBleFrameContinuationFragment(fragments.second.front().fragment(), 51);
U2fBleFrameAssembler assembler(fragments.first);
FidoBleFrameAssembler assembler(fragments.first);
EXPECT_FALSE(assembler.IsDone());
EXPECT_FALSE(assembler.GetFrame());
EXPECT_FALSE(assembler.AddFragment(fragments.second.front()));
......@@ -107,35 +107,35 @@ TEST(U2fBleFramesTest, FrameAssemblerError) {
EXPECT_FALSE(assembler.GetFrame());
}
TEST(U2fBleFramesTest, FrameGettersAndValidity) {
TEST(FidoBleFramesTest, FrameGettersAndValidity) {
{
U2fBleFrame frame(FidoBleDeviceCommand::kKeepAlive,
std::vector<uint8_t>(2));
FidoBleFrame frame(FidoBleDeviceCommand::kKeepAlive,
std::vector<uint8_t>(2));
EXPECT_FALSE(frame.IsValid());
}
{
U2fBleFrame frame(FidoBleDeviceCommand::kError, {});
FidoBleFrame frame(FidoBleDeviceCommand::kError, {});
EXPECT_FALSE(frame.IsValid());
}
for (auto code : {U2fBleFrame::KeepaliveCode::TUP_NEEDED,
U2fBleFrame::KeepaliveCode::PROCESSING}) {
U2fBleFrame frame(FidoBleDeviceCommand::kKeepAlive,
std::vector<uint8_t>(1, static_cast<uint8_t>(code)));
for (auto code : {FidoBleFrame::KeepaliveCode::TUP_NEEDED,
FidoBleFrame::KeepaliveCode::PROCESSING}) {
FidoBleFrame frame(FidoBleDeviceCommand::kKeepAlive,
std::vector<uint8_t>(1, static_cast<uint8_t>(code)));
EXPECT_TRUE(frame.IsValid());
EXPECT_EQ(code, frame.GetKeepaliveCode());
}
for (auto code : {
U2fBleFrame::ErrorCode::INVALID_CMD,
U2fBleFrame::ErrorCode::INVALID_PAR,
U2fBleFrame::ErrorCode::INVALID_SEQ,
U2fBleFrame::ErrorCode::INVALID_LEN,
U2fBleFrame::ErrorCode::REQ_TIMEOUT, U2fBleFrame::ErrorCode::NA_1,
U2fBleFrame::ErrorCode::NA_2, U2fBleFrame::ErrorCode::NA_3,
FidoBleFrame::ErrorCode::INVALID_CMD,
FidoBleFrame::ErrorCode::INVALID_PAR,
FidoBleFrame::ErrorCode::INVALID_SEQ,
FidoBleFrame::ErrorCode::INVALID_LEN,
FidoBleFrame::ErrorCode::REQ_TIMEOUT, FidoBleFrame::ErrorCode::NA_1,
FidoBleFrame::ErrorCode::NA_2, FidoBleFrame::ErrorCode::NA_3,
}) {
U2fBleFrame frame(FidoBleDeviceCommand::kError,
{static_cast<uint8_t>(code)});
FidoBleFrame frame(FidoBleDeviceCommand::kError,
{static_cast<uint8_t>(code)});
EXPECT_TRUE(frame.IsValid());
EXPECT_EQ(code, frame.GetErrorCode());
}
......
device/fido/u2f_ble_transaction.cc → device/fido/fido_ble_transaction.cc
View file @ 1710f5ad
......@@ -2,52 +2,52 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/u2f_ble_transaction.h"
#include "device/fido/fido_ble_transaction.h"
#include <utility>
#include "device/fido/fido_ble_connection.h"
#include "device/fido/fido_constants.h"
#include "device/fido/u2f_ble_connection.h"
namespace device {
U2fBleTransaction::U2fBleTransaction(U2fBleConnection* connection,
uint16_t control_point_length)
FidoBleTransaction::FidoBleTransaction(FidoBleConnection* connection,
uint16_t control_point_length)
: connection_(connection),
control_point_length_(control_point_length),
weak_factory_(this) {
buffer_.reserve(control_point_length_);
}
U2fBleTransaction::~U2fBleTransaction() = default;
FidoBleTransaction::~FidoBleTransaction() = default;
void U2fBleTransaction::WriteRequestFrame(U2fBleFrame request_frame,
FrameCallback callback) {
void FidoBleTransaction::WriteRequestFrame(FidoBleFrame request_frame,
FrameCallback callback) {
DCHECK(!request_frame_ && callback_.is_null());
request_frame_ = std::move(request_frame);
callback_ = std::move(callback);
U2fBleFrameInitializationFragment request_init_fragment;
FidoBleFrameInitializationFragment request_init_fragment;
std::tie(request_init_fragment, request_cont_fragments_) =
request_frame_->ToFragments(control_point_length_);
WriteRequestFragment(request_init_fragment);
}
void U2fBleTransaction::WriteRequestFragment(
const U2fBleFrameFragment& fragment) {
void FidoBleTransaction::WriteRequestFragment(
const FidoBleFrameFragment& fragment) {
buffer_.clear();
fragment.Serialize(&buffer_);
// A weak pointer is required, since this call might time out. If that
// happens, the current U2fBleTransaction could be destroyed.
// happens, the current FidoBleTransaction could be destroyed.
connection_->WriteControlPoint(
buffer_, base::BindOnce(&U2fBleTransaction::OnRequestFragmentWritten,
buffer_, base::BindOnce(&FidoBleTransaction::OnRequestFragmentWritten,
weak_factory_.GetWeakPtr()));
// WriteRequestFragment() expects an invocation of OnRequestFragmentWritten()
// soon after.
StartTimeout();
}
void U2fBleTransaction::OnRequestFragmentWritten(bool success) {
void FidoBleTransaction::OnRequestFragmentWritten(bool success) {
StopTimeout();
if (!success) {
OnError();
......@@ -66,11 +66,11 @@ void U2fBleTransaction::OnRequestFragmentWritten(bool success) {
WriteRequestFragment(next_request_fragment);
}
void U2fBleTransaction::OnResponseFragment(std::vector<uint8_t> data) {
void FidoBleTransaction::OnResponseFragment(std::vector<uint8_t> data) {
StopTimeout();
if (!response_frame_assembler_) {
U2fBleFrameInitializationFragment fragment;
if (!U2fBleFrameInitializationFragment::Parse(data, &fragment)) {
FidoBleFrameInitializationFragment fragment;
if (!FidoBleFrameInitializationFragment::Parse(data, &fragment)) {
DLOG(ERROR) << "Malformed Frame Initialization Fragment";
OnError();
return;
......@@ -78,8 +78,8 @@ void U2fBleTransaction::OnResponseFragment(std::vector<uint8_t> data) {
response_frame_assembler_.emplace(fragment);
} else {
U2fBleFrameContinuationFragment fragment;
if (!U2fBleFrameContinuationFragment::Parse(data, &fragment)) {
FidoBleFrameContinuationFragment fragment;
if (!FidoBleFrameContinuationFragment::Parse(data, &fragment)) {
DLOG(ERROR) << "Malformed Frame Continuation Fragment";
OnError();
return;
......@@ -94,12 +94,12 @@ void U2fBleTransaction::OnResponseFragment(std::vector<uint8_t> data) {
return;
}
U2fBleFrame frame = std::move(*response_frame_assembler_->GetFrame());
FidoBleFrame frame = std::move(*response_frame_assembler_->GetFrame());
response_frame_assembler_.reset();
ProcessResponseFrame(std::move(frame));
}
void U2fBleTransaction::ProcessResponseFrame(U2fBleFrame response_frame) {
void FidoBleTransaction::ProcessResponseFrame(FidoBleFrame response_frame) {
if (response_frame.command() == request_frame_->command()) {
request_frame_.reset();
std::move(callback_).Run(std::move(response_frame));
......@@ -120,15 +120,15 @@ void U2fBleTransaction::ProcessResponseFrame(U2fBleFrame response_frame) {
OnError();
}
void U2fBleTransaction::StartTimeout() {
timer_.Start(FROM_HERE, kDeviceTimeout, this, &U2fBleTransaction::OnError);
void FidoBleTransaction::StartTimeout() {
timer_.Start(FROM_HERE, kDeviceTimeout, this, &FidoBleTransaction::OnError);
}
void U2fBleTransaction::StopTimeout() {
void FidoBleTransaction::StopTimeout() {
timer_.Stop();
}
void U2fBleTransaction::OnError() {
void FidoBleTransaction::OnError() {
request_frame_.reset();
request_cont_fragments_ = {};
response_frame_assembler_.reset();
......
device/fido/u2f_ble_transaction.h → device/fido/fido_ble_transaction.h
View file @ 1710f5ad
......@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_FIDO_U2F_BLE_TRANSACTION_H_
#define DEVICE_FIDO_U2F_BLE_TRANSACTION_H_
#ifndef DEVICE_FIDO_FIDO_BLE_TRANSACTION_H_
#define DEVICE_FIDO_FIDO_BLE_TRANSACTION_H_
#include <memory>
#include <vector>
......@@ -13,52 +13,52 @@
#include "base/memory/weak_ptr.h"
#include "base/optional.h"
#include "base/timer/timer.h"
#include "device/fido/u2f_ble_frames.h"
#include "device/fido/fido_ble_frames.h"
namespace device {
class U2fBleConnection;
class FidoBleConnection;
// This class encapsulates logic related to a single U2F BLE request and
// response. U2fBleTransaction is owned by U2fBleDevice, which is the only class
// that should make use of this class.
class U2fBleTransaction {
// response. FidoBleTransaction is owned by FidoBleDevice, which is the only
// class that should make use of this class.
class FidoBleTransaction {
public:
using FrameCallback = base::OnceCallback<void(base::Optional<U2fBleFrame>)>;
using FrameCallback = base::OnceCallback<void(base::Optional<FidoBleFrame>)>;
U2fBleTransaction(U2fBleConnection* connection,
uint16_t control_point_length);
~U2fBleTransaction();
FidoBleTransaction(FidoBleConnection* connection,
uint16_t control_point_length);
~FidoBleTransaction();
void WriteRequestFrame(U2fBleFrame request_frame, FrameCallback callback);
void WriteRequestFrame(FidoBleFrame request_frame, FrameCallback callback);
void OnResponseFragment(std::vector<uint8_t> data);
private:
void WriteRequestFragment(const U2fBleFrameFragment& fragment);
void WriteRequestFragment(const FidoBleFrameFragment& fragment);
void OnRequestFragmentWritten(bool success);
void ProcessResponseFrame(U2fBleFrame response_frame);
void ProcessResponseFrame(FidoBleFrame response_frame);
void StartTimeout();
void StopTimeout();
void OnError();
U2fBleConnection* connection_;
FidoBleConnection* connection_;
uint16_t control_point_length_;
base::Optional<U2fBleFrame> request_frame_;
base::Optional<FidoBleFrame> request_frame_;
FrameCallback callback_;
base::queue<U2fBleFrameContinuationFragment> request_cont_fragments_;
base::Optional<U2fBleFrameAssembler> response_frame_assembler_;
base::queue<FidoBleFrameContinuationFragment> request_cont_fragments_;
base::Optional<FidoBleFrameAssembler> response_frame_assembler_;
std::vector<uint8_t> buffer_;
base::OneShotTimer timer_;
base::WeakPtrFactory<U2fBleTransaction> weak_factory_;
base::WeakPtrFactory<FidoBleTransaction> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(U2fBleTransaction);
DISALLOW_COPY_AND_ASSIGN(FidoBleTransaction);
};
} // namespace device
#endif // DEVICE_FIDO_U2F_BLE_TRANSACTION_H_
#endif // DEVICE_FIDO_FIDO_BLE_TRANSACTION_H_
device/fido/fido_discovery.cc
View file @ 1710f5ad
......@@ -8,8 +8,8 @@
#include "base/logging.h"
#include "build/build_config.h"
#include "device/fido/fido_ble_discovery.h"
#include "device/fido/fido_device.h"
#include "device/fido/u2f_ble_discovery.h"
// HID is not supported on Android.
#if !defined(OS_ANDROID)
......@@ -34,7 +34,7 @@ std::unique_ptr<FidoDiscovery> CreateFidoDiscoveryImpl(
#endif // !defined(OS_ANDROID)
break;
case U2fTransportProtocol::kBluetoothLowEnergy:
discovery = std::make_unique<U2fBleDiscovery>();
discovery = std::make_unique<FidoBleDiscovery>();
break;
}
......
device/fido/mock_u2f_ble_connection.cc → device/fido/mock_fido_ble_connection.cc
View file @ 1710f5ad
......@@ -2,33 +2,33 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/fido/mock_u2f_ble_connection.h"
#include "device/fido/mock_fido_ble_connection.h"
#include <utility>
namespace device {
MockU2fBleConnection::MockU2fBleConnection(std::string device_address)
: U2fBleConnection(std::move(device_address)) {}
MockFidoBleConnection::MockFidoBleConnection(std::string device_address)
: FidoBleConnection(std::move(device_address)) {}
MockU2fBleConnection::~MockU2fBleConnection() = default;
MockFidoBleConnection::~MockFidoBleConnection() = default;
void MockU2fBleConnection::ReadControlPointLength(
void MockFidoBleConnection::ReadControlPointLength(
ControlPointLengthCallback callback) {
ReadControlPointLengthPtr(&callback);
}
void MockU2fBleConnection::ReadServiceRevisions(
void MockFidoBleConnection::ReadServiceRevisions(
ServiceRevisionsCallback callback) {
ReadServiceRevisionsPtr(&callback);
}
void MockU2fBleConnection::WriteControlPoint(const std::vector<uint8_t>& data,
WriteCallback callback) {
void MockFidoBleConnection::WriteControlPoint(const std::vector<uint8_t>& data,
WriteCallback callback) {
WriteControlPointPtr(data, &callback);
}
void MockU2fBleConnection::WriteServiceRevision(
void MockFidoBleConnection::WriteServiceRevision(
ServiceRevision service_revision,
WriteCallback callback) {
WriteServiceRevisionPtr(service_revision, &callback);
......
device/fido/mock_u2f_ble_connection.h → device/fido/mock_fido_ble_connection.h
View file @ 1710f5ad
......@@ -2,23 +2,23 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_FIDO_MOCK_U2F_BLE_CONNECTION_H_
#define DEVICE_FIDO_MOCK_U2F_BLE_CONNECTION_H_
#ifndef DEVICE_FIDO_MOCK_FIDO_BLE_CONNECTION_H_
#define DEVICE_FIDO_MOCK_FIDO_BLE_CONNECTION_H_
#include <string>
#include <vector>
#include "base/component_export.h"
#include "base/macros.h"
#include "device/fido/u2f_ble_connection.h"
#include "device/fido/fido_ble_connection.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace device {
class MockU2fBleConnection : public U2fBleConnection {
class MockFidoBleConnection : public FidoBleConnection {
public:
explicit MockU2fBleConnection(std::string device_address);
~MockU2fBleConnection() override;
explicit MockFidoBleConnection(std::string device_address);
~MockFidoBleConnection() override;
MOCK_METHOD0(Connect, void());
// GMock cannot mock a method taking a move-only type.
......@@ -48,9 +48,9 @@ class MockU2fBleConnection : public U2fBleConnection {
ConnectionStatusCallback connection_status_callback_;
ReadCallback read_callback_;
DISALLOW_COPY_AND_ASSIGN(MockU2fBleConnection);
DISALLOW_COPY_AND_ASSIGN(MockFidoBleConnection);
};
} // namespace device
#endif // DEVICE_FIDO_MOCK_U2F_BLE_CONNECTION_H_
#endif // DEVICE_FIDO_MOCK_FIDO_BLE_CONNECTION_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment