Auto pairing bluetooth device

Auto-accept bluetooth pairing possible?

In the Android 2.3.3 BluetoothChat example with with createInsecureRfcommSocketToServiceRecord() API, users are still prompted to accept the pairing request, even though no PIN code is presented. Is there a way to automate Bluetooth pairing request without user intervention? Or is this never possible due to security concerns? I have been looking online for 2 days now and haven’t really found much, so if anybody knows, please post. Thanks!

3 Answers 3

So, I had this cuestion, if some one needs the answer to this working in android 4.4.2

 IntentFilter filter = new IntentFilter( "android.bluetooth.device.action.PAIRING_REQUEST"); /* * Registering a new BTBroadcast receiver from the Main Activity context * with pairing request event */ registerReceiver( new PairingRequest(), filter); 

and the code for the Receiver

 public static class PairingRequest extends BroadcastReceiver < public PairingRequest() < super(); >@Override public void onReceive(Context context, Intent intent) < if (intent.getAction().equals("android.bluetooth.device.action.PAIRING_REQUEST")) < try < BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); int pin=intent.getIntExtra("android.bluetooth.device.extra.PAIRING_KEY", 0); //the pin in case you need to accept for an specific pin Log.d("PIN", " " + intent.getIntExtra("android.bluetooth.device.extra.PAIRING_KEY",0)); //maybe you look for a name or address Log.d("Bonded", device.getName()); byte[] pinBytes; pinBytes = (""+pin).getBytes("UTF-8"); device.setPin(pinBytes); //setPairing confirmation if neeeded device.setPairingConfirmation(true); >catch (Exception e) < e.printStackTrace(); >> > > 

and the broadcastReceiver

Not with the standard API, no: if the MAC address is not already in the pairing database there will always be the prompt. I’m told that if you have a device that has been rooted and have public read/write access to the bluetooth service’s DBus endpoint you can work around that but I’ve never seen that actually implemented.

Thanks! That explains a lot. I even looked at the source of BluetoothAdapter.java class to see if there’s any unofficial APIs I can leverage. Is it then possible to add MAC address into the pairing database ahead of time to allow pairing to occur automatically when the devices are in range?

Not that I’m aware of: that’s a BlueZ level thing, so you might have some more luck looking in the android BlueZ git.

i came across the same problem, i hope the following code will help: firsly we need:

secondly we need the BluetoothDevice class, and:

public class PairingRequest extends BroadcastReceiver < @Override public void onReceive(Context context, Intent intent)< if (intent.getAction().equals("ACTION_PAIRING_REQUEST")) < BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); byte[] pinBytes = BluetoothDevice.convertPinToBytes("1234"); device.setPin(pinBytes); >> > 

Despite the grepcode, these two methods do not appear exist in standard Android distributions, nor in the BluetoothDevice javadoc While it would certainly be nice, it’s not there.

This code is extremely helpful. Just use a little of reflection and beware of hidden string constants and you will be fine. There is definitely possible to inject PIN and connect but the target device remains unpaired. OK for me. I can provide a full source code used in my own project.

Another problem (sort of) found. When using the above algorithm the first time an Android device connects to a target it does connect but still shows the PIN Dialog. Pressing leaves the connection intact! The target is never paired. Next time the device connects it never shows the dialog again. Either some kind of a race or Android intimate internals problem. Verified with 2.3.5 and 4.1.2 Androids.

Источник

Bluetooth LE pre-pairing

Windows 10 supports LE Bluetooth peripherals automatically pairing to a single PC, after all devices have been provisioned and enabled during the manufacturing process. Users do not need to keep LE devices paired and connected after both the host PC and bundled devices are supplied power for the first time. These peripherals can still be used as regular Bluetooth devices, and maintain full functionality when out of range of the host PC. However, if the peripherals are unpaired and within range of the host PC, they will automatically re-pair and connect.

When an LE peripheral supporting this feature is supplied power for the first time, it sends out proprietary Microsoft-defined data in an undirected connectable advertisement. That advertisement is then picked up by the host PC. If the device is in range and its advertisement matches a pattern that is pre-provisioned in the host PC during manufacturing, then the device is paired. This is through Out-Of-Band Pairing which uses a separate secret OOB key that was also pre-provisioned. The distance from the host PC in which the peripheral may pair is determined by another pre-provisioned minimum RSSI value, which is represented in dB, so ranges may vary. All data pre-provisioned must be stored in UEFI to preserve this functionality on clean installs and system restores.

When a bundled device is unpaired within the range defined by the RSSI value, the Bluetooth device automatically re-pairs to Windows. Users must leave the range of the host PC, to be able to pair their device to other Bluetooth enabled PCs.

OEMs must determine on their own how to manufacture these devices. They must also guarantee security and that they will all be in the same box when shipped to customers.

Feature requirements

PC

• Windows 10 Anniversary Update
• UEFI Stored Variables
• Microsoft-defined Bluetooth HCI commands for optimized battery life.

