ezcrypto 0.1

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2004 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,130 @@
+= EzCrypto - Easy to use Crypto for Ruby
+
+EzCrypto is an easy to use wrapper around the poorly documented OpenSSL ruby library.
+
+== Features
+
+* Defaults to AES 128 CBC
+* Will use the systems OpenSSL library for transparent hardware crypto support
+* Single class object oriented access to most commonly used features
+* Ruby like
+
+== Simple examples
+
+==== To encrypt:
+
+Generate a key using a password and a salt. Use the keys encrypt method to encrypt a strings worth of data:
+
+  @key=EzCrypto::Key.with_password "password", "system salt"
+  @encrypted=@key.encrypt "Top secret should not be revealed"
+    
+==== To decrypt:
+
+Same procedure as encrypt. Generate a key using a password and a salt. Use the keys decrypt method to decrypt a strings worth of data:
+
+  @key=EzCrypto::Key.with_password "password", "system salt"
+  @key.decrypt @encrypted
+  
+==== One liners:
+
+These simple examples use one line each:
+
+  @encrypted=EzCrypto::Key.encrypt_with_password "password", @salt,"Top secret should not be revealed"
+  
+  EzCrypto::Key.decrypt_with_password "password", @salt,@encrypted
+
+== Keys
+
+The only class you need to know for most uses og EzCrypto is the Key class. You don't need understand ciphers or the encryption life cycle.
+
+==== Generating a random key
+
+The most secure type of key is the randomly generated key:
+
+  @key=EzCrypto::Key.generate
+  
+==== Initializing a key with raw key data
+
+If you already have a key from some other source, you simply have to call the constructor with the raw data:
+
+  @key=EzCrypto::Key.new @binarykey
+  
+==== Initializing a Key with a Base64 encoded key
+
+As seen above you can create a key from a password. This should be used if you don't want the key to be stored on disk for example:
+
+  @key=EzCrypto::Key.with_password "Secret password"
+
+==== Initializing a Key with a Base64 encoded key
+
+If you already have a key from some other source in the popular Base64 encoded format, you use the decode class method:
+
+  @key=EzCrypto::Key.decode @binarykey
+
+==== Exporting the key
+
+To export or save a key use the encode method (or to_s) method for a Base64 encoded key or raw as the raw binary data.
+
+  puts @key.encode
+  puts @key.raw
+  
+The raw method could be used for storing in a database using a tinyblob column.
+
+== Encryption and Decryption
+
+EzCrypto is optimized for simple encryption and decryption of strings. There are encrypt/decrypt pairs for normal binary use as well as for Base64 encoded use.
+
+==== Regular raw use
+
+Assuming you have generated a key using one of the above methods:
+
+  @encrypted=@key.encrypt("clear text")
+  @decrypted=@key.decrypt(@encrypted)
+  assert "clear text", @decrypted
+
+==== Base64 encoded use
+
+This uses the encrypt64 and decrypt64 methods. Otherwise it is all the same:
+
+  @encrypted=@key.encrypt64("clear text")
+  @decrypted=@key.decrypt64(@encrypted)
+  assert "clear text", @decrypted
+
+== FAQ
+
+=== What algorithm does this use?
+
+It uses as the default algorithm the AES 128 bit standard. This is a very fast and highly secure algorithm specified as the national standard in the US. For more information see:
+
+http://en.wikipedia.org/wiki/AES
+
+=== Only 128 bits. Is that enough?
+
+While it might sound like more would make it more secure, there is really no real security advantage for most commercial applications to use more than 128 bit AES.
+
+=== What is Base64 encoding?
+
+This is the most efficient and commonly used encoding scheme for binary data. This is used amongst other things for email attachments. It is also very common to use it for encrypted data.
+
+=== What is a Salt?
+
+A salt is just a piece of data we hash in with the password to create the key. If it is a server based application you could use store a salt within your source file. The salt must be the same for both encryption and decryption.
+
+
+== License
+
+Action Web Service is released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard

data/lib/CVS/Entries

@@ -0,0 +1 @@
+D

data/lib/CVS/Repository

@@ -0,0 +1 @@
+ezcrypto/lib

data/lib/CVS/Root

@@ -0,0 +1 @@
+:ext:pelleb@rubyforge.net:/var/cvs/ezcrypto

data/lib/ezcrypto.rb

