blob: 7dc587bf920c6f1eef2298d5ff935aa1eb0d4428 [file] [log] [blame]
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/u2f/u2f_ble_connection.h"
#include <utility>
#include "base/barrier_closure.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/bluetooth_gatt_connection.h"
#include "device/bluetooth/bluetooth_gatt_notify_session.h"
#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
#include "device/bluetooth/bluetooth_remote_gatt_service.h"
#include "device/bluetooth/bluetooth_uuid.h"
#include "device/u2f/u2f_ble_uuids.h"
namespace device {
namespace {
constexpr const char* ToString(BluetoothDevice::ConnectErrorCode error_code) {
switch (error_code) {
case BluetoothDevice::ERROR_AUTH_CANCELED:
return "ERROR_AUTH_CANCELED";
case BluetoothDevice::ERROR_AUTH_FAILED:
return "ERROR_AUTH_FAILED";
case BluetoothDevice::ERROR_AUTH_REJECTED:
return "ERROR_AUTH_REJECTED";
case BluetoothDevice::ERROR_AUTH_TIMEOUT:
return "ERROR_AUTH_TIMEOUT";
case BluetoothDevice::ERROR_FAILED:
return "ERROR_FAILED";
case BluetoothDevice::ERROR_INPROGRESS:
return "ERROR_INPROGRESS";
case BluetoothDevice::ERROR_UNKNOWN:
return "ERROR_UNKNOWN";
case BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
return "ERROR_UNSUPPORTED_DEVICE";
default:
NOTREACHED();
return "";
}
}
constexpr const char* ToString(BluetoothGattService::GattErrorCode error_code) {
switch (error_code) {
case BluetoothGattService::GATT_ERROR_UNKNOWN:
return "GATT_ERROR_UNKNOWN";
case BluetoothGattService::GATT_ERROR_FAILED:
return "GATT_ERROR_FAILED";
case BluetoothGattService::GATT_ERROR_IN_PROGRESS:
return "GATT_ERROR_IN_PROGRESS";
case BluetoothGattService::GATT_ERROR_INVALID_LENGTH:
return "GATT_ERROR_INVALID_LENGTH";
case BluetoothGattService::GATT_ERROR_NOT_PERMITTED:
return "GATT_ERROR_NOT_PERMITTED";
case BluetoothGattService::GATT_ERROR_NOT_AUTHORIZED:
return "GATT_ERROR_NOT_AUTHORIZED";
case BluetoothGattService::GATT_ERROR_NOT_PAIRED:
return "GATT_ERROR_NOT_PAIRED";
case BluetoothGattService::GATT_ERROR_NOT_SUPPORTED:
return "GATT_ERROR_NOT_SUPPORTED";
default:
NOTREACHED();
return "";
}
}
} // namespace
U2fBleConnection::U2fBleConnection(std::string device_address)
: address_(std::move(device_address)), weak_factory_(this) {}
U2fBleConnection::U2fBleConnection(
std::string device_address,
ConnectionStatusCallback connection_status_callback,
ReadCallback read_callback)
: address_(std::move(device_address)),
connection_status_callback_(std::move(connection_status_callback)),
read_callback_(std::move(read_callback)),
weak_factory_(this) {
DCHECK(!address_.empty());
}
U2fBleConnection::~U2fBleConnection() {
if (adapter_)
adapter_->RemoveObserver(this);
}
void U2fBleConnection::Connect() {
BluetoothAdapterFactory::GetAdapter(
base::Bind(&U2fBleConnection::OnGetAdapter, weak_factory_.GetWeakPtr()));
}
void U2fBleConnection::ReadControlPointLength(
ControlPointLengthCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
if (!u2f_service) {
std::move(callback).Run(base::nullopt);
return;
}
BluetoothRemoteGattCharacteristic* control_point_length =
u2f_service->GetCharacteristic(*control_point_length_id_);
if (!control_point_length) {
DLOG(ERROR) << "No Control Point Length characteristic present.";
std::move(callback).Run(base::nullopt);
return;
}
auto copyable_callback = base::AdaptCallbackForRepeating(std::move(callback));
control_point_length->ReadRemoteCharacteristic(
base::Bind(OnReadControlPointLength, copyable_callback),
base::Bind(OnReadControlPointLengthError, copyable_callback));
}
void U2fBleConnection::ReadServiceRevisions(ServiceRevisionsCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
if (!u2f_service) {
std::move(callback).Run({});
return;
}
DCHECK(service_revision_id_ || service_revision_bitfield_id_);
BluetoothRemoteGattCharacteristic* service_revision =
service_revision_id_
? u2f_service->GetCharacteristic(*service_revision_id_)
: nullptr;
BluetoothRemoteGattCharacteristic* service_revision_bitfield =
service_revision_bitfield_id_
? u2f_service->GetCharacteristic(*service_revision_bitfield_id_)
: nullptr;
if (!service_revision && !service_revision_bitfield) {
DLOG(ERROR) << "Service Revision Characteristics do not exist.";
std::move(callback).Run({});
return;
}
// Start from a clean state.
service_revisions_.clear();
// In order to obtain the full set of supported service revisions it is
// possible that both the |service_revision_| and |service_revision_bitfield_|
// characteristics must be read. Potentially we need to take the union of
// the individually supported service revisions, hence the indirection to
// ReturnServiceRevisions() is introduced.
base::Closure copyable_callback = base::AdaptCallbackForRepeating(
base::BindOnce(&U2fBleConnection::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,
weak_factory_.GetWeakPtr(), copyable_callback),
base::Bind(&U2fBleConnection::OnReadServiceRevisionError,
weak_factory_.GetWeakPtr(), copyable_callback));
return;
}
// If the Service Revision characteristic is not present, only
// attempt to read the Service Revision Bitfield characteristic.
if (!service_revision) {
service_revision_bitfield->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfield,
weak_factory_.GetWeakPtr(), copyable_callback),
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfieldError,
weak_factory_.GetWeakPtr(), copyable_callback));
return;
}
// This is the case where both characteristics are present. These reads can
// happen in parallel, but both must finish before a result can be returned.
// Hence a BarrierClosure is introduced invoking ReturnServiceRevisions() once
// both characteristic reads are done.
base::RepeatingClosure barrier_closure =
base::BarrierClosure(2, copyable_callback);
service_revision->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevision,
weak_factory_.GetWeakPtr(), barrier_closure),
base::Bind(&U2fBleConnection::OnReadServiceRevisionError,
weak_factory_.GetWeakPtr(), barrier_closure));
service_revision_bitfield->ReadRemoteCharacteristic(
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfield,
weak_factory_.GetWeakPtr(), barrier_closure),
base::Bind(&U2fBleConnection::OnReadServiceRevisionBitfieldError,
weak_factory_.GetWeakPtr(), barrier_closure));
}
void U2fBleConnection::WriteControlPoint(const std::vector<uint8_t>& data,
WriteCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
if (!u2f_service) {
std::move(callback).Run(false);
return;
}
BluetoothRemoteGattCharacteristic* control_point =
u2f_service->GetCharacteristic(*control_point_id_);
if (!control_point) {
DLOG(ERROR) << "Control Point characteristic not present.";
std::move(callback).Run(false);
return;
}
auto copyable_callback = base::AdaptCallbackForRepeating(std::move(callback));
control_point->WriteRemoteCharacteristic(
data, base::Bind(OnWrite, copyable_callback),
base::Bind(OnWriteError, copyable_callback));
}
void U2fBleConnection::WriteServiceRevision(ServiceRevision service_revision,
WriteCallback callback) {
const BluetoothRemoteGattService* u2f_service = GetU2fService();
if (!u2f_service) {
std::move(callback).Run(false);
return;
}
BluetoothRemoteGattCharacteristic* service_revision_bitfield =
u2f_service->GetCharacteristic(*service_revision_bitfield_id_);
if (!service_revision_bitfield) {
DLOG(ERROR) << "Service Revision Bitfield characteristic not present.";
std::move(callback).Run(false);
return;
}
std::vector<uint8_t> payload;
switch (service_revision) {
case ServiceRevision::VERSION_1_1:
payload.push_back(0x80);
break;
case ServiceRevision::VERSION_1_2:
payload.push_back(0x40);
break;
default:
DLOG(ERROR)
<< "Write Service Revision Failed: Unsupported Service Revision.";
std::move(callback).Run(false);
return;
}
auto copyable_callback = base::AdaptCallbackForRepeating(std::move(callback));
service_revision_bitfield->WriteRemoteCharacteristic(
payload, base::Bind(OnWrite, copyable_callback),
base::Bind(OnWriteError, copyable_callback));
}
void U2fBleConnection::OnGetAdapter(scoped_refptr<BluetoothAdapter> adapter) {
if (!adapter) {
DLOG(ERROR) << "Failed to get Adapter.";
OnConnectionError();
return;
}
DVLOG(2) << "Got Adapter: " << adapter->GetAddress();
adapter_ = std::move(adapter);
adapter_->AddObserver(this);
CreateGattConnection();
}
void U2fBleConnection::CreateGattConnection() {
BluetoothDevice* device = adapter_->GetDevice(address_);
if (!device) {
DLOG(ERROR) << "Failed to get Device.";
OnConnectionError();
return;
}
device->CreateGattConnection(
base::Bind(&U2fBleConnection::OnCreateGattConnection,
weak_factory_.GetWeakPtr()),
base::Bind(&U2fBleConnection::OnCreateGattConnectionError,
weak_factory_.GetWeakPtr()));
}
void U2fBleConnection::OnCreateGattConnection(
std::unique_ptr<BluetoothGattConnection> connection) {
connection_ = std::move(connection);
BluetoothDevice* device = adapter_->GetDevice(address_);
if (!device) {
DLOG(ERROR) << "Failed to get Device.";
OnConnectionError();
return;
}
if (device->IsGattServicesDiscoveryComplete())
ConnectToU2fService();
}
void U2fBleConnection::OnCreateGattConnectionError(
BluetoothDevice::ConnectErrorCode error_code) {
DLOG(ERROR) << "CreateGattConnection() failed: " << ToString(error_code);
OnConnectionError();
}
void U2fBleConnection::ConnectToU2fService() {
BluetoothDevice* device = adapter_->GetDevice(address_);
if (!device) {
DLOG(ERROR) << "Failed to get Device.";
OnConnectionError();
return;
}
DCHECK(device->IsGattServicesDiscoveryComplete());
const std::vector<BluetoothRemoteGattService*> services =
device->GetGattServices();
auto found =
std::find_if(services.begin(), services.end(), [](const auto* service) {
return service->GetUUID().canonical_value() == kU2fServiceUUID;
});
if (found == services.end()) {
DLOG(ERROR) << "Failed to get U2F Service.";
OnConnectionError();
return;
}
const BluetoothRemoteGattService* u2f_service = *found;
u2f_service_id_ = u2f_service->GetIdentifier();
DVLOG(2) << "Got U2F Service: " << *u2f_service_id_;
for (const auto* characteristic : u2f_service->GetCharacteristics()) {
// NOTE: Since GetUUID() returns a temporary |uuid| can't be a reference,
// even though canonical_value() returns a const reference.
const std::string uuid = characteristic->GetUUID().canonical_value();
if (uuid == kU2fControlPointLengthUUID) {
control_point_length_id_ = characteristic->GetIdentifier();
DVLOG(2) << "Got U2F Control Point Length: " << *control_point_length_id_;
} else if (uuid == kU2fControlPointUUID) {
control_point_id_ = characteristic->GetIdentifier();
DVLOG(2) << "Got U2F Control Point: " << *control_point_id_;
} else if (uuid == kU2fStatusUUID) {
status_id_ = characteristic->GetIdentifier();
DVLOG(2) << "Got U2F Status: " << *status_id_;
} else if (uuid == kU2fServiceRevisionUUID) {
service_revision_id_ = characteristic->GetIdentifier();
DVLOG(2) << "Got U2F Service Revision: " << *service_revision_id_;
} else if (uuid == kU2fServiceRevisionBitfieldUUID) {
service_revision_bitfield_id_ = characteristic->GetIdentifier();
DVLOG(2) << "Got U2F Service Revision Bitfield: "
<< *service_revision_bitfield_id_;
}
}
if (!control_point_length_id_ || !control_point_id_ || !status_id_ ||
(!service_revision_id_ && !service_revision_bitfield_id_)) {
DLOG(ERROR) << "U2F characteristics missing.";
OnConnectionError();
return;
}
u2f_service->GetCharacteristic(*status_id_)
->StartNotifySession(
base::Bind(&U2fBleConnection::OnStartNotifySession,
weak_factory_.GetWeakPtr()),
base::Bind(&U2fBleConnection::OnStartNotifySessionError,
weak_factory_.GetWeakPtr()));
}
void U2fBleConnection::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(
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "StartNotifySession() failed: " << ToString(error_code);
OnConnectionError();
}
void U2fBleConnection::OnConnectionError() {
connection_status_callback_.Run(false);
connection_.reset();
notify_session_.reset();
u2f_service_id_.reset();
control_point_length_id_.reset();
control_point_id_.reset();
status_id_.reset();
service_revision_id_.reset();
service_revision_bitfield_id_.reset();
}
const BluetoothRemoteGattService* U2fBleConnection::GetU2fService() const {
if (!adapter_) {
DLOG(ERROR) << "No adapter present.";
return nullptr;
}
const BluetoothDevice* device = adapter_->GetDevice(address_);
if (!device) {
DLOG(ERROR) << "No device present.";
return nullptr;
}
if (!u2f_service_id_) {
DLOG(ERROR) << "Unknown U2F service id.";
return nullptr;
}
const BluetoothRemoteGattService* u2f_service =
device->GetGattService(*u2f_service_id_);
if (!u2f_service) {
DLOG(ERROR) << "No U2F service present.";
return nullptr;
}
return u2f_service;
}
void U2fBleConnection::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) {
if (adapter != adapter_ || old_address != address_)
return;
address_ = device->GetAddress();
}
void U2fBleConnection::DeviceChanged(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (adapter != adapter_ || device->GetAddress() != address_)
return;
if (connection_ && !device->IsGattConnected()) {
DLOG(ERROR) << "GATT Disconnected: " << device->GetAddress();
OnConnectionError();
}
}
void U2fBleConnection::GattCharacteristicValueChanged(
BluetoothAdapter* adapter,
BluetoothRemoteGattCharacteristic* characteristic,
const std::vector<uint8_t>& value) {
if (characteristic->GetIdentifier() != status_id_)
return;
DVLOG(2) << "Status characteristic value changed.";
read_callback_.Run(value);
}
void U2fBleConnection::GattServicesDiscovered(BluetoothAdapter* adapter,
BluetoothDevice* device) {
if (adapter != adapter_ || device->GetAddress() != address_)
return;
ConnectToU2fService();
}
// static
void U2fBleConnection::OnReadControlPointLength(
ControlPointLengthCallback callback,
const std::vector<uint8_t>& value) {
if (value.size() != 2) {
DLOG(ERROR) << "Wrong Control Point Length: " << value.size() << " bytes";
std::move(callback).Run(base::nullopt);
return;
}
uint16_t length = (value[0] << 8) | value[1];
DVLOG(2) << "Control Point Length: " << length;
std::move(callback).Run(length);
}
// static
void U2fBleConnection::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(
base::OnceClosure callback,
const std::vector<uint8_t>& value) {
std::string service_revision(value.begin(), value.end());
DVLOG(2) << "Service Revision: " << service_revision;
if (service_revision == "1.0") {
service_revisions_.insert(ServiceRevision::VERSION_1_0);
} else if (service_revision == "1.1") {
service_revisions_.insert(ServiceRevision::VERSION_1_1);
} else if (service_revision == "1.2") {
service_revisions_.insert(ServiceRevision::VERSION_1_2);
} else {
DLOG(ERROR) << "Unknown Service Revision: " << service_revision;
std::move(callback).Run();
return;
}
std::move(callback).Run();
}
void U2fBleConnection::OnReadServiceRevisionError(
base::OnceClosure callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Error reading Service Revision: " << ToString(error_code);
std::move(callback).Run();
}
void U2fBleConnection::OnReadServiceRevisionBitfield(
base::OnceClosure callback,
const std::vector<uint8_t>& value) {
if (value.empty()) {
DLOG(ERROR) << "Service Revision Bitfield is empty.";
std::move(callback).Run();
return;
}
if (value.size() != 1u) {
DLOG(ERROR) << "Service Revision Bitfield has unexpected size: "
<< value.size() << ". Ignoring all but the first byte.";
}
const uint8_t bitset = value[0];
if (bitset & 0x3F) {
DLOG(ERROR) << "Service Revision Bitfield has unexpected bits set: 0x"
<< std::hex << (bitset & 0x3F)
<< ". Ignoring all but the first two bits.";
}
if (bitset & 0x80) {
service_revisions_.insert(ServiceRevision::VERSION_1_1);
DVLOG(2) << "Detected Support for Service Revision 1.1";
}
if (bitset & 0x40) {
service_revisions_.insert(ServiceRevision::VERSION_1_2);
DVLOG(2) << "Detected Support for Service Revision 1.2";
}
std::move(callback).Run();
}
void U2fBleConnection::OnReadServiceRevisionBitfieldError(
base::OnceClosure callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Error reading Service Revision Bitfield: "
<< ToString(error_code);
std::move(callback).Run();
}
void U2fBleConnection::ReturnServiceRevisions(
ServiceRevisionsCallback callback) {
std::move(callback).Run(std::move(service_revisions_));
}
// static
void U2fBleConnection::OnWrite(WriteCallback callback) {
DVLOG(2) << "Write succeeded.";
std::move(callback).Run(true);
}
// static
void U2fBleConnection::OnWriteError(
WriteCallback callback,
BluetoothGattService::GattErrorCode error_code) {
DLOG(ERROR) << "Write Failed: " << ToString(error_code);
std::move(callback).Run(false);
}
} // namespace device