jamescook-ezcrypto 0.7.4

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: crypto_test.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: crypto_test.sqlite3.db
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: crypto_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: crypto_test

data/test/digest_test.rb

@@ -0,0 +1,50 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+require 'ezcrypto'
+require 'digest/sha1'
+
+class DigestTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_digest
+    ["hello","","test"].each do |data|
+      assert_equal Digest::SHA1.digest(data)[0..15],EzCrypto::Digester.digest(data)
+    end
+  end
+  
+  def test_digest64
+    ["hello","","test"].each do |data|
+      assert_equal [Digest::SHA1.digest(data)[0..15]].pack('m'),EzCrypto::Digester.digest64(data)
+    end    
+  end
+  
+  def test_hexdigest
+    ["hello","","test"].each do |data|
+      assert_equal Digest::SHA1.hexdigest(data)[0..40],EzCrypto::Digester.hexdigest(data)
+    end
+  end
+  
+  def test_generate_key
+    key=EzCrypto::Digester.generate_key
+    assert 16,key.size
+  end
+  
+  def test_generate_key64
+    key=EzCrypto::Digester.generate_key64
+    assert 24,key.size
+    
+  end
+  
+  def test_generate_hexkey
+    key=EzCrypto::Digester.generate_hexkey
+    assert 40,key.size
+    
+  end
+  
+  def test_get_key
+    
+  end
+end

data/test/dsakey.pem

@@ -0,0 +1,12 @@
+-----BEGIN DSA PRIVATE KEY-----
+MIIBugIBAAKBgQCGwFYmCsY6XeXmC2vB2VwGy7N4jV0vjwTh22VAXLlMtKrjJJ0k
+WW/QI7wYWqttUIDQ1//ETRlW5+uV9E9WF1EtMo/Dv48LU/c1YCDjA5EAp2Wu/CnU
+Qgd6ibLNTvkzSDdiZhryuq3nv0s1hLR6cysMOWg/l6usiwU5jgWDXrMK2wIVAJS8
+gadASb6W8ZL6Ua4EqIFdYCdbAoGAWzwV5WF157O/oZeOmNv6IuV8MLD0m3JkJNkZ
+DrY0G0M7YIVryCkmvCOuu8PLu7M+GGp9hEKV/wrpWJgiOlWAz0C0yxwxMyz3GFbx
+ipqEL0CqKkl4QVMpKAhL1h2iIL+yI7p/8whcfeMnQXb0iIMD7AVvF++AJ/LAzulb
+zZXdfP8CgYApedgToseniE9KWVrV3CMXrkwf3Er5CgcVF2JJWAfBbm8/PI2wX5GU
+zT5++k+2sPISPQV3RFZiVKwdFNdft41KNNdfFPEC/4KhgHbK4nCJ3ReLiy2+MkHi
+msgzvxAg8WRc+0aZKNFlNyqsIezE6ufs8e9YvKZJ2d30ggOqCHTBtgIUZ6jIgX60
+PmOeqfRh32svQkP1p/E=
+-----END DSA PRIVATE KEY-----

data/test/dsapubkey.pem

@@ -0,0 +1,12 @@
+-----BEGIN PUBLIC KEY-----
+MIIBtjCCASsGByqGSM44BAEwggEeAoGBAIbAViYKxjpd5eYLa8HZXAbLs3iNXS+P
+BOHbZUBcuUy0quMknSRZb9AjvBhaq21QgNDX/8RNGVbn65X0T1YXUS0yj8O/jwtT
+9zVgIOMDkQCnZa78KdRCB3qJss1O+TNIN2JmGvK6ree/SzWEtHpzKww5aD+Xq6yL
+BTmOBYNeswrbAhUAlLyBp0BJvpbxkvpRrgSogV1gJ1sCgYBbPBXlYXXns7+hl46Y
+2/oi5XwwsPSbcmQk2RkOtjQbQztghWvIKSa8I667w8u7sz4Yan2EQpX/CulYmCI6
+VYDPQLTLHDEzLPcYVvGKmoQvQKoqSXhBUykoCEvWHaIgv7Ijun/zCFx94ydBdvSI
+gwPsBW8X74An8sDO6VvNld18/wOBhAACgYApedgToseniE9KWVrV3CMXrkwf3Er5
+CgcVF2JJWAfBbm8/PI2wX5GUzT5++k+2sPISPQV3RFZiVKwdFNdft41KNNdfFPEC
+/4KhgHbK4nCJ3ReLiy2+MkHimsgzvxAg8WRc+0aZKNFlNyqsIezE6ufs8e9YvKZJ
+2d30ggOqCHTBtg==
+-----END PUBLIC KEY-----