@@ -0,0 +1,357 @@
+require 'openssl'
+require 'digest/sha2'
+require 'digest/sha1'
+require 'base64'
+
+module EzCrypto
+
+
+=begin rdoc
+The Key is the only class you need to understand for simple use.
+
+=== Algorithms
+
+The crypto algorithms default to aes-128-cbc however on any of the class methods you can change it to one of the standard openssl cipher names using the
+optional <tt>:algorithm=>alg name</tt> parameter.
+
+Eg. 
+    Key.new @raw, :algorithm=>"des"
+    Key.generate :algorithm=>"blowfish"
+    Key.with_password @pwd,@salt,:algorithm=>"aes256"    
+
+
+== License
+
+Action Web Service is released under the MIT license.
+
+
+== Support
+
+To contact the author, send mail to pelleb@gmail.com
+
+Also see my blogs at:
+http://stakeventures.com and
+http://neubia.com
+
+This project was based on code used in my project StakeItOut, where you can securely share web services with your partners.
+https://stakeitout.com
+
+(C) 2005 Pelle Braendgaard
+
+=end
+
+  class Key
+    attr_reader :raw,:algorithm
+    
+=begin rdoc
+Initialize the key with raw binary key data. This needs to be at least
+16 bytes long for the default aes-128 algorithm.
+=end
+    def initialize(raw,options = {})
+      @raw=raw
+      @algorithm=options[:algorithm]||"aes-128-cbc"
+    end
+    
+=begin rdoc
+Generate random key.
+=end
+    def self.generate(options = {})      
+      Key.new(EzCrypto::Digester.generate_key(calculate_key_size(options[:algorithm])),options)
+    end
+            
+=begin rdoc
+Create key generated from the given password and salt  
+=end
+    def self.with_password(password,salt,options = {})
+      Key.new(EzCrypto::Digester.get_key(password,salt,calculate_key_size(options[:algorithm])),options)
+    end
+    
+=begin rdoc
+Initialize the key with Base64 encoded key data.
+=end
+    def self.decode(encoded,options = {})
+      Key.new(Base64.decode64(encoded),options)
+    end
+    
+=begin rdoc
+Encrypts the data with the given password and a salt. Short hand for:
+
+  key=Key.with_password(password,salt,options)
+  key.encrypt(data)
+
+=end
+    def self.encrypt_with_password(password,salt,data,options = {})
+      key=Key.with_password(password,salt,options)
+      key.encrypt(data)
+    end
+    
+=begin rdoc
+Decrypts the data with the given password and a salt. Short hand for:
+
+  key=Key.with_password(password,salt,options)
+  key.decrypt(data)
+
+  
+=end
+    def self.decrypt_with_password(password,salt,data,options = {})
+      key=Key.with_password(password,salt,options)
+      key.decrypt(data)
+    end
+    
+=begin rdoc
+Given an algorithm this calculates the keysize. This is used by both the generate and with_password methods. This is not yet 100% complete.  
+=end
+    def self.calculate_key_size(algorithm)    
+      if !algorithm.nil?
+        algorithm=~/^([[:alnum:]]+)(-(\d+))?/
+        if $3
+          size=($3.to_i)/8
+        else 
+          case $1 
+            when "bf"
+              size = 16
+            when "blowfish"
+              size = 16
+            when "des"
+              size = 8
+            when "des3"
+              size = 24
+            when "aes128"
+              size = 16
+            when "aes192"
+              size = 24
+            when "aes256"
+              size = 32
+            when "rc2"
+              size = 16
+            when "rc4"
+              size = 16
+            else 
+              size = 16
+            end
+        end
+      end
+      if size.nil?
+        size = 16
+      end
+      
+      size
+    end
+
+=begin rdoc
+returns the Base64 encoded key.
+=end
+    def encode
+      Base64.encode64 @raw
+    end
+    
+=begin rdoc
+returns the Base64 encoded key. Synonymo for encode.  
+=end
+    def to_s
+      encoded
+    end
+    
+=begin rdoc
+Encrypts the data and returns it in encrypted binary form.
+=end
+    def encrypt(data)
+      @cipher=EzCrypto::Encrypter.new(self,"",@algorithm)
+      @cipher.encrypt(data)
+    end
+
+=begin rdoc
+Encrypts the data and returns it in encrypted Base64 encoded form.
+=end
+    def encrypt64(data)
+      Base64.encode64(encrypt(data))
+    end
+    
+=begin rdoc
+Decrypts the data passed to it in binary format.
+=end    
+    def decrypt(data)
+      @cipher=EzCrypto::Decrypter.new(self,"",@algorithm)
+      @cipher.gulp(data)
+    rescue
+      puts @algorithm
+      throw $!
+    end
+    
+=begin rdoc
+Decrypts a Base64 formatted string  
+=end
+    def decrypt64(data)
+      decrypt(Base64.decode64(data))
+    end
+
+    
+  end
+=begin rdoc
+Abstract Wrapper around OpenSSL's Cipher object. Extended by Encrypter and Decrypter.
+  
+You probably should be using the Key class instead.
+
+Warning! The interface may change.
+
+=end
+  class CipherWrapper
+
+=begin rdoc
+  
+=end
+    def initialize(key,target,mode,algorithm)
+      @cipher = OpenSSL::Cipher::Cipher.new(algorithm)  
+      if mode
+        @cipher.encrypt
+      else
+        @cipher.decrypt
+      end
+      @cipher.key=key.raw
+      @cipher.padding=1
+      @target=target
+      @finished=false
+    end
+    
+=begin rdoc
+Process the givend data with the cipher.
+=end
+    def update(data)
+      reset if @finished
+      @target<< @cipher.update(data)
+    end
+
+=begin rdoc
+  
+=end
+    def <<(data)
+      update(data)
+    end
+    
+=begin rdoc
+Finishes up any last bits of data in the cipher and returns the final result.
+=end
+    def final
+      @target<< @cipher.final
+      @finished=true
+      @target
+    end
+    
+=begin rdoc
+Processes the entire data string using update and performs a final on it returning the data.
+=end
+    def gulp(data)
+      update(data)
+      final 
+    end  
+
+=begin rdoc
+  
+=end
+    def reset(target="")
+      @target=target
+      @finished=false
+    end
+  end
+
+=begin rdoc
+Wrapper around OpenSSL Cipher for Encryption use.
+
+You probably should be using Key instead.
+
+Warning! The interface may change.
+
+=end
+  class Encrypter<EzCrypto::CipherWrapper
+
+=begin rdoc
+  
+=end
+    def initialize(key,target="",algorithm="aes-128-cbc")
+      super(key,target,true,algorithm)
+    end
+    
+=begin rdoc
+  
+=end    
+    def encrypt(data)    
+      gulp(data)
+    end
+  end
+
+=begin rdoc
+Wrapper around OpenSSL Cipher for Decryption use.
+
+You probably should be using Key instead.
+
+Warning! The interface may change.
+=end
+  class Decrypter<EzCrypto::CipherWrapper
+=begin rdoc
+  
+=end
+    def initialize(key,target="",algorithm="aes-128-cbc")
+      super(key,target,false,algorithm)
+    end
+    
+=begin rdoc
+  
+=end    
+    def decrypt(data)
+      gulp(data)
+    end
+  end
+
+=begin rdoc
+
+=end
+  class Digester    
+=begin rdoc
+Various handy Digest methods. 
+
+Warning! The interface may change.
+=end
+    def self.get_key(password,salt,size)
+        digest(salt+password,size)
+    end
+  
+=begin rdoc
+  
+=end
+    def self.generate_key(size=16)
+        key=OpenSSL::Random.random_bytes(size)
+        digest(key,size)
+    end
+  
+=begin rdoc
+  
+=end
+    def self.generate_key64(size=32)
+        key=OpenSSL::Random.random_bytes(size)
+        digest(key,size)
+    end   
+    
+=begin rdoc
+  
+=end
+    def self.digest(data,size=16)
+      if size==0
+        ""
+      elsif size<=16
+        Digest::SHA1.digest(data)[0..(size-1)]
+      else
+        Digest::SHA256.digest(data)[0..(size-1)]
+      end
+    end
+    
+=begin rdoc
+  
+=end
+    def self.digest64(data)
+      Base64.encode64(digest(data))
+    end
+	end
+
+end
+
+

data/rakefile

@@ -0,0 +1,195 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'ezcrypto'
+PKG_VERSION   = '0.1' + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "ezcrypto"
+RUBY_FORGE_USER    = "pelleb"
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+}
+
+
+# Genereate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "EzCrypto - Simplified Crypto Library"
+  rdoc.options << '--line-numbers --inline-source --main README'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/ezcrypto.rb')
+#  rdoc.rdoc_files.include('lib/ezcrypto/*.rb')
+}
+
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "Simplified encryption library."
+  s.description = %q{Makes it easier and safer to write crypto code.}
+  s.version = PKG_VERSION
+
+  s.author = "Pelle Braendgaard"
+  s.email = "pelle@stakeitout.com"
+  s.rubyforge_project = "ezcrypto"
+  s.homepage = "http://ezcrypto.rubyforge.org"
+
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+  s.require_path = 'lib'
+
+  s.files = [ "rakefile", "README", "MIT-LICENSE" ]
+  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+
+desc "Publish the API documentation"
+task :pgem => [:package] do 
+  Rake::SshFilePublisher.new("pelleb@rubyforge.org", "/var/www/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("pelleb@rubyforge.org", "/var/www/gforge-projects/ezcrypto", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [:package] do
+  files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+
+  if RUBY_FORGE_PROJECT then
+    require 'net/http'
+    require 'open-uri'
+
+    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+    project_data = open(project_uri) { |data| data.read }
+    group_id = project_data[/[?&]group_id=(\d+)/, 1]
+    raise "Couldn't get group id" unless group_id
+
+    # This echos password to shell which is a bit sucky
+    if ENV["RUBY_FORGE_PASSWORD"]
+      password = ENV["RUBY_FORGE_PASSWORD"]
+    else
+      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+      password = STDIN.gets.chomp
+    end
+
+    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+      data = [
+        "login=1",
+        "form_loginname=#{RUBY_FORGE_USER}",
+        "form_pw=#{password}"
+      ].join("&")
+      http.post("/account/login.php", data)
+    end
+
+    cookie = login_response["set-cookie"]
+    raise "Login failed" unless cookie
+    headers = { "Cookie" => cookie }
+
+    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+    release_data = open(release_uri, headers) { |data| data.read }
+    package_id = release_data[/[?&]package_id=(\d+)/, 1]
+    raise "Couldn't get package id" unless package_id
+
+    first_file = true
+    release_id = ""
+
+    files.each do |filename|
+      basename  = File.basename(filename)
+      file_ext  = File.extname(filename)
+      file_data = File.open(filename, "rb") { |file| file.read }
+
+      puts "Releasing #{basename}..."
+
+      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+        type_map = {
+          ".zip"    => "3000",
+          ".tgz"    => "3110",
+          ".gz"     => "3110",
+          ".gem"    => "1400"
+        }; type_map.default = "9999"
+        type = type_map[file_ext]
+        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+
+        query_hash = if first_file then
+          {
+            "group_id" => group_id,
+            "package_id" => package_id,
+            "release_name" => RELEASE_NAME,
+            "release_date" => release_date,
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "release_notes" => "",
+            "release_changes" => "",
+            "preformatted" => "1",
+            "submit" => "1"
+          }
+        else
+          {
+            "group_id" => group_id,
+            "release_id" => release_id,
+            "package_id" => package_id,
+            "step2" => "1",
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "submit" => "Add This File"
+          }
+        end
+
+        query = "?" + query_hash.map do |(name, value)|
+          [name, URI.encode(value)].join("=")
+        end.join("&")
+
+        data = [
+          "--" + boundary,
+          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+          "Content-Type: application/octet-stream",
+          "Content-Transfer-Encoding: binary",
+          "", file_data, ""
+          ].join("\x0D\x0A")
+
+        release_headers = headers.merge(
+          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+        )
+
+        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+        http.post(target + query, data, release_headers)
+      end
+
+      if first_file then
+        release_id = release_response.body[/release_id=(\d+)/, 1]
+        raise("Couldn't get release id") unless release_id
+      end
+
+      first_file = false
+    end
+  end
+end

data/test/CVS/Entries

@@ -0,0 +1 @@
+D

data/test/CVS/Repository

@@ -0,0 +1 @@
+ezcrypto/test

data/test/CVS/Root

@@ -0,0 +1 @@
+:ext:pelleb@rubyforge.net:/var/cvs/ezcrypto

data/test/ezcrypto_test.rb

@@ -0,0 +1,112 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'test/unit'
+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 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)
+    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
+

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: ezcrypto
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2005-07-20
+summary: Simplified encryption library.
+require_paths: 
+  - lib
+email: pelle@stakeitout.com
+homepage: http://ezcrypto.rubyforge.org
+rubyforge_project: ezcrypto
+description: Makes it easier and safer to write crypto code.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Pelle Braendgaard
+files: 
+  - rakefile
+  - README
+  - MIT-LICENSE
+  - lib/CVS
+  - lib/ezcrypto.rb
+  - lib/CVS/Entries
+  - lib/CVS/Repository
+  - lib/CVS/Root
+  - test/CVS
+  - test/ezcrypto_test.rb
+  - test/fixtures
+  - test/CVS/Entries
+  - test/CVS/Repository
+  - test/CVS/Root
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: 
+  - none
+dependencies: []