鸿蒙仓颉语言【cryptocj 库】提供 非对称加密算法

4 提供 非对称加密算法

前置条件：NA

场景：

1. 支持非对称加密算法。

性能： 支持版本几何性能持平

可靠性： NA

4.1 DSA

DSA使用公开密钥，为接受者验证数据的完整性，也可用于由第三方去确定签名和所签数据的真实性。

支持 dsa 签名验证

4.1.1 主要接口

enum DsaTypeId

DSA 签名验证类型

public enum AlgorithmType <: ToString{
    | NID_md5
    | NID_sha1
    | NID_sha256
    | NID_sha384
    | NID_sha512
    | NID_md5_sha1
    | NULL

    /*
     * 获取各类型值
     *
     * 返回值 Int32 - 返回各个类型的值
     */
    public func getNum(): Int32
}

class DSASIG

签名结构

public class DSASIG {

    /*
     * 初始化 DSASIG
     */
    public init()

    /*
     * 初始化 DSASIG
     * 
     * 参数 r - DSASIG 值
     */
    public init(r: UInt64)

    /*
     * 获取 DSASIG 值
     *
     * 返回值 UInt64 
     */
    public func getDsaSign(): UInt64
}

class DSA

DSA 数据结构

public class DSA {

    /*
     * 初始化 DSA
     */
    public init()
}

class SINCALLOC

给签名值分配地址

public class SINCALLOC {

    /*
     * 初始化 SINCALLOC
     */
    public init(dsa: DSA)
}

class SINSTR

签名后的值

public class SINSTR {

    /*
     * 初始化 SINSTR
     */
    public init(s: Array<UInt8>, l: Int32)
    /*
     * 获取签名后值得长度
     *
     * 返回值 Int32
     */
    public func getSinLen(): Int32
    /*
     * 获取签名后值
     *
     * 返回值 Array<UInt8>
     */
    public func getArrayUtf8(): Array<UInt8>

}

4.1.2 全局函数

/*
 * 生成一个DSA数据结构
 *
 * 返回值 DSA
 */
public func dsaNew(): DSA

/*
 * 生成密钥参数。
 * 
 * 参数 dsa - DSA
 * 参数 bits - bits 位于 512 到 1024 之间，且为 64 的倍数
 * 返回值 Unit
 */
public func dsaGenerateParameters(dsa: DSA, bits: Int32): Unit

/*
 * 根据密钥参数生成公私钥
 * 
 * 参数 dsa - DSA
 * 返回值 Unit
 */
public func dsaGenerateKey(dsa: DSA): Unit

/*
 * DSA 签名
 * 
 * 参数 types - dsa 签名类型
 * 参数 dgst - 签名数据
 * 参数 sig - 签名值缓存区
 * 参数 dsa - DSA
 * 返回值 SINSTR - 签名后的值
 */
public func dsaSign(types: DsaTypeId, dgst: Array<UInt8>, sig: SINCALLOC, dsa: DSA): SINSTR

/*
 * DSA 验证
 * 
 * 参数 types - dsa验证类型，同签名类型一致
 * 参数 dgst - 签名数据
 * 参数 sigbuf - 签名后值（dsaSign 返回值）
 * 参数 dsa - DSA
 * 返回值 Int32 - 1 验证成功
 *             -  其他失败
 */
public func dsaVerify(types: DsaTypeId, dgst: Array<UInt8>, sigbuf: SINSTR, dsa: DSA): Int32

/*
 * 获取DSA密钥长度的字节数
 * 
 * 参数 dsa - DSA
 * 返回值 Int32
 */
public func dsaSize(dsa: DSA): Int32

/*
 * 将 DSA 密钥及相关参数输出
 * 
 * 参数 dsa - DSA
 * 返回值 Int32 - 成功 1，失败 0
 */
public func dsaPrint(dsa: DSA): Int32

/*
 * 生成 DSA 公钥 pem 文件
 * 
 * 参数 pub_key_fn - 文件路径
 * 参数 dsa - DSA
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 Unit
 */
public func pemWriteDsaPub(pub_key_fn: String, dsa: DSA, isPrint: Bool): Unit

/*
 * 生成 DSA 私钥 pem 文件
 * 
 * 参数 pub_key_fn - 文件路径
 * 参数 dsa - DSA
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 Unit
 */
public func pemWriteDsaPri(pub_key_fn: String, dsa: DSA, isPrint: Bool): Unit

/*
 * 生成 DSA 密钥参数 pem 文件
 * 
 * 参数 pub_key_fn - 文件路径
 * 参数 dsa - DSA
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 Unit
 */
public func pemWriteDsaPara(pub_key_fn: String, dsa: DSA, isPrint: Bool): Unit

/*
 * 从私钥文件读取 DSA 私钥
 * 
 * 参数 pri_key_fn - 文件路径
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 DSA
 */
public func pemReadDsaPri(pri_key_fn: String, isPrint: Bool): DSA

/*
 * 从公钥文件读取 DSA 公钥
 * 
 * 参数 pub_key_fn - 文件路径
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 DSA
 */
public func pemReadDsaPub(pub_key_fn: String, isPrint: Bool): DSA

/*
 * DSA 数字签名
 * 
 * 参数 dgst - 签名数据
 * 参数 pri_key_fn - 文件路径
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 DSA
 */
public func dsaDoSign(dgst: Array<UInt8>, pri_key_fn: String, isPrint: Bool): DSASIG

/*
 * DSA 数字签名验证
 * 
 * 参数 dgst - 签名数据
 * 参数 sig - 签名结构（取自 dsaDoSign 返回值）
 * 参数 pub_key_fn - 文件路径
 * 参数 isPrint - 是否打印密钥信息
 * 返回值 DSA - 1 验证成功，其他失败
 */
public func dsaDoVerify(dgst: Array<UInt8>, sig: DSASIG, pub_key_fn: String, isPrint: Bool): Int32

4.1.3 示例

代码如下：

from crypto4cj import dsacj.*
from std import os.posix.*

main() {  
    var path: String = getcwd()
    var ret: Int32 = 0
    var input_string: Array<UInt8> = [49,50,51,52,53,54,55,56,57,48,49,50,51,52,53,54,55,56,57,48,78,89,90]
    let dsa = dsaNew()
    dsaGenerateParameters(dsa, 1024)
    dsaGenerateKey(dsa)
    pemWriteDsaPara("${path}/dsaParams.pem", dsa, false)
    pemWriteDsaPri("${path}/dsaPri.pem", dsa, true)
    pemWriteDsaPub("${path}/dsaPub.pem", dsa, false)
    var sign_string: SINCALLOC = SINCALLOC(dsa)
    var res: SINSTR = dsaSign(DsaTypeId.NID_sha1, input_string, sign_string, dsa)
    var sinArray: Array<UInt8> = res.getArrayUtf8()
    ret = dsaVerify(DsaTypeId.NID_sha1, input_string, res, dsa)
    if(ret != 1) {
        return -1
    }
    return 0 
}

运行结果如下：

0

4.2 DH

DH算法是W.Diffie和M.Hellman提出的。此算法是最早的公钥算法。它实质是一个通信双方进行密钥协商的协议：两个实体中的任何一个使用自己的私钥和另一实体的公钥，得到一个对称密钥，这一对称密钥其它实体都计算不出来。DH算法的安全性基于有限域上计算离散对数的困难性。离散对数的研究现状表明：所使用的DH密钥至少需要1024位，才能保证有足够的中、长期安全。

支持 dh 共享密钥生成功能

4.2.1 主要接口

enum DHGENERATOR

密钥参数生成安全素数的生成器，通常选择 2 或 5.

public enum DHGENERATOR <: ToString{ 
    | DH_GENERATOR_2		
    | DH_GENERATOR_3		
    | DH_GENERATOR_5		

    /*
     * 获取生成器的值
     * 返回值 Int32 
     */
    public func getNum(): Int32
}

class SHAREMALLOC

给共享密钥分配内存

public class SHAREMALLOC {
    /*
     * 初始化 SHAREMALLOC
     */
    public init(dh: DH)

    /*
     * 获得共享密钥内存
     *
     * 返回值 UInt64 
     */
    public func getShareMalloc(): CString

}

class DH

DH 结构

public class DH {

    /*
     * 初始化
     */
    public init()
}

4.2.2 全局函数

/*
 * 生成 DH 数据结构
 *
 * 返回值 DH 
 */
public func dhNew(): DH

/*
 * 获取 DH 密钥长度的字节数。
 *
 * 参数 dh 
 * 返回值 Int32 - 字节数
 */
public func dhSize(dh: DH): Int32 

/*
 * 生成 DH 密钥参数。
 * 生成的密钥长度为 安全素数长度/8, 小数部分直接进位，如 513 计算的密钥长度为 65
 *
 * 参数 dh 
 * 参数 prime_len - 生成的安全素数的长度,512-10000 间的任意整数
 * 参数 generator - 生成器
 * 返回值 Unit
 */
public func dhGenerateParameters(dh: DH, prime_len: Int32, generator: DHGENERATOR): Unit 

/*
 * 检查 DH 密钥。
 *
 * 参数 dh
 * 返回值 Unit
 */
public func dhCheck(dh: DH): Unit

/*
 * 生成 DH 公私钥。
 *
 * 参数 dh
 * 返回值 Unit
 */
public func dhGenerateKey(dh: DH): Unit

/*
 * 检查公钥。
 *
 * 参数 dh
 * 参数 pub_key
 * 返回值 Unit
 */
public func dhCheckPubKey(dh: DH, pub_key: CPointer<BIGNUM>): Unit 

/*
 * 计算共享密钥，用于数据交换。去除前导零字节。
 *
 * 参数 key - SHAREMALLOC 类型
 * 参数 pub_key - 共享公钥
 * 参数 dh
 * 返回值 Int32 - 生成共享密钥长度，可用于测试生成共享密钥是否成功
 * 返回值 Array<UInt8> - 生成的共享密钥，可用于测试生成共享密钥是否成功
 */
public func dhComputeKey(key: SHAREMALLOC, pub_key: CPointer<BIGNUM>, dh: DH): (Int32, Array<UInt8>)

/*
 * 计算共享密钥，用于数据交换。保留前导零字节。
 *
 * 参数 key - SHAREMALLOC 类型
 * 参数 pub_key - 共享公钥
 * 参数 dh
 * 返回值 Int32 - 生成共享密钥长度，可用于测试生成共享密钥是否成功
 * 返回值 Array<UInt8> - 生成的共享密钥，可用于测试生成共享密钥是否成功
 */
public func dhComputePaddeKey(key: SHAREMALLOC, pub_key: CPointer<BIGNUM>, dh: UInt64): (Int32, Array<UInt8>)

/*
 * 打印 DH 密钥参数。
 *
 * 参数 dh
 * 返回值 Unit
 */
public func dhParamsPrint(x: DH): Unit

/*
 * 获取 DH 密钥参数素数。
 *
 * 参数 dh
 * 返回值 CPointer<BIGNUM>
 */
public func dhGetP(dh: DH): CPointer<BIGNUM>

/*
 * 获取 DH 密钥参数素数。
 *
 * 参数 dh
 * 返回值 CPointer<BIGNUM>
 */
public func dhGetQ(dh: DH): CPointer<BIGNUM>

/*
 * 获取 DH 密钥参数生成器。
 *
 * 参数 dh
 * 返回值 CPointer<BIGNUM>
 */
public func dhGetG(dh: DH): CPointer<BIGNUM>

/*
 * 获取 DH 私钥。
 *
 * 参数 dh
 * 返回值 CPointer<BIGNUM>
 */
public func dhGetPrivKey(dh: DH): CPointer<BIGNUM>

/*
 * 获取 DH 公钥。
 *
 * 参数 dh
 * 返回值 CPointer<BIGNUM>
 */
public func dhGetPubKey(dh: DH): CPointer<BIGNUM>

/*
 * 设置 DH 密钥参数。
 *
 * 参数 dh
 * 参数 p - 密钥参数素数
 * 参数 q - 密钥参数素数
 * 参数 g - 密钥参数生成器
 * 返回值 CPointer<BIGNUM>
 */
public func dnSetPQG(dh: DH, p: CPointer<BIGNUM>, q: CPointer<BIGNUM>, g: CPointer<BIGNUM>): Unit

/*
 * 设置 DH 公私钥。
 *
 * 参数 dh
 * 参数 pubKey - 公钥
 * 参数 privKey - 私钥
 * 返回值 CPointer<BIGNUM>
 */
public func dhSetKey(dh: DH, pubKey: CPointer<BIGNUM>, privKey: CPointer<BIGNUM>): Unit

/*
 * 将密钥参数输出到 pem 文件。
 *
 * 参数 params_fn - 文件路径
 * 参数 x - dh
 * 返回值 CPointer<BIGNUM>
 */
public func pemWriteDHparams(params_fn: String, x: DH): Unit 

/*
 * 从文件读取密钥参数。
 *
 * 参数 params_fn - 文件路径
 * 返回值 DH
 */
public func pemReadDHparams(params_fn: String): DH 

4.2.3 示例

代码如下：

from crypto4cj import dhcj.*
from crypto4cj import bignumcj.*
from encoding import base64.*
main() {  
    let d1: DH = dhNew()
    let d2: DH = dhNew()
    var ret: Int32 = 0
    var size1: Int32 = 0
    var size2: Int32 = 0
    var p: CPointer<BIGNUM> = CPointer<BIGNUM>()
    var g: CPointer<BIGNUM> = CPointer<BIGNUM>()
    var q: CPointer<BIGNUM> = CPointer<BIGNUM>()
    var d1Pub: CPointer<BIGNUM> = CPointer<BIGNUM>()
    var d2Pub: CPointer<BIGNUM> = CPointer<BIGNUM>()
    /* 生成d1 的密钥参数*/
    dhGenerateParameters(d1, 512, DHGENERATOR.DH_GENERATOR_2)
    /* 检查密钥参数 */
    dhCheck(d1)
    /* d1 生成公私钥 */
    dhGenerateKey(d1)
    /* p和g为公开的密钥参数,因此可以拷贝 */
    p = dhGetP(d1)
    g = dhGetG(d1)
    d1Pub = dhGetPubKey(d1)
    /* d1 检查公钥 */
    dhCheckPubKey(d1, d1Pub)
    dnSetPQG(d2, p, q, g)
    /* d2 生成公私钥,用于测试生成共享密钥 */
    dhGenerateKey(d2)
    d2Pub = dhGetPubKey(d2)
    /* 密钥大小 */
    size1 = dhSize(d1)
    size2 = dhSize(d2)
    /* 计算共享密钥 */
    var sharekey1: SHAREMALLOC = SHAREMALLOC(d1)
    var sharekey2: SHAREMALLOC = SHAREMALLOC(d2)
    var (len1, sharekey11) = dhComputeKey(sharekey1, d2Pub, d1)
    var (len2, sharekey22) = dhComputeKey(sharekey2, d1Pub, d2)
    dhParamsPrint(d1)

    var (len3, sharekey33) = dhComputePaddeKey(sharekey1, d2Pub, d1)
    var (len4, sharekey44) = dhComputePaddeKey(sharekey2, d1Pub, d2)

    if(len1 != len2 || sharekey11 != sharekey22) {
       return -1
    }
    return 0 
}

