You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

451 lines
10 KiB

// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package keccak
import (
"fmt"
"gitlab.com/nitya-sattva/go-x11/hash"
)
// HashSize holds the size of a hash in bytes.
const HashSize = int(64)
// BlockSize holds the size of a block in bytes.
const BlockSize = uintptr(72)
////////////////
type digest struct {
ptr uintptr
cnt uintptr
h [25]uint64
b [144]byte
}
// New returns a new digest compute a KECCAK512 hash.
func New() hash.Digest {
ref := &digest{}
ref.Reset()
return ref
}
////////////////
// Reset resets the digest to its initial state.
func (ref *digest) Reset() {
ref.ptr = 0
ref.cnt = 200 - (512 >> 2)
h := ref.h[:]
h[0] = uint64(0x0)
h[1] = uint64(0xFFFFFFFFFFFFFFFF)
h[2] = uint64(0xFFFFFFFFFFFFFFFF)
h[3] = uint64(0x0)
h[4] = uint64(0x0)
h[5] = uint64(0x0)
h[6] = uint64(0x0)
h[7] = uint64(0x0)
h[8] = uint64(0xFFFFFFFFFFFFFFFF)
h[9] = uint64(0x0)
h[10] = uint64(0x0)
h[11] = uint64(0x0)
h[12] = uint64(0xFFFFFFFFFFFFFFFF)
h[13] = uint64(0x0)
h[14] = uint64(0x0)
h[15] = uint64(0x0)
h[16] = uint64(0x0)
h[17] = uint64(0xFFFFFFFFFFFFFFFF)
h[18] = uint64(0x0)
h[19] = uint64(0x0)
h[20] = uint64(0xFFFFFFFFFFFFFFFF)
h[21] = uint64(0x0)
h[22] = uint64(0x0)
h[23] = uint64(0x0)
h[24] = uint64(0x0)
}
// Sum appends the current hash to dst and returns the result
// as a slice. It does not change the underlying hash state.
func (ref *digest) Sum(dst []byte) []byte {
dgt := *ref
hsh := [64]byte{}
dgt.Close(hsh[:], 0, 0)
return append(dst, hsh[:]...)
}
// Write more data to the running hash, never returns an error.
func (ref *digest) Write(src []byte) (int, error) {
sln := uintptr(len(src))
fln := len(src)
ptr := ref.ptr
buf := ref.b[:]
sta := ref.h[:]
if sln < (BlockSize - ptr) {
copy(ref.b[ptr:], src)
ref.ptr += sln
return int(sln), nil
}
for sln > 0 {
cln := BlockSize - ptr
if cln > sln {
cln = sln
}
sln -= cln
copy(ref.b[ptr:], src[:cln])
src = src[cln:]
ptr += cln
if ptr == BlockSize {
sta[0] ^= decUInt64le(buf[0:])
sta[1] ^= decUInt64le(buf[8:])
sta[2] ^= decUInt64le(buf[16:])
sta[3] ^= decUInt64le(buf[24:])
sta[4] ^= decUInt64le(buf[32:])
sta[5] ^= decUInt64le(buf[40:])
sta[6] ^= decUInt64le(buf[48:])
sta[7] ^= decUInt64le(buf[56:])
sta[8] ^= decUInt64le(buf[64:])
for j := uintptr(0); j < 24; j++ {
var t0, t1, t2, t3, t4, tp uint64
{
var tt0, tt1, tt2, tt3 uint64
tt0 = sta[1] ^ sta[6]
tt1 = sta[11] ^ sta[16]
tt0 = tt0 ^ sta[21]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[4] ^ sta[9]
tt3 = sta[14] ^ sta[19]
tt0 = tt0 ^ sta[24]
tt2 = tt2 ^ tt3
t0 = tt0 ^ tt2
tt0 = sta[2] ^ sta[7]
tt1 = sta[12] ^ sta[17]
tt0 = tt0 ^ sta[22]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[0] ^ sta[5]
tt3 = sta[10] ^ sta[15]
tt0 = tt0 ^ sta[20]
tt2 = tt2 ^ tt3
t1 = tt0 ^ tt2
tt0 = sta[3] ^ sta[8]
tt1 = sta[13] ^ sta[18]
tt0 = tt0 ^ sta[23]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[1] ^ sta[6]
tt3 = sta[11] ^ sta[16]
tt0 = tt0 ^ sta[21]
tt2 = tt2 ^ tt3
t2 = tt0 ^ tt2
tt0 = sta[4] ^ sta[9]
tt1 = sta[14] ^ sta[19]
tt0 = tt0 ^ sta[24]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[2] ^ sta[7]
tt3 = sta[12] ^ sta[17]
tt0 = tt0 ^ sta[22]
tt2 = tt2 ^ tt3
t3 = tt0 ^ tt2
tt0 = sta[0] ^ sta[5]
tt1 = sta[10] ^ sta[15]
tt0 = tt0 ^ sta[20]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[3] ^ sta[8]
tt3 = sta[13] ^ sta[18]
tt0 = tt0 ^ sta[23]
tt2 = tt2 ^ tt3
t4 = tt0 ^ tt2
}
sta[0] = sta[0] ^ t0
sta[1] = sta[1] ^ t1
sta[2] = sta[2] ^ t2
sta[3] = sta[3] ^ t3
sta[4] = sta[4] ^ t4
sta[5] = sta[5] ^ t0
sta[6] = sta[6] ^ t1
sta[7] = sta[7] ^ t2
sta[8] = sta[8] ^ t3
sta[9] = sta[9] ^ t4
sta[10] = sta[10] ^ t0
sta[11] = sta[11] ^ t1
sta[12] = sta[12] ^ t2
sta[13] = sta[13] ^ t3
sta[14] = sta[14] ^ t4
sta[15] = sta[15] ^ t0
sta[16] = sta[16] ^ t1
sta[17] = sta[17] ^ t2
sta[18] = sta[18] ^ t3
sta[23] = sta[23] ^ t3
sta[19] = sta[19] ^ t4
sta[20] = sta[20] ^ t0
sta[22] = sta[22] ^ t2
sta[21] = sta[21] ^ t1
sta[24] = sta[24] ^ t4
sta[1] = (sta[1] << 1) | (sta[1] >> (64 - 1))
sta[2] = (sta[2] << 62) | (sta[2] >> (64 - 62))
sta[3] = (sta[3] << 28) | (sta[3] >> (64 - 28))
sta[4] = (sta[4] << 27) | (sta[4] >> (64 - 27))
sta[5] = (sta[5] << 36) | (sta[5] >> (64 - 36))
sta[6] = (sta[6] << 44) | (sta[6] >> (64 - 44))
sta[7] = (sta[7] << 6) | (sta[7] >> (64 - 6))
sta[8] = (sta[8] << 55) | (sta[8] >> (64 - 55))
sta[9] = (sta[9] << 20) | (sta[9] >> (64 - 20))
sta[10] = (sta[10] << 3) | (sta[10] >> (64 - 3))
sta[11] = (sta[11] << 10) | (sta[11] >> (64 - 10))
sta[12] = (sta[12] << 43) | (sta[12] >> (64 - 43))
sta[13] = (sta[13] << 25) | (sta[13] >> (64 - 25))
sta[14] = (sta[14] << 39) | (sta[14] >> (64 - 39))
sta[15] = (sta[15] << 41) | (sta[15] >> (64 - 41))
sta[16] = (sta[16] << 45) | (sta[16] >> (64 - 45))
sta[17] = (sta[17] << 15) | (sta[17] >> (64 - 15))
sta[18] = (sta[18] << 21) | (sta[18] >> (64 - 21))
sta[19] = (sta[19] << 8) | (sta[19] >> (64 - 8))
sta[20] = (sta[20] << 18) | (sta[20] >> (64 - 18))
sta[21] = (sta[21] << 2) | (sta[21] >> (64 - 2))
sta[22] = (sta[22] << 61) | (sta[22] >> (64 - 61))
sta[23] = (sta[23] << 56) | (sta[23] >> (64 - 56))
sta[24] = (sta[24] << 14) | (sta[24] >> (64 - 14))
tp = ^sta[12]
t0 = sta[6] | sta[12]
t0 = sta[0] ^ t0
t1 = tp | sta[18]
t1 = sta[6] ^ t1
t2 = sta[18] & sta[24]
t2 = sta[12] ^ t2
t3 = sta[24] | sta[0]
t3 = sta[18] ^ t3
t4 = sta[0] & sta[6]
t4 = sta[24] ^ t4
sta[0] = t0
sta[6] = t1
sta[12] = t2
sta[18] = t3
sta[24] = t4
tp = ^sta[22]
t0 = sta[9] | sta[10]
t0 = sta[3] ^ t0
t1 = sta[10] & sta[16]
t1 = sta[9] ^ t1
t2 = sta[16] | tp
t2 = sta[10] ^ t2
t3 = sta[22] | sta[3]
t3 = sta[16] ^ t3
t4 = sta[3] & sta[9]
t4 = sta[22] ^ t4
sta[3] = t0
sta[9] = t1
sta[10] = t2
sta[16] = t3
sta[22] = t4
tp = ^sta[19]
t0 = sta[7] | sta[13]
t0 = sta[1] ^ t0
t1 = sta[13] & sta[19]
t1 = sta[7] ^ t1
t2 = tp & sta[20]
t2 = sta[13] ^ t2
t3 = sta[20] | sta[1]
t3 = tp ^ t3
t4 = sta[1] & sta[7]
t4 = sta[20] ^ t4
sta[1] = t0
sta[7] = t1
sta[13] = t2
sta[19] = t3
sta[20] = t4
tp = ^sta[17]
t0 = sta[5] & sta[11]
t0 = sta[4] ^ t0
t1 = sta[11] | sta[17]
t1 = sta[5] ^ t1
t2 = tp | sta[23]
t2 = sta[11] ^ t2
t3 = sta[23] & sta[4]
t3 = tp ^ t3
t4 = sta[4] | sta[5]
t4 = sta[23] ^ t4
sta[4] = t0
sta[5] = t1
sta[11] = t2
sta[17] = t3
sta[23] = t4
tp = ^sta[8]
t0 = tp & sta[14]
t0 = sta[2] ^ t0
t1 = sta[14] | sta[15]
t1 = tp ^ t1
t2 = sta[15] & sta[21]
t2 = sta[14] ^ t2
t3 = sta[21] | sta[2]
t3 = sta[15] ^ t3
t4 = sta[2] & sta[8]
t4 = sta[21] ^ t4
sta[2] = t0
sta[8] = t1
sta[14] = t2
sta[15] = t3
sta[21] = t4
sta[0] = sta[0] ^ kSpec[j+0]
t0 = sta[5]
sta[5] = sta[3]
sta[3] = sta[18]
sta[18] = sta[17]
sta[17] = sta[11]
sta[11] = sta[7]
sta[7] = sta[10]
sta[10] = sta[1]
sta[1] = sta[6]
sta[6] = sta[9]
sta[9] = sta[22]
sta[22] = sta[14]
sta[14] = sta[20]
sta[20] = sta[2]
sta[2] = sta[12]
sta[12] = sta[13]
sta[13] = sta[19]
sta[19] = sta[23]
sta[23] = sta[15]
sta[15] = sta[4]
sta[4] = sta[24]
sta[24] = sta[21]
sta[21] = sta[8]
sta[8] = sta[16]
sta[16] = t0
}
ptr = 0
}
}
ref.ptr = ptr
return fln, nil
}
// Close the digest by writing the last bits and storing the hash
// in dst. This prepares the digest for reuse by calling reset. A call
// to Close with a dst that is smaller then HashSize will return an error.
func (ref *digest) Close(dst []byte, bits uint8, bcnt uint8) error {
if ln := len(dst); HashSize > ln {
return fmt.Errorf("Keccak Close: dst min length: %d, got %d", HashSize, ln)
}
var tln uintptr
var tmp [73]uint8
off := uint8((uint16(0x100) | uint16(bits&0xFF)) >> (8 - bcnt))
if ref.ptr == (72 - 1) {
if bcnt == 7 {
tmp[0] = off
tmp[72] = 0x80
tln = 1 + 72
} else {
tmp[0] = uint8(off | 0x80)
tln = 1
}
} else {
tln = 72 - ref.ptr
tmp[0] = off
tmp[tln-1] = 0x80
}
ref.Write(tmp[:tln])
ref.h[1] = ^ref.h[1]
ref.h[2] = ^ref.h[2]
ref.h[8] = ^ref.h[8]
ref.h[12] = ^ref.h[12]
ref.h[17] = ^ref.h[17]
ref.h[20] = ^ref.h[20]
for u := uintptr(0); u < 64; u += 8 {
encUInt64le(dst[u:], ref.h[(u>>3)])
}
ref.Reset()
return nil
}
// Size returns the number of bytes required to store the hash.
func (*digest) Size() int {
return HashSize
}
// BlockSize returns the block size of the hash.
func (*digest) BlockSize() int {
return int(BlockSize)
}
////////////////
func decUInt64le(src []byte) uint64 {
return (uint64(src[0]) |
uint64(src[1])<<8 |
uint64(src[2])<<16 |
uint64(src[3])<<24 |
uint64(src[4])<<32 |
uint64(src[5])<<40 |
uint64(src[6])<<48 |
uint64(src[7])<<56)
}
func encUInt64le(dst []byte, src uint64) {
dst[0] = uint8(src)
dst[1] = uint8(src >> 8)
dst[2] = uint8(src >> 16)
dst[3] = uint8(src >> 24)
dst[4] = uint8(src >> 32)
dst[5] = uint8(src >> 40)
dst[6] = uint8(src >> 48)
dst[7] = uint8(src >> 56)
}
////////////////
var kSpec = []uint64{
uint64(0x0000000000000001), uint64(0x0000000000008082),
uint64(0x800000000000808A), uint64(0x8000000080008000),
uint64(0x000000000000808B), uint64(0x0000000080000001),
uint64(0x8000000080008081), uint64(0x8000000000008009),
uint64(0x000000000000008A), uint64(0x0000000000000088),
uint64(0x0000000080008009), uint64(0x000000008000000A),
uint64(0x000000008000808B), uint64(0x800000000000008B),
uint64(0x8000000000008089), uint64(0x8000000000008003),
uint64(0x8000000000008002), uint64(0x8000000000000080),
uint64(0x000000000000800A), uint64(0x800000008000000A),
uint64(0x8000000080008081), uint64(0x8000000000008080),
uint64(0x0000000080000001), uint64(0x8000000080008008),
}