## 前言
平时一般简单的调试可以直接cout，但是不方便使用。
希望封装一个简单易用的接口，可以打印不同的数据，且可以打印出对应的文件，函数名和所在行数。

没有source_location之前想要打印文件，函数名和所在行数等信息。就是使用宏和使用C可变参数宏打印。直到source_location出现，才有C++式的获取文件，函数名和所在行数的方法。


## 代码：
```cpp
#include <cstdio>
#include <cstdarg>
#include <source_location>

using sl = std::source_location;

struct Fmt {
    Fmt(const char* fmt, const sl& location = sl::current()):
        _fmt(fmt), _location(location)
    { }
    const char* _fmt;
    const sl    _location;
};

void debug(Fmt fmt, ...)
{
    constexpr int buf_size      = 8192;
    char          buf[buf_size] = {0};
    int           bufsize       = buf_size;
    int           len           = 0;

    len = snprintf(buf, bufsize, "[ %s:%d %s ]: ", fmt._location.file_name(),
        fmt._location.line(), fmt._location.function_name());

    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf + len, bufsize - len, fmt._fmt, ap);
    va_end(ap);
    printf("%s", buf);
}

int main(int argc, char const* argv[])
{
    debug("abc %s\n", "hello");
    return 0;
}
```
代码简单明了。主要支持格式化输出。

上面的代码输出：
```text
[ main.cpp:35 int main(int, const char**) ]: abc hello
```
上面的实现使用的是C语言风格的格式化输出，可能会因为类型问题出现段错误，考虑使用`C++`模板支持类型安全，如下：

## 另一种实现：
```cpp
// debug2.hpp
#pragma once
#include <iostream>
#include <source_location>
using sl = std::source_location;

template <typename... Ts>
struct info {
    info(const char* fmt, Ts&&... ts, const sl& loc = sl::current())
    {
        printf("[%s:%d %s]:", loc.file_name(), loc.line(), loc.function_name());
        __print(fmt, ts...);
    }
    info(const sl& loc = sl::current())
    {
        printf(
            "[%s:%d %s]\n", loc.file_name(), loc.line(), loc.function_name());
    }

  private:
    void __print(const char* format)
    {
        if(format)
            printf("%s", format);
        std::flush(std::cout);
    }

    template <typename T, typename... Targs>
    void __print(const char* format, T value, Targs... Fargs)
    {
        for(; *format != '\0'; format++) {
            if(*format == '%') {
                std::cout << value;
                __print(format + 1, Fargs...);
                return;
            }
            std::cout << *format;
        }
    }
};

template <typename... Ts>
info(const char*, Ts&&...) -> info<Ts...>;

template <typename... Ts>
info() -> info<Ts...>;

// main.cpp
#include "debug2.hpp"

int main(int argc, char const* argv[])
{
    info();
    info("hello %\n", "world");
    return 0;
}
```
上面的代码输出：
```txt
[main.cpp:6 int main(int, const char**)]
[main.cpp:7 int main(int, const char**)]:hello world
```

基于source_location的调试接口



### 简介

SM4算法是一个分组加密算法。该算法的分组长度为128比特，密钥长度为128比特。加密算法与密钥扩展算法都采用32轮非线性迭代结构。其密文长度等于明文长度。

### 加密一段数据

EVP提供的接口可以在一个函数中根据不同的参数来执行加密或加密计算。其主要接口：

```c
int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                      const unsigned char *key, const unsigned char *iv, int enc);
int EVP_Cipher(EVP_CIPHER_CTX *c, unsigned char *out, const unsigned char *in,
               unsigned int inl);
```

一个简单的例子：

```c
// sm4_str.c
#include <errno.h>
#include <openssl/evp.h>
#include <stdio.h>
#include <string.h>

/**
 * @brief 加密或解密数据
 *
 * @param in 输入数据
 * @param inl 输入数据的长度
 * @param out 输出数据
 * @param do_encrypt 1-加密，0-解密
 * @return void 
 */
void do_crypt(const unsigned char* in, const unsigned int inlen,
             unsigned char* out, int do_encrypt, const unsigned char* key)
{
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    // FIXME:CBC模式需要传入IV
    EVP_CipherInit_ex(ctx, EVP_sm4_cbc(), NULL, key, NULL, do_encrypt);
    EVP_Cipher(ctx, out, in, inlen);
    EVP_CIPHER_CTX_free(ctx);
    return;
}

int main(int argc, char const* argv[])
{
    unsigned char key[] = {0, 1, 2,  3,  4,  5,  6,  7,
                           8, 9, 10, 11, 12, 13, 14, 15};
    const char* str     = "hello world";
    printf("origin data= %s\n", str);

    // encrypt
    unsigned char buf[BUFSIZ] = {0};
    do_crypt((const unsigned char*)str, strlen(str), buf, 1, key);
    printf("after encrypt str(hex)= ");
    for (int i = 0; i < 12; i++) {
        printf("%2X", buf[i]);
    }

    // decrypt
    unsigned char bufout[BUFSIZ] = {0};
    do_crypt(buf, strlen((const char*)buf), bufout, 0, key);
    printf("\nafter decrypt data= %s\n", bufout);
    return 0;
}
```

编译执行：

```bash
$ gcc -g -Wall sm4_str.c -lcrypto -std=c11 -o sm4_str
$ ./sm4_str 
origin data= hello world
after encrypt str(hex)= 8CA754D2A26F6FC638C1953F
after decrypt data= hello world
```

### 对大数据进行加密1

OpenSSL还提供了一组接口用于对不能一次性完成加密的大数据进行加密。

```c
int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                      const unsigned char *key, const unsigned char *iv, int enc);
int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
                     const unsigned char *in, int inl);
int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
```

一个简单的例子：

```c
// sm4_file.c
#include <openssl/evp.h>
#include <stdio.h>

static unsigned char key[] = {0, 1, 2,  3,  4,  5,  6,  7,
                              8, 9, 10, 11, 12, 13, 14, 15};

/**
 * @brief 加密或解密文件中的数据
 * 
 * @param in 输入文件
 * @param out 输出文件
 * @param do_encrypt 1-加密，0-解密
 * @return int 成功返回0，否则返回-1
 */
int do_crypt(FILE* in, FILE* out, int do_encrypt)
{
    unsigned char inbuf[BUFSIZ], outbuf[BUFSIZ + EVP_MAX_BLOCK_LENGTH];
    int outlen;
    size_t inlen;
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    // 指定SM4初始化ctx，FIXME:CBC模式需要传入IV
    EVP_CipherInit_ex(ctx, EVP_sm4_cbc(), NULL, key, NULL, do_encrypt);

    while ((inlen = fread(inbuf, 1, BUFSIZ, in)) > 0) {
        if (!EVP_CipherUpdate(ctx, outbuf, &outlen, inbuf, inlen)) {
            EVP_CIPHER_CTX_free(ctx); return 1;
        }
        fwrite(outbuf, 1, outlen, out);
    }
    if (!EVP_CipherFinal_ex(ctx, outbuf, &outlen)) {
        EVP_CIPHER_CTX_free(ctx); return 1;
    }
    fwrite(outbuf, 1, outlen, out);

    EVP_CIPHER_CTX_free(ctx);
    return 0;
}

int main(int argc, char const* argv[])
{
    if (argc != 2) {
        printf("usage: %s <filename>\n", argv[0]);
        return 1;
    }

    char* encry_file_neme = "/tmp/encry_file";
    char* decry_file_name = "/tmp/decry_file";
    FILE* orig_file  = fopen(argv[1], "r");
    FILE* encry_file = fopen(encry_file_neme, "w");
    
    // encrypt
    do_crypt(orig_file, encry_file, 1);

    fclose(orig_file);
    fclose(encry_file);
    encry_file       = fopen(encry_file_neme, "r");
    FILE* decry_file = fopen(decry_file_name, "w");

    // decrypt
    do_crypt(encry_file, decry_file, 0);
    fclose(encry_file);
    fclose(decry_file);

    printf("sm4 do_encry finish. see encrypt file:%s and decrypt file:%s.\n",
           encry_file_neme, decry_file_name);
    return 0;
}
```

编译执行：

```bash
$ ./sm4_file sm4_file.c 
sm4 do_encry finish. see encrypt file:/tmp/encry_file and decrypt file:/tmp/decry_file.
```

然后就可以在`/tmp/encry_file`和`/tmp/decry_file`查看加密的文件和解密后的文件。

### 对大数据进行加密2

OpenSSL还提供了另一组接口，将加密和解密运算分开。

```c
int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                       const unsigned char *key, const unsigned char *iv);
int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,int *outl,
                      const unsigned char *in, int inl);
int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);

int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
                       const unsigned char *key, const unsigned char *iv);
int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
                      const unsigned char *in, int inl);
int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl);
```

一个简单的例子：

```c
// sm4_file1.c
#include <errno.h>
#include <openssl/evp.h>
#include <stdio.h>
#include <string.h>

#define BUFSIZE 20

/**
 * @brief 对文件内容进行加密
 *
 * @param fp 要对里面的内容进行加密的文件指针
 * @param out 加密后的数据输出
 * @param outlen 加密后的数据长度
 * @param key 秘钥,可以为NULL
 * @return int 函数返回值
 */
int do_encrypt(FILE* fp, unsigned char* out, int* outlen,
               const unsigned char* key)
{
    int tmplen          = 0;
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_EncryptInit_ex(ctx, EVP_sm4_ecb(), NULL, key, NULL);

    unsigned char buf[BUFSIZE] = {0};
    size_t nread               = 0;
    while ((nread = fread(buf, 1, BUFSIZE, fp)) > 0) {
        EVP_EncryptUpdate(ctx, out + tmplen, outlen, buf, nread);
        tmplen += (*outlen);
    }
    EVP_EncryptFinal_ex(ctx, out + tmplen, outlen);
    *outlen += tmplen;
    EVP_CIPHER_CTX_free(ctx);
    return 0;
}

/**
 * @brief 对文件的加密内容进行解密
 *
 * @param fp 文件指针
 * @param out 解密后数据
 * @param outlen 解密后的数据长度
 * @param key 秘钥，可以为NULL
 * @return int 函数返回值
 */
int do_decrypt(FILE* fp, unsigned char* out, int* outlen,
               const unsigned char* key)
{
    int tmplen          = 0;
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    EVP_DecryptInit_ex(ctx, EVP_sm4_ecb(), NULL, key, NULL);

    unsigned char buf[BUFSIZE] = {0};
    size_t nread               = 0;
    while ((nread = fread(buf, 1, BUFSIZE, fp)) > 0) {
        EVP_DecryptUpdate(ctx, out + tmplen, outlen, buf, nread);
        tmplen += (*outlen);
    }
    EVP_DecryptFinal_ex(ctx, out + tmplen, outlen);
    *outlen += tmplen;
    EVP_CIPHER_CTX_free(ctx);
    return 0;
}

int main(int argc, char const* argv[])
{
    unsigned char key[] = {0, 1, 2,  3,  4,  5,  6,  7,
                           8, 9, 10, 11, 12, 13, 14, 15};
    int ret             = 0;
    int outlen          = 0;
    if (argc < 2) {
        printf("usage: %s <file name>\n", argv[0]);
        return 1;
    }
    FILE* fp = fopen(argv[1], "r");
    // encrypt
    unsigned char out[BUFSIZ];
    ret = do_encrypt(fp, out, &outlen, key);
    fclose(fp);
    const char* enc_file = "/tmp/sm4_enc_file.txt";
    const char* dec_file = "/tmp/sm4_dec_file.txt";
    FILE* enc_fp         = fopen(enc_file, "w");
    fwrite(out, 1, outlen, enc_fp);
    fclose(enc_fp);
    printf("encrypt data write in %s\n", enc_file);

    // decrypt
    enc_fp = fopen(enc_file, "r");
    ret    = do_decrypt(fp, out, &outlen, key);
    fclose(enc_fp);

    FILE* dec_fp = fopen(dec_file, "w");
    fwrite(out, 1, outlen, dec_fp);
    fclose(dec_fp);
    printf("decrypt data write in %s\n", dec_file);
    return ret;
}
```

编译运行：

```bash
$ gcc -g -Wall sm4_file1.c -lcrypto -std=c11 -o sm4_file1
$ ./sm4_file1 sm4_file1.c 
encrypt data write in /tmp/sm4_enc_file.txt
decrypt data write in /tmp/sm4_dec_file.txt
```

然后可以在`/tmp/sm4_enc_file.txt`和`/tmp/sm4_dec_file.txt`查看加密和解密的内容。

### 其他

相关代码位于[gitee仓库](https://gitee.com/nongguangxin/information_security.git)，还包括其他SM2，SM3， SM4，数字信封，RSA，MD5，SHA等代码。

国密SM4 OpenSSL EVP接口例子



### 简介

国产SM3是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。SM3算法适用于商用密码应用中的数字签名和验证，是在SHA-256基础上改进实现的一种算法。SM3算法采用Merkle-Damgard结构，消息分组长度为512位，摘要值长度为256位。

EVP是OpenSSL提供的一组高级接口，使用EVP可以通过一致简单的接口调用不同的算法。

### 单次哈希

单次哈希就是只计算一次哈希，适用于数据较短的情况，可以一次完成计算。

OpenSSL提供了接口来直接计算一段数据的哈希值：

```c
int EVP_Digest(const void *data, size_t count, unsigned char *md, unsigned int *size,
               const EVP_MD *type, ENGINE *impl);
```

参数都比较好理解，`data`和`count`为输入数据和数据长度，`md`和`size`分别哈希值和哈希值长度，`type`为使用的哈希算法，`impl`是要使用的计算引擎，一般设为`NULL`使用默认的引擎。

一个简单的例子，计算"hello world"的哈希值：

```c
// sm3.c
#include <openssl/evp.h>
#include <stdio.h>
#include <string.h>

/**
 * @brief 计算一段数据的哈希值
 * 
 * @param str  [in]   数据
 * @param len  [in]   数据长度
 * @param hash [out]  哈希值
 * @param hlen [hlen] 哈希值长度
 * @return 成功返回0
 */
int hash_date(const char* data, const size_t len,
    unsigned char* hash, unsigned int *hlen)
{
    // 创建哈希上下文，可指定不同的算法, 如EVP_md5。
    const EVP_MD* alg = EVP_sm3();
    // const EVP_MD* alg = EVP_md5();
    if(1 != EVP_Digest(data, len, hash, hlen, alg, NULL))
        return 1;
    return 0;
}

int main(int argc, char const* argv[])
{
    char* str = "hello world";
    unsigned char hash[64];
    unsigned int hlen;

    hash_date(str, strlen(str), hash, &hlen);

    printf("hash '%s', return len=%d\nhash=", str, hlen);
    for (int i = 0; i < hlen; i++) {
        printf("%02X", hash[i]);
    }
    printf("\n");

    return 0;
}

```

我们在代码第20行调用`EVP_sm3()`函数来使用SM3算法计算哈希，如果想使用其他的哈希算法，可以调用其他类似的函数，如：`EVP_md5()`, `EVP_sha256()`等。第28行的`EVP_MD_size`用来计算相应哈希算法的哈希值长度，如果不知道一个算法返回的哈希值长度的话可以先用次函数得到。

编译执行：

```bash
$ gcc -Wall sm3.c -lcrypto -std=c11 -o sm3
$ ./sm3
hash 'hello world', return len=32
hash val=44F0061E69FA6FDFC290C494654A05DC0C053DA7E5C52B84EF93A9D67D3FFF88
```

可以使用OpenSSL提供的命令行工具对结果进行验证：

```bash
$ echo -n "hello world" | openssl sm3
(stdin)= 44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88
```


### 多次哈希

有时可能数据较大或其他原因不能将所有的数据放在读入内存，可以多次读取多次计算得到数据的数据值，OpenSSL提供了一组实现这种功能的函数：

```c
int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl);
int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, size_t cnt);
int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s);
```

一个简单的例子：

```c
// sm3_file.c
#include <openssl/evp.h>
#include <stdio.h>
#include <string.h>

// 哈希值长度（字节）
static const unsigned int HASH_RESULT_LEN = 32;
static const size_t BUFSIZE = 8;
/**
 * @brief 计算文件中的数据哈希值
 * 
 * @param fp 文件结构体
 * @param hash_result 文件哈希值
 */
void hash_file(FILE* fp, unsigned char* hash_result)
{
    const EVP_MD* md = EVP_sm3();
    EVP_MD_CTX* ctx  = EVP_MD_CTX_new();

    char buf[BUFSIZE];
    size_t nread = 0;

    EVP_DigestInit_ex(ctx, md, NULL);
    while ((nread = fread(buf, 1, BUFSIZE, fp)) > 0) {
        EVP_DigestUpdate(ctx, buf, nread);
    }
    EVP_DigestFinal_ex(ctx, hash_result, NULL);

    EVP_MD_CTX_free(ctx);
    return;
}

int main(int argc, char const* argv[])
{
    if (argc != 2) {
        printf("usage: %s <file name>\n", argv[0]);
        return 1;
    }
    FILE* fp = fopen(argv[1], "r");
    if (!fp) {
        printf("%s open failed.\n", argv[1]);
        return 1;
    }

    unsigned char hash_result[HASH_RESULT_LEN];
    hash_file(fp, hash_result);
    printf("SM3(%s)= ", argv[1]);
    for (int i = 0; i < HASH_RESULT_LEN; i++) {
        printf("%02x", hash_result[i]);
    }
    printf("\n");

    fclose(fp);
    return 0;
}
```

我们在第8行定义了每次读取8个字节，避免fread函数一次读取完文件的所有数据，达不到多次计算哈希的效果。

编译运行：

```bash
$ gcc -g -Wall sm3_file.c -lcrypto -std=c11 -o sm3_file
$ ./sm3_file sm3_file.c
SM3(sm3_file.c)= 124834c2c678680ef6ead002232f7d5acfb55778446c39719aca8821a68a7fdf
```

和OpenSSL命令行的结果进行对比：

```bash
$ cat sm3_file.c | openssl sm3
(stdin)= 124834c2c678680ef6ead002232f7d5acfb55778446c39719aca8821a68a7fdf
```

### 其他

相关代码位于[gitee仓库](https://gitee.com/nongguangxin/information_security.git)，还包括其他SM2，SM3， SM4，数字信封，RSA，MD5，SHA等代码。

国密SM3 OpenSSL EVP接口例子



### 简介

SM2是一个非对称加密算法。主要用于加解密，数字签名，秘钥协商。私钥长度为256位，公钥是SM2椭圆曲线上的一个点，由`（x, y）`两个分量表示，每个分量长度为256位。由于SM2加解密运算速度较慢，一般不用SM2进行大数据两加解密.

### 代码示例(openssl 1.1.1n)


一个简单的使用例子：

```c
// sm2.c
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/ec.h>
#include <stdio.h>
#include <string.h>

#define PUTLOC printf("ERRLOC: %s:%d\n", __FILE__, __LINE__)

EVP_PKEY* sm2_gen_keypair()
{
    int rc = 0;
    EVP_PKEY* pkey = NULL;
    EVP_PKEY_CTX* pctx = NULL;

    do {
#if OPENSSL_VERSION_MAJOR >= 3
        pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_SM2, NULL);
#else
        pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
#endif
        if(pctx == NULL) break;

        rc = EVP_PKEY_paramgen_init(pctx);
        if(rc != 1 ) break;
        
        rc = EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2);
        if(rc <= 0) break;

        rc = EVP_PKEY_keygen_init(pctx);
        if ( rc != 1 ) break;

        rc = EVP_PKEY_keygen(pctx, &pkey);
        if ( rc != 1 ) break;

#if OPENSSL_VERSION_MAJOR < 3
        rc = EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2);
#endif
    } while(0);

    EVP_PKEY_CTX_free(pctx);
    if(rc == 1)
        return pkey;

    EVP_PKEY_free(pkey);
    return NULL;
}

void sm2_del_keypair(EVP_PKEY* key)
{
    EVP_PKEY_free(key);
}

int sm2_sign(EVP_PKEY* pkey, const char* id, const size_t idlen,
    const unsigned char* msg, const size_t mlen,
    unsigned char* sig, size_t* sig_len)
{
    int rc = 0;
    EVP_MD_CTX* md_ctx = NULL;
    EVP_PKEY_CTX* sctx = NULL;

    do {
        md_ctx = EVP_MD_CTX_new();
        if(NULL == md_ctx) break;

        sctx = EVP_PKEY_CTX_new(pkey, NULL);
        if(NULL == sctx) break;

        if(id && idlen > 0){
            rc = EVP_PKEY_CTX_set1_id(sctx, id, idlen);
            if(rc <= 0) break;
        }
        EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);

        rc = EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey);
        if(rc != 1) break;

        rc = EVP_DigestSignUpdate(md_ctx, msg, mlen);
        if(rc != 1) break;

        rc = EVP_DigestSignFinal(md_ctx, NULL, sig_len);
        if(rc != 1) break;

        rc = EVP_DigestSignFinal(md_ctx, sig, sig_len);
    } while(0);

    if(md_ctx) EVP_MD_CTX_free(md_ctx);
    if(sctx) EVP_PKEY_CTX_free(sctx);
    return (rc == 1 ? 0 : rc);
}

int sm2_verify(EVP_PKEY* pkey, const char* id, const size_t idlen,
    const unsigned char* msg, const size_t mlen,
    unsigned char* sig, size_t sig_len)
{
    int rc = 0;
    EVP_MD_CTX* md_ctx = NULL;
    EVP_PKEY_CTX* sctx = NULL;

    do {
        md_ctx = EVP_MD_CTX_new();
        if(NULL == md_ctx) break;

        sctx = EVP_PKEY_CTX_new(pkey, NULL);
        if(NULL == sctx) break;

        if(id && idlen > 0){
            rc = EVP_PKEY_CTX_set1_id(sctx, id, idlen);
            if(rc <= 0) break;
        }
        EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);

        rc = EVP_DigestVerifyInit(md_ctx, NULL, EVP_sm3(), NULL, pkey);
        if(rc != 1) break;

        rc = EVP_DigestVerifyUpdate(md_ctx, msg, mlen);
        if(rc != 1) break;

        rc = EVP_DigestVerifyFinal(md_ctx, sig, sig_len);
    }while(0);
    
    EVP_PKEY_CTX_free(sctx);
    EVP_MD_CTX_free(md_ctx);
    return (rc == 1 ? 0 : rc);
}

int sm2_encrypt(EVP_PKEY* key, const unsigned char* in,
    size_t inlen, unsigned char* out, size_t* olen)
{
    int rc = 0;
    EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(key, NULL);
    if(NULL == ctx) return -1;

    do {
        rc = EVP_PKEY_encrypt_init(ctx);
        if(rc != 1) break;

        rc = EVP_PKEY_encrypt(ctx, NULL, olen, in, inlen);
        if(rc != 1) break;

        rc = EVP_PKEY_encrypt(ctx, out, olen, in, inlen);
    }while(0);

    EVP_PKEY_CTX_free(ctx);
    return (rc == 1 ? 0 : rc);
}

int sm2_decrypt(EVP_PKEY* key, const unsigned char* in,
    size_t inlen, unsigned char* out, size_t* olen)
{
    int rc = 0;
    EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(key, NULL);
    if(NULL == ctx) return -1;

    do {
        rc = EVP_PKEY_decrypt_init(ctx);
        if(rc != 1) break;

        rc = EVP_PKEY_decrypt(ctx, NULL, olen, in, inlen);
        if(rc != 1) break;
        
        rc = EVP_PKEY_decrypt(ctx, out, olen, in, inlen);
    }while(0);

    EVP_PKEY_CTX_free(ctx);
    return (rc == 1 ? 0 : rc);
}

int sm2_sv_test()
{
    EVP_PKEY* eckey = sm2_gen_keypair();
    if(!eckey){
        printf("SM2 key generate failed.\n");
        return 0;
    }

    const char* id = "1234567887654321";
    const char* msg = "hello world";
    unsigned char sig[128] = {0};
    size_t siglen = 0;

    if(sm2_sign(eckey, id, sizeof(id),
        (unsigned char*)msg, strlen(msg), sig, &siglen)){
        printf("sm2 sign failed.\n");
        goto out;
    }

    printf("sm2 sign passed.\n");
    printf("signaturn(%ld):", siglen);
    for(size_t i = 0; i<16 ;i++)
        printf("%02X", sig[i]);
    printf("\n");

    if(sm2_verify(eckey, id, sizeof(id),
        (unsigned char*)msg, strlen(msg), sig, siglen)){
        printf("sm2 verify failed.\n");
    }else{
        printf("sm2 verify passed.\n");
    }

out:
    sm2_del_keypair(eckey);
    return 0;
}

int sm2_ed_test()
{
    EVP_PKEY* eckey = sm2_gen_keypair();
    if(!eckey){
        printf("SM2 key generate failed.\n");
        return 0;
    }

    const char* msg = "hello world";
    size_t mlen = strlen(msg);

    unsigned char cipher[1024];
    size_t clen;

    unsigned char plain[1024];
    size_t plen;

    if(sm2_encrypt(eckey, (unsigned char*)msg, mlen, cipher, &clen)){
        printf("sm2 encrypt failed.\n");
        goto out;
    }

    if(sm2_decrypt(eckey, cipher, clen, plain, &plen)){
        printf("sm2 decrypt failed.\n");
        goto out;
    }

    printf(" data(%ld):", mlen);
    for(size_t i = 0; i<mlen ;i++)
        printf("%02X", msg[i]);
    printf("\n");

    // printf("cipher(%ld):", clen);
    // for(size_t i = 0; i<clen ;i++)
    //     printf("%02X", cipher[i]);
    // printf("\n");

    printf("plain(%ld):", plen);
    for(size_t i = 0; i<plen ;i++)
        printf("%02X", plain[i]);
    printf("\n");

out:
    sm2_del_keypair(eckey);
    return 0;
}

int main()
{
    return sm2_sv_test() + sm2_ed_test();
}
```

编译运行：

```bash
$ gcc -g -Wall sm2.c -lcrypto -std=c11 -o sm2
$ ./sm2
sm2 sign passed.
signaturn(72):3046022100C54776C5304484F48DBA85
sm2 verify passed.
 data(11):68656C6C6F20776F726C64
plain(11):68656C6C6F20776F726C64
```


### 其他

相关代码位于[gitee仓库](https://gitee.com/nongguangxin/information_security.git)，还包括其他SM2，SM3， SM4，数字信封，RSA，MD5，SHA等代码。

国密SM2 OpenSSL EVP接口例子

## 示例程序

```cpp
class TestClass {
private:
    int a;
    int b;
public:
    TestClass(){};
    virtual ~TestClass(){};
};

int main(int argc, char const *argv[]) { 
    TestClass t; // clang查看内存布局要求，其他需删除
    sizeof(TestClass); // clang查看虚函数表要求，其他需删除。
    return 0;
}
```

## MSVC

查看命令：
```bash
cl -d1 reportSingleClassLayoutTestClass ./class_layout.cpp
```

我电脑上的输出：
```txt
用于 x86 的 Microsoft (R) C/C++ 优化编译器 19.34.31935 版
版权所有(C) Microsoft Corporation。保留所有权利。

class_layout.cpp

class TestClass size(12):
        +---
 0      | {vfptr}
 4      | a
 8      | b
        +---

TestClass::$vftable@:
        | &TestClass_meta
        |  0
 0      | &TestClass::{dtor} 

TestClass::{dtor} this adjustor: 0
TestClass::__delDtor this adjustor: 0
TestClass::__vecDelDtor this adjustor: 0
Microsoft (R) Incremental Linker Version 14.34.31935.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:class_layout.exe
class_layout.obj
```

## GCC

查看命令：
```bash
g++ -fdump-lang-class ./class_layout.cpp
```
我环境上的结果：
```txt
Vtable for TestClass
TestClass::_ZTV9TestClass: 4 entries
0     (int (*)(...))0
8     (int (*)(...))(& _ZTI9TestClass)
16    (int (*)(...))TestClass::~TestClass
24    (int (*)(...))TestClass::~TestClass

Class TestClass
   size=16 align=8
   base size=16 base align=8
TestClass (0x0x7f5a03004420) 0
    vptr=((& TestClass::_ZTV9TestClass) + 16)

```

## clang

### 查看布局
```bash
clang++ -Xclang -fdump-record-layouts ./class_layout.cpp
```
我环境上的输出：
```txt
*** Dumping AST Record Layout
         0 | class TestClass
         0 |   (TestClass vtable pointer)
         8 |   int a
        12 |   int b
           | [sizeof=16, dsize=16, align=8,
           |  nvsize=16, nvalign=8]
```
### 查看虚函数表

查看命令：
```bash
clang++ -Xclang -fdump-vtable-layouts ./class_layout.cpp
```

我环境上的输出：
```txt
Vtable for 'TestClass' (4 entries).
   0 | offset_to_top (0)
   1 | TestClass RTTI
       -- (TestClass, 0) vtable address --
   2 | TestClass::~TestClass() [complete]
   3 | TestClass::~TestClass() [deleting]

VTable indices for 'TestClass' (2 entries).
   0 | TestClass::~TestClass() [complete]
   1 | TestClass::~TestClass() [deleting]
```

## GDB
用另一个示例：
```cpp
class Driver {
public:
    virtual void print(){};
    virtual ~Driver() = default;
};

class TestClass: public Driver {
private:
    int a;
    int b;
public:
    TestClass(){};
    virtual ~TestClass(){};
};

int main(int argc, char const *argv[]) {
    TestClass t;
    return 0;
}
```
我环境上的输出(省略部分无关输出)：
```txt
# g++ class_layout.cpp -g
# gdb ./a.out 
(gdb) b class_layout.cpp:18
Breakpoint 1 at 0x1198: file main.cpp, line 18.
(gdb) r
Breakpoint 1, main (argc=1, argv=0x7fffffffdef8) at main.cpp:19
19          return 0;
(gdb) set print object on
(gdb) set print pretty on
(gdb) p t
$1 = (TestClass) {
  <Driver> = {
    _vptr.Driver = 0x555555557d48 <vtable for TestClass+16>
  }, 
  members of TestClass:
  a = 0,
  b = 0
}
(gdb) info vtbl t
vtable for 'TestClass' @ 0x555555557d48 (subobject @ 0x7fffffffddb0):
[0]: 0x5555555551c6 <Driver::print()>
(gdb) 
```