noise-ruby 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f9bedd93319f9cf54acb51c1a83c64fcfd25cfdaef69204f709b59c83060c4
-  data.tar.gz: c72fb7afa8aab1c577b305f1d57316ab34ad183b6bbf249d420b3b17d4bb81e6
+  metadata.gz: 9fcf6ecf59b631aacb32b66661719e57a205ccea71a487748d3bb2979fc2ee4b
+  data.tar.gz: 22bee13bda1fe1a9339777261eccd6d173e32679e969e78b065abe457d06884e
 SHA512:
-  metadata.gz: be31e461a923db0af2f6ae19b42fa74ac3b70fcac8e332a281a46377ac0fa0164ce799567ba19e862fbbc40b367b06672bd095ea850bcd4bfaec2291b1b4ab16
-  data.tar.gz: e3495a893d23263a534d7f490fdcd84a5f33c81b4e5d8437d1a268abc8111940916ecf6f832f2b13bf610d5ec9f1059129c16a9f2a0728a823b96a147482e7ac
+  metadata.gz: 2cbd93529da1345b646b9be626591bf81eb1fe53d211d70a75fe6fe1f56d99c7b55bdedc7102aed3d20c27080fcf4f04b0619b7bacd8f664f8301397f3f4e069
+  data.tar.gz: '0845488f8a48edb3f09fba247a8f7950aefd0c5a6cade1ae114e3b3e683e4f66dbc3d34267b2ee298f066d170ddd84343da3d843a5a89587ce592cac906da849'

data/README.md

@@ -49,7 +49,53 @@ gem 'secp256k1-ruby'
 
 ## Usage
 
-TODO: Write usage instructions here
+Followings shows handshake protocol with "Noise_NN_25519_ChaChaPoly_BLAKE2b"
+
+### Handshake
+
+#### initiator
+
+```
+initiator = Noise::Connection::Initiator.new("Noise_NN_25519_ChaChaPoly_BLAKE2b")
+initiator.prologue = "test" # => "test"
+initiator.start_handshake # => true
+cipher = initiator.write_message("") # => "\xB6\xF7gmxi\xAB\xBCY|t\xF0\x9D\x01A\ad\x92\xBBvp\x80ZNU\f=\x83\x81^\xFD\x15"
+```
+
+then initiator sends `cipher` to responder.
+
+#### responder
+
+Responder receive `cipher` from initiator.
+Responder respond messages to initiator.
+
+```
+responder = Noise::Connection::Responder.new("Noise_NN_25519_ChaChaPoly_BLAKE2b")
+responder.prologue = "test" # => "test"
+responder.start_handshake # => true
+plain = responder.read_message(cipher) # => ""
+cipher = responder.write_message("") # => "\v\xD9\x97'\xC0\xB1\xC9\xFFD\x8C\x7F\x18L\xB0\xF2\x14\xB0\x11\xC0\x90\xAAZ\xE1\x03\x17z)\xB81/5L\x16\xE3\xD1\xBE<{\xB8\xBB\xD6\xF1\x00\x10]\x99=\xD7"
+```
+
+
+### initiator
+
+```
+plain = initiator.read_message(cipher) # => ""
+```
+
+### Send transport message (after handshake finished)
+
+```
+cipher = initiator.encrypt("Hello, World!") # => "\xDA\xC7\xD7as\v\xFA\xCC,\xB3\xC7\xD0/xL\xE8I,\xD9\n\xEExh\x8F\xFA\xD6\x01\x99W"
+```
+
+### Receive transport message
+
+```
+plain = responder.decrypt(cipher) # => "Hello, World!"
+```
+
 
 ## Development
 

data/bin/console

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'noise'
 

data/lib/noise.rb

@@ -12,6 +12,7 @@ require 'noise/utils/string'
 
 module Noise
   autoload :Connection, 'noise/connection'
+  autoload :Key, 'noise/key'
   autoload :KeyPair, 'noise/key_pair'
   autoload :Protocol, 'noise/protocol'
   autoload :Pattern, 'noise/pattern'

data/lib/noise/connection.rb

@@ -1,94 +1,9 @@
 # frozen_string_literal: true
 
 module Noise
