stribog 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc696f1b18cb6ec04fce7cf3cc740be1eed204a6
-  data.tar.gz: ad56184c6dae90af01b9edd83424e7ba1864e2d4
+  metadata.gz: 81cda8678e16f6f25d1cc99e89c31cae61c7e389
+  data.tar.gz: 414fe5e18f7909b12649582b18d4b0af7bb2cfcc
 SHA512:
-  metadata.gz: e02b4f9c61c008e4d0a4b413c0739d8866d645d12152829fd6fda289c524e2baba94e787ba40c04a1734a80e33d9ad70f8c1df2378e493a6e885792902fadafa
-  data.tar.gz: fde879defcd83fb2fb86910fe2c2b2c3177cde3c3580db70551573d6870073b5dcfeb863cd02a7b8854609adac733b4347f592a839cd9e0b9b20043e9109e8ac
+  metadata.gz: cdb8f9ff439e21593f0cc918e37141c0f2d31cca11123f61a257c313be5e86fb0d609bb6154334d2273f191eb14c3dac500c3192dd672b0c5d40f879b1e0145c
+  data.tar.gz: a53ade4b91a890313fedc0f0682f9a9888a0c181fe860effb3b7d854d1c5116234f2b79773d48293b26f8f5602183c27632863601aea4bdec603c5923d6f9f63

data/.rubocop.yml

@@ -13,7 +13,7 @@ Metrics/MethodLength:
   Max: 13
 
 Metrics/AbcSize:
-  Max: 20
+  Max: 25
 
 Metrics/ClassLength:
-  Max: 120
+  Max: 120

data/README.rdoc

@@ -28,10 +28,14 @@ Or install it yourself as:
   hash = Stribog::CreateHash.new('ruby')
 
   # for 256 bit
-  hash.(256).to_hex #=> "cde7864b760a690f4ec24ffe5c66bd2c00db843e9cf1b82b6c467dba5a7846a7"
+  hash.(256).hex #=> "cde7864b760a690f4ec24ffe5c66bd2c00db843e9cf1b82b6c467dba5a7846a7"
+  hash.(256).base64
+  hash.(256).pack
 
   # for 512 bit
-  hash.(512).to_hex #=> "f0dafc0703f801d1ecbe7ff246808d07507f67879eaacf887ba041336fd51e0a964f00470ed0eedb0378a39e019eb308876ea8c84bb89e2c35159fb6dbbdc598"
+  hash.(512).hex #=> "f0dafc0703f801d1ecbe7ff246808d07507f67879eaacf887ba041336fd51e0a964f00470ed0eedb0378a39e019eb308876ea8c84bb89e2c35159fb6dbbdc598"
+  hash.(512).base64
+  hash.(512).pack
 
 === Contributing
 

data/lib/stribog.rb

@@ -1,11 +1,23 @@
 require 'stribog/version'
+# require 'pry'
+# require 'pry-byebug'
 # Stribog gost
 #
 # @author WildDima
 module Stribog
   require_relative './stribog/create_hash'
   require_relative './stribog/hash_params'
-  require_relative './stribog/compression'
-  require_relative './stribog/binary_vector'
+  require_relative './stribog/compression_func'
   require_relative './stribog/digest'
+  require_relative './stribog/byte_vector'
+  require_relative './stribog/stage/base'
+  require_relative './stribog/stage/initial'
+  require_relative './stribog/stage/compression'
+  require_relative './stribog/stage/final'
+
+  HASH_LENGTH = 512
+
+  def self.vector
+    ByteVector
+  end
 end

data/lib/stribog/byte_vector.rb

@@ -0,0 +1,96 @@
+module Stribog
+  # byte_array
+  #
+  # @author WildDima
+  class ByteVector
+    include Enumerable
+
+    attr_reader :vector
+
+    def self.convert(vector)
+      case vector
+      when String
+        new(vector.unpack('C*'))
+      when Numeric
+        # TODO: REFACTOR
+        bin = vector.to_s(2)
+        size = 2**Math.log2(vector.size * 8).ceil
+        new(['0' * (size - bin.size) + bin].pack('B*').unpack('C*'))
+      end
+    end
+
+    def initialize(vector)
+      @vector = vector
+    end
+
+    def ^(other)
+      vec = [other, self].sort_by(&:size).reverse.map(&:reverse)
+      self.class.new vec[0].map
+                           .with_index { |bit, index| bit ^ (vec[1][index] || 0) }.reverse
+    end
+
+    def +(other)
+      self.class.new vector + other.to_a
+    end
+
+    def addition(size: 64)
+      return self if vector.size >= size
+      self.class.new(Array.new(size - vector.size, 0) + vector)
+    end
+
+    def padding(size: 64)
+      return self if vector.size >= size
+      # (self.class.new([1]) + vector).addition_by_zeros(size: 512)
+      self.class.new([1] + vector).addition(size: size)
+    end
+
+    def byte8
+      @byte8 ||= vector.pack('C*').unpack('Q*')
+    end
+
+    def bit64
+      @bit64 ||= byte8.map { |b| [b].pack('Q*').unpack('B*') }.flatten
+    end
+
+    def to_dec
+      # to_s.to_i(2)
+      vector.pack('C*').unpack('B*').first.to_i(2)
+    end
+
+    def to_hex
+      to_s.to_i(2).to_s(16)
+    end
+
+    def to_s
+      # vector.pack('C*')
+      vector
+    end
+
+    def size
+      @size ||= vector.size
+    end
+
+    def [](index)
+      vector[index]
+    end
+
+    def each
+      return vector.each unless block_given?
+      vector.each do |v|
+        yield(v)
+      end
+    end
+
+    def to_a
+      vector
+    end
+
+    def zero?
+      vector.any?(&:zero?)
+    end
+
+    def reverse
+      self.class.new vector.reverse
+    end
+  end
+end

data/lib/stribog/{compression.rb → compression_func.rb}

@@ -3,7 +3,7 @@ module Stribog
   #
   # Class implements compression function of GOST R 34.11-2012 algorithm.
   # @author WildDima
-  class Compression
+  class CompressionFunc
     include HashParams
 
     def initialize(n, message, hash_vector)
@@ -32,36 +32,34 @@ module Stribog
     end
 
     def replacement_pi(vector)
-      BinaryVector.from_byte_array vector.to_byte_array
-                                         .map { |byte| PI[byte] }
+      ByteVector.new vector.map { |byte| PI[byte] }
     end
 
     # rubocop:disable Style/EachWithObject
     def permutation_t(vector)
