gecko-dev/dom/u2f/U2F.h

159 lines
4.2 KiB
C
Raw Normal View History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */
#ifndef mozilla_dom_U2F_h
#define mozilla_dom_U2F_h
#include "js/TypeDecls.h"
#include "mozilla/Attributes.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/Nullable.h"
#include "mozilla/dom/U2FBinding.h"
#include "mozilla/dom/WebAuthnManagerBase.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/MozPromise.h"
#include "nsProxyRelease.h"
#include "nsWrapperCache.h"
#include "U2FAuthenticator.h"
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialResult;
class WebAuthnGetAssertionResult;
class U2FRegisterCallback;
class U2FSignCallback;
// Defined in U2FBinding.h by the U2F.webidl; their use requires a JSContext.
struct RegisterRequest;
struct RegisteredKey;
class U2FTransaction
{
typedef Variant<nsMainThreadPtrHandle<U2FRegisterCallback>,
nsMainThreadPtrHandle<U2FSignCallback>> U2FCallback;
public:
explicit U2FTransaction(const U2FCallback&& aCallback)
: mCallback(std::move(aCallback))
, mId(NextId())
{
MOZ_ASSERT(mId > 0);
}
bool HasRegisterCallback() {
return mCallback.is<nsMainThreadPtrHandle<U2FRegisterCallback>>();
}
auto& GetRegisterCallback() {
return mCallback.as<nsMainThreadPtrHandle<U2FRegisterCallback>>();
}
bool HasSignCallback() {
return mCallback.is<nsMainThreadPtrHandle<U2FSignCallback>>();
}
auto& GetSignCallback() {
return mCallback.as<nsMainThreadPtrHandle<U2FSignCallback>>();
}
// The callback passed to the API.
U2FCallback mCallback;
// Unique transaction id.
uint64_t mId;
private:
// Generates a unique id for new transactions. This doesn't have to be unique
// forever, it's sufficient to differentiate between temporally close
// transactions, where messages can intersect. Can overflow.
static uint64_t NextId() {
static uint64_t id = 0;
return ++id;
}
};
class U2F final : public WebAuthnManagerBase
, public nsWrapperCache
{
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(U2F)
explicit U2F(nsPIDOMWindowInner* aParent)
: WebAuthnManagerBase(aParent)
{ }
nsPIDOMWindowInner*
GetParentObject() const
{
return mParent;
}
void
Init(ErrorResult& aRv);
virtual JSObject*
WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
void
Register(const nsAString& aAppId,
const Sequence<RegisterRequest>& aRegisterRequests,
const Sequence<RegisteredKey>& aRegisteredKeys,
U2FRegisterCallback& aCallback,
const Optional<Nullable<int32_t>>& opt_aTimeoutSeconds,
ErrorResult& aRv);
void
Sign(const nsAString& aAppId,
const nsAString& aChallenge,
const Sequence<RegisteredKey>& aRegisteredKeys,
U2FSignCallback& aCallback,
const Optional<Nullable<int32_t>>& opt_aTimeoutSeconds,
ErrorResult& aRv);
// WebAuthnManagerBase
void
FinishMakeCredential(const uint64_t& aTransactionId,
const WebAuthnMakeCredentialResult& aResult) override;
void
FinishGetAssertion(const uint64_t& aTransactionId,
const WebAuthnGetAssertionResult& aResult) override;
void
RequestAborted(const uint64_t& aTransactionId,
const nsresult& aError) override;
protected:
// Cancels the current transaction (by sending a Cancel message to the
// parent) and rejects it by calling RejectTransaction().
void CancelTransaction(const nsresult& aError) override;
private:
~U2F();
template<typename T, typename C>
void ExecuteCallback(T& aResp, nsMainThreadPtrHandle<C>& aCb);
// Clears all information we have about the current transaction.
void ClearTransaction();
// Rejects the current transaction and clears it.
void RejectTransaction(const nsresult& aError);
nsString mOrigin;
// The current transaction, if any.
Maybe<U2FTransaction> mTransaction;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_U2F_h