sha3 0.2.6 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 436b7ffcabd2a9189627fae92670969c380bcb32
-  data.tar.gz: 8acf1e3317cd25aed84682f3c00859ac9bd77def
+  metadata.gz: 4eb74d4c4626be8751f643664a1820c0227a88dd
+  data.tar.gz: bb6c33da2459890eeb083874e209cbf75b3ca83e
 SHA512:
-  metadata.gz: 1a9de0610411fca06486af4f447d8ea965726dc7e00bca1ae1ca9548c65156d34505c6aca06307a5bfec353fccad0ded756b2f446e01fbfcb57b45a25d722525
-  data.tar.gz: 992efbc3bf525432faabde2c4ecc30435cc49718e76a7a5e9c27766f61bc3e5cf507535f42fc5efcfe3ec89d30491c4e1909a53092a58c98a0756afc868a95db
+  metadata.gz: ed137cc7d02d2c376b256c96f55bd430305fead1d00942cc251f7027c9651d08877b1a31372c9822cb8daf5fcebae689683b59c216d5bf3ffe413e179a5258cb
+  data.tar.gz: 1446633b9181a36ed9b0fa04a3d2a7593add059fbe473a496ad35b9c0837da9dd690b167d8bb2d2ea036b6dca60f83b644e8e0719e728d8883aa72064ed8a32d

data/.gitignore

@@ -20,3 +20,5 @@ tmp
 _yardoc
 doc/
 Gemfile.lock
+
+.idea/

data/.travis.yml

@@ -1,11 +1,11 @@
 language: ruby
 rvm:
+  - ruby-head
   - 2.1.0
   - 2.0.0
   - 1.9.3
   - 1.9.2
   - 1.8.7
-  - ruby-head
   - rbx-2
 
 gemfile: Gemfile.ci
@@ -13,3 +13,11 @@ gemfile: Gemfile.ci
 branches:
   only:
     - master
+
+os:
+  - linux
+  - osx
+
+matrix:
+  allow_failures:
+    - os: osx

data/Gemfile.ci

@@ -2,10 +2,10 @@ source "http://rubygems.org"
 
 gemspec
 
