gost_magma 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd350e44bcc1d1a5292bb8c55bc4b3c823642a17
+  data.tar.gz: a5cd6e5ad70cf28dc9b488b4cd6bd19f0adaa5d8
+SHA512:
+  metadata.gz: e4123d9e2d4b88bbae6a8e2803eb9994cecccfc602dab301e90a439e5b17cdd2fe1bf0adb780a39914c002d56ce577ee19c837f9e36765f58d29ccf6a3cd26e9
+  data.tar.gz: 2cc20c75e00a0b34d88082c161c279fbb1a9be4d8cda253c718e4d94707562a00580ea3246498c0b6c8e326d63700e77a1b243cd5cf6a5f19a2c7853db84a873

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.4.5
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in gost_magma.gemspec
+gemspec
+
+gem 'minitest-reporters', '1.2.0'

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    gost_magma (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.3)
+    minitest (5.11.3)
+    minitest-reporters (1.2.0)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    rake (10.5.0)
+    ruby-progressbar (1.10.0)
+
+PLATFORMS
+  x64-mingw32
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  gost_magma!
+  minitest (~> 5.0)
+  minitest-reporters (= 1.2.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 vblazhnov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+# GostMagma
+
+GOST R 34.12/13-2015 (Magma) block cipher algorithms for ECB, CBC, CTR, OFB, CFB, OMAC, CTR-ACPKM, OMAC-ACPKM modes and key export/import algorithms.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gost_magma'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gost_magma
+
+## Usage
+
+```ruby
+require 'gost_magma'
+include GostMagma
+
+BlockSize = Magma::BlockLengthInBytes
+
+# GOST R 34.13-2015 Magma test data
+SelfTestGostMMasterKeyData = [
+  0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88, 
+  0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
+  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 
+  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+].pack('C*').freeze
+key = SelfTestGostMMasterKeyData
+
+SelfTestGostMPlainText = [
+  0x92, 0xde, 0xf0, 0x6b, 0x3c, 0x13, 0x0a, 0x59, 
+  0xdb, 0x54, 0xc7, 0x04, 0xf8, 0x18, 0x9d, 0x20,
+  0x4a, 0x98, 0xfb, 0x2e, 0x67, 0xa8, 0x02, 0x4c, 
+  0x89, 0x12, 0x40, 0x9b, 0x17, 0xb5, 0x7e, 0x41,
+].pack('C*').freeze
+plain_text = SelfTestGostMPlainText
+
+# ECB mode
+SelfTestGostMEcbEncText = [
+  0x2b, 0x07, 0x3f, 0x04, 0x94, 0xf3, 0x72, 0xa0, 
+  0xde, 0x70, 0xe7, 0x15, 0xd3, 0x55, 0x6e, 0x48,
+  0x11, 0xd8, 0xd9, 0xe9, 0xea, 0xcf, 0xbc, 0x1e, 
+  0x7c, 0x68, 0x26, 0x09, 0x96, 0xc6, 0x7e, 0xfb
+].pack('C*').freeze
+encrypted_test = SelfTestGostMEcbEncText
+
+encrypted_text = MagmaEcb.new(key).encrypt(plain_text)
+puts "ECB encrypted_text == encrypted_test: #{encrypted_text == encrypted_test}" 
+    
+decrypted_text = MagmaEcb.new(key).decrypt(encrypted_test)
+puts "ECB decrypted_text == plain_text: #{decrypted_text == plain_text}" 
+
+# OMAC mode
+SelfTestGostMMacValue = [
+  0x15, 0x4e, 0x72, 0x10, 0x20, 0x30, 0xc5, 0xbb
+].pack('C*').freeze
+mac_test = SelfTestGostMMacValue
+
+mac = MagmaOmac.new(key, mac_test.length).update(plain_text).final
+puts "OMAC mac == mac_test: #{mac == mac_test}" 
+
+# CTR mode 
+SelfTestGostMCtrSV = [
+  0x12, 0x34, 0x56, 0x78
+].pack('C*').freeze
+iv = SelfTestGostMCtrSV
+
+SelfTestGostMCtrEncText = [
+  0x4e, 0x98, 0x11, 0x0c, 0x97, 0xb7, 0xb9, 0x3c,
+  0x3e, 0x25, 0x0d, 0x93, 0xd6, 0xe8, 0x5d, 0x69,
+  0x13, 0x6d, 0x86, 0x88, 0x07, 0xb2, 0xdb, 0xef,
+  0x56, 0x8e, 0xb6, 0x80, 0xab, 0x52, 0xa1, 0x2d    
+].pack('C*').freeze
+encrypted_test = SelfTestGostMCtrEncText
+
+encrypted_text = MagmaCtr.new(key, iv, BlockSize).encrypt(plain_text)
+puts "CTR encrypted_text == encrypted_test: #{encrypted_text == encrypted_test}"
+
+# CTR multi-part usage    
+text_len = plain_text.length
+ctx = MagmaCtr.new(key, iv, BlockSize)
+decrypted_text = ctx.decrypt(encrypted_test[0...text_len/3]) +
+  ctx.decrypt(encrypted_test[text_len/3..-1])
+puts "CTR decrypted_text == plain_text: #{decrypted_text == plain_text}" 
+
+# Key export/import (TC 26 KExp15/KImp15) 
+TC26_K = [ 
+	0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 
+	0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
+	0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 
+	0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF 
+].pack('C*').freeze
+TC26_Kmac = [
+	0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 
+	0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F 
+].pack('C*').freeze
+TC26_Kenc = [ 
+	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 
+	0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 
+	0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 
+	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37
+].pack('C*').freeze
+TC26_IV_M = [ 
+	0x67, 0xBE, 0xD6, 0x54
+].pack('C*').freeze
+TC26_Kexp_M = [
+	0xCF, 0xD5, 0xA1, 0x2D,	0x5B, 0x81, 0xB6, 0xE1, 
+  0xE9, 0x9C, 0x91, 0x6D, 0x07, 0x90, 0x0C, 0x6A, 
+  0xC1, 0x27, 0x03, 0xFB, 0x3A, 0xBD, 0xED, 0x55, 
+  0x56, 0x7B, 0xF3, 0x74, 0x2C, 0x89, 0x9C, 0x75, 
+  0x5D, 0xAF, 0xE7, 0xB4, 0x2E, 0x3A, 0x8B, 0xD9
+].pack('C*').freeze
+
+key = TC26_K
+key_mac = TC26_Kmac
+key_enc = TC26_Kenc
+iv = TC26_IV_M
+key_exp_test = TC26_Kexp_M
+
+key_exp = MagmaKeyExpImp::export(key, key_mac, key_enc, iv)
+puts "Key Export key_exp == key_exp_test: #{key_exp == key_exp_test}"
+
+imp_key = MagmaKeyExpImp::import(key_exp_test, key_mac, key_enc, iv)
+puts "Key Import imp_key == key: #{imp_key == key}"
+```
+
+For other cipher modes see test samples in /test/gost_magma_test.rb please.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/vblazhnovgit/gost_magma.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gost_magma"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gost_magma.gemspec

@@ -0,0 +1,38 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "gost_magma/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "gost_magma"
+  spec.version       = GostMagma::VERSION
+  spec.authors       = ["vblazhnovgit"]
+  spec.email         = ["vblazhnov@yandex.ru"]
+
+  spec.summary       = %q{Magma block ciphers}
+  spec.description   = %q{GOST R 34.12/13-2015 (Magma) block cipher algorithms for ECB, CBC, CTR, OFB, CFB, OMAC, CTR-ACPKM and OMAC-ACPKM modes.}
+  spec.homepage      = "https://github.com/vblazhnovgit/gost_magma.git"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/gost_magma.rb

@@ -0,0 +1,15 @@
+require "gost_magma/version"
+
+module GostMagma
+  require "gost_magma/magma"
+  require "gost_magma/magma_tables"
+  require "gost_magma/magma_ecb"
+  require "gost_magma/magma_omac"
+  require "gost_magma/magma_ctr"
+  require "gost_magma/magma_ofb"
+  require "gost_magma/magma_cfb"
+  require "gost_magma/magma_cbc"
+  require "gost_magma/magma_ctr_acpkm"
+  require "gost_magma/magma_omac_acpkm"
+  require "gost_magma/magma_key_exp_imp"
+end

data/lib/gost_magma/magma.rb

@@ -0,0 +1,165 @@
+module GostMagma
+  # Base abstract class
+  class Magma
+    # class constants
+    BlockLengthInBytes = 8
+    KeyLengthInBytes = 32
+    
+    # 's' stands for native-endian byte order but 'n' stands for network (big-endian) byte order
+    BigEndian = [1].pack('s') == [1].pack('n')
+
+    protected
+
+    def self.printBytes(bytes, line_size = 16)
+      bytes.unpack('H*')[0].scan(/.{1,#{line_size}}/).each{|s| puts(s)}
+    end
+
+    def self.zeroBytes(n)
+      ("\x00"*n).force_encoding('BINARY')
+    end
+
+    def self.zeroBlock
+      ("\x00"*BlockLengthInBytes).force_encoding('BINARY')
+    end
+
+    # Unload 32-bit number to 8-byte string
+    # (big-endian, adding leading zeroes)
+    def self.uint32ToUint8BE(n)
+      str = n.to_s(16) # big-endian
+      len = str.length
+      # add leading zeroes
+      str.insert(0, '0'*(8 - len)) if len < 8
+      # To byte string
+      bytes = [str].pack('H*')
+    end 
+    
+    # Unload 32-bit number to 8-byte string
+    # (native-endian, adding leading zeroes)
+    def self.uint32ToUint8(n)
+      bytes = uint32ToUint8BE(n)    
+      bytes.reverse! unless BigEndian   
+      bytes
+    end
+    
+    # Unpacks 8-byte string to 32-bit number 
+    # (native-endian)
+    def self.uint8ToUint32(bytes)
+      bytes.unpack('L*')[0]
+    end
+    
+    def self.encryptRound(right, left, key1, key2)
+      t = (key1 + right) & 0xffffffff
+      left ^= TzTable[0][t & 0xff] ^ TzTable[1][(t >> 8) & 0xff] ^
+        TzTable[2][(t >> 16) & 0xff] ^ TzTable[3][t >> 24 & 0xff]
+      t = (key2 + left) & 0xffffffff
+      right ^= TzTable[0][t & 0xff] ^ TzTable[1][(t >> 8) & 0xff] ^
+        TzTable[2][(t >> 16) & 0xff] ^ TzTable[3][(t >> 24) & 0xff]
+      [right, left]
+    end
+
+    def self.encryptCycle(right, left, keys)
+      right, left = encryptRound(right, left, keys[0], keys[1])
+      right, left = encryptRound(right, left, keys[2], keys[3])
+      right, left = encryptRound(right, left, keys[4], keys[5])
+      right, left = encryptRound(right, left, keys[6], keys[7])
+      right, left = encryptRound(right, left, keys[0], keys[1])
+      right, left = encryptRound(right, left, keys[2], keys[3])
+      right, left = encryptRound(right, left, keys[4], keys[5])
+      right, left = encryptRound(right, left, keys[6], keys[7])
+      right, left = encryptRound(right, left, keys[0], keys[1])
+      right, left = encryptRound(right, left, keys[2], keys[3])
+      right, left = encryptRound(right, left, keys[4], keys[5])
+      right, left = encryptRound(right, left, keys[6], keys[7])
+      right, left = encryptRound(right, left, keys[7], keys[6])
+      right, left = encryptRound(right, left, keys[5], keys[4])
+      right, left = encryptRound(right, left, keys[3], keys[2])
+      right, left = encryptRound(right, left, keys[1], keys[0])
+      [right, left]
+    end
+
+    def self.decryptCycle(right, left, keys)
+      right, left = encryptRound(right, left, keys[0], keys[1])
+      right, left = encryptRound(right, left, keys[2], keys[3])
+      right, left = encryptRound(right, left, keys[4], keys[5])
+      right, left = encryptRound(right, left, keys[6], keys[7])
+      right, left = encryptRound(right, left, keys[7], keys[6])
+      right, left = encryptRound(right, left, keys[5], keys[4])
+      right, left = encryptRound(right, left, keys[3], keys[2])
+      right, left = encryptRound(right, left, keys[1], keys[0])
+      right, left = encryptRound(right, left, keys[7], keys[6])
+      right, left = encryptRound(right, left, keys[5], keys[4])
+      right, left = encryptRound(right, left, keys[3], keys[2])
+      right, left = encryptRound(right, left, keys[1], keys[0])
+      right, left = encryptRound(right, left, keys[7], keys[6])
+      right, left = encryptRound(right, left, keys[5], keys[4])
+      right, left = encryptRound(right, left, keys[3], keys[2])
+      right, left = encryptRound(right, left, keys[1], keys[0])
+      [right, left]
+    end
+
+    def self.encryptBlockUintKey(input, keys)
+      right = uint8ToUint32(input[0..3])
+      left = uint8ToUint32(input[4..-1])
+      right, left = encryptCycle(right, left, keys)
+      output = uint32ToUint8(left) + uint32ToUint8(right)
+    end
+
+    def self.decryptBlockUintKey(input, keys)
+      right = uint8ToUint32(input[0..3])
+      left = uint8ToUint32(input[4..-1])
+      right, left = decryptCycle(right, left, keys)
+      output = uint32ToUint8(left) + uint32ToUint8(right)
+    end
+
+    def self.encryptBlock(input, keys)
+      tmp_input = input.reverse 
+      tmp_output = encryptBlockUintKey(tmp_input, keys)
+      output = tmp_output.reverse
+    end
+
+    def self.decryptBlock(input, keys)
+      tmp_input = input.reverse
+      tmp_output = decryptBlockUintKey(tmp_input, keys)
+      output = tmp_output.reverse
+    end
+
+    # Increment CTR counter
+    def self.incrementModulo(counter, size)
+      lastIndex = size - 1
+      (0...size).each do |i|
+        if counter[lastIndex - i].ord > 0xfe then  
+          counter[lastIndex - i] = (counter[lastIndex - i].ord - 0xff).chr  
+        else 
+          counter[lastIndex - i] = (counter[lastIndex - i].ord + 1).chr 
+          break 
+        end  
+      end
+      counter
+    end
+    
+    # block - byte string  
+    def self.shiftLeftOne(block)
+      (0...(BlockLengthInBytes-1)).each do |i|
+        ri1 = block[i+1].ord
+        ri = block[i].ord << 1
+        ri &= 0xfe
+        ri |= (ri1 >> 7) & 0x1
+        block[i] = ri.chr
+      end
+      ri = block[BlockLengthInBytes-1].ord << 1
+      block[BlockLengthInBytes-1] = (ri & 0xfe).chr
+      block
+    end
+    
+    def self.padd(incomplete_block)
+      padding_len = BlockLengthInBytes - (incomplete_block.length % BlockLengthInBytes)
+      padded_block = incomplete_block.dup
+      padded_block += 0x80.chr
+      padding_len -= 1
+      if padding_len > 0 then
+        padded_block += 0.chr * padding_len
+      end
+      padded_block
+    end
+  end
+end