Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 03dca330 authored by Himanshu Rawat's avatar Himanshu Rawat
Browse files

RESTRICT AUTOMERGE Disallow unexpected incoming HID connections 

HID profile accepted any new incoming HID connection. Even when the
connection policy disabled HID connection, remote devices could initiate
HID connection.
This change ensures that incoming HID connection are accepted only if
application was interested in that HID connection.
This vulnerarbility no longer exists on the main because of feature
request b/324093729.

Test: mmm packages/modules/Bluetooth
Test: Manual | Pair and connect a HID device, disable HID connection
from Bluetooth device setting, attempt to connect from the HID device.
Bug: 308429049
Ignore-AOSP-First: security

Change-Id: I013d0528fb18ee87195fb3c8aab553c6a8da5ae4
parent 62944f39

android/app/jni/com_android_bluetooth_hid_host.cpp

+5 −3
Original line number Diff line number Diff line
@@ -282,7 +282,8 @@ static jboolean connectHidNative(JNIEnv* env, jobject object, 
}



static jboolean disconnectHidNative(JNIEnv* env, jobject object,

                                    jbyteArray address) {

                                    jbyteArray address,

                                    jboolean reconnect_allowed) {

  jbyte* addr;

  jboolean ret = JNI_TRUE;

  if (!sBluetoothHidInterface) return JNI_FALSE;
@@ -293,7 +294,8 @@ static jboolean disconnectHidNative(JNIEnv* env, jobject object, 
    return JNI_FALSE;

  }



  bt_status_t status = sBluetoothHidInterface->disconnect((RawAddress*)addr);

  bt_status_t status =

      sBluetoothHidInterface->disconnect((RawAddress*)addr, reconnect_allowed);

  if (status != BT_STATUS_SUCCESS) {

    ALOGE("Failed disconnect hid channel, status: %d", status);

    ret = JNI_FALSE;
@@ -509,7 +511,7 @@ static JNINativeMethod sMethods[] = { 
    {"initializeNative", "()V", (void*)initializeNative},

    {"cleanupNative", "()V", (void*)cleanupNative},

    {"connectHidNative", "([B)Z", (void*)connectHidNative},

    {"disconnectHidNative", "([B)Z", (void*)disconnectHidNative},

    {"disconnectHidNative", "([BZ)Z", (void*)disconnectHidNative},

    {"getProtocolModeNative", "([B)Z", (void*)getProtocolModeNative},

    {"virtualUnPlugNative", "([B)Z", (void*)virtualUnPlugNative},

    {"setProtocolModeNative", "([BB)Z", (void*)setProtocolModeNative},

android/app/src/com/android/bluetooth/hid/HidHostService.java

+5 −2
Original line number Diff line number Diff line
@@ -186,7 +186,10 @@ public class HidHostService extends ProfileService { 
                break;

                case MESSAGE_DISCONNECT: {

                    BluetoothDevice device = (BluetoothDevice) msg.obj;

                    if (!disconnectHidNative(getByteAddress(device))) {

                    int connectionPolicy = getConnectionPolicy(device);

                    boolean reconnectAllowed =

                            connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED;

                    if (!disconnectHidNative(getByteAddress(device), reconnectAllowed)) {

                        broadcastConnectionState(device, BluetoothProfile.STATE_DISCONNECTING);

                        broadcastConnectionState(device, BluetoothProfile.STATE_DISCONNECTED);

                        break;
@@ -1019,7 +1022,7 @@ public class HidHostService extends ProfileService { 


    private native boolean connectHidNative(byte[] btAddress);



    private native boolean disconnectHidNative(byte[] btAddress);

    private native boolean disconnectHidNative(byte[] btAddress, boolean reconnectAllowed);



    private native boolean getProtocolModeNative(byte[] btAddress);

system/btif/include/btif_hh.h

+3 −1
Original line number Diff line number Diff line
@@ -106,6 +106,7 @@ typedef struct { 
  uint8_t dev_handle;

  RawAddress bd_addr;

  tBTA_HH_ATTR_MASK attr_mask;

  bool reconnect_allowed;

} btif_hh_added_device_t;



/**
@@ -130,7 +131,8 @@ extern btif_hh_cb_t btif_hh_cb; 
extern btif_hh_device_t* btif_hh_find_connected_dev_by_handle(uint8_t handle);

extern void btif_hh_remove_device(RawAddress bd_addr);

extern bool btif_hh_add_added_dev(const RawAddress& bda,

                                  tBTA_HH_ATTR_MASK attr_mask);

                                  tBTA_HH_ATTR_MASK attr_mask,

                                  bool reconnect_allowed);

extern bt_status_t btif_hh_virtual_unplug(const RawAddress* bd_addr);

extern void btif_hh_disconnect(RawAddress* bd_addr);

extern void btif_hh_setreport(btif_hh_device_t* p_dev,

system/btif/include/btif_storage.h

+23 −0
Original line number Diff line number Diff line
@@ -196,6 +196,29 @@ void btif_storage_load_consolidate_devices(void); 
 ******************************************************************************/

bt_status_t btif_storage_load_bonded_devices(void);



/*******************************************************************************

 *

 * Function         btif_storage_set_hid_connection_policy

 *

 * Description      Stores connection policy info in nvram

 *

 * Returns          BT_STATUS_SUCCESS

 *

 ******************************************************************************/

bt_status_t btif_storage_set_hid_connection_policy(const RawAddress& addr,

                                                   bool reconnect_allowed);

/*******************************************************************************

 *

 * Function         btif_storage_get_hid_connection_policy

 *

 * Description      get connection policy info from nvram

 *

 * Returns          BT_STATUS_SUCCESS

 *

 ******************************************************************************/

bt_status_t btif_storage_get_hid_connection_policy(const RawAddress& addr,

                                                   bool* reconnect_allowed);



/*******************************************************************************

 *

 * Function         btif_storage_add_hid_device_info

system/btif/src/btif_hh.cc

+81 −5
Original line number Diff line number Diff line
@@ -308,6 +308,24 @@ btif_hh_device_t* btif_hh_find_connected_dev_by_handle(uint8_t handle) { 
      return &btif_hh_cb.devices[i];

    }

  }

  return nullptr;

}



/*******************************************************************************

 *

 * Function         btif_hh_find_added_dev

 *

 * Description      Return the added device pointer of the specified address

 *

 * Returns          Added device entry

 ******************************************************************************/

btif_hh_added_device_t* btif_hh_find_added_dev(const RawAddress& addr) {

  for (int i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {

    btif_hh_added_device_t* added_dev = &btif_hh_cb.added_devices[i];

    if (added_dev->bd_addr == addr) {

      return added_dev;

    }

  }

  return NULL;

}
@@ -351,6 +369,23 @@ static btif_hh_device_t* btif_hh_find_connected_dev_by_bda( 
  return NULL;

}



static bool btif_hh_connection_allowed(const RawAddress& bda) {

  /* Accept connection only if reconnection is allowed for the known device, or

   * outgoing connection was requested */

  btif_hh_added_device_t* added_dev = btif_hh_find_added_dev(bda);

  if (added_dev != nullptr && added_dev->reconnect_allowed) {

    LOG_VERBOSE("Connection allowed %s", PRIVATE_ADDRESS(bda));

    return true;

  } else if (btif_hh_cb.pending_conn_address == bda) {

    LOG_VERBOSE("Device connection was pending for: %s, status: %s",

                PRIVATE_ADDRESS(bda),

                btif_hh_status_text(btif_hh_cb.status).c_str());

    return true;

  }



  return false;

}



/*******************************************************************************

 *

 * Function      btif_hh_stop_vup_timer
@@ -396,7 +431,8 @@ void btif_hh_start_vup_timer(const RawAddress* bd_addr) { 
 *

 * Returns          true if add successfully, otherwise false.

 ******************************************************************************/

bool btif_hh_add_added_dev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask) {

bool btif_hh_add_added_dev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask,

                           bool reconnect_allowed) {

  int i;

  for (i = 0; i < BTIF_HH_MAX_ADDED_DEV; i++) {

    if (btif_hh_cb.added_devices[i].bd_addr == bda) {
@@ -410,6 +446,7 @@ bool btif_hh_add_added_dev(const RawAddress& bda, tBTA_HH_ATTR_MASK attr_mask) { 
      btif_hh_cb.added_devices[i].bd_addr = bda;

      btif_hh_cb.added_devices[i].dev_handle = BTA_HH_INVALID_HANDLE;

      btif_hh_cb.added_devices[i].attr_mask = attr_mask;

      btif_hh_cb.added_devices[i].reconnect_allowed = reconnect_allowed;

      return true;

    }

  }
@@ -775,9 +812,26 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) { 
            p_data->status);

      break;



    case BTA_HH_OPEN_EVT:

    case BTA_HH_OPEN_EVT: {

      BTIF_TRACE_WARNING("%s: BTA_HH_OPN_EVT: handle=%d, status =%d", __func__,

                         p_data->conn.handle, p_data->conn.status);



      if (!btif_hh_connection_allowed(p_data->conn.bda)) {

        LOG_WARN("Reject incoming HID Connection, device: %s",

                 PRIVATE_ADDRESS(p_data->conn.bda));

        btif_hh_device_t* p_dev =

            btif_hh_find_connected_dev_by_handle(p_data->conn.handle);

        if (p_dev != nullptr) {

          p_dev->dev_status = BTHH_CONN_STATE_DISCONNECTED;

        }



        btif_hh_cb.status = (BTIF_HH_STATUS)BTIF_HH_DEV_DISCONNECTED;

        BTA_HhClose(p_data->conn.handle);

        HAL_CBACK(bt_hh_callbacks, connection_state_cb, &p_data->conn.bda,

                  BTHH_CONN_STATE_DISCONNECTED);

        return;

      }



      btif_hh_cb.pending_conn_address = RawAddress::kEmpty;

      if (p_data->conn.status == BTA_HH_OK) {

        p_dev = btif_hh_find_connected_dev_by_handle(p_data->conn.handle);
@@ -836,6 +890,7 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) { 
        btif_hh_cb.status = (BTIF_HH_STATUS)BTIF_HH_DEV_DISCONNECTED;

      }

      break;

    }



    case BTA_HH_CLOSE_EVT:

      BTIF_TRACE_DEBUG("BTA_HH_CLOSE_EVT: status = %d, handle = %d",
@@ -1009,7 +1064,7 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) { 
                                p_data->dscp_info.version,

                                p_data->dscp_info.ctry_code, len,

                                p_data->dscp_info.descriptor.dsc_list);

        if (btif_hh_add_added_dev(p_dev->bd_addr, p_dev->attr_mask)) {

        if (btif_hh_add_added_dev(p_dev->bd_addr, p_dev->attr_mask, true)) {

          tBTA_HH_DEV_DSCP_INFO dscp_info;

          bt_status_t ret;

          btif_hh_copy_hid_info(&dscp_info, &p_data->dscp_info);
@@ -1025,6 +1080,8 @@ static void btif_hh_upstreams_evt(uint16_t event, char* p_param) { 
              p_data->dscp_info.ssr_min_tout, len,

              p_data->dscp_info.descriptor.dsc_list);



          btif_storage_set_hid_connection_policy(p_dev->bd_addr, true);



          ASSERTC(ret == BT_STATUS_SUCCESS, "storing hid info failed", ret);

          BTIF_TRACE_WARNING("BTA_HH_GET_DSCP_EVT: Called add device");
@@ -1312,6 +1369,13 @@ static bt_status_t init(bthh_callbacks_t* callbacks) { 
 ******************************************************************************/

static bt_status_t connect(RawAddress* bd_addr) {

  if (btif_hh_cb.status != BTIF_HH_DEV_CONNECTING) {

    /* If the device was already added, ensure that reconnections are allowed */

    btif_hh_added_device_t* added_dev = btif_hh_find_added_dev(*bd_addr);

    if (added_dev != nullptr && !added_dev->reconnect_allowed) {

      added_dev->reconnect_allowed = true;

      btif_storage_set_hid_connection_policy(*bd_addr, true);

    }



    btif_transfer_context(btif_hh_handle_evt, BTIF_HH_CONNECT_REQ_EVT,

                          (char*)bd_addr, sizeof(RawAddress), NULL);

    return BT_STATUS_SUCCESS;
@@ -1332,7 +1396,7 @@ static bt_status_t connect(RawAddress* bd_addr) { 
 * Returns         bt_status_t

 *

 ******************************************************************************/

static bt_status_t disconnect(RawAddress* bd_addr) {

static bt_status_t disconnect(RawAddress* bd_addr, bool reconnect_allowed) {

  CHECK_BTHH_INIT();

  BTIF_TRACE_EVENT("BTHH: %s", __func__);

  btif_hh_device_t* p_dev;
@@ -1342,6 +1406,17 @@ static bt_status_t disconnect(RawAddress* bd_addr) { 
                       btif_hh_cb.status);

    return BT_STATUS_FAIL;

  }



  if (!reconnect_allowed) {

    LOG_INFO("Incoming reconnections disabled for device %s",

             PRIVATE_ADDRESS((*bd_addr)));

    btif_hh_added_device_t* added_dev = btif_hh_find_added_dev(*bd_addr);

    if (added_dev != nullptr && added_dev->reconnect_allowed) {

      added_dev->reconnect_allowed = false;

      btif_storage_set_hid_connection_policy(added_dev->bd_addr, false);

    }

  }



  p_dev = btif_hh_find_connected_dev_by_bda(*bd_addr);

  if (p_dev != NULL) {

    return btif_transfer_context(btif_hh_handle_evt, BTIF_HH_DISCONNECT_REQ_EVT,
@@ -1473,9 +1548,10 @@ static bt_status_t set_info(RawAddress* bd_addr, bthh_hid_info_t hid_info) { 
      (uint8_t*)osi_malloc(dscp_info.descriptor.dl_len);

  memcpy(dscp_info.descriptor.dsc_list, &(hid_info.dsc_list), hid_info.dl_len);



  if (btif_hh_add_added_dev(*bd_addr, hid_info.attr_mask)) {

  if (btif_hh_add_added_dev(*bd_addr, hid_info.attr_mask, true)) {

    BTA_HhAddDev(*bd_addr, hid_info.attr_mask, hid_info.sub_class,

                 hid_info.app_id, dscp_info);

    btif_storage_set_hid_connection_policy(*bd_addr, true);

  }



  osi_free_and_reset((void**)&dscp_info.descriptor.dsc_list);