crypto-toolbox 0.1.18 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37d4aab806c87b5df97642e506ea938733be2b79
-  data.tar.gz: 0527ceaba2da2046e998194405f3b7d5a48394d7
+  metadata.gz: 5e7c5e78c91895522590c24250dced966fcfb2f6
+  data.tar.gz: 55532ae19e4091a32318dc423c59df4e3dc06ad4
 SHA512:
-  metadata.gz: f5e20456aa954a252cf3c7407ecacbabb1cd09c53fbaa5773fc0468283f18a5a2f80a4ded360e83bffe84b7cd058120194fbb2191c04f915d23eaba0c5bb070d
-  data.tar.gz: 8e41fdd52797f51022df4a97abc30320df50e95f29038ffb96e844ee74fb53d4d7aa681eaf80aa99168f05d142cc4234efbc5856559ded55ad7c7016066dcc2e
+  metadata.gz: 8ea2cb29c172ff16ba8f48e7d66393e41caa78a539fb48089038ff38ae8dbed5c130a061f2102522f3fcbfe0e3955a743f65e85ba53aa72142b3e20640965671
+  data.tar.gz: b250861b903d5bbaec6511a0bb8e734b8225916bf369fdd10e7b3d7b09d9ae7d297b97065953facafb80154a835872c58cb7d1c786bf073c00d6b395a379372b

data/bin/break-vigenere-xor

@@ -7,5 +7,10 @@ if ARGV[0].nil?
 else
   ciphertext = ARGV[0]
 
-  Analyzers::VigenereXor.new.analyze(ciphertext)
+  results = Analyzers::VigenereXor.new.analyze(ciphertext)
+  unless results.empty?
+    puts "[Success] Found valid result(s):"
+    puts results.map(&:str)
+  end
+
 end

data/lib/crypto-toolbox.rb

@@ -4,7 +4,11 @@ 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/ascii_language_detector.rb'
 require 'crypto-toolbox/analyzers/utils/spell_checker.rb'
+require 'crypto-toolbox/analyzers/utils/human_language_detector.rb'
+
 require 'crypto-toolbox/analyzers/padding_oracle.rb'
 require 'crypto-toolbox/analyzers/cbc_mac.rb'
 require 'crypto-toolbox/analyzers/vigenere_xor.rb'
@@ -12,3 +16,5 @@ require 'crypto-toolbox/analyzers/vigenere_xor.rb'
 
 require 'crypto-toolbox/ciphers/caesar.rb'
 require 'crypto-toolbox/ciphers/rot13.rb'
+
+require 'crypto-toolbox/crypto_challanges/solver.rb'

data/lib/crypto-toolbox/analyzers/padding_oracle/analyzer.rb

@@ -8,11 +8,11 @@ module Analyzers
     class Analyzer
       class FailedAnalysis < RuntimeError; end
       attr_reader :result
-
+      include ::Utils::Reporting::Console
       
-      def initialize(oracle_class = ::Analyzers::PaddingOracle::Oracles::TcpOracle)
+      def initialize(oracle = ::Analyzers::PaddingOracle::Oracles::TcpOracle.new)
         @result      = [ ]
-        @oracle      = oracle_class.new
+        @oracle      = oracle
       end
 
       # start with the second to last block to manipulate the final block ( cbc xor behaviour )
@@ -24,34 +24,45 @@ module Analyzers
       # changing this byte  ^- will change ^- this byte at decryption
       def analyze(cipher)
         blocks = CryptBuffer.from_hex(cipher).chunks_of(16)
+
+        # for whatever reason ranges cant be from high to low
+        (1..(blocks.length() -1)).reverse_each do |block_index|
+          result.unshift analyse_block(blocks,block_index)
+        end
         
-        (blocks.length - 1).downto(1) do |block_index|
-          result_part = []
-          # manipulate each byte of the 16 byte block
-          1.upto(blocks[block_index -1 ].length) do |pad_index|
-            @oracle.connect
-            
-            jot("processing byte #{pad_index} in block: #{block_index - 1} => #{block_index}",debug: true)
-            byte = read_byte(pad_index,result_part,blocks,block_index)
-            result_part.unshift byte
-            
-            @oracle.disconnect
+        report_result(result)
+      end
+
+
+      
+      private
+
+      def analyse_block(blocks,block_index)
+        block_result = []
+        
+        # manipulate each byte of the 16 byte block
+        1.upto(blocks[block_index -1].length) do |pad_index|
+          with_oracle_connection do
+            jot("processing byte #{pad_index} in block: #{block_index -1} => #{block_index}",debug: true)
+            byte = read_byte(pad_index,block_result,blocks,block_index)
+            block_result.unshift byte
           end
-          result.unshift result_part
         end
+        block_result
+      end
+
+      def report_result(result)
         jot(CryptBuffer(result.flatten).chars.inspect,debug: false)
         jot("stripping padding!",debug: true)
         jot(CryptBuffer(result.flatten).strip_padding.str,debug: false)
       end
 
-
-      private
-      def jot(message, debug: false)
-        if debug == false || ENV["DEBUG_ANALYSIS"]
-          puts message
-        end
+      def with_oracle_connection
+        @oracle.connect
+        yield
+        @oracle.disconnect
       end
-      
+
       def apply_found_bytes(buf,cur_result,pad_index)
         # first we have to apply all the already found bytes
 
@@ -62,38 +73,53 @@ module Analyzers
         buf.xor(other)
       end
 
-
+      # the blocks are:
+      # xxxxxxxx xxxxxxxx xxxxxxxx   [..]
+      # ^- IV    ^- first ^- second  ...
       def read_byte(pad_index,cur_result,blocks,block_index)
-        #iv, first, second, last
         jot(cur_result.inspect,debug: true)
         
         # apply all the current-result bytes to the block corresponding to <block_index>
         # and store the result in a buffer we will mess with
-        #
         forge_buf = apply_found_bytes(blocks[block_index - 1],cur_result,pad_index)
         
         1.upto 256 do |guess|
-          # the bytes from the subset we will send to the padding oracle
-          subset = blocks[0,block_index+1]
-          subset[block_index -1 ] = forge_buf.xor_at([guess,pad_index], -1 * pad_index)
- 
-          input =  subset.map(&:bytes).flatten
+          input = assemble_oracle_input(forge_buf,blocks,block_index,pad_index,guess)
           
-          # skip the first correct guess on the first iteration of the first block
-          # otherwise the resulting ciphertext would eq the original input
-          #next if input == blocks.map(&:bytes).flatten
-          next if guess == pad_index && guess == 1 && block_index == 2
-
-          block_amount = block_index + 1
-          if @oracle.valid_padding?(input,block_amount)
-            return guess 
-          end
+          next if skip?(pad_index,block_index,guess,cur_result)
 
+          return guess if@oracle.valid_padding?(input,block_amount(block_index))
         end
 
         raise FailedAnalysis, "No padding found... this should neve happen..."
       end
+      private
 
+      # include the block after the index, since this
+      # is the one effected by our manipulation. ( due to cbc mode )
+      def block_amount(index)
+        index +1 
+      end
+
+      # Create a subset to only send the blocks we still need to decrypt.
+      # manipulate the byte with a padding-index and a guess
+      # map the crypt buffer array to a flat array of integers ( representing bytes )
+      def assemble_oracle_input(buffer,blocks,block_index,pad_index,guess)
+        # the bytes from the subset we will send to the padding oracle
+        subset = blocks[0,block_index+1]
+        subset[block_index -1 ] = buffer.xor_at([guess,pad_index], -1 * pad_index)
+        subset.map(&:bytes).flatten
+      end
+      
+      # In case of the first iteration there is a special case to skip:
+      # 1) No other blocks have been decrypted yet ( result.empty? )
+      # 2) No bytes of the current block have been processed yet ( block_result_empty? )
+      # 3) guess xor pad-index does not modify anything ( eq zero )
+      # => This would leed to the original ciphertext without any modification beeing sent
+      def skip?(pad_index,block_index,guess,block_result)
+        result.empty? && block_result.empty? && (guess ^ pad_index).zero?
+      end
+      
     end
   end
 end

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

@@ -0,0 +1,72 @@
+module Analyzers
+  module Utils
+    class AsciiLanguageDetector
+      ASCII_BASE_RANGE=(32..127).freeze
+      ASCII_BLACKLIST = [40,41,42,43,47,60,61,62,91,92,93,94,95,96,35,59].freeze 
+      ASCII_WHITELIST = [10]
+      ASCII_CHARACTERS = ( ASCII_BASE_RANGE.to_a + ASCII_WHITELIST - ASCII_BLACKLIST ).to_ary.freeze # 10 == \n is now allowed!
+=begin
+NOTE: This is the output of the benchmark script contained in this gem
+      see: benchmarks/language_detection.rb
+It compares many ways of filtering bytes to check if only "plain" language
+characters are contained. Result:
+
+Comparison:
+   ascii_range_check:                 1773.5 i/s                <- use range.cover? and then blacklist.include
+ ascii_lingual_byte?:                 1494.8 i/s - 1.19x slower <- now uses range.cover? internally
+ascii_lingual_bytes?:                 1459.2 i/s - 1.22x slower <- see prev. but get the entire byte array
+      ascii_lingual?:                 1420.1 i/s - 1.25x slower <- see prev. but works on crypt buffers
+ascii_lingual_and_human_language:     1413.6 i/s - 1.25x slower  <- use human_languge?, but apply 0 < byte < 127 first
+   ascii_shift_check:                  634.4 i/s - 2.80x slower  <- uses & (1 << 5).zero? but has to do slow additional checks
+ascii_whitelist.bsearch?:              483.8 i/s - 3.50x slower  <- whitelist lookup using bsearch
+hunspell.human_language?:              212.3 i/s - 8.35x slower  <- use human_languge?
+ascii_whitelist.include?:               90.2 i/s - 19.67x slower <- use (whitelist - blacklist).include?
+hunspell_human_language_without_dict:    0.2 i/s - 10013.62x slower <- instanciating the dict seems to be very very slow...
+
+NOTE:
+  Normally the shift solution would be the fastes, but we have to convert back and forth,
+  thus the range.cover? check still seems to be the best soution. It is also more readable
+
+  (We need the chr.downcase.ord conversion to support upper case letters)
+  byte < 127 && !(byte.chr.downcase.ord & (1 << 5)).zero?
+=end
+      def ascii_lingual_byte?(byte)
+        # check how fast bsearch is, if range.cover is no longer needed we can nicely add 10 to the array
+        (ascii_base_range.cover?(byte) && !ascii_blacklist.include?(byte)) || ( ascii_whitelist.bsearch{|i| i == byte} )
+      end
+      
+      def ascii_lingual_bytes?(bytes)
+        bytes.all?{|b| ascii_lingual_byte?(b) }
+      end
+
+      def ascii_lingual_chars
+        ASCII_CHARACTERS
+      end
+      
+      def ascii_lingual?(buf)
+        ascii_lingual_bytes?(buf.bytes)
+      end
+
+      def ascii_lingual_bytes
+        ascii_whitelist.to_ary
+      end
+
+      private
+     
+      # building up the range is too slow, thus we cache
+      def ascii_base_range
+        ASCII_BASE_RANGE
+      end
+      
+      def ascii_whitelist
+        ASCII_WHITELIST
+      end
+
+      def ascii_blacklist
+        ASCII_BLACKLIST
+      end
+
+    end
+  end
+end
+      

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

