Skip to content

web_authn

AuthenticatorId

Bases: str

Source code in zendriver/cdp/web_authn.py 
15
16
17
18
19
20
21
22
23
24
class AuthenticatorId(str):
    def to_json(self) -> str:
        return self

    @classmethod
    def from_json(cls, json: str) -> AuthenticatorId:
        return cls(json)

    def __repr__(self):
        return "AuthenticatorId({})".format(super().__repr__())

__repr__()

Source code in zendriver/cdp/web_authn.py 
23
24
def __repr__(self):
    return "AuthenticatorId({})".format(super().__repr__())

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
19
20
21
@classmethod
def from_json(cls, json: str) -> AuthenticatorId:
    return cls(json)

to_json()

Source code in zendriver/cdp/web_authn.py 
16
17
def to_json(self) -> str:
    return self

AuthenticatorProtocol

Bases: Enum

Source code in zendriver/cdp/web_authn.py 
27
28
29
30
31
32
33
34
35
36
class AuthenticatorProtocol(enum.Enum):
    U2F = "u2f"
    CTAP2 = "ctap2"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> AuthenticatorProtocol:
        return cls(json)

CTAP2 = 'ctap2' class-attribute instance-attribute

U2F = 'u2f' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
34
35
36
@classmethod
def from_json(cls, json: str) -> AuthenticatorProtocol:
    return cls(json)

to_json()

Source code in zendriver/cdp/web_authn.py 
31
32
def to_json(self) -> str:
    return self.value

AuthenticatorTransport

Bases: Enum

Source code in zendriver/cdp/web_authn.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
class AuthenticatorTransport(enum.Enum):
    USB = "usb"
    NFC = "nfc"
    BLE = "ble"
    CABLE = "cable"
    INTERNAL = "internal"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> AuthenticatorTransport:
        return cls(json)

BLE = 'ble' class-attribute instance-attribute

CABLE = 'cable' class-attribute instance-attribute

INTERNAL = 'internal' class-attribute instance-attribute

NFC = 'nfc' class-attribute instance-attribute

USB = 'usb' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
61
62
63
@classmethod
def from_json(cls, json: str) -> AuthenticatorTransport:
    return cls(json)

to_json()

Source code in zendriver/cdp/web_authn.py 
58
59
def to_json(self) -> str:
    return self.value

Credential dataclass

Source code in zendriver/cdp/web_authn.py 
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
@dataclass
class Credential:
    credential_id: str

    is_resident_credential: bool

    #: The ECDSA P-256 private key in PKCS#8 format. (Encoded as a base64 string when passed over JSON)
    private_key: str

    #: Signature counter. This is incremented by one for each successful
    #: assertion.
    #: See https://w3c.github.io/webauthn/#signature-counter
    sign_count: int

    #: Relying Party ID the credential is scoped to. Must be set when adding a
    #: credential.
    rp_id: typing.Optional[str] = None

    #: An opaque byte sequence with a maximum size of 64 bytes mapping the
    #: credential to a specific user. (Encoded as a base64 string when passed over JSON)
    user_handle: typing.Optional[str] = None

    #: The large blob associated with the credential.
    #: See https://w3c.github.io/webauthn/#sctn-large-blob-extension (Encoded as a base64 string when passed over JSON)
    large_blob: typing.Optional[str] = None

    #: Assertions returned by this credential will have the backup eligibility
    #: (BE) flag set to this value. Defaults to the authenticator's
    #: defaultBackupEligibility value.
    backup_eligibility: typing.Optional[bool] = None

    #: Assertions returned by this credential will have the backup state (BS)
    #: flag set to this value. Defaults to the authenticator's
    #: defaultBackupState value.
    backup_state: typing.Optional[bool] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["credentialId"] = self.credential_id
        json["isResidentCredential"] = self.is_resident_credential
        json["privateKey"] = self.private_key
        json["signCount"] = self.sign_count
        if self.rp_id is not None:
            json["rpId"] = self.rp_id
        if self.user_handle is not None:
            json["userHandle"] = self.user_handle
        if self.large_blob is not None:
            json["largeBlob"] = self.large_blob
        if self.backup_eligibility is not None:
            json["backupEligibility"] = self.backup_eligibility
        if self.backup_state is not None:
            json["backupState"] = self.backup_state
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> Credential:
        return cls(
            credential_id=str(json["credentialId"]),
            is_resident_credential=bool(json["isResidentCredential"]),
            private_key=str(json["privateKey"]),
            sign_count=int(json["signCount"]),
            rp_id=str(json["rpId"]) if json.get("rpId", None) is not None else None,
            user_handle=(
                str(json["userHandle"])
                if json.get("userHandle", None) is not None
                else None
            ),
            large_blob=(
                str(json["largeBlob"])
                if json.get("largeBlob", None) is not None
                else None
            ),
            backup_eligibility=(
                bool(json["backupEligibility"])
                if json.get("backupEligibility", None) is not None
                else None
            ),
            backup_state=(
                bool(json["backupState"])
                if json.get("backupState", None) is not None
                else None
            ),
        )

backup_eligibility: typing.Optional[bool] = None class-attribute instance-attribute

backup_state: typing.Optional[bool] = None class-attribute instance-attribute

credential_id: str instance-attribute

is_resident_credential: bool instance-attribute

large_blob: typing.Optional[str] = None class-attribute instance-attribute

private_key: str instance-attribute

rp_id: typing.Optional[str] = None class-attribute instance-attribute

sign_count: int instance-attribute

user_handle: typing.Optional[str] = None class-attribute instance-attribute

__init__(credential_id, is_resident_credential, private_key, sign_count, rp_id=None, user_handle=None, large_blob=None, backup_eligibility=None, backup_state=None)

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
@classmethod
def from_json(cls, json: T_JSON_DICT) -> Credential:
    return cls(
        credential_id=str(json["credentialId"]),
        is_resident_credential=bool(json["isResidentCredential"]),
        private_key=str(json["privateKey"]),
        sign_count=int(json["signCount"]),
        rp_id=str(json["rpId"]) if json.get("rpId", None) is not None else None,
        user_handle=(
            str(json["userHandle"])
            if json.get("userHandle", None) is not None
            else None
        ),
        large_blob=(
            str(json["largeBlob"])
            if json.get("largeBlob", None) is not None
            else None
        ),
        backup_eligibility=(
            bool(json["backupEligibility"])
            if json.get("backupEligibility", None) is not None
            else None
        ),
        backup_state=(
            bool(json["backupState"])
            if json.get("backupState", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/web_authn.py 
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["credentialId"] = self.credential_id
    json["isResidentCredential"] = self.is_resident_credential
    json["privateKey"] = self.private_key
    json["signCount"] = self.sign_count
    if self.rp_id is not None:
        json["rpId"] = self.rp_id
    if self.user_handle is not None:
        json["userHandle"] = self.user_handle
    if self.large_blob is not None:
        json["largeBlob"] = self.large_blob
    if self.backup_eligibility is not None:
        json["backupEligibility"] = self.backup_eligibility
    if self.backup_state is not None:
        json["backupState"] = self.backup_state
    return json

CredentialAdded dataclass

Triggered when a credential is added to an authenticator.

Source code in zendriver/cdp/web_authn.py 
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
@event_class("WebAuthn.credentialAdded")
@dataclass
class CredentialAdded:
    """
    Triggered when a credential is added to an authenticator.
    """

    authenticator_id: AuthenticatorId
    credential: Credential

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CredentialAdded:
        return cls(
            authenticator_id=AuthenticatorId.from_json(json["authenticatorId"]),
            credential=Credential.from_json(json["credential"]),
        )

authenticator_id: AuthenticatorId instance-attribute

credential: Credential instance-attribute

__init__(authenticator_id, credential)

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
562
563
564
565
566
567
@classmethod
def from_json(cls, json: T_JSON_DICT) -> CredentialAdded:
    return cls(
        authenticator_id=AuthenticatorId.from_json(json["authenticatorId"]),
        credential=Credential.from_json(json["credential"]),
    )

CredentialAsserted dataclass

Triggered when a credential is used in a webauthn assertion.

Source code in zendriver/cdp/web_authn.py 
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
@event_class("WebAuthn.credentialAsserted")
@dataclass
class CredentialAsserted:
    """
    Triggered when a credential is used in a webauthn assertion.
    """

    authenticator_id: AuthenticatorId
    credential: Credential

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> CredentialAsserted:
        return cls(
            authenticator_id=AuthenticatorId.from_json(json["authenticatorId"]),
            credential=Credential.from_json(json["credential"]),
        )

authenticator_id: AuthenticatorId instance-attribute

credential: Credential instance-attribute

__init__(authenticator_id, credential)

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
580
581
582
583
584
585
@classmethod
def from_json(cls, json: T_JSON_DICT) -> CredentialAsserted:
    return cls(
        authenticator_id=AuthenticatorId.from_json(json["authenticatorId"]),
        credential=Credential.from_json(json["credential"]),
    )

Ctap2Version

Bases: Enum

Source code in zendriver/cdp/web_authn.py 
39
40
41
42
43
44
45
46
47
48
class Ctap2Version(enum.Enum):
    CTAP2_0 = "ctap2_0"
    CTAP2_1 = "ctap2_1"

    def to_json(self) -> str:
        return self.value

    @classmethod
    def from_json(cls, json: str) -> Ctap2Version:
        return cls(json)

CTAP2_0 = 'ctap2_0' class-attribute instance-attribute

CTAP2_1 = 'ctap2_1' class-attribute instance-attribute

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
46
47
48
@classmethod
def from_json(cls, json: str) -> Ctap2Version:
    return cls(json)

to_json()

Source code in zendriver/cdp/web_authn.py 
43
44
def to_json(self) -> str:
    return self.value

VirtualAuthenticatorOptions dataclass

Source code in zendriver/cdp/web_authn.py 
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
@dataclass
class VirtualAuthenticatorOptions:
    protocol: AuthenticatorProtocol

    transport: AuthenticatorTransport

    #: Defaults to ctap2_0. Ignored if ``protocol`` == u2f.
    ctap2_version: typing.Optional[Ctap2Version] = None

    #: Defaults to false.
    has_resident_key: typing.Optional[bool] = None

    #: Defaults to false.
    has_user_verification: typing.Optional[bool] = None

    #: If set to true, the authenticator will support the largeBlob extension.
    #: https://w3c.github.io/webauthn#largeBlob
    #: Defaults to false.
    has_large_blob: typing.Optional[bool] = None

    #: If set to true, the authenticator will support the credBlob extension.
    #: https://fidoalliance.org/specs/fido-v2.1-rd-20201208/fido-client-to-authenticator-protocol-v2.1-rd-20201208.html#sctn-credBlob-extension
    #: Defaults to false.
    has_cred_blob: typing.Optional[bool] = None

    #: If set to true, the authenticator will support the minPinLength extension.
    #: https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html#sctn-minpinlength-extension
    #: Defaults to false.
    has_min_pin_length: typing.Optional[bool] = None

    #: If set to true, the authenticator will support the prf extension.
    #: https://w3c.github.io/webauthn/#prf-extension
    #: Defaults to false.
    has_prf: typing.Optional[bool] = None

    #: If set to true, tests of user presence will succeed immediately.
    #: Otherwise, they will not be resolved. Defaults to true.
    automatic_presence_simulation: typing.Optional[bool] = None

    #: Sets whether User Verification succeeds or fails for an authenticator.
    #: Defaults to false.
    is_user_verified: typing.Optional[bool] = None

    #: Credentials created by this authenticator will have the backup
    #: eligibility (BE) flag set to this value. Defaults to false.
    #: https://w3c.github.io/webauthn/#sctn-credential-backup
    default_backup_eligibility: typing.Optional[bool] = None

    #: Credentials created by this authenticator will have the backup state
    #: (BS) flag set to this value. Defaults to false.
    #: https://w3c.github.io/webauthn/#sctn-credential-backup
    default_backup_state: typing.Optional[bool] = None

    def to_json(self) -> T_JSON_DICT:
        json: T_JSON_DICT = dict()
        json["protocol"] = self.protocol.to_json()
        json["transport"] = self.transport.to_json()
        if self.ctap2_version is not None:
            json["ctap2Version"] = self.ctap2_version.to_json()
        if self.has_resident_key is not None:
            json["hasResidentKey"] = self.has_resident_key
        if self.has_user_verification is not None:
            json["hasUserVerification"] = self.has_user_verification
        if self.has_large_blob is not None:
            json["hasLargeBlob"] = self.has_large_blob
        if self.has_cred_blob is not None:
            json["hasCredBlob"] = self.has_cred_blob
        if self.has_min_pin_length is not None:
            json["hasMinPinLength"] = self.has_min_pin_length
        if self.has_prf is not None:
            json["hasPrf"] = self.has_prf
        if self.automatic_presence_simulation is not None:
            json["automaticPresenceSimulation"] = self.automatic_presence_simulation
        if self.is_user_verified is not None:
            json["isUserVerified"] = self.is_user_verified
        if self.default_backup_eligibility is not None:
            json["defaultBackupEligibility"] = self.default_backup_eligibility
        if self.default_backup_state is not None:
            json["defaultBackupState"] = self.default_backup_state
        return json

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> VirtualAuthenticatorOptions:
        return cls(
            protocol=AuthenticatorProtocol.from_json(json["protocol"]),
            transport=AuthenticatorTransport.from_json(json["transport"]),
            ctap2_version=(
                Ctap2Version.from_json(json["ctap2Version"])
                if json.get("ctap2Version", None) is not None
                else None
            ),
            has_resident_key=(
                bool(json["hasResidentKey"])
                if json.get("hasResidentKey", None) is not None
                else None
            ),
            has_user_verification=(
                bool(json["hasUserVerification"])
                if json.get("hasUserVerification", None) is not None
                else None
            ),
            has_large_blob=(
                bool(json["hasLargeBlob"])
                if json.get("hasLargeBlob", None) is not None
                else None
            ),
            has_cred_blob=(
                bool(json["hasCredBlob"])
                if json.get("hasCredBlob", None) is not None
                else None
            ),
            has_min_pin_length=(
                bool(json["hasMinPinLength"])
                if json.get("hasMinPinLength", None) is not None
                else None
            ),
            has_prf=(
                bool(json["hasPrf"]) if json.get("hasPrf", None) is not None else None
            ),
            automatic_presence_simulation=(
                bool(json["automaticPresenceSimulation"])
                if json.get("automaticPresenceSimulation", None) is not None
                else None
            ),
            is_user_verified=(
                bool(json["isUserVerified"])
                if json.get("isUserVerified", None) is not None
                else None
            ),
            default_backup_eligibility=(
                bool(json["defaultBackupEligibility"])
                if json.get("defaultBackupEligibility", None) is not None
                else None
            ),
            default_backup_state=(
                bool(json["defaultBackupState"])
                if json.get("defaultBackupState", None) is not None
                else None
            ),
        )

automatic_presence_simulation: typing.Optional[bool] = None class-attribute instance-attribute

ctap2_version: typing.Optional[Ctap2Version] = None class-attribute instance-attribute

default_backup_eligibility: typing.Optional[bool] = None class-attribute instance-attribute

default_backup_state: typing.Optional[bool] = None class-attribute instance-attribute

has_cred_blob: typing.Optional[bool] = None class-attribute instance-attribute

has_large_blob: typing.Optional[bool] = None class-attribute instance-attribute

has_min_pin_length: typing.Optional[bool] = None class-attribute instance-attribute

has_prf: typing.Optional[bool] = None class-attribute instance-attribute

has_resident_key: typing.Optional[bool] = None class-attribute instance-attribute

has_user_verification: typing.Optional[bool] = None class-attribute instance-attribute

is_user_verified: typing.Optional[bool] = None class-attribute instance-attribute

protocol: AuthenticatorProtocol instance-attribute

transport: AuthenticatorTransport instance-attribute

__init__(protocol, transport, ctap2_version=None, has_resident_key=None, has_user_verification=None, has_large_blob=None, has_cred_blob=None, has_min_pin_length=None, has_prf=None, automatic_presence_simulation=None, is_user_verified=None, default_backup_eligibility=None, default_backup_state=None)

from_json(json) classmethod

Source code in zendriver/cdp/web_authn.py 
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
@classmethod
def from_json(cls, json: T_JSON_DICT) -> VirtualAuthenticatorOptions:
    return cls(
        protocol=AuthenticatorProtocol.from_json(json["protocol"]),
        transport=AuthenticatorTransport.from_json(json["transport"]),
        ctap2_version=(
            Ctap2Version.from_json(json["ctap2Version"])
            if json.get("ctap2Version", None) is not None
            else None
        ),
        has_resident_key=(
            bool(json["hasResidentKey"])
            if json.get("hasResidentKey", None) is not None
            else None
        ),
        has_user_verification=(
            bool(json["hasUserVerification"])
            if json.get("hasUserVerification", None) is not None
            else None
        ),
        has_large_blob=(
            bool(json["hasLargeBlob"])
            if json.get("hasLargeBlob", None) is not None
            else None
        ),
        has_cred_blob=(
            bool(json["hasCredBlob"])
            if json.get("hasCredBlob", None) is not None
            else None
        ),
        has_min_pin_length=(
            bool(json["hasMinPinLength"])
            if json.get("hasMinPinLength", None) is not None
            else None
        ),
        has_prf=(
            bool(json["hasPrf"]) if json.get("hasPrf", None) is not None else None
        ),
        automatic_presence_simulation=(
            bool(json["automaticPresenceSimulation"])
            if json.get("automaticPresenceSimulation", None) is not None
            else None
        ),
        is_user_verified=(
            bool(json["isUserVerified"])
            if json.get("isUserVerified", None) is not None
            else None
        ),
        default_backup_eligibility=(
            bool(json["defaultBackupEligibility"])
            if json.get("defaultBackupEligibility", None) is not None
            else None
        ),
        default_backup_state=(
            bool(json["defaultBackupState"])
            if json.get("defaultBackupState", None) is not None
            else None
        ),
    )

to_json()

Source code in zendriver/cdp/web_authn.py 
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
def to_json(self) -> T_JSON_DICT:
    json: T_JSON_DICT = dict()
    json["protocol"] = self.protocol.to_json()
    json["transport"] = self.transport.to_json()
    if self.ctap2_version is not None:
        json["ctap2Version"] = self.ctap2_version.to_json()
    if self.has_resident_key is not None:
        json["hasResidentKey"] = self.has_resident_key
    if self.has_user_verification is not None:
        json["hasUserVerification"] = self.has_user_verification
    if self.has_large_blob is not None:
        json["hasLargeBlob"] = self.has_large_blob
    if self.has_cred_blob is not None:
        json["hasCredBlob"] = self.has_cred_blob
    if self.has_min_pin_length is not None:
        json["hasMinPinLength"] = self.has_min_pin_length
    if self.has_prf is not None:
        json["hasPrf"] = self.has_prf
    if self.automatic_presence_simulation is not None:
        json["automaticPresenceSimulation"] = self.automatic_presence_simulation
    if self.is_user_verified is not None:
        json["isUserVerified"] = self.is_user_verified
    if self.default_backup_eligibility is not None:
        json["defaultBackupEligibility"] = self.default_backup_eligibility
    if self.default_backup_state is not None:
        json["defaultBackupState"] = self.default_backup_state
    return json

add_credential(authenticator_id, credential)

Adds the credential to the specified authenticator.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
credential Credential
required
Source code in zendriver/cdp/web_authn.py 
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
def add_credential(
    authenticator_id: AuthenticatorId, credential: Credential
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Adds the credential to the specified authenticator.

    :param authenticator_id:
    :param credential:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    params["credential"] = credential.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.addCredential",
        "params": params,
    }
    json = yield cmd_dict

add_virtual_authenticator(options)

Creates and adds a virtual authenticator.

Parameters:

Name Type Description Default
options VirtualAuthenticatorOptions
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, AuthenticatorId]
Source code in zendriver/cdp/web_authn.py 
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
def add_virtual_authenticator(
    options: VirtualAuthenticatorOptions,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, AuthenticatorId]:
    """
    Creates and adds a virtual authenticator.

    :param options:
    :returns:
    """
    params: T_JSON_DICT = dict()
    params["options"] = options.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.addVirtualAuthenticator",
        "params": params,
    }
    json = yield cmd_dict
    return AuthenticatorId.from_json(json["authenticatorId"])

clear_credentials(authenticator_id)

Clears all the credentials from the specified device.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
Source code in zendriver/cdp/web_authn.py 
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
def clear_credentials(
    authenticator_id: AuthenticatorId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Clears all the credentials from the specified device.

    :param authenticator_id:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.clearCredentials",
        "params": params,
    }
    json = yield cmd_dict

disable()

Disable the WebAuthn domain.

Source code in zendriver/cdp/web_authn.py 
312
313
314
315
316
317
318
319
def disable() -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Disable the WebAuthn domain.
    """
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.disable",
    }
    json = yield cmd_dict

enable(enable_ui=None)

Enable the WebAuthn domain and start intercepting credential storage and retrieval with a virtual authenticator.

Parameters:

Name Type Description Default
enable_ui Optional[bool]

(Optional) Whether to enable the WebAuthn user interface. Enabling the UI is recommended for debugging and demo purposes, as it is closer to the real experience. Disabling the UI is recommended for automated testing. Supported at the embedder's discretion if UI is available. Defaults to false.

 None
Source code in zendriver/cdp/web_authn.py 
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
def enable(
    enable_ui: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Enable the WebAuthn domain and start intercepting credential storage and
    retrieval with a virtual authenticator.

    :param enable_ui: *(Optional)* Whether to enable the WebAuthn user interface. Enabling the UI is recommended for debugging and demo purposes, as it is closer to the real experience. Disabling the UI is recommended for automated testing. Supported at the embedder's discretion if UI is available. Defaults to false.
    """
    params: T_JSON_DICT = dict()
    if enable_ui is not None:
        params["enableUI"] = enable_ui
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.enable",
        "params": params,
    }
    json = yield cmd_dict