-  class Connection
-    module Status
-      STATIC = 1
-      REMOTE_STATIC = 2
-      EPHEMERAL = 3
-      REMOTE_EPHEMERAL = 4
-    end
-
-    attr_accessor :protocol, :handshake_started, :handshake_finished, :fn
-
-    def initialize(name)
-      @protocol = Protocol.create(name)
-      @handshake_started = false
-      @handshake_finished = false
-      @fn = nil
-      @write_message_proc = ->(payload) { write_message(payload) }
-      @read_message_proc = ->(payload) { read_message(payload) }
-    end
-
-    def psks=(psks)
-      @protocol.psks = psks
-    end
-
-    def prologue=(prologue)
-      @protocol.prologue = prologue
-    end
-
-    def set_as_initiator!
-      @protocol.initiator = true
-      @fn = @write_message_proc
-    end
-
-    def set_as_responder!
-      @protocol.initiator = false
-      @fn = @read_message_proc
-    end
-
-    def set_keypair_from_private(keypair, private_key)
-      @protocol.keypairs[keypair.to_sym] = @protocol.dh_fn.class.from_private(private_key)
-    end
-
-    def set_keypair_from_public(keypair, public_key)
-      @protocol.keypairs[keypair.to_sym] = @protocol.dh_fn.class.from_public(public_key)
-    end
-
-    def start_handshake
-      @protocol.validate
-      @protocol.initialise_handshake_state
-      @handshake_started = true
-    end
-
-    def write_message(payload = '')
-      # Call NoiseConnection.start_handshake first
-      raise Noise::Exceptions::NoiseHandshakeError unless @handshake_started
-      raise Noise::Exceptions::NoiseHandshakeError if @fn != @write_message_proc
-      # Handshake finished. NoiseConnection.encrypt should be used now
-      raise Noise::Exceptions::NoiseHandshakeError if @handshake_finished
-      @fn = @read_message_proc
-      buffer = +''
-      result = @protocol.handshake_state.write_message(payload, buffer)
-      @handshake_finished = true if result
-      buffer
-    end
-
-    def read_message(data)
-      # Call NoiseConnection.start_handshake first
-      raise Noise::Exceptions::NoiseHandshakeError unless @handshake_started
-      raise Noise::Exceptions::NoiseHandshakeError if @fn != @read_message_proc
-      # Handshake finished. NoiseConnection.encrypt should be used now
-      raise Noise::Exceptions::NoiseHandshakeError if @handshake_finished
-
-      @fn = @write_message_proc
-      buffer = +''
-      result = @protocol.handshake_state.read_message(data, buffer)
-      @handshake_finished = true if result
-      buffer
-    end
-
-    def encrypt(data)
-      raise Noise::Exceptions::NoiseHandshakeError unless @handshake_finished
-      # raise Noise::Exceptions::NoiseInvalidMessage
-      @protocol.cipher_state_encrypt.encrypt_with_ad('', data)
-    end
-
-    def decrypt(data)
-      raise Noise::Exceptions::NoiseHandshakeError unless @handshake_finished
-      # raise Noise::Exceptions::NoiseInvalidMessage
-      @protocol.cipher_state_decrypt.decrypt_with_ad('', data)
-    end
+  module Connection
+    autoload :Base, 'noise/connection/base'
+    autoload :Initiator, 'noise/connection/initiator'
+    autoload :Responder, 'noise/connection/responder'
   end
 end

