keys Usage

RSA Key Example

Generating RSA Public and Private Keys, Encrypting Data Using the OAEP Padding Mode of the Public Key, and Decrypting Data Using the OAEP Padding Mode of the Private Key

import crypto.keys.*
import crypto.digest.*
import std.io.*
import std.crypto.digest.*

main() {
    var rsaPri = RSAPrivateKey(2048)
    var rsaPub = RSAPublicKey(rsaPri)

    var str: String = "hello world, hello cangjie"
    var bas1 = ByteArrayStream()
    var bas2 = ByteArrayStream()
    var bas3 = ByteArrayStream()
    bas1.write(str.toArray())

    var encOpt = OAEPOption(SHA1(), SHA256())
    rsaPub.encrypt(bas1, bas2, padType: OAEP(encOpt))
    var encOpt2 = OAEPOption(SHA1(), SHA256())
    rsaPri.decrypt(bas2, bas3, padType: OAEP(encOpt2))

    var buf = Array<Byte>(str.size, item:0)
    bas3.read(buf)
    if (str.toArray() == buf){
        println("success")
    } else {
        println("fail")
    }
}

Running result:

success

Reading the RSA Public and Private Keys from a File, Using the PKCS1 Padding Mode of the Private Key for Signing, and Using the PKCS1 Padding Mode of the Public Key to Verify the Signature Result

Note: >

• The public and private key files need to be prepared in advance.

import crypto.keys.*
import crypto.digest.*
import std.crypto.digest.*
import std.fs.*

main() {
    var pemPri = String.fromUtf8(File("./files/rsaPri.pem", OpenOption.Open(true, false)).readToEnd())
    var rsaPri = RSAPrivateKey.decodeFromPem(pemPri)

    var pemPub = String.fromUtf8(File("./files/rsaPub.pem", OpenOption.Open(true, false)).readToEnd())
    var rsaPub = RSAPublicKey.decodeFromPem(pemPub)

    var str: String = "helloworld"
    var sha512Instance = SHA512()
    var md: Array<Byte> = digest(sha512Instance, str)

    var sig = rsaPri.sign(sha512Instance, md, padType: PKCS1)
    if (rsaPub.verify(sha512Instance, md, sig, padType: PKCS1)){
        println("verify successful")
    }
}

Running result:

verify successful

ECDSA Key Example

ECDSA Key Usage Example

Generating ECDSA Public and Private Keys, Using the Private Key for Signing, and Using the Public Key to Verify the Signature Result

import crypto.keys.*
import crypto.digest.*
import std.convert.*
import std.crypto.digest.*

main() {
    var ecPri = ECDSAPrivateKey(P224)
    var ecPub = ECDSAPublicKey(ecPri)

    var str: String = "helloworld"
    var sha512Instance = SHA512()
    var md: Array<Byte> = digest(sha512Instance, str)

    var sig = ecPri.sign(md)
    println(sig)
    if (ecPub.verify(md, sig)){
        println("verify successful")
    }
}

Running result:

verify successful

SM2 Key Example

Generating SM2 Public and Private Keys, Using the Private Key for Signing, and Using the Public Key to Verify the Signature Result

main(): Unit {
    // Generates public and private keys without parameters.
    let sm2PrivateKey = SM2PrivateKey()
    let sm2PublicKey = SM2PublicKey(sm2PrivateKey)

    // Exports the public and private keys.
    let priPem = sm2PrivateKey.encodeToPem()
    let file1: File = File("./sm2Pri.pem", OpenOption.CreateOrTruncate(true))
    file1.write(priPem.encode().toArray())
    file1.close()

    let pubPem = sm2PublicKey.encodeToPem()
    let file2: File = File("./sm2Pub.pem", OpenOption.CreateOrTruncate(true))
    file2.write(pubPem.encode().toArray())
    file2.close()

    // Encrypts data using the public key and decrypts data using the private key.
    let str: String = "helloworld"
    let encresult = sm2PublicKey.encrypt(str.toArray())
    let decresult = sm2PrivateKey.decrypt(encresult)
    println(String.fromUtf8(decresult))

    // Performs signing using the private key and verifies the signature using the public key.
    let strSig: String = "helloworld"
    let sigRe = sm2PrivateKey.sign(strSig.toArray())
    let verifyre  = sm2PublicKey.verify(strSig.toArray(), sigRe)
    println(verifyre)

    //Imports the private and public keys.
    let pemPri = String.fromUtf8(File("./sm2Pri.pem", OpenOption.Open(true, false)).readToEnd())
    let sm2PrivateKeyNew = SM2PrivateKey.decodeFromPem(pemPri)
    let pemPub = String.fromUtf8(File("./sm2Pub.pem", OpenOption.Open(true, false)).readToEnd())
    let sm2PublicKeyNew = SM2PublicKey.decodeFromPem(pemPub)

    }

Running result:

helloworld
true