ruby-aes-cext 1.1-i486-linux

data/doc/rdoc/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/examples/encrypt_block.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+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,25 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+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,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+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/aes_shared.rb

@@ -0,0 +1,77 @@
+=begin
+    This file is a part of ruby-aes <http://rubyforge.org/projects/ruby-aes>
+    Written by Alex Boussinet <alex.boussinet@gmail.com>
+
+    It contains the code shared by all the implementations
+=end
+
+module AesShared
+    def encrypt_blocks(buffer)
+        raise "Bad block length" unless (buffer.length % 16).zero?
+        ct = ""
+        block = ""
+        buffer.each_byte do |char|
+            block << char
+            if block.length == 16
+                ct << encrypt_block(block)
+                block = ""
+            end
+        end
+        ct
+    end
+
+    def decrypt_blocks(buffer)
+        raise "Bad block length" unless (buffer.length % 16).zero?
+        pt = ""
+        block = ""
+        buffer.each_byte do |char|
+            block << char
+            if block.length == 16
+                pt << decrypt_block(block)
+                block = ""
+            end
+        end
+        pt
+    end
+
+    def encrypt_buffer(buffer)
+        ct = ""
+        block = ""
+        buffer.each_byte do |char|
+            block << char
+            if block.length == 16
+                ct << encrypt_block(block)
+                block = ""
+            end
+        end
+        c = "\000"
+        if (m = 16 - block.length % 16) != 16
+            c = m.chr
+            ct << encrypt_block(block << c * m)
+        end
+        ct << c
+    end
+
+    def decrypt_buffer(buffer)
+        pt = ""
+        block = ""
+        buffer.each_byte do |char|
+            block << char
+            if block.length == 16
+                pt << decrypt_block(block)
+                block = ""
+            end
+        end
+        if block.length != 1
+            raise 'Bad Block Padding'
+        elsif (c = block[-1]).zero?
+            pt
+        else
+            if block * c == pt[-c..-1]
+                pt[0..-c-1]
+            else
+                raise "Bad Block Padding"
+            end
+        end
+    end
+end

data/lib/ruby-aes.rb

@@ -0,0 +1,168 @@
+=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 ? key_string.length : 0
+        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)
+              if buf.length == @@bs
+                sout << @@aes.encrypt_blocks(buf)
+              else
+                sout << @@aes.encrypt_buffer(buf)
+              end
+            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)#+1)
+              if buf.length == @@bs
+                sout << @@aes.decrypt_blocks(buf)
+              else
+                sout << @@aes.decrypt_buffer(buf)
+              end
+            end
+        else
+            raise "Bad input stream (String, IO)"
+        end
+    end
+
+end # end Aes