data/lib/noise/connection/base.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Noise
+  module Connection
+    class Base
+      attr_reader :protocol, :handshake_started, :handshake_finished, :handshake_hash
+      attr_reader :cipher_state_encrypt, :cipher_state_decrypt, :cipher_state_handshake
+      attr_accessor :psks, :prologue
+
+      def initialize(name, keypairs: { s: nil, e: nil, rs: nil, re: nil })
+        @protocol = Protocol.create(name)
+
+        @keypairs = keypairs
+        # parameter keypairs[:e] and keypairs[:s] are strings, so should convert Noise::Key object.
+        @keypairs[:e] = @protocol.dh_fn.class.from_private(@keypairs[:e]) if @keypairs[:e]
+        @keypairs[:s] = @protocol.dh_fn.class.from_private(@keypairs[:s]) if @keypairs[:s]
+
+        @handshake_started = false
+        @handshake_finished = false
+        @next_message = nil
+      end
+
+      def start_handshake
+        validate
+        initialise_handshake_state
+        @handshake_started = true
+      end
+
+      def initialise_handshake_state
+        @handshake_state = Noise::State::HandshakeState.new(
+          self,
+          protocol,
+          initiator?,
+          @prologue,
+          @keypairs
+        )
+        @symmetric_state = @handshake_state.symmetric_state
+        @cipher_state_handshake = @symmetric_state.cipher_state
+      end
+
+      def write_message(payload = '')
+        # Call NoiseConnection.start_handshake first
+        raise Noise::Exceptions::NoiseHandshakeError unless @handshake_started
+        raise Noise::Exceptions::NoiseHandshakeError if @next_message != :write
+        # Handshake finished. NoiseConnection.encrypt should be used now
+        raise Noise::Exceptions::NoiseHandshakeError if @handshake_finished
+        @next_message = :read
+        buffer = +''
+        result = @handshake_state.write_message(payload, buffer)
+        @handshake_finished = true if result
+        buffer
+      end
+
+      def read_message(data)
+        # Call NoiseConnection.start_handshake first
+        raise Noise::Exceptions::NoiseHandshakeError unless @handshake_started
+        raise Noise::Exceptions::NoiseHandshakeError if @next_message != :read
+        # Handshake finished. NoiseConnection.encrypt should be used now
+        raise Noise::Exceptions::NoiseHandshakeError if @handshake_finished
+
+        @next_message = :write
+        buffer = +''
+        result = @handshake_state.read_message(data, buffer)
+        @handshake_finished = true if result
+        buffer
+      end
+
+      def encrypt(data)
+        raise Noise::Exceptions::NoiseHandshakeError unless @handshake_finished
+        # raise Noise::Exceptions::NoiseInvalidMessage
+        @cipher_state_encrypt.encrypt_with_ad('', data)
+      end
+
+      def decrypt(data)
+        raise Noise::Exceptions::NoiseHandshakeError unless @handshake_finished
+        # raise Noise::Exceptions::NoiseInvalidMessage
+        @cipher_state_decrypt.decrypt_with_ad('', data)
+      end
+
+      def validate_psk!
+        # Invalid psk length! Has to be 32 bytes long
+        raise Noise::Exceptions::NoisePSKError if @psks.any? { |psk| psk.bytesize != 32 }
+        # Bad number of PSKs provided to this protocol! {} are required,
+        # given {}'.format(self.pattern.psk_count, len(self.psks)))
+        raise Noise::Exceptions::NoisePSKError if @protocol.pattern.psk_count != @psks.count
+      end
+
+      def valid_keypairs?
+        @protocol.pattern.required_keypairs(initiator?).any? { |keypair| !@keypairs[keypair] }
+      end
+
+      def validate
+        validate_psk! if psk_handshake?
+
+        # 'Keypair {} has to be set for chosen handshake pattern'.format(keypair)
+        raise Noise::Exceptions::NoiseValidationError if valid_keypairs?
+        true
+      end
+
+      def psk_handshake?
+        @protocol.is_psk_handshake
+      end
+
+      def handshake_done(_c1, _c2)
+        @handshake_hash = @symmetric_state.handshake_hash
+        @handshake_state = nil
+        @symmetric_state = nil
+        @cipher_state_handshake = nil
+      end
+    end
+  end
+end

data/lib/noise/connection/initiator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Noise
+  module Connection
+    class Initiator < Base
+      def initialize(name, keypairs: { s: nil, e: nil, rs: nil, re: nil })
+        super
+        @next_message = :write
+      end
+
+      def initiator?
+        true
+      end
+
+      def handshake_done(c1, c2)
+        super
+        @cipher_state_encrypt = c1
+        @cipher_state_decrypt = @protocol.pattern.one_way ? nil : c2
+      end
+    end
+  end
+end

data/lib/noise/connection/responder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Noise
+  module Connection
+    class Responder < Base
+      def initialize(name, keypairs: { s: nil, e: nil, rs: nil, re: nil })
+        super
+        @next_message = :read
+      end
+
+      def initiator?
+        false
+      end
+
+      def handshake_done(c1, c2)
+        super
+        @cipher_state_decrypt = c1
+        @cipher_state_encrypt = @protocol.pattern.one_way ? nil : c2
+      end
+    end
+  end
+end

data/lib/noise/functions/cipher/cha_cha_poly.rb

@@ -8,14 +8,14 @@ module Noise
           @cipher = RbNaCl::AEAD::ChaCha20Poly1305IETF.new(String.new(k).force_encoding('ASCII-8BIT'))
           @cipher.encrypt(nonce_to_bytes(n), plaintext, ad)
         rescue ::RbNaCl::CryptoError => e
-          raise Noise::Exceptions::EncryptError.new(e)
+          raise Noise::Exceptions::EncryptError, e
         end
 
         def decrypt(k, n, ad, ciphertext)
           @cipher = RbNaCl::AEAD::ChaCha20Poly1305IETF.new(String.new(k).force_encoding('ASCII-8BIT'))
           @cipher.decrypt(nonce_to_bytes(n), ciphertext, ad)
         rescue ::RbNaCl::CryptoError => e
-          raise Noise::Exceptions::DecryptError.new(e)
+          raise Noise::Exceptions::DecryptError, e
         end
 
         def nonce_to_bytes(n)

data/lib/noise/functions/dh/ed25519.rb

@@ -9,7 +9,7 @@ module Noise
           private_key = 1 + SecureRandom.random_number(RbNaCl::GroupElement::STANDARD_GROUP_ORDER - 1)
           scalar_as_string = ECDSA::Format::IntegerOctetString.encode(private_key, 32)
           public_key = RbNaCl::GroupElements::Curve25519.base.mult(scalar_as_string)
