digest-siphash 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c27f151cfd6e1509a0b7b8086b872f697faa1da9
+  data.tar.gz: 24c64c35d7be6a31e1099f272e79d638778f1e8f
+SHA512:
+  metadata.gz: e073e6bdc4e2d985eb7ab22fb253d2460120bcda4fc71f4fd033ee52e473abf06f5ffbffe2e64b7aef9ea652e867815a468b9f9125f2068ef52125b77dd7f263
+  data.tar.gz: ade5bfd91c2b4403d7463f5d4d934e80d0e41a5abba1ca9fe5944797dd1ba7a3d28dd192c4e8f96c4ae86193c154c26380bdae4af0006f9076fce8991d6f257b

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 ksss
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,53 @@
+# Digest::SipHash
+
+[![Build Status](https://travis-ci.org/ksss/digest-siphash.png)](https://travis-ci.org/ksss/digest-siphash)
+
+Digest::SipHash is a class of message digest use algorithm SipHash.
+
+## Usage
+
+```ruby
+require 'digest/siphash'
+
+p Digest::SipHash.digest("siphash") #=> "\x59\xca\xae\xb9\x0d\x54\x24\x64"
+p Digest::SipHash.hexdigest("siphash") #=> "59caaeb90d542464"
+```
+
+you can change seed string(128bits).
+seed default value is `SipHash::DEFAULT_SEED` ("\x00" * 16)
+
+```ruby
+seed = (0..0x0f).to_a.pack("C16")
+p Digest::SipHash.digest("siphash", seed) #=> "\x88\x27\x68\x57\x0d\xc7\x1c\x92"
+p Digest::SipHash.hexdigest("siphash", seed) #=> "882768570dc71c92"
+```
+
+and other way. instance use.
+
+```ruby
+siphash = Digest::SipHash.new
+siphash.update "siphash"
+p siphash.digest #=> "\x88\x27\x68\x57\x0d\xc7\x1c\x92"
+
+# of course, can change seed value.
+siphash.seed = (0..0x0f).to_a.pack("C16")
+p siphash.hexdigest "siphash" #=> "882768570dc71c92"
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'digest-siphash'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install digest-siphash
+
+## See also
+
+[https://131002.net/siphash/](https://131002.net/siphash/)

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-Ilib"]
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = true
+end
+task :spec => :compile
+
+require 'rake/extensiontask'
+spec = Bundler::GemHelper.gemspec
+Rake::ExtensionTask.new('siphash', spec) do |ext|
+  ext.ext_dir = 'ext/digest/siphash'
+  ext.lib_dir = 'lib/digest/siphash'
+end
+
+
+task :default => [:spec,:build]

data/digest-siphash.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "digest-siphash"
+  spec.version       = "0.0.1"
+  spec.authors       = "ksss"
+  spec.email         = "co000ri@gmail.com"
+  spec.summary       = %q{Digest::SipHash is a class of message digest use algorithm SipHash.}
+  spec.description   = %q{Digest::SipHash is a class of message digest use algorithm SipHash.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/digest/siphash/extconf.rb"]
+
+  spec.add_runtime_dependency "digest-stringbuffer", ["~> 0.0.2"]
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ['~> 2.11']
+  spec.add_development_dependency "rake-compiler", ["~> 0.8.3"]
+end

data/ext/digest/siphash/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$preload = %w[digest]
+
+create_makefile('digest/siphash/siphash')

data/ext/digest/siphash/init.c

@@ -0,0 +1,147 @@
+#include "siphash24.h"
+#include "siphash.h"
+
+#define siphash crypto_auth
+#define DEFAULT_SEED "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+
+VALUE cDigest_SipHash;
+ID id_DEFAULT_SEED;
+ID id_seed;
+
+static VALUE
+siphash_seed_get(VALUE self)
+{
+	if (!rb_ivar_defined(self, id_seed)) {
+		rb_ivar_set(self, id_seed, rb_usascii_str_new(DEFAULT_SEED, 16));
+	}
+	return rb_ivar_get(self, id_seed);
+}
+
+static VALUE
+siphash_seed_set(VALUE self, VALUE obj)
+{
+	StringValue(obj);
+	if (RSTRING_LEN(obj) != 16) {
+		rb_raise(rb_eArgError, "seed string should 128 bit chars");
+	}
+	return rb_ivar_set(self, id_seed, obj);
+}
+
+static void
+_siphash_s_digest(uint8_t* digest, int argc, VALUE *argv)
+{
+	VALUE str;
+	const unsigned char *seed;
+
+	if (argc < 1)
+		rb_raise(rb_eArgError, "no data given");
+
+	str = argv[0];
+	StringValue(str);
+
+	if (1 < argc) {
+		StringValue(argv[1]);
+		if (RSTRING_LEN(argv[1]) != 16) {
+			rb_raise(rb_eArgError, "seed string should 128 bit chars");
+		}
+		seed = (const unsigned char*) RSTRING_PTR(argv[1]);
+	} else {
+		seed = (const unsigned char*) RSTRING_PTR(
+				rb_const_get(cDigest_SipHash, id_DEFAULT_SEED));
+	}
+
+	siphash(digest, (const unsigned char*) RSTRING_PTR(str), RSTRING_LEN(str), seed);
+}
+
+static inline void
+_siphash_finish(uint8_t *digest, VALUE self)
+{
+	const unsigned char *seed;
+	buffer_t *ptr;
+
+	Data_Get_Struct(self, buffer_t, ptr);
+	seed = (const unsigned char *) RSTRING_PTR(siphash_seed_get(self));
+	siphash(digest, (const unsigned char *) ptr->buffer, ptr->p - ptr->buffer, seed);
+}
+
+static VALUE
+siphash_finish(VALUE self)
+{
+	uint8_t digest[8];
+#if LITTLE_ENDIAN
+	uint8_t roll[8];
+	int i;
+#endif
+	_siphash_finish(digest, self);
+#if LITTLE_ENDIAN
+	for (i = 0; i < 8; i++) {
+		roll[i] = digest[7 - i];
+	}
+	memcpy(digest, roll, 8);
+#endif
+	return rb_str_new((const char*) digest, 8);
+}
+
+static VALUE
+siphash_to_i(VALUE self)
+{
+	uint8_t digest[8];
+	_siphash_finish(digest, self);
+	return ULL2NUM(*(uint64_t *) digest);
+}
+
+static VALUE
+siphash_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+	uint8_t digest[8];
+#if LITTLE_ENDIAN
+	uint8_t roll[8];
+	int i;
+#endif
+	_siphash_s_digest(digest, argc, argv);
+#if LITTLE_ENDIAN
+	for (i = 0; i < 8; i++) {
+		roll[i] = digest[7 - i];
+	}
+	memcpy(digest, roll, 8);
+#endif
+	return rb_str_new((const char*) digest, 8);
+}
+
+static VALUE
+siphash_s_hexdigest(int argc, VALUE *argv, VALUE klass)
+{
+	return hexencode_str_new(siphash_s_digest(argc, argv, klass));
+}
+
+static VALUE
+siphash_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+	uint8_t digest[8];
+	_siphash_s_digest(digest, argc, argv);
+	return ULL2NUM(*(uint64_t *) digest);
+}
+
+void
+Init_siphash(void)
+{
+	VALUE mDigest, cDigest_StringBuffer;
+
+	id_DEFAULT_SEED = rb_intern("DEFAULT_SEED");
+	id_seed = rb_intern("seed");
+
+	/* Digest::SipHash is require that Digest::StringBuffer */
+	mDigest = rb_path2class("Digest");
+	cDigest_StringBuffer = rb_path2class("Digest::StringBuffer");
+
+	/* class Digest::SipHash < Digest::StringBuffer */
+	cDigest_SipHash = rb_define_class_under(mDigest, "SipHash", cDigest_StringBuffer);
+	rb_define_private_method(cDigest_SipHash, "finish", siphash_finish, 0);
+	rb_define_method(cDigest_SipHash, "to_i", siphash_to_i, 0);
+	rb_define_method(cDigest_SipHash, "seed", siphash_seed_get, 0);
+	rb_define_method(cDigest_SipHash, "seed=", siphash_seed_set, 1);
+	rb_define_const(cDigest_SipHash, "DEFAULT_SEED", rb_usascii_str_new(DEFAULT_SEED, 16));
+	rb_define_singleton_method(cDigest_SipHash, "digest", siphash_s_digest, -1);
+	rb_define_singleton_method(cDigest_SipHash, "hexdigest", siphash_s_hexdigest, -1);
+	rb_define_singleton_method(cDigest_SipHash, "rawdigest", siphash_s_rawdigest, -1);
+}

data/ext/digest/siphash/siphash.h

@@ -0,0 +1,68 @@
+#ifndef SIPHASH_INCLUDED
+#  define SIPHASH_INCLUDED
+
+#include "ruby.h"
+
+#ifndef LITTLE_ENDIAN
+/* NO-OP for little-endian platforms */
+#  if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
+#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#      define LITTLE_ENDIAN 1
+#    endif
+/* if __BYTE_ORDER__ is not predefined (like FreeBSD), use arch */
+#  elif defined(__i386)  || defined(__x86_64) ||  defined(__alpha) || defined(__vax)
+#    define LITTLE_ENDIAN 1
+#  endif
+#endif
+
+/* last resort (big-endian w/o __builtin_bswap64) */
+#ifndef LITTLE_ENDIAN
+#  define LITTLE_ENDIAN 0
+#endif
+
+/* should be same type structure to digest/stringbuffer */
+typedef struct {
+	char* buffer;
+	char* p;
+	size_t memsize;
+} buffer_t;
+
+/*
+ * from https://github.com/ruby/ruby/blob/trunk/ext/digest/digest.c
+ * Copyright (C) 1995-2001 Yukihiro Matsumoto
+ * Copyright (C) 2001-2006 Akinori MUSHA
+ */
+static VALUE
+hexencode_str_new(VALUE str_digest)
+{
+	char *digest;
+	size_t digest_len;
+	size_t i;
+	VALUE str;
+	char *p;
+	static const char hex[] = {
+		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+		'a', 'b', 'c', 'd', 'e', 'f'
+	};
+
+	StringValue(str_digest);
+	digest = RSTRING_PTR(str_digest);
+	digest_len = RSTRING_LEN(str_digest);
+
+	if (LONG_MAX / 2 < digest_len) {
+		rb_raise(rb_eRuntimeError, "digest string too long");
+	}
+
+	str = rb_usascii_str_new(0, digest_len * 2);
+
+	for (i = 0, p = RSTRING_PTR(str); i < digest_len; i++) {
+		unsigned char byte = digest[i];
+
+		p[i + i]     = hex[byte >> 4];
+		p[i + i + 1] = hex[byte & 0x0f];
+	}
+
+	return str;
+}
+
+#endif /* ifndef SIPHASH_INCLUDED */

data/ext/digest/siphash/siphash24.h

@@ -0,0 +1,103 @@
+/*
+   SipHash reference C implementation
+
+   Written in 2012 by
+   Jean-Philippe Aumasson <jeanphilippe.aumasson@gmail.com>
+   Daniel J. Bernstein <djb@cr.yp.to>
+
+   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/>.
+*/
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef uint64_t u64;
+typedef uint32_t u32;
+typedef uint8_t u8;
+
+#define ROTL(x,b) (u64)( ((x) << (b)) | ( (x) >> (64 - (b))) )
+
+#define U32TO8_LE(p, v)         \
+    (p)[0] = (u8)((v)      ); (p)[1] = (u8)((v) >>  8); \
+    (p)[2] = (u8)((v) >> 16); (p)[3] = (u8)((v) >> 24);
+
+#define U64TO8_LE(p, v)         \
+  U32TO8_LE((p),     (u32)((v)      ));   \
+  U32TO8_LE((p) + 4, (u32)((v) >> 32));
+
+#define U8TO64_LE(p) \
+  (((u64)((p)[0])      ) | \
+   ((u64)((p)[1]) <<  8) | \
+   ((u64)((p)[2]) << 16) | \
+   ((u64)((p)[3]) << 24) | \
+   ((u64)((p)[4]) << 32) | \
+   ((u64)((p)[5]) << 40) | \
+   ((u64)((p)[6]) << 48) | \
+   ((u64)((p)[7]) << 56))
+
+#define SIPROUND            \
+  do {              \
+    v0 += v1; v1=ROTL(v1,13); v1 ^= v0; v0=ROTL(v0,32); \
+    v2 += v3; v3=ROTL(v3,16); v3 ^= v2;     \
+    v0 += v3; v3=ROTL(v3,21); v3 ^= v0;     \
+    v2 += v1; v1=ROTL(v1,17); v1 ^= v2; v2=ROTL(v2,32); \
+  } while(0)
+
+/* SipHash-2-4 */
+int crypto_auth( unsigned char *out, const unsigned char *in, unsigned long long inlen, const unsigned char *k )
+{
+  /* "somepseudorandomlygeneratedbytes" */
+  u64 v0 = 0x736f6d6570736575ULL;
+  u64 v1 = 0x646f72616e646f6dULL;
+  u64 v2 = 0x6c7967656e657261ULL;
+  u64 v3 = 0x7465646279746573ULL;
+  u64 b;
+  u64 k0 = U8TO64_LE( k );
+  u64 k1 = U8TO64_LE( k + 8 );
+  u64 m;
+  const u8 *end = in + inlen - ( inlen % sizeof( u64 ) );
+  const int left = inlen & 7;
+  b = ( ( u64 )inlen ) << 56;
+  v3 ^= k1;
+  v2 ^= k0;
+  v1 ^= k1;
+  v0 ^= k0;
+
+  for ( ; in != end; in += 8 )
+  {
+    m = U8TO64_LE( in );
+    v3 ^= m;
+    SIPROUND;
+    SIPROUND;
+    v0 ^= m;
+  }
+
+  switch( left )
+  {
+  case 7: b |= ( ( u64 )in[ 6] )  << 48;
+  case 6: b |= ( ( u64 )in[ 5] )  << 40;
+  case 5: b |= ( ( u64 )in[ 4] )  << 32;
+  case 4: b |= ( ( u64 )in[ 3] )  << 24;
+  case 3: b |= ( ( u64 )in[ 2] )  << 16;
+  case 2: b |= ( ( u64 )in[ 1] )  <<  8;
+  case 1: b |= ( ( u64 )in[ 0] ); break;
+  case 0: break;
+  }
+
+  v3 ^= b;
+  SIPROUND;
+  SIPROUND;
+  v0 ^= b;
+  v2 ^= 0xff;
+  SIPROUND;
+  SIPROUND;
+  SIPROUND;
+  SIPROUND;
+  b = v0 ^ v1 ^ v2  ^ v3;
+  U64TO8_LE( out, b );
+  return 0;
+}

data/lib/digest/siphash.rb

@@ -0,0 +1,6 @@
+require "digest/stringbuffer"
+begin
+  require "digest/siphash/#{RUBY_VERSION[/\d+.\d+/]}/siphash"
+rescue LoadError
+  require "digest/siphash/siphash"
+end

data/spec/digest_spec.rb

@@ -0,0 +1,60 @@
+# coding: ascii-8bit
+require 'spec_helper'
+
+describe Digest::SipHash do
+  let :seed do
+    (0..0x0f).to_a.pack("C16")
+  end
+
+  it "initialize" do
+    expect(SipHash.new).to be_a_kind_of(StringBuffer)
+  end
+
+  it "DEFAULT_SEED" do
+    expect(SipHash::DEFAULT_SEED).to eq("\x00" * 16)
+  end
+
+  it "seed" do
+    sip = SipHash.new
+    expect(sip.seed).to eq("\x00" * 16)
+  end
+
+  it "seed=" do
+    sip = SipHash.new
+    sip.seed = seed
+    expect(sip.seed).to eq(seed)
+  end
+
+  it "digest" do
+    expect(SipHash.digest("")).to eq("\x1e\x92\x4b\x9d\x73\x77\x00\xd7")
+    expect(SipHash.digest("", seed)).to eq("\x72\x6f\xdb\x47\xdd\x0e\x0e\x31")
+    expect(SipHash.digest("\x00", seed)).to eq("\x74\xf8\x39\xc5\x93\xdc\x67\xfd")
+    expect(SipHash.digest("\x00\x01", seed)).to eq("\x0d\x6c\x80\x09\xd9\xa9\x4f\x5a")
+  end
+
+  it "hexdigest" do
+    expect(SipHash.hexdigest("")).to eq("1e924b9d737700d7")
+    expect(SipHash.hexdigest("", seed)).to eq("726fdb47dd0e0e31")
+    expect(SipHash.hexdigest("\x00", seed)).to eq("74f839c593dc67fd")
+    expect(SipHash.hexdigest("\x00\x01", seed)).to eq("0d6c8009d9a94f5a")
+  end
+
+  it "rawdigest" do
+    expect(SipHash.rawdigest("")).to eq(0x1e924b9d737700d7)
+    expect(SipHash.rawdigest("", seed)).to eq(0x726fdb47dd0e0e31)
+    expect(SipHash.rawdigest("\x00", seed)).to eq(0x74f839c593dc67fd)
+    expect(SipHash.rawdigest("\x00\x01", seed)).to eq(0x0d6c8009d9a94f5a)
+  end
+
+  it "instance digest" do
+    sip = SipHash.new
+    sip.update ""
+    expect(sip.digest).to eq("\x1e\x92\x4b\x9d\x73\x77\x00\xd7")
+    expect(sip.to_i).to eq(0x1e924b9d737700d7)
+    
+    sip.seed = seed
+    expect(sip.digest).to eq("\x72\x6f\xdb\x47\xdd\x0e\x0e\x31")
+    expect(sip.to_i).to eq(0x726fdb47dd0e0e31)
+  end
+end
+

data/spec/exception_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Digest::SipHash do
+  it "no data given" do
+    expect{ SipHash::digest }.to raise_error(ArgumentError)
+  end
+
+  it "seed string should 128 bit chars" do
+    expect{ SipHash::digest("siphash", "\x00") }.to raise_error(ArgumentError)
+
+    sip = SipHash.new
+    expect{ sip.seed = "0x00" }.to raise_error(ArgumentError)
+  end
+end
+
+
+

data/spec/mem_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Digest::SipHash do
+  it "gc safe" do
+    sip = SipHash.new
+    GC.start
+    sip.update "siphash"
+    GC.start
+    expect(sip.hexdigest).to eq("59caaeb90d542464")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'digest/siphash'
+include Digest

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: digest-siphash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: digest-stringbuffer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+description: Digest::SipHash is a class of message digest use algorithm SipHash.
+email: co000ri@gmail.com
+executables: []
+extensions:
+- ext/digest/siphash/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- digest-siphash.gemspec
+- ext/digest/siphash/extconf.rb
+- ext/digest/siphash/init.c
+- ext/digest/siphash/siphash.h
+- ext/digest/siphash/siphash24.h
+- lib/digest/siphash.rb
+- spec/digest_spec.rb
+- spec/exception_spec.rb
+- spec/mem_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Digest::SipHash is a class of message digest use algorithm SipHash.
+test_files:
+- spec/digest_spec.rb
+- spec/exception_spec.rb
+- spec/mem_spec.rb
+- spec/spec_helper.rb