mirror of
https://gogs.blitter.com/RLabs/xs
synced 2024-08-14 10:26:42 +00:00
f5be3578a8
2/3 Added vendor/ dir to lock down dependent pkg versions.
The author of git.schwanenlied.me/yawning/{chacha20,newhope,kyber}.git has copied
their repos to gitlab.com/yawning/ but some imports of chacha20 from newhope still
inconsistently refer to git.schwanenlied.me/, breaking build.
Licenses for chacha20 also changed from CC0 to AGPL, which may or may not be an
issue. Until the two aforementioned issues are resolved, locking to last-good
versions is probably the best way forward for now.
To build with vendored deps, use make VENDOR=1 clean all
3/3 Moved body of CI push script into bacillus/
116 lines
3.4 KiB
Go
116 lines
3.4 KiB
Go
// Copyright 2015 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package tea implements the TEA algorithm, as defined in Needham and
|
|
// Wheeler's 1994 technical report, “TEA, a Tiny Encryption Algorithm”. See
|
|
// http://www.cix.co.uk/~klockstone/tea.pdf for details.
|
|
//
|
|
// TEA is a legacy cipher and its short block size makes it vulnerable to
|
|
// birthday bound attacks (see https://sweet32.info). It should only be used
|
|
// where compatibility with legacy systems, not security, is the goal.
|
|
//
|
|
// Deprecated: any new system should use AES (from crypto/aes, if necessary in
|
|
// an AEAD mode like crypto/cipher.NewGCM) or XChaCha20-Poly1305 (from
|
|
// golang.org/x/crypto/chacha20poly1305).
|
|
package tea
|
|
|
|
import (
|
|
"crypto/cipher"
|
|
"encoding/binary"
|
|
"errors"
|
|
)
|
|
|
|
const (
|
|
// BlockSize is the size of a TEA block, in bytes.
|
|
BlockSize = 8
|
|
|
|
// KeySize is the size of a TEA key, in bytes.
|
|
KeySize = 16
|
|
|
|
// delta is the TEA key schedule constant.
|
|
delta = 0x9e3779b9
|
|
|
|
// numRounds is the standard number of rounds in TEA.
|
|
numRounds = 64
|
|
)
|
|
|
|
// tea is an instance of the TEA cipher with a particular key.
|
|
type tea struct {
|
|
key [16]byte
|
|
rounds int
|
|
}
|
|
|
|
// NewCipher returns an instance of the TEA cipher with the standard number of
|
|
// rounds. The key argument must be 16 bytes long.
|
|
func NewCipher(key []byte) (cipher.Block, error) {
|
|
return NewCipherWithRounds(key, numRounds)
|
|
}
|
|
|
|
// NewCipherWithRounds returns an instance of the TEA cipher with a given
|
|
// number of rounds, which must be even. The key argument must be 16 bytes
|
|
// long.
|
|
func NewCipherWithRounds(key []byte, rounds int) (cipher.Block, error) {
|
|
if len(key) != 16 {
|
|
return nil, errors.New("tea: incorrect key size")
|
|
}
|
|
|
|
if rounds&1 != 0 {
|
|
return nil, errors.New("tea: odd number of rounds specified")
|
|
}
|
|
|
|
c := &tea{
|
|
rounds: rounds,
|
|
}
|
|
copy(c.key[:], key)
|
|
|
|
return c, nil
|
|
}
|
|
|
|
// BlockSize returns the TEA block size, which is eight bytes. It is necessary
|
|
// to satisfy the Block interface in the package "crypto/cipher".
|
|
func (*tea) BlockSize() int {
|
|
return BlockSize
|
|
}
|
|
|
|
// Encrypt encrypts the 8 byte buffer src using the key in t and stores the
|
|
// result in dst. Note that for amounts of data larger than a block, it is not
|
|
// safe to just call Encrypt on successive blocks; instead, use an encryption
|
|
// mode like CBC (see crypto/cipher/cbc.go).
|
|
func (t *tea) Encrypt(dst, src []byte) {
|
|
e := binary.BigEndian
|
|
v0, v1 := e.Uint32(src), e.Uint32(src[4:])
|
|
k0, k1, k2, k3 := e.Uint32(t.key[0:]), e.Uint32(t.key[4:]), e.Uint32(t.key[8:]), e.Uint32(t.key[12:])
|
|
|
|
sum := uint32(0)
|
|
delta := uint32(delta)
|
|
|
|
for i := 0; i < t.rounds/2; i++ {
|
|
sum += delta
|
|
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1)
|
|
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3)
|
|
}
|
|
|
|
e.PutUint32(dst, v0)
|
|
e.PutUint32(dst[4:], v1)
|
|
}
|
|
|
|
// Decrypt decrypts the 8 byte buffer src using the key in t and stores the
|
|
// result in dst.
|
|
func (t *tea) Decrypt(dst, src []byte) {
|
|
e := binary.BigEndian
|
|
v0, v1 := e.Uint32(src), e.Uint32(src[4:])
|
|
k0, k1, k2, k3 := e.Uint32(t.key[0:]), e.Uint32(t.key[4:]), e.Uint32(t.key[8:]), e.Uint32(t.key[12:])
|
|
|
|
delta := uint32(delta)
|
|
sum := delta * uint32(t.rounds/2) // in general, sum = delta * n
|
|
|
|
for i := 0; i < t.rounds/2; i++ {
|
|
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3)
|
|
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1)
|
|
sum -= delta
|
|
}
|
|
|
|
e.PutUint32(dst, v0)
|
|
e.PutUint32(dst[4:], v1)
|
|
}
|