Don't let AES-KW to wrap/unwrap JWK #6102

alanwaketan · 2017-05-30T22:10:29Z

No description provided.

jimsch · 2017-05-31T01:24:31Z

Yes, it appears that this requirement was lost in the spec at some point. It is currently open as w3c/crypto#187. In the event that the document is changed then this should be fixed.

jimsch

This is an error that was lost in the document. Orignally everything was returned that way.

w3c-bots · 2017-05-31T07:38:18Z

*This report has been truncated because the total content is 129172 characters in length, which is in excess of GitHub.com's limit for comments (65536 characters).

View the complete job log.

Firefox (nightly)

Testing web-platform-tests at revision ecb20b2
Using browser at version BuildID 20170530100155; SourceStamp 286f71223256cbb3a769432fd860f563c4886e81
Starting 10 test iterations

Unstable results

Test	Subtest	Results	Messages
`/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html`	`Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-KW`	PASS: 1/10, MISSING: 9/10
`/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html`	`Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-KW`	PASS: 1/10, MISSING: 9/10

All results

2 tests ran

/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html

Subtest	Results	Messages
	OK
`Can wrap and unwrap RSA-PSS public key keys using spki and AES-CTR`	PASS
`Can wrap and unwrap RSA-PSS public key keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-CTR`	PASS
`Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-CTR`	PASS
`Can wrap and unwrap RSA-PSS private key keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSA-PSS private key keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap RSA-PSS private key non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using spki and AES-CTR`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys using pkcs8 and AES-CTR`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys as non-extractable using pkcs8 and AES-CTR`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap RSASSA-PKCS1-v1_5 private key non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-CTR keys using raw and AES-CTR`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using raw and AES-CTR`	PASS
`Can wrap and unwrap AES-CTR keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap AES-CTR non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-CBC keys using raw and AES-CTR`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-CTR`	PASS
`Can wrap and unwrap AES-CBC keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap AES-CBC non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-GCM keys using raw and AES-CTR`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using raw and AES-CTR`	PASS
`Can wrap and unwrap AES-GCM keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap AES-GCM non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap AES-KW keys using raw and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using raw and AES-CTR`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap AES-KW non-extractable keys using jwk and AES-CTR`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap HMAC keys using raw and AES-CTR`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using raw and AES-CTR`	PASS
`Can wrap and unwrap HMAC keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap HMAC non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using spki and AES-CTR`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSA-OAEP private key keys using pkcs8 and AES-CTR`	PASS
`Can wrap and unwrap RSA-OAEP private key keys as non-extractable using pkcs8 and AES-CTR`	PASS
`Can wrap and unwrap RSA-OAEP private key keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap RSA-OAEP private key keys as non-extractable using jwk and AES-CTR`	PASS
`Can unwrap RSA-OAEP private key non-extractable keys using jwk and AES-CTR`	PASS
`Can wrap and unwrap ECDSA public key keys using spki and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA public key keys using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Could not run all tests`	FAIL	`assert_unreached: A test failed to run: NotSupportedError: Operation is not supported Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys as non-extractable using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap ECDSA private key non-extractable keys using jwk and AES-CTR`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap ECDH public key keys using spki and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH public key keys using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH private key keys using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH private key keys as non-extractable using jwk and AES-CTR`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap ECDH private key non-extractable keys using jwk and AES-CTR`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap AES-CTR keys using raw and AES-KW`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using raw and AES-KW`	PASS
`Can wrap and unwrap AES-CBC keys using raw and AES-KW`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-KW`	PASS
`Can wrap and unwrap AES-GCM keys using raw and AES-KW`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using raw and AES-KW`	PASS
`Can wrap and unwrap AES-KW keys using raw and AES-KW`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using raw and AES-KW`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap HMAC keys using raw and AES-KW`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using raw and AES-KW`	PASS
`Can wrap and unwrap ECDSA public key keys using spki and AES-KW`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH public key keys using spki and AES-KW`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap RSA-PSS public key keys using spki and RSA-OAEP`	PASS
`Can wrap and unwrap RSA-PSS public key keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using spki and RSA-OAEP`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CTR keys using raw and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using raw and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CTR keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using jwk and RSA-OAEP`	PASS
`Can unwrap AES-CTR non-extractable keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CBC keys using raw and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using raw and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CBC keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using jwk and RSA-OAEP`	PASS
`Can unwrap AES-CBC non-extractable keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-GCM keys using raw and RSA-OAEP`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using raw and RSA-OAEP`	PASS
`Can wrap and unwrap AES-GCM keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using jwk and RSA-OAEP`	PASS
`Can unwrap AES-GCM non-extractable keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap AES-KW keys using raw and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using raw and RSA-OAEP`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap AES-KW non-extractable keys using jwk and RSA-OAEP`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap HMAC keys using raw and RSA-OAEP`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using raw and RSA-OAEP`	PASS
`Can wrap and unwrap HMAC keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using jwk and RSA-OAEP`	PASS
`Can unwrap HMAC non-extractable keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using spki and RSA-OAEP`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using jwk and RSA-OAEP`	PASS
`Can wrap and unwrap ECDSA public key keys using spki and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA public key keys using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys as non-extractable using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap ECDSA private key non-extractable keys using jwk and RSA-OAEP`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap ECDH public key keys using spki and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH public key keys using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH private key keys using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH private key keys as non-extractable using jwk and RSA-OAEP`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap ECDH private key non-extractable keys using jwk and RSA-OAEP`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap RSA-PSS public key keys using spki and AES-GCM`	PASS
`Can wrap and unwrap RSA-PSS public key keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-GCM`	PASS
`Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-GCM`	PASS
`Can wrap and unwrap RSA-PSS private key keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSA-PSS private key keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap RSA-PSS private key non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using spki and AES-GCM`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys using pkcs8 and AES-GCM`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys as non-extractable using pkcs8 and AES-GCM`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap RSASSA-PKCS1-v1_5 private key non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-CTR keys using raw and AES-GCM`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using raw and AES-GCM`	PASS
`Can wrap and unwrap AES-CTR keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap AES-CTR non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-CBC keys using raw and AES-GCM`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-GCM`	PASS
`Can wrap and unwrap AES-CBC keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap AES-CBC non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-GCM keys using raw and AES-GCM`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using raw and AES-GCM`	PASS
`Can wrap and unwrap AES-GCM keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap AES-GCM non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap AES-KW keys using raw and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using raw and AES-GCM`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap AES-KW non-extractable keys using jwk and AES-GCM`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap HMAC keys using raw and AES-GCM`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using raw and AES-GCM`	PASS
`Can wrap and unwrap HMAC keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap HMAC non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using spki and AES-GCM`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSA-OAEP private key keys using pkcs8 and AES-GCM`	PASS
`Can wrap and unwrap RSA-OAEP private key keys as non-extractable using pkcs8 and AES-GCM`	PASS
`Can wrap and unwrap RSA-OAEP private key keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap RSA-OAEP private key keys as non-extractable using jwk and AES-GCM`	PASS
`Can unwrap RSA-OAEP private key non-extractable keys using jwk and AES-GCM`	PASS
`Can wrap and unwrap ECDSA public key keys using spki and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA public key keys using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys as non-extractable using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap ECDSA private key non-extractable keys using jwk and AES-GCM`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap ECDH public key keys using spki and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH public key keys using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH private key keys using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDH private key keys as non-extractable using jwk and AES-GCM`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap ECDH private key non-extractable keys using jwk and AES-GCM`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap RSA-PSS public key keys using spki and AES-CBC`	PASS
`Can wrap and unwrap RSA-PSS public key keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-CBC`	PASS
`Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-CBC`	PASS
`Can wrap and unwrap RSA-PSS private key keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSA-PSS private key keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap RSA-PSS private key non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using spki and AES-CBC`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 public key keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys using pkcs8 and AES-CBC`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys as non-extractable using pkcs8 and AES-CBC`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSASSA-PKCS1-v1_5 private key keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap RSASSA-PKCS1-v1_5 private key non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-CTR keys using raw and AES-CBC`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using raw and AES-CBC`	PASS
`Can wrap and unwrap AES-CTR keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-CTR keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap AES-CTR non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-CBC keys using raw and AES-CBC`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using raw and AES-CBC`	PASS
`Can wrap and unwrap AES-CBC keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-CBC keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap AES-CBC non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-GCM keys using raw and AES-CBC`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using raw and AES-CBC`	PASS
`Can wrap and unwrap AES-GCM keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-GCM keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap AES-GCM non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap AES-KW keys using raw and AES-CBC`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using raw and AES-CBC`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys using jwk and AES-CBC`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap AES-KW keys as non-extractable using jwk and AES-CBC`	FAIL	`assert_unreached: Round trip for key unwrapped non-extractable threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can unwrap AES-KW non-extractable keys using jwk and AES-CBC`	FAIL	`assert_equals: Unwrapping a non-extractable JWK as extractable fails with DataError expected "DataError" but got "Error"`
`Can wrap and unwrap HMAC keys using raw and AES-CBC`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using raw and AES-CBC`	PASS
`Can wrap and unwrap HMAC keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap HMAC keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap HMAC non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using spki and AES-CBC`	PASS
`Can wrap and unwrap RSA-OAEP public key keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSA-OAEP private key keys using pkcs8 and AES-CBC`	PASS
`Can wrap and unwrap RSA-OAEP private key keys as non-extractable using pkcs8 and AES-CBC`	PASS
`Can wrap and unwrap RSA-OAEP private key keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap RSA-OAEP private key keys as non-extractable using jwk and AES-CBC`	PASS
`Can unwrap RSA-OAEP private key non-extractable keys using jwk and AES-CBC`	PASS
`Can wrap and unwrap ECDSA public key keys using spki and AES-CBC`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA public key keys using jwk and AES-CBC`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys using jwk and AES-CBC`	FAIL	`assert_unreached: Round trip for extractable key threw an error - NotSupportedError: "Operation is not supported" Reached unreachable code`
`Can wrap and unwrap ECDSA private key keys as n

