Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-26 12:20:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1437616 - Use proper WebAuthn result types defined in the .pidl r=jcj

Browse Source 
Reviewers: jcj

Reviewed By: jcj

Bug #: 1437616

Differential Revision: https://phabricator.services.mozilla.com/D582
This commit is contained in:
Tim Taubert 2018-02-12 21:08:54 +01:00
parent dce09604e1
commit bc18da5fe7
13 changed files with 54 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
dom/u2f/U2F.cpp
View File

@ -462,7 +462,7 @@ U2F::Register(const nsAString& aAppId,
void
U2F::FinishMakeCredential(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aRegBuffer)
const WebAuthnMakeCredentialResult& aResult)
{
MOZ_ASSERT(NS_IsMainThread());
@ -483,7 +483,7 @@ U2F::FinishMakeCredential(const uint64_t& aTransactionId,
}
CryptoBuffer regBuf;
if (NS_WARN_IF(!regBuf.Assign(aRegBuffer))) {
if (NS_WARN_IF(!regBuf.Assign(aResult.RegBuffer()))) {
RejectTransaction(NS_ERROR_ABORT);
return;
}
@ -606,8 +606,7 @@ U2F::Sign(const nsAString& aAppId,
void
U2F::FinishGetAssertion(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aCredentialId,
nsTArray<uint8_t>& aSigBuffer)
const WebAuthnGetAssertionResult& aResult)
{
MOZ_ASSERT(NS_IsMainThread());
@ -628,13 +627,13 @@ U2F::FinishGetAssertion(const uint64_t& aTransactionId,
}
CryptoBuffer credBuf;
if (NS_WARN_IF(!credBuf.Assign(aCredentialId))) {
if (NS_WARN_IF(!credBuf.Assign(aResult.CredentialID()))) {
RejectTransaction(NS_ERROR_ABORT);
return;
}
CryptoBuffer sigBuf;
if (NS_WARN_IF(!sigBuf.Assign(aSigBuffer))) {
if (NS_WARN_IF(!sigBuf.Assign(aResult.SigBuffer()))) {
RejectTransaction(NS_ERROR_ABORT);
return;
}

6
dom/u2f/U2F.h
View File

@ -13,6 +13,7 @@
#include "mozilla/dom/Nullable.h"
#include "mozilla/dom/U2FBinding.h"
#include "mozilla/dom/WebAuthnManagerBase.h"
#include "mozilla/dom/PWebAuthnTransaction.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/MozPromise.h"
#include "nsProxyRelease.h"
@ -122,12 +123,11 @@ public:
void
FinishMakeCredential(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aRegBuffer) override;
const WebAuthnMakeCredentialResult& aResult) override;
void
FinishGetAssertion(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aCredentialId,
nsTArray<uint8_t>& aSigBuffer) override;
const WebAuthnGetAssertionResult& aResult) override;
void
RequestAborted(const uint64_t& aTransactionId,

13
dom/webauthn/PWebAuthnTransaction.ipdl
View File

@ -43,6 +43,10 @@ struct WebAuthnMakeCredentialInfo {
WebAuthnAuthenticatorSelection AuthenticatorSelection;
};
struct WebAuthnMakeCredentialResult {
uint8_t[] RegBuffer;
};
struct WebAuthnGetAssertionInfo {
uint8_t[] RpIdHash;
uint8_t[] ClientDataHash;
@ -52,6 +56,11 @@ struct WebAuthnGetAssertionInfo {
WebAuthnExtension[] Extensions;
};
struct WebAuthnGetAssertionResult {
uint8_t[] CredentialID;
uint8_t[] SigBuffer;
};
async protocol PWebAuthnTransaction {
manager PBackground;
@ -63,8 +72,8 @@ async protocol PWebAuthnTransaction {
child:
async __delete__();
async ConfirmRegister(uint64_t aTransactionId, uint8_t[] RegBuffer);
async ConfirmSign(uint64_t aTransactionId, uint8_t[] CredentialID, uint8_t[] ReplyBuffer);
async ConfirmRegister(uint64_t aTransactionId, WebAuthnMakeCredentialResult aResult);
async ConfirmSign(uint64_t aTransactionId, WebAuthnGetAssertionResult aResult);
async Abort(uint64_t aTransactionId, nsresult Error);
};

4
dom/webauthn/U2FHIDTokenManager.cpp
View File

@ -214,7 +214,7 @@ U2FHIDTokenManager::HandleRegisterResult(UniquePtr<U2FResult>&& aResult)
return;
}
U2FRegisterResult result(Move(registration));
WebAuthnMakeCredentialResult result(registration);
mRegisterPromise.Resolve(Move(result), __func__);
}
@ -241,7 +241,7 @@ U2FHIDTokenManager::HandleSignResult(UniquePtr<U2FResult>&& aResult)
return;
}
U2FSignResult result(Move(keyHandle), Move(signature));
WebAuthnGetAssertionResult result(keyHandle, signature);
mSignPromise.Resolve(Move(result), __func__);
}

4
dom/webauthn/U2FSoftTokenManager.cpp
View File

@ -689,7 +689,7 @@ U2FSoftTokenManager::Register(const nsTArray<WebAuthnScopedCredential>& aCredent
registrationBuf.AppendSECItem(attestCert.get()->derCert);
registrationBuf.AppendSECItem(signatureItem);
U2FRegisterResult result((nsTArray<uint8_t>(registrationBuf)));
WebAuthnMakeCredentialResult result((nsTArray<uint8_t>(registrationBuf)));
return U2FRegisterPromise::CreateAndResolve(Move(result), __func__);
}
@ -832,7 +832,7 @@ U2FSoftTokenManager::Sign(const nsTArray<WebAuthnScopedCredential>& aCredentials
signatureBuf.AppendSECItem(counterItem);
signatureBuf.AppendSECItem(signatureItem);
U2FSignResult result(Move(keyHandle), nsTArray<uint8_t>(signatureBuf));
WebAuthnGetAssertionResult result(keyHandle, nsTArray<uint8_t>(signatureBuf));
return U2FSignPromise::CreateAndResolve(Move(result), __func__);
}

20
dom/webauthn/U2FTokenManager.cpp
View File

@ -251,7 +251,7 @@ U2FTokenManager::Register(PWebAuthnTransactionParent* aTransactionParent,
aTransactionInfo.ClientDataHash(),
aTransactionInfo.TimeoutMS())
->Then(GetCurrentThreadSerialEventTarget(), __func__,
[tid, startTime](U2FRegisterResult&& aResult) {
[tid, startTime](WebAuthnMakeCredentialResult&& aResult) {
U2FTokenManager* mgr = U2FTokenManager::Get();
mgr->MaybeConfirmRegister(tid, aResult);
Telemetry::ScalarAdd(
@ -274,15 +274,12 @@ U2FTokenManager::Register(PWebAuthnTransactionParent* aTransactionParent,
void
U2FTokenManager::MaybeConfirmRegister(const uint64_t& aTransactionId,
U2FRegisterResult& aResult)
const WebAuthnMakeCredentialResult& aResult)
{
MOZ_ASSERT(mLastTransactionId == aTransactionId);
mRegisterPromise.Complete();
nsTArray<uint8_t> registration;
aResult.ConsumeRegistration(registration);
Unused << mTransactionParent->SendConfirmRegister(aTransactionId, registration);
Unused << mTransactionParent->SendConfirmRegister(aTransactionId, aResult);
ClearTransaction();
}
@ -325,7 +322,7 @@ U2FTokenManager::Sign(PWebAuthnTransactionParent* aTransactionParent,
aTransactionInfo.RequireUserVerification(),
aTransactionInfo.TimeoutMS())
->Then(GetCurrentThreadSerialEventTarget(), __func__,
[tid, startTime](U2FSignResult&& aResult) {
[tid, startTime](WebAuthnGetAssertionResult&& aResult) {
U2FTokenManager* mgr = U2FTokenManager::Get();
mgr->MaybeConfirmSign(tid, aResult);
Telemetry::ScalarAdd(
@ -348,17 +345,12 @@ U2FTokenManager::Sign(PWebAuthnTransactionParent* aTransactionParent,
void
U2FTokenManager::MaybeConfirmSign(const uint64_t& aTransactionId,
U2FSignResult& aResult)
const WebAuthnGetAssertionResult& aResult)
{
MOZ_ASSERT(mLastTransactionId == aTransactionId);
mSignPromise.Complete();
nsTArray<uint8_t> keyHandle;
aResult.ConsumeKeyHandle(keyHandle);
nsTArray<uint8_t> signature;
aResult.ConsumeSignature(signature);
Unused << mTransactionParent->SendConfirmSign(aTransactionId, keyHandle, signature);
Unused << mTransactionParent->SendConfirmSign(aTransactionId, aResult);
ClearTransaction();
}

7
dom/webauthn/U2FTokenManager.h
View File

@ -8,6 +8,7 @@
#define mozilla_dom_U2FTokenManager_h
#include "mozilla/dom/U2FTokenTransport.h"
#include "mozilla/dom/PWebAuthnTransaction.h"
/*
* Parent process manager for U2F and WebAuthn API transactions. Handles process
@ -46,9 +47,11 @@ private:
RefPtr<U2FTokenTransport> GetTokenManagerImpl();
void AbortTransaction(const uint64_t& aTransactionId, const nsresult& aError);
void ClearTransaction();
void MaybeConfirmRegister(const uint64_t& aTransactionId, U2FRegisterResult& aResult);
void MaybeConfirmRegister(const uint64_t& aTransactionId,
const WebAuthnMakeCredentialResult& aResult);
void MaybeAbortRegister(const uint64_t& aTransactionId, const nsresult& aError);
void MaybeConfirmSign(const uint64_t& aTransactionId, U2FSignResult& aResult);
void MaybeConfirmSign(const uint64_t& aTransactionId,
const WebAuthnGetAssertionResult& aResult);
void MaybeAbortSign(const uint64_t& aTransactionId, const nsresult& aError);
// Using a raw pointer here, as the lifetime of the IPC object is managed by
// the PBackground protocol code. This means we cannot be left holding an

39
dom/webauthn/U2FTokenTransport.h
View File

@ -18,43 +18,8 @@
namespace mozilla {
namespace dom {
class U2FRegisterResult {
public:
explicit U2FRegisterResult(nsTArray<uint8_t>&& aRegistration)
: mRegistration(aRegistration)
{ }
void ConsumeRegistration(nsTArray<uint8_t>& aBuffer) {
aBuffer = Move(mRegistration);
}
private:
nsTArray<uint8_t> mRegistration;
};
class U2FSignResult {
public:
explicit U2FSignResult(nsTArray<uint8_t>&& aKeyHandle,
nsTArray<uint8_t>&& aSignature)
: mKeyHandle(aKeyHandle)
, mSignature(aSignature)
{ }
void ConsumeKeyHandle(nsTArray<uint8_t>& aBuffer) {
aBuffer = Move(mKeyHandle);
}
void ConsumeSignature(nsTArray<uint8_t>& aBuffer) {
aBuffer = Move(mSignature);
}
private:
nsTArray<uint8_t> mKeyHandle;
nsTArray<uint8_t> mSignature;
};
typedef MozPromise<U2FRegisterResult, nsresult, true> U2FRegisterPromise;
typedef MozPromise<U2FSignResult, nsresult, true> U2FSignPromise;
typedef MozPromise<WebAuthnMakeCredentialResult, nsresult, true> U2FRegisterPromise;
typedef MozPromise<WebAuthnGetAssertionResult, nsresult, true> U2FSignPromise;
class U2FTokenTransport
{

14
dom/webauthn/WebAuthnManager.cpp
View File

@ -650,7 +650,7 @@ WebAuthnManager::Store(const Credential& aCredential)
void
WebAuthnManager::FinishMakeCredential(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aRegBuffer)
const WebAuthnMakeCredentialResult& aResult)
{
MOZ_ASSERT(NS_IsMainThread());
@ -660,7 +660,8 @@ WebAuthnManager::FinishMakeCredential(const uint64_t& aTransactionId,
}
CryptoBuffer regData;
if (NS_WARN_IF(!regData.Assign(aRegBuffer.Elements(), aRegBuffer.Length()))) {
if (NS_WARN_IF(!regData.Assign(aResult.RegBuffer().Elements(),
aResult.RegBuffer().Length()))) {
RejectTransaction(NS_ERROR_OUT_OF_MEMORY);
return;
}
@ -783,8 +784,7 @@ WebAuthnManager::FinishMakeCredential(const uint64_t& aTransactionId,
void
WebAuthnManager::FinishGetAssertion(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aCredentialId,
nsTArray<uint8_t>& aSigBuffer)
const WebAuthnGetAssertionResult& aResult)
{
MOZ_ASSERT(NS_IsMainThread());
@ -794,8 +794,8 @@ WebAuthnManager::FinishGetAssertion(const uint64_t& aTransactionId,
}
CryptoBuffer tokenSignatureData;
if (NS_WARN_IF(!tokenSignatureData.Assign(aSigBuffer.Elements(),
aSigBuffer.Length()))) {
if (NS_WARN_IF(!tokenSignatureData.Assign(aResult.SigBuffer().Elements(),
aResult.SigBuffer().Length()))) {
RejectTransaction(NS_ERROR_OUT_OF_MEMORY);
return;
}
@ -833,7 +833,7 @@ WebAuthnManager::FinishGetAssertion(const uint64_t& aTransactionId,
}
CryptoBuffer credentialBuf;
if (!credentialBuf.Assign(aCredentialId)) {
if (!credentialBuf.Assign(aResult.CredentialID())) {
RejectTransaction(NS_ERROR_OUT_OF_MEMORY);
return;
}

5
dom/webauthn/WebAuthnManager.h
View File

@ -123,12 +123,11 @@ public:
void
FinishMakeCredential(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aRegBuffer) override;
const WebAuthnMakeCredentialResult& aResult) override;
void
FinishGetAssertion(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aCredentialId,
nsTArray<uint8_t>& aSigBuffer) override;
const WebAuthnGetAssertionResult& aResult) override;
void
RequestAborted(const uint64_t& aTransactionId,

6
dom/webauthn/WebAuthnManagerBase.h
View File

@ -7,6 +7,7 @@
#ifndef mozilla_dom_WebAuthnManagerBase_h
#define mozilla_dom_WebAuthnManagerBase_h
#include "mozilla/dom/PWebAuthnTransaction.h"
#include "nsIDOMEventListener.h"
/*
@ -28,12 +29,11 @@ public:
virtual void
FinishMakeCredential(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aRegBuffer) = 0;
const WebAuthnMakeCredentialResult& aResult) = 0;
virtual void
FinishGetAssertion(const uint64_t& aTransactionId,
nsTArray<uint8_t>& aCredentialId,
nsTArray<uint8_t>& aSigBuffer) = 0;
const WebAuthnGetAssertionResult& aResult) = 0;
virtual void
RequestAborted(const uint64_t& aTransactionId,

9
dom/webauthn/WebAuthnTransactionChild.cpp
View File

@ -22,26 +22,25 @@ WebAuthnTransactionChild::WebAuthnTransactionChild(WebAuthnManagerBase* aManager
mozilla::ipc::IPCResult
WebAuthnTransactionChild::RecvConfirmRegister(const uint64_t& aTransactionId,
nsTArray<uint8_t>&& aRegBuffer)
const WebAuthnMakeCredentialResult& aResult)
{
if (NS_WARN_IF(!mManager)) {
return IPC_FAIL_NO_REASON(this);
}
mManager->FinishMakeCredential(aTransactionId, aRegBuffer);
mManager->FinishMakeCredential(aTransactionId, aResult);
return IPC_OK();
}
mozilla::ipc::IPCResult
WebAuthnTransactionChild::RecvConfirmSign(const uint64_t& aTransactionId,
nsTArray<uint8_t>&& aCredentialId,
nsTArray<uint8_t>&& aBuffer)
const WebAuthnGetAssertionResult& aResult)
{
if (NS_WARN_IF(!mManager)) {
return IPC_FAIL_NO_REASON(this);
}
mManager->FinishGetAssertion(aTransactionId, aCredentialId, aBuffer);
mManager->FinishGetAssertion(aTransactionId, aResult);
return IPC_OK();
}

5
dom/webauthn/WebAuthnTransactionChild.h
View File

@ -28,12 +28,11 @@ public:
mozilla::ipc::IPCResult
RecvConfirmRegister(const uint64_t& aTransactionId,
nsTArray<uint8_t>&& aRegBuffer) override;
const WebAuthnMakeCredentialResult& aResult) override;
mozilla::ipc::IPCResult
RecvConfirmSign(const uint64_t& aTransactionId,
nsTArray<uint8_t>&& aCredentialId,
nsTArray<uint8_t>&& aBuffer) override;
const WebAuthnGetAssertionResult& aResult) override;
mozilla::ipc::IPCResult
RecvAbort(const uint64_t& aTransactionId, const nsresult& aError) override;