-      BinaryVector.from_byte_array(
-        vector.to_byte_array
-              .each.with_index.inject([]) do |b_arr, (byte, index)|
-                b_arr[T[index]] = byte
-                b_arr
-              end
+      ByteVector.new(
+        vector.each.with_index.inject([]) do |b_arr, (byte, index)|
+          b_arr[T[index]] = byte
+          b_arr
+        end.map(&:to_i)
       )
     end
     # rubocop:enable Style/EachWithObject
 
     def linear_transformation(vector)
-      BinaryVector.from_byte_array(
-        vector.each_slice(64).map do |byte8|
-          small_linear_transformation(BinaryVector.new(byte8)).to_dec
-        end,
-        size: 64
+      ByteVector.new(
+        vector.bit64.map do |byte8|
+          small_linear_transformation(byte8)
+        end.flatten
       )
     end
 
     def small_linear_transformation(vector)
-      BinaryVector.from_byte(
+      # REFACTOR
+      ByteVector.convert(
         not_zeros_indexes(vector)
           .inject(0) { |acc, elem| acc ^ MATRIX_A[elem] }
-      ).addition_by_zeros(size: 64)
+      ).to_a
     end
 
     # rubocop:disable Style/EachWithObject
@@ -70,8 +68,7 @@ module Stribog
                 .inject(v1: first_vector.dup,
                         v2: second_vector.dup) do |vs, const|
         vs[:v2] = lpsx_func(vs[:v1], vs[:v2])
-        vs[:v1] = lpsx_func(vs[:v1], BinaryVector.from_byte(const.to_i(16),
-                                                            size: 512))
+        vs[:v1] = lpsx_func(vs[:v1], ByteVector.convert(const))
         vs
       end
       vectors[:v1] ^ vectors[:v2]
@@ -79,8 +76,8 @@ module Stribog
     # rubocop:enable Style/EachWithObject
 
     def not_zeros_indexes(vector)
-      vector.map.with_index do |bit, index|
-        next if bit.zero?
+      vector.chars.map.with_index do |bit, index|
+        next if bit == '0'
         index
       end.compact
     end

data/lib/stribog/create_hash.rb

@@ -27,11 +27,12 @@ module Stribog
     #   digest.message_vector
     # @return [BinaryVector] binary representation of message
     attr_reader :message_vector
+    attr_reader :vector
 
-    HASH_LENGTH = 512
-
-    def initialize(message)
+    def initialize(message, transformation = :from_hex, vector = Stribog.vector)
       @message = message
+      @transformation = transformation
+      @vector = vector
     end
 
     # Create digest of {#message}. Default equal to 512.
@@ -41,140 +42,38 @@ module Stribog
     #   Stribog::CreateHash.new('ruby').call(512)
     # @author WildDima
     def call(digest_length = HASH_LENGTH)
-      prepare_hash_params!(digest_length: digest_length)
-
+      @digest_length = digest_length
       return_hash(
-        final_compression(
-          core_hashing(
-            compact_message(
-              sum: @sum,
-              n: @n,
-              message_vector: message_vector,
-              hash_vector: @hash_vector
-            )
+        Stage::Final.new(
+          Stage::Compression.new(
+            Stage::Initial.new(self)
           )
-        )
+        ).call
       )
     end
 
     private
 
-    # Create instance vars for hashing
-    def prepare_hash_params!(digest_length:)
-      @n = binary_vector_field_by
-      @sum = binary_vector_field_by
-      @digest_length = digest_length
-      @hash_vector = create_hash_vector
-      @message_vector = binary_vector.from_hex(message)
-    end
-
-    # Create hash_vector for hashing
-    def create_hash_vector
-      case digest_length
-      when 512
-        binary_vector_field_by(size: 512)
-      when 256
-        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
-
-    # Method, which slices longer messages, and hashings them by parts.
-    def compact_message(sum:, n:, message_vector:, hash_vector:, message_head: nil)
-      current_vector = message_head || message_vector
-      if current_vector.size < HASH_LENGTH
-        return { sum: sum, n: n, message_vector: current_vector,
-                 hash_vector: hash_vector }
-      end
-
-      compact_message(
-        sum: addition_in_ring_to_binary(sum.to_dec, current_vector.to_dec),
-        n: addition_in_ring_to_binary(n.to_dec, slice_message_tail(current_vector).size),
-        message_vector: message_vector,
-        hash_vector: compress(n: n, message: slice_message_tail(current_vector),
-                              hash_vector: hash_vector),
-        message_head: slice_message_head(current_vector)
-      )
-    end
-
-    # Method, which slices head of message
-    def slice_message_head(message_vector)
-      binary_vector_from_array(message_vector.vector[0...-HASH_LENGTH])
-    end
-
-    # Method, which slices head of tail
-    def slice_message_tail(message_vector)
-      binary_vector_from_array(message_vector.vector[-HASH_LENGTH..-1])
-    end
-
-    # Method, which implements main hashing
-    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
-
-    # Method, which implements final compression
-    def final_compression(sum:, n:, hash_vector:)
-      compress(message: sum, hash_vector: compress(message: n, hash_vector: hash_vector))
-    end
-
     # Method, which return digest, dependent on them length
     def return_hash(final_vector)
       case digest_length
       when 512
         create_digest(final_vector)
       when 256
-        create_digest(binary_vector_from_array(final_vector[0..255]))
+        create_digest(vector_from_array(final_vector[0..31]))
       else
         raise ArgumentError,
               "digest length must be equal to 256 or 512, not #{digest_length}"
       end
     end
 
-    # Method implements addition in ring
-    def addition_in_ring(first, second, ring)
-      (first + second) % ring
-    end
-
-    # Method implements addition in ring and creates binary vector
-    def addition_in_ring_to_binary(first, second, ring = 2**HASH_LENGTH, size: HASH_LENGTH)
-      binary_vector.from_byte(addition_in_ring(first, second, ring), size: size)
-    end
-
-    # Compression method
-    def compress(message:, hash_vector:, n: binary_vector_field_by)
-      Compression.new(n, message, hash_vector).call
-    end
-
-    # Method creates binary vector from array
-    def binary_vector_from_array(vector)
-      binary_vector.new(vector)
-    end
-
-    # Method creates binary vector and fields it by passed values
-    def binary_vector_field_by(size: HASH_LENGTH, value: 0)
-      binary_vector_from_array(Array.new(size, value))
+    def vector_from_array(v)
+      vector.new(v)
     end
 
     # Create new instance of Digest
-    def create_digest(binary_vector)
-      digest.new(binary_vector: binary_vector)
-    end
-
-    def binary_vector
-      @binary_vector ||= BinaryVector
+    def create_digest(vector)
+      digest.new(vector: vector)
     end
 
     def digest

data/lib/stribog/digest.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 module Stribog
   # Digest
   #
@@ -12,18 +14,31 @@ module Stribog
     # @example
     #   digest.binary
     # @return [Array] binary representation of digest
-    attr_reader :binary
+    attr_reader :vector
+    attr_reader :dec
     # Contains hex value of hash
     #
     # @api public
     # @example
     #   digest.hex
     # @return [String] hex representation of digest
-    attr_reader :hex
 
-    def initialize(binary_vector:)
-      @binary = binary_vector.vector
-      @hex = binary_vector.to_hex
+    def initialize(vector:)
+      @vector = vector
+      @dec = vector.to_dec
+    end
+
+    def hex
+      dec.to_s(16)
+    end
+    alias to_hex hex
+
+    def base64
+      Base64.encode64(dec.to_s)
+    end
+
+    def pack(meaning = 'C*')
+      binary.to_byte_array.pack(meaning)
     end
   end
 end

data/lib/stribog/hash_params.rb

@@ -38,17 +38,17 @@ module Stribog
                 0x70a6a56e2440598e, 0x3853dc371220a247, 0x1ca76e95091051ad, 0x0edd37c48a08a6d8,
                 0x07e095624504536c, 0x8d70c431ac02a736, 0xc83862965601dd1b, 0x641c314b2b8ee083].freeze
 
-    CONSTANTS_C = %w(b1085bda1ecadae9ebcb2f81c0657c1f2f6a76432e45d016714eb88d7585c4fc4b7ce09192676901a2422a08a460d31505767436cc744d23dd806559f2a64507
-                     6fa3b58aa99d2f1a4fe39d460f70b5d7f3feea720a232b9861d55e0f16b501319ab5176b12d699585cb561c2db0aa7ca55dda21bd7cbcd56e679047021b19bb7
-                     f574dcac2bce2fc70a39fc286a3d843506f15e5f529c1f8bf2ea7514b1297b7bd3e20fe490359eb1c1c93a376062db09c2b6f443867adb31991e96f50aba0ab2
-                     ef1fdfb3e81566d2f948e1a05d71e4dd488e857e335c3c7d9d721cad685e353fa9d72c82ed03d675d8b71333935203be3453eaa193e837f1220cbebc84e3d12e
-                     4bea6bacad4747999a3f410c6ca923637f151c1f1686104a359e35d7800fffbdbfcd1747253af5a3dfff00b723271a167a56a27ea9ea63f5601758fd7c6cfe57
-                     ae4faeae1d3ad3d96fa4c33b7a3039c02d66c4f95142a46c187f9ab49af08ec6cffaa6b71c9ab7b40af21f66c2bec6b6bf71c57236904f35fa68407a46647d6e
-                     f4c70e16eeaac5ec51ac86febf240954399ec6c7e6bf87c9d3473e33197a93c90992abc52d822c3706476983284a05043517454ca23c4af38886564d3a14d493
-                     9b1f5b424d93c9a703e7aa020c6e41414eb7f8719c36de1e89b4443b4ddbc49af4892bcb929b069069d18d2bd1a5c42f36acc2355951a8d9a47f0dd4bf02e71e
-                     378f5a541631229b944c9ad8ec165fde3a7d3a1b258942243cd955b7e00d0984800a440bdbb2ceb17b2b8a9aa6079c540e38dc92cb1f2a607261445183235adb
-                     abbedea680056f52382ae548b2e4f3f38941e71cff8a78db1fffe18a1b3361039fe76702af69334b7a1e6c303b7652f43698fad1153bb6c374b4c7fb98459ced
-                     7bcd9ed0efc889fb3002c6cd635afe94d8fa6bbbebab076120018021148466798a1d71efea48b9caefbacd1d7d476e98dea2594ac06fd85d6bcaa4cd81f32d1b
-                     378ee767f11631bad21380b00449b17acda43c32bcdf1d77f82012d430219f9b5d80ef9d1891cc86e71da4aa88e12852faf417d5d9b21b9948bc924af11bd720).freeze
+    CONSTANTS_C = [0xb1085bda1ecadae9ebcb2f81c0657c1f2f6a76432e45d016714eb88d7585c4fc4b7ce09192676901a2422a08a460d31505767436cc744d23dd806559f2a64507,
+                   0x6fa3b58aa99d2f1a4fe39d460f70b5d7f3feea720a232b9861d55e0f16b501319ab5176b12d699585cb561c2db0aa7ca55dda21bd7cbcd56e679047021b19bb7,
+                   0xf574dcac2bce2fc70a39fc286a3d843506f15e5f529c1f8bf2ea7514b1297b7bd3e20fe490359eb1c1c93a376062db09c2b6f443867adb31991e96f50aba0ab2,
+                   0xef1fdfb3e81566d2f948e1a05d71e4dd488e857e335c3c7d9d721cad685e353fa9d72c82ed03d675d8b71333935203be3453eaa193e837f1220cbebc84e3d12e,
+                   0x4bea6bacad4747999a3f410c6ca923637f151c1f1686104a359e35d7800fffbdbfcd1747253af5a3dfff00b723271a167a56a27ea9ea63f5601758fd7c6cfe57,
+                   0xae4faeae1d3ad3d96fa4c33b7a3039c02d66c4f95142a46c187f9ab49af08ec6cffaa6b71c9ab7b40af21f66c2bec6b6bf71c57236904f35fa68407a46647d6e,
+                   0xf4c70e16eeaac5ec51ac86febf240954399ec6c7e6bf87c9d3473e33197a93c90992abc52d822c3706476983284a05043517454ca23c4af38886564d3a14d493,
+                   0x9b1f5b424d93c9a703e7aa020c6e41414eb7f8719c36de1e89b4443b4ddbc49af4892bcb929b069069d18d2bd1a5c42f36acc2355951a8d9a47f0dd4bf02e71e,
+                   0x378f5a541631229b944c9ad8ec165fde3a7d3a1b258942243cd955b7e00d0984800a440bdbb2ceb17b2b8a9aa6079c540e38dc92cb1f2a607261445183235adb,
+                   0xabbedea680056f52382ae548b2e4f3f38941e71cff8a78db1fffe18a1b3361039fe76702af69334b7a1e6c303b7652f43698fad1153bb6c374b4c7fb98459ced,
+                   0x7bcd9ed0efc889fb3002c6cd635afe94d8fa6bbbebab076120018021148466798a1d71efea48b9caefbacd1d7d476e98dea2594ac06fd85d6bcaa4cd81f32d1b,
+                   0x378ee767f11631bad21380b00449b17acda43c32bcdf1d77f82012d430219f9b5d80ef9d1891cc86e71da4aa88e12852faf417d5d9b21b9948bc924af11bd720].freeze
   end
 end

data/lib/stribog/stage/base.rb

@@ -0,0 +1,62 @@
+module Stribog
+  # Stage
+  #
+  # @author WildDima
+  module Stage
+    # Base
+    #
+    # @author WildDima
+    class Base
+      attr_reader :prev_stage
+      attr_reader :vector
+      attr_accessor :n
+      attr_accessor :sum
+      attr_accessor :digest_length
+      attr_accessor :hash_vector
+      attr_accessor :message_vector
+      attr_accessor :message_head
+      attr_accessor :current_vector
+
+      def initialize(prev_stage, vector = Stribog.vector)
+        @prev_stage = prev_stage
+        @vector = vector
+      end
+
+      def call
+        raise NotImplementedYet
+      end
+
+      protected
+
+      def prev_stage_call
+        @prev_stage_call ||= prev_stage.call
+      end
+
+      def field_vector(value:, size: 64)
+        vector.new(Array.new(size, value))
+      end
+
+      def empty_vector(size: 64)
+        field_vector(value: 0, size: size)
+      end
+
+      def slice_message_head(message_vector)
+        vector.new(message_vector.vector[0...-HASH_LENGTH / 8])
+      end
+
+      # Method, which slices head of tail
+      def slice_message_tail(message_vector)
+        vector.new(message_vector.vector[-HASH_LENGTH / 8..-1])
+      end
+
+      # Compression method
+      def compress(message:, hash_vector:, n: empty_vector)
+        CompressionFunc.new(n, message, hash_vector).call
+      end
+
+      def addition_in_ring(first, second, ring = 2**HASH_LENGTH)
+        vector.convert((first + second) % ring)
+      end
+    end
+  end
+end

data/lib/stribog/stage/compression.rb

@@ -0,0 +1,53 @@
+module Stribog
+  # BinaryVector
+  #
+  # @author WildDima
+  module Stage
+    # Compression
+    #
+    # @author WildDima
+    class Compression < Base
+      def call
+        set_params
+        compression
+      end
+
+      private
+
+      def set_params
+        @n = prev_stage_call[:n]
+        @sum = prev_stage_call[:sum]
+        @digest_length = prev_stage_call[:digest_length]
+        @hash_vector = prev_stage_call[:hash_vector]
+        @message_vector = prev_stage_call[:message_vector]
+        @message_head = nil
+      end
+
+      def return_params
+        {
+          n: n,
+          sum: sum,
+          digest_length: digest_length,
+          hash_vector: hash_vector,
+          message_vector: current_vector
+        }
+      end
+
+      def compression
+        self.current_vector = message_head || message_vector
+        return return_params if current_vector.size * 8 < HASH_LENGTH
+        transformation
+        compression
+      end
+
+      def transformation
+        self.hash_vector = compress(n: n,
+                                    message: slice_message_tail(current_vector),
+                                    hash_vector: hash_vector)
+        self.sum = addition_in_ring(sum.to_dec, current_vector.to_dec)
+        self.n = addition_in_ring(n.to_dec, slice_message_tail(current_vector).size * 8)
+        self.message_head = slice_message_head(current_vector)
+      end
+    end
+  end
+end

data/lib/stribog/stage/final.rb

@@ -0,0 +1,37 @@
+module Stribog
+  # BinaryVector
+  #
+  # @author WildDima
+  module Stage
+    # Final
+    #
+    # @author WildDima
+    class Final < Base
+      def call
+        set_params
+        final
+      end
+
+      private
+
+      def set_params
+        @n = prev_stage_call[:n]
+        @sum = prev_stage_call[:sum]
+        @digest_length = prev_stage_call[:digest_length]
+        @hash_vector = prev_stage_call[:hash_vector]
+        @message_vector = prev_stage_call[:message_vector]
+        @message_head = nil
+      end
+
+      def final
+        self.hash_vector = compress(n: n.addition(size: HASH_LENGTH / 8),
+                                    message: message_vector.padding,
+                                    hash_vector: hash_vector)
+        self.sum = addition_in_ring(sum.to_dec, message_vector.padding.to_dec)
+        self.n = addition_in_ring(n.to_dec, message_vector.size * 8)
+
+        compress(message: sum, hash_vector: compress(message: n, hash_vector: hash_vector))
+      end
+    end
+  end
+end

data/lib/stribog/stage/initial.rb

@@ -0,0 +1,47 @@
+module Stribog
+  # BinaryVector
+  #
+  # @author WildDima
+  module Stage
+    # Initial
+    #
+    # @author WildDima
+    class Initial < Base
+      def call
+        return_params
+      end
+
+      private
+
+      def return_params
+        {
+          n: empty_vector,
+          sum: empty_vector,
+          digest_length: digest_length,
+          hash_vector: hash_vector,
+          message_vector: message_vector
+        }
+      end
+
+      def hash_vector
+        case digest_length
+        when 512
+          empty_vector
+        when 256
+          field_vector(value: 1)
+        else
+          raise ArgumentError,
+                "digest length must be equal to 256 or 512, not #{digest_length}"
+        end
+      end
+
+      def digest_length
+        @digest_length ||= prev_stage.digest_length
+      end
+
+      def message_vector
+        @message_vector ||= vector.convert(prev_stage.message)
+      end
+    end
+  end
+end

data/lib/stribog/version.rb

@@ -1,3 +1,3 @@
 module Stribog
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/stribog.gemspec

@@ -34,5 +34,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rubocop", "~> 0.45.0"
-  spec.add_development_dependency "byebug", "~> 9.0"
+  spec.add_development_dependency "pry", "~> 0.10.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stribog
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - WildDima
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-04 00:00:00.000000000 Z
+date: 2017-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,19 +67,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.45.0
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: 0.10.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '9.0'
+        version: 0.10.4
 description: 
 email:
 - dtopornin@gmail.com
@@ -99,11 +99,15 @@ files:
 - bin/console
 - bin/setup
 - lib/stribog.rb
-- lib/stribog/binary_vector.rb
-- lib/stribog/compression.rb
+- lib/stribog/byte_vector.rb
+- lib/stribog/compression_func.rb
 - lib/stribog/create_hash.rb
 - lib/stribog/digest.rb
 - lib/stribog/hash_params.rb
+- lib/stribog/stage/base.rb
+- lib/stribog/stage/compression.rb
+- lib/stribog/stage/final.rb
+- lib/stribog/stage/initial.rb
 - lib/stribog/version.rb
 - stribog.gemspec
 homepage: https://github.com/WildDima/stribog

data/lib/stribog/binary_vector.rb

@@ -1,105 +0,0 @@
-module Stribog
-  # BinaryVector
-  #
-  # @author WildDima
-  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_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)
-      @vector = vector
-      raise 'NotBinaryError' unless binary?
-    end
-
-    def ^(other)
-      raise 'DimensionError' unless according_dimension?(other)
-      self.class.new vector.map.with_index { |bit, index| bit ^ other[index] }
-    end
-
-    def +(other)
-      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_bit_padding(size: 512)
-      return self if vector.size >= size
-      (self.class.new([1]) + vector).addition_by_zeros(size: 512)
-    end
-
-    def to_dec
-      to_s.to_i(2)
-    end
-
-    def to_hex
-      to_s.to_i(2).to_s(16)
-    end
-
-    def to_s
-      vector.join
-    end
-
-    def size
-      vector.size
-    end
-
-    def [](index)
-      vector[index]
-    end
-
-    def each
-      vector.each do |v|
-        yield(v)
-      end
-    end
-
-    def to_a
-      vector
-    end
-
-    def to_byte_array
-      raise 'DimensionError' unless (vector.size % 8).zero?
-      vector.each_slice(8).map { |byte| byte.join.to_i(2) }
-    end
-
-    def zero?
-      to_dec.zero?
-    end
-
-    private
-
-    def binary?
-      vector.all? { |el| [0, 1].include? el }
-    end
-
-    def according_dimension?(second_vector)
-      vector.size == second_vector.size
-    end
-  end
-end