w3c-bots · 2017-05-31T07:38:19Z

View the complete job log.

Sauce (safari)

Testing web-platform-tests at revision ecb20b2
Using browser at version 10.0
Starting 10 test iterations
All results were stable

All results

2 tests ran

/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html

Subtest	Results	Messages
	OK
`WebCryptoAPI: wrapKey() and unwrapKey()`	FAIL	`TypeError: undefined is not an object (evaluating 'subtle.generateKey')`

/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.worker.html

Subtest	Results	Messages
	OK
`Untitled`	FAIL	`TypeError: undefined is not an object (evaluating 'self.crypto.subtle')`

w3c-bots · 2017-05-31T07:38:20Z

View the complete job log.

Chrome (unstable)

Testing web-platform-tests at revision ecb20b2

w3c-bots · 2017-05-31T07:38:20Z

View the complete job log.

Sauce (MicrosoftEdge)

Testing web-platform-tests at revision ecb20b2
Using browser at version 14.14393
Starting 10 test iterations

alanwaketan · 2017-06-01T03:53:31Z

Thanks @jimsch for approving my PR. I am quite confused of what the check fail is. Do you know how should I proceed and fix that? Sorry for troubling you with this as this is my first PR to web-platform-tests.

jimsch · 2017-06-01T04:22:50Z

You need to find out what failed in the firefox build. It may be that it always failed in the past but it could also be your changes.

alanwaketan · 2017-06-01T05:09:58Z

Firefox fails as usual. Is that enough to merge this PR?

sideshowbarker · 2017-06-30T06:04:07Z

What is this waiting on?

jimsch · 2017-06-30T06:36:08Z

@sideshowbarker I am unsure of what the correct procedure should be for this. It is still failing a test, but it is claimed that this is what it does before the changes. Given my position as that of an interested bystander who does not do anything at all with browsers, it is not clear to me that I really should be the one to merge such a change into the test suite.

zcorpan · 2018-10-01T12:19:53Z

@alanwaketan can you rebase this to rerun the bots?

foolip · 2019-12-03T10:58:11Z

@alanwaketan if you rebase this and it then passes all the CI, I can merge it. Or you can, I've added you to the reviewers team so you have write access. Please see https://github.com/orgs/web-platform-tests/teams/reviewers/discussions for things you may have to do to avoid excessive GitHub email.

stephenmcgruer · 2020-01-14T16:00:35Z

I rebased this in #21149 to see what would happen.

Safari overall improves in % of tests passed (https://wpt.fyi/results/WebCryptoAPI/wrapKey_unwrapKey?diff&filter=ADC&run_id=389460003&run_id=406580004), but there are three tests in test_wrapKey_unwrapKey.https.html that go from PASS -> FAIL.

There are no (easily extractable) Chrome/Firefox results because it fails the stability checks on both:

Chrome:

 0:59.42 INFO ## Unstable results ##
 0:59.42 INFO |                                  Test                                 |                                         Subtest                                          |            Results            | Messages |
 0:59.42 INFO |-----------------------------------------------------------------------|------------------------------------------------------------------------------------------|-------------------------------|----------|
 0:59.42 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.worker.html` | `Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-KW`                    | **PASS: 1/10, MISSING: 9/10** |          |
 0:59.42 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.worker.html` | `Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-KW` | **PASS: 1/10, MISSING: 9/10** |          |
 0:59.42 INFO

Firefox:

11:33.69 INFO ## Unstable results ##
11:33.69 INFO |                                  Test                                 |                                         Subtest                                          |            Results            | Messages |
11:33.69 INFO |-----------------------------------------------------------------------|------------------------------------------------------------------------------------------|-------------------------------|----------|
11:33.69 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.worker.html` | `Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-KW`                    | **PASS: 1/10, MISSING: 9/10** |          |
11:33.69 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.worker.html` | `Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-KW` | **PASS: 1/10, MISSING: 9/10** |          |
11:33.69 INFO

I don't know if those are pre-existing flakes or not.

stephenmcgruer · 2020-01-14T17:34:01Z

From #21149, @jimsch said:

As I read the spec now, it appears that there is a way to get bytes from the JWK in the specification. I think therefore that this is probably a dead change and should be closed.

@alanwaketan if you disagree, please feel free to re-open this PR to discuss :)

