keccak 1.2.0

data/ext/digest/displayIntermediateValues.c

@@ -0,0 +1,117 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include <stdio.h>
+#include "displayIntermediateValues.h"
+#include "KeccakNISTInterface.h"
+
+FILE *intermediateValueFile = 0;
+int displayLevel = 0;
+
+void displaySetIntermediateValueFile(FILE *f)
+{
+    intermediateValueFile = f;
+}
+
+void displaySetLevel(int level)
+{
+    displayLevel = level;
+}
+
+void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<size; i++)
+            fprintf(intermediateValueFile, "%02X ", bytes[i]);
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst)
+{
+    unsigned int i, iByte, iBit;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<size; i++) {
+            iByte = i/8;
+            iBit = i%8;
+            if (MSBfirst)
+                fprintf(intermediateValueFile, "%d ", ((data[iByte] << iBit) & 0x80) != 0);
+            else
+                fprintf(intermediateValueFile, "%d ", ((data[iByte] >> iBit) & 0x01) != 0);
+        }
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayStateAsBytes(int level, const char *text, const unsigned char *state)
+{
+    displayBytes(level, text, state, KeccakPermutationSizeInBytes);
+}
+
+void displayStateAs32bitWords(int level, const char *text, const unsigned int *state)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<KeccakPermutationSize/64; i++) {
+            fprintf(intermediateValueFile, "%08X:%08X", (unsigned int)state[2*i+0], (unsigned int)state[2*i+1]);
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+    }
+}
+
+void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<KeccakPermutationSize/64; i++) {
+            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] >> 32));
+            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] & 0xFFFFFFFFULL));
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+    }
+}
+
+void displayRoundNumber(int level, unsigned int i)
+{
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "--- Round %d ---\n", i);
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayText(int level, const char *text)
+{
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s", text);
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}

data/ext/digest/displayIntermediateValues.h

@@ -0,0 +1,29 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _displayIntermediateValues_h_
+#define _displayIntermediateValues_h_
+
+#include <stdio.h>
+
+void displaySetIntermediateValueFile(FILE *f);
+void displaySetLevel(int level);
+void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size);
+void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst);
+void displayStateAsBytes(int level, const char *text, const unsigned char *state);
+void displayStateAs32bitWords(int level, const char *text, const unsigned int *state);
+void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state);
+void displayRoundNumber(int level, unsigned int i);
+void displayText(int level, const char *text);
+
+#endif

data/ext/digest/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+have_header('ruby/digest.h')
+have_func('rb_str_set_len')
+
+$CFLAGS << " -fvisibility=hidden"
+create_makefile('digest/sha3')

data/ext/digest/sha3.c

@@ -0,0 +1,153 @@
+#include "ruby.h"
+#ifdef HAVE_RUBY_DIGEST_H
+#include "ruby/digest.h"
+#else
+#include "digest.h"
+#endif
+#include "KeccakNISTInterface.h"
+
+#define MAX_DIGEST_SIZE 64
+#define DEFAULT_DIGEST_LEN 512
+
+static int sha3_init_func(hashState *ctx);
+static void sha3_update_func(hashState *ctx, unsigned char *str, size_t len);
+static int sha3_finish_func(hashState *ctx, unsigned char *digest);
+
+/*
+  Metadata definition for the SHA3 algorithm.
+  Defines the Version, sizes for block and digest as well as
+  the entry points for the algorithms
+*/
+static rb_digest_metadata_t sha3 = {
+	RUBY_DIGEST_API_VERSION,
+	DEFAULT_DIGEST_LEN,
+	KeccakPermutationSize - (2 * DEFAULT_DIGEST_LEN), //size of blocks
+	sizeof(hashState), //size of context for the object we'll be passed in below functions.
+	(rb_digest_hash_init_func_t)sha3_init_func,
+	(rb_digest_hash_update_func_t)sha3_update_func,
+	(rb_digest_hash_finish_func_t)sha3_finish_func,
+};
+
+/* Initialization function for the algorithm,
+   gets called during allocation of the digest object.
+   we override initialize to do custom hash size, so we don't care too much here.
+*/
+static int
+sha3_init_func(hashState *ctx) {
+  // Just return a 1 ' successful' we override the init function
+  // so this is not necessary
+  // the base class alloc calls this to initialize the algorithm
+  return 1;
+}
+
+/* Update function, take the current context and add str to it */
+static void
+sha3_update_func(hashState *ctx, unsigned char *str, size_t len) {
+	Update(ctx, str, len * 8);
+}
+
+/* Finish the hash calculation and return the finished string */
+static int
+sha3_finish_func(hashState *ctx, unsigned char *digest) {
+	Final(ctx, digest);
+	return 1;
+}
+
+/* Ruby method.  Digest::SHA3#finish()
+ * No Arguments
+ * @returns [String] Encoded Digest String
+ */
+static VALUE
+rb_sha3_finish(VALUE self) {
+  hashState *ctx;
+  VALUE digest;
+
+  ctx = (hashState *)RTYPEDDATA_DATA(self);
+  digest = rb_str_new(0, ctx->capacity / 2 / 8);
+  sha3_finish_func(ctx, (unsigned char *)RSTRING_PTR(digest));
+
+  return digest;
+}
+
+/* :nodoc: private method
+ * initialize the ctx with the bitlength
+ */
+static void
+sha3_init(hashState *ctx, size_t bitlen) {
+	switch (Init(ctx, bitlen)) {
+	case SUCCESS:
+		return;
+	case FAIL:
+		rb_raise(rb_eRuntimeError, "Unknown error");
+	case BAD_HASHLEN:
+		rb_raise(rb_eArgError, "Bad hash length (must be 0, 224, 256, 384 or 512)");
+	default:
+		rb_raise(rb_eRuntimeError, "Unknown error code");
+	}
+}
+
+/* Ruby method.  Digest::SHA3.new(hashlen)
+ * @param hashlen The length of hash, only supports 224, 256, 384 or 512
+ * @returns [Digest::SHA3] new object.
+ */
+static VALUE
+rb_sha3_initialize(int argc, VALUE *argv, VALUE self) {
+	hashState *ctx;
+	VALUE hashlen;
+	int i_hashlen;
+
+	if (rb_scan_args(argc, argv, "01", &hashlen) == 0) {
+		i_hashlen = DEFAULT_DIGEST_LEN;
+	} else {
+		i_hashlen = NUM2INT(hashlen);
+	}
+	if ( i_hashlen == 0) {
+		rb_raise(rb_eArgError, "Unsupported hash length");
+  }
+
+  ctx = (hashState *)RTYPEDDATA_DATA(self);
+	sha3_init(ctx, i_hashlen);
+
+	return rb_call_super(0, NULL);
+}
+
+/* Ruby method.  Digest::SHA3#digest_length
+ * @returns [Numeric] Length of the digest.
+ */
+static VALUE
+rb_sha3_digest_length(VALUE self) {
+	hashState *ctx;
+
+	ctx = (hashState *)RTYPEDDATA_DATA(self);
+	return INT2FIX(ctx->capacity / 2 / 8);
+}
+
+/* Ruby method.  Digest::SHA3#block_length
+ * @returns [Numeric] Length of blocks in this digest.
+ */
+static VALUE
+rb_sha3_block_length(VALUE self) {
+	hashState *ctx;
+
+	ctx = (hashState *)RTYPEDDATA_DATA(self);
+	return INT2FIX(ctx->rate / 8);
+}
+
+void __attribute__((visibility("default")))
+Init_sha3() {
+	VALUE mDigest, cDigest_Base, cSHA3;
+
+	rb_require("digest");
+
+	mDigest = rb_path2class("Digest");
+	cDigest_Base = rb_path2class("Digest::Base");
+
+	cSHA3 = rb_define_class_under(mDigest, "SHA3", cDigest_Base);
+
+	rb_iv_set(cSHA3, "metadata", Data_Wrap_Struct(0, 0, 0, (void *)&sha3));
+
+  rb_define_method(cSHA3, "initialize", rb_sha3_initialize, -1);
+  rb_define_method(cSHA3, "digest_length", rb_sha3_digest_length, 0);
+  rb_define_method(cSHA3, "block_length", rb_sha3_block_length, 0);
+  rb_define_method(cSHA3, "finish", rb_sha3_finish, 0);
+}