@@ -0,0 +1,37 @@
+module Analyzers
+  module Utils
+    # NOTE the implementation decisions are based on the result of
+    # benchmarks/language_detector.rb
+    class HumanLanguageDetector
+      def initialize
+        @spell_checker = ::Analyzers::Utils::SpellChecker.new
+        @ascii_checker = ::Analyzers::Utils::AsciiLanguageDetector.new
+      end
+
+      # NOTE: we dont use the human_language? method
+      # to be faster at processing and more idiomatic
+      def human_language_entries(buffers,spellcheck: true )
+        filtered = buffers.select{|b| ascii_valid?(b) }
+        if spellcheck
+          buffers.select{|b| spell_valid?(b) }
+        else
+          filtered
+        end
+      end
+      
+      def human_language?(buffer)
+        ascii_valid?(buffer) && spell_valid?(buffer)
+      end
+      
+      private
+
+      def ascii_valid?(buf)
+        @ascii_checker.ascii_lingual?(buf)
+      end
+      
+      def spell_valid?(buf)
+        @spell_checker.human_language?(buf.str)
+      end
+    end
+  end
+end

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

@@ -11,6 +11,9 @@ module Analyzers
       # }
       include ::Utils::Reporting::Console
 
+      def initialize
+        @lang_detector = Analyzers::Utils::AsciiLanguageDetector.new
+      end
       # factory method for easy use
       def self.create(input_buf,keylen)
         new.run(input_buf,keylen)
@@ -22,9 +25,19 @@ module Analyzers
       # 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|
-    
+        #return run2(input_buf,keylen)
+        detector = Analyzers::Utils::HumanLanguageDetector.new
+        
+        candidate_map = (0..(keylen-1)).each_with_object({}) do |key_byte_pos,hsh|
+=begin
+# Letter frquency testing
+            freqs = letter_freq(nth_byte_stream.xor_all_with(guess).str)
+            diff = FREQUENCIES.keys - freqs.keys
+            binding.pry  if     nth_byte_stream.xor_all_with(guess).bytes.all?{|byte| acceptable_char?(byte) } &&
+                                ((diff.map{|c| FREQUENCIES[c]}.reduce(&:+)||0) > 16)
+=end
+
+          
           # 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
@@ -34,9 +47,9 @@ module Analyzers
           # 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) } }
+          hsh[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)
+          jot("found #{hsh[key_byte_pos].inspect} bytes for position: #{key_byte_pos}",debug: true)
         end
         candidate_map
       end
@@ -45,10 +58,8 @@ module Analyzers
       
       # Checks if a given byte maps to a reasonable english language character
       def acceptable_char?(byte)
-        (byte > 31 && byte < 123) && (byte != 60 && byte !=64)
+        @lang_detector.ascii_lingual_byte?(byte)
       end
-
-      
     end
   end
 end

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

@@ -0,0 +1,36 @@
+module Analyzers
+  module Utils
+    class LetterFrequency
+      
+      FREQUENCIES={
+        ' ' =>  20,  # ??
+        'e' =>	12.02,
+        't' =>	9.10,
+        'a' =>	8.12,
+        'o' =>	7.68,
+        'i' =>	7.31,
+        'n' =>	6.95,
+        's' =>	6.28,
+        'r' =>	6.02,
+        'h' =>	5.92,
+        'd' =>	4.32,
+        'l' =>	3.98,
+        'u' =>	2.88,
+        'c' =>	2.71
+      }
+      def letter_count(str)
+        str.downcase.each_char.with_object({}) do |c,h|
+          h[c] = (h.fetch(c,0) + 1) if c =~ /[A-Za-z ]/
+        end
+      end
+      
+      def letter_freq(str)
+        counts   = letter_count(str)
+        quotient = counts.values.reduce(&:+).to_f
+        counts.sort_by{|k,v| v}.reverse.to_h.each_with_object({}){|(k,v),hsh| hsh[k] = (v/quotient) }
+      end
+
+
+    end
+  end
+end

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

@@ -1,10 +1,8 @@
 require 'ffi/hunspell'
 
-
 module Analyzers
   module Utils
     class SpellChecker
-
       
       def initialize(dict_lang="en_GB")
         @dict = FFI::Hunspell.dict(dict_lang)
@@ -23,15 +21,18 @@ Some statistics about it:
           8          13           9         534        1319        2809 
 (0.84,0.88] (0.88,0.92] (0.92,0.96]    (0.96,1] 
       10581       46598      198477     1440651 
+
+NOTE: There is ony caveat: Short messages with < 5 words may have 33 or 50% error rates
+if numbers or single char words are taken into account
 =end
       def known_words(str)
