@atomicfinance/types 4.2.8 → 4.3.1

package/.yalc/@node-dlc/noise/lib/noise-socket-options.ts

@@ -0,0 +1,32 @@
+import { ILogger } from '@node-dlc/logger';
+import { Socket } from 'net';
+
+import { NoiseState } from './noise-state';
+
+export type NoiseSocketOptions = {
+  /**
+   * Standard TCP Socket from the net module that will be wrapped
+   */
+  socket: Socket;
+
+  /**
+   * State machine for noise connections that is injected into the socket
+   */
+  noiseState: NoiseState;
+
+  /**
+   * Remote public key when connecting to a remote server. When provided,
+   * makes the socket the noise state initiator.
+   */
+  rpk?: Buffer;
+
+  /**
+   * Logger that can be optionally used by the noise system
+   */
+  logger?: ILogger;
+
+  /**
+   * High watermark for the stream
+   */
+  highWaterMark?: number;
+};

package/.yalc/@node-dlc/noise/lib/noise-socket.ts

@@ -0,0 +1,381 @@
+import { ILogger } from '@node-dlc/logger';
+import assert from 'assert';
+import { Socket } from 'net';
+import { Duplex } from 'stream';
+
+import { HANDSHAKE_STATE } from './handshake-state';
+import { NoiseError } from './noise-error';
+import { NoiseSocketOptions } from './noise-socket-options';
+import { NoiseState } from './noise-state';
+import { READ_STATE } from './read-state';
+
+export class NoiseSocket extends Duplex {
+  public static READ_STATE = READ_STATE;
+  public static HANDSHAKE_STATE = HANDSHAKE_STATE;
+
+  /**
+   * Remote public key as a 33-byte compressed public key for
+   * elliptic curve secp256k1
+   */
+  public rpk: Buffer;
+
+  /**
+   * Indicates if the socket was the connection initiator
+   * which will determine how the handshake happens.
+   */
+  public initiator: boolean;
+
+  /**
+   * Count of messages received by the socket.
+   */
+  public messagesReceived: number;
+
+  /**
+   * A logger instance
+   */
+  public logger: ILogger;
+
+  /**
+   * Controls the handshake process at the start of the connection.
+   * The socket is not readable until the handshake has been performed.
+   */
+  private _handshakeState: HANDSHAKE_STATE;
+
+  /**
+   * Controls how reading and piping from the underlying TCP socket to
+   * the Duplex Streams read buffer works
+   */
+  private _readState: READ_STATE;
+
+  /**
+   * Private property that maintains the handshakes and
+   * encrypts and decrypts messages while maintaining the
+   * proper key rotation scheme used defined in BOLT #8.
+   */
+  private _noiseState: NoiseState;
+
+  /**
+   * The wrapped socket
+   */
+  private _socket: Socket;
+
+  /**
+   * Message length state used for messages that may be split
+   * across multiple packets.
+   */
+  private _l: number;
+
+  /**
+   * NoiseSocket is a Duplex Stream that wraps a standard TCP Socket
+   * and layers in the BOLT #8 implementation of the Noise Protocol
+   * Framework.
+   *
+   * This socket can be used for any communication that wants to
+   * benefit from the security and privacy enhancing used by the
+   * Noise Protocol Framework.
+   */
+  constructor({
+    socket,
+    noiseState,
+    rpk,
+    logger,
+    highWaterMark = 2048,
+  }: NoiseSocketOptions) {
+    super({ objectMode: true, highWaterMark });
+    // perform type assertions
+    assert.ok(socket instanceof Socket, new NoiseError("socket argument must be an instance of Socket")); // prettier-ignore
+
+    this.rpk = rpk;
+
+    // if remote is provided, then we are the initiator
+    this.initiator = rpk !== undefined;
+
+    this._handshakeState = this.initiator
+      ? HANDSHAKE_STATE.INITIATOR_INITIATING
+      : HANDSHAKE_STATE.AWAITING_INITIATOR;
+
+    this._readState = READ_STATE.READY_FOR_LEN;
+
+    this._noiseState = noiseState;
+
+    this.messagesReceived = 0;
+
+    this._socket = socket;
+
+    this._socket.on('close', (hadError) => this.emit('close', hadError));
+    this._socket.on('connect', this._onConnected.bind(this));
+    this._socket.on('drain', () => this.emit('drain'));
+    this._socket.on('end', () => this.emit('end'));
+    this._socket.on('error', (err) => this.emit('error', err));
+    this._socket.on('lookup', (e, a, f, h) => this.emit('lookup', e, a, f, h));
+    this._socket.on('readable', this._onData.bind(this));
+    this._socket.on('timeout', () => this.emit('timeout'));
+
+    this.logger = logger;
+  }
+
+  /**
+   * Half-closes the socket. It is still possible that the opposite
+   * side is still sending data.
+   */
+  public end(): this {
+    this._socket.end();
+    return this;
+  }
+
+  /**
+   * Destroys the socket and ensures that no more I/O activity happens
+   * on the socket. When an `err` is included, an 'error' event will
+   * be emitted and all listeners will receive the error as an
+   * argument.
+   * @param err optional error to send
+   */
+  public destroy(err?: Error): this {
+    this._socket.destroy(err);
+    return this;
+  }
+
+  /**
+   * Fires when the socket has connected. This method initiates the
+   * handshake and if there is a failure, terminates the connection.
+   */
+  private _onConnected() {
+    try {
+      if (this.initiator) {
+        this._initiateHandshake();
+      }
+    } catch (err) {
+      this.destroy(err);
+    }
+  }
+
+  /**
+   * _onData is triggered by the "readable" event on the
+   * underlying TCP socket. It is called each time there is new data
+   * received. It is responsible for reading data from the socket and
+   * performing the appropriate action given the current read state.
+   */
+  private _onData() {
+    try {
+      // Loop while there was still data to process on the socket's
+      // buffer. This will stop when we don't have enough data or
+      // we encounter a back pressure issue;
+      let readMore = true;
+      do {
+        if (this._handshakeState !== HANDSHAKE_STATE.READY) {
+          switch (this._handshakeState) {
+            // Initiator received data before initialized
+            case HANDSHAKE_STATE.INITIATOR_INITIATING:
+              throw new NoiseError('Pending state is invalid');
+
+            // Responder Act1
+            case HANDSHAKE_STATE.AWAITING_INITIATOR:
+              readMore = this._processInitiator();
+              break;
+
+            // Responder Act3
+            case HANDSHAKE_STATE.AWAITING_INITIATOR_REPLY:
+              readMore = this._processInitiatorReply();
+              break;
+
+            // Initiator Act2
+            case HANDSHAKE_STATE.AWAITING_RESPONDER_REPLY:
+              readMore = this._processResponderReply();
+              break;
+          }
+        } else {
+          switch (this._readState) {
+            case READ_STATE.READY_FOR_LEN:
+              readMore = this._processPacketLength();
+              break;
+            case READ_STATE.READY_FOR_BODY:
+              readMore = this._processPacketBody();
+              break;
+            case READ_STATE.BLOCKED:
+              readMore = false;
+              break;
+            default:
+              throw new NoiseError('Unknown read state');
+          }
+        }
+      } while (readMore);
+    } catch (err) {
+      // Terminate on failures as we won't be able to recovery
+      // since the noise state has rotated nonce and we won't
+      // be able to any more data without additional errors.
+      this.destroy(err);
+    }
+  }
+
+  private _initiateHandshake() {
+    // create Initiator Act 1 message
+    const m = this._noiseState.initiatorAct1(this.rpk);
+
+    // send message to Responder
+    this._socket.write(m);
+
+    // transition state
+    this._handshakeState = HANDSHAKE_STATE.AWAITING_RESPONDER_REPLY;
+  }
+
+  private _processInitiator() {
+    // must read 50 bytes
+    let m = this._socket.read(50) as Buffer;
+    if (!m) return false;
+
+    // validate initiator act1 message
+    this._noiseState.receiveAct1(m);
+
+    // create reply message
+    m = this._noiseState.recieveAct2();
+
+    // send the reply
+    this._socket.write(m);
+
+    // transition
+    this._handshakeState = HANDSHAKE_STATE.AWAITING_INITIATOR_REPLY;
+
+    // indicate processing was successful
+    return true;
+  }
+
+  private _processInitiatorReply() {
+    // must read 66 bytes
+    const m = this._socket.read(66) as Buffer;
+    if (!m) return false;
+
+    // validate initiator act3 message
+    this._noiseState.receiveAct3(m);
+
+    // transition
+    this._handshakeState = HANDSHAKE_STATE.READY;
+
+    // capture the rpk since it is now available
+    this.rpk = this._noiseState.rpk;
+
+    // emit that we're ready!
+    this.emit('connect');
+    this.emit('ready');
+
+    // return true to continue processing
+    return true;
+  }
+
+  private _processResponderReply() {
+    // must read 50 bytes
+    let m = this._socket.read(50) as Buffer;
+    if (!m) return;
+
+    // process reply
+    this._noiseState.initiatorAct2(m);
+
+    // create final act of the handshake
+    m = this._noiseState.initiatorAct3();
+
+    // send final handshake
+    this._socket.write(m);
+
+    // transition
+    this._handshakeState = HANDSHAKE_STATE.READY;
+
+    // emit that we're ready!
+    this.emit('connect');
+    this.emit('ready');
+
+    // return true to continue processing
+    return true;
+  }
+
+  private _processPacketLength() {
+    const LEN_CIPHER_BYTES = 2;
+    const LEN_MAC_BYTES = 16;
+
+    // Try to read the length cipher bytes and the length MAC bytes
+    // If we cannot read the 18 bytes, the attempt to process the
+    // message will abort.
+    const lc = this._socket.read(LEN_CIPHER_BYTES + LEN_MAC_BYTES) as Buffer;
+    if (!lc) return;
+
+    // Decrypt the length including the MAC
+    const l = this._noiseState.decryptLength(lc);
+
+    // We need to store the value in a local variable in case
+    // we are unable to read the message body in its entirety.
+    // This allows us to skip the length read and prevents
+    // nonce issues since we've already decrypted the length.
+    this._l = l;
+
+    // Transition state
+    this._readState = READ_STATE.READY_FOR_BODY;
+
+    // return true to continue reading
+    return true;
+  }
+
+  private _processPacketBody() {
+    const MESSAGE_MAC_BYTES = 16;
+
+    // With the length, we can attempt to read the message plus
+    // the MAC for the message. If we are unable to read because
+    // there is not enough data in the read buffer, we need to
+    // store l. We are not able to simply unshift it becuase we
+    // have already rotated the keys.
+    const c = this._socket.read(this._l + MESSAGE_MAC_BYTES) as Buffer;
+    if (!c) return;
+
+    // Decrypt the full message cipher + MAC
+    const m = this._noiseState.decryptMessage(c);
+
+    // Now that we've read the message, we can remove the
+    // cached length before we transition states
+    this._l = null;
+
+    // Increment the number of messages received
+    this.messagesReceived++;
+
+    // Push the message onto the read buffer for the consumer to
+    // read. We are mindful of slow reads by the consumer and
+    // will respect backpressure signals.
+    const pushOk = this.push(m);
+    if (pushOk) {
+      this._readState = READ_STATE.READY_FOR_LEN;
+      return true;
+    } else {
+      if (this.logger) this.logger.debug('socket read is blocked');
+      this._readState = READ_STATE.BLOCKED;
+      return false;
+    }
+  }
+
+  // tslint:disable-next-line: member-ordering
+  public _read(): void {
+    if (this._handshakeState !== HANDSHAKE_STATE.READY) {
+      return;
+    }
+
+    if (this._readState === READ_STATE.BLOCKED) {
+      if (this.logger) this.logger.debug('socket read is unblocked');
+      this._readState = READ_STATE.READY_FOR_LEN;
+    }
+    // Trigger a read but wait until the end of the event loop.
+    // This is necessary when reading in paused mode where
+    // _read was triggered by stream.read() originating inside
+    // a "readable" event handler. Attempting to push more data
+    // synchronously will not trigger another "readable" event.
+    setImmediate(() => this._onData());
+  }
+
+  // tslint:disable-next-line: member-ordering
+  public _write(
+    data: Buffer,
+    encoding: string,
+    cb: (err: Error) => void,
+  ): void {
+    const c = this._noiseState.encryptMessage(data);
+    this._socket.write(c, cb);
+  }
+
+  public _final(): void {
+    //
+  }
+}

package/.yalc/@node-dlc/noise/lib/noise-state-options.ts

@@ -0,0 +1,18 @@
+import { ILogger } from '@node-dlc/logger';
+
+export type NoiseStateOptions = {
+  /**
+   * Local private key as a 32-byte buffer
+   */
+  ls: Buffer;
+
+  /**
+   * Ephemeral private key as a 32-byte
+   */
+  es: Buffer;
+
+  /**
+   * Logger to use for NoiseState
+   */
+  logger?: ILogger;
+};