-gem 'rubygems-tasks', '> 0.2'
-gem 'rake', '> 0.9'
-gem 'rspec', '~> 2.11'
-gem 'yard', '~> 0.8'
+gem 'rubygems-tasks'
+gem 'rake'
+gem 'rspec', '~> 3.3'
+gem 'yard'
 
 platforms :rbx do
   gem 'racc'

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Johanns Gregorian
+Copyright (c) 2015 Johanns Gregorian
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,145 @@
+# sha3  
+
+[![Gem Version](https://badge.fury.io/rb/sha3.svg)](https://badge.fury.io/rb/sha3) [![CI](https://secure.travis-ci.org/johanns/sha3.png)](https://secure.travis-ci.org/johanns/sha3) [![Dependencies](https://gemnasium.com/johanns/sha3.png)](https://gemnasium.com/johanns/sha3) [![CodeClimate](https://codeclimate.com/github/johanns/sha3.png)](https://codeclimate.com/github/johanns/sha3)
+
+**SHA3 for Ruby** is a native (C) binding to SHA3 (Keccak FIPS 202) cryptographic hashing algorithm.
+
+- Home :: [https://github.com/johanns/sha3#readme]()
+- Issues :: [https://github.com/johanns/sha3/issues]()
+- Documentation :: [http://rubydoc.info/gems/sha3/frames]()
+
+## Warnings
+
+- Version 1.0+ breaks compatibility with previous versions of this gem.
+- Do NOT use SHA3 to hash passwords; use either ```bcrypt``` or ```scrypt``` instead!
+
+## Module details
+
+**SHA3::Digest**: A standard *Digest* _subclass_. The interface, and operation of this class are parallel to digest classes bundled with MRI-based Rubies (e.g.: **Digest::SHA2**, and **OpenSSL::Digest**).
+
+See [documentation for Ruby's **Digest** class for additional details](http://www.ruby-doc.org/stdlib-2.2.3/libdoc/digest/rdoc/Digest.html).
+
+## Installation
+
+```shell
+gem install sha3
+```
+
+## Usage
+
+```ruby
+require 'sha3'
+```
+
+Valid hash bit-lengths are: *224*, *256*, *384*, *512*.
+
+```ruby
+:sha224  :sha256  :sha384  :sha512
+
+# SHA3::Digest.new(224) is SHA3::Digest.new(:sha224)
+```
+
+Alternatively, you can instantiate using one of four sub-classes:
+
+```ruby
+SHA3::Digest::SHA224.new() # 224 bits
+SHA3::Digest::SHA256.new() # 256 bits
+SHA3::Digest::SHA384.new() # 384 bits
+SHA3::Digest::SHA512.new() # 512 bits
+```
+
+### Basics
+
+```ruby
+# Instantiate a new SHA3::Digest class with 256 bit length
+s = SHA3::Digest.new(:sha256)
+
+# OR #
+
+s = SHA3::Digest::SHA256.new()
+
+# Update hash state, and compute new value
+s.update "Compute Me"
+
+# << is an .update() alias
+s << "Me too"
+
+# Returns digest value in bytes
+s.digest
+# => "\xBE\xDF\r\xD9\xA1..."
+
+# Returns digest value as hex string
+s.hexdigest
+# => "bedf0dd9a15b647..."
+
+### Digest class-methods: ###
+
+SHA3::Digest.hexdigest(:sha224, "Hash me, please")
+# => "200e7bc18cd613..."
+
+SHA3::Digest::SHA384.digest("Hash me, please")
+# => "\xF5\xCEpC\xB0eV..."
+```
+
+### Hashing a file
+
+```ruby
+# Compute the hash value for given file, and return the result as hex
+s = SHA3::Digest::SHA224.file("my_fantastical_file.bin").hexdigest
+
+# Calling SHA3::Digest.file(...) defaults to SHA256
+s = SHA3::Digest.file("tests.sh")
+# => #<SHA3::Digest: a9801db49389339...>
+```
+
+## Development
+
+* Native build tools (e.g., GCC, Minigw, etc.)
+* Gems: rubygems-tasks, rake, rspec, yard
+
+### Testing + RSpec
+
+Call ```rake``` to run the included RSpec tests.
+
+Only a small subset of test vectors are included in the source repository; however, the complete test vectors suite is available for download. Simply run the ```tests.sh``` shell script (available in the root of source directory) to generate full byte-length RSpec test files.
+
+  ```sh tests.sh```
+
+### Rubies
+
+Tested with Rubies:
+
+  - MRI Ruby-Head
+  - MRI 2.1.0
+  - MRI 2.0.0
+  - MRI 1.9.3
+  - MRI 1.9.2
+  - MRI 1.8.7
+  - Rubinius 2
+
+On:
+
+  - Ubuntu 12.04, 12.10, 13.04, 14.04, 15.04
+  - Windows 7, 8, 8.1, 10
+  - Mac OS X 10.6 - 10.11
+
+## Releases
+
+- *1.0.1* :: FIPS 202 compliance (breaks compatibility with earlier releases)
+- *0.2.6* :: Fixed bug #4
+- *0.2.5* :: Bug fixes. (See ChangeLog.rdoc)
+- *0.2.4* :: Bug fixes. (YANKED)
+- *0.2.3* :: Added documentation file (decoupled form C source); refactored C source.
+- *0.2.2* :: Added sub-class for each SHA3 supported bit-lengths (example: SHA3::Digest::SHA256). Minor bug fix.
+- *0.2.0* :: Production worthy, but breaks API compatibility with 0.1.x. Backward-compatibility will be maintained henceforth.
+- *0.1.x* :: Alpha code, and not suitable for production.
+
+## TO DO
+
+- Add SHAKE128/256 support
+
+## Copyright
+
+Copyright (c) 2012 - 2015 Johanns Gregorian (https://github.com/johanns)
+
+**See LICENSE.txt for details.**

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems'
 require 'rake'
 
 begin
-  gem 'rubygems-tasks', '~> 0.2'
+  gem 'rubygems-tasks'
   require 'rubygems/tasks'
 
   Gem::Tasks.new
@@ -14,7 +14,7 @@ rescue LoadError => e
 end
 
 begin
-  gem 'rspec', '~> 2.4'
+  gem 'rspec', '~> 3.3'
   require 'rspec/core/rake_task'
 
   RSpec::Core::RakeTask.new
@@ -28,10 +28,10 @@ task :test    => :spec
 task :default => [:compile, :spec]
 
 begin
-  gem 'yard', '~> 0.8'
+  gem 'yard'
   require 'yard'
 
-  YARD::Rake::YardocTask.new  
+  YARD::Rake::YardocTask.new
 rescue LoadError => e
   task :yard do
     abort "Please run `gem install yard` to install YARD."
@@ -54,4 +54,3 @@ rescue LoadError => e
     abort "Please run `gem install rake-compiler` to install Rake-Compiler."
   end
 end
-

data/ext/sha3/KeccakF-1600-interface.h

@@ -1,46 +1,40 @@
 /*
-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 Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
 
-Implementation by the designers,
-hereby denoted as "the implementer".
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
 
 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 _KeccakPermutationInterface_h_
-#define _KeccakPermutationInterface_h_
+#ifndef _KeccakF1600Interface_h_
+#define _KeccakF1600Interface_h_
 
-#include "KeccakF-1600-int-set.h"
+#include <string.h>
 
-void KeccakInitialize( void );
-void KeccakInitializeState(unsigned char *state);
-void KeccakPermutation(unsigned char *state);
-#ifdef ProvideFast576
-void KeccakAbsorb576bits(unsigned char *state, const unsigned char *data);
-#endif
-#ifdef ProvideFast832
-void KeccakAbsorb832bits(unsigned char *state, const unsigned char *data);
-#endif
-#ifdef ProvideFast1024
-void KeccakAbsorb1024bits(unsigned char *state, const unsigned char *data);
-#endif
-#ifdef ProvideFast1088
-void KeccakAbsorb1088bits(unsigned char *state, const unsigned char *data);
-#endif
-#ifdef ProvideFast1152
-void KeccakAbsorb1152bits(unsigned char *state, const unsigned char *data);
-#endif
-#ifdef ProvideFast1344
-void KeccakAbsorb1344bits(unsigned char *state, const unsigned char *data);
-#endif
-void KeccakAbsorb(unsigned char *state, const unsigned char *data, unsigned int laneCount);
-#ifdef ProvideFast1024
-void KeccakExtract1024bits(const unsigned char *state, unsigned char *data);
-#endif
-void KeccakExtract(const unsigned char *state, unsigned char *data, unsigned int laneCount);
+#define KeccakF_width 1600
+#define KeccakF_laneInBytes 8
+#define KeccakF_stateSizeInBytes (KeccakF_width/8)
+#define KeccakF_1600
+
+void KeccakF1600_Initialize( void );
+void KeccakF1600_StateInitialize(void *state);
+void KeccakF1600_StateXORBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakF1600_StateOverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakF1600_StateOverwriteWithZeroes(void *state, unsigned int byteCount);
+void KeccakF1600_StateComplementBit(void *state, unsigned int position);
+void KeccakF1600_StatePermute(void *state);
+void KeccakF1600_StateExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakF1600_StateExtractAndXORBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+size_t KeccakF1600_FBWL_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen, unsigned char trailingBits);
+size_t KeccakF1600_FBWL_Squeeze(void *state, unsigned int laneCount, unsigned char *data, size_t dataByteLen);
+size_t KeccakF1600_FBWL_Wrap(void *state, unsigned int laneCount, const unsigned char *dataIn, unsigned char *dataOut, size_t dataByteLen, unsigned char trailingBits);
+size_t KeccakF1600_FBWL_Unwrap(void *state, unsigned int laneCount, const unsigned char *dataIn, unsigned char *dataOut, size_t dataByteLen, unsigned char trailingBits);
 
 #endif

data/ext/sha3/KeccakHash.c

@@ -0,0 +1,80 @@
+/*
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
+
+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 <string.h>
+#include "KeccakHash.h"
+
+/* ---------------------------------------------------------------- */
+
+HashReturn Keccak_HashInitialize(Keccak_HashInstance *instance, unsigned int rate, unsigned int capacity, unsigned int hashbitlen, unsigned char delimitedSuffix)
+{
+    HashReturn result;
+
+    if (delimitedSuffix == 0)
+        return FAIL;
+    result = (HashReturn)Keccak_SpongeInitialize(&instance->sponge, rate, capacity);
+    if (result != SUCCESS)
+        return result;
+    instance->fixedOutputLength = hashbitlen;
+    instance->delimitedSuffix = delimitedSuffix;
+    return SUCCESS;
+}
+
+/* ---------------------------------------------------------------- */
+
+HashReturn Keccak_HashUpdate(Keccak_HashInstance *instance, const BitSequence *data, DataLength databitlen)
+{
+    if ((databitlen % 8) == 0)
+        return (HashReturn)Keccak_SpongeAbsorb(&instance->sponge, data, databitlen/8);
+    else {
+        HashReturn ret = (HashReturn)Keccak_SpongeAbsorb(&instance->sponge, data, databitlen/8);
+        if (ret == SUCCESS) {
+            // The last partial byte is assumed to be aligned on the least significant bits
+            unsigned char lastByte = data[databitlen/8];
+            // Concatenate the last few bits provided here with those of the suffix
+            unsigned short delimitedLastBytes = (unsigned short)lastByte | ((unsigned short)instance->delimitedSuffix << (databitlen % 8));
+            if ((delimitedLastBytes & 0xFF00) == 0x0000) {
+                instance->delimitedSuffix = delimitedLastBytes & 0xFF;
+            }
+            else {
+                unsigned char oneByte[1];
+                oneByte[0] = delimitedLastBytes & 0xFF;
+                ret = (HashReturn)Keccak_SpongeAbsorb(&instance->sponge, oneByte, 1);
+                instance->delimitedSuffix = (delimitedLastBytes >> 8) & 0xFF;
+            }
+        }
+        return ret;
+    }
+}
+
+/* ---------------------------------------------------------------- */
+
+HashReturn Keccak_HashFinal(Keccak_HashInstance *instance, BitSequence *hashval)
+{
+    HashReturn ret = (HashReturn)Keccak_SpongeAbsorbLastFewBits(&instance->sponge, instance->delimitedSuffix);
+    if (ret == SUCCESS)
+        return (HashReturn)Keccak_SpongeSqueeze(&instance->sponge, hashval, instance->fixedOutputLength/8);
+    else
+        return ret;
+}
+
+/* ---------------------------------------------------------------- */
+
+HashReturn Keccak_HashSqueeze(Keccak_HashInstance *instance, BitSequence *data, DataLength databitlen)
+{
+    if ((databitlen % 8) != 0)
+        return FAIL;
+    return (HashReturn)Keccak_SpongeSqueeze(&instance->sponge, data, databitlen/8);
+}

data/ext/sha3/KeccakHash.h

@@ -0,0 +1,110 @@
+/*
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
+
+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 _KeccakHashInterface_h_
+#define _KeccakHashInterface_h_
+
+#include "KeccakSponge.h"
+#include <string.h>
+
+typedef unsigned char BitSequence;
+typedef size_t DataLength;
+typedef enum { SUCCESS = 0, FAIL = 1, BAD_HASHLEN = 2 } HashReturn;
+
+typedef struct {
+    Keccak_SpongeInstance sponge;
+    unsigned int fixedOutputLength;
+    unsigned char delimitedSuffix;
+} Keccak_HashInstance;
+
+/**
+  * Function to initialize the Keccak[r, c] sponge function instance used in sequential hashing mode.
+  * @param  hashInstance    Pointer to the hash instance to be initialized.
+  * @param  rate        The value of the rate r.
+  * @param  capacity    The value of the capacity c.
+  * @param  hashbitlen  The desired number of output bits,
+  *                     or 0 for an arbitrarily-long output.
+  * @param  delimitedSuffix Bits that will be automatically appended to the end
+  *                         of the input message, as in domain separation.
+  *                         This is a byte containing from 0 to 7 bits
+  *                         formatted like the @a delimitedData parameter of
+  *                         the Keccak_SpongeAbsorbLastFewBits() function.
+  * @pre    One must have r+c=1600 and the rate a multiple of 8 bits in this implementation.
+  * @return SUCCESS if successful, FAIL otherwise.
+  */
+HashReturn Keccak_HashInitialize(Keccak_HashInstance *hashInstance, unsigned int rate, unsigned int capacity, unsigned int hashbitlen, unsigned char delimitedSuffix);
+
+/** Macro to initialize a SHAKE128 instance as specified in the FIPS 202 standard.
+  */
+#define Keccak_HashInitialize_SHAKE128(hashInstance)        Keccak_HashInitialize(hashInstance, 1344,  256,   0, 0x1F)
+
+/** Macro to initialize a SHAKE256 instance as specified in the FIPS 202 standard.
+  */
+#define Keccak_HashInitialize_SHAKE256(hashInstance)        Keccak_HashInitialize(hashInstance, 1088,  512,   0, 0x1F)
+
+/** Macro to initialize a SHA3-224 instance as specified in the FIPS 202 standard.
+  */
+#define Keccak_HashInitialize_SHA3_224(hashInstance)        Keccak_HashInitialize(hashInstance, 1152,  448, 224, 0x06)
+
+/** Macro to initialize a SHA3-256 instance as specified in the FIPS 202 standard.
+  */
+#define Keccak_HashInitialize_SHA3_256(hashInstance)        Keccak_HashInitialize(hashInstance, 1088,  512, 256, 0x06)
+
+/** Macro to initialize a SHA3-384 instance as specified in the FIPS 202 standard.
+  */
+#define Keccak_HashInitialize_SHA3_384(hashInstance)        Keccak_HashInitialize(hashInstance,  832,  768, 384, 0x06)
+
+/** Macro to initialize a SHA3-512 instance as specified in the FIPS 202 standard.
+  */
+#define Keccak_HashInitialize_SHA3_512(hashInstance)        Keccak_HashInitialize(hashInstance,  576, 1024, 512, 0x06)
+
+/**
+  * Function to give input data to be absorbed.
+  * @param  hashInstance    Pointer to the hash instance initialized by Keccak_HashInitialize().
+  * @param  data        Pointer to the input data.
+  *                     When @a databitLen is not a multiple of 8, the last bits of data must be
+  *                     in the least significant bits of the last byte (little-endian convention).
+  * @param  databitLen  The number of input bits provided in the input data.
+  * @pre    In the previous call to Keccak_HashUpdate(), databitlen was a multiple of 8.
+  * @return SUCCESS if successful, FAIL otherwise.
+  */
+HashReturn Keccak_HashUpdate(Keccak_HashInstance *hashInstance, const BitSequence *data, DataLength databitlen);
+
+/**
+  * Function to call after all input blocks have been input and to get
+  * output bits if the length was specified when calling Keccak_HashInitialize().
+  * @param  hashInstance    Pointer to the hash instance initialized by Keccak_HashInitialize().
+  * If @a hashbitlen was not 0 in the call to Keccak_HashInitialize(), the number of
+  *     output bits is equal to @a hashbitlen.
+  * If @a hashbitlen was 0 in the call to Keccak_HashInitialize(), the output bits
+  *     must be extracted using the Keccak_HashSqueeze() function.
+  * @param  state       Pointer to the state of the sponge function initialized by Init().
+  * @param  hashval     Pointer to the buffer where to store the output data.
+  * @return SUCCESS if successful, FAIL otherwise.
+  */
+HashReturn Keccak_HashFinal(Keccak_HashInstance *hashInstance, BitSequence *hashval);
+
+ /**
+  * Function to squeeze output data.
+  * @param  hashInstance    Pointer to the hash instance initialized by Keccak_HashInitialize().
+  * @param  data        Pointer to the buffer where to store the output data.
+  * @param  databitlen  The number of output bits desired (must be a multiple of 8).
+  * @pre    Keccak_HashFinal() must have been already called.
+  * @pre    @a databitlen is a multiple of 8.
+  * @return SUCCESS if successful, FAIL otherwise.
+  */
+HashReturn Keccak_HashSqueeze(Keccak_HashInstance *hashInstance, BitSequence *data, DataLength databitlen);
+
+#endif