@aptos-labs/ts-sdk 7.1.2 → 7.2.0-beta.0

package/src/cli/spawnArgs.ts

@@ -25,7 +25,7 @@
  * Common, legitimate CLI argument characters (letters, digits, `-`, `_`,
  * `=`, `.`, `,`, `:`, `/`, `\`, space) are unaffected.
  */
-const UNSAFE_SHELL_CHARS = /[&|;<>`$()"'\n\r^!*?%]/;
+const UNSAFE_SHELL_CHARS = /[&|;<>`$()[\]#"'\n\r^!*?%]/;
 
 /**
  * Validates that a CLI argument does not contain shell metacharacters that
@@ -40,7 +40,7 @@ export function assertSafeCliArg(arg: string): void {
   if (UNSAFE_SHELL_CHARS.test(arg)) {
     throw new Error(
       `CLI argument contains characters that could be interpreted by the shell: ${JSON.stringify(arg)}. ` +
-        "Remove shell metacharacters (& | ; < > \" ' ` $ ( ) ^ ! * ? % newlines).",
+        "Remove shell metacharacters (& | ; < > \" ' ` $ ( ) [ ] # ^ ! * ? % newlines).",
     );
   }
 }
@@ -53,3 +53,58 @@ export function assertSafeCliArgs(args: ReadonlyArray<string>): void {
     assertSafeCliArg(arg);
   }
 }
