Re-implemented legacy pairing support

Author: PilnyTomas

libraries/BluetoothSerial/README.md

@@ -34,7 +34,11 @@ Using 3rd party Serial BT module will require to study the documentation of the
 
 ### Pairing options
 
-There are two major options - with and without Secure Simple Pairing (SSP).
+There are two easy options and one difficult.
+
+The easy options can be used as usual. These offer pairing with and without Secure Simple Pairing (SSP).
+
+The difficult option offers legacy pairing (using fixed PIN) however this must be compiled with Arduino as an IDF component with disabled sdkconfig option `CONFIG_BT_SSP_ENABLED`.
 
 #### Without SSP
 
@@ -63,5 +67,12 @@ Both options must be called before `begin()` or if it is called after `begin()`
 * **inputCapability=false and outputCapability=true**
     * Only the other device authenticates pairing without any pin.
 * **inputCapability=true and outputCapability=false**
-    * User will be required to input the passkey to the ESP32 device to authenticate.
-    * This must be implemented by registering callback via `onKeyRequest()` and in this callback the entered passkey will be responded via `respondPasskey(passkey)`
+    * The user will be required to input the passkey to the ESP32 device to authenticate.
+    * This must be implemented by registering a callback via `onKeyRequest`()` and in this callback the entered passkey will be responded via `respondPasskey(passkey)`
+
+### Legacy Pairing (IDF component)
+
+To use Legacy pairing you will have to use [Arduino as an IDF component](https://espressif-docs.readthedocs-hosted.com/projects/arduino-esp32/en/latest/esp-idf_component.html) and disable option `CONFIG_BT_SSP_ENABLED`.
+Please refer to the documentation on how to setup Arduino as an IDF component and when you are done, run `idf.py menuconfig` navigate to `Component Config -> Bluetooth -> Bluedroid -> [ ] Secure Simple Pairing` and disable it.
+While in the menuconfig you will also need to change partition scheme `Partition Table -> Partition Table -> (X) Single Factory app (large), no OTA`.
+After these changes save & quit menuconfig a you are ready to go: `idf.py  monitor flash`.

libraries/BluetoothSerial/examples/SerialToSerialBT_Legacy/.skip.esp32c3

@@ -0,0 +1,66 @@
+// This example code is in the Public Domain (or CC0 licensed, at your option.)
+//
+// This example creates a bridge between Serial and Classical Bluetooth (SPP with authentication)
+// and also demonstrate that SerialBT have the same functionalities of a normal Serial
+// Legacy pairing TODO
+// Must be run as idf component ... todo
+
+#include "BluetoothSerial.h"
+
+// Check if BlueTooth is available
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+  #error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+// Check Serial Port Profile
+#if !defined(CONFIG_BT_SPP_ENABLED)
+  #error Serial Port Profile for BlueTooth is not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+// Check Simple Secure Pairing
+#if defined(CONFIG_BT_SSP_ENABLED)
+  #warning Legacy Pairing is disabled (the CONFIG_BT_SSP_ENABLED is enabled) disable it in menuconfig.
+  void setup(){}
+  void loop(){}
+#else
+const char * deviceName = "ESP32_Legacy_example";
+
+BluetoothSerial SerialBT;
+bool confirmRequestDone = false;
+
+void BTAuthCompleteCallback(boolean success){
+  if (success){
+    confirmRequestDone = true;
+    Serial.println("Pairing success!!");
+  }
+  else{
+    Serial.println("Pairing failed, rejected by user!!");
+  }
+}
+
+void serial_response(){
+  if (Serial.available()){
+      SerialBT.write(Serial.read());
+    }
+    if (SerialBT.available()){
+      Serial.write(SerialBT.read());
+    }
+    delay(20);
+}
+
+void setup(){
+  Serial.begin(115200);
+  SerialBT.onAuthComplete(BTAuthCompleteCallback);
+  SerialBT.begin(deviceName); // Initiate Bluetooth device with name in parameter
+  SerialBT.setPin("1234", 4);
+  Serial.printf("The device started with name \"%s\", now you can pair it with Bluetooth!\n", deviceName);
+}
+
+void loop(){
+  if (confirmRequestDone){
+    serial_response();
+  }else{
+    delay(1); // Feed the watchdog
+  }
+}
+#endif

libraries/BluetoothSerial/examples/SerialToSerialBT_Legacy/.skip.esp32c6

@@ -87,7 +87,6 @@ void BTKeyRequestCallback(){
 }
 
 void BTAuthCompleteCallback(boolean success){
-  Serial.printf("BTAuthCompleteCallback(boolean success=%d)", success);
   if (success){
     confirmRequestDone = true;
     Serial.println("Pairing success!!");

libraries/BluetoothSerial/examples/SerialToSerialBT_Legacy/.skip.esp32h2

@@ -20,21 +20,21 @@ class BTAdvertisedDeviceSet;
 
 class BTScanResults {
 public:
-	virtual ~BTScanResults() = default;
+    virtual ~BTScanResults() = default;
 
-    virtual void        		dump(Print *print = nullptr);
-    virtual int         		getCount();
+    virtual void                dump(Print *print = nullptr);
+    virtual int                 getCount();
     virtual BTAdvertisedDevice* getDevice(int i);
 };
 
 class BTScanResultsSet : public BTScanResults {
 public:
-    void                	dump(Print *print = nullptr);
-    int                 	getCount();
-    BTAdvertisedDevice*		getDevice(int i);
+    void                       dump(Print *print = nullptr);
+    int                        getCount();
+    BTAdvertisedDevice*        getDevice(int i);
 
-	bool add(BTAdvertisedDeviceSet advertisedDevice, bool unique = true);
-	void clear();
+    bool add(BTAdvertisedDeviceSet advertisedDevice, bool unique = true);
+    void clear();
 
     std::map<std::string, BTAdvertisedDeviceSet> m_vectorAdvertisedDevices;
 };

libraries/BluetoothSerial/examples/SerialToSerialBT_Legacy/.skip.esp32s2

@@ -28,6 +28,7 @@
 #endif
 
 #include "BluetoothSerial.h"
+#include "BTAdvertisedDevice.h"
 
 #include "esp_bt.h"
 #include "esp_bt_main.h"
@@ -71,9 +72,13 @@ static esp_bd_addr_t _peer_bd_addr;
 static char _remote_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
 static bool _isRemoteAddressSet;
 static bool _isMaster;
-static bool _enableSSP;
-static bool _IO_CAP_INPUT;
-static bool _IO_CAP_OUTPUT;
+#ifdef CONFIG_BT_SSP_ENABLED
+  static bool _enableSSP;
+  static bool _IO_CAP_INPUT;
+  static bool _IO_CAP_OUTPUT;
+#endif
+esp_bt_pin_code_t _pin_code = {0};
+uint8_t _pin_code_len = 0; // Number of valid Bytes in the esp_bt_pin_code_t array
 static esp_spp_sec_t _sec_mask;
 static esp_spp_role_t _role;
 // start connect on ESP_SPP_DISCOVERY_COMP_EVT or save entry for getChannels
@@ -528,28 +533,23 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
                     auth_complete_callback(true);
                 }
             } else {
-                log_e("authentication failed for connecting with \"%s\", status:%d", param->auth_cmpl.device_name, param->auth_cmpl.stat);
+                log_e("authentication failed, status:%d", param->auth_cmpl.stat);
                 if (auth_complete_callback) {
                     auth_complete_callback(false);
                 }
             }
             break;
         case ESP_BT_GAP_PIN_REQ_EVT: // Enum 5 - Legacy Pairing Pin code request
-            // default pairing pins
-            log_i("ESP_BT_GAP_PIN_REQ_EVT min_16_digit:%d", param->pin_req.min_16_digit);
-            if (param->pin_req.min_16_digit) {
-                log_i("Input pin code: 0000 0000 0000 0000");
-                esp_bt_pin_code_t pin_code;
-                memset(pin_code, '0', ESP_BT_PIN_CODE_LEN);
-                esp_bt_gap_pin_reply(param->pin_req.bda, true, 16, pin_code);
+            log_i("ESP_BT_GAP_PIN_REQ_EVT (min_16_digit=%d)", param->pin_req.min_16_digit);
+            if (param->pin_req.min_16_digit && _pin_code_len < 16) {
+                esp_bt_gap_pin_reply(param->pin_req.bda, false, 0, NULL);
             } else {
-                log_i("Input pin code: 1234");
-                esp_bt_pin_code_t pin_code;
-                memcpy(pin_code, "1234", 4);
-                esp_bt_gap_pin_reply(param->pin_req.bda, true, 4, pin_code);
+                //log_i("Input pin code: \"%s\"=0x%x", _pin_code);
+                log_i("Input pin code: \"%.*s\"=0x%x", _pin_code_len, _pin_code, *(int*)_pin_code);
+                esp_bt_gap_pin_reply(param->pin_req.bda, true, _pin_code_len, _pin_code);
             }
             break;
-       
+#ifdef CONFIG_BT_SSP_ENABLED
         case ESP_BT_GAP_CFM_REQ_EVT: // Enum 6 - Security Simple Pairing User Confirmation request.
             log_i("ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %d", param->cfm_req.num_val);
             if (confirm_request_callback) {
@@ -561,11 +561,13 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
                 esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, false);
             }
             break;
+#endif
 
         case ESP_BT_GAP_KEY_NOTIF_EVT: // Enum 7 - Security Simple Pairing Passkey Notification
             log_i("ESP_BT_GAP_KEY_NOTIF_EVT passkey:%d", param->key_notif.passkey);
             break;
 
+#ifdef CONFIG_BT_SSP_ENABLED
         case ESP_BT_GAP_KEY_REQ_EVT: // Enum 8 - Security Simple Pairing Passkey request
             log_i("ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
             if (key_request_callback) {
@@ -577,6 +579,7 @@ static void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
                 esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, false);
             }
             break;
+#endif
 
         case ESP_BT_GAP_READ_RSSI_DELTA_EVT: // Enum 9 - Read rssi event
             log_i("ESP_BT_GAP_READ_RSSI_DELTA_EVT Read rssi event");
@@ -718,6 +721,7 @@ static bool _init_bt(const char *deviceName)
     log_i("device name set");
     esp_bt_dev_set_device_name(deviceName);
 
+#ifdef CONFIG_BT_SSP_ENABLED
     if (_enableSSP) {
         log_i("Simple Secure Pairing");
         esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE;
@@ -733,6 +737,7 @@ static bool _init_bt(const char *deviceName)
         }
         esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t));
     }
+#endif
 
     // the default BTA_DM_COD_LOUDSPEAKER does not work with the macOS BT stack
     esp_bt_cod_t cod;
@@ -908,6 +913,7 @@ void BluetoothSerial::end()
     _stop_bt();
 }
 
+#ifdef CONFIG_BT_SSP_ENABLED
 void BluetoothSerial::onConfirmRequest(ConfirmRequestCb cb)
 {
     confirm_request_callback = cb;
@@ -921,6 +927,7 @@ void BluetoothSerial::onKeyRequest(KeyRequestCb cb)
 void BluetoothSerial::respondPasskey(uint32_t passkey){
     esp_bt_gap_ssp_passkey_reply(current_bd_addr, true, passkey);
 }
+#endif
 
 void BluetoothSerial::onAuthComplete(AuthCompleteCb cb)
 {
@@ -939,6 +946,7 @@ esp_err_t BluetoothSerial::register_callback(esp_spp_cb_t * callback)
     return ESP_OK;
 }
 
+#ifdef CONFIG_BT_SSP_ENABLED
 // Enable Simple Secure Pairing (using generated PIN)
 // This must be called before calling begin, otherwise has no effect!
 void BluetoothSerial::enableSSP() {
@@ -974,6 +982,19 @@ void BluetoothSerial::disableSSP() {
     _enableSSP = false;
 }
 
+#else
+
+bool BluetoothSerial::setPin(const char *pin, uint8_t pin_code_len){
+    if(pin_code_len == 0 || pin_code_len > 16){
+        log_e("PIN code must be 1-16 Bytes long! Called with length %d", pin_code_len);
+        return false;
+    }
+    _pin_code_len = pin_code_len;
+    memcpy(_pin_code, pin, pin_code_len);
+    return (esp_bt_gap_set_pin(ESP_BT_PIN_TYPE_FIXED, _pin_code_len, _pin_code) == ESP_OK);
+}
+#endif
+
 bool BluetoothSerial::connect(String remoteName)
 {
     bool retval = false;