blake2 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4250cbe6cd64da1a6b5a975ad4723dc257cb08b3
-  data.tar.gz: 06f89ae5b24e3a63536cf7718490c12624e0b05b
+  metadata.gz: ebb3461da94a57c4dd9ebeaed5555d4b11b0d720
+  data.tar.gz: 3784c55e622aa55dd12d07b5e7eb95c3271e73cb
 SHA512:
-  metadata.gz: 6c963fd93b7772aa6c39e476b635568b10d521959b67b8d6ee1019707b2a18e3c66c9b09c2047f009785caf47fac9069ce40669fde646909fbceeac3a564e00a
-  data.tar.gz: 37fefa3f64d105717495ac62c10a12b3f85e551146c8d455be2d0e3577a41e3cc2fdd7d8cc21b27cc80ef8bcd0df71556c2f2a007bb01dc6fa46edf5873adf6b
+  metadata.gz: c55e7c376319578fe76410cb85dfa2f0e9c32d071292e27100bf12c4e963928fe8c38dda15375d83e5f4554485e150100fa1bd2ce3a72e2957bccf6b296011c8
+  data.tar.gz: 21b309d84d0195f062452c086857fc387be0a928ca5234a029ee083eb8a62c00089e65f98da8516bc06bfd64701f720f380daec4412cd6796398a9f764562359

data/.travis.yml

@@ -1,4 +1,7 @@
 language: ruby
 rvm:
   - 2.1.0
+  - 2.2.4
+  - 2.3.0
+  - ruby-head
 script: rake

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Releases
 
-## UNRELEASED (0.3.0)
+## 0.5.0
+
+* Locked development dependencies in the gemspec
+
+## 0.4.0 (yanked)
+
+* Signed commits and tags
+* I (Franck) changed my PGP key since 0.3.0
+
+## 0.3.0 (yanked)
+
+* Another pass at memory leaks
+* Performance non-regression tests
 
 ## 0.2.0
 

data/README.md

@@ -1,36 +1,90 @@
-# BLAKE2 for Ruby
+# BLAKE2s for Ruby
 
 ## SUMMARY
 
-This gem is a C-extension for using BLAKE2 in Ruby.
+This gem is a C-extension for using BLAKE2s in Ruby.
 
