ruby-aes-cext 1.0-i686-linux

data/CHANGELOG

@@ -0,0 +1,6 @@
+= 0.1
+
+=== 2007-07-30
+* Initial release: RAA project import
+* Added a C extension for speed along the 6 other versions (see README)
+* Minor changes in the API

data/COPYING

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Alex Boussinet
+
+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,77 @@
+README for ruby-aes
+===================
+
+Ruby AES <http://rubyforge.org/projects/ruby-aes> is an implementation of the Rijndael algorithm.
+
+Written by Alex Boussinet <mailto:alex.boussinet@gmail.com>
+
+This release is mainly an import from the Ruby Application Archive (RAA).
+I've added all the versions I was working on (algorithm variations) and a new
+C extension for improved performance.
+6 variations are available:
+
+* "Normal":
+Pure Ruby implementation of the Rijndael algorithm specifications.
+Useful for understanding the algorithm.
+
+* "Optimized":
+Pure Ruby implementation based on the "Normal" code but optimized for speed.
+The SubBytes and ShiftRows methods have been combined.
+
+* "Table Optimized 1":
+Pure Ruby implementation based on the C code from the Rijndael website.
+The arrays of constants are bigger because all the operations are
+already computed so it's mainly based on table look ups.
+
+* "Table Optimized 2":
+Pure Ruby implementation based on the "Table Optimized 1" code.
+The arrays of constants are bigger because all the operations are
+already computed and table look ups are also combined.
+
+* "Table Unroll Optimized 1":
+Pure Ruby implementation based on the "Table Optimized 1" code.
+The change here is that the loops are unrolled.
+
+* "Table Unroll Optimized 2":
+Pure Ruby implementation based on the "Table Optimized 2" code.
+The change here is that the loops are unrolled.
+
+* "EXT Table Unroll Optimized 2":
+C extension based on the "Table Unroll Optimized 2" code.
+This extension is provided for major speed improvement.
+
+All those variations share the same API:
+  Default key_length: 128
+  Default mode: 'ECB'
+  Default IV: 16 null chars ("00" * 16 in hex format)
+  Default key: 16 null chars ("00" * 16 in hex format)
+  Default input text: "PLAINTEXT"
+
+  Aes.check_key(key_string, key_length)
+  Aes.check_iv(iv_string)
+  Aes.check_kl(key_length)
+  Aes.check_mode(mode)
+  Aes.init(key_length, mode, key, iv)
+  Aes.encrypt_block(key_length, mode, key, iv, block) # no padding
+  Aes.decrypt_block(key_length, mode, key, iv, block) # no padding
+  Aes.encrypt_buffer(key_length, mode, key, iv, block) # padding
+  Aes.decrypt_buffer(key_length, mode, key, iv, block) # padding
+  Aes.encrypt_stream(key_length, mode, key, iv, sin, sout)
+  Aes.decrypt_stream(key_length, mode, key, iv, sin, sout)
+  Aes.bs() # block size for read operations (stream)
+  Aes.bs=(bs)
+
+Valid modes are:
+    * ECB (Electronic Code Book)
+    * CBC (Cipher Block Chaining)
+    * OFB (Output Feedback)
+    * CFB (Cipher Feedback)
+
+Valid key length:
+    * 128 bits
+    * 192 bits
+    * 256 bits
+
+For a really good encryption, 256 bits CBC is recommanded.
+
+For more information on AES-Rijndael, see: <http://csrc.nist.gov/encryption/aes/rijndael/>

data/Rakefile