Peripheral

• Bluetooth LE
• Store for Device ID (hashed from Bluetooth Address) & TK value
• Custom Advertisement (defined below)

UEFI on host PC

This feature is dependent on storing information to aid the pairing process in UEFI. The feature allows this functionality to persist on system recovery and clean installs. After the UEFI variables are defined, they must be locked to be read-only.

For each device supporting automatic pairing, the host PC should program the following OOB information into its NVRAM:

• RSSI Threshold: Defines a distance threshold in dB for when peripherals are “out of range of the host PC”
  • Set as a minimum signal strength before pairing takes place
  • The OEM must define the appropriate threshold

  Note If device ID is not unique per device, or at least per bundle, there will be conflicts if multiple devices are within range of each other. Peripherals pair with unanticipated PCs.

  OOB info pseudocode representation

  const unsigned long BTH_LE_DEVICE_ID_SIZE = 8; #pragma pack(push,1) typedef struct < CHAR RssiThreshold; UCHAR DeviceId[BTHLE_PREPAIRING_DEVICE_ID_SIZE]; UCHAR SmpTK[16]; // TK Max Size >BTHLE_PREPAIRING_ENTRY; #pragma pack(pop) 

  Public UEFI NVRAM interface definition

  static const LPWSTR BTH_LE_PREPAIRING_NVRAM_VAR_NAME = L"BluetoothPairingInfo"; static const LPWSTR BTH_LE_PREPAIRING_NVRAM_VAR_GUID = L""; 

  Advertisement Layout of Peripherals

  Section Type [1 Byte]	Manufacturer [2 bytes]	MsftSectionType [4 bytes]	Device Identifier [8 bytes]
  0xff (vendor specific)	0x0006 (MSFT)	0x00000004 (Prepairing)	device identifier

  Security Concerns

  During Manufacturing

  There is the potential for Man in The Middle attacks if the provisioning data is obtained. Keeping the data secure is up to the OEM.

  After the customer has purchased the device

  It is possible for the values stored in UEFI to be read, and then spoofed on another device. This can grant access to the system by a malicious user. To mitigate this, we have also created the MDM policy Bluetooth/AllowPrepairing. This policy will allow enterprise and pro deployments to disable this feature.

  Источник

  Steps for Automatically Pairing Bluetooth Devices

  The HID application has the capability to connect to bonded HID devices automatically. To achieve this behavior, it’s important to understand the difference between a BLE Peripheral and a Bluetooth Headset. When a device is paired, it means that the keys for encryption are stored by both the central and peripheral.

  How I do a Bluetooth auto pairing?

  While developing an Android Studio app with two activities, I am currently working on the first activity, which allows users to scan nearby devices. Upon touching a device, the app automatically switches to the next activity. However, if the device has not been previously paired, there is a possibility that either the connection fail error or app crash may occur. The order of the Broadcast and createBond functions in this scenario is unclear to me.

  I attempted to place the createBond() function following the setPairingConfirmation() function.

   private BroadcastReceiver mReceiver5 = new BroadcastReceiver() < @Override public void onReceive(Context context, Intent intent) < final String action = intent.getAction(); if (action.equals(BluetoothDevice.ACTION_PAIRING_REQUEST)) < try < BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); // int pin=intent.getIntExtra("android.bluetooth.device.extra.PAIRING_KEY", 0); // the pin in case you need to accept for an specific pin int pin = intent.getIntExtra("android.bluetooth.device.extra.PAIRING_KEY",CONTRASEÑA); Log.d(TAG, "Start Auto Pairing. PIN = " +intent.getIntExtra("android.bluetooth.device.extra.PAIRING_KEY",CONTRASEÑA)); byte[] pinBytes; // pinBytes = (""+pin).getBytes("UTF-8"); pinBytes = ("" + pin).getBytes("UTF-8"); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) < device.setPin(pinBytes); device.setPairingConfirmation(true); >> catch (Exception e) < Log.e(TAG, "Error occurs when trying to auto pair"); e.printStackTrace(); >> > > private AdapterView.OnItemClickListener mDeviceClickListener = new AdapterView.OnItemClickListener() < public void onItemClick(AdapterView av, View v, int arg2, long arg3) < // Se detiene discovery porque es muy intenso para la memoria mBTAdapter.cancelDiscovery(); Log.d(TAG, "onItemClick: clickeaste sobre un dispositivo"); String deviceName = mBTDevices.get(arg2).getName(); String deviceAddress = mBTDevices.get(arg2).getAddress(); Log.d(TAG, "onItemClick: deviceName = " + deviceName); Log.d(TAG, "onItemClick: deviceAddress = " + deviceAddress); // Crea el enlace // NOTA: se requiere api 17 o más if(Build.VERSION.SDK_INT >Build.VERSION_CODES.JELLY_BEAN_MR2) < // Entra si la versión del SDK es mayor a versión Lollipop Log.d(TAG, "Tratando de emparejar con: " + deviceName); mBTDevices.get(arg2).createBond(); >IntentFilter intentFilter = new IntentFilter(BluetoothDevice.ACTION_PAIRING_REQUEST); registerReceiver(mReceiver5,intentFilter); Intent i = new Intent(DispositivosBT.this, MainActivity.class); // i.putExtra(EXTRA_DEVICE_ADDRESS, deviceAddress); startActivity(i); > >; 

  At times, the app stops working when I attempt to connect to an unpaired device. On other occasions, the connection fails, but the app continues to function. However, if I retry connecting, the connection is successful. My objective is to connect to an unpaired device and proceed to the next activity.

  This is the solution I discovered.

   private AdapterView.OnItemClickListener mDeviceClickListener = new AdapterView.OnItemClickListener() < public void onItemClick(AdapterView av, View v, int arg2, long arg3) < cancelarDiscovery(mBTAdapter); Log.d(TAG, "onItemClick: clickeaste sobre un dispositivo"); String deviceName = mBTDevices.get(arg2).getName(); deviceAddress = mBTDevices.get(arg2).getAddress(); Log.d(TAG, "onItemClick: deviceName = " + deviceName); Log.d(TAG, "onItemClick: deviceAddress = " + deviceAddress); if (Build.VERSION.SDK_INT >Build.VERSION_CODES.JELLY_BEAN_MR2) < Log.d(TAG, "Trying to pair with: " + deviceName); mBTDevices.get(arg2).createBond(); >if(mBTDevices.get(arg2).getBondState() == BluetoothDevice.BOND_BONDED) < nextActivity(); >> >; 

  Algorithm — How can I loop over pair in c++, I am trying to print the elements in pair, but it’s throwing an error: «no matching function call» Code: #include #include using namespace std; int main()

  How to auto pair my BLE Peripheral on my device?

  Our application requires automatic pairing between the smartphone and the BLE Peripheral when they are in close proximity.

  The RN4871 Microchip BLE Board is being utilized. After pairing the device from settings for the first time, powering it off and back on again does not result in automatic connection to Android. This differs from the behavior of a Bluetooth headset.

  How can I achieve the desired behavior that distinguishes a BLE peripheral from a Bluetooth headset?

  Generally, when a central and peripheral device are paired or bonded, their keys used for encryption and other purposes are stored for future connections.

  It is possible to program peripherals to advertise with a designated Bluetooth device address as their target.

  Regarding your query, when it comes to Android, for a device to be connected, an «application» needs to establish a connection with it, irrespective of whether it is paired or not. This application can either be a regular app that you download or the inbuilt HID application present in the Bluetooth stack. However, if the bonded HID devices are enabled, the HID application will automatically connect to them. Consequently, if there is no interest in connecting the peripheral device, it will not remain connected.

  Java — How I do a Bluetooth auto pairing?, In the first one, you can scan near devices and when you touch some device, the app change to the next activity. If the device hasn’t been paired before, the connection fail or the app crashed. Im not sure the order of the Broadcast and the createBond I tried putting createBond () after setPairingConfirmation ()

  Auto-unpacking a pair of iterators

  If we have a function returns a std::pair in C++, it can be automatically received in the following manner:

  auto pr = some_function(); std::cout  

  The C++17 standard offers an elegant method of directly extracting the pair into distinct variables.

  auto [x, y] = some_function(); std::cout  

  One of the library functions, std::minmax_element() , can be used to retrieve a pair of iterators. These iterators correspond to the smallest and largest elements of a vector passed as an argument to the std::minmax_element() function.

  One approach to acknowledging these iterators is by treating them normally and then dereferencing them at a later point, as shown below.

  std::vector v = ; auto [x, y] = std::minmax_element(v.begin(), v.end()); std::cout  

  I have a question regarding dereferencing while unpacking. Specifically, in the code provided, is it possible to replace " var1 " and " var2 " with valid C++ code that prints the value pointed to by those iterators?

  std::vector v = ; auto [var1, var2] = std::minmax_element(v.begin(), v.end()); std::cout  

  Create a function that accepts two things that can be encoded using derefer and then returns the output of dereferencing them.

  template ::reference> auto deref(std::pair p) -> std::pair < return ; > 

  And then use that function:

  auto [var1, var2] = deref(std::minmax_element(v.begin(), v.end())); 

  It should be noted that dereferencing the end iterator twice in case the range is empty makes it UB.

  struct deref_t < template ::reference> friend auto operator|(std::pair p, deref_t) -> std::pair < return < *p.first, *p.second >; > >; inline constexpr deref_t deref<>; 

  auto [var1, var2] = std::minmax_element(v.begin(), v.end()) | deref; 

  Setting up Bluetooth automatic pairing on Linux, Use the agent interface and implements your own PIN code. After registring your agent, bluez will automaticaly call and use you own agent when a pairing is asked. Moreover, you can set the DiscoverableTimeout to 0 through DBus with org.bluez.Adapter1 interface.

  Источник