gost_magma 0.1.1

data/lib/gost_magma/magma_cbc.rb

@@ -0,0 +1,44 @@
+module GostMagma
+  class MagmaCbc < Magma
+    def initialize(key, iv)
+      @key = key.dup.force_encoding('BINARY')
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+      
+      @ctxR = iv.dup.force_encoding('BINARY')
+    end
+    
+    def encrypt(data)
+      data_len = data.length
+      outdata = ''
+      (0...(data_len / BlockLengthInBytes)).each do |i|
+        encr_block = data[(i * BlockLengthInBytes)...((i+1) * BlockLengthInBytes)]      
+        (0...BlockLengthInBytes).each do |j|
+          encr_block[j] = (@ctxR[j].ord ^ data[i * BlockLengthInBytes + j].ord).chr
+        end
+        encr_block = self.class.encryptBlock(encr_block, @keys)
+        outdata += encr_block
+        @ctxR = @ctxR[BlockLengthInBytes..-1] + encr_block  
+      end
+      outdata
+    end
+    
+    def decrypt(data)
+      data_len = data.length
+      outdata = ''
+      (0...(data_len / BlockLengthInBytes)).each do |i|
+        encr_block = data[(i * BlockLengthInBytes)...((i+1) * BlockLengthInBytes)]
+        decr_block = self.class.decryptBlock(encr_block, @keys)
+        (0...BlockLengthInBytes).each do |j|
+          decr_block[j] = (@ctxR[j].ord ^ decr_block[j].ord).chr
+        end
+        outdata += decr_block
+        @ctxR = @ctxR[BlockLengthInBytes..-1] + encr_block
+      end
+      outdata
+    end
+    
+  end
+end  

data/lib/gost_magma/magma_cfb.rb

@@ -0,0 +1,146 @@
+module GostMagma
+  class MagmaCfb < Magma
+    def initialize(key, iv, gamma_s)
+      @key = key.dup.force_encoding('BINARY')
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+
+      @gamma_s = gamma_s
+      @ctxR = iv.dup.force_encoding('BINARY')
+      tmp_block = @ctxR[0...BlockLengthInBytes]
+      @gamma_block = self.class.encryptBlock(tmp_block, @keys)
+      @incomplete_block = ''  
+      @incomplete_block_len = 0
+    end
+    
+    def encrypt(data)
+      data_len = data.length
+      left_data_len = data_len
+      outdata = ''
+      if @incomplete_block_len > 0 then      
+        # use old @gamma_block
+        if data_len < @gamma_s - @incomplete_block_len then
+          # incomplete block yet
+          encr_data = data.dup
+          (0...data_len).each do |j|
+            encr_data[j] = (@gamma_block[@incomplete_block_len + j].ord ^ encr_data[j].ord).chr
+          end
+          @incomplete_block_len += data_len
+          @incomplete_block += encr_data
+          return encr_data
+        else
+          encr_data = data[0...(@gamma_s - @incomplete_block_len)]
+          (0...encr_data.length).each do |j|
+            encr_data[j] = (@gamma_block[@incomplete_block_len + j].ord ^ encr_data[j].ord).chr
+          end
+          outdata += encr_data
+          # complete block - gamma update
+          @incomplete_block += encr_data
+          left_data_len -= encr_data.length
+          @ctxR = @ctxR[@gamma_s..-1] + @incomplete_block
+          tmp_block = @ctxR[0...BlockLengthInBytes]
+          @gamma_block = self.class.encryptBlock(tmp_block, @keys)
+          @incomplete_block = ''
+        end
+      end
+      
+      (0...(left_data_len / @gamma_s)).each do |i|
+        if @incomplete_block_len > 0 then
+          encr_data = data[((i + 1) * @gamma_s - @incomplete_block_len)...((i + 2) * @gamma_s - @incomplete_block_len)]
+        else
+          encr_data = data[(i * @gamma_s)...((i + 1) * @gamma_s)]
+        end
+        (0...@gamma_s).each do |j|
+          encr_data[j] = (@gamma_block[j].ord ^ encr_data[j].ord).chr
+        end
+        outdata += encr_data
+        # complete block - gamma update        
+        @ctxR = @ctxR[@gamma_s..-1] + encr_data
+        tmp_block = @ctxR[0...BlockLengthInBytes]
+        @gamma_block = self.class.encryptBlock(tmp_block, @keys)      
+      end
+      
+      left_data_len %= @gamma_s 
+      if left_data_len > 0 then
+        # incomplete block start
+        encr_data = data[-left_data_len..-1]
+        (0...left_data_len).each do |j|
+          encr_data[j] = (@gamma_block[j].ord ^ encr_data[j].ord).chr
+        end
+        outdata += encr_data
+        @incomplete_block_len = left_data_len
+        @incomplete_block = encr_data
+      end
+      outdata
+    end
+    
+    # Use input encrypted text to gamma update    
+    def decrypt(data)
+      data_len = data.length
+      left_data_len = data_len
+      outdata = ''
+      if @incomplete_block_len > 0 then      
+        # use old @gamma_block
+        if data_len < @gamma_s - @incomplete_block_len then
+          # incomplete block yet
+          encr_data = data.dup
+          decr_data = data.dup
+          (0...data_len).each do |j|
+            decr_data[j] = (@gamma_block[@incomplete_block_len + j].ord ^ encr_data[j].ord).chr
+          end
+          @incomplete_block_len += data_len
+          @incomplete_block += encr_data
+          return decr_data
+        else
+          encr_data = data[0...(@gamma_s - @incomplete_block_len)]
+          decr_data = encr_data.dup
+          (0...encr_data.length).each do |j|
+            decr_data[j] = (@gamma_block[@incomplete_block_len + j].ord ^ encr_data[j].ord).chr
+          end
+          outdata += decr_data
+          # complete block - gamma update
+          @incomplete_block += encr_data
+          left_data_len -= encr_data.length
+          @ctxR = @ctxR[@gamma_s..-1] + @incomplete_block
+          tmp_block = @ctxR[0...BlockLengthInBytes]
+          @gamma_block = self.class.encryptBlock(tmp_block, @keys)
+          @incomplete_block = ''
+        end
+      end
+      
+      (0...(left_data_len / @gamma_s)).each do |i|
+        if @incomplete_block_len > 0 then
+          encr_data = data[((i + 1) * @gamma_s - @incomplete_block_len)...((i + 2) * @gamma_s - @incomplete_block_len)]
+        else
+          encr_data = data[(i * @gamma_s)...((i + 1) * @gamma_s)]
+        end
+        decr_data = encr_data.dup
+        (0...@gamma_s).each do |j|
+          decr_data[j] = (@gamma_block[j].ord ^ encr_data[j].ord).chr
+        end
+        outdata += decr_data
+        # complete block - gamma update        
+        @ctxR = @ctxR[@gamma_s..-1] + encr_data
+        tmp_block = @ctxR[0...BlockLengthInBytes]
+        @gamma_block = self.class.encryptBlock(tmp_block, @keys)      
+      end
+      
+      left_data_len %= @gamma_s 
+      if left_data_len > 0 then
+        # incomplete block start
+        encr_data = data[-left_data_len..-1]
+        decr_data = encr_data.dup
+        (0...left_data_len).each do |j|
+          decr_data[j] = (@gamma_block[j].ord ^ encr_data[j].ord).chr
+        end
+        outdata += decr_data
+        @incomplete_block_len = left_data_len
+        @incomplete_block = encr_data
+      end
+      outdata
+    end
+    
+  end
+end  

