# harmony_crypto

**Repository Path**: somesky/harmony_crypto

## Basic Information

- **Project Name**: harmony_crypto
- **Description**: 鸿蒙加解密相关API实例
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-04-08
- **Last Updated**: 2025-08-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# @letter/crypto

## 简介

鸿蒙加解密相关API示例
包含国际算法和国密算法的生成密钥，数据加解密，消息摘要计算，数字签名和验证，生成随机数等接口实现，用户可以更便捷的使用加解密相关接口。

## 功能模块

### 1.GenerateKey  生成密钥类

* 用于生成密钥对象的类，支持对称和非对称密钥算法，支持自定义密钥数据传入，生成指定算法类型的密钥对象。

| 方法                       | 说明                                     |
|:-------------------------|:---------------------------------------|
| generateSymKeySync       | 根据指定对称密钥算法，可选输入密钥数据，生成对称密钥对象           |
| generateAsyKeySync       | 根据指定非对称密钥算法，可选输入公钥/私钥数据，生成非对称密钥对象      |
| generateKeyAgreementSync | 根据指定非对称密钥算法，输入不同密钥对象的公钥和私钥数据，生成协商密钥    |
| generateSm9KeySync       | 根据指定SM9算法，生成SM9签名主密钥，签名密钥，加解密主密钥，加解密密钥 |

* 简单调用示例

*     //生成对称密钥
      let algo: CryptoAlgo.SymKeyAlgo = CryptoAlgo.SymKeyAlgo.SM4_128;
      let symKey: cryptoFramework.SymKey = GenerateKey.generateSymKeySync(algo)

      let hexKey: string = buffer.from(symKey.getEncoded().data).toString('hex');
      symKey = GenerateKey.generateSymKeySync(algo, hexKey);

*     //生成非对称密钥
      let algo: CryptoAlgo.AsyKeyAlgo = CryptoAlgo.AsyKeyAlgo.SM2_256;
      let keyPair: cryptoFramework.KeyPair = GenerateKey.generateAsyKeySync(algo);

      let hexPubKey: string = buffer.from(keyPair.pubKey.getEncoded().data).toString('hex');
      let hexPriKey: string = buffer.from(keyPair.priKey.getEncoded().data).toString('hex');
      keyPair = GenerateKey.generateAsyKeySync(algo, hexPubKey, hexPriKey)

*     //生成协商密钥
      let algo: CryptoAlgo.AsyKeyAlgo = CryptoAlgo.AsyKeyAlgo.ECC_BrainPoolP224r1;
      let keyA = GenerateKey.generateAsyKeySync(algo);
      let keyB = GenerateKey.generateAsyKeySync(algo);
      let A = GenerateKey.generateKeyAgreementSync(algo, keyA.pubKey, keyB.priKey);
      let B = GenerateKey.generateKeyAgreementSync(algo, keyB.pubKey, keyA.priKey);

*     //生成SM9密钥
      let userId = buffer.from("letter").toString('hex');
      let signMasterKey: cryptoFramework.KeyPair = GenerateKey.generateSm9KeySync(CryptoAlgo.AsyKeyAlgo.SM9_SIGN_MASTER);
      let signKey: cryptoFramework.KeyPair = GenerateKey.generateSm9KeySync(CryptoAlgo.AsyKeyAlgo.SM9_SIGN, signMasterKey.priKey, userId);

### 2.Cipher  数据加密解密类

* 根据密钥对象，对数据进行加密/解密操作。

| 方法                  | 说明           |
|:--------------------|:-------------|
| symKeyEcbCipherSync | 对称密钥ECB模式加解密 |
| symKeyCbcCipherSync | 对称密钥CBC模式加解密 |
| asyKeyCipherSync    | 非对称密钥加解密     |
| sm2CipherTextSpec   | SM2密文格式转换    |
| zucCipherSync       | 祖冲之算法加解密     |
| sm9CipherSync       | SM9加解密       |

* 简单调用示例
*     let plain: string = "123456789"
      let hexPlain: string = buffer.from(plain).toString("hex"); 

*     //对称密钥加密/解密
      let symKey: cryptoFramework.SymKey = generateSymKey(CryptoAlgo.SymKeyAlgo.SM4_128);
      let mode: cryptoFramework.CryptoMode = cryptoFramework.CryptoMode.ENCRYPT_MODE;
      let hexEncData: string = Cipher.symKeyEcbCipherSync(symKey, mode, hexPlain);
      mode = cryptoFramework.CryptoMode.DECRYPT_MODE;
      hexPlain = Cipher.symKeyEcbCipherSync(symKey, mode, hexEncData);

*     //非对称密钥加密/解密
      let keypair: cryptoFramework.KeyPair = generateAsyKey(CryptoAlgo.AsyKeyAlgo.SM2_256);
      let hexEncData: string = Cipher.asyKeyCipherSync(keypair.pubKey, hexPlain);
      hexEncData = Cipher.sm2CipherTextSpec(hexEncData, 0x01, 0x11);
      hexEncData = Cipher.sm2CipherTextSpec(hexEncData, 0x11, 0x01);
      hexPlain = Cipher.asyKeyCipherSync(keypair.priKey, hexEncData);

