trsa

node-rsa rsa with an API that you understand.

node-rsa is a great module, it offers good encryption. Sadly its API is to complex. This module reduce the API for rsa signing / verification and encryption/decryption to a minimum of just 6 functions. Also it let you work with plane old javascript objects and data types. You don't need to hassle with internal classes.

• generateKeyPair({bits: 512}) to create 512 bit public and private key

• sign(data, privateKey) to sign data

• verify(data, signature, publicKey) to verify the source of the data

• encrypt(data, publicKey) to encrypt something that only the corresponding privateKey can decrypt

• decrypt(data, privateKey) decrypt data that was encrypted specially for you.

you can use webpack or browserify to use the rsa module in the browser. And the now it has a corresponding implementation in golang.

const rsa = require('trsa')
const keypair = rsa.generateKeyPair({bits:512});

// encryption
const messageForAlice = rsa.encrypt('Hallo, this is Bob. I have something to tell you.', keyPair.publicKey);
const decryptedMessage = rsa.decrypt(messageForAlice, keypair.privateKey);

// signature
const statement = "very tough statement";
const signature = rsa.sign(statement, keypair.privateKey);
const isSigned = rsa.verify(statement, signature, keypair.publicKey);

// save key: using node-rsa directly, this is not possible so easy ! !
// as you see, that you can easily return the key as it is, to a client, without any extra transformation.
fs.writeKeySync('./keyFile.json', JSON.stringify(keypair));

GOLANG

For golang you simple import github.com/tobiasnickel/trsa/golang/trsa or run the following command for installation:

go get github.com/tobiasnickel/trsa/golang/trsa

and then you can do the same as before:

package main

import (
	"fmt"
	"io/ioutil"

	"github.com/tobiasnickel/trsa/golang/trsa"
)

func main() {
	publicKey, privateKey, err := trsa.GenerateKeys(2048)
	if err != nil {
		fmt.Println(err)
		return
	}

	golangMessage := []byte("Hallo Javascript from Golang !!!")
    
	encryptedMessage, err := trsa.Encrypt(golangMessage, publicKey)
	if err != nil {
		fmt.Println(err)
		return
	}
    decryptedMessage, err := trsa.Decrypt(encryptedMessage, privateKey) 
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("decrypted message:", string(decryptedMessage));
	signature, err := trsa.Sign(golangMessage, privateKey)
	if err != nil {
		fmt.Println(err)
		return
	}

	err = trsa.Verify(golangMessage, signature, publicKey);
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("done")
}