cryptosphere 0.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.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/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--backtrace
+--default_path spec

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.9.3
+  - ruby-head
+#  - jruby-19mode not working due to JCE issues
+#  - jruby-head
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem 'jruby-openssl', :platform => 'jruby'
+
+# Specify your gem's dependencies in cryptosphere.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Tony Arcieri
+
+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,77 @@
+![Celluloid](https://github.com/tarcieri/cryptosphere/raw/master/logo.png)
+================
+[![Build Status](http://travis-ci.org/tarcieri/cryptosphere.png)](http://travis-ci.org/tarcieri/cryptosphere)
+
+> "I want people to see the truth... regardless of who they are... because
+> without information, you cannot make informed decisions as a public" _-- Bradley Manning_
+
+The Cryptosphere is a global peer-to-peer cryptosystem for publishing and
+securely distributing content anonymously with no central point of failure.
+The system is openly federated and anyone can join. To ensure quality service
+and prevent abuse, the Cryptosphere uses an integrated cryptographically
+secure reputation system which provides a distributed web of trust.
+
+There are several systems with similar goals to the Cryptosphere, such as
+MNet, Freenet, and Tahoe-LAFS. These systems serve as inspiration for the
+Cryptosphere's design. The Cryptosphere is also heavily influenced by Git, the
+distributed version control system.
+
+For more information, please see the [project philosophy][philosophy]
+page in the wiki.
+
+Like the Cryptosphere? [Join the Google Group][google group]
+We're also on IRC at #cryptosphere on irc.freenode.net
+
+[philosophy]:   https://github.com/tarcieri/cryptosphere/wiki/Philosophy
+[google group]: https://groups.google.com/group/cryptosphere
+
+### Is it any good?
+
+[Yes.](http://news.ycombinator.com/item?id=3067434)
+
+### Is It "Production Ready™"?
+
+No, the Cryptosphere is still in an early development stage, and is not yet
+ready for general usage.
+
+Use Cases
+---------
+
+The Cryptosphere provides an encrypted storage system where only users with
+the capability tokens for respective content are able to access it. Unlike
+many other peer to systems, there is no global search system because all
+content in the system is encrypted and therefore unsearchable.
+
+This makes the Cryptosphere quite a bit different from many other P2P systems
+which sought to publicize users content. Instead, the Cryptosphere tries to
+keep your content as confidential as possible. This makes it useful for the
+following things:
+
+* Secure personal backups
+* File sharing among small groups (ala Dropbox)
+* Secure anonymous encrypted source control
+* Censorship-proof anonymous web hosting
+
+Suggested Reading
+-----------------
+
+* [Tahoe - The Least-Authority Filesystem (Tahoe-LAFS)](https://tahoe-lafs.org/~zooko/lafs.pdf)
+* [A Distributed Decentralized Information Storage and Retrieval System (Freenet)](http://freenetproject.org/papers/ddisrs.pdf)
+* [Efficient Sharing of Encrypted Data (GNUnet)](http://grothoff.org/christian/esed.pdf)
+* [Samsara: Honor Among Thieves in Peer-to-Peer Storage](http://www.eecs.harvard.edu/~mema/courses/cs264/papers/samsara-sosp2003.pdf)
+* [The Sybil Attack](http://research.microsoft.com/pubs/74220/IPTPS2002.pdf)
+* [A Sybilproof Indirect Reciprocity Mechanism for Peer-to-Peer Networks](http://discovery.ucl.ac.uk/14962/1/14962.pdf)
+* [Incentive-driven QoS in peer-to-peer overlays](http://discovery.ucl.ac.uk/19490/1/19490.pdf)
+
+Contributing to the Cryptosphere
+--------------------------------
+
+* Fork this repository on github
+* Make your changes and send me a pull request
+* If I like them I'll merge them
+
+License
+-------
+
+Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
+LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+Dir["tasks/**/*.task"].each { |task| load task }
+
+task :default => :spec

data/bin/csphere

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'cryptosphere'
+
+Cryptosphere::CLI.start(ARGV)

data/cryptosphere.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/cryptosphere/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tony Arcieri"]
+  gem.email         = ["tony.arcieri@gmail.com"]
+  gem.description   = "A decentralized globally distributed peer-to-peer data archive"
+  gem.summary       = "The Cryptosphere is a P2P cryptosystem for publishing and securely distributing content anonymously with no central point of failure"
+  gem.homepage      = "http://github.com/tarcieri/cryptosphere"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "cryptosphere"
+  gem.require_paths = ["lib"]
+  gem.version       = Cryptosphere::VERSION
+  
+  gem.add_dependency "celluloid"
+  gem.add_dependency "thor"
+  gem.add_dependency "hkdf"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/lib/cryptosphere.rb

@@ -0,0 +1,45 @@
+require 'digest/sha2'
+require 'openssl'
+require 'cryptosphere/version'
+
+require 'cryptosphere/crypto/asymmetric_cipher'
+require 'cryptosphere/crypto/kdf'
+require 'cryptosphere/crypto/signature_algorithm'
+
+require 'cryptosphere/blobs/blob'
+require 'cryptosphere/blobs/tree'
+
+require 'cryptosphere/protocol/handshake'
+
+require 'cryptosphere/cli'
+require 'cryptosphere/head'
+require 'cryptosphere/identity'
+
+module Cryptosphere
+  # How large of a key to use for the pubkey cipher
+  PUBKEY_SIZE = 2048
+
+  # Secure random data source
+  def random_bytes(size)
+    OpenSSL::Random.random_bytes(size)
+  end
+
+  # 256-bit hash function
+  def self.hash_function
+    Digest::SHA256.new
+  end
+
+  # 256-bit block cipher
+  def self.block_cipher
+    OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+  end
+
+  # Request to do something we're incapable of
+  class CapabilityError < StandardError; end
+
+  # Signature doesn't match (potential data tampering)
+  class InvalidSignatureError < StandardError; end
+
+  # Implausible timestamps (i.e. ones from the future)
+  class InvalidTimestampError < StandardError; end
+end

data/lib/cryptosphere/blobs/blob.rb

@@ -0,0 +1,117 @@
+require 'tempfile'
+require 'fileutils'
+
+module Cryptosphere
+  class Blob
+    # Prefix added to the beginning of every Cryptosphere node
+    PREFIX = "blob::"
+
+    attr_reader :id, :key, :path
+
+    class << self
+      attr_reader :path
+
+      # Configure the Cryptosphere Node store
+      def setup(options = {})
+        unless options[:root]
+          raise ArgumentError, "no :root path given"
+        end
+
+        unless File.directory? options[:root]
+          raise ArgumentError, "no such directory: #{options[:root]}"
+        end
+
+        @path = File.expand_path("nodes", options[:root])
+        FileUtils.mkdir @path unless File.directory? @path
+
+        nil
+      end
+
+      # Create a node from a given object
+      def [](obj)
+        builder = Builder.new
+        builder << obj
+        builder.finish
+      end
+    end
+
+    def initialize(id, key)
+      @id, @key = id, key
+      @path = File.join(self.class.path, @id)
+    end
+
+    def decrypt
+      raise "can't decrypt node without key" unless @key
+
+      cipher = Cryptosphere.block_cipher
+      cipher.decrypt
+      cipher.key = @key[0...32]
+      cipher.iv  = @key[32...64]
+
+      output = ''
+
+      File.open(@path, 'r') do |file|
+        while data = file.read(4096)
+          output << cipher.update(data)
+        end
+      end
+
+      output << cipher.final
+    end
+
+    # Encrypt a node and insert it into the local store
+    class Builder
+      def initialize
+        @hash_function = Cryptosphere.hash_function
+        @hash_function << PREFIX
+
+        @file = Tempfile.new 'cryptosphere'
+      end
+
+      def write(data)
+        @hash_function << data
+        @file << data
+      end
+      alias_method :<<, :write
+
+      def finish
+        keys = Cryptosphere.kdf(@hash_function.digest, size: 64)
+        key, iv = keys[0...32], keys[32...64]
+
+        block_cipher = Cryptosphere.block_cipher
+        block_cipher.encrypt
+        block_cipher.key, block_cipher.iv = key, iv
+
+        @file.rewind
+        output = Tempfile.new 'cryptosphere'
+
+        begin
+          hash_function = Cryptosphere.hash_function
+          while plaintext = @file.read(4096)
+            ciphertext = block_cipher.update(plaintext)
+            output << ciphertext
+            hash_function << ciphertext
+          end
+
+          ciphertext = block_cipher.final
+          output << ciphertext
+          hash_function << ciphertext
+          output.close
+
+          node_id = hash_function.hexdigest
+          FileUtils.mv output.path, File.join(Blob.path, node_id)
+
+          Blob.new(node_id, key + iv)
+        rescue Exception
+          output.close rescue nil
+          output.unlink rescue nil
+
+          raise
+        end
+      ensure
+        @file.close rescue nil
+        @file.unlink rescue nil
+      end
+    end
+  end
+end

data/lib/cryptosphere/blobs/tree.rb

@@ -0,0 +1,22 @@
+module Cryptosphere
+  class Tree < Blob
+    def self.[](*entries)
+      new(entries)
+    end
+
+    def initialize(entries)
+      @entries = entries
+    end
+
+    def to_s
+      @entries.sort_by { |e| e.name }.map(&:to_s).join("\n")
+    end
+
+    # Individual entries in a tree
+    class Entry < Struct.new(:mode, :type, :id, :key, :name)
+      def to_s
+        "#{mode} #{type} #{id} #{key} #{name}"
+      end
+    end
+  end
+end

data/lib/cryptosphere/cli.rb

@@ -0,0 +1,11 @@
+require 'thor'
+
+module Cryptosphere
+  class CLI < Thor
+    
+    desc 'setup', 'Configure the Cryptosphere'
+    def setup
+      puts "Hi there!"
+    end
+  end
+end

data/lib/cryptosphere/crypto/asymmetric_cipher.rb

@@ -0,0 +1,73 @@
+require 'openssl'
+
+module Cryptosphere
+  # Asymmetric encryption cipher: 2048-bit RSA
+  class AsymmetricCipher
+    KEY_SIZE = 2048
+
+    def self.generate_key
+      OpenSSL::PKey::RSA.generate(KEY_SIZE).to_pem
+    end
+
+    def initialize(key)
+      openssl_key = OpenSSL::PKey::RSA.new(key)
+
+      if openssl_key.private?
+        @private_key = openssl_key
+        @public_key  = openssl_key.public_key
+      else
+        @private_key = nil
+        @public_key  = openssl_key
+      end
+    end
+
+    # Serialize canonical private key with Distinguished Encoding Rules (DER)
+    def private_key
+      @private_key.to_der
+    end
+
+    # Serialize private key in Privacy Enhanced Mail (PEM) format
+    def private_key_pem
+      @private_key.to_pem
+    end
+
+    # Is a private key present?
+    def private_key?
+      !!@private_key
+    end
+
+    # Serialize canonical public key with Distinguished Encoding Rules (DER)
+    def public_key
+      @public_key.to_der
+    end
+
+    # Obtain the fingerprint for this public key
+    def public_key_fingerprint
+      Cryptosphere.kdf(public_key).unpack('H*').first.scan(/.{4}/).join(":")
+    end
+
+    # Encrypt a value using the private key
+    # Value can be decrypted with the public key
+    def private_encrypt(plaintext)
+      @private_key.private_encrypt(plaintext)
+    end
+
+    # Decrypt a value using the private key
+    # Ciphertext must be encrypted with public key
+    def private_decrypt(ciphertext)
+      @private_key.private_decrypt(ciphertext)
+    end
+
+    # Encrypt a value using the public key
+    # Value can only be decrypted with the private key
+    def public_encrypt(plaintext)
+      @public_key.public_encrypt(plaintext)
+    end
+
+    # Decrypt a value using the public key
+    # Ciphertext must be encrypted with private key
+    def public_decrypt(ciphertext)
+      @public_key.public_decrypt(ciphertext)
+    end
+  end
+end

data/lib/cryptosphere/crypto/kdf.rb

@@ -0,0 +1,12 @@
+require 'hkdf'
+
+module Cryptosphere
+  # Cryptographically secure key derivation function: HKDF (RFC 5869)
+  #
+  # Options:
+  # * size: how many bytes of output to generate (default 32, i.e. 256 bits)
+  def self.kdf(secret, options = {})
+    size = options[:size] || 32
+    HKDF.new(secret).next_bytes(size)
+  end
+end

data/lib/cryptosphere/crypto/signature_algorithm.rb

@@ -0,0 +1,17 @@
+module Cryptosphere
+  # Sign the given message with a private key
+  def self.sign(key, message)
+    AsymmetricCipher.new(key).private_encrypt(kdf(message))
+  end
+
+  # Verify a message with the public key. Returns if the signature matches,
+  # and false if there's a mismatch
+  def self.verify(key, message, signature)
+    AsymmetricCipher.new(key).public_decrypt(signature) == kdf(message)
+  end
+
+  # Verify a message, raising InvalidSignatureError on signature mismatch
+  def self.verify!(key, message, signature)
+    verify(key, message, signature) or raise InvalidSignatureError, "signature mismatch"
+  end
+end

data/lib/cryptosphere/head.rb

@@ -0,0 +1,77 @@
+module Cryptosphere
+  class Head
+    attr_reader :signing_key, :read_key, :verify_key, :timestamp
+
+    def self.generate
+      access_key = AsymmetricCipher.generate_key
+      read_key   = Cryptosphere.random_bytes(32)
+
+      new(verify_key.to_der, read_key, signing_key.to_der)
+    end
+
+    def initialize(access_key, read_key = nil)
+      @signing_cipher = AsymmetricCipher.new(access_key)
+      @read_key      = read_key
+
+      @id        = @signing_cipher.public_key_fingerprint
+      @location  = nil
+      @timestamp = nil
+    end
+
+    def location
+      raise CapabilityError, "can't read location" unless @read_key
+      @location
+    end
+
+    def move(location, timestamp = Time.now)
+      raise CapabilityError, "don't have write capability" unless @signing_cipher.private_key?
+      @location, @timestamp = location, timestamp
+    end
+    alias_method :location=, :move
+
+    def to_signed_message
+      cipher = Cryptosphere.block_cipher
+      cipher.encrypt
+      cipher.key = @read_key
+      cipher.iv  = iv = cipher.random_iv
+
+      ciphertext = cipher.update(location)
+      ciphertext << cipher.final
+
+      message   = [@timestamp.to_i, iv, ciphertext].pack("QA16A*")
+      signature = @signing_cipher.private_encrypt Cryptosphere.kdf(message)
+
+      [signature.size, signature, message].pack("nA*A*")
+    end
+
+    def update(signed_message)
+      signature_size, rest = signed_message.unpack("nA*")
+      signature, message = rest.unpack("A#{signature_size}A*")
+
+      if @signing_cipher.public_decrypt(signature) != Cryptosphere.kdf(message)
+        raise InvalidSignatureError, "signature does not match message"
+      end
+
+      timestamp, iv, ciphertext = message.unpack("QA16A*")
+      timestamp = Time.at(timestamp)
+
+      if timestamp > Time.now
+        raise InvalidTimestampError, "timestamp is in the future"
+      elsif @timestamp && timestamp < @timestamp
+        return false # we have a newer version
+      end
+
+      if @read_key
+        cipher = Cryptosphere.block_cipher
+        cipher.decrypt
+        cipher.key = @read_key
+        cipher.iv = iv
+
+        location = cipher.update(ciphertext)
+        location << cipher.final
+
+        @location = location
+      end
+    end
+  end
+end

data/lib/cryptosphere/identity.rb

@@ -0,0 +1,21 @@
+module Cryptosphere
+  class Identity
+    attr_reader :id
+
+    extend Forwardable
+    def_delegators :@cipher, :private_key, :public_key
+
+    def self.generate
+      new AsymmetricCipher.generate_key
+    end
+
+    def initialize(private_key)
+      @cipher = AsymmetricCipher.new(private_key)
+      @id     = @cipher.public_key_fingerprint
+    end
+
+    def to_s
+      "#<Cryptosphere::Identity:#{id}>"
+    end
+  end
+end

data/lib/cryptosphere/protocol/handshake.rb

@@ -0,0 +1,37 @@
+module Cryptosphere
+  module Handshake
+    module_function
+
+    def encode_request(sender, recipient)
+      # TODO: encrypt sender's public key
+      # Sure would be nice to have some Curve25519 here
+      message = sender.public_key
+      Cryptosphere.sign(sender.private_key, message) + message
+    end
+
+    def decode_request(recipient, message)
+      bytes = PUBKEY_SIZE / 8
+      signature, message = message[0...bytes], message[bytes..-1]
+
+      # FIXME: this should be encrypted :(
+      sender_key = message
+      Cryptosphere.verify!(sender_key, message, signature)
+
+      sender_key
+    end
+
+    def encode_response(sender, recipient, secret = Cryptosphere.random_bytes(32))
+      cipher = AsymmetricCipher.new(recipient.public_key)
+      message = cipher.public_encrypt(secret)
+      Cryptosphere.sign(sender.private_key, message) + message
+    end
+
+    def decode_response(recipient, sender, message)
+      bytes = PUBKEY_SIZE / 8
+      signature, message = message[0...bytes], message[bytes..-1]
+      Cryptosphere.verify!(sender.public_key, message, signature)
+      cipher = AsymmetricCipher.new(recipient.private_key)
+      cipher.private_decrypt(message)
+    end
+  end
+end

data/lib/cryptosphere/version.rb

@@ -0,0 +1,3 @@
+module Cryptosphere
+  VERSION = "0.0.0"
+end

data/spec/cryptosphere/blobs/blob_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Cryptosphere::Blob do
+  it "creates blobs from data" do
+    builder = Cryptosphere::Blob::Builder.new
+    builder << "foobar"
+    blob = builder.finish
+    blob.decrypt.should == "foobar"
+  end
+end

data/spec/cryptosphere/blobs/tree_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Cryptosphere::Tree do
+  it "creates nodes" do
+    file = Cryptosphere::Blob["file::foobar"]
+    foobar = Cryptosphere::Tree::Entry['-', 'file', file.id, file.key, "foobar"]
+    tree = Cryptosphere::Tree[foobar]
+    tree.to_s.should == "- file #{file.id} #{file.key} foobar"
+  end
+end

data/spec/cryptosphere/head_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Cryptosphere::Head do
+  let(:read_key)   { "X" * 32 }
+  let(:write_key)  { example_private_key }
+  let(:verify_key) { example_public_key }
+
+  let(:reader) { Cryptosphere::Head.new(verify_key, read_key) }
+  let(:writer) { Cryptosphere::Head.new(write_key,  read_key) }
+
+  let(:example_location) { "221B Baker Street" }
+
+  it "moves heads" do
+    writer.move(example_location)
+    message = writer.to_signed_message
+    message.length.should be < MAX_DATAGRAM_LENGTH
+
+    reader.update message
+    reader.location.should == example_location
+  end
+end

data/spec/cryptosphere/identity_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Cryptosphere::Identity do
+  it "generates identities" do
+    Cryptosphere::Identity.generate.should be_a Cryptosphere::Identity
+  end
+end

data/spec/cryptosphere/protocol/handshake_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Cryptosphere::Handshake do
+  let(:alice)  { Cryptosphere::Identity.new(alice_private_key) }
+  let(:bob)    { Cryptosphere::Identity.new(bob_private_key) }
+  let(:secret) { "X" * 32 }
+
+  it "encodes and decodes request packets" do
+    packet = Cryptosphere::Handshake.encode_request(alice, bob)
+
+    # FIXME: need elliptic curve crypto here for smaller packets
+    #packet.length.should be < MAX_DATAGRAM_LENGTH
+    public_key = Cryptosphere::Handshake.decode_request(bob, packet)
+    public_key.should eq alice.public_key
+  end
+
+  it "encodes and decodes response packets" do
+    packet   = Cryptosphere::Handshake.encode_response(bob, alice, secret)
+    response = Cryptosphere::Handshake.decode_response(alice, bob, packet)
+    response.should eq secret
+  end
+end

data/spec/fixtures/alice.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAzwQYjchBgWq7nStqQeTvRhC15kGJc2Aa3q3ytIt7iH3gQSH+
+KbZKckGh184JnPoCEOUDHJ2klhpTkjf0kgAcx6TOUt9DdP63B3FpX22LG0PU4qbm
+SxZ4QXsqhEhj2UyxMbkKbBE9lKx90K9SO7dDB797cghoD5Sh2T69y+4bg6etJpVv
+x0oP+9/HUynQBwZqykHIXPyhcBGsaWcB52tmwwYVQCkhaOhQv3iI4Z+33M2gAbpr
+cH83kJCnKVZlRnhrswsxUUQ5nrX66edNXztcz28Lj6r8bMrQlymd+1zFjVCX1h5e
+h2n/DNVRU5LkeK3VPom7mQ/xZygdhvEksebsSwIDAQABAoIBACDyJ+44lqRAFke3
+JxwBkUr3UdupRnTEMMKLsHqnUCuyzMPQ4yBEUKjKZTVxJvqCl12U9N/S/uScn/w/
+R38M4YesZOGvgo7WEs7ub7SuPFtEelbv9OqyUsUpEuUmmC13FSQyrMPyInjM0uEp
+Zc73JYXQJZdKWzVPlEp8v7v60woqlchFzFk9i+byhN40gKUx4Irm6UCeMRBlmPP8
+6Ck3iUZw0I6NARF9tRNa0gn+nDoX7bBJfohsb5yLYvDHjv9ED2u4ivDyk5X0HvPP
+nHCBFgtt5MK0WVdaaIKxXXPJaPCXVlpYTCLmwqjuVQslPZXzv0CAhO40ZvMnLfAn
+xZ9MCjECgYEA+ysg7gE5WoWL/hPVS0JA5tKqn83f4tinWAnRgbPg7cUnFVrNI3qZ
+riPvj/SdFQMrGEsnq6RH7hoBfKPIEImWETaNMgWvGEegs1JDzHXI40BUZBmm1ioZ
+tCF0hmDibYckJBhU8BKSiM0wAx3QEbC/VzKsSto2mOICIidEyw+Wk6cCgYEA0v+K
+MGhOusBxDDx/mRlW3/1+nCzyla+NDTRKcJaDGOArgU+AOqRcHuyiBdD25fyhs3JC
+3GsxJmOvO+UrX2tFpNycEpmMR/XYPVWZlNbaoOp15/+ijx9OAOTMmjOQ26HUHhar
+3jP5DLbodcnnuHCeTNpW8zTswbqnArRPYXZKBr0CgYEAmvJaWDmtFij42f+GP+1Z
+eIxR8k/hZGJfqjI0ax17D3Pmzoe7sb16fTFyIo63MTVJKq2ChaLNNRgZ/rhTPdCD
+IY9Tv54+DG5ztuxzIvkuuvL+nNouUEScosFYz2WJiiQqqZHRJGFwwLBEhEeqCp/N
+CpAaNfs0X1BeHI+5IsQ1ElUCgYEAmuULnlPEkCZcFx6GkW7frtmaS65Xe3l/c9US
+XKqxnN5cMbaaLPKhyfXvT5PC3L1kO6bC3Ks4TrVZW//1ojvOyaNGVAUyzVT2JLil
+YXWE1CKq4eBxht31VoSgiwcV7ZZUcK42B45h42qXJnlNScIrA8I5mJsev211029o
+4uSCnYUCgYEAlpfHrPIvHzjrgg2+d18hFmF1139zeAfuDVNpvRC2sjTZVAWfmyDj
+9rlsBXPM8vg2AUojiKy4Q+CuhIcBKOpMAEgmU33sH6/rEZTPmQrztx4f1YJHHQjR
+JyL+dplE4InNOiO2m8ymQA7JfRa4hC+VZnVUNxPl1TcB2yp/iMZyg8M=
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/bob.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAycdXNUdBLGbnyKt8M8LhT9sObVzvKY+WQJsdvxyPoROaS8aY
+ZxFTLHxSbJpHp9Yl+A3ZZjoNdE0b6mc771S/PorY6SQc+KOGbDP7864fn5y+haYP
+BT8qBB93wZdkCIQay5HnAS1xdIzAFCAsu3dKVgfxQt/+sFnSw/qtC1BuxCqXckDk
+HVYcgkdQUXKh1prj240M/NfGjYIPfHnGvAKwhTKzJYVPSKDtgs432NcD5u8Oa+eU
+yrA8PpaeXdwnndbjXbyvXwWc1sep77NHXkcZNpOqC9vKY+PHXbHvpV+pILeZxH7z
+lE9mf/l0ucbmCH4EnLx+ZXTU2lZMTCqH2JwaRwIDAQABAoIBAF85A57REaCyr4+z
+3dlPjqTw684QnY0vhejXSyJ1iBKr/ZTlE+cP9gB4ay11YXuDREfbwUzM+Kx590KX
+lWFMzTPmspbTxBhSk41cuvo0ohfhEMhhpZUESf/IGevyVfLu5PZM1IdpurEV+0+E
+H5gYo6wV83Vr3/W5bg2urxs3yg4odNH59f5RIi++q3YpIXctZErboh6nEGNoP4aK
+NsCmPv+dTheryHbY29OBCqtFZWNma57gNViuuliDQYlgqbjvOGE2jEm6PmqOYuN/
+/nRlgD0hFscJUGfnxjm7b2pu3J9hLosiJ7WCkKuA6QkFYBX8IbiCGPX0QB/uVS2P
+bNgJaYECgYEA6mTjPZAE6NG1lErp5FRknuzm4R1Damm0SVYC3K6kkIimXBf4z0lk
+TB/l0j5e7wS7b29eoQcylXoxLAS/tG3odEDyZXwncncWjYyvwOeonfxRCFxhKyEP
+GV6ATz/arOUqjN7b39j6grtrNy+SLg6xpGwnue3wVUz4m4TENRtlSvMCgYEA3GDP
+nNDNBqdsjzjSccCZXo6AL+TNDP0PkhzZNGRFXLn2kr2bmL2rdS7A8iYwbYsX0US/
+WUTZAfTBaC2nWa4RyKLTLrwChKflccrz4a0EjTeZvheSy+HRyBMLrIg7bK+VaTxg
+kgNKxfxMYb7L4sqMvgyG2XUoI70wOPUvRqAooF0CgYBOn162BLwQ2F8fCe3goApM
+YMylECrP4/sMamR1X8Nlk+CxnXzhEw4olr6BQliXti+lFmdYflCSYTVjPYiMXh2N
++UcVkYqt05JmEp3ViB9ANyV7N3mEfQdSjCdf7dxNCGW4cPyx3ldRSMqS7UsMVfNy
+YrEEpfJqunHdwLAL3E+izwKBgHLH4ZpVjlPG4938xG8G11rOcamAS+RV8cQyTlbh
+Wtce7HQlWWNGdoUEIu58QYDsjy0p11fRag2AwzNVg/JLnWuYktGmjtE0+WY5RKjo
+CpTavrKpaIXUSgUhFlV4ZysGkJVNIycpm8pezBGk5GBtCrz5nUqpoIxsvy8LVOI+
+DKrpAoGBAL3g75JCxSuCxETK+bDns6h/t4YDmyxWsZOp+SZE4j3pYbILwQQr24l8
+FVNsGkLiti5k2pgHB6jDAPEiZBzR9zXAoBxJaM5ga1XirdC4YkFVULP+vUflHbRz
+jz8R+pzjVuUr+b/sTeudgh8FRofHcHi0fNVK7XnLgmQaj6mTArf5
+-----END RSA PRIVATE KEY-----

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'cryptosphere'
+require 'fileutils'
+
+Root = File.expand_path("../tmp", __FILE__)
+
+FileUtils.rm_rf File.join(Root, "*")
+Cryptosphere::Blob.setup :root => Root
+
+module KeyExamples
+  def load_fixture_private_key(name = 'alice.key')
+    File.read File.expand_path("../fixtures/#{name}", __FILE__)
+  end
+
+  def load_fixture_public_key(name = 'alice.key')
+    Cryptosphere::AsymmetricCipher.new(load_fixture_private_key(name)).public_key
+  end
+
+  def alice_private_key
+    @alice_private_key ||= load_fixture_private_key('alice.key')
+  end
+  alias_method :example_private_key, :alice_private_key
+
+  def alice_public_key
+    @alice_public_key ||= load_fixture_public_key('alice.key')
+  end
+  alias_method :example_public_key, :alice_public_key
+
+  def bob_private_key
+    @bob_private_key ||= load_fixture_private_key('bob.key')
+  end
+
+  def bob_public_key
+    @bob_public_key  ||= load_fixture_public_key('bob.key')
+  end
+end
+
+include KeyExamples
+
+# Maximum datagram length the Cryptosphere protocol permits
+# Taken from RFC 879 maximum size reassembly buffer
+MAX_DATAGRAM_LENGTH = 512

data/tasks/rspec.task

@@ -0,0 +1,7 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: cryptosphere
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Tony Arcieri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: &70140313417880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70140313417880
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70140313417460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70140313417460
+- !ruby/object:Gem::Dependency
+  name: hkdf
+  requirement: &70140313417040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70140313417040
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70140313416620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70140313416620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70140313416200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70140313416200
+description: A decentralized globally distributed peer-to-peer data archive
+email:
+- tony.arcieri@gmail.com
+executables:
+- csphere
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/csphere
+- cryptosphere.gemspec
+- lib/cryptosphere.rb
+- lib/cryptosphere/blobs/blob.rb
+- lib/cryptosphere/blobs/tree.rb
+- lib/cryptosphere/cli.rb
+- lib/cryptosphere/crypto/asymmetric_cipher.rb
+- lib/cryptosphere/crypto/kdf.rb
+- lib/cryptosphere/crypto/signature_algorithm.rb
+- lib/cryptosphere/head.rb
+- lib/cryptosphere/identity.rb
+- lib/cryptosphere/protocol/handshake.rb
+- lib/cryptosphere/version.rb
+- logo.png
+- spec/cryptosphere/blobs/blob_spec.rb
+- spec/cryptosphere/blobs/tree_spec.rb
+- spec/cryptosphere/head_spec.rb
+- spec/cryptosphere/identity_spec.rb
+- spec/cryptosphere/protocol/handshake_spec.rb
+- spec/fixtures/alice.key
+- spec/fixtures/bob.key
+- spec/spec_helper.rb
+- spec/tmp/.gitkeep
+- tasks/rspec.task
+homepage: http://github.com/tarcieri/cryptosphere
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: The Cryptosphere is a P2P cryptosystem for publishing and securely distributing
+  content anonymously with no central point of failure
+test_files:
+- spec/cryptosphere/blobs/blob_spec.rb
+- spec/cryptosphere/blobs/tree_spec.rb
+- spec/cryptosphere/head_spec.rb
+- spec/cryptosphere/identity_spec.rb
+- spec/cryptosphere/protocol/handshake_spec.rb
+- spec/fixtures/alice.key
+- spec/fixtures/bob.key
+- spec/spec_helper.rb
+- spec/tmp/.gitkeep
+has_rdoc: