jose 6.2.4: CompactSign, compactVerify

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify jose.CompactSign and jose.compactVerify in pkg:npm/jose@6.2.4
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/jose@6.2.4
Demonstrate these symbols/APIs:
  - CompactSign
  - compactVerify

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:a7a17ddf0b31ba2fefbde78831ff00ee8998c14ce10f6ed935492b814e49a6bc","contract":["CompactSign produces a 3-part compact JWS using symmetric secret key (HS256) that is verified by compactVerify, returning original payload bytes and protected header","CompactSign produces a compact JWS using asymmetric private key (ES256) that is verified by compactVerify with public key","CompactSign produces a compact JWS with RSA-PSS algorithm (PS256) that is verified by compactVerify","compactVerify supports dynamic key resolution via key resolver callback function","compactVerify rejects disallowed algorithms when restricted via algorithms option with JOSEAlgNotAllowed","compactVerify rejects malformed compact JWS strings with JWSInvalid","compactVerify rejects verification when using incorrect key or tampered signature with JWSSignatureVerificationFailed","CompactSign rejects signing without protected header with JWSInvalid"],"goal":"verify jose.CompactSign and jose.compactVerify in pkg:npm/jose@6.2.4","kind":"HOW","packages":["pkg:npm/jose@6.2.4"],"schemaVersion":1,"symbols":["CompactSign","compactVerify"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/jose@6.2.4"],"schemaVersion":1,"subject":"pkg:npm/jose@6.2.4","symbols":["CompactSign","compactVerify"],"verifierAdapter":"node-typescript@1"}

{
  "name": "verify-jose-compact-sign-verify",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "verify-jose-compact-sign-verify",
      "version": "1.0.0",
      "dependencies": {
        "jose": "6.2.4"
      }
    },
    "node_modules/jose": {
      "version": "6.2.4",
      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.4.tgz",
      "integrity": "sha512-N8acGzVsQy6M/fjFcxtysNc4Q379TcM5dM/qKkNtsHFji88yANnXTr7BLeP75iPnFwBfQzM/jg2BZ9+HZrHCZA==",
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/panva"
      }
    }
  }
}