get_credential(authenticator_id, credential_id)

Returns a single credential stored in the given virtual authenticator that matches the credential ID.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
credential_id str
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, Credential]
Source code in zendriver/cdp/web_authn.py 
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
def get_credential(
    authenticator_id: AuthenticatorId, credential_id: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, Credential]:
    """
    Returns a single credential stored in the given virtual authenticator that
    matches the credential ID.

    :param authenticator_id:
    :param credential_id:
    :returns:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    params["credentialId"] = credential_id
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.getCredential",
        "params": params,
    }
    json = yield cmd_dict
    return Credential.from_json(json["credential"])

get_credentials(authenticator_id)

Returns all the credentials stored in the given virtual authenticator.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required

Returns:

Type Description
Generator[T_JSON_DICT, T_JSON_DICT, List[Credential]]
Source code in zendriver/cdp/web_authn.py 
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
def get_credentials(
    authenticator_id: AuthenticatorId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, typing.List[Credential]]:
    """
    Returns all the credentials stored in the given virtual authenticator.

    :param authenticator_id:
    :returns:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.getCredentials",
        "params": params,
    }
    json = yield cmd_dict
    return [Credential.from_json(i) for i in json["credentials"]]

remove_credential(authenticator_id, credential_id)

Removes a credential from the authenticator.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
credential_id str
required
Source code in zendriver/cdp/web_authn.py 
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
def remove_credential(
    authenticator_id: AuthenticatorId, credential_id: str
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes a credential from the authenticator.

    :param authenticator_id:
    :param credential_id:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    params["credentialId"] = credential_id
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.removeCredential",
        "params": params,
    }
    json = yield cmd_dict

