akero 1.0.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.swp
+.rbenv-version
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in smime.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,18 @@
+my_code = <<'RUBY_CODE'
+  if type == 'failed'
+    system "ssh 192.168.1.106 '~/bin/keyboard_leds -c1 >/dev/null'"
+    system "ssh 192.168.1.106 'afplay ~/.fail.wav'"
+  end
+  if type == 'success'
+    system "ssh 192.168.1.106 '~/bin/keyboard_leds -c0 >/dev/null'"
+    system "ssh 192.168.1.106 'afplay ~/.success.wav'"
+  end
+RUBY_CODE
+
+notification :eval_notifier, :code => my_code
+
+guard 'rspec', :cli => '--color --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 moe@busyloop.net
+
+MIT License
+
+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,98 @@
+# Akero [![Build Status](https://travis-ci.org/busyloop/akero.png?branch=master)](https://travis-ci.org/busyloop/akero) [![Dependency Status](https://gemnasium.com/busyloop/akero.png)](https://gemnasium.com/busyloop/akero)
+
+Akero ([ἄγγελος](http://en.wiktionary.org/wiki/%F0%90%80%80%F0%90%80%90%F0%90%80%AB), messenger) is an easy-to-use library for peer-to-peer [public key cryptography](http://en.wikipedia.org/wiki/Public-key_cryptography). It enables two or more endpoints to exchange encrypted and/or signed messages without requiring a pre-shared secret.
+
+Under the hood Akero uses standard OpenSSL primitives. Each instance wraps a [RSA](http://en.wikipedia.org/wiki/RSA)-keypair, a corresponding [X.509 certificate](http://en.wikipedia.org/wiki/X.509) and exchanges self-signed messages ([PKCS#7](https://tools.ietf.org/html/rfc2315)) with other instances.
+
+Akero does not try to be a substitute for a fully featured [PKI](http://en.wikipedia.org/wiki/Public_key_infrastructure). It is meant to be used as a building block in scenarios where trust-relationships and keyrings can be externally managed, and where the complexity of traditional solutions (X.509 PKI, OpenPGP, homegrown RSA) yields no tangible benefits.
+
+## Features
+
+* Secure 1-to-n messaging (sign-only -or- sign->encrypt->sign)
+* Low complexity; easy to use, understand and review (only 166 lines of code)
+* Transport agnostic; messages and certificates are self-contained, ascii-armored (base64)
+* Built on standard OpenSSL primitives, no homegrown algorithms
+* [100%](https://busyloop.net/oss/akero/coverage/) test coverage
+
+
+## Usage
+
+```ruby
+# Alice, Bob and Charlie are Akero instances
+alice = Akero.new
+bob = Akero.new
+charlie = Akero.new
+
+# Inspect Alice's keypair fingerprint
+alice.id # => "AK:12:34:56:..."
+
+# Alice signs a message
+signed_msg = alice.sign("Hello world!")
+
+# Anyone can receive this message and extract
+# Alice's fingerprint and public key from it
+msg = bob.receive(signed_msg)
+msg.body # => "Hello world!"
+msg.from # => "AK:12:34:56:..."
+msg.from_pk # => "(alice-public-key)"
+
+# Bob encrypts a message for Alice
+bobs_msg = bob.encrypt(msg.from_pk, "Hello Alice!")
+ 
+# Alice can receive it...
+msg = alice.receive(bobs_msg)
+msg.body # => "Hello Alice!"
+msg.from # => "AK:ab:cd:ef:..."
+msg.from_pk # => "(bob-public-key)"
+
+# ...and Charlie can't
+msg = charlie.receive(bobs_msg) # => Exception is raised
+
+# Alice encrypts a message for Bob and Charlie
+msg = alice.encrypt([bob.public_key, charlie.public_key], "Hello!")
+
+# Save Alice to a file
+File.open('/tmp/alice.akr', 'w') { |f| f.write(alice.private_key) }
+
+# And load her again
+new_alice = Akero.load(File.read('/tmp/alice.akr'))
+
+```
+
+## Documentation
+
+* [API Docs](http://rubydoc.info/gems/akero/Akero)
+* [Spec](https://github.com/busyloop/akero/blob/master/spec/akero_spec.rb)
+
+
+## Benchmarks
+
+![Throughput](http://github.com/busyloop/akero/raw/master/benchmark/bm_rate.png)
+![Message size](http://github.com/busyloop/akero/raw/master/benchmark/bm_size.png)
+
+The above charts were generated on an [AMD Turion II Neo N40L CPU](http://www.cpubenchmark.net/cpu.php?cpu=AMD+Turion+II+Neo+N40L+Dual-Core).
+You may run the benchmarks on your own machine with `rake benchmark`.
+
+## License (MIT)
+
+Copyright (c) 2012 moe@busyloop.net
+
+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/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+task :default => :test
+
+RSpec::Core::RakeTask.new("test:spec") do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+    t.rspec_opts = '--fail-fast -b -c -f documentation --tag ~benchmark'
+end
+
+desc 'Run test suite'
+task :test => [ 'test:spec' ]
+
+desc "Run benchmark suite"
+task :benchmark do
+  require 'akero/benchmark'
+  Akero::Benchmark.run!
+end
+
+namespace :docs do
+  task :push do
+    `bl_www_sync akero coverage`
+  end
+end

data/akero.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'akero/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "akero"
+  gem.version       = Akero::VERSION
+  gem.authors       = ["Moe"]
+  gem.email         = ["moe@busyloop.net"]
+  gem.description   = %q{Easy peer-to-peer public key cryptography}
+  gem.summary       = %q{Easy peer-to-peer public key cryptography}
+  gem.homepage      = "https://github.com/busyloop/akero"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rb-inotify'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'b'
+  gem.add_development_dependency 'gnuplot'
+  gem.add_development_dependency 'yard'
+end

data/lib/akero.rb

@@ -0,0 +1,361 @@
+# Copyright (c) 2012 moe@busyloop.net
+# 
+# MIT License
+# 
+# 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.
+
+require "akero/version"
+
+require 'openssl'
+require 'base64'
+
+# Akero is an easy-to-use library for peer-to-peer public key cryptography.
+class Akero
+  # Akero::Message wraps a received message.
+  class Message
+    # @return [String] Message body
+    attr_reader :body
+    # @return [Symbol] Message type (:signed or :encrypted)
+    attr_reader :type
+
+    # @private
+    def initialize(body, signer_cert, type)
+      @body, @signer_cert, @type = body, signer_cert, type
+    end
+
+    # @private
+    def inspect
+      "#<Akero::Message @type=#{@type} @from=#{from} @body=(#{@body.length} bytes)>"
+    end
+
+    # @!attribute [r] from
+    # @return [String] Sender Fingerprint
+    def from
+      Akero.fingerprint_from_cert(@signer_cert)
+    end
+
+    # @!attribute [r] from_pk
+    # @return [String] Sender public key
+    def from_pk
+      Akero.replate(@signer_cert.to_s, PLATE_CERT)
+    end
+  end
+end
+
+class Akero
+  ERR_MSG_MALFORMED_ENV = "Malformed message: Could not parse envelope" # @private
+  ERR_MSG_MALFORMED_BODY = "Malformed message: Could not parse body; POSSIBLE SPOOF ATTEMPT" # @private
+  ERR_PKEY_CORRUPT = "Invalid private key (checksum mismatch)" # @private
+  ERR_CERT_CORRUPT = "Invalid certificate" # @private
+  ERR_INVALID_RECIPIENT = "Invalid recipient (must be a String)" # @private
+  ERR_INVALID_RECIPIENT_CERT = "Invalid recipient (corrupt public key?)" # @private
+  ERR_DECRYPT = "Could not decrypt message" # @private
+  ERR_MSG_NOT_STRING_NOR_PKCS7 = "Message must be of type String or OpenSSL::PKCS7" # @private
+  ERR_MSG_CORRUPT_CERT = "Malformed message: Embedded certificate could not be verified; POSSIBLE SPOOF ATTEMPT!" # @private
+  ERR_MSG_TOO_MANY_SIGNERS = "Corrupt message: Zero or multiple signers, expected exactly 1; POSSIBLE SPOOF ATTEMPT" # @private
+  ERR_MSG_SIG_MISMATCH = "Inner signature does not match outer signature; POSSIBLE SPOOF ATTEMPT" # @private
+
+  PKEY_HEADER = "-----BEGIN AKERO PRIVATE KEY-----\n" # @private
+  PKEY_FOOTER = "-----END AKERO PRIVATE KEY-----\n" # @private
+  PLATE_CERT = ['CERTIFICATE','AKERO PUBLIC KEY'] # @private
+  PLATE_SIGNED = ['PKCS7', 'AKERO SIGNED MESSAGE'] # @private
+  PLATE_CRYPTED = ['PKCS7', 'AKERO SECRET MESSAGE'] # @private
+
+  DEFAULT_RSA_BITS = 2048
+
+  # Unique fingerprint of this Akero keypair.
+  #
+  # @return [String] Akero fingerprint
+  def id
+    Akero.fingerprint_from_cert(@cert)
+  end
+
+  # Create a new Akero instance.
+  #
+  # @example Create new Akero instance with default settings
+  #   Akero.new
+  #
+  # @example Create new Akero instance with a 4096-bit key
+  #   Akero.new(4096)
+  #
+  # @example Create new Akero instance with a 4096-bit key and SHA512 digest
+  #   Akero.new(4096, OpenSSL::Digest::SHA512)
+  #
+  # @param [Integer] rsa_bits RSA key length
+  # @param [OpenSSL::Digest] sign_digest Signature digest
+  # @return [Akero] New Akero instance
+  def initialize(rsa_bits=DEFAULT_RSA_BITS, sign_digest=OpenSSL::Digest::SHA512)
+    @key, @cert = generate_keypair(rsa_bits, sign_digest) unless rsa_bits.nil?
+  end
+
+  # Load an Akero identity.
+  # 
+  # @example Load previously stored private key
+  #   Akero.load(File.read('/tmp/alice.akr'))
+  #
+  # @param [String] private_key Akero private key
+  # @return [Akero] New Akero instance
+  def self.load(private_key)
+    inner = Base64.decode64(private_key[PKEY_HEADER.length..private_key.length-PKEY_FOOTER.length])
+    if inner[0..63] != OpenSSL::Digest::SHA512.new(inner[64..-1]).digest
+      raise RuntimeError, ERR_PKEY_CORRUPT
+    end
+    cert_len = inner[64..65].unpack('S')[0]
+    akero = Akero.new(nil)
+    akero.instance_variable_set(:@cert, OpenSSL::X509::Certificate.new(inner[66..66+cert_len]))
+    akero.instance_variable_set(:@key, OpenSSL::PKey::RSA.new(inner[66+cert_len..-1]))
+    akero
+  end
+
+  # Akero public key.
+  #
+  # Share this with other Akero instances that you
+  # wish to receive encrypted messages from.
+  #
+  # @return [String] Public key (ascii armored)
+  def public_key
+    Akero::replate(@cert.to_s, Akero::PLATE_CERT)
+  end
+
+  # Private key (do not share this with anyone!)
+  # 
+  # @example Save and load an Akero identity
+  #   alice = Akero.new
+  #   # Save
+  #   File.open('/tmp/alice.akr', 'w') { |f| f.write(alice.private_key) }
+  #   # Load
+  #   new_alice = Akero.load(File.read('/tmp/alice.akr'))
+  # 
+  # @return [String] Private key (ascii armored)
+  # @see Akero#load
+  def private_key
+    # We do not use PKCS#12 ("PFX") for serialization here
+    # because of http://www.cs.auckland.ac.nz/~pgut001/pubs/pfx.html
+    cert_der = @cert.to_der
+    out = [cert_der.length].pack('S')
+    out << cert_der
+    out << @key.to_der
+    out.prepend(OpenSSL::Digest::SHA512.new(out).digest)
+    PKEY_HEADER+Base64.encode64(out)+PKEY_FOOTER
+  end
+
+  # Sign a message.
+  #
+  # @param [String] plaintext The message to sign (binary safe)
+  # @return [String] Akero signed message
+  def sign(plaintext)
+    Akero.replate(_sign(plaintext).to_s, Akero::PLATE_SIGNED)
+  end
+
+  # Sign->encrypt->sign a message for 1 or more recipients.
+  #
+  # Only the listed recipients can decrypt the message-body
+  # but anyone can extract the sender's public key.
+  #
+  # @example Alice encrypts a message to Bob
+  #   alice = Akero.new
+  #   bob = Akero.new
+  #   ciphertext = alice.encrypt(bob.public_key, "Hello Bob!")
+  #
+  # @example Alice encrypts a message to Bob and Charlie
+  #   alice = Akero.new
+  #   bob = Akero.new
+  #   charlie = Akero.new
+  #   ciphertext = alice.encrypt([bob.public_key, charlie.public_key], "Hello Bob and Charlie!")
+  #
+  # @param [Array] to Akero public keys of recipients
+  # @param [String] plaintext The message to encrypt (binary safe)
+  # @return [String] Akero secret message
+  def encrypt(to, plaintext)
+    to = [to] unless to.is_a? Array
+    to = to.map { |e| 
+      case e
+        when String
+          begin
+            OpenSSL::X509::Certificate.new(Akero.replate(e, Akero::PLATE_CERT, true))
+          rescue OpenSSL::X509::CertificateError
+            raise RuntimeError, ERR_INVALID_RECIPIENT_CERT
+          end
+        else
+          raise RuntimeError, ERR_INVALID_RECIPIENT
+      end
+    }
+    Akero.replate(_sign(_encrypt(to, _sign(plaintext))).to_s, PLATE_CRYPTED)
+  end
+
+  # Receive an Akero message.
+  #
+  # @param [String] ciphertext Akero Message
+  # @return [Akero::Message] Message_body, signer_certificate, body_type
+  def receive(ciphertext)
+    ciphertext = Akero.replate(ciphertext, Akero::PLATE_CRYPTED, true)
+    begin
+      body, outer_signer_cert, body_type = verify(ciphertext)
+    rescue ArgumentError
+      raise RuntimeError, ERR_MSG_MALFORMED_ENV
+    end
+
+    case body_type.ord
+      when 0x00
+        # public message (signed)
+        return Message.new(body, outer_signer_cert, :signed)
+      when 0x01
+        # private message (signed, crypted, signed)
+        signed_plaintext = _decrypt(body)
+        plaintext, inner_signer_cert, body_type = verify(signed_plaintext)
+        msg = Message.new(plaintext, inner_signer_cert, :encrypted)
+
+        if msg.from != Akero.fingerprint_from_cert(outer_signer_cert)
+          raise RuntimeError, ERR_MSG_SIG_MISMATCH
+        end
+        return msg
+    end
+    raise RuntimeError, ERR_MSG_MALFORMED_BODY
+  end
+
+  # @private
+  def inspect
+    "#<Akero id=#{id}>"
+  end
+
+  # @private
+  def to_s
+    inspect
+  end
+ 
+  #---------------------------------------------------------------------------
+  protected
+
+  # Swap the "license plates" on an ascii-armored message.
+  # This is done for user-friendliness, so stored Akero
+  # messages and keys can be easily identified at a glance.
+  #
+  # @param [String] msg Message to be replated
+  # @param [Array] plates Array of the two plates to swap
+  # @param [Boolean] reverse Reverse the swap?
+  # @return [String] The replated message
+  def self.replate(msg, plates, reverse=false)
+    a,b = reverse ? [1,0] : [0,1]
+    "-----BEGIN #{plates[b]}-----#{msg.strip[plates[a].length+16..-(plates[a].length+15)]}-----END #{plates[b]}-----\n"
+  end
+
+  # Extract fingerprint from an Akero public key.
+  #
+  # @return [String] Akero fingerprint
+  def self.fingerprint_from_cert(cert)
+    cert.extensions.map.each do |e|
+      return "AK:#{e.value}" if e.oid == 'subjectKeyIdentifier'
+    end
+    raise RuntimeError, ERR_CERT_CORRUPT
+  end
+ 
+  #---------------------------------------------------------------------------
+  private 
+
+  def _decrypt(crypted_msg)
+    begin
+      OpenSSL::PKCS7.new(crypted_msg).decrypt(@key, @cert)
+    rescue OpenSSL::PKCS7::PKCS7Error, "decrypt error"
+      raise RuntimeError, ERR_DECRYPT
+    end
+  end
+
+  # Encrypt a message for one ore more recipients.
+  #
+  # @return [Array] Message_body, signer_certificate, body_type
+  def _encrypt(to, msg, cipher=nil)
+    cipher ||= OpenSSL::Cipher::new("AES-256-CFB")
+    OpenSSL::PKCS7::encrypt(to, msg.to_der, cipher, OpenSSL::PKCS7::BINARY)
+  end
+
+  # Sign a message.
+  #
+  # @overload _sign(message)
+  #   Sign a message.
+  #   @param [String] message Message
+  #   @return [OpenSSL::PKCS7] Signed message
+  # @overload _sign(message)
+  #   Sign a message.
+  #   @param [OpenSSL::PKCS7] message Message
+  #   @return [OpenSSL::PKCS7] Signed message
+  def _sign(message)
+    case message
+      when String
+        type = 0x00
+      when OpenSSL::PKCS7
+        type = 0x01
+      else
+        raise RuntimeError, ERR_MSG_NOT_STRING_NOR_PKCS7
+    end
+    message = message.to_der if message.is_a? OpenSSL::PKCS7
+    OpenSSL::PKCS7::sign(@cert, @key, type.chr + message, [], OpenSSL::PKCS7::BINARY)
+  end
+
+  # Verify a signed message against its embedded certificate.
+  #
+  # @return [Array] message_body, signer_certificate, body_type
+  def verify(signed_msg)
+    signed_msg = OpenSSL::PKCS7.new(signed_msg) if signed_msg.is_a? String
+    store = OpenSSL::X509::Store.new
+    if signed_msg.certificates.nil? or signed_msg.certificates.length != 1
+      raise RuntimeError, ERR_MSG_TOO_MANY_SIGNERS
+    end
+
+    signer_cert = signed_msg.certificates[0]
+    unless signed_msg.verify([signer_cert], store, nil, OpenSSL::PKCS7::NOINTERN | OpenSSL::PKCS7::NOVERIFY)
+      raise RuntimeError, ERR_MSG_CORRUPT_CERT
+    end
+
+    [signed_msg.data[1..-1], signer_cert, signed_msg.data[0]]
+  end
+
+  # Generate new RSA keypair and certificate.
+  #
+  # @param [Integer] rsa_bits RSA key length
+  # @param [OpenSSL::Digest] sign_digest Signature digest
+  # @return [Array] rsa_keypair, certificate
+  def generate_keypair(rsa_bits=DEFAULT_RSA_BITS, sign_digest=OpenSSL::Digest::SHA512)
+    cn = "Akero #{Akero::VERSION}"
+    rsa = OpenSSL::PKey::RSA.new(rsa_bits)
+
+    cert = OpenSSL::X509::Certificate.new
+    cert.version = 3
+    cert.serial = rand(2**42)
+    name = OpenSSL::X509::Name.parse("/CN=#{cn}")
+    cert.subject = name
+    cert.issuer = name
+    cert.not_before = Time.now
+    cert.not_after = 64060588800
+    cert.public_key = rsa.public_key
+    
+    ef = OpenSSL::X509::ExtensionFactory.new(nil, cert)
+    ef.issuer_certificate = cert
+    cert.extensions = [
+      ef.create_extension("basicConstraints","CA:FALSE"),
+      ef.create_extension("subjectKeyIdentifier", "hash"),
+    ]
+    aki = ef.create_extension("authorityKeyIdentifier",
+                              "keyid:always,issuer:always")
+    cert.add_extension(aki)
+    cert.sign(rsa, sign_digest.new)
+    [rsa, cert]
+  end
+end
+

data/lib/akero/benchmark.rb

@@ -0,0 +1,124 @@
+require 'akero'
+require 'gnuplot'
+require 'b'
+
+class Akero
+  # @private
+  class Benchmark
+    class << self
+      def run!
+        b_size
+        b_timing
+      end
+
+      def b_size
+        puts "Running size benchmark..."
+
+        rnd = Random.new
+        msg_sizes = (8..13).map{|x| 2**x}
+        key_sizes = [2048, 4096]
+        results = {}
+        key_sizes.each do |ksize|
+          alice = Akero.new(ksize)
+          bob   = Akero.new(ksize)
+          msg_sizes.each do |msize|
+            msg = rnd.bytes(msize)
+            ciphertext = alice.encrypt(bob.public_key, msg)
+            (results["ENCRYPT #{ksize} bits"] ||= []) << [msize, ciphertext.length / msg.length.to_f]
+          end
+        end
+
+        plot('benchmark/bm_size.png', results, 'Message size overhead', 'Input size (bytes)', 'x')
+      end
+
+      def b_timing
+        puts "Running timing benchmark..."
+
+        msg_sizes = (4..18).map{|x| 2**x}
+        key_sizes = [2048, 4096]
+
+        rnd = Random.new
+
+        rounds = 50
+        results = []
+        key_sizes.each do |ksize|
+          results << B.enchmark("ENCRYPT #{ksize} bits", :rounds => rounds, :compare => :mean) do
+            alice = Akero.new(ksize)
+            bob   = Akero.new(ksize)
+            msg_sizes.each_with_index do |msize, i|
+              msg = rnd.bytes(msize)
+              job "msg_size #{msize}" do
+                alice.encrypt(bob.public_key, msg)
+              end
+            end
+          end
+        end
+
+        key_sizes.each do |ksize|
+          results << B.enchmark("SIGN #{ksize} bits", :rounds => rounds, :compare => :mean) do
+            alice = Akero.new(ksize)
+            bob   = Akero.new(ksize)
+            msg_sizes.each_with_index do |msize, i|
+              msg = rnd.bytes(msize)
+              job "msg_size #{msize}" do
+                alice.sign(msg)
+              end
+            end
+          end
+        end
+
+        key_sizes.each do |ksize|
+          results << B.enchmark("DECRYPT #{ksize} bits", :rounds => rounds, :compare => :mean) do
+            alice = Akero.new(ksize)
+            bob   = Akero.new(ksize)
+            msg_sizes.each_with_index do |msize, i|
+              msg = rnd.bytes(msize)
+              msg = alice.encrypt(bob.public_key, msg)
+              job "msg_size #{msize}" do
+                bob.receive(msg)
+              end
+            end
+          end
+        end
+
+        ds = {}
+        title = []
+        results.each_with_index do |r, i|
+          r.each_with_index do |v,j|
+            (ds[v[:group]] ||= []) << [msg_sizes[j],v[:rate]]
+          end
+        end
+
+        plot('benchmark/bm_rate.png', ds, "Throughput", 'Input size (bytes)', 'Messages/sec')
+      end
+
+      def plot(path, ds, label, xlabel, ylabel)
+        Gnuplot.open do |gp|
+          Gnuplot::Plot.new( gp ) do |plot|
+            plot.terminal "png"
+            plot.output path
+            plot.title  label
+            plot.xlabel xlabel
+            plot.ylabel ylabel
+            plot.xtics :axis
+            plot.style 'line 1 lc rgb "#8b1a0e" pt 1 ps 1 lt 1 lw 2'
+            plot.style 'line 2 lc rgb "#5e9c36" pt 6 ps 1 lt 1 lw 2'
+            plot.style 'line 11 lc rgb "#808080" lt 1'
+            plot.set 'border 3 back ls 11'
+            plot.set 'tics nomirror'
+            plot.style 'line 12 lc rgb "#808080" lt 0 lw 1'
+            plot.set 'grid back ls 12'
+            i=0
+            ds.each do |k, v|
+              plot.data << Gnuplot::DataSet.new([v.collect {|x| x[0]}, v.collect {|x| x[1]}]) do |_ds|
+                _ds.with = "lp ls #{i+1}"
+                _ds.title = k
+              end
+              i+=1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/akero/version.rb

@@ -0,0 +1,3 @@
+class Akero
+  VERSION = "1.0.0"
+end

data/spec/akero_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+require 'openssl'
+
+describe Akero do
+  subject { Akero.new(1024) }
+  describe '#new' do
+    it "returns instance with unique fingerprint" do
+      memo = {}
+      10.times do
+        id = Akero.new.id
+        memo.should_not include id
+        memo[id] = true
+      end
+    end
+  end
+
+  describe '#id' do
+    it "returns a String that looks like an Akero fingerprint" do
+      subject.id.should be_a String
+      subject.id.should match /^AK(:([a-fA-Z0-9]){2}){20}$/
+    end
+  end
+
+  describe '#private_key' do
+    describe 'return value' do
+      it "is a String that looks like an Akero private key" do
+        subject.private_key.should be_a String
+        subject.private_key.should match /^#{Akero::PKEY_HEADER}/
+        subject.private_key.should match /\n#{Akero::PKEY_FOOTER}$/
+      end
+
+      it "can be loaded by Akero" do
+        bob = Akero.load(subject.private_key)
+        bob.id.should == subject.id
+        bob.public_key.should == subject.public_key
+      end
+    end
+  end
+
+  describe '#public_key' do
+    describe 'return value' do
+      it "is a String that looks like an Akero public key" do
+        subject.public_key.should be_a String
+        subject.public_key.should match /^-----BEGIN #{Akero::PLATE_CERT[1]}-----\n/
+        subject.public_key.should match /\n-----END #{Akero::PLATE_CERT[1]}-----\n$/
+      end
+
+      it "raises RuntimeError when trying to load as private key" do
+        lambda {
+          bob = Akero.load(subject.public_key)
+          bob.id.should == subject.id
+          bob.public_key.should == subject.public_key
+        }.should raise_error RuntimeError, Akero::ERR_PKEY_CORRUPT
+      end
+    end
+  end
+
+  describe '#sign' do
+    describe 'return value' do
+      it "is a String that looks like an Akero signed message" do
+        plaintext = "Hello world!"
+        signed_msg = subject.sign(plaintext)
+        signed_msg.should be_a String
+        signed_msg.should match /^-----BEGIN #{Akero::PLATE_SIGNED[1]}-----\n/
+        signed_msg.should match /\n-----END #{Akero::PLATE_SIGNED[1]}-----\n$/
+      end
+
+      it "contains valid signature" do
+        plaintext = "Hello world!"
+        signed_msg = subject.sign(plaintext)
+        bob = Akero.new
+        msg = bob.receive(signed_msg)
+        msg.from.should == subject.id
+        msg.from_pk.should == subject.public_key
+        msg.body.should == plaintext
+        msg.type.should == :signed
+      end
+    end
+  end
+
+  describe '#encrypt' do
+    describe 'return value' do
+      it "is a String that looks like an Akero secret message" do
+        plaintext = "Hello world!"
+        ciphertext = subject.encrypt(subject.public_key, plaintext)
+        ciphertext.should be_a String
+        ciphertext.should match /^-----BEGIN #{Akero::PLATE_CRYPTED[1]}-----\n/
+        ciphertext.should match /\n-----END #{Akero::PLATE_CRYPTED[1]}-----\n$/
+      end
+
+      it "contains valid signature" do
+        plaintext = "Hello world!"
+        signed_msg = subject.sign(plaintext)
+        bob = Akero.new
+        msg = bob.receive(signed_msg)
+        msg.from == subject.id
+        msg.from_pk.should == subject.public_key
+        msg.body.should == plaintext
+        msg.type.should == :signed
+      end
+
+      it "raises RuntimeError on invalid recipient (invalid public key)" do
+        lambda {
+          msg = "Hello world!"
+          ciphertext = subject.encrypt([subject.public_key, 'foo'], msg)
+        }.should raise_error RuntimeError, Akero::ERR_INVALID_RECIPIENT_CERT
+      end
+
+      it "raises RuntimeError on invalid recipient (wrong type)" do
+        lambda {
+          msg = "Hello world!"
+          ciphertext = subject.encrypt([subject.public_key, 42], msg)
+        }.should raise_error RuntimeError, Akero::ERR_INVALID_RECIPIENT
+      end
+
+      it "raises RuntimeError when message is not String" do
+        lambda {
+          msg = "Hello world!"
+          ciphertext = subject.encrypt(subject.public_key, 42)
+        }.should raise_error RuntimeError, Akero::ERR_MSG_NOT_STRING_NOR_PKCS7
+      end
+    end
+  end
+
+  describe '#receive' do
+    it "decrypts message that was encrypted for self" do
+      plaintext = "Hello world!"
+      ciphertext = subject.encrypt(subject.public_key, plaintext)
+      msg = subject.receive(ciphertext)
+      msg.body.should == plaintext
+      msg.type.should == :encrypted
+    end
+
+    it "decrypts message that was encrypted for self and other recipients" do
+      plaintext = "Hello world!"
+      alice = Akero.new
+      bob   = Akero.new
+      ciphertext = subject.encrypt([alice.public_key, subject.public_key, bob.public_key], plaintext)
+      msg = subject.receive(ciphertext)
+      msg.body.should == plaintext
+      msg.type.should == :encrypted
+    end
+
+    it "fails to decrypt message that was encrypted only for other recipients" do
+      lambda {
+        plaintext = "Hello world!"
+        alice = Akero.new
+        bob   = Akero.new
+        ciphertext = subject.encrypt([alice.public_key, bob.public_key], plaintext)
+        msg = subject.receive(ciphertext)
+        msg.body.should == plaintext
+        msg.type.should == :encrypted
+      }.should raise_error RuntimeError, Akero::ERR_DECRYPT
+    end
+
+    it "extracts signature from signed message" do
+      plaintext = "Hello world!"
+      alice = Akero.new
+      signed_msg = subject.sign(plaintext)
+      msg = alice.receive(signed_msg)
+      msg.body.should == plaintext
+      msg.type.should == :signed
+    end
+
+    it "raises RuntimeError on invalid message" do
+      lambda {
+        subject.receive("foobar")
+      }.should raise_error RuntimeError, Akero::ERR_MSG_MALFORMED_ENV
+    end
+
+    it "raises RuntimeError when inner does not match outer signature" do
+      lambda {
+        oscar = Akero.new
+        raw_key = subject.send(:instance_variable_get, '@cert')
+        a = subject.send(:_encrypt, [raw_key], subject.send(:_sign, 'foobar'))
+        b = oscar.send(:_sign, a).to_s
+        c = Akero.replate(b, Akero::PLATE_CRYPTED)
+        subject.receive(c)
+      }.should raise_error RuntimeError, Akero::ERR_MSG_SIG_MISMATCH
+    end
+
+    it "raises RuntimeError on malformed inner message" do
+      lambda {
+        key, cert = subject.send(:generate_keypair, 1024)
+        env = OpenSSL::PKCS7::sign(cert, key, 0xff.chr, [], OpenSSL::PKCS7::BINARY)
+        broken_msg = Akero.replate(env.to_s, Akero::PLATE_CRYPTED)
+        subject.receive(broken_msg)
+      }.should raise_error RuntimeError, Akero::ERR_MSG_MALFORMED_BODY
+    end
+
+    it "raises RuntimeError on unsigned message" do
+      lambda {
+        raw_key = subject.send(:instance_variable_get, '@cert')
+        env = OpenSSL::PKCS7::encrypt([raw_key], 'foobar', OpenSSL::Cipher::new("AES-256-CFB"), OpenSSL::PKCS7::BINARY)
+        broken_msg = Akero.replate(env.to_s, Akero::PLATE_CRYPTED)
+        subject.receive(broken_msg)
+      }.should raise_error RuntimeError, Akero::ERR_MSG_TOO_MANY_SIGNERS
+    end
+  end
+ 
+  describe '#verify' do
+    it "raises RuntimeError when embedded certificate can not be verified" do
+      lambda {
+        fake_msg = mock('fake_msg')
+        fake_msg.stub(:verify).and_return(false)
+        fake_msg.stub_chain(:certificates, :length).and_return(1)
+        fake_msg.stub_chain(:certificates, :[]).and_return(nil)
+        subject.send(:verify, fake_msg)
+      }.should raise_error RuntimeError, Akero::ERR_MSG_CORRUPT_CERT
+    end
+
+  end
+
+  describe '#inspect' do
+    it "returns a summary String" do
+      s = subject.inspect
+      s.should match /id=AK:/
+    end
+  end
+
+  describe '#to_s' do
+    it "returns the same value as #inspect" do
+      subject.to_s.should == subject.inspect
+    end
+  end
+  
+  describe '.fingerprint_from_cert' do
+    it "raises RuntimeError on invalid cert" do
+      mock_cert = mock('mock_cert')
+      mock_cert.stub_chain(:extensions, :map, :each).and_return(nil)
+      lambda {
+        Akero.fingerprint_from_cert(mock_cert)
+      }.should raise_error RuntimeError, Akero::ERR_CERT_CORRUPT
+    end
+  end
+
+  describe Akero::Message do
+    describe '#inspect' do
+      it "returns a summary String" do
+        signed_msg = subject.sign('')
+        msg = subject.receive(signed_msg)
+        s = msg.inspect
+        s.should be_a String
+        s.should match /@type=/
+        s.should match /@from=/
+        s.should match /@body=/
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'akero'

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: akero
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Moe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: b
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gnuplot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy peer-to-peer public key cryptography
+email:
+- moe@busyloop.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- .yardopts
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- akero.gemspec
+- benchmark/bm_rate.png
+- benchmark/bm_size.png
+- lib/akero.rb
+- lib/akero/benchmark.rb
+- lib/akero/version.rb
+- spec/akero_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/busyloop/akero
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4483146424576861364
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4483146424576861364
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Easy peer-to-peer public key cryptography
+test_files:
+- spec/akero_spec.rb
+- spec/spec_helper.rb
+has_rdoc: