crypt 1.1.3 → 2.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07de2fdabf4cc3650b826ccac32ac579233f4af0
+  data.tar.gz: de13a85d6748f2a22fb8bdc52db8d1ae976f4242
+SHA512:
+  metadata.gz: 4690385b4b75cb6b991fa28ba778680efc3593af479be399ce2792f5d0ab7035fb7bf38ee3d2be443f34b1b545ac5e01a04f3a99d165d4f3d1c359be7e2c09e8
+  data.tar.gz: 63a59b1f09d8d8cd298f936960b4a7cca07e71a343a7a1f89342fec3f3cb452af7f14394292e12789f39ba65d4ac9aca78a9e8084da5bc87e449471c0dfbeb43

data/CREDITS

@@ -0,0 +1,13 @@
+# CREDITS
+
+The Blowfish code was adapted from Bruce Schneier's reference C code 
+(http://www.schneier.com/blowfish-download.html)
+
+The GOST code was adapted from Wei Dai's C++ code from the Crypto++ project 
+(http://sourceforge.net/projects/cryptopp).
+
+The IDEA code was based on the reference C implementation once published by MediaCrypt 
+(http://web.archive.org/web/20000816173624/www.ascom.ch/infosec/downloads.html)
+
+The Rijndael code was adapted from the reference ANSI C code by Paulo Barreto and Vincent Rijmen.
+(http://www.esat.kuleuven.ac.be/~rijmen/rijndael/rijndael-fst-3.0.zip)

data/LICENSE

@@ -0,0 +1,6 @@
+# LICENSE
+
+This work is placed in the public domain.
+Blowfish, GOST, IDEA, and Rijndael are freely available for use.
+
+IDEA is no longer under patent.

data/README

@@ -0,0 +1,10 @@
+# README
+
+The Crypt library is a pure-ruby implementation of a number of popular
+encryption algorithms. Block cyphers currently include Blowfish, GOST, IDEA,
+and Rijndael (AES). Cypher Block Chaining (CBC) has been implemented. 
+
+Crypt is written entirely in ruby so deployment is simple - no platform
+concerns, no library dependencies, nothing to compile.
+
+This work is placed in the public domain.

data/{crypt → lib/crypt}/blowfish-tables.rb

@@ -1,5 +1,61 @@
-# blowfish-tables.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
+#The Crypt library is a pure-ruby implementation of a number of popular encryption algorithms.
+#Block cyphers currently available include Blowfish, GOST, IDEA, and Rijndael (AES).
+#Cypher Block Chaining (CBC) has been implemented.
+#
+#Crypt is written entirely in ruby so deployment is simple - no platform concerns,
+#no library dependencies, nothing to compile.
+#
+#Performance is what you would expect from a pure-ruby implementation: it is adequate for shorter messages
+#but I wouldn't try to encrypt my whole disk with it. If performance is critical then you might want to try
+#ezcrypto's (http://ezcrypto.rubyforge.org) interface to OpenSSL.
+#
+#v.2.2.0 released 23 Sep 2015 fixes a defect in IDEA and replaces tests with specs.
+#
+#    require 'crypt/blowfish'
+#    blowfish = Crypt::Blowfish.new("A key up to 56 bytes long")
+#    plainBlock = "ABCD1234"
+#    encryptedBlock = blowfish.encrypt_block(plainBlock)
+#    decryptedBlock = blowfish.decrypt_block(encryptedBlock)
+#		 string = "This is a string which is not a multiple of 8 characters long"
+#    encryptedString = bf.encrypt_string(string)
+#    decryptedString = bf.decrypt_string(encryptedString)
+#		bf.encrypt_file('plain.txt', 'crypt.txt')
+#    bf.decrypt_file('crypt.txt', 'decrypt.txt')
+#
+#    require 'crypt/gost' 
+#    # a key shorter than 32 bytes will be padded out with zeroes
+#    gost = Crypt::Gost.new("This is a contrived 32 byte key!")
+#    plainBlock = "ABCD1234"
+#    encryptedBlock = gost.encrypt_block(plainBlock)
+#    decryptedBlock = gost.decrypt_block(encryptedBlock)
+#
+#    require 'crypt/idea' 
+#    idea = Crypt::IDEA.new("A key up to 56 bytes long")
+#    plainBlock = "ABCD1234"
+#    encryptedBlock = idea.encrypt_block(plainBlock)
+#    decryptedBlock = idea.decrypt_block(encryptedBlock)
+#
+#    require 'crypt/rijndael' 
+#    rijndael = Crypt::Rijndael.new("A key 16, 24, or 32 bytes length")
+#    plainBlock = "ABCDEFGH12345678"
+#    encryptedBlock = rijndael.encrypt_block(plainBlock)
+#    decryptedBlock = rijndael.decrypt_block(encryptedBlock)
+#
+#Cipher-block chaining (CBC) is supported for each algorithm:
+#
+#    blowfish = Crypt::Blowfish.new("A sample key better than this one")
+#    blowfish.encrypt_file('plain.txt', 'crypt.txt')
+#    blowfish.decrypt_file('crypt.txt', 'plain.txt')
+#
+#You can also read from a plain text stream,
+#encrypt and write to an encrypted output stream, or treat a string as a stream:
+#
+#    f = File.new('plain.txt', 'r')
+#    g = TCPSocket.new('encrypted.example.com', 2222)
+#    blowfish.encrypt_stream(f, g)
+# 
+#    plainText = "This is plain text."
+#    encrypted = blowfish.encrypt_string(plainText)
 module Crypt
 module BlowfishTables
   
@@ -187,4 +243,4 @@ module BlowfishTables
   
 
 end
-end
+end

data/{crypt → lib/crypt}/blowfish.rb

@@ -1,24 +1,18 @@
-# blowfish.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+module Crypt
+# blowfish.rb  Richard Kernahan 
 #
 #  Blowfish algorithm by Bruce Schneider
 #  Ported by Richard Kernahan from the reference C code
-
-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 +20,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 +32,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 +41,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 +62,7 @@ class Blowfish
       }
     }
   end
-  
+
   def encrypt_pair(xl, xr)
     0.upto(15) { |i|
         xl = (xl ^ @pArray[i]) % ULONG
@@ -76,8 +74,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 +87,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 → lib/crypt}/cbc.rb

@@ -1,59 +1,58 @@
-# cbc.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
 module Crypt
+
+# cbc.rb  Richard Kernahan 
 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?
     buffer = block.split('')
     remainingMessageBytes = buffer.length
+    # we use 7-bit characters to avoid possible strange behavior on the Mac
     remainingMessageBytes.upto(block_size()-2) { buffer << rand(128).chr }
     buffer << remainingMessageBytes.chr
     block = buffer.join('')
     block = block ^ chain
     encrypted = encrypt_block(block)
     cryptStream.write(encrypted)
-    chain = encrypted
   end
-  
-  
+
+
   def decrypt_stream(cryptStream, plainStream)
     # Cypher-block-chain mode
     chain = cryptStream.read(block_size())
@@ -64,44 +63,43 @@ 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.closed?
+      aFile.close() unless aFile.nil? || aFile.closed?
       raise
     end
     return(aFile)
   end
-  
-  
+
+
   def encrypt_file(plainFilename, cryptFilename)
-    plainFile = carefully_open_file(plainFilename, 'br')
-    cryptFile = carefully_open_file(cryptFilename, 'bw+')
+    plainFile = carefully_open_file(plainFilename, 'rb')
+    cryptFile = carefully_open_file(cryptFilename, 'wb+')
     encrypt_stream(plainFile, cryptFile)
     plainFile.close unless plainFile.closed?
     cryptFile.close unless cryptFile.closed?
   end
-  
-  
+
+
   def decrypt_file(cryptFilename, plainFilename)
-    cryptFile = carefully_open_file(cryptFilename, 'br')
-    plainFile = carefully_open_file(plainFilename, 'bw+')
+    cryptFile = carefully_open_file(cryptFilename, 'rb')
+    plainFile = carefully_open_file(plainFilename, 'wb+')
     decrypt_stream(cryptFile, plainFile)
     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 → lib/crypt}/gost.rb

@@ -1,9 +1,8 @@
+module Crypt
 # gost.rb  
-# Adapted by Richard Kernahan <kernighan_rich@rubyforge.org> 
+# Adapted by Richard Kernahan 
 # from C++ code written by Wei Dai 
 # of the Crypto++ project http://www.eskimo.com/~weidai/cryptlib.html
-
-module Crypt
 class Gost
 
   require 'crypt/cbc'
@@ -137,4 +136,4 @@ class Gost
 
 
 end
-end
+end

data/{crypt → lib/crypt}/idea.rb

@@ -1,59 +1,55 @@
-# idea.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+module Crypt
+# idea.rb  Richard Kernahan 
 
-# IDEA (International Data Encryption Algorithm) by 
-# Xuejia Lai and James Massey (1992).  Refer to license info at end.
-# Ported by Richard Kernahan 2005
+# IDEA (International Data Encryption Algorithm) by
+# Xuejia Lai and James Massey (1992). 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
   
-  
+  attr_accessor(:subkeys)
+
   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
-      key128 = digest.unpack('n'*8)
+    if (key128.class == String)
+      digest = Digest::MD5.new().digest(key128.b).b()
+      key128 = digest.unpack('n8')
     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)
