/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "hasht.h"
#include "mozilla/dom/CallbackFunction.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/CryptoBuffer.h"
#include "mozilla/dom/NSSU2FTokenRemote.h"
#include "mozilla/dom/U2F.h"
#include "mozilla/Preferences.h"
#include "mozilla/ReentrantMonitor.h"
#include "nsContentUtils.h"
#include "nsINSSU2FToken.h"
#include "nsNetCID.h"
#include "nsNSSComponent.h"
#include "nsURLParsers.h"
#include "nsXPCOMCIDInternal.h"
#include "pk11pub.h"

using mozilla::dom::ContentChild;

namespace mozilla {
namespace dom {

#define PREF_U2F_SOFTTOKEN_ENABLED "security.webauth.u2f_enable_softtoken"
#define PREF_U2F_USBTOKEN_ENABLED  "security.webauth.u2f_enable_usbtoken"

NS_NAMED_LITERAL_CSTRING(kPoolName, "WebAuth_U2F-IO");
NS_NAMED_LITERAL_STRING(kFinishEnrollment, "navigator.id.finishEnrollment");
NS_NAMED_LITERAL_STRING(kGetAssertion, "navigator.id.getAssertion");

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(U2F)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(U2F)
NS_IMPL_CYCLE_COLLECTING_RELEASE(U2F)

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(U2F, mParent)

static mozilla::LazyLogModule gWebauthLog("webauth_u2f");

static nsresult
AssembleClientData(const nsAString& aOrigin, const nsAString& aTyp,
                   const nsAString& aChallenge, CryptoBuffer& aClientData)
{
  MOZ_ASSERT(NS_IsMainThread());
  ClientData clientDataObject;
  clientDataObject.mTyp.Construct(aTyp); // "Typ" from the U2F specification
  clientDataObject.mChallenge.Construct(aChallenge);
  clientDataObject.mOrigin.Construct(aOrigin);

  nsAutoString json;
  if (NS_WARN_IF(!clientDataObject.ToJSON(json))) {
    return NS_ERROR_FAILURE;
  }

  if (NS_WARN_IF(!aClientData.Assign(NS_ConvertUTF16toUTF8(json)))) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  return NS_OK;
}

U2FStatus::U2FStatus()
  : mCount(0)
  , mIsStopped(false)
  , mReentrantMonitor("U2FStatus")
{}

U2FStatus::~U2FStatus()
{}

void
U2FStatus::WaitGroupAdd()
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);

  mCount += 1;
  MOZ_LOG(gWebauthLog, LogLevel::Debug,
          ("U2FStatus::WaitGroupAdd, now %d", mCount));
}

void
U2FStatus::WaitGroupDone()
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);

  MOZ_ASSERT(mCount > 0);
  mCount -= 1;
  MOZ_LOG(gWebauthLog, LogLevel::Debug,
          ("U2FStatus::WaitGroupDone, now %d", mCount));
  if (mCount == 0) {
    mReentrantMonitor.NotifyAll();
  }
}

void
U2FStatus::WaitGroupWait()
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
  MOZ_LOG(gWebauthLog, LogLevel::Debug,
          ("U2FStatus::WaitGroupWait, now %d", mCount));

  while (mCount > 0) {
    mReentrantMonitor.Wait();
  }

  MOZ_ASSERT(mCount == 0);
  MOZ_LOG(gWebauthLog, LogLevel::Debug,
          ("U2FStatus::Wait completed, now count=%d stopped=%d", mCount,
           mIsStopped));
}

void
U2FStatus::Stop(const ErrorCode aErrorCode)
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
  MOZ_ASSERT(!mIsStopped);
  mIsStopped = true;
  mErrorCode = aErrorCode;

  // TODO: Let WaitGroupWait exit early upon a Stop. Requires consideration of
  // threads calling IsStopped() followed by WaitGroupDone(). Right now, Stop
  // prompts work tasks to end early, but it could also prompt an immediate
  // "Go ahead" to the thread waiting at WaitGroupWait.
}

void
U2FStatus::Stop(const ErrorCode aErrorCode, const nsAString& aResponse)
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
  Stop(aErrorCode);
  mResponse = aResponse;
}

bool
U2FStatus::IsStopped()
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
  return mIsStopped;
}

ErrorCode
U2FStatus::GetErrorCode()
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
  MOZ_ASSERT(mIsStopped);
  return mErrorCode;
}

