crypto-toolbox 0.0.16 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93d0e21458b968e566229e504155d5cf4bafb51c
-  data.tar.gz: a35a6a7b37778a4a360c2395f0564fe104f65c4e
+  metadata.gz: b8cd55faeae9f38185945c99d5b079a84ba2373f
+  data.tar.gz: db5ab428bd11e21c9fa9c4662b71c109e99d98f1
 SHA512:
-  metadata.gz: 95b25bb19566388f581700126ddc35aff62b37c5640f54fde98d077a2304aafdc055bf5d96b5e3bfdffa7deffd977037482efd41fe0380f2ab45c18a1ce8d550
-  data.tar.gz: 32da8806bfd42dace43a3601c8aec14420d8120cfb1245914cd8ce3489b5c9dec34d879c3a6959458a60864287a6551888bb296467cd7cf2ae0e6a41fa3d16d2
+  metadata.gz: 80cb527eba8c5526e6e07cdf747f9426de16f3fb2cc694534b4d3bf4b7e4b3d4ee426bb3e24331204cf4ccad0546f91347e036851fbaada0ee47b49e5f51236e
+  data.tar.gz: c3d0d0be185630772ee9c30069881663bf4e94369e53212694881f23e38562d8955db2fd7c16dc19666242d933158c6cb99136c6e2c9bb439836d224a4c99398

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

@@ -16,12 +16,14 @@ module Analyzers
     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
     
     def find_pattern(buf)
-      bitstring = buf.nth_bits(0).join("")
+      bitstring = buf.nth_bits(7).join("")
       
       1.upto([buf.bytes.length,62].min).map do |ksize|
         parts = bitstring.scan(/.{#{ksize}}/)
@@ -54,7 +56,7 @@ module Analyzers
 
         candidate_map[key_byte]=[]
         1.upto(255).each do |possible_key_value|
-          if smart_buf.xor_all_with(possible_key_value).bytes.all?{|byte| acceptable_byte?(byte) }
+          if smart_buf.xor_all_with(possible_key_value).bytes.all?{|byte| acceptable_char?(byte) }
             jot("YES: " + smart_buf.xor_all_with(possible_key_value).to_s,debug: true)
             candidate_map[key_byte] << possible_key_value
           else

data/lib/crypto-toolbox/crypt_buffer.rb

@@ -2,151 +2,212 @@ require 'aes'
 require 'openssl'
 require 'forwardable'
 
-class CryptBuffer
-  class OutOfRangeError < RuntimeError; end
-  
-  attr_accessor :bytes
+module CryptBufferAspect
+  module Comparable
+    def ==(other)
+      bytes == bytes_from_any(other)
+    end
 
-  include Enumerable
-  extend ::Forwardable
-  def_delegators :@bytes, :[], :empty?,:include?, :length
-  
-  def initialize(input)
-    @bytes = bytes_from_any(input)
   end
 
-  # Make sure input strings are always interpreted as hex strings
-  # This is especially useful for unknown or uncertain inputs like
-  # strings with or without leading 0x
-  def self.from_hex(input)
-    hexstr =""
-    unless input.nil?
-      hexstr = (input =~ /^0x/ ? input : "0x#{pad_hex_char(input)}" )
+  module ByteExpander
+    private
+    def expand_bytes(input,total)
+      if input.length >= total
+        input
+      else
+        n = total / input.length
+        rest = total % input.length
+        
+        # expand the input to the full length of the internal data
+        (input * n) + input[0,rest]
+      end
     end
-    CryptBuffer.new(hexstr)
   end
   
-  def each(&block)
-    @bytes.each(&block)
-  end
+  module Convertable
+    def hex
+      bytes2hex(bytes).upcase
+    end
+    
+    alias_method :h, :hex
+    
+    def chars
+      map{|b| b.to_i.chr}
+    end
+    alias_method :c, :chars
+    
+    def str
+      chars.join
+    end
+    alias_method :s, :str
 
-  alias_method :b, :bytes
+    def bits
+      map{|b| "%08d" % b.to_s(2) }
+    end
 
-  def hex
-    bytes2hex(bytes).upcase
-  end
-  alias_method :h, :hex
-  
-  def chars
-    map{|b| b.to_i.chr}
+    def to_s
+      str
+    end
+    private
+    def bytes2hex(bytes)
+      bytes.map{|b| b.to_s(16)}.map{|hs| hs.length == 1 ? "0#{hs}" : hs  }.join
+    end
   end
-  alias_method :c, :chars
 
-  def str
-    chars.join
-  end
-  alias_method :s, :str
+  module Xorable
+    
+    def xor_at(input,pos)
+      return self if input.nil? || (pos.abs > length)
+      
+      case input
+      when Array
+        # map our current data to xor all inputs with the given bytepos.
+        # all other bytes are kept as they were
+        tmp = bytes.map.with_index{|b,i| i == pos ? xor_multiple(b,input) : b }
+        CryptBuffer(tmp)
+      else
+        tmp = bytes
+        tmp[pos] = tmp[pos] ^ input
+        CryptBuffer(tmp)
+      end 
+    end
+    
+    def xor(input,expand_input: false)
+      if expand_input
+        xor_all_with(input)
+      else
+        xor_bytes(bytes_from_any(input))
+      end
+    end
 
+    def xor_all_with(input)
+      expanded = expand_bytes(bytes_from_any(input),self.bytes.length)
+      xor_bytes(expanded)
+    end
 
-  # Returns an array of the nth least sigificant by bit of each byte
-  def nth_bits(n)
-    raise OutOfRangeError if n < 0
-    raise OutOfRangeError if n > 7
+
+    def xor_space
+      xor(0x20,expand_input: true)
+    end
+    private
     
-    bits.map{|b| b.reverse[n].to_i }
-  end
-  
-  def bits
-    map{|b| "%08d" % b.to_s(2) }
-  end
+    def xor_bytes(byt)
+      len = [self.bytes.size,byt.size].min
+      result = self.bytes[0...len].map.with_index{|b,i| b ^ byt[i] } + self.bytes[len,self.bytes.length - len]
+      self.class.new(result)
+    end
+
+    def xor_hex(hex)
+      x = hex2bytes(hex)
+      xor_bytes(x)
+    end
 
-  def modulus(mod)
-    real_mod = sanitize_modulus(mod)
-    CryptBuffer( bytes.map{|b| b % real_mod } )
   end
 
+  module ByteManipulation
+    
+    def modulus(mod)
+      real_mod = sanitize_modulus(mod)
+      CryptBuffer( bytes.map{|b| b % real_mod } )
+    end
 
-  def mod_sub(n,mod: 256)
-    tmp = bytes.map do |byte|
-      val = byte.to_bn.mod_sub(n,mod).to_i
+    def mod_sub(n,mod: 256)
+      tmp = bytes.map do |byte|
+        val = byte.to_bn.mod_sub(n,mod).to_i
+      end
+      CryptBuffer(tmp)
     end
-    CryptBuffer(tmp)
-  end
 
-  def sub(n)
-    CryptBuffer( bytes.map{|byte| byte -n } )
-  end
-  def add(n, mod: 256, offset: 0)
-    real_mod = [256,mod].min
+    def sub(n)
+      CryptBuffer( bytes.map{|byte| byte -n } )
+    end
+    
+    def add(n, mod: 256, offset: 0)
+      real_mod = [256,mod].min
 
-    tmp = bytes.map do |b|
-      val = (b + n) % real_mod
-      val >= offset ? val : val+offset
+      tmp = bytes.map do |b|
+        val = (b + n) % real_mod
+        val >= offset ? val : val+offset
+      end
+      CryptBuffer(tmp)
     end
-    CryptBuffer(tmp)
   end
 
 
-  def xor_at(input,pos)
-    return self if input.nil? || (pos.abs > length)
+  module PrettyPrint
+    def pp
+      puts pretty_hexstr
+    end
     
-    case input
-    when Array
-      # map our current data to xor all inputs with the given bytepos.
-      # all other bytes are kept as they were
-      tmp = bytes.map.with_index{|b,i| i == pos ? xor_multiple(b,input) : b }
-      CryptBuffer(tmp)
-    else
-      tmp = bytes
-      tmp[pos] = tmp[pos] ^ input
-      CryptBuffer(tmp)
-    end 
-  end
-  
-  def xor(input,expand_input: false)
-    if expand_input
-      xor_all_with(input)
-    else
-      xor_bytes(bytes_from_any(input))
+    private
+    def pretty_hexstr
+      str = h.scan(/.{2}/).to_a.join(" ")
+      "0x#{h.upcase} (#{str.upcase})"
     end
   end
+end
 
-  def xor_all_with(input)
-    expanded = expand_bytes(bytes_from_any(input),self.bytes.length)
-    xor_bytes(expanded)
-  end
 
-  def pp
-    puts pretty_hexstr
+
+class CryptBuffer
+  class OutOfRangeError < RuntimeError; end
+
+
+  include CryptBufferAspect::Convertable
+  include CryptBufferAspect::Comparable
+  include CryptBufferAspect::Xorable
+  include CryptBufferAspect::ByteManipulation
+  include CryptBufferAspect::PrettyPrint
+  include CryptBufferAspect::ByteExpander
+  
+  extend Forwardable
+  def_delegators :@bytes, :[], :empty?,:include?, :length
+
+
+  attr_accessor :bytes
+  alias_method :b, :bytes
+
+  
+  def initialize(input)
+    @bytes = bytes_from_any(input)
   end
 
-  def xor_space
-    xor(0x20,expand_input: true)
+  # Make sure input strings are always interpreted as hex strings
+  # This is especially useful for unknown or uncertain inputs like
+  # strings with or without leading 0x
+  def self.from_hex(input)
+    hexstr =""
+    unless input.nil?
+      hexstr = (input =~ /^0x/ ? input : "0x#{pad_hex_char(input)}" )
+    end
+    CryptBuffer.new(hexstr)
   end
 
-  def ==(other)
-    bytes == bytes_from_any(other)
+  include Enumerable
+  def each(&block)
+    @bytes.each(&block)
   end
 
-  def to_s
-    str
+
+  # Returns an array of the nth least sigificant by bit of each byte
+  def nth_bits(n)
+    raise OutOfRangeError if n < 0
+    raise OutOfRangeError if n > 7
+    
+    bits.map{|b| b.reverse[n].to_i }
+  end
+  
+  def chunks_of(n)
+    self.bytes.each_slice(n).map{|chunk| CryptBuffer(chunk) }
   end
 
+  
   private
   def sanitize_modulus(mod)
     (mod > 0) ? mod : 256
   end
-  def expand_bytes(input,total)
-    if input.length >= total
-      input
-    else
-      n = total / input.length
-      rest = total % input.length
 
-      # expand the input to the full length of the internal data
-      (input * n) + input[0,rest]
-    end
-  end
   def xor_multiple(byte,bytes)
     ([byte] + bytes).reduce(:^)
   end
@@ -188,18 +249,6 @@ class CryptBuffer
     raise "remove 0x from hexinput"
   end
 
-
-  def xor_bytes(byt)
-    len = [self.bytes.size,byt.size].min
-    result = self.bytes[0...len].map.with_index{|b,i| b ^ byt[i] } + self.bytes[len,self.bytes.length - len]
-    CryptBuffer.new(result)
-  end
-
-  def xor_hex(hex)
-    x = hex2bytes(hex)
-    xor_bytes(x)
-  end
-
   def hex2bytes(hexstr)
     hexstr.scan(/../).map{|h| h.to_i(16) }
   end
@@ -208,14 +257,7 @@ class CryptBuffer
     str.bytes.to_a
   end
 
-  def bytes2hex(bytes)
-    bytes.map{|b| b.to_s(16)}.map{|hs| hs.length == 1 ? "0#{hs}" : hs  }.join
-  end
 
-  def pretty_hexstr
-    str = h.scan(/.{2}/).to_a.join(" ")
-   "0x#{h.upcase} (#{str.upcase})"
-  end
 end
 
 def CryptBuffer(input)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crypto-toolbox
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.1.0
 platform: ruby
 authors:
 - Dennis Sivia