@andrewheberle/serverless-ssh-ca 0.22.0 → 0.23.0

package/src/certificate.ts

@@ -1,14 +1,9 @@
 import { seconds } from "itty-time"
-import sshpk from "sshpk"
-import type { Certificate, Identity, Key, PrivateKey } from "sshpk"
-import { SSHExtension } from "./types.js"
+import type { PrivateKey, PublicKey } from "./ssh/keys.js"
 import { getPrivateKey, split } from "./utils.js"
 import type { SshCaBindings } from "./types.js"
-
-// sshpk is CommonJS and Node's ESM loader cannot detect most of its named exports, so values are taken from the default import
-const { createCertificate, identityForHost, identityForUser, identityFromDN } = sshpk
-
-// const sshCertificateExtensions = split(env.SSH_CERTIFICATE_EXTENSIONS)
+import { signCertificate, type CertificateFields, type SshCertificate } from "./ssh/certificate.js"
+import { createSigner } from "./ssh/signer.js"
 
 export type CreateCertificateOptions = {
 	lifetime?: number
@@ -16,12 +11,6 @@ export type CreateCertificateOptions = {
 	extensions?: string[]
 }
 
-/* const DefaultCreateCertificateOptions: CreateCertificateOptions = {
-	lifetime: seconds(env.SSH_CERTIFICATE_LIFETIME),
-	principals: [],
-	extensions: sshCertificateExtensions
-} */
-
 export class CertificateError extends Error {
 	constructor(message: string) {
 		super(message)
@@ -41,18 +30,36 @@ export type GenerateCertificateOptions = {
 	serial?: bigint
 } & CreateCertificateOptions
 
-export const generateCertificate = (env: SshCaBindings, email: string, key: PrivateKey, public_key: Key, options?: GenerateCertificateOptions): Certificate => {
-	let { lifetime } = options ?? {}
-	const { principals, extensions, serial } = options ?? {}
+/**
+ * Signs a certificate with the CA key
+ *
+ * @throws {@link CertificateError} when the certificate has no principals,
+ * as OpenSSH accepts a certificate without principals for any user or host
+ */
+const sign = async (key: PrivateKey, fields: Omit<CertificateFields, "validAfter" | "validBefore">, lifetime: number): Promise<SshCertificate> => {
+	if (fields.principals.length === 0) {
+		throw new CertificateError("a certificate must have at least one principal")
+	}
+
+	// the validity is to the second, so starts at the current second rather
+	// than in the future
+	const validAfter = new Date(Math.floor(Date.now() / 1000) * 1000)
+	const validBefore = new Date(validAfter.getTime() + lifetime * 1000)
 
-	// add identities
+	return await signCertificate({ ...fields, validAfter, validBefore }, await createSigner(key))
+}
+
+export const generateCertificate = async (env: SshCaBindings, email: string, key: PrivateKey, public_key: PublicKey, options?: GenerateCertificateOptions): Promise<SshCertificate> => {
+	const { lifetime, principals, extensions, serial } = options ?? {}
+
+	// add principals
 	const includeSelf = env.SSH_CERTIFICATE_INCLUDE_SELF === undefined
 		? false
 		: typeof env.SSH_CERTIFICATE_INCLUDE_SELF === "string"
 			? env.SSH_CERTIFICATE_INCLUDE_SELF === "true"
 			: env.SSH_CERTIFICATE_INCLUDE_SELF
-	const identity = includeSelf
-		? [identityForUser(email.split("@")[0]!)]
+	const certificatePrincipals = includeSelf
+		? [email.split("@")[0]!]
 		: []
 
 	// add email?
@@ -62,86 +69,43 @@ export const generateCertificate = (env: SshCaBindings, email: string, key: Priv
 			? env.SSH_CERTIFICATE_INCLUDE_SELF_EMAIL === "true"
 			: env.SSH_CERTIFICATE_INCLUDE_SELF_EMAIL
 	if (includeSelfEmail) {
-		identity.push(identityForUser(email))
+		certificatePrincipals.push(email)
 	}
 
 	if (principals !== undefined) {
-		for (const p of principals) {
-			identity.push(identityForUser(p))
-		}
-	}
-
-	for (const p of split(env.SSH_CERTIFICATE_PRINCIPALS)) {
-		identity.push(identityForUser(p))
+		certificatePrincipals.push(...principals)
 	}
 
-
-	// lifetime is the smaller of what was provided in the options or the default
-	lifetime = lifetime !== undefined
-		? Math.min(lifetime, seconds(env.SSH_CERTIFICATE_LIFETIME))
-		: seconds(env.SSH_CERTIFICATE_LIFETIME)
-
-	// generate value for serial of certificate
-	const s = generateSerial(serial)
-
-	// set issuer of certificate based on ISSUER_DN
-	const issuer = identityFromDN(env.ISSUER_DN)
-
-	// create certificate
-	const certificate = createCertificate(identity, public_key, issuer, key, { lifetime: lifetime, serial: s })
-
-	// ensure openssh info is included in certificate (should not occur)
-	if (certificate.signatures.openssh === undefined) {
-		throw new CertificateError("missing openssh information in certificate")
-	}
+	certificatePrincipals.push(...split(env.SSH_CERTIFICATE_PRINCIPALS))
 
 	const sshCertificateExtensions = split(env.SSH_CERTIFICATE_EXTENSIONS)
 
-	// add usage extensions
-	const sshextensions: SSHExtension[] = []
+	// if extensions are provided in request, ensure they do not include extra extensions beyond the defaults
 	if (extensions !== undefined) {
-		// if extensions are provided in request, ensure they do not include extra extensions beyond the defaults
 		for (const ext of extensions) {
 			if (!sshCertificateExtensions.includes(ext)) {
 				throw new CertificateError(`${ext} is not allowed`)
 			}
-
-			// add to list of allowed extensions
-			sshextensions.push({
-				critical: false,
-				name: ext,
-				data: Buffer.alloc(0)
-			})
-		}
-	} else {
-		// use defaults if not provided
-		sshCertificateExtensions.forEach((ext: string) => {
-			sshextensions.push({
-				critical: false,
-				name: ext,
-				data: Buffer.alloc(0)
-			})
-		})
-
-	}
-
-	// add info to certificate
-	certificate.signatures = {
-		openssh: {
-			nonce: certificate.signatures.openssh.nonce,
-			keyId: email,
-			signature: certificate.signatures.openssh.signature,
-			exts: sshextensions
 		}
 	}
 
-	// re-sign after changes
-	certificate.signWith(key)
+	// lifetime is the smaller of what was provided in the options or the default
+	const certificateLifetime = lifetime !== undefined
+		? Math.min(lifetime, seconds(env.SSH_CERTIFICATE_LIFETIME))
+		: seconds(env.SSH_CERTIFICATE_LIFETIME)
 
-	return certificate
+	return await sign(key, {
+		kind: "user",
+		publicKey: public_key,
+		serial: serial ?? generateSerial(),
+		keyId: email,
+		principals: certificatePrincipals,
+		// use defaults if not provided
+		extensions: extensions ?? sshCertificateExtensions,
+	}, certificateLifetime)
 }
 
-export async function createSignedCertificate(env: SshCaBindings, email: string, public_key: Key, options?: CreateCertificateOptions): Promise<Certificate> {
+export async function createSignedCertificate(env: SshCaBindings, email: string, public_key: PublicKey, options?: CreateCertificateOptions): Promise<SshCertificate> {
 	// grab private key from secret store
 	const key = await getPrivateKey(env)
 
@@ -153,13 +117,12 @@ export async function createSignedCertificate(env: SshCaBindings, email: string,
 		}
 	}
 
-	return generateCertificate(env, email, key, public_key, options)
+	return await generateCertificate(env, email, key, public_key, options)
 }
 
 export type CreateHostCertificateOptions = {
 	lifetime?: number
 	principals?: string[]
-	subjects?: Identity[]
 }
 
 export class BadIssuerError extends Error {
@@ -171,54 +134,30 @@ export class BadIssuerError extends Error {
 	}
 }
 
-export async function createSignedHostCertificate(env: SshCaBindings, public_key: Key, options?: CreateHostCertificateOptions): Promise<Certificate> {
-	if (options === undefined) {
-		options = {
-			lifetime: seconds(env.SSH_HOST_CERTIFICATE_LIFETIME),
-			principals: []
-		}
-	}
-	// generate list of identities for host key
-	const identity: Identity[] = []
-	if (options.principals !== undefined) {
-		for (const p of options.principals) {
-			identity.push(identityForHost(p))
-		}
-	}
-
-	// add any already provided subjects (for renewals only)
-	if (options.subjects !== undefined) {
-		identity.push(...options.subjects)
-	}
+export async function createSignedHostCertificate(env: SshCaBindings, public_key: PublicKey, options?: CreateHostCertificateOptions): Promise<SshCertificate> {
+	const principals = options?.principals ?? []
 
 	// grab private key from secret store
 	const key = await getPrivateKey(env)
 
 	// lifetime is the smaller of what was provided in the options or the default
-	const lifetime = options.lifetime !== undefined
+	const lifetime = options?.lifetime !== undefined
 		? Math.min(options.lifetime, seconds(env.SSH_HOST_CERTIFICATE_LIFETIME))
 		: seconds(env.SSH_HOST_CERTIFICATE_LIFETIME)
 
-	// generate value for serial of certificate
-	const serial = generateSerial()
-
-	// set issuer of certificate based on ISSUER_DN
-	const issuer = identityFromDN(env.ISSUER_DN)
-
-	// create certificate
-	const certificate = createCertificate(identity, public_key, issuer, key, { lifetime: lifetime, serial: serial })
-
-	return certificate
+	return await sign(key, {
+		kind: "host",
+		publicKey: public_key,
+		serial: generateSerial(),
+		keyId: `host_${principals[0]}`,
+		principals,
+		extensions: [],
+	}, lifetime)
 }
 
-export const generateSerial = (serial?: bigint): Buffer<ArrayBuffer> => {
-	if (serial !== undefined) {
-		const s = Buffer.alloc(8)
-		s.writeBigUInt64BE(serial)
-
-		return s
-	}
-
-	const randomBytes = crypto.getRandomValues(new Uint8Array(8))
-	return Buffer.from(randomBytes)
+/**
+ * Returns a random certificate serial number
+ */
+export const generateSerial = (): bigint => {
+	return new DataView(crypto.getRandomValues(new Uint8Array(8)).buffer).getBigUint64(0)
 }

package/src/db/index.ts

@@ -1,4 +1,5 @@
-import type { Certificate, Format, Identity } from "sshpk"
+import { PublicKey } from "../ssh/keys.js"
+import type { SshCertificate } from "../ssh/certificate.js"
 import { logger } from "../logger.js"
 import type { SshCaBindings } from "../types.js"
 import { D1QB } from "workers-qb"
@@ -48,27 +49,22 @@ export const dbCleanup = async (env: SshCaBindings) => {
 	}
 }
 
-export const recordCertificate = async (env: SshCaBindings, certificate: Certificate, keyid: string, certificateType: CertificateType = CertificateType.User) => {
-	const serial = certificate.serial.readBigUInt64BE(0)
-	const subjects = certificate.subjects.map((v: Identity): string => {
-		return v.toString()
-	}).join(",")
-	const extensions = certificate.getExtensions().map((v: Format.OpenSshSignatureExt | Format.x509SignatureExt): string => {
-		// @ts-expect-error: the name property does exist
-		return v.name as string
-	}).join(",")
+export const recordCertificate = async (env: SshCaBindings, certificate: SshCertificate, keyid: string, certificateType: CertificateType = CertificateType.User) => {
+	// principals are recorded as distinguished names, as they were when
+	// certificates were created with sshpk
+	const principals = certificate.principals.map((p) => `${certificate.kind === "host" ? "CN" : "UID"}=${p}`).join(",")
 	const qb = await connect(env)
 	const res = await qb.insert({
 		tableName: "certificates",
 		data: {
-			serial: `${serial}`,
+			serial: `${certificate.serial}`,
 			key_id: keyid,
-			principals: subjects,
-			extensions: extensions,
-			valid_after: certificate.validFrom.toISOString(),
-			valid_before: certificate.validUntil.toISOString(),
+			principals: principals,
+			extensions: certificate.extensions.join(","),
+			valid_after: certificate.validAfter.toISOString(),
+			valid_before: certificate.validBefore.toISOString(),
 			certificate_type: certificateType,
-			public_key: certificate.subjectKey.toString("ssh")
+			public_key: certificate.publicKey.toString()
 		},
 	}).execute()
 
@@ -95,21 +91,44 @@ export enum RevocationStatus {
 	NotFound,
 	Revoked,
 	Revokable,
-	Unrevokable
 }
 
-export const revocationStatus = async (env: SshCaBindings, serial: bigint, publickey: string, certificateType: CertificateType): Promise<RevocationStatus> => {
+// whether a public key recorded in OpenSSH format is the same as another key,
+// treating a recorded key that cannot be parsed as a different key
+const isKey = (recorded: string, publicKey: PublicKey): boolean => {
+	try {
+		return PublicKey.parse(recorded).equals(publicKey)
+	} catch {
+		return false
+	}
+}
+
+/**
+ * Returns whether a certificate can be revoked by the holder of a public key.
+ *
+ * The public key is compared by fingerprint, so a key with a different
+ * comment to the one the certificate was issued for still matches.
+ *
+ * @param env The CA bindings
+ * @param serial The serial of the certificate
+ * @param publicKey The public key the requester has proven possession of
+ * @param certificateType The type of certificate
+ * @returns The revocation status of the certificate
+ */
+export const revocationStatus = async (env: SshCaBindings, serial: bigint, publicKey: PublicKey, certificateType: CertificateType): Promise<RevocationStatus> => {
 	const qb = await connect(env)
 	const res = await qb.fetchOne({
 		tableName: "certificates",
 		fields: ["public_key", "revoked_at"],
 		where: {
-			conditions: "serial = ? AND public_key = ? AND certificate_type = ?",
-			params: [`${serial}`, publickey, certificateType]
+			conditions: "serial = ? AND certificate_type = ?",
+			params: [`${serial}`, certificateType]
 		}
 	}).execute()
 
-	if (res.results === undefined) {
+	// a certificate issued for another key is reported as not found, so
+	// requests cannot be used to discover which serials exist
+	if (res.results?.public_key == null || !isKey(res.results.public_key, publicKey)) {
 		return RevocationStatus.NotFound
 	}
 
@@ -117,11 +136,7 @@ export const revocationStatus = async (env: SshCaBindings, serial: bigint, publi
 		return RevocationStatus.Revoked
 	}
 
-	if (publickey === res.results.public_key) {
-		return RevocationStatus.Revokable
-	}
-
-	return RevocationStatus.Unrevokable
+	return RevocationStatus.Revokable
 }
 
 export const getRevocationList = async (env: SshCaBindings, certificateType: CertificateType): Promise<string[]> => {

package/src/krl.ts

@@ -1,5 +1,5 @@
-import type { AlgorithmPart, PrivateKey } from "sshpk"
-import { toFixedWidth } from "./sshsig/sig_parser.js"
+import type { PrivateKey } from "./ssh/keys.js"
+import { createSigner } from "./ssh/signer.js"
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
@@ -59,32 +59,6 @@ function encodeSection(sectionType: number, data: Uint8Array): Uint8Array {
     return concat(new Uint8Array([sectionType]), encodeString(data))
 }
 
-// ── CA public-key extraction ─────────────────────────────────────────────────
-
-/**
- * Extract the SSH wire-format public key bytes from an sshpk PrivateKey.
- *
- * sshpk's "ssh" format produces a string like:
- *   ssh-ed25519 AAAA...base64... [comment]
- *
- * The base64 blob *is* the SSH wire encoding of the public key, so we just
- * decode it.  This works for both Ed25519 and ECDSA keys.
- */
-function caKeyWireBytes(caKey: PrivateKey): Uint8Array {
-    const sshString = caKey.toPublic().toString("ssh")
-    // Format: "<type> <base64> [<comment>]"  — we want the second token.
-    const base64 = sshString.trim().split(/\s+/)[1]
-    if (!base64) {
-        throw new Error("Unexpected sshpk 'ssh' format output: " + sshString)
-    }
-    const binary = atob(base64)
-    const bytes = new Uint8Array(binary.length)
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i)
-    }
-    return bytes
-}
-
 // ── Constants ────────────────────────────────────────────────────────────────
 
 const SSHSIG_MAGIC = new TextEncoder().encode("SSHSIG")
@@ -92,156 +66,6 @@ const SIG_VERSION = 1
 const NAMESPACE = "krl@com.github.serverless-ssh-ca.andrewheberle"
 const HASH_ALGORITHM = "sha512"
 
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Get the raw bytes of a named part of an sshpk key.
- */
-function keyPart(key: PrivateKey, name: AlgorithmPart): Uint8Array {
-    const part = key.parts.find((p) => p.name === name)
-    if (part === undefined) {
-        throw new Error(`Missing ${name} part in ${key.type} key`)
-    }
-    return part.data
-}
-
-/**
- * Base64url-encode bytes without padding, as used for JWK values.
- */
-function base64url(bytes: Uint8Array): string {
-    let binary = ""
-    for (const byte of bytes) {
-        binary += String.fromCharCode(byte)
-    }
-    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
-}
-
-/**
- * Import an sshpk PrivateKey into a WebCrypto CryptoKey.
- * Supports Ed25519 and ECDSA (P-256 / P-384 / P-521).
- */
-async function importPrivateKey(caKey: PrivateKey): Promise<{
-    cryptoKey: CryptoKey
-    sigAlgo: string // SSH signature algorithm name
-    webCryptoAlgo: Parameters<SubtleCrypto["sign"]>[0]
-}> {
-    const type = caKey.type // "ed25519" | "ecdsa" | etc.
-    const curve = (caKey as unknown as { curve?: string }).curve
-
-    if (type === "ed25519") {
-        // import from the raw key parts as a JWK rather than via sshpk's PKCS#8
-        // output, which drops a leading zero byte from the seed (about 1 key in
-        // 512) and is then rejected by WebCrypto
-        const seed = keyPart(caKey, "k")
-        const publicKey = keyPart(caKey, "A")
-        if (seed.length !== 32 || publicKey.length !== 32) {
-            throw new Error(`Unexpected Ed25519 key part lengths: k=${seed.length} A=${publicKey.length}`)
-        }
-        const cryptoKey = await crypto.subtle.importKey(
-            "jwk",
-            { kty: "OKP", crv: "Ed25519", d: base64url(seed), x: base64url(publicKey) },
-            { name: "Ed25519" },
-            false,
-            ["sign"],
-        )
-        return {
-            cryptoKey,
-            sigAlgo: "ssh-ed25519",
-            webCryptoAlgo: { name: "Ed25519" },
-        }
-    } else if (type === "ecdsa") {
-        let namedCurve: string
-        let sigAlgo: string
-        let hash: string
-        let size: number // bytes in each coordinate and the private key
-
-        if (curve === "nistp256") {
-            namedCurve = "P-256"
-            sigAlgo = "ecdsa-sha2-nistp256"
-            hash = "SHA-256"
-            size = 32
-        } else if (curve === "nistp384") {
-            namedCurve = "P-384"
-            sigAlgo = "ecdsa-sha2-nistp384"
-            hash = "SHA-384"
-            size = 48
-        } else if (curve === "nistp521") {
-            namedCurve = "P-521"
-            sigAlgo = "ecdsa-sha2-nistp521"
-            hash = "SHA-512"
-            size = 66
-        } else {
-            throw new Error(`Unsupported ECDSA curve: ${curve}`)
-        }
-
-        // import from the raw key parts as a JWK rather than via sshpk's PKCS#8
-        // output, which drops leading zero bytes from the private key so it is
-        // shorter than RFC 5915 requires (about half of P-521 keys)
-        const point = keyPart(caKey, "Q")
-        if (point.length !== 1 + size * 2 || point[0] !== 0x04) {
-            throw new Error(`Unexpected ECDSA public key encoding for ${curve}`)
-        }
-        // d is an SSH mpint, so may be short or have a leading sign byte
-        const d = toFixedWidth(keyPart(caKey, "d"), size)
-        const cryptoKey = await crypto.subtle.importKey(
-            "jwk",
-            {
-                kty: "EC",
-                crv: namedCurve,
-                d: base64url(d),
-                x: base64url(point.subarray(1, 1 + size)),
-                y: base64url(point.subarray(1 + size)),
-            },
-            { name: "ECDSA", namedCurve },
-            false,
-            ["sign"],
-        )
-        return {
-            cryptoKey,
-            sigAlgo,
-            webCryptoAlgo: { name: "ECDSA", hash: { name: hash } },
-        }
-    } else {
-        throw new Error(`Unsupported key type: ${type}`)
-    }
-}
-
-/**
- * Convert a WebCrypto ECDSA signature (IEEE P1363: raw r||s) to the SSH wire
- * encoding: string(algo) + string(mpint(r) + mpint(s)).
- *
- * SSH mpints are big-endian, with a leading 0x00 byte if the high bit is set.
- */
-function p1363ToSshEcdsaSig(
-    p1363: Uint8Array,
-    sigAlgo: string,
-): Uint8Array {
-    const half = p1363.length / 2
-    const r = p1363.slice(0, half)
-    const s = p1363.slice(half)
-
-    function encodeMpint(n: Uint8Array): Uint8Array {
-        // Strip leading zero bytes, then re-pad if high bit set.
-        let start = 0
-        while (start < n.length - 1 && n[start] === 0) start++
-        const trimmed = n.slice(start)
-        const padded =
-            trimmed[0]! & 0x80 ? concat(new Uint8Array([0x00]), trimmed) : trimmed
-        return encodeString(padded)
-    }
-
-    const innerSig = concat(encodeMpint(r), encodeMpint(s))
-    return concat(encodeString(sigAlgo), encodeString(innerSig))
-}
-
-/**
- * Wrap an Ed25519 WebCrypto signature into SSH wire encoding:
- * string(algo) + string(sig_bytes)
- */
-function wrapEd25519Sig(sig: Uint8Array): Uint8Array {
-    return concat(encodeString("ssh-ed25519"), encodeString(sig))
-}
-
 /**
  * Base64-encode bytes and wrap in SSH signature armor at 76 chars per line.
  */
@@ -310,7 +134,7 @@ export class KRLBuilder {
         const keyIds = [...this._keyIds].sort()
 
         const content = concat(
-            encodeString(caKeyWireBytes(this._caKey)),
+            encodeString(this._caKey.publicKey.blob),
             encodeUint32(serials.length),
             ...serials.map(encodeUint64),
             encodeUint32(keyIds.length),
@@ -375,7 +199,7 @@ export class KRLBuilder {
         //   <one or more cert sub-sections>
         //
         const certSectionData = concat(
-            encodeString(caKeyWireBytes(this._caKey)), // ca_key
+            encodeString(this._caKey.publicKey.blob), // ca_key
             encodeString(""), // reserved
             ...certSubSections
         )
@@ -409,7 +233,7 @@ export class KRLBuilder {
         } else {
             krl = this._krl
         }
-        const { cryptoKey, sigAlgo, webCryptoAlgo } = await importPrivateKey(this._caKey)
+        const signer = await createSigner(this._caKey)
 
         // 1. Hash the KRL bytes with SHA-512.
         const krlHash = new Uint8Array(
@@ -431,18 +255,10 @@ export class KRLBuilder {
             encodeString(krlHash),
         )
 
-        // 3. Sign the blob.
-        const rawSig = new Uint8Array(
-            await crypto.subtle.sign(webCryptoAlgo, cryptoKey, signedData),
-        )
-
-        // 4. Encode the signature into SSH wire format.
-        const sshSig =
-            sigAlgo === "ssh-ed25519"
-                ? wrapEd25519Sig(rawSig)
-                : p1363ToSshEcdsaSig(rawSig, sigAlgo)
+        // 3. Sign the blob, which returns the signature in SSH wire format.
+        const sshSig = await signer.sign(signedData)
 
-        // 5. Assemble the outer SSHSIG blob.
+        // 4. Assemble the outer SSHSIG blob.
         //
         //   byte[6]  "SSHSIG"
         //   uint32   SIG_VERSION (1)
@@ -451,18 +267,17 @@ export class KRLBuilder {
         //   string   reserved  (empty)
         //   string   hash_algorithm
         //   string   signature
-        const publicKeyWire = caKeyWireBytes(this._caKey)
         const sigBlob = concat(
             SSHSIG_MAGIC,
             encodeUint32(SIG_VERSION),
-            encodeString(publicKeyWire),
+            encodeString(signer.publicKey),
             encodeString(NAMESPACE),
             encodeString(""),      // reserved
             encodeString(HASH_ALGORITHM),
             encodeString(sshSig),
         )
 
-        // 6. Armor and return.
+        // 5. Armor and return.
         return armorSignature(sigBlob)
     }
 }