*     //祖冲之加解密
      let key: string = Random.getNumberRandomSync(16);
      let hexKey = buffer.from(key).toString("hex");
      hexEncData = Cipher.zucCipherSync(hexKey, hexIv16, hexPlain);
      hexPlain = Cipher.zucCipherSync(hexKey, hexIv16, hexEncData);

*     //SM9加解密
      let userId = buffer.from("letter").toString('hex');
      let encMasterKey: cryptoFramework.KeyPair = GenerateKey.generateSm9KeySync(CryptoAlgo.AsyKeyAlgo.SM9_ENC_MASTER);
      let encKey: cryptoFramework.KeyPair = GenerateKey.generateSm9KeySync(CryptoAlgo.AsyKeyAlgo.SM9_ENC, encMasterKey.priKey, userId);
      hexEncData: string = Cipher.sm9CipherSync(encMasterKey.pubKey, userId, hexPlain);
      hexPlain = Cipher.sm9CipherSync(encKey.priKey, userId, hexEncData);

### 3.MessageDigest  消息摘要计算类

* 根据密钥对象，对数据进行加密/解密操作。

| 方法            | 说明         |
|:--------------|:-----------|
| doMdSync      | 消息摘要计算     |
| doHmacSync    | 消息认证码计算    |
| calculateSM2Z | 国密SM2的Z值计算 |

* 简单调用示例
*     //消息摘要计算
      let plain: string = "123456789"
      let hexPlain: string = buffer.from(plain).toString("hex"); 
      let hexHashData: string = MessageDigest.doMdSync(CryptoAlgo.HashAlgo.SM3, hexPlain);

*     //国密SM2的Z值计算
      let keypair = GenerateKey.generateAsyKeySync(CryptoAlgo.AsyKeyAlgo.SM2_256);
      let zValue: string = MessageDigest.calculateSM2Z(keypair.pubKey);

### 4.Signature  数字签名验签类

* 根据密钥对象和哈希算法，对数据进行签名/验签操作。

| 方法            | 说明                  |
|:--------------|:--------------------|
| signSync      | 非对称密钥签名             |
| verifySync    | 非对称密钥验签             |
| rsaVerifySync | RSA密钥验签，支持不传入HASH类型 |
| sm9SignSync   | sm9密钥签名             |
| sm9VerifySync | sm9密钥验签             |

* 简单调用示例
*     //数字签名验签
      let plain: string = "123456789"
      let hexPlain: string = buffer.from(plain).toString("hex"); 

      let keypair = GenerateKey.generateAsyKeySync(CryptoAlgo.AsyKeyAlgo.RSA2048_PRIMES_2);
      let base64SignData: string = Signature.signSync(keypair.priKey, CryptoAlgo.HashAlgo.SHA256, hexPlain);
      let verify: boolean = Signature.rsaVerifySync(keypair.pubKey, hexPlain, base64SignData);

      keypair = GenerateKey.generateAsyKeySync(CryptoAlgo.AsyKeyAlgo.SM2_256);
      base64SignData = Signature.signSync(keypair.priKey, CryptoAlgo.HashAlgo.SM3, hexPlain);
      verify = Signature.verifySync(keypair.pubKey, CryptoAlgo.HashAlgo.SM3, hexPlain, base64SignData);

      let userId = buffer.from("letter").toString('hex');
      let signMasterKey: cryptoFramework.KeyPair = GenerateKey.generateSm9KeySync(CryptoAlgo.AsyKeyAlgo.SM9_SIGN_MASTER);
      let signKey: cryptoFramework.KeyPair = GenerateKey.generateSm9KeySync(CryptoAlgo.AsyKeyAlgo.SM9_SIGN, signMasterKey.priKey, userId);
      let sig: string = Signature.sm9SignSync(signKey.priKey, hexPlain);
      verify = Signature.sm9VerifySync(signMasterKey.pubKey, hexPlain, sig, userId);

### 5.Random  生成随机数类

* 根据指定长度，获取随机数。

| 方法                  | 说明               |
|:--------------------|:-----------------|
| getNumberRandomSync | 获取数字随机数          |
| getRandomSync       | 获取随机数            |
| getNumeralsSync     | 获取数字键盘数据随机排列的字符串 |
| getAlphabetsSync    | 获取字母键盘字母随机排列的字符串 |

* 简单调用示例
*     //生成随机数
      let rand: string = Random.getNumberRandomSync(12);
      let randBuffer: Uint8Array = Random.getRandomSync(8);
     
      //密码键盘随机
      rand = Random.getNumeralsSync(true);
      rand = Random.getAlphabetsSync(true);

## 使用说明

* ohpm i @letter/crypto

*     在项目oh-package.json中，会添加此依赖：
      "dependencies": {
      "@letter/crypto": "^1.1.1"
      },

具体方法类导入使用：

*     import { GenerateKey, Cipher, MessageDigest, Signature, Random, CryptoAlgo } from "@letter/crypto"

## 仓库地址

https://gitee.com/somesky/harmony_crypto