crypt 1.1.4 → 2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 52adac97c724e6cda38884007042b2eda55fc299
+  data.tar.gz: a017aaec965e38ea808116495ddc84ed94048f94
+SHA512:
+  metadata.gz: 97bb5b0bed207146235d0285d78c6435cee219544eee140c8c9aa86b7d70b7437ad657d930f44a3cdaa3face1ef937f62ff16e58e6dd58daa3b84a088714050b
+  data.tar.gz: 51fec804a2c85eba54a33c81ee4b980636cb9a8e6015c033260acc26812eac511d99f569f13f7802b776038e0bb760cf71ad3f4d8d73ecd1b14e49a9960e79ce

data/crypt/blowfish.rb

@@ -5,20 +5,15 @@
 
 module Crypt
 class Blowfish
-  
+
   require 'crypt/cbc'
   include Crypt::CBC
-  
+
   require 'crypt/blowfish-tables'
   include Crypt::BlowfishTables
-  
+
   ULONG = 0x100000000
-  
-  def block_size
-    return(8)
-  end
-  
-  
+
   def initialize(key)
     @key = key
     raise "Bad key length: the key must be 1-56 bytes." unless (key.length.between?(1,56))
@@ -26,8 +21,11 @@ class Blowfish
     @sBoxes = []
     setup_blowfish()
   end
-  
-  
+
+  def block_size()
+    8
+  end
+
   def f(x)
     a, b, c, d = [x].pack('N').unpack('CCCC')
     y = (@sBoxes[0][a] + @sBoxes[1][b]) % ULONG
@@ -35,8 +33,8 @@ class Blowfish
     y = (y + @sBoxes[3][d]) % ULONG
     return(y)
   end
-  
-  
+
+
   def setup_blowfish()
     @sBoxes = Array.new(4) { |i| INITIALSBOXES[i].clone }
     @pArray = INITIALPARRAY.clone
@@ -44,7 +42,8 @@ class Blowfish
     0.upto(17) { |i|
       data = 0
       4.times {
-        data = ((data << 8) | @key[keypos]) % ULONG
+        k = @key[keypos].ord()    # ruby 2.0
+        data = ((data << 8) | k) % ULONG
         keypos = (keypos.next) % @key.length
       }
       @pArray[i] = (@pArray[i] ^ data) % ULONG
@@ -64,7 +63,7 @@ class Blowfish
       }
     }
   end
