RSA Javascript encryption and Golang decryption

I have a scenario where I need to use RSA public key encryption standard with JavaScript and Golang.
I need to encrypt data in JavaScript using public key and decrypt the same in Golang using the private key.
I tried using PKCS#1(travst library for JavaScript and crypto/rsa for Golang), but failed in decryption. Can anyone suggest solutions for this?

I tried all possible solutions and researched many documents, but still I couldn't find a proper method. If I do encrypt and decrypt within golang, its working fine. But there is some integration problem between javascript and golang. I am not sure about the padding methodology used in javasript.

This is my golang code to decrypt:

func Decrypt(encryptedData, label []byte) (decryptedData []byte) {
var err error
var block *pem.Block
var private_key *rsa.PrivateKey

if block, _ = pem.Decode([]byte(privatKeyData)); block == nil || block.Type != "RSA PRIVATE KEY" { //privatKeyData is in string format
	log.Fatal("No valid PEM data found")
}

//Read Private Key
if private_key, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil {
	log.Fatalf("Private key can't be decoded: %s", err)
}

//Decrypt
if decrypted, err = rsa.DecryptPKCS1v15(rand.Reader, private_key, encryptedData); err != nil {
        log.Println(err)
}
return
}

It's possible to encrypt in javascript and decrypt in Go. Using the library you refer to, jsencrypt:

Create public & private key pair:

openssl genrsa -out key.pem
openssl rsa -in key.pem -pubout > pub.pem

Encryption in javascript:

var encrypt = new JSEncrypt();
encrypt.setPublicKey($('#pubkey').val());

var encrypted = encrypt.encrypt($('#message').val());

$.post("/decrypt", encrypted, function(response) {
	$("#decrypted").val(response);
});

Decryption in Go:

func handleDecrypt(w http.ResponseWriter, r *http.Request) {
	decoder := base64.NewDecoder(base64.StdEncoding, r.Body)
	defer r.Body.Close()
	encrypted, err := ioutil.ReadAll(decoder)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	data, err := rsa.DecryptPKCS1v15(rand.Reader, privateKey, encrypted)
	if err != nil {
		http.Error(w, "decrypt error", http.StatusBadRequest)
		log.Println(err)
		return
	}
	fmt.Fprint(w, string(data))
}

Update: the privateKey variable is a *rsa.PrivateKey derived from the private key file created by openssl, in this case the "key.pem" file. A pem file is a Base64 encoded DER certificate, eg, -----BEGIN RSA PRIVATE KEY----- and -----END RSA PRIVATE KEY----- show a private key in PEM format. Go standard library provides the x509.ParsePKCS1PrivateKey() method to parse a pem encoded key from a byte slice.

So loading the key into Go might look something like this:

keyBytes, err := ioutil.ReadFile("path/to/key.pem")
if err != nil { ... }

privateKey, err := x509.ParsePKCS1PrivateKey(keyBytes)
if err != nil { ... }

1：You can encrypt cleartext in javascript reference from.

> https://github.com/travist/jsencrypt

var encrypt = new JSEncrypt();
encrypt.setPublicKey($('#pubkey').val());
var encrypted = encrypt.encrypt($('#input').val());

2：Be aware of that the jsencrypt has already done encrypt and base64encode.

Be aware of that jsencrypt use PKCS1 not OAEP

3: Base64decode in golang and decrypt message from step 1.

var encrypted := 'change this to the encrypted text your js sent'
privateKey,_ = ioutil.ReadFile("private.pem")
cipherText,_ := base64.StdEncoding.DecodeString(encrypted)
originText,_ :=RsaDecrypt([]byte(cipherText))

decrypt function

func RsaDecrypt(cipherText []byte) ([]byte, error) {
    	block, _ := pem.Decode(privateKey)
    	if block == nil {
    		return nil, errors.New("private key error!")
    	}
    	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    	if err != nil {
    		return nil, err
    	}
    
    	return rsa.DecryptPKCS1v15(rand.Reader, priv, cipherText)
    }

now you get the encrypted text originText
reference from

> https://segmentfault.com/q/1010000002505932

4: Further more, you can generate key pair in go

func GenRsaKey(bits int) error {
	privateKey, err := rsa.GenerateKey(rand.Reader, bits)
	if err != nil {
		return err
	}
	derStream := x509.MarshalPKCS1PrivateKey(privateKey)
	block := &pem.Block{
		Type:  "privete key",
		Bytes: derStream,
	}
	file, err := os.Create("private.pem")
	if err != nil {
		return err
	}
	err = pem.Encode(file, block)
	if err != nil {
		return err
	}
	publicKey := &privateKey.PublicKey
	derPkix, err := x509.MarshalPKIXPublicKey(publicKey)
	if err != nil {
		return err
	}
	block = &pem.Block{
		Type:  "public key",
		Bytes: derPkix,
	}
	file, err = os.Create("public.pem")
	if err != nil {
		return err
	}
	err = pem.Encode(file, block)
	if err != nil {
		return err
	}
	return nil
}