remove_virtual_authenticator(authenticator_id)

Removes the given authenticator.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
Source code in zendriver/cdp/web_authn.py 
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
def remove_virtual_authenticator(
    authenticator_id: AuthenticatorId,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Removes the given authenticator.

    :param authenticator_id:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.removeVirtualAuthenticator",
        "params": params,
    }
    json = yield cmd_dict

set_automatic_presence_simulation(authenticator_id, enabled)

Sets whether tests of user presence will succeed immediately (if true) or fail to resolve (if false) for an authenticator. The default is true.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
enabled bool
required
Source code in zendriver/cdp/web_authn.py 
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
def set_automatic_presence_simulation(
    authenticator_id: AuthenticatorId, enabled: bool
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets whether tests of user presence will succeed immediately (if true) or fail to resolve (if false) for an authenticator.
    The default is true.

    :param authenticator_id:
    :param enabled:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    params["enabled"] = enabled
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.setAutomaticPresenceSimulation",
        "params": params,
    }
    json = yield cmd_dict

set_credential_properties(authenticator_id, credential_id, backup_eligibility=None, backup_state=None)

Allows setting credential properties. https://w3c.github.io/webauthn/#sctn-automation-set-credential-properties

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
credential_id str
required
backup_eligibility Optional[bool]

