Class: EzCrypto::Key

### Home Classes Methods

### In Files

- lib/ezcrypto.rb

### Parent

Object

### Methods

- ::block_size
- ::block_size=
- ::calculate_key_size
- ::decode
- ::decrypt_with_password
- ::encrypt_with_password
- ::generate
- ::load
- ::new
- ::with_password
- #decrypt
- #decrypt64
- #decrypt_file
- #decrypter
- #encode
- #encrypt
- #encrypt64
- #encrypt_file
- #encrypter
- #marshal_dump
- #marshal_load
- #on_decrypter
- #on_encrypter
- #store
- #to_s

### Files

- CHANGELOG
- README.rdoc
- README_ACTIVE_CRYPTO
- README_DIGITAL_SIGNATURES

### Class/Module Index

Quicksearch

- EzCrypto
- EzCrypto::Certificate
- EzCrypto::Digester
- EzCrypto::Key
- EzCrypto::Name
- EzCrypto::Signer
- EzCrypto::TrustStore
- EzCrypto::Verifier
- ActiveCrypto
- ActiveCrypto::AssociationKeyHolder
- ActiveCrypto::ClassMethods
- ActiveCrypto::Encrypted
- ActiveCrypto::Encrypted::ClassAccessors
- ActiveCrypto::KeyHolder
- ActiveCrypto::MissingKeyError

No matching classes.

# EzCrypto::Key

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 `:algorithm=>alg name` parameter.

Eg.

    Key.new @raw, :algorithm=>"des"
    Key.generate :algorithm=>"blowfish"
    Key.with_password @pwd,@salt,:algorithm=>"aes256"

## License

ActiveCrypto and EzCrypto are released under the MIT license.

## Support

To contact the author, send mail to pelleb@gmail.com

Also see my blogs at: stakeventures.com and neubia.com

This project was based on code used in my project StakeItOut, where you can securely share web services with your partners. stakeitout.com

(C) 2005 Pelle Braendgaard

### Attributes

algorithm[R]
raw[R]

### Public Class Methods

block_size() click to toggle source

Return the block-size for IO-operations.

    # File lib/ezcrypto.rb, line 59
    def self.block_size
      @@block_size
    end

block_size=(size) click to toggle source

Set the block-size for IO-operations (default: 512 bytes)

    # File lib/ezcrypto.rb, line 52
    def self.block_size=(size)
      @@block_size = size
    end

calculate_key_size(algorithm) click to toggle source

Given an algorithm this calculates the keysize. This is used by both the generate and with_password methods. This is not yet 100% complete.

    # File lib/ezcrypto.rb, line 123
    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

decode(encoded,options = {}) click to toggle source

Initialize the key with Base64 encoded key data.

    # File lib/ezcrypto.rb, line 90
    def self.decode(encoded,options = {})
      Key.new(Base64.decode64(encoded),options)
    end

decrypt_with_password(password,salt,data,options = {}) click to toggle source

Decrypts the data with the given password and a salt. Short hand for:

    key=Key.with_password(password,salt,options)
    key.decrypt(data)

    # File lib/ezcrypto.rb, line 114
    def self.decrypt_with_password(password,salt,data,options = {})
      key=Key.with_password(password,salt,options)
      key.decrypt(data)
    end

encrypt_with_password(password,salt,data,options = {}) click to toggle source

Encrypts the data with the given password and a salt. Short hand for:

    key=Key.with_password(password,salt,options)
    key.encrypt(data)

    # File lib/ezcrypto.rb, line 101
    def self.encrypt_with_password(password,salt,data,options = {})
      key=Key.with_password(password,salt,options)
      key.encrypt(data)
    end

generate(options = {}) click to toggle source

Generate random key.

    # File lib/ezcrypto.rb, line 76
    def self.generate(options = {})
      Key.new(EzCrypto::Digester.generate_key(calculate_key_size(options[:algorithm])),options)
    end

load(filename) click to toggle source

Load a key from a yaml_file generated via Key#store.

    # File lib/ezcrypto.rb, line 290
    def self.load(filename)
      require 'yaml'
      hash = YAML::load_file(filename)
      req = proc { |k| hash[k] or raise "Missing element #{k} in #{filename}" }
      key = self.new Base64.decode64(req.call(:key)) , :algorithm => req.call(:algorithm)
      return key
    end

new(raw,options = {}) click to toggle source

Initialize the key with raw unencoded binary key data. This needs to be at least 16 bytes long for the default aes-128 algorithm.

    # File lib/ezcrypto.rb, line 68
    def initialize(raw,options = {})
      @raw=raw
      @algorithm=options[:algorithm]||"aes-128-cbc"
    end

with_password(password,salt,options = {}) click to toggle source

Create key generated from the given password and salt

    # File lib/ezcrypto.rb, line 83
    def self.with_password(password,salt,options = {})
      Key.new(EzCrypto::Digester.get_key(password,salt,calculate_key_size(options[:algorithm])),options)
    end

### Public Instance Methods

decrypt(data) click to toggle source

Decrypts the data passed to it in binary format.

    # File lib/ezcrypto.rb, line 196
        def decrypt(data)
          if data==nil || data==""
            nil
          else
            decrypter("")
            @cipher.gulp(data)
          end
    #    rescue
    #      puts @algorithm
    #      puts self.encode
    #      puts data.size
    #      throw $!
        end

decrypt64(data) click to toggle source

Decrypts a Base64 formatted string

    # File lib/ezcrypto.rb, line 213
    def decrypt64(data)
      decrypt(Base64.decode64(data))
    end

decrypt_file(src, tgt=nil, options = {} ) click to toggle source

Decrypt a file 'inplace' and remove a suffix see cipher_file IMPORTANT: The inputfile will be deleted by default.

    # File lib/ezcrypto.rb, line 383
    def decrypt_file(src, tgt=nil, options = {} )
      options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
      unless tgt
        tgt = src
        tgt = tgt.gsub(/#{options[:suffix]}$/, '')
      end
      cipher_file :on_decrypter, src, tgt, options[:autoclean]
    end

decrypter(target='') click to toggle source

Get a Decrypter object. You have to call final on it by yourself!

    # File lib/ezcrypto.rb, line 327
    def decrypter(target='')
      @cipher = EzCrypto::Decrypter.new(self,target,@algorithm)
    end

encode() click to toggle source

returns the Base64 encoded key.

    # File lib/ezcrypto.rb, line 163
    def encode
      Base64.encode64(@raw).chop
    end

encrypt(data) click to toggle source

Encrypts the data and returns it in encrypted binary form.

    # File lib/ezcrypto.rb, line 177
    def encrypt(data)
      if data==nil || data==""
        nil
      else
        encrypter("")
        @cipher.encrypt(data)
      end
    end

encrypt64(data) click to toggle source

Encrypts the data and returns it in encrypted Base64 encoded form.

    # File lib/ezcrypto.rb, line 189
    def encrypt64(data)
      Base64.encode64(encrypt(data))
    end

encrypt_file(src, tgt=nil, options = {} ) click to toggle source

Encrypt a file 'inplace' and add a suffix see cipher_file. IMPORTANT: The inputfile will be deleted by default.

    # File lib/ezcrypto.rb, line 371
    def encrypt_file(src, tgt=nil, options = {} )
      options = { :suffix => '.ez', :autoclean => 'true' }.update(options)
      tgt = "#{src}#{options[:suffix]}" unless tgt
      cipher_file :on_encrypter, src, tgt, options[:autoclean]
    end

encrypter(target='') click to toggle source

Get a Encrypter object. You have to call final on it by yourself!

    # File lib/ezcrypto.rb, line 319
    def encrypter(target='')
      @cipher = EzCrypto::Encrypter.new(self,target,@algorithm)
    end

marshal_dump() click to toggle source

Allows keys to be marshalled

    # File lib/ezcrypto.rb, line 220
    def marshal_dump
       "#{self.algorithm}$$$#{self.encode}"
    end

marshal_load(s) click to toggle source

Allows keys to be unmarshalled

    # File lib/ezcrypto.rb, line 227
    def marshal_load(s)
       a, r = s.split '$$$'
       @algorithm = a
       @raw = Base64.decode64(r)
    end

on_decrypter(target='', &block) click to toggle source

Create a Decrypter object and yield it to a block. You must not call final by yourself, the method does this.

    # File lib/ezcrypto.rb, line 336
    def on_decrypter(target='', &block)
      decrypter(target)
      on_cipher(&block)
    end

on_encrypter(target='', &block) click to toggle source

Create an Encrypter object and yield it to a block. You must not call final by yourself, the method does this.

    # File lib/ezcrypto.rb, line 346
    def on_encrypter(target='', &block)
      encrypter(target)
      on_cipher(&block)
    end

store(filename) click to toggle source

Save the key data into a file, try to do this in a secure manner. NOTE: YAML::store & friends are not used to encance control over the generated file format.

    # File lib/ezcrypto.rb, line 304
    def store(filename)
      safe_create(filename) do |f|
        selfenc = self.encode
        f.puts "---"
        f.puts ":EZCRYPTO KEY FILE: KEEP THIS SECURE !"
        f.puts ":created: #{Time.now}"
        f.puts ":algorithm: #{@algorithm}"
        f.puts ":key: #{selfenc}"
      end
    end

to_s() click to toggle source

returns the Base64 encoded key. Synonym for encode.

    # File lib/ezcrypto.rb, line 170
    def to_s
      encode
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.