package main
import (
	"bufio"
	"crypto"
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/base64"
	"encoding/json"
	"encoding/pem"
	"errors"
	"fmt"
	"io"
	"net"
)
func Encode(data []byte) string {
	hb := base64.StdEncoding.EncodeToString([]byte(data))
	return hb
}
// Decoding the base string to array of bytes
func Decode(data string) []byte {
	hb, _ := base64.StdEncoding.DecodeString(data)
	return hb
}
// Generating RSA private key
func GenerateRsaPrivateKey(size int) (*rsa.PrivateKey, error) {
	privateKey, err := rsa.GenerateKey(rand.Reader, size)
	if err != nil {
		return nil, err
	}
	return privateKey, nil
}
// Generating RSA public key
func GenerateRsaPublicKey(privateKey *rsa.PrivateKey) rsa.PublicKey {
	return privateKey.PublicKey
}
// This function can be use encrypt a plain text with rsa algorithm
func RsaEncrypt(publicKey rsa.PublicKey, data string) ([]byte, error) {
	encryptedBytes, err := rsa.EncryptPKCS1v15(
		rand.Reader,
		&publicKey,
		[]byte(data))
	return encryptedBytes, err
	// encryptedBytes, err := rsa.EncryptOAEP(
	// 	sha256.New(),
	// 	rand.Reader,
	// 	&publicKey,
	// 	[]byte(data),
	// 	nil)
	// return encryptedBytes, err
}
// This function can be use decrypt a encrypted text with rsa algorithm
func RsaDecrypt(privateKey rsa.PrivateKey, data []byte) ([]byte, error) {
	decryptedBytes, err := privateKey.Decrypt(
		nil,
		data,
		&rsa.OAEPOptions{Hash: crypto.SHA256})
	return decryptedBytes, err
}
//  This fucntion is used to dump/serialize the rsa public key
func DumpKey(key *rsa.PublicKey) ([]byte, error) {
	return x509.MarshalPKCS1PublicKey(key), nil
}
// This function is used to load the rsa public key
func LoadKey(byteKey []byte) (*rsa.PublicKey, error) {
	key, err := x509.ParsePKCS1PublicKey(byteKey)
	return key, err
}
// Generate fixed size byte array
func GenerateAesKey(size int) []byte {
	token := make([]byte, size)
	rand.Read(token)
	return token
}
// This fucntion can be used for encrypting a plain text using AES-GCM algorithm
func AesEncryption(key []byte, data string) ([]byte, error) {
	c, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(c)
	if err != nil {
		return nil, err
	}
	nonce := make([]byte, gcm.NonceSize())
	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
		return nil, err
	}
	cipherText := gcm.Seal(nonce, nonce, []byte(data), nil)
	return cipherText, nil
}
// This fucntion can be used for decrypting the ciphertext encrypted using AES-GCM algorithm
func AesDecryption(key []byte, cipherText []byte, nonce []byte) ([]byte, error) {
	c, err := aes.NewCipher(key)
	if err != nil {
		fmt.Println("1")
		return nil, err
	}
	gcm, err := cipher.NewGCM(c)
	if err != nil {
		fmt.Println("2")
		return nil, err
	}
	noncesize := gcm.NonceSize()
	if len(cipherText) < noncesize {
		fmt.Println("3")
		return nil, err
	}
	cipherText = cipherText[noncesize:]
	// nonce, cipherText := cipherText[:noncesize], cipherText[noncesize:]
	plainText, err := gcm.Open(nil, nonce, cipherText, nil)
	if err != nil {
		fmt.Println("4", err.Error())
		return nil, err
	}
	return plainText, nil
}
func ParseRsaPublicKeyFromPemStr(pubPEM string) (*rsa.PublicKey, error) {
	block, _ := pem.Decode([]byte(pubPEM))
	if block == nil {
		return nil, errors.New("failed to parse PEM block containing the key")
	}
	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	switch pub := pub.(type) {
	case *rsa.PublicKey:
		return pub, nil
	default:
		break // fall through
	}
	return nil, errors.New("Key type is not RSA")
}
type trans struct {
	Key string `json:"key"`
}
type creden struct {
	Data  []byte `json:"data"`
	Nonce []byte `json:"nonce"`
}
func startServer() {
	fmt.Println("Starting Server...")
	l, err := net.Listen("tcp", "127.0.0.1:8080")
	if err != nil {
		panic(err)
	}
	defer l.Close()
	c, err := l.Accept()
	if err != nil {
		panic(err)
	}
	fmt.Println("Client Connected: ", c)
	data, err := bufio.NewReader(c).ReadBytes('\n')
	if err != nil {
		panic(err)
	}
	var t trans
	err_ := json.Unmarshal(data, &t)
	if err != nil {
		panic(err_)
	}
	// fmt.Println("Key: ", t.Key)
	publicKey, e := ParseRsaPublicKeyFromPemStr(t.Key)
	if e != nil {
		panic(e)
	}
	// fmt.Println("Success", publicKey)
	var cre creden
	cre.Data = GenerateAesKey(32)
	cre.Nonce = GenerateAesKey(12)
	jsonRes, err := json.Marshal(cre)
	if err != nil {
		panic(err)
	}
	cipherText, e_r := RsaEncrypt(*publicKey, string(jsonRes))
	if e_r != nil {
		panic(e_r)
	}
	fmt.Println("cipherText: ", len(cipherText), " | ", cipherText)
	encodedCipherText := Encode(cipherText)
	n, err := c.Write([]byte(encodedCipherText))
	if err != nil {
		panic(err)
	}
	fmt.Println("Written back the response. Written Bytes: ", n)
	data2, err2 := bufio.NewReader(c).ReadBytes('\n')
	if err2 != nil {
		panic(err2)
	}
	var t2 trans
	err_2 := json.Unmarshal(data2, &t2)
	if err_2 != nil {
		panic(err_2)
	}
	fmt.Println("recv data: ", t2.Key)
	cipherText2 := Decode(t2.Key)
	fmt.Println("cipherText2: ", cipherText2)
	plainText2, err := AesDecryption(cre.Data, cipherText2, cre.Nonce)
	if err != nil {
		panic(err)
	}
	fmt.Println("plainText: ", plainText2)
}
func main() {
	startServer()
}

void connectFunc() async {
Socket socket = await Socket.connect('10.0.2.2', 8080);
print(socket);
print("Connected...");
// listen to the received data event stream
RSAKeypair rsaKeypair = RSAKeypair.fromRandom();
socket.listen((List<int> event) {
String base64Response = utf8.decode(event);
// dynamic response = base64.decode(base64Response);
// print(response.length);
// print(response.runtimeType);
try {
String plainText = rsaKeypair.privateKey.decrypt(base64Response);
print(plainText);
dynamic jsonData = jsonDecode(plainText);
String Key = jsonData["data"];
String Nonce = jsonData["nonce"];
var aes = AesCrypt(key: Key, padding: PaddingAES.pkcs7);
print('AES Symmetric GCM:');
var crypted = aes.gcm.encrypt(inp: 'words', iv: Nonce); //encrypt
// print(crypted);
// print(aes.gcm.decrypt(enc: crypted, iv: Nonce)); //decrypt
// print('');
print("send data: " + crypted);
dynamic dictData = {
"key": crypted,
};
socket.add(utf8.encode(jsonEncode(dictData) + "\n"));
} catch (e) {
print(e);
}
// dynamic response = jsonDecode(jsonResponse);
// String key = response["data"];
// String nonce = response["nonce"];
});
// RSAKeypair rsaKeypair = RSAKeypair.fromRandom();
dynamic dictData = {
"key": rsaKeypair.publicKey.toFormattedPEM(),
};
socket.add(utf8.encode(jsonEncode(dictData) + "\n"));
// send hello
// socket.add(utf8.encode('hello from flutter/dart'));
// return socket;
}