def test_reject_non_resolved_address_with_one_bond(peripheral, central, central2): """validate that when a peripheral with: * privacy enabled * privacy policy set to REJECT_NON_RESOLVED_ADDRESS * at least a bond is connected by an unknown privacy enabled device then the connection is rejected""" init_privacy(central2) perform_bonding_with_privacy_and_disconnect(peripheral, central) peripheral.gap.setPeripheralPrivacyConfiguration( False, "REJECT_NON_RESOLVED_ADDRESS") advertising_data = start_advertising_of_type(peripheral, "CONNECTABLE_UNDIRECTED") central2.gap.setCentralPrivacyConfiguration(False, "DO_NOT_RESOLVE") central2.gap.setPeripheralPrivacyConfiguration(False, "DO_NOT_RESOLVE") scan_results = start_scanning_for_data(central2, advertising_data) scan = scan_results[0] disconnection_cmd = peripheral.gap.waitForDisconnection.setAsync()(10000) central2.gap.startConnecting(scan["peer_address_type"], scan["peer_address"]).result assert disconnection_cmd.result
def test_privacy_random_resolvable_and_nonresolvable_address( peripheral, central, advertising_type, unresolvable): """validate that when privacy is enabled and a peripheral use a random resolvable address then a random resolvable address is used for all advertising modes.""" init_privacy(peripheral) init_privacy(central) peripheral.gap.setPeripheralPrivacyConfiguration(unresolvable, "DO_NOT_RESOLVE") advertising_data = start_advertising_of_type(peripheral, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "DO_NOT_RESOLVE") scan_results = start_scanning_for_data(central, advertising_data) assert len(scan_results) > 0 at_least_one_resolved = False for scan in scan_results: if scan["peer_address_type"] == "RANDOM": if unresolvable and advertising_type != "CONNECTABLE_UNDIRECTED": assert address_is_random_non_resolvable(scan["peer_address"]) else: assert address_is_random_resolvable(scan["peer_address"]) at_least_one_resolved = True assert at_least_one_resolved
def test_resolve_and_filter_unknown_address_with_bond_present( peripheral, central, peripheral2, advertising_type): """Ensure that if the central privacy policy is set to resolve and filter and the device has a bond then resolved private addresses are filtered""" init_privacy(peripheral2) perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral2, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "RESOLVE_AND_FILTER") scan_results = start_scanning_for_data(central, advertising_data) assert len(scan_results) == 0
def test_central_not_resolve_policy(peripheral, central, advertising_type): """validate that when a peripheral with privacy enabled using private resolvable address advertise then a known peer that do not resolves addresses do not resolve the address advertised""" perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "DO_NOT_RESOLVE") central.gap.setPeripheralPrivacyConfiguration(False, "DO_NOT_RESOLVE") scan_results = start_scanning_for_data(central, advertising_data) for scan in scan_results: assert scan["peer_address_type"] == "RANDOM" assert address_is_random_resolvable(scan["peer_address"])
def test_resolve_and_filter_bonded_peer(peripheral, central, advertising_type): """Ensure that if the central privacy policy is set to resolve and filter bonded devices show up in scan results as resolved addresses""" perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "RESOLVE_AND_FILTER") scan_results = start_scanning_for_data(central, advertising_data) assert len(scan_results) for scan in scan_results: assert scan["peer_address_type"] == "RANDOM_STATIC_IDENTITY" assert address_is_random_resolvable(scan["peer_address"]) is False assert address_is_random_non_resolvable(scan["peer_address"]) is False
def test_resolve_and_filter_unknown_address(peripheral, central, advertising_type): """Ensure that if the central privacy policy is set to resolve and filter and the device has no bond then resolvable private addresses are not filtered""" init_privacy(peripheral) init_privacy(central) advertising_data = start_advertising_of_type(peripheral, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "RESOLVE_AND_FILTER") scan_results = start_scanning_for_data(central, advertising_data) assert len(scan_results) for scan in scan_results: assert scan["peer_address_type"] == "RANDOM" assert address_is_random_resolvable(scan["peer_address"])
def test_non_resolved_address_with_resolve_and_forward(peripheral, central, peripheral2, advertising_type): """Ensure that if the central privacy policy is set to resolve and forward and the device has one bond then non resolved private addresses are forwarded""" init_privacy(peripheral2) perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral2, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "RESOLVE_AND_FORWARD") scan_results = start_scanning_for_data(central, advertising_data) assert len(scan_results) for scan in scan_results: assert scan["peer_address_type"] == "RANDOM" assert address_is_random_resolvable(scan["peer_address"])
def test_connection_to_non_resolved_address(peripheral, central): """validate that when a peripheral with privacy enabled using private resolvable address advertise then a known peer that do not resolves addresses can connect to the non resolved address""" perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral, "CONNECTABLE_UNDIRECTED") central.gap.setCentralPrivacyConfiguration(False, "DO_NOT_RESOLVE") central.gap.setPeripheralPrivacyConfiguration(False, "DO_NOT_RESOLVE") scan_results = start_scanning_for_data(central, advertising_data) scan = scan_results[0] assert scan["peer_address_type"] == "RANDOM" assert address_is_random_resolvable(scan["peer_address"]) connect_to_address(central, peripheral, scan["peer_address_type"], scan["peer_address"])
def test_reject_non_resolved_address_with_no_bond_accepts_connection( peripheral, central): """validate that when a peripheral with privacy enabled, the privacy policy set to REJECT_NON_RESOLVED_ADDRESS and no bond is connected by an unknown privacy enabled then connection is accepted""" init_privacy(peripheral) init_privacy(central) peripheral.gap.setPeripheralPrivacyConfiguration( False, "REJECT_NON_RESOLVED_ADDRESS") advertising_data = start_advertising_of_type(peripheral, "CONNECTABLE_UNDIRECTED") central.gap.setCentralPrivacyConfiguration(False, "DO_NOT_RESOLVE") scan_results = start_scanning_for_data(central, advertising_data) scan = scan_results[0] connect_to_address(central, peripheral, scan["peer_address_type"], scan["peer_address"])
def test_connection_with_resolved_address(peripheral, central): """validate that when a peripheral with privacy enabled using private resolvable address advertise then a known peer that resolves addresses can connect with the resolved address""" perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral, "CONNECTABLE_UNDIRECTED") central.gap.setCentralPrivacyConfiguration(False, "RESOLVE_AND_FORWARD") sleep(1) scan_results = start_scanning_for_data(central, advertising_data) for scan in scan_results: if scan["peer_address_type"] == "RANDOM_STATIC_IDENTITY" or scan[ "peer_address_type"] == "PUBLIC_IDENTITY": central_connection, _ = connect_to_address( central, peripheral, scan["peer_address_type"], scan["peer_address"]) assert central_connection["peer_address_type"] == scan[ "peer_address_type"] assert central_connection["peer_address"] == scan["peer_address"] break
def test_address_resolution_when_advertised(peripheral, central, advertising_type): """validate that when a peripheral with privacy enabled using private resolvable address advertise then a known peer that resolves addresses resolve the address advertised""" perform_bonding_with_privacy_and_disconnect(peripheral, central) advertising_data = start_advertising_of_type(peripheral, advertising_type) central.gap.setCentralPrivacyConfiguration(False, "RESOLVE_AND_FORWARD") scan_results = start_scanning_for_data(central, advertising_data) at_least_one_resolved = False for scan in scan_results: if scan["peer_address_type"] == "RANDOM_STATIC_IDENTITY": if address_is_random_resolvable(scan["peer_address"]) is False: if address_is_random_non_resolvable( scan["peer_address"]) is False: at_least_one_resolved = True break assert at_least_one_resolved