(Optional)

 None
backup_state Optional[bool]

(Optional)

 None
Source code in zendriver/cdp/web_authn.py 
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
def set_credential_properties(
    authenticator_id: AuthenticatorId,
    credential_id: str,
    backup_eligibility: typing.Optional[bool] = None,
    backup_state: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Allows setting credential properties.
    https://w3c.github.io/webauthn/#sctn-automation-set-credential-properties

    :param authenticator_id:
    :param credential_id:
    :param backup_eligibility: *(Optional)*
    :param backup_state: *(Optional)*
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    params["credentialId"] = credential_id
    if backup_eligibility is not None:
        params["backupEligibility"] = backup_eligibility
    if backup_state is not None:
        params["backupState"] = backup_state
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.setCredentialProperties",
        "params": params,
    }
    json = yield cmd_dict

set_response_override_bits(authenticator_id, is_bogus_signature=None, is_bad_uv=None, is_bad_up=None)

Resets parameters isBogusSignature, isBadUV, isBadUP to false if they are not present.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
is_bogus_signature Optional[bool]

(Optional) If isBogusSignature is set, overrides the signature in the authenticator response to be zero. Defaults to false.

 None
is_bad_uv Optional[bool]

(Optional) If isBadUV is set, overrides the UV bit in the flags in the authenticator response to be zero. Defaults to false.

 None