sideshowbarker · 2020-01-22T01:26:51Z

Reopening per #6102 (comment)

alanwaketan · 2020-01-22T01:44:37Z

Also, from the spec:
"The key wrapping operations for some algorithms place constraints on the payload size. For example AES-KW requires the payload to be a multiple of 8 bytes in length and RSA-OAEP places a restriction on the length. For key formats that offer flexibility in serialization of a given key (for example JWK), implementations may choose to adapt the serialization to the constraints of the wrapping algorithm. This is why JSON.stringify is not normatively required, as otherwise it would prohibit implementations from introducing added padding."

For implementations that don't want to add padding to address the constraints of AES-KW. The operations may well fail. Therefore, excluding AES-KW in the test seems better.

jimsch · 2020-01-22T01:48:32Z

I would agree that there is no guaranteed order of how the fields of a JWK are serialized. I don't understand why you believe that this matters. The output from the encryption process is hopefully going to be different in most cases for symmetric keys because of different IVs. It is going to be different for an RSA key because of the random bytes that are put into the padding.

alanwaketan · 2020-01-22T01:53:47Z

@jimsch Sorry for leaving misleading comments. See my last comment, that's my reason to not include AES-KW in the wrapping/unwrapping tests.

jimsch · 2020-01-22T02:16:54Z

But the test already has a check for the case of the exported key not being a multiple of 8 already.

alanwaketan · 2020-01-22T22:44:30Z

But the test already has a check for the case of the exported key not being a multiple of 8 already.

I believe that check is for other binary output formats. Also, JWK doesn't have the field "byteLength".

jimsch · 2020-01-22T23:14:20Z

so, instead adding a check for "JSON.stringify(exportedKey).length % 8 == 0" would be the same. The only issue would be if stringify is not used.

alanwaketan · 2020-01-22T23:28:02Z

so, instead adding a check for "JSON.stringify(exportedKey).length % 8 == 0" would be the same. The only issue would be if stringify is not used.

I'm fine with that as WebKit uses stringify.

jimsch · 2020-01-22T23:40:03Z

Go ahead and mke the change and I will approve that.

…le of 8

jimsch · 2020-01-23T05:02:59Z

@sideshowbarker - I don't know how to check if the failures are because of this change. The only thing that should have changed is that a set of tests are no longer run. The specification allows for the removed tests to be successful if a custom JSON to string function is used, but I do not know of any way to check this.

sideshowbarker · 2020-01-23T06:24:31Z

@sideshowbarker - I don't know how to check if the failures are because of this change

I'll check and then post a comment after I've looked into it

sideshowbarker · 2020-01-23T07:11:53Z

OK, looking at the Taskcluster log, it seems there’s an actual problem in the test that was touched in this change (rather than, say, some unrelated failures elsewhere). Specifically, I see the failure seems to be due to a test that has accurately been identified as flaky — with both Firefox and Chrome:

https://community-tc.services.mozilla.com/tasks/IAKREmxISs-1xPaQHbU6BA/runs/0/logs/https%3A%2F%2Fcommunity-tc.services.mozilla.com%2Fapi%2Fqueue%2Fv1%2Ftask%2FIAKREmxISs-1xPaQHbU6BA%2Fruns%2F0%2Fartifacts%2Fpublic%2Flogs%2Flive.log#1121