运行结果如下：

0

4.3 ECC

ECC 算法，包括三部分： ECC 算法(crypto/ec)、椭圆曲线数字签名算法 ECDSA (crypto/ecdsa)以及椭圆曲线密钥交换算法 ECDH(crypto/dh)。

支持 ecdsa 签名验证和 ecdh共享密钥生成

4.4.1 主要接口

enum CurvesId

椭圆曲线

public enum CurvesId {
    | NID_secp112r1
    | NID_secp112r2 
    | NID_secp128r1 
    | NID_secp128r2 
    | NID_secp160k1 
    | NID_secp160r1 
    | NID_secp160r2 
    | NID_secp192k1 
    | NID_secp224k1 
    | NID_secp224r1 
    | NID_secp256k1 
    | NID_secp384r1 
    | NID_secp521r1 
    | NID_X9_62_prime192v1 
    | NID_X9_62_prime192v2 
    | NID_X9_62_prime192v3 
    | NID_X9_62_prime239v1 
    | NID_X9_62_prime239v2 
    | NID_X9_62_prime239v3 
    | NID_X9_62_prime256v1 
    | NID_sect113r1 
    | NID_sect113r2 
    | NID_sect131r1 
    | NID_sect131r2 
    | NID_sect163k1 
    | NID_sect163r1 
    | NID_sect163r2 
    | NID_sect193r1 
    | NID_sect193r2 
    | NID_sect233k1 
    | NID_sect233r1 
    | NID_sect239k1 
    | NID_sect283k1 
    | NID_sect283r1 
    | NID_sect409k1 
    | NID_sect409r1 
    | NID_sect571k1 
    | NID_sect571r1 
    | NID_X9_62_c2pnb163v1 
    | NID_X9_62_c2pnb163v2 
    | NID_X9_62_c2pnb163v3 
    | NID_X9_62_c2pnb176v1 
    | NID_X9_62_c2tnb191v1 
    | NID_X9_62_c2tnb191v2 
    | NID_X9_62_c2tnb191v3 
    | NID_X9_62_c2pnb208w1 
    | NID_X9_62_c2tnb239v1 
    | NID_X9_62_c2tnb239v2 
    | NID_X9_62_c2tnb239v3 
    | NID_X9_62_c2pnb272w1 
    | NID_X9_62_c2pnb304w1 
    | NID_X9_62_c2tnb359v1 
    | NID_X9_62_c2pnb368w1 
    | NID_X9_62_c2tnb431r1 
    | NID_wap_wsg_idm_ecid_wtls1 
    | NID_wap_wsg_idm_ecid_wtls3 
    | NID_wap_wsg_idm_ecid_wtls4 
    | NID_wap_wsg_idm_ecid_wtls5 
    | NID_wap_wsg_idm_ecid_wtls6 
    | NID_wap_wsg_idm_ecid_wtls7 
    | NID_wap_wsg_idm_ecid_wtls8 
    | NID_wap_wsg_idm_ecid_wtls9 
    | NID_wap_wsg_idm_ecid_wtls10 
    | NID_wap_wsg_idm_ecid_wtls11 
    | NID_wap_wsg_idm_ecid_wtls12 
    | NID_ipsec3 
    | NID_ipsec4 
    | NID_brainpoolP160r1 
    | NID_brainpoolP160t1 
    | NID_brainpoolP192r1 
    | NID_brainpoolP192t1 
    | NID_brainpoolP224r1 
    | NID_brainpoolP224t1 
    | NID_brainpoolP256r1 
    | NID_brainpoolP256t1 
    | NID_brainpoolP320r1 
    | NID_brainpoolP320t1 
    | NID_brainpoolP384r1 
    | NID_brainpoolP384t1 
    | NID_brainpoolP512r1 
    | NID_brainpoolP512t1 
    | NID_sm2 

    /*
     * 获得椭圆曲线对应 id
     *
     * 返回值 Int32
     */
    public func getNum(): Int32
}