data/lib/gost_magma/magma_ctr.rb

@@ -0,0 +1,73 @@
+module GostMagma
+  class MagmaCtr < Magma
+    def initialize(key, iv, gamma_s)
+      @key = key.dup.force_encoding('BINARY')
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+      
+      @gamma_s = gamma_s
+      @iv = iv.dup.force_encoding('BINARY')
+      @prev_len = 0
+      @bytes_count = 0
+      @tmp_block = self.class.zeroBlock
+      if @iv.length < BlockLengthInBytes/2 then
+        @iv += self.class.zeroBytes(BlockLengthInBytes/2 - @iv.length)
+      end
+      @counter = @iv[0...(BlockLengthInBytes/2)] 
+      @counter += self.class.zeroBytes(BlockLengthInBytes/2) 
+    end
+    
+    def encrypt(indata)
+      data_len = indata.length
+      outdata = self.class.zeroBytes(data_len)
+      data_index = 0
+      if @prev_len > 0 then
+        if data_len < (@gamma_s - @prev_len) then
+          (0...data_len).each do |j|
+            outdata[j] = (indata[j].ord ^ @tmp_block[j + @prev_len].ord).chr
+          end
+          @prev_len += data_len
+          @bytes_count += data_len
+          return outdata        
+        else
+          (0...(@gamma_s - @prev_len)).each do |j|
+            outdata[j] = (indata[j].ord ^ @tmp_block[j + @prev_len].ord).chr
+          end
+          data_index += @gamma_s - @prev_len
+          @bytes_count += @gamma_s - @prev_len
+          data_len -= @gamma_s - @prev_len
+          self.class.incrementModulo(@counter, BlockLengthInBytes)
+          @prev_len = 0      
+        end
+      end
+      (0...(data_len / @gamma_s)).each do |i|
+        @tmp_block = self.class.encryptBlock(@counter, @keys)
+        (0...@gamma_s).each do |j|
+          outdata[data_index + j] = (indata[data_index + j].ord ^ @tmp_block[j].ord).chr
+        end
+        data_index += @gamma_s
+        @bytes_count += @gamma_s
+        data_len -= @gamma_s
+        self.class.incrementModulo(@counter, BlockLengthInBytes)
+        @prev_len = 0
+      end     
+      if data_len > 0 then
+        @tmp_block = self.class.encryptBlock(@counter, @keys)
+        (0...data_len).each do |j|
+          outdata[data_index + j] = (indata[data_index + j].ord ^ @tmp_block[j].ord).chr
+        end
+        @bytes_count += data_len
+        @prev_len = data_len
+      end
+      return outdata
+    end
+
+    def decrypt(data)
+      encrypt(data)
+    end
+    
+  end
+end
+

data/lib/gost_magma/magma_ctr_acpkm.rb

@@ -0,0 +1,91 @@
+module GostMagma
+  class MagmaCtrAcpkm < Magma
+    def initialize(key, iv, gamma_s, section_N)
+      @key = key.dup.force_encoding('BINARY')
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+
+      @iv = iv.dup.force_encoding('BINARY')
+      @gamma_s = gamma_s
+      @section_N = section_N
+      @gamma_bytes = 0
+      @section_bytes = 0
+      @block_bytes = 0
+      @bytes_count = 0
+      if @iv.length < BlockLengthInBytes/2 then
+        @iv += 0.chr * (BlockLengthInBytes/2 - @iv.length)
+      end
+      @counter = @iv[0...(BlockLengthInBytes/2)] 
+      @counter += 0.chr * (BlockLengthInBytes/2) 
+      @gamma = self.class.encryptBlock(@counter, @keys)
+      self.class.incrementModulo(@counter, BlockLengthInBytes)           
+    end
+    
+    def encrypt(indata)
+      data_len = indata.length
+      if data_len > 0 then
+        outdata = self.class.zeroBytes(data_len)
+        (0...data_len).each do |i|
+          if @section_bytes == @section_N then
+            acpkmCtrKey
+            @gamma = self.class.encryptBlock(@counter, @keys)
+            self.class.incrementModulo(@counter, BlockLengthInBytes)                  
+            @section_bytes = 0
+            @block_bytes = 0
+            @gamma_bytes = 0         
+          else
+            if @gamma_bytes == @gamma_s then
+              @gamma = self.class.encryptBlock(@counter, @keys)
+              self.class.incrementModulo(@counter, BlockLengthInBytes)              
+              @gamma_bytes = 0
+            end
+            if @block_bytes == BlockLengthInBytes then
+              @block_bytes = 0
+            end        
+          end                
+          outdata[i] = (indata[i].ord ^ @gamma[@gamma_bytes].ord).chr
+          @gamma_bytes += 1
+          @block_bytes += 1
+          @section_bytes += 1
+          @bytes_count += 1
+        end
+        return outdata
+      else
+        return ''
+      end
+    end
+    
+    def decrypt(indata)
+      encrypt(indata)
+    end
+    
+    protected
+    
+    W1 = [
+      0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87
+    ].pack('C*').freeze  
+    W2 = [
+      0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f
+    ].pack('C*').freeze  
+    W3 = [
+      0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97
+    ].pack('C*').freeze  
+    W4 = [
+      0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f
+    ].pack('C*').freeze  
+    
+    def acpkmCtrKey
+      @key = self.class.encryptBlock(W1, @keys) + 
+        self.class.encryptBlock(W2, @keys) +
+        self.class.encryptBlock(W3, @keys) +
+        self.class.encryptBlock(W4, @keys)
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+    end
+    
+  end
+end

data/lib/gost_magma/magma_ecb.rb

@@ -0,0 +1,47 @@
+module GostMagma
+  class MagmaEcb < Magma
+    # key = 32-byte string
+    def initialize(key)
+      @key = key.dup.force_encoding('BINARY')
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+    end
+    
+    # returns encrypted text string
+    def encrypt(plain_text)
+      len = plain_text.length
+      if (len == 0) || (len % BlockLengthInBytes > 0) then
+        puts "(plain_text.length == 0) || (plain_text.length % BlockLengthInBytes > 0)"
+        return nil
+      end
+      blocks = plain_text.scan(/.{8}/m)
+      encrypted_blocks = []
+      blocks.each do |block|
+        encryptedBlock = self.class.encryptBlock(block, @keys)
+        encrypted_blocks << encryptedBlock
+      end
+      output = encrypted_blocks.join
+      return output
+    end
+    
+    # returns decrypted text string
+    def decrypt(encrypted_text)
+      len = encrypted_text.length
+      if (len == 0) || (len % BlockLengthInBytes > 0) then
+        puts "(encrypted_text.length == 0) || (encrypted_text.length % BlockLengthInBytes > 0)"
+        return nil
+      end
+      blocks = encrypted_text.scan(/.{8}/m)
+      decrypted_blocks = []
+      blocks.each do |block|
+        decryptedBlock = self.class.decryptBlock(block, @keys)
+        decrypted_blocks << decryptedBlock
+      end
+      output = decrypted_blocks.join
+      return output
+    end
+
+  end
+end

