noise-ruby 0.1.0

data/lib/noise/functions/dh.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module DH
+      autoload :DH448, 'noise/functions/dh/dh448'
+      autoload :DH25519, 'noise/functions/dh/dh25519'
+      autoload :Secp256k1, 'noise/functions/dh/secp256k1'
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Noise
+  module Functions
+    module DH
+      class DH25519
+        DHLEN = 32
+        def generate_keypair
+          private_key = RbNaCl::Signatures::Ed25519::SigningKey.generate
+          public_key = private_key.verify_key
+          [private_key.to_bytes, public_key.to_bytes]
+        end
+
+        def dh(private_key, public_key)
+          point = RbNaCl::GroupElement.new(public_key).mult(private_key)
+          point.to_bytes
+        end
+
+        def dhlen
+          DHLEN
+        end
+
+        def self.from_private(private_key)
+          private_key = RbNaCl::GroupElements::Curve25519.new(private_key)
+          public_key = RbNaCl::GroupElements::Curve25519.base.mult(private_key)
+          [private_key.to_bytes, public_key.to_bytes]
+        end
+
+        def self.from_public(public_key)
+          public_key = RbNaCl::Signatures::Ed25519::VerifyKey.new(public_key)
+          [nil, public_key.to_bytes]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Noise
+  module Functions
+    module DH
+      class DH448
+        DHLEN = 56
+        def generate_keypair
+          throw NotImplementedError
+        end
+
+        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
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module DH
+      class Secp256k1
+        def generate_keypair
+          group = ECDSA::Group::Secp256k1
+          private_key = 1 + SecureRandom.random_number(group.order - 1)
+          public_key = group.generator.multiply_by_scalar(private_key)
+          [private_key, public_key]
+        end
+
+        def dh(private_key, public_key)
+          public_key.multiply_by_scalar(private_key)
+        end
+
+        def dhlen
+          64
+        end
+        def self.from_private(private_key)
+        end
+        def self.from_public(private_key)
+        end
+      end
+    end
+  end
+end

data/lib/noise/functions/hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module Hash
+      autoload :Blake2b, 'noise/functions/hash/blake2b'
+      autoload :Blake2s, 'noise/functions/hash/blake2s'
+      autoload :Sha256, 'noise/functions/hash/sha256'
+      autoload :Sha512, 'noise/functions/hash/sha512'
+
+      def self.hmac_hash(key, data, digest)
+        # TODO: support for blake2b, blake2s
+        OpenSSL::HMAC.digest(OpenSSL::Digest.new(digest), key, data)
+      end
+
+      def self.create_hkdf_fn(digest)
+        ->(chaining_key, input_key_material, num_output) {
+          hkdf(chaining_key, input_key_material, num_output, digest)
+        }
+      end
+
+      def self.hkdf(chaining_key, input_key_material, num_outputs, digest)
+        temp_key = hmac_hash(chaining_key, input_key_material, digest)
+        output1 = hmac_hash(temp_key, "\x01", digest)
+        output2 = hmac_hash(temp_key, output1 + "\x02", digest)
+        return [output1, output2] if num_outputs == 2
+        output3 = hmac_hash(temp_key, output2 + "\x03", digest)
+        [output1, output2, output3]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module Hash
+      class Blake2b
+        HASHLEN = 64
+        BLOCKLEN = 128
+        def hash(data)
+          RbNaCl::Hash.blake2b(data)
+        end
+
+        def hashlen
+          HASHLEN
+        end
+
+        def blocklen
+          BLOCKLEN
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module Hash
+      class Blake2s
+        HASHLEN = 32
+        BLOCKLEN = 64
+        def hash(data)
+          throw NotImplementedError
+        end
+
+        def hashlen
+          HASHLEN
+        end
+
+        def blocklen
+          BLOCKLEN
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module Hash
+      class Sha256
+        HASHLEN = 32
+        BLOCKLEN = 64
+        def hash(data)
+          RbNaCl::Hash.sha256(data)
+        end
+
+        def hashlen
+          HASHLEN
+        end
+
+        def blocklen
+          BLOCKLEN
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Noise
+  module Functions
+    module Hash
+      class Sha512
+        HASHLEN = 64
+        BLOCKLEN = 128
+        def hash(data)
+          RbNaCl::Hash.sha512(data)
+        end
+
+        def hashlen
+          HASHLEN
+        end
+
+        def blocklen
+          BLOCKLEN
+        end
+      end
+    end
+  end
+end

