camellia-rb 1.1

data/History.txt

@@ -0,0 +1,18 @@
+== 1.0 2008-07-18
+the first edition
+
+== 1.1 2008-09-09
+Changes from version 1.0
+
+* 'the object generation method' and 'the setting method of the encrypting key'
+  Camellia.new
+  Camellia#set_key('key')
+  ->  Camellia.new('key')
+
+* 'CamelliaError#errno' and 'CamelliaError#error' is deleted
+
+* 'CamelliaError' is changed to 'Error'
+
+* the directory name of extended library is changed to 'ext'
+
+* unused file/directory is deleted from the package

data/License.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2008
+NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer as
+  the first lines of this file unmodified.
+2. Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY NTT ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL NTT BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

data/Manifest.txt

@@ -0,0 +1,29 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+ext/camellia.c
+ext/camellia.c
+ext/camellia.h
+ext/camellia-rb.c
+ext/extconf.rb
+ext/camellia-example.rb
+lib/camellia/version.rb
+script/destroy
+script/destroy.cmd
+script/generate
+script/generate.cmd
+script/txt2html
+script/txt2html.cmd
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,82 @@
+############################################################
+
+camellia_rb
+
+############################################################
+
+About Camellia
+
+ Camellia is a symmetric key block cipher developed jointly in 2000 by world top class encryption
+researchers at NTT and Mitsubishi Electric Corporation. Technologically speaking, Camellia naturally
+has not only a high level of security, but also excellent efficiency and practical characteristics. 
+It can be implemented at high performance by software on various platforms. In regard to hardware
+implementation, compact, and low-power consumption type implementation as well as high-speed
+implementation is possible.
+
+ Based on these technological advantages, Camellia has been internationally recognized, 
+for example the selection project on the European recommendation of strong cryptographic primitives,
+NESSIE, evaluated Camellia to have "many similarities to the AES, so much of the analysis for the AES
+is also applicable to Camellia." Currently, Camellia is the only cipher internationally recognized
+which has the same level of security and performance as AES, and is selected for many international
+standard/recommended ciphers. In particular, as Japanese domestic ciphers, this is the first case
+to be approved as IETF standard ciphers (Proposed Standard RFC) . 
+
+Camellia Website : http://info.isl.ntt.co.jp/crypt/eng/camellia/index.html
+
+
+About camellia_rb
+
+  camellia_rb is a Camellia package for Ruby. Camellia engine is implemented in "C".
+  Camellia implimentation is imported from
+  http://info.isl.ntt.co.jp/crypt/camellia/dl/camellia-BSD-1.2.0.tar.gz
+
+  Supported key length : 128bit/192bit/256bit
+  Supported modes of operation : ECB/CFB/CBC
+  license : see License.txt
+
+
+How to install
+
+% ruby extconf.rb
+% make
+% make install
+
+
+How to use
+
+Interfaces
+
+  Camellia.new('key')
+
+  #ECB
+  Camellia#encrypt('plain text 16byte')
+  Camellia#decrypt('cipher text 16byte')
+
+  #CFB
+  Camellia#cfb_salt('salt 16byte')
+  Camellia#cfb_encrypt('plain text')
+  Camellia#cfb_decrypt('cipher text')
+
+  #CBC
+  Camellia#cbc_salt('salt 16byte')
+  Camellia#cbc_pchar('padding character')
+  Camellia#cbc_encrypt('plain text')
+  Camellia#cbc_decryp('cipher text')
+
+
+Sample program(camellia-example.rb)
+
+  # ruby camellia-example.rb
+
+  deadbeefdeadbeef
+  now is the time for all good men to come to the aid of thei.chr country.
+  now is the time for all good men to come to the aid of thei.chr country.
+
+
+
+############################################################
+
+ * Copyright (c) 2008
+ * NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.
+
+############################################################

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,75 @@
+require 'camellia/version'
+
+AUTHOR = 'FIXME full name'  # can also be an array of Authors
+EMAIL = "FIXME email"
+DESCRIPTION = "description of gem"
+GEM_NAME = 'camellia-rb' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'camellia-rb' # The unix name for your project
+#HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+HOMEPATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Camellia::VERSION::STRING + (REV ? ".#{REV}" : "")
+#RDOC_OPTS = ['--quiet', '--title', 'camellia documentation',
+RDOC_OPTS = ['--title', 'camellia documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+   p.spec_extras = {
+    :extensions => ['ext/extconf.rb'],
+  }
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'camellia_rb'

data/ext/camellia-example.rb

@@ -0,0 +1,44 @@
+#* camellia-example.rb
+#*
+#* Copyright (c) 2008
+#* NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.
+#*
+#* Redistribution and use in source and binary forms, with or without
+#* modification, are permitted provided that the following conditions
+#* are met:
+#* 1. Redistributions of source code must retain the above copyright
+#*   notice, this list of conditions and the following disclaimer as
+#*   the first lines of this file unmodified.
+#* 2. Redistributions in binary form must reproduce the above copyright
+#*   notice, this list of conditions and the following disclaimer in the
+#*   documentation and/or other materials provided with the distribution.
+#*
+#* THIS SOFTWARE IS PROVIDED BY NTT ``AS IS'' AND ANY EXPRESS OR
+#* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+#* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+#* IN NO EVENT SHALL NTT BE LIABLE FOR ANY DIRECT, INDIRECT,
+#* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+#* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+#* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#*
+require "camellia"
+
+#ECB
+a=Camellia.new('deadbeefdeadbeefdeadbeefdeadbeef')
+b=a.encrypt("deadbeefdeadbeef")
+print a.decrypt(b),"\n"  # should print deadbeefdeadbeef
+
+#CFB
+a.cfb_salt('128bitbinaryvalu') # must be a 128-bit BINARY value
+b=a.cfb_encrypt("now is the time for all good men to come to the aid of thei.chr country.\n")
+a.cfb_salt('128bitbinaryvalu') # must be a 128-bit BINARY value
+print a.cfb_decrypt(b)
+
+#CBC
+a.cbc_salt('128bitbinaryvalu') # must be a 128-bit BINARY value
+b=a.cbc_encrypt("now is the time for all good men to come to the aid of thei.chr country.\n")
+a.cbc_salt('128bitbinaryvalu') # must be a 128-bit BINARY value
+print a.cbc_decrypt(b)

data/ext/camellia-rb.c

@@ -0,0 +1,546 @@
+/* camellia-rb.c
+ *
+ * Copyright (c) 2008
+ * NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer as
+ *   the first lines of this file unmodified.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY NTT ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL NTT BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <ruby.h>
+#include "camellia.h"
+#include <stdio.h>
+
+typedef unsigned char u1byte;
+
+// error class
+static VALUE eCamellia;
+
+// camellia object
+typedef struct {
+	int				key_len;		// key lengh
+	KEY_TABLE_TYPE	key;			// sub keys
+	int				key_gen;		// key initialized flag
+	u1byte			cfb_blk[16];	// buffer for CFB
+	u1byte			cfb_crypt[16];	// buffer for CFB
+	int				cfb128_idx;		// index for buffer of CFB
+	u1byte			cbc_blk[16];	// buffer for CBC
+	u1byte			cbc_crypt[16];	// buffer for CBC
+	int				cbc128_idx;		// index for buffer of CBC
+	u1byte			cbc_pchar;		// padding char(default:0x05)
+} camelliaObject;
+
+/*
+# return a new camellia object
+*/
+static VALUE s_new(VALUE self)
+{
+	camelliaObject *camellia;
+	VALUE camellia_data;
+
+	camellia = ALLOC(camelliaObject);
+	camellia->key_gen = 0;	// key is not initialized
+	camellia->cfb128_idx = -2;	// CFB index is initialized
+	camellia->cbc128_idx = -2;	// CBC index is initialized
+	camellia->cbc_pchar = 0x05;
+	camellia->key_gen = 0;
+
+	camellia_data = Data_Wrap_Struct(self, 0, free, camellia);
+
+	//rb_obj_call_init(camellia_data, 0, NULL);
+	return camellia_data;
+}
+
+/*
+# set_key method
+*/
+static VALUE set_key(VALUE self, VALUE key)
+{
+	unsigned char *skey;
+	int skey_len;
+	camelliaObject *camellia;
+
+	Data_Get_Struct(self, camelliaObject, camellia);
+
+	Check_Type(key, T_STRING);
+	skey_len = RSTRING(key)->len;
+	skey = (unsigned char *)RSTRING(key)->ptr;
+
+	// check key length
+	if (skey_len != 16 && skey_len != 24 && skey_len != 32)
+	{
+    	rb_raise(rb_eArgError, "wrong key length (must be 16, 24, or 32 bytes,not %d)", skey_len);
+		return self; 
+	}
+
+	// key generation
+	camellia->key_len = skey_len*8;
+	Camellia_Ekeygen(camellia->key_len, skey, camellia->key);
+	camellia->key_gen = 1;	//key is initialized
+
+	//return self;
+	return Qnil;
+}
+
+/*
+# encryption method
+*/
+static VALUE encrypt(VALUE self, VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *data;
+	int data_len;
+	u1byte out_blk[16];
+
+	Check_Type(args, T_STRING);
+	data_len = RSTRING(args)->len;
+	data = (unsigned char *)RSTRING(args)->ptr;
+
+	Data_Get_Struct(self, camelliaObject, camellia);
+
+	// check data length
+	if (data_len != 16)
+	{
+		rb_raise(rb_eArgError, "wrong data length (must be 16 bytes, found %d bytes)", data_len);
+		return self;
+	}
+
+	// check if key is initialized
+	if (!camellia->key_gen)
+	{
+		rb_raise(eCamellia,"must set up a key before you can encrypt!");
+		return self; 
+	}
+
+	// encryption
+   Camellia_EncryptBlock(camellia->key_len, data, camellia->key, out_blk);
+
+	return rb_str_new((char *)out_blk, 16);
+}
+
+/*
+# decryption method
+*/
+static VALUE decrypt(VALUE self,VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *data;
+	int data_len;
+	u1byte out_blk[16];
+
+	Check_Type(args, T_STRING);
+	data_len = RSTRING(args)->len;
+	data = (unsigned char *)RSTRING(args)->ptr;
+
+	// check data length
+	if (data_len != 16)
+	{
+		rb_raise(rb_eArgError, "wrong data length (must be 16 bytes, found %d bytes)", data_len);
+		return 0;
+	}
+
+	Data_Get_Struct(self, camelliaObject, camellia);
+
+	// check if key is initialized
+	if (!camellia->key_gen)
+	{
+		rb_raise(eCamellia,"must set up a key before you can decrypt!");
+		return 0; 
+	}
+
+	// decryption
+	Camellia_DecryptBlock(camellia->key_len, data, camellia->key, out_blk);
+
+	return rb_str_new((char *)out_blk,16);
+}
+
+/*
+# CFB IV set method
+*/
+static VALUE cfb_salt(VALUE self, VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	unsigned char *dest;
+	int src_len;
+	int i;
+
+	Check_Type(args,T_STRING);
+	src = (unsigned char *)RSTRING(args)->ptr;
+	src_len = RSTRING(args)->len;
+
+	// check IV length
+	if (src_len != 16)
+	{
+		rb_raise(rb_eArgError, "wrong data length (must be 16 bytes, found %d bytes)", src_len);
+		return self;
+	}
+
+	Data_Get_Struct(self, camelliaObject, camellia);
+
+	// CFB initial set
+	camellia->cfb128_idx = -1;
+	dest = camellia->cfb_blk;
+	for (i = 0; i < 16; i++)
+	{
+		*dest++ = *src++;
+	}
+	
+	return self;
+}
+
+/*
+# CFB encryption method
+*/
+static VALUE cfb_encrypt(VALUE self,VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	unsigned char *destdata;
+	int srclen;
+	int i,ch;
+	VALUE retvalue;
+
+	Check_Type(args,T_STRING);
+	src = (unsigned char *)RSTRING(args)->ptr;
+	srclen = RSTRING(args)->len;
+
+	Data_Get_Struct(self,camelliaObject,camellia);
+
+	// check if key is initialized
+	if (!camellia->key_gen)
+	{
+		rb_raise(eCamellia,"must set up a key before you can cfb_encrypt!");
+		return self; 
+	}
+
+	// check if IV is initialized
+	if (camellia->cfb128_idx != -1)
+	{
+		rb_raise(eCamellia,"must set up a salt before you can cfb_encrypt!");
+		return self; 
+	}
+
+	destdata = (unsigned char *)malloc(srclen);
+
+	// CFB encryption
+	for (i = 0; i < srclen; i++)
+	{
+	   	if ((camellia->cfb128_idx < 0) || (camellia->cfb128_idx > 15))
+		{
+			Camellia_EncryptBlock(camellia->key_len, camellia->cfb_blk, camellia->key, camellia->cfb_crypt);
+			camellia->cfb128_idx=0;
+		}
+		ch = src[i] ^ camellia->cfb_crypt[camellia->cfb128_idx];
+		camellia->cfb_blk[camellia->cfb128_idx++] = ch; 
+		destdata[i] = (unsigned char)ch;
+	}
+
+	retvalue = rb_str_new((char *)destdata, srclen);
+	free(destdata);
+	return retvalue;
+}
+
+/*
+# CFB decryption method
+*/
+static VALUE cfb_decrypt(VALUE *self, VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	unsigned char *destdata;
+	int srclen;
+	int i;
+	unsigned char ch;
+	VALUE retvalue;
+
+	Check_Type(args, T_STRING);
+	srclen = RSTRING(args)->len;
+	src = (unsigned char *)RSTRING(args)->ptr;
+
+	Data_Get_Struct(self,camelliaObject, camellia);
+
+	// check if key is initialized
+	if (!camellia->key_gen)
+	{
+		rb_raise(eCamellia,"must set up a key before you can cfb_decrypt!");
+		return 0; 
+	}
+
+	// check if IV is initialized
+	if (camellia->cfb128_idx != -1)
+	{
+		rb_raise(eCamellia,"must set up a salt before you can cfb_decrypt!");
+		return 0; 
+	}
+
+	destdata = (unsigned char *)malloc(srclen);
+
+	// CFB decryption
+	for (i = 0; i < srclen; i++)
+	{
+		if (camellia->cfb128_idx < 0 || camellia->cfb128_idx > 15)
+		{
+			Camellia_EncryptBlock(camellia->key_len,  camellia->cfb_blk, camellia->key, camellia->cfb_crypt);
+			camellia->cfb128_idx=0;
+		}
+		ch = src[i];
+		destdata[i] = ch ^ camellia->cfb_crypt[camellia->cfb128_idx]; 
+		camellia->cfb_blk[camellia->cfb128_idx++] = ch; 
+	}
+
+	retvalue=rb_str_new((char *)destdata, srclen);
+	free(destdata);
+	return retvalue;
+}
+
+/*
+# CBC IV set
+*/
+static VALUE cbc_salt(VALUE self, VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	unsigned char *dest, *dest2;
+	int src_len;
+	int i;
+
+	Check_Type(args,T_STRING);
+	src = (unsigned char *)RSTRING(args)->ptr;
+	src_len = RSTRING(args)->len;
+
+	// check IV length
+	if (src_len != 16)
+	{
+		rb_raise(rb_eArgError, "wrong data length (must be 16 bytes, found %d bytes)", src_len);
+		return self;
+	}
+
+	Data_Get_Struct(self, camelliaObject, camellia);
+
+	// CBC initial set
+	camellia->cbc128_idx = -1;
+	dest = camellia->cbc_blk;
+	dest2 = camellia->cbc_crypt;
+	for (i = 0; i < 16; i++)
+	{
+		*dest++ = *src;
+		*dest2++ = *src++;
+	}
+	
+	return self;
+}
+
+/*
+# CBC padding charactor set
+*/
+static VALUE cbc_pchar(VALUE self, VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	int src_len;
+
+	Check_Type(args,T_STRING);
+	src = (unsigned char *)RSTRING(args)->ptr;
+	src_len = RSTRING(args)->len;
+
+	// check pcharlength
+	if (src_len != 1)
+	{
+		rb_raise(rb_eArgError, "wrong padding data length (must be 1 bytes, found %d bytes)", src_len);
+		return self;
+	}
+
+	Data_Get_Struct(self, camelliaObject, camellia);
+
+	// pchar set
+	camellia->cbc_pchar = *src;
+	
+	return self;
+}
+
+/*
+# CBC encryption method
+*/
+static VALUE cbc_encrypt(VALUE self,VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	unsigned char *destdata;
+	int srclen;
+	int i, j, ch, destidx;
+	VALUE retvalue;
+
+	Check_Type(args,T_STRING);
+	src = (unsigned char *)RSTRING(args)->ptr;
+	srclen = RSTRING(args)->len;
+
+	Data_Get_Struct(self,camelliaObject,camellia);
+
+	// check if key is initialized
+	if (!camellia->key_gen)
+	{
+		rb_raise(eCamellia,"must set up a key before you can cbc_encrypt!");
+		return self; 
+	}
+
+	// check if IV is initialized
+	if (camellia->cbc128_idx != -1)
+	{
+		rb_raise(eCamellia,"must set up a salt before you can cbc_encrypt!");
+		return self; 
+	}
+
+	if (srclen % 16 == 0)
+		destdata = (unsigned char *)malloc(srclen);
+	else
+		destdata = (unsigned char *)malloc((srclen/16+1)*16);
+
+	// CBC encryption
+	destidx = 0;
+	camellia->cbc128_idx = 0;
+	for (i = 0; i < srclen; i++)
+	{
+		ch = src[i] ^ camellia->cbc_crypt[camellia->cbc128_idx];
+		camellia->cbc_blk[camellia->cbc128_idx++] = ch; 
+
+	   	if (camellia->cbc128_idx == 16)
+		{
+			Camellia_EncryptBlock(camellia->key_len, camellia->cbc_blk, camellia->key, camellia->cbc_crypt);
+			camellia->cbc128_idx=0;
+			for (j = 0; j < 16; j++)
+			{
+				destdata[destidx++] = camellia->cbc_crypt[j];
+			}
+		}
+	}
+	if (srclen % 16 != 0)
+	{
+		while (camellia->cbc128_idx < 16)
+		{
+			camellia->cbc_blk[camellia->cbc128_idx] = camellia->cbc_pchar ^ camellia->cbc_crypt[camellia->cbc128_idx++];
+		}
+	
+		Camellia_EncryptBlock(camellia->key_len, camellia->cbc_blk, camellia->key, camellia->cbc_crypt);
+		for (j = 0; j < 16; j++)
+		{
+			destdata[destidx++] = camellia->cbc_crypt[j];
+		}
+	}
+
+	if (srclen % 16 == 0)
+		retvalue = rb_str_new((char *)destdata, srclen);
+	else
+		retvalue = rb_str_new((char *)destdata, (srclen/16+1)*16);
+	free(destdata);
+	return retvalue;
+}
+
+/*
+# CBC decryption method
+*/
+static VALUE cbc_decrypt(VALUE *self, VALUE args)
+{
+	camelliaObject *camellia;
+	unsigned char *src;
+	unsigned char *destdata;
+	int srclen;
+	int i, j, destidx;
+	u1byte tmp[16];
+	VALUE retvalue;
+
+	Check_Type(args, T_STRING);
+	srclen = RSTRING(args)->len;
+	src = (unsigned char *)RSTRING(args)->ptr;
+
+	Data_Get_Struct(self,camelliaObject, camellia);
+
+	// check if key is initialized
+	if (!camellia->key_gen)
+	{
+		rb_raise(eCamellia,"must set up a key before you can cbc_decrypt!");
+		return 0; 
+	}
+
+	// check if IV is initialized
+	if (camellia->cbc128_idx != -1)
+	{
+		rb_raise(eCamellia,"must set up a salt before you can cbc_decrypt!");
+		return 0; 
+	}
+
+	destdata = (unsigned char *)malloc(srclen);
+
+	// CBC decryption
+	destidx = 0;
+	camellia->cbc128_idx = 0;
+	for (i = 0; i < srclen; i++)
+	{
+		tmp[camellia->cbc128_idx] = camellia->cbc_blk[camellia->cbc128_idx];
+		camellia->cbc_blk[camellia->cbc128_idx++] = src[i];
+
+		if (camellia->cbc128_idx == 16)
+		{
+			Camellia_DecryptBlock(camellia->key_len,  camellia->cbc_blk, camellia->key, camellia->cbc_crypt);
+			camellia->cbc128_idx=0;
+			
+			for (j = 0; j < 16; j++)
+			{
+				destdata[destidx++] = camellia->cbc_crypt[j] ^ tmp[j];
+			}
+		}
+	}
+
+	// remove paddingchar
+	while (destdata[srclen-1] == camellia->cbc_pchar)
+	{
+		srclen--;
+	}
+
+	retvalue=rb_str_new((char *)destdata, srclen);
+	free(destdata);
+	return retvalue;
+}
+
+// 
+void Init_camellia() 
+{
+	VALUE cCamellia = rb_define_class("Camellia", rb_cObject);
+	rb_define_alloc_func(cCamellia, s_new);
+	
+	//rb_define_singleton_method(cCamellia, "new", s_new, 0);
+	rb_define_private_method(cCamellia, "initialize", set_key, 1);
+	//rb_define_method(cCamellia, "set_key", set_key, 1);
+	rb_define_method(cCamellia, "encrypt", encrypt, 1);
+	rb_define_method(cCamellia, "decrypt", decrypt, 1);
+	rb_define_method(cCamellia, "cfb_salt", cfb_salt, 1);
+	rb_define_method(cCamellia, "cfb_encrypt", cfb_encrypt, 1);
+	rb_define_method(cCamellia, "cfb_decrypt", cfb_decrypt, 1);
+	rb_define_method(cCamellia, "cbc_salt", cbc_salt, 1);
+	rb_define_method(cCamellia, "cbc_pchar", cbc_pchar, 1);
+	rb_define_method(cCamellia, "cbc_encrypt", cbc_encrypt, 1);
+	rb_define_method(cCamellia, "cbc_decrypt", cbc_decrypt, 1);
+	
+	eCamellia = rb_define_class("Error", rb_eStandardError);
+	//rb_define_method(eCamellia, "error", error_error, 0);
+	//rb_define_method(eCamellia, "errno", error_errno, 0);
+
+	rb_define_const(eCamellia, "WRONG_KEY_LENGTH", INT2NUM(1));
+}