@@ -0,0 +1,154 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+
+include FileUtils
+
+@name = 'ruby-aes'
+@version = '1.0'
+@native = false
+
+@lib = "lib/#{@name}"
+@ext = "ext/#{@name}"
+@ext_o = 'aes_alg.o'
+@ext_so = "aes_alg.#{Config::CONFIG['DLEXT']}"
+
+RDOC_OPTS = ['--quiet',
+    '--title', 'ruby-aes reference',
+    '--opname', 'index.html',
+    '--exclude', 'ext',
+    '--line-numbers',
+    '--main', 'README',
+    '--inline-source']
+
+CLEAN.include [
+    '**/.*.sw?', '*.gem', '.config', '**/.DS_Store',
+    "#{@ext}/#{@ext_so}", "#{@ext}/#{@ext_o}",
+    "#{@ext}/Makefile", "#{@ext}/aes_cons.h", "#{@ext}/mkmf.log",
+    "#{@lib}/aes_alg.rb", "#{@lib}/aes_cons.rb", "#{@lib}/aes_gencons.rb"
+]
+
+SPEC = Gem::Specification.new do |s|
+    s.name = @name
+    s.version = @version
+    s.platform = Gem::Platform::RUBY
+    s.has_rdoc = true
+    s.rdoc_options += RDOC_OPTS
+    s.extra_rdoc_files = ['README', 'CHANGELOG', 'COPYING']
+    s.summary = 'ruby-aes is an implementation of the Rijndael algorithm (AES)'
+    s.description = s.summary
+    s.author = 'Alex Boussinet'
+    s.email = 'alex.boussinet@gmail.com'
+    s.homepage = "http://#{@name}.rubyforge.org"
+    s.rubyforge_project = @name
+    s.test_files = FileList['test/test_*.rb']
+    s.require_paths = ['lib']
+#    s.bindir = 'bin'
+    s.files = %w(CHANGELOG COPYING README Rakefile) +
+        Dir.glob('{doc,examples,lib,test}/**/*')
+end
+
+def task_gem
+    desc 'Build the gem'
+    Rake::GemPackageTask.new(SPEC) do |p|
+        p.need_tar = true
+        p.gem_spec = SPEC
+    end
+end
+
+Dir.glob('extras/*').each do |project|
+    desc "Specify the project to use"
+    task File.basename(project).to_sym do |t|
+        @type = t.name
+
+        @gem_name = "#{@name}-#{@type}"
+        SPEC.name = @gem_name
+        SPEC.files += [ "#{@lib}/aes_alg.rb", "#{@lib}/aes_cons.rb" ]
+        task_gem
+    end
+end
+
+desc "Specify the project to use"
+task :cext do |t|
+    @type = t.name
+
+    @gem_name = "#{@name}-#{@type}"
+    SPEC.name = @gem_name
+    SPEC.require_paths += ['ext']
+    if @native
+        SPEC.files += ["#{@ext}/#{@ext_so}"]
+        SPEC.platform = Gem::Platform::CURRENT
+    else
+        SPEC.files += Dir.glob("#{@ext}/*")
+        SPEC.extensions = FileList["#{@ext}/extconf.rb"].to_a
+    end
+    task_gem
+end
+desc "Use the native version of cext"
+task :native do
+    @native = true
+    Rake::Task[:cext].invoke
+end
+
+task :prepare do
+    if @type == 'cext'
+        Dir.chdir(@ext) do
+            ruby 'aes_gencons.rb'
+            if @native
+                ruby 'extconf.rb'
+                sh(PLATFORM =~ /win32/ ? 'nmake' : 'make')
+            end
+        end
+    else
+        cp "extras/#{@type}/aes_alg.rb", "#{@lib}/"
+        cp "extras/#{@type}/aes_gencons.rb", "#{@lib}/"
+        Dir.chdir(@lib) do
+            ruby 'aes_gencons.rb'
+            rm_f 'aes_gencons.rb'
+        end
+    end
+end
+
+task :package => [:clean, :prepare, :rerdoc]
+
+task :default do
+    STDERR.puts <<-EOM
+You must call rake with one of this task as first param:
+    normal
+    optimized
+    table1
+    table2
+    unroll1
+    unroll2
+    cext
+    native (imply cext)
+    EOM
+end
+
+desc 'Run all the tests'
+Rake::TestTask.new do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/test_*.rb']
+    t.verbose = true
+end
+
+desc 'Build the documentation'
+Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = 'doc/rdoc'
+    rdoc.options += RDOC_OPTS
+    rdoc.main = 'README'
+    rdoc.rdoc_files.add ['README', 'CHANGELOG', 'COPYING', 'lib/**/*.rb']
+end
+
+desc 'Install the package'
+task :install do |t|
+    sh %{sudo gem install pkg/#{@gem_name}}
+end
+
+desc 'Uninstall the package'
+task :uninstall do
+    sh %{sudo gem uninstall #{@gem_name}}
+end

data/examples/encrypt_block.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'ruby-aes'
+require 'example_helper'
+
+class RubyAES_block
+
+    include RubyAES_helper
+
+    def initialize
+        setup
+        pt = "0123467890ABCDEF"
+        puts "Using #{@kl}-#{@mode} encryption/decryption"
+        puts "Plaintext is: #{pt} (a block should be 16 octets)"
+        ct = Aes.encrypt_block(@kl, @mode, @keys[@kl], @iv, pt)
+        puts "Ciphertext (unpacked) is: #{ct.unpack("H*").first}"
+        npt = Aes.decrypt_block(@kl, @mode, @keys[@kl], @iv, ct)
+        puts "Decrypted ciphertext is: #{npt} (should be: #{pt})"
+    end
+
+end
+RubyAES_block.new

data/examples/encrypt_buffer.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'ruby-aes'
+require 'example_helper'
+
+class RubyAES_buffer
+
+    include RubyAES_helper
+
+    def initialize
+        setup
+        puts "Using #{@kl}-#{@mode} encryption/decryption"
+        pt = "The quick brown fox jumps over the lazy dog"
+        puts "Plaintext is: '#{pt}'"
+        puts "(a buffer will be padded so that its length will be a multiple of 16)"
+        ct = Aes.encrypt_buffer(@kl, @mode, @keys[@kl], @iv, pt)
+        puts "Ciphertext (unpacked) is: #{ct.unpack("H*").first}"
+        npt = Aes.decrypt_buffer(@kl, @mode, @keys[@kl], @iv, ct)
+        puts "Decrypted ciphertext is: '#{npt}'"
+        puts "(should be: '#{pt}')"
+    end
+
+end
+RubyAES_buffer.new

data/examples/encrypt_stream.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'ruby-aes'
+require 'example_helper'
+require 'fileutils'
+
+class RubyAES_stream
+
+    include RubyAES_helper
+
+    def initialize
+        setup
+        puts "Using #{@kl}-#{@mode} encryption/decryption"
+        file = "_ruby-aes_encrypt_stream_"
+
+        sin = File.open(file, "w+b")
+        sin.puts "The quick brown fox jumps over the lazy dog"
+        sin.rewind
+        sout = File.open("#{file}.aes", "w+b")
+        Aes.encrypt_stream(@kl, @mode, @keys[@kl], @iv, sin, sout)
+        sin.close
+        sout.close
+
+        sin = File.open("#{file}.aes", "rb")
+        sout = File.open("#{file}.plain", "w+b")
+        Aes.decrypt_stream(@kl, @mode, @keys[@kl], @iv, sin, sout)
+        sin.close
+        sout.close
+
+        if IO.read(file) == IO.read("#{file}.plain")
+            puts "The decrypted file is exactly the same as the original one"
+        else
+            puts "The decrypted file differs from the orginal one"
+        end
+        FileUtils.rm_f [ file, "#{file}.aes", "#{file}.plain" ]
+    end
+
+end
+RubyAES_stream.new

data/examples/example_helper.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+module RubyAES_helper
+
+    KEY_LENGTH = [128,192,256].freeze
+    MODES = ['ECB','CBC','OFB','CFB'].freeze
+
+    def random_fill(n, buffer)
+        n.times do
+            buffer << rand(256).chr
+        end
+    end
+
+    def setup
+        @keys = {}
+        KEY_LENGTH.each do |kl|
+            @keys[kl] = ""
+            random_fill(kl/8, @keys[kl])
+        end
+
+        @iv = ""; random_fill(16, @iv)
+        @pt = ""; random_fill(64, @pt)
+        @kl = KEY_LENGTH[(rand * KEY_LENGTH.length).to_i]
+        @mode = MODES[(rand * MODES.length).to_i]
+    end
+
+end

data/lib/ruby-aes.rb

@@ -0,0 +1,162 @@
+=begin
+    This file is a part of ruby-aes <http://rubyforge.org/projects/ruby-aes>
+    Written by Alex Boussinet <alex.boussinet@gmail.com>
+
+==Valid modes are:
+    * ECB (Electronic Code Book)
+    * CBC (Cipher Block Chaining)
+    * OFB (Output Feedback)
+    * CFB (Cipher Feedback)
+
+==Valid key length:
+    * 128 bits
+    * 192 bits
+    * 256 bits
+
+==API calls:
+    Default key_length: 128
+    Default mode: 'ECB'
+    Default IV: 16 null chars ("00" * 16 in hex format)
+    Default key: 16 null chars ("00" * 16 in hex format)
+    Default input text: "PLAINTEXT"
+
+    Aes.check_key(key_string, key_length)
+    Aes.check_iv(iv_string)
+    Aes.check_kl(key_length)
+    Aes.check_mode(mode)
+    Aes.init(key_length, mode, key, iv)
+    Aes.encrypt_block(key_length, mode, key, iv, block) # no padding
+    Aes.decrypt_block(key_length, mode, key, iv, block) # no padding
+    Aes.encrypt_buffer(key_length, mode, key, iv, block) # padding
+    Aes.decrypt_buffer(key_length, mode, key, iv, block) # padding
+    Aes.encrypt_stream(key_length, mode, key, iv, sin, sout)
+    Aes.decrypt_stream(key_length, mode, key, iv, sin, sout)
+    Aes.bs() # block size for read operations (stream)
+    Aes.bs=(bs)
+=end
+
+module Aes
+
+    require 'ruby-aes/aes_alg'
+
+    @@aes = nil
+    @@bs = 4096
+
+    def Aes.bs(); return @@bs end
+    def Aes.bs=(bs); @@bs = bs.to_i; @@bs==0 ? 4096 : @@bs = @@bs - @@bs%16 end
+
+    def Aes.check_key(key_string, kl = 128)
+        kl = Aes.check_kl(kl)
+        k = key_string.length
+        raise "Bad key string or bad key length" if (k != kl/8) && (k != kl/4)
+        hex = (key_string =~ /[a-f0-9A-F]{#{k}}/) == 0 && (k == kl/4)
+        bin = ! hex
+        if ! (([32, 48, 64].include?(k) && hex) ||
+           ([16, 24, 32].include?(k) && bin))
+            raise "Bad key string"
+        end
+        hex ? [key_string].pack("H*") : key_string
+    end
+
+    def Aes.check_iv(iv_string)
+        k = iv_string.length
+        hex = (iv_string =~ /[a-f0-9A-F]{#{k}}/) == 0
+        bin = ! hex
+        if k == 32 && hex
+            return [iv_string].pack("H*")
+        elsif k == 16 && bin
+            return iv_string
+        else
+            raise "Bad IV string"
+        end
+    end
+
+    def Aes.check_mode (mode)
+        case mode
+        when 'ECB', 'CBC', 'OFB', 'CFB'
+        else raise "Bad cipher mode"
+        end
+        mode
+    end
+
+    def Aes.check_kl(key_length)
+        case key_length
+        when 128, 192, 256
+        else raise "Bad key length"
+        end
+        key_length
+    end
+
+    def Aes.init(keyl, mode, key, iv)
+        unless @@aes
+            @@aes = AesAlg.new(Aes.check_kl(keyl), Aes.check_mode(mode),
+                               Aes.check_key(key, keyl), iv ? Aes.check_iv(iv) : nil)
+        else
+            @@aes.init(Aes.check_kl(keyl), Aes.check_mode(mode),
+                       Aes.check_key(key, keyl), iv ? Aes.check_iv(iv) : nil)
+        end
+    end
+
+    def Aes.encrypt_block(keyl, mode, key, iv, block = "DEFAULT PLAINTXT")
+        raise "Bad Block size" if block.length < 16 || block.length > 16
+        Aes.init(keyl, mode, key, iv)
+        @@aes.encrypt_block(block)
+    end
+
+    def Aes.decrypt_block(keyl, mode, key, iv, block = "DEFAULT PLAINTXT")
+        Aes.init(keyl, mode, key, iv)
+        @@aes.decrypt_block(block)
+    end
+
+    def Aes.encrypt_buffer(keyl, mode, key, iv, buffer = "PLAINTEXT")
+        Aes.init(keyl, mode, key, iv)
+        @@aes.encrypt_buffer(buffer)
+    end
+
+    def Aes.decrypt_buffer(keyl, mode, key, iv, buffer = "DEFAULT PLAINTXT")
+        raise "Bad Block size" if buffer.length < 16
+        Aes.init(keyl, mode, key, iv)
+        @@aes.decrypt_buffer(buffer)
+    end
+
+    def Aes.encrypt_stream(keyl, mode, key, iv, sin = STDIN, sout = STDOUT)
+        Aes.init(keyl, mode, key, iv)
+        case sout
+        when String, Array, IO
+        else
+            raise "Bad output stream (String, Array, IO)"
+        end
+        case sin
+        when String
+            sout << @@aes.encrypt_buffer(sin)
+        when IO
+            while buf = sin.read(@@bs)
+                sout << ((buf.length % 16).zero? ? @@aes.encrypt_blocks(buf) :
+                         @@aes.encrypt_buffer(buf))
+            end
+        else
+            raise "Bad input stream (String, IO)"
+        end
+    end
+
+    def Aes.decrypt_stream(keyl, mode, key, iv, sin = STDIN, sout = STDOUT)
+        Aes.init(keyl, mode, key, iv)
+        case sout
+        when String, Array, IO
+        else
+            raise "Bad output stream (String, Array, IO)"
+        end
+        case sin
+        when String
+            sout << @@aes.decrypt_buffer(sin)
+        when IO
+            while buf = sin.read(@@bs)
+                sout << (sin.eof? ? @@aes.decrypt_buffer(buf) :
+                         @@aes.decrypt_blocks(buf))
+            end
+        else
+            raise "Bad input stream (String, IO)"
+        end
+    end
+
+end # end Aes