rubysl-digest 0.0.1 → 1.0.0

data/ext/rubysl/digest/sha2/sha2.h

@@ -0,0 +1,109 @@
+/*
+ * sha2.h
+ *
+ * Version 1.0.0beta1
+ *
+ * Written by Aaron D. Gifford <me@aarongifford.com>
+ *
+ * Copyright 2000 Aaron D. Gifford.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTOR(S) ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTOR(S) BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+/* $RoughId: sha2.h,v 1.3 2002/02/24 08:14:32 knu Exp $ */
+/* $Id: sha2.h 11708 2007-02-12 23:01:19Z shyouhei $ */
+
+#ifndef __SHA2_H__
+#define __SHA2_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "defs.h"
+
+
+/*** SHA-256/384/512 Various Length Definitions ***********************/
+#define SHA256_BLOCK_LENGTH		64
+#define SHA256_DIGEST_LENGTH		32
+#define SHA256_DIGEST_STRING_LENGTH	(SHA256_DIGEST_LENGTH * 2 + 1)
+#define SHA384_BLOCK_LENGTH		128
+#define SHA384_DIGEST_LENGTH		48
+#define SHA384_DIGEST_STRING_LENGTH	(SHA384_DIGEST_LENGTH * 2 + 1)
+#define SHA512_BLOCK_LENGTH		128
+#define SHA512_DIGEST_LENGTH		64
+#define SHA512_DIGEST_STRING_LENGTH	(SHA512_DIGEST_LENGTH * 2 + 1)
+
+
+/*** SHA-256/384/512 Context Structures *******************************/
+
+typedef struct _SHA256_CTX {
+	uint32_t	state[8];
+	uint64_t	bitcount;
+	uint8_t	buffer[SHA256_BLOCK_LENGTH];
+} SHA256_CTX;
+typedef struct _SHA512_CTX {
+	uint64_t	state[8];
+	uint64_t	bitcount[2];
+	uint8_t	buffer[SHA512_BLOCK_LENGTH];
+} SHA512_CTX;
+
+typedef SHA512_CTX SHA384_CTX;
+
+
+#ifdef RUBY
+#define SHA256_Init		rb_Digest_SHA256_Init
+#define SHA256_Update		rb_Digest_SHA256_Update
+#define SHA256_Finish		rb_Digest_SHA256_Finish
+
+#define SHA384_Init		rb_Digest_SHA384_Init
+#define SHA384_Update		rb_Digest_SHA384_Update
+#define SHA384_Finish		rb_Digest_SHA384_Finish
+
+#define SHA512_Init		rb_Digest_SHA512_Init
+#define SHA512_Update		rb_Digest_SHA512_Update
+#define SHA512_Finish		rb_Digest_SHA512_Finish
+#endif
+
+/*** SHA-256/384/512 Function Prototypes ******************************/
+void SHA256_Init _((SHA256_CTX *));
+void SHA256_Update _((SHA256_CTX*, const uint8_t*, size_t));
+void SHA256_Finish _((SHA256_CTX*, uint8_t[SHA256_DIGEST_LENGTH]));
+
+void SHA384_Init _((SHA384_CTX*));
+void SHA384_Update _((SHA384_CTX*, const uint8_t*, size_t));
+void SHA384_Finish _((SHA384_CTX*, uint8_t[SHA384_DIGEST_LENGTH]));
+
+void SHA512_Init _((SHA512_CTX*));
+void SHA512_Update _((SHA512_CTX*, const uint8_t*, size_t));
+void SHA512_Finish _((SHA512_CTX*, uint8_t[SHA512_DIGEST_LENGTH]));
+
+#ifdef	__cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __SHA2_H__ */
+

data/ext/rubysl/digest/sha2/sha2init.c