+
+/**
+ * Validates a single CLI argument and returns a copy with any shell
+ * metacharacters stripped out.
+ *
+ * {@link assertSafeCliArg} already rejects every shell metacharacter, so the
+ * scrubbing chain below is a runtime no-op for any argument that passes
+ * validation. We keep it as defense-in-depth and, importantly, so that static
+ * analysis (e.g. CodeQL's "Unsafe shell command constructed from library
+ * input" query) can see that the value flowing into `spawn(..., { shell: true })`
+ * on Windows has been stripped of shell metacharacters. CodeQL only recognizes
+ * a sequence of `String.prototype.replace` calls that covers every shell
+ * metacharacter as a sanitizer barrier; a `RegExp.test`-based guard in a
+ * separate function is not enough to break the tracked data flow.
+ *
+ * The chain strips every character that {@link UNSAFE_SHELL_CHARS}/
+ * {@link assertSafeCliArg} reject, so the scrub is a complete superset of the
+ * validation blocklist rather than only the subset CodeQL requires.
+ *
+ * @returns the validated argument with shell metacharacters removed.
+ * @throws Error if `arg` contains any unsafe shell character.
+ */
+export function sanitizeCliArg(arg: string): string {
+  assertSafeCliArg(arg);
+  return arg
+    .replace(/&/g, "")
+    .replace(/\|/g, "")
+    .replace(/;/g, "")
+    .replace(/</g, "")
+    .replace(/>/g, "")
+    .replace(/`/g, "")
+    .replace(/\$/g, "")
+    .replace(/\(/g, "")
+    .replace(/\)/g, "")
+    .replace(/\[/g, "")
+    .replace(/\]/g, "")
+    .replace(/#/g, "")
+    .replace(/"/g, "")
+    .replace(/'/g, "")
+    .replace(/\^/g, "")
+    .replace(/!/g, "")
+    .replace(/\*/g, "")
+    .replace(/\?/g, "")
+    .replace(/%/g, "")
+    .replace(/\n/g, "")
+    .replace(/\r/g, "");
+}
+
+/**
+ * Validates and scrubs every element of an args array, returning the sanitized
+ * array that should be passed to `spawn`. See {@link sanitizeCliArg}.
+ */
+export function sanitizeCliArgs(args: ReadonlyArray<string>): string[] {
+  return args.map(sanitizeCliArg);
+}

package/src/core/crypto/federatedKeyless.ts

@@ -16,6 +16,10 @@ import {
 } from "./keyless.js";
 import { AptosConfig } from "../../api/aptosConfig.js";
 import { Signature } from "../index.js";
+// Register keyless variants so that importing `FederatedKeylessPublicKey` directly
+// triggers registration without relying on the keyless.ts cross-import. Kept from being
+// tree-shaken away via the `sideEffects` allowlist in package.json. See keyless.ts.
+import "./keylessRegistration.js";
 
 /**
  * Represents the FederatedKeylessPublicKey public key

package/src/core/crypto/keyless.ts

@@ -40,6 +40,13 @@ import { FederatedKeylessPublicKey } from "./federatedKeyless.js";
 import { generateSigningMessage } from "../../transactions/transactionBuilder/signingMessage.js";
 import { WeierstrassPoint } from "@noble/curves/abstract/weierstrass.js";
 import { Fp2 } from "@noble/curves/abstract/tower.js";
+// Register keyless variants with the AnyPublicKey/AnySignature registry. This lives
+// next to the primitive definitions so that importing any keyless primitive (e.g.
+// `KeylessPublicKey`/`KeylessSignature`) triggers registration — not only importing an
+// account class. It is kept from being tree-shaken away via the `sideEffects` allowlist
+// in package.json. Without it, deserializing a keyless AnyPublicKey/AnySignature in a
+// bundled (tree-shaken) build throws "Unknown variant index for AnyPublicKey: 3".
+import "./keylessRegistration.js";
 
 /**
  * @group Implementation

package/src/internal/keyless.ts

@@ -27,7 +27,13 @@ import { Account } from "../account/index.js";
 import { EphemeralKeyPair } from "../account/EphemeralKeyPair.js";
 import { KeylessAccount } from "../account/KeylessAccount.js";
 import { ProofFetchCallback } from "../account/AbstractKeylessAccount.js";
-import { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from "../types/keyless.js";
+import {
+  PepperFetchRequest,
+  PepperFetchResponse,
+  ProverRequest,
+  ProverResponse,
+  SignatureFetchResponse,
+} from "../types/keyless.js";
 import { lookupOriginalAccountAddress } from "./account.js";
 import { FederatedKeylessPublicKey } from "../core/crypto/federatedKeyless.js";
 import { FederatedKeylessAccount } from "../account/FederatedKeylessAccount.js";
@@ -76,6 +82,52 @@ export async function getPepper(args: {
   return Hex.fromHexInput(data.pepper).toUint8Array();
 }
 
+/**
+ * Retrieves the `pepper_base` for an account — the VUF signature from which the final pepper is derived.
+ *
+ * Unlike {@link getPepper} (which hits the pepper service `fetch` endpoint and returns the 31-byte derived
+ * pepper), this hits the `signature` endpoint and returns the raw 48-byte `pepper_base` (a compressed
+ * BLS12-381 G1 point). `pepper_base` is deterministic for a given OIDC identity, independent of the ephemeral
+ * key and of the derivation path, which makes it a stable seed for deriving a confidential-asset decryption
+ * key (see `@aptos-labs/confidential-asset`'s `TwistedEd25519PrivateKey.fromPepperBase`). Deriving secrets
+ * from `pepper_base` rather than the final pepper also ensures a leaked pepper does not compromise them.
+ *
+ * @param args - The arguments required to fetch the pepper base.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.jwt - The JSON Web Token used for authentication.
+ * @param args.ephemeralKeyPair - The ephemeral key pair used for the operation.
+ * @param args.uidKey - An optional unique identifier key (defaults to "sub").
+ * @param args.derivationPath - An optional derivation path for the key.
+ * @returns A Uint8Array containing the 48-byte `pepper_base`.
+ * @group Implementation
+ */
+export async function getPepperBase(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+}): Promise<Uint8Array> {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = "sub", derivationPath } = args;
+
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+    derivation_path: derivationPath,
+  };
+  const { data } = await postAptosPepperService<PepperFetchRequest, SignatureFetchResponse>({
+    aptosConfig,
+    path: "signature",
+    body,
+    originMethod: "getPepperBase",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  return Hex.fromHexInput(data.signature).toUint8Array();
+}
+
 /**
  * Generates a zero-knowledge proof based on the provided parameters.
  * This function is essential for creating a signed proof that can be used in various cryptographic operations.

package/src/types/keyless.ts

@@ -45,6 +45,14 @@ export type PepperFetchRequest = {
  */
 export type PepperFetchResponse = { pepper: string; address: string };
 
+/**
+ * The response from the pepper service `signature` endpoint, containing the VUF signature — i.e. the
+ * 48-byte `pepper_base` (compressed BLS12-381 G1 point) from which the final pepper is derived.
+ * @group Implementation
+ * @category Types
+ */
+export type SignatureFetchResponse = { signature: string };
+
 /**
  * The response for keyless configuration containing the maximum committed EPK bytes.
  * @group Implementation

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "7.1.2";
+export const VERSION = "7.2.0-beta.0";