Presentation with key binding

app/.well-known/jwt-issuer/route.ts

@@ -3,8 +3,10 @@ import { NextResponse } from 'next/server'
 export async function GET(request: Request) {
   const issuerMetadata = {
     "issuer": "did:web:dune.did.ai",
-    "jwks_uri": "https://dune.did.ai/.well-known/jwks"
-    }
+    "jwks_uri": "https://dune.did.ai/.well-known/jwks",
+    "audience": "https://dune.did.ai",
+    "challenge_endpoint": "https://dune.did.ai/.well-known/spice-challenge"
+  }
   return NextResponse.json(issuerMetadata)
 }
 

app/.well-known/spice-challenge/[token]/route.ts

@@ -0,0 +1,104 @@
+import moment from 'moment'
+import { NextResponse } from 'next/server'
+
+import transmute from '@transmute/verifiable-credentials'
+
+export type PostChallengeTokenParams = {
+  token: string
+}
+
+type VerifiedSpiceChallengeToken = {
+  protectedHeader: {
+    kid: string
+    alg: string
+  }
+  claimset: {
+    iss: string
+    iat: number
+    exp: number
+    aud: string
+  }
+}
+
+export async function POST(request: Request, {params}: { params: PostChallengeTokenParams }) {
+  const challenge = params.token;
+  const secretKeyJwk = JSON.parse(process.env.PRIVATE_KEY_JWK as string)
+  const {d, ...publicKeyJwk} = secretKeyJwk
+
+  const isChallengeUnixTimestamp = !Number.isNaN(parseInt(challenge, 10))
+  let audienceForChallenge = 'https://dune.did.ai'
+  let nonceForChallenge = challenge
+  if (isChallengeUnixTimestamp){
+    // check time here
+    const now = moment()
+    const nonceTime = moment.unix(parseInt(challenge, 10))
+    // const nonceAge = nonceTime.fromNow()
+    // console.log('Key binding token nonce age: ', nonceAge)
+    if (now.isAfter(nonceTime.add(5, 'minutes'))){
+      throw new Error('nonce for key binding token is too stale to accept')
+    }
+   } else {
+    try {
+      const verifiedChallengeToken =  await transmute.vc.sd.verifier<VerifiedSpiceChallengeToken>({
+        resolver: {
+          resolve: async (kid: string) => {
+            if (kid === `did:web:dune.did.ai#${publicKeyJwk.kid}`){
+              return publicKeyJwk
+            } 
+            throw new Error('Unsupported kid: ' + kid)
+          }
+        }
+      }).verify({
+        token: challenge
+      })
+      const {iss, iat, exp, aud} = verifiedChallengeToken.claimset
+      if (iss !== 'did:web:dune.did.ai') {
+        throw new Error('Unknown challenge token issuer.')
+      }
+      const now = moment();
+      if (now.isBefore(moment.unix(iat))) {
+        throw new Error('Challenge token cannot be issued in the future.')
+      }
+      if (now.isAfter(moment.unix(exp))) {
+        throw new Error('Challenge token cannot be expired in the past.')
+      }
+      if (aud !== 'https://dune.did.ai') {
+        throw new Error('Challenge token must be issued for https://dune.did.ai')
+      }
+      audienceForChallenge = aud;
+    } catch(e){
+      console.error(e)
+      return NextResponse.json({type: 'Verification Failed', detail: 'Challenge token was not signed for this audience' }, {
+        status: 500,
+      })
+    }
+  }
+
+
+  try {
+    const token = await request.json();
+    await transmute.vc.sd.verifier({
+      resolver: {
+        resolve: async (kid: string) => {
+          if (kid === `did:web:dune.did.ai#${publicKeyJwk.kid}`){
+            return publicKeyJwk
+          } 
+          throw new Error('Unsupported kid: ' + kid)
+        }
+      }
+    }).verify({
+      audience: audienceForChallenge, 
+      nonce: nonceForChallenge,
+      token
+    })
+    return NextResponse.json({message: "Challenge accepted"})
+  } catch(e){
+    console.error(e)
+    return NextResponse.json({type: 'Verification Failed', detail: 'Verification Failed' }, {
+      status: 500,
+    })
+  }
+}
+
+// forces the route handler to be dynamic
+export const dynamic = "force-dynamic";

app/.well-known/spice-challenge/route.ts