data/test/dsig_test.rb

@@ -0,0 +1,287 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+require 'fileutils'
+require 'ezsig'
+
+class EzCryptoTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def _test_generate_key #very slow so not run by default
+    signer=EzCrypto::Signer.generate
+    assert signer.rsa?
+    assert !signer.dsa?
+    
+    assert_signer(signer)
+  end
+  
+  def test_from_file
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/testsigner.pem"
+    assert signer.rsa?
+    assert !signer.dsa?
+    assert_signer(signer)
+  end
+
+  def test_dsa_from_file
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/dsakey.pem"
+    assert signer.dsa?
+    assert !signer.rsa?
+    assert_signer(signer)
+  end
+
+  def test_from_password_protected_file
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/protectedsigner.pem","secret"
+    assert signer.rsa?
+    assert !signer.dsa?
+    assert_signer(signer)
+  end
+  
+  def test_public_key_read
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/testsigner.pem"
+    verifier=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testpub.pem"
+    assert verifier
+    sig=signer.sign "test this rsa"
+    assert sig
+    assert verifier.verify( sig,"test this rsa")
+
+    assert !verifier.cert?
+    assert_equal signer.public_key.to_s, verifier.public_key.to_s
+  end
+  
+  def test_dsa_public_key_read
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/dsakey.pem"
+    verifier=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/dsapubkey.pem"
+    
+    assert verifier
+    sig=signer.sign "test this dsa"
+    assert sig
+    assert verifier.verify( sig,"test this dsa")
+
+    assert !verifier.cert?
+    
+    # This fails as it seems like it returns an incorrect public key
+#    assert_equal signer.public_key.to_s, verifier.public_key.to_s
+  end
+  
+  def test_certificate_reader
+    signer=EzCrypto::Signer.from_file File.dirname(__FILE__) + "/testsigner.pem"
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert cert
+    assert cert.cert?
+    assert_instance_of EzCrypto::Certificate, cert
+    assert_equal signer.public_key.to_s, cert.public_key.to_s
+    
+    sig=signer.sign "hello"
+    assert sig
+    assert cert.verify( sig,"hello")
+    
+    assert_equal "/C=DK/ST=Denmark/L=Copenhagen/O=EzCrypto Test Certificate/OU=testing/CN=EzCrypto Testing/emailAddress=pelleb@gmail.com",cert.subject.to_s
+    assert_equal "/C=DK/ST=Denmark/L=Copenhagen/O=EzCrypto Test Certificate/OU=testing/CN=EzCrypto Testing/emailAddress=pelleb@gmail.com",cert.issuer.to_s
+    
+    assert_kind_of EzCrypto::Name,cert.issuer
+    assert_kind_of EzCrypto::Name,cert.subject
+    assert cert.serial
+    assert cert.not_after
+    assert cert.not_before
+    assert cert.valid?
+    
+    
+    assert_equal cert.subject[:emailAddress],"pelleb@gmail.com"
+    assert_equal cert.subject[:C],"DK"
+    assert_equal cert.subject[:ST],"Denmark"
+    assert_equal cert.subject[:L],"Copenhagen"
+    assert_equal cert.subject[:OU],"testing"
+    assert_equal cert.subject[:O],"EzCrypto Test Certificate"
+    assert_equal cert.subject[:CN],"EzCrypto Testing"
+
+    assert_equal cert.subject.emailAddress,"pelleb@gmail.com"
+    assert_equal cert.subject.C,"DK"
+    assert_equal cert.subject.ST,"Denmark"
+    assert_equal cert.subject.L,"Copenhagen"
+    assert_equal cert.subject.OU,"testing"
+    assert_equal cert.subject.O,"EzCrypto Test Certificate"
+    assert_equal cert.subject.CN,"EzCrypto Testing"
+
+    assert_equal cert.subject.email,"pelleb@gmail.com"
+    assert_equal cert.subject.c,"DK"
+    assert_equal cert.subject.st,"Denmark"
+    assert_equal cert.subject.l,"Copenhagen"
+    assert_equal cert.subject.ou,"testing"
+    assert_equal cert.subject.o,"EzCrypto Test Certificate"
+    assert_equal cert.subject.cn,"EzCrypto Testing"
+
+    assert_equal cert.subject.country,"DK"
+    assert_equal cert.subject.state,"Denmark"
+    assert_equal cert.subject.locality,"Copenhagen"
+    assert_equal cert.subject.organisational_unit,"testing"
+    assert_equal cert.subject.organisation,"EzCrypto Test Certificate"
+    assert_equal cert.subject.organizational_unit,"testing"
+    assert_equal cert.subject.organization,"EzCrypto Test Certificate"
+    assert_equal cert.subject.name,"EzCrypto Testing"
+    assert_equal cert.subject.common_name,"EzCrypto Testing"
+
+    assert_equal cert.emailAddress,"pelleb@gmail.com"
+    assert_equal cert.C,"DK"
+    assert_equal cert.ST,"Denmark"
+    assert_equal cert.L,"Copenhagen"
+    assert_equal cert.OU,"testing"
+    assert_equal cert.O,"EzCrypto Test Certificate"
+    assert_equal cert.CN,"EzCrypto Testing"
+                     
+    assert_equal cert.email,"pelleb@gmail.com"
+    assert_equal cert.c,"DK"
+    assert_equal cert.st,"Denmark"
+    assert_equal cert.l,"Copenhagen"
+    assert_equal cert.ou,"testing"
+    assert_equal cert.o,"EzCrypto Test Certificate"
+    assert_equal cert.cn,"EzCrypto Testing"
+                     
+    assert_equal cert.country,"DK"
+    assert_equal cert.state,"Denmark"
+    assert_equal cert.locality,"Copenhagen"
+    assert_equal cert.organisational_unit,"testing"
+    assert_equal cert.organisation,"EzCrypto Test Certificate"
+    assert_equal cert.organizational_unit,"testing"
+    assert_equal cert.organization,"EzCrypto Test Certificate"
+    assert_equal cert.name,"EzCrypto Testing"
+    assert_equal cert.common_name,"EzCrypto Testing"
+
+    assert_equal cert.issuer[:emailAddress],"pelleb@gmail.com"
+    assert_equal cert.issuer[:C],"DK"
+    assert_equal cert.issuer[:ST],"Denmark"
+    assert_equal cert.issuer[:L],"Copenhagen"
+    assert_equal cert.issuer[:OU],"testing"
+    assert_equal cert.issuer[:O],"EzCrypto Test Certificate"
+    assert_equal cert.issuer[:CN],"EzCrypto Testing"
+
+    assert_equal cert.issuer.emailAddress,"pelleb@gmail.com"
+    assert_equal cert.issuer.C,"DK"
+    assert_equal cert.issuer.ST,"Denmark"
+    assert_equal cert.issuer.L,"Copenhagen"
+    assert_equal cert.issuer.OU,"testing"
+    assert_equal cert.issuer.O,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.CN,"EzCrypto Testing"
+
+    assert_equal cert.issuer.email,"pelleb@gmail.com"
+    assert_equal cert.issuer.c,"DK"
+    assert_equal cert.issuer.st,"Denmark"
+    assert_equal cert.issuer.l,"Copenhagen"
+    assert_equal cert.issuer.ou,"testing"
+    assert_equal cert.issuer.o,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.cn,"EzCrypto Testing"
+    assert_equal cert.issuer.country,"DK"
+    assert_equal cert.issuer.state,"Denmark"
+    assert_equal cert.issuer.locality,"Copenhagen"
+    assert_equal cert.issuer.organisational_unit,"testing"
+    assert_equal cert.issuer.organisation,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.organizational_unit,"testing"
+    assert_equal cert.issuer.organization,"EzCrypto Test Certificate"
+    assert_equal cert.issuer.name,"EzCrypto Testing"
+    assert_equal cert.issuer.common_name,"EzCrypto Testing"
+    
+    ## Extensions
+    
+    assert cert.extensions
+    
+  end
+  
+  def test_in_memory_store
+    trust=EzCrypto::TrustStore.new
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert !trust.verify(cert)
+    trust.add cert
+    assert trust.verify(cert)
+    
+    sf_root=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf-class2-root.crt"
+    assert !trust.verify(sf_root)
+    starfield=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf_intermediate.crt"
+    assert !trust.verify(starfield)
+    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+    assert !trust.verify(agree2)
+    
+    trust.add sf_root
+    assert trust.verify(sf_root)
+    assert trust.verify(starfield)
+    assert !trust.verify(agree2)
+    
+    trust.add starfield
+    assert trust.verify(agree2)
+  end
+  
+  def test_disk_store
+    trust=EzCrypto::TrustStore.new File.dirname(__FILE__) + "/store"
+    sf_root=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf-class2-root.crt"
+    trust.add(sf_root)
+    assert trust.verify(sf_root)
+    starfield=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf_intermediate.crt"
+    assert trust.verify(starfield)
+    trust.add(starfield)
+    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+    assert trust.verify(agree2)
+    
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert !trust.verify(cert)
+    trust.add cert
+    assert trust.verify(cert)
+  end
+  
+  def test_load_combined
+    certs=EzCrypto::Verifier.load_all_from_file File.dirname(__FILE__) + "/../lib/trusted.pem"
+    assert certs.is_a?( Array)
+    assert certs.size>1
+    certs.each do |cert|
+      assert_instance_of EzCrypto::Certificate, cert
+    end
+  end
+  
+  def test_load_trusted_truststore
+    trust=EzCrypto::TrustStore.default_trusted
+    sf_root=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf-class2-root.crt"
+    assert trust.verify(sf_root)
+    starfield=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/sf_intermediate.crt"
+    assert trust.verify(starfield)
+    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+    assert trust.verify(agree2)
+    
+    cert=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/testsigner.cert"
+    assert !trust.verify(cert)
+    trust.add cert
+    assert trust.verify(cert)  
+  end
+
+# Disabling these until pkyp is back up  
+#  def test_public_key_load_from_pkyp
+#    verifier=EzCrypto::Verifier.from_pkyp "e93e18114cbefaaa89fda908b09df63d3662879a"
+#    agree2=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+#    assert_equal agree2.cert.to_s,verifier.cert.to_s
+#    assert verifier
+#  end
+#
+#  def test_register_public_key_at_pkyp
+#    pub=EzCrypto::Verifier.from_file File.dirname(__FILE__) + "/agree2.com.cert"
+#    assert_equal pub.digest,pub.register_with_pkyp
+#  end
+#  
+#  def test_create_register_and_fetch_public_key
+#    signer=EzCrypto::Signer.generate
+#    assert_equal signer.verifier.digest,signer.verifier.register_with_pkyp
+#    verifier=EzCrypto::Verifier.from_pkyp signer.verifier.digest
+#    sig=signer.sign "hello"
+#    assert sig
+#    assert verifier.verify( sig,"hello")    
+#  end
+#  
+  
+  def assert_signer(signer)
+    assert signer
+    assert signer.public_key
+    
+    sig=signer.sign "hello"
+    assert sig
+    assert signer.verifier
+    assert signer.verifier.verify( sig,"hello")
+  end
+  
+end

data/test/encrypt_test.rb

@@ -0,0 +1,41 @@
+require 'association_key_holder_test'
+
+class EncUser < ActiveRecord::Base
+  set_table_name "users"
+  encrypt :name, :base64=>true
+end
+
+class RawUser < ActiveRecord::Base
+  set_table_name "users"
+end
+
+class EncryptTest < AssociationKeyHolderTest
+  def setup
+    @key_holder=EncUser.create 
+  end
+  
+  def test_should_be_base64
+    assert EncUser.ezcrypto_base64?
+  end
+  
+  def test_should_retain_session_key_on_reload
+    key=EzCrypto::Key.generate
+    key_holder.set_session_key key
+    assert_not_nil key_holder.session_key
+    assert_equal key.raw,key_holder.session_key.raw
+    
+    key_holder.name="bob"
+    key_holder.save
+    
+    assert_equal "bob",key_holder.name
+    
+    found=EncUser.find key_holder.id
+    assert_equal key_holder.name,found.name
+    
+    raw=RawUser.find key_holder.id
+    assert_not_nil raw.name
+    assert_not_equal key_holder.name,raw.name
+    
+  end
+  
+end

data/test/ezcrypto_test.rb

@@ -0,0 +1,215 @@
+#coding: utf-8
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+require 'fileutils'
+require 'ezcrypto'
+require 'base64'
+
+class EzCryptoTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_generate_alg_key
+    assert_generate_alg_key "aes-128-cbc",16
+    assert_generate_alg_key "aes-192-cbc",24
+    assert_generate_alg_key "aes-256-cbc",32    
+    assert_generate_alg_key "rc2-40-cbc",5 
+    assert_generate_alg_key "rc2-64-cbc",8
+    assert_generate_alg_key "rc4-64" ,8
+    assert_generate_alg_key "blowfish" ,16
+    assert_generate_alg_key "des" ,8
+  end
+  
+  def test_with_password
+      assert_with_password "","secret","aes-128-cbc",16
+      assert_with_password "test","secret","aes-128-cbc",16
+      assert_with_password "password","secret","aes-128-cbc",16
+      assert_with_password "a�sldfad8q5�34j2�l4j24l6j2456","secret","aes-128-cbc",16
+      
+      assert_with_password "","secret","aes-192-cbc",24
+      assert_with_password "test","secret","aes-192-cbc",24
+      assert_with_password "password","secret","aes-192-cbc",24
+      assert_with_password "a�sldfad8q5�34j2�l4j24l6j2456","secret","aes-192-cbc",24
+
+      assert_with_password "","secret","aes-256-cbc",32
+      assert_with_password "test","secret","aes-256-cbc",32
+      assert_with_password "password","secret","aes-256-cbc",32
+      assert_with_password "a�sldfad8q5�34j2�l4j24l6j2456","secret","aes-256-cbc",32
+
+  end
+
+  def test_encoded
+    0.upto 32 do |size|
+      assert_encoded_keys size
+    end
+  end
+  
+  def test_encrypt    
+    0.upto(CLEAR_TEXT.size-1) do |size|
+      assert_encrypt CLEAR_TEXT[0..size]
+    end  
+  end
+  
+  def test_decrypt    
+    0.upto(CLEAR_TEXT.size) do |size|
+      assert_decrypt CLEAR_TEXT[0..size]
+    end  
+  end
+
+  def test_decrypt64
+    0.upto(CLEAR_TEXT.size) do |size|
+      assert_decrypt64 CLEAR_TEXT[0..size]
+    end  
+  end
+    
+  def test_keyfile_store_load
+
+    algo, size = "aes-256-cbc", 32   
+    keyfile = 'ezcrypto-test.key'
+    
+    FileUtils.rm [keyfile], :force => true
+    key = EzCrypto::Key.generate :algorithm => algo    
+    assert_file_not_exists keyfile    
+    key.store keyfile    
+    assert_file_exists keyfile    
+    assert_file_permissions keyfile, 0100400    
+    
+    key2 = EzCrypto::Key.load(keyfile)    
+    assert_equal key.raw, key2.raw
+    
+    FileUtils.rm [keyfile], :force => true    
+  end
+  
+  def test_filestuff_with_defaults      
+
+    clearfile = 'lorem_ipsum.txt'
+    keyfile = 'lorem_ipsum.key'
+    algo, size = "aes-256-cbc", 32
+    
+    File.open(clearfile, 'w') { |f| f.write(CLEAR_TEXT) }
+    assert_file_contains clearfile, CLEAR_TEXT    
+
+    key = EzCrypto::Key.generate :algorithm => algo    
+
+    # default behaviour: remove clearfile, append '.ez' suffix  
+    cryptfile = key.encrypt_file(clearfile)    
+    assert_equal cryptfile, clearfile + ".ez"
+    #assert_file_not_exists clearfile
+    assert_file_exists cryptfile 
+    assert_file_contains cryptfile, key.encrypt(CLEAR_TEXT)
+
+    # default behaviour: unlink cryptfile and remove suffix from filename
+    clearfile = key.decrypt_file cryptfile
+    assert_file_exists clearfile
+    assert_file_not_exists cryptfile
+    assert_file_contains clearfile, CLEAR_TEXT    
+    FileUtils.rm [keyfile, clearfile, cryptfile], :force => true
+  end
+  
+  def test_filestuff_with_options
+  
+    clearfile = 'lorem_ipsum.txt'
+    keyfile = 'lorem_ipsum.key'
+    algo, size = "aes-256-cbc", 32    
+
+    File.open(clearfile, 'w') { |f| f.write(CLEAR_TEXT) }
+    assert_file_contains clearfile, CLEAR_TEXT
+    
+    key = EzCrypto::Key.generate :algorithm => algo      
+    
+    # with options: keep the original file, auto-create a 
+    # new filename with a user-defined suffix        
+    cryptfile = key.encrypt_file(clearfile, nil, :autoclean => false, :suffix => '.Encrypted')
+    assert_equal cryptfile, clearfile + ".Encrypted", 'suffix was added'
+    assert_file_exists clearfile
+    assert_file_exists cryptfile    
+    assert_file_permissions cryptfile, 0100600
+    
+    assert_raises(Errno::EEXIST, "the original file would not be overwritten") { 
+      key.decrypt_file(cryptfile, nil, :autoclean => false, :suffix => '.Encrypted')
+    } 
+    FileUtils.rm [clearfile], :force => true    
+
+    clearfile = key.decrypt_file(cryptfile, nil, :autoclean => false, :suffix => '.Encrypted')
+    assert_equal cryptfile, clearfile + ".Encrypted", 'suffix was removed'    
+    assert_file_exists clearfile
+    assert_file_exists cryptfile
+    assert_file_permissions cryptfile, 0100600    
+    assert_file_contains clearfile, CLEAR_TEXT    
+
+    FileUtils.rm [keyfile, clearfile, cryptfile], :force => true        
+  end
+    
+  def assert_file_permissions(filename, mode, msg='')
+    fmode = File.stat(filename).mode
+    assert_equal fmode, mode, msg 
+  end
+  
+  def assert_file_exists(filename)
+    assert File.exists?(filename)
+  end
+
+  def assert_file_not_exists(filename)
+    assert !File.exists?(filename)
+  end
+  
+  def assert_file_contains(filename, expected)
+    assert_file_exists(filename)
+    content = File.open(filename,'rb').read # Use b flag here to prevent encoding errors
+    assert_equal expected, content
+  end
+  
+  def assert_key_size(size,key)
+    assert_equal size,key.raw.size      
+  end
+  
+  def assert_generate_alg_key(algorithm,size)
+    key=EzCrypto::Key.generate :algorithm=>algorithm
+    assert_key_size size,key 
+  end
+ 
+  def assert_with_password(password,salt,algorithm,size)
+    key=EzCrypto::Key.with_password password,salt,:algorithm=>algorithm
+    assert_key_size size,key
+    assert_equal key.raw,EzCrypto::Key.with_password( password,salt,:algorithm=>algorithm).raw
+  end
+  
+  def assert_encoded_keys(size)
+    # In original test, we pass in integer. generate expects a hash with a :algorithm key -james
+    key = EzCrypto::Key.new(EzCrypto::Digester.generate_key(size))
+    #key=EzCrypto::Key.generate size
+    key2=EzCrypto::Key.decode(key.encode)
+    assert_equal key.raw, key2.raw    
+  end
+  
+  def assert_encrypt(clear)
+    ALGORITHMS.each do |alg|
+      key=EzCrypto::Key.generate :algorithm=>alg
+      encrypted=key.encrypt clear
+      assert_not_nil encrypted    
+    end
+  end
+  
+  def assert_decrypt(clear)
+    ALGORITHMS.each do |alg|
+      key=EzCrypto::Key.generate :algorithm=>alg
+      encrypted=key.encrypt clear
+      assert_not_nil encrypted
+      assert_equal clear,key.decrypt(encrypted)
+    end
+  end
+  
+  def assert_decrypt64(clear)
+    key=EzCrypto::Key.generate
+    encrypted=key.encrypt64 clear
+    assert_not_nil encrypted
+    assert_equal clear,key.decrypt64(encrypted)
+  end
+  
+  ALGORITHMS=["aes128","bf","blowfish","des","des3","rc4","rc2"]
+  CLEAR_TEXT="Lorem ipsum dolor sit amet, suspendisse id interdum mus leo id. Sapien tempus consequat nullam, platea vitae sociis sed elementum et fermentum, vel praesent eget. Sed blandit augue, molestie mus sed habitant, semper voluptatibus neque, nullam a augue. Aptent imperdiet curabitur, quam quis laoreet. Dolor magna. Quis vestibulum amet eu arcu fringilla nibh, mi urna sunt dictumst nulla, elit quisque purus eros, sem hendrerit. Vulputate tortor rhoncus ac nonummy tortor nulla. Nunc id nunc luctus ligula."
+end
+
+