I'm trying to get a remoteSigner To work with the did-jwt library...suggestions appreciated

[bshambaugh]

To be as plain as I can. I can construct a JWT using a signer on the local machine,, but I cannot construct a JWT using a signer on a remote machine.

I can send a crafted payload to the remote machine and get a correct signature.

I can get other responses too that a remote, but not JWTs.

Here is some link to code:
https://github.com/bshambaugh/key-did-provider-p256Test-remote/blob/master/src/index.ts (gives a JWT on local machine)
https://github.com/bshambaugh/key-did-provider-p256Test-remote/blob/master/src/remote-getPublicKey.ts (gets the public key )
https://github.com/bshambaugh/key-did-provider-p256Test-remote/blob/master/src/remote-getJWT-matchremoteDID.ts (gives the right response from remote with one await)
https://github.com/bshambaugh/key-did-provider-p256Test-remote/blob/master/src/remote-getJWT-matchremoteDID_multi.ts (gives the right response from remote with multiple awaits in the loop)
https://github.com/bshambaugh/key-did-provider-p256Test-remote/blob/master/src/remote-getSignature.ts (gives correct remote signatures for a given payload)
https://github.com/bshambaugh/key-did-provider-p256Test-remote/blob/master/src/remote-matchDIDKeyWRemoteT2-getJWT.ts(gives a failing signature for the JWT)

`const server = http.createServer();
const websocketServer = WebSocket.createServer({server: server})

DNS.lookup(OS.hostname(), function (err, add, fam) {
console.log('addr: '+add);
})

websocketServer.on('stream',function(stream,request) {

setInterval(function(){
(async function() {

      let did = 'did:key:zDnaerx9CtbPJ1q36T5Ln5wYt3MQYeGRG5ehnPAmxcf5mDZpv';
      const newDID = await matchDIDKeyWithRemote(did,stream);
      const signer = await remoteP256Signer(stream);
      const jwt = await createJWT({ requested: ['name', 'phone'] }, { issuer: newDID, signer },{alg: 'ES256'})
      console.log(jwt)

})();
},250);

})

server.listen(3000);

function remoteP256Signer(stream): Signer {
return async (payload: string | Uint8Array): Promise => {
return await getSignature(stream,payload);
}
}`

That's the basic skeleton for getting a JWT.

[bshambaugh]

`
websocketServer.on('stream',function(stream,request) {

(async function() {

      let did = 'did:key:zDnaerx9CtbPJ1q36T5Ln5wYt3MQYeGRG5ehnPAmxcf5mDZpv';
      const newDID = await matchDIDKeyWithRemote(did,stream);
      const signer = await remoteP256Signer(stream);
      const jwt = await createJWT({ requested: ['name', 'phone'] }, { issuer: newDID, signer },{alg: 'ES256'})
      console.log(jwt)

})();

})
`
Alternatively, this gives me no socket activity that I know of.

[bshambaugh]

Someone commented that setInterval creates a lot of promises, and since it is not required to do anything with them it just triggers more every 1/4 of second.

[bshambaugh]

This confuses me, because I've proven that createJWT works on a local machine index.ts.
I've also proven that I can get data adequately signed remotely.
remote-getSignature.ts

Unfortunately, this function, or something else is the culprit:

function remoteP256Signer(stream): Signer { return async (payload: string | Uint8Array): Promise<string> => { return await getSignature(stream,payload); } }

Functionally, I it supposed to look like this:
ES256Signer.ts

`
/**

• Creates a configured signer function for signing data using the ES256 (secp256r1 + sha256) algorithm.
• The signing function itself takes the data as a Uint8Array or string and returns a base64Url-encoded signature
• @example
• const sign: Signer = ES256Signer(process.env.PRIVATE_KEY)
• const signature: string = await sign(data)
• @param {String} privateKey a private key as Uint8Array
• @return {Function} a configured signer function (data: string | Uint8Array): Promise<string>
  */
  export function ES256Signer(privateKey: Uint8Array): Signer {
  const privateKeyBytes: Uint8Array = privateKey
  if (privateKeyBytes.length !== 32) {
  throw new Error(bad_key: Invalid private key format. Expecting 32 bytes, but got ${privateKeyBytes.length})
  }
  const keyPair: elliptic.ec.KeyPair = secp256r1.keyFromPrivate(privateKeyBytes)

return async (data: string | Uint8Array): Promise => {
const { r, s }: elliptic.ec.Signature = keyPair.sign(sha256(data))
return toJose({
r: leftpad(r.toString('hex')),
s: leftpad(s.toString('hex')),
})
}
}
`
this is the function that is called to get a locally produced JWT.

Obviously, I cannot use that one with a remote signer.

Notice I call my remote one like this:

const signer = await remoteP256Signer(stream);

It is supposed to use the private key stored remotely and the data that is provided to:

return async (payload: string | Uint8Array): Promise<string> => { return await getSignature(stream,payload); }

but no bueno (edited)

https://github.com/bshambaugh/key-did-provider-p256Test-remote is kind of a mess as a repo. I have multiple files each testing a part or merging multiple smaller parts. Things were breaking when trying to write a unified test file using beforeEach and Aftereach where I tried to spin up and spin down a socket server and flush the socket connections between each test.

[bshambaugh]

A person commented that by invoking setInterval I'm invoking the function, but they weren't sure if the promise was being lost.

[bshambaugh]

Here is a gist showing the output from running the script:

https://gist.github.com/bshambaugh/a63fb0d68471f21ed86d98224d77824c

[bshambaugh]

This is what it looks like on the side of the RPC, what JavaScript is calling over websockets:
https://github.com/bshambaugh/BlinkyProject/blob/remoteSigner/edgeDevices/ESP32-testing/src/main.cpp

[bshambaugh]

Okay, this works. It appeared to be an issue with the network. Things were getting signed properly on the ESP32 side.

websocketServer.on('stream',function(stream,request) {

 //   stream.setEncoding('utf8');

setTimeout(function(){
  (async function() {
    
    
          let did = 'did:key:zDnaezUFn4zmNoNeZvBEdVyCv6MVL69X8NRD8YavTCJWGuXM7';
          const signer = await remoteP256Signer(stream);
          const jwt = await createJWT({ requested: ['name', 'phone'] }, { issuer: did, signer },{alg: 'ES256'})
          console.log(jwt)
    
  })();

},250);

})