@@ -0,0 +1,52 @@
+/* $RoughId: sha2init.c,v 1.3 2001/07/13 20:00:43 knu Exp $ */
+/* $Id: sha2init.c 19020 2008-09-01 07:48:53Z nobu $ */
+
+#include "digest.h"
+#include "sha2.h"
+
+#define FOREACH_BITLEN(func)	func(256) func(384) func(512)
+
+#define DEFINE_ALGO_METADATA(bitlen) \
+static const rb_digest_metadata_t sha##bitlen = { \
+    RUBY_DIGEST_API_VERSION, \
+    SHA##bitlen##_DIGEST_LENGTH, \
+    SHA##bitlen##_BLOCK_LENGTH, \
+    sizeof(SHA##bitlen##_CTX), \
+    (rb_digest_hash_init_func_t)SHA##bitlen##_Init, \
+    (rb_digest_hash_update_func_t)SHA##bitlen##_Update, \
+    (rb_digest_hash_finish_func_t)SHA##bitlen##_Finish, \
+};
+
+FOREACH_BITLEN(DEFINE_ALGO_METADATA)
+
+/*
+ * Classes for calculating message digests using the SHA-256/384/512
+ * Secure Hash Algorithm(s) by NIST (the US' National Institute of
+ * Standards and Technology), described in FIPS PUB 180-2.
+ */
+void
+Init_sha2()
+{
+    VALUE mDigest, cDigest_Base;
+    ID id_metadata;
+
+#define DECLARE_ALGO_CLASS(bitlen) \
+    VALUE cDigest_SHA##bitlen;
+
+    FOREACH_BITLEN(DECLARE_ALGO_CLASS)
+
+    rb_require("digest");
+
+    id_metadata = rb_intern("metadata");
+
+    mDigest = rb_path2class("Digest");
+    cDigest_Base = rb_path2class("Digest::Base");
+
+#define DEFINE_ALGO_CLASS(bitlen) \
+    cDigest_SHA##bitlen = rb_define_class_under(mDigest, "SHA" #bitlen, cDigest_Base); \
+\
+    rb_ivar_set(cDigest_SHA##bitlen, id_metadata, \
+      Data_Wrap_Struct(rb_cObject, 0, 0, (void *)&sha##bitlen));
+
+    FOREACH_BITLEN(DEFINE_ALGO_CLASS)
+}

data/lib/digest/bubblebabble.rb

@@ -0,0 +1 @@
+require 'digest/bubblebabble/bubblebabble'

data/lib/digest/hmac.rb

@@ -0,0 +1,302 @@
+# == License
+#
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# Documentation by Akinori MUSHA
+#
+# All rights reserved.  You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+#   $Id$
+#
+
+warn "use of the experimetal library 'digest/hmac' is discouraged; require 'openssl' and use OpenSSL::HMAC instead." if $VERBOSE
+
+require 'digest'
+
+module Digest
+  # = digest/hmac.rb
+  #
+  # An experimental implementation of HMAC keyed-hashing algorithm
+  #
+  # == Overview
+  #
+  # CAUTION: Use of this library is discouraged, because this
+  # implementation was meant to be experimental but somehow got into the
+  # 1.9 series without being noticed.  Please use OpenSSL::HMAC in the
+  # "openssl" library instead.
+  #
+  # == Examples
+  #
+  #   require 'digest/hmac'
+  #
+  #   # one-liner example
+  #   puts Digest::HMAC.hexdigest("data", "hash key", Digest::SHA1)
+  #
+  #   # rather longer one
+  #   hmac = Digest::HMAC.new("foo", Digest::RMD160)
+  #
+  #   buf = ""
+  #   while stream.read(16384, buf)
+  #     hmac.update(buf)
+  #   end
+  #
+  #   puts hmac.bubblebabble
+  #
+  class HMAC < Digest::Class
+
+    # Creates a Digest::HMAC instance.
+
+    def initialize(key, digester)
+      @md = digester.new
+
+      block_len = @md.block_length
+
+      if key.bytesize > block_len
+        key = @md.digest(key)
+      end
+
+      ipad = Array.new(block_len, 0x36)
+      opad = Array.new(block_len, 0x5c)
+
+      key.bytes.each_with_index { |c, i|
+        ipad[i] ^= c
+        opad[i] ^= c
+      }
+
+      @key = key.freeze
+      @ipad = ipad.pack('C*').freeze
+      @opad = opad.pack('C*').freeze
+      @md.update(@ipad)
+    end
+
+    def initialize_copy(other) # :nodoc:
+      @md = other.instance_eval { @md.clone }
+    end
+
+    # call-seq:
+    #   hmac.update(string) -> hmac
+    #   hmac << string -> hmac
+    #
+    # Updates the hmac using a given +string+ and returns self.
+    def update(text)
+      @md.update(text)
+      self
+    end
+    alias << update
+
+    # call-seq:
+    #   hmac.reset -> hmac
+    #
+    # Resets the hmac to the initial state and returns self.
+    def reset
+      @md.reset
+      @md.update(@ipad)
+      self
+    end
+
+    def finish # :nodoc:
+      d = @md.digest!
+      @md.update(@opad)
+      @md.update(d)
+      @md.digest!
+    end
+    private :finish
+
+    # call-seq:
+    #   hmac.digest_length -> Integer
+    #
+    # Returns the length in bytes of the hash value of the digest.
+    def digest_length
+      @md.digest_length
+    end
+
+    # call-seq:
+    #   hmac.block_length -> Integer
+    #
+    # Returns the block length in bytes of the hmac.
+    def block_length
+      @md.block_length
+    end
+
+    # call-seq:
+    #   hmac.inspect -> string
+    #
+    # Creates a printable version of the hmac object.
+    def inspect
+      sprintf('#<%s: key=%s, digest=%s>', self.class.name, @key.inspect, @md.inspect.sub(/^\#<(.*)>$/) { $1 });
+    end
+  end
+end
+
+if $0 == __FILE__
+  eval DATA.gets(nil), nil, $0, DATA.lineno
+end
+
+__END__
+
+require 'test/unit'
+
+module TM_HMAC
+  def test_s_hexdigest
+    cases.each { |h|
+      digesters.each { |d|
+        assert_equal(h[:hexdigest], Digest::HMAC.hexdigest(h[:data], h[:key], d))
+      }
+    }
+  end
+
+  def test_hexdigest
+    cases.each { |h|
+      digesters.each { |d|
+        hmac = Digest::HMAC.new(h[:key], d)
+
+        hmac.update(h[:data])
+
+        assert_equal(h[:hexdigest], hmac.hexdigest)
+      }
+    }
+  end
+
+  def test_reset
+    cases.each { |h|
+      digesters.each { |d|
+        hmac = Digest::HMAC.new(h[:key], d)
+        hmac.update("test")
+        hmac.reset
+        hmac.update(h[:data])
+
+        assert_equal(h[:hexdigest], hmac.hexdigest)
+      }
+    }
+  end
+end
+
+class TC_HMAC_MD5 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::MD5, Digest::MD5.new]
+  end
+
+  # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+  def cases
+    [
+     {
+       :key		=> "\x0b" * 16,
+       :data		=> "Hi There",
+       :hexdigest	=> "9294727a3638bb1c13f48ef8158bfc9d",
+     }, {
+       :key		=> "Jefe",
+       :data		=> "what do ya want for nothing?",
+       :hexdigest	=> "750c783e6ab0b503eaa86e310a5db738",
+     }, {
+       :key		=> "\xaa" * 16,
+       :data		=> "\xdd" * 50,
+       :hexdigest	=> "56be34521d144c88dbb8c733f0e8b3f6",
+     }, {
+       :key		=> "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data		=> "\xcd" * 50,
+       :hexdigest	=> "697eaf0aca3a3aea3a75164746ffaa79",
+     }, {
+       :key		=> "\x0c" * 16,
+       :data		=> "Test With Truncation",
+       :hexdigest	=> "56461ef2342edc00f9bab995690efd4c",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest	=> "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest	=> "6f630fad67cda0ee1fb1f562db3aa53e",
+     }
+    ]
+  end
+end
+
+class TC_HMAC_SHA1 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::SHA1, Digest::SHA1.new]
+  end
+
+  # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+  def cases
+    [
+     {
+       :key		=> "\x0b" * 20,
+       :data		=> "Hi There",
+       :hexdigest	=> "b617318655057264e28bc0b6fb378c8ef146be00",
+     }, {
+       :key		=> "Jefe",
+       :data		=> "what do ya want for nothing?",
+       :hexdigest	=> "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+     }, {
+       :key		=> "\xaa" * 20,
+       :data		=> "\xdd" * 50,
+       :hexdigest	=> "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+     }, {
+       :key		=> "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data		=> "\xcd" * 50,
+       :hexdigest	=> "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+     }, {
+       :key		=> "\x0c" * 20,
+       :data		=> "Test With Truncation",
+       :hexdigest	=> "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest	=> "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest	=> "e8e99d0f45237d786d6bbaa7965c7808bbff1a91",
+     }
+    ]
+  end
+end
+
+class TC_HMAC_RMD160 < Test::Unit::TestCase
+  include TM_HMAC
+
+  def digesters
+    [Digest::RMD160, Digest::RMD160.new]
+  end
+
+  # Taken from RFC 2286: Test Cases for HMAC-RIPEMD160 and HMAC-RIPEMD128
+  def cases
+    [
+     {
+       :key		=> "\x0b" * 20,
+       :data		=> "Hi There",
+       :hexdigest	=> "24cb4bd67d20fc1a5d2ed7732dcc39377f0a5668",
+     }, {
+       :key		=> "Jefe",
+       :data		=> "what do ya want for nothing?",
+       :hexdigest	=> "dda6c0213a485a9e24f4742064a7f033b43c4069",
+     }, {
+       :key		=> "\xaa" * 20,
+       :data		=> "\xdd" * 50,
+       :hexdigest	=> "b0b105360de759960ab4f35298e116e295d8e7c1",
+     }, {
+       :key		=> "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+       :data		=> "\xcd" * 50,
+       :hexdigest	=> "d5ca862f4d21d5e610e18b4cf1beb97a4365ecf4",
+     }, {
+       :key		=> "\x0c" * 20,
+       :data		=> "Test With Truncation",
+       :hexdigest	=> "7619693978f91d90539ae786500ff3d8e0518e39",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key - Hash Key First",
+       :hexdigest	=> "6466ca07ac5eac29e1bd523e5ada7605b791fd8b",
+     }, {
+       :key		=> "\xaa" * 80,
+       :data		=> "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+       :hexdigest	=> "69ea60798d71616cce5fd0871e23754cd75d5a0a",
+     }
+    ]
+  end
+end

data/lib/digest/md5.rb

@@ -0,0 +1,23 @@
+# just for compatibility; requiring "md5" is obsoleted
+#
+# $RoughId: md5.rb,v 1.4 2001/07/13 15:38:27 knu Exp $
+# $Id: md5.rb 12008 2007-03-06 10:12:12Z knu $
+
+require 'digest/md5/md5'
+
+class MD5 < Digest::MD5
+  class << self
+    alias orig_new new
+    def new(str = nil)
+      if str
+        orig_new.update(str)
+      else
+        orig_new
+      end
+    end
+
+    def md5(*args)
+      new(*args)
+    end
+  end
+end

data/lib/digest/rmd160.rb

@@ -0,0 +1 @@
+require 'digest/rmd160/rmd160'

data/lib/digest/sha1.rb

@@ -0,0 +1,23 @@
+# just for compatibility; requiring "sha1" is obsoleted
+#
+# $RoughId: sha1.rb,v 1.4 2001/07/13 15:38:27 knu Exp $
+# $Id: sha1.rb 12008 2007-03-06 10:12:12Z knu $
+
+require 'digest/sha1/sha1'
+
+class SHA1 < Digest::SHA1
+  class << self
+    alias orig_new new
+    def new(str = nil)
+      if str
+        orig_new.update(str)
+      else
+        orig_new
+      end
+    end
+
+    def sha1(*args)
+      new(*args)
+    end
+  end
+end

data/lib/digest/sha2.rb

@@ -0,0 +1,74 @@
+#--
+# sha2.rb - defines Digest::SHA2 class which wraps up the SHA256,
+#           SHA384, and SHA512 classes.
+#++
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+#   $Id: sha2.rb 11708 2007-02-12 23:01:19Z shyouhei $
+
+require 'digest'
+require 'digest/sha2/sha2'
+
+module Digest
+  #
+  # A meta digest provider class for SHA256, SHA384 and SHA512.
+  #
+  class SHA2 < Digest::Class
+    # call-seq:
+    #     Digest::SHA2.new(bitlen = 256) -> digest_obj
+    #
+    # Creates a new SHA2 hash object with a given bit length.
+    def initialize(bitlen = 256)
+      case bitlen
+      when 256
+        @sha2 = Digest::SHA256.new
+      when 384
+        @sha2 = Digest::SHA384.new
+      when 512
+        @sha2 = Digest::SHA512.new
+      else
+        raise ArgumentError, "unsupported bit length: %s" % bitlen.inspect
+      end
+      @bitlen = bitlen
+    end
+
+    # :nodoc:
+    def reset
+      @sha2.reset
+      self
+    end
+
+    # :nodoc:
+    def update(str)
+      @sha2.update(str)
+      self
+    end
+    alias << update
+
+    def finish
+      @sha2.digest!
+    end
+    private :finish
+
+    def block_length
+      @sha2.block_length
+    end
+
+    def digest_length
+      @sha2.digest_length
+    end
+
+    # :nodoc:
+    def initialize_copy(other)
+      @sha2 = other.instance_eval { @sha2.clone }
+    end
+
+    # :nodoc:
+    def inspect
+      "#<%s:%d %s>" % [self.class.name, @bitlen, hexdigest]
+    end
+  end
+end

data/lib/digest.rb

@@ -0,0 +1 @@
+require "rubysl/digest"

data/lib/rubysl/digest/digest.rb

@@ -0,0 +1,88 @@
+require 'digest/digest'
+
+module Digest
+  def self.const_missing(name) # :nodoc:
+    case name
+    when :SHA256, :SHA384, :SHA512
+      lib = 'digest/sha2'
+    else
+      lib = File.join('digest', name.to_s.downcase)
+    end
+
+    begin
+      require lib
+    rescue LoadError
+      raise LoadError, "library not found for class Digest::#{name} -- #{lib}", caller(1)
+    end
+    unless Digest.const_defined?(name)
+      raise NameError, "uninitialized constant Digest::#{name}", caller(1)
+    end
+    Digest.const_get(name)
+  end
+
+  class ::Digest::Class
+    # creates a digest object and reads a given file, _name_.
+    #
+    #   p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+    #   # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+    def self.file(name)
+      new.file(name)
+    end
+
+    # Returns the base64 encoded hash value of a given _string_.  The
+    # return value is properly padded with '=' and contains no line
+    # feeds.
+    def self.base64digest(str, *args)
+      [digest(str, *args)].pack('m0')
+    end
+  end
+
+  module Instance
+    # updates the digest with the contents of a given file _name_ and
+    # returns self.
+    def file(name)
+      File.open(name, "rb") {|f|
+        buf = ""
+        while f.read(16384, buf)
+          update buf
+        end
+      }
+      self
+    end
+
+    # If none is given, returns the resulting hash value of the digest
+    # in a base64 encoded form, keeping the digest's state.
+    #
+    # If a +string+ is given, returns the hash value for the given
+    # +string+ in a base64 encoded form, resetting the digest to the
+    # initial state before and after the process.
+    #
+    # In either case, the return value is properly padded with '=' and
+    # contains no line feeds.
+    def base64digest(str = nil)
+      [str ? digest(str) : digest].pack('m0')
+    end
+
+    # Returns the resulting hash value and resets the digest to the
+    # initial state.
+    def base64digest!
+      [digest!].pack('m0')
+    end
+  end
+end
+
+# call-seq:
+#   Digest(name) -> digest_subclass
+#
+# Returns a Digest subclass by +name+.
+#
+#   require 'digest'
+#
+#   Digest("MD5")
+#   # => Digest::MD5
+#
+#   Digest("Foo")
+#   # => LoadError: library not found for class Digest::Foo -- digest/foo
+def Digest(name)
+  Digest.const_get(name)
+end

data/lib/{rubysl-digest → rubysl/digest}/version.rb

@@ -1,5 +1,5 @@
 module RubySL
   module Digest
-    VERSION = "0.0.1"
+    VERSION = "1.0.0"
   end
 end

data/lib/rubysl/digest.rb

@@ -0,0 +1,2 @@
+require "rubysl/digest/version"
+require "rubysl/digest/digest"