harden: verify all approval fields and make failed signing retryable (closes #174)
All checks were successful
check / check (push) Successful in 30s
All checks were successful
check / check (push) Successful in 30s
approvalVerify now compares every field of the signed artifact against the approval, not a subset. Transaction types are allowlisted to 0/1/2 and any field the module does not check is refused outright, so a future transaction type cannot smuggle consequential fields past verification -- an EIP-7702 type-4 artifact that delegates the signer's own EOA while matching every displayed field was accepted before this change. The serialized bytes handed to broadcastTransaction are compared against the parsed artifact, so the guarantee covers the bytes that actually go to the node. Signing failures in the popup are retryable again. To make that safe, an approval is claimed synchronously before the first await and every path that resolves or removes one goes through a single chokepoint that refuses a claimed approval. Without it, closing the approval window, switching the active address or a late reject would report "User rejected the request." to the dApp while the broadcast completed -- the user then redoes the transfer at a fresh nonce and it sends twice. Failure copy distinguishes the stage reached, so a user is never told to start again from the site when the first attempt may already have reached the network.
This commit was merged in pull request #205.
This commit is contained in:
@@ -1,8 +1,28 @@
|
||||
const { Network, Transaction, Wallet } = require("ethers");
|
||||
const {
|
||||
Network,
|
||||
Transaction,
|
||||
Wallet,
|
||||
decodeRlp,
|
||||
encodeRlp,
|
||||
} = require("ethers");
|
||||
const {
|
||||
verifySignedTx,
|
||||
verifySignature,
|
||||
assertNoForbiddenFields,
|
||||
assertNothingUnchecked,
|
||||
assertCanonicalBytes,
|
||||
sameAddress,
|
||||
failureIsRetryable,
|
||||
describeTxFailure,
|
||||
describeSigningFailure,
|
||||
ALLOWED_TX_TYPES,
|
||||
SERIALIZED_FIELDS,
|
||||
FORBIDDEN_FIELDS,
|
||||
TX_STAGE_SIGN,
|
||||
TX_STAGE_VERIFY,
|
||||
TX_STAGE_BROADCAST,
|
||||
MAX_GAS_LIMIT,
|
||||
MAX_FEE_PER_GAS,
|
||||
} = require("../src/shared/approvalVerify");
|
||||
const { getSignerForAddress } = require("../src/shared/wallet");
|
||||
|
||||
@@ -18,6 +38,10 @@ const other = new Wallet(OTHER_KEY);
|
||||
const RECIPIENT = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
|
||||
const OTHER_RECIPIENT = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
|
||||
|
||||
// The chain id of the selected network, as networks.js carries it.
|
||||
const SELECTED = "0x1";
|
||||
const SEPOLIA = "0xaa36a7";
|
||||
|
||||
// Approved parameters as a dApp would supply them over eth_sendTransaction.
|
||||
const TX_PARAMS = {
|
||||
from: signer.address,
|
||||
@@ -27,25 +51,38 @@ const TX_PARAMS = {
|
||||
gas: "0x5208",
|
||||
};
|
||||
|
||||
// The values populateTransaction() fills in when the dApp fixed none of them.
|
||||
const POPULATED = {
|
||||
chainId: 1,
|
||||
nonce: 7,
|
||||
gasLimit: 100000n,
|
||||
maxFeePerGas: 2000000000n,
|
||||
maxPriorityFeePerGas: 1000000000n,
|
||||
type: 2,
|
||||
};
|
||||
|
||||
// Build a signable transaction from approved params. The popup does the same
|
||||
// thing through populateTransaction(); here the fields are fixed so the test
|
||||
// needs no provider.
|
||||
function txFor(params) {
|
||||
// needs no provider. `overrides` stands in for what a tampered or misbuilt
|
||||
// popup would put on the wire.
|
||||
function txFor(params, overrides) {
|
||||
return {
|
||||
chainId: 1,
|
||||
nonce: 7,
|
||||
gasLimit: 100000n,
|
||||
maxFeePerGas: 2000000000n,
|
||||
maxPriorityFeePerGas: 1000000000n,
|
||||
type: 2,
|
||||
...POPULATED,
|
||||
to: params.to,
|
||||
value: params.value === undefined ? 0n : BigInt(params.value),
|
||||
data: params.data || "0x",
|
||||
...(overrides || {}),
|
||||
};
|
||||
}
|
||||
|
||||
async function signedFor(params, withWallet) {
|
||||
return (withWallet || signer).signTransaction(txFor(params));
|
||||
async function signedFor(params, withWallet, overrides) {
|
||||
return (withWallet || signer).signTransaction(txFor(params, overrides));
|
||||
}
|
||||
|
||||
// Sign the approved transaction with one field changed from what was
|
||||
// populated, which is the shape of every tamper case below.
|
||||
async function signedWith(overrides) {
|
||||
return signedFor(TX_PARAMS, signer, overrides);
|
||||
}
|
||||
|
||||
describe("sameAddress", () => {
|
||||
@@ -71,7 +108,7 @@ describe("sameAddress", () => {
|
||||
describe("verifySignedTx", () => {
|
||||
test("accepts the approved transaction signed by the approved address", async () => {
|
||||
const raw = await signedFor(TX_PARAMS);
|
||||
const parsed = verifySignedTx(raw, TX_PARAMS, signer.address);
|
||||
const parsed = verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED);
|
||||
expect(parsed.from).toBe(signer.address);
|
||||
expect(parsed.hash).toBe(Transaction.from(raw).hash);
|
||||
});
|
||||
@@ -79,14 +116,16 @@ describe("verifySignedTx", () => {
|
||||
test("accepts a contract creation with no recipient", async () => {
|
||||
const params = { to: undefined, value: "0x0", data: "0x600160005500" };
|
||||
const raw = await signedFor(params);
|
||||
expect(() => verifySignedTx(raw, params, signer.address)).not.toThrow();
|
||||
expect(() =>
|
||||
verifySignedTx(raw, params, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts an absent value as zero", async () => {
|
||||
const approved = { to: RECIPIENT, data: "0x" };
|
||||
const raw = await signedFor(approved);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address),
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
@@ -94,7 +133,7 @@ describe("verifySignedTx", () => {
|
||||
const approved = { to: RECIPIENT, value: "0x0", data: "0xDEADBEEF" };
|
||||
const raw = await signedFor(approved);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address),
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
@@ -103,9 +142,9 @@ describe("verifySignedTx", () => {
|
||||
...TX_PARAMS,
|
||||
to: OTHER_RECIPIENT,
|
||||
});
|
||||
expect(() => verifySignedTx(raw, TX_PARAMS, signer.address)).toThrow(
|
||||
/approved recipient/,
|
||||
);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/approved recipient/);
|
||||
});
|
||||
|
||||
test("rejects an inflated value", async () => {
|
||||
@@ -113,48 +152,48 @@ describe("verifySignedTx", () => {
|
||||
...TX_PARAMS,
|
||||
value: "0x4563918244f40000",
|
||||
});
|
||||
expect(() => verifySignedTx(raw, TX_PARAMS, signer.address)).toThrow(
|
||||
/approved value/,
|
||||
);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/approved value/);
|
||||
});
|
||||
|
||||
test("rejects substituted call data", async () => {
|
||||
const raw = await signedFor({ ...TX_PARAMS, data: "0xc0ffee" });
|
||||
expect(() => verifySignedTx(raw, TX_PARAMS, signer.address)).toThrow(
|
||||
/approved call data/,
|
||||
);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/approved call data/);
|
||||
});
|
||||
|
||||
test("rejects a transaction signed by a different address", async () => {
|
||||
const raw = await signedFor(TX_PARAMS, other);
|
||||
expect(() => verifySignedTx(raw, TX_PARAMS, signer.address)).toThrow(
|
||||
/different address/,
|
||||
);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/different address/);
|
||||
});
|
||||
|
||||
test("rejects an unsigned transaction", () => {
|
||||
const unsigned = Transaction.from(txFor(TX_PARAMS)).unsignedSerialized;
|
||||
expect(() =>
|
||||
verifySignedTx(unsigned, TX_PARAMS, signer.address),
|
||||
verifySignedTx(unsigned, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/no valid signature/);
|
||||
});
|
||||
|
||||
test("rejects a missing or malformed payload", () => {
|
||||
expect(() =>
|
||||
verifySignedTx(undefined, TX_PARAMS, signer.address),
|
||||
verifySignedTx(undefined, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/missing or malformed/);
|
||||
expect(() => verifySignedTx("nope", TX_PARAMS, signer.address)).toThrow(
|
||||
/missing or malformed/,
|
||||
);
|
||||
expect(() =>
|
||||
verifySignedTx("0xc0ffee", TX_PARAMS, signer.address),
|
||||
verifySignedTx("nope", TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/missing or malformed/);
|
||||
expect(() =>
|
||||
verifySignedTx("0xc0ffee", TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/could not be decoded/);
|
||||
});
|
||||
|
||||
test("every rejection message is a full sentence", async () => {
|
||||
const raw = await signedFor({ ...TX_PARAMS, to: OTHER_RECIPIENT });
|
||||
try {
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address);
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED);
|
||||
throw new Error("expected a rejection");
|
||||
} catch (e) {
|
||||
expect(e.message).toMatch(/^[A-Z].*\.$/);
|
||||
@@ -162,6 +201,606 @@ describe("verifySignedTx", () => {
|
||||
});
|
||||
});
|
||||
|
||||
// One case per consequential field: the field alone differs from what was
|
||||
// approved, and that alone must refuse the signature.
|
||||
describe("verifySignedTx field comparison", () => {
|
||||
test("rejects a chain id that is not the selected network", async () => {
|
||||
const raw = await signedWith({ chainId: 11155111 });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/different network than the one that is selected/);
|
||||
});
|
||||
|
||||
test("rejects a chain id that is not the approved one", async () => {
|
||||
// Selected network and signed chain id agree; the dApp asked for a
|
||||
// different chain, so the artifact is not what was approved.
|
||||
const approved = { ...TX_PARAMS, chainId: SEPOLIA };
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/different network than the one that was approved/);
|
||||
});
|
||||
|
||||
test("refuses when the selected network is unknown", async () => {
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, undefined),
|
||||
).toThrow(/selected network is unknown/);
|
||||
});
|
||||
|
||||
test("rejects a substituted nonce", async () => {
|
||||
const approved = { ...TX_PARAMS, nonce: 7 };
|
||||
const raw = await signedWith({ nonce: 8 });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved nonce/);
|
||||
});
|
||||
|
||||
test("rejects a substituted gas limit", async () => {
|
||||
const approved = { ...TX_PARAMS, gasLimit: "0x186a0" };
|
||||
const raw = await signedWith({ gasLimit: 250000n });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved gas limit/);
|
||||
});
|
||||
|
||||
test("rejects a substituted maximum fee per gas", async () => {
|
||||
const approved = { ...TX_PARAMS, maxFeePerGas: "0x77359400" };
|
||||
const raw = await signedWith({ maxFeePerGas: 900000000000n });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved maximum fee per gas/);
|
||||
});
|
||||
|
||||
test("rejects a substituted maximum priority fee per gas", async () => {
|
||||
const approved = { ...TX_PARAMS, maxPriorityFeePerGas: "0x3b9aca00" };
|
||||
const raw = await signedWith({ maxPriorityFeePerGas: 1500000000n });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved maximum priority fee per gas/);
|
||||
});
|
||||
|
||||
test("rejects a substituted legacy gas price", async () => {
|
||||
const approved = { ...TX_PARAMS, gasPrice: "0x77359400" };
|
||||
const legacy = {
|
||||
type: 0,
|
||||
gasPrice: 9000000000n,
|
||||
maxFeePerGas: null,
|
||||
maxPriorityFeePerGas: null,
|
||||
};
|
||||
const raw = await signedWith(legacy);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved gas price/);
|
||||
});
|
||||
|
||||
test("rejects an approved legacy fee signed as an EIP-1559 fee", async () => {
|
||||
const approved = { ...TX_PARAMS, gasPrice: "0x77359400" };
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved fee mechanism/);
|
||||
});
|
||||
|
||||
test("rejects an approved EIP-1559 fee signed as a legacy fee", async () => {
|
||||
const approved = { ...TX_PARAMS, maxFeePerGas: "0x77359400" };
|
||||
const raw = await signedWith({
|
||||
type: 0,
|
||||
gasPrice: 2000000000n,
|
||||
maxFeePerGas: null,
|
||||
maxPriorityFeePerGas: null,
|
||||
});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).toThrow(/approved fee mechanism/);
|
||||
});
|
||||
|
||||
test("rejects a gas limit above anything a supported network accepts", async () => {
|
||||
const raw = await signedWith({ gasLimit: MAX_GAS_LIMIT + 1n });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/gas limit no network this wallet supports/);
|
||||
});
|
||||
|
||||
test("rejects an absurd fee per gas the approval never fixed", async () => {
|
||||
const raw = await signedWith({
|
||||
maxFeePerGas: MAX_FEE_PER_GAS + 1n,
|
||||
maxPriorityFeePerGas: MAX_FEE_PER_GAS + 1n,
|
||||
});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/fee per gas far above any plausible value/);
|
||||
});
|
||||
|
||||
test("every field mismatch is a refusal, not a warning", async () => {
|
||||
const raw = await signedWith({ nonce: 8 });
|
||||
try {
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, nonce: 7 },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
);
|
||||
throw new Error("expected a rejection");
|
||||
} catch (e) {
|
||||
expect(e.approvalMismatch).toBe(true);
|
||||
expect(e.message).toMatch(/^[A-Z].*\.$/);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// The transaction type decides which fields exist, so an artifact of a type
|
||||
// this wallet does not sign carries consequences the approval cannot describe
|
||||
// and none of the field comparisons can see. The approval used here is the
|
||||
// ordinary dApp shape with no fee fields — the common case, since
|
||||
// populateTransaction() fills them — which is exactly the case the
|
||||
// fee-mechanism check cannot catch by accident.
|
||||
describe("verifySignedTx transaction type", () => {
|
||||
const BARE_APPROVAL = {
|
||||
from: signer.address,
|
||||
to: RECIPIENT,
|
||||
value: "0x2386f26fc10000",
|
||||
data: "0x",
|
||||
};
|
||||
|
||||
// An EIP-7702 artifact that pays the approved amount to the approved
|
||||
// recipient and, in the same transaction, installs the attacker's code at
|
||||
// the signer's own account for good. Every field the approval screen shows
|
||||
// matches; only the type and the authorization list do not.
|
||||
test("refuses a type 4 artifact that delegates the signer's own account", async () => {
|
||||
const authorization = await signer.authorize({
|
||||
address: OTHER_RECIPIENT,
|
||||
chainId: 1,
|
||||
nonce: 8,
|
||||
});
|
||||
const raw = await signedFor(BARE_APPROVAL, signer, {
|
||||
type: 4,
|
||||
authorizationList: [authorization],
|
||||
});
|
||||
const parsed = Transaction.from(raw);
|
||||
expect(parsed.type).toBe(4);
|
||||
expect(parsed.authorizationList[0].address).toBe(OTHER_RECIPIENT);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, BARE_APPROVAL, signer.address, SELECTED),
|
||||
).toThrow(/type this wallet does not sign/);
|
||||
});
|
||||
|
||||
test("refuses a type 3 blob artifact", async () => {
|
||||
const raw = await signedFor(BARE_APPROVAL, signer, {
|
||||
type: 3,
|
||||
maxFeePerBlobGas: 1000000000n,
|
||||
blobVersionedHashes: ["0x01" + "ab".repeat(31)],
|
||||
});
|
||||
expect(Transaction.from(raw).type).toBe(3);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, BARE_APPROVAL, signer.address, SELECTED),
|
||||
).toThrow(/type this wallet does not sign/);
|
||||
});
|
||||
|
||||
test("refuses every type outside the allowlist, not just the known ones", async () => {
|
||||
for (const type of [3, 4]) {
|
||||
expect(ALLOWED_TX_TYPES).not.toContain(type);
|
||||
}
|
||||
expect(ALLOWED_TX_TYPES).toEqual([0, 1, 2]);
|
||||
});
|
||||
|
||||
test("a type refusal is a refusal, not a warning", async () => {
|
||||
const authorization = await signer.authorize({
|
||||
address: OTHER_RECIPIENT,
|
||||
chainId: 1,
|
||||
nonce: 8,
|
||||
});
|
||||
const raw = await signedFor(BARE_APPROVAL, signer, {
|
||||
type: 4,
|
||||
authorizationList: [authorization],
|
||||
});
|
||||
try {
|
||||
verifySignedTx(raw, BARE_APPROVAL, signer.address, SELECTED);
|
||||
throw new Error("expected a rejection");
|
||||
} catch (e) {
|
||||
expect(e.approvalMismatch).toBe(true);
|
||||
expect(e.message).toMatch(/^[A-Z].*\.$/);
|
||||
}
|
||||
});
|
||||
|
||||
test("accepts a legacy type 0 transaction", async () => {
|
||||
const approved = { ...BARE_APPROVAL, gasPrice: "0x77359400" };
|
||||
const raw = await signedFor(approved, signer, {
|
||||
type: 0,
|
||||
gasPrice: 2000000000n,
|
||||
maxFeePerGas: null,
|
||||
maxPriorityFeePerGas: null,
|
||||
});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts a type 1 transaction whose access list is the approved one", async () => {
|
||||
const accessList = [{ address: OTHER_RECIPIENT, storageKeys: [] }];
|
||||
const approved = {
|
||||
...BARE_APPROVAL,
|
||||
gasPrice: "0x77359400",
|
||||
accessList,
|
||||
};
|
||||
const raw = await signedFor(approved, signer, {
|
||||
type: 1,
|
||||
gasPrice: 2000000000n,
|
||||
maxFeePerGas: null,
|
||||
maxPriorityFeePerGas: null,
|
||||
accessList,
|
||||
});
|
||||
expect(Transaction.from(raw).type).toBe(1);
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("refuses an access list the approval never carried", async () => {
|
||||
const raw = await signedFor(BARE_APPROVAL, signer, {
|
||||
accessList: [{ address: OTHER_RECIPIENT, storageKeys: [] }],
|
||||
});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, BARE_APPROVAL, signer.address, SELECTED),
|
||||
).toThrow(/approved access list/);
|
||||
});
|
||||
|
||||
test("treats an absent access list and an empty one as the same thing", async () => {
|
||||
const approved = { ...BARE_APPROVAL, accessList: [] };
|
||||
const raw = await signedFor(BARE_APPROVAL, signer, {});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
// The allowlist is only exhaustive while it accounts for every field an
|
||||
// artifact can carry. These tests are what makes that claim checkable rather
|
||||
// than asserted.
|
||||
describe("verifySignedTx exhaustiveness", () => {
|
||||
// Every accessor ethers exposes on a parsed transaction, and where this
|
||||
// module deals with it. If an ethers upgrade adds a transaction field,
|
||||
// this fails and forces a decision about it instead of letting it default
|
||||
// to unchecked.
|
||||
test("every field ethers can parse is accounted for", () => {
|
||||
const derived = [
|
||||
// Recovered from the signature or computed from the payload, not
|
||||
// independent content: covered by the signer check and by the
|
||||
// fields below.
|
||||
"from",
|
||||
"fromPublicKey",
|
||||
"hash",
|
||||
"serialized",
|
||||
"signature",
|
||||
"type",
|
||||
"typeName",
|
||||
"unsignedHash",
|
||||
"unsignedSerialized",
|
||||
// Blob sidecar machinery, meaningful only alongside `blobs`,
|
||||
// which is refused outright.
|
||||
"kzg",
|
||||
"blobWrapperVersion",
|
||||
];
|
||||
const accounted = new Set([
|
||||
...derived,
|
||||
...FORBIDDEN_FIELDS.map((f) => f.key),
|
||||
...Object.values(SERIALIZED_FIELDS).flat(),
|
||||
]);
|
||||
const exposed = Object.getOwnPropertyNames(Transaction.prototype)
|
||||
.filter((name) => {
|
||||
const d = Object.getOwnPropertyDescriptor(
|
||||
Transaction.prototype,
|
||||
name,
|
||||
);
|
||||
return d && typeof d.get === "function";
|
||||
})
|
||||
.sort();
|
||||
expect(exposed.filter((name) => !accounted.has(name))).toEqual([]);
|
||||
});
|
||||
|
||||
// The two layers behind the type allowlist. Nothing reachable through
|
||||
// verifySignedTx can trip either of them while the allowlist holds — that
|
||||
// is what they are for — so they are exercised directly rather than taken
|
||||
// on trust.
|
||||
test("a forbidden field is refused even on an allowed type", async () => {
|
||||
const authorization = await signer.authorize({
|
||||
address: OTHER_RECIPIENT,
|
||||
chainId: 1,
|
||||
nonce: 8,
|
||||
});
|
||||
const carriers = {
|
||||
authorizationList: [authorization],
|
||||
blobVersionedHashes: ["0x01" + "ab".repeat(31)],
|
||||
blobs: ["0x00"],
|
||||
maxFeePerBlobGas: 1n,
|
||||
};
|
||||
for (const key of Object.keys(carriers)) {
|
||||
expect(FORBIDDEN_FIELDS.map((f) => f.key)).toContain(key);
|
||||
let thrown;
|
||||
try {
|
||||
assertNoForbiddenFields({ type: 2, [key]: carriers[key] });
|
||||
throw new Error("expected a rejection");
|
||||
} catch (e) {
|
||||
thrown = e;
|
||||
}
|
||||
expect(thrown.approvalMismatch).toBe(true);
|
||||
expect(thrown.message).toMatch(/^[A-Z].*\.$/);
|
||||
}
|
||||
expect(() => assertNoForbiddenFields({ type: 2 })).not.toThrow();
|
||||
});
|
||||
|
||||
// Stands in for a future ethers that parses a field this module does not
|
||||
// know about onto an allowed type: every field the module checks is
|
||||
// identical, and the bytes are not.
|
||||
test("an artifact carrying more than the checked fields is refused", async () => {
|
||||
const parsed = Transaction.from(await signedWith({}));
|
||||
const smuggled = { type: parsed.type };
|
||||
for (const key of SERIALIZED_FIELDS[parsed.type]) {
|
||||
smuggled[key] = parsed[key];
|
||||
}
|
||||
smuggled.unsignedSerialized = parsed.unsignedSerialized + "ff";
|
||||
expect(() => assertNothingUnchecked(smuggled)).toThrow(
|
||||
/beyond the fields that were checked/,
|
||||
);
|
||||
expect(() => assertNothingUnchecked(parsed)).not.toThrow();
|
||||
});
|
||||
|
||||
// The closing check rebuilds the artifact from the fields the module
|
||||
// compared and compares the bytes, so an artifact carrying anything else
|
||||
// is refused without the module having to name it. Assert the rebuild is
|
||||
// faithful for every accepted shape, since a rebuild that dropped a
|
||||
// legitimate field would refuse honest transactions.
|
||||
test("an accepted artifact of each allowed type rebuilds byte for byte", async () => {
|
||||
const shapes = [
|
||||
{
|
||||
approved: { ...TX_PARAMS, gasPrice: "0x77359400" },
|
||||
overrides: {
|
||||
type: 0,
|
||||
gasPrice: 2000000000n,
|
||||
maxFeePerGas: null,
|
||||
maxPriorityFeePerGas: null,
|
||||
},
|
||||
},
|
||||
{
|
||||
approved: {
|
||||
...TX_PARAMS,
|
||||
gasPrice: "0x77359400",
|
||||
accessList: [
|
||||
{
|
||||
address: RECIPIENT,
|
||||
storageKeys: ["0x" + "11".repeat(32)],
|
||||
},
|
||||
],
|
||||
},
|
||||
overrides: {
|
||||
type: 1,
|
||||
gasPrice: 2000000000n,
|
||||
maxFeePerGas: null,
|
||||
maxPriorityFeePerGas: null,
|
||||
accessList: [
|
||||
{
|
||||
address: RECIPIENT,
|
||||
storageKeys: ["0x" + "11".repeat(32)],
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
{ approved: TX_PARAMS, overrides: {} },
|
||||
];
|
||||
for (const shape of shapes) {
|
||||
const raw = await signedFor(
|
||||
shape.approved,
|
||||
signer,
|
||||
shape.overrides,
|
||||
);
|
||||
const parsed = verifySignedTx(
|
||||
raw,
|
||||
shape.approved,
|
||||
signer.address,
|
||||
SELECTED,
|
||||
);
|
||||
const fields = { type: parsed.type };
|
||||
for (const key of SERIALIZED_FIELDS[parsed.type]) {
|
||||
fields[key] = parsed[key];
|
||||
}
|
||||
expect(Transaction.from(fields).unsignedSerialized).toBe(
|
||||
parsed.unsignedSerialized,
|
||||
);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// Every comparison above runs against the decode, but the string that is
|
||||
// handed to broadcastTransaction() is the artifact. An encoding the decoder
|
||||
// normalizes away therefore checks as one transaction and broadcasts as
|
||||
// different bytes, so the artifact must be the canonical encoding of itself.
|
||||
describe("verifySignedTx canonical encoding", () => {
|
||||
// Re-encode a signed type-2 artifact with a leading zero byte on the RLP
|
||||
// value field. It decodes to exactly the approved transaction — same
|
||||
// value, same signer, same everything the field comparisons look at — and
|
||||
// it is not the same string.
|
||||
async function nonCanonical() {
|
||||
const raw = await signedWith({});
|
||||
const items = decodeRlp("0x" + raw.slice(4));
|
||||
// type 2 payload order: chainId, nonce, maxPriorityFeePerGas,
|
||||
// maxFeePerGas, gasLimit, to, value, data, accessList, then the
|
||||
// signature.
|
||||
const padded = items.slice();
|
||||
padded[6] = "0x00" + items[6].slice(2);
|
||||
return "0x02" + encodeRlp(padded).slice(2);
|
||||
}
|
||||
|
||||
test("the mutation decodes to the approved transaction and is not it", async () => {
|
||||
const raw = await signedWith({});
|
||||
const mutated = await nonCanonical();
|
||||
const parsed = Transaction.from(mutated);
|
||||
expect(mutated).not.toBe(raw);
|
||||
expect(mutated.length).toBeGreaterThan(raw.length);
|
||||
expect(parsed.value).toBe(BigInt(TX_PARAMS.value));
|
||||
expect(parsed.from).toBe(signer.address);
|
||||
expect(parsed.serialized).not.toBe(mutated);
|
||||
});
|
||||
|
||||
test("refuses an artifact that is not its own canonical encoding", async () => {
|
||||
const mutated = await nonCanonical();
|
||||
expect(() =>
|
||||
verifySignedTx(mutated, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/not encoded canonically/);
|
||||
});
|
||||
|
||||
test("assertCanonicalBytes accepts what ethers itself produced", async () => {
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
assertCanonicalBytes(Transaction.from(raw), raw),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("hex case is not part of the encoding", async () => {
|
||||
const raw = await signedWith({});
|
||||
const upper = "0x" + raw.slice(2).toUpperCase();
|
||||
expect(() =>
|
||||
verifySignedTx(upper, TX_PARAMS, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
// The approval and the artifact spell the same values differently. None of
|
||||
// these differences is tampering, so none may refuse the signature.
|
||||
describe("verifySignedTx normalization", () => {
|
||||
test("accepts a decimal chain id against a hex selected network", async () => {
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, 1),
|
||||
).not.toThrow();
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, "1"),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts an approved chain id written in hex", async () => {
|
||||
const raw = await signedWith({});
|
||||
const approved = { ...TX_PARAMS, chainId: "0x1" };
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts a hex nonce against a numeric one", async () => {
|
||||
const raw = await signedWith({ nonce: 7 });
|
||||
expect(() =>
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, nonce: "0x7" },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts a decimal gas limit against a hex one", async () => {
|
||||
const raw = await signedWith({ gasLimit: 100000n });
|
||||
expect(() =>
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, gasLimit: "100000" },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts fee fields spelled as hex, decimal, number and bigint", async () => {
|
||||
const raw = await signedWith({});
|
||||
for (const maxFee of [
|
||||
"0x77359400",
|
||||
"2000000000",
|
||||
2000000000,
|
||||
2000000000n,
|
||||
]) {
|
||||
expect(() =>
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, maxFeePerGas: maxFee },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
),
|
||||
).not.toThrow();
|
||||
}
|
||||
});
|
||||
|
||||
test("accepts an approval that fixes no nonce, gas or fee at all", async () => {
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts an approval whose recipient case differs", async () => {
|
||||
const raw = await signedWith({});
|
||||
const approved = { ...TX_PARAMS, to: RECIPIENT.toLowerCase() };
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("accepts absent call data against 0x", async () => {
|
||||
const approved = { to: RECIPIENT, value: "0x0" };
|
||||
const raw = await signedFor({ ...approved, data: "0x" });
|
||||
expect(() =>
|
||||
verifySignedTx(raw, approved, signer.address, SELECTED),
|
||||
).not.toThrow();
|
||||
});
|
||||
|
||||
test("refuses an approved quantity that is not a number", async () => {
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, maxFeePerGas: "cheap" },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
),
|
||||
).toThrow(/is not a number/);
|
||||
});
|
||||
|
||||
// The value is page-controlled. A refusal is correct; a raw BigInt
|
||||
// conversion error is not, because it is not a mismatch, so it would be
|
||||
// reported retryable and leave the approval unspent behind a live button
|
||||
// that can never succeed.
|
||||
test("refuses an approved value that is not a number, as a mismatch", async () => {
|
||||
const raw = await signedWith({});
|
||||
for (const value of ["cheap", 1.5, "1e18", {}]) {
|
||||
let thrown;
|
||||
try {
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, value },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
);
|
||||
throw new Error("expected a rejection");
|
||||
} catch (e) {
|
||||
thrown = e;
|
||||
}
|
||||
expect(thrown.approvalMismatch).toBe(true);
|
||||
expect(thrown.message).toMatch(/approved value is not a number/);
|
||||
expect(failureIsRetryable(thrown)).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
test("refuses an approved access list that is not an access list", async () => {
|
||||
const raw = await signedWith({});
|
||||
expect(() =>
|
||||
verifySignedTx(
|
||||
raw,
|
||||
{ ...TX_PARAMS, accessList: ["nope"] },
|
||||
signer.address,
|
||||
SELECTED,
|
||||
),
|
||||
).toThrow(/not a valid access list/);
|
||||
});
|
||||
});
|
||||
|
||||
const TYPED_DATA = JSON.stringify({
|
||||
domain: {
|
||||
name: "AutistMask Test",
|
||||
@@ -281,6 +920,147 @@ describe("verifySignature", () => {
|
||||
});
|
||||
});
|
||||
|
||||
// What happens after a signing attempt fails: the background keeps the
|
||||
// approval for anything the user can correct, and the popup only offers the
|
||||
// button again when it did.
|
||||
describe("signing failure and retry", () => {
|
||||
test("a failure that is not a mismatch leaves the approval retryable", () => {
|
||||
expect(failureIsRetryable(new Error("The node is unreachable."))).toBe(
|
||||
true,
|
||||
);
|
||||
expect(failureIsRetryable(undefined)).toBe(true);
|
||||
});
|
||||
|
||||
test("a mismatch spends the approval", async () => {
|
||||
const raw = await signedFor({ ...TX_PARAMS, to: OTHER_RECIPIENT });
|
||||
try {
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED);
|
||||
throw new Error("expected a rejection");
|
||||
} catch (e) {
|
||||
expect(failureIsRetryable(e)).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
test("a retryable failure keeps the button usable and says only what failed", () => {
|
||||
const outcome = describeSigningFailure(
|
||||
{ error: "The node rejected the transaction.", retryable: true },
|
||||
"The transaction could not be sent.",
|
||||
);
|
||||
expect(outcome.retryable).toBe(true);
|
||||
expect(outcome.message).toBe("The node rejected the transaction.");
|
||||
});
|
||||
|
||||
test("a refusal tells the user to start again from the site", () => {
|
||||
const outcome = describeSigningFailure(
|
||||
{
|
||||
error: "The signed transaction does not go to the approved recipient.",
|
||||
retryable: false,
|
||||
},
|
||||
"The transaction could not be sent.",
|
||||
);
|
||||
expect(outcome.retryable).toBe(false);
|
||||
expect(outcome.message).toMatch(/start it again from the site\.$/);
|
||||
});
|
||||
|
||||
test("a refusal for an attempt already running does not say to start again", () => {
|
||||
const outcome = describeSigningFailure(
|
||||
{
|
||||
error: "This request is already being signed.",
|
||||
retryable: false,
|
||||
stage: "inflight",
|
||||
},
|
||||
"The message could not be signed.",
|
||||
);
|
||||
expect(outcome.retryable).toBe(false);
|
||||
expect(outcome.message).not.toMatch(/start it again from the site/);
|
||||
expect(outcome.message).toMatch(/first attempt is still running/);
|
||||
});
|
||||
|
||||
test("a response the background never sent is treated as a spent approval", () => {
|
||||
const outcome = describeSigningFailure(
|
||||
undefined,
|
||||
"The transaction could not be sent.",
|
||||
);
|
||||
expect(outcome.retryable).toBe(false);
|
||||
expect(outcome.message).toMatch(/^The transaction could not be sent\./);
|
||||
});
|
||||
|
||||
test("every failure message is a full sentence", () => {
|
||||
const outcome = describeSigningFailure(
|
||||
{ error: "The node is on fire", retryable: true },
|
||||
"The transaction could not be sent.",
|
||||
);
|
||||
expect(outcome.message).toMatch(/^[A-Z].*\.$/);
|
||||
});
|
||||
|
||||
test("a popup that could not sign leaves the approval standing", () => {
|
||||
const outcome = describeTxFailure(
|
||||
TX_STAGE_SIGN,
|
||||
"That password is incorrect. Please try again.",
|
||||
);
|
||||
expect(outcome.retryable).toBe(true);
|
||||
expect(outcome.spendApproval).toBe(false);
|
||||
expect(outcome.error).toMatch(/password is incorrect/);
|
||||
});
|
||||
|
||||
test("a mismatch found at verification spends the approval", async () => {
|
||||
const raw = await signedFor({ ...TX_PARAMS, to: OTHER_RECIPIENT });
|
||||
let outcome;
|
||||
try {
|
||||
verifySignedTx(raw, TX_PARAMS, signer.address, SELECTED);
|
||||
} catch (e) {
|
||||
outcome = describeTxFailure(TX_STAGE_VERIFY, e);
|
||||
}
|
||||
expect(outcome.retryable).toBe(false);
|
||||
expect(outcome.spendApproval).toBe(true);
|
||||
});
|
||||
|
||||
test("a failure before the check ran is still retryable", () => {
|
||||
const outcome = describeTxFailure(
|
||||
TX_STAGE_VERIFY,
|
||||
new Error("The wallet state could not be read."),
|
||||
);
|
||||
expect(outcome.retryable).toBe(true);
|
||||
expect(outcome.spendApproval).toBe(false);
|
||||
});
|
||||
|
||||
// A broadcast that throws after the node took the transaction is routine:
|
||||
// a timeout, a dropped response, a node answering "already known". The
|
||||
// popup's retry does not re-broadcast the same bytes — it re-populates and
|
||||
// re-signs at a freshly fetched nonce — so a retryable broadcast failure
|
||||
// would put the approved transfer on the chain twice.
|
||||
test("a failed broadcast is terminal, whatever the node said", () => {
|
||||
for (const message of [
|
||||
"already known",
|
||||
"timeout of 30000ms exceeded",
|
||||
"could not coalesce error",
|
||||
"replacement transaction underpriced",
|
||||
]) {
|
||||
const outcome = describeTxFailure(
|
||||
TX_STAGE_BROADCAST,
|
||||
new Error(message),
|
||||
);
|
||||
expect(outcome.retryable).toBe(false);
|
||||
expect(outcome.spendApproval).toBe(true);
|
||||
expect(outcome.error).toBe(message);
|
||||
}
|
||||
});
|
||||
|
||||
test("a failed broadcast does not tell the user to send it again", () => {
|
||||
const outcome = describeSigningFailure(
|
||||
{
|
||||
error: "The node did not answer.",
|
||||
retryable: false,
|
||||
stage: TX_STAGE_BROADCAST,
|
||||
},
|
||||
"The transaction could not be sent.",
|
||||
);
|
||||
expect(outcome.retryable).toBe(false);
|
||||
expect(outcome.message).toMatch(/may still have reached the network/);
|
||||
expect(outcome.message).not.toMatch(/start it again from the site/);
|
||||
});
|
||||
});
|
||||
|
||||
// End-to-end over the messaging boundary, without a browser: run the exact
|
||||
// sequence the approval popup runs, then hand the artifact to the exact check
|
||||
// the background runs before it broadcasts or resolves. Only what the popup
|
||||
@@ -314,7 +1094,12 @@ describe("popup signing sequence to background verification", () => {
|
||||
|
||||
test("a populated, signed transaction is accepted and broadcastable", async () => {
|
||||
const rawSignedTx = await popupSignsTx(TX_PARAMS);
|
||||
const parsed = verifySignedTx(rawSignedTx, TX_PARAMS, signer.address);
|
||||
const parsed = verifySignedTx(
|
||||
rawSignedTx,
|
||||
TX_PARAMS,
|
||||
signer.address,
|
||||
SELECTED,
|
||||
);
|
||||
expect(parsed.nonce).toBe(7);
|
||||
expect(parsed.chainId).toBe(1n);
|
||||
expect(parsed.gasLimit).toBe(21000n);
|
||||
@@ -349,7 +1134,14 @@ describe("popup signing sequence to background verification", () => {
|
||||
to: OTHER_RECIPIENT,
|
||||
});
|
||||
expect(() =>
|
||||
verifySignedTx(rawSignedTx, TX_PARAMS, signer.address),
|
||||
verifySignedTx(rawSignedTx, TX_PARAMS, signer.address, SELECTED),
|
||||
).toThrow(/approved recipient/);
|
||||
});
|
||||
|
||||
test("the background rejects a transaction populated on another network", async () => {
|
||||
const rawSignedTx = await popupSignsTx(TX_PARAMS);
|
||||
expect(() =>
|
||||
verifySignedTx(rawSignedTx, TX_PARAMS, signer.address, SEPOLIA),
|
||||
).toThrow(/different network than the one that is selected/);
|
||||
});
|
||||
});
|
||||
|
||||
679
tests/backgroundApproval.test.js
Normal file
679
tests/backgroundApproval.test.js
Normal file
@@ -0,0 +1,679 @@
|
||||
// The background's approval message wiring, driven end to end: a dApp
|
||||
// eth_sendTransaction raises a pending approval, and the popup answers it with
|
||||
// AUTISTMASK_TX_RESPONSE / AUTISTMASK_SIGN_RESPONSE.
|
||||
//
|
||||
// What this exists for is the duplicate response. The handler verifies and
|
||||
// broadcasts asynchronously, and the approval deliberately survives a
|
||||
// retryable failure so the user can try again with the transaction they
|
||||
// already saw — which means the entry being present is not by itself proof
|
||||
// that no attempt is running. A second response carrying the same id (a
|
||||
// reloaded approval window re-rendering a live Approve button, a popup that
|
||||
// emits the message twice) must not start a second verify and broadcast: with
|
||||
// the ordinary dApp approval shape the page fixes no nonce, so two artifacts
|
||||
// signed at different nonces both verify, and the approved transfer would go
|
||||
// out twice.
|
||||
|
||||
const { Wallet } = require("ethers");
|
||||
|
||||
const SIGNER_KEY =
|
||||
"0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
|
||||
const signer = new Wallet(SIGNER_KEY);
|
||||
const RECIPIENT = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
|
||||
|
||||
const ORIGIN = "https://dapp.example";
|
||||
const HOSTNAME = "dapp.example";
|
||||
const EXT_URL = "chrome-extension://autistmask/";
|
||||
|
||||
// What the dApp asks for: no nonce, no gas, no fees. This is the shape that
|
||||
// makes a duplicate broadcast possible at all.
|
||||
const TX_PARAMS = {
|
||||
from: signer.address,
|
||||
to: RECIPIENT,
|
||||
value: "0x2386f26fc10000",
|
||||
data: "0x",
|
||||
};
|
||||
|
||||
// The fields the popup's populateTransaction() would fill in. The nonce is a
|
||||
// parameter because the duplicate case turns on the two artifacts differing
|
||||
// in exactly the field nothing constrains.
|
||||
function populated(nonce) {
|
||||
return {
|
||||
type: 2,
|
||||
chainId: 1,
|
||||
nonce,
|
||||
gasLimit: 100000n,
|
||||
maxFeePerGas: 2000000000n,
|
||||
maxPriorityFeePerGas: 1000000000n,
|
||||
to: TX_PARAMS.to,
|
||||
value: BigInt(TX_PARAMS.value),
|
||||
data: TX_PARAMS.data,
|
||||
};
|
||||
}
|
||||
|
||||
function signedAtNonce(nonce) {
|
||||
return signer.signTransaction(populated(nonce));
|
||||
}
|
||||
|
||||
// A promise whose settlement the test controls, so a broadcast can be held in
|
||||
// flight while the second response arrives.
|
||||
function deferred() {
|
||||
let resolve;
|
||||
let reject;
|
||||
const promise = new Promise((res, rej) => {
|
||||
resolve = res;
|
||||
reject = rej;
|
||||
});
|
||||
return { promise, resolve, reject };
|
||||
}
|
||||
|
||||
// Load the background worker against stubbed browser and network APIs and
|
||||
// return the handles the tests drive it through. Everything that would touch
|
||||
// the network or the browser's own schedulers is mocked; the approval
|
||||
// verification is the real module, because that is what the handler under
|
||||
// test is wired to.
|
||||
function loadBackground(options) {
|
||||
const opts = options || {};
|
||||
jest.resetModules();
|
||||
|
||||
const broadcastTransaction = jest.fn();
|
||||
const loadState = jest.fn(opts.loadState || (async () => {}));
|
||||
|
||||
jest.doMock("../src/shared/state", () => ({
|
||||
state: { rpcUrl: "https://rpc.invalid", wallets: [] },
|
||||
loadState,
|
||||
saveState: jest.fn(async () => {}),
|
||||
currentNetwork: () => ({ chainId: "0x1" }),
|
||||
}));
|
||||
jest.doMock("../src/shared/balances", () => ({
|
||||
getProvider: () => ({ broadcastTransaction }),
|
||||
refreshBalances: jest.fn(async () => {}),
|
||||
}));
|
||||
jest.doMock("../src/shared/phishingDomains", () => ({
|
||||
isPhishingDomain: () => false,
|
||||
refreshPhishingListOnSchedule: jest.fn(async () => {}),
|
||||
initPhishingList: jest.fn(async () => {}),
|
||||
}));
|
||||
jest.doMock("../src/shared/alarms", () => ({
|
||||
BALANCE_REFRESH_ALARM: "balance",
|
||||
PHISHING_REFRESH_ALARM: "phishing",
|
||||
BALANCE_REFRESH_PERIOD_MINUTES: 1,
|
||||
ensureRecurringAlarms: jest.fn(async () => {}),
|
||||
registerAlarmHandlers: jest.fn(),
|
||||
}));
|
||||
|
||||
const persisted = {
|
||||
wallets: [
|
||||
{ name: "Wallet 1", type: "hd", addresses: [signer.address] },
|
||||
],
|
||||
rpcUrl: "https://rpc.invalid",
|
||||
activeAddress: signer.address,
|
||||
allowedSites: { [signer.address]: [HOSTNAME] },
|
||||
deniedSites: {},
|
||||
};
|
||||
|
||||
let messageListener = null;
|
||||
let windowRemovedListener = null;
|
||||
const created = [];
|
||||
const removed = [];
|
||||
|
||||
global.chrome = {
|
||||
storage: {
|
||||
local: {
|
||||
get: jest.fn(async () => ({ autistmask: persisted })),
|
||||
set: jest.fn(async () => {}),
|
||||
},
|
||||
},
|
||||
runtime: {
|
||||
getURL: (path) => EXT_URL + path,
|
||||
onMessage: {
|
||||
addListener: (fn) => {
|
||||
messageListener = fn;
|
||||
},
|
||||
},
|
||||
onConnect: { addListener: () => {} },
|
||||
lastError: null,
|
||||
},
|
||||
windows: {
|
||||
getLastFocused: (cb) => cb(null),
|
||||
create: (options2, cb) => {
|
||||
created.push(options2);
|
||||
cb({ id: created.length });
|
||||
},
|
||||
remove: (id, cb) => {
|
||||
removed.push(id);
|
||||
if (cb) cb();
|
||||
},
|
||||
// Captured, not swallowed: closing the approval window is the
|
||||
// event that used to retire an approval out from under a live
|
||||
// broadcast, and a no-op stub here hides exactly that.
|
||||
onRemoved: {
|
||||
addListener: (fn) => {
|
||||
windowRemovedListener = fn;
|
||||
},
|
||||
},
|
||||
},
|
||||
tabs: {
|
||||
query: (q, cb) => cb([]),
|
||||
sendMessage: () => {},
|
||||
},
|
||||
action: { setPopup: () => {} },
|
||||
};
|
||||
|
||||
require("../src/background/index");
|
||||
|
||||
// Send a message the way the browser would, and hand back whatever the
|
||||
// handler passed to sendResponse.
|
||||
function send(msg, sender) {
|
||||
const sendResponse = jest.fn();
|
||||
const kept = messageListener(msg, sender || {}, sendResponse);
|
||||
return { sendResponse, kept };
|
||||
}
|
||||
|
||||
// Raise a pending transaction approval the way a dApp does, and dig the
|
||||
// approval id back out of the popup URL the background opened.
|
||||
function requestTx() {
|
||||
let rpcResult = null;
|
||||
const sendResponse = jest.fn((r) => {
|
||||
rpcResult = r;
|
||||
});
|
||||
messageListener(
|
||||
{
|
||||
type: "AUTISTMASK_RPC",
|
||||
method: "eth_sendTransaction",
|
||||
params: [TX_PARAMS],
|
||||
},
|
||||
{ origin: ORIGIN },
|
||||
sendResponse,
|
||||
);
|
||||
return {
|
||||
id: () => new URL(created[0].url).searchParams.get("approval"),
|
||||
result: () => rpcResult,
|
||||
};
|
||||
}
|
||||
|
||||
// The user closes the approval popup. `created` is index-aligned with the
|
||||
// ids the window stub hands back, so window 1 is the first popup opened.
|
||||
function closeWindow(windowId) {
|
||||
windowRemovedListener(windowId);
|
||||
}
|
||||
|
||||
return {
|
||||
send,
|
||||
requestTx,
|
||||
closeWindow,
|
||||
broadcastTransaction,
|
||||
loadState,
|
||||
created,
|
||||
removed,
|
||||
fromPopup: { url: EXT_URL + "src/popup/index.html" },
|
||||
};
|
||||
}
|
||||
|
||||
// Let the handler's promise chain run to the next suspension point.
|
||||
async function settle() {
|
||||
for (let i = 0; i < 10; i++) await Promise.resolve();
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
delete global.chrome;
|
||||
jest.resetModules();
|
||||
});
|
||||
|
||||
describe("one approval, one broadcast", () => {
|
||||
test("a second AUTISTMASK_TX_RESPONSE for the same id does not broadcast again", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
expect(id).toBeTruthy();
|
||||
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
|
||||
// The popup answers. Verification passes and the broadcast is held
|
||||
// open, which is the whole window the second message arrives in.
|
||||
const first = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
|
||||
// A reloaded approval window signs the same approval again. Nothing
|
||||
// in the approval fixes a nonce, so this artifact verifies just as
|
||||
// well as the first one.
|
||||
const second = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(8),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(second.sendResponse).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
error: expect.stringMatching(/already being sent/),
|
||||
retryable: false,
|
||||
}),
|
||||
);
|
||||
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
expect(first.sendResponse).toHaveBeenCalledWith({ txHash: "0xfeed" });
|
||||
expect(pending.result()).toEqual({ result: "0xfeed" });
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test("the same artifact sent twice broadcasts once", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
const raw = await signedAtNonce(7);
|
||||
const msg = {
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: raw,
|
||||
};
|
||||
|
||||
bg.send(msg, { url: bg.fromPopup.url });
|
||||
bg.send(msg, { url: bg.fromPopup.url });
|
||||
await settle();
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test("a response arriving after the broadcast finished finds nothing to send", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
bg.broadcastTransaction.mockResolvedValue({ hash: "0xfeed" });
|
||||
bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
const late = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(8),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(late.sendResponse).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test("a second AUTISTMASK_SIGN_RESPONSE for the same id is refused", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
// Hold the transaction approval in flight, then answer it a second
|
||||
// time as if it were a sign approval: the sign handler must apply the
|
||||
// same interlock rather than running its own verification.
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
const second = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_SIGN_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
signature: "0x00",
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(second.sendResponse).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
error: expect.stringMatching(/already being signed/),
|
||||
retryable: false,
|
||||
}),
|
||||
);
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
// The interlock must not cost the retry the approval exists to allow.
|
||||
describe("the interlock releases a failed attempt", () => {
|
||||
test("a retryable failure before the broadcast leaves the approval usable", async () => {
|
||||
let failNext = true;
|
||||
const bg = loadBackground({
|
||||
loadState: async () => {
|
||||
if (failNext) {
|
||||
failNext = false;
|
||||
throw new Error("storage unavailable");
|
||||
}
|
||||
},
|
||||
});
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const first = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(bg.broadcastTransaction).not.toHaveBeenCalled();
|
||||
expect(first.sendResponse).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ retryable: true }),
|
||||
);
|
||||
|
||||
bg.broadcastTransaction.mockResolvedValue({ hash: "0xfeed" });
|
||||
const retry = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
expect(retry.sendResponse).toHaveBeenCalledWith({ txHash: "0xfeed" });
|
||||
expect(pending.result()).toEqual({ result: "0xfeed" });
|
||||
});
|
||||
|
||||
test("a mismatched artifact spends the approval outright", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
// Signed for a different recipient than the one that was approved.
|
||||
const wrong = await signer.signTransaction({
|
||||
...populated(7),
|
||||
to: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
|
||||
});
|
||||
const first = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: wrong,
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(first.sendResponse).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ retryable: false, stage: "verify" }),
|
||||
);
|
||||
|
||||
const retry = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(bg.broadcastTransaction).not.toHaveBeenCalled();
|
||||
expect(retry.sendResponse).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
// The claim is what makes one approval one broadcast, so it has to hold
|
||||
// against everything else that retires an approval, not just against a second
|
||||
// AUTISTMASK_TX_RESPONSE. Each of these paths used to resolve the waiting
|
||||
// promise 4001 while the attempt behind it ran to completion: the transaction
|
||||
// reached the chain and the page was told the user rejected it, which invites
|
||||
// the user to send it a second time at a fresh nonce.
|
||||
describe("a claimed approval outlives every other retirement path", () => {
|
||||
// The approval popup stays open across the broadcast it is waiting on, so
|
||||
// a user closing an apparently-hung window needs no adversary at all.
|
||||
test("closing the approval window mid-broadcast still reports the result", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
const first = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
|
||||
// The user closes the window while the broadcast is still open.
|
||||
bg.closeWindow(1);
|
||||
await settle();
|
||||
expect(pending.result()).toBeNull();
|
||||
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
|
||||
expect(pending.result()).toEqual({ result: "0xfeed" });
|
||||
expect(first.sendResponse).toHaveBeenCalledWith({ txHash: "0xfeed" });
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test("switching the active address mid-broadcast still reports the result", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
|
||||
// The user switches account in the toolbar popup, which rejects and
|
||||
// force-closes every pending approval.
|
||||
bg.send(
|
||||
{ type: "AUTISTMASK_ACTIVE_CHANGED" },
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(pending.result()).toBeNull();
|
||||
// The window an in-flight attempt reports into is left standing too.
|
||||
expect(bg.removed).toEqual([]);
|
||||
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
|
||||
expect(pending.result()).toEqual({ result: "0xfeed" });
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
test("a reject arriving mid-broadcast is refused, not honoured", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
const reject = bg.send(
|
||||
{ type: "AUTISTMASK_TX_RESPONSE", id, approved: false },
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(pending.result()).toBeNull();
|
||||
expect(reject.sendResponse).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
retryable: false,
|
||||
stage: "broadcast",
|
||||
}),
|
||||
);
|
||||
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
|
||||
expect(pending.result()).toEqual({ result: "0xfeed" });
|
||||
expect(bg.broadcastTransaction).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// The refusals above must not cost the rejection its ordinary meaning.
|
||||
test("with no attempt running, closing the window still rejects", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
|
||||
bg.closeWindow(1);
|
||||
await settle();
|
||||
|
||||
expect(pending.result()).toEqual({
|
||||
error: { code: 4001, message: "User rejected the request." },
|
||||
});
|
||||
expect(bg.broadcastTransaction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test("with no attempt running, an active-address switch still rejects and closes", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
|
||||
bg.send(
|
||||
{ type: "AUTISTMASK_ACTIVE_CHANGED" },
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(pending.result()).toEqual({
|
||||
error: { code: 4001, message: "User rejected the request." },
|
||||
});
|
||||
expect(bg.removed).toEqual([1]);
|
||||
});
|
||||
|
||||
// A sign approval held by a running verification is the same shape, and
|
||||
// the refusal must not tell the user to start again from the site while
|
||||
// the first attempt may still hand back a signature.
|
||||
test("a reject during a sign attempt is refused with the in-flight stage", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const inFlight = deferred();
|
||||
bg.broadcastTransaction.mockReturnValue(inFlight.promise);
|
||||
bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
|
||||
const reject = bg.send(
|
||||
{ type: "AUTISTMASK_SIGN_RESPONSE", id, approved: false },
|
||||
{ url: bg.fromPopup.url },
|
||||
);
|
||||
await settle();
|
||||
expect(reject.sendResponse).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ retryable: false, stage: "inflight" }),
|
||||
);
|
||||
|
||||
inFlight.resolve({ hash: "0xfeed" });
|
||||
await settle();
|
||||
expect(pending.result()).toEqual({ result: "0xfeed" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("popup-only messages", () => {
|
||||
test("a page sender cannot answer an approval", async () => {
|
||||
const bg = loadBackground();
|
||||
const pending = bg.requestTx();
|
||||
await settle();
|
||||
const id = pending.id();
|
||||
|
||||
const spoof = bg.send(
|
||||
{
|
||||
type: "AUTISTMASK_TX_RESPONSE",
|
||||
id,
|
||||
approved: true,
|
||||
rawSignedTx: await signedAtNonce(7),
|
||||
},
|
||||
{ url: ORIGIN + "/index.html" },
|
||||
);
|
||||
await settle();
|
||||
|
||||
expect(bg.broadcastTransaction).not.toHaveBeenCalled();
|
||||
expect(spoof.sendResponse).toHaveBeenCalledWith({
|
||||
error: "Unauthorized sender",
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user