stribog 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6dbadae89288325c543d7ddfbd077e59daa953ca
-  data.tar.gz: 8b2957b6d6eed667eeed5ca9a8908c665a0f4a35
+  metadata.gz: 56a62cd1418c7e1264f036de4784f516f51a2ee1
+  data.tar.gz: ab86cf5faf9d8a5c214a5f88bff9f9128b7da8ed
 SHA512:
-  metadata.gz: 672923eb97afdddf14f12123799400f57445fdda8302ce3d6a4b9b8d70153e20821114db301558e225d17d4738f5780822062afdbb202bd9a54e6402a4403a0a
-  data.tar.gz: 519f6bf11aac2e307ac7dc8bd6f87c4ea1ef5fd7877c38c21511aee88074b5cc001d5eccc0dba4684964f3fd241d0e8b660fa4492042b2fbb60a0c5026a1d403
+  metadata.gz: 53203b0d1059510c0737e508cfd9bb9da92d12831559605ee811f8ef6e687121df7a3983ace8e3f079f2fda1243bf8fce680e211725eb7b862832374a0770b93
+  data.tar.gz: 35974a63681b24a92cf62e3095d136138eec89e3ebbae94539df53c4f95c7bf4e564ff323df0fa1042c7fe7e3422d98fccb1b6d73f3032b5ce85de71ee5f9a30

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem

data/lib/stribog.rb

@@ -6,5 +6,4 @@ module Stribog
   require_relative './stribog/create_hash'
   require_relative './stribog/compression'
   require_relative './stribog/binary_vector'
-  require_relative './stribog/message'
 end

data/lib/stribog/binary_vector.rb

@@ -5,15 +5,28 @@ module Stribog
   class BinaryVector
     include Enumerable
 
+    attr_reader :vector
+
     class << self
       def from_byte(byte, size: 8)
-        new(byte.to_s(2).chars.map(&:to_i)).addition_to(size: size)
+        new(byte.to_s(2).chars.map(&:to_i)).addition_by_zeros(size: size)
       end
 
       def from_byte_array(byte_array, size: 8)
         new(byte_array.map { |byte| from_byte(byte, size: size).to_a }
                       .inject([]) { |acc, elem| acc + elem })
       end
+
+      def from_hex(hex)
+        new hex_to_bin(hex)
+      end
+
+      def hex_to_bin(hex)
+        hex.chars.map do |x|
+          bin = x.to_i(16).to_s(2)
+          '0' * (4 - bin.length) + bin
+        end.join.chars.map(&:to_i)
+      end
     end
 
     def initialize(vector)
@@ -23,16 +36,21 @@ module Stribog
 
     def ^(other)
       raise 'DimensionError' unless according_dimension?(other)
-      self.class.new @vector.map.with_index { |bit, index| bit ^ other[index] }
+      self.class.new vector.map.with_index { |bit, index| bit ^ other[index] }
     end
 
     def +(other)
-      self.class.new @vector + other.to_a
+      self.class.new vector + other.to_a
+    end
+
+    def addition_by_zeros(size: 512)
+      return self if vector.size >= size
+      self.class.new(Array.new(size - vector.size, 0) + @vector)
     end
 
-    def addition_to(size: 512)
-      return self if @vector.size >= size
-      self.class.new(Array.new(size - @vector.size, 0) + @vector)
+    def addition_bit_padding(size: 512)
+      return self if vector.size >= size
+      (self.class.new([1]) + vector).addition_by_zeros(size: 512)
     end
 
     def to_dec
@@ -44,30 +62,30 @@ module Stribog
     end
 
     def to_s
-      @vector.join
+      vector.join
     end
 
     def size
-      @vector.size
+      vector.size
     end
 
     def [](index)
-      @vector[index]
+      vector[index]
     end
 
     def each
-      @vector.each do |v|
+      vector.each do |v|
         yield(v)
       end
     end
 
     def to_a
-      @vector
+      vector
     end
 
     def to_byte_array
-      raise 'DimensionError' unless (@vector.size % 8).zero?
-      @vector.each_slice(8).map { |byte| byte.join.to_i(2) }
+      raise 'DimensionError' unless (vector.size % 8).zero?
+      vector.each_slice(8).map { |byte| byte.join.to_i(2) }
     end
 
     def zero?
@@ -77,11 +95,11 @@ module Stribog
     private
 
     def binary?
-      @vector.all? { |el| [0, 1].include? el }
+      vector.all? { |el| [0, 1].include? el }
     end
 
-    def according_dimension?(vector)
-      @vector.size == vector.size
+    def according_dimension?(second_vector)
+      vector.size == second_vector.size
     end
   end
 end

data/lib/stribog/compression.rb

@@ -13,7 +13,7 @@ module Stribog
       @hash_vector = hash_vector
     end
 
