Exemple #1
0
    def _get_devices(self, otp_mode=False):
        res = []
        descs_to_match = self._descs[:]
        handled_serials = set()
        time.sleep(0.5)  # Let macOS take time to see the reader
        for transport in [TRANSPORT.CCID, TRANSPORT.OTP, TRANSPORT.FIDO]:
            if not descs_to_match:
                return res
            for dev in list_devices(transport):
                if not descs_to_match:
                    return res

                serial = dev.serial
                selectable = usb_selectable(dev, otp_mode)

                if selectable and not otp_mode and transport == TRANSPORT.CCID:
                    controller = OathController(dev.driver)
                    has_password = controller.locked
                else:
                    has_password = False

                if serial not in handled_serials:
                    handled_serials.add(serial)
                    matches = [
                        d for d in descs_to_match
                        if (d.key_type, d.mode) == (dev.driver.key_type,
                                                    dev.driver.mode)
                    ]
                    if len(matches) > 0:
                        matching_descriptor = matches[0]
                        res.append({
                            'name':
                            dev.device_name,
                            'version':
                            '.'.join(
                                str(x)
                                for x in dev.version) if dev.version else '',
                            'serial':
                            serial or '',
                            'usbInterfacesEnabled':
                            str(dev.mode).split('+'),
                            'hasPassword':
                            has_password,
                            'selectable':
                            selectable,
                            'validated':
                            not has_password
                        })
                        descs_to_match.remove(matching_descriptor)
        return res
from ykman.util import TRANSPORT

_skip = True

_test_serials = os.environ.get('DESTRUCTIVE_TEST_YUBIKEY_SERIALS')
_serials_present = set()
_no_prompt = os.environ.get('DESTRUCTIVE_TEST_DO_NOT_PROMPT') == 'TRUE'
_versions = {}

if _test_serials is not None:
    start_time = time.time()
    print('Initiating device discovery...')

    _test_serials = set(int(s) for s in _test_serials.split(','))

    for dev in list_devices():
        print('{:.3f} {}'.format(time.time() - start_time, dev))
        _serials_present.add(dev.serial)
        _versions[dev.serial] = dev.version
        dev.close()

    _unwanted_serials = _serials_present.difference(_test_serials)

    if len(_unwanted_serials) != 0:
        print('Encountered YubiKeys not listed in serial numbers to be used '
              'for the test: {}'.format(_unwanted_serials),
              file=sys.stderr)
        sys.exit(1)

    if _serials_present != _test_serials:
        print('Test YubiKeys missing: {}'.format(
Exemple #3
0
        def _get_devices(self, otp_mode=False):
            res = []
            descs_to_match = self._descs[:]
            handled_serials = set()
            time.sleep(0.5)  # Let macOS take time to see the reader
            for transport in [TRANSPORT.CCID, TRANSPORT.OTP, TRANSPORT.FIDO]:
                if not descs_to_match:
                    return res
                for dev in list_devices(transport):
                    if not descs_to_match:
                        return res

                    serial = dev.serial
                    selectable = usb_selectable(dev, otp_mode)

                    if dev.version:
                        version = ".".join(str(x) for x in dev.version)
                    else:
                        version = ""

                    if selectable and not otp_mode and transport == TRANSPORT.CCID:
                        controller = OathController(dev.driver)
                        has_password = controller.locked
                    else:
                        has_password = False

                    if serial not in handled_serials:
                        handled_serials.add(serial)

                        matches_all = [
                            d
                            for d in self._descs[:]
                            if (d.key_type, d.mode)
                            == (dev.driver.key_type, dev.driver.mode)
                        ]

                        matches_left = [
                            d
                            for d in descs_to_match
                            if (d.key_type, d.mode)
                            == (dev.driver.key_type, dev.driver.mode)
                        ]

                        if len(matches_left) > 0:

                            if len(matches_all) == 1 and version == "":
                                # Only one matching descriptor of all descriptors,
                                # try reading any missing version from it
                                descriptor = matches_all[0]
                                if descriptor.version:
                                    version = ".".join(
                                        str(x) for x in descriptor.version
                                    )

                            res.append(
                                {
                                    "name": dev.device_name,
                                    "version": version,
                                    "serial": serial or "",
                                    "usbInterfacesEnabled": str(dev.mode).split("+"),
                                    "hasPassword": has_password,
                                    "selectable": selectable,
                                    "validated": not has_password,
                                }
                            )

                            descs_to_match.remove(matches_left[0])
            return res