OVMS3-idf/components/bt/bluedroid/stack/gatt/gatt_auth.c
Tian Hao b80325604d component/bt: add bluedroid 1st version
1. add bluedroid 1st version
2. alarm adapter
3. task semaphore lock
4. other bugs resolved
2016-09-26 21:37:39 +08:00

536 lines
17 KiB
C
Executable file

/******************************************************************************
*
* Copyright (C) 1999-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
*
* this file contains GATT authentication handling functions
*
******************************************************************************/
#include "bt_target.h"
//#include "bt_utils.h"
#if BLE_INCLUDED == TRUE
#include <string.h>
#include "gki.h"
#include "gatt_int.h"
#include "gatt_api.h"
#include "btm_int.h"
/*******************************************************************************
**
** Function gatt_sign_data
**
** Description This function sign the data for write command.
**
** Returns TRUE if encrypted, otherwise FALSE.
**
*******************************************************************************/
static BOOLEAN gatt_sign_data (tGATT_CLCB *p_clcb)
{
tGATT_VALUE *p_attr = (tGATT_VALUE *)p_clcb->p_attr_buf;
UINT8 *p_data = NULL, *p;
UINT16 payload_size = p_clcb->p_tcb->payload_size;
BOOLEAN status = FALSE;
UINT8 *p_signature;
/* do not need to mark channel securoty activity for data signing */
gatt_set_sec_act(p_clcb->p_tcb, GATT_SEC_OK);
p_data = (UINT8 *)GKI_getbuf((UINT16)(p_attr->len + 3)); /* 3 = 2 byte handle + opcode */
if (p_data != NULL)
{
p = p_data;
UINT8_TO_STREAM(p, GATT_SIGN_CMD_WRITE);
UINT16_TO_STREAM(p, p_attr->handle);
ARRAY_TO_STREAM(p, p_attr->value, p_attr->len);
/* sign data length should be attribulte value length plus 2B handle + 1B op code */
if ((payload_size - GATT_AUTH_SIGN_LEN - 3) < p_attr->len)
p_attr->len = payload_size - GATT_AUTH_SIGN_LEN - 3;
p_signature = p_attr->value + p_attr->len;
if (BTM_BleDataSignature(p_clcb->p_tcb->peer_bda,
p_data,
(UINT16)(p_attr->len + 3), /* 3 = 2 byte handle + opcode */
p_signature))
{
p_attr->len += BTM_BLE_AUTH_SIGN_LEN;
gatt_set_ch_state(p_clcb->p_tcb, GATT_CH_OPEN);
gatt_act_write(p_clcb, GATT_SEC_SIGN_DATA);
}
else
{
gatt_end_operation(p_clcb, GATT_INTERNAL_ERROR, NULL);
}
GKI_freebuf(p_data);
}
return status;
}
/*******************************************************************************
**
** Function gatt_verify_signature
**
** Description This function start to verify the sign data when receiving
** the data from peer device.
**
** Returns
**
*******************************************************************************/
void gatt_verify_signature(tGATT_TCB *p_tcb, BT_HDR *p_buf)
{
UINT16 cmd_len;
UINT8 op_code;
UINT8 *p, *p_orig = (UINT8 *)(p_buf + 1) + p_buf->offset;
UINT32 counter;
if (p_buf->len < GATT_AUTH_SIGN_LEN + 4) {
GATT_TRACE_ERROR("%s: Data length %u less than expected %u",
__func__, p_buf->len, GATT_AUTH_SIGN_LEN + 4);
return;
}
cmd_len = p_buf->len - GATT_AUTH_SIGN_LEN + 4;
p = p_orig + cmd_len - 4;
STREAM_TO_UINT32(counter, p);
if (BTM_BleVerifySignature(p_tcb->peer_bda, p_orig, cmd_len, counter, p))
{
STREAM_TO_UINT8(op_code, p_orig);
gatt_server_handle_client_req (p_tcb, op_code, (UINT16)(p_buf->len - 1), p_orig);
}
else
{
/* if this is a bad signature, assume from attacker, ignore it */
GATT_TRACE_ERROR("Signature Verification Failed, data ignored");
}
return;
}
/*******************************************************************************
**
** Function gatt_sec_check_complete
**
** Description security check complete and proceed to data sending action.
**
** Returns void.
**
*******************************************************************************/
void gatt_sec_check_complete(BOOLEAN sec_check_ok, tGATT_CLCB *p_clcb, UINT8 sec_act)
{
if (p_clcb && p_clcb->p_tcb && GKI_queue_is_empty(&p_clcb->p_tcb->pending_enc_clcb))
gatt_set_sec_act(p_clcb->p_tcb, GATT_SEC_NONE);
if (!sec_check_ok)
{
gatt_end_operation(p_clcb, GATT_AUTH_FAIL, NULL);
}
else if (p_clcb->operation == GATTC_OPTYPE_WRITE)
{
gatt_act_write(p_clcb, sec_act);
}
else if (p_clcb->operation == GATTC_OPTYPE_READ)
{
gatt_act_read(p_clcb, p_clcb->counter);
}
}
/*******************************************************************************
**
** Function gatt_enc_cmpl_cback
**
** Description link encryption complete callback.
**
** Returns
**
*******************************************************************************/
void gatt_enc_cmpl_cback(BD_ADDR bd_addr, tBT_TRANSPORT transport, void *p_ref_data, tBTM_STATUS result)
{
tGATT_TCB *p_tcb;
UINT8 sec_flag;
BOOLEAN status = FALSE;
tGATT_PENDING_ENC_CLCB *p_buf;
UINT16 count;
UNUSED(p_ref_data);
GATT_TRACE_DEBUG("gatt_enc_cmpl_cback");
if ((p_tcb = gatt_find_tcb_by_addr(bd_addr, transport)) != NULL)
{
if (gatt_get_sec_act(p_tcb) == GATT_SEC_ENC_PENDING)
return;
if ((p_buf = (tGATT_PENDING_ENC_CLCB *)GKI_dequeue (&p_tcb->pending_enc_clcb)) != NULL)
{
if (result == BTM_SUCCESS)
{
if (gatt_get_sec_act(p_tcb) == GATT_SEC_ENCRYPT_MITM )
{
BTM_GetSecurityFlagsByTransport(bd_addr, &sec_flag, transport);
if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED)
{
status = TRUE;
}
}
else
{
status = TRUE;
}
}
gatt_sec_check_complete(status , p_buf->p_clcb, p_tcb->sec_act);
GKI_freebuf(p_buf);
/* start all other pending operation in queue */
count = GKI_queue_length(&p_tcb->pending_enc_clcb);
for (; count > 0; count --)
{
if ((p_buf = (tGATT_PENDING_ENC_CLCB *)GKI_dequeue (&p_tcb->pending_enc_clcb)) != NULL)
{
gatt_security_check_start(p_buf->p_clcb);
GKI_freebuf(p_buf);
}
else
break;
}
}
else
{
GATT_TRACE_ERROR("Unknown operation encryption completed");
}
}
else
{
GATT_TRACE_ERROR("enc callback for unknown bd_addr");
}
}
/*******************************************************************************
**
** Function gatt_notify_enc_cmpl
**
** Description link encryption complete notification for all encryption process
** initiated outside GATT.
**
** Returns
**
*******************************************************************************/
void gatt_notify_enc_cmpl(BD_ADDR bd_addr)
{
tGATT_TCB *p_tcb;
tGATT_PENDING_ENC_CLCB *p_buf;
UINT16 count;
UINT8 i = 0;
if ((p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_LE)) != NULL)
{
for (i = 0; i < GATT_MAX_APPS; i++)
{
if (gatt_cb.cl_rcb[i].in_use && gatt_cb.cl_rcb[i].app_cb.p_enc_cmpl_cb)
{
(*gatt_cb.cl_rcb[i].app_cb.p_enc_cmpl_cb)(gatt_cb.cl_rcb[i].gatt_if, bd_addr);
}
}
if (gatt_get_sec_act(p_tcb) == GATT_SEC_ENC_PENDING)
{
gatt_set_sec_act(p_tcb, GATT_SEC_NONE);
count = GKI_queue_length(&p_tcb->pending_enc_clcb);
for (; count > 0; count --)
{
if ((p_buf = (tGATT_PENDING_ENC_CLCB *)GKI_dequeue (&p_tcb->pending_enc_clcb)) != NULL)
{
gatt_security_check_start(p_buf->p_clcb);
GKI_freebuf(p_buf);
}
else
break;
}
}
}
else
{
GATT_TRACE_DEBUG("notify GATT for encryption completion of unknown device");
}
return;
}
/*******************************************************************************
**
** Function gatt_set_sec_act
**
** Description This function set the sec_act in clcb
**
** Returns none
**
*******************************************************************************/
void gatt_set_sec_act(tGATT_TCB *p_tcb, tGATT_SEC_ACTION sec_act)
{
if (p_tcb)
{
p_tcb->sec_act = sec_act;
}
}
/*******************************************************************************
**
** Function gatt_get_sec_act
**
** Description This function get the sec_act in clcb
**
** Returns none
**
*******************************************************************************/
tGATT_SEC_ACTION gatt_get_sec_act(tGATT_TCB *p_tcb)
{
tGATT_SEC_ACTION sec_act = GATT_SEC_NONE;
if (p_tcb)
{
sec_act = p_tcb->sec_act;
}
return sec_act;
}
/*******************************************************************************
**
** Function gatt_determine_sec_act
**
** Description This routine determine the security action based on auth_request and
** current link status
**
** Returns tGATT_SEC_ACTION security action
**
*******************************************************************************/
tGATT_SEC_ACTION gatt_determine_sec_act(tGATT_CLCB *p_clcb )
{
tGATT_SEC_ACTION act = GATT_SEC_OK;
UINT8 sec_flag;
tGATT_TCB *p_tcb = p_clcb->p_tcb;
tGATT_AUTH_REQ auth_req = p_clcb->auth_req;
BOOLEAN is_link_encrypted= FALSE;
BOOLEAN is_link_key_known=FALSE;
BOOLEAN is_key_mitm=FALSE;
UINT8 key_type;
tBTM_BLE_SEC_REQ_ACT sec_act = BTM_LE_SEC_NONE;
if (auth_req == GATT_AUTH_REQ_NONE )
return act;
BTM_GetSecurityFlagsByTransport(p_tcb->peer_bda, &sec_flag, p_clcb->p_tcb->transport);
btm_ble_link_sec_check(p_tcb->peer_bda, auth_req, &sec_act);
/* if a encryption is pending, need to wait */
if (sec_act == BTM_BLE_SEC_REQ_ACT_DISCARD &&
auth_req != GATT_AUTH_REQ_NONE)
return GATT_SEC_ENC_PENDING;
if (sec_flag & (BTM_SEC_FLAG_ENCRYPTED| BTM_SEC_FLAG_LKEY_KNOWN))
{
if (sec_flag & BTM_SEC_FLAG_ENCRYPTED)
is_link_encrypted = TRUE;
is_link_key_known = TRUE;
if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED)
is_key_mitm = TRUE;
}
/* first check link key upgrade required or not */
switch (auth_req)
{
case GATT_AUTH_REQ_MITM:
case GATT_AUTH_REQ_SIGNED_MITM:
if (!is_key_mitm)
act = GATT_SEC_ENCRYPT_MITM;
break;
case GATT_AUTH_REQ_NO_MITM:
case GATT_AUTH_REQ_SIGNED_NO_MITM:
if (!is_link_key_known)
act = GATT_SEC_ENCRYPT_NO_MITM;
break;
default:
break;
}
/* now check link needs to be encrypted or not if the link key upgrade is not required */
if (act == GATT_SEC_OK)
{
if (p_tcb->transport == BT_TRANSPORT_LE &&
(p_clcb->operation == GATTC_OPTYPE_WRITE) &&
(p_clcb->op_subtype == GATT_WRITE_NO_RSP))
{
/* this is a write command request
check data signing required or not */
if (!is_link_encrypted)
{
btm_ble_get_enc_key_type(p_tcb->peer_bda, &key_type);
if ( (key_type & BTM_LE_KEY_LCSRK) &&
((auth_req == GATT_AUTH_REQ_SIGNED_NO_MITM) ||
(auth_req == GATT_AUTH_REQ_SIGNED_MITM)))
{
act = GATT_SEC_SIGN_DATA;
}
else
{
act = GATT_SEC_ENCRYPT;
}
}
}
else
{
if (!is_link_encrypted)
{
act = GATT_SEC_ENCRYPT;
}
}
}
return act ;
}
/*******************************************************************************
**
** Function gatt_get_link_encrypt_status
**
** Description This routine get the encryption status of the specified link
**
**
** Returns tGATT_STATUS link encryption status
**
*******************************************************************************/
tGATT_STATUS gatt_get_link_encrypt_status(tGATT_TCB *p_tcb)
{
tGATT_STATUS encrypt_status = GATT_NOT_ENCRYPTED;
UINT8 sec_flag=0;
BTM_GetSecurityFlagsByTransport(p_tcb->peer_bda, &sec_flag, p_tcb->transport);
if ((sec_flag & BTM_SEC_FLAG_ENCRYPTED) && (sec_flag & BTM_SEC_FLAG_LKEY_KNOWN))
{
encrypt_status = GATT_ENCRYPED_NO_MITM;
if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED)
encrypt_status = GATT_ENCRYPED_MITM;
}
GATT_TRACE_DEBUG("gatt_get_link_encrypt_status status=0x%x",encrypt_status);
return encrypt_status ;
}
/*******************************************************************************
**
** Function gatt_convert_sec_action
**
** Description Convert GATT security action enum into equivalent BTM BLE security action enum
**
** Returns BOOLEAN TRUE - conversation is successful
**
*******************************************************************************/
static BOOLEAN gatt_convert_sec_action(tGATT_SEC_ACTION gatt_sec_act, tBTM_BLE_SEC_ACT *p_btm_sec_act )
{
BOOLEAN status = TRUE;
switch (gatt_sec_act)
{
case GATT_SEC_ENCRYPT:
*p_btm_sec_act = BTM_BLE_SEC_ENCRYPT;
break;
case GATT_SEC_ENCRYPT_NO_MITM:
*p_btm_sec_act = BTM_BLE_SEC_ENCRYPT_NO_MITM;
break;
case GATT_SEC_ENCRYPT_MITM:
*p_btm_sec_act = BTM_BLE_SEC_ENCRYPT_MITM;
break;
default:
status = FALSE;
break;
}
return status;
}
/*******************************************************************************
**
** Function gatt_check_enc_req
**
** Description check link security.
**
** Returns TRUE if encrypted, otherwise FALSE.
**
*******************************************************************************/
BOOLEAN gatt_security_check_start(tGATT_CLCB *p_clcb)
{
tGATT_TCB *p_tcb = p_clcb->p_tcb;
tGATT_SEC_ACTION gatt_sec_act;
tBTM_BLE_SEC_ACT btm_ble_sec_act;
BOOLEAN status = TRUE;
tBTM_STATUS btm_status;
tGATT_SEC_ACTION sec_act_old = gatt_get_sec_act(p_tcb);
gatt_sec_act = gatt_determine_sec_act(p_clcb);
if (sec_act_old == GATT_SEC_NONE)
gatt_set_sec_act(p_tcb, gatt_sec_act);
switch (gatt_sec_act )
{
case GATT_SEC_SIGN_DATA:
GATT_TRACE_DEBUG("gatt_security_check_start: Do data signing");
gatt_sign_data(p_clcb);
break;
case GATT_SEC_ENCRYPT:
case GATT_SEC_ENCRYPT_NO_MITM:
case GATT_SEC_ENCRYPT_MITM:
if (sec_act_old < GATT_SEC_ENCRYPT)
{
GATT_TRACE_DEBUG("gatt_security_check_start: Encrypt now or key upgreade first");
gatt_convert_sec_action(gatt_sec_act, &btm_ble_sec_act);
btm_status = BTM_SetEncryption(p_tcb->peer_bda, p_tcb->transport , gatt_enc_cmpl_cback, &btm_ble_sec_act);
if ( (btm_status != BTM_SUCCESS) && (btm_status != BTM_CMD_STARTED))
{
GATT_TRACE_ERROR("gatt_security_check_start BTM_SetEncryption failed btm_status=%d", btm_status);
status = FALSE;
}
}
if (status)
gatt_add_pending_enc_channel_clcb (p_tcb, p_clcb);
break;
case GATT_SEC_ENC_PENDING:
gatt_add_pending_enc_channel_clcb (p_tcb, p_clcb);
/* wait for link encrypotion to finish */
break;
default:
gatt_sec_check_complete(TRUE, p_clcb, gatt_sec_act);
break;
}
if (status == FALSE)
{
gatt_set_sec_act(p_tcb, GATT_SEC_NONE);
gatt_set_ch_state(p_tcb, GATT_CH_OPEN);
}
return status;
}
#endif /* BLE_INCLUDED */