data/lib/gost_magma/magma_key_exp_imp.rb

@@ -0,0 +1,22 @@
+module GostMagma
+  class MagmaKeyExpImp < Magma
+    def self.export(key, key_mac, key_enc, iv)
+      mac = MagmaOmac.new(key_mac, BlockLengthInBytes).update(iv+key).final
+      ctr = MagmaCtr.new(key_enc, iv, BlockLengthInBytes)
+      encr_key = ctr.encrypt(key)
+      encr_mac = ctr.encrypt(mac)
+      encr_key += encr_mac
+    end
+    
+    def self.import(encr_key, key_mac, key_enc, iv)
+      buf = MagmaCtr.new(key_enc, iv, BlockLengthInBytes).decrypt(encr_key)
+      decr_key = buf[0...-BlockLengthInBytes]
+      decr_mac = buf[decr_key.length..-1]
+      mac = MagmaOmac.new(key_mac, BlockLengthInBytes).update(iv+decr_key).final
+      if mac != decr_mac then
+        decr_key = nil
+      end
+      decr_key
+    end
+  end
+end  

data/lib/gost_magma/magma_ofb.rb

@@ -0,0 +1,79 @@
+module GostMagma
+  class MagmaOfb < Magma
+    def initialize(key, iv, gamma_s)
+      @key = key.dup.force_encoding('BINARY')
+      @keys = []
+      (0...8).each do |i|
+        @keys << self.class.uint8ToUint32(@key[i*4...(i+1)*4].reverse)
+      end
+      
+      @gamma_s = gamma_s
+      @ctxR = iv.dup.force_encoding('BINARY')
+      tmp_block = @ctxR[0...BlockLengthInBytes]
+      @gamma_block = self.class.encryptBlock(tmp_block, @keys)
+      @ctxR = @ctxR[BlockLengthInBytes..-1] + @gamma_block
+      @incomplete_block_len = 0
+    end
+    
+    def encrypt(data)
+      data_len = data.length
+      outdata = ''
+      left_data_len = data_len
+      if @incomplete_block_len > 0 then      
+        # use old @gamma_block
+        if data_len < @gamma_s - @incomplete_block_len then
+          # incomplete block yet
+          outdata = data.dup
+          (0...data_len).each do |j|
+            outdata[j] = (@gamma_block[@incomplete_block_len + j].ord ^ outdata[j].ord).chr
+          end
+          @incomplete_block_len += data_len
+          return outdata
+        else
+          outdata = data[0...(@gamma_s - @incomplete_block_len)]
+          (0...outdata.length).each do |j|
+            outdata[j] = (@gamma_block[@incomplete_block_len + j].ord ^ outdata[j].ord).chr
+          end
+          # complete block - update gamma block
+          tmp_block = @ctxR[0...BlockLengthInBytes]
+          @gamma_block = self.class.encryptBlock(tmp_block, @keys)
+          @ctxR = @ctxR[BlockLengthInBytes..-1] + @gamma_block
+          left_data_len -= outdata.length
+        end
+      end
+            
+      (0...(left_data_len / @gamma_s)).each do |i|
+        if @incomplete_block_len > 0 then
+          encr_data = data[((i + 1) * @gamma_s - @incomplete_block_len)...((i + 2) * @gamma_s - @incomplete_block_len)]
+        else
+          encr_data = data[(i * @gamma_s)...((i + 1) * @gamma_s)]
+        end
+        (0...@gamma_s).each do |j|
+          encr_data[j] = (@gamma_block[j].ord ^ encr_data[j].ord).chr
+        end
+        outdata += encr_data
+        # complete block - update gamma block        
+        tmp_block = @ctxR[0...BlockLengthInBytes]
+        @gamma_block = self.class.encryptBlock(tmp_block, @keys)
+        @ctxR = @ctxR[BlockLengthInBytes..-1] + @gamma_block
+        left_data_len -= @gamma_s
+      end
+            
+      if left_data_len > 0 then
+        # incomplete block start
+        encr_data = data[-left_data_len..-1]
+        (0...left_data_len).each do |j|
+          encr_data[j] = (@gamma_block[j].ord ^ encr_data[j].ord).chr
+        end
+        outdata += encr_data
+        @incomplete_block_len = left_data_len
+      end
+      outdata
+    end
+    
+    def decrypt(data)
+      encrypt(data)
+    end
+    
+  end
+end