nsString
U2FStatus::GetResponse()
{
  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
  MOZ_ASSERT(mIsStopped);
  return mResponse;
}

U2FTask::U2FTask(const nsAString& aOrigin, const nsAString& aAppId,
                 const Authenticator& aAuthenticator)
  : mOrigin(aOrigin)
  , mAppId(aAppId)
  , mAuthenticator(aAuthenticator)
{}

U2FTask::~U2FTask()
{}

RefPtr<U2FPromise>
U2FTask::Execute()
{
  RefPtr<U2FPromise> p = mPromise.Ensure(__func__);

  nsCOMPtr<nsIRunnable> r(this);

  // TODO: Use a thread pool here, but we have to solve the PContentChild issues
  // of being in a worker thread.
  AbstractThread::MainThread()->Dispatch(r.forget());
  return p;
}

U2FPrepTask::U2FPrepTask(const Authenticator& aAuthenticator)
  : mAuthenticator(aAuthenticator)
{}

U2FPrepTask::~U2FPrepTask()
{}

RefPtr<U2FPrepPromise>
U2FPrepTask::Execute()
{
  RefPtr<U2FPrepPromise> p = mPromise.Ensure(__func__);

  nsCOMPtr<nsIRunnable> r(this);

  // TODO: Use a thread pool here, but we have to solve the PContentChild issues
  // of being in a worker thread.
  AbstractThread::MainThread()->Dispatch(r.forget());
  return p;
}

U2FIsRegisteredTask::U2FIsRegisteredTask(const Authenticator& aAuthenticator,
                                         const LocalRegisteredKey& aRegisteredKey)
  : U2FPrepTask(aAuthenticator)
  , mRegisteredKey(aRegisteredKey)
{}

U2FIsRegisteredTask::~U2FIsRegisteredTask()
{}

NS_IMETHODIMP
U2FIsRegisteredTask::Run()
{
  bool isCompatible = false;
  nsresult rv = mAuthenticator->IsCompatibleVersion(mRegisteredKey.mVersion,
                                                    &isCompatible);
  if (NS_FAILED(rv)) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  if (!isCompatible) {
    mPromise.Reject(ErrorCode::BAD_REQUEST, __func__);
    return NS_ERROR_FAILURE;
  }

  // Decode the key handle
  CryptoBuffer keyHandle;
  rv = keyHandle.FromJwkBase64(mRegisteredKey.mKeyHandle);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    mPromise.Reject(ErrorCode::BAD_REQUEST, __func__);
    return NS_ERROR_FAILURE;
  }

  // We ignore mTransports, as it is intended to be used for sorting the
  // available devices by preference, but is not an exclusion factor.

  bool isRegistered = false;
  rv = mAuthenticator->IsRegistered(keyHandle.Elements(), keyHandle.Length(),
                                    &isRegistered);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  if (isRegistered) {
    mPromise.Reject(ErrorCode::DEVICE_INELIGIBLE, __func__);
    return NS_OK;
  }

  mPromise.Resolve(mAuthenticator, __func__);
  return NS_OK;
}

U2FRegisterTask::U2FRegisterTask(const nsAString& aOrigin,
                                 const nsAString& aAppId,
                                 const Authenticator& aAuthenticator,
                                 const CryptoBuffer& aAppParam,
                                 const CryptoBuffer& aChallengeParam,
                                 const LocalRegisterRequest& aRegisterEntry)
  : U2FTask(aOrigin, aAppId, aAuthenticator)
  , mAppParam(aAppParam)
  , mChallengeParam(aChallengeParam)
  , mRegisterEntry(aRegisterEntry)
{}

U2FRegisterTask::~U2FRegisterTask()
{}

NS_IMETHODIMP
U2FRegisterTask::Run()
{
  bool isCompatible = false;
  nsresult rv = mAuthenticator->IsCompatibleVersion(mRegisterEntry.mVersion,
                                                    &isCompatible);
  if (NS_FAILED(rv)) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  if (!isCompatible) {
    mPromise.Reject(ErrorCode::BAD_REQUEST, __func__);
    return NS_ERROR_FAILURE;
  }

  uint8_t* buffer;
  uint32_t bufferlen;
  rv = mAuthenticator->Register(mAppParam.Elements(),
                                mAppParam.Length(),
                                mChallengeParam.Elements(),
                                mChallengeParam.Length(),
                                &buffer, &bufferlen);
  if (NS_WARN_IF(NS_FAILED(rv)))  {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  MOZ_ASSERT(buffer);
  CryptoBuffer regData;
  if (NS_WARN_IF(!regData.Assign(buffer, bufferlen))) {
    free(buffer);
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_OUT_OF_MEMORY;
  }
  free(buffer);

  // Assemble a response object to return
  nsString clientDataBase64;
  nsString registrationDataBase64;
  nsresult rvClientData = mRegisterEntry.mClientData.ToJwkBase64(clientDataBase64);
  nsresult rvRegistrationData = regData.ToJwkBase64(registrationDataBase64);

  if (NS_WARN_IF(NS_FAILED(rvClientData)) ||
      NS_WARN_IF(NS_FAILED(rvRegistrationData))) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  RegisterResponse response;
  response.mClientData.Construct(clientDataBase64);
  response.mRegistrationData.Construct(registrationDataBase64);
  response.mErrorCode.Construct(static_cast<uint32_t>(ErrorCode::OK));

  nsString responseStr;
  if (NS_WARN_IF(!response.ToJSON(responseStr))) {
    return NS_ERROR_FAILURE;
  }
  mPromise.Resolve(responseStr, __func__);
  return NS_OK;
}

U2FSignTask::U2FSignTask(const nsAString& aOrigin,
                         const nsAString& aAppId,
                         const nsAString& aVersion,
                         const Authenticator& aAuthenticator,
                         const CryptoBuffer& aAppParam,
                         const CryptoBuffer& aChallengeParam,
                         const CryptoBuffer& aClientData,
                         const CryptoBuffer& aKeyHandle)
  : U2FTask(aOrigin, aAppId, aAuthenticator)
  , mVersion(aVersion)
  , mAppParam(aAppParam)
  , mChallengeParam(aChallengeParam)
  , mClientData(aClientData)
  , mKeyHandle(aKeyHandle)
{}

U2FSignTask::~U2FSignTask()
{}

NS_IMETHODIMP
U2FSignTask::Run()
{
  bool isCompatible = false;
  nsresult rv = mAuthenticator->IsCompatibleVersion(mVersion, &isCompatible);
  if (NS_FAILED(rv)) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  if (!isCompatible) {
    mPromise.Reject(ErrorCode::BAD_REQUEST, __func__);
    return NS_ERROR_FAILURE;
  }

  bool isRegistered = false;
  rv = mAuthenticator->IsRegistered(mKeyHandle.Elements(), mKeyHandle.Length(),
                                    &isRegistered);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  if (!isRegistered) {
    mPromise.Reject(ErrorCode::DEVICE_INELIGIBLE, __func__);
    return NS_OK;
  }

  CryptoBuffer signatureData;
  uint8_t* buffer;
  uint32_t bufferlen;
  rv = mAuthenticator->Sign(mAppParam.Elements(), mAppParam.Length(),
                            mChallengeParam.Elements(), mChallengeParam.Length(),
                            mKeyHandle.Elements(), mKeyHandle.Length(),
                            &buffer, &bufferlen);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  MOZ_ASSERT(buffer);
  if (NS_WARN_IF(!signatureData.Assign(buffer, bufferlen))) {
    free(buffer);
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_OUT_OF_MEMORY;
  }
  free(buffer);

  // Assemble a response object to return
  nsString clientDataBase64;
  nsString signatureDataBase64;
  nsString keyHandleBase64;
  nsresult rvClientData = mClientData.ToJwkBase64(clientDataBase64);
  nsresult rvSignatureData = signatureData.ToJwkBase64(signatureDataBase64);
  nsresult rvKeyHandle = mKeyHandle.ToJwkBase64(keyHandleBase64);
  if (NS_WARN_IF(NS_FAILED(rvClientData)) ||
      NS_WARN_IF(NS_FAILED(rvSignatureData) ||
      NS_WARN_IF(NS_FAILED(rvKeyHandle)))) {
    mPromise.Reject(ErrorCode::OTHER_ERROR, __func__);
    return NS_ERROR_FAILURE;
  }

  SignResponse response;
  response.mKeyHandle.Construct(keyHandleBase64);
  response.mClientData.Construct(clientDataBase64);
  response.mSignatureData.Construct(signatureDataBase64);
  response.mErrorCode.Construct(static_cast<uint32_t>(ErrorCode::OK));

  nsString responseStr;
  if (NS_WARN_IF(!response.ToJSON(responseStr))) {
    return NS_ERROR_FAILURE;
  }
  mPromise.Resolve(responseStr, __func__);
  return NS_OK;
}

U2FRunnable::U2FRunnable(const nsAString& aOrigin, const nsAString& aAppId)
  : mOrigin(aOrigin)
  , mAppId(aAppId)
{}

U2FRunnable::~U2FRunnable()
{}

// EvaluateAppIDAndRunTask determines whether the supplied FIDO AppID is valid for
// the current FacetID, e.g., the current origin.
// See https://fidoalliance.org/specs/fido-u2f-v1.0-nfc-bt-amendment-20150514/fido-appid-and-facets.html
// for a description of the algorithm.
ErrorCode
U2FRunnable::EvaluateAppID()
{
  nsCOMPtr<nsIURLParser> urlParser =
      do_GetService(NS_STDURLPARSER_CONTRACTID);

  MOZ_ASSERT(urlParser);

  uint32_t facetSchemePos;
  int32_t facetSchemeLen;
  uint32_t facetAuthPos;
  int32_t facetAuthLen;
  // Facet is the specification's way of referring to the web origin.
  nsAutoCString facetUrl = NS_ConvertUTF16toUTF8(mOrigin);
  nsresult rv = urlParser->ParseURL(facetUrl.get(), mOrigin.Length(),
                                    &facetSchemePos, &facetSchemeLen,
                                    &facetAuthPos, &facetAuthLen,
                                    nullptr, nullptr);      // ignore path
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return ErrorCode::BAD_REQUEST;
  }

  nsAutoCString facetScheme(Substring(facetUrl, facetSchemePos, facetSchemeLen));
  nsAutoCString facetAuth(Substring(facetUrl, facetAuthPos, facetAuthLen));

  uint32_t appIdSchemePos;
  int32_t appIdSchemeLen;
  uint32_t appIdAuthPos;
  int32_t appIdAuthLen;
  // AppID is user-supplied. It's quite possible for this parse to fail.
  nsAutoCString appIdUrl = NS_ConvertUTF16toUTF8(mAppId);
  rv = urlParser->ParseURL(appIdUrl.get(), mAppId.Length(),
                           &appIdSchemePos, &appIdSchemeLen,
                           &appIdAuthPos, &appIdAuthLen,
                           nullptr, nullptr);      // ignore path
  if (NS_FAILED(rv)) {
    return ErrorCode::BAD_REQUEST;
  }

  nsAutoCString appIdScheme(Substring(appIdUrl, appIdSchemePos, appIdSchemeLen));
  nsAutoCString appIdAuth(Substring(appIdUrl, appIdAuthPos, appIdAuthLen));

  // If the facetId (origin) is not HTTPS, reject
  if (!facetScheme.LowerCaseEqualsLiteral("https")) {
    return ErrorCode::BAD_REQUEST;
  }

  // If the appId is empty or null, overwrite it with the facetId and accept
  if (mAppId.IsEmpty() || mAppId.EqualsLiteral("null")) {
    mAppId.Assign(mOrigin);
    return ErrorCode::OK;
  }

  // if the appId URL is not HTTPS, reject.
  if (!appIdScheme.LowerCaseEqualsLiteral("https")) {
    return ErrorCode::BAD_REQUEST;
  }

  // If the facetId and the appId auths match, accept
  if (facetAuth == appIdAuth) {
    return ErrorCode::OK;
  }

  // TODO(Bug 1244959) Implement the remaining algorithm.
  return ErrorCode::BAD_REQUEST;
}