+    return((a * b) % modulus % USHORT)   # fixed with % USHORT
   end
-  
-  
+
   def mulInv(x)
     modulus = 0x10001
-    x = x.to_i % USHORT
+    x = x.to_i % 0x10000
     return(x) if (x <= 1)
-    t1 = 0x10000 / x
+    t1 = modulus / x
     y  = modulus % x
     if (y == 1)
       inv = (1 - t1) & 0xFFFF
@@ -72,11 +68,10 @@ class IDEA
     inv = (1 - t1) & 0xFFFF
     return(inv)
   end
-  
-  
+
   def generate_encryption_subkeys(key)
     encrypt_keys = []
-    encrypt_keys[0..7] = key
+    encrypt_keys[0..7] = key.dup
     8.upto(51) { |i|
       a = ((i + 1) % 8 > 0) ? (i-7)  : (i-15)
       b = ((i + 2) % 8 < 2) ? (i-14) : (i-6)
@@ -84,8 +79,7 @@ class IDEA
     }
     return(encrypt_keys)
   end
-  
-  
+
   def generate_decryption_subkeys(key)
     encrypt_keys = generate_encryption_subkeys(key)
     decrypt_keys = []
@@ -97,7 +91,7 @@ class IDEA
       decrypt_keys[i+4] = encrypt_keys.shift % USHORT
       decrypt_keys[i+5] = encrypt_keys.shift % USHORT
       decrypt_keys[i]   = mulInv(encrypt_keys.shift)
