CRPGP

This module based on threefold/crpgp repo, which is a wrapper for rpgp

Install

All needed libs can be installed from install.sh

High Level API

• List of supported functions with a description for each method

Notes:

• key_type is enum of [cv25519, rsa], by default key_type will be cv25519
• key_length used if key_type is rsa and 3072 is a default value

How to use !

• We will go together step by step to illustrate how to use this module.

• Import crpgp module

import crpgp

• We have two options here, generate a new key, or import

1. Generate:

• CV25519 key:

ssk := crpgp.generate_key(name: <YOUR_NAME>, email: <YOUR_EMAIL>) !

• RSA key

// key_length 3072 if not passed
ssk := crpgp.generate_key(name: <YOUR_NAME>, email: <YOUR_EMAIL>, key_type: .rsa) !

or

ssk := crpgp.generate_key(name: <YOUR_NAME>, email: <YOUR_EMAIL>, key_type: .rsa, key_length: <LENGTH>) !

2. Import signed secret key from file

ssk := crpgp.import_secretkey_from_file(<FILE_PATH>) !

• Now we have a signed secret key, let us get a signed public key, also we have two options, get from secret key or import

1. Get signed public key from signed secret key

spk := ssk.get_signed_public_key() !

2. import signed public key from file

spk := crpgp.import_publickey_from_file(<FILE_PATH>) !

• Now we have a signed public and secret key, let us try to sign and verify a message

message := 'these are my secrets\n12345'
mut sig := ssk.sign_message(message) !
println(sig.to_hex() !) // In case we want to convert it to hex, here just to display it

if spk.verify_signature(sig, message) {
    println('✅ message signed and verified!')
}

• let us try encrypt and decrypt message.

encrypted := spk.encrypt_from_text(message) !
decrypted := ssk.decrypt_to_text(encrypted) !
if message == decrypted {
    println('✅ message encrypted and decrypted!')
}

• Done !

fn cu8_to_vbytes(ptr &u8, l u64) []byte

fn deserialize_signature(bytes []byte) !Signature

fn generate_key(k KeyParams) !SignedSecretKey

fn import_publickey(data string) !SignedPublicKey

import functions import public key from ASCII armor text format

fn import_publickey_from_file(path string) !SignedPublicKey

import public key from ASCII armor file format

fn import_secretkey(data string) !SignedSecretKey

import secret key from ASCII armor text format

fn import_secretkey_from_file(path string) !SignedSecretKey

import secret key from ASCII armor file format

fn new_secret_key_param_builder() !SecretKeyParamsBuilder

fn new_subkey_params_builder() SubkeyParamsBuilder

fn signature_from_hex(sig string) !Signature

fn signed_public_key_from_armored(s string) !SignedPublicKey

fn signed_public_key_from_bytes(bytes []byte) !SignedPublicKey

fn signed_secret_key_from_armored(s string) !SignedSecretKey

fn signed_secret_key_from_bytes(bytes []byte) !SignedSecretKey

fn str_to_bytes(s string) []byte

fn (p &PublicKey) verify(data []byte, sig &Signature) !

fn (p &PublicKey) sign_and_free(sk SignedSecretKey) !SignedPublicKey

fn (s &PublicKey) encrypt(data []byte) ![]byte

fn (s &SecretKey) sign() !SignedSecretKey

fn (s &SecretKeyParams) generate_and_free() !SecretKey

fn (b &SecretKeyParamsBuilder) primary_key_id(primary_key_id string) !

fn (b &SecretKeyParamsBuilder) key_type(key_type C.KeyType) !

fn (b &SecretKeyParamsBuilder) subkey(subkey SubkeyParams) !

fn (b &SecretKeyParamsBuilder) build() !SecretKeyParams

fn (s &Signature) serialize() ![]byte

fn (sig &Signature) to_hex() !string

fn (b &SubkeyParamsBuilder) key_type(key_type C.KeyType) !

fn (b &SubkeyParamsBuilder) build() !SubkeyParams

enum CipherSuite {
	cv25519 // ed_dsa primary, ecdh sub
	rsa     // rsa primary (rsa and bitsize can be parameterized)
}

enum KeyType_Tag {
	rsa
	ecdh
	ed_dsa
}

Things that are hard to convert from the c header file automatically

struct KeyParams {
	name     string @[required]
	email    string @[required]
	key_type CipherSuite
	length   u32 = 3072
	comment  string
}

KeyParams

struct SignedPublicKey {
	internal &C.SignedPublicKey
}

fn (s &SignedPublicKey) encrypt(data []byte) ![]byte

fn (spk &SignedPublicKey) encrypt_from_text(message string) ![]byte

fn (s &SignedPublicKey) encrypt_with_any(data []byte) ![]byte

fn (s &SignedPublicKey) to_armored() !string

fn (s &SignedPublicKey) to_bytes() ![]byte

fn (p &SignedPublicKey) verify(data []byte, sig &Signature) !

fn (spk &SignedPublicKey) verify_signature(sig &Signature, message string) bool

Public Key Functions

struct SignedSecretKey {
	internal &C.SignedSecretKey
}

fn (s &SignedSecretKey) create_signature(data []byte) !Signature

fn (s &SignedSecretKey) decrypt(data []byte) ![]byte

fn (ssk &SignedSecretKey) decrypt_to_text(encrypted_message []byte) !string

fn (ssk &SignedSecretKey) get_signed_public_key() !SignedPublicKey

fn (s &SignedSecretKey) public_key() !PublicKey

fn (ssk &SignedSecretKey) sign_message(message string) !Signature

Secret Key Fucntions

fn (s &SignedSecretKey) to_armored() !string

fn (s &SignedSecretKey) to_bytes() ![]byte