-  
+
   def encrypt_pair(xl, xr)
     0.upto(15) { |i|
         xl = (xl ^ @pArray[i]) % ULONG
@@ -76,8 +75,8 @@ class Blowfish
     xl = (xl ^ @pArray[17]) % ULONG
     return([xl, xr])
   end
-  
-  
+
+
   def decrypt_pair(xl, xr)
     17.downto(2) { |i|
         xl = (xl ^ @pArray[i]) % ULONG
@@ -89,22 +88,25 @@ class Blowfish
     xl = (xl ^ @pArray[0]) % ULONG
     return([xl, xr])
   end
-  
-  
+
+
   def encrypt_block(block)
+    block = block.force_encoding("ASCII-8BIT") # to treat unicode characters as two bytes
+    raise "block must be #{block_size()} bytes long" if (block.length() != block_size())
     xl, xr = block.unpack('NN')
     xl, xr = encrypt_pair(xl, xr)
     encrypted = [xl, xr].pack('NN')
     return(encrypted)
   end
-  
-  
+
+
   def decrypt_block(block)
+    raise "block must be #{block_size()} bytes long" if (block.length() != block_size())
     xl, xr = block.unpack('NN')
     xl, xr = decrypt_pair(xl, xr)
     decrypted = [xl, xr].pack('NN')
     return(decrypted)
   end
-  
+
+end
 end
-end

data/crypt/cbc.rb

@@ -2,43 +2,42 @@
 
 module Crypt
 module CBC
-  
+
   require 'stringio'
   require 'crypt/stringxor'
-  
+
   ULONG = 0x100000000
-  
+
   # When this module is mixed in with an encryption class, the class
   # must provide three methods: encrypt_block(block) and decrypt_block(block)
   # and block_size()
-  
-  
+
+
   def generate_initialization_vector(words)
     srand(Time.now.to_i)
-    vector = ""
+    vector = "".force_encoding("ASCII-8BIT")  # stop ruby 2 using Unicode
     words.times {
       vector << [rand(ULONG)].pack('N')
     }
     return(vector)
   end
-  
-  
+
+
   def encrypt_stream(plainStream, cryptStream)
     # Cypher-block-chain mode
-    
+
     initVector = generate_initialization_vector(block_size() / 4)
     chain = encrypt_block(initVector)
     cryptStream.write(chain)
 
     while ((block = plainStream.read(block_size())) && (block.length == block_size()))
-      block = block ^ chain 
+      block = block ^ chain
       encrypted = encrypt_block(block)
       cryptStream.write(encrypted)
       chain = encrypted
     end
-   
     # write the final block
-    # At most block_size()-1 bytes can be part of the message. 
+    # At most block_size()-1 bytes can be part of the message.
     # That means the final byte can be used to store the number of meaningful
     # bytes in the final block
     block = '' if block.nil?
@@ -52,8 +51,8 @@ module CBC
     encrypted = encrypt_block(block)
     cryptStream.write(encrypted)
   end
-  
-  
+
+
   def decrypt_stream(cryptStream, plainStream)
     # Cypher-block-chain mode
     chain = cryptStream.read(block_size())
@@ -64,26 +63,25 @@ module CBC
       plainStream.write(plainText) unless cryptStream.eof?
       chain = block
     end
-    
     # write the final block, omitting the padding
     buffer = plainText.split('')
     remainingMessageBytes = buffer.last.unpack('C').first
     remainingMessageBytes.times { plainStream.write(buffer.shift) }
   end
-  
-  
+
+
   def carefully_open_file(filename, mode)
     begin
       aFile = File.new(filename, mode)
     rescue
       puts "Sorry. There was a problem opening the file <#{filename}>."
-      aFile.close() unless aFile.nil?
+      aFile.close() unless aFile.nil? || aFile.closed?
       raise
     end
     return(aFile)
   end
-  
-  
+
+
   def encrypt_file(plainFilename, cryptFilename)
     plainFile = carefully_open_file(plainFilename, 'rb')
     cryptFile = carefully_open_file(cryptFilename, 'wb+')
@@ -91,8 +89,8 @@ module CBC
     plainFile.close unless plainFile.closed?
     cryptFile.close unless cryptFile.closed?
   end
-  
-  
+
+
   def decrypt_file(cryptFilename, plainFilename)
     cryptFile = carefully_open_file(cryptFilename, 'rb')
     plainFile = carefully_open_file(plainFilename, 'wb+')
@@ -100,8 +98,8 @@ module CBC
     cryptFile.close unless cryptFile.closed?
     plainFile.close unless plainFile.closed?
   end
-  
-  
+
+
   def encrypt_string(plainText)
     plainStream = StringIO.new(plainText)
     cryptStream = StringIO.new('')
@@ -109,8 +107,8 @@ module CBC
     cryptText = cryptStream.string
     return(cryptText)
   end
-  
-  
+
+
   def decrypt_string(cryptText)
     cryptStream = StringIO.new(cryptText)
     plainStream = StringIO.new('')
@@ -118,6 +116,6 @@ module CBC
     plainText = plainStream.string
     return(plainText)
   end
-  
+
+end
 end
-end

data/crypt/idea.rb

@@ -1,54 +1,54 @@
 # idea.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
 
-# IDEA (International Data Encryption Algorithm) by 
+# IDEA (International Data Encryption Algorithm) by
 # Xuejia Lai and James Massey (1992).  Refer to license info at end.
 # Ported by Richard Kernahan 2005
 
 module Crypt
 class IDEA
-  
+
   require 'crypt/cbc'
   include Crypt::CBC
 
   require 'digest/md5'
-  
+
   ULONG   = 0x100000000
   USHORT  = 0x10000
-  
+
   ENCRYPT = 0
   DECRYPT = 1
-  
-  
+
+
   def block_size
     return(8)
   end
-  
-  
+
+
   def initialize(key128, mode)
     # IDEA is subject to attack unless the key is sufficiently random, so we
     # take an MD5 digest of a variable-length passphrase to ensure a solid key
-    if (key128.class == String)  
-      digest = Digest::MD5.new(key128).digest
+    if (key128.class == String)
+      digest = Digest::MD5.new().digest(key128)
       key128 = digest.unpack('n'*8)
     end
     raise "Key must be 128 bits (8 words)" unless (key128.class == Array) && (key128.length == 8)
     raise "Mode must be IDEA::ENCRYPT or IDEA::DECRYPT" unless ((mode == ENCRYPT) | (mode == DECRYPT))
     if (mode == ENCRYPT)
       @subkeys = generate_encryption_subkeys(key128)
-    else (mode == DECRYPT)
+    else
       @subkeys = generate_decryption_subkeys(key128)
     end
   end
-  
-  
+
+
   def mul(a, b)
     modulus = 0x10001
     return((1 - b) % USHORT) if (a == 0)
     return((1 - a) % USHORT) if (b == 0)
     return((a * b) % modulus)
   end
-  
-  
+
+
   def mulInv(x)
     modulus = 0x10001
     x = x.to_i % USHORT
@@ -72,8 +72,8 @@ class IDEA
     inv = (1 - t1) & 0xFFFF
     return(inv)
   end
-  
-  
+
+
   def generate_encryption_subkeys(key)
     encrypt_keys = []
     encrypt_keys[0..7] = key.dup
@@ -84,8 +84,8 @@ class IDEA
     }
     return(encrypt_keys)
   end
-  
-  
+
+
   def generate_decryption_subkeys(key)
     encrypt_keys = generate_encryption_subkeys(key)
     decrypt_keys = []
@@ -108,8 +108,8 @@ class IDEA
     }
     return(decrypt_keys)
   end