U2FRegisterRunnable::U2FRegisterRunnable(const nsAString& aOrigin,
                                         const nsAString& aAppId,
                                         const Sequence<RegisterRequest>& aRegisterRequests,
                                         const Sequence<RegisteredKey>& aRegisteredKeys,
                                         const Sequence<Authenticator>& aAuthenticators,
                                         U2FRegisterCallback* aCallback)
  : U2FRunnable(aOrigin, aAppId)
  , mAuthenticators(aAuthenticators)
  // U2FRegisterCallback does not support threadsafe refcounting, and must be
  // used and destroyed on main.
  , mCallback(new nsMainThreadPtrHolder<U2FRegisterCallback>(aCallback))
{
  MOZ_ASSERT(NS_IsMainThread());

  // The WebIDL dictionary types RegisterRequest and RegisteredKey cannot
  // be copied to this thread, so store them serialized.
  for (size_t i = 0; i < aRegisterRequests.Length(); ++i) {
    RegisterRequest req(aRegisterRequests[i]);

    // Check for required attributes
    if (!req.mChallenge.WasPassed() || !req.mVersion.WasPassed()) {
      continue;
    }

    LocalRegisterRequest localReq;
    localReq.mVersion = req.mVersion.Value();
    localReq.mChallenge = req.mChallenge.Value();

    nsresult rv = AssembleClientData(mOrigin, kFinishEnrollment,
                                     localReq.mChallenge, localReq.mClientData);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      continue;
    }

    mRegisterRequests.AppendElement(localReq);
  }

  for (size_t i = 0; i < aRegisteredKeys.Length(); ++i) {
    RegisteredKey key(aRegisteredKeys[i]);

    // Check for required attributes
    if (!key.mVersion.WasPassed() || !key.mKeyHandle.WasPassed()) {
      continue;
    }

    LocalRegisteredKey localKey;
    localKey.mVersion = key.mVersion.Value();
    localKey.mKeyHandle = key.mKeyHandle.Value();
    if (key.mAppId.WasPassed()) {
      localKey.mAppId.SetValue(key.mAppId.Value());
    }

    mRegisteredKeys.AppendElement(localKey);
  }
}