-        words = str.split(" ").select{|w| @dict.check?(w) }
+        words = str.split(" ").select{|w| check?(w) }
       end
 
       def human_word?(str)
-        @dict.check?(str)
+        check?(str)
       end
-
+      
       def human_phrase?(string)
         string.split(" ").all?{|part| human_word?(part)}
       end
@@ -46,19 +47,34 @@ Some statistics about it:
       # Using shell instead of hunspell ffi causes lots of escaping errors, even with shellwords.escape
       # errors = Float(`echo '#{Shellwords.escape(str)}' |hunspell -l |wc -l `.split.first)
       def human_language?(str)
-        words  = str.split(" ").length
-        errors = str.split(" ").map{|e| @dict.check?(e) }.count{|e| e == false}
-        
-        error_rate = errors.to_f/words
-        
-        $stderr.puts error_rate.round(4) if ENV["CRYPTO_TOOBOX_PRINT_ERROR_RATES"]
+        #NOTE should be reject 1char numbers or all 1 char symbols
+        words       = str.split(" ").reject{|w| (w.length < 2 || w =~ /^[0-9]+$/) }
+        word_amount = words.length
+        errors      = words.map{|e| check?(e) }.count{|e| e == false}
         
+        error_rate = errors.to_f/word_amount
+
+        report_error_rate(str,error_rate) if ENV["DEBUG_ANALYSIS"]
+
         error_rate_sufficient?(error_rate)
       end
       
       private
+
+      def report_error_rate(str,error_rate)
+        if ENV["DEBUG_ANALYSIS"]
+          $stderr.puts "=================================================="
+          $stderr.puts "str: #{str} has error rate: #{error_rate.round(4)}"
+          $stderr.puts "=================================================="
+        end
+      end
+
+      def check?(input)
+        @dict.check?(input) rescue false 
+      end
+      
       def error_rate_sufficient?(rate)
-        rate < 0.5
+        rate < 0.20
       end
     end
   end

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

@@ -27,77 +27,128 @@ module Analyzers
     # the error rate of the candidate plaintext using hunspell
     
     include ::Utils::Reporting::Console
+
+    class HammingDistanceKeyLengthFinder
+      def keylen_for(buffer)
+        offset = 2
+        distances = ((0+offset)..64).map do |keysize|
+          # take the first 4 blocks of keysize length, generate all combinations (6),
+          # map than to normalized hamming distance and take mean
+          buffer.chunks_of(keysize)[0,4].combination(2).map{|a,b| a.hdist(b,normalize: true)}.reduce(&:+) / 6.0
+        end
+        # get the min distance, find its index, convert the keylen
+        distances.min(4).map{|m| distances.index(m)}.map{|i| i + offset }.uniq
+      end
+    end
     
-    def find_pattern(buf)
-      bitstring = buf.nth_bits(7).join("")
+    class EightBitPatternFinder
+      include ::Utils::Reporting::Console
+      def keylen_for(buf)
+        # Example: "100100" || nil
+        key_pattern = find_pattern(buf)
+        
+        assert_key_pattern!(key_pattern)
+        
+        report_pattern_info(key_pattern)
+
+        [key_pattern.length]
+      end
       