data/lib/noise/pattern.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Noise
+  module Token
+    E = 'e'
+    S = 's'
+    EE = 'ee'
+    ES = 'es'
+    SE = 'se'
+    SS = 'ss'
+    PSK = 'psk'
+  end
+
+  class Pattern
+    attr_reader :one_way, :tokens
+
+    def self.create(name)
+      class_name = "Noise::Pattern#{name}"
+      klass = Object.const_get(class_name)
+      klass.new
+    end
+
+    def initialize
+      @pre_messages = [[], []]
+      @tokens = []
+      @name = ''
+      @one_way = false
+      @psk_count = 0
+    end
+
+    # initiator [Boolean]
+    def required_keypairs(initiator)
+      required = []
+      if initiator
+        required << :s if ['K', 'X', 'I'].include?(@name[0])
+        required << :rs if @one_way || @name[1] == 'K'
+      else
+        required << :rs if @name[0] == 'K'
+        required << :s if @one_way || ['K', 'X'].include?(@name[1])
+      end
+      required
+    end
+
+    def initiator_pre_messages
+      @pre_messages[0].dup
+    end
+
+    def responder_pre_messages
+      @pre_messages[1].dup
+    end
+  end
+
+  class OneWayPattern < Pattern
+    def initialize
+      super
+      @one_way = true
+    end
+  end
+
+  class PatternN < OneWayPattern
+    def initialize
+      super
+      @name = 'N'
+      @pre_messages = [[], [Token::S]]
+      @tokens = [[Token::E, Token::ES]]
+    end
+  end
+
+  class PatternK < OneWayPattern
+    def initialize
+      super
+      @name = 'K'
+      @pre_messages = [[Token::S], [Token::S]]
+      @tokens = [[Token::E, Token::ES, Token::SS]]
+    end
+  end
+
+  class PatternX < OneWayPattern
+    def initialize
+      super
+      @name = 'X'
+      @pre_messages = [[], [Token::S]]
+      @tokens = [[Token::E, Token::ES, Token::S, Token::SS]]
+    end
+  end
+
+  class PatternNN < Pattern
+    def initialize
+      super
+      @name = 'NN'
+      @pre_messages = []
+      @tokens = [[Token::E], [Token::E, Token::EE]]
+    end
+  end
+
+  class PatternKN < Pattern
+    def initialize
+      super
+      @name = 'KN'
+      @pre_messages = [[Token::S], []]
+      @tokens = [[Token::E], [Token::E, Token::EE, Token::SE]]
+    end
+  end
+
+  class PatternNK < Pattern
+    def initialize
+      super
+      @name = 'NK'
+      @pre_messages = [[], [Token::S]]
+      @tokens = [[Token::E, Token::ES], [Token::E, Token::EE]]
+    end
+  end
+
+  class PatternKK < Pattern
+    def initialize
+      super
+      @name = 'KK'
+      @pre_messages = [[Token::S], [Token::S]]
+      @tokens = [[Token::E, Token::ES, Token::SS], [Token::E, Token::EE, Token::SE]]
+    end
+  end
+
+  class PatternNX < Pattern
+    def initialize
+      super
+      @name = 'NX'
+      @tokens = [[Token::E], [Token::E, Token::EE, Token::S, Token::ES]]
+    end
+  end
+
+  class PatternKX < Pattern
+    def initialize
+      super
+      @name = 'KX'
+      @pre_messages = [[Token::S], []]
+      @tokens = [[Token::E], [Token::E, Token::EE, Token::SE, Token::S, Token::ES]]
+    end
+  end
+
+  class PatternXN < Pattern
+    def initialize
+      super
+      @name = 'XN'
+      @tokens = [[Token::E], [Token::E, Token::EE], [Token::S, Token::SE]]
+    end
+  end
+
+  class PatternIN < Pattern
+    def initialize
+      super
+      @name = 'IN'
+      @tokens = [[Token::E, Token::S], [Token::E, Token::EE, Token::SE]]
+    end
+  end
+
+  class PatternXK < Pattern
+    def initialize
+      super
+      @name = 'XK'
+      @pre_messages = [[], [Token::S]]
+      @tokens = [[Token::E, Token::ES], [Token::E, Token::EE], [Token::S, Token::SE]]
+    end
+  end
+
+  class PatternIK < Pattern
+    def initialize
+      super
+      @name = 'IK'
+      @pre_messages = [[], [Token::S]]
+      @tokens = [[Token::E, Token::ES, Token::S, Token::SS], [Token::E, Token::EE, Token::SE]]
+    end
+  end
+
+  class PatternXX < Pattern
+    def initialize
+      super
+      @name = 'XX'
+      @tokens = [[Token::E], [Token::E, Token::EE, Token::S, Token::ES], [Token::S, Token::SE]]
+    end
+  end
+
+  class PatternIX < Pattern
+    def initialize
+      super
+      @name = 'IX'
+      @tokens = [[Token::E, Token::S], [Token::E, Token::EE, Token::SE, Token::S, Token::ES]]
+    end
+  end
+end
+    #
+    # def has_pre_messages(self):
+    #     return any(map(lambda x: len(x) > 0, self.pre_messages))
+    #
+    # def get_initiator_pre_messages(self) -> list:
+    #     return self.pre_messages[0].copy()
+    #
+    # def get_responder_pre_messages(self) -> list:
+    #     return self.pre_messages[1].copy()
+    #
+    # def apply_pattern_modifiers(self, modifiers: List[str]) -> None:
+    #     # Applies given pattern modifiers to self.tokens of the Pattern instance.
+    #     for modifier in modifiers:
+    #         if modifier.startswith('psk'):
+    #             try:
+    #                 index = int(modifier.replace('psk', '', 1))
+    #             except ValueError:
+    #                 raise ValueError('Improper psk modifier {}'.format(modifier))
+    #
+    #             if index // 2 > len(self.tokens):
+    #                 raise ValueError('Modifier {} cannot be applied - pattern has not enough messages'.format(modifier))
+    #
+    #             # Add TOKEN_PSK in the correct place in the correct message
+    #             if index == 0:  # if 0, insert at the beginning of first message
+    #                 self.tokens[0].insert(0, TOKEN_PSK)
+    #             else:  # if bigger than zero, append at the end of first, second etc.
+    #                 self.tokens[index - 1].append(TOKEN_PSK)
+    #             self.psk_count += 1
+    #
+    #         elif modifier == 'fallback':
+    #             raise NotImplementedError  # TODO implement
+    #
+    #         else:
+    #             raise ValueError('Unknown pattern modifier {}'.format(modifier))