{
  "name": "verify-jose-compact-sign-verify",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "dependencies": {
    "jose": "6.2.4"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify jose.CompactSign and jose.compactVerify in pkg:npm/jose@6.2.4",
  "kind": "HOW",
  "packages": [
    "pkg:npm/jose@6.2.4"
  ],
  "symbols": [
    "CompactSign",
    "compactVerify"
  ]
}

import { CompactSign, compactVerify } from 'jose';

/**
 * Signs a payload into a compact JWS token (3 dot-separated base64url parts).
 *
 * @param {Uint8Array} payload - Raw byte payload to sign
 * @param {import('jose').CompactJWSHeaderParameters} protectedHeader - JWS protected header (must include alg)
 * @param {Uint8Array | import('jose').KeyLike} key - Symmetric secret or asymmetric private key
 * @param {import('jose').SignOptions} [options] - Additional sign options
 * @returns {Promise<string>} Compact JWS string
 */
export async function signCompact(payload, protectedHeader, key, options) {
  const signer = new CompactSign(payload).setProtectedHeader(protectedHeader);
  return signer.sign(key, options);
}

/**
 * Verifies a compact JWS token using the provided key or key resolver callback.
 *
 * @param {string | Uint8Array} jws - Compact JWS string or binary representation
 * @param {Uint8Array | import('jose').KeyLike | import('jose').CompactVerifyGetKey} key - Verification key or key resolver
 * @param {import('jose').CompactVerifyOptions} [options] - Verification options such as allowed algorithms
 * @returns {Promise<{ payload: Uint8Array, protectedHeader: import('jose').CompactJWSHeaderParameters }>}
 */
export async function verifyCompact(jws, key, options) {
  return compactVerify(jws, key, options);
}

export { CompactSign, compactVerify };
export default compactVerify;

import assert from 'node:assert/strict';
import {
  CompactSign,
  compactVerify,
  generateSecret,
  generateKeyPair,
  errors
} from 'jose';
import { signCompact, verifyCompact } from '../src/index.mjs';

const encoder = new TextEncoder();
const decoder = new TextDecoder();
const rawMessage = 'Hello, CodeSampleX CompactSign and compactVerify!';
const payloadBytes = encoder.encode(rawMessage);

// 1. CompactSign produces a 3-part compact JWS using symmetric secret key (HS256) that is verified by compactVerify, returning original payload bytes and protected header
{
  const secretKey = await generateSecret('HS256');
  const jws = await signCompact(payloadBytes, { alg: 'HS256', cty: 'text/plain' }, secretKey);

  assert.equal(typeof jws, 'string');
  assert.equal(jws.split('.').length, 3);

  const { payload, protectedHeader } = await verifyCompact(jws, secretKey);
  assert.equal(decoder.decode(payload), rawMessage);
  assert.equal(protectedHeader.alg, 'HS256');
  assert.equal(protectedHeader.cty, 'text/plain');
}

// 2. CompactSign produces a compact JWS using asymmetric private key (ES256) that is verified by compactVerify with public key
{
  const { publicKey, privateKey } = await generateKeyPair('ES256');
  const jws = await signCompact(payloadBytes, { alg: 'ES256' }, privateKey);

  const { payload, protectedHeader } = await verifyCompact(jws, publicKey);
  assert.equal(decoder.decode(payload), rawMessage);
  assert.equal(protectedHeader.alg, 'ES256');
}

// 3. CompactSign produces a compact JWS with RSA-PSS algorithm (PS256) that is verified by compactVerify
{
  const { publicKey, privateKey } = await generateKeyPair('PS256');
  const jws = await signCompact(payloadBytes, { alg: 'PS256' }, privateKey);

  const { payload, protectedHeader } = await verifyCompact(jws, publicKey);
  assert.equal(decoder.decode(payload), rawMessage);
  assert.equal(protectedHeader.alg, 'PS256');
}

// 4. compactVerify supports dynamic key resolution via key resolver callback function
{
  const key1 = await generateSecret('HS256');
  const key2 = await generateSecret('HS256');
  const keyStore = new Map([
    ['key-id-1', key1],
    ['key-id-2', key2],
  ]);

  const jws = await new CompactSign(payloadBytes)
    .setProtectedHeader({ alg: 'HS256', kid: 'key-id-2' })
    .sign(key2);

  const keyResolver = async (protectedHeader) => {
    const foundKey = keyStore.get(protectedHeader.kid);
    if (!foundKey) throw new Error('Key not found');
    return foundKey;
  };

  const { payload, protectedHeader } = await compactVerify(jws, keyResolver);
  assert.equal(decoder.decode(payload), rawMessage);
  assert.equal(protectedHeader.kid, 'key-id-2');
}

// 5. compactVerify rejects disallowed algorithms when restricted via algorithms option with JOSEAlgNotAllowed
{
  const secretKey = await generateSecret('HS256');
  const jws = await signCompact(payloadBytes, { alg: 'HS256' }, secretKey);

  await assert.rejects(
    async () => {
      await compactVerify(jws, secretKey, {
        algorithms: ['ES256'],
      });
    },
    (err) => {
      assert(err instanceof errors.JOSEAlgNotAllowed);
      assert.equal(err.code, 'ERR_JOSE_ALG_NOT_ALLOWED');
      return true;
    }
  );
}

// 6. compactVerify rejects malformed compact JWS strings with JWSInvalid
{
  const secretKey = await generateSecret('HS256');

  await assert.rejects(
    async () => {
      await compactVerify('invalid.jws.string.extra.part', secretKey);
    },
    (err) => {
      assert(err instanceof errors.JWSInvalid);
      assert.equal(err.code, 'ERR_JWS_INVALID');
      return true;
    }
  );

  await assert.rejects(
    async () => {
      await compactVerify('invalid-token', secretKey);
    },
    (err) => {
      assert(err instanceof errors.JWSInvalid);
      assert.equal(err.code, 'ERR_JWS_INVALID');
      return true;
    }
  );
}

// 7. compactVerify rejects verification when using incorrect key or tampered signature with JWSSignatureVerificationFailed
{
  const key1 = await generateSecret('HS256');
  const key2 = await generateSecret('HS256');

  const jws = await signCompact(payloadBytes, { alg: 'HS256' }, key1);

  // Wrong key
  await assert.rejects(
    async () => {
      await compactVerify(jws, key2);
    },
    (err) => {
      assert(err instanceof errors.JWSSignatureVerificationFailed);
      assert.equal(err.code, 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');
      return true;
    }
  );

  // Tampered payload
  const parts = jws.split('.');
  parts[1] = Buffer.from('tampered').toString('base64url');
  const tamperedJws = parts.join('.');

  await assert.rejects(
    async () => {
      await compactVerify(tamperedJws, key1);
    },
    (err) => {
      assert(err instanceof errors.JWSSignatureVerificationFailed);
      assert.equal(err.code, 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED');
      return true;
    }
  );
}

// 8. CompactSign rejects signing without protected header with JWSInvalid
{
  const secretKey = await generateSecret('HS256');
  const signer = new CompactSign(payloadBytes);

  await assert.rejects(
    async () => {
      await signer.sign(secretKey);
    },
    (err) => {
      assert(err instanceof errors.JWSInvalid);
      assert.equal(err.code, 'ERR_JWS_INVALID');
      return true;
    }
  );
}

console.log('Contract tests passed successfully.');