fix: share the key encoding across encrypters and keep RSA peer keys (#3669)

* refactor(plaintext): exchange the public key as protobuf bytes

The key type is now read from the key instead of guessed from its length. The wire format is unchanged, pinned by new tests for Ed25519 and RSA.

* fix(tls): keep the public key of RSA remote peers

Encode the certificate key with publicKeyToProtobuf, dropping the duplicated key schema, and derive the remote peer id from the key directly.

* refactor: derive peer ids from public keys directly instead of via a CID

* refactor(noise): return the remote peer from the handshake instead of parsing the identity key twice

* test: assert connection encrypters return RSA remote peers with their key

Author: tabcat

packages/connection-encrypter-noise/src/noise.ts

@@ -1,6 +1,4 @@
-import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
 import { InvalidCryptoExchangeError, serviceCapabilities } from '@libp2p/interface'
-import { peerIdFromPublicKey } from '@libp2p/peer-id'
 import { lpStream } from '@libp2p/utils'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import { NOISE_MSG_MAX_LENGTH_BYTES } from './constants.ts'
@@ -95,12 +93,10 @@ export class Noise implements INoiseConnection {
       options?.remotePeer,
       options
     )
-    const publicKey = publicKeyFromProtobuf(handshake.payload.identityKey)
-
     return {
       connection: toMessageStream(wrappedConnection.unwrap(), handshake, this.metrics),
       remoteExtensions: handshake.payload.extensions,
-      remotePeer: peerIdFromPublicKey(publicKey),
+      remotePeer: handshake.remotePeer,
       streamMuxer: options?.skipStreamMuxerNegotiation === true ? undefined : this.getStreamMuxer(handshake.payload.extensions?.streamMuxers)
     }
   }
@@ -150,12 +146,10 @@ export class Noise implements INoiseConnection {
       options?.remotePeer,
       options
     )
-    const publicKey = publicKeyFromProtobuf(handshake.payload.identityKey)
-
     return {
       connection: toMessageStream(wrappedConnection.unwrap(), handshake, this.metrics),
       remoteExtensions: handshake.payload.extensions,
-      remotePeer: peerIdFromPublicKey(publicKey),
+      remotePeer: handshake.remotePeer,
       streamMuxer: options?.skipStreamMuxerNegotiation === true ? undefined : this.getStreamMuxer(handshake.payload.extensions?.streamMuxers)
     }
   }

packages/connection-encrypter-noise/src/performHandshake.ts

@@ -35,7 +35,7 @@ export async function performHandshakeInitiator (init: HandshakeParams, options?
   logRemoteStaticKey(xx.rs, log)
 
   log.trace("Initiator going to check remote's signature...")
-  const receivedPayload = await decodeHandshakePayload(plaintext, xx.rs, remotePeer)
+  const received = await decodeHandshakePayload(plaintext, xx.rs, remotePeer)
   log.trace('All good with the signature!')
 
   log.trace('Stage 2 - Initiator sending third handshake message.')
@@ -46,7 +46,8 @@ export async function performHandshakeInitiator (init: HandshakeParams, options?
   logCipherState(cs1, cs2, log)
 
   return {
-    payload: receivedPayload,
+    payload: received.payload,
+    remotePeer: received.remotePeer,
     encrypt: (plaintext) => cs1.encryptWithAd(ZEROLEN, plaintext),
     decrypt: (ciphertext, dst) => cs2.decryptWithAd(ZEROLEN, ciphertext, dst)
   }
@@ -78,13 +79,14 @@ export async function performHandshakeResponder (init: HandshakeParams, options?
   log.trace('Stage 2 - Responder waiting for third handshake message...')
   const plaintext = xx.readMessageC(await connection.read(options))
   log.trace('Stage 2 - Responder received the message, finished handshake.')
-  const receivedPayload = await decodeHandshakePayload(plaintext, xx.rs, remotePeer)
+  const received = await decodeHandshakePayload(plaintext, xx.rs, remotePeer)
 
   const [cs1, cs2] = xx.ss.split()
   logCipherState(cs1, cs2, log)
 
   return {
-    payload: receivedPayload,
+    payload: received.payload,
+    remotePeer: received.remotePeer,
     encrypt: (plaintext) => cs2.encryptWithAd(ZEROLEN, plaintext),
     decrypt: (ciphertext, dst) => cs1.decryptWithAd(ZEROLEN, ciphertext, dst)
   }

packages/connection-encrypter-noise/src/types.ts

@@ -31,6 +31,7 @@ export interface HandshakeParams {
 
 export interface HandshakeResult {
   payload: NoiseHandshakePayload
+  remotePeer: PeerId
   encrypt (plaintext: Uint8Array | Uint8ArrayList): Uint8Array | Uint8ArrayList
   decrypt (ciphertext: Uint8Array | Uint8ArrayList, dst?: Uint8Array): Uint8Array | Uint8ArrayList
 }

packages/connection-encrypter-noise/src/utils.ts

@@ -32,15 +32,14 @@ export async function decodeHandshakePayload (
   payloadBytes: Uint8Array | Uint8ArrayList,
   remoteStaticKey?: Uint8Array | Uint8ArrayList,
   remotePeer?: PeerId
-): Promise<NoiseHandshakePayload> {
+): Promise<{ payload: NoiseHandshakePayload, remotePeer: PeerId }> {
   try {
     const payload = NoiseHandshakePayload.decode(payloadBytes)
     const publicKey = publicKeyFromProtobuf(payload.identityKey)
+    const payloadPeer = peerIdFromPublicKey(publicKey)
 
     // compare peer ids, an expected peer id may not carry its public key (e.g. RSA)
     if (remotePeer != null) {
-      const payloadPeer = peerIdFromPublicKey(publicKey)
-
       if (!remotePeer.equals(payloadPeer)) {
         throw new Error(`Payload peer id ${payloadPeer} does not match expected remote peer id ${remotePeer}`)
       }
@@ -56,7 +55,7 @@ export async function decodeHandshakePayload (
       throw new Error('Invalid payload signature')
     }
 
-    return payload
+    return { payload, remotePeer: payloadPeer }
   } catch (e) {
     throw new UnexpectedPeerError((e as Error).message)
   }

packages/connection-encrypter-plaintext/package.json

@@ -59,7 +59,8 @@
     "@libp2p/logger": "^6.2.15",
     "aegir": "^48.1.1",
     "protons": "^9.0.1",
-    "sinon": "^22.0.0"
+    "sinon": "^22.0.0",
+    "uint8-varint": "^3.0.0"
   },
   "sideEffects": false
 }

packages/connection-encrypter-plaintext/src/index.ts

@@ -21,12 +21,13 @@
  * ```
  */
 
-import { publicKeyFromRaw } from '@libp2p/crypto/keys'
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { UnexpectedPeerError, InvalidCryptoExchangeError, serviceCapabilities, ProtocolError } from '@libp2p/interface'
 import { peerIdFromPublicKey } from '@libp2p/peer-id'
 import { pbStream } from '@libp2p/utils'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { Exchange, KeyType } from './pb/proto.ts'
+import { withArrayBuffer } from 'uint8arrays/with-array-buffer'
+import { Exchange } from './pb/proto.ts'
 import type { ComponentLogger, Logger, ConnectionEncrypter, SecuredConnection, PrivateKey, SecureConnectionOptions, MessageStream } from '@libp2p/interface'
 
 const PROTOCOL = '/plaintext/2.0.0'
@@ -74,10 +75,7 @@ class Plaintext implements ConnectionEncrypter {
     // Encode the public key and write it to the remote peer
     await pb.write({
       id: publicKey.toMultihash().bytes,
-      pubkey: {
-        Type: KeyType[publicKey.type],
-        Data: publicKey.raw
-      }
+      pubkey: withArrayBuffer(publicKeyToProtobuf(publicKey))
     }, options)
 
     // Get the Exchange message
@@ -89,20 +87,21 @@ class Plaintext implements ConnectionEncrypter {
         throw new ProtocolError('Public key missing')
       }
 
-      if (response.pubkey.Data.byteLength === 0) {
+      if (response.pubkey.byteLength === 0) {
         throw new ProtocolError('Public key data too short')
       }
 
       if (response.id == null) {
         throw new ProtocolError('Remote id missing')
       }
 
-      const pubKey = publicKeyFromRaw(response.pubkey.Data)
-      peerId = peerIdFromPublicKey(pubKey)
+      const pubKey = publicKeyFromProtobuf(response.pubkey)
 
-      if (!uint8ArrayEquals(peerId.toMultihash().bytes, response.id)) {
+      if (!uint8ArrayEquals(pubKey.toMultihash().bytes, response.id)) {
         throw new InvalidCryptoExchangeError('Public key did not match id')
       }
+
+      peerId = peerIdFromPublicKey(pubKey)
     } catch (err: any) {
       log.error('invalid public key - %e', err)
       throw new InvalidCryptoExchangeError(`Invalid public key - ${err.message}`)

packages/connection-encrypter-plaintext/src/pb/proto.proto

@@ -2,17 +2,6 @@ syntax = "proto3";
 
 message Exchange {
   optional bytes id = 1;
-  optional PublicKey pubkey = 2;
-}
-
-enum KeyType {
-  RSA = 0;
-  Ed25519 = 1;
-  secp256k1 = 2;
-  ECDSA = 3;
-}
-
-message PublicKey {
-  optional KeyType Type = 1;
-  bytes Data = 2;
+  // a protobuf encoded libp2p PublicKey
+  optional bytes pubkey = 2;
 }