enum EC_KEY

密钥数据结构

public class EC_KEY {
    /*
     * 初始化 EC_KEY
     *
     * 参数 key - EC_KEY 值
     */
    public init(key: UInt64)

    /*
     * Get ECC key 值
     *
     * 返回值 UInt64
     */
    public func getEcKey(): UInt64
}

class EC_POINT

ECC 公钥

public class EC_POINT {

    /*
     * 初始化 EC_POINT
     *
     * 参数 point - EC_POINT 值
     */
    public init(point: UInt64)

    /*
     * 获取 ECC 公钥值
     *
     * 参数 key - EC_POINT 值
     */
    public func getEcPoint(): UInt64
}

class EC_GROUP

ECC 密钥参数

public class EC_GROUP {
    /*
     * 初始化 EC_GROUP
     *
     * 参数 group - EC_GROUP 值
     */
    public init(group: UInt64)

    /*
     * 获取 ECC 密钥参数值
     *
     * 返回值 UInt64
     */
    public func getEcGroup(): UInt64
}

class SIN_MALLOC

为签名值分配内存

public class SIN_MALLOC {

    /*
     * 初始化 SIN_MALLOC
     *
     * 参数 size - SIN_MALLOC 值
     */
    public init(size: Int32)
    
    /*
     * 获取签名值内存
     *
     * 返回值 Array<UInt8>
     */
    public func getSinMalloc(): Array<UInt8>

}

class SINSTR

签名结果

public class SINSTR {

    /*
     * 初始化 SINSTR
     *
     * 参数 s - Signature 值
     * 参数 l - Signature 值 length
     */
    public init(s: Array<UInt8>, l: Int32)

    /*
     * 获取签名值
     *
     * 返回值 Array<UInt8>
     */
    public func getSinStr(): Array<UInt8>

    /*
     * 获取签名值长度
     *
     * 返回值 Int32 - Signature 值 length
     */
    public func getSinLen(): Int32
}

4.4.2 全局函数

/*
 * 创建 ECC 密钥结构
 *
 * 返回值 EC_KEY
 */
public func ecKeyNew(): EC_KEY

/*
 * 创建 ECC 公钥结构
 *
 * 参数 group - 密钥参数结构
 * 返回值 EC_POINT
 */
public func ecPoint(group: EC_GROUP): EC_POINT

/*
 * 创建 ECC 密钥参数结构
 *
 * 返回值 EC_GROUP
 */
public func ecGroup(): EC_GROUP

/*
 * 根据椭圆曲线 id 值创建 EC 密钥参数结构
 *
 * 参数 nid - 椭圆曲线 id
 * 返回值 EC_GROUP - 密钥参数结构
 */
public func ecGroupNewByCurveName(nid: CurvesId): EC_GROUP

/*
 * 设置密钥参数。
 *
 * 参数 key - EC_KEY
 * 参数 group - EC_GROUP
 * 返回值 Unit
 */
public func ecKeySetGroup(key: EC_KEY, group: EC_GROUP): Unit

/*
 * 获取密钥参数。
 *
 * 参数 key - EC_KEY
 * 返回值 EC_GROUP
 */
public func ecKeyGetGroup(key: EC_KEY): EC_GROUP

/*
 * 根据密钥参数生成公私钥。
 *
 * 参数 key - EC_KEY
 * 返回值 Unit
 */
public func ecKeyGenerateKey(key: EC_KEY): Unit

/*
 * 检查密钥。
 *
 * 参数 key - EC_KEY
 * 返回值 Unit
 */
public func ecKeyCheckKey(key: EC_KEY): Unit

/*
 * 返回签名的最大长度。
 *
 * 参数 key - EC_KEY
 * 返回值 Int32
 */
public func ecdsaSize(eckey: EC_KEY): Int32

