Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
T
tor-browser-build
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Deploy
Releases
Package Registry
Container Registry
Model registry
Operate
Terraform modules
Monitor
Incidents
Service Desk
Analyze
Value stream analytics
Contributor analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
henry
tor-browser-build
Commits
959bdfb9
Commit
959bdfb9
authored
1 year ago
by
Pier Angelo Vendrame
Browse files
Options
Downloads
Patches
Plain Diff
Bug 41048: Remove the kcp-go project
parent
338d8950
No related branches found
Branches containing commit
No related tags found
No related merge requests found
Changes
1
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
projects/kcp-go/remove-crypt-fec.patch
+0
-1019
0 additions, 1019 deletions
projects/kcp-go/remove-crypt-fec.patch
with
0 additions
and
1019 deletions
projects/kcp-go/remove-crypt-fec.patch
deleted
100644 → 0
+
0
−
1019
View file @
338d8950
From 0b9d0759f979a5d828b747ea51771f307c53d221 Mon Sep 17 00:00:00 2001
From: David Fifield <david@bamsoftware.com>
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
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment