GLS/SEN/SPE/BI-09-C

RE: GLS/SEN/SPE/BI-09-C

moon.kim — Wed, 29 Jul 2020 00:33:47 GMT

I solved this problem by not performing pm_conn_secure(m_conn_handle, false) in sec_req_timeout_handler.

It doesn't seem to be a test to change RACP permissions.

RE: GLS/SEN/SPE/BI-09-C

Vidar Berg — Tue, 28 Jul 2020 09:35:40 GMT

Hello,

The record access control point characteristic must be set with a security level equal or greater than "Just works". The test case will fail if it's set with open access (BLE_GAP_CONN_SEC_MODE_SET_OPEN).

But the problem according to the original log you posted seems to be that PTS is enabling encryption. Did you make sure to skip step 4 which was outlined in section 4.2.2 of the GLS test suite document?

Best regards,

Vidar

RE: GLS/SEN/SPE/BI-09-C

moon.kim — Fri, 24 Jul 2020 12:33:39 GMT

Yes..

The same failure message still appears.

I wish another technical supporter would let me know the good news.

devzone.nordicsemi.com/.../gls.7z

I send the log files recorded in Profile Test Suite.
You could open it with the PTS program...

RE: GLS/SEN/SPE/BI-09-C

haakonsh — Fri, 24 Jul 2020 12:13:36 GMT

Do you still get the same error message?

I'm going on vacation for a week, but I'll assign your case to another Tech Supporter.

BR,

Håkon HoldhusI

RE: GLS/SEN/SPE/BI-09-C

moon.kim — Fri, 24 Jul 2020 11:54:50 GMT

Hi.

I tested all the characetistic and attributes of GLS by changing them to BLE_GAP_CONN_SEC_MODE_SET_OPEN, but the test also failed.

A look at the Bluetooth SIG's GLS test suite is described below.

I know QDID 49943 has passed the GLS test. Can you check the related source code?

RE: GLS/SEN/SPE/BI-09-C

haakonsh — Fri, 24 Jul 2020 11:01:37 GMT

BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);

Try setting open access to all attributes of all characteristics in the GLS service.

You should also ask BT SIG why they don't support encryption in their tests. It seems kinda weird to do conformance tests on a GLS service without any encryption since there should be no devices deployed with an open GLS service.

RE: GLS/SEN/SPE/BI-09-C

moon.kim — Fri, 24 Jul 2020 09:46:35 GMT

Because I use SDK 15.0.0, the source code is a bit wrong.

However, it was modified in ble_gls.c as indicated.

static uint32_t glucose_measurement_char_add(ble_gls_t * p_gls)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_md_t cccd_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;
    ble_gls_rec_t       initial_gls_rec_value;
    uint8_t             encoded_gls_meas[MAX_GLM_LEN];

    memset(&cccd_md, 0, sizeof(cccd_md));

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
    //BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&cccd_md.write_perm);	
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);
	
    cccd_md.vloc = BLE_GATTS_VLOC_STACK;

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.notify = 1;
    char_md.p_char_user_desc  = NULL;
    char_md.p_char_pf         = NULL;
    char_md.p_user_desc_md    = NULL;
    char_md.p_cccd_md         = &cccd_md;
    char_md.p_sccd_md         = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_GLUCOSE_MEASUREMENT_CHAR);
    memset(&attr_md, 0, sizeof(attr_md));

    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);

    attr_md.vloc    = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 0;
    attr_md.vlen    = 1;

    memset(&attr_char_value, 0, sizeof(attr_char_value));
    memset(&initial_gls_rec_value, 0, sizeof(initial_gls_rec_value));

    attr_char_value.p_uuid    = &ble_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len  = gls_meas_encode(&initial_gls_rec_value.meas, encoded_gls_meas);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len   = MAX_GLM_LEN;
    attr_char_value.p_value   = encoded_gls_meas;

    return sd_ble_gatts_characteristic_add(p_gls->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_gls->glm_handles);
}

static uint32_t glucose_context_char_add(ble_gls_t * p_gls)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_md_t cccd_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;
    ble_gls_rec_t       initial_gls_rec_value;
    uint8_t             encoded_gls_meas[MAX_GLM_LEN];
    uint8_t             num_recs;
    memset(&cccd_md, 0, sizeof(cccd_md));

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
    //BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&cccd_md.write_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);

	cccd_md.vloc = BLE_GATTS_VLOC_STACK;

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.notify = 1;
    char_md.p_char_user_desc  = NULL;
    char_md.p_char_pf         = NULL;
    char_md.p_user_desc_md    = NULL;
    char_md.p_cccd_md         = &cccd_md;
    char_md.p_sccd_md         = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_GLUCOSE_MEASUREMENT_CONTEXT_CHAR);
    memset(&attr_md, 0, sizeof(attr_md));

    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);

    attr_md.vloc    = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 0;
    attr_md.vlen    = 1;

    memset(&attr_char_value, 0, sizeof(attr_char_value));
    memset(&initial_gls_rec_value, 0, sizeof(initial_gls_rec_value));

    num_recs = ble_gls_db_num_records_get();
    if (num_recs > 0)
    {
        uint32_t err_code = ble_gls_db_record_get(num_recs - 1, &initial_gls_rec_value);
        if (err_code != NRF_SUCCESS)
        {
            return err_code;
        }
    }

    attr_char_value.p_uuid    = &ble_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len  = gls_meas_encode(&initial_gls_rec_value.meas, encoded_gls_meas);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len   = MAX_GLM_LEN;
    attr_char_value.p_value   = encoded_gls_meas;

    return sd_ble_gatts_characteristic_add(p_gls->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_gls->glm_context_handles);
}

static uint32_t glucose_feature_char_add(ble_gls_t * p_gls)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;
    uint8_t             encoded_initial_feature[2];

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.read  = 1;
    char_md.p_char_user_desc = NULL;
    char_md.p_char_pf        = NULL;
    char_md.p_user_desc_md   = NULL;
    char_md.p_cccd_md        = NULL;
    char_md.p_sccd_md        = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_GLUCOSE_FEATURE_CHAR);

    memset(&attr_md, 0, sizeof(attr_md));

    BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);

    attr_md.vloc    = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 0;
    attr_md.vlen    = 0;

    memset(&attr_char_value, 0, sizeof(attr_char_value));

    encoded_initial_feature[0] = (uint8_t)(p_gls->feature);
    encoded_initial_feature[1] = (uint8_t)((p_gls->feature) >> 8);

    attr_char_value.p_uuid    = &ble_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len  = sizeof (uint16_t);
    attr_char_value.init_offs = 0;
    attr_char_value.max_len   = sizeof (uint16_t);
    attr_char_value.p_value   = encoded_initial_feature;

    return sd_ble_gatts_characteristic_add(p_gls->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_gls->glf_handles);
}


static uint32_t record_access_control_point_char_add(ble_gls_t * p_gls)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_md_t cccd_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;

    memset(&cccd_md, 0, sizeof(cccd_md));

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
    //BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&cccd_md.write_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);
    cccd_md.vloc = BLE_GATTS_VLOC_STACK;

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.indicate = 1;
    char_md.char_props.write    = 1;
    char_md.p_char_user_desc    = NULL;
    char_md.p_char_pf           = NULL;
    char_md.p_user_desc_md      = NULL;
    char_md.p_cccd_md           = &cccd_md;
    char_md.p_sccd_md           = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_RECORD_ACCESS_CONTROL_POINT_CHAR);

    memset(&attr_md, 0, sizeof(attr_md));

    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_ENC_NO_MITM(&attr_md.write_perm);

    attr_md.vloc    = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth = 0;
    attr_md.wr_auth = 1;
    attr_md.vlen    = 1;

    memset(&attr_char_value, 0, sizeof(attr_char_value));

    attr_char_value.p_uuid    = &ble_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len  = 0;
    attr_char_value.init_offs = 0;
    attr_char_value.max_len   = BLE_GATT_ATT_MTU_DEFAULT;
    ///attr_char_value.max_len   = BLE_L2CAP_MTU_DEF;
    attr_char_value.p_value   = 0;

    return sd_ble_gatts_characteristic_add(p_gls->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_gls->racp_handles);
}

However, the test still failed.

It was tested using PCA 100400e and the latest SDK. But the result was also a failure.

// Here the sec level for the Glucose Service can be changed/increased.
gls_init.gl_meas_cccd_wr_sec = SEC_OPEN;
gls_init.gl_feature_rd_sec   = SEC_OPEN;
gls_init.racp_cccd_wr_sec    = SEC_OPEN;
gls_init.racp_wr_sec         = SEC_OPEN;

Are there any other parts that need to be modified?

RE: GLS/SEN/SPE/BI-09-C

haakonsh — Fri, 24 Jul 2020 07:49:52 GMT

It could be the read/write permissions of the individual characteristics.

In the examples/ble_peripheral/ble_app_gls/main.c on line 433, the permissions for the GLS characteristics is set to JustWorks. Try setting all the permissions for the GLS characteristics in services_init()to SEC_OPEN.

If this is an actual product you're making you need to make sure to use the appropriate security levels when you deploy.

RE: GLS/SEN/SPE/BI-09-C

moon.kim — Fri, 24 Jul 2020 00:17:29 GMT

Hi, haakonsh

Check this in the items below.

TSPC_GLS_2_22

TSPC_GLS_3_1

GLS/SEN/SPE/BI-09-C : RACP write without Authentication

I don't understand well about turning the encrytion off.

I tried the test by setting the Security parameter as follows:

But it also failed.

#define SEC_PARAM_BOND					1
#define SEC_PARAM_MITM					0											
#define SEC_PARAM_IO_CAPABILITIES		BLE_GAP_IO_CAPS_NONE						
#define SEC_PARAM_LESC					0											
#define SEC_PARAM_KEYPRESS				0											
#define SEC_PARAM_OOB					0											
#define SEC_PARAM_MIN_KEY_SIZE			7											
#define SEC_PARAM_MAX_KEY_SIZE			16

And I tried changing the settings below but it also failed.

BLE_GAP_CONN_SEC_MODE_SET_OPEN(&SecMode);
Err_code = sd_ble_gap_device_name_set(&SecMode,
									(const uint8_t *)DEVICE_NAME,
									 sizeof(DEVICE_NAME));

What settings should I change to turn off encryption?

RE: GLS/SEN/SPE/BI-09-C

haakonsh — Thu, 23 Jul 2020 14:36:47 GMT

What is that test case? Is it just a conformance test of the GLS profile?

It seems the test only works for unencrypted links, i suggest you turn off encryption.