[tor-commits] [Git][tpo/applications/tor-browser-build][main] Bug 41048: Remove the kcp-go project

Pier Angelo Vendrame pushed to branch main at The Tor Project / Applications / tor-browser-build

Commits:

959bdfb9
by Pier Angelo Vendrame at 2023-12-15T09:15:18+00:00
```
Bug 41048: Remove the kcp-go project
```

1 changed file:

− projects/kcp-go/remove-crypt-fec.patch

Changes:

projects/kcp-go/remove-crypt-fec.patch deleted

 -From 0b9d0759f979a5d828b747ea51771f307c53d221 Mon Sep 17 00:00:00 2001
 -From: David Fifield <david@xxxxxxxxxxxxxxx>
 -Date: Thu, 9 Apr 2020 11:27:44 -0600
 -Subject: [PATCH] Remove crypt and FEC dependencies.
+-
 ----
 - crypt.go   | 618 -----------------------------------------------------
 - fec.go     | 337 -----------------------------
 - removed.go |  29 +++
 - 3 files changed, 29 insertions(+), 955 deletions(-)
 - delete mode 100644 crypt.go
 - delete mode 100644 fec.go
 - create mode 100644 removed.go
+-
 -diff --git a/crypt.go b/crypt.go
 -deleted file mode 100644
 -index d882852..0000000
 ---- a/crypt.go
 -+++ /dev/null
 -@@ -1,618 +0,0 @@
 --package kcp
 --
 --import (
 --	"crypto/aes"
 --	"crypto/cipher"
 --	"crypto/des"
 --	"crypto/sha1"
 --	"unsafe"
 --
 --	xor "github.com/templexxx/xorsimd"
 --	"github.com/tjfoc/gmsm/sm4"
 --
 --	"golang.org/x/crypto/blowfish"
 --	"golang.org/x/crypto/cast5"
 --	"golang.org/x/crypto/pbkdf2"
 --	"golang.org/x/crypto/salsa20"
 --	"golang.org/x/crypto/tea"
 --	"golang.org/x/crypto/twofish"
 --	"golang.org/x/crypto/xtea"
 --)
 --
 --var (
 --	initialVector = []byte{167, 115, 79, 156, 18, 172, 27, 1, 164, 21, 242, 193, 252, 120, 230, 107}
 --	saltxor       = `sH3CIVoF#rWLtJo6`
 --)
 --
 --// BlockCrypt defines encryption/decryption methods for a given byte slice.
 --// Notes on implementing: the data to be encrypted contains a builtin
 --// nonce at the first 16 bytes
 --type BlockCrypt interface {
 --	// Encrypt encrypts the whole block in src into dst.
 --	// Dst and src may point at the same memory.
 --	Encrypt(dst, src []byte)
 --
 --	// Decrypt decrypts the whole block in src into dst.
 --	// Dst and src may point at the same memory.
 --	Decrypt(dst, src []byte)
 --}
 --
 --type salsa20BlockCrypt struct {
 --	key [32]byte
 --}
 --
 --// NewSalsa20BlockCrypt https://en.wikipedia.org/wiki/Salsa20
 --func NewSalsa20BlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(salsa20BlockCrypt)
 --	copy(c.key[:], key)
 --	return c, nil
 --}
 --
 --func (c *salsa20BlockCrypt) Encrypt(dst, src []byte) {
 --	salsa20.XORKeyStream(dst[8:], src[8:], src[:8], &c.key)
 --	copy(dst[:8], src[:8])
 --}
 --func (c *salsa20BlockCrypt) Decrypt(dst, src []byte) {
 --	salsa20.XORKeyStream(dst[8:], src[8:], src[:8], &c.key)
 --	copy(dst[:8], src[:8])
 --}
 --
 --type sm4BlockCrypt struct {
 --	encbuf [sm4.BlockSize]byte // 64bit alignment enc/dec buffer
 --	decbuf [2 * sm4.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewSM4BlockCrypt https://github.com/tjfoc/gmsm/tree/master/sm4
 --func NewSM4BlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(sm4BlockCrypt)
 --	block, err := sm4.NewCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *sm4BlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *sm4BlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type twofishBlockCrypt struct {
 --	encbuf [twofish.BlockSize]byte
 --	decbuf [2 * twofish.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewTwofishBlockCrypt https://en.wikipedia.org/wiki/Twofish
 --func NewTwofishBlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(twofishBlockCrypt)
 --	block, err := twofish.NewCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *twofishBlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *twofishBlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type tripleDESBlockCrypt struct {
 --	encbuf [des.BlockSize]byte
 --	decbuf [2 * des.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewTripleDESBlockCrypt https://en.wikipedia.org/wiki/Triple_DES
 --func NewTripleDESBlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(tripleDESBlockCrypt)
 --	block, err := des.NewTripleDESCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *tripleDESBlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *tripleDESBlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type cast5BlockCrypt struct {
 --	encbuf [cast5.BlockSize]byte
 --	decbuf [2 * cast5.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewCast5BlockCrypt https://en.wikipedia.org/wiki/CAST-128
 --func NewCast5BlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(cast5BlockCrypt)
 --	block, err := cast5.NewCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *cast5BlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *cast5BlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type blowfishBlockCrypt struct {
 --	encbuf [blowfish.BlockSize]byte
 --	decbuf [2 * blowfish.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewBlowfishBlockCrypt https://en.wikipedia.org/wiki/Blowfish_(cipher)
 --func NewBlowfishBlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(blowfishBlockCrypt)
 --	block, err := blowfish.NewCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *blowfishBlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *blowfishBlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type aesBlockCrypt struct {
 --	encbuf [aes.BlockSize]byte
 --	decbuf [2 * aes.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewAESBlockCrypt https://en.wikipedia.org/wiki/Advanced_Encryption_Standard
 --func NewAESBlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(aesBlockCrypt)
 --	block, err := aes.NewCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *aesBlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *aesBlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type teaBlockCrypt struct {
 --	encbuf [tea.BlockSize]byte
 --	decbuf [2 * tea.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewTEABlockCrypt https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
 --func NewTEABlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(teaBlockCrypt)
 --	block, err := tea.NewCipherWithRounds(key, 16)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *teaBlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *teaBlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type xteaBlockCrypt struct {
 --	encbuf [xtea.BlockSize]byte
 --	decbuf [2 * xtea.BlockSize]byte
 --	block  cipher.Block
 --}
 --
 --// NewXTEABlockCrypt https://en.wikipedia.org/wiki/XTEA
 --func NewXTEABlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(xteaBlockCrypt)
 --	block, err := xtea.NewCipher(key)
 --	if err != nil {
 --		return nil, err
 --	}
 --	c.block = block
 --	return c, nil
 --}
 --
 --func (c *xteaBlockCrypt) Encrypt(dst, src []byte) { encrypt(c.block, dst, src, c.encbuf[:]) }
 --func (c *xteaBlockCrypt) Decrypt(dst, src []byte) { decrypt(c.block, dst, src, c.decbuf[:]) }
 --
 --type simpleXORBlockCrypt struct {
 --	xortbl []byte
 --}
 --
 --// NewSimpleXORBlockCrypt simple xor with key expanding
 --func NewSimpleXORBlockCrypt(key []byte) (BlockCrypt, error) {
 --	c := new(simpleXORBlockCrypt)
 --	c.xortbl = pbkdf2.Key(key, []byte(saltxor), 32, mtuLimit, sha1.New)
 --	return c, nil
 --}
 --
 --func (c *simpleXORBlockCrypt) Encrypt(dst, src []byte) { xor.Bytes(dst, src, c.xortbl) }
 --func (c *simpleXORBlockCrypt) Decrypt(dst, src []byte) { xor.Bytes(dst, src, c.xortbl) }
 --
 --type noneBlockCrypt struct{}
 --
 --// NewNoneBlockCrypt does nothing but copying
 --func NewNoneBlockCrypt(key []byte) (BlockCrypt, error) {
 --	return new(noneBlockCrypt), nil
 --}
 --
 --func (c *noneBlockCrypt) Encrypt(dst, src []byte) { copy(dst, src) }
 --func (c *noneBlockCrypt) Decrypt(dst, src []byte) { copy(dst, src) }
 --
 --// packet encryption with local CFB mode
 --func encrypt(block cipher.Block, dst, src, buf []byte) {
 --	switch block.BlockSize() {
 --	case 8:
 --		encrypt8(block, dst, src, buf)
 --	case 16:
 --		encrypt16(block, dst, src, buf)
 --	default:
 --		panic("unsupported cipher block size")
 --	}
 --}
 --
 --// optimized encryption for the ciphers which works in 8-bytes
 --func encrypt8(block cipher.Block, dst, src, buf []byte) {
 --	tbl := buf[:8]
 --	block.Encrypt(tbl, initialVector)
 --	n := len(src) / 8
 --	base := 0
 --	repeat := n / 8
 --	left := n % 8
 --	ptr_tbl := (*uint64)(unsafe.Pointer(&tbl[0]))
 --
 --	for i := 0; i < repeat; i++ {
 --		s := src[base:][0:64]
 --		d := dst[base:][0:64]
 --		// 1
 --		*(*uint64)(unsafe.Pointer(&d[0])) = *(*uint64)(unsafe.Pointer(&s[0])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[0:8])
 --		// 2
 --		*(*uint64)(unsafe.Pointer(&d[8])) = *(*uint64)(unsafe.Pointer(&s[8])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[8:16])
 --		// 3
 --		*(*uint64)(unsafe.Pointer(&d[16])) = *(*uint64)(unsafe.Pointer(&s[16])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[16:24])
 --		// 4
 --		*(*uint64)(unsafe.Pointer(&d[24])) = *(*uint64)(unsafe.Pointer(&s[24])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[24:32])
 --		// 5
 --		*(*uint64)(unsafe.Pointer(&d[32])) = *(*uint64)(unsafe.Pointer(&s[32])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[32:40])
 --		// 6
 --		*(*uint64)(unsafe.Pointer(&d[40])) = *(*uint64)(unsafe.Pointer(&s[40])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[40:48])
 --		// 7
 --		*(*uint64)(unsafe.Pointer(&d[48])) = *(*uint64)(unsafe.Pointer(&s[48])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[48:56])
 --		// 8
 --		*(*uint64)(unsafe.Pointer(&d[56])) = *(*uint64)(unsafe.Pointer(&s[56])) ^ *ptr_tbl
 --		block.Encrypt(tbl, d[56:64])
 --		base += 64
 --	}
 --
 --	switch left {
 --	case 7:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 6:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 5:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 4:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 3:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 2:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 1:
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *ptr_tbl
 --		block.Encrypt(tbl, dst[base:])
 --		base += 8
 --		fallthrough
 --	case 0:
 --		xorBytes(dst[base:], src[base:], tbl)
 --	}
 --}
 --
 --// optimized encryption for the ciphers which works in 16-bytes
 --func encrypt16(block cipher.Block, dst, src, buf []byte) {
 --	tbl := buf[:16]
 --	block.Encrypt(tbl, initialVector)
 --	n := len(src) / 16
 --	base := 0
 --	repeat := n / 8
 --	left := n % 8
 --	for i := 0; i < repeat; i++ {
 --		s := src[base:][0:128]
 --		d := dst[base:][0:128]
 --		// 1
 --		xor.Bytes16Align(d[0:16], s[0:16], tbl)
 --		block.Encrypt(tbl, d[0:16])
 --		// 2
 --		xor.Bytes16Align(d[16:32], s[16:32], tbl)
 --		block.Encrypt(tbl, d[16:32])
 --		// 3
 --		xor.Bytes16Align(d[32:48], s[32:48], tbl)
 --		block.Encrypt(tbl, d[32:48])
 --		// 4
 --		xor.Bytes16Align(d[48:64], s[48:64], tbl)
 --		block.Encrypt(tbl, d[48:64])
 --		// 5
 --		xor.Bytes16Align(d[64:80], s[64:80], tbl)
 --		block.Encrypt(tbl, d[64:80])
 --		// 6
 --		xor.Bytes16Align(d[80:96], s[80:96], tbl)
 --		block.Encrypt(tbl, d[80:96])
 --		// 7
 --		xor.Bytes16Align(d[96:112], s[96:112], tbl)
 --		block.Encrypt(tbl, d[96:112])
 --		// 8
 --		xor.Bytes16Align(d[112:128], s[112:128], tbl)
 --		block.Encrypt(tbl, d[112:128])
 --		base += 128
 --	}
 --
 --	switch left {
 --	case 7:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 6:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 5:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 4:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 3:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 2:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 1:
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		block.Encrypt(tbl, dst[base:])
 --		base += 16
 --		fallthrough
 --	case 0:
 --		xorBytes(dst[base:], src[base:], tbl)
 --	}
 --}
 --
 --// decryption
 --func decrypt(block cipher.Block, dst, src, buf []byte) {
 --	switch block.BlockSize() {
 --	case 8:
 --		decrypt8(block, dst, src, buf)
 --	case 16:
 --		decrypt16(block, dst, src, buf)
 --	default:
 --		panic("unsupported cipher block size")
 --	}
 --}
 --
 --// decrypt 8 bytes block, all byte slices are supposed to be 64bit aligned
 --func decrypt8(block cipher.Block, dst, src, buf []byte) {
 --	tbl := buf[0:8]
 --	next := buf[8:16]
 --	block.Encrypt(tbl, initialVector)
 --	n := len(src) / 8
 --	base := 0
 --	repeat := n / 8
 --	left := n % 8
 --	ptr_tbl := (*uint64)(unsafe.Pointer(&tbl[0]))
 --	ptr_next := (*uint64)(unsafe.Pointer(&next[0]))
 --
 --	for i := 0; i < repeat; i++ {
 --		s := src[base:][0:64]
 --		d := dst[base:][0:64]
 --		// 1
 --		block.Encrypt(next, s[0:8])
 --		*(*uint64)(unsafe.Pointer(&d[0])) = *(*uint64)(unsafe.Pointer(&s[0])) ^ *ptr_tbl
 --		// 2
 --		block.Encrypt(tbl, s[8:16])
 --		*(*uint64)(unsafe.Pointer(&d[8])) = *(*uint64)(unsafe.Pointer(&s[8])) ^ *ptr_next
 --		// 3
 --		block.Encrypt(next, s[16:24])
 --		*(*uint64)(unsafe.Pointer(&d[16])) = *(*uint64)(unsafe.Pointer(&s[16])) ^ *ptr_tbl
 --		// 4
 --		block.Encrypt(tbl, s[24:32])
 --		*(*uint64)(unsafe.Pointer(&d[24])) = *(*uint64)(unsafe.Pointer(&s[24])) ^ *ptr_next
 --		// 5
 --		block.Encrypt(next, s[32:40])
 --		*(*uint64)(unsafe.Pointer(&d[32])) = *(*uint64)(unsafe.Pointer(&s[32])) ^ *ptr_tbl
 --		// 6
 --		block.Encrypt(tbl, s[40:48])
 --		*(*uint64)(unsafe.Pointer(&d[40])) = *(*uint64)(unsafe.Pointer(&s[40])) ^ *ptr_next
 --		// 7
 --		block.Encrypt(next, s[48:56])
 --		*(*uint64)(unsafe.Pointer(&d[48])) = *(*uint64)(unsafe.Pointer(&s[48])) ^ *ptr_tbl
 --		// 8
 --		block.Encrypt(tbl, s[56:64])
 --		*(*uint64)(unsafe.Pointer(&d[56])) = *(*uint64)(unsafe.Pointer(&s[56])) ^ *ptr_next
 --		base += 64
 --	}
 --
 --	switch left {
 --	case 7:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 6:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 5:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 4:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 3:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 2:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 1:
 --		block.Encrypt(next, src[base:])
 --		*(*uint64)(unsafe.Pointer(&dst[base])) = *(*uint64)(unsafe.Pointer(&src[base])) ^ *(*uint64)(unsafe.Pointer(&tbl[0]))
 --		tbl, next = next, tbl
 --		base += 8
 --		fallthrough
 --	case 0:
 --		xorBytes(dst[base:], src[base:], tbl)
 --	}
 --}
 --
 --func decrypt16(block cipher.Block, dst, src, buf []byte) {
 --	tbl := buf[0:16]
 --	next := buf[16:32]
 --	block.Encrypt(tbl, initialVector)
 --	n := len(src) / 16
 --	base := 0
 --	repeat := n / 8
 --	left := n % 8
 --	for i := 0; i < repeat; i++ {
 --		s := src[base:][0:128]
 --		d := dst[base:][0:128]
 --		// 1
 --		block.Encrypt(next, s[0:16])
 --		xor.Bytes16Align(d[0:16], s[0:16], tbl)
 --		// 2
 --		block.Encrypt(tbl, s[16:32])
 --		xor.Bytes16Align(d[16:32], s[16:32], next)
 --		// 3
 --		block.Encrypt(next, s[32:48])
 --		xor.Bytes16Align(d[32:48], s[32:48], tbl)
 --		// 4
 --		block.Encrypt(tbl, s[48:64])
 --		xor.Bytes16Align(d[48:64], s[48:64], next)
 --		// 5
 --		block.Encrypt(next, s[64:80])
 --		xor.Bytes16Align(d[64:80], s[64:80], tbl)
 --		// 6
 --		block.Encrypt(tbl, s[80:96])
 --		xor.Bytes16Align(d[80:96], s[80:96], next)
 --		// 7
 --		block.Encrypt(next, s[96:112])
 --		xor.Bytes16Align(d[96:112], s[96:112], tbl)
 --		// 8
 --		block.Encrypt(tbl, s[112:128])
 --		xor.Bytes16Align(d[112:128], s[112:128], next)
 --		base += 128
 --	}
 --
 --	switch left {
 --	case 7:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 6:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 5:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 4:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 3:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 2:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 1:
 --		block.Encrypt(next, src[base:])
 --		xor.Bytes16Align(dst[base:], src[base:], tbl)
 --		tbl, next = next, tbl
 --		base += 16
 --		fallthrough
 --	case 0:
 --		xorBytes(dst[base:], src[base:], tbl)
 --	}
 --}
 --
 --// per bytes xors
 --func xorBytes(dst, a, b []byte) int {
 --	n := len(a)
 --	if len(b) < n {
 --		n = len(b)
 --	}
 --	if n == 0 {
 --		return 0
 --	}
 --
 --	for i := 0; i < n; i++ {
 --		dst[i] = a[i] ^ b[i]
 --	}
 --	return n
 --}
 -diff --git a/fec.go b/fec.go
 -deleted file mode 100644
 -index 97cd40b..0000000
 ---- a/fec.go
 -+++ /dev/null
 -@@ -1,337 +0,0 @@
 --package kcp
 --
 --import (
 --	"encoding/binary"
 --	"sync/atomic"
 --
 --	"github.com/klauspost/reedsolomon"
 --)
 --
 --const (
 --	fecHeaderSize      = 6
 --	fecHeaderSizePlus2 = fecHeaderSize + 2 // plus 2B data size
 --	typeData           = 0xf1
 --	typeParity         = 0xf2
 --	fecExpire          = 60000
 --)
 --
 --// fecPacket is a decoded FEC packet
 --type fecPacket []byte
 --
 --func (bts fecPacket) seqid() uint32 { return binary.LittleEndian.Uint32(bts) }
 --func (bts fecPacket) flag() uint16  { return binary.LittleEndian.Uint16(bts[4:]) }
 --func (bts fecPacket) data() []byte  { return bts[6:] }
 --
 --// fecElement has auxcilliary time field
 --type fecElement struct {
 --	fecPacket
 --	ts uint32
 --}
 --
 --// fecDecoder for decoding incoming packets
 --type fecDecoder struct {
 --	rxlimit      int // queue size limit
 --	dataShards   int
 --	parityShards int
 --	shardSize    int
 --	rx           []fecElement // ordered receive queue
 --
 --	// caches
 --	decodeCache [][]byte
 --	flagCache   []bool
 --
 --	// zeros
 --	zeros []byte
 --
 --	// RS decoder
 --	codec reedsolomon.Encoder
 --}
 --
 --func newFECDecoder(rxlimit, dataShards, parityShards int) *fecDecoder {
 --	if dataShards <= 0 || parityShards <= 0 {
 --		return nil
 --	}
 --	if rxlimit < dataShards+parityShards {
 --		return nil
 --	}
 --
 --	dec := new(fecDecoder)
 --	dec.rxlimit = rxlimit
 --	dec.dataShards = dataShards
 --	dec.parityShards = parityShards
 --	dec.shardSize = dataShards + parityShards
 --	codec, err := reedsolomon.New(dataShards, parityShards)
 --	if err != nil {
 --		return nil
 --	}
 --	dec.codec = codec
 --	dec.decodeCache = make([][]byte, dec.shardSize)
 --	dec.flagCache = make([]bool, dec.shardSize)
 --	dec.zeros = make([]byte, mtuLimit)
 --	return dec
 --}
 --
 --// decode a fec packet
 --func (dec *fecDecoder) decode(in fecPacket) (recovered [][]byte) {
 --	// insertion
 --	n := len(dec.rx) - 1
 --	insertIdx := 0
 --	for i := n; i >= 0; i-- {
 --		if in.seqid() == dec.rx[i].seqid() { // de-duplicate
 --			return nil
 --		} else if _itimediff(in.seqid(), dec.rx[i].seqid()) > 0 { // insertion
 --			insertIdx = i + 1
 --			break
 --		}
 --	}
 --
 --	// make a copy
 --	pkt := fecPacket(xmitBuf.Get().([]byte)[:len(in)])
 --	copy(pkt, in)
 --	elem := fecElement{pkt, currentMs()}
 --
 --	// insert into ordered rx queue
 --	if insertIdx == n+1 {
 --		dec.rx = append(dec.rx, elem)
 --	} else {
 --		dec.rx = append(dec.rx, fecElement{})
 --		copy(dec.rx[insertIdx+1:], dec.rx[insertIdx:]) // shift right
 --		dec.rx[insertIdx] = elem
 --	}
 --
 --	// shard range for current packet
 --	shardBegin := pkt.seqid() - pkt.seqid()%uint32(dec.shardSize)
 --	shardEnd := shardBegin + uint32(dec.shardSize) - 1
 --
 --	// max search range in ordered queue for current shard
 --	searchBegin := insertIdx - int(pkt.seqid()%uint32(dec.shardSize))
 --	if searchBegin < 0 {
 --		searchBegin = 0
 --	}
 --	searchEnd := searchBegin + dec.shardSize - 1
 --	if searchEnd >= len(dec.rx) {
 --		searchEnd = len(dec.rx) - 1
 --	}
 --
 --	// re-construct datashards
 --	if searchEnd-searchBegin+1 >= dec.dataShards {
 --		var numshard, numDataShard, first, maxlen int
 --
 --		// zero caches
 --		shards := dec.decodeCache
 --		shardsflag := dec.flagCache
 --		for k := range dec.decodeCache {
 --			shards[k] = nil
 --			shardsflag[k] = false
 --		}
 --
 --		// shard assembly
 --		for i := searchBegin; i <= searchEnd; i++ {
 --			seqid := dec.rx[i].seqid()
 --			if _itimediff(seqid, shardEnd) > 0 {
 --				break
 --			} else if _itimediff(seqid, shardBegin) >= 0 {
 --				shards[seqid%uint32(dec.shardSize)] = dec.rx[i].data()
 --				shardsflag[seqid%uint32(dec.shardSize)] = true
 --				numshard++
 --				if dec.rx[i].flag() == typeData {
 --					numDataShard++
 --				}
 --				if numshard == 1 {
 --					first = i
 --				}
 --				if len(dec.rx[i].data()) > maxlen {
 --					maxlen = len(dec.rx[i].data())
 --				}
 --			}
 --		}
 --
 --		if numDataShard == dec.dataShards {
 --			// case 1: no loss on data shards
 --			dec.rx = dec.freeRange(first, numshard, dec.rx)
 --		} else if numshard >= dec.dataShards {
 --			// case 2: loss on data shards, but it's recoverable from parity shards
 --			for k := range shards {
 --				if shards[k] != nil {
 --					dlen := len(shards[k])
 --					shards[k] = shards[k][:maxlen]
 --					copy(shards[k][dlen:], dec.zeros)
 --				} else if k < dec.dataShards {
 --					shards[k] = xmitBuf.Get().([]byte)[:0]
 --				}
 --			}
 --			if err := dec.codec.ReconstructData(shards); err == nil {
 --				for k := range shards[:dec.dataShards] {
 --					if !shardsflag[k] {
 --						// recovered data should be recycled
 --						recovered = append(recovered, shards[k])
 --					}
 --				}
 --			}
 --			dec.rx = dec.freeRange(first, numshard, dec.rx)
 --		}
 --	}
 --
 --	// keep rxlimit
 --	if len(dec.rx) > dec.rxlimit {
 --		if dec.rx[0].flag() == typeData { // track the unrecoverable data
 --			atomic.AddUint64(&DefaultSnmp.FECShortShards, 1)
 --		}
 --		dec.rx = dec.freeRange(0, 1, dec.rx)
 --	}
 --
 --	// timeout policy
 --	current := currentMs()
 --	numExpired := 0
 --	for k := range dec.rx {
 --		if _itimediff(current, dec.rx[k].ts) > fecExpire {
 --			numExpired++
 --			continue
 --		}
 --		break
 --	}
 --	if numExpired > 0 {
 --		dec.rx = dec.freeRange(0, numExpired, dec.rx)
 --	}
 --	return
 --}
 --
 --// free a range of fecPacket
 --func (dec *fecDecoder) freeRange(first, n int, q []fecElement) []fecElement {
 --	for i := first; i < first+n; i++ { // recycle buffer
 --		xmitBuf.Put([]byte(q[i].fecPacket))
 --	}
 --
 --	if first == 0 && n < cap(q)/2 {
 --		return q[n:]
 --	}
 --	copy(q[first:], q[first+n:])
 --	return q[:len(q)-n]
 --}
 --
 --// release all segments back to xmitBuf
 --func (dec *fecDecoder) release() {
 --	if n := len(dec.rx); n > 0 {
 --		dec.rx = dec.freeRange(0, n, dec.rx)
 --	}
 --}
 --
 --type (
 --	// fecEncoder for encoding outgoing packets
 --	fecEncoder struct {
 --		dataShards   int
 --		parityShards int
 --		shardSize    int
 --		paws         uint32 // Protect Against Wrapped Sequence numbers
 --		next         uint32 // next seqid
 --
 --		shardCount int // count the number of datashards collected
 --		maxSize    int // track maximum data length in datashard
 --
 --		headerOffset  int // FEC header offset
 --		payloadOffset int // FEC payload offset
 --
 --		// caches
 --		shardCache  [][]byte
 --		encodeCache [][]byte
 --
 --		// zeros
 --		zeros []byte
 --
 --		// RS encoder
 --		codec reedsolomon.Encoder
 --	}
 --)
 --
 --func newFECEncoder(dataShards, parityShards, offset int) *fecEncoder {
 --	if dataShards <= 0 || parityShards <= 0 {
 --		return nil
 --	}
 --	enc := new(fecEncoder)
 --	enc.dataShards = dataShards
 --	enc.parityShards = parityShards
 --	enc.shardSize = dataShards + parityShards
 --	enc.paws = 0xffffffff / uint32(enc.shardSize) * uint32(enc.shardSize)
 --	enc.headerOffset = offset
 --	enc.payloadOffset = enc.headerOffset + fecHeaderSize
 --
 --	codec, err := reedsolomon.New(dataShards, parityShards)
 --	if err != nil {
 --		return nil
 --	}
 --	enc.codec = codec
 --
 --	// caches
 --	enc.encodeCache = make([][]byte, enc.shardSize)
 --	enc.shardCache = make([][]byte, enc.shardSize)
 --	for k := range enc.shardCache {
 --		enc.shardCache[k] = make([]byte, mtuLimit)
 --	}
 --	enc.zeros = make([]byte, mtuLimit)
 --	return enc
 --}
 --
 --// encodes the packet, outputs parity shards if we have collected quorum datashards
 --// notice: the contents of 'ps' will be re-written in successive calling
 --func (enc *fecEncoder) encode(b []byte) (ps [][]byte) {
 --	// The header format:
 --	// | FEC SEQID(4B) | FEC TYPE(2B) | SIZE (2B) | PAYLOAD(SIZE-2) |
 --	// |<-headerOffset                |<-payloadOffset
 --	enc.markData(b[enc.headerOffset:])
 --	binary.LittleEndian.PutUint16(b[enc.payloadOffset:], uint16(len(b[enc.payloadOffset:])))
 --
 --	// copy data from payloadOffset to fec shard cache
 --	sz := len(b)
 --	enc.shardCache[enc.shardCount] = enc.shardCache[enc.shardCount][:sz]
 --	copy(enc.shardCache[enc.shardCount][enc.payloadOffset:], b[enc.payloadOffset:])
 --	enc.shardCount++
 --
 --	// track max datashard length
 --	if sz > enc.maxSize {
 --		enc.maxSize = sz
 --	}
 --
 --	//  Generation of Reed-Solomon Erasure Code
 --	if enc.shardCount == enc.dataShards {
 --		// fill '0' into the tail of each datashard
 --		for i := 0; i < enc.dataShards; i++ {
 --			shard := enc.shardCache[i]
 --			slen := len(shard)
 --			copy(shard[slen:enc.maxSize], enc.zeros)
 --		}
 --
 --		// construct equal-sized slice with stripped header
 --		cache := enc.encodeCache
 --		for k := range cache {
 --			cache[k] = enc.shardCache[k][enc.payloadOffset:enc.maxSize]
 --		}
 --
 --		// encoding
 --		if err := enc.codec.Encode(cache); err == nil {
 --			ps = enc.shardCache[enc.dataShards:]
 --			for k := range ps {
 --				enc.markParity(ps[k][enc.headerOffset:])
 --				ps[k] = ps[k][:enc.maxSize]
 --			}
 --		}
 --
 --		// counters resetting
 --		enc.shardCount = 0
 --		enc.maxSize = 0
 --	}
 --
 --	return
 --}
 --
 --func (enc *fecEncoder) markData(data []byte) {
 --	binary.LittleEndian.PutUint32(data, enc.next)
 --	binary.LittleEndian.PutUint16(data[4:], typeData)
 --	enc.next++
 --}
 --
 --func (enc *fecEncoder) markParity(data []byte) {
 --	binary.LittleEndian.PutUint32(data, enc.next)
 --	binary.LittleEndian.PutUint16(data[4:], typeParity)
 --	// sequence wrap will only happen at parity shard
 --	enc.next = (enc.next + 1) % enc.paws
 --}
 -diff --git a/removed.go b/removed.go
 -new file mode 100644
 -index 0000000..5ecf446
 ---- /dev/null
 -+++ b/removed.go
 -@@ -0,0 +1,29 @@
 -+package kcp
 -+
 -+// Dummy implementations for types from crypt.go and fec.go, removed to reduce
 -+// dependencies.
 -+
 -+const (
 -+	fecHeaderSize      = 6
 -+	fecHeaderSizePlus2 = fecHeaderSize + 2
 -+	typeData           = 0xf1
 -+	typeParity         = 0xf2
 -+)
 -+
 -+type (
 -+	BlockCrypt interface {
 -+		Encrypt(_, _ []byte)
 -+		Decrypt(_, _ []byte)
 -+	}
 -+	fecDecoder struct{}
 -+	fecEncoder struct{}
 -+	fecPacket  []byte
 -+)
 -+
 -+func newFECDecoder(rxlimit, dataShards, parityShards int) *fecDecoder { return nil }
 -+func newFECEncoder(dataShards, parityShards, offset int) *fecEncoder  { return nil }
 -+
 -+func (_ *fecDecoder) decode(in fecPacket) [][]byte { panic("disabled") }
 -+func (_ *fecDecoder) release()                     { panic("disabled") }
 -+func (_ *fecEncoder) encode(b []byte) [][]byte     { panic("disabled") }
 -+func (_ fecPacket) flag() uint16                   { panic("disabled") }
 ---
 -2.20.1
+-