Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- This WPT test may be referenced by the following Test IDs:
- /webauthn/public-key-credential-to-json.https.window.html - WPT Dashboard Interop Dashboard
// META: script=/resources/testdriver.js
// META: script=/resources/testdriver-vendor.js
// META: script=/resources/utils.js
// META: script=helpers.js
function assertObjectKeysEq(a, b) {
let a_keys = new Set(Object.keys(a));
let b_keys = new Set(Object.keys(b));
assert_true(
a_keys.length == b_keys.length && [...a_keys].every(k => b_keys.has(k)),
`keys differ: ${a_keys} != ${b_keys}`);
}
// Returns the JSON encoding for `value`. If `value` is a function, `optParent`
// is the object to which execution should be bound.
function convertValue(value, optParent) {
switch (typeof value) {
case 'undefined':
case 'boolean':
case 'number':
case 'bigint':
case 'string':
case 'symbol':
return value;
case 'function':
return value.apply(optParent);
case 'object':
if (value.__proto__.constructor === Object) {
var result = {};
Object.entries(value).map((k, v) => {
result[k] = convertValue(k, v);
});
return result;
}
if (value instanceof Array) {
return value.map(convertValue);
}
if (value instanceof ArrayBuffer) {
return base64urlEncode(new Uint8Array(value));
}
throw `can't convert value ${value} in ${parent}`;
default:
throw `${value} has unexpected type`;
}
}
// Conversion spec for a single attribute.
// @typedef {Object} ConvertParam
// @property {string} name - The name of the attribute to convert from
// @property {string=} target - The name of the attribute to convert to, if
// different from `name`
// @property {function=} func - Method to convert this property. Defaults to
// convertValue().
// Returns the JSON object for `obj`.
//
// @param obj
// @param {Array<(string|ConvertParam)>} keys - The names of parameters in
// `obj` to convert, or instances of ConvertParam for complex cases.
function convertObject(obj, params) {
let result = {};
params.forEach((param) => {
switch (typeof (param)) {
case 'string':
assert_true(param in obj, `missing ${param}`);
if (obj[param] !== null) {
result[param] = convertValue(obj[param], obj);
}
break;
case 'object':
assert_true(param.name in obj, `missing ${param.name}`);
const val = obj[param.name];
const target_key = param.target || param.name;
const convert_func = param.func || convertValue;
try {
result[target_key] =
convert_func(((typeof val) == 'function' ? val.apply(obj) : val));
} catch (e) {
throw `failed to convert ${param.name}: ${e}`
}
break;
default:
throw `invalid key ${param}`;
}
});
return result;
}
// Converts an AuthenticatorResponse instance into a JSON object.
// @param {!AuthenticatorResponse}
function authenticatorResponseToJson(response) {
assert_true(
(response instanceof AuthenticatorAttestationResponse) ||
(response instanceof AuthenticatorAssertionResponse));
const isAttestation = (response instanceof AuthenticatorAttestationResponse);
const keys =
(isAttestation ?
[
'clientDataJSON', 'attestationObject',
{name: 'getAuthenticatorData', target: 'authenticatorData'},
{name: 'getPublicKey', target: 'publicKey'},
{name: 'getPublicKeyAlgorithm', target: 'publicKeyAlgorithm'},
{name: 'getTransports', target: 'transports'}
] :
['clientDataJSON', 'authenticatorData', 'signature', 'userHandle']);
return convertObject(response, keys);
}
// Converts a PublicKeyCredential instance to a JSON object.
// @param {!PublicKeyCredential}
function publicKeyCredentialToJson(cred) {
const keys = [
'id', 'rawId', {name: 'response', func: authenticatorResponseToJson},
'authenticatorAttachment',
{name: 'getClientExtensionResults', target: 'clientExtensionResults'},
'type'
];
return convertObject(cred, keys);
}
virtualAuthenticatorPromiseTest(
async t => {
let credential = await createCredential();
assertJsonEquals(
credential.toJSON(), publicKeyCredentialToJson(credential));
let assertion = await assertCredential(credential);
assertJsonEquals(
assertion.toJSON(), publicKeyCredentialToJson(assertion));
},
{
protocol: 'ctap2_1',
transport: 'usb',
},
'toJSON()');