SMP_Encrypt refactor (231c14a5) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/btm/btm_ble.cc

+39 −52

Original line number	Diff line number	Diff line
		@@ -44,9 +44,6 @@
		#include "osi/include/osi.h"
		#include "smp_api.h"

		extern bool aes_cipher_msg_auth_code(BT_OCTET16 key, uint8_t* input,
		uint16_t length, uint16_t tlen,
		uint8_t* p_signature);
		extern void gatt_notify_phy_updated(uint8_t status, uint16_t handle,
		uint8_t tx_phy, uint8_t rx_phy);
		extern void btm_ble_advertiser_notify_terminated_legacy(
		@@ -2177,11 +2174,12 @@ bool BTM_BleDataSignature(const RawAddress& bd_addr, uint8_t* p_text,
		tBTM_SEC_DEV_REC* p_rec = btm_find_dev(bd_addr);

		BTM_TRACE_DEBUG("%s", __func__);
		bool ret = false;
		if (p_rec == NULL) {
		BTM_TRACE_ERROR("%s-data signing can not be done from unknown device",
		__func__);
		} else {
		return false;
		}

		uint8_t* p_mac = (uint8_t*)signature;
		uint8_t* pp;
		uint8_t* p_buf = (uint8_t*)osi_malloc(len + 4);
		@@ -2197,12 +2195,9 @@ bool BTM_BleDataSignature(const RawAddress& bd_addr, uint8_t* p_text,
		UINT32_TO_STREAM(pp, p_rec->ble.keys.local_counter);
		UINT32_TO_STREAM(p_mac, p_rec->ble.keys.local_counter);

		ret = aes_cipher_msg_auth_code(p_rec->ble.keys.lcsrk, p_buf,
		(uint16_t)(len + 4), BTM_CMAC_TLEN_SIZE,
		p_mac);
		if (ret) {
		aes_cipher_msg_auth_code(p_rec->ble.keys.lcsrk, p_buf, (uint16_t)(len + 4),
		BTM_CMAC_TLEN_SIZE, p_mac);
		btm_ble_increment_sign_ctr(bd_addr, true);
		}

		BTM_TRACE_DEBUG("%s p_mac = %d", __func__, p_mac);
		BTM_TRACE_DEBUG(
		@@ -2214,8 +2209,7 @@ bool BTM_BleDataSignature(const RawAddress& bd_addr, uint8_t* p_text,
		"0x%02x",
		(p_mac + 4), (p_mac + 5), (p_mac + 6), (p_mac + 7));
		osi_free(p_buf);
		}
		return ret;
		return true;
		}

		/*******************************************************************************
		@@ -2249,14 +2243,13 @@ bool BTM_BleVerifySignature(const RawAddress& bd_addr, uint8_t* p_orig,
		BTM_TRACE_DEBUG("%s rcv_cnt=%d >= expected_cnt=%d", __func__, counter,
		p_rec->ble.keys.counter);

		if (aes_cipher_msg_auth_code(p_rec->ble.keys.pcsrk, p_orig, len,
		BTM_CMAC_TLEN_SIZE, p_mac)) {
		aes_cipher_msg_auth_code(p_rec->ble.keys.pcsrk, p_orig, len,
		BTM_CMAC_TLEN_SIZE, p_mac);
		if (memcmp(p_mac, p_comp, BTM_CMAC_TLEN_SIZE) == 0) {
		btm_ble_increment_sign_ctr(bd_addr, false);
		verified = true;
		}
		}
		}
		return verified;
		}

		@@ -2476,7 +2469,6 @@ static void btm_ble_process_irk(tSMP_ENC* p) {
		******************************************************************************/
		static void btm_ble_process_dhk(tSMP_ENC* p) {
		uint8_t btm_ble_irk_pt = 0x01;
		tSMP_ENC output;

		BTM_TRACE_DEBUG("btm_ble_process_dhk");

		@@ -2484,14 +2476,10 @@ static void btm_ble_process_dhk(tSMP_ENC* p) {
		memcpy(btm_cb.devcb.id_keys.dhk, p->param_buf, BT_OCTET16_LEN);
		BTM_TRACE_DEBUG("BLE DHK generated.");

		tSMP_ENC output;
		/* IRK = D1(IR, 1) */
		if (!SMP_Encrypt(btm_cb.devcb.id_keys.ir, BT_OCTET16_LEN, &btm_ble_irk_pt,
		1, &output)) {
		/* reset all identity root related key */
		memset(&btm_cb.devcb.id_keys, 0, sizeof(tBTM_BLE_LOCAL_ID_KEYS));
		} else {
		SMP_Encrypt(btm_cb.devcb.id_keys.ir, &btm_ble_irk_pt, 1, &output);
		btm_ble_process_irk(&output);
		}
		} else {
		/* reset all identity root related key */
		memset(&btm_cb.devcb.id_keys, 0, sizeof(tBTM_BLE_LOCAL_ID_KEYS));
		@@ -2525,8 +2513,7 @@ void btm_ble_reset_id(void) {
		memcpy(&btm_cb.devcb.id_keys.ir[8], rand, BT_OCTET8_LEN);
		/* generate DHK= Eir({0x03, 0x00, 0x00 ...}) */

		SMP_Encrypt(btm_cb.devcb.id_keys.ir, BT_OCTET16_LEN, &btm_ble_dhk_pt, 1,
		&output);
		SMP_Encrypt(btm_cb.devcb.id_keys.ir, &btm_ble_dhk_pt, 1, &output);
		btm_ble_process_dhk(&output);

		BTM_TRACE_DEBUG("BLE IR generated.");

system/stack/btm/btm_ble_addr.cc

+4 −8

Original line number	Diff line number	Diff line
		@@ -94,13 +94,9 @@ void btm_gen_resolve_paddr_low(BT_OCTET8 rand) {
		p_cb->private_addr.address[0] = rand[2];

		/* encrypt with ur IRK */
		if (!SMP_Encrypt(btm_cb.devcb.id_keys.irk, BT_OCTET16_LEN, rand, 3,
		&output)) {
		btm_gen_resolve_paddr_cmpl(NULL);
		} else {
		SMP_Encrypt(btm_cb.devcb.id_keys.irk, rand, 3, &output);
		btm_gen_resolve_paddr_cmpl(&output);
		}
		}
		/*******************************************************************************
		*
		* Function btm_gen_resolvable_private_addr
		@@ -244,7 +240,7 @@ bool btm_ble_addr_resolvable(const RawAddress& rpa,
		rand[2] = rpa.address[0];

		/* generate X = E irk(R0, R1, R2) and R is random address 3 LSO */
		SMP_Encrypt(p_dev_rec->ble.keys.irk, BT_OCTET16_LEN, &rand[0], 3, &output);
		SMP_Encrypt(p_dev_rec->ble.keys.irk, &rand[0], 3, &output);

		rand[0] = rpa.address[5];
		rand[1] = rpa.address[4];
		@@ -292,7 +288,7 @@ static bool btm_ble_match_random_bda(void* data, void* context) {
		return true;

		/* generate X = E irk(R0, R1, R2) and R is random address 3 LSO */
		SMP_Encrypt(p_dev_rec->ble.keys.irk, BT_OCTET16_LEN, &rand[0], 3, &output);
		SMP_Encrypt(p_dev_rec->ble.keys.irk, &rand[0], 3, &output);
		// if it was match, finish iteration, otherwise continue
		return !btm_ble_proc_resolve_x(output, *random_bda);
		}

system/stack/btm/btm_ble_multi_adv.cc

+1 −2

Original line number	Diff line number	Diff line
		@@ -204,8 +204,7 @@ class BleAdvertisingManagerImpl
		BTM_GetDeviceIDRoot(irk);
		tSMP_ENC output;

		if (!SMP_Encrypt(irk, BT_OCTET16_LEN, rand, 3, &output))
		LOG_ASSERT(false) << "SMP_Encrypt failed";
		SMP_Encrypt(irk, rand, 3, &output);

		/* set hash to be LSB of rpAddress */
		bda.address[5] = output.param_buf[0];

system/stack/include/smp_api.h

+5 −6

Original line number	Diff line number	Diff line
		@@ -180,8 +180,8 @@ extern void SMP_SecureConnectionOobDataReply(uint8_t* p_data);
		*
		* Description Encrypt the data with the specified key.
		*
		* Parameters: key - Pointer to key key[0] conatins the MSB
		* key_len - key length
		* Parameters: key - Pointer to key key conatins the MSB,
		* must be 128bit
		* plain_text - Pointer to data to be encrypted
		* plain_text[0] conatins the MSB
		* pt_len - plain text length
		@@ -189,8 +189,8 @@ extern void SMP_SecureConnectionOobDataReply(uint8_t* p_data);
		*
		* Returns Boolean - true: encryption is successful
		******************************************************************************/
		extern bool SMP_Encrypt(uint8_t* key, uint8_t key_len, uint8_t* plain_text,
		uint8_t pt_len, tSMP_ENC* p_out);
		extern void SMP_Encrypt(uint8_t* key, uint8_t* plain_text, uint8_t pt_len,
		tSMP_ENC* p_out);

		/*******************************************************************************
		*
		@@ -234,9 +234,8 @@ extern void smp_link_encrypted(const RawAddress& bda, uint8_t encr_enable);
		// \|length\| - length of the input in byte.
		// \|tlen\| - lenth of mac desired
		// \|p_signature\| - data pointer to where signed data to be stored, tlen long.
		// Returns false if out of resources, true in other cases.
		//
		bool aes_cipher_msg_auth_code(BT_OCTET16 key, uint8_t* input, uint16_t length,
		void aes_cipher_msg_auth_code(BT_OCTET16 key, uint8_t* input, uint16_t length,
		uint16_t tlen, uint8_t* p_signature);

		#endif /* SMP_API_H */

system/stack/smp/smp_api.cc

+6 −10

Original line number	Diff line number	Diff line
		@@ -489,22 +489,18 @@ void SMP_SecureConnectionOobDataReply(uint8_t* p_data) {
		* Description This function is called to encrypt the data with the
		* specified key
		*
		* Parameters: key - Pointer to key key[0] conatins the MSB
		* key_len - key length
		* Parameters: key - Pointer to key key conatins the MSB,
		* must be 128bit
		* plain_text - Pointer to data to be encrypted
		* plain_text[0] conatins the MSB
		* pt_len - plain text length
		* p_out - output of the encrypted texts
		*
		* Returns Boolean - request is successful
		******************************************************************************/
		bool SMP_Encrypt(uint8_t* key, uint8_t key_len, uint8_t* plain_text,
		uint8_t pt_len, tSMP_ENC* p_out)
		void SMP_Encrypt(uint8_t* key, uint8_t* plain_text, uint8_t pt_len,
		tSMP_ENC* p_out)

		{
		bool status = false;
		status = smp_encrypt_data(key, key_len, plain_text, pt_len, p_out);
		return status;
		smp_encrypt_data(key, plain_text, pt_len, p_out);
		}

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