data/keccak.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('lib/digest/sha3/version')
+
+Gem::Specification.new do |s|
+  s.name = "keccak"
+  s.version = Digest::SHA3::Version::STRING
+  s.summary = "The Keccak (SHA-3) hash used by Ethereum."
+  s.email = "ruby@q9f.cc"
+  s.homepage = "https://github.com/q9f/keccak.rb"
+  s.description = "The Keccak (SHA-3) hash use by Ethereum. This does not implement the final FIPS202 standard, today known as SHA3 but rather an early version, commonly referred to as Keccak."
+  s.authors = ["Afri Schoedon", "Chris Metcalfe", "Hongli Lai (Phusion)", "Keccak authors"]
+  s.extensions << "ext/digest/extconf.rb"
+  s.required_ruby_version = ">= 2.2"
+  s.license = "Apache-2.0"
+
+  s.files = Dir[
+    "README.md",
+    "COPYRIGHT",
+    "LICENSE",
+    "Makefile",
+    "keccak.gemspec",
+    "ext/**/*.{c,h,rb}",
+    "lib/**/*"
+  ]
+end

data/lib/digest/sha3/version.rb

@@ -0,0 +1,7 @@
+module Digest
+  class SHA3
+    module Version
+      STRING = "1.2.0"
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: keccak
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Afri Schoedon
+- Chris Metcalfe
+- Hongli Lai (Phusion)
+- Keccak authors
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-30 00:00:00.000000000 Z
+dependencies: []
+description: The Keccak (SHA-3) hash use by Ethereum. This does not implement the
+  final FIPS202 standard, today known as SHA3 but rather an early version, commonly
+  referred to as Keccak.
+email: ruby@q9f.cc
+executables: []
+extensions:
+- ext/digest/extconf.rb
+extra_rdoc_files: []
+files:
+- COPYRIGHT
+- LICENSE
+- Makefile
+- README.md
+- ext/digest/KeccakF-1600-int-set.h
+- ext/digest/KeccakF-1600-interface.h
+- ext/digest/KeccakF-1600-reference.c
+- ext/digest/KeccakNISTInterface.c
+- ext/digest/KeccakNISTInterface.h
+- ext/digest/KeccakSponge.c
+- ext/digest/KeccakSponge.h
+- ext/digest/brg_endian.h
+- ext/digest/displayIntermediateValues.c
+- ext/digest/displayIntermediateValues.h
+- ext/digest/extconf.rb
+- ext/digest/sha3.c
+- keccak.gemspec
+- lib/digest/sha3/version.rb
+homepage: https://github.com/q9f/keccak.rb
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.27
+signing_key:
+specification_version: 4
+summary: The Keccak (SHA-3) hash used by Ethereum.
+test_files: []