U2FRegisterRunnable::~U2FRegisterRunnable()
{
  nsNSSShutDownPreventionLock locker;

  if (isAlreadyShutDown()) {
    return;
  }
  shutdown(ShutdownCalledFrom::Object);
}

void
U2FRegisterRunnable::SetTimeout(const int32_t aTimeoutMillis)
{
  opt_mTimeoutSeconds.SetValue(aTimeoutMillis);
}

void
U2FRegisterRunnable::SendResponse(const RegisterResponse& aResponse)
{
  MOZ_ASSERT(NS_IsMainThread());

  ErrorResult rv;
  mCallback->Call(aResponse, rv);
  NS_WARNING_ASSERTION(!rv.Failed(), "callback failed");
  // Useful exceptions already got reported.
  rv.SuppressException();
}

NS_IMETHODIMP
U2FRegisterRunnable::Run()
{
  MOZ_ASSERT(!NS_IsMainThread());

  nsNSSShutDownPreventionLock locker;
  if (isAlreadyShutDown()) {
    return NS_ERROR_FAILURE;
  }

  // Create a Status object to keep track of when we're done
  RefPtr<U2FStatus> status = new U2FStatus();

  // Evaluate the AppID
  ErrorCode appIdResult = EvaluateAppID();
  if (appIdResult != ErrorCode::OK) {
    status->Stop(appIdResult);
  }

  // First, we must determine if any of the RegisteredKeys are already
  // registered, e.g., in the whitelist.
  for (LocalRegisteredKey key: mRegisteredKeys) {
    nsTArray<RefPtr<U2FPrepPromise>> prepPromiseList;
    for (size_t a = 0; a < mAuthenticators.Length(); ++a) {
      Authenticator token(mAuthenticators[a]);
      RefPtr<U2FIsRegisteredTask> compTask = new U2FIsRegisteredTask(token, key);
      prepPromiseList.AppendElement(compTask->Execute());
    }

    // Treat each call to Promise::All as a work unit, as it completes together
    status->WaitGroupAdd();

    U2FPrepPromise::All(AbstractThread::MainThread(), prepPromiseList)
    ->Then(AbstractThread::MainThread(), __func__,
      [status] (const nsTArray<Authenticator>& aTokens) {
        MOZ_LOG(gWebauthLog, LogLevel::Debug,
                ("ALL: None of the RegisteredKeys were recognized. n=%d",
                 aTokens.Length()));

        status->WaitGroupDone();
      },
      [status] (ErrorCode aErrorCode) {
        status->Stop(aErrorCode);
        status->WaitGroupDone();
    });
  }

  // Wait for all the IsRegistered tasks to complete
  status->WaitGroupWait();

  // Check to see whether we're supposed to stop, because one of the keys was
  // recognized.
  if (status->IsStopped()) {
    status->WaitGroupAdd();
    RefPtr<U2FRegisterRunnable> self = this;
    AbstractThread::MainThread()->Dispatch(NS_NewRunnableFunction(
      [status, self] () {
        RegisterResponse response;
        response.mErrorCode.Construct(
            static_cast<uint32_t>(status->GetErrorCode()));
        self->SendResponse(response);
        status->WaitGroupDone();
      }
    ));

    // Don't exit until the main thread runnable completes
    status->WaitGroupWait();
    return NS_OK;
  }

  // Since we're continuing, we hash the AppID into the AppParam
  nsCString cAppId = NS_ConvertUTF16toUTF8(mAppId);
  CryptoBuffer appParam;
  if (!appParam.SetLength(SHA256_LENGTH, fallible)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  // Note: This could use nsICryptoHash to avoid having to interact with NSS
  // directly.
  SECStatus srv;
  srv = PK11_HashBuf(SEC_OID_SHA256, appParam.Elements(),
                     reinterpret_cast<const uint8_t*>(cAppId.BeginReading()),
                     cAppId.Length());
  if (srv != SECSuccess) {
    return NS_ERROR_FAILURE;
  }

  // Now proceed to actually register a new key.
  for (LocalRegisterRequest req : mRegisterRequests) {
    // Hash the ClientData into the ChallengeParam
    CryptoBuffer challengeParam;
    if (!challengeParam.SetLength(SHA256_LENGTH, fallible)) {
      continue;
    }

    srv = PK11_HashBuf(SEC_OID_SHA256, challengeParam.Elements(),
                       req.mClientData.Elements(), req.mClientData.Length());
    if (srv != SECSuccess) {
      continue;
    }

    for (size_t a = 0; a < mAuthenticators.Length(); ++a) {
      Authenticator token(mAuthenticators[a]);
      RefPtr<U2FRegisterTask> registerTask = new U2FRegisterTask(mOrigin, mAppId,
                                                                 token, appParam,
                                                                 challengeParam,
                                                                 req);
      status->WaitGroupAdd();

      registerTask->Execute()->Then(AbstractThread::MainThread(), __func__,
        [status, this] (nsString aResponse) {
          if (status->IsStopped()) {
            return;
          }
          status->Stop(ErrorCode::OK, aResponse);
          status->WaitGroupDone();
        },
        [status, this] (ErrorCode aErrorCode) {
          if (status->IsStopped()) {
            return;
          }
          status->Stop(aErrorCode);
          status->WaitGroupDone();
     });
    }
  }

  // Wait until the first key is successfuly generated
  status->WaitGroupWait();

  // If none of the tasks completed, then nothing could satisfy.
  if (!status->IsStopped()) {
    status->Stop(ErrorCode::BAD_REQUEST);
  }

  // Transmit back to the JS engine from the Main Thread
  status->WaitGroupAdd();
  RefPtr<U2FRegisterRunnable> self = this;
  AbstractThread::MainThread()->Dispatch(NS_NewRunnableFunction(
    [status, self] () {
      RegisterResponse response;
      if (status->GetErrorCode() == ErrorCode::OK) {
        response.Init(status->GetResponse());
      } else {
        response.mErrorCode.Construct(
            static_cast<uint32_t>(status->GetErrorCode()));
      }
      self->SendResponse(response);
      status->WaitGroupDone();
    }
  ));

  // TODO: Add timeouts, Bug 1301793
  status->WaitGroupWait();
  return NS_OK;
}

U2FSignRunnable::U2FSignRunnable(const nsAString& aOrigin,
                                 const nsAString& aAppId,
                                 const nsAString& aChallenge,
                                 const Sequence<RegisteredKey>& aRegisteredKeys,
                                 const Sequence<Authenticator>& aAuthenticators,
                                 U2FSignCallback* aCallback)
  : U2FRunnable(aOrigin, aAppId)
  , mAuthenticators(aAuthenticators)
  // U2FSignCallback does not support threadsafe refcounting, and must be used
  // and destroyed on main.
  , mCallback(new nsMainThreadPtrHolder<U2FSignCallback>(aCallback))
{
  MOZ_ASSERT(NS_IsMainThread());

  // Convert WebIDL objects to generic structs to pass between threads
  for (size_t i = 0; i < aRegisteredKeys.Length(); ++i) {
    RegisteredKey key(aRegisteredKeys[i]);

    // Check for required attributes
    if (!key.mVersion.WasPassed() || !key.mKeyHandle.WasPassed()) {
      continue;
    }

    LocalRegisteredKey localKey;
    localKey.mVersion = key.mVersion.Value();
    localKey.mKeyHandle = key.mKeyHandle.Value();
    if (key.mAppId.WasPassed()) {
      localKey.mAppId.SetValue(key.mAppId.Value());
    }

    mRegisteredKeys.AppendElement(localKey);
  }

  // Assemble a clientData object
  nsresult rv = AssembleClientData(aOrigin, kGetAssertion, aChallenge,
                                   mClientData);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    MOZ_LOG(gWebauthLog, LogLevel::Warning,
            ("Failed to AssembleClientData for the U2FSignRunnable."));
    return;
  }
}

