@aztec/accounts 0.47.1 → 0.48.0

package/src/ecdsa/{account_contract.ts → ecdsa_k/account_contract.ts}

@@ -4,16 +4,16 @@ import { Ecdsa } from '@aztec/circuits.js/barretenberg';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
-import { DefaultAccountContract } from '../defaults/account_contract.js';
-import { EcdsaAccountContractArtifact } from './artifact.js';
+import { DefaultAccountContract } from '../../defaults/account_contract.js';
+import { EcdsaKAccountContractArtifact } from './artifact.js';
 
 /**
  * Account contract that authenticates transactions using ECDSA signatures
  * verified against a secp256k1 public key stored in an immutable encrypted note.
  */
-export class EcdsaAccountContract extends DefaultAccountContract {
+export class EcdsaKAccountContract extends DefaultAccountContract {
   constructor(private signingPrivateKey: Buffer) {
-    super(EcdsaAccountContractArtifact as ContractArtifact);
+    super(EcdsaKAccountContractArtifact as ContractArtifact);
   }
 
   getDeploymentArgs() {
@@ -22,12 +22,12 @@ export class EcdsaAccountContract extends DefaultAccountContract {
   }
 
   getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
-    return new EcdsaAuthWitnessProvider(this.signingPrivateKey);
+    return new EcdsaKAuthWitnessProvider(this.signingPrivateKey);
   }
 }
 
 /** Creates auth witnesses using ECDSA signatures. */
-class EcdsaAuthWitnessProvider implements AuthWitnessProvider {
+class EcdsaKAuthWitnessProvider implements AuthWitnessProvider {
   constructor(private signingPrivateKey: Buffer) {}
 
   createAuthWit(messageHash: Fr): Promise<AuthWitness> {

package/src/ecdsa/ecdsa_k/artifact.ts

@@ -0,0 +1,5 @@
+import { type NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import EcdsaKAccountContractJson from '../../../artifacts/EcdsaKAccount.json' assert { type: 'json' };
+
+export const EcdsaKAccountContractArtifact = loadContractArtifact(EcdsaKAccountContractJson as NoirCompiledContract);

package/src/ecdsa/ecdsa_k/index.ts

@@ -0,0 +1,37 @@
+/**
+ * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
+ * Consider using this account type when working with integrations with Ethereum wallets.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, type Salt } from '@aztec/aztec.js/account';
+import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { type PXE } from '@aztec/circuit-types';
+import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+
+import { EcdsaKAccountContract } from './account_contract.js';
+
+export { EcdsaKAccountContractArtifact } from './artifact.js';
+export { EcdsaKAccountContract };
+
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param secretKey - Secret key used to derive all the keystore keys.
+ * @param signingPrivateKey - Secp256k1 key used for signing transactions.
+ * @param salt - Deployment salt.
+ */
+export function getEcdsaKAccount(pxe: PXE, secretKey: Fr, signingPrivateKey: Buffer, salt?: Salt): AccountManager {
+  return new AccountManager(pxe, secretKey, new EcdsaKAccountContract(signingPrivateKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using ECDSA signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - ECDSA key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getEcdsaKWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaKAccountContract(signingPrivateKey));
+}

package/src/ecdsa/index.ts

@@ -1,37 +1,2 @@
-/**
- * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
- * Consider using this account type when working with integrations with Ethereum wallets.
- *
- * @packageDocumentation
- */
-import { AccountManager, type Salt } from '@aztec/aztec.js/account';
-import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
-import { type PXE } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
-
-import { EcdsaAccountContract } from './account_contract.js';
-
-export { EcdsaAccountContractArtifact } from './artifact.js';
-export { EcdsaAccountContract };
-
-/**
- * Creates an Account that relies on an ECDSA signing key for authentication.
- * @param pxe - An PXE server instance.
- * @param secretKey - Secret key used to derive all the keystore keys.
- * @param signingPrivateKey - Secp256k1 key used for signing transactions.
- * @param salt - Deployment salt.
- */
-export function getEcdsaAccount(pxe: PXE, secretKey: Fr, signingPrivateKey: Buffer, salt?: Salt): AccountManager {
-  return new AccountManager(pxe, secretKey, new EcdsaAccountContract(signingPrivateKey), salt);
-}
-
-/**
- * Gets a wallet for an already registered account using ECDSA signatures.
- * @param pxe - An PXE server instance.
- * @param address - Address for the account.
- * @param signingPrivateKey - ECDSA key used for signing transactions.
- * @returns A wallet for this account that can be used to interact with a contract instance.
- */
-export function getEcdsaWallet(pxe: PXE, address: AztecAddress, signingPrivateKey: Buffer): Promise<AccountWallet> {
-  return getWallet(pxe, address, new EcdsaAccountContract(signingPrivateKey));
-}
+export * from './ecdsa_k/index.js';
+export * from './ssh_ecdsa_r/index.js';

package/src/ecdsa/ssh_ecdsa_r/account_contract.ts

@@ -0,0 +1,88 @@
+import { type AuthWitnessProvider } from '@aztec/aztec.js/account';
+import { AuthWitness, type CompleteAddress } from '@aztec/circuit-types';
+import { EcdsaSignature } from '@aztec/circuits.js/barretenberg';
+import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type Fr } from '@aztec/foundation/fields';
+
+import { DefaultAccountContract } from '../../defaults/account_contract.js';
+import { signWithAgent } from '../../utils/ssh_agent.js';
+import { EcdsaRAccountContractArtifact } from './artifact.js';
+
+const secp256r1N = 115792089210356248762697446949407573529996955224135760342422259061068512044369n;
+/**
+ * Account contract that authenticates transactions using ECDSA signatures
+ * verified against a secp256r1 public key stored in an immutable encrypted note.
+ * Since this implementation relays signatures to an SSH agent, we provide the
+ * public key here not for signature verification, but to identify actual identity
+ * that will be used to sign authwitnesses.
+ */
+export class EcdsaRSSHAccountContract extends DefaultAccountContract {
+  constructor(private signingPublicKey: Buffer) {
+    super(EcdsaRAccountContractArtifact as ContractArtifact);
+  }
+
+  getDeploymentArgs() {
+    return [this.signingPublicKey.subarray(0, 32), this.signingPublicKey.subarray(32, 64)];
+  }
+
+  getAuthWitnessProvider(_address: CompleteAddress): AuthWitnessProvider {
+    return new SSHEcdsaRAuthWitnessProvider(this.signingPublicKey);
+  }
+}
+
+/** Creates auth witnesses using ECDSA signatures. */
+class SSHEcdsaRAuthWitnessProvider implements AuthWitnessProvider {
+  constructor(private signingPublicKey: Buffer) {}
+
+  #parseECDSASignature(data: Buffer) {
+    // Extract ECDSA signature components
+    let offset = 0;
+    const sigTypeLen = data.readUInt32BE(offset);
+    offset += 4;
+    const sigType = data.subarray(offset, offset + sigTypeLen).toString();
+    offset += sigTypeLen;
+
+    if (sigType !== 'ecdsa-sha2-nistp256') {
+      throw new Error(`Unexpected signature type: ${sigType}`);
+    }
+
+    offset += 4;
+    const rLen = data.readUInt32BE(offset);
+    offset += 4;
+    let r = data.subarray(offset, offset + rLen);
+    offset += rLen;
+
+    const sLen = data.readUInt32BE(offset);
+    offset += 4;
+    let s = data.subarray(offset, offset + sLen);
+
+    // R and S are encoded using ASN.1 DER format, which may include a leading zero byte to avoid interpreting the value as negative
+    if (r.length > 32) {
+      r = Buffer.from(Uint8Array.prototype.slice.call(r, 1));
+    }
+
+    if (s.length > 32) {
+      s = Buffer.from(Uint8Array.prototype.slice.call(s, 1));
+    }
+
+    const maybeHighS = BigInt(`0x${s.toString('hex')}`);
+
+    // ECDSA signatures must have a low S value so they can be used as a nullifier. BB forces a value of 27 for v, so
+    // only one PublicKey can verify the signature (and not its negated counterpart) https://ethereum.stackexchange.com/a/55728
+    if (maybeHighS > secp256r1N / 2n + 1n) {
+      s = Buffer.from((secp256r1N - maybeHighS).toString(16), 'hex');
+    }
+
+    return new EcdsaSignature(r, s, Buffer.from([0]));
+  }
+
+  async createAuthWit(messageHash: Fr): Promise<AuthWitness> {
+    // Key type and curve name
+    const keyType = Buffer.from('ecdsa-sha2-nistp256');
+    const curveName = Buffer.from('nistp256');
+    const data = await signWithAgent(keyType, curveName, this.signingPublicKey, messageHash.toBuffer());
+    const signature = this.#parseECDSASignature(data);
+
+    return new AuthWitness(messageHash, [...signature.r, ...signature.s]);
+  }
+}

package/src/ecdsa/ssh_ecdsa_r/artifact.ts

@@ -0,0 +1,5 @@
+import { type NoirCompiledContract, loadContractArtifact } from '@aztec/aztec.js';
+
+import EcdsaRAccountContractJson from '../../../artifacts/EcdsaRAccount.json' assert { type: 'json' };
+
+export const EcdsaRAccountContractArtifact = loadContractArtifact(EcdsaRAccountContractJson as NoirCompiledContract);

package/src/ecdsa/ssh_ecdsa_r/index.ts

@@ -0,0 +1,37 @@
+/**
+ * The `@aztec/accounts/ecdsa` export provides an ECDSA account contract implementation, that uses an ECDSA private key for authentication, and a Grumpkin key for encryption.
+ * Consider using this account type when working with integrations with Ethereum wallets.
+ *
+ * @packageDocumentation
+ */
+import { AccountManager, type Salt } from '@aztec/aztec.js/account';
+import { type AccountWallet, getWallet } from '@aztec/aztec.js/wallet';
+import { type PXE } from '@aztec/circuit-types';
+import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+
+import { EcdsaRSSHAccountContract } from './account_contract.js';
+
+export { EcdsaRAccountContractArtifact } from './artifact.js';
+export { EcdsaRSSHAccountContract };
+
+/**
+ * Creates an Account that relies on an ECDSA signing key for authentication.
+ * @param pxe - An PXE server instance.
+ * @param secretKey - Secret key used to derive all the keystore keys.
+ * @param signingPublicKey - Secp2561 key used to identify its corresponding private key in the SSH Agent.
+ * @param salt - Deployment salt.
+ */
+export function getEcdsaRSSHAccount(pxe: PXE, secretKey: Fr, signingPublicKey: Buffer, salt?: Salt): AccountManager {
+  return new AccountManager(pxe, secretKey, new EcdsaRSSHAccountContract(signingPublicKey), salt);
+}
+
+/**
+ * Gets a wallet for an already registered account using ECDSA signatures.
+ * @param pxe - An PXE server instance.
+ * @param address - Address for the account.
+ * @param signingPrivateKey - ECDSA key used for signing transactions.
+ * @returns A wallet for this account that can be used to interact with a contract instance.
+ */
+export function getEcdsaRSSHWallet(pxe: PXE, address: AztecAddress, signingPublicKey: Buffer): Promise<AccountWallet> {
+  return getWallet(pxe, address, new EcdsaRSSHAccountContract(signingPublicKey));
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './ssh_agent.js';

package/src/utils/ssh_agent.ts

@@ -0,0 +1,136 @@
+import { Buffer } from 'buffer';
+import net from 'net';
+
+const SSH_AGENT_IDENTITIES_REQUEST = 11;
+const SSH_AGENT_IDENTITIES_RESPONSE = 12;
+const SSH_AGENT_SIGN_REQUEST = 13;
+const SSH_AGENT_SIGN_RESPONSE = 14;
+
+/**
+ * Connect to the SSH agent via a TCP socket using the standard env variable
+ */
+export function connectToAgent() {
+  const socketPath = process.env.SSH_AUTH_SOCK;
+  if (!socketPath) {
+    throw new Error('SSH_AUTH_SOCK is not set');
+  }
+  return net.connect(socketPath);
+}
+
+/**
+ * Type representing a stored key in the SSH agent.
+ */
+type StoredKey = {
+  /**
+   * Type of the key.
+   */
+  type: string;
+  /**
+   * Public key in base64 encoding.
+   */
+  publicKey: string;
+  /**
+   * Comment associated with the key.
+   */
+  comment: string;
+};
+
+/**
+ * Retrieve the identities stored in the SSH agent.
+ */
+export function getIdentities(): Promise<StoredKey[]> {
+  return new Promise((resolve, reject) => {
+    const stream = connectToAgent();
+    stream.on('connect', () => {
+      const request = Buffer.concat([
+        Buffer.from([0, 0, 0, 5 + 4]), // length
+        Buffer.from([SSH_AGENT_IDENTITIES_REQUEST]),
+        Buffer.from([0, 0, 0, 0]), // flags
+      ]);
+
+      stream.write(request);
+    });
+
+    stream.on('data', data => {
+      const responseType = data[4];
+      if (responseType === SSH_AGENT_IDENTITIES_RESPONSE) {
+        let offset = 5;
+        const numKeys = data.readUInt32BE(offset);
+        offset += 4;
+
+        const keys = [];
+        for (let i = 0; i < numKeys; i++) {
+          const keyLength = data.readUInt32BE(offset);
+          offset += 4;
+          const key = data.subarray(offset, offset + keyLength);
+          offset += keyLength;
+          const commentLength = data.readUInt32BE(offset);
+          offset += 4;
+          const comment = data.subarray(offset, offset + commentLength);
+          offset += commentLength;
+
+          let keyOffset = 0;
+          const typeLen = key.readUInt32BE(keyOffset);
+          keyOffset += 4;
+          const type = key.subarray(keyOffset, keyOffset + typeLen);
+
+          keys.push({
+            type: type.toString('ascii'),
+            publicKey: key.toString('base64'),
+            comment: comment.toString('utf8'),
+          });
+        }
+        stream.end();
+        resolve(keys);
+      } else {
+        stream.end();
+        reject(`Unexpected response type: ${responseType}`);
+      }
+    });
+  });
+}
+
+/**
+ * Sign data using a key stored in the SSH agent. The private signing key is identified by its corresponding public key.
+ */
+export function signWithAgent(keyType: Buffer, curveName: Buffer, publicKey: Buffer, data: Buffer) {
+  return new Promise<Buffer>((resolve, reject) => {
+    const stream = connectToAgent();
+    stream.on('connect', () => {
+      // Construct the key blob
+      const keyBlob = Buffer.concat([
+        Buffer.from([0, 0, 0, keyType.length]),
+        keyType,
+        Buffer.from([0, 0, 0, curveName.length]),
+        curveName,
+        Buffer.from([0, 0, 0, publicKey.length + 1, 4]),
+        publicKey,
+      ]);
+      const request = Buffer.concat([
+        Buffer.from([0, 0, 0, 5 + keyBlob.length + 4 + data.length + 4]), // length
+        Buffer.from([SSH_AGENT_SIGN_REQUEST]),
+        Buffer.from([0, 0, 0, keyBlob.length]), // key blob length
+        keyBlob,
+        Buffer.from([0, 0, 0, data.length]), // data length
+        data,
+        Buffer.from([0, 0, 0, 0]), // flags
+      ]);
+
+      stream.write(request);
+    });
+
+    stream.on('data', data => {
+      const type = data[4];
+
+      if (type === SSH_AGENT_SIGN_RESPONSE) {
+        const signatureLength = data.readUInt32BE(5);
+        const signature = data.subarray(9, 9 + signatureLength);
+        stream.end();
+        resolve(signature);
+      } else {
+        stream.end();
+        reject(`Unexpected response type: ${type}`);
+      }
+    });
+  });
+}