@@ -0,0 +1,31 @@
+import moment from 'moment'
+import { NextResponse } from 'next/server'
+
+import transmute from '@transmute/verifiable-credentials'
+
+export async function GET(request: Request) {
+  const secretKeyJwk = JSON.parse(process.env.PRIVATE_KEY_JWK as string)
+  const iat = moment().subtract(1, 'second').unix()
+  const exp = moment().add(5, 'minutes').unix()
+  const claimset = `
+iss: "did:web:dune.did.ai"
+aud: "https://dune.did.ai"
+iat: ${iat}
+exp: ${exp}
+  `.trim()
+  const token =  await transmute.vc.sd.issuer({
+    kid: `did:web:dune.did.ai#${secretKeyJwk.kid}`,
+    secretKeyJwk,
+  }).issue({
+    claimset
+  })
+
+  const newHeaders = new Headers(request.headers)
+  newHeaders.set('Content-Type', 'application/sd-jwt')
+  return new NextResponse(Buffer.from(token),  {
+    headers: newHeaders,
+  })
+}
+
+// forces the route handler to be dynamic
+export const dynamic = "force-dynamic";

app/internal/disclose/route.ts

@@ -10,6 +10,10 @@ export async function POST(request: Request) {
   const nonce = url.searchParams.get('nonce') || ''
   const secretKeyJwk = JSON.parse(process.env.PRIVATE_KEY_JWK as string)
   try {
+    if (audience !== 'https://dune.did.ai'){
+      throw new Error('This demo only supports key binding for itself as the audience.')
+    }
+
     const disclosedToken = await transmute.vc.sd.holder({
       kid: `did:web:dune.did.ai#${secretKeyJwk.kid}`,
       secretKeyJwk

app/internal/issue/route.ts

@@ -13,8 +13,7 @@ export async function POST(request: Request) {
     }).issue({
       holder: publicKeyJwk,
       claimset: disclosable
-    })
-
+    })  
     return NextResponse.json({ token })
   } catch(e){
     return NextResponse.json({type: 'Issuance Failed', detail: 'Issuance Failed' }, {

app/internal/verify/route.ts

@@ -2,14 +2,76 @@ import { NextResponse } from 'next/server'
 
 import transmute from '@transmute/verifiable-credentials'
 
+import moment from 'moment';
 
-export async function POST(request: Request) {
-  const { audience, nonce, token } = await request.json();
 
+type VerifiedSpiceChallengeToken = {
+  protectedHeader: {
+    kid: string
+    alg: string
+  }
+  claimset: {
+    iss: string
+    iat: number
+    exp: number
+    aud: string
+  }
+}
+
+export async function POST(request: Request) {
+  const { nonce, token } = await request.json();
   const secretKeyJwk = JSON.parse(process.env.PRIVATE_KEY_JWK as string)
   const {d, ...publicKeyJwk} = secretKeyJwk
+  let audienceForChallenge = 'https://dune.did.ai'
+  let nonceForChallenge = nonce
+  const isChallengeUnixTimestamp = !Number.isNaN(parseInt(nonce, 10))
+  if (isChallengeUnixTimestamp){
+    // check time here
+    const now = moment()
+    const nonceTime = moment.unix(nonce)
+    // const nonceAge = nonceTime.fromNow()
+    // console.log('Key binding token nonce age: ', nonceAge)
+    if (now.isAfter(nonceTime.add(5, 'minutes'))){
+      throw new Error('nonce for key binding token is too stale to accept')
+    }
+   } else {
+    try {
+      const verifiedChallengeToken =  await transmute.vc.sd.verifier<VerifiedSpiceChallengeToken>({
+        resolver: {
+          resolve: async (kid: string) => {
+            if (kid === `did:web:dune.did.ai#${publicKeyJwk.kid}`){
+              return publicKeyJwk
+            } 
+            throw new Error('Unsupported kid: ' + kid)
+          }
+        }
+      }).verify({
+        token: nonce
+      })
+      const {iss, iat, exp, aud} = verifiedChallengeToken.claimset;
+      if (iss !== 'did:web:dune.did.ai') {
+        throw new Error('Unknown challenge token issuer.')
+      }
+      const now = moment();
+      if (now.isBefore(moment.unix(iat))) {
+        throw new Error('Challenge token cannot be issued in the future.')
+      }
+      if (now.isAfter(moment.unix(exp))) {
+        throw new Error('Challenge token cannot be expired in the past.')
+      }
+      if (aud !== 'https://dune.did.ai') {
+        throw new Error('Challenge token must be issued for https://dune.did.ai')
+      }
+      audienceForChallenge = aud;
+    } catch(e){
+      console.error(e)
+      return NextResponse.json({type: 'Verification Failed', detail: 'Challenge token was not signed for this audience' }, {
+        status: 500,
+      })
+    }
+  }
 
-  try{
+  try {
     const verification =  await transmute.vc.sd.verifier({
       resolver: {
         resolve: async (kid: string) => {
@@ -20,8 +82,8 @@ export async function POST(request: Request) {
         }
       }
     }).verify({
-      audience, 
-      nonce,
+      audience: audienceForChallenge, 
+      nonce: nonceForChallenge,
       token
     })
     return NextResponse.json(verification)