package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha512"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "log"
)

// GenerateKeyPair generates a new key pair
func GenerateKeyPair(bits int) (*rsa.PrivateKey, *rsa.PublicKey) {
    privkey, err := rsa.GenerateKey(rand.Reader, bits)
    if err != nil {
        log.Fatal(err)

    }
    return privkey, &privkey.PublicKey
}

// PrivateKeyToBytes private key to bytes
func PrivateKeyToBytes(priv *rsa.PrivateKey) []byte {
    privBytes := pem.EncodeToMemory(
        &pem.Block{
            Type:  "RSA PRIVATE KEY",
            Bytes: x509.MarshalPKCS1PrivateKey(priv),
        },
    )

    return privBytes
}

// PublicKeyToBytes public key to bytes
func PublicKeyToBytes(pub *rsa.PublicKey) []byte {
    pubASN1, err := x509.MarshalPKIXPublicKey(pub)
    if err != nil {
        log.Fatal(err)
    }

    pubBytes := pem.EncodeToMemory(&pem.Block{
        Type:  "RSA PUBLIC KEY",
        Bytes: pubASN1,
    })

    return pubBytes
}

// BytesToPrivateKey bytes to private key
func BytesToPrivateKey(priv []byte) *rsa.PrivateKey {
    block, _ := pem.Decode(priv)
    enc := x509.IsEncryptedPEMBlock(block)
    b := block.Bytes
    var err error
    if enc {
        log.Println("is encrypted pem block")
        b, err = x509.DecryptPEMBlock(block, nil)
        if err != nil {
            log.Fatal(err)
        }
    }
    key, err := x509.ParsePKCS1PrivateKey(b)
    if err != nil {
        log.Fatal(err)
    }
    return key
}

// BytesToPublicKey bytes to public key
func BytesToPublicKey(pub []byte) *rsa.PublicKey {
    block, _ := pem.Decode(pub)
    enc := x509.IsEncryptedPEMBlock(block)
    b := block.Bytes
    var err error
    if enc {
        log.Println("is encrypted pem block")
        b, err = x509.DecryptPEMBlock(block, nil)
        if err != nil {
            log.Fatal(err)
        }
    }
    ifc, err := x509.ParsePKIXPublicKey(b)
    if err != nil {
        log.Fatal(err)
    }
    key, ok := ifc.(*rsa.PublicKey)
    if !ok {
        log.Fatal("not ok")
    }
    return key
}

// EncryptWithPublicKey encrypts data with public key
func EncryptWithPublicKey(msg []byte, pub *rsa.PublicKey) []byte {
    hash := sha512.New()
    ciphertext, err := rsa.EncryptOAEP(hash, rand.Reader, pub, msg, nil)
    if err != nil {
        log.Fatal(err)
    }
    return ciphertext
}

// DecryptWithPrivateKey decrypts data with private key
func DecryptWithPrivateKey(ciphertext []byte, priv *rsa.PrivateKey) []byte {
    hash := sha512.New()
    plaintext, err := rsa.DecryptOAEP(hash, rand.Reader, priv, ciphertext, nil)
    if err != nil {
        log.Fatal(err)
    }
    return plaintext
}

func main() {
    public_k, private_k := GenerateKeyPair(2048)
    fmt.Println("Private Key : ", private_k)
    fmt.Println("Public key ", public_k)
    fmt.Println(EncryptWithPublicKey([]byte("kek"), *public_k))