107 lines
3.2 KiB
Go
107 lines
3.2 KiB
Go
package meowlib
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"time"
|
|
|
|
"github.com/ProtonMail/gopenpgp/v2/crypto"
|
|
"github.com/ProtonMail/gopenpgp/v2/helper"
|
|
"github.com/rs/zerolog/log"
|
|
)
|
|
|
|
type KeyPair struct {
|
|
Public string `json:"public,omitempty"`
|
|
Private string `json:"private,omitempty"`
|
|
Generated time.Time `json:"generated,omitempty"`
|
|
}
|
|
|
|
type KeysArray []KeyPair
|
|
|
|
func NewKeyPair() KeyPair {
|
|
var kp KeyPair
|
|
keys, err := crypto.GenerateKey("name", "mail", "x25519", 0)
|
|
if err != nil {
|
|
log.Error().Msg("Key generation failed")
|
|
}
|
|
kp.Generated = time.Now()
|
|
pub, err := keys.GetArmoredPublicKey()
|
|
if err != nil {
|
|
log.Error().Msg("Public key extraction failed")
|
|
}
|
|
kp.Public = base64.StdEncoding.EncodeToString([]byte(pub))
|
|
priv, err := keys.Armor()
|
|
if err != nil {
|
|
log.Error().Msg("Private key extraction failed")
|
|
}
|
|
kp.Private = base64.StdEncoding.EncodeToString([]byte(priv))
|
|
return kp
|
|
}
|
|
|
|
func (keyPair *KeyPair) GetCryptoKeyObject() *crypto.Key {
|
|
priv, err := base64.StdEncoding.DecodeString(keyPair.Private)
|
|
if err != nil {
|
|
log.Error().Msg("Create key from armoured b64 failed")
|
|
}
|
|
key, err := crypto.NewKeyFromArmored(string(priv))
|
|
if err != nil {
|
|
log.Error().Msg("Create key from armoured failed")
|
|
}
|
|
return key
|
|
}
|
|
|
|
func Encrypt(publicKey string, data []byte) ([]byte, error) {
|
|
pub, err := base64.StdEncoding.DecodeString(publicKey)
|
|
if err != nil {
|
|
log.Error().Msg("Message encryption b64 failed")
|
|
}
|
|
armor, err := helper.EncryptBinaryMessageArmored(string(pub), data)
|
|
if err != nil {
|
|
log.Error().Msg("Message encryption failed")
|
|
}
|
|
return []byte(armor), err
|
|
}
|
|
|
|
func Decrypt(privateKey string, data []byte) ([]byte, error) {
|
|
priv, err := base64.StdEncoding.DecodeString(privateKey)
|
|
if err != nil {
|
|
log.Error().Msg("Message decryption b64 failed")
|
|
}
|
|
decrypted, err := helper.DecryptBinaryMessageArmored(string(priv), nil, string(data))
|
|
if err != nil {
|
|
log.Error().Msg("Message decryption failed")
|
|
}
|
|
return []byte(decrypted), err
|
|
}
|
|
|
|
func EncryptAndSign(publicEncKey string, privateSignKey string, data []byte) ([]byte, []byte, error) {
|
|
pub, err := base64.StdEncoding.DecodeString(publicEncKey)
|
|
if err != nil {
|
|
log.Error().Msg("Message encryption and sign b64 failed")
|
|
}
|
|
priv, err := base64.StdEncoding.DecodeString(privateSignKey)
|
|
if err != nil {
|
|
log.Error().Msg("Message encryption and sign b64 failed")
|
|
}
|
|
encrypted, signature, err := helper.EncryptSignBinaryDetached(string(pub), string(priv), nil, data)
|
|
if err != nil {
|
|
log.Error().Msg("Message encryption and sign failed")
|
|
}
|
|
return []byte(encrypted), []byte(signature), err
|
|
}
|
|
|
|
func DecryptAndCheck(MyPrivateEncryptionKey string, peerContactPublicKey string, data []byte, signature []byte) (DecryptedMessage []byte, err error) {
|
|
pub, err := base64.StdEncoding.DecodeString(MyPrivateEncryptionKey)
|
|
if err != nil {
|
|
log.Error().Msg("Message decryption and sign b64 failed")
|
|
}
|
|
priv, err := base64.StdEncoding.DecodeString(peerContactPublicKey)
|
|
if err != nil {
|
|
log.Error().Msg("Message decryption and sign b64 failed")
|
|
}
|
|
DecryptedMessage, err = helper.DecryptVerifyBinaryDetached(string(pub), string(priv), nil, data, string(signature))
|
|
if err != nil {
|
|
log.Error().Msg("Message decryption and sign failed")
|
|
}
|
|
return DecryptedMessage, err
|
|
}
|