components/proximity_auth/ble/proximity_auth_ble_system.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_PROXIMITY_AUTH_BLE_PROXIMITY_AUTH_BLE_SYSTEM_H_
   6 #define COMPONENTS_PROXIMITY_AUTH_BLE_PROXIMITY_AUTH_BLE_SYSTEM_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/macros.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/time/time.h"
  14 #include "components/proximity_auth/connection_observer.h"
  15 #include "components/proximity_auth/cryptauth/cryptauth_client.h"
  16 #include "components/proximity_auth/screenlock_bridge.h"
  17
  18 class PrefRegistrySimple;
  19 class PrefService;
  20
  21 namespace device {
  22 class BluetoothGattConnection;
  23 }
  24
  25 namespace proximity_auth {
  26
  27 class BluetoothLowEnergyConnection;
  28 class BluetoothLowEnergyConnectionFinder;
  29 class BluetoothLowEnergyDeviceWhitelist;
  30 class Connection;
  31 class ConnectionFinder;
  32 class ProximityAuthClient;
  33
  34 // This is the main entry point to start Proximity Auth over Bluetooth Low
  35 // Energy. This is the underlying system for the Smart Lock features. It will
  36 // discover Bluetooth Low Energy phones and unlock the lock screen if the phone
  37 // passes an authorization and authentication protocol.
  38 class ProximityAuthBleSystem : public ScreenlockBridge::Observer,
  39                                public ConnectionObserver {
  40  public:
  41   ProximityAuthBleSystem(
  42       ScreenlockBridge* screenlock_bridge,
  43       ProximityAuthClient* proximity_auth_client,
  44       scoped_ptr<CryptAuthClientFactory> cryptauth_client_factory,
  45       PrefService* pref_service);
  46   ~ProximityAuthBleSystem() override;
  47
  48   // Registers the prefs used by this class
  49   static void RegisterPrefs(PrefRegistrySimple* registry);
  50
  51   // ScreenlockBridge::Observer:
  52   void OnScreenDidLock(
  53       ScreenlockBridge::LockHandler::ScreenType screen_type) override;
  54   void OnScreenDidUnlock(
  55       ScreenlockBridge::LockHandler::ScreenType screen_type) override;
  56   void OnFocusedUserChanged(const std::string& user_id) override;
  57
  58   // proximity_auth::ConnectionObserver:
  59   void OnConnectionStatusChanged(Connection* connection,
  60                                  Connection::Status old_status,
  61                                  Connection::Status new_status) override;
  62   void OnMessageReceived(const Connection& connection,
  63                          const WireMessage& message) override;
  64
  65  protected:
  66   class ScreenlockBridgeAdapter {
  67    public:
  68     ScreenlockBridgeAdapter(ScreenlockBridge* screenlock_bridge);
  69     virtual ~ScreenlockBridgeAdapter();
  70
  71     virtual void AddObserver(ScreenlockBridge::Observer* observer);
  72     virtual void RemoveObserver(ScreenlockBridge::Observer* observer);
  73     virtual void Unlock(ProximityAuthClient* client);
  74
  75    protected:
  76     ScreenlockBridgeAdapter();
  77
  78    private:
  79     // Not owned. Must outlive this object.
  80     ScreenlockBridge* screenlock_bridge_;
  81   };
  82
  83   // Used for testing.
  84   ProximityAuthBleSystem(scoped_ptr<ScreenlockBridgeAdapter> screenlock_bridge,
  85                          ProximityAuthClient* proximity_auth_client);
  86
  87   // Virtual for testing.
  88   virtual ConnectionFinder* CreateConnectionFinder();
  89
  90  private:
  91   // Fetches the the public keys of devices that can be used as unlock keys.
  92   void GetUnlockKeys();
  93
  94   // Checks if the devices in |device_whitelist_| have their public keys
  95   // registered in CryptAuth (|unlock_keys_|), removes the ones that do not.
  96   void RemoveStaleWhitelistedDevices();
  97
  98   // Callbacks for cryptauth::CryptAuthClient::GetMyDevices.
  99   void OnGetMyDevices(const cryptauth::GetMyDevicesResponse& response);
 100   void OnGetMyDevicesError(const std::string& error);
 101
 102   // Handler for a new connection found event.
 103   void OnConnectionFound(scoped_ptr<Connection> connection);
 104
 105   // Start (recurrently) polling every |polling_interval_| ms for the screen
 106   // state of the remote device.
 107   void StartPollingScreenState();
 108
 109   // Stop polling for screen state of the remote device, if currently active.
 110   void StopPollingScreenState();
 111
 112   // Checks if |message| contains a valid public key (registered in
 113   // |unlock_keys_|). If so, returns the public key in |out_public_key|.
 114   bool HasUnlockKey(const std::string& message, std::string* out_public_key);
 115
 116   scoped_ptr<ScreenlockBridgeAdapter> screenlock_bridge_;
 117
 118   // Not owned. Must outlive this object.
 119   ProximityAuthClient* proximity_auth_client_;
 120
 121   // Creates CryptAuth client instances to make API calls.
 122   scoped_ptr<CryptAuthClientFactory> cryptauth_client_factory_;
 123
 124   // We only support one concurrent API call.
 125   scoped_ptr<CryptAuthClient> cryptauth_client_;
 126
 127   // Maps devices public keys to the device friendly name.
 128   std::map<std::string, std::string> unlock_keys_;
 129
 130   scoped_ptr<ConnectionFinder> connection_finder_;
 131
 132   scoped_ptr<Connection> connection_;
 133
 134   scoped_ptr<BluetoothLowEnergyDeviceWhitelist> device_whitelist_;
 135
 136   const base::TimeDelta polling_interval_;
 137
 138   // True if the remote device sent public key contained in |unlock_keyes_| or
 139   // |device_whitelist_|.
 140   bool device_authenticated_;
 141
 142   // True if the screen is locked and call to |screenlock_bridge_->Unlock()| was
 143   // made, but |OnScreenDidUnlock| was not called yet. This is a guard to avoid
 144   // a double |screenlock_bridge_->Unlock()| call.
 145   bool unlock_requested_;
 146
 147   bool is_polling_screen_state_;
 148
 149   base::WeakPtrFactory<ProximityAuthBleSystem> weak_ptr_factory_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(ProximityAuthBleSystem);
 152 };
 153
 154 }  // namespace proximity_auth
 155
 156 #endif  // COMPONENTS_PROXIMITY_AUTH_BLE_PROXIMITY_AUTH_BLE_SYSTEM_H_