Chrome

 0:57.42 INFO ## Unstable results ##
 0:57.42 INFO |                                 Test                                |                                          Subtest                                          |            Results            | Messages |
 0:57.42 INFO |---------------------------------------------------------------------|-------------------------------------------------------------------------------------------|-------------------------------|----------|
 0:57.42 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html` | `Can wrap and unwrap RSA-OAEP private key keys using pkcs8 and AES-KW`                    | **PASS: 1/10, MISSING: 9/10** |          |
 0:57.42 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html` | `Can wrap and unwrap RSA-OAEP private key keys as non-extractable using pkcs8 and AES-KW` | **PASS: 1/10, MISSING: 9/10** |          |
 0:57.42 INFO 
 0:57.42 INFO ::: Running tests in a loop 10 times : FAIL
 0:57.42 INFO :::
 0:57.42 ERROR ::: Test verification FAIL

Chrome

https://community-tc.services.mozilla.com/tasks/J9j5RWrJSritXyEQVV7hWA/runs/0/logs/https%3A%2F%2Fcommunity-tc.services.mozilla.com%2Fapi%2Fqueue%2Fv1%2Ftask%2FJ9j5RWrJSritXyEQVV7hWA%2Fruns%2F0%2Fartifacts%2Fpublic%2Flogs%2Flive.log#L122816### Firefox