-  
-  
+
+
   def crypt_pair(l, r)
     word = [l, r].pack('NN').unpack('nnnn')
     k = @subkeys[0..51]
@@ -137,15 +137,15 @@ class IDEA
     twoLongs = result.pack('nnnn').unpack('NN')
     return(twoLongs)
   end
-  
+
   def encrypt_block(block)
     xl, xr = block.unpack('NN')
     xl, xr = crypt_pair(xl, xr)
     encrypted = [xl, xr].pack('NN')
     return(encrypted)
   end
-  
-  
+
+
   def decrypt_block(block)
     xl, xr = block.unpack('NN')
     xl, xr = crypt_pair(xl, xr)
@@ -167,27 +167,26 @@ end
   # the algorithm for commercial purposes is thus subject to a license from Ascom
   # Systec Ltd. of CH-5506 Maegenwil (Switzerland), being the patentee and sole
   # owner of all rights, including the trademark IDEA.
-  # 
+  #
   # Commercial purposes shall mean any revenue generating purpose including but
   # not limited to:
-  # 
+  #
   # i) Using the algorithm for company internal purposes (subject to a site
   #    license).
-  # 
+  #
   # ii) Incorporating the algorithm into any software and distributing such
   #     software and/or providing services relating thereto to others (subject to
   #     a product license).
-  # 
+  #
   # iii) Using a product containing the algorithm not covered by an IDEA license
   #      (subject to an end user license).
-  # 
+  #
   # All such end user license agreements are available exclusively from Ascom
   # Systec Ltd and may be requested via the WWW at http://www.ascom.ch/systec or
   # by email to idea@ascom.ch.
-  # 
+  #
   # Use other than for commercial purposes is strictly limited to non-revenue
   # generating data transfer between private individuals.  The use by government
   # agencies, non-profit organizations, etc is considered as use for commercial
   # purposes but may be subject to special conditions.  Any misuse will be
   # prosecuted.
-

data/crypt/noise.rb

@@ -17,7 +17,7 @@ module Noise
       puts "is #{minimumNewLength} bytes which allows for no noise in the message."
       puts "You should choose an obscured length of at least double the clear text"
       puts "length, such as #{message.length / 8 * 32} bytes"
-      raise "Insufficient length for noisy message" 
+      raise "Insufficient length for noisy message"
     end
     bitmap = []
     usableNoisyMessageLength.times { bitmap << false }
@@ -32,8 +32,8 @@ module Noise
         positionsSelected = positionsSelected.next
       end
     end
-    
-    noisyMessage = ""
+
+    noisyMessage = "".force_encoding("ASCII-8BIT")  # stop ruby 2 using Unicode
     0.upto(bitmapSize-1) { |byte|
       c = 0
       0.upto(7) { |bit|
@@ -58,17 +58,17 @@ module Noise
     }
     return(noisyMessage)
   end
-  
-  
+
+
   def remove_noise
     noisyMessage = self
     bitmapSize = noisyMessage.length / 9
     actualMessageLength =  bitmapSize * 8
-    
+
     actualMessageStart = bitmapSize
     actualMessageFinish = bitmapSize + actualMessageLength - 1
     actualMessage = noisyMessage[actualMessageStart..actualMessageFinish]
-    
+
     bitmap = []
     0.upto(bitmapSize - 1) { |byte|
       c = noisyMessage[byte]
@@ -76,7 +76,7 @@ module Noise
         bitmap[byte * 8 + bit] = (c[bit] == 1)
       }
     }
-    clearMessage = ""
+    clearMessage = "".force_encoding("ASCII-8BIT")  # stop ruby 2 using Unicode
     0.upto(actualMessageLength) { |pos|
       meaningful = bitmap[pos]
       if meaningful
@@ -85,10 +85,10 @@ module Noise
     }
     return(clearMessage)
   end
-  
+
 end
 end
 
 class String
   include Crypt::Noise
-end
+end