crypto-toolbox 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2eab51c42b84900135dc165a677a18be4d470a1b
-  data.tar.gz: a2ec0819114133ae5f613ef2ce4ed153c10a3dff
+  metadata.gz: fdd99e3ce62f22f02f795da59cc1f8b543e227b6
+  data.tar.gz: cc192b11d8368034f427a520ce187d4ae22def74
 SHA512:
-  metadata.gz: 340f89d19a2bb483beffa8b93c16c4c260c6ddb289ce2e187fb53b731413078eb7aa79b8c93b633ad1d5e8e29bde23eded39b7605d873530c0b30c3aff50aaa8
-  data.tar.gz: 0be69d404f8007cd889051c403e92ab4cf09b0600bb8aa04432115c3042fadcb1505429f873cfbd7625333206826cd12a7ac5bcc036eeedb7c3e2626e1fe5c60
+  metadata.gz: 8ab6e8349e86a0a8f4e8d59d29071e947e158aca611841a3838f8e79ab9af3697df6842d17a0b3f59c63327607f42036b92de767e65e215e0cda5a42c5e11350
+  data.tar.gz: 3ea4f85090f439fd204a68a644ac44cd4d95978546c208906393252f506bc49e441d9dbeb339ce4ff9789c3a5f28a13ab3fb3766523468db45e488844ba466bf

data/lib/crypto-toolbox.rb

@@ -1,7 +1,8 @@
+require 'crypto-toolbox/utils/reporting/console.rb'
+
 require 'crypto-toolbox/crypt_buffer_input_converter.rb'
 require 'crypto-toolbox/crypt_buffer.rb'
 
-
 require 'crypto-toolbox/analyzers/utils/key_filter.rb'
 require 'crypto-toolbox/analyzers/utils/spell_checker.rb'
 require 'crypto-toolbox/analyzers/padding_oracle.rb'

data/lib/crypto-toolbox/analyzers/utils/key_candidate_map.rb

@@ -0,0 +1,54 @@
+module Analyzers
+  module Utils
+    class KeyCandidateMap
+      # This class represents a position-index based map of possible values of a key.
+      # Example:
+      # {
+      #  1 => [1,100,22,33]
+      #  2 => [2,77,255]
+      #  ...
+      # n => [22,55,222]
+      # }
+      include ::Utils::Reporting::Console
+
+      # factory method for easy use
+      def self.create(input_buf,keylen)
+        new.run(input_buf,keylen)
+      end
+
+      # Algorithm
+      # 1) for each position of the key: (key_byte_pos)
+      # 2) create a stream of all the nth bytes of the keylen
+      # 3) xor any possible byte value (guess) with all nth's bytes
+      # 4) select those guesses that decipher the nth-byte stream to only english plain ascii chars
+      def run(input_buf,keylen)
+        candidate_map ={}
+        (0..(keylen-1)).each do |key_byte_pos|
+    
+          # create an array of every nth byte of the input. ( thus a pseudo stream of the nth bytes )
+          # 1) create an enumerator of the nth positions. e.g for iteration 0: [0,7,14,...]
+          # 2) Next: Map the positions to bytes of the input buffer
+          #
+          # NOTE: regular implementation without cryptbuffer magic:
+          # nth_stream = (key_byte_pos).step(input_buf.bytes.length() -1, keylen).map{|i| input_buf.bytes[i]}
+          # nth_byte_stream2 = CryptBuffer.new(nth_stream)
+
+          nth_byte_stream = input_buf.nth_bytes(keylen,offset: key_byte_pos)
+          candidate_map[key_byte_pos] = 0.upto(255).select{|guess| nth_byte_stream.xor_all_with(guess).bytes.all?{|byte| acceptable_char?(byte) } }
+          
+          jot("found #{candidate_map[key_byte_pos].inspect} bytes for position: #{key_byte_pos}",debug: true)
+        end
+        candidate_map
+      end
+      
+      private
+      
+      # Checks if a given byte maps to a reasonable english language character
+      def acceptable_char?(byte)
+        (byte > 31 && byte < 123) && (byte != 60 && byte !=64)
+      end
+
+      
+    end
+  end
+end

data/lib/crypto-toolbox/analyzers/vigenere_xor.rb

@@ -1,3 +1,4 @@
+require 'crypto-toolbox/analyzers/utils/key_candidate_map.rb'
 
 =begin
 # References:
@@ -24,22 +25,8 @@ module Analyzers
     #
     # 4) Do an English language Analysis of the possible result by using
     # the error rate of the candidate plaintext using hunspell
-    #
-
     
-    def jot(message, debug: false)
-      if debug == false || ENV["DEBUG_ANALYSIS"]
-        puts message
-      end
-    end
-    def print_delimiter_line
-      puts "=====================================================================" 
-    end
-
-    # Checks if a given byte maps to a reasonable english language character
-    def acceptable_char?(byte)
-      (byte > 31 && byte < 123) && (byte != 60 && byte !=64)
-    end
+    include ::Utils::Reporting::Console
     
     def find_pattern(buf)
       bitstring = buf.nth_bits(7).join("")
@@ -53,44 +40,20 @@ module Analyzers
         end
       end.compact.first
     end
-
-    def create_candidate_map(buf,keylen)
-      candidate_map ={}
-      (0..(keylen-1)).each do |key_byte_pos|
-
-        nth_stream = (key_byte_pos).step(buf.bytes.length() -1, keylen).map{|i| buf.bytes[i]}
-        smart_buf = CryptBuffer.new(nth_stream)
-
-        candidate_map[key_byte_pos]=[]
-        1.upto(255).each do |guess|
-          if smart_buf.xor_all_with(guess).bytes.all?{|byte| acceptable_char?(byte) }
-            jot("YES: " + smart_buf.xor_all_with(guess).to_s,debug: true)
-            candidate_map[key_byte_pos] << guess
-          else
-            # the current byte does not create a plain ascii result ( thus skip it )
-            #jot  "NO: " + smart_buf.xor_all_with(guess).to_s
-          end
-        end
-      end
-      
-      candidate_map
-    end
     
     def analyze(input)
       buf = CryptBuffer.from_hex(input)
-
+## === Should this be extracted into a dedicated class ?
       # Example: "100100" || nil
       key_pattern = find_pattern(buf)
-      if key_pattern.nil?
-        $stderr.puts "failed to find keylength by ASCII-8-Bit anlysis"
-        exit(1)
-      end
-      keylen = key_pattern.length
-      jot "Found recurring key pattern: #{key_pattern}"
-      jot "Detected key length: #{keylen}"
 
+      assert_key_pattern!(key_pattern)
       
-      candidate_map = create_candidate_map(buf,keylen)
+      report_pattern_info(key_pattern)
+
+##====
+      
+      candidate_map = Analyzers::Utils::KeyCandidateMap.create(buf,key_pattern.length)
       jot "Amount of candidate keys: #{candidate_map.map{|k,v| v.length}.reduce(&:*)}. Starting Permutation (RAM intensive)"
       
       # split the candidate map into head and*tail to create the prduct of all combinations
@@ -99,12 +62,19 @@ module Analyzers
 
       if ENV["DEBUG_ANALYSIS"]
         ensure_consistent_result!(combinations,candidate_map)
-        print_candidate_decryptions(candidate_map,keylen,buf)
+        print_candidate_decryptions(candidate_map,key_pattern.length,buf)
       end
       
       results = Analyzers::Utils::KeyFilter::AsciiPlain.new(combinations,buf).filter
       report_result(results,buf)
     end
+    private
+    def assert_key_pattern!(key_pattern)
+      if key_pattern.nil?
+        $stderr.puts "failed to find keylength by ASCII-8-Bit anlysis"
+        exit(1)
+      end
+    end
 
     def ensure_consistent_result!(combinations,condidate_map)
       # NOTE Consistency check ( enable if you dont trust the generation anymore )
@@ -114,6 +84,12 @@ module Analyzers
       end      
     end
 
+    def report_pattern_info(key_pattern)
+      jot "Found recurring key pattern: #{key_pattern}"
+      jot "Detected key length: #{key_pattern.length}"
+    end
+      
+
     def report_result(results,buf)
        unless results.empty?
         jot "[Success] Found valid result(s):"

data/lib/crypto-toolbox/crypt_buffer.rb

@@ -44,6 +44,13 @@ class CryptBuffer
     CryptBufferInputConverter.new.from_hex(input)
   end
 
+  def nth_bytes(n,offset: 0)
+    return CryptBuffer([]) if n.nil? || n < 1
+
+    CryptBuffer((0+offset).step(length,n).map{|i| bytes[i] }.compact)
+  end
+  
+
   # Returns an array of the nth least sigificant by bit of each byte
   def nth_bits(n)
     raise OutOfRangeError if n < 0

data/lib/crypto-toolbox/utils/reporting/console.rb

@@ -0,0 +1,16 @@
+module Utils
+  module Reporting
+    module Console
+      # Print to stdout with support of debug conditions
+      # This is especially helpfull if the analysis fails or is too slow
+      def jot(message, debug: false)
+        if debug == false || ENV["DEBUG_ANALYSIS"]
+          puts message
+        end
+      end
+      def print_delimiter_line
+        puts "=====================================================================" 
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crypto-toolbox
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Dennis Sivia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-22 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aes
@@ -52,6 +52,7 @@ files:
 - lib/crypto-toolbox/analyzers/padding_oracle/analyzer.rb
 - lib/crypto-toolbox/analyzers/padding_oracle/oracles/http_oracle.rb
 - lib/crypto-toolbox/analyzers/padding_oracle/oracles/tcp_oracle.rb
+- lib/crypto-toolbox/analyzers/utils/key_candidate_map.rb
 - lib/crypto-toolbox/analyzers/utils/key_filter.rb
 - lib/crypto-toolbox/analyzers/utils/spell_checker.rb
 - lib/crypto-toolbox/analyzers/vigenere_xor.rb
@@ -67,6 +68,7 @@ files:
 - lib/crypto-toolbox/crypt_buffer/concerns/random.rb
 - lib/crypto-toolbox/crypt_buffer/concerns/xor.rb
 - lib/crypto-toolbox/crypt_buffer_input_converter.rb
+- lib/crypto-toolbox/utils/reporting/console.rb
 homepage: https://github.com/scepticulous/crypto-toolbox
 licenses:
 - GPLv3