2017-05-22  Jiewen Tan  <jiewen_tan@apple.com>

        [WebCrypto] Support RSA-PSS

        https://bugs.webkit.org/show_bug.cgi?id=170869

        <rdar://problem/31640672>

        Reviewed by NOBODY (OOPS!).

        * wtf/Platform.h:

        Add a flag to enable RSA-PSS in the future.

2017-05-22  Jiewen Tan  <jiewen_tan@apple.com>

        [WebCrypto] Support RSA-PSS

        https://bugs.webkit.org/show_bug.cgi?id=170869

        <rdar://problem/31640672>

        Reviewed by Brent Fulgham.

        This patch implements RSA-PSS according to the spec: https://www.w3.org/TR/WebCryptoAPI/#rsa-pss.

        Supported operations include sign, verify, generateKey, importKey and exportKey.

        Tests: crypto/subtle/rsa-pss-generate-export-key-jwk-sha1.html

               crypto/subtle/rsa-pss-generate-export-key-jwk-sha224.html

               crypto/subtle/rsa-pss-generate-export-key-jwk-sha256.html

               crypto/subtle/rsa-pss-generate-export-key-jwk-sha384.html

               crypto/subtle/rsa-pss-generate-export-key-jwk-sha512.html

               crypto/subtle/rsa-pss-generate-export-key-pkcs8.html

               crypto/subtle/rsa-pss-generate-export-key-spki.html

               crypto/subtle/rsa-pss-generate-key.html

               crypto/subtle/rsa-pss-import-jwk-private-key.html

               crypto/subtle/rsa-pss-import-jwk-public-key-empty-usages.html

               crypto/subtle/rsa-pss-import-jwk-public-key-sha1.html

               crypto/subtle/rsa-pss-import-jwk-public-key-sha224.html

               crypto/subtle/rsa-pss-import-jwk-public-key-sha256.html

               crypto/subtle/rsa-pss-import-jwk-public-key-sha384.html

               crypto/subtle/rsa-pss-import-jwk-public-key-sha512.html

               crypto/subtle/rsa-pss-import-key-sign-large-salt.html

               crypto/subtle/rsa-pss-import-key-sign.html

               crypto/subtle/rsa-pss-import-key-verify.html

               crypto/subtle/rsa-pss-import-pkcs8-key.html

               crypto/subtle/rsa-pss-import-spki-key-empty-usages.html

               crypto/subtle/rsa-pss-import-spki-key.html

               crypto/workers/subtle/rsa-pss-import-key-sign.html

               crypto/workers/subtle/rsa-pss-import-key-verify.html

        * CMakeLists.txt:

        * DerivedSources.make:

        * PlatformGTK.cmake:

        * WebCore.xcodeproj/project.pbxproj:

        * bindings/js/JSSubtleCryptoCustom.cpp:

        (WebCore::normalizeCryptoAlgorithmParameters):

        * crypto/CryptoAlgorithmParameters.h:

        * crypto/algorithms/CryptoAlgorithmRSA_PSS.cpp: Added.

        (WebCore::CryptoAlgorithmRSA_PSS::create):

        (WebCore::CryptoAlgorithmRSA_PSS::identifier):

        (WebCore::CryptoAlgorithmRSA_PSS::sign):

        (WebCore::CryptoAlgorithmRSA_PSS::verify):

        (WebCore::CryptoAlgorithmRSA_PSS::generateKey):

        (WebCore::CryptoAlgorithmRSA_PSS::importKey):

        (WebCore::CryptoAlgorithmRSA_PSS::exportKey):

        * crypto/algorithms/CryptoAlgorithmRSA_PSS.h: Added.

        * crypto/mac/CryptoAlgorithmECDSAMac.cpp:

        (WebCore::cryptoDigestAlgorithm): Deleted.

        Extract function cryptoDigestAlgorithm to a separate file.

        * crypto/mac/CryptoAlgorithmRSASSA_PKCS1_v1_5Mac.cpp:

        (WebCore::cryptoDigestAlgorithm): Deleted.

        Extract function cryptoDigestAlgorithm to a separate file.

        * crypto/mac/CryptoAlgorithmRSA_PSSMac.cpp: Added.

        (WebCore::signRSA_PSS):

        (WebCore::verifyRSA_PSS):

        (WebCore::CryptoAlgorithmRSA_PSS::platformSign):

        (WebCore::CryptoAlgorithmRSA_PSS::platformVerify):

        * crypto/mac/CryptoAlgorithmRegistryMac.cpp:

        (WebCore::CryptoAlgorithmRegistry::platformRegisterAlgorithms):

        * crypto/mac/CryptoDigestAlgorithm.h: Added.

        (WebCore::cryptoDigestAlgorithm):

        Have cryptoDigestAlgorithm in a separate file.

        * crypto/parameters/CryptoAlgorithmRsaPssParams.h: Added.

        * crypto/parameters/RsaPssParams.idl: Added.

#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101300) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000)

#define HAVE_RSA_PSS 1

#endif

    crypto/parameters/RsaPssParams.idl

	$(WebCore)/crypto/parameters/RsaPssParams.idl \

        crypto/algorithms/CryptoAlgorithmRSA_PSS.cpp

		5721A9851ECE4FB90081295A /* CryptoAlgorithmRSA_PSSMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5721A9831ECE4FB90081295A /* CryptoAlgorithmRSA_PSSMac.cpp */; };

		5721A9871ECE53B10081295A /* CryptoDigestAlgorithm.h in Headers */ = {isa = PBXBuildFile; fileRef = 5721A9861ECE53B10081295A /* CryptoDigestAlgorithm.h */; };

		5721A98B1ECE57040081295A /* CryptoAlgorithmRsaPssParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 5721A9881ECE57040081295A /* CryptoAlgorithmRsaPssParams.h */; };

		5754719F1ECE628300DD63B2 /* JSRsaPssParams.h in Headers */ = {isa = PBXBuildFile; fileRef = 575471991ECE5D2A00DD63B2 /* JSRsaPssParams.h */; };

		575471A01ECE628700DD63B2 /* JSRsaPssParams.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5754719A1ECE5D2A00DD63B2 /* JSRsaPssParams.cpp */; };

		5790996D1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.h in Headers */ = {isa = PBXBuildFile; fileRef = 5790996B1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.h */; };

		5790996E1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5790996C1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.cpp */; };

		5721A9831ECE4FB90081295A /* CryptoAlgorithmRSA_PSSMac.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CryptoAlgorithmRSA_PSSMac.cpp; sourceTree = "<group>"; };

		5721A9861ECE53B10081295A /* CryptoDigestAlgorithm.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CryptoDigestAlgorithm.h; sourceTree = "<group>"; };

		5721A9881ECE57040081295A /* CryptoAlgorithmRsaPssParams.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmRsaPssParams.h; sourceTree = "<group>"; };

		5721A98A1ECE57040081295A /* RsaPssParams.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = RsaPssParams.idl; sourceTree = "<group>"; };

		575471991ECE5D2A00DD63B2 /* JSRsaPssParams.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSRsaPssParams.h; sourceTree = "<group>"; };

		5754719A1ECE5D2A00DD63B2 /* JSRsaPssParams.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRsaPssParams.cpp; sourceTree = "<group>"; };

		5790996B1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmRSA_PSS.h; sourceTree = "<group>"; };

		5790996C1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CryptoAlgorithmRSA_PSS.cpp; sourceTree = "<group>"; };

				5721A9831ECE4FB90081295A /* CryptoAlgorithmRSA_PSSMac.cpp */,

				5721A9861ECE53B10081295A /* CryptoDigestAlgorithm.h */,

				5790996B1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.h */,

				5790996C1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.cpp */,

				5721A9881ECE57040081295A /* CryptoAlgorithmRsaPssParams.h */,

				5721A98A1ECE57040081295A /* RsaPssParams.idl */,

				5754719A1ECE5D2A00DD63B2 /* JSRsaPssParams.cpp */,

				575471991ECE5D2A00DD63B2 /* JSRsaPssParams.h */,

				5754719F1ECE628300DD63B2 /* JSRsaPssParams.h in Headers */,

				5721A9871ECE53B10081295A /* CryptoDigestAlgorithm.h in Headers */,

				5790996D1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.h in Headers */,

				5721A98B1ECE57040081295A /* CryptoAlgorithmRsaPssParams.h in Headers */,

				5790996E1ECD23DA00FC0768 /* CryptoAlgorithmRSA_PSS.cpp in Sources */,

				5721A9851ECE4FB90081295A /* CryptoAlgorithmRSA_PSSMac.cpp in Sources */,

				575471A01ECE628700DD63B2 /* JSRsaPssParams.cpp in Sources */,

#include "JSRsaPssParams.h"

        RsaPssParams,

/*

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "CryptoAlgorithmRSA_PSS.h"

#if ENABLE(SUBTLE_CRYPTO) && HAVE(RSA_PSS)

#include "CryptoAlgorithmRsaHashedImportParams.h"

#include "CryptoAlgorithmRsaHashedKeyGenParams.h"

#include "CryptoKeyPair.h"

#include "CryptoKeyRSA.h"

#include "ExceptionCode.h"

#include <wtf/Variant.h>

namespace WebCore {

static const char* const ALG1 = "PS1";

static const char* const ALG224 = "PS224";

static const char* const ALG256 = "PS256";

static const char* const ALG384 = "PS384";

static const char* const ALG512 = "PS512";

Ref<CryptoAlgorithm> CryptoAlgorithmRSA_PSS::create()

{

    return adoptRef(*new CryptoAlgorithmRSA_PSS);

}

CryptoAlgorithmIdentifier CryptoAlgorithmRSA_PSS::identifier() const

{

    return s_identifier;

}

void CryptoAlgorithmRSA_PSS::sign(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& data, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)

{

    if (key->type() != CryptoKeyType::Private) {

        exceptionCallback(INVALID_ACCESS_ERR);

        return;

    }

    platformSign(WTFMove(parameters), WTFMove(key), WTFMove(data), WTFMove(callback), WTFMove(exceptionCallback), context, workQueue);

}

void CryptoAlgorithmRSA_PSS::verify(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& signature, Vector<uint8_t>&& data, BoolCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)

{

    if (key->type() != CryptoKeyType::Public) {

        exceptionCallback(INVALID_ACCESS_ERR);

        return;

    }

    platformVerify(WTFMove(parameters), WTFMove(key), WTFMove(signature), WTFMove(data), WTFMove(callback), WTFMove(exceptionCallback), context, workQueue);

}

void CryptoAlgorithmRSA_PSS::generateKey(const CryptoAlgorithmParameters& parameters, bool extractable, CryptoKeyUsageBitmap usages, KeyOrKeyPairCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context)

{

    const auto& rsaParameters = downcast<CryptoAlgorithmRsaHashedKeyGenParams>(parameters);

    if (usages & (CryptoKeyUsageDecrypt | CryptoKeyUsageEncrypt | CryptoKeyUsageDeriveKey | CryptoKeyUsageDeriveBits | CryptoKeyUsageWrapKey | CryptoKeyUsageUnwrapKey)) {

        exceptionCallback(SYNTAX_ERR);

        return;

    }

    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {

        pair.publicKey->setUsagesBitmap(pair.publicKey->usagesBitmap() & CryptoKeyUsageVerify);

        pair.privateKey->setUsagesBitmap(pair.privateKey->usagesBitmap() & CryptoKeyUsageSign);

        capturedCallback(WTFMove(pair));

    };

    auto failureCallback = [capturedCallback = WTFMove(exceptionCallback)]() {

        capturedCallback(OperationError);

    };

    CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier::RSA_PSS, rsaParameters.hashIdentifier, true, rsaParameters.modulusLength, rsaParameters.publicExponentVector(), extractable, usages, WTFMove(keyPairCallback), WTFMove(failureCallback), &context);

}

void CryptoAlgorithmRSA_PSS::importKey(SubtleCrypto::KeyFormat format, KeyData&& data, const std::unique_ptr<CryptoAlgorithmParameters>&& parameters, bool extractable, CryptoKeyUsageBitmap usages, KeyCallback&& callback, ExceptionCallback&& exceptionCallback)

{

    ASSERT(parameters);

    const auto& rsaParameters = downcast<CryptoAlgorithmRsaHashedImportParams>(*parameters);

    RefPtr<CryptoKeyRSA> result;

    switch (format) {

    case SubtleCrypto::KeyFormat::Jwk: {

        JsonWebKey key = WTFMove(WTF::get<JsonWebKey>(data));

        if (usages && ((!key.d.isNull() && (usages ^ CryptoKeyUsageSign)) || (key.d.isNull() && (usages ^ CryptoKeyUsageVerify)))) {

            exceptionCallback(SYNTAX_ERR);

            return;

        }

        if (usages && !key.use.isNull() && key.use != "sig") {

            exceptionCallback(DataError);

            return;

        }

        bool isMatched = false;

        switch (rsaParameters.hashIdentifier) {

        case CryptoAlgorithmIdentifier::SHA_1:

            isMatched = key.alg.isNull() || key.alg == ALG1;

            break;

        case CryptoAlgorithmIdentifier::SHA_224:

            isMatched = key.alg.isNull() || key.alg == ALG224;

            break;

        case CryptoAlgorithmIdentifier::SHA_256:

            isMatched = key.alg.isNull() || key.alg == ALG256;

            break;

        case CryptoAlgorithmIdentifier::SHA_384:

            isMatched = key.alg.isNull() || key.alg == ALG384;

            break;

        case CryptoAlgorithmIdentifier::SHA_512:

            isMatched = key.alg.isNull() || key.alg == ALG512;

            break;

        default:

            break;

        }

        if (!isMatched) {

            exceptionCallback(DataError);

            return;

        }

        result = CryptoKeyRSA::importJwk(rsaParameters.identifier, rsaParameters.hashIdentifier, WTFMove(key), extractable, usages);

        break;

    }

    case SubtleCrypto::KeyFormat::Spki: {

        if (usages && (usages ^ CryptoKeyUsageVerify)) {

            exceptionCallback(SYNTAX_ERR);

            return;

        }

        // FIXME: <webkit.org/b/165436>

        result = CryptoKeyRSA::importSpki(rsaParameters.identifier, rsaParameters.hashIdentifier, WTFMove(WTF::get<Vector<uint8_t>>(data)), extractable, usages);

        break;

    }

    case SubtleCrypto::KeyFormat::Pkcs8: {

        if (usages && (usages ^ CryptoKeyUsageSign)) {

            exceptionCallback(SYNTAX_ERR);

            return;

        }

        // FIXME: <webkit.org/b/165436>

        result = CryptoKeyRSA::importPkcs8(parameters->identifier, rsaParameters.hashIdentifier, WTFMove(WTF::get<Vector<uint8_t>>(data)), extractable, usages);

        break;

    }

    default:

        exceptionCallback(NOT_SUPPORTED_ERR);

        return;

    }

    if (!result) {

        exceptionCallback(DataError);

        return;

    }

    callback(*result);

}

void CryptoAlgorithmRSA_PSS::exportKey(SubtleCrypto::KeyFormat format, Ref<CryptoKey>&& key, KeyDataCallback&& callback, ExceptionCallback&& exceptionCallback)

{

    const auto& rsaKey = downcast<CryptoKeyRSA>(key.get());

    if (!rsaKey.keySizeInBits()) {

        exceptionCallback(OperationError);

        return;

    }

    KeyData result;

    switch (format) {

    case SubtleCrypto::KeyFormat::Jwk: {

        JsonWebKey jwk = rsaKey.exportJwk();

        switch (rsaKey.hashAlgorithmIdentifier()) {

        case CryptoAlgorithmIdentifier::SHA_1:

            jwk.alg = String(ALG1);

            break;

        case CryptoAlgorithmIdentifier::SHA_224:

            jwk.alg = String(ALG224);

            break;

        case CryptoAlgorithmIdentifier::SHA_256:

            jwk.alg = String(ALG256);

            break;

        case CryptoAlgorithmIdentifier::SHA_384:

            jwk.alg = String(ALG384);

            break;

        case CryptoAlgorithmIdentifier::SHA_512:

            jwk.alg = String(ALG512);

            break;

        default:

            ASSERT_NOT_REACHED();

        }

        result = WTFMove(jwk);

        break;

    }

    case SubtleCrypto::KeyFormat::Spki: {

        auto spki = rsaKey.exportSpki();

        if (spki.hasException()) {

            exceptionCallback(spki.releaseException().code());

            return;

        }

        result = spki.releaseReturnValue();

        break;

    }

    case SubtleCrypto::KeyFormat::Pkcs8: {

        auto pkcs8 = rsaKey.exportPkcs8();

        if (pkcs8.hasException()) {

            exceptionCallback(pkcs8.releaseException().code());

            return;

        }

        result = pkcs8.releaseReturnValue();

        break;

    }

    default:

        exceptionCallback(NOT_SUPPORTED_ERR);

        return;

    }

    callback(format, WTFMove(result));

}

}

#endif // ENABLE(SUBTLE_CRYPTO) && HAVE(RSA_PSS)

/*

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#include "CryptoAlgorithm.h"

#if ENABLE(SUBTLE_CRYPTO) && HAVE(RSA_PSS)

namespace WebCore {

class CryptoKeyRSA;

class CryptoAlgorithmRSA_PSS final : public CryptoAlgorithm {

public:

    static constexpr const char* s_name = "RSA-PSS";

    static constexpr CryptoAlgorithmIdentifier s_identifier = CryptoAlgorithmIdentifier::RSA_PSS;

    static Ref<CryptoAlgorithm> create();

private:

    CryptoAlgorithmRSA_PSS() = default;

    CryptoAlgorithmIdentifier identifier() const final;

    void sign(std::unique_ptr<CryptoAlgorithmParameters>&&, Ref<CryptoKey>&&, Vector<uint8_t>&&, VectorCallback&&, ExceptionCallback&&, ScriptExecutionContext&, WorkQueue&) final;

    void verify(std::unique_ptr<CryptoAlgorithmParameters>&&, Ref<CryptoKey>&&, Vector<uint8_t>&& signature, Vector<uint8_t>&&, BoolCallback&&, ExceptionCallback&&, ScriptExecutionContext&, WorkQueue&) final;

    void generateKey(const CryptoAlgorithmParameters&, bool extractable, CryptoKeyUsageBitmap, KeyOrKeyPairCallback&&, ExceptionCallback&&, ScriptExecutionContext&) final;

    void importKey(SubtleCrypto::KeyFormat, KeyData&&, const std::unique_ptr<CryptoAlgorithmParameters>&&, bool extractable, CryptoKeyUsageBitmap, KeyCallback&&, ExceptionCallback&&) final;

    void exportKey(SubtleCrypto::KeyFormat, Ref<CryptoKey>&&, KeyDataCallback&&, ExceptionCallback&&) final;

    void platformSign(std::unique_ptr<CryptoAlgorithmParameters>&&, Ref<CryptoKey>&&, Vector<uint8_t>&&, VectorCallback&&, ExceptionCallback&&, ScriptExecutionContext&, WorkQueue&);

    void platformVerify(std::unique_ptr<CryptoAlgorithmParameters>&&, Ref<CryptoKey>&&, Vector<uint8_t>&& signature, Vector<uint8_t>&&, BoolCallback&&, ExceptionCallback&&, ScriptExecutionContext&, WorkQueue&);

};

} // namespace WebCore

#endif // ENABLE(SUBTLE_CRYPTO) && HAVE(RSA_PSS)

#include "CryptoDigestAlgorithm.h"

#include "CryptoDigestAlgorithm.h"

/*

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "CryptoAlgorithmRSA_PSS.h"

#if ENABLE(SUBTLE_CRYPTO) && HAVE(RSA_PSS)

#include "CommonCryptoUtilities.h"

#include "CryptoAlgorithmRsaPssParams.h"

#include "CryptoDigestAlgorithm.h"

#include "CryptoKeyRSA.h"

#include "ExceptionCode.h"

#include "ScriptExecutionContext.h"

namespace WebCore {

static ExceptionOr<Vector<uint8_t>> signRSA_PSS(CryptoAlgorithmIdentifier hash, const PlatformRSAKey key, size_t keyLength, const Vector<uint8_t>& data, size_t saltLength)

{

    CCDigestAlgorithm digestAlgorithm;

    if (!getCommonCryptoDigestAlgorithm(hash, digestAlgorithm))

        return Exception { OperationError };

    auto cryptoDigestAlgorithm = WebCore::cryptoDigestAlgorithm(hash);

    if (!cryptoDigestAlgorithm)

        return Exception { OperationError };

    auto digest = PAL::CryptoDigest::create(*cryptoDigestAlgorithm);

    if (!digest)

        return Exception { OperationError };

    digest->addBytes(data.data(), data.size());

    auto digestData = digest->computeHash();

    Vector<uint8_t> signature(keyLength / 8); // Per https://tools.ietf.org/html/rfc3447#section-8.1.1

    size_t signatureSize = signature.size();

    CCCryptorStatus status = CCRSACryptorSign(key, ccRSAPSSPadding, digestData.data(), digestData.size(), digestAlgorithm, saltLength, signature.data(), &signatureSize);

    if (status)

        return Exception { OperationError };

    return WTFMove(signature);

}

static ExceptionOr<bool> verifyRSA_PSS(CryptoAlgorithmIdentifier hash, const PlatformRSAKey key, const Vector<uint8_t>& signature, const Vector<uint8_t>& data, size_t saltLength)

{

    CCDigestAlgorithm digestAlgorithm;

    if (!getCommonCryptoDigestAlgorithm(hash, digestAlgorithm))

        return Exception { OperationError };

    auto cryptoDigestAlgorithm = WebCore::cryptoDigestAlgorithm(hash);

    if (!cryptoDigestAlgorithm)

        return Exception { OperationError };

    auto digest = PAL::CryptoDigest::create(*cryptoDigestAlgorithm);

    if (!digest)

        return Exception { OperationError };

    digest->addBytes(data.data(), data.size());

    auto digestData = digest->computeHash();

    auto status = CCRSACryptorVerify(key, ccRSAPSSPadding, digestData.data(), digestData.size(), digestAlgorithm, saltLength, signature.data(), signature.size());

    if (!status)

        return true;

    return false;

}

void CryptoAlgorithmRSA_PSS::platformSign(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& data, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)

{

    context.ref();

    workQueue.dispatch([parameters = WTFMove(parameters), key = WTFMove(key), data = WTFMove(data), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback), &context]() mutable {

        auto& rsaKey = downcast<CryptoKeyRSA>(key.get());

        auto& rsaParams = downcast<CryptoAlgorithmRsaPssParams>(*parameters);

        auto result = signRSA_PSS(rsaKey.hashAlgorithmIdentifier(), rsaKey.platformKey(), rsaKey.keySizeInBits(), data, rsaParams.saltLength);

        if (result.hasException()) {

            // We should only dereference callbacks after being back to the Document/Worker threads.

            context.postTask([exceptionCallback = WTFMove(exceptionCallback), ec = result.releaseException().code(), callback = WTFMove(callback)](ScriptExecutionContext& context) {

                exceptionCallback(ec);

                context.deref();

            });

            return;

        }

        // We should only dereference callbacks after being back to the Document/Worker threads.

        context.postTask([callback = WTFMove(callback), result = result.releaseReturnValue(), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {

            callback(result);

            context.deref();

        });

    });

}

void CryptoAlgorithmRSA_PSS::platformVerify(std::unique_ptr<CryptoAlgorithmParameters>&& parameters, Ref<CryptoKey>&& key, Vector<uint8_t>&& signature, Vector<uint8_t>&& data, BoolCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)

{

    context.ref();

    workQueue.dispatch([parameters = WTFMove(parameters), key = WTFMove(key), signature = WTFMove(signature), data = WTFMove(data), callback = WTFMove(callback), exceptionCallback = WTFMove(exceptionCallback), &context]() mutable {

        auto& rsaKey = downcast<CryptoKeyRSA>(key.get());

        auto& rsaParams = downcast<CryptoAlgorithmRsaPssParams>(*parameters);

        auto result = verifyRSA_PSS(rsaKey.hashAlgorithmIdentifier(), rsaKey.platformKey(), signature, data, rsaParams.saltLength);

        if (result.hasException()) {

            // We should only dereference callbacks after being back to the Document/Worker threads.

            context.postTask([exceptionCallback = WTFMove(exceptionCallback), ec = result.releaseException().code(), callback = WTFMove(callback)](ScriptExecutionContext& context) {

                exceptionCallback(ec);

                context.deref();

            });

            return;

        }

        // We should only dereference callbacks after being back to the Document/Worker threads.

        context.postTask([callback = WTFMove(callback), result = result.releaseReturnValue(), exceptionCallback = WTFMove(exceptionCallback)](ScriptExecutionContext& context) {

            callback(result);

            context.deref();

        });

    });

}

} // namespace WebCore

#endif // ENABLE(SUBTLE_CRYPTO) && HAVE(RSA_PSS)

#include "CryptoAlgorithmRSA_PSS.h"

#if HAVE(RSA_PSS)

    registerAlgorithm<CryptoAlgorithmRSA_PSS>();

#endif

/*

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#include <pal/crypto/CryptoDigest.h>

#if ENABLE(SUBTLE_CRYPTO)

#include "CryptoAlgorithm.h"

namespace WebCore {

static std::optional<PAL::CryptoDigest::Algorithm> cryptoDigestAlgorithm(CryptoAlgorithmIdentifier hashFunction)

{

    switch (hashFunction) {

    case CryptoAlgorithmIdentifier::SHA_1:

        return PAL::CryptoDigest::Algorithm::SHA_1;

    case CryptoAlgorithmIdentifier::SHA_224:

        return PAL::CryptoDigest::Algorithm::SHA_224;

    case CryptoAlgorithmIdentifier::SHA_256:

        return PAL::CryptoDigest::Algorithm::SHA_256;

    case CryptoAlgorithmIdentifier::SHA_384:

        return PAL::CryptoDigest::Algorithm::SHA_384;

    case CryptoAlgorithmIdentifier::SHA_512:

        return PAL::CryptoDigest::Algorithm::SHA_512;

    default:

        return std::nullopt;

    }

}

} // namespace WebCore

#endif // ENABLE(SUBTLE_CRYPTO)

/*

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#include "CryptoAlgorithmParameters.h"

#if ENABLE(SUBTLE_CRYPTO)

namespace WebCore {

class CryptoAlgorithmRsaPssParams final : public CryptoAlgorithmParameters {

public:

    size_t saltLength;

    Class parametersClass() const final { return Class::RsaPssParams; }

};

} // namespace WebCore

SPECIALIZE_TYPE_TRAITS_CRYPTO_ALGORITHM_PARAMETERS(RsaPssParams)

#endif // ENABLE(SUBTLE_CRYPTO)

/*

 * Copyright (C) 2017 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

[

    Conditional=SUBTLE_CRYPTO,

    ImplementedAs=CryptoAlgorithmRsaPssParams

] dictionary RsaPssParams : CryptoAlgorithmParameters {

    // The desired length of the random salt

    required [EnforceRange] unsigned long saltLength;

};

2017-05-22  Jiewen Tan  <jiewen_tan@apple.com>

        [WebCrypto] Support RSA-PSS

        https://bugs.webkit.org/show_bug.cgi?id=170869

        <rdar://problem/31640672>

        Reviewed by Brent Fulgham.

        * TestExpectations:

        Skip tests related to RSA-PSS for now.

        * crypto/subtle/rsa-generate-key-malformed-parameters-expected.txt:

        * crypto/subtle/rsa-generate-key-malformed-parameters.html:

        * crypto/subtle/rsa-import-key-malformed-parameters-expected.txt:

        * crypto/subtle/rsa-import-key-malformed-parameters.html:

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha1-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha1.html: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha224-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha224.html: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha256-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha256.html: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha384-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha384.html: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha512-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-jwk-sha512.html: Added.

        * crypto/subtle/rsa-pss-generate-export-key-pkcs8-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-pkcs8.html: Added.

        * crypto/subtle/rsa-pss-generate-export-key-spki-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-export-key-spki.html: Added.

        * crypto/subtle/rsa-pss-generate-key-expected.txt: Added.

        * crypto/subtle/rsa-pss-generate-key.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-private-key-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-private-key.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-empty-usages-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-empty-usages.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha1-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha1.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha224-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha224.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha256-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha256.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha384-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha384.html: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha512-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-jwk-public-key-sha512.html: Added.

        * crypto/subtle/rsa-pss-import-key-sign-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-key-sign-large-salt-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-key-sign-large-salt.html: Added.

        * crypto/subtle/rsa-pss-import-key-sign.html: Added.

        * crypto/subtle/rsa-pss-import-key-verify-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-key-verify.html: Added.

        * crypto/subtle/rsa-pss-import-pkcs8-key-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-pkcs8-key.html: Added.

        * crypto/subtle/rsa-pss-import-spki-key-empty-usages-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-spki-key-empty-usages.html: Added.

        * crypto/subtle/rsa-pss-import-spki-key-expected.txt: Added.

        * crypto/subtle/rsa-pss-import-spki-key.html: Added.

        * crypto/workers/subtle/resources/rsa-pss-import-key-sign.js: Added.

        * crypto/workers/subtle/resources/rsa-pss-import-key-verify.js: Added.

        * crypto/workers/subtle/rsa-pss-import-key-sign-expected.txt: Added.

        * crypto/workers/subtle/rsa-pss-import-key-sign.html: Added.

        * crypto/workers/subtle/rsa-pss-import-key-verify-expected.txt: Added.

        * crypto/workers/subtle/rsa-pss-import-key-verify.html: Added.

crypto/subtle/rsa-pss-generate-export-key-jwk-sha1.html [ Skip ]

crypto/subtle/rsa-pss-generate-export-key-jwk-sha224.html [ Skip ]

crypto/subtle/rsa-pss-generate-export-key-jwk-sha256.html [ Skip ]

crypto/subtle/rsa-pss-generate-export-key-jwk-sha384.html [ Skip ]

crypto/subtle/rsa-pss-generate-export-key-jwk-sha512.html [ Skip ]

crypto/subtle/rsa-pss-generate-export-key-pkcs8.html [ Skip ]

crypto/subtle/rsa-pss-generate-export-key-spki.html [ Skip ]

crypto/subtle/rsa-pss-generate-key.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-private-key.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-public-key-empty-usages.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-public-key-sha1.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-public-key-sha224.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-public-key-sha256.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-public-key-sha384.html [ Skip ]

crypto/subtle/rsa-pss-import-jwk-public-key-sha512.html [ Skip ]

crypto/subtle/rsa-pss-import-key-sign-large-salt.html [ Skip ]

crypto/subtle/rsa-pss-import-key-sign.html [ Skip ]

crypto/subtle/rsa-pss-import-key-verify.html [ Skip ]

crypto/subtle/rsa-pss-import-pkcs8-key.html [ Skip ]

crypto/subtle/rsa-pss-import-spki-key-empty-usages.html [ Skip ]

crypto/subtle/rsa-pss-import-spki-key.html [ Skip ]

crypto/workers/subtle/rsa-pss-import-key-sign.html [ Skip ]

crypto/workers/subtle/rsa-pss-import-key-verify.html [ Skip ]

PASS crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["encrypt"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["decrypt"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["deriveKey"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["deriveBits"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["wrapKey"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["unwrapKey"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

shouldReject('crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["encrypt"])');

shouldReject('crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["decrypt"])');

shouldReject('crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["deriveKey"])');

shouldReject('crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["deriveBits"])');

shouldReject('crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["wrapKey"])');

shouldReject('crypto.subtle.generateKey({name: "RSA-PSS", modulusLength: 2048, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["unwrapKey"])');

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["sign"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, d: d}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, d: ""}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, use: "enc"}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, use: ""}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS224"}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS256"}, {name: "RSA-PSS", hash: "sha-224"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS384"}, {name: "RSA-PSS", hash: "sha-256"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS512"}, {name: "RSA-PSS", hash: "sha-384"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS1"}, {name: "RSA-PSS", hash: "sha-512"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-224"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-256"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-384"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-512"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("spki", spkiKey, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["sign"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

PASS crypto.subtle.importKey("pkcs8", pkcs8Key, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"]) rejected promise  with NotSupportedError (DOM Exception 9): The operation is not supported..

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["sign"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, d: d}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, d: ""}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, use: "enc"}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, use: ""}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS224"}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS256"}, {name: "RSA-PSS", hash: "sha-224"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS384"}, {name: "RSA-PSS", hash: "sha-256"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS512"}, {name: "RSA-PSS", hash: "sha-384"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: "PS1"}, {name: "RSA-PSS", hash: "sha-512"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-224"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-256"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-384"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("jwk", {kty: "RSA", n: n, e: e, alg: ""}, {name: "RSA-PSS", hash: "sha-512"}, extractable, ["verify"])');

shouldReject('crypto.subtle.importKey("spki", spkiKey, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["sign"])');

shouldReject('crypto.subtle.importKey("pkcs8", pkcs8Key, {name: "RSA-PSS", hash: "sha-1"}, extractable, ["verify"])');

Test exporting a SHA-1 RSA-PSS key pair with JWK format.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Generating a key pair...

Exporting the public key...

PASS publicKey.kty is 'RSA'

PASS publicKey.key_ops is ['verify']

PASS publicKey.alg is 'PS1'

PASS publicKey.ext is true

PASS Base64URL.parse(publicKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(publicKey.e)) is '010001'

Exporting the private key...

PASS privateKey.kty is 'RSA'

PASS privateKey.key_ops is ['sign']

PASS privateKey.alg is 'PS1'

PASS privateKey.ext is true

PASS Base64URL.parse(privateKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(privateKey.e)) is '010001'

PASS privateKey.oth is undefined.

PASS successfullyParsed is true

TEST COMPLETE

<!DOCTYPE html>

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<script src="../resources/common.js"></script>

</head>

<body>

<p id="description"></p>

<div id="console"></div>

<script>

description("Test exporting a SHA-1 RSA-PSS key pair with JWK format.");

jsTestIsAsync = true;

var algorithmKeyGen = {

    name: "RSA-PSS",

    // RsaKeyGenParams

    modulusLength: 2048,

    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537

    hash: "sha-1",

};

var extractable = true;

var keyPair;

debug("Generating a key pair...");

crypto.subtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {

    keyPair = result;

    debug("Exporting the public key...");

    return crypto.subtle.exportKey("jwk", keyPair.publicKey);

}).then(function(result) {

    publicKey = result;

    shouldBe("publicKey.kty", "'RSA'");

    shouldBe("publicKey.key_ops", "['verify']");

    shouldBe("publicKey.alg", "'PS1'");

    shouldBe("publicKey.ext", "true");

    shouldBe("Base64URL.parse(publicKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(publicKey.e))", "'010001'");

    debug("Exporting the private key...");

    return crypto.subtle.exportKey("jwk", keyPair.privateKey);

}).then(function(result) {

    privateKey = result;

    shouldBe("privateKey.kty", "'RSA'");

    shouldBe("privateKey.key_ops", "['sign']");

    shouldBe("privateKey.alg", "'PS1'");

    shouldBe("privateKey.ext", "true");

    shouldBe("Base64URL.parse(privateKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(privateKey.e))", "'010001'");

    shouldBeUndefined("privateKey.oth");

    finishJSTest();

});

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

Test exporting a SHA-224 RSA-PSS key pair with JWK format.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Generating a key pair...

Exporting the public key...

PASS publicKey.kty is 'RSA'

PASS publicKey.key_ops is ['verify']

PASS publicKey.alg is 'PS224'

PASS publicKey.ext is true

PASS Base64URL.parse(publicKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(publicKey.e)) is '010001'

Exporting the private key...

PASS privateKey.kty is 'RSA'

PASS privateKey.key_ops is ['sign']

PASS privateKey.alg is 'PS224'

PASS privateKey.ext is true

PASS Base64URL.parse(privateKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(privateKey.e)) is '010001'

PASS privateKey.oth is undefined.

PASS successfullyParsed is true

TEST COMPLETE

<!DOCTYPE html>

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<script src="../resources/common.js"></script>

</head>

<body>

<p id="description"></p>

<div id="console"></div>

<script>

description("Test exporting a SHA-224 RSA-PSS key pair with JWK format.");

jsTestIsAsync = true;

var algorithmKeyGen = {

    name: "RSA-PSS",

    // RsaKeyGenParams

    modulusLength: 2048,

    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537

    hash: "sha-224",

};

var extractable = true;

var keyPair;

debug("Generating a key pair...");

crypto.subtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {

    keyPair = result;

    debug("Exporting the public key...");

    return crypto.subtle.exportKey("jwk", keyPair.publicKey);

}).then(function(result) {

    publicKey = result;

    shouldBe("publicKey.kty", "'RSA'");

    shouldBe("publicKey.key_ops", "['verify']");

    shouldBe("publicKey.alg", "'PS224'");

    shouldBe("publicKey.ext", "true");

    shouldBe("Base64URL.parse(publicKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(publicKey.e))", "'010001'");

    debug("Exporting the private key...");

    return crypto.subtle.exportKey("jwk", keyPair.privateKey);

}).then(function(result) {

    privateKey = result;

    shouldBe("privateKey.kty", "'RSA'");

    shouldBe("privateKey.key_ops", "['sign']");

    shouldBe("privateKey.alg", "'PS224'");

    shouldBe("privateKey.ext", "true");

    shouldBe("Base64URL.parse(privateKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(privateKey.e))", "'010001'");

    shouldBeUndefined("privateKey.oth");

    finishJSTest();

});

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

Test exporting a SHA-256 RSA-PSS key pair with JWK format.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Generating a key pair...

Exporting the public key...

PASS publicKey.kty is 'RSA'

PASS publicKey.key_ops is ['verify']

PASS publicKey.alg is 'PS256'

PASS publicKey.ext is true

PASS Base64URL.parse(publicKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(publicKey.e)) is '010001'

Exporting the private key...

PASS privateKey.kty is 'RSA'

PASS privateKey.key_ops is ['sign']

PASS privateKey.alg is 'PS256'

PASS privateKey.ext is true

PASS Base64URL.parse(privateKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(privateKey.e)) is '010001'

PASS privateKey.oth is undefined.

PASS successfullyParsed is true

TEST COMPLETE

<!DOCTYPE html>

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<script src="../resources/common.js"></script>

</head>

<body>

<p id="description"></p>

<div id="console"></div>

<script>

description("Test exporting a SHA-256 RSA-PSS key pair with JWK format.");

jsTestIsAsync = true;

var algorithmKeyGen = {

    name: "RSA-PSS",

    // RsaKeyGenParams

    modulusLength: 2048,

    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537

    hash: "sha-256",

};

var extractable = true;

var keyPair;

debug("Generating a key pair...");

crypto.subtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {

    keyPair = result;

    debug("Exporting the public key...");

    return crypto.subtle.exportKey("jwk", keyPair.publicKey);

}).then(function(result) {

    publicKey = result;

    shouldBe("publicKey.kty", "'RSA'");

    shouldBe("publicKey.key_ops", "['verify']");

    shouldBe("publicKey.alg", "'PS256'");

    shouldBe("publicKey.ext", "true");

    shouldBe("Base64URL.parse(publicKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(publicKey.e))", "'010001'");

    debug("Exporting the private key...");

    return crypto.subtle.exportKey("jwk", keyPair.privateKey);

}).then(function(result) {

    privateKey = result;

    shouldBe("privateKey.kty", "'RSA'");

    shouldBe("privateKey.key_ops", "['sign']");

    shouldBe("privateKey.alg", "'PS256'");

    shouldBe("privateKey.ext", "true");

    shouldBe("Base64URL.parse(privateKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(privateKey.e))", "'010001'");

    shouldBeUndefined("privateKey.oth");

    finishJSTest();

});

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

Test exporting a SHA-384 RSA-PSS key pair with JWK format.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Generating a key pair...

Exporting the public key...

PASS publicKey.kty is 'RSA'

PASS publicKey.key_ops is ['verify']

PASS publicKey.alg is 'PS384'

PASS publicKey.ext is true

PASS Base64URL.parse(publicKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(publicKey.e)) is '010001'

Exporting the private key...

PASS privateKey.kty is 'RSA'

PASS privateKey.key_ops is ['sign']

PASS privateKey.alg is 'PS384'

PASS privateKey.ext is true

PASS Base64URL.parse(privateKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(privateKey.e)) is '010001'

PASS privateKey.oth is undefined.

PASS successfullyParsed is true

TEST COMPLETE

<!DOCTYPE html>

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<script src="../resources/common.js"></script>

</head>

<body>

<p id="description"></p>

<div id="console"></div>

<script>

description("Test exporting a SHA-384 RSA-PSS key pair with JWK format.");

jsTestIsAsync = true;

var algorithmKeyGen = {

    name: "RSA-PSS",

    // RsaKeyGenParams

    modulusLength: 2048,

    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537

    hash: "sha-384",

};

var extractable = true;

var keyPair;

debug("Generating a key pair...");

crypto.subtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {

    keyPair = result;

    debug("Exporting the public key...");

    return crypto.subtle.exportKey("jwk", keyPair.publicKey);

}).then(function(result) {

    publicKey = result;

    shouldBe("publicKey.kty", "'RSA'");

    shouldBe("publicKey.key_ops", "['verify']");

    shouldBe("publicKey.alg", "'PS384'");

    shouldBe("publicKey.ext", "true");

    shouldBe("Base64URL.parse(publicKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(publicKey.e))", "'010001'");

    debug("Exporting the private key...");

    return crypto.subtle.exportKey("jwk", keyPair.privateKey);

}).then(function(result) {

    privateKey = result;

    shouldBe("privateKey.kty", "'RSA'");

    shouldBe("privateKey.key_ops", "['sign']");

    shouldBe("privateKey.alg", "'PS384'");

    shouldBe("privateKey.ext", "true");

    shouldBe("Base64URL.parse(privateKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(privateKey.e))", "'010001'");

    shouldBeUndefined("privateKey.oth");

    finishJSTest();

});

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

Test exporting a SHA-512 RSA-PSS key pair with JWK format.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Generating a key pair...

Exporting the public key...

PASS publicKey.kty is 'RSA'

PASS publicKey.key_ops is ['verify']

PASS publicKey.alg is 'PS512'

PASS publicKey.ext is true

PASS Base64URL.parse(publicKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(publicKey.e)) is '010001'

Exporting the private key...

PASS privateKey.kty is 'RSA'

PASS privateKey.key_ops is ['sign']

PASS privateKey.alg is 'PS512'

PASS privateKey.ext is true

PASS Base64URL.parse(privateKey.n).byteLength is 256

PASS bytesToHexString(Base64URL.parse(privateKey.e)) is '010001'

PASS privateKey.oth is undefined.

PASS successfullyParsed is true

TEST COMPLETE

<!DOCTYPE html>

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<script src="../resources/common.js"></script>

</head>

<body>

<p id="description"></p>

<div id="console"></div>

<script>

description("Test exporting a SHA-512 RSA-PSS key pair with JWK format.");

jsTestIsAsync = true;

var algorithmKeyGen = {

    name: "RSA-PSS",

    // RsaKeyGenParams

    modulusLength: 2048,

    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537

    hash: "sha-512",

};

var extractable = true;

var keyPair;

debug("Generating a key pair...");

crypto.subtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {

    keyPair = result;

    debug("Exporting the public key...");

    return crypto.subtle.exportKey("jwk", keyPair.publicKey);

}).then(function(result) {

    publicKey = result;

    shouldBe("publicKey.kty", "'RSA'");

    shouldBe("publicKey.key_ops", "['verify']");

    shouldBe("publicKey.alg", "'PS512'");

    shouldBe("publicKey.ext", "true");

    shouldBe("Base64URL.parse(publicKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(publicKey.e))", "'010001'");

    debug("Exporting the private key...");

    return crypto.subtle.exportKey("jwk", keyPair.privateKey);

}).then(function(result) {

    privateKey = result;

    shouldBe("privateKey.kty", "'RSA'");

    shouldBe("privateKey.key_ops", "['sign']");

    shouldBe("privateKey.alg", "'PS512'");

    shouldBe("privateKey.ext", "true");

    shouldBe("Base64URL.parse(privateKey.n).byteLength", "256");

    shouldBe("bytesToHexString(Base64URL.parse(privateKey.e))", "'010001'");

    shouldBeUndefined("privateKey.oth");

    finishJSTest();

});

</script>

<script src="../../resources/js-test-post.js"></script>

</body>

</html>

Test exporting a RSA-PSS private key with PKCS8 format.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".

Generating a key pair...

Exporting the private key...

PASS privateKey is an instance of ArrayBuffer

PASS successfullyParsed is true

TEST COMPLETE

<!DOCTYPE html>

<html>

<head>

<script src="../../resources/js-test-pre.js"></script>

<script src="../resources/common.js"></script>

</head>

<body>

<p id="description"></p>