U2FSignRunnable::~U2FSignRunnable()
{
  nsNSSShutDownPreventionLock locker;

  if (isAlreadyShutDown()) {
    return;
  }
  shutdown(ShutdownCalledFrom::Object);
}

void
U2FSignRunnable::SetTimeout(const int32_t aTimeoutMillis)
{
  opt_mTimeoutSeconds.SetValue(aTimeoutMillis);
}

void
U2FSignRunnable::SendResponse(const SignResponse& aResponse)
{
  MOZ_ASSERT(NS_IsMainThread());

  ErrorResult rv;
  mCallback->Call(aResponse, rv);
  NS_WARNING_ASSERTION(!rv.Failed(), "callback failed");
  // Useful exceptions already got reported.
  rv.SuppressException();
}

NS_IMETHODIMP
U2FSignRunnable::Run()
{
  MOZ_ASSERT(!NS_IsMainThread());

  nsNSSShutDownPreventionLock locker;
  if (isAlreadyShutDown()) {
    return NS_ERROR_FAILURE;
  }

  // Create a Status object to keep track of when we're done
  RefPtr<U2FStatus> status = new U2FStatus();

  // Evaluate the AppID
  ErrorCode appIdResult = EvaluateAppID();
  if (appIdResult != ErrorCode::OK) {
    status->Stop(appIdResult);
  }

  // Hash the AppID and the ClientData into the AppParam and ChallengeParam
  nsCString cAppId = NS_ConvertUTF16toUTF8(mAppId);
  CryptoBuffer appParam;
  CryptoBuffer challengeParam;
  if (!appParam.SetLength(SHA256_LENGTH, fallible) ||
      !challengeParam.SetLength(SHA256_LENGTH, fallible)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  SECStatus srv;
  srv = PK11_HashBuf(SEC_OID_SHA256, appParam.Elements(),
                     reinterpret_cast<const uint8_t*>(cAppId.BeginReading()),
                     cAppId.Length());
  if (srv != SECSuccess) {
    return NS_ERROR_FAILURE;
  }

  srv = PK11_HashBuf(SEC_OID_SHA256, challengeParam.Elements(),
                     mClientData.Elements(), mClientData.Length());
  if (srv != SECSuccess) {
    return NS_ERROR_FAILURE;
  }

  // Search the signing requests for one a token can fulfill
  for (LocalRegisteredKey key : mRegisteredKeys) {
    // Do not permit an individual RegisteredKey to assert a different AppID
    if (!key.mAppId.IsNull() && mAppId != key.mAppId.Value()) {
      continue;
    }

    // Decode the key handle
    CryptoBuffer keyHandle;
    nsresult rv = keyHandle.FromJwkBase64(key.mKeyHandle);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      continue;
    }

    // We ignore mTransports, as it is intended to be used for sorting the
    // available devices by preference, but is not an exclusion factor.

    for (size_t a = 0; a < mAuthenticators.Length() ; ++a) {
      Authenticator token(mAuthenticators[a]);

      RefPtr<U2FSignTask> signTask = new U2FSignTask(mOrigin, mAppId,
                                                     key.mVersion, token,
                                                     appParam, challengeParam,
                                                     mClientData, keyHandle);
      status->WaitGroupAdd();

      signTask->Execute()->Then(AbstractThread::MainThread(), __func__,
        [status, this] (nsString aResponse) {
          if (status->IsStopped()) {
            return;
          }
          status->Stop(ErrorCode::OK, aResponse);
          status->WaitGroupDone();
        },
        [status, this] (ErrorCode aErrorCode) {
          if (status->IsStopped()) {
            return;
          }
          status->Stop(aErrorCode);
          status->WaitGroupDone();
      });
    }
  }

  // Wait for the authenticators to finish
  status->WaitGroupWait();

  // If none of the tasks completed, then nothing could satisfy.
  if (!status->IsStopped()) {
    status->Stop(ErrorCode::DEVICE_INELIGIBLE);
  }

  // Transmit back to the JS engine from the Main Thread
  status->WaitGroupAdd();
  RefPtr<U2FSignRunnable> self = this;
  AbstractThread::MainThread()->Dispatch(NS_NewRunnableFunction(
    [status, self] () {
      SignResponse response;
      if (status->GetErrorCode() == ErrorCode::OK) {
        response.Init(status->GetResponse());
      } else {
        response.mErrorCode.Construct(
          static_cast<uint32_t>(status->GetErrorCode()));
      }
      self->SendResponse(response);
      status->WaitGroupDone();
    }
  ));

  // TODO: Add timeouts, Bug 1301793
  status->WaitGroupWait();
  return NS_OK;
}