-    def start
+    def call
       vector = lpsx_func @n, @hash_vector
       vector = func_e vector, @message
       vector = vector ^ @hash_vector
@@ -62,7 +62,7 @@ module Stribog
       BinaryVector.from_byte(
         not_zeros_indexes(vector)
           .inject(0) { |acc, elem| acc ^ MATRIX_A[elem] }
-      ).addition_to(size: 64)
+      ).addition_by_zeros(size: 64)
     end
 
     # rubocop:disable Style/EachWithObject

data/lib/stribog/create_hash.rb

@@ -4,97 +4,127 @@ module Stribog
   #
   # @author WildDima
   class CreateHash
-    attr_reader :vector_adapter, :message_adapter, :message, :digest_length
+    attr_reader :binary_vector, :message_adapter, :message, :digest_length, :message_vector
 
     HASH_LENGTH = 512
 
-    def initialize(message, vector_adapter: BinaryVector, message_adapter: Message)
-      @vector_adapter = vector_adapter
-      @message_adapter = message_adapter
-      @message = message
-      @n = new_binary_vector(Array.new(HASH_LENGTH, 0))
-      @sum = new_binary_vector(Array.new(HASH_LENGTH, 0))
+    def initialize(message, binary_vector: BinaryVector)
+      @binary_vector = binary_vector
+      @message = binary_vector.from_hex(message)
+      @n = binary_vector_field_by
+      @sum = binary_vector_field_by
     end
 
-    def call(digest_length: HASH_LENGTH)
-      @digest_length = digest_length
-      @hash_vector = create_hash_vector
-
-      while message.size > HASH_LENGTH
-        message = new_message_from_bin new_binary_vector(@message.vector[-HASH_LENGTH..-1])
-        message_cut!(sum: @sum, n: @n, message: message, hash_vector: @hash_vector)
-        @message = new_message_from_bin new_binary_vector(@message.vector[0...-HASH_LENGTH])
-      end
-
-      core_hashing!(sum: @sum, n: @n, message: @message, hash_vector: @hash_vector)
-
-      @hash_vector = compress(message: @n, hash_vector: @hash_vector)
+    def call(digest_length = HASH_LENGTH)
+      create_hash_params!(digest_length: digest_length)
+
+      return_hash(
+        final_compression(
+          core_hashing(
+            compact_message(
+              sum: @sum,
+              n: @n,
+              message_vector: message_vector,
+              hash_vector: @hash_vector
+            )
+          )
+        )
+      )
+    end
 
-      @hash_vector = compress(message: @sum, hash_vector: @hash_vector)
+    private
 
-      hash_vector
+    def create_hash_params!(digest_length:)
+      @digest_length = digest_length
+      @hash_vector = create_hash_vector
+      @message_vector = message.dup
     end
 
-    # TODO: MORE DRY
-    def hash_vector
+    def create_hash_vector
       case digest_length
       when 512
-        @hash_vector
+        binary_vector_field_by(size: 512)
       when 256
-        new_binary_vector(@hash_vector[0..255])
+        binary_vector_from_array(Array.new(64, '00000001').join.chars.map(&:to_i))
       else
         raise ArgumentError,
               "digest length must be equal to 256 or 512, not #{digest_length}"
       end
     end
 
-    private
+    def compact_message(sum:, n:, message_vector:, hash_vector:, message_head: nil)
+      if message_vector.size < HASH_LENGTH || !message_head.nil? && message_head.size < HASH_LENGTH
+        return { sum: sum, n: n, message_vector: message_head || message_vector,
+                 hash_vector: hash_vector }
+      end
 
-    def create_hash_vector
+      compact_message(
+        sum: addition_in_ring_to_binary(sum.to_dec, message_vector.to_dec),
+        n: addition_in_ring_to_binary(n.to_dec, slice_message_tail(message_vector).size),
+        message_vector: message_vector,
+        hash_vector: compress(n: n, message: slice_message_tail(message_vector),
+                              hash_vector: hash_vector),
+        message_head: slice_message_head(message_vector)
+      )
+    end
+
+    def slice_message_head(message_vector)
+      binary_vector_from_array(message_vector.vector[0...-HASH_LENGTH])
+    end
+
+    def slice_message_tail(message_vector)
+      binary_vector_from_array(message_vector.vector[-HASH_LENGTH..-1])
+    end
+
+    def core_hashing(sum:, n:, message_vector:, hash_vector:)
+      new_sum = addition_in_ring_to_binary(sum.to_dec,
+                                           message_vector
+                                            .addition_bit_padding(size: HASH_LENGTH)
+                                            .to_dec)
+
+      new_n = addition_in_ring_to_binary(n.to_dec, message_vector.size)
+
+      new_hash_vector = compress(n: n.addition_by_zeros(size: HASH_LENGTH),
+                                 message: message_vector.addition_bit_padding(size: HASH_LENGTH),
+                                 hash_vector: hash_vector)
+
+      { sum: new_sum, n: new_n, hash_vector: new_hash_vector }
+    end
+
+    def final_compression(sum:, n:, hash_vector:)
+      compress(message: sum, hash_vector: compress(message: n, hash_vector: hash_vector))
+    end
+
+    def return_hash(final_vector)
       case digest_length
       when 512