/*
 * 使用提供的私钥进行签名
 *
 * 参数 dgst - 待签名值
 * 参数 sig - 已分配内存的签名值
 * 参数 eckey - EC_KEY
 * 返回值 SINSTR - 签名值和签名值长度
 */
public func ecdsaSign(dgst: Array<UInt8>, sig: SIN_MALLOC, eckey: EC_KEY): SINSTR

/*
 * 使用指定的公钥验证签名。
 *
 * 参数 dgst - 待签名值
 * 参数 sig - Allocating memory for signatures
 * 参数 eckey - EC_KEY
 * 返回值 Int32 - 1: 成功，其他失败
 */
public func ecdsaVerify(dgst: Array<UInt8>, sig: SINSTR, eckey: EC_KEY): Int32

/*
 * 获取 EC 公钥。
 *
 * 参数 key - EC_KEY
 * 返回值 EC_POINT
 */
public func ecKeyGet0PublicKey(key: EC_KEY): EC_POINT

/*
 * 获取 EC 私钥。
 *
 * 参数 key - EC_KEY
 * 返回值 CPointer<BIGNUM>
 */
public func ecKeyGet0PrivateKey(key: EC_KEY): CPointer<BIGNUM>

/*
 * 获取共享密钥。
 *
 * 参数 outlen - 共享密钥长度
 * 参数 pub_key - EC_POINT
 * 参数 ecdh - EC_POINT
 * 返回值 Int32 - 共享密钥长度
 *         Array<UInt8> - 共享密钥
 */
public func ecdhComputeKey(outlen: Int32, pub_key: EC_POINT, ecdh: EC_KEY): (Int32, Array<UInt8>)

/*
 * 释放 EC_KEY 结构。
 *
 * 参数 key - EC_KEY
 * 返回值 Unit
 */
public func ecKeyFree(key: EC_KEY): Unit

/*
 * 打印 EC 密钥参数。
 *
 * 参数 key - EC_KEY
 * 返回值 Unit
 */
public func ecParamstersPrint(key: EC_KEY): Unit

/*
 * 打印 EC 密钥。
 *
 * 参数 key - EC_KEY
 * 返回值 Unit
 */
public func ecKeyPrint(key: EC_KEY): Unit

/*
 * 将 EC 公钥写入 pem 文件。
 *
 * 参数 pub_key_fn - file path
 * 参数 ecKey - EC_KEY
 * 返回值 Unit
 */
public func pemWriteEcPub(pub_key_fn: String, ecKey: EC_KEY): Unit

/*
 * 将 EC 私钥写入 pem 文件。
 *
 * 参数 pub_key_fn - file path
 * 参数 ecKey - EC_KEY
 * 返回值 Unit
 */
public func pemWriteEcPri(pri_key_fn: String, ecKey: EC_KEY): Unit

/*
 * 将 EC 公密钥参数写入 pem 文件。
 *
 * 参数 pub_key_fn - file path
 * 参数 ecKey - EC_GROUP
 * 返回值 Unit
 */
public func pemWriteEcPara(para_key_fn: String, ecGroup: EC_GROUP): Unit

/*
 * 从文件读取私钥。
 *
 * 参数 pri_key_fn - file path
 * 返回值 EC_KEY
 */
public func pemReadEcPri(pri_key_fn: String): EC_KEY

/*
 * 从文件读取公钥。
 *
 * 参数 pri_key_fn - file path
 * 返回值 EC_KEY
 */
public func pemReadEcPub(pub_key_fn: String): EC_KEY

/*
 * 从文件读取密钥参数。
 *
 * 参数 pri_key_fn - file path
 * 返回值 EC_KEY
 */
public func pemReadEcPara(para_key_fn: String): EC_GROUP

/*
 * 使用椭圆曲线直接创建 EC_KEY
 *
 * 参数 nid - curve id
 * 返回值 EC_KEY
 */
public func ecKeyNewByCurveName(nid: CurvesId): EC_KEY

4.4.3 示例

代码如下：

