rbnacl 1.0.0.pre

data/.coveralls.yml

@@ -0,0 +1 @@
+service-name: travis-pro

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,21 @@
+script: "LD_LIBRARY_PATH=lib bundle exec rake ci"
+
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - ree
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+  - rbx-18mode
+  - rbx-19mode 
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+
+notifications:
+  irc: "irc.freenode.org#cryptosphere"

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --no-private lib/**/*.rb - README.md LICENSE.txt 

data/CHANGES.md

@@ -0,0 +1,4 @@
+HEAD
+----
+
+Unreleased!

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rbnacl.gemspec
+gemspec
+
+group :test do
+  gem 'base32'
+  gem 'coveralls', :require => false
+end

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2012 Tony Arcieri
+Copyright (c) 2013 Jonathan Stott
+
+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,179 @@
+![RbNaCl](https://raw.github.com/cryptosphere/rbnacl/master/images/logo.png)
+======
+[![Build Status](https://travis-ci.org/cryptosphere/rbnacl.png?branch=master)](https://travis-ci.org/cryptosphere/rbnacl)
+[![Code Climate](https://codeclimate.com/github/cryptosphere/rbnacl.png)](https://codeclimate.com/github/cryptosphere/rbnacl)
+[![Coverage Status](https://coveralls.io/repos/cryptosphere/rbnacl/badge.png?branch=master)](https://coveralls.io/r/cryptosphere/rbnacl)
+
+A Ruby binding to the state-of-the-art [Networking and Cryptography][nacl]
+library by Daniel J. Bernstein. This is **NOT** Google Native Client. This
+is a crypto library.
+
+On a completely unrelated topic, RbNaCl is also the empirical formula for
+Rubidium Sodium Chloride.
+
+Need help with RbNaCl? Join the [RbNaCl Google Group][group]
+
+[nacl]: http://nacl.cr.yp.to/
+[group]: http://groups.google.com/group/rbnacl
+
+## Why NaCl?
+
+NaCl is a different kind of cryptographic library. In the past crypto
+libraries were kitchen sinks of little bits and pieces, like ciphers,
+MACs, signature algorithms, and hash functions. To accomplish anything
+you had to make a lot of decisions about which specific pieces to use,
+and if any of your decisions were wrong, the result was an insecure
+system. The choices are also not easy: EAX? GCM? CCM? AES-CTR? CMAC?
+OMAC1? AEAD? NIST? CBC? CFB? CTR? ECB? OMGWTFBBQ!
+
+NaCl puts cryptography on Rails! Instead of making you choose which
+cryptographic primitives to use, NaCl provides convention over configuration
+in the form of expertly-assembled high-level cryptographic APIs that ensure
+not only the confidentiality of your data, but also detect tampering.
+These high-level, easy-to-use APIs are designed to be hard to attack by
+default in ways primitives exposed by libraries like OpenSSL are not.
+
+This approach makes NaCl a lot closer to a system like GPG than it is
+to the cryptographic primitive APIs in a library like OpenSSL. In addition,
+NaCl also uses state-of-the-art encryption, including Curve25519 elliptic
+curves and the XSalsa20 stream cipher. This means with NaCl you not only get
+a system which is designed to be secure-by-default, you also get one which
+is extremely fast with comparatively small cryptographic keys.
+
+For more information on NaCl's goals, see Dan Bernstein's presentation
+[Blaming the Cryptographic User](http://cr.yp.to/talks/2012.08.08/slides.pdf)
+
+## Supported platforms
+
+You can use RbNaCl anywhere you can get libsodium installed (see below).
+RbNaCl is continuously integration tested on the following Ruby VMs:
+
+* MRI 1.8 / REE
+* MRI 1.9 (YARV)
+* JRuby 1.7 (in both 1.8/1.9 mode)
+* Rubinius HEAD (in both 1.8/1.9 mode)
+
+In theory Windows should be supported, although there are not yet any
+reports of successful Windows users.
+
+## Installation
+
+### libsodium
+
+RbNaCl is implemented as a Ruby FFI binding, which is designed to bind to
+shared libraries. Unfortunately NaCl does not presently ship a shared library,
+so RbNaCl cannot take advantage of it via FFI. RbNaCl will support usage with
+the upstream NaCl once it is able to compile a shared library.
+
+For now, to use RbNaCl, you will need to install libsodium, a portable version
+of NaCl based upon the reference C code. Please see the libsodium project
+for information regarding installation:
+
+https://github.com/jedisct1/libsodium
+
+#### OS X
+
+Unfortunately libsodium is not in homebrew proper yet (I would strongly
+encourage you to [ask for libsodium's inclusion in homebrew][homebrew]),
+however you can use homebrew's "tap" feature for the time being to
+install libsodium:
+
+```
+brew tap qmx/homebrew-libsodium
+brew install libsodium
+```
+
+[homebrew]: https://github.com/mxcl/homebrew/pull/17275
+
+### RbNaCl gem
+
+Once you have libsodium installed, add this line to your application's Gemfile:
+
+    gem 'rbnacl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rbnacl
+
+## Documentation
+
+RbNaCl's documentation can be found [in the Wiki][wiki]. The following features
+are supported:
+
+* [Secret-key Encryption][secretkey]: authenticated symmetric encryption using a
+  single key shared among parties
+* [Public-key Encryption][publickey]: securely send messages to a given public
+  key which can only be decrypted by a secret key
+* [Digital Signatures][signatures]: sign messages with a private key which can
+  be verified by a public one
+* [Authenticators][macs]: create codes which can be used to check the
+  authenticity of messages
+* [Hash Functions][hashes]: compute a secure, fixed-length code from a message
+  which does not reveal the contents of the message
+
+Additional power-user features are available. Please see the Wiki for further
+information.
+
+[wiki]: https://github.com/cryptosphere/rbnacl/wiki
+[secretkey]: https://github.com/cryptosphere/rbnacl/wiki/Secret-Key-Encryption
+[publickey]: https://github.com/cryptosphere/rbnacl/wiki/Public-Key-Encryption
+[signatures]: https://github.com/cryptosphere/rbnacl/wiki/Digital-Signatures
+[macs]: https://github.com/cryptosphere/rbnacl/wiki/Authenticators
+[hashes]: https://github.com/cryptosphere/rbnacl/wiki/Hash-Functions
+
+## Security Notes
+
+NaCl itself has been expertly crafted to avoid a whole range of
+side-channel attacks, however the RbNaCl code itself has not been
+written with the same degree of expertise. While the code is
+straightforward it should be considered experimental until audited
+by professional cryptographers.
+
+That said, it's probably still a million times better than OpenSSL...
+
+## Reporting Security Problems
+
+If you have discovered a bug in RbNaCl of a sensitive nature, i.e.
+one which can compromise the security of RbNaCl users, you can
+report it securely by sending a GPG encrypted message. Please use
+the following key:
+
+https://raw.github.com/cryptosphere/rbnacl/master/rbnacl.gpg
+
+The key fingerprint is (or should be):
+
+`190E 42D6 8327 A515 BFDF AAE0 B210 269D BB2D 8787`
+
+## Learn More
+
+While NaCl has designed to be easier-than-usual to use for a crypto
+library, cryptography is an incredibly difficult subject and it's
+always helpful to know as much as you can about it before applying
+it to a particular use case. That said, the creator of NaCl, Dan
+Bernstein, has published a number of papers about NaCl. If you are
+interested in learning more about how NaCl works, it's recommended
+that you read them:
+
+* [Cryptography in NaCl](http://cr.yp.to/highspeed/naclcrypto-20090310.pdf)
+* [Curve25519: new Diffie-Hellman speed records](http://cr.yp.to/ecdh/curve25519-20060209.pdf)
+* [Ed25519: High-speed high-security signatures](http://ed25519.cr.yp.to/ed25519-20110926.pdf)
+
+Have a general interest in cryptography? Check out the free course
+Coursera offers from Stanford University Professor Dan Boneh:
+
+[http://crypto-class.org](http://crypto-class.org)
+
+## Contributing
+
+* Fork this repository on Github
+* Make your changes and send a pull request
+* If your changes look good, we'll merge 'em
+
+## License
+
+Copyright (c) 2013 Tony Arcieri, Jonathan Stott.
+Distributed under the MIT License. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+Dir[File.expand_path("../tasks/**/*.rake", __FILE__)].each { |task| load task }
+require File.expand_path("../lib/rbnacl/rake_tasks", __FILE__)
+
+task :default => :spec

data/lib/rbnacl.rb

@@ -0,0 +1,46 @@
+# encoding: binary
+module Crypto
+  # Oh no, something went wrong!
+  #
+  # This indicates a failure in the operation of a cryptographic primitive such
+  # as authentication failing on an attempt to decrypt a ciphertext.  Classes
+  # in the library may define more specific subclasses.
+  class CryptoError < StandardError; end
+
+  # Something, probably a key, is the wrong length
+  #
+  # This indicates some argument with an expected length was not that length.
+  # Since this is probably a cryptographic key, you should check that!
+  class LengthError < ArgumentError; end
+end
+
+# TIMTOWTDI!
+RbNaCl = Crypto
+
+require "rbnacl/nacl"
+require "rbnacl/version"
+require "rbnacl/serializable"
+require "rbnacl/keys/key_comparator"
+require "rbnacl/keys/private_key"
+require "rbnacl/keys/public_key"
+require "rbnacl/keys/signing_key"
+require "rbnacl/keys/verify_key"
+require "rbnacl/box"
+require "rbnacl/secret_box"
+require "rbnacl/hash"
+require "rbnacl/util"
+require "rbnacl/auth"
+require "rbnacl/hmac/sha512256"
+require "rbnacl/hmac/sha256"
+require "rbnacl/auth/one_time"
+require "rbnacl/random"
+require "rbnacl/encoder"
+require "rbnacl/encoders/base64"
+require "rbnacl/encoders/hex"
+require "rbnacl/encoders/raw"
+require "rbnacl/point"
+require "rbnacl/random_nonce_box"
+require "rbnacl/test_vectors"
+
+# Perform self test on load
+require "rbnacl/self_test"

data/lib/rbnacl/auth.rb

@@ -0,0 +1,78 @@
+# encoding: binary
+module Crypto
+  # Secret Key Authenticators
+  #
+  # These provide a means of verifying the integrity of a message, but only
+  # with the knowledge of a shared key.  This can be a preshared key, or one
+  # that is derived through some cryptographic protocol.
+  class Auth
+    # Number of bytes in a valid key
+    KEYBYTES = 0
+
+    # Number of bytes in a valid authenticator
+    BYTES = 0
+
+    attr_reader :key
+    private :key
+
+    # A new authenticator, ready for auth and verification
+    #
+    # @param [#to_str] key the key used for authenticators, 32 bytes.
+    # @param [#to_sym] encoding decode key from this format (default raw)
+    def initialize(key, encoding = :raw)
+      @key = Encoder[encoding].decode(key)
+      Util.check_length(@key, self.class::KEYBYTES, "#{self.class} key")
+    end
+
+    # Compute authenticator for message
+    #
+    # @param [#to_str] key the key used for the authenticator
+    # @param [#to_str] message message to construct an authenticator for
+    #
+    # @return [String] The authenticator, as raw bytes
+    def self.auth(key, message)
+      new(key).auth(message)
+    end
+
+    # Verifies the given authenticator with the message.
+    #
+    # @param [#to_str] key the key used for the authenticator
+    # @param [#to_str] message the message to be authenticated
+    # @param [#to_str] authenticator to be checked
+    #
+    # @return [Boolean] Was it valid?
+    def self.verify(key, message, authenticator)
+      new(key).verify(message, authenticator)
+    end
+
+    # Compute authenticator for message
+    #
+    # @param [#to_str] message the message to authenticate
+    # @param [#to_sym] authenticator_encoding format of the authenticator (default raw)
+    #
+    # @return [String] The authenticator in the requested encoding (default raw)
+    def auth(message, authenticator_encoding = :raw)
+      authenticator = Util.zeros(self.class::BYTES)
+      message = message.to_str
+      compute_authenticator(message, authenticator)
+      Encoder[authenticator_encoding].encode(authenticator)
+    end
+
+    # Verifies the given authenticator with the message.
+    #
+    # @param [#to_str] authenticator to be checked
+    # @param [#to_str] message the message to be authenticated
+    # @param [#to_sym] authenticator_encoding format of the authenticator (default raw)
+    #
+    # @return [Boolean] Was it valid?
+    def verify(message, authenticator, authenticator_encoding = :raw)
+      auth = Encoder[authenticator_encoding].decode(authenticator)
+      return false unless auth.bytesize == self.class::BYTES
+      verify_message(message, auth)
+    end
+
+    private
+    def compute_authenticator(message, authenticator); raise NotImplementedError; end
+    def verify_message(message, authenticator);        raise NotImplementedError; end
+  end
+end

data/lib/rbnacl/auth/one_time.rb

@@ -0,0 +1,38 @@
+# encoding: binary
+module Crypto
+  class Auth
+    # Computes an authenticator using poly1305
+    #
+    # The authenticator can be used at a later time to verify the provenence of
+    # the message by recomputing the tag over the message and then comparing it to
+    # the provided authenticator.  The class provides methods for generating
+    # signatures and also has a constant-time implementation for checking them.
+    #
+    # As the name suggests, this is a **ONE TIME** authenticator.  Computing an
+    # authenticator for two messages using the same key probably gives an
+    # attacker enough information to forge further authenticators for the same
+    # key.
+    #
+    # This is a secret key authenticator, i.e. anyone who can verify signatures
+    # can also create them.
+    #
+    # @see http://nacl.cr.yp.to/onetimeauth.html
+    class OneTime < self
+      # Number of bytes in a valid key
+      KEYBYTES = NaCl::ONETIME_KEYBYTES
+
+      # Number of bytes in a valid authenticator
+      BYTES = NaCl::ONETIME_BYTES
+
+      private
+      def compute_authenticator(message, authenticator)
+        NaCl.crypto_auth_onetime(authenticator, message, message.bytesize, key)
+      end
+
+      def verify_message(message, authenticator)
+        NaCl.crypto_auth_onetime_verify(authenticator, message, message.bytesize, key)
+      end
+
+    end
+  end
+end