1.添加AES和XOR加密方法。

Signed-off-by: dmy@lab <dmy@lab.com>

tscipher/aes.go

@@ -0,0 +1,79 @@
+package tscipher
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	crtrand "crypto/rand"
+	//	"errors"
+	"io"
+	"log"
+)
+
+type AES struct {
+	key []byte
+}
+
+func (this *AES) aesEncrypt(key, text []byte) (ciphertext []byte) {
+	ciphertext = make([]byte, aes.BlockSize+len(string(text)))
+	// iv =  initialization vector
+	iv := ciphertext[:aes.BlockSize]
+
+	io.ReadFull(crtrand.Reader, iv)
+
+	//	var block cipher.Block
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		ciphertext = nil
+		log.Println("encrypt err", err)
+	}
+
+	cfb := cipher.NewCFBEncrypter(block, iv)
+	cfb.XORKeyStream(ciphertext[aes.BlockSize:], text)
+	return
+}
+
+func (this *AES) aesDecrypt(key, ciphertext []byte) (plaintext []byte) {
+
+	//	var block cipher.Block
+	//	if len(ciphertext) < aes.BlockSize {
+	//		err := errors.New("ciphertext too short")
+	//		plaintext = nil
+	//		log.Println("decrypt err", err)
+	//	}
+
+	iv := ciphertext[:aes.BlockSize]
+	ciphertext = ciphertext[aes.BlockSize:]
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		plaintext = nil
+		log.Println("decrypt err", err)
+	}
+	cfb := cipher.NewCFBDecrypter(block, iv)
+	cfb.XORKeyStream(ciphertext, ciphertext)
+
+	plaintext = ciphertext
+
+	return
+}
+
+func (this *AES) Decrypt(data []byte) (decrypted []byte, err error) {
+	data = this.aesDecrypt(this.key, data)
+	decrypted = data
+	err = nil
+	return
+}
+
+func (this *AES) Encrypt(data []byte) (encryped []byte, err error) {
+	this.aesEncrypt(this.key, data)
+	encryped = data
+	err = nil
+	return
+}
+
+func NewAES() (cipher Cipher) {
+	key := make([]byte, 32)
+	io.ReadFull(crtrand.Reader, key)
+	return &AES{
+		key: key,
+	}
+}

tscipher/chacha.go

@@ -1,20 +1,40 @@
 package tscipher
 
+import (
+	chacha "github.com/codahale/chacha20"
+	"log"
+)
+
 type ChaCha struct {
+	key   []byte
+	nonce []byte
 }
 
-func (*ChaCha) Decrypt(data []byte) (decrypted []byte, err error) {
+func (this *ChaCha) Decrypt(data []byte) (decrypted []byte, err error) {
+	//	xor, err := chacha.NewXChaCha(this.key, this.nonce)
+	if err != nil {
+		log.Fatalln("Decrypt", err)
+	}
+	//	xor.XORKeyStream(data, data)
 	decrypted = data
 	err = nil
 	return
 }
 
-func (*ChaCha) Encrypt(data []byte) (encryped []byte, err error) {
+func (this *ChaCha) Encrypt(data []byte) (encryped []byte, err error) {
+	xor, err := chacha.NewXChaCha(this.key, this.nonce)
+	if err != nil {
+		log.Fatalln("Chacha Encrypt", err)
+	}
+	xor.XORKeyStream(data, data)
 	encryped = data
 	err = nil
 	return
 }
 
 func NewChaCha() (cipher Cipher) {
-	return &ChaCha{}
+	return &ChaCha{
+		key:   make([]byte, 256),
+		nonce: make([]byte, 64),
+	}
 }

tscipher/cipher.go

@@ -19,15 +19,38 @@ func NewCipher(cipherName string) (cipher Cipher) {
 	if cipherName == "default" {
 		return NewChaCha()
 	}
+	if cipherName == "AES" {
+		return NewAES()
+	}
+	if cipherName == "XOR" {
+		return NewXOR([]byte("fasdfasdf"))
+	}
 	return nil //TODO:临时这样处理
 }
 
 func SendData(carrier *Carrier, nByte int) (n int, err error) {
-	n, err = carrier.Conn.Write(carrier.Cache[:nByte])
+	encrypedByte, err := carrier.Cipher.Encrypt(carrier.Cache[:nByte])
+	if err != nil {
+		n = 0
+		return
+	}
+	n, err = carrier.Conn.Write(encrypedByte[:nByte])
 	return
 }
 
 func ReceiveData(carrier *Carrier) (n int, err error) {
 	n, err = carrier.Conn.Read(carrier.Cache)
+	if err != nil {
+		n = 0
+		return
+	}
+	//TODO:err
+	decrypted, err := carrier.Cipher.Decrypt(carrier.Cache[:n])
+	copy(carrier.Cache, decrypted[:n])
+
+	if err != nil {
+		n = 0
+		return
+	}
 	return
 }

tscipher/xor.go

@@ -0,0 +1,31 @@
+package tscipher
+
+import ()
+
+type XOR struct {
+	key []byte
+}
+
+func (this *XOR) Decrypt(data []byte) (decrypted []byte, err error) {
+	decrypted = make([]byte, len(data))
+	for i := 0; i < len(data); i++ {
+		decrypted[i] = data[i] ^ this.key[i%len(this.key)]
+	}
+	err = nil
+	return
+}
+
+func (this *XOR) Encrypt(data []byte) (encryped []byte, err error) {
+	encryped = make([]byte, len(data))
+	for i := 0; i < len(data); i++ {
+		encryped[i] = data[i] ^ this.key[i%len(this.key)]
+	}
+	err = nil
+	return
+}
+
+func NewXOR(key []byte) (cipher Cipher) {
+	return &XOR{
+		key: key,
+	}
+}