Further progress on handshake - fixed various bugs in multiple locations

Author: 2xic

exampels/connectToLocal.ts

@@ -1,4 +1,4 @@
-import { Peer, KeyPair, parseEncode, MessageType } from '../dist';
+import { Peer, KeyPair, parseEncode, MessageType, NodeServer } from '../dist';
 
 (async () => {
   const node = new Peer(
@@ -9,6 +9,9 @@ import { Peer, KeyPair, parseEncode, MessageType } from '../dist';
       '0a04fa0107c51d2b9fa4504e220537f1a3aaf287cfcd5a66b8c2c8272fd8029a'
     )
   );
+  const server = new NodeServer(
+    '0a04fa0107c51d2b9fa4504e220537f1a3aaf287cfcd5a66b8c2c8272fd8029a'
+  );
   await node.connect(
     parseEncode(
       'enode://565201cf682f2e62fc03173098e39e72ca49cb28beef29e956b480763150565be0471c39bccc8ffb4d8684e658034c3e7a93d315f57a42e82506bb29a973273e@localhost:30303'

exampels/connectToPeer.ts

@@ -12,7 +12,7 @@ import { Peer, enocdes, MessageType, parseEncode } from '../dist';
     });
   */
       await node.sendMessage({
-        type: MessageType.AUTH,
+        type: MessageType.AUTH_EIP_8,
       });
     })
   );

jest.config.int.js

@@ -1,8 +1,8 @@
 // eslint-disable-next-line no-undef
 module.exports = {
-  testRegex: ['.*.int.test.js'],
+  testRegex: [".*.int.test.ts"],
   transform: {
-    '\\.(js|ts|jsx|tsx)$': 'babel-jest',
+    "\\.(js|ts|jsx|tsx)$": "babel-jest",
   },
- // verbose: true,
+  // verbose: true,
 };

jest.config.js

@@ -1,7 +1,7 @@
 module.exports = {
-  testRegex: ['.*.unit.test.js'],
+  testRegex: [".*.unit.test.js"],
   transform: {
-    "\\.(js|ts|jsx|tsx)$": "babel-jest",
+    '\\.(js|ts|jsx|tsx)$': 'babel-jest',
   },
   // verbose: true,
 };

src/network/Packet.ts