-      1.upto(buf.bytes.length).map do |ksize|
-        parts = bitstring.scan(/.{#{ksize}}/)
-        if parts.uniq.length == 1
-          parts.first
-        else
-          nil
+      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.compact.first
+      end
+
+      def report_pattern_info(key_pattern)
+        jot "Found recurring key pattern: #{key_pattern}"
+        jot "Detected key length: #{key_pattern.length}"
+      end
+      
+      def find_pattern(buf)
+        bitstring = buf.nth_bits(7).join("")
+        
+        1.upto(buf.bytes.length).map do |ksize|
+          parts = bitstring.scan(/.{#{ksize}}/)
+          if parts.uniq.length == 1
+            parts.first
+          else
+            nil
+          end
+        end.compact.first
+      end
+    end
+
+    class StaticKeylength
+      def initialize(keylength)
+        @keylength = keylength
+      end
+      def keylen_for(dummy)
+        [@keylength]
+      end
     end
+
+
     
-    def analyze(input)
+    def analyze(input, keylength_strategy=EightBitPatternFinder.new)
       buf = CryptBuffer.from_hex(input)
-## === Should this be extracted into a dedicated class ?
-      # Example: "100100" || nil
-      key_pattern = find_pattern(buf)
 
-      assert_key_pattern!(key_pattern)
-      
-      report_pattern_info(key_pattern)
+      keylength_strategy.keylen_for(buf).map do |keylen|
+        analyse_single(buf,keylen)
+      end.flatten
+    end
+
+
+    
+    def analyse_single(buf,key_length)
+      candidate_map = Analyzers::Utils::KeyCandidateMap.create(buf,key_length)
+
+     
+      candidate_amount = candidate_map.map{|k,v| v.length}.reduce(&:*)
+      if candidate_amount.zero?
+        jot("no combinations for keylen #{key_length} (at least one byte has no candidates)",debug: true)
+        return []
+      end
+      jot "Amount of candidate keys: #{candidate_map.map{|k,v| v.length}.reduce(&:*)}. Starting Permutation (RAM intensive)",debug: true
 
-##====
-      
-      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
       head,*tail = candidate_map.map{|k,v|v}
-      combinations = head.product(*tail)
+      begin
+        combinations = head.product(*tail) 
+        # we simply skip too big products
+      rescue RangeError => ex
+        jot "keylen: #{key_length}: #{ex}"
+        return []
+      end
 
+
+      
       if ENV["DEBUG_ANALYSIS"]
         ensure_consistent_result!(combinations,candidate_map)
-        print_candidate_decryptions(candidate_map,key_pattern.length,buf)
+        print_candidate_decryptions(candidate_map,key_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)
+      keys = Analyzers::Utils::KeyFilter::AsciiPlain.new(combinations,buf).filter.reject(&:empty?)
+
+      # return the result, not the key
+      keys.map do|key|
+        key.xor(buf)
       end
     end
+    private
 
-    def ensure_consistent_result!(combinations,condidate_map)
+    def ensure_consistent_result!(combinations,candidate_map)
       # NOTE Consistency check ( enable if you dont trust the generation anymore )
       # make sure all permutations are still according to the bytes per position map
       combinations.select do |arr|
         raise "Inconsistent key candidate combinations" unless arr.map.with_index{|e,i| candidate_map[i].include?(e)  }.all?{|e| e ==true}
       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):"
-        results.each do |r|
-          jot r.xor(buf).str
-        end
-      end
-    end
     
     def print_candidate_decryptions(candidate_map,keylen,buf)
       # printout for debugging. (Manual analysis of the characters)

data/lib/crypto-toolbox/crypt_buffer.rb

@@ -51,6 +51,10 @@ class CryptBuffer
     CryptBufferInputConverter.new.from_hex(input)
   end
 
+  def self.from_base64(input)
+    CryptBufferInputConverter.new.from_base64(input)
+  end
+
   def nth_bytes(n,offset: 0)
     return CryptBuffer([]) if n.nil? || n < 1
 

data/lib/crypto-toolbox/crypt_buffer/concerns/arithmetic.rb

@@ -27,7 +27,19 @@ module CryptBufferConcern
       CryptBuffer(tmp)
     end
 
+    def hdist(other,normalize: false)
+      if normalize
+        hamming_distance(other) / length.to_f
+      else
+        hamming_distance(other)
+      end
+    end
+
     private
+
+    def hamming_distance(other)
+      (self ^ other).bits.join.count("1") 
+    end
     
     def sanitize_modulus(mod)
       (mod > 0) ? mod : 256

data/lib/crypto-toolbox/crypt_buffer/concerns/array.rb

@@ -22,8 +22,8 @@ module CryptBufferConcern
       CryptBuffer(bytes.last(n))
     end
 
-    def [](anything)
-      CryptBuffer(bytes[anything])
+    def [](*things)
+      CryptBuffer(bytes[*things])
     end
 
   end

data/lib/crypto-toolbox/crypt_buffer/concerns/convertable.rb

@@ -23,6 +23,11 @@ module CryptBufferConcern
     def to_s
       str
     end
+
+    def base64(strict: true)
+      strict ?  Base64.strict_encode64(str) : Base64.encode64(str) 
+    end
+
     private
     def bytes2hex(bytes)
       bytes.map{|b| b.to_s(16)}.map{|hs| hs.length == 1 ? "0#{hs}" : hs  }.join

data/lib/crypto-toolbox/crypt_buffer_input_converter.rb

@@ -16,6 +16,11 @@ class CryptBufferInputConverter
     CryptBuffer.new(hex2bytes(hexstr))
   end
   
+  def from_base64(input)
+    string = Base64.decode64(input)
+    CryptBuffer.new(str2bytes(string))
+  end
+  
   private
   def bytes_from_any(input)
     case input

data/lib/crypto-toolbox/crypto_challanges/solver.rb

@@ -0,0 +1,56 @@
+
+module CryptoChallanges
+  class Solver
+    def solve1(input)
+      #CryptoChallanges::Set1::Challange1::Solver.run(input)
+      CryptBuffer.from_hex(input).base64
+    end
+    def solve2(c1,c2)
+      (CryptBuffer.from_hex(c1) ^ CryptBuffer.from_hex(c2)).hex.downcase
+    end
+
+    def letter_count(str)
+      str.downcase.each_char.with_object({}) do |c,h|
+        h[c] = (h.fetch(c,0) + 1) if c =~ /[A-Za-z ]/
+      end
+    end
+    
+    def letter_freq(str)
+      counts   = letter_count(str)
+      quotient = counts.values.reduce(&:+).to_f
+      counts.sort_by{|k,v| v}.reverse.to_h.each_with_object({}){|(k,v),hsh| hsh[k] = (v/quotient) }
+    end
+    
+    def solve3(input)
+      candidates = (1..256).map{ |guess| CryptBuffer.from_hex(input).xor_all_with(guess) }
+      detector = Analyzers::Utils::HumanLanguageDetector.new
+      
+      detector.human_language_entries(candidates).first.to_s
+    end
+    
+    def solve4(hexstrings)
+      detector = Analyzers::Utils::HumanLanguageDetector.new
+      result = hexstrings.map{|h| CryptBuffer.from_hex(h)}.map.with_index do |c,i|
+        candidates = (1..256).map{ |guess| c.xor_all_with(guess) }
+        matches = detector.human_language_entries(candidates)
+
+        matches.empty? ? nil : matches
+      end
+      result.flatten.compact.map(&:str).first
+    end
+    
+    def solve5(input,key)
+      CryptBuffer(input).xor(key,expand_input: true).hex
+    end
+
+    def solve6(input)
+      buffer = CryptBuffer.from_base64(input)
+      Analyzers::VigenereXor.new.analyze(buffer.hex,Analyzers::VigenereXor::HammingDistanceKeyLengthFinder.new)
+    end
+
+    def solve7(input,key)
+    end
+    
+    
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crypto-toolbox
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.19
 platform: ruby
 authors:
 - Dennis Sivia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-07 00:00:00.000000000 Z
+date: 2015-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aes
@@ -59,8 +59,11 @@ 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/ascii_language_detector.rb
+- lib/crypto-toolbox/analyzers/utils/human_language_detector.rb
 - lib/crypto-toolbox/analyzers/utils/key_candidate_map.rb
 - lib/crypto-toolbox/analyzers/utils/key_filter.rb
+- lib/crypto-toolbox/analyzers/utils/letter_frequency.rb
 - lib/crypto-toolbox/analyzers/utils/spell_checker.rb
 - lib/crypto-toolbox/analyzers/vigenere_xor.rb
 - lib/crypto-toolbox/ciphers/caesar.rb
@@ -76,6 +79,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/crypto_challanges/solver.rb
 - lib/crypto-toolbox/utils/reporting/console.rb
 homepage: https://github.com/scepticulous/crypto-toolbox
 licenses: