cryptic 1.0.0.beta.6 → 1.0.0.beta.7

data/.gitignore

@@ -15,4 +15,3 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-cryptic_*.pem

data/README.md

@@ -11,7 +11,7 @@ Just run: `gem install cryptic` or add `gem 'cryptic'` to your Gemfile.
 ### Command line
 
 ```
-[ecarey @ cryptic]$ cryptic 
+[ecarey @ cryptic]$ cryptic
 Commands:
   cryptic decrypt [PRIVATE_KEY] [ENCRYPTED_FILE] [OPTIONS]  # Decrypt a file with a private key
   cryptic encrypt [PUBLIC_KEY] [TEXT_FILE] [OPTIONS]        # Encrypt a file with a public key
@@ -24,22 +24,22 @@ Commands:
 ```ruby
 require 'cryptic'
 
-# Generate a keypair to use with a passphrase and the number of bits you'd like:
-keypair = Cryptic::Keypair.new('P4$SpHr4z3', 2048)
-keypair.save("#{ENV['HOME']}/.cryptic_keys")
+# Load a keypair to use:
+keypair = Cryptic::Keypair.new('cryptic_private.pem', public_key: 'cryptic_public.pem')
 
+# Obtain your public/private keys from the `Cryptic::Keypair` object:
 private_key = keypair.private_key
 public_key = keypair.public_key
 
 # Encrypt a file:
 data = File.read('foo.txt')
-encrypted = Cryptic::EncryptedData.new(data, public_key)
+encrypted = Cryptic::EncryptedData.new(data, public_key, :base64)
 
-# Returns an encrypted string you can save off to a file
+# Returns an encrypted string you can save off to a file:
 encrypted.data
 
-# To return the data call decrypt on the encrypted data object w/ the private key and passphrase
-decrypted = encrypted.decrypt(private_key, 'P4$SpHr4z3')
+# To return the data call decrypt on the encrypted data object w/ the private key and passphrase:
+decrypted = encrypted.decrypt(private_key, 'P4$SpHr4z3', :base64)
 ```
 ## Contributing
 

data/bin/cryptic

@@ -5,6 +5,10 @@
 require 'cryptic'
 require 'thor'
 
+# TODO: Add support for localized descriptions
+# TODO: Add support for localized alias of commands in locales that share the
+# English alphabet?
+
 class CrypticCLI < Thor
   desc 'decrypt [PRIVATE_KEY] [ENCRYPTED_FILE] [OPTIONS]', 'Decrypt a file with a private key'
   method_option :passphrase, aliases: %w[-p], default: nil, desc: 'The passphrase to unlock the private key with'
@@ -53,7 +57,7 @@ class CrypticCLI < Thor
     end
   end
 
-  desc 'generate [OPTIONS]', 'Generate a private/public keypair', aliases: %w[gen key-gen]
+  desc 'generate [OPTIONS]', 'Generate a private/public keypair'
   method_option :bits, aliases: %w[-b size], default: 2048, desc: 'The number of bits to use when generating your key'
   method_option :passphrase, aliases: %w[-p], default: nil, desc: 'The passphrase to generate the private key with'
   method_option :path, aliases: %w[-o], default: '.', desc: 'Where to place the generated keys'

data/cryptic_private.pem

@@ -0,0 +1,30 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-256-CBC,7982FC649F5EDF03FA207CADC0B871BA
+
+3MXSorbMApz+QvQOB/yBrsBMdOk6sNZCmxdAVO+LAXsgifLJJuRnaJlFb7pqTSsI
+bXSmDuhleIEoTMCVnThnLsWV16Aw/rYPv2hB1g8PUsiJlMMjaDep2tCgPb1RE0pH
+Soq3vh5sX49TsSXPf1WTUnYnUnbdxyVaBsKaGfvxrI7Dq6RI5D6DPr7ZmP0XJkFb
+xiILWriqbnTrf3gbnAEZsz+msledZ9zT1bEJJLOoGOzF2UhrHZnestDakl2mK+RS
+qHutCCEMp0ei/p+mp/5COGKWgXsvnmIK7+KyaWq6G0k+iI/WfzGjt4qDRsa81duA
+/f9i86aONqullGOannQr/YzTuFoURKbmG6aRJ/EDmXsEFmlritSuJRh8c956l8U5
+wAYuo+fRWP2nOkEAL3z8xvDaGCX33jyGcRn8krH2xQSAgElItSmxpLVqEFfvlOUn
+5Hxw7g8z0OS+XnkiwhGMg1yrFp/e5RewAQwbyUFHf0XN9U06iVooSlPOgOptZFLK
+HaRmm9rjhZbrxQf1Yb1O8B2gfu05VmKLI8sNPz/3sSYaNVTAil4f4JZ1vclac+Gr
+drtD6z1llUbRK1svX7IjFvOUJZ92oblYBnSzyGsV0QzQiyu2rKyKa67/aR8Syaou
+PfHGS+VoibquyYQL+YCASf7x9UZIV0X4CCj2JpE1iV0YknDcYT+MxCWA12itdmw+
+6D9fYRuroE3YX4g/md3XUnklFb/XnUHr40HxuKo3wHa6xoTvCCwooi3HmlCUsKIl
+b57TlfejlbfVFYNEIDjz1rCv2FZjgB6cITNaIeoHKxGzjPtql/llnKNnjW+8z1Hj
+udSTehbB7SBiZKS5rj0WHKwMmvrkzagnhSxxS4sGHH17rsxSj3YeXG2ABKhz1ark
+KYvM3pRVMK1LMeM8VtVbaJKtqr2bo2/FSPtxkzHqGQ9domkWuaczFiQ+Fk7/SAlF
+wxaLs1KlnGA5RVfuOysDr+EbqbDvoABLOx0Ec0Wv5OkUmHtn7zvAxY+brQLOld8l
+9LeXwmQS4ELAdS9uuhpWlZ9Qa8/fimbBcYWU/EVlBEw65avtZ/O9T1n2LKnd9WSZ
+fVioG86EE1MXqEX9KOWRu2VKMoemjwq5AJBENyHyofPQN13UH4uHiYHe+DghrAw4
+WYX7cgKHh1fuRHrdqwTfScUNMWQWamQj4I5Uny1aWtGhPrPyoW2lfMIe/CzF2O0O
+BxF0HgaZOpUgCZ2HQi+dKnb2NUhRa5wQZS3hHi6ZWwQgWyX+fQmlHvPnWqD5ZKbl
+rKnZiUX9AVWNsIri/Xfe4p+3sT4Bq0wGrQc22jjWbeSvbRkOxGt7iXbrUwQhGq/V
++MOIDiXBlQZBVan98cKQYYZCILLKsMnP0QUHyGOU2r6oI+bi31dpTE5/nYA8MULS
+sGN33v8v3OQtTA0LAOb3VTl9FYshpfuYkR1SYYM5ft2rhleybWRguF3eduxO0GmB
+WJ5xYWbU7FAoYIox2mg8zehL8n71aiH8LOPPkAzhn+NNP67GdVgvIeRgxPB4fdw1
+sVlcWO7yFTz1PO8XS21RJntidcEUzndjlC4OPksjWUobz08m8ZpPyHLh+8xDJxlp
+-----END RSA PRIVATE KEY-----

data/cryptic_public.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzOWt9cgkhxkdGs8SFlgZ
+BXCETwddfTg0zez/IeFiCAe8gcKQBDHa62jMbkwAg/tNAherRXqguWF9ZLm4ZTf3
+fxRHafj0KA83KLdLWcxaU1TsN/c2/DcDcsSwdgMKGz4YQR64RC6c98s/c0HZQzPj
+vEQPA/fU0LoFmGynZ9/pdEXQe6N3kzbpG8//64RxgFPco7g7HbZIVaRqyx3U4UgQ
+FKb+HoYDs5U+P6qz6TU4YFZbqglunptxKIjUZG7lywGPtDhD9gQf2n5n+wId4MgD
+xKwrj+ZQF220Mmq96LSm1a3BtiRhZInKLPn9Yr7JFh7CgVmqn2/50UVAbbdKKO4x
+TwIDAQAB
+-----END PUBLIC KEY-----

data/lib/cryptic/encrypted_data.rb

@@ -46,6 +46,7 @@ module Cryptic
     # Creates a new encrypted data object from an encrypted data string
     #
     # @param [String] data the encrypted data to load
+    # @param [Symbol] encoding the encoding to use
     # @return [EncryptedData] an encrypted data object
     def self.load(data, encoding = :none)
       new(data, nil, encoding)

data/lib/cryptic/exceptions/incorrect_passphrase.rb

@@ -0,0 +1,9 @@
+module Cryptic
+  module Exceptions
+    # A exception to throw if the the passphrase for a private key was entered
+    # incorrectly
+    #
+    # @author Erran Carey <me@errancarey.com>
+    class IncorrectPassphrase < ArgumentError; end
+  end
+end

data/lib/cryptic/exceptions/invalid_key.rb

@@ -0,0 +1,8 @@
+module Cryptic
+  module Exceptions
+    # A exception to throw if an invalid key was provided
+    #
+    # @author Erran Carey <me@errancarey.com>
+    class InvalidKey < ArgumentError; end
+  end
+end

data/lib/cryptic/exceptions.rb

@@ -2,6 +2,8 @@ require 'colorize'
 require 'cryptic/exceptions/decryption_error'
 require 'cryptic/exceptions/encryption_error'
 require 'cryptic/exceptions/invalid_data'
+require 'cryptic/exceptions/invalid_key'
+require 'cryptic/exceptions/incorrect_passphrase'
 require 'cryptic/exceptions/key_generation_failure'
 require 'cryptic/exceptions/key_mismatch'
 require 'cryptic/exceptions/key_not_found'

data/lib/cryptic/keypair.rb

@@ -8,27 +8,81 @@ module Cryptic
 
   # A class that represents a private and public keypair
   #
-  # @!attribute [String] private_key the contents of the private key file
-  # @!attribute [String] public_key the contents of the public key file
   # @author Erran Carey <me@errancarey.com>
   class Keypair
-    attr_reader :private_key
-    attr_reader :public_key
+    attr_accessor :private_key
+    attr_accessor :public_key
+
+    # Initializes a Cryptic::Keypair object from a private/public keypair
+    #
+    # @note The passphrase isn't saved
+    # @todo Use the Ruby 2 named parameters syntax vs. an opts hash
+    # @todo Validate that keys are public/private
+    # @param [String] private_key the private key (or file) to use
+    # @param [Hash] opts additional options to configure your Keypair with
+    # @option opts [String] public_key the public key (or file) to use
+    # @option opts [String] passphrase the passphrase to determine the public key
+    #   from
+    # @return [Keypair] the initialized Cryptic::Keypair object
+    def initialize(private_key, opts = { public_key: nil, passphrase: nil })
+      @private_key = OpenSSL::PKey::RSA.new(
+                       if File.exists?(private_key)
+                         File.read(private_key)
+                       else
+                         private_key
+                       end,
+                       opts[:passphrase]
+                     )
+
+      unless @private_key.private?
+        raise(
+          Cryptic::InvalidKey,
+          "Public key '#{private_key}' provided as a private key."
+        )
+      end
+
+      @public_key = OpenSSL::PKey::RSA.new(
+                      if opts[:public_key] && File.exists?(opts[:public_key])
+                        File.read(opts[:public_key])
+                      elsif opts[:public_key]
+                        opts[:public_key]
+                      else
+                        @private_key
+                      end,
+                      opts[:passphrase]
+                    ).public_key
+    rescue OpenSSL::PKey::RSAError => e
+      if e.message.eql? 'Neither PUB key nor PRIV key:: not enough data'
+        if @private_key.nil?
+          raise Cryptic::InvalidKey, "Invalid private key: #{private_key}"
+        elsif @public_key.nil?
+          raise Cryptic::InvalidKey, "Invalid public key: #{public_key}"
+        end
+      elsif e.message.eql? 'Neither PUB key nor PRIV key:: nested asn1 error'
+        raise Cryptic::IncorrectPassphrase, "Unable to open private key:
+        '#{private_key}'. was the passphrase valid?"
+      else
+        raise e
+      end
+    end
+
     # Creates a keypair to be saved with #save
     #
+    # @note The passphrase isn't saved
+    # @param [String] passphrase the passphrase to give the private key
     # @param [Fixnum] size the amount of bits to use in your key
     # @return [Keypair] an object representing a private/public keypair
-    def initialize(passphrase = nil, size = 2048)
-      @saved = false
-
+    def self.generate(passphrase = nil, size = 2048)
+      # OPTIMIZE: There are so many hammers in here it looks like we're playing
+      # Whack-a-mole
+      # TODO: Find a better way to handle retries
       attempts ||= 0
       attempts += 1
 
       rsa_key = OpenSSL::PKey::RSA.new(size)
-      cipher = OpenSSL::Cipher::AES256.new(:CBC)
+      cipher ||= OpenSSL::Cipher::AES256.new(:CBC)
 
-      @private_key = rsa_key.to_pem(cipher, passphrase)
-      @public_key = rsa_key.public_key.to_pem
+      new(rsa_key.to_pem(cipher, passphrase), rsa_key.public_key.to_pem)
     rescue OpenSSL::PKey::RSAError => e
       if e.message =~ /^read key$/
         retry unless attempts > 1
@@ -41,9 +95,10 @@ module Cryptic
     #
     # @param [String] path the path to save the keypair into
     # @todo Document what save may raise
+    # @todo Update this method
     # @return [String] returns the path files were saved to
     def save(path = '.')
-      if @private_key.to_s.eql?('') || @public_key.to_s.eql?('')
+      if @private_key.to_pem.eql?('') || @public_key.to_pem.eql?('')
         raise Cryptic::KeyGenerationFailure, "The keypair was never successfully generated"
       end
 
@@ -57,7 +112,6 @@ module Cryptic
         file.write @public_key
       end
 
-      @saved = true
       path
     end
   end

data/lib/cryptic/version.rb

@@ -1,4 +1,4 @@
 module Cryptic
   # The version of the cryptic gem
-  VERSION = '1.0.0.beta.6'
+  VERSION = '1.0.0.beta.7'
 end

data/locales/files/README.en.md

@@ -0,0 +1,50 @@
+# Cryptic [![Build Status](https://secure.travis-ci.org/ipwnstuff/cryptic.png)](http://travis-ci.org/ipwnstuff/cryptic) [![Dependency Status](https://gemnasium.com/ipwnstuff/cryptic.png)](https://gemnasium.com/ipwnstuff/cryptic)
+A Ruby gem for public key encryption, private key decryption, and generating key pairs.
+
+## Documentation
+http://www.rubydoc.info/github/ipwnstuff/cryptic
+
+## Installation
+Just run: `gem install cryptic` or add `gem 'cryptic'` to your Gemfile.
+
+## Usage
+### Command line
+
+```
+[ecarey @ cryptic]$ cryptic
+Commands:
+  cryptic decrypt [PRIVATE_KEY] [ENCRYPTED_FILE] [OPTIONS]  # Decrypt a file with a private key
+  cryptic encrypt [PUBLIC_KEY] [TEXT_FILE] [OPTIONS]        # Encrypt a file with a public key
+  cryptic generate [OPTIONS]                                # Generate a private/public keypair
+  cryptic help [COMMAND]                                    # Describe available commands or one specific command
+```
+
+### Ruby
+
+```ruby
+require 'cryptic'
+
+# Load a keypair to use:
+keypair = Cryptic::Keypair.new('cryptic_private.pem', public_key: 'cryptic_public.pem')
+
+# Obtain your public/private keys from the `Cryptic::Keypair` object:
+private_key = keypair.private_key
+public_key = keypair.public_key
+
+# Encrypt a file:
+data = File.read('foo.txt')
+encrypted = Cryptic::EncryptedData.new(data, public_key, :base64)
+
+# Returns an encrypted string you can save off to a file:
+encrypted.data
+
+# To return the data call decrypt on the encrypted data object w/ the private key and passphrase:
+decrypted = encrypted.decrypt(private_key, 'P4$SpHr4z3', :base64)
+```
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b feature/my-awesome-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin feature/my-awesome-feature`)
+5. Create new Pull Request

data/locales/files/README.es.md

@@ -0,0 +1,52 @@
+# Cryptic [![Estado de Creación](https://secure.travis-ci.org/ipwnstuff/cryptic.png)](http://travis-ci.org/ipwnstuff/cryptic) [![Estado de Dependencia](https://gemnasium.com/ipwnstuff/cryptic.png)](https://gemnasium.com/ipwnstuff/cryptic)
+Una Ruby gem para cifrar datos con su clave pública, descifrarlos con su clave privada, y generar nuevas claves.
+
+## Documentación
+Ahorita no hay ninguna documentación española.
+En Inglès: http://www.rubydoc.info/github/ipwnstuff/cryptic
+
+## Instalación
+Sólo corra `gem install cryptic` o añada `gem 'cryptic'` a su `Gemfile`.
+También se puede descargar desde el código fuente.
+
+## Uso
+### Línea de Comandos
+
+```
+[ecarey @ cryptic]$ cryptic
+Commands:
+  cryptic decrypt [CLAVE_PRIVADA] [FICHERO_CIFRADO] [OPCIONES]  # Descifrar una fichero con una clave privada
+  cryptic encrypt [CLAVE_PUBLICO] [FICHERO_TEXTO] [OPTIONS]     # Cifrar una fichero con una clave pública
+  cryptic generate [OPTIONS]                                    # Generar nuevas claves
+  cryptic help [COMMAND]                                        # Describe available commands or one specific command
+```
+
+### Ruby
+
+```ruby
+require 'cryptic'
+
+# Para cargar las claves existantes:
+claves = Cryptic::Keypair.new('cryptic_private.pem', public_key: 'cryptic_public.pem')
+
+# Obtener las claves desde el objeto `Cryptic::Keypair`:
+clave_privada = claves.private_key
+clave_publica = claves.public_key
+
+# Cifrar un fichero:
+datos = File.read('foo.txt')
+cifrado = Cryptic::EncryptedData.new(datos, clave_publica, :base64)
+
+# Retornar los datos cifrados:
+cifrado.data
+
+# Descifrarlos con su clave privada y su contraseña:
+descifrado = cifrado.decrypt(clave_privada, 'P4$SpHr4z3', :base64)
+```
+
+## Contribuyendo
+1. Bifurcarlo
+2. Crear un rama de la característica en Inglés (`git checkout -b feature/my-awesome-feature`)
+3. Comfirmar su cambios con un mensaje Inglés (`git commit -am 'Add some feature'`)
+4. Empujar a su rama (`git push origin feature/my-awesome-feature`)
+5. Crear un nuevo Pull Request

data/spec/keypair_spec.rb

@@ -0,0 +1,79 @@
+require 'cryptic/keypair'
+
+describe Cryptic::Keypair do
+  let :private_keys do
+    keys = [
+      './cryptic_private.pem',
+      File.read('./cryptic_private.pem')
+    ]
+
+    # Repeat the keys for zipping
+    keys *= 2
+  end
+
+  let :public_keys do
+    keys = [
+      './cryptic_public.pem',
+      File.read('./cryptic_public.pem')
+    ]
+
+    # Repeat the keys in opposing order for zipping
+    keys += keys.reverse
+  end
+
+  it 'should be able to create a keypair from a private key' do
+    private_keys.uniq.each do |private_key|
+      expect {
+        Cryptic::Keypair.new(
+          private_key,
+          passphrase: 'P4$SpHr4z3'
+        )
+      }.to_not raise_error
+    end
+  end
+
+  it 'should be able to create a keypair from a private key and a public key' do
+    private_keys.zip(public_keys).each do |private_key, public_key|
+      expect {
+        Cryptic::Keypair.new(
+          private_key,
+          passphrase: 'P4$SpHr4z3',
+          public_key: public_key
+        )
+      }.to_not raise_error
+    end
+  end
+
+  # TODO: Add custom error classes below once implemented
+
+  it 'should not be able to create a keypair with an empty private key' do
+    expect { Cryptic::Keypair.new('') }.to raise_error
+    expect { Cryptic::Keypair.new(nil) }.to raise_error
+  end
+
+  it 'should not be able to create a keypair with an invalid private key' do
+    public_keys.uniq.each do |public_key|
+      expect {
+        Cryptic::Keypair.new(
+          public_key,
+          passphrase: 'P4$SpHr4z3'
+        )
+      }.to raise_error
+
+      expect { Cryptic::Keypair.new(public_key) }.to raise_error
+    end
+
+    expect { Cryptic::Keypair.new('invalid') }.to raise_error
+  end
+
+  it 'should not be able to create a keypair with an invalid passphrase' do
+    private_keys.uniq.each do |private_key|
+      expect {
+        Cryptic::Keypair.new(
+          private_key,
+          passphrase: 'BadPassphrase'
+        )
+      }.to raise_error
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cryptic
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.6
+  version: 1.0.0.beta.7
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-06 00:00:00.000000000 Z
+date: 2013-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -139,19 +139,25 @@ files:
 - Thorfile
 - bin/cryptic
 - cryptic.gemspec
+- cryptic_private.pem
+- cryptic_public.pem
 - lib/cryptic.rb
 - lib/cryptic/encrypted_data.rb
 - lib/cryptic/exceptions.rb
 - lib/cryptic/exceptions/decryption_error.rb
 - lib/cryptic/exceptions/encryption_error.rb
+- lib/cryptic/exceptions/incorrect_passphrase.rb
 - lib/cryptic/exceptions/invalid_data.rb
+- lib/cryptic/exceptions/invalid_key.rb
 - lib/cryptic/exceptions/key_generation_failure.rb
 - lib/cryptic/exceptions/key_mismatch.rb
 - lib/cryptic/exceptions/key_not_found.rb
 - lib/cryptic/exceptions/unsupported_encoding.rb
 - lib/cryptic/keypair.rb
 - lib/cryptic/version.rb
-- spec/default_spec.rb
+- locales/files/README.en.md
+- locales/files/README.es.md
+- spec/keypair_spec.rb
 homepage: https://github.com/ipwnstuff/cryptic
 licenses:
 - MIT
@@ -167,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2304157530869896599
+      hash: -1776955629962300703
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -182,5 +188,5 @@ specification_version: 3
 summary: A quick way to encrypt data using public keys. Only people with the private
   key can decrypt said data.
 test_files:
-- spec/default_spec.rb
+- spec/keypair_spec.rb
 has_rdoc: 

data/spec/default_spec.rb

@@ -1 +0,0 @@
-# TODO: Implement tests