-For a detailed explanation about BLAKE2, [here's the offical website](https://blake2.net/).
+>BLAKE2 comes in two basic flavors:
+>
+>BLAKE2b (or just BLAKE2) is optimized for 64-bit platforms and
+>produces digests of any size between 1 and 64 bytes.
+>
+>BLAKE2s is optimized for 8- to 32-bit platforms and produces
+>digests of any size between 1 and 32 bytes.
+>
+>Both BLAKE2b and BLAKE2s are believed to be highly secure and perform
+>well on any platform, software, or hardware.  BLAKE2 does not require
+>a special "HMAC" (Hashed Message Authentication Code) construction
+>for keyed message authentication as it has a built-in keying
+>mechanism.
+>
+>[https://tools.ietf.org/html/rfc7693#page-3](https://tools.ietf.org/html/rfc7693#page-3)
 
-## INSTALL
+This implementation supports the BLAKE2s variant with 32 Bytes of output.
+
+The C code for this gem is taken from the [official reference C implementation](https://github.com/BLAKE2/BLAKE2)
+as of commit `02bf34f3d49c205812c34dfce9123a7c74509605`.
+
+For a detailed explanation about BLAKE2s, [here's the offical website](https://blake2.net/).
 
-    gem install blake2
+## INSTALL
 
+```
+gem install blake2
+```
 
 ## USAGE
 
-    out_len = 32
-    input   = "hello world"
-    key     = Key.from_string("foo bar baz") # or `Key.none`, or `Key.from_hex("0xDEADBEAF")`
+``` ruby
+require 'blake2'
+
+# The UTF-8 String (Required) that you want to digest.
+input   = 'abc'
+
+# The main application of keyed BLAKE2 is as a message authentication code (MAC)
+# By default `Blake2::Key.none` is used.
+key = Blake2::Key.none
+# key = Blake2::Key.from_string("foo bar baz")
+# key = Blake2::Key.from_hex('DEADBEAF')
+# key = Blake2::Key.from_bytes([222, 173, 190, 175])
+
+# The output length in Bytes of the Hash, Max and Default is 32.
+out_len = 32
+
+# HEX OUTPUT
+############
+
+Blake2.hex(input)
+=> "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"
+
+Blake2.hex(input, key)
+=> "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"
+
+Blake2.hex(input, key, out_len)
+=> "508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"
+
+# BYTES OUTPUT
+##############
 
-    digestor = Blake2.new(out_len, key)
+Blake2.bytes(input)
+=> [80, 140, 94, ...]
 
-    digestor.digest(input, :to_hex) # => 9567...b180
-    digestor.digest(input, :to_bytes) # => [0x95, 0x67, <28 bytes later...>, 0xb1, 0x80]
+Blake2.bytes(input, key)
+=> [80, 140, 94, ...]
 
+Blake2.bytes(input, key, out_len)
+=> [80, 140, 94, ...]
 
-## API
+```
 
-TODO
+## DEVELOPMENT
 
-## TODO
+After checking out the repo, run `bin/setup` to install dependencies. Then,
+run `rake full` to build and test, or `rake test` to only run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you
+to experiment.
 
-* [ ] Documentation
-* [ ] Improve controls/type checks in the `digest` methods
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## CONTRIBUTE
 

data/Rakefile

@@ -1,18 +1,46 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 require 'rake/extensiontask'
+
 spec = Gem::Specification.load('blake2.gemspec')
+
 Rake::ExtensionTask.new('blake2_ext', spec) do |ext|
-  ext.source_pattern = "*.{c,h}"
+  ext.source_pattern = '*.{c,h}'
 end
 
-require 'rake/testtask'
 Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.pattern = "test/**/*_test.rb"
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
   t.verbose = true
   t.warning = true
 end
 
-task :default => :full
+task default: :full
+
+desc 'clean, compile, and run the full test suite'
+task full: %w(clean compile test)
 
-desc "Run the full spec suite"
-task :full => ["clean", "compile", "test"]
+def gemspec
+  @gemspec ||= begin
+                 file = File.expand_path('../blake2.gemspec', __FILE__)
+                 eval(File.read(file), binding, file)
+               end
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc "Build the gem"
+task :gem => [:gemspec, :build] do
+  mkdir_p "pkg"
+  sh "gem build blake2.gemspec"
+  mv "#{gemspec.full_name}.gem", "pkg"
+
+  require 'digest/sha2'
+  built_gem_path = "pkg/#{gemspec.full_name}.gem"
+  checksum = Digest::SHA512.new.hexdigest(File.read(built_gem_path))
+  checksum_path = "checksums/#{gemspec.version}.sha512"
+  File.open(checksum_path, 'w' ) {|f| f.write(checksum) }
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'blake2'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/blake2.gemspec

@@ -1,25 +1,28 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name     = "blake2"
-  spec.version  = "0.2.0"
+  spec.version  = "0.5.0"
   spec.authors  = ["Franck Verrot"]
   spec.email    = ["franck@verrot.fr"]
   spec.homepage = "https://github.com/franckverrot/blake2"
-  spec.license  = "GPLv3"
+  spec.license  = "GPL-3.0"
 
   spec.summary     = "BLAKE2 - fast secure hashing - for Ruby"
-  spec.description = spec.summary
-  spec.files       = `git ls-files -z`.split("\x0")
+  spec.required_ruby_version = ">= 2.1.0"
+  spec.description = "BLAKE2 is a C-extension for using BLAKE2s in Ruby"
+  spec.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir      = "bin"
 
   spec.extensions << "ext/blake2_ext/extconf.rb"
 
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake-compiler", "~> 0.9"
+  spec.add_development_dependency "bundler"      , "~> 1.5"
+  spec.add_development_dependency "rake"         , "~> 11.1"
+  spec.add_development_dependency "minitest"     , "~> 5.8"
+  spec.add_development_dependency "pry"          , "~> 0.10"
 
   spec.cert_chain  = ['certs/franckverrot.pem']
   spec.signing_key = File.expand_path(ENV['RUBYGEMS_CERT_PATH']) if $0 =~ /gem\z/

data/checksums/0.3.0.sha512

@@ -0,0 +1 @@
+db9a73c5bb1baea243f4b690023d2a990b2bbb5e5a9ab032b6f844cef9dfe8cb534bf2d121993e986518caeedb7263d67b1c7d9693739b234118f46ba4ae4df1

data/ext/blake2_ext/blake2-impl.h

@@ -1,20 +1,23 @@
 /*
    BLAKE2 reference source code package - reference C implementations
-
-   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
-
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
-
-   You should have received a copy of the CC0 Public Domain Dedication along with
-   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+  
+   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+   your option.  The terms of these licenses can be found at:
+  
+   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+   - OpenSSL license   : https://www.openssl.org/source/license.html
+   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+  
+   More information about the BLAKE2 hash function can be found at
+   https://blake2.net.
 */
 #pragma once
 #ifndef __BLAKE2_IMPL_H__
 #define __BLAKE2_IMPL_H__
 
 #include <stdint.h>
+#include <string.h>
 
 static inline uint32_t load32( const void *src )
 {
@@ -126,10 +129,10 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c )
 }
 
 /* prevents compiler optimizing out memset() */
-static inline void secure_zero_memory( void *v, size_t n )
+static inline void secure_zero_memory(void *v, size_t n)
 {
-  volatile uint8_t *p = ( volatile uint8_t * )v;
-  while( n-- ) *p++ = 0;
+  static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
+  memset_v(v, 0, n);
 }
 
 #endif

data/ext/blake2_ext/blake2.h

@@ -1,14 +1,16 @@
 /*
    BLAKE2 reference source code package - reference C implementations
-
-   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
-
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
-
-   You should have received a copy of the CC0 Public Domain Dedication along with
-   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+  
+   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+   your option.  The terms of these licenses can be found at:
+  
+   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+   - OpenSSL license   : https://www.openssl.org/source/license.html
+   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+  
+   More information about the BLAKE2 hash function can be found at
+   https://blake2.net.
 */
 #pragma once
 #ifndef __BLAKE2_H__
@@ -17,12 +19,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#if defined(_MSC_VER)
-#define ALIGN(x) __declspec(align(x))
-#else
-#define ALIGN(x) __attribute__((aligned(x)))
-#endif
-
 #if defined(__cplusplus)
 extern "C" {
 #endif
@@ -45,23 +41,7 @@ extern "C" {
     BLAKE2B_PERSONALBYTES = 16
   };
 
-#pragma pack(push, 1)
-  typedef struct __blake2s_param
-  {
-    uint8_t  digest_length; // 1
-    uint8_t  key_length;    // 2
-    uint8_t  fanout;        // 3
-    uint8_t  depth;         // 4
-    uint32_t leaf_length;   // 8
-    uint8_t  node_offset[6];// 14
-    uint8_t  node_depth;    // 15
-    uint8_t  inner_length;  // 16
-    // uint8_t  reserved[0];
-    uint8_t  salt[BLAKE2S_SALTBYTES]; // 24
-    uint8_t  personal[BLAKE2S_PERSONALBYTES];  // 32
-  } blake2s_param;
-
-  ALIGN( 64 ) typedef struct __blake2s_state
+  typedef struct __blake2s_state
   {
     uint32_t h[8];
     uint32_t t[2];
@@ -69,24 +49,9 @@ extern "C" {
     uint8_t  buf[2 * BLAKE2S_BLOCKBYTES];
     size_t   buflen;
     uint8_t  last_node;
-  } blake2s_state ;
-
-  typedef struct __blake2b_param
-  {
-    uint8_t  digest_length; // 1
-    uint8_t  key_length;    // 2
-    uint8_t  fanout;        // 3
-    uint8_t  depth;         // 4
-    uint32_t leaf_length;   // 8
-    uint64_t node_offset;   // 16
-    uint8_t  node_depth;    // 17
-    uint8_t  inner_length;  // 18
-    uint8_t  reserved[14];  // 32
-    uint8_t  salt[BLAKE2B_SALTBYTES]; // 48
-    uint8_t  personal[BLAKE2B_PERSONALBYTES];  // 64
-  } blake2b_param;
+  } blake2s_state;
 
-  ALIGN( 64 ) typedef struct __blake2b_state
+  typedef struct __blake2b_state
   {
     uint64_t h[8];
     uint64_t t[2];
@@ -111,6 +76,38 @@ extern "C" {
     uint8_t buf[4 * BLAKE2B_BLOCKBYTES];
     size_t  buflen;
   } blake2bp_state;
+
+
+#pragma pack(push, 1)
+  typedef struct __blake2s_param
+  {
+    uint8_t  digest_length; // 1
+    uint8_t  key_length;    // 2
+    uint8_t  fanout;        // 3
+    uint8_t  depth;         // 4
+    uint32_t leaf_length;   // 8
+    uint8_t  node_offset[6];// 14
+    uint8_t  node_depth;    // 15
+    uint8_t  inner_length;  // 16
+    // uint8_t  reserved[0];
+    uint8_t  salt[BLAKE2S_SALTBYTES]; // 24
+    uint8_t  personal[BLAKE2S_PERSONALBYTES];  // 32
+  } blake2s_param;
+
+  typedef struct __blake2b_param
+  {
+    uint8_t  digest_length; // 1
+    uint8_t  key_length;    // 2
+    uint8_t  fanout;        // 3
+    uint8_t  depth;         // 4
+    uint32_t leaf_length;   // 8
+    uint64_t node_offset;   // 16
+    uint8_t  node_depth;    // 17
+    uint8_t  inner_length;  // 18
+    uint8_t  reserved[14];  // 32
+    uint8_t  salt[BLAKE2B_SALTBYTES]; // 48
+    uint8_t  personal[BLAKE2B_PERSONALBYTES];  // 64
+  } blake2b_param;
 #pragma pack(pop)
 
   // Streaming API

data/ext/blake2_ext/blake2s-ref.c

@@ -1,14 +1,16 @@
 /*
    BLAKE2 reference source code package - reference C implementations
-
-   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
-
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
-
-   You should have received a copy of the CC0 Public Domain Dedication along with
-   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+  
+   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+   your option.  The terms of these licenses can be found at:
+  
+   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+   - OpenSSL license   : https://www.openssl.org/source/license.html
+   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+  
+   More information about the BLAKE2 hash function can be found at
+   https://blake2.net.
 */
 
 #include <stdint.h>
@@ -40,22 +42,27 @@ static const uint8_t blake2s_sigma[10][16] =
 
 static inline int blake2s_set_lastnode( blake2s_state *S )
 {
-  S->f[1] = ~0U;
+  S->f[1] = -1;
   return 0;
 }
 
 static inline int blake2s_clear_lastnode( blake2s_state *S )
 {
-  S->f[1] = 0U;
+  S->f[1] = 0;
   return 0;
 }
 
 /* Some helper functions, not necessarily useful */
+static inline int blake2s_is_lastblock( const blake2s_state *S )
+{
+  return S->f[0] != 0;
+}
+
 static inline int blake2s_set_lastblock( blake2s_state *S )
 {
   if( S->last_node ) blake2s_set_lastnode( S );
 
-  S->f[0] = ~0U;
+  S->f[0] = -1;
   return 0;
 }
 
@@ -63,7 +70,7 @@ static inline int blake2s_clear_lastblock( blake2s_state *S )
 {
   if( S->last_node ) blake2s_clear_lastnode( S );
 
-  S->f[0] = 0U;
+  S->f[0] = 0;
   return 0;
 }
 
@@ -301,9 +308,13 @@ int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen )
 {
   uint8_t buffer[BLAKE2S_OUTBYTES] = {0};
 
-  if( outlen > BLAKE2S_OUTBYTES )
+  if( out == NULL || outlen == 0 || outlen > BLAKE2S_OUTBYTES )
+    return -1;
+
+  if( blake2s_is_lastblock( S ) )
     return -1;
 
+
   if( S->buflen > BLAKE2S_BLOCKBYTES )
   {
     blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
@@ -329,11 +340,15 @@ int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen
   blake2s_state S[1];
 
   /* Verify parameters */
-  if ( NULL == in ) return -1;
+  if ( NULL == in && inlen > 0 ) return -1;
 
   if ( NULL == out ) return -1;
 
-  if ( NULL == key ) keylen = 0; /* Fail here instead if keylen != 0 and key == NULL? */
+  if ( NULL == key && keylen > 0) return -1;
+
+  if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1;
+
+  if( keylen > BLAKE2S_KEYBYTES ) return -1;
 
   if( keylen > 0 )
   {
@@ -349,6 +364,13 @@ int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen
   return 0;
 }
 
+#if defined(SUPERCOP)
+int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen )
+{
+  return blake2s( out, in, NULL, BLAKE2S_OUTBYTES, inlen, 0 );
+}
+#endif
+
 #if defined(BLAKE2S_SELFTEST)
 #include <string.h>
 #include "blake2-kat.h"

data/ext/blake2_ext/rbext.c

@@ -18,15 +18,19 @@ VALUE cBlake2;
 static void blake2_free(Blake2 *blake2) {
   if(blake2->key_length > 0) {
     ruby_xfree(blake2->key_bytes);
+    blake2->key_length = 0;
   }
 
   if(blake2->output_length > 0) {
     ruby_xfree(blake2->output);
+    blake2->output_length = 0;
   }
+
+  free(blake2);
 }
 
-VALUE blake2_alloc(VALUE klass) {
-  VALUE blake2_obj = ruby_xmalloc(sizeof(Blake2));
+static VALUE blake2_alloc(VALUE klass) {
+  Blake2 *blake2_obj = (Blake2 *)malloc(sizeof(Blake2));
 
   return Data_Wrap_Struct(klass, NULL, blake2_free, blake2_obj);
 }
@@ -59,7 +63,7 @@ VALUE m_blake2_initialize(VALUE self, VALUE _len, VALUE _key) {
 VALUE m_blake2_digest(VALUE self, VALUE _input, VALUE _representation) {
   Blake2 *blake2;
 
-  char * input     = RSTRING_PTR(_input);
+  char *input      = RSTRING_PTR(_input);
   int input_length = RSTRING_LEN(_input);
   int i;
 
@@ -76,23 +80,27 @@ VALUE m_blake2_digest(VALUE self, VALUE _input, VALUE _representation) {
     for(i = 0; i < blake2->output_length; i++) {
       rb_ary_push(result, INT2NUM(blake2->output[i]));
     }
-
-    return result;
   } else if(_representation == blake2->to_hex) {
-    char * c_str = (char*)ruby_xmalloc(blake2->output_length * sizeof(char) * 2);
+    int ary_len = blake2->output_length * sizeof(char) * 2;
+    char *c_str = (char*)malloc(ary_len + 1);
 
     for(i = 0; i < blake2->output_length; i++) {
       sprintf(c_str + (i * 2), "%02x", blake2->output[i]);
     }
+    c_str[ary_len] = 0;
 
-    result = rb_str_new2(c_str);
+    result = rb_str_new(c_str, ary_len);
 
-    ruby_xfree(c_str);
+    if(RSTRING_LEN(result) != ary_len) {
+      rb_raise(rb_eRuntimeError, "m_blake2_digest: sizes don't match. Ary: %d != %d", RSTRING_LEN(result), ary_len);
+    }
 
-    return result;
+    free(c_str);
   } else {
-    rb_raise(rb_eArgError, "Unknown representation", _representation);
+    rb_raise(rb_eArgError, "unknown representation :%"PRIsVALUE"", _representation);
   }
+
+  return result;
 }
 
 void Init_blake2_ext() {

data/lib/blake2.rb

@@ -1,2 +1,29 @@
 require 'blake2_ext'
 require 'blake2/key'
+
+class Blake2
+  def self.hex(input, key = Blake2::Key.none, out_len = 32)
+    check_if_valid!(input, key, out_len)
+    Blake2.new(out_len, key).digest(input, :to_hex)
+  end
+
+  def self.bytes(input, key = Blake2::Key.none, out_len = 32)
+    check_if_valid!(input, key, out_len)
+    Blake2.new(out_len, key).digest(input, :to_bytes)
+  end
+
+  def self.check_if_valid!(input, key, out_len)
+    unless input.is_a?(String)
+      raise ArgumentError, 'input arg must be a String'
+    end
+
+    unless key.is_a?(Blake2::Key)
+      raise ArgumentError, 'key arg must be a Blake2::Key'
+    end
+
+    unless out_len.is_a?(Integer) && out_len.between?(1, 32)
+      raise ArgumentError, 'out_len arg must be an Integer between 1 and 32 inclusive'
+    end
+  end
+  private_class_method :check_if_valid!
+end

data/lib/blake2/key.rb

@@ -1,23 +1,55 @@
 class Blake2
+  # Validate and normalize an HMAC key, provided in different formats,
+  # into an Array of Integer Bytes.
   class Key
-    def bytes
-      @bytes
-    end
+    attr_reader :bytes
 
     def initialize(bytes)
       @bytes = bytes
     end
 
+    # Create a blank Key
+    #
+    # @return [Blake2::Key] a Blake2::Key object with a `bytes` attr
+    def self.none
+      new([])
+    end
+
+    # Create a key from an ASCII String
+    #
+    # @param str [String] an ASCII String key
+    # @return [Blake2::Key] a Blake2::Key object with a `bytes` attr
     def self.from_string(str)
-      new(str.bytes)
+      if str.is_a?(String) && str.ascii_only?
+        new(str.bytes)
+      else
+        raise ArgumentError, 'key must be an ASCII String'
+      end
     end
 
-    def self.from_hex(hex_str)
-      new([hex_str].pack("H*").bytes)
+    # Create a key from a Hex String [a-fA-F0-9]
+    #
+    # @param str [String] a Hex String key
+    # @return [Blake2::Key] a Blake2::Key object with a `bytes` attr
+    def self.from_hex(str)
+      if str.is_a?(String) && str.match(/^[a-fA-F0-9]+$/)
+        new([str].pack('H*').bytes)
+      else
+        raise ArgumentError, 'key must be a Hex String [a-fA-F0-9]'
+      end
     end
 
-    def self.none
-      new([])
+    # Create a key from Array of Integer (0-255) Bytes.
+    # This simply validates and passes through the Array.
+    #
+    # @param str [Array] an Array of Integer (0-255) Bytes
+    # @return [Blake2::Key] a Blake2::Key object with a `bytes` attr
+    def self.from_bytes(bytes)
+      if bytes.all? { |b| b.is_a?(Integer) && b.between?(0, 255) }
+        new(bytes)
+      else
+        raise ArgumentError, 'key must be a Byte Array of Integers (0-255)'
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blake2
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Franck Verrot
@@ -30,22 +30,22 @@ cert_chain:
   Z7BoH/Mfxw3P4yyir173p9JWvVqLiQE13XBeD13NPA8neoWpLJxm6k03PcTElT/E
   QrOSgKrHAb/fFJma
   -----END CERTIFICATE-----
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -64,31 +64,45 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: BLAKE2 - fast secure hashing - for Ruby
+        version: '0.10'
+description: BLAKE2 is a C-extension for using BLAKE2s in Ruby
 email:
 - franck@verrot.fr
 executables: []
@@ -103,9 +117,12 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - blake2.gemspec
 - certs/franckverrot.pem
 - checksums/0.1.0.sha512
+- checksums/0.3.0.sha512
 - ext/blake2_ext/blake2-impl.h
 - ext/blake2_ext/blake2.h
 - ext/blake2_ext/blake2s-ref.c
@@ -113,12 +130,9 @@ files:
 - ext/blake2_ext/rbext.c
 - lib/blake2.rb
 - lib/blake2/key.rb
-- test/blake2/key_test.rb
-- test/blake2_test.rb
-- test/test_helper.rb
 homepage: https://github.com/franckverrot/blake2
 licenses:
-- GPLv3
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -128,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -140,7 +154,4 @@ rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: BLAKE2 - fast secure hashing - for Ruby
-test_files:
-- test/blake2/key_test.rb
-- test/blake2_test.rb
-- test/test_helper.rb
+test_files: []

data/test/blake2/key_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-class KeyTest < MiniTest::Test
-  def test_from_string
-    key = Blake2::Key.from_string("foo bar baz")
-    assert_equal [102, 111, 111, 32, 98, 97, 114, 32, 98, 97, 122], key.bytes
-  end
-
-  def test_none
-    key = Blake2::Key.none
-    assert_equal [], key.bytes
-  end
-
-  def test_from_hex
-    key = Blake2::Key.from_hex("DEADBEAF")
-    assert_equal [0XDE, 0xAD, 0xBE, 0xAF], key.bytes
-  end
-end

data/test/blake2_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-class Blake2Test < MiniTest::Test
-  def setup
-    out_len = 32
-    key     = Blake2::Key.from_string("foo bar baz") # or `Key.none`, or `Key.from_hex("0xDEADBEAF")`
-
-    @digestor = Blake2.new(out_len, key)
-
-    @input    = "hello world"
-    @expected = "95670379036532875f58bf23fbcb549675b656bd639a6124a614ccd8a980b180"
-  end
-
-  def test_to_hex
-    res = @digestor.digest(@input, :to_hex) # => 9567...b180
-    assert_kind_of String, res
-    assert_equal   @expected, res
-  end
-
-  def to_bytes
-    res = @digestor.digest(@input, :to_bytes) # => [0x95, 0x67, <28 bytes later...>, 0xb1, 0x80]
-    assert_kind_of Array, res
-    assert_equal   @expected.pack("H*").bytes, res
-  end
-end

data/test/test_helper.rb

@@ -1,11 +0,0 @@
-require 'minitest/autorun'
-require 'minitest/assertions'
-require 'pp'
-
-class Array
-  def hd
-    self.each.map { |b| sprintf("%X", b) }.join
-  end
-end
-
-require 'blake2'