tweetnacl 0.2.0 → 0.3.0

data/lib/tweet_na_cl.rb

@@ -0,0 +1,2 @@
+module TweetNaCl
+end

data/lib/tweetnacl/crypto_box.rb

@@ -0,0 +1,17 @@
+module TweetNaCl
+  class CryptoBox
+    attr_reader :keypair, :cipher, :message
+
+    def initialize(keypair = KeyPair.new)
+      @keypair = keypair
+    end
+
+    def close(message, nonce)
+      @cipher = TweetNaCl.crypto_box(message, nonce, @keypair.public_key, @keypair.secret_key)
+    end
+
+    def open(box, nonce)
+      @message = TweetNaCl.crypto_box_open(box.cipher, nonce, @keypair.public_key, @keypair.secret_key)
+    end
+  end
+end

data/lib/tweetnacl/crypto_sign.rb

@@ -0,0 +1,17 @@
+module TweetNaCl
+  class CryptoSign
+    attr_reader :keypair, :signed_message, :message
+
+    def initialize(keypair = KeyPair.new(TweetNaCl.crypto_sign_keypair))
+      @keypair = keypair
+    end
+
+    def sign(message)
+      @signed_message = TweetNaCl.crypto_sign(message, @keypair.secret_key)
+    end
+
+    def verify(message)
+      @message = TweetNaCl.crypto_sign_open(message.signed_message, @keypair.public_key)
+    end
+  end
+end

data/lib/tweetnacl/key_pair.rb

@@ -0,0 +1,9 @@
+module TweetNaCl
+  class KeyPair
+    attr_reader :public_key, :secret_key
+
+    def initialize(keypair = TweetNaCl.crypto_box_keypair)
+      @public_key, @secret_key = keypair
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,9 +1,15 @@
 require 'tweetnacl'
+require 'tweetnacl/crypto_sign'
+require 'tweetnacl/crypto_box'
+require 'tweetnacl/key_pair'
 require 'minitest/autorun'
 require 'minitest/assertions'
+require 'pp'
 
 class String
   def hd
     self.each_byte.map { |b| sprintf("%X", b) }.join
   end
 end
+
+ValidNonce = "x" * 24

data/test/tweetnacl/crypto_box_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class CryptoBoxTest < MiniTest::Test
+  def test_initializes_with_a_keypair_object
+    TweetNaCl::CryptoBox.new(Object.new)
+  end
+
+  def test_generate_a_keypair_object_if_none_provided
+    TweetNaCl::CryptoBox.new
+    assert :did_not_raise, "A CryptoBox object can be created without arguments"
+  end
+
+  def test_can_box_a_message_with_a_nonce
+    message = "hello world"
+    nonce = ValidNonce
+    nonce = "*" * 24
+
+    sender , receiver = TweetNaCl::KeyPair.new, TweetNaCl::KeyPair.new
+
+    encryption_keypair = TweetNaCl::KeyPair.new([receiver.public_key, sender.secret_key])
+    encrypted_box      = TweetNaCl::CryptoBox.new(encryption_keypair)
+    encrypted_box.close(message, nonce)
+
+    decryption_keypair = TweetNaCl::KeyPair.new([sender.public_key, receiver.secret_key])
+    decryption_box     = TweetNaCl::CryptoBox.new(decryption_keypair)
+    decryption_box.open(encrypted_box, nonce)
+
+    assert_equal message, decryption_box.message
+  end
+end

data/test/tweetnacl/crypto_sign_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class CryptoSignTest < MiniTest::Test
+  def test_initializes_with_a_keypair_object
+    TweetNaCl::CryptoSign.new(Object.new)
+  end
+
+  def test_generate_a_keypair_object_if_none_provided
+    TweetNaCl::CryptoSign.new
+    assert :did_not_raise, "A CryptoSign object can be created without arguments"
+  end
+
+  def test_can_sign_a_message
+    message = "hello world"
+
+    sender_keypair = TweetNaCl::KeyPair.new(TweetNaCl.crypto_sign_keypair)
+    signed_message = TweetNaCl::CryptoSign.new(sender_keypair)
+    signed_message.sign(message)
+
+    verified_message = TweetNaCl::CryptoSign.new(sender_keypair)
+    verified_message.verify(signed_message)
+
+    assert_equal message, verified_message.message
+  end
+end

data/test/tweetnacl/key_pair_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module TweetNaCl
+  class KeyPairTest < MiniTest::Test
+    def test_initializes_with_a_key_pair
+      kp = TweetNaCl::KeyPair.new([nil,nil])
+      assert_respond_to kp, :public_key
+      assert_respond_to kp, :secret_key
+    end
+
+    def test_can_generate_a_keypair_if_none_provided
+      kp = TweetNaCl::KeyPair.new
+      assert kp.public_key
+      assert kp.secret_key
+    end
+  end
+end

data/test/tweetnacl_alias_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class TweetNaClAliasTest < MiniTest::Test
+  def test_crypto_box_aliased_curve25519xsalsa20poly1305
+    assert_equal TweetNaCl.method(:crypto_box),      TweetNaCl.method(:crypto_box_curve25519xsalsa20poly1305)
+    assert_equal TweetNaCl.method(:crypto_box_open), TweetNaCl.method(:crypto_box_curve25519xsalsa20poly1305_open)
+  end
+
+  def test_crypto_secretbox_aliased_xsalsa20poly1305
+    assert_equal TweetNaCl.method(:crypto_secretbox),      TweetNaCl.method(:crypto_secretbox_xsalsa20poly1305)
+    assert_equal TweetNaCl.method(:crypto_secretbox_open), TweetNaCl.method(:crypto_secretbox_xsalsa20poly1305_open)
+  end
+
+  def test_crypto_sign_aliased_ed25519
+    assert_equal TweetNaCl.method(:crypto_sign),      TweetNaCl.method(:crypto_sign_ed25519)
+    assert_equal TweetNaCl.method(:crypto_sign_open), TweetNaCl.method(:crypto_sign_ed25519_open)
+  end
+end

data/test/tweetnacl_constants_test.rb

@@ -0,0 +1,172 @@
+require 'test_helper'
+
+class TweetNaClConstantsTest < MiniTest::Test
+  def _const(const_name)
+    TweetNaCl.const_get(const_name)
+  end
+
+  def test_constants
+    assert_instance_of String, _const("CRYPTO_AUTH_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_AUTH_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_AUTH_KEYBYTES")
+    assert_instance_of String, _const("CRYPTO_AUTH_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_AUTH_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_AUTH_HMACSHA512256_TWEET_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_AUTH_HMACSHA512256_TWEET_KEYBYTES")
+    assert_instance_of String, _const("CRYPTO_AUTH_HMACSHA512256_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_AUTH_HMACSHA512256_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_AUTH_HMACSHA512256_KEYBYTES")
+    assert_instance_of String, _const("CRYPTO_AUTH_HMACSHA512256_VERSION")
+    assert_instance_of String, _const("CRYPTO_AUTH_HMACSHA512256_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_BOX_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_PUBLICKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_SECRETKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_BEFORENMBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_NONCEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_ZEROBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_BOXZEROBYTES")
+    assert_instance_of String, _const("CRYPTO_BOX_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_BOX_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_PUBLICKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_SECRETKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_BEFORENMBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_NONCEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_ZEROBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_BOXZEROBYTES")
+    assert_instance_of String, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_PUBLICKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_SECRETKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_BEFORENMBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_NONCEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_ZEROBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_BOXZEROBYTES")
+    assert_instance_of String, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_VERSION")
+    assert_instance_of String, _const("CRYPTO_BOX_CURVE25519XSALSA20POLY1305_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_CORE_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_OUTPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_INPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_CONSTBYTES")
+    assert_instance_of String, _const("CRYPTO_CORE_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_CORE_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_TWEET_OUTPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_TWEET_INPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_TWEET_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_TWEET_CONSTBYTES")
+    assert_instance_of String, _const("CRYPTO_CORE_SALSA20_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_OUTPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_INPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_SALSA20_CONSTBYTES")
+    assert_instance_of String, _const("CRYPTO_CORE_SALSA20_VERSION")
+    assert_instance_of String, _const("CRYPTO_CORE_SALSA20_IMPLEMENTATION")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_TWEET_OUTPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_TWEET_INPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_TWEET_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_TWEET_CONSTBYTES")
+    assert_instance_of String, _const("CRYPTO_CORE_HSALSA20_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_OUTPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_INPUTBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_CORE_HSALSA20_CONSTBYTES")
+    assert_instance_of String, _const("CRYPTO_CORE_HSALSA20_VERSION")
+    assert_instance_of String, _const("CRYPTO_CORE_HSALSA20_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_STATEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_BLOCKBYTES")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA512_TWEET_STATEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA512_TWEET_BLOCKBYTES")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_SHA512_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA512_STATEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA512_BLOCKBYTES")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_SHA512_VERSION")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_SHA512_IMPLEMENTATION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA256_TWEET_STATEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA256_TWEET_BLOCKBYTES")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_SHA256_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA256_STATEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_HASHBLOCKS_SHA256_BLOCKBYTES")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_SHA256_VERSION")
+    assert_instance_of String, _const("CRYPTO_HASHBLOCKS_SHA256_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_HASH_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_HASH_BYTES")
+    assert_instance_of String, _const("CRYPTO_HASH_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_HASH_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASH_SHA512_TWEET_BYTES")
+    assert_instance_of String, _const("CRYPTO_HASH_SHA512_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASH_SHA512_BYTES")
+    assert_instance_of String, _const("CRYPTO_HASH_SHA512_VERSION")
+    assert_instance_of String, _const("CRYPTO_HASH_SHA512_IMPLEMENTATION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASH_SHA256_TWEET_BYTES")
+    assert_instance_of String, _const("CRYPTO_HASH_SHA256_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_HASH_SHA256_BYTES")
+    assert_instance_of String, _const("CRYPTO_HASH_SHA256_VERSION")
+    assert_instance_of String, _const("CRYPTO_HASH_SHA256_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_ONETIMEAUTH_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_ONETIMEAUTH_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_ONETIMEAUTH_KEYBYTES")
+    assert_instance_of String, _const("CRYPTO_ONETIMEAUTH_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_ONETIMEAUTH_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_ONETIMEAUTH_POLY1305_TWEET_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_ONETIMEAUTH_POLY1305_TWEET_KEYBYTES")
+    assert_instance_of String, _const("CRYPTO_ONETIMEAUTH_POLY1305_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_ONETIMEAUTH_POLY1305_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_ONETIMEAUTH_POLY1305_KEYBYTES")
+    assert_instance_of String, _const("CRYPTO_ONETIMEAUTH_POLY1305_VERSION")
+    assert_instance_of String, _const("CRYPTO_ONETIMEAUTH_POLY1305_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_SCALARMULT_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_SCALARMULT_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SCALARMULT_SCALARBYTES")
+    assert_instance_of String, _const("CRYPTO_SCALARMULT_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_SCALARMULT_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_SCALARMULT_CURVE25519_TWEET_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SCALARMULT_CURVE25519_TWEET_SCALARBYTES")
+    assert_instance_of String, _const("CRYPTO_SCALARMULT_CURVE25519_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_SCALARMULT_CURVE25519_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SCALARMULT_CURVE25519_SCALARBYTES")
+    assert_instance_of String, _const("CRYPTO_SCALARMULT_CURVE25519_VERSION")
+    assert_instance_of String, _const("CRYPTO_SCALARMULT_CURVE25519_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_SECRETBOX_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_NONCEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_ZEROBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_BOXZEROBYTES")
+    assert_instance_of String, _const("CRYPTO_SECRETBOX_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_SECRETBOX_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_NONCEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_ZEROBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_BOXZEROBYTES")
+    assert_instance_of String, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_NONCEBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_ZEROBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_BOXZEROBYTES")
+    assert_instance_of String, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_VERSION")
+    assert_instance_of String, _const("CRYPTO_SECRETBOX_XSALSA20POLY1305_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_SIGN_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_PUBLICKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_SECRETKEYBYTES")
+    assert_instance_of String, _const("CRYPTO_SIGN_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_SIGN_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_ED25519_TWEET_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_ED25519_TWEET_PUBLICKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_ED25519_TWEET_SECRETKEYBYTES")
+    assert_instance_of String, _const("CRYPTO_SIGN_ED25519_TWEET_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_ED25519_BYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_ED25519_PUBLICKEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_SIGN_ED25519_SECRETKEYBYTES")
+    assert_instance_of String, _const("CRYPTO_SIGN_ED25519_VERSION")
+    assert_instance_of String, _const("CRYPTO_SIGN_ED25519_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_STREAM_PRIMITIVE")
+    assert_instance_of Fixnum, _const("CRYPTO_STREAM_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_STREAM_NONCEBYTES")
+    assert_instance_of String, _const("CRYPTO_STREAM_IMPLEMENTATION")
+    assert_instance_of String, _const("CRYPTO_STREAM_VERSION")
+    assert_instance_of Fixnum, _const("CRYPTO_STREAM_XSALSA20_TWEET_KEYBYTES")
+    assert_instance_of Fixnum, _const("CRYPTO_STREAM_XSALSA20_TWEET_NONCEBYTES")
+  end
+end

data/test/tweetnacl_crypto_box_key_pair_test.rb

@@ -1,14 +1,8 @@
 require 'test_helper'
 
 class TweetNaClCryptoBoxKeyPairTest < MiniTest::Test
-  def setup
-    @t = TweetNaCl.new
-  end
-
-  def teardown; end
-
   def test_generate_a_keypair
-    pk, sk = @t.crypto_box_keypair
+    pk, sk = TweetNaCl.crypto_box_keypair
 
     assert_equal 32, pk.length
     assert_equal 32, sk.length

data/test/tweetnacl_crypto_box_open_test.rb

@@ -1,49 +1,23 @@
 require 'test_helper'
 
 class TweetNaClCryptoBoxOpenTest < MiniTest::Test
-  def setup
-    @t = TweetNaCl.new
+  def test_crypto_box_open_require_cipher_to_decrypt
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box_open(nil, nil, nil, nil) }
   end
 
-  def teardown; end
+  def test_crypto_box_open_nonce_not_correct_length
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box("foo", "bar", "pk", "sk") }
+  end
 
-  def test_crypto_box_open_require_cipher_to_decrypt
-    set = false
-    begin
-      @t.crypto_box_open(nil, nil, nil, nil)
-    rescue Exception => e
-      set = true
-    end
-    assert set, "A cipher is required"
+  def test_crypto_box_open_require_matching_public_and_secret_keys
+    assert_raises(RuntimeError) { TweetNaCl.crypto_box_open("foo", "x"*24, "x"*32, "x"*32) }
   end
 
   def test_crypto_box_open_require_public_key
-    set = false
-    begin
-      @t.crypto_box_open("foo", nil, "foo", nil)
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "A public key is required"
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box_open("foo", "x"*24, "foo", nil) }
   end
 
   def test_crypto_box_open_require_secret_key
-    set = false
-    begin
-      @t.crypto_box_open("foo", "foo", "foo", nil)
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "A secret key is required"
-  end
-
-  def test_crypto_box_open_nonce_not_correct_length
-    set = false
-    begin
-      @t.crypto_box("foo", "bar", "pk", "sk")
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "Incorrect nonce length should have raised ArgumentError"
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box_open("foo", "x"*24, "foo", nil) }
   end
 end

data/test/tweetnacl_crypto_box_test.rb

@@ -1,12 +1,6 @@
 require 'test_helper'
 
 class TweetNaClCryptoBoxTest < MiniTest::Test
-  def setup
-    @t = TweetNaCl.new
-  end
-
-  def teardown; end
-
   def test_crypto_box
     input = "hello world"
     nonce = "*" * 24
@@ -14,51 +8,27 @@ class TweetNaClCryptoBoxTest < MiniTest::Test
     pk = "\x60\xF0\x23\x07\xDF\xB6\x8B\xBB\x15\xE2\x92\x59\x05\x1B\x2D\xF8\xC8\x59\xDB\x5B\xDE\x97\xFA\xE8\x9B\x5F\xE5\x62\x63\x11\xD6\x56"
     sk = "\xBE\x38\x7C\x59\xD1\x81\x0B\xCC\x8E\xD8\x90\xDB\x3D\xF9\x80\x63\x9E\xD2\x54\x44\xFB\x4D\xD1\x92\xB6\xC6\x75\x53\xF9\x76\x9F\xCF"
 
-    cipher = @t.crypto_box(input, nonce, pk, sk)
+    cipher = TweetNaCl.crypto_box(input, nonce, pk, sk)
 
-    output = @t.crypto_box_open(cipher, nonce, pk, sk)
+    output = TweetNaCl.crypto_box_open(cipher, nonce, pk, sk)
 
     assert_equal input, output
     assert_equal expected_cipher, cipher.hd
   end
 
   def test_crypto_box_require_message_to_cipher
-    set = false
-    begin
-      @t.crypto_box(nil, "bar", "pk", "sk")
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "A message is required"
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box(nil, "bar", "pk", "sk") }
   end
 
   def test_crypto_box_require_public_key
-    set = false
-    begin
-      @t.crypto_box("foo", "bar", nil, "sk")
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "A public key is required"
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box("foo", "bar", nil, "sk") }
   end
 
   def test_crypto_box_require_secret_key
-    set = false
-    begin
-      @t.crypto_box("foo", "bar", "pk", nil)
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "A secret key is required"
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box("foo", "bar", "pk", nil) }
   end
 
   def test_crypto_box_nonce_not_correct_length
-    set = false
-    begin
-      @t.crypto_box("foo", "bar", "pk", "sk")
-    rescue ArgumentError => e
-      set = true
-    end
-    assert set, "Incorrect nonce length should have raised ArgumentError"
+    assert_raises(ArgumentError) { TweetNaCl.crypto_box("foo", "bar", "pk", "sk") }
   end
 end