174 lines
3.2 KiB
Go
174 lines
3.2 KiB
Go
// Package tz contains Tillich-Zemor checksum implementations
|
|
// using different backends.
|
|
//
|
|
// Copyright 2022 (c) NSPCC
|
|
package tz
|
|
|
|
import (
|
|
"errors"
|
|
"hash"
|
|
|
|
"golang.org/x/sys/cpu"
|
|
)
|
|
|
|
type Implementation int
|
|
|
|
const (
|
|
// Size is the size of a Tillich-Zemor hash sum in bytes.
|
|
Size = 64
|
|
hashBlockSize = 128
|
|
|
|
_ Implementation = iota
|
|
AVX
|
|
AVX2
|
|
AVX2Inline
|
|
PureGo
|
|
AVXInline
|
|
)
|
|
|
|
var (
|
|
hasAVX = cpu.X86.HasAVX
|
|
// Having AVX2 does not guarantee
|
|
// that AVX is also present.
|
|
hasAVX2 = cpu.X86.HasAVX2 && hasAVX
|
|
)
|
|
|
|
func (impl Implementation) String() string {
|
|
switch impl {
|
|
case AVX:
|
|
return "AVX"
|
|
case AVXInline:
|
|
return "AVXInline"
|
|
case AVX2:
|
|
return "AVX2"
|
|
case AVX2Inline:
|
|
return "AVX2Inline"
|
|
case PureGo:
|
|
return "PureGo"
|
|
default:
|
|
return "UNKNOWN"
|
|
}
|
|
}
|
|
|
|
func NewWith(impl Implementation) hash.Hash {
|
|
switch impl {
|
|
case AVX:
|
|
return newAVX()
|
|
case AVXInline:
|
|
return newAVXInline()
|
|
case AVX2:
|
|
return newAVX2()
|
|
case AVX2Inline:
|
|
return newAVX2Inline()
|
|
case PureGo:
|
|
return newPure()
|
|
default:
|
|
return New()
|
|
}
|
|
}
|
|
|
|
// New returns a new hash.Hash computing the Tillich-Zémor checksum.
|
|
func New() hash.Hash {
|
|
if hasAVX2 {
|
|
return newAVX2Inline()
|
|
} else if hasAVX {
|
|
return newAVXInline()
|
|
} else {
|
|
return newPure()
|
|
}
|
|
}
|
|
|
|
// Sum returns Tillich-Zémor checksum of data.
|
|
func Sum(data []byte) [Size]byte {
|
|
if hasAVX2 {
|
|
d := newAVX2Inline()
|
|
_, _ = d.Write(data) // no errors
|
|
return d.checkSum()
|
|
} else if hasAVX {
|
|
d := newAVXInline()
|
|
_, _ = d.Write(data) // no errors
|
|
return d.checkSum()
|
|
} else {
|
|
d := newPure()
|
|
_, _ = d.Write(data) // no errors
|
|
return d.checkSum()
|
|
}
|
|
}
|
|
|
|
// Concat performs combining of hashes based on homomorphic property.
|
|
func Concat(hs [][]byte) ([]byte, error) {
|
|
var b, c sl2
|
|
|
|
b = id
|
|
for i := range hs {
|
|
if err := c.UnmarshalBinary(hs[i]); err != nil {
|
|
return nil, err
|
|
}
|
|
b.Mul(&b, &c)
|
|
}
|
|
return b.MarshalBinary()
|
|
}
|
|
|
|
// Validate checks if hashes in hs combined are equal to h.
|
|
func Validate(h []byte, hs [][]byte) (bool, error) {
|
|
var (
|
|
b []byte
|
|
got, expected [Size]byte
|
|
err error
|
|
)
|
|
|
|
if len(h) != Size {
|
|
return false, errors.New("invalid hash")
|
|
} else if len(hs) == 0 {
|
|
return false, errors.New("empty slice")
|
|
}
|
|
|
|
copy(expected[:], h)
|
|
|
|
b, err = Concat(hs)
|
|
if err != nil {
|
|
return false, errors.New("cant concatenate hashes")
|
|
}
|
|
|
|
copy(got[:], b)
|
|
|
|
return expected == got, nil
|
|
}
|
|
|
|
// SubtractR returns hash a, such that Concat(a, b) == c
|
|
// This is possible, because Tillich-Zemor hash is actually a matrix
|
|
// which can be inversed.
|
|
func SubtractR(c, b []byte) (a []byte, err error) {
|
|
var p1, p2, r sl2
|
|
|
|
if err = r.UnmarshalBinary(c); err != nil {
|
|
return nil, err
|
|
}
|
|
if err = p2.UnmarshalBinary(b); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
p1 = *Inv(&p2)
|
|
p1.Mul(&r, &p1)
|
|
|
|
return p1.MarshalBinary()
|
|
}
|
|
|
|
// SubtractL returns hash b, such that Concat(a, b) == c
|
|
// This is possible, because Tillich-Zemor hash is actually a matrix
|
|
// which can be inversed.
|
|
func SubtractL(c, a []byte) (b []byte, err error) {
|
|
var p1, p2, r sl2
|
|
|
|
if err = r.UnmarshalBinary(c); err != nil {
|
|
return nil, err
|
|
}
|
|
if err = p1.UnmarshalBinary(a); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
p2 = *Inv(&p1)
|
|
p2.Mul(&p2, &r)
|
|
|
|
return p2.MarshalBinary()
|
|
}
|