-          [ECDSA::Format::IntegerOctetString.encode(private_key, 32), public_key.to_bytes]
+          Noise::Key.new(ECDSA::Format::IntegerOctetString.encode(private_key, 32), public_key.to_bytes)
         end
 
         def dh(private_key, public_key)
@@ -22,11 +22,7 @@ module Noise
 
         def self.from_private(private_key)
           public_key = RbNaCl::GroupElements::Curve25519.base.mult(private_key)
-          [private_key, public_key.to_bytes]
-        end
-
-        def self.from_public(public_key)
-          [nil, public_key]
+          Noise::Key.new(private_key, public_key.to_bytes)
         end
       end
     end

data/lib/noise/functions/dh/ed448.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Noise
   module Functions
     module DH
@@ -7,18 +9,13 @@ module Noise
           throw NotImplementedError
         end
 
-        def dh(key_pair, public_key)
+        def dh(_key_pair, _public_key)
           throw NotImplementedError
         end
 
         def dhlen
           DHLEN
         end
-
-        def self.from_private(private_key)
-        end
-        def self.from_public(private_key)
-        end
       end
     end
   end

data/lib/noise/functions/dh/secp256k1.rb

@@ -5,7 +5,6 @@ begin
 rescue LoadError
 end
 
-
 module Noise
   module Functions
     module DH
@@ -14,17 +13,17 @@ module Noise
           group = ECDSA::Group::Secp256k1
           private_key = 1 + SecureRandom.random_number(group.order - 1)
           public_key = group.generator.multiply_by_scalar(private_key)
-          [
+          Noise::Key.new(
             ECDSA::Format::IntegerOctetString.encode(private_key, 32),
             ECDSA::Format::PointOctetString.encode(public_key, compression: true)
-          ]
+          )
         end
 
         def dh(private_key, public_key)
           key = ::Secp256k1::PublicKey.new(pubkey: public_key, raw: true)
           key.ecdh(private_key)
         rescue ::Secp256k1::AssertError => _
-          raise Noise::Exceptions::InvalidPublicKeyError.new(public_key)
+          raise Noise::Exceptions::InvalidPublicKeyError, public_key
         end
 
         def dhlen
@@ -35,11 +34,7 @@ module Noise
           group = ECDSA::Group::Secp256k1
           scalar = ECDSA::Format::IntegerOctetString.decode(private_key)
           point = group.generator.multiply_by_scalar(scalar)
-          [private_key, ECDSA::Format::PointOctetString.encode(point, compression: true)]
-        end
-
-        def self.from_public(public_key)
-          [nil, public_key]
+          Noise::Key.new(private_key, ECDSA::Format::PointOctetString.encode(point, compression: true))
         end
       end
     end

data/lib/noise/functions/hash/blake2s.rb

@@ -27,46 +27,46 @@ module Noise
       end
 
       class Blake2sDigester
-        IV = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19]
+        IV = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19].freeze
         SIGMA = [
-          [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ],
-          [ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 ],
-          [ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 ],
-          [ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 ],
-          [ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 ],
-          [ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 ],
-          [ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 ],
-          [ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 ],
-          [ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 ],
-          [ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 ]
-        ]
+          [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+          [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+          [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
+          [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
+          [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
+          [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9],
+          [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11],
+          [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10],
+          [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5],
+          [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0]
+        ].freeze
 
         def initialize(key: '')
           @key = key
-          @ctx = init(Blake2s::HASHLEN, @key.unpack("C*"))
+          @ctx = init(Blake2s::HASHLEN, @key.unpack('C*'))
         end
 
         def update(data)
-          update_internal(@ctx, data.unpack("C*"))
+          update_internal(@ctx, data.unpack('C*'))
           self
         end
 
         def digest
           out = []
           final(@ctx, out)
-          out.pack("C*")
+          out.pack('C*')
         end
 
         # @return context
         def init(out_len, key)
-          raise ArgumentError if out_len == 0 || out_len > 32
+          raise ArgumentError if out_len.zero? || out_len > 32
           h = IV.dup
           h[0] ^= 0x01010000 ^ (key.size << 8) ^ out_len
           t = 0
           c = 0
           b = Array.new(Blake2s::BLOCKLEN).fill(0, key.size)
           ctx = Context.new(b, h, t, c, out_len)
-          if key.size > 0
+          if key.size.positive?
             update_internal(ctx, key)
             ctx.c = 64
           end
@@ -101,12 +101,12 @@ module Noise
         private
 
         def to_int32(x)
-          x = x & 0xFFFFFFFF
+          x &= 0xFFFFFFFF
           x < 0x80000000 ? x : x - 2**32
         end
 
-        def rshift(x, y, range=32)
-          (x + (x > 0 ? 0 : 2 ** range)) >> y
+        def rshift(x, y, range = 32)
+          (x + (x.positive? ? 0 : 2**range)) >> y
         end
 
         def rotr32(x, y)
@@ -151,11 +151,11 @@ module Noise
           end
 
           10.times do |i|
-            mix_g(v, 0, 4,  8, 12, m[SIGMA[i][ 0]], m[SIGMA[i][ 1]])
-            mix_g(v, 1, 5,  9, 13, m[SIGMA[i][ 2]], m[SIGMA[i][ 3]])
-            mix_g(v, 2, 6, 10, 14, m[SIGMA[i][ 4]], m[SIGMA[i][ 5]])
-            mix_g(v, 3, 7, 11, 15, m[SIGMA[i][ 6]], m[SIGMA[i][ 7]])
-            mix_g(v, 0, 5, 10, 15, m[SIGMA[i][ 8]], m[SIGMA[i][ 9]])
+            mix_g(v, 0, 4,  8, 12, m[SIGMA[i][0]], m[SIGMA[i][1]])
+            mix_g(v, 1, 5,  9, 13, m[SIGMA[i][2]], m[SIGMA[i][3]])
+            mix_g(v, 2, 6, 10, 14, m[SIGMA[i][4]], m[SIGMA[i][5]])
+            mix_g(v, 3, 7, 11, 15, m[SIGMA[i][6]], m[SIGMA[i][7]])
+            mix_g(v, 0, 5, 10, 15, m[SIGMA[i][8]], m[SIGMA[i][9]])
             mix_g(v, 1, 6, 11, 12, m[SIGMA[i][10]], m[SIGMA[i][11]])
             mix_g(v, 2, 7,  8, 13, m[SIGMA[i][12]], m[SIGMA[i][13]])
             mix_g(v, 3, 4,  9, 14, m[SIGMA[i][14]], m[SIGMA[i][15]])

data/lib/noise/key.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Noise
+  class Key
+    attr_reader :private_key, :public_key
+
+    def initialize(private_key, public_key)
+      @private_key = private_key
+      @public_key = public_key
+    end
+  end
+end

data/lib/noise/protocol.rb

@@ -2,14 +2,9 @@
 
 module Noise
   class Protocol
-    attr_accessor :prologue, :initiator
-    attr_accessor :cipher_state_encrypt, :cipher_state_decrypt
-    attr_accessor :cipher_state_handshake
-    attr_accessor :psks
-    attr_reader :name, :cipher_fn, :hash_fn, :dh_fn, :hkdf_fn, :pattern
-    attr_reader :handshake_state, :keypairs, :keypair_fn
-    attr_reader :handshake_hash
-    attr_accessor :ck
+    attr_accessor :is_psk_handshake
+    attr_accessor :cipher_fn, :hash_fn, :dh_fn, :hkdf_fn
+    attr_reader :name, :pattern
 
     CIPHER = {
       'AESGCM': Noise::Functions::Cipher::AesGcm,
@@ -38,9 +33,7 @@ module Noise
     def initialize(name, pattern_name, cipher_name, hash_name, dh_name)
       @name = name
       @pattern = Noise::Pattern.create(pattern_name)
-      @keypairs = { s: [], e: [], rs: [], re: [] }
       @hkdf_fn = Noise::Functions::Hash.create_hkdf_fn(hash_name)
-      @psks = []
       @is_psk_handshake = @pattern.modifiers.any? { |m| m.start_with?('psk') }
 
       @pattern.apply_pattern_modifiers
@@ -55,68 +48,6 @@ module Noise
       raise Noise::Exceptions::ProtocolNameError unless @cipher_fn && @hash_fn && @dh_fn
     end
 
-    def handshake_done
-      if @pattern.one_way
-        if @initiator
-          @cipher_state_decrypt = nil
-        else
-          @cipher_state_encrypt = nil
-        end
-      end
-      @handshake_hash = @symmetric_state.handshake_hash
-      @keypairs = @handshake_state.keypairs
-
-      @handshake_state = nil
-      @ck = @symmetric_state.ck
-      @symmetric_state = nil
-      @cipher_state_handshake = nil
-      @prologue = nil
-      @initiator = nil
-      @dh_fn = nil
-      @hash_fn = nil
-      @keypair_fn = nil
-    end
-
-    def validate_psk!
-      # Invalid psk length! Has to be 32 bytes long
-      raise Noise::Exceptions::NoisePSKError if @psks.any? { |psk| psk.bytesize != 32 }
-      # Bad number of PSKs provided to this protocol! {} are required,
-      # given {}'.format(self.pattern.psk_count, len(self.psks)))
-      raise Noise::Exceptions::NoisePSKError if @pattern.psk_count != @psks.count
-    end
-
-    def valid_keypairs?
-      @pattern.required_keypairs(@initiator).any? { |keypair| !@keypairs[keypair] }
-    end
-
-    def validate
-      validate_psk! if psk_handshake?
-
-      # You need to set role with NoiseConnection.set_as_initiator
-      # or NoiseConnection.set_as_responder
-      raise Noise::Exceptions::NoiseValidationError if @initiator.nil?
-
-      # 'Keypair {} has to be set for chosen handshake pattern'.format(keypair)
-      raise Noise::Exceptions::NoiseValidationError if valid_keypairs?
-
-      if @keypairs[:e] || @keypairs[:re]
-        # warnings
-        # One of ephemeral keypairs is already set.
-        # This is OK for testing, but should NEVER happen in production!
-      end
-      true
-    end
-
-    def initialise_handshake_state
-      @handshake_state = Noise::State::HandshakeState.new(
-        self,
-        @initiator,
-        @prologue,
-        @keypairs
-      )
-      @symmetric_state = @handshake_state.symmetric_state
-    end
-
     def psk_handshake?
       @is_psk_handshake
     end

data/lib/noise/state/cipher_state.rb

@@ -17,11 +17,13 @@ module Noise
         @cipher = cipher
       end
 
+      # @param [String] 32 bytes key
       def initialize_key(key)
         @k = key
         @n = 0
       end
 
+      # @return [Boolean] true if k is non-empty, false otherwise.
       def key?
         !@k.nil?
       end
@@ -30,6 +32,7 @@ module Noise
         @n = nonce
       end
 
+      #  @return [String] ENCRYPT(k, n++, ad, plaintext) if k is non-empty, otherwise returns plaintext.
       def encrypt_with_ad(ad, plaintext)
         return plaintext unless key?
         raise Noise::Exceptions::MaxNonceError if @n == MAX_NONCE
@@ -38,6 +41,7 @@ module Noise
         ciphertext
       end
 
+      # @return DECRYPT(k, n++, ad, ciphertext) if k is non-empty, otherwise returns ciphertext.
       def decrypt_with_ad(ad, ciphertext)
         return ciphertext unless key?
         raise Noise::Exceptions::MaxNonceError if @n == MAX_NONCE

data/lib/noise/state/handshake_state.rb

@@ -10,15 +10,20 @@ module Noise
     # rs: The remote party's static public key
     # re: The remote party's ephemeral public key
     #
+    # A HandshakeState also has variables to track its role, and the remaining portion of the handshake pattern:
+    #
+    # initiator: A boolean indicating the initiator or responder role.
+    #
+    # message_patterns: A sequence of message patterns.
+    #     Each message pattern is a sequence of tokens from the set ("e", "s", "ee", "es", "se", "ss").
     class HandshakeState
-
       attr_reader :message_patterns, :symmetric_state
 
-      def initialize(protocol, initiator, prologue, keypairs)
-        # @protocol = handshake_pattern.to_protocol
+      def initialize(connection, protocol, initiator, prologue, keypairs)
+        @connection = connection
         @protocol = protocol
         @symmetric_state = SymmetricState.new
-        @symmetric_state.initialize_symmetric(@protocol)
+        @symmetric_state.initialize_symmetric(@protocol, connection)
         @symmetric_state.mix_hash(prologue)
         @initiator = initiator
         @s = keypairs[:s]
@@ -29,7 +34,7 @@ module Noise
         # TODO : Calls MixHash() once for each public key listed in the pre-messages from  handshake_pattern, with the
         # specified public key as input (see Section 7 for an explanation of pre-messages). If both initiator and
         # responder have pre-messages, the initiator's public keys are hashed first.
-        get_local_keypair = ->(token) { instance_variable_get('@' + token) }
+        get_local_keypair = ->(token) { instance_variable_get('@' + token).public_key }
         get_remote_keypair = ->(token) { instance_variable_get('@r' + token) }
 
         if initiator
@@ -42,17 +47,18 @@ module Noise
 
         @protocol.pattern.initiator_pre_messages&.map do |message|
           keypair = initiator_keypair_getter.call(message)
-          @symmetric_state.mix_hash(keypair[1])
+          @symmetric_state.mix_hash(keypair)
         end
 
         @protocol.pattern.responder_pre_messages&.map do |message|
           keypair = responder_keypair_getter.call(message)
-          @symmetric_state.mix_hash(keypair[1])
+          @symmetric_state.mix_hash(keypair)
         end
         # Sets message_patterns to the message patterns from handshake_pattern
         @message_patterns = @protocol.pattern.tokens.dup
       end
 
+      # Takes a payload byte sequence which may be zero-length, and a message_buffer to write the output into
       def write_message(payload, message_buffer)
         pattern = @message_patterns.shift
         dh_fn = @protocol.dh_fn
@@ -60,37 +66,32 @@ module Noise
         pattern.each do |token|
           case token
           when 'e'
-            @e = dh_fn.generate_keypair if @e.empty?
-            message_buffer << @e[1]
-            @symmetric_state.mix_hash(@e[1])
-            @symmetric_state.mix_key(@e[1]) if @protocol.psk_handshake?
-            next
+            @e = dh_fn.generate_keypair if @e.nil?
+            message_buffer << @e.public_key
+            @symmetric_state.mix_hash(@e.public_key)
+            @symmetric_state.mix_key(@e.public_key) if @protocol.psk_handshake?
           when 's'
-            message_buffer << @symmetric_state.encrypt_and_hash(@s[1])
-            next
+            message_buffer << @symmetric_state.encrypt_and_hash(@s.public_key)
           when 'ee'
-            @symmetric_state.mix_key(dh_fn.dh(@e[0], @re[1]))
-            next
+            @symmetric_state.mix_key(dh_fn.dh(@e.private_key, @re))
           when 'es'
-            private_key, public_key = @initiator ? [@e[0], @rs[1]] : [@s[0], @re[1]]
+            private_key, public_key = @initiator ? [@e.private_key, @rs] : [@s.private_key, @re]
             @symmetric_state.mix_key(dh_fn.dh(private_key, public_key))
-            next
           when 'se'
-            private_key, public_key = @initiator ? [@s[0], @re[1]] : [@e[0], @rs[1]]
+            private_key, public_key = @initiator ? [@s.private_key, @re] : [@e.private_key, @rs]
             @symmetric_state.mix_key(dh_fn.dh(private_key, public_key))
-            next
           when 'ss'
-            @symmetric_state.mix_key(dh_fn.dh(@s[0], @rs[1]))
-            next
+            @symmetric_state.mix_key(dh_fn.dh(@s.private_key, @rs))
           when 'psk'
-            @symmetric_state.mix_key_and_hash(@protocol.psks.shift)
-            next
+            @symmetric_state.mix_key_and_hash(@connection.psks.shift)
           end
         end
         message_buffer << @symmetric_state.encrypt_and_hash(payload)
         @symmetric_state.split if @message_patterns.empty?
       end
 
+      # Takes a byte sequence containing a Noise handshake message,
+      # and a payload_buffer to write the message's plaintext payload into
       def read_message(message, payload_buffer)
         pattern = @message_patterns.shift
         dh_fn = @protocol.dh_fn
@@ -98,44 +99,32 @@ module Noise
         pattern.each do |token|
           case token
           when 'e'
-            @re = @protocol.dh_fn.class.from_public(message[0...len]) if @re.empty?
+            @re = message[0...len] if @re.nil?
             message = message[len..-1]
-            @symmetric_state.mix_hash(@re[1])
-            @symmetric_state.mix_key(@re[1]) if @protocol.psk_handshake?
-            next
+            @symmetric_state.mix_hash(@re)
+            @symmetric_state.mix_key(@re) if @protocol.psk_handshake?
           when 's'
-            offset = @protocol.cipher_state_handshake.key? ? 16 : 0
+            offset = @connection.cipher_state_handshake.key? ? 16 : 0
             temp = message[0...len + offset]
             message = message[(len + offset)..-1]
-            @rs = @protocol.dh_fn.class.from_public(@symmetric_state.decrypt_and_hash(temp))
-            next
+            @rs = @symmetric_state.decrypt_and_hash(temp)
           when 'ee'
-            @symmetric_state.mix_key(dh_fn.dh(@e[0], @re[1]))
-            next
+            @symmetric_state.mix_key(dh_fn.dh(@e.private_key, @re))
           when 'es'
-            private_key, public_key = @initiator ? [@e[0], @rs[1]] : [@s[0], @re[1]]
+            private_key, public_key = @initiator ? [@e.private_key, @rs] : [@s.private_key, @re]
             @symmetric_state.mix_key(dh_fn.dh(private_key, public_key))
-            next
           when 'se'
-            private_key, public_key = @initiator ? [@s[0], @re[1]] : [@e[0], @rs[1]]
+            private_key, public_key = @initiator ? [@s.private_key, @re] : [@e.private_key, @rs]
             @symmetric_state.mix_key(dh_fn.dh(private_key, public_key))
-            next
           when 'ss'
-            @symmetric_state.mix_key(dh_fn.dh(@s[0], @rs[1]))
-            next
+            @symmetric_state.mix_key(dh_fn.dh(@s.private_key, @rs))
           when 'psk'
-            @symmetric_state.mix_key_and_hash(@protocol.psks.shift)
-            next
+            @symmetric_state.mix_key_and_hash(@connection.psks.shift)
           end
         end
         payload_buffer << @symmetric_state.decrypt_and_hash(message)
         @symmetric_state.split if @message_patterns.empty?
       end
-
-      # no need for ephemeral keys after handshake has completed.
-      def keypairs
-        { s: @s, rs: @rs }
-      end
     end
   end
 end

data/lib/noise/state/symmetric_state.rb

@@ -11,21 +11,13 @@ module Noise
       attr_reader :h, :ck
       attr_reader :cipher_state
 
-      def initialize_h(protocol)
-        if protocol.name.length <= protocol.hash_fn.hashlen
-          protocol.name.ljust(protocol.hash_fn.hashlen, "\x00")
-        else
-          protocol.hash_fn.hash(protocol.name)
-        end
-      end
-
-      def initialize_symmetric(protocol)
+      def initialize_symmetric(protocol, connection)
         @protocol = protocol
+        @connection = connection
         @ck = @h = initialize_h(protocol)
 
         @cipher_state = CipherState.new(cipher: @protocol.cipher_fn)
         @cipher_state.initialize_key(nil)
-        @protocol.cipher_state_handshake = @cipher_state
       end
 
       def mix_key(input_key_meterial)
@@ -34,11 +26,12 @@ module Noise
         @cipher_state.initialize_key(temp_k)
       end
 
-      # data [String] binary string
+      # @param [String] data binary string to be hashed
       def mix_hash(data)
         @h = @protocol.hash_fn.hash(@h + data)
       end
 
+      # This function is used for handling pre-shared symmetric keys.
       def mix_key_and_hash(input_key_meterial)
         @ck, temp_h, temp_k = @protocol.hkdf_fn.call(@ck, input_key_meterial, 3)
         mix_hash(temp_h)
@@ -46,42 +39,58 @@ module Noise
         @cipher_state.initialize_key(temp_k)
       end
 
+      # Returns h. This function should only be called at the end of a handshake,
+      # i.e. after the Split() function has been called.
+      # This function is used for channel binding
+      # @returns [String] h
       def handshake_hash
         @h
       end
 
+      # Note that if k is empty, the  EncryptWithAd() call will set ciphertext equal to plaintext.
       def encrypt_and_hash(plaintext)
         ciphertext = @cipher_state.encrypt_with_ad(@h, plaintext)
         mix_hash(ciphertext)
         ciphertext
       end
 
+      # Note that if k is empty, the  DecryptWithAd() call will set plaintext equal to ciphertext.
       def decrypt_and_hash(ciphertext)
         plaintext = @cipher_state.decrypt_with_ad(@h, ciphertext)
         mix_hash(ciphertext)
         plaintext
       end
 
-      def create_cipher_state(k)
-        k = truncate(k)
-        c = CipherState.new(cipher: @protocol.cipher_fn)
-        c.initialize_key(k)
-        c
-      end
-
+      # @return [CipherState, CipherState] a pair of CipherState objects for encrypting transport messages.
       def split
         temp_k1, temp_k2 = @protocol.hkdf_fn.call(@ck, '', 2)
         c1 = create_cipher_state(temp_k1)
         c2 = create_cipher_state(temp_k2)
-        @protocol.cipher_state_encrypt = @protocol.initiator ? c1 : c2
-        @protocol.cipher_state_decrypt = @protocol.initiator ? c2 : c1
-        @protocol.handshake_done
+        @connection.handshake_done(c1, c2)
         [c1, c2]
       end
 
+      private
+
+      def initialize_h(protocol)
+        if protocol.name.length <= protocol.hash_fn.hashlen
+          protocol.name.ljust(protocol.hash_fn.hashlen, "\x00")
+        else
+          protocol.hash_fn.hash(protocol.name)
+        end
+      end
+
+      # truncates temp_k to 32 bytes if HASHLEN is 64
       def truncate(k)
         @protocol.hash_fn.hashlen == 64 ? k[0, 32] : k
       end
+
+      def create_cipher_state(k)
+        k = truncate(k)
+        c = CipherState.new(cipher: @protocol.cipher_fn)
+        c.initialize_key(k)
+        c
+      end
     end
   end
 end

data/lib/noise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Noise
-  VERSION = '0.7.1'
+  VERSION = '0.7.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: noise-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Hajime Yamaguchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-19 00:00:00.000000000 Z
+date: 2019-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,6 +128,9 @@ files:
 - bin/setup
 - lib/noise.rb
 - lib/noise/connection.rb
+- lib/noise/connection/base.rb
+- lib/noise/connection/initiator.rb
+- lib/noise/connection/responder.rb
 - lib/noise/exceptions.rb
 - lib/noise/exceptions/decrypt_error.rb
 - lib/noise/exceptions/encrypt_error.rb
@@ -151,6 +154,7 @@ files:
 - lib/noise/functions/hash/blake2s.rb
 - lib/noise/functions/hash/sha256.rb
 - lib/noise/functions/hash/sha512.rb
+- lib/noise/key.rb
 - lib/noise/key_pair.rb
 - lib/noise/pattern.rb
 - lib/noise/protocol.rb