U2F::U2F()
  : mInitialized(false)
{}

U2F::~U2F()
{
  nsNSSShutDownPreventionLock locker;

  if (isAlreadyShutDown()) {
    return;
  }
  shutdown(ShutdownCalledFrom::Object);
}

/* virtual */ JSObject*
U2F::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
  return U2FBinding::Wrap(aCx, this, aGivenProto);
}

void
U2F::Init(nsPIDOMWindowInner* aParent, ErrorResult& aRv)
{
  MOZ_ASSERT(!mInitialized);
  MOZ_ASSERT(!mParent);
  mParent = do_QueryInterface(aParent);
  MOZ_ASSERT(mParent);

  nsCOMPtr<nsIDocument> doc = mParent->GetDoc();
  MOZ_ASSERT(doc);

  nsIPrincipal* principal = doc->NodePrincipal();
  aRv = nsContentUtils::GetUTFOrigin(principal, mOrigin);
  if (NS_WARN_IF(aRv.Failed())) {
    return;
  }

  if (NS_WARN_IF(mOrigin.IsEmpty())) {
    aRv.Throw(NS_ERROR_FAILURE);
    return;
  }

  if (!EnsureNSSInitializedChromeOrContent()) {
    MOZ_LOG(gWebauthLog, LogLevel::Debug,
            ("Failed to get NSS context for U2F"));
    aRv.Throw(NS_ERROR_FAILURE);
    return;
  }

  // This only functions in e10s mode
  if (XRE_IsParentProcess()) {
    MOZ_LOG(gWebauthLog, LogLevel::Debug,
            ("Is non-e10s Process, U2F not available"));
    aRv.Throw(NS_ERROR_FAILURE);
    return;
  }

  // Monolithically insert compatible nsIU2FToken objects into mAuthenticators.
  // In future functionality expansions, this is where we could add a dynamic
  // add/remove interface.
  if (Preferences::GetBool(PREF_U2F_SOFTTOKEN_ENABLED)) {
    if (!mAuthenticators.AppendElement(new NSSU2FTokenRemote(),
                                       mozilla::fallible)) {
      aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
      return;
    }
  }

  mInitialized = true;
}

