encryption 1.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    M2EyM2Q4MWUzM2VhZGE3ZmE5YmM2MGQ5N2Y2MTM0YzVjOWNhOTkwOQ==
+  data.tar.gz: !binary |-
+    YzQ1NjNkZDg0MWExNTZmN2YzNGMzNzczZTJjOGEzMWViNWYwOTc1ZA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MjY3NDQzYzQwNTY3OTA5Yzc2MDRiYmE1N2Y5ODhjZWZlMmZhNjdiNDQ5ZmU3
+    ZDU4ZmEwNDJkZWY1ZmRkZjM2NTU5NTc2YzhmZDE4ODQ0ZTI2NzIyZTBmN2Rj
+    YjJlM2FkOGM1NmE3NmFiNjkyODQwMzI2NTc2NGY4NjhlNzhkNGQ=
+  data.tar.gz: !binary |-
+    ZTA3ZmZlM2I1OGZiNDg1OWQyZWQ2Nzc4ODA0NzliZmVmY2YyMzE0Yzc3NGJl
+    NzNjNWJmN2ZiMGZjMDZjZjU4NTU4NWRiOGM5OWI5ODAxZmY4MDQ1OTlkYWMw
+    NDE2YTdiOTM4YTE1MWIzNmI2ZmM0OWE5NWVhNGNiYjQ2MTgzYzU=

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    encryption (1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.1)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  encryption!
+  rspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Itay Grudev
+
+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.md

@@ -0,0 +1,74 @@
+Encryption
+==========
+
+[![Code Climate](https://codeclimate.com/github/Itehnological/encryption.png)](https://codeclimate.com/github/Itehnological/encryption)
+
+A simple wrapper for the OpenSSL Cipher library
+
+Usage
+-----
+
+ Basic
+ -----
+ ```ruby
+Encryption.key = 'your encryption key'
+enc_str = Encryption.encrypt "data to encrypt" # non-human readable string
+Encryption.decrypt enc_str # "data to encrypt"
+ ```
+ 
+ Installation
+ ------------
+ ```bash
+ gem install encryption
+ ```
+ 
+ Configuration
+ -------------
+ You can pass the config settings with a configuration block
+ ```ruby
+Encryption.config do |config|
+  key: 'encryption key',
+  iv: 'initialization vector', # Optional
+  cipher: 'aes-256-cbc' # Optional. Defaults to `aes-256-cbc`
+end
+ ```
+`Encryption::key`: is the encryption key. has to be set to use the encryption / decryption methods. Usually about 30+ charecters long.
+`Encryption::iv`: _[Optional]_ the initialization vector. Defaults to the charecter "\0".
+`Encryption::cipher`: _[Optional]_ the encryption algorithm to be used. Defaults to "aes-256-cbc".
+ 
+Advanced
+--------
+In some cases you'll need a separate instance of the encryptor, rather than a global one.
+To do that you just have to create a new instance of the `Encryption::Encryptor` class.
+```ruby
+encryptor = Encryption::Encryptor.new
+encryptor.key = 'encryption key'
+encryptor.iv = 'initialization vector' # Optional
+encryptor.cipher = 'aes-128-cbc' # Optional
+# Or you can configure it with a block
+encryptor.config do |config|
+  key: 'your encryption key'
+end
+data = "data to encrypt"
+enc_str = encryptor.encrypt(data) # Encrypt the string
+dec_str = encryptor.decrypt(enc_str) # Decrypt it
+data == dec_str # true
+```
+String Helper
+-------------
+The gem adds a few helper methods to the String class. You can use them as follows:
+```ruby
+"this is not a secret".encrypt # Non human readable string
+"this is a secret".encrypt!
+"3nCRYpteD DaTA".decrypt
+"3nCRYpteD DaTA".decrypt!
+```
+__Note:__ To use the string helpers you have t oset the encryption with `Encryption.key` or with a configuration block.
+
+License
+-------
+This gem is published under The MIT License (MIT).
+
+ Author
+ ------
+ Itay Grudev - ![Itay Grudev](http://safemail.justlikeed.net/e/a5307c0c2dd405f756cab9f4c76cd63a.png)

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# Make RSpec the default task
+task :default => :spec

data/encryption.gemspec

@@ -0,0 +1,15 @@
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'encryption'
+  s.version     = '1.0.1'
+  s.date        = '2013-03-24'
+  s.summary     = 'A simple wrapper for the OpenSSL Cipher library'
+  s.description = 'A simple wrapper for the OpenSSL Cipher library'
+  s.authors     = ['Itay Grudev']
+  s.email       = ['itay.grudev@gmail.com']
+  s.homepage    = 'https://github.com/Itehnological/encryption'
+  s.files       = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.license = "MIT"
+end

data/lib/encryption.rb

@@ -0,0 +1,34 @@
+require 'encryption/configuration.rb'
+require 'encryption/encryptor.rb'
+require 'encryption/string_helper.rb'
+
+String.send(:include, Encryption::String)
+
+module Encryption
+
+  @@own_instance = nil
+
+  def self.method_missing(name, *args, &block)
+    initalize_own_instance
+
+    if @@own_instance.respond_to?(name)
+      return @@own_instance.send(name, *args, &block)
+    end
+
+    super
+  end
+
+  def self.respond_to?(name)
+    initalize_own_instance
+    return true if @@own_instance.respond_to?(name)
+    super
+  end
+
+private
+  def self.initalize_own_instance
+    if @@own_instance.nil?
+      @@own_instance = Encryption::Encryptor.new
+    end
+  end
+
+end

data/lib/encryption/configuration.rb

@@ -0,0 +1,40 @@
+module Encryption
+  class Configuration
+
+    def initialize
+      @config = {
+        key: nil,
+        iv: "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
+        cipher: 'aes-256-cbc'
+      }
+    end
+
+    def config
+      yield self
+    end
+
+    def method_missing(name, *args)
+      
+      return @config[name.to_sym] if is_valid_getter(name)
+      return @config[name[0...-1].to_sym] = args[0] if is_valid_setter(name)
+
+      super
+    end
+
+    def respond_to?(name)
+      return true if is_valid_getter(name) or is_valid_setter(name)
+      super
+    end
+
+  private
+  
+    def is_valid_getter(name)
+      @config.has_key? name.to_sym
+    end
+
+    def is_valid_setter(name)
+      name[-1] == '=' and @config.has_key? name[0...-1].to_sym
+    end
+
+  end
+end

data/lib/encryption/encryptor.rb

@@ -0,0 +1,60 @@
+require 'openssl'
+
+module Encryption
+  class Encryptor
+
+    @cipher = nil
+    @decipher = nil
+    @configuration = nil
+
+    def initialize
+      @configuration = Encryption::Configuration.new
+    end
+
+    def method_missing(name, *args, &block)
+      if @configuration.respond_to? name
+        return @configuration.send(name, *args, &block)
+      end
+      super
+    end
+
+    def respond_to?(name)
+      return true if @configuration.respond_to? name
+      super
+    end
+
+    def encrypt(data)
+      prepare(_cipher)
+      _cipher.update(data) + _cipher.final
+    end
+
+    def decrypt(data)
+      prepare(_decipher)
+      _decipher.update(data) + _decipher.final
+    end
+
+  private
+    def prepare(what)
+      what.key = @configuration.key
+      what.iv = @configuration.iv
+    end
+
+    def _cipher
+      if @cipher.nil?
+        @cipher = OpenSSL::Cipher.new(@configuration.cipher)
+        @cipher.encrypt
+      end
+
+      @cipher
+    end
+
+    def _decipher
+      if @decipher.nil?
+        @decipher = OpenSSL::Cipher.new(@configuration.cipher)
+        @decipher.decrypt
+      end
+
+      @decipher
+    end
+  end
+end

data/lib/encryption/string_helper.rb

@@ -0,0 +1,30 @@
+module Encryption
+
+  #
+  # Extends String. Adds helper methods for encrypting / decrypting strings
+  #
+  module String
+
+    # Returns an encrypted version of a string
+    def encrypt
+      Encryption.encrypt self
+    end
+
+    # Replaces the string with an encrypted version of itself
+    def encrypt!
+      replace encrypt
+    end
+
+    # Returns a decrypted version of a string
+    def decrypt
+      Encryption.decrypt self
+    end
+
+    # Replaces the string with a decrypted version of itself
+    def decrypt!
+      replace decrypt
+    end
+
+  end 
+
+end

data/spec/encryption_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Encryption do
+
+  it { should respond_to :key }
+  it { should respond_to :iv }
+  it { should respond_to :cipher }
+  it { should respond_to :encrypt }
+  it { should respond_to :decrypt }
+
+  random = Proc.new { Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join) }
+
+  it "should be configurable with a block" do
+    key = random.call
+    iv = random.call
+    cipher = OpenSSL::Cipher.ciphers[rand(OpenSSL::Cipher.ciphers.count - 1)]
+
+    Encryption.config do |config|
+      config.cipher = cipher
+      config.key = key
+      config.iv = iv
+    end
+
+    Encryption.key.should eq key
+    Encryption.iv.should eq iv
+    Encryption.cipher.should eq cipher
+  end
+
+  describe "should encrypt / decrypt at ease" do
+
+    before(:each) do
+      Encryption.key = random.call
+      Encryption.iv = random.call
+      @original = random.call
+    end
+
+    it "should generate encrypted values different than the original" do
+      encrypted = Encryption.encrypt(@original)
+      encrypted.should_not eq @original
+    end
+
+    it "should decrypt encrypted values so they match the original string" do
+      encrypted = Encryption.encrypt(@original)
+      decrypted = Encryption.decrypt(encrypted)
+      decrypted.should eq @original
+    end
+
+    it "should generate same encrypted values for equal strings" do
+      encrypted1 = Encryption.encrypt(@original)
+      encrypted2 = Encryption.encrypt(@original)
+      encrypted1.should eq encrypted2
+    end
+
+    it "should have the same encoding for original and decrypted string" do
+      encrypted = Encryption.encrypt(@original)
+      decrypted = Encryption.decrypt(encrypted)
+      decrypted.encoding.should eq @original.encoding
+    end
+
+  end
+end

data/spec/modules/configuration_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'openssl'
+
+describe Encryption::Configuration do
+
+  it { should respond_to :key }
+  it { should respond_to :iv }
+  it { should respond_to :cipher }
+  it { should respond_to :config }
+
+  random = Proc.new { Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join) }
+
+  it "should be configurable with a block" do
+    key = random.call
+    iv = random.call
+    cipher = random.call
+
+    @config = Encryption::Configuration.new
+    @config.config do |config|
+      config.cipher = cipher
+      config.key = key
+      config.iv = iv
+    end
+
+    @config.key.should eq key
+    @config.iv.should eq iv
+    @config.cipher.should eq cipher
+  end
+
+  before(:each) do
+    @config = Encryption::Configuration.new
+  end
+
+  it "should set and return key" do
+    random_value = random.call
+    @config.key = random_value
+    @config.key.should == random_value
+  end
+
+  it "should set and return iv" do
+    random_value = random.call
+    @config.iv = random_value
+    @config.iv.should == random_value
+  end
+
+  it "should set and return ciper" do
+    random_value = random.call
+    @config.cipher = random_value
+    @config.cipher.should == random_value
+  end
+  
+end

data/spec/modules/encryptor_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Encryption::Encryptor do
+
+  it { should respond_to :key }
+  it { should respond_to :iv }
+  it { should respond_to :cipher }
+  it { should respond_to :encrypt }
+  it { should respond_to :decrypt }
+  
+  random = Proc.new { Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join) }
+
+  it "should be configurable with a block" do
+    key = random.call
+    iv = random.call
+    cipher = random.call
+
+    @encryptor = Encryption::Encryptor.new
+    @encryptor.config do |config|
+      config.cipher = cipher
+      config.key = key
+      config.iv = iv
+    end
+
+    @encryptor.key.should eq key
+    @encryptor.iv.should eq iv
+    @encryptor.cipher.should eq cipher
+  end
+
+  describe "should encrypt / decrypt at ease" do
+
+    OpenSSL::Cipher.ciphers.each do |cipher|
+      before(:each) do
+        @encryptor = Encryption::Encryptor.new
+        @encryptor.cipher = cipher
+        @encryptor.key = random.call
+        @encryptor.iv = random.call
+        @original = random.call
+      end
+
+
+      it "should generate encrypted values different than the original" do
+        encrypted = @encryptor.encrypt(@original)
+        encrypted.should_not eq @original
+      end
+
+      it "should decrypt encrypted values so they match the original string" do
+        encrypted = @encryptor.encrypt(@original)
+        decrypted = @encryptor.decrypt(encrypted)
+        decrypted.should eq @original
+      end
+
+      it "should generate same encrypted values for equal strings" do
+        encrypted1 = @encryptor.encrypt(@original)
+        encrypted2 = @encryptor.encrypt(@original)
+        encrypted1.should eq encrypted2
+      end
+
+      it "should have the same encoding for original and decrypted string" do
+        encrypted = @encryptor.encrypt(@original)
+        decrypted = @encryptor.decrypt(encrypted)
+        decrypted.encoding.should eq @original.encoding
+      end
+    end
+
+  end
+end

data/spec/modules/string_helper_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe String do
+
+  it { should respond_to :encrypt }
+  it { should respond_to :encrypt! }
+  it { should respond_to :decrypt }
+  it { should respond_to :decrypt! }
+
+  before(:all) do
+    random = Proc.new { Digest::SHA256.hexdigest(([Time.now.to_s] * rand(3)).join) }
+
+    Encryption.config do |config|
+      config.key = random.call
+      config.iv = random.call
+    end
+
+    @random_string = random.call
+  end
+
+  it "should generate encrypted values different than the original" do
+      encrypted = @random_string.encrypt
+      encrypted.should_not eq @random_string
+    end
+
+  it "should decrypt encrypted values so they match the original string" do
+    encrypted = @random_string.encrypt
+    decrypted = encrypted.decrypt
+    decrypted.should eq @random_string
+  end
+
+  it "should generate same encrypted values for equal strings" do
+    encrypted1 = @random_string.encrypt
+    encrypted2 = @random_string.encrypt
+    encrypted1.should eq encrypted2
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'encryption'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: encryption
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Itay Grudev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-24 00:00:00.000000000 Z
+dependencies: []
+description: A simple wrapper for the OpenSSL Cipher library
+email:
+- itay.grudev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- encryption.gemspec
+- lib/encryption.rb
+- lib/encryption/configuration.rb
+- lib/encryption/encryptor.rb
+- lib/encryption/string_helper.rb
+- spec/encryption_spec.rb
+- spec/modules/configuration_spec.rb
+- spec/modules/encryptor_spec.rb
+- spec/modules/string_helper_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Itehnological/encryption
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A simple wrapper for the OpenSSL Cipher library
+test_files: []