-      if (i ==0)
+      if (i == 0)
         decrypt_keys[1] = (-encrypt_keys.shift) % USHORT
         decrypt_keys[2] = (-encrypt_keys.shift) % USHORT
       else
@@ -108,8 +102,7 @@ class IDEA
     }
     return(decrypt_keys)
   end
-  
-  
+
   def crypt_pair(l, r)
     word = [l, r].pack('NN').unpack('nnnn')
     k = @subkeys[0..51]
@@ -137,15 +130,14 @@ 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)
@@ -153,41 +145,6 @@ class IDEA
     return(decrypted)
   end
 
-
 end
 end
 
-  # LICENSE INFORMATION
-  #
-  # This software product contains the IDEA algorithm as described and claimed in
-  # US patent 5,214,703, EPO patent 0482154 (covering Austria, France, Germany,
-  # Italy, the Netherlands, Spain, Sweden, Switzerland, and the UK), and Japanese
-  # patent application 508119/1991, "Device for the conversion of a digital block
-  # and use of same" (hereinafter referred to as "the algorithm").  Any use of
-  # 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 → lib/crypt}/noise.rb

@@ -1,9 +1,9 @@
-# crypt/rattle.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+module Crypt
+# crypt/noise.rb  Richard Kernahan 
 
 # add_noise - take a message and intersperse noise to make a new noisy message of given byte-length
 # remove_noise - take a noisy message and extract the message
 
-module Crypt
 module Noise
 
   def add_noise(newLength)
@@ -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

data/{crypt → lib/crypt}/rijndael-tables.rb

@@ -1,6 +1,5 @@
-# rijndael-tables.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
 module Crypt
+# rijndael-tables.rb  
 module RijndaelTables
 
 LogTable = [
@@ -114,4 +113,4 @@ Shifts = [
 ]
 
 end
-end
+end