rbnacl 1.1.0 → 2.0.0

metadata.gz.sig

@@ -1,2 +1,2 @@
-Ea���E?�&rL}:�!�`��u�B�\�$GP�>�:	����݋)cv�"H*�#��4���ei��*�&�pjk#*�芚$��I�_����:��oC����W��h �=���ƕʗZ��K��Oc{����<P�~G�(���M���
-��X�V���>'XA�'�C�y� Tvj�q�	S�X�����
+�.	�r_Q���; �|��A�;e�(�zX#�u?���ݛ�Zܻ�@c�ךk�����ɛ�ID>����ߣg�J����4
+%Wh���h�o�ҟ�����,�W�,��˥�{�tw{#�B؄k\� 

data/lib/rbnacl/box.rb

@@ -1,171 +0,0 @@
-# encoding: binary
-module Crypto
-  # The Box class boxes and unboxes messages between a pair of keys
-  #
-  # This class uses the given public and secret keys to derive a shared key,
-  # which is used with the nonce given to encrypt the given messages and
-  # decrypt the given ciphertexts.  The same shared key will generated from
-  # both pairing of keys, so given two keypairs belonging to alice (pkalice,
-  # skalice) and bob(pkbob, skbob), the key derived from (pkalice, skbob) with
-  # equal that from (pkbob, skalice).  This is how the system works:
-  #
-  # @example
-  #   # On bob's system
-  #   bobkey = Crypto::PrivateKey.generate
-  #   #=> #<Crypto::PrivateKey ...>
-  #
-  #   # send bobkey.public_key to alice
-  #   # recieve alice's public key, alicepk
-  #   # NB: This is actually the hard part of the system.  How to do it securely
-  #   # is left as an exercise to for the reader.
-  #   alice_pubkey = "..."
-  #
-  #   # make a box
-  #   alicebob_box = Crypto::Box.new(alice_pubkey, bobkey)
-  #   #=> #<Crypto::Box ...>
-  #
-  #   # encrypt a message to alice
-  #   cipher_text = alicebob_box.box("A bad example of a nonce", "Hello, Alice!")
-  #   #=> "..." # a string of bytes, 29 bytes long
-  #
-  #   # send ["A bad example of a nonce", cipher_text] to alice
-  #   # note that nonces don't have to be secret
-  #   # receive [nonce, cipher_text_to_bob] from alice
-  #
-  #   # decrypt the reply
-  #   # Alice has been a little more sensible than bob, and has a random nonce
-  #   # that is too fiddly to type here.  But there are other choices than just
-  #   # random
-  #   plain_text = alicebob_box.open(nonce, cipher_text_to_bob)
-  #   #=> "Hey there, Bob!"
-  #
-  #   # we have a new message!
-  #   # But Eve has tampered with this message, by flipping some bytes around!
-  #   # [nonce2, cipher_text_to_bob_honest_love_eve]
-  #   alicebob_box.open(nonce2, cipher_text_to_bob_honest_love_eve)
-  #
-  #   # BOOM!
-  #   # Bob gets a Crypto::CryptoError to deal with!
-  #
-  # It is VITALLY important that the nonce is a nonce, i.e. it is a number used
-  # only once for any given pair of keys.  If you fail to do this, you
-  # compromise the privacy of the the messages encrypted.  Also, bear in mind
-  # the property mentioned just above. Give your nonces a different prefix, or
-  # have one side use an odd counter and one an even counter.  Just make sure
-  # they are different.
-  #
-  # The ciphertexts generated by this class include a 16-byte authenticator which
-  # is checked as part of the decryption.  An invalid authenticator will cause
-  # the unbox function to raise.  The authenticator is not a signature.  Once
-  # you've looked in the box, you've demonstrated the ability to create
-  # arbitrary valid messages, so messages you send are repudiatable.  For
-  # non-repudiatable messages, sign them before or after encryption.
-  class Box
-
-    # Number of bytes in a Box nonce
-    NONCEBYTES = NaCl::CURVE25519_XSALSA20_POLY1305_BOX_NONCEBYTES
-
-    # Create a new Box
-    #
-    # Sets up the Box for deriving the shared key and encrypting and
-    # decrypting messages.
-    #
-    # @param public_key [String,Crypto::PublicKey] The public key to encrypt to
-    # @param private_key [String,Crypto::PrivateKey] The private key to encrypt with
-    # @param encoding [Symbol] Parse keys from the given encoding
-    #
-    # @raise [Crypto::LengthError] on invalid keys
-    #
-    # @return [Crypto::Box] The new Box, ready to use
-    def initialize(public_key, private_key, encoding = :raw)
-      @public_key   = PublicKey  === public_key  ? public_key  : PublicKey.new(public_key, encoding)
-      @private_key  = PrivateKey === private_key ? private_key : PrivateKey.new(private_key, encoding)
-      raise IncorrectPrimitiveError unless @public_key.primitive == primitive && @private_key.primitive == primitive
-    end
-
-    # Encrypts a message
-    #
-    # Encrypts the message with the given nonce to the keypair set up when
-    # initializing the class.  Make sure the nonce is unique for any given
-    # keypair, or you might as well just send plain text.
-    #
-    # This function takes care of the padding required by the NaCL C API.
-    #
-    # @param nonce [String] A 24-byte string containing the nonce.
-    # @param message [String] The message to be encrypted.
-    #
-    # @raise [Crypto::LengthError] If the nonce is not valid
-    #
-    # @return [String] The ciphertext without the nonce prepended (BINARY encoded)
-    def box(nonce, message)
-      Util.check_length(nonce, nonce_bytes, "Nonce")
-      msg = Util.prepend_zeros(NaCl::ZEROBYTES, message)
-      ct  = Util.zeros(msg.bytesize)
-
-      NaCl.crypto_box_curve25519_xsalsa20_poly1305_afternm(ct, msg, msg.bytesize, nonce, beforenm) || raise(CryptoError, "Encryption failed")
-      Util.remove_zeros(NaCl::BOXZEROBYTES, ct)
-    end
-    alias encrypt box
-
-    # Decrypts a ciphertext
-    #
-    # Decrypts the ciphertext with the given nonce using the keypair setup when
-    # initializing the class.
-    #
-    # This function takes care of the padding required by the NaCL C API.
-    #
-    # @param nonce [String] A 24-byte string containing the nonce.
-    # @param ciphertext [String] The message to be decrypted.
-    #
-    # @raise [Crypto::LengthError] If the nonce is not valid
-    # @raise [Crypto::CryptoError] If the ciphertext cannot be authenticated.
-    #
-    # @return [String] The decrypted message (BINARY encoded)
-    def open(nonce, ciphertext)
-      Util.check_length(nonce, nonce_bytes, "Nonce")
-      ct = Util.prepend_zeros(NaCl::BOXZEROBYTES, ciphertext)
-      message  = Util.zeros(ct.bytesize)
-
-      NaCl.crypto_box_curve25519_xsalsa20_poly1305_open_afternm(message, ct, ct.bytesize, nonce, beforenm) || raise(CryptoError, "Decryption failed. Ciphertext failed verification.")
-      Util.remove_zeros(NaCl::ZEROBYTES, message)
-    end
-    alias decrypt open
-
-    # The crypto primitive for the box class
-    #
-    # @return [Symbol] The primitive used
-    def self.primitive
-      :curve25519_xsalsa20_poly1305
-    end
-
-    # The crypto primitive for the box class
-    #
-    # @return [Symbol] The primitive used
-    def primitive
-      self.class.primitive
-    end
-
-    # The nonce bytes for the box class
-    #
-    # @return [Integer] The number of bytes in a valid nonce
-    def self.nonce_bytes
-      NONCEBYTES
-    end
-
-    # The nonce bytes for the box instance
-    #
-    # @return [Integer] The number of bytes in a valid nonce
-    def nonce_bytes
-      NONCEBYTES
-    end
-
-    private
-    def beforenm
-      @k ||= begin
-               k = Util.zeros(NaCl::CURVE25519_XSALSA20_POLY1305_BOX_BEFORENMBYTES)
-               NaCl.crypto_box_curve25519_xsalsa20_poly1305_beforenm(k, @public_key.to_s, @private_key.to_s) || raise(CryptoError, "Failed to derive shared key")
-               k
-             end
-    end
-  end
-end

data/lib/rbnacl/encoder.rb

@@ -1,44 +0,0 @@
-# encoding: binary
-module Crypto
-  # Encoders can be used to serialize or deserialize keys, ciphertexts, hashes,
-  # and signatures. To provide an encoder, simply subclass Encoder and call the
-  # register class method, then define the encode and decode methods:
-  #
-  #     class CrazysauceEncoder < Crypto::Encoder
-  #       register :crazysauce
-  #
-  #       def encode(string)
-  #         ...
-  #       end
-  #
-  #       def decode(string)
-  #         ...
-  #       end
-  #     end
-  #
-  # Once an encoder has been registered, an instance of it is available via
-  # calling Crypto::Encoder[], e.g. Crypto::Encoder[:hex].encode("foobar")
-  #
-  class Encoder
-    # Hash where encoder objects are stored
-    Registry = {}
-
-    # Register the current class as an encoder
-    def self.register(name)
-      self[name] = self.new
-    end
-
-    # Look up an encoder by the given name
-    def self.[](name)
-      Registry[name.to_sym] or raise ArgumentError, "unsupported encoder: #{name}"
-    end
-
-    # Register an encoder object directly
-    def self.[]=(name, obj)
-      Registry[name.to_sym] = obj
-    end
-
-    def encode(string); raise NotImplementedError, "encoding not implemented"; end
-    def decode(string); raise NotImplementedError, "decoding not implemented"; end
-  end
-end

data/lib/rbnacl/encoders/base32.rb

@@ -1,33 +0,0 @@
-# encoding: binary
-# Requires the base32 gem
-require 'base32'
-
-module Crypto
-  module Encoders
-    # Base64 encoding provider
-    #
-    # Accessable as Crypto::Encoder[:base64]
-    #
-    class Base32 < Crypto::Encoder
-      register :base32
-
-      # Base64 encodes a message
-      #
-      # @param [String] bytes The bytes to encode
-      #
-      # @return [String] Lovely, elegant "Zooko-style" Base32
-      def encode(bytes)
-        ::Base32.encode(bytes.to_s).downcase
-      end
-
-      # Hex decodes a message
-      #
-      # @param [String] base32 string to decode.
-      #
-      # @return [String] crisp and clean bytes
-      def decode(base32)
-        ::Base32.decode(base32.to_s.upcase)
-      end
-    end
-  end
-end

data/lib/rbnacl/encoders/base64.rb

@@ -1,30 +0,0 @@
-# encoding: binary
-module Crypto
-  module Encoders
-    # Base64 encoding provider
-    #
-    # Accessable as Crypto::Encoder[:base64]
-    #
-    class Base64 < Crypto::Encoder
-      register :base64
-
-      # Base64 encodes a message
-      #
-      # @param [String] bytes The bytes to encode
-      #
-      # @return [String] Clunky old base64
-      def encode(bytes)
-        [bytes.to_s].pack("m").gsub("\n", '')
-      end
-
-      # Hex decodes a message
-      #
-      # @param [String] base64 string to decode.
-      #
-      # @return [String] crisp and clean bytes
-      def decode(base64)
-        base64.to_s.unpack("m").first
-      end
-    end
-  end
-end

data/lib/rbnacl/encoders/hex.rb

@@ -1,30 +0,0 @@
-# encoding: binary
-module Crypto
-  module Encoders
-    # Hex encoding provider
-    #
-    # Accessable as Crypto::Encoder[:hex]
-    #
-    class Hex < Crypto::Encoder
-      register :hex
-
-      # Hex encodes a message
-      #
-      # @param [String] bytes The bytes to encode
-      #
-      # @return [String] Tasty, tasty hexidecimal
-      def encode(bytes)
-        bytes.to_s.unpack("H*").first
-      end
-
-      # Hex decodes a message
-      #
-      # @param [String] hex hex to decode.
-      #
-      # @return [String] crisp and clean bytes
-      def decode(hex)
-        [hex.to_s].pack("H*")
-      end
-    end
-  end
-end

data/lib/rbnacl/encoders/raw.rb

@@ -1,12 +0,0 @@
-# encoding: binary
-module Crypto
-  module Encoders
-    # Raw encoder which only does a string conversion (if necessary)
-    class Raw < Crypto::Encoder
-      register :raw
-
-      def encode(bytes); bytes.to_s; end
-      def decode(bytes); bytes.to_s; end
-    end
-  end
-end

data/lib/rbnacl/keys/signing_key.rb

@@ -1,95 +0,0 @@
-# encoding: binary
-module Crypto
-  # Private key for producing digital signatures using the Ed25519 algorithm.
-  # Ed25519 provides a 128-bit security level, that is to say, all known attacks
-  # take at least 2^128 operations, providing the same security level as
-  # AES-128, NIST P-256, and RSA-3072.
-  #
-  # Signing keys are produced from a 32-byte (256-bit) random seed value.
-  # This value can be passed into the SigningKey constructoras a String
-  # whose bytesize is 32.
-  #
-  # The public VerifyKey can be computed from the private 32-byte seed value
-  # as well, eliminating the need to store a "keypair".
-  #
-  # SigningKey produces 64-byte (512-bit) signatures. The signatures are
-  # deterministic: signing the same message will always produce the same
-  # signature. This prevents "entropy failure" seen in other signature
-  # algorithms like DSA and ECDSA, where poor random number generators can
-  # leak enough information to recover the private key.
-  class SigningKey
-    include KeyComparator
-    include Serializable
-
-    attr_reader :verify_key
-
-    # Generate a random SigningKey
-    #
-    # @return [Crypto::SigningKey] Freshly-generated random SigningKey
-    def self.generate
-      new Crypto::Random.random_bytes(NaCl::ED25519_SEED_BYTES)
-    end
-
-    # Create a SigningKey from a seed value
-    #
-    # @param seed [String] Random 32-byte value (i.e. private key)
-    # @param encoding [Symbol] Parse seed from the given encoding
-    #
-    # @return [Crypto::SigningKey] Key which can sign messages
-    def initialize(seed, encoding = :raw)
-      seed = Encoder[encoding].decode(seed)
-
-      Util.check_length(seed, NaCl::ED25519_SEED_BYTES, "seed")
-
-      pk = Util.zeros(NaCl::ED25519_VERIFYKEY_BYTES)
-      sk = Util.zeros(NaCl::ED25519_SIGNINGKEY_BYTES)
-
-      NaCl.crypto_sign_ed25519_seed_keypair(pk, sk, seed) || raise(CryptoError, "Failed to generate a key pair")
-
-      @seed, @signing_key = seed, sk
-      @verify_key = VerifyKey.new(pk)
-    end
-
-    # Sign a message using this key
-    #
-    # @param message [String] Message to be signed by this key
-    # @param encoding [Symbol] Encode signature in the given format
-    #
-    # @return [String] Signature as bytes
-    def sign(message, encoding = :raw)
-      buffer = Util.prepend_zeros(signature_bytes, message)
-      buffer_len = Util.zeros(FFI::Type::LONG_LONG.size)
-
-      NaCl.crypto_sign_ed25519(buffer, buffer_len, message, message.bytesize, @signing_key)
-
-      signature = buffer[0, signature_bytes]
-      Encoder[encoding].encode(signature)
-    end
-
-    # Return the raw seed value of this key
-    #
-    # @return [String] seed used to create this key
-    def to_bytes; @seed; end
-
-    # The crypto primitive the SigningKey class uses for signatures
-    #
-    # @return [Symbol] The primitive
-    def self.primitive; :ed25519; end
-
-    # The crypto primitive this SigningKey class uses for signatures
-    #
-    # @return [Symbol] The primitive
-    def primitive; self.class.primitive; end
-
-    # The size of signatures generated by the SigningKey class
-    #
-    # @return [Integer] The number of bytes in a signature
-    def self.signature_bytes; NaCl::ED25519_SIGNATUREBYTES; end
-
-    # The size of signatures generated by the SigningKey instance
-    #
-    # @return [Integer] The number of bytes in a signature
-    def signature_bytes; NaCl::ED25519_SIGNATUREBYTES; end
-
-  end
-end

data/lib/rbnacl/keys/verify_key.rb

@@ -1,96 +0,0 @@
-# encoding: binary
-module Crypto
-  # The signature was forged or otherwise corrupt
-  class BadSignatureError < CryptoError; end
-
-  # The public key counterpart to an Ed25519 SigningKey for producing digital
-  # signatures. Like the name says, VerifyKeys can be used to verify that a
-  # given digital signature is authentic.
-  #
-  # For more information on the Ed25519 digital signature system, please see
-  # the SigningKey documentation.
-  class VerifyKey
-    include KeyComparator
-    include Serializable
-
-    # Create a new VerifyKey object from a serialized public key. The key can
-    # be decoded from any serialization format supported by the
-    # Crypto::Encoding system.
-    #
-    # @param key [String] Serialized Ed25519 public key
-    # @param encoding [Symbol] Parse key from the given encoding
-    #
-    # @return [Crypto::SigningKey] Key which can sign messages
-    def initialize(key, encoding = :raw)
-      key = Encoder[encoding].decode(key)
-      Util.check_length(key, NaCl::ED25519_VERIFYKEY_BYTES, "key")
-
-      @key = key
-    end
-
-    # Create a new VerifyKey object from a serialized public key. The key can
-    # be decoded from any serialization format supported by the
-    # Crypto::Encoding system.
-    #
-    # You can remember the argument ordering by "verify message with signature"
-    # It's like a legal document, with the signature at the end.
-    #
-    # @param message [String] Message to be authenticated
-    # @param signature [String] Alleged signature to be checked
-    # @param signature_encoding [Symbol] Parse signature from the given encoding
-    #
-    # @return [Boolean] was the signature authentic?
-    def verify(message, signature, signature_encoding = :raw)
-      signature = Encoder[signature_encoding].decode(signature)
-      Util.check_length(signature, signature_bytes, "signature")
-
-      sig_and_msg = signature + message
-      buffer = Util.zeros(sig_and_msg.bytesize)
-      buffer_len = Util.zeros(FFI::Type::LONG_LONG.size)
-
-      NaCl.crypto_sign_ed25519_open(buffer, buffer_len, sig_and_msg, sig_and_msg.bytesize, @key)
-    end
-
-    # "Dangerous" (but probably safer) verify that raises an exception if a
-    # signature check fails. This is probably less likely to go unnoticed than
-    # an improperly checked verify, as you are forced to deal with the
-    # exception explicitly (and failing signature checks are certainly an
-    # exceptional condition!)
-    #
-    # The arguments are otherwise the same as the verify method.
-    #
-    # @param message [String] Message to be authenticated
-    # @param signature [String] Alleged signature to be checked
-    # @param signature_encoding [Symbol] Parse signature from the given encoding
-    #
-    # @return [true] Will raise BadSignatureError if signature check fails
-    def verify!(message, signature, signature_encoding = :raw)
-      verify(message, signature, signature_encoding) or raise BadSignatureError, "signature was forged/corrupt"
-    end
-
-    # Return the raw key in byte format
-    #
-    # @return [String] raw key as bytes
-    def to_bytes; @key; end
-
-    # The crypto primitive the VerifyKey class uses for signatures
-    #
-    # @return [Symbol] The primitive
-    def self.primitive; :ed25519; end
-
-    # The crypto primitive this VerifyKey class uses for signatures
-    #
-    # @return [Symbol] The primitive
-    def primitive; self.class.primitive; end
-
-    # The size of signatures verified by the VerifyKey class
-    #
-    # @return [Integer] The number of bytes in a signature
-    def self.signature_bytes; NaCl::ED25519_SIGNATUREBYTES; end
-
-    # The size of signatures verified by the VerifyKey instance
-    #
-    # @return [Integer] The number of bytes in a signature
-    def signature_bytes; NaCl::ED25519_SIGNATUREBYTES; end
-  end
-end

data/lib/rbnacl/nacl.rb

@@ -1,146 +0,0 @@
-# encoding: binary
-require 'ffi'
-module Crypto
-  # This module has all the FFI code hanging off it
-  #
-  # And that's all it does, really.
-  #
-  # HERE BE DRAGONS!
-  #
-  # Do **NOT** use constants and methods defined here.  If you do find yourself
-  # needing to, that is a bug in RbNaCl and should be reported.
-  #
-  # @private
-  module NaCl
-    extend FFI::Library
-    ffi_lib 'sodium'
-
-    # Wraps an NaCl function so it returns a sane value
-    #
-    # The NaCl functions generally have an integer return value which is 0 in
-    # the case of success and below 0 if they failed.  This is a bit
-    # inconvinient in ruby, where 0 is a truthy value, so this makes them
-    # return true/false based on success.
-    #
-    # @param [Symbol] name Function name that will return true/false
-    # @param [Symbol] function Function to attach
-    # @param [Array<Symbol>] arguments Array of arguments to the function
-    def self.wrap_nacl_function(name, function, arguments)
-      module_eval <<-eos, __FILE__, __LINE__ + 1
-      attach_function #{function.inspect}, #{arguments.inspect}, :int
-      def self.#{name}(*args)
-        ret = #{function}(*args)
-        ret == 0
-      end
-      eos
-    end
-
-    SHA256BYTES = 32
-    wrap_nacl_function :crypto_hash_sha256,
-                       :crypto_hash_sha256_ref,
-                       [:pointer, :pointer, :long_long]
-
-    SHA512BYTES = 64
-    wrap_nacl_function :crypto_hash_sha512,
-                       :crypto_hash_sha512_ref,
-                       [:pointer, :pointer, :long_long]
-
-    CURVE25519_XSALSA20_POLY1305_PUBLICKEY_BYTES = 32
-    PUBLICKEYBYTES = CURVE25519_XSALSA20_POLY1305_PUBLICKEY_BYTES
-    CURVE25519_XSALSA20_POLY1305_SECRETKEY_BYTES = 32
-    SECRETKEYBYTES = CURVE25519_XSALSA20_POLY1305_SECRETKEY_BYTES
-    wrap_nacl_function :crypto_box_curve25519xsalsa20poly1305_keypair,
-                       :crypto_box_curve25519xsalsa20poly1305_ref_keypair,
-                       [:pointer, :pointer]
-
-    CURVE25519_XSALSA20_POLY1305_BOX_NONCEBYTES    = 24
-    NONCEBYTES     = CURVE25519_XSALSA20_POLY1305_BOX_NONCEBYTES
-    ZEROBYTES      = 32
-    BOXZEROBYTES   = 16
-    CURVE25519_XSALSA20_POLY1305_BOX_BEFORENMBYTES = 32
-
-    wrap_nacl_function :crypto_box_curve25519_xsalsa20_poly1305_beforenm,
-                       :crypto_box_curve25519xsalsa20poly1305_ref_beforenm,
-                       [:pointer, :pointer, :pointer]
-
-    wrap_nacl_function :crypto_box_curve25519_xsalsa20_poly1305_afternm,
-                       :crypto_box_curve25519xsalsa20poly1305_ref_afternm,
-                       [:pointer, :pointer, :long_long, :pointer, :pointer]
-
-    wrap_nacl_function :crypto_box_curve25519_xsalsa20_poly1305_open_afternm,
-                       :crypto_box_curve25519xsalsa20poly1305_ref_open_afternm,
-                       [:pointer, :pointer, :long_long, :pointer, :pointer]
-
-    XSALSA20_POLY1305_SECRETBOX_KEYBYTES   = 32
-    XSALSA20_POLY1305_SECRETBOX_NONCEBYTES = 24
-    wrap_nacl_function :crypto_secretbox_xsalsa20poly1305,
-                       :crypto_secretbox_xsalsa20poly1305_ref,
-                       [:pointer, :pointer, :long_long, :pointer, :pointer]
-
-    wrap_nacl_function :crypto_secretbox_xsalsa20poly1305_open,
-                       :crypto_secretbox_xsalsa20poly1305_ref_open,
-                       [:pointer, :pointer, :long_long, :pointer, :pointer]
-
-    HMACSHA512256_KEYBYTES = 32
-    HMACSHA512256_BYTES = 32
-    wrap_nacl_function :crypto_auth_hmacsha512256,
-                       :crypto_auth_hmacsha512256_ref,
-                       [:pointer, :pointer, :long_long, :pointer]
-    wrap_nacl_function :crypto_auth_hmacsha512256_verify,
-                       :crypto_auth_hmacsha512256_ref_verify,
-                       [:pointer, :pointer, :long_long, :pointer]
-
-    HMACSHA256_KEYBYTES = 32
-    HMACSHA256_BYTES = 32
-    wrap_nacl_function :crypto_auth_hmacsha256,
-                       :crypto_auth_hmacsha256_ref,
-                       [:pointer, :pointer, :long_long, :pointer]
-    wrap_nacl_function :crypto_auth_hmacsha256_verify,
-                       :crypto_auth_hmacsha256_ref_verify,
-                       [:pointer, :pointer, :long_long, :pointer]
-    
-    ONETIME_KEYBYTES = 32
-    ONETIME_BYTES = 16
-    wrap_nacl_function :crypto_auth_onetime,
-                       :crypto_onetimeauth_poly1305_ref,
-                       [:pointer, :pointer, :long_long, :pointer]
-    wrap_nacl_function :crypto_auth_onetime_verify,
-                       :crypto_onetimeauth_poly1305_ref_verify,
-                       [:pointer, :pointer, :long_long, :pointer]
-
-    wrap_nacl_function :random_bytes,
-                       :randombytes,
-                       [:pointer, :long_long]
-
-    wrap_nacl_function :crypto_verify_32,
-                       :crypto_verify_32_ref,
-                       [:pointer, :pointer]
-    wrap_nacl_function :crypto_verify_16,
-                       :crypto_verify_16_ref,
-                       [:pointer, :pointer]
-
-    ED25519_SIGNATUREBYTES   = 64
-    SIGNATUREBYTES           = ED25519_SIGNATUREBYTES
-    ED25519_SIGNINGKEY_BYTES = 64
-    ED25519_VERIFYKEY_BYTES  = 32
-    ED25519_SEED_BYTES       = 32
-    wrap_nacl_function :crypto_sign_ed25519_seed_keypair,
-                       :crypto_sign_ed25519_ref_seed_keypair,
-                       [:pointer, :pointer, :pointer]
-
-    wrap_nacl_function :crypto_sign_ed25519,
-                       :crypto_sign_ed25519_ref,
-                       [:pointer, :pointer, :pointer, :long_long, :pointer]
-
-    wrap_nacl_function :crypto_sign_ed25519_open,
-                       :crypto_sign_ed25519_ref_open,
-                       [:pointer, :pointer, :pointer, :long_long, :pointer]
-
-    ED25519_SCALARBYTES = 32
-    SCALARBYTES         = ED25519_SCALARBYTES
-
-    wrap_nacl_function :crypto_scalarmult_curve25519,
-                       :crypto_scalarmult_curve25519_ref,
-                       [:pointer, :pointer, :pointer]
-  end
-end