LCOV - code coverage report
Current view: top level - dom/base - SubtleCrypto.cpp (source / functions) Hit Total Coverage
Test: output.info Lines: 0 43 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 22 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
       3             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       5             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #include "mozilla/dom/SubtleCrypto.h"
       8             : 
       9             : #include "mozilla/dom/Promise.h"
      10             : #include "mozilla/dom/SubtleCryptoBinding.h"
      11             : #include "mozilla/dom/WebCryptoTask.h"
      12             : #include "mozilla/Telemetry.h"
      13             : 
      14             : namespace mozilla {
      15             : namespace dom {
      16             : 
      17           0 : NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(SubtleCrypto, mParent)
      18           0 : NS_IMPL_CYCLE_COLLECTING_ADDREF(SubtleCrypto)
      19           0 : NS_IMPL_CYCLE_COLLECTING_RELEASE(SubtleCrypto)
      20           0 : NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SubtleCrypto)
      21           0 :   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
      22           0 :   NS_INTERFACE_MAP_ENTRY(nsISupports)
      23           0 : NS_INTERFACE_MAP_END
      24             : 
      25             : 
      26             : 
      27           0 : SubtleCrypto::SubtleCrypto(nsIGlobalObject* aParent)
      28             :   : mParent(aParent)
      29           0 :   , mRecordedTelemetry(false)
      30             : {
      31           0 : }
      32             : 
      33             : JSObject*
      34           0 : SubtleCrypto::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
      35             : {
      36           0 :   return SubtleCryptoBinding::Wrap(aCx, this, aGivenProto);
      37             : }
      38             : 
      39             : void
      40           0 : SubtleCrypto::RecordTelemetryOnce() {
      41           0 :   if (mRecordedTelemetry) {
      42           0 :     return;
      43             :   }
      44             : 
      45           0 :   mRecordedTelemetry = true;
      46           0 :   JSObject* global = mParent->GetGlobalJSObject();
      47           0 :   bool isSecure = JS_GetIsSecureContext(js::GetObjectCompartment(global));
      48           0 :   Telemetry::Accumulate(Telemetry::WEBCRYPTO_METHOD_SECURE, isSecure);
      49             : }
      50             : 
      51             : #define SUBTLECRYPTO_METHOD_BODY(Operation, aRv, ...)                   \
      52             :   MOZ_ASSERT(mParent);                                                  \
      53             :   RefPtr<Promise> p = Promise::Create(mParent, aRv);                    \
      54             :   if (aRv.Failed()) {                                                   \
      55             :     return nullptr;                                                     \
      56             :   }                                                                     \
      57             :   RecordTelemetryOnce();                                                \
      58             :   RefPtr<WebCryptoTask> task =                                          \
      59             :     WebCryptoTask::Create ## Operation ## Task(__VA_ARGS__);            \
      60             :   task->DispatchWithPromise(p);                                         \
      61             :   return p.forget();
      62             : 
      63             : already_AddRefed<Promise>
      64           0 : SubtleCrypto::Encrypt(JSContext* cx,
      65             :                       const ObjectOrString& algorithm,
      66             :                       CryptoKey& key,
      67             :                       const CryptoOperationData& data,
      68             :                       ErrorResult& aRv)
      69             : {
      70           0 :   SUBTLECRYPTO_METHOD_BODY(Encrypt, aRv, cx, algorithm, key, data)
      71             : }
      72             : 
      73             : already_AddRefed<Promise>
      74           0 : SubtleCrypto::Decrypt(JSContext* cx,
      75             :                       const ObjectOrString& algorithm,
      76             :                       CryptoKey& key,
      77             :                       const CryptoOperationData& data,
      78             :                       ErrorResult& aRv)
      79             : {
      80           0 :   SUBTLECRYPTO_METHOD_BODY(Decrypt, aRv, cx, algorithm, key, data)
      81             : }
      82             : 
      83             : already_AddRefed<Promise>
      84           0 : SubtleCrypto::Sign(JSContext* cx,
      85             :                    const ObjectOrString& algorithm,
      86             :                    CryptoKey& key,
      87             :                    const CryptoOperationData& data,
      88             :                    ErrorResult& aRv)
      89             : {
      90           0 :   SUBTLECRYPTO_METHOD_BODY(Sign, aRv, cx, algorithm, key, data)
      91             : }
      92             : 
      93             : already_AddRefed<Promise>
      94           0 : SubtleCrypto::Verify(JSContext* cx,
      95             :                      const ObjectOrString& algorithm,
      96             :                      CryptoKey& key,
      97             :                      const CryptoOperationData& signature,
      98             :                      const CryptoOperationData& data,
      99             :                      ErrorResult& aRv)
     100             : {
     101           0 :   SUBTLECRYPTO_METHOD_BODY(Verify, aRv, cx, algorithm, key, signature, data)
     102             : }
     103             : 
     104             : already_AddRefed<Promise>
     105           0 : SubtleCrypto::Digest(JSContext* cx,
     106             :                      const ObjectOrString& algorithm,
     107             :                      const CryptoOperationData& data,
     108             :                      ErrorResult& aRv)
     109             : {
     110           0 :   SUBTLECRYPTO_METHOD_BODY(Digest, aRv, cx, algorithm, data)
     111             : }
     112             : 
     113             : 
     114             : already_AddRefed<Promise>
     115           0 : SubtleCrypto::ImportKey(JSContext* cx,
     116             :                         const nsAString& format,
     117             :                         JS::Handle<JSObject*> keyData,
     118             :                         const ObjectOrString& algorithm,
     119             :                         bool extractable,
     120             :                         const Sequence<nsString>& keyUsages,
     121             :                         ErrorResult& aRv)
     122             : {
     123           0 :   SUBTLECRYPTO_METHOD_BODY(ImportKey, aRv, mParent, cx, format, keyData,
     124             :                            algorithm, extractable, keyUsages)
     125             : }
     126             : 
     127             : already_AddRefed<Promise>
     128           0 : SubtleCrypto::ExportKey(const nsAString& format,
     129             :                         CryptoKey& key,
     130             :                         ErrorResult& aRv)
     131             : {
     132           0 :   SUBTLECRYPTO_METHOD_BODY(ExportKey, aRv, format, key)
     133             : }
     134             : 
     135             : already_AddRefed<Promise>
     136           0 : SubtleCrypto::GenerateKey(JSContext* cx, const ObjectOrString& algorithm,
     137             :                           bool extractable, const Sequence<nsString>& keyUsages,
     138             :                           ErrorResult& aRv)
     139             : {
     140           0 :   SUBTLECRYPTO_METHOD_BODY(GenerateKey, aRv, mParent, cx, algorithm,
     141             :                            extractable, keyUsages)
     142             : }
     143             : 
     144             : already_AddRefed<Promise>
     145           0 : SubtleCrypto::DeriveKey(JSContext* cx,
     146             :                         const ObjectOrString& algorithm,
     147             :                         CryptoKey& baseKey,
     148             :                         const ObjectOrString& derivedKeyType,
     149             :                         bool extractable, const Sequence<nsString>& keyUsages,
     150             :                         ErrorResult& aRv)
     151             : {
     152           0 :   SUBTLECRYPTO_METHOD_BODY(DeriveKey, aRv, mParent, cx, algorithm, baseKey,
     153             :                            derivedKeyType, extractable, keyUsages)
     154             : }
     155             : 
     156             : already_AddRefed<Promise>
     157           0 : SubtleCrypto::DeriveBits(JSContext* cx,
     158             :                          const ObjectOrString& algorithm,
     159             :                          CryptoKey& baseKey,
     160             :                          uint32_t length,
     161             :                          ErrorResult& aRv)
     162             : {
     163           0 :   SUBTLECRYPTO_METHOD_BODY(DeriveBits, aRv, cx, algorithm, baseKey, length)
     164             : }
     165             : 
     166             : already_AddRefed<Promise>
     167           0 : SubtleCrypto::WrapKey(JSContext* cx,
     168             :                       const nsAString& format,
     169             :                       CryptoKey& key,
     170             :                       CryptoKey& wrappingKey,
     171             :                       const ObjectOrString& wrapAlgorithm,
     172             :                       ErrorResult& aRv)
     173             : {
     174           0 :   SUBTLECRYPTO_METHOD_BODY(WrapKey, aRv, cx, format, key, wrappingKey, wrapAlgorithm)
     175             : }
     176             : 
     177             : already_AddRefed<Promise>
     178           0 : SubtleCrypto::UnwrapKey(JSContext* cx,
     179             :                         const nsAString& format,
     180             :                         const ArrayBufferViewOrArrayBuffer& wrappedKey,
     181             :                         CryptoKey& unwrappingKey,
     182             :                         const ObjectOrString& unwrapAlgorithm,
     183             :                         const ObjectOrString& unwrappedKeyAlgorithm,
     184             :                         bool extractable,
     185             :                         const Sequence<nsString>& keyUsages,
     186             :                         ErrorResult& aRv)
     187             : {
     188           0 :   SUBTLECRYPTO_METHOD_BODY(UnwrapKey, aRv, mParent, cx, format, wrappedKey,
     189             :                            unwrappingKey, unwrapAlgorithm,
     190             :                            unwrappedKeyAlgorithm, extractable, keyUsages)
     191             : }
     192             : 
     193             : } // namespace dom
     194             : } // namespace mozilla

Generated by: LCOV version 1.13