ec_pri.pem 私钥内容

-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIABuIWCDVlRlwTMWil2jjxAOgr3n0f7trsUQ5GDQ1EtwoAoGCCqBHM9V
AYItoUQDQgAEjQY/9Vs0KoRoRWzFELo+W4ovlSh9xNGDkgM+5FvKmSGg5EsW/DxK
KnkHGORtg3uQzAAjDkRt2/sxLsLy7YrUhQ==
-----END EC PRIVATE KEY-----

ec_pub.pem 公钥内容

-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEjQY/9Vs0KoRoRWzFELo+W4ovlSh9
xNGDkgM+5FvKmSGg5EsW/DxKKnkHGORtg3uQzAAjDkRt2/sxLsLy7YrUhQ==
-----END PUBLIC KEY-----

from crypto4cj import eccj.*
from encoding import hex.*
from std import os.posix.*

main() {  
    var path: String = getcwd() 
    var s: String = "e665c280cf27dacd1f1b6b053cb307f32ee32fd0"
    var dgst: Array<UInt8> = fromHexString(s).getOrThrow()
    var keyPri: EC_KEY = ecKeyNew()
    var ret: Int32 = 0
    // 从文件读取私钥
    keyPri = pemReadEcPri("${path}/ec_pri.pem")
    // 获取ECC 密钥大小字节数
    let buf_len = ecdsaSize(keyPri)
    //分配内存，buffer用来保存签名后的数据
    let sigbuf: SIN_MALLOC = SIN_MALLOC(buf_len)
    //签名
    let sin: SINSTR = ecdsaSign(dgst, sigbuf, keyPri)
    // 从文件读取公钥
    var keyPub: EC_KEY = ecKeyNew()
    keyPub = pemReadEcPub("${path}/ec_pub.pem")
    // 验签
    ret = ecdsaVerify(dgst, sin, keyPub)
    ecKeyFree(keyPri)
    ecKeyFree(keyPub)
    if(ret != 1) {
       return -1
    }
    return 0 
}

运行结果如下：

0

最后呢

很多开发朋友不知道需要学习那些鸿蒙技术？鸿蒙开发岗位需要掌握那些核心技术点？为此鸿蒙的开发学习必须要系统性的进行。

而网上有关鸿蒙的开发资料非常的少，假如你想学好鸿蒙的应用开发与系统底层开发。你可以参考这份资料，少走很多弯路，节省没必要的麻烦。由两位前阿里高级研发工程师联合打造的《鸿蒙NEXT星河版OpenHarmony开发文档》里面内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（Harmony NEXT）技术知识点

如果你是一名Android、Java、前端等等开发人员，想要转入鸿蒙方向发展。可以直接领取这份资料辅助你的学习。下面是鸿蒙开发的学习路线图。

针对鸿蒙成长路线打造的鸿蒙学习文档。话不多说，我们直接看详细鸿蒙（OpenHarmony ）手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门视频，帮助大家在技术的道路上更进一步。

• 《鸿蒙 (OpenHarmony)开发学习视频》
• 《鸿蒙生态应用开发V2.0白皮书》
• 《鸿蒙 (OpenHarmony)开发基础到实战手册》
• OpenHarmony北向、南向开发环境搭建
• 《鸿蒙开发基础》
• 《鸿蒙开发进阶》
• 《鸿蒙开发实战》

总结

鸿蒙—作为国家主力推送的国产操作系统。部分的高校已经取消了安卓课程，从而开设鸿蒙课程；企业纷纷跟进启动了鸿蒙研发。

并且鸿蒙是完全具备无与伦比的机遇和潜力的；预计到年底将有 5,000 款的应用完成原生鸿蒙开发，未来将会支持 50 万款的应用。那么这么多的应用需要开发，也就意味着需要有更多的鸿蒙人才。鸿蒙开发工程师也将会迎来爆发式的增长，学习鸿蒙势在必行！ 自↓↓↓拿