@@ -21,8 +21,21 @@ import {
 import { ReadOutRlp } from '../rlp/ReadOutRlp';
 import ip6addr from 'ip6addr';
 import { convertNumberToPadHex } from './convertNumberToPadHex';
+import { getBufferFromHex } from './getBufferFromHex';
+import BigNumber from 'bignumber.js';
 
 export class Packet {
+  public parse({ packet }: { packet: Buffer }) {
+    const packetId = packet[0];
+    // falsy values are parsed as 0x80 in RLP
+    const parsedPacketId = packetId === 0x80 ? 0 : packetId;
+    if (parsedPacketId === PacketTypes.HELLO) {
+      return this.decodeHello({ input: packet });
+    } else {
+      throw new Error(`Unknown packet (${parsedPacketId})`);
+    }
+  }
+
   public encodePing(_input: PingPacket): string {
     /*
       packet-data = [4, from, to, expiration, enr-seq ...]
@@ -50,33 +63,58 @@ export class Packet {
     });
   }
 
+  // TODO Moves this into an encoder / decoder class
   public decodeHello({ input }: { input: Buffer }): ParsedHelloPacket {
     const data = new RlpDecoder().decode({ input: input.toString('hex') });
     const rlpReader = new ReadOutRlp(data);
 
+    console.log(`HELLO PACKET ${input.toString('hex')}`);
+
+    console.log(data);
+
+    // protocol version
+    const [protocolVersion] = rlpReader.readArray<number>({
+      length: 1,
+      isFlat: true,
+    });
     const [client] = rlpReader.readArray<string>({
-      skip: 1,
       length: 1,
+      isFlat: true,
     });
-
-    const [version] = rlpReader.readArray<number>({
-      length: 2,
-      isNumeric: true,
-      valueFetcher: (item) => {
-        if (Array.isArray(item) && Array.isArray(item[1])) {
-          return [item[1][1] as number];
-        } else {
-          throw new Error('Missing data');
-        }
-      },
+    const capabilities = rlpReader.readArray<string[]>({
+      length: 1,
+      isFlat: true,
+    });
+    const [listenPort] = rlpReader.readArray<number | boolean>({
+      length: 1,
+      isFlat: true,
+    });
+    const [nodeId] = rlpReader.readArray<string>({
+      length: 1,
     });
-
     return {
+      protocolVersion,
+      capabilities,
+      listenPort: typeof listenPort === 'boolean' ? 0 : listenPort,
       userAgent: client,
-      version,
+      nodeId,
+      //   version: capabilities[0][0] as unknown as number,
     };
   }
 
+  public encodeHello({ packet }: { packet: ParsedHelloPacket }) {
+    const helloPacket = new RlpEncoder().encode({
+      input: [
+        packet.protocolVersion,
+        packet.userAgent,
+        packet.capabilities,
+        packet.listenPort,
+        getBufferFromHex(packet.nodeId),
+      ],
+    });
+    return Buffer.concat([Buffer.from([0x80]), getBufferFromHex(helloPacket)]);
+  }
+
   public decodePing({
     input,
   }: {
@@ -137,6 +175,7 @@ export class Packet {
 }
 
 export enum PacketTypes {
+  HELLO = 0x0,
   PING = 1,
   PONG = 2,
   FIND_NODE = 3,
@@ -145,8 +184,11 @@ export enum PacketTypes {
 }
 
 interface ParsedHelloPacket {
-  version: number;
   userAgent: string | number;
+  capabilities: string[][];
+  protocolVersion: number;
+  listenPort: number;
+  nodeId: string;
 }
 
 interface ParsedPacket {

src/network/Packets.unit.test.ts

@@ -2,15 +2,14 @@ import { cleanString } from '../utils';
 import { getBufferFromHex } from './getBufferFromHex';
 import { Packet, PacketTypes } from './Packet';
 import ip6addr from 'ip6addr';
+import { decode } from '@ethereumjs/devp2p';
+import { HelpOutline } from '@mui/icons-material';
 
 describe('Packets', () => {
   // from https://github.com/ethereum/go-ethereum/pull/2091/files#diff-a2488b7a37555bfb5c64327072acdbbf703ab127176956f6b6558067950f8f73R455
 
   it('should correctly decode hello packet', () => {
     // from https://eips.ethereum.org/EIPS/eip-8
-    const nodeKey = getBufferFromHex(
-      'b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291'
-    );
     const helloPacket = getBufferFromHex(
       cleanString(`
     f87137916b6e6574682f76302e39312f706c616e39cdc5836574683dc6846d6f726b1682270fb840
@@ -20,7 +19,33 @@ describe('Packets', () => {
     );
 
     const decodedPacket = new Packet().decodeHello({ input: helloPacket });
-    expect(decodedPacket.version).toBe(22);
+    //expect(decodedPacket.version).toBe(22);
+    expect(decodedPacket.nodeId).toBe(
+      '0xfda1cff674c90c9a197539fe3dfb53086ace64f83ed7c6eabec741f7f381cc803e52ab2cd55d5569bce4347107a310dfd5f88a010cd2ffd1005ca406f1842877'
+    );
+  });
+
+  it('should correctly decode hello packet from geth', () => {
+    const helloPacket = getBufferFromHex(
+      cleanString(`
+      80f88305b0476574682f76312e31302e31372d737461626c652d32356339623439662f6c696e75782d616d6436342f676f312e3138cdc58365746842c684736e61700180b840565201cf682f2e62fc03173098e39e72ca49cb28beef29e956b480763150565be0471c39bccc8ffb4d8684e658034c3e7a93d315f57a42e82506bb29a973273e     `)
+    );
+
+    const decodedPacket = new Packet().decodeHello({ input: helloPacket });
+    expect(decodedPacket.userAgent).toBe(
+      'Geth/v1.10.17-stable-25c9b49f/linux-amd64/go1.18'
+    );
+    expect(decodedPacket.protocolVersion).toBe(5);
+    expect(decodedPacket.capabilities.toString()).toBe(
+      [
+        ['eth', 66],
+        ['snap', 1],
+      ].toString()
+    );
+    expect(decodedPacket.listenPort).toBe(0);
+    expect(decodedPacket.nodeId).toBe(
+      '0x565201cf682f2e62fc03173098e39e72ca49cb28beef29e956b480763150565be0471c39bccc8ffb4d8684e658034c3e7a93d315f57a42e82506bb29a973273e'
+    );
   });
 
   it('should correctly decode a ping packet', () => {
@@ -50,7 +75,7 @@ describe('Packets', () => {
     expect(decodedPacket.toTcpPort).toBe(3333);
   });
 
-  it.only('should correctly encode a ping packet', () => {
+  it('should correctly encode a ping packet', () => {
     // https://github.com/ethereum/devp2p/blob/master/discv4.md#ping-packet-0x01
     const packet = new Packet().encodePing({
       version: 4,
@@ -166,4 +191,16 @@ dd7fc0c04ad9ebf3919644c91cb247affc82b69bd2ca235c71eab8e49737c937a2c396
     expect(decodedPacket.nodes.length).toBe(4);
     expect(decodedPacket.nodes[0].ip).toBeTruthy();
   });
+
+  it('should correctly create an hello packet', () => {
+    const helloPacket = getBufferFromHex(
+      cleanString(`
+      80f88305b0476574682f76312e31302e31372d737461626c652d32356339623439662f6c696e75782d616d6436342f676f312e3138cdc58365746842c684736e61700180b840565201cf682f2e62fc03173098e39e72ca49cb28beef29e956b480763150565be0471c39bccc8ffb4d8684e658034c3e7a93d315f57a42e82506bb29a973273e     `)
+    );
+
+    const decodedPacket = new Packet().decodeHello({ input: helloPacket });
+
+    const packet = new Packet().encodeHello({ packet: decodedPacket });
+    expect(packet.toString('hex')).toBe(helloPacket.toString('hex'));
+  });
 });

src/network/Peer.int.test.ts

@@ -1,10 +1,15 @@
+import { encode } from '@ethereumjs/devp2p';
 import { ThirtyFpsSharp } from '@mui/icons-material';
 import net from 'net';
+import { RlpEncoder } from '../rlp/RlpEncoder';
 import { KeyPair } from '../signatures/KeyPair';
 import { FrameCommunication } from './auth/FrameCommunication';
 import { Auth8Eip } from './AuthEip8';
 import { getBufferFromHex } from './getBufferFromHex';
 import { getRandomPeer } from './getRandomPeer';
+import { CryptoNonceGenerator } from './nonce-generator/CryptoNonceGenerator';
+import { NonceGenerator } from './nonce-generator/NonceGenerator';
+import { Packet, PacketTypes } from './Packet';
 import { Rlpx } from './Rlpx';
 import { AbstractSocket } from './socket/AbstractSocket';
 
@@ -30,11 +35,14 @@ export class Peer {
   constructor(
     private keyPair = new KeyPair(),
     private ephemeralKeyPair = new KeyPair(),
-    private socket: AbstractSocket = new net.Socket() as AbstractSocket
+    private socket: AbstractSocket = new net.Socket() as AbstractSocket,
+    private randomNumberGenerator: NonceGenerator = new CryptoNonceGenerator()
   ) {
     this.rlpx = new Rlpx(
       this.keyPair,
-      Buffer.from(this.ephemeralKeyPair.privatekey, 'hex')
+      Buffer.from(this.ephemeralKeyPair.privatekey, 'hex'),
+      new RlpEncoder(),
+      this.randomNumberGenerator
     );
     this.auth8Eip = new Auth8Eip(this.rlpx);
   }
@@ -102,13 +110,9 @@ export class Peer {
   }
 
   public async sendMessage(message: MessageOptions) {
-    if ([MessageType.AUTH, MessageType.AUTH_EIP_8].includes(message.type)) {
-      const rlpx = new Rlpx(
-        this.keyPair,
-        Buffer.from(this.ephemeralKeyPair.privatekey, 'hex')
-      );
+    if (MessageType.AUTH_EIP_8 === message.type) {
       const { results: authMessage, header } =
-        await rlpx.createEncryptedAuthMessageEip8({
+        await this.rlpx.createEncryptedAuthMessageEip8({
           ethNodePublicKey: this.nodePublicKey,
         });
 
@@ -121,6 +125,9 @@ export class Peer {
       );
 
       await this.connectionWrite(authMessage);
+    } else if (MessageType.HELLO === message.type) {
+      console.log('hello ser');
+      throw new Error('nono, please go in order ser');
     } else {
       throw new Error(`Unknown message type${message.type}`);
     }
@@ -145,26 +152,42 @@ export class Peer {
         this._senderNonce,
         getBufferFromHex(nonce)
       ).setup({
-        secret: this._secret,
-
-        remoteNonce: getBufferFromHex(nonce),
         remotePacket: message,
-
         initiatorPacket: this.sentPacket,
-        initiatorNonce: this._senderNonce,
       });
-      console.log(':)');
     } else {
-      console.log('hello ? what is this ser?');
-      console.log(
-        this.frameCommunication?.parse({
-          message,
-        })
-      );
+      if (!this.frameCommunication) {
+        throw new Error('Missing frame communicator');
+      }
+      const body = this.frameCommunication.parse({
+        message,
+      });
+      const packetParser = new Packet();
+      const hello = packetParser.parse({
+        packet: body,
+      });
+      /** Todo run some validation here maybe ? */
+      console.log('Trying to say hello');
+      /*await this.sendMessage({
+        type: MessageType.HELLO,
+      });
+      */
+      const heloMessage = new Packet().encodeHello({
+        packet: {
+          ...hello,
+          nodeId: `0x${this.keyPair.getPublicKey()}`,
+        },
+      });
+      const encodedMessage = this.frameCommunication.encode({
+        message: heloMessage,
+      });
+      await this.connectionWrite(encodedMessage);
     }
   }
 
   private async connectionWrite(message: Buffer) {
+    console.log(`writing on the wire SER, ${message.length}`);
+    console.log(` ${message.toString('hex')}`);
     await new Promise<void>((resolve, reject) => {
       this.connection.write(message, (error) => {
         if (error) {
@@ -195,7 +218,7 @@ type MessageOptions = BaseMessage;
 
 export enum MessageType {
   AUTH_EIP_8,
-  AUTH,
+  HELLO,
 }
 interface BaseMessage {
   type: MessageType;