digest 1.0.0

data/ext/digest/sha2/sha2.h

@@ -0,0 +1,225 @@
+/*
+ * FILE:	sha2.h
+ * AUTHOR:	Aaron D. Gifford - http://www.aarongifford.com/
+ *
+ * Copyright (c) 2000-2001, 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 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 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.
+ *
+ * $OrigId: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
+ * $RoughId: sha2.h,v 1.3 2002/02/24 08:14:32 knu Exp $
+ * $Id$
+ */
+
+#ifndef __SHA2_H__
+#define __SHA2_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * Import u_intXX_t size_t type definitions from system headers.  You
+ * may need to change this, or define these things yourself in this
+ * file.
+ */
+#include <sys/types.h>
+
+#ifdef RUBY
+# ifdef HAVE_PROTOTYPES
+#  undef NOPROTO
+# else
+#  define NOPROTO
+# endif /* HAVE_PROTOTYPES */
+# ifndef BYTE_ORDER
+#  define LITTLE_ENDIAN	1234
+#  define BIG_ENDIAN	4321
+#  ifdef WORDS_BIGENDIAN
+#   define BYTE_ORDER	BIG_ENDIAN
+#  else
+#   define BYTE_ORDER	LITTLE_ENDIAN
+#  endif
+# endif /* BYTE_ORDER */
+# define SHA2_USE_INTTYPES_H
+#else /* RUBY */
+#ifdef SHA2_USE_INTTYPES_H
+
+#include <inttypes.h>
+
+#endif /* SHA2_USE_INTTYPES_H */
+#endif /* RUBY */
+
+
+/*** 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 *******************************/
+/* NOTE: If your architecture does not define either u_intXX_t types or
+ * uintXX_t (from inttypes.h), you may need to define things by hand
+ * for your system:
+ */
+#ifndef SHA2_USE_INTTYPES_H
+# ifdef HAVE_U_INT8_T
+typedef u_int8_t uint8_t;		/* 1-byte  (8-bits)  */
+typedef u_int32_t uint32_t;		/* 4-bytes (32-bits) */
+typedef u_int64_t uint64_t;		/* 8-bytes (64-bits) */
+# else
+typedef unsigned char uint8_t;		/* 1-byte  (8-bits)  */
+typedef unsigned int uint32_t;		/* 4-bytes (32-bits) */
+typedef unsigned long long uint64_t;	/* 8-bytes (64-bits) */
+# endif
+#endif
+
+/*
+ * Most BSD systems already define u_intXX_t types, as does Linux.
+ * Some systems, however, like Compaq's Tru64 Unix instead can use
+ * uintXX_t types defined by very recent ANSI C standards and included
+ * in the file:
+ *
+ *   #include <inttypes.h>
+ *
+ * If you choose to use <inttypes.h> then please define:
+ *
+ *   #define SHA2_USE_INTTYPES_H
+ *
+ * Or on the command line during compile:
+ *
+ *   cc -DSHA2_USE_INTTYPES_H ...
+ */
+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;
+
+
+/*** SHA-256/384/512 Function Prototypes ******************************/
+#ifdef RUBY
+#define SHA256_Init		rb_Digest_SHA256_Init
+#define SHA256_Update		rb_Digest_SHA256_Update
+#define SHA256_Finish		rb_Digest_SHA256_Finish
+#define SHA256_Data		rb_Digest_SHA256_Data
+#define SHA256_End		rb_Digest_SHA256_End
+#define SHA256_Last		rb_Digest_SHA256_Last
+#define SHA256_Transform	rb_Digest_SHA256_Transform
+#define SHA256_Final(d, c)	SHA256_Finish(c, d)
+
+#define SHA384_Init		rb_Digest_SHA384_Init
+#define SHA384_Update		rb_Digest_SHA384_Update
+#define SHA384_Finish		rb_Digest_SHA384_Finish
+#define SHA384_Data		rb_Digest_SHA384_Data
+#define SHA384_End		rb_Digest_SHA384_End
+#define SHA384_Last		rb_Digest_SHA384_Last
+#define SHA384_Transform	rb_Digest_SHA384_Transform
+#define SHA384_Final(d, c)	SHA384_Finish(c, d)
+
+#define SHA512_Init		rb_Digest_SHA512_Init
+#define SHA512_Update		rb_Digest_SHA512_Update
+#define SHA512_Finish		rb_Digest_SHA512_Finish
+#define SHA512_Data		rb_Digest_SHA512_Data
+#define SHA512_End		rb_Digest_SHA512_End
+#define SHA512_Last		rb_Digest_SHA512_Last
+#define SHA512_Transform	rb_Digest_SHA512_Transform
+#define SHA512_Final(d, c)	SHA512_Finish(c, d)
+#endif /* RUBY */
+
+#ifndef NOPROTO
+
+int SHA256_Init(SHA256_CTX *);
+void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
+int SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
+char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
+char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+
+int SHA384_Init(SHA384_CTX*);
+void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
+int SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
+char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
+char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+
+int SHA512_Init(SHA512_CTX*);
+void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
+int SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
+char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
+char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+
+#else /* NOPROTO */
+
+int SHA256_Init();
+void SHA256_Update();
+#ifdef RUBY
+int SHA256_Finish();
+#else
+int SHA256_Final();
+#endif /* RUBY */
+char* SHA256_End();
+char* SHA256_Data();
+
+int SHA384_Init();
+void SHA384_Update();
+#ifdef RUBY
+int SHA384_Finish();
+#else
+int SHA384_Final();
+#endif /* RUBY */
+char* SHA384_End();
+char* SHA384_Data();
+
+int SHA512_Init();
+void SHA512_Update();
+#ifdef RUBY
+int SHA512_Finish();
+#else
+int SHA512_Final();
+#endif /* RUBY */
+char* SHA512_End();
+char* SHA512_Data();
+
+#endif /* NOPROTO */
+
+#ifdef	__cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __SHA2_H__ */
+

data/ext/digest/sha2/sha2cc.h

@@ -0,0 +1,31 @@
+#define COMMON_DIGEST_FOR_OPENSSL 1
+#include <CommonCrypto/CommonDigest.h>
+
+#define SHA256_BLOCK_LENGTH	CC_SHA256_BLOCK_BYTES
+#define SHA384_BLOCK_LENGTH	CC_SHA384_BLOCK_BYTES
+#define SHA512_BLOCK_LENGTH	CC_SHA512_BLOCK_BYTES
+
+#define SHA384_CTX		CC_SHA512_CTX
+
+static DEFINE_UPDATE_FUNC_FOR_UINT(SHA256)
+static DEFINE_FINISH_FUNC_FROM_FINAL(SHA256)
+static DEFINE_UPDATE_FUNC_FOR_UINT(SHA384)
+static DEFINE_FINISH_FUNC_FROM_FINAL(SHA384)
+static DEFINE_UPDATE_FUNC_FOR_UINT(SHA512)
+static DEFINE_FINISH_FUNC_FROM_FINAL(SHA512)
+
+
+#undef SHA256_Update
+#undef SHA256_Finish
+#define SHA256_Update rb_digest_SHA256_update
+#define SHA256_Finish rb_digest_SHA256_finish
+
+#undef SHA384_Update
+#undef SHA384_Finish
+#define SHA384_Update rb_digest_SHA384_update
+#define SHA384_Finish rb_digest_SHA384_finish
+
+#undef SHA512_Update
+#undef SHA512_Finish
+#define SHA512_Update rb_digest_SHA512_update
+#define SHA512_Finish rb_digest_SHA512_finish

data/ext/digest/sha2/sha2init.c