is_bad_up Optional[bool]

(Optional) If isBadUP is set, overrides the UP bit in the flags in the authenticator response to be zero. Defaults to false.

 None
Source code in zendriver/cdp/web_authn.py 
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
def set_response_override_bits(
    authenticator_id: AuthenticatorId,
    is_bogus_signature: typing.Optional[bool] = None,
    is_bad_uv: typing.Optional[bool] = None,
    is_bad_up: typing.Optional[bool] = None,
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Resets parameters isBogusSignature, isBadUV, isBadUP to false if they are not present.

    :param authenticator_id:
    :param is_bogus_signature: *(Optional)* If isBogusSignature is set, overrides the signature in the authenticator response to be zero. Defaults to false.
    :param is_bad_uv: *(Optional)* If isBadUV is set, overrides the UV bit in the flags in the authenticator response to be zero. Defaults to false.
    :param is_bad_up: *(Optional)* If isBadUP is set, overrides the UP bit in the flags in the authenticator response to be zero. Defaults to false.
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    if is_bogus_signature is not None:
        params["isBogusSignature"] = is_bogus_signature
    if is_bad_uv is not None:
        params["isBadUV"] = is_bad_uv
    if is_bad_up is not None:
        params["isBadUP"] = is_bad_up
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.setResponseOverrideBits",
        "params": params,
    }
    json = yield cmd_dict

set_user_verified(authenticator_id, is_user_verified)

Sets whether User Verification succeeds or fails for an authenticator. The default is true.

Parameters:

Name Type Description Default
authenticator_id AuthenticatorId
required
is_user_verified bool
required
Source code in zendriver/cdp/web_authn.py 
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
def set_user_verified(
    authenticator_id: AuthenticatorId, is_user_verified: bool
) -> typing.Generator[T_JSON_DICT, T_JSON_DICT, None]:
    """
    Sets whether User Verification succeeds or fails for an authenticator.
    The default is true.

    :param authenticator_id:
    :param is_user_verified:
    """
    params: T_JSON_DICT = dict()
    params["authenticatorId"] = authenticator_id.to_json()
    params["isUserVerified"] = is_user_verified
    cmd_dict: T_JSON_DICT = {
        "method": "WebAuthn.setUserVerified",
        "params": params,
    }
    json = yield cmd_dict