-        new_binary_vector(Array.new(512, 0))
+        final_vector
       when 256
-        new_binary_vector(Array.new(64, '00000001').join.chars.map(&:to_i))
+        binary_vector_from_array(final_vector[0..255])
       else
         raise ArgumentError,
               "digest length must be equal to 256 or 512, not #{digest_length}"
       end
     end
 
-    def message_cut!(sum:, n:, message:, hash_vector:)
-      @hash_vector = compress(n: n, message: message.vector, hash_vector: hash_vector)
-      @n = addition_in_ring_to_binary(n.to_dec, message.vector.size)
-      @sum = addition_in_ring_to_binary(sum.to_dec, message.vector.to_dec)
-    end
-
-    def core_hashing!(sum:, n:, message:, hash_vector:)
-      @hash_vector = compress(n: n.addition_to(size: HASH_LENGTH),
-                              message: message.addition_to(size: HASH_LENGTH),
-                              hash_vector: hash_vector)
-      @n = addition_in_ring_to_binary(n.to_dec, message.size)
-      @sum = addition_in_ring_to_binary(sum.to_dec, message.addition_to(size: HASH_LENGTH).to_dec)
-    end
-
     def addition_in_ring(first, second, ring)
       (first + second) % ring
     end
 
     def addition_in_ring_to_binary(first, second, ring = 2**HASH_LENGTH, size: HASH_LENGTH)
-      vector_adapter.from_byte(addition_in_ring(first, second, ring), size: size)
+      binary_vector.from_byte(addition_in_ring(first, second, ring), size: size)
     end
 
-    def compress(message:, hash_vector:, n: nil)
-      n ||= new_binary_vector(Array.new(HASH_LENGTH, 0))
-      Compression.new(n, message, hash_vector).start
+    def compress(message:, hash_vector:, n: binary_vector_field_by)
+      Compression.new(n, message, hash_vector).call
     end
 
-    def new_message_from_bin(bin)
-      message_adapter.from_bin(bin)
+    def binary_vector_from_array(vector)
+      binary_vector.new(vector)
     end
 
-    def new_binary_vector(vector)
-      vector_adapter.new(vector)
+    def binary_vector_field_by(size: HASH_LENGTH, value: 0)
+      binary_vector_from_array(Array.new(size, value))
     end
   end
 end

data/lib/stribog/version.rb

@@ -1,3 +1,3 @@
 module Stribog
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stribog
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - WildDima
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-01 00:00:00.000000000 Z
+date: 2017-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -103,7 +103,6 @@ files:
 - lib/stribog/compression.rb
 - lib/stribog/create_hash.rb
 - lib/stribog/hash_params.rb
-- lib/stribog/message.rb
 - lib/stribog/version.rb
 - stribog.gemspec
 homepage: https://github.com/WildDima/stribog

data/lib/stribog/message.rb

@@ -1,72 +0,0 @@
-module Stribog
-  # Message
-  #
-  # @author WildDima
-  class Message
-    private_class_method :new
-
-    attr_accessor :message, :vector
-
-    def initialize(message, vector)
-      @message = message
-      @vector = vector
-    end
-
-    class << self
-      def from_bin(bin)
-        new bin_to_hex(bin), bin
-      end
-
-      def from_hex(hex)
-        new hex, hex_to_bin(hex)
-      end
-
-      def from_string(string)
-        new string, BinaryVector.new(string.unpack('B*')[0].chars.map(&:to_i))
-      end
-
-      def from_path(path)
-        file = File.read(path)
-        new file, file.unpack('B*')
-      end
-
-      def hex_to_bin(hex)
-        BinaryVector.new(hex.chars.map do |x|
-                           bin = x.to_i(16).to_s(2)
-                           '0' * (4 - bin.length) + bin
-                         end.join.chars.map(&:to_i))
-      end
-
-      def bin_to_hex(bin)
-        bin.to_dec.to_s(16)
-      end
-    end
-
-    def addition_to(size: 512)
-      return if vector.size >= size
-      (BinaryVector.new([1]) + vector).addition_to(size: 512)
-    end
-
-    def size
-      @vector.size
-    end
-
-    private
-
-    def to_vector(message)
-      BinaryVector.new message.to_bits
-    end
-
-    def to_bits(byteorder: :big)
-      case byteorder
-      when :big
-        message.unpack('B*')
-      when :small
-        message.unpack('b*')
-      else
-        raise ArgumentError,
-              "byteorder must be equal to :big or :small, not: #{byteorder}"
-      end
-    end
-  end
-end