mirror of
https://github.com/emn178/js-sha3.git
synced 2026-08-12 19:41:36 +08:00
### Added
- TupleHash128, TupleHash256, TupleHashXOF128, and TupleHashXOF256 (NIST SP 800-185) ### Fixed - KMAC repeated output reads after finalize
This commit is contained in:
Yi-Cyuan Chen
@@ -16,6 +16,10 @@ function unset() {
|
||||
shake256 = null;
|
||||
kmac128 = null;
|
||||
kmac256 = null;
|
||||
tuplehash128 = null;
|
||||
tuplehash256 = null;
|
||||
tuplehashxof128 = null;
|
||||
tuplehashxof256 = null;
|
||||
BUFFER = undefined;
|
||||
JS_SHA3_NO_WINDOW = undefined;
|
||||
JS_SHA3_NO_NODE_JS = undefined;
|
||||
@@ -41,6 +45,10 @@ function requireToGlobal() {
|
||||
cshake256 = sha3.cshake256;
|
||||
kmac128 = sha3.kmac128;
|
||||
kmac256 = sha3.kmac256;
|
||||
tuplehash128 = sha3.tuplehash128;
|
||||
tuplehash256 = sha3.tuplehash256;
|
||||
tuplehashxof128 = sha3.tuplehashxof128;
|
||||
tuplehashxof256 = sha3.tuplehashxof256;
|
||||
}
|
||||
|
||||
function runCommonJsTest() {
|
||||
@@ -57,6 +65,7 @@ function runWindowTest(extra) {
|
||||
require('./test-shake.js');
|
||||
require('./test-cshake.js');
|
||||
require('./test-kmac.js');
|
||||
require('./test-tuplehash.js');
|
||||
}
|
||||
unset();
|
||||
}
|
||||
@@ -108,6 +117,10 @@ define = function (func) {
|
||||
cshake256 = sha3.cshake256;
|
||||
kmac128 = sha3.kmac128;
|
||||
kmac256 = sha3.kmac256;
|
||||
tuplehash128 = sha3.tuplehash128;
|
||||
tuplehash256 = sha3.tuplehash256;
|
||||
tuplehashxof128 = sha3.tuplehashxof128;
|
||||
tuplehashxof256 = sha3.tuplehashxof256;
|
||||
require('./test.js');
|
||||
};
|
||||
define.amd = true;
|
||||
|
||||
@@ -0,0 +1,262 @@
|
||||
(function (tuplehash256, tuplehash128, tuplehashxof256, tuplehashxof128, kmac128) {
|
||||
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/TupleHash_samples.pdf
|
||||
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/TupleHashXOF_samples.pdf
|
||||
var t1 = [0x00, 0x01, 0x02];
|
||||
var t2 = [0x10, 0x11, 0x12, 0x13, 0x14, 0x15];
|
||||
var t3 = [0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28];
|
||||
|
||||
var testCases = [
|
||||
{
|
||||
name: 'tuplehash128',
|
||||
method: tuplehash128,
|
||||
cases: [
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 256,
|
||||
s: '',
|
||||
output: 'c5d8786c1afb9b82111ab34b65b2c0048fa64e6d48e263264ce1707d3ffc8ed1'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 256,
|
||||
s: 'My Tuple App',
|
||||
output: '75cdb20ff4db1154e841d758e24160c54bae86eb8c13e7f5f40eb35588e96dfb'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2, t3],
|
||||
bits: 256,
|
||||
s: 'My Tuple App',
|
||||
output: 'e60f202c89a2631eda8d4c588ca5fd07f39e5151998deccf973adb3804bb6e84'
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
name: 'tuplehash256',
|
||||
method: tuplehash256,
|
||||
cases: [
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 512,
|
||||
s: '',
|
||||
output: 'cfb7058caca5e668f81a12a20a2195ce97a925f1dba3e7449a56f82201ec607311ac2696b1ab5ea2352df1423bde7bd4bb78c9aed1a853c78672f9eb23bbe194'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 512,
|
||||
s: 'My Tuple App',
|
||||
output: '147c2191d5ed7efd98dbd96d7ab5a11692576f5fe2a5065f3e33de6bba9f3aa1c4e9a068a289c61c95aab30aee1e410b0b607de3620e24a4e3bf9852a1d4367e'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2, t3],
|
||||
bits: 512,
|
||||
s: 'My Tuple App',
|
||||
output: '45000be63f9b6bfd89f54717670f69a9bc763591a4f05c50d68891a744bcc6e7d6d5b5e82c018da999ed35b0bb49c9678e526abd8e85c13ed254021db9e790ce'
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
name: 'tuplehashxof128',
|
||||
method: tuplehashxof128,
|
||||
cases: [
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 256,
|
||||
s: '',
|
||||
output: '2f103cd7c32320353495c68de1a8129245c6325f6f2a3d608d92179c96e68488'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 256,
|
||||
s: 'My Tuple App',
|
||||
output: '3fc8ad69453128292859a18b6c67d7ad85f01b32815e22ce839c49ec374e9b9a'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2, t3],
|
||||
bits: 256,
|
||||
s: 'My Tuple App',
|
||||
output: '900fe16cad098d28e74d632ed852f99daab7f7df4d99e775657885b4bf76d6f8'
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
name: 'tuplehashxof256',
|
||||
method: tuplehashxof256,
|
||||
cases: [
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 512,
|
||||
s: '',
|
||||
output: '03ded4610ed6450a1e3f8bc44951d14fbc384ab0efe57b000df6b6df5aae7cd568e77377daf13f37ec75cf5fc598b6841d51dd207c991cd45d210ba60ac52eb9'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2],
|
||||
bits: 512,
|
||||
s: 'My Tuple App',
|
||||
output: '6483cb3c9952eb20e830af4785851fc597ee3bf93bb7602c0ef6a65d741aeca7e63c3b128981aa05c6d27438c79d2754bb1b7191f125d6620fca12ce658b2442'
|
||||
},
|
||||
{
|
||||
inputs: [t1, t2, t3],
|
||||
bits: 512,
|
||||
s: 'My Tuple App',
|
||||
output: '0c59b11464f2336c34663ed51b2b950bec743610856f36c28d1d088d8a2446284dd09830a6a178dc752376199fae935d86cfdee5913d4922dfd369b66a53c897'
|
||||
}
|
||||
]
|
||||
}
|
||||
];
|
||||
|
||||
testCases.forEach(function (testCase) {
|
||||
describe('#' + testCase.name, function () {
|
||||
testCase.cases.forEach(function (c) {
|
||||
it('should match NIST sample vector', function () {
|
||||
expect(testCase.method(c.inputs, c.bits, c.s)).to.be(c.output);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('#tuplehash API', function () {
|
||||
it('should treat empty tuple and empty inputs as valid', function () {
|
||||
var emptyTuple = tuplehash128([], 256, '');
|
||||
var oneEmpty = tuplehash128([''], 256, '');
|
||||
var twoEmpty = tuplehash128(['', ''], 256, '');
|
||||
expect(emptyTuple).to.not.be(oneEmpty);
|
||||
expect(oneEmpty).to.not.be(twoEmpty);
|
||||
expect(twoEmpty).to.not.be(tuplehash128(['', '', ''], 256, ''));
|
||||
expect(tuplehash128.create(256, '').update('').update(t1).hex()).to.be(tuplehash128(['', t1], 256, ''));
|
||||
});
|
||||
|
||||
it('should distinguish tuple boundaries', function () {
|
||||
expect(tuplehash128(['abc', 'd'], 256, '')).to.not.be(tuplehash128(['ab', 'cd'], 256, ''));
|
||||
});
|
||||
|
||||
it('should match instance update and method update with one-shot', function () {
|
||||
var expected = tuplehash128(['abc', 'd'], 256, 'cache');
|
||||
var incremental = tuplehash128.create(256, 'cache').update('abc').update('d').hex();
|
||||
var methodUpdate = tuplehash128.update(['abc'], 256, 'cache').update('d').hex();
|
||||
expect(incremental).to.be(expected);
|
||||
expect(methodUpdate).to.be(expected);
|
||||
expect(tuplehash128.update(['abc', 'd'], 256, 'cache').hex()).to.be(expected);
|
||||
});
|
||||
|
||||
it('should stream binary messages in irregular chunks', function () {
|
||||
var bytes = [];
|
||||
for (var i = 0; i < 200; ++i) {
|
||||
bytes.push(i & 0xff);
|
||||
}
|
||||
var expected = tuplehash128([bytes, t1], 256, '');
|
||||
var hash = tuplehash128.create(256, '');
|
||||
hash.beginInput(bytes.length);
|
||||
hash.updateChunk(bytes.slice(0, 1));
|
||||
hash.updateChunk(bytes.slice(1, 17));
|
||||
hash.updateChunk(bytes.slice(17, 168));
|
||||
hash.updateChunk(bytes.slice(168));
|
||||
hash.beginInput(t1.length);
|
||||
hash.updateChunk(t1);
|
||||
expect(hash.hex()).to.be(expected);
|
||||
});
|
||||
|
||||
it('should stream ArrayBuffer and Uint8Array views', function () {
|
||||
var expected = tuplehash128([t1, t2], 256, '');
|
||||
var buffer = new Uint8Array(t1).buffer;
|
||||
var view = new Uint8Array(new Uint8Array(t2).buffer, 0, t2.length);
|
||||
var hash = tuplehash128.create(256, '');
|
||||
hash.beginInput(t1.length).updateChunk(buffer);
|
||||
hash.beginInput(t2.length).updateChunk(view);
|
||||
expect(hash.hex()).to.be(expected);
|
||||
});
|
||||
|
||||
it('should support zero-length streaming input', function () {
|
||||
var expected = tuplehash128(['', t1], 256, '');
|
||||
var hash = tuplehash128.create(256, '');
|
||||
hash.beginInput(0);
|
||||
hash.beginInput(t1.length).updateChunk(t1);
|
||||
expect(hash.hex()).to.be(expected);
|
||||
});
|
||||
|
||||
it('should reject invalid streaming usage', function () {
|
||||
var hash = tuplehash128.create(256, '');
|
||||
expect(function () { hash.updateChunk(t1); }).to.throwError(/no active tuple input/);
|
||||
hash.beginInput(2);
|
||||
expect(function () { hash.updateChunk([1, 2, 3]); }).to.throwError(/exceeds declared length/);
|
||||
expect(function () { hash.beginInput(1); }).to.throwError(/incomplete/);
|
||||
expect(function () { hash.update(t1); }).to.throwError(/incomplete/);
|
||||
expect(function () { hash.hex(); }).to.throwError(/incomplete/);
|
||||
hash.updateChunk([1]);
|
||||
expect(function () { hash.hex(); }).to.throwError(/incomplete/);
|
||||
});
|
||||
|
||||
it('should reject invalid beginInput lengths', function () {
|
||||
var hash = tuplehash128.create(256, '');
|
||||
expect(function () { hash.beginInput(-1); }).to.throwError(/byte length is invalid/);
|
||||
expect(function () { hash.beginInput(1.5); }).to.throwError(/byte length is invalid/);
|
||||
expect(function () { hash.beginInput(NaN); }).to.throwError(/byte length is invalid/);
|
||||
expect(function () { hash.beginInput(0x20000000); }).to.throwError(/byte length is invalid/);
|
||||
});
|
||||
|
||||
it('should allow repeated output representations', function () {
|
||||
var hash = tuplehash128.create(256, '').update(t1).update(t2);
|
||||
var hex = hash.hex();
|
||||
var array = hash.array();
|
||||
var digest = hash.digest();
|
||||
var buffer = hash.arrayBuffer();
|
||||
expect(hash.hex()).to.be(hex);
|
||||
expect(array).to.eql(digest);
|
||||
expect(Array.prototype.slice.call(new Uint8Array(buffer))).to.eql(array);
|
||||
expect(function () { hash.update(t1); }).to.throwError(/finalize already called/);
|
||||
expect(function () { hash.updateChunk(t1); }).to.throwError(/finalize already called/);
|
||||
});
|
||||
|
||||
it('should require customization like KMAC', function () {
|
||||
expect(function () { tuplehash128([t1], 256); }).to.throwError(/input is invalid type/);
|
||||
});
|
||||
|
||||
it('should require inputs to be an array', function () {
|
||||
expect(function () { tuplehash128('abc', 256, ''); }).to.throwError(/input is invalid type/);
|
||||
expect(function () { tuplehash128.update(t1, 256, ''); }).to.throwError(/input is invalid type/);
|
||||
expect(function () { tuplehash128.hex(null, 256, ''); }).to.throwError(/input is invalid type/);
|
||||
expect(function () { tuplehashxof128(undefined, 256, ''); }).to.throwError(/input is invalid type/);
|
||||
});
|
||||
|
||||
it('should export identical aliases', function () {
|
||||
var sha3 = require('../src/sha3.js');
|
||||
expect(sha3.tuplehash128).to.be(sha3.tuplehash_128);
|
||||
expect(sha3.tuplehash256).to.be(sha3.tuplehash_256);
|
||||
expect(sha3.tuplehashxof128).to.be(sha3.tuplehashxof_128);
|
||||
expect(sha3.tuplehashxof256).to.be(sha3.tuplehashxof_256);
|
||||
});
|
||||
|
||||
it('should count UTF-8 string bytes for streaming', function () {
|
||||
var message = 'åbc'; // 2 + 1 + 1 = 4 UTF-8 bytes
|
||||
var expected = tuplehash128([message], 256, '');
|
||||
var hash = tuplehash128.create(256, '');
|
||||
hash.beginInput(4).updateChunk('å').updateChunk('bc');
|
||||
expect(hash.hex()).to.be(expected);
|
||||
expect(message.length).to.be(3);
|
||||
});
|
||||
|
||||
it('should count 3-byte and 4-byte UTF-8 string bytes for streaming', function () {
|
||||
var message = '中\uE000\uD83D\uDE00'; // 3 + 3 + 4 = 10 UTF-8 bytes
|
||||
var expected = tuplehash128([message], 256, '');
|
||||
var hash = tuplehash128.create(256, '');
|
||||
hash.beginInput(10).updateChunk('中').updateChunk('\uE000').updateChunk('\uD83D\uDE00');
|
||||
expect(hash.hex()).to.be(expected);
|
||||
});
|
||||
|
||||
it('should reject update and beginInput after finalize', function () {
|
||||
var hash = tuplehash128.create(256, '').update([0x00]);
|
||||
hash.hex();
|
||||
expect(function () { hash.update([0x01]); }).to.throwError(/finalize already called/);
|
||||
expect(function () { hash.beginInput(1); }).to.throwError(/finalize already called/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('#kmac repeated output', function () {
|
||||
it('should allow repeated output reads after finalize fix', function () {
|
||||
var hash = kmac128.create([0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F], 256, '');
|
||||
hash.update([0x00, 0x01, 0x02, 0x03]);
|
||||
var hex = hash.hex();
|
||||
expect(hash.hex()).to.be(hex);
|
||||
expect(hash.array().length).to.be(32);
|
||||
});
|
||||
});
|
||||
})(tuplehash256, tuplehash128, tuplehashxof256, tuplehashxof128, kmac128);
|
||||
Reference in New Issue
Block a user