Refactor to share more code between OpenSSL and NSS implementations.

content/renderer/webcrypto/platform_crypto.cc

+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/renderer/webcrypto/platform_crypto.h"
+
+#include "base/logging.h"
+#include "content/renderer/webcrypto/crypto_data.h"
+#include "content/renderer/webcrypto/webcrypto_util.h"
+#include "crypto/secure_util.h"
+#include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
+#include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
+#include "third_party/WebKit/public/platform/WebCryptoKey.h"
+
+namespace content {
+
+namespace webcrypto {
+
+namespace {
+
+// TODO(eroman): Move this helper to WebCryptoKey.
+bool KeyUsageAllows(const blink::WebCryptoKey& key,
+                    const blink::WebCryptoKeyUsage usage) {
+  return ((key.usages() & usage) != 0);
+}
+
+const size_t kAesBlockSizeBytes = 16;
+
+Status EncryptAesCbc(PlatformCrypto* crypto,
+                     const blink::WebCryptoAlgorithm& algorithm,
+                     const blink::WebCryptoKey& key,
+                     const CryptoData& data,
+                     blink::WebArrayBuffer* buffer) {
+  PlatformSymKey* sym_key = crypto->ToSymKey(key);
+  if (!sym_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoAesCbcParams* params = algorithm.aesCbcParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  CryptoData iv(params->iv().data(), params->iv().size());
+  if (iv.byte_length() != kAesBlockSizeBytes)
+    return Status::ErrorIncorrectSizeAesCbcIv();
+
+  return crypto->PlatformEncryptAesCbc(sym_key, iv, data, buffer);
+}
+
+Status DecryptAesCbc(PlatformCrypto* crypto,
+                     const blink::WebCryptoAlgorithm& algorithm,
+                     const blink::WebCryptoKey& key,
+                     const CryptoData& data,
+                     blink::WebArrayBuffer* buffer) {
+  PlatformSymKey* sym_key = crypto->ToSymKey(key);
+  if (!sym_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoAesCbcParams* params = algorithm.aesCbcParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  CryptoData iv(params->iv().data(), params->iv().size());
+  if (iv.byte_length() != kAesBlockSizeBytes)
+    return Status::ErrorIncorrectSizeAesCbcIv();
+
+  return crypto->PlatformDecryptAesCbc(sym_key, iv, data, buffer);
+}
+
+Status EncryptAesGcm(PlatformCrypto* crypto,
+                     const blink::WebCryptoAlgorithm& algorithm,
+                     const blink::WebCryptoKey& key,
+                     const CryptoData& data,
+                     blink::WebArrayBuffer* buffer) {
+  PlatformSymKey* sym_key = crypto->ToSymKey(key);
+  if (!sym_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoAesGcmParams* params = algorithm.aesGcmParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  return crypto->PlatformEncryptAesGcm(sym_key, params, data, buffer);
+}
+
+Status DecryptAesGcm(PlatformCrypto* crypto,
+                     const blink::WebCryptoAlgorithm& algorithm,
+                     const blink::WebCryptoKey& key,
+                     const CryptoData& data,
+                     blink::WebArrayBuffer* buffer) {
+  PlatformSymKey* sym_key = crypto->ToSymKey(key);
+  if (!sym_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoAesGcmParams* params = algorithm.aesGcmParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  return crypto->PlatformDecryptAesGcm(sym_key, params, data, buffer);
+}
+
+Status EncryptRsaEsPkcs1v1_5(PlatformCrypto* crypto,
+                             const blink::WebCryptoAlgorithm& algorithm,
+                             const blink::WebCryptoKey& key,
+                             const CryptoData& data,
+                             blink::WebArrayBuffer* buffer) {
+  PlatformPublicKey* public_key = crypto->ToPublicKey(key);
+  if (!public_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  // RSAES encryption does not support empty input
+  if (!data.byte_length())
+    return Status::Error();
+
+  return crypto->PlatformEncryptRsaEsPkcs1v1_5(public_key, data, buffer);
+}
+
+Status DecryptRsaEsPkcs1v1_5(PlatformCrypto* crypto,
+                             const blink::WebCryptoAlgorithm& algorithm,
+                             const blink::WebCryptoKey& key,
+                             const CryptoData& data,
+                             blink::WebArrayBuffer* buffer) {
+  PlatformPrivateKey* private_key = crypto->ToPrivateKey(key);
+  if (!private_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  // RSAES decryption does not support empty input
+  if (!data.byte_length())
+    return Status::Error();
+
+  return crypto->PlatformDecryptRsaEsPkcs1v1_5(private_key, data, buffer);
+}
+
+Status SignHmac(PlatformCrypto* crypto,
+                const blink::WebCryptoAlgorithm& algorithm,
+                const blink::WebCryptoKey& key,
+                const CryptoData& data,
+                blink::WebArrayBuffer* buffer) {
+  PlatformSymKey* sym_key = crypto->ToSymKey(key);
+  if (!sym_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoHmacParams* params = algorithm.hmacParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  if (!IsHashAlgorithm(params->hash().id()))
+    return Status::ErrorUnexpected();
+
+  if (params->hash().id() != GetInnerHashAlgorithm(key.algorithm()).id())
+    return Status::ErrorKeyAlgorithmMismatch();
+
+  return crypto->PlatformSignHmac(sym_key, params->hash(), data, buffer);
+}
+
+Status VerifyHmac(PlatformCrypto* crypto,
+                  const blink::WebCryptoAlgorithm& algorithm,
+                  const blink::WebCryptoKey& key,
+                  const CryptoData& signature,
+                  const CryptoData& data,
+                  bool* signature_match) {
+  blink::WebArrayBuffer result;
+  Status status = SignHmac(crypto, algorithm, key, data, &result);
+  if (status.IsError())
+    return status;
+
+  // Do not allow verification of truncated signatures.
+  *signature_match =
+      result.byteLength() == signature.byte_length() &&
+      crypto::SecureMemEqual(
+          result.data(), signature.bytes(), signature.byte_length());
+
+  return Status::Success();
+}
+
+Status SignRsaSsaPkcs1v1_5(PlatformCrypto* crypto,
+                           const blink::WebCryptoAlgorithm& algorithm,
+                           const blink::WebCryptoKey& key,
+                           const CryptoData& data,
+                           blink::WebArrayBuffer* buffer) {
+  PlatformPrivateKey* private_key = crypto->ToPrivateKey(key);
+  if (!private_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoRsaSsaParams* params = algorithm.rsaSsaParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  if (!IsHashAlgorithm(params->hash().id()))
+    return Status::ErrorUnexpected();
+
+  // TODO(eroman): Verify the key has not been used with any other hash.
+
+  return crypto->PlatformSignRsaSsaPkcs1v1_5(
+      private_key, params->hash(), data, buffer);
+}
+
+Status VerifyRsaSsaPkcs1v1_5(PlatformCrypto* crypto,
+                             const blink::WebCryptoAlgorithm& algorithm,
+                             const blink::WebCryptoKey& key,
+                             const CryptoData& signature,
+                             const CryptoData& data,
+                             bool* signature_match) {
+  PlatformPublicKey* public_key = crypto->ToPublicKey(key);
+  if (!public_key)
+    return Status::ErrorUnexpectedKeyType();
+
+  const blink::WebCryptoRsaSsaParams* params = algorithm.rsaSsaParams();
+  if (!params)
+    return Status::ErrorUnexpected();
+
+  if (!IsHashAlgorithm(params->hash().id()))
+    return Status::ErrorUnexpected();
+
+  // TODO(eroman): Verify the key has not been used with any other hash.
+
+  return crypto->PlatformVerifyRsaSsaPkcs1v1_5(
+      public_key, params->hash(), signature, data, signature_match);
+}
+
+Status ImportKeyRaw(PlatformCrypto* crypto,
+                    const CryptoData& key_data,
+                    const blink::WebCryptoAlgorithm& algorithm_or_null,
+                    bool extractable,
+                    blink::WebCryptoKeyUsageMask usage_mask,
+                    blink::WebCryptoKey* key) {
+  if (algorithm_or_null.isNull())
+    return Status::ErrorMissingAlgorithmImportRawKey();
+
+  switch (algorithm_or_null.id()) {
+    case blink::WebCryptoAlgorithmIdAesCbc:
+      if (key_data.byte_length() != 16 && key_data.byte_length() != 24 &&
+          key_data.byte_length() != 32) {
+        return Status::Error();
+      }
+    // Fallthrough intentional!
+    case blink::WebCryptoAlgorithmIdHmac:
+    case blink::WebCryptoAlgorithmIdAesKw:
+    case blink::WebCryptoAlgorithmIdAesGcm:
+      return crypto->PlatformImportKeyRaw(
+          key_data, algorithm_or_null, extractable, usage_mask, key);
+
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+}  // namespace
+
+Status PlatformCrypto::Encrypt(const blink::WebCryptoAlgorithm& algorithm,
+                               const blink::WebCryptoKey& key,
+                               const CryptoData& data,
+                               blink::WebArrayBuffer* buffer) {
+  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageEncrypt))
+    return Status::ErrorUnexpected();
+  if (algorithm.id() != key.algorithm().id())
+    return Status::ErrorKeyAlgorithmMismatch();
+
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdAesCbc:
+      return EncryptAesCbc(this, algorithm, key, data, buffer);
+    case blink::WebCryptoAlgorithmIdAesGcm:
+      return EncryptAesGcm(this, algorithm, key, data, buffer);
+    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
+      return EncryptRsaEsPkcs1v1_5(this, algorithm, key, data, buffer);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::Decrypt(const blink::WebCryptoAlgorithm& algorithm,
+                               const blink::WebCryptoKey& key,
+                               const CryptoData& data,
+                               blink::WebArrayBuffer* buffer) {
+  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageDecrypt))
+    return Status::ErrorUnexpected();
+  if (algorithm.id() != key.algorithm().id())
+    return Status::ErrorKeyAlgorithmMismatch();
+
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdAesCbc:
+      return DecryptAesCbc(this, algorithm, key, data, buffer);
+    case blink::WebCryptoAlgorithmIdAesGcm:
+      return DecryptAesGcm(this, algorithm, key, data, buffer);
+    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
+      return DecryptRsaEsPkcs1v1_5(this, algorithm, key, data, buffer);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::Digest(const blink::WebCryptoAlgorithm& algorithm,
+                              const CryptoData& data,
+                              blink::WebArrayBuffer* buffer) {
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdSha1:
+    case blink::WebCryptoAlgorithmIdSha224:
+    case blink::WebCryptoAlgorithmIdSha256:
+    case blink::WebCryptoAlgorithmIdSha384:
+    case blink::WebCryptoAlgorithmIdSha512:
+      return PlatformDigestSha(algorithm.id(), data, buffer);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::GenerateSecretKey(
+    const blink::WebCryptoAlgorithm& algorithm,
+    bool extractable,
+    blink::WebCryptoKeyUsageMask usage_mask,
+    blink::WebCryptoKey* key) {
+  unsigned int keylen_bytes = 0;
+
+  // Get the secret key length in bytes from generation parameters.
+  // This resolves any defaults.
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdAesCbc:
+    case blink::WebCryptoAlgorithmIdAesGcm:
+    case blink::WebCryptoAlgorithmIdAesKw: {
+      if ((algorithm.aesKeyGenParams()->lengthBits() % 8) != 0)
+        return Status::ErrorGenerateKeyLength();
+      keylen_bytes = algorithm.aesKeyGenParams()->lengthBits() / 8;
+      break;
+    }
+    case blink::WebCryptoAlgorithmIdHmac: {
+      const blink::WebCryptoHmacKeyParams* params = algorithm.hmacKeyParams();
+      DCHECK(params);
+      if (params->hasLengthBytes()) {
+        keylen_bytes = params->optionalLengthBytes();
+      } else {
+        keylen_bytes = ShaBlockSizeBytes(params->hash().id());
+        if (keylen_bytes == 0)
+          return Status::ErrorUnsupported();
+      }
+      break;
+    }
+
+    default:
+      return Status::ErrorUnsupported();
+  }
+
+  // TODO(eroman): Is this correct? HMAC can import zero-length keys, so should
+  //               probably be able to allowed to generate them too.
+  if (keylen_bytes == 0)
+    return Status::ErrorGenerateKeyLength();
+
+  return PlatformGenerateSecretKey(
+      algorithm, extractable, usage_mask, keylen_bytes, key);
+}
+
+Status PlatformCrypto::GenerateKeyPair(
+    const blink::WebCryptoAlgorithm& algorithm,
+    bool extractable,
+    blink::WebCryptoKeyUsageMask usage_mask,
+    blink::WebCryptoKey* public_key,
+    blink::WebCryptoKey* private_key) {
+  // TODO(padolph): Handle other asymmetric algorithm key generation.
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
+    case blink::WebCryptoAlgorithmIdRsaOaep:
+    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
+      if (!algorithm.rsaKeyGenParams())
+        return Status::ErrorUnexpected();
+      return PlatformGenerateRsaKeyPair(
+          algorithm, extractable, usage_mask, public_key, private_key);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::ImportKey(
+    blink::WebCryptoKeyFormat format,
+    const CryptoData& key_data,
+    const blink::WebCryptoAlgorithm& algorithm_or_null,
+    bool extractable,
+    blink::WebCryptoKeyUsageMask usage_mask,
+    blink::WebCryptoKey* key) {
+  switch (format) {
+    case blink::WebCryptoKeyFormatRaw:
+      return ImportKeyRaw(
+          this, key_data, algorithm_or_null, extractable, usage_mask, key);
+      return PlatformImportKeyRaw(
+          key_data, algorithm_or_null, extractable, usage_mask, key);
+    case blink::WebCryptoKeyFormatSpki:
+      return PlatformImportKeySpki(
+          key_data, algorithm_or_null, extractable, usage_mask, key);
+    case blink::WebCryptoKeyFormatPkcs8:
+      return PlatformImportKeyPkcs8(
+          key_data, algorithm_or_null, extractable, usage_mask, key);
+    case blink::WebCryptoKeyFormatJwk:
+      return ImportKeyJwk(
+          key_data, algorithm_or_null, extractable, usage_mask, key);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::ExportKey(blink::WebCryptoKeyFormat format,
+                                 const blink::WebCryptoKey& key,
+                                 blink::WebArrayBuffer* buffer) {
+  if (!key.extractable())
+    return Status::ErrorKeyNotExtractable();
+
+  switch (format) {
+    case blink::WebCryptoKeyFormatRaw: {
+      PlatformSymKey* sym_key = ToSymKey(key);
+      if (!sym_key)
+        return Status::ErrorUnexpectedKeyType();
+      return PlatformExportKeyRaw(sym_key, buffer);
+    }
+    case blink::WebCryptoKeyFormatSpki: {
+      PlatformPublicKey* public_key = ToPublicKey(key);
+      if (!public_key)
+        return Status::ErrorUnexpectedKeyType();
+      return PlatformExportKeySpki(public_key, buffer);
+    }
+    case blink::WebCryptoKeyFormatPkcs8:
+    case blink::WebCryptoKeyFormatJwk:
+      // TODO(eroman):
+      return Status::ErrorUnsupported();
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::Sign(const blink::WebCryptoAlgorithm& algorithm,
+                            const blink::WebCryptoKey& key,
+                            const CryptoData& data,
+                            blink::WebArrayBuffer* buffer) {
+  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageSign))
+    return Status::ErrorUnexpected();
+  if (algorithm.id() != key.algorithm().id())
+    return Status::ErrorKeyAlgorithmMismatch();
+
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdHmac:
+      return SignHmac(this, algorithm, key, data, buffer);
+    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
+      return SignRsaSsaPkcs1v1_5(this, algorithm, key, data, buffer);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+Status PlatformCrypto::VerifySignature(
+    const blink::WebCryptoAlgorithm& algorithm,
+    const blink::WebCryptoKey& key,
+    const CryptoData& signature,
+    const CryptoData& data,
+    bool* signature_match) {
+  if (!KeyUsageAllows(key, blink::WebCryptoKeyUsageVerify))
+    return Status::ErrorUnexpected();
+  if (algorithm.id() != key.algorithm().id())
+    return Status::ErrorKeyAlgorithmMismatch();
+
+  if (!signature.byte_length()) {
+    // None of the algorithms generate valid zero-length signatures so this
+    // will necessarily fail verification. Early return to protect
+    // implementations from dealing with a NULL signature pointer.
+    *signature_match = false;
+    return Status::Success();
+  }
+
+  switch (algorithm.id()) {
+    case blink::WebCryptoAlgorithmIdHmac:
+      return VerifyHmac(this, algorithm, key, signature, data, signature_match);
+    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
+      return VerifyRsaSsaPkcs1v1_5(
+          this, algorithm, key, signature, data, signature_match);
+    default:
+      return Status::ErrorUnsupported();
+  }
+}
+
+}  // namespace webcrypto
+}  // namespace content