@1shotapi/ows-signer 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1shotapi/ows-signer",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "OWS Signing Layer — plain JavaScript WebAuthn PRF key custody with curve-based signing (on-chain via EIP-8244)",
   "type": "module",
   "files": [

package/src/crypto/sign.js

@@ -27,10 +27,12 @@ export async function signWithScheme(
         lowS: true,
       });
       const compact = sig.toCompactRawBytes();
+      // Ethereum ecrecover / OpenZeppelin ECDSA require v ∈ {27, 28}.
+      // Noble returns recovery ∈ {0,1} (rarely 2,3); mask to yParity then +27.
       const recovery = sig.recovery ?? 0;
       const out = new Uint8Array(65);
       out.set(compact, 0);
-      out[64] = recovery;
+      out[64] = 27 + (recovery & 1);
       return to0xHex(out);
     }
     case "secp256k1-bip340":

package/src/handlers.js

@@ -36,7 +36,7 @@ import {
   getAssertionSignatureBase64Url,
   getCredentialId,
   getPasskeyAssertion,
-  getPasskeyPublicKeyBase64Url,
+  getCosePublicKeyBase64Url,
 } from "./webauthn.js";
 
 /**
@@ -227,7 +227,7 @@ async function handleCreateCredential(params, correlationId, targetOrigin) {
 
     emitEvent(window.parent, targetOrigin, "CredentialCreated", correlationId, {
       credentialId,
-      passkeyPublicKey: getPasskeyPublicKeyBase64Url(credential),
+      cosePublicKey: getCosePublicKeyBase64Url(credential),
       secp256k1PublicKey: to0xHex(keys.secp256k1PublicKey),
     });
     zeroize(keys.secp256k1PrivateKey);
@@ -626,7 +626,7 @@ async function handleGetPublicKey(params, correlationId, targetOrigin) {
 
     emitEvent(window.parent, targetOrigin, "PublicKey", correlationId, {
       credentialId: getCredentialId(credential),
-      passkeyPublicKey: getPasskeyPublicKeyBase64Url(credential),
+      cosePublicKey: getCosePublicKeyBase64Url(credential),
       secp256k1PublicKey: to0xHex(keys.secp256k1PublicKey),
       ed25519PublicKey: to0xHex(keys.ed25519PublicKey),
     });

package/src/webauthn.js

@@ -126,15 +126,112 @@ export function getCredentialId(credential) {
 
 /**
  * @param {PublicKeyCredential} credential
- * @returns {string | null}
+ * @returns {string | null} COSE credentialPublicKey as base64url, or null
  */
-export function getPasskeyPublicKeyBase64Url(credential) {
+export function getCosePublicKeyBase64Url(credential) {
   const response = credential.response;
-  if ("getPublicKey" in response && typeof response.getPublicKey === "function") {
-    const key = response.getPublicKey();
-    return key ? bufferToBase64Url(key) : null;
+  // COSE lives in attestation authenticator data only — not on assertions,
+  // and not via AuthenticatorAttestationResponse.getPublicKey() (that is SPKI).
+  if (
+    !("getAuthenticatorData" in response) ||
+    typeof response.getAuthenticatorData !== "function"
+  ) {
+    return null;
   }
-  return null;
+  const authData = response.getAuthenticatorData();
+  if (!authData) return null;
+  const cose = extractCosePublicKeyFromAuthenticatorData(
+    new Uint8Array(authData),
+  );
+  return cose ? bufferToBase64Url(cose) : null;
+}
+
+/**
+ * Slice the COSE credentialPublicKey from attested credential data.
+ * @param {Uint8Array} authData
+ * @returns {Uint8Array | null}
+ */
+function extractCosePublicKeyFromAuthenticatorData(authData) {
+  if (authData.length < 37) return null;
+  const flags = authData[32];
+  const hasAttestedCredentialData = (flags & 0x40) !== 0;
+  if (!hasAttestedCredentialData) return null;
+
+  let offset = 37; // rpIdHash(32) + flags(1) + signCount(4)
+  offset += 16; // aaguid
+  if (offset + 2 > authData.length) return null;
+  const credentialIdLength = (authData[offset] << 8) | authData[offset + 1];
+  offset += 2 + credentialIdLength;
+  if (offset >= authData.length) return null;
+
+  try {
+    const length = cborFirstItemLength(authData, offset);
+    return authData.subarray(offset, offset + length);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Byte length of the first definite-length CBOR item at `offset`.
+ * Sufficient for WebAuthn COSE public keys (maps of ints / bstrs).
+ * @param {Uint8Array} buf
+ * @param {number} offset
+ * @returns {number}
+ */
+function cborFirstItemLength(buf, offset) {
+  if (offset >= buf.length) throw new Error("cborTruncated");
+  const initial = buf[offset];
+  const major = initial >> 5;
+  const additional = initial & 31;
+  let pos = offset + 1;
+  let argument = additional;
+
+  if (additional === 24) {
+    argument = buf[pos];
+    pos += 1;
+  } else if (additional === 25) {
+    argument = (buf[pos] << 8) | buf[pos + 1];
+    pos += 2;
+  } else if (additional === 26) {
+    argument =
+      (buf[pos] << 24) |
+      (buf[pos + 1] << 16) |
+      (buf[pos + 2] << 8) |
+      buf[pos + 3];
+    pos += 4;
+  } else if (additional === 27) {
+    // 64-bit; WebAuthn keys never need this size
+    throw new Error("cborUint64Unsupported");
+  } else if (additional >= 28) {
+    throw new Error("cborIndefiniteUnsupported");
+  }
+
+  if (major === 0 || major === 1) {
+    return pos - offset;
+  }
+  if (major === 2 || major === 3) {
+    return pos - offset + argument;
+  }
+  if (major === 7) {
+    if (additional < 24) return pos - offset;
+    if (additional === 25) return pos - offset + 2;
+    if (additional === 26) return pos - offset + 4;
+    if (additional === 27) return pos - offset + 8;
+    return pos - offset;
+  }
+  if (major === 6) {
+    const inner = cborFirstItemLength(buf, pos);
+    return pos - offset + inner;
+  }
+  if (major === 4 || major === 5) {
+    const valueCount = major === 5 ? argument * 2 : argument;
+    for (let i = 0; i < valueCount; i++) {
+      pos += cborFirstItemLength(buf, pos);
+    }
+    return pos - offset;
+  }
+  throw new Error("cborUnsupportedMajor");
 }
 
 /**