tweetnacl 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: deaf1ed99efeefb3138a1b0c78e43e7cb1c1699e
-  data.tar.gz: 73a15e0587d64171ef60723f879ed0f7e65631e8
+  metadata.gz: 3c1932fa8b635f8c885f09dc44235ddf4b8a0c82
+  data.tar.gz: 0b1a0d43b9f60f1885b20bde5b5916246601d872
 SHA512:
-  metadata.gz: 048804948082736c35a551cfe6c54a1756330f8603ac2bc4eef8f9c31fdf3c42b2a7a2c48775132a4a99d0e899136aa5ce8ba44e23718183f61d847f7d28e4bc
-  data.tar.gz: 378798dffd4d8761e4f43447379ae7a2c14acc26f1d01efded7cddd50c99dd97c283c5d934d8862a8a659e2cbbcd03ce1991bb277003da92a609c7c55b215e1d
+  metadata.gz: 3d29a42561260b81947f4988443a41233561f38b7169772d9d488ce7376b8f7d93e92601d3903b00df13cb35b65b2e887a4e1b939e893fa55a1af728705b0bb8
+  data.tar.gz: e3bfb32b5a80d8e3cbe83e9522fb2f37320683ce5b7e30c1c43c38e325465e0debd27323c3c2c03b5e7ce790e76001361543cb3bf5093eef0dd7e704aed6f802

data/.gitignore

@@ -1,2 +1,4 @@
 *.gem
 Gemfile.lock
+lib/tweetnacl.bundle
+tmp/

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Releases
 
-## UNRELEASED
+## UNRELEASED (0.4.0)
+
+## 0.3.0 - Aug 19th 2014
+
+* Added crypto\_sign\_key\_pair
+* Added crypto\_sign
+* Added crypto\_sign\_open
+* Added a CryptoBox class to the Ruby API
+* Added the C #define's to the Ruby API as constants under the TweetNacl module
 
 ## 0.2.0 
 

data/README.md

@@ -16,16 +16,58 @@ For a detailed explanation of TweetNaCl, [here's the research paper associated w
     input = "<text to cipher>"
     nonce = "<a 24-char string>"
 
-    @t = TweetNaCl.new
+    pk, sk = TweetNaCl.crypto_box_keypair # This generates a pair of public and secret keys
 
-    pk, sk = @t.crypto_box_keypair # This generates a pair of public and secret keys
+    cipher = TweetNaCl.crypto_box(input, nonce, pk, sk) # Encrypt !
 
-    cipher = @t.crypto_box(input, nonce, pk, sk) # Encrypt !
-
-    output = @t.crypto_box_open(cipher, nonce, pk, sk) # Decrypt!
+    output = TweetNaCl.crypto_box_open(cipher, nonce, pk, sk) # Decrypt!
 
     assert_equal input, output # They're the same !
 
+## RUBY API
+
+### KeyPair
+
+A KeyPair object represents a pair of public and secret keys. They are created
+with the `crypto_box_keypair` function call.
+
+    keypair = KeyPair.new
+
+One can also create a keypair with an existing tuple of keys like this:
+
+    keypair = KeyPair.new(["<public_key>","<private_key>"])
+
+
+### CryptoBox
+
+#### initialize / new (<optional: Keypair object>)
+A Cryptobox object contains all the methods required to sign, encrypt and verify
+messages. It is instantiated like so:
+
+    cb = CryptoBox.new(<Optional: KeyPair object>)
+
+if no KeyPair is given, `CryptoBox` will create a new one by calling `KeyPair.new`
+
+#### close(message, nonce)
+
+Closing a box requires a message and a nonce.
+
+    cb = CryptBox.new(keypair_to_encrypt)
+    cb.close("hello world", "<a 24-byte nonce>")
+
+#### open(box, nonce)
+
+Opening a box requires a closed box and a nonce.
+
+    [...]
+    closed_box = CryptBox.new(keypair_to_encrypt).tap do |b|
+      b.close("hello world", "<a 24-byte nonce>")
+    end
+
+    decryption_box = CryptBox.new(keypair_to_decrypt)
+    decryption_box.open(closed_box, "<a 24-byte nonce>")
+
+
 ## FUNCTIONS
 
 ### crypto_box_keypair
@@ -36,20 +78,65 @@ Generate a pair of public and secret keys.
 
 Encrypt and sign the input given the other parameters.
 
-### crypto_box_keypair(ciphered_message, nonce, public_key, secret_key)
+### crypto_box_open(ciphered_message, nonce, public_key, secret_key)
 
 Decrypt and verify the signature of the ciphered message given the other parameters.
 
+### crypto_secretbox(input, nonce, public_key)
+
+Encrypt the input given the other parameters.
+
+### crypto_secretbox_open(ciphered_message, nonce, public_key)
+
+Decrypt the ciphered message given the other parameters.
+
+### crypto_sign_keypair
+
+Generate a pair of public and secret keys.
+
+### crypto_sign(message, secret_key)
+
+Sign a message with a secret key.
+
+### crypto_sign_open(message, public_key)
+
+Verify the signature in message with a public key.
+
+
 ## TODO
 
+### Raw C-API
+* [x] crypto_box (aliased crypto_box_curve25519xsalsa20poly1305)
+* [x] crypto_box_open (aliased crypto_box_curve25519xsalsa20poly1305_open)
 * [x] crypto_box_keypair
-* [x] crypto_box
-* [x] crypto_box_open
-* [x] crypto_box_curve25519xsalsa20poly1305_keypair
-* [x] crypto_box_curve25519xsalsa20poly1305
-* [x] crypto_box_curve25519xsalsa20poly1305_open
-* [ ] All the other functions !
-* [ ] Use high-level objects
+* [ ] crypto_box_beforenm
+* [ ] crypto_box_afternm
+* [ ] crypto_box_open_afternm
+* [ ] crypto_core_salsa20
+* [ ] crypto_core_hsalsa20
+* [ ] crypto_hashblocks = crypto_hashblocks_sha512
+* [ ] crypto_hash = crypto_hash_sha512
+* [ ] crypto_onetimeauth = crypto_onetimeauth_poly1305
+* [ ] crypto_onetimeauth_verify
+* [ ] crypto_scalarmult = crypto_scalarmult_curve25519
+* [ ] crypto_scalarmult_base
+* [x] crypto_secretbox (aliased crypto_secretbox_xsalsa20poly1305)
+* [x] crypto_secretbox_open (aliased crypto_secretbox_xsalsa20poly1305_open)
+* [x] crypto_sign = crypto_sign_ed25519
+* [x] crypto_sign_open
+* [x] crypto_sign_keypair
+* [ ] crypto_stream = crypto_stream_xsalsa20
+* [ ] crypto_stream_xor
+* [ ] crypto_stream_salsa20
+* [ ] crypto_stream_salsa20_xor
+* [ ] crypto_verify_16
+* [ ] crypto_verify_32
+* [ ] USDT / probes
+
+### Ruby API
+
+* [x] CryptoBox object
+* [x] CryptoSign object
 
 ## Is it PRODUCTION-READY?
 

data/Rakefile

@@ -7,7 +7,7 @@ end
 require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.pattern = "test/*_test.rb"
+  t.pattern = "test/**/*_test.rb"
   t.verbose = true
   t.warning = true
 end

data/ext/tweetnacl/rbext.c

@@ -1,22 +1,8 @@
-#include <ruby.h>
+#include <ruby/ruby.h>
 #include <ruby/encoding.h>
 #include "tweetnacl.h"
 #define PADDING_LEN 32
 
-typedef struct {
-} TweetNaCl;
-
-static void tweetnacl_free() {
-}
-
-static VALUE tweetnacl_alloc(VALUE klass) {
-  return Data_Wrap_Struct(klass, NULL, tweetnacl_free, ruby_xmalloc(sizeof(TweetNaCl)));
-}
-
-static VALUE tweetnacl_init(VALUE self) {
-  return Qnil;
-}
-
 void hexdump(char * data, int len)
 {
   int i;
@@ -28,11 +14,13 @@ void hexdump(char * data, int len)
 
 VALUE m_crypto_box_keypair(VALUE self) {
   VALUE ary = rb_ary_new2(2);
-  char *pk = calloc(crypto_box_PUBLICKEYBYTES, sizeof(unsigned char));
-  char *sk = calloc(crypto_box_SECRETKEYBYTES, sizeof(unsigned char));
+  unsigned char *pk = calloc(crypto_box_PUBLICKEYBYTES, sizeof(unsigned char));
+  unsigned char *sk = calloc(crypto_box_SECRETKEYBYTES, sizeof(unsigned char));
+
   int res = crypto_box_keypair(pk, sk);
-  pk[crypto_box_PUBLICKEYBYTES] = 0;
-  sk[crypto_box_SECRETKEYBYTES] = 0;
+  // TODO: use an exception instead of exit()
+  if (0 != res) { rb_raise(rb_eRuntimeError, "crypto_box_keypair did not work. error %d\n", res); }
+
   rb_ary_store(ary, 0, rb_str_new(pk, crypto_box_PUBLICKEYBYTES));
   rb_ary_store(ary, 1, rb_str_new(sk, crypto_box_SECRETKEYBYTES));
   return ary;
@@ -40,6 +28,7 @@ VALUE m_crypto_box_keypair(VALUE self) {
 
 VALUE m_crypto_box(VALUE self, VALUE _m, VALUE _n, VALUE _pk, VALUE _sk) {
   if(_m == Qnil) { rb_raise(rb_eArgError, "A message should have been given"); }
+  if(_n == Qnil) { rb_raise(rb_eArgError, "A nonce should have been given"); }
   if(_pk == Qnil) { rb_raise(rb_eArgError, "Public key should have been given"); }
   if(_sk == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
   if (RSTRING_LEN(_n)  != 24) { rb_raise(rb_eArgError, "nonce should be 24-byte long"); }
@@ -55,6 +44,7 @@ VALUE m_crypto_box(VALUE self, VALUE _m, VALUE _n, VALUE _pk, VALUE _sk) {
   memcpy(padded_message + PADDING_LEN, message, strlen(message));
   char * c = malloc(strlen(message) + PADDING_LEN);
   int res = crypto_box(c, padded_message, len + PADDING_LEN, nonce, pk, sk);
+  // TODO: use an exception instead of exit()
   if (0 != res) { fprintf(stderr, "Something went wrong\n"); exit(res); }
   VALUE ret = rb_str_new(c, len + PADDING_LEN);
   return ret;
@@ -62,89 +52,298 @@ VALUE m_crypto_box(VALUE self, VALUE _m, VALUE _n, VALUE _pk, VALUE _sk) {
 
 VALUE m_crypto_box_open(VALUE self, VALUE _c, VALUE _n, VALUE _pk, VALUE _sk) {
   if(_c == Qnil) { rb_raise(rb_eArgError, "A cipher should have been given"); }
+  if(_n == Qnil) { rb_raise(rb_eArgError, "A nonce should have been given"); }
   if(_pk == Qnil) { rb_raise(rb_eArgError, "Public key should have been given"); }
   if(_sk == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
-  if (RSTRING_LEN(_n)  != 24) { rb_raise(rb_eArgError, "nonce should be 24-byte long"); }
-  if (RSTRING_LEN(_pk) != 32) { rb_raise(rb_eArgError, "public key should be 24-byte long"); }
-  if (RSTRING_LEN(_sk) != 32) { rb_raise(rb_eArgError, "secret key should be 24-byte long"); }
+  if (RSTRING_LEN(_n)  != crypto_box_NONCEBYTES)     { rb_raise(rb_eArgError, "nonce should be %d-byte long", crypto_box_NONCEBYTES); }
+  if (RSTRING_LEN(_pk) != crypto_box_PUBLICKEYBYTES) { rb_raise(rb_eArgError, "public key should be %d-byte long", crypto_box_PUBLICKEYBYTES); }
+  if (RSTRING_LEN(_sk) != crypto_box_SECRETKEYBYTES) { rb_raise(rb_eArgError, "secret key should be %d-byte long", crypto_box_SECRETKEYBYTES); }
 
   unsigned char * c = RSTRING_PTR(_c);
   char * nonce = RSTRING_PTR(_n);
   char * pk = RSTRING_PTR(_pk);
   char * sk = RSTRING_PTR(_sk);
   int padded_mlen = rb_str_strlen(_c);
-  char * message = calloc(padded_mlen, sizeof(char));
+  unsigned char * message = (unsigned char*)calloc(padded_mlen, sizeof(unsigned char));
 
   int res = crypto_box_open(message, c, padded_mlen, nonce, pk, sk);
-  if (0 != res) { rb_raise(rb_eRuntimeError, "crypto_box_open did not work"); }
+  if (0 != res) { rb_raise(rb_eRuntimeError, "crypto_box_open did not work. error %d", res); }
 
-  return rb_str_new2(message + PADDING_LEN);
-}
+  message[padded_mlen + 1] = 0;
 
-VALUE m_crypto_box_curve25519xsalsa20poly1305_keypair(VALUE self) {
-  VALUE ary = rb_ary_new2(2);
-  char *pk = calloc(crypto_box_curve25519xsalsa20poly1305_tweet_PUBLICKEYBYTES, sizeof(unsigned char));
-  char *sk = calloc(crypto_box_curve25519xsalsa20poly1305_tweet_SECRETKEYBYTES, sizeof(unsigned char));
-  int res = crypto_box_curve25519xsalsa20poly1305_keypair(pk, sk);
-  pk[crypto_box_curve25519xsalsa20poly1305_tweet_PUBLICKEYBYTES] = 0;
-  sk[crypto_box_curve25519xsalsa20poly1305_tweet_SECRETKEYBYTES] = 0;
-  rb_ary_store(ary, 0, rb_str_new(pk, crypto_box_curve25519xsalsa20poly1305_tweet_PUBLICKEYBYTES));
-  rb_ary_store(ary, 1, rb_str_new(sk, crypto_box_curve25519xsalsa20poly1305_tweet_SECRETKEYBYTES));
-  return ary;
+  VALUE ret = rb_str_new2(message + PADDING_LEN);
+  return ret;
 }
 
-VALUE m_crypto_box_curve25519xsalsa20poly1305(VALUE self, VALUE _m, VALUE _n, VALUE _pk, VALUE _sk) {
+VALUE m_crypto_secretbox(VALUE self, VALUE _m, VALUE _n, VALUE _k) {
   if(_m == Qnil) { rb_raise(rb_eArgError, "A message should have been given"); }
-  if(_pk == Qnil) { rb_raise(rb_eArgError, "Public key should have been given"); }
-  if(_sk == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
+  if(_k == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
   if (RSTRING_LEN(_n)  != 24) { rb_raise(rb_eArgError, "nonce should be 24-byte long"); }
-  if (RSTRING_LEN(_pk) != 32) { rb_raise(rb_eArgError, "public key should be 24-byte long"); }
-  if (RSTRING_LEN(_sk) != 32) { rb_raise(rb_eArgError, "secret key should be 24-byte long"); }
+  if (RSTRING_LEN(_k) != 32) { rb_raise(rb_eArgError, "Secret key should be 24-byte long"); }
 
   char * message = RSTRING_PTR(_m);
   char * nonce = RSTRING_PTR(_n);
-  char * pk = RSTRING_PTR(_pk);
-  char * sk = RSTRING_PTR(_sk);
+  char * k = RSTRING_PTR(_k);
   int len = strlen(message);
   char * padded_message = (char*)calloc(sizeof(char), len + PADDING_LEN);
   memcpy(padded_message + PADDING_LEN, message, strlen(message));
   char * c = malloc(strlen(message) + PADDING_LEN);
-  int res = crypto_box_curve25519xsalsa20poly1305(c, padded_message, len + PADDING_LEN, nonce, pk, sk);
+  int res = crypto_secretbox(c, padded_message, len + PADDING_LEN, nonce, k);
+  // TODO: use an exception instead of exit()
   if (0 != res) { fprintf(stderr, "Something went wrong\n"); exit(res); }
   VALUE ret = rb_str_new(c, len + PADDING_LEN);
   return ret;
 }
 
-VALUE m_crypto_box_curve25519xsalsa20poly1305_open(VALUE self, VALUE _c, VALUE _n, VALUE _pk, VALUE _sk) {
+VALUE m_crypto_secretbox_open(VALUE self, VALUE _c, VALUE _n, VALUE _k) {
   if(_c == Qnil) { rb_raise(rb_eArgError, "A cipher should have been given"); }
-  if(_pk == Qnil) { rb_raise(rb_eArgError, "Public key should have been given"); }
-  if(_sk == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
+  if(_k == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
   if (RSTRING_LEN(_n)  != 24) { rb_raise(rb_eArgError, "nonce should be 24-byte long"); }
-  if (RSTRING_LEN(_pk) != 32) { rb_raise(rb_eArgError, "public key should be 24-byte long"); }
-  if (RSTRING_LEN(_sk) != 32) { rb_raise(rb_eArgError, "secret key should be 24-byte long"); }
+  if (RSTRING_LEN(_k) != 32) { rb_raise(rb_eArgError, "secret key should be 24-byte long"); }
 
   unsigned char * c = RSTRING_PTR(_c);
   char * nonce = RSTRING_PTR(_n);
-  char * pk = RSTRING_PTR(_pk);
-  char * sk = RSTRING_PTR(_sk);
+  char * k = RSTRING_PTR(_k);
   int padded_mlen = rb_str_strlen(_c);
   char * message = calloc(padded_mlen, sizeof(char));
 
-  int res = crypto_box_curve25519xsalsa20poly1305_open(message, c, padded_mlen, nonce, pk, sk);
-  if (0 != res) { rb_raise(rb_eRuntimeError, "crypto_box_open did not work"); }
+  int res = crypto_secretbox_open(message, c, padded_mlen, nonce, k);
+  if (0 != res) { rb_raise(rb_eRuntimeError, "crypto_secretbox_open did not work"); }
 
   return rb_str_new2(message + PADDING_LEN);
 }
 
+VALUE m_crypto_sign_keypair(VALUE self) {
+  VALUE ary = rb_ary_new2(2);
+  unsigned char *pk = (unsigned char*)calloc(crypto_sign_PUBLICKEYBYTES, sizeof(unsigned char));
+  unsigned char *sk = (unsigned char*)calloc(crypto_sign_SECRETKEYBYTES, sizeof(unsigned char));
+  int res = crypto_sign_keypair(pk, sk);
+  pk[crypto_sign_PUBLICKEYBYTES] = 0;
+  sk[crypto_sign_SECRETKEYBYTES] = 0;
+  rb_ary_store(ary, 0, rb_str_new(pk, crypto_sign_PUBLICKEYBYTES));
+  rb_ary_store(ary, 1, rb_str_new(sk, crypto_sign_SECRETKEYBYTES));
+  return ary;
+}
+
+VALUE m_crypto_sign(VALUE self, VALUE _m, VALUE _k) {
+  if(_m == Qnil) { rb_raise(rb_eArgError, "A message should have been given"); }
+  if(_k == Qnil) { rb_raise(rb_eArgError, "Secret key should have been given"); }
+  if (RSTRING_LEN(_k) != crypto_sign_SECRETKEYBYTES) { rb_raise(rb_eArgError, "Secret key should be %d-byte long", crypto_sign_SECRETKEYBYTES); }
+
+  unsigned char * message = RSTRING_PTR(_m);
+  int len = rb_str_strlen(_m);
+  unsigned char * c = (unsigned char*)calloc(sizeof(unsigned char), len + crypto_sign_BYTES);
+  char * k = RSTRING_PTR(_k);
+  unsigned long long int smlen = 0;
+
+  int res = crypto_sign(c, &smlen, message, len, k);
+  // TODO: use an exception instead of exit()
+  if (0 != res) { fprintf(stderr, "crypto_sign did not work\n"); exit(res); }
+  VALUE ret = rb_str_new(c, smlen);
+  return ret;
+}
+
+VALUE m_crypto_sign_open(VALUE self, VALUE _c, VALUE _k) {
+  if(_c == Qnil) { rb_raise(rb_eArgError, "A message should have been given"); }
+  if(_k == Qnil) { rb_raise(rb_eArgError, "Public key should have been given"); }
+  if (RSTRING_LEN(_k) != crypto_sign_PUBLICKEYBYTES) { rb_raise(rb_eArgError, "public key should be %d-byte long", crypto_sign_PUBLICKEYBYTES); }
+
+  unsigned char * cipher = RSTRING_PTR(_c);
+  int len = rb_str_strlen(_c);
+  unsigned char * message = (unsigned char*)calloc(sizeof(unsigned char), len + 1);
+  char * k = RSTRING_PTR(_k);
+  unsigned long long int mlen = 0;
+
+  int res = crypto_sign_open(message, &mlen, cipher, len, k);
+  message[len] = 0;
+  if (0 != res) { rb_raise(rb_eRuntimeError, "crypto_sign_open did not work. error %d\n", res); }
+  VALUE ret = rb_str_new(message, mlen);
+  return ret;
+}
+
+
 void Init_tweetnacl() {
-  VALUE c = rb_define_class("TweetNaCl", rb_cObject);
-
-  rb_define_alloc_func(c, tweetnacl_alloc);
-  rb_define_private_method(c, "initialize", RUBY_METHOD_FUNC(tweetnacl_init), 0);
-  rb_define_method(c, "crypto_box_keypair", RUBY_METHOD_FUNC(m_crypto_box_keypair), 0);
-  rb_define_method(c, "crypto_box", RUBY_METHOD_FUNC(m_crypto_box), 4);
-  rb_define_method(c, "crypto_box_open", RUBY_METHOD_FUNC(m_crypto_box_open), 4);
-  rb_define_method(c, "crypto_box_curve25519xsalsa20poly1305_keypair", RUBY_METHOD_FUNC(m_crypto_box_curve25519xsalsa20poly1305_keypair), 0);
-  rb_define_method(c, "crypto_box_curve25519xsalsa20poly1305", RUBY_METHOD_FUNC(m_crypto_box_curve25519xsalsa20poly1305), 4);
-  rb_define_method(c, "crypto_box_curve25519xsalsa20poly1305_open", RUBY_METHOD_FUNC(m_crypto_box_curve25519xsalsa20poly1305_open), 4);
+  VALUE c = rb_define_module("TweetNaCl");
+
+  rb_define_module_function(c , "crypto_box_keypair"                         , RUBY_METHOD_FUNC(m_crypto_box_keypair)    , 0);
+
+  rb_define_module_function(c , "crypto_box"                                 , RUBY_METHOD_FUNC(m_crypto_box)            , 4);
+  rb_define_module_function(c , "crypto_box_open"                            , RUBY_METHOD_FUNC(m_crypto_box_open)       , 4);
+  rb_define_module_function(c , "crypto_box_curve25519xsalsa20poly1305"      , RUBY_METHOD_FUNC(m_crypto_box)            , 4);
+  rb_define_module_function(c , "crypto_box_curve25519xsalsa20poly1305_open" , RUBY_METHOD_FUNC(m_crypto_box_open)       , 4);
+
+  rb_define_module_function(c , "crypto_secretbox"                           , RUBY_METHOD_FUNC(m_crypto_secretbox)      , 3);
+  rb_define_module_function(c , "crypto_secretbox_open"                      , RUBY_METHOD_FUNC(m_crypto_secretbox_open) , 3);
+  rb_define_module_function(c , "crypto_secretbox_xsalsa20poly1305"          , RUBY_METHOD_FUNC(m_crypto_secretbox)      , 3);
+  rb_define_module_function(c , "crypto_secretbox_xsalsa20poly1305_open"     , RUBY_METHOD_FUNC(m_crypto_secretbox_open) , 3);
+
+  rb_define_module_function(c , "crypto_sign_keypair"                        , RUBY_METHOD_FUNC(m_crypto_sign_keypair)   , 0);
+
+  rb_define_module_function(c , "crypto_sign"                                , RUBY_METHOD_FUNC(m_crypto_sign)           , 2);
+  rb_define_module_function(c , "crypto_sign_ed25519"                        , RUBY_METHOD_FUNC(m_crypto_sign)           , 2);
+  rb_define_module_function(c , "crypto_sign_open"                           , RUBY_METHOD_FUNC(m_crypto_sign_open)      , 2);
+  rb_define_module_function(c , "crypto_sign_ed25519_open"                   , RUBY_METHOD_FUNC(m_crypto_sign_open)      , 2);
+
+  rb_define_const(c , "CRYPTO_AUTH_PRIMITIVE"                                      , rb_str_new2("hmacsha512256"));
+  rb_define_const(c , "CRYPTO_AUTH_BYTES"                                          , INT2NUM(crypto_auth_hmacsha512256_BYTES));
+  rb_define_const(c , "CRYPTO_AUTH_KEYBYTES"                                       , INT2NUM(crypto_auth_hmacsha512256_KEYBYTES));
+  rb_define_const(c , "CRYPTO_AUTH_IMPLEMENTATION"                                 , rb_str_new2(crypto_auth_hmacsha512256_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_AUTH_VERSION"                                        , rb_str_new2(crypto_auth_hmacsha512256_VERSION));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_TWEET_BYTES"                      , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_TWEET_KEYBYTES"                   , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_TWEET_VERSION"                    , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_BYTES"                            , INT2NUM(crypto_auth_hmacsha512256_tweet_BYTES));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_KEYBYTES"                         , INT2NUM(crypto_auth_hmacsha512256_tweet_KEYBYTES));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_VERSION"                          , rb_str_new2(crypto_auth_hmacsha512256_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_AUTH_HMACSHA512256_IMPLEMENTATION"                   , rb_str_new2("crypto_auth/hmacsha512256/tweet"));
+  rb_define_const(c , "CRYPTO_BOX_PRIMITIVE"                                       , rb_str_new2("curve25519xsalsa20poly1305"));
+  rb_define_const(c , "CRYPTO_BOX_PUBLICKEYBYTES"                                  , INT2NUM(crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES));
+  rb_define_const(c , "CRYPTO_BOX_SECRETKEYBYTES"                                  , INT2NUM(crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES));
+  rb_define_const(c , "CRYPTO_BOX_BEFORENMBYTES"                                   , INT2NUM(crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES));
+  rb_define_const(c , "CRYPTO_BOX_NONCEBYTES"                                      , INT2NUM(crypto_box_curve25519xsalsa20poly1305_NONCEBYTES));
+  rb_define_const(c , "CRYPTO_BOX_ZEROBYTES"                                       , INT2NUM(crypto_box_curve25519xsalsa20poly1305_ZEROBYTES));
+  rb_define_const(c , "CRYPTO_BOX_BOXZEROBYTES"                                    , INT2NUM(crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES));
+  rb_define_const(c , "CRYPTO_BOX_IMPLEMENTATION"                                  , rb_str_new2(crypto_box_curve25519xsalsa20poly1305_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_BOX_VERSION"                                         , rb_str_new2(crypto_box_curve25519xsalsa20poly1305_VERSION));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_PUBLICKEYBYTES" , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_SECRETKEYBYTES" , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_BEFORENMBYTES"  , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_NONCEBYTES"     , INT2NUM(24));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_ZEROBYTES"      , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_BOXZEROBYTES"   , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_TWEET_VERSION"        , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_PUBLICKEYBYTES"       , INT2NUM(crypto_box_curve25519xsalsa20poly1305_tweet_PUBLICKEYBYTES));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_SECRETKEYBYTES"       , INT2NUM(crypto_box_curve25519xsalsa20poly1305_tweet_SECRETKEYBYTES));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_BEFORENMBYTES"        , INT2NUM(crypto_box_curve25519xsalsa20poly1305_tweet_BEFORENMBYTES));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_NONCEBYTES"           , INT2NUM(crypto_box_curve25519xsalsa20poly1305_tweet_NONCEBYTES));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_ZEROBYTES"            , INT2NUM(crypto_box_curve25519xsalsa20poly1305_tweet_ZEROBYTES));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_BOXZEROBYTES"         , INT2NUM(crypto_box_curve25519xsalsa20poly1305_tweet_BOXZEROBYTES));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_VERSION"              , rb_str_new2(crypto_box_curve25519xsalsa20poly1305_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_BOX_CURVE25519XSALSA20POLY1305_IMPLEMENTATION"       , rb_str_new2("crypto_box/curve25519xsalsa20poly1305/tweet"));
+  rb_define_const(c , "CRYPTO_CORE_PRIMITIVE"                                      , rb_str_new2("salsa20"));
+  rb_define_const(c , "CRYPTO_CORE_OUTPUTBYTES"                                    , INT2NUM(crypto_core_salsa20_OUTPUTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_INPUTBYTES"                                     , INT2NUM(crypto_core_salsa20_INPUTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_KEYBYTES"                                       , INT2NUM(crypto_core_salsa20_KEYBYTES));
+  rb_define_const(c , "CRYPTO_CORE_CONSTBYTES"                                     , INT2NUM(crypto_core_salsa20_CONSTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_IMPLEMENTATION"                                 , rb_str_new2(crypto_core_salsa20_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_CORE_VERSION"                                        , rb_str_new2(crypto_core_salsa20_VERSION));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_TWEET_OUTPUTBYTES"                      , INT2NUM(64));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_TWEET_INPUTBYTES"                       , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_TWEET_KEYBYTES"                         , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_TWEET_CONSTBYTES"                       , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_TWEET_VERSION"                          , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_OUTPUTBYTES"                            , INT2NUM(crypto_core_salsa20_tweet_OUTPUTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_INPUTBYTES"                             , INT2NUM(crypto_core_salsa20_tweet_INPUTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_KEYBYTES"                               , INT2NUM(crypto_core_salsa20_tweet_KEYBYTES));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_CONSTBYTES"                             , INT2NUM(crypto_core_salsa20_tweet_CONSTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_VERSION"                                , rb_str_new2(crypto_core_salsa20_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_CORE_SALSA20_IMPLEMENTATION"                         , rb_str_new2("crypto_core/salsa20/tweet"));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_TWEET_OUTPUTBYTES"                     , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_TWEET_INPUTBYTES"                      , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_TWEET_KEYBYTES"                        , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_TWEET_CONSTBYTES"                      , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_TWEET_VERSION"                         , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_OUTPUTBYTES"                           , INT2NUM(crypto_core_hsalsa20_tweet_OUTPUTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_INPUTBYTES"                            , INT2NUM(crypto_core_hsalsa20_tweet_INPUTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_KEYBYTES"                              , INT2NUM(crypto_core_hsalsa20_tweet_KEYBYTES));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_CONSTBYTES"                            , INT2NUM(crypto_core_hsalsa20_tweet_CONSTBYTES));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_VERSION"                               , rb_str_new2(crypto_core_hsalsa20_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_CORE_HSALSA20_IMPLEMENTATION"                        , rb_str_new2("crypto_core/hsalsa20/tweet"));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_PRIMITIVE"                                , rb_str_new2("sha512"));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_STATEBYTES"                               , INT2NUM(crypto_hashblocks_sha512_STATEBYTES));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_BLOCKBYTES"                               , INT2NUM(crypto_hashblocks_sha512_BLOCKBYTES));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_IMPLEMENTATION"                           , rb_str_new2(crypto_hashblocks_sha512_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_VERSION"                                  , rb_str_new2(crypto_hashblocks_sha512_VERSION));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_TWEET_STATEBYTES"                  , INT2NUM(64));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_TWEET_BLOCKBYTES"                  , INT2NUM(128));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_TWEET_VERSION"                     , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_STATEBYTES"                        , INT2NUM(crypto_hashblocks_sha512_tweet_STATEBYTES));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_BLOCKBYTES"                        , INT2NUM(crypto_hashblocks_sha512_tweet_BLOCKBYTES));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_VERSION"                           , rb_str_new2(crypto_hashblocks_sha512_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA512_IMPLEMENTATION"                    , rb_str_new2("crypto_hashblocks/sha512/tweet"));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_TWEET_STATEBYTES"                  , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_TWEET_BLOCKBYTES"                  , INT2NUM(64));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_TWEET_VERSION"                     , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_STATEBYTES"                        , INT2NUM(crypto_hashblocks_sha256_tweet_STATEBYTES));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_BLOCKBYTES"                        , INT2NUM(crypto_hashblocks_sha256_tweet_BLOCKBYTES));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_VERSION"                           , rb_str_new2(crypto_hashblocks_sha256_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_HASHBLOCKS_SHA256_IMPLEMENTATION"                    , rb_str_new2("crypto_hashblocks/sha256/tweet"));
+  rb_define_const(c , "CRYPTO_HASH_PRIMITIVE"                                      , rb_str_new2("sha512"));
+  rb_define_const(c , "CRYPTO_HASH_BYTES"                                          , INT2NUM(crypto_hash_sha512_BYTES));
+  rb_define_const(c , "CRYPTO_HASH_IMPLEMENTATION"                                 , rb_str_new2(crypto_hash_sha512_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_HASH_VERSION"                                        , rb_str_new2(crypto_hash_sha512_VERSION));
+  rb_define_const(c , "CRYPTO_HASH_SHA512_TWEET_BYTES"                             , INT2NUM(64));
+  rb_define_const(c , "CRYPTO_HASH_SHA512_TWEET_VERSION"                           , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_HASH_SHA512_BYTES"                                   , INT2NUM(crypto_hash_sha512_tweet_BYTES));
+  rb_define_const(c , "CRYPTO_HASH_SHA512_VERSION"                                 , rb_str_new2(crypto_hash_sha512_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_HASH_SHA512_IMPLEMENTATION"                          , rb_str_new2("crypto_hash/sha512/tweet"));
+  rb_define_const(c , "CRYPTO_HASH_SHA256_TWEET_BYTES"                             , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_HASH_SHA256_TWEET_VERSION"                           , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_HASH_SHA256_BYTES"                                   , INT2NUM(crypto_hash_sha256_tweet_BYTES));
+  rb_define_const(c , "CRYPTO_HASH_SHA256_VERSION"                                 , rb_str_new2(crypto_hash_sha256_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_HASH_SHA256_IMPLEMENTATION"                          , rb_str_new2("crypto_hash/sha256/tweet"));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_PRIMITIVE"                               , rb_str_new2("poly1305"));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_BYTES"                                   , INT2NUM(crypto_onetimeauth_poly1305_BYTES));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_KEYBYTES"                                , INT2NUM(crypto_onetimeauth_poly1305_KEYBYTES));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_IMPLEMENTATION"                          , rb_str_new2(crypto_onetimeauth_poly1305_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_VERSION"                                 , rb_str_new2(crypto_onetimeauth_poly1305_VERSION));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_TWEET_BYTES"                    , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_TWEET_KEYBYTES"                 , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_TWEET_VERSION"                  , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_BYTES"                          , INT2NUM(crypto_onetimeauth_poly1305_tweet_BYTES));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_KEYBYTES"                       , INT2NUM(crypto_onetimeauth_poly1305_tweet_KEYBYTES));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_VERSION"                        , rb_str_new2(crypto_onetimeauth_poly1305_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_ONETIMEAUTH_POLY1305_IMPLEMENTATION"                 , rb_str_new2("crypto_onetimeauth/poly1305/tweet"));
+  rb_define_const(c , "CRYPTO_SCALARMULT_PRIMITIVE"                                , rb_str_new2("curve25519"));
+  rb_define_const(c , "CRYPTO_SCALARMULT_BYTES"                                    , INT2NUM(crypto_scalarmult_curve25519_BYTES));
+  rb_define_const(c , "CRYPTO_SCALARMULT_SCALARBYTES"                              , INT2NUM(crypto_scalarmult_curve25519_SCALARBYTES));
+  rb_define_const(c , "CRYPTO_SCALARMULT_IMPLEMENTATION"                           , rb_str_new2(crypto_scalarmult_curve25519_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_SCALARMULT_VERSION"                                  , rb_str_new2(crypto_scalarmult_curve25519_VERSION));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_TWEET_BYTES"                   , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_TWEET_SCALARBYTES"             , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_TWEET_VERSION"                 , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_BYTES"                         , INT2NUM(crypto_scalarmult_curve25519_tweet_BYTES));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_SCALARBYTES"                   , INT2NUM(crypto_scalarmult_curve25519_tweet_SCALARBYTES));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_VERSION"                       , rb_str_new2(crypto_scalarmult_curve25519_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_SCALARMULT_CURVE25519_IMPLEMENTATION"                , rb_str_new2("crypto_scalarmult/curve25519/tweet"));
+  rb_define_const(c , "CRYPTO_SECRETBOX_PRIMITIVE"                                 , rb_str_new2("xsalsa20poly1305"));
+  rb_define_const(c , "CRYPTO_SECRETBOX_KEYBYTES"                                  , INT2NUM(crypto_secretbox_xsalsa20poly1305_KEYBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_NONCEBYTES"                                , INT2NUM(crypto_secretbox_xsalsa20poly1305_NONCEBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_ZEROBYTES"                                 , INT2NUM(crypto_secretbox_xsalsa20poly1305_ZEROBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_BOXZEROBYTES"                              , INT2NUM(crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_IMPLEMENTATION"                            , rb_str_new2(crypto_secretbox_xsalsa20poly1305_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_SECRETBOX_VERSION"                                   , rb_str_new2(crypto_secretbox_xsalsa20poly1305_VERSION));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_KEYBYTES"           , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_NONCEBYTES"         , INT2NUM(24));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_ZEROBYTES"          , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_BOXZEROBYTES"       , INT2NUM(16));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_TWEET_VERSION"            , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_KEYBYTES"                 , INT2NUM(crypto_secretbox_xsalsa20poly1305_tweet_KEYBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_NONCEBYTES"               , INT2NUM(crypto_secretbox_xsalsa20poly1305_tweet_NONCEBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_ZEROBYTES"                , INT2NUM(crypto_secretbox_xsalsa20poly1305_tweet_ZEROBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_BOXZEROBYTES"             , INT2NUM(crypto_secretbox_xsalsa20poly1305_tweet_BOXZEROBYTES));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_VERSION"                  , rb_str_new2(crypto_secretbox_xsalsa20poly1305_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_SECRETBOX_XSALSA20POLY1305_IMPLEMENTATION"           , rb_str_new2("crypto_secretbox/xsalsa20poly1305/tweet"));
+  rb_define_const(c , "CRYPTO_SIGN_PRIMITIVE"                                      , rb_str_new2("ed25519"));
+  rb_define_const(c , "CRYPTO_SIGN_BYTES"                                          , INT2NUM(crypto_sign_ed25519_BYTES));
+  rb_define_const(c , "CRYPTO_SIGN_PUBLICKEYBYTES"                                 , INT2NUM(crypto_sign_ed25519_PUBLICKEYBYTES));
+  rb_define_const(c , "CRYPTO_SIGN_SECRETKEYBYTES"                                 , INT2NUM(crypto_sign_ed25519_SECRETKEYBYTES));
+  rb_define_const(c , "CRYPTO_SIGN_IMPLEMENTATION"                                 , rb_str_new2(crypto_sign_ed25519_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_SIGN_VERSION"                                        , rb_str_new2(crypto_sign_ed25519_VERSION));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_TWEET_BYTES"                            , INT2NUM(64));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_TWEET_PUBLICKEYBYTES"                   , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_TWEET_SECRETKEYBYTES"                   , INT2NUM(64));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_TWEET_VERSION"                          , rb_str_new2("-"));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_BYTES"                                  , INT2NUM(crypto_sign_ed25519_tweet_BYTES));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_PUBLICKEYBYTES"                         , INT2NUM(crypto_sign_ed25519_tweet_PUBLICKEYBYTES));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_SECRETKEYBYTES"                         , INT2NUM(crypto_sign_ed25519_tweet_SECRETKEYBYTES));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_VERSION"                                , rb_str_new2(crypto_sign_ed25519_tweet_VERSION));
+  rb_define_const(c , "CRYPTO_SIGN_ED25519_IMPLEMENTATION"                         , rb_str_new2("crypto_sign/ed25519/tweet"));
+  rb_define_const(c , "CRYPTO_STREAM_PRIMITIVE"                                    , rb_str_new2("xsalsa20"));
+  rb_define_const(c , "CRYPTO_STREAM_KEYBYTES"                                     , INT2NUM(crypto_stream_xsalsa20_KEYBYTES));
+  rb_define_const(c , "CRYPTO_STREAM_NONCEBYTES"                                   , INT2NUM(crypto_stream_xsalsa20_NONCEBYTES));
+  rb_define_const(c , "CRYPTO_STREAM_IMPLEMENTATION"                               , rb_str_new2(crypto_stream_xsalsa20_IMPLEMENTATION));
+  rb_define_const(c , "CRYPTO_STREAM_VERSION"                                      , rb_str_new2(crypto_stream_xsalsa20_VERSION));
+  rb_define_const(c , "CRYPTO_STREAM_XSALSA20_TWEET_KEYBYTES"                      , INT2NUM(32));
+  rb_define_const(c , "CRYPTO_STREAM_XSALSA20_TWEET_NONCEBYTES"                    , INT2NUM(24));
 }