void
U2F::Register(const nsAString& aAppId,
              const Sequence<RegisterRequest>& aRegisterRequests,
              const Sequence<RegisteredKey>& aRegisteredKeys,
              U2FRegisterCallback& aCallback,
              const Optional<Nullable<int32_t>>& opt_aTimeoutSeconds,
              ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread());

  if (!mInitialized) {
    aRv.Throw(NS_ERROR_NOT_AVAILABLE);
    return;
  }

  RefPtr<SharedThreadPool> pool = SharedThreadPool::Get(kPoolName);
  RefPtr<U2FRegisterRunnable> task = new U2FRegisterRunnable(mOrigin, aAppId,
                                                             aRegisterRequests,
                                                             aRegisteredKeys,
                                                             mAuthenticators,
                                                             &aCallback);
  pool->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}

void
U2F::Sign(const nsAString& aAppId,
          const nsAString& aChallenge,
          const Sequence<RegisteredKey>& aRegisteredKeys,
          U2FSignCallback& aCallback,
          const Optional<Nullable<int32_t>>& opt_aTimeoutSeconds,
          ErrorResult& aRv)
{
  MOZ_ASSERT(NS_IsMainThread());

  if (!mInitialized) {
    aRv.Throw(NS_ERROR_NOT_AVAILABLE);
    return;
  }

  RefPtr<SharedThreadPool> pool = SharedThreadPool::Get(kPoolName);
  RefPtr<U2FSignRunnable> task = new U2FSignRunnable(mOrigin, aAppId, aChallenge,
                                                     aRegisteredKeys,
                                                     mAuthenticators, &aCallback);
  pool->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
}

} // namespace dom
} // namespace mozilla