@@ -0,0 +1,55 @@
+/* $RoughId: sha2init.c,v 1.3 2001/07/13 20:00:43 knu Exp $ */
+/* $Id$ */
+
+#include <ruby/ruby.h>
+#include "../digest.h"
+#if defined(SHA2_USE_COMMONDIGEST)
+#include "sha2cc.h"
+#else
+#include "sha2.h"
+#endif
+
+#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(void)
+{
+    VALUE mDigest, cDigest_Base;
+    ID id_metadata = rb_id_metadata();
+
+#define DECLARE_ALGO_CLASS(bitlen) \
+    VALUE cDigest_SHA##bitlen;
+
+    FOREACH_BITLEN(DECLARE_ALGO_CLASS)
+
+    mDigest = rb_digest_namespace();
+    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(0, 0, 0, (void *)&sha##bitlen));
+
+#undef RUBY_UNTYPED_DATA_WARNING
+#define RUBY_UNTYPED_DATA_WARNING 0
+    FOREACH_BITLEN(DEFINE_ALGO_CLASS)
+}

data/ext/digest/test.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+#
+# $RoughId: test.sh,v 1.5 2001/07/13 15:38:27 knu Exp $
+# $Id$
+
+RUBY=${RUBY:=ruby}
+MAKE=${MAKE:=make}
+CFLAGS=${CFLAGS:=-Wall}
+
+${RUBY} extconf.rb --with-cflags="${CFLAGS}"
+${MAKE} clean
+${MAKE}
+
+for algo in md5 rmd160 sha1 sha2; do
+    args=--with-cflags="${CFLAGS}"
+
+    if [ $WITH_BUNDLED_ENGINES ]; then
+	args="$args --with-bundled-$algo"
+    fi
+
+    (cd $algo &&
+	${RUBY} extconf.rb $args;
+	${MAKE} clean;
+	${MAKE})
+    ln -sf ../../$algo/$algo.so lib/digest/
+done
+
+${RUBY} -I. -I./lib ../../test/digest/test_digest.rb
+
+rm lib/digest/*.so

data/ext/openssl/deprecation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: false
+module OpenSSL
+  def self.deprecated_warning_flag
+    unless flag = (@deprecated_warning_flag ||= nil)
+      if try_compile("", flag = "-Werror=deprecated-declarations")
+        $warnflags << " #{flag}"
+      else
+        flag = ""
+      end
+      @deprecated_warning_flag = flag
+    end
+    flag
+  end
+
+  def self.check_func(func, header)
+    have_func(func, header, deprecated_warning_flag)
+  end
+
+  def self.check_func_or_macro(func, header)
+    check_func(func, header) or
+      have_macro(func, header) && $defs.push("-DHAVE_#{func.upcase}")
+  end
+end

data/lib/digest.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: false
+require 'digest.so'
+
+module Digest
+  # A mutex for Digest().
+  REQUIRE_MUTEX = Thread::Mutex.new
+
+  def self.const_missing(name) # :nodoc:
+    case name
+    when :SHA256, :SHA384, :SHA512
+      lib = 'digest/sha2.so'
+    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_.
+    # Optional arguments are passed to the constructor of the digest
+    # class.
+    #
+    #   p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+    #   # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+    def self.file(name, *args)
+      new(*args).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+ in a thread-safe manner even
+# when on-demand loading is involved.
+#
+#   require 'digest'
+#
+#   Digest("MD5")
+#   # => Digest::MD5
+#
+#   Digest(:SHA256)
+#   # => Digest::SHA256
+#
+#   Digest(:Foo)
+#   # => LoadError: library not found for class Digest::Foo -- digest/foo
+def Digest(name)
+  const = name.to_sym
+  Digest::REQUIRE_MUTEX.synchronize {
+    # Ignore autoload's because it is void when we have #const_missing
+    Digest.const_missing(const)
+  }
+rescue LoadError
+  # Constants do not necessarily rely on digest/*.
+  if Digest.const_defined?(const)
+    Digest.const_get(const)
+  else
+    raise
+  end
+end