11:40.93 INFO ## Unstable results ##
11:40.93 INFO |                                  Test                                 |                                          Subtest                                          |            Results            | Messages |
11:40.93 INFO |-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------|-------------------------------|----------|
11:40.93 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html`   | `Can wrap and unwrap RSA-PSS private key keys using pkcs8 and AES-KW`                     | **PASS: 1/10, MISSING: 9/10** |          |
11:40.93 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/test_wrapKey_unwrapKey.https.html`   | `Can wrap and unwrap RSA-PSS private key keys as non-extractable using pkcs8 and AES-KW`  | **PASS: 1/10, MISSING: 9/10** |          |
11:40.93 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.worker.html` | `Can wrap and unwrap RSA-OAEP private key keys using pkcs8 and AES-KW`                    | **PASS: 1/10, MISSING: 9/10** |          |
11:40.93 INFO | `/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.https.worker.html` | `Can wrap and unwrap RSA-OAEP private key keys as non-extractable using pkcs8 and AES-KW` | **PASS: 1/10, MISSING: 9/10** |          |
11:40.93 INFO 
11:40.93 INFO ::: Running tests in a loop 10 times : FAIL
11:40.93 INFO :::
11:40.93 ERROR ::: Test verification FAIL

Now, I don’t know whether that test was already flaky before the change in this PR — but, regardless, I think the flakiness needs to be investigated and resolved before this can be merged.

sideshowbarker · 2020-01-23T07:18:49Z

The only thing that should have changed is that a set of tests are no longer run.

When I look at the actual patch, I see what was added is this:

wpt/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.js

Lines 249 to 251 in 7306f19

    
           if ("kty" in exportedKey && algorithmName === "AES-KW") { 
        
               return JSON.stringify(exportedKey).length % 8 == 0; 
        
           }

…so when you say, “The only thing that should have changed is that a set of tests are no longer run”, I guess you mean that change adds an early return that has the effect of causing some tests to be run that would be run otherwise if that early return weren’t there?

sideshowbarker · 2020-01-23T07:24:32Z

Now, I don’t know whether that test was already flaky before the change in this PR — but, regardless, I think the flakiness needs to be investigated and resolved before this can be merged.

I’ve zero specific domain knowledge about the underlying functionality here, but looking at this:

wpt/WebCryptoAPI/wrapKey_unwrapKey/wrapKey_unwrapKey.js

Lines 249 to 251 in 7306f19

    
           if ("kty" in exportedKey && algorithmName === "AES-KW") { 
        
               return JSON.stringify(exportedKey).length % 8 == 0; 
        
           }

…it doesn’t at all look to me at least that part would be a potential cause for flakiness, so I suspect the test was already flaky prior to the change in this PR…

alanwaketan · 2020-01-24T00:25:37Z

…it doesn’t at all look to me at least that part would be a potential cause for flakiness, so I suspect the test was already flaky prior to the change in this PR…

The test is flaky without my change. I thought my change will improve its stability. Anyway, I think we should land my change and not wait another 3 years. Then if we have time, we should make another attempt to improve the test.

sideshowbarker · 2020-01-24T03:36:52Z

OK, merging per #6102 (comment)

alanwaketan · 2020-01-24T06:22:13Z

Thank you all! @jimsch @sideshowbarker

wpt-pr-bot added WebCryptoAPI wg-webcrypto labels May 30, 2017

wpt-pr-bot requested review from engelke, jimsch and wafflespeanut May 30, 2017 22:10

jimsch approved these changes May 31, 2017

View reviewed changes

sideshowbarker added the stale:awaiting-submitter-response label Jun 30, 2017

wpt-pr-bot removed the request for review from engelke October 1, 2018 12:20

stephenmcgruer mentioned this pull request Jan 14, 2020

Don't let AES-KW to wrap/unwrap JWK #21149

Closed

stephenmcgruer closed this Jan 14, 2020

sideshowbarker reopened this Jan 22, 2020

Don't let AES-KW to wrap/unwrap JWK whose stringified is not a multip…

7306f19

…le of 8

alanwaketan force-pushed the WebCryptoAPI_wrapKey_unwrapKey branch from 2c7cc34 to 7306f19 Compare January 23, 2020 02:12

wpt-pr-bot assigned jimsch Jan 23, 2020

sideshowbarker added the flaky label Jan 23, 2020

sideshowbarker merged commit fbc8a58 into web-platform-tests:master Jan 24, 2020

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Don't let AES-KW to wrap/unwrap JWK #6102

Don't let AES-KW to wrap/unwrap JWK #6102

alanwaketan commented May 30, 2017 •

edited by wpt-pr-bot

Loading

jimsch commented May 31, 2017

jimsch left a comment

w3c-bots commented May 31, 2017

w3c-bots commented May 31, 2017

w3c-bots commented May 31, 2017

w3c-bots commented May 31, 2017

alanwaketan commented Jun 1, 2017

jimsch commented Jun 1, 2017

alanwaketan commented Jun 1, 2017

sideshowbarker commented Jun 30, 2017

jimsch commented Jun 30, 2017

zcorpan commented Oct 1, 2018

foolip commented Dec 3, 2019

stephenmcgruer commented Jan 14, 2020

stephenmcgruer commented Jan 14, 2020

sideshowbarker commented Jan 22, 2020

alanwaketan commented Jan 22, 2020

jimsch commented Jan 22, 2020

alanwaketan commented Jan 22, 2020 •

edited

Loading

jimsch commented Jan 22, 2020

alanwaketan commented Jan 22, 2020

jimsch commented Jan 22, 2020

alanwaketan commented Jan 22, 2020

jimsch commented Jan 22, 2020

jimsch commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020 •

edited

Loading

alanwaketan commented Jan 24, 2020

sideshowbarker commented Jan 24, 2020

alanwaketan commented Jan 24, 2020

Don't let AES-KW to wrap/unwrap JWK #6102

Don't let AES-KW to wrap/unwrap JWK #6102

Conversation

alanwaketan commented May 30, 2017 • edited by wpt-pr-bot Loading

jimsch commented May 31, 2017

jimsch left a comment

Choose a reason for hiding this comment

w3c-bots commented May 31, 2017

Firefox (nightly)

Unstable results

All results

w3c-bots commented May 31, 2017

Sauce (safari)

All results

w3c-bots commented May 31, 2017

Chrome (unstable)

w3c-bots commented May 31, 2017

Sauce (MicrosoftEdge)

alanwaketan commented Jun 1, 2017

jimsch commented Jun 1, 2017

alanwaketan commented Jun 1, 2017

sideshowbarker commented Jun 30, 2017

jimsch commented Jun 30, 2017

zcorpan commented Oct 1, 2018

foolip commented Dec 3, 2019

stephenmcgruer commented Jan 14, 2020

stephenmcgruer commented Jan 14, 2020

sideshowbarker commented Jan 22, 2020

alanwaketan commented Jan 22, 2020

jimsch commented Jan 22, 2020

alanwaketan commented Jan 22, 2020 • edited Loading

jimsch commented Jan 22, 2020

alanwaketan commented Jan 22, 2020

jimsch commented Jan 22, 2020

alanwaketan commented Jan 22, 2020

jimsch commented Jan 22, 2020

jimsch commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020

Chrome

Chrome

sideshowbarker commented Jan 23, 2020

sideshowbarker commented Jan 23, 2020 • edited Loading

alanwaketan commented Jan 24, 2020

sideshowbarker commented Jan 24, 2020

alanwaketan commented Jan 24, 2020

alanwaketan commented May 30, 2017 •

edited by wpt-pr-bot

Loading

alanwaketan commented Jan 22, 2020 •

edited

Loading

sideshowbarker commented Jan 23, 2020 •

edited

Loading