网络对抗期末（二~四）

加密实验室

实验二~四：密钥加密实验室、单向哈希函数实验室、公钥加密和PKI实验室

密钥加密实验室：探索秘密密钥加密及其使用OpenSSL的应用程序。

单向哈希函数实验室：探索使用OpenSSL的单向散列函数及其应用程序。

公钥加密和PKI实验室：使用OpenSSL探索公钥密码学，数字签名，证书和PKI。

1 基础理论

1.1 GmSSL简介

GmSSL是一个开源密码工具包，提供对中国国家密码算法和协议的第一级支持，这些算法和协议已在GM/T系列标准中规定。作为OpenSSL项目的一个分支，GmSSL提供了与OpenSSL的API级兼容，并且保持了所有功能。现有的项目，如Apache Web服务器，可以很容易地通过少量修改和简单的重新构建移植到GmSSL上。自2014年底首次发布以来，GmSSL已被Open Source China选为六个推荐的加密项目之一，也被评为2015年中国Linux软件奖的获胜者。

GmSSL具有以下特点：

1. 支持国家密码算法和协议。GmSSL支持国家密码标准中规定的算法和协议，包括SM2、SM3、SM4等算法，这些算法在中国的应用范围广泛，并得到了政府的大力支持。

2. 与OpenSSL兼容。GmSSL与OpenSSL具有API级别兼容性，这意味着使用GmSSL的开发人员可以在不太改变代码的情况下，将现有的OpenSSL项目移植到GmSSL上。

3. 维护所有功能。GmSSL保持了OpenSSL的所有功能，包括对称加密、非对称加密、哈希、数字签名等方面的支持。

4. 易于使用。GmSSL提供了易于使用的接口和文档，使得开发人员可以快速地学习和使用它。

5. 开源。GmSSL是开源的，任何人都可以查看和修改源代码，从而保证了它的安全性和可靠性。

GmSSL是一个重要的密码学工具包，它提供了对中国国家密码算法和协议的支持，并与OpenSSL兼容，使得开发人员可以快速地移植现有的OpenSSL项目。GmSSL的开源和易用性也使得它成为了广大开发人员的首选加密库之一。

1.2 openssl算法

密钥证书管理：

密钥和证书管理是PKI的一个重要组成部分，OpenSSL为之提供了丰富的功能，支持多种标准。
首先，OpenSSL实现了ASN.1的证书和密钥相关标准，提供了对证书、公钥、私钥、证书请求以及CRL等数据对象的DER、PEM和BASE64的编解码功能。OpenSSL提供了产生各种公开密钥对和对称密钥的方法、函数和应用程序，同时提供了对公钥和私钥的DER编解码功能。并实现了私钥的PKCS#12和PKCS#8的编解码功能。OpenSSL在标准中提供了对私钥的加密保护功能，使得密钥可以安全地进行存储和分发。
在此基础上，OpenSSL实现了对证书的X.509标准编解码、PKCS#12格式的编解码以及PKCS#7的编解码功能。并提供了一种文本数据库，支持证书的管理功能，包括证书密钥产生、请求产生、证书签发、吊销和验证等功能。
事实上，OpenSSL提供的CA应用程序就是一个小型的证书管理中心（CA），实现了证书签发的整个流程和证书管理的大部分机制。
SSL和TLS协议：OpenSSL实现了SSL协议的SSLv2和SSLv3，支持了其中绝大部分算法协议。OpenSSL也实现了TLSv1.0，TLS是SSLv3的标准化版，虽然区别不大，但毕竟有很多细节不尽相同。

虽然已经有众多的软件实现了OpenSSL的功能，但是OpenSSL里面实现的SSL协议能够让我们对SSL协议有一个更加清楚的认识，因为至少存在两点：一是OpenSSL实现的SSL协议是开放源代码的，我们可以追究SSL协议实现的每一个细节；二是OpenSSL实现的SSL协议是纯粹的SSL协议，没有跟其它协议（如HTTP）协议结合在一起，澄清了SSL协议的本来面目。

对称加密：

OpenSSL一共提供了8种对称加密算法，其中7种是分组加密算法，仅有的一种流加密算法是RC4。这7种分组加密算法分别是AES、DES、Blowfish、CAST、IDEA、RC2、RC5，都支持电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）和输出反馈模式（OFB）四种常用的分组密码加密模式。其中，AES使用的加密反馈模式（CFB）和输出反馈模式（OFB）分组长度是128位，其它算法使用的则是64位。事实上，DES算法里面不仅仅是常用的DES算法，还支持三个密钥和两个密钥3DES算法。

非对称加密：

OpenSSL一共实现了4种非对称加密算法，包括DH算法、RSA算法、DSA算法和椭圆曲线算法（EC）。DH算法一般用于密钥交换。RSA算法既可以用于密钥交换，也可以用于数字签名，当然，如果你能够忍受其缓慢的速度，那么也可以用于数据加密。DSA算法则一般只用于数字签名。

信息摘要：

OpenSSL实现了5种信息摘要算法，分别是MD2、MD5、MDC2、SHA（SHA1）和RIPEMD。SHA算法事实上包括了SHA和SHA1两种信息摘要算法。此外，OpenSSL还实现了DSS标准中规定的两种信息摘要算法DSS和DSS1。

1.3 gmssl算法

GmSSL是一个开源密码学工具包，它提供了对中国国家密码算法和协议的支持，包括以下算法：

SM1对称加密算法：SM1是中国国家密码管理局推出的一种对称密码算法，基于特定的置换和S盒运算。
SM2非对称加密算法：SM2是中国自主研发的一种ECC曲线加密算法，具有速度快、安全性高等特点。
SM3哈希算法：SM3是中国自主研发的一种哈希算法，具有安全性高、效率高等特点。
SM4对称加密算法：SM4是中国自主研发的一种分组密码算法，基于特定的S盒和置换运算。
GM/T证书验证算法：中国政府制定的数字证书标准GM/T 0012规定了一种数字证书验证算法。

除了以上算法，GmSSL也支持其他常用的密码学算法和协议，如RSA、DSA、DH、TLS等。可以通过使用GmSSL来保证中国特定的密码标准和协议的安全性。

2 应用程序简介

2.1 应用场景

本实验的应用场景是数字电视条件接收系统中的加密与应用。数字电视条件接收系统（CAS）是指用来控制订户对广播服务或者节目进行接收的系统，通过该系统订户只能收看经过授权的广播服务或者节目。通过在电视台电视系统中对用户进行授权控制及授权管理，CAS系统实现了数据广播系统的有偿服务，这是实现为用户提供个性化服务的关键所在。加密算法是条件接收系统的功能及安全核心，一旦CAS中的算法被破解，整个系统即被破坏。因此，选择优秀的加密算法及合理的算法应用是CAS系统的核心问题。目前主流的CAS一般使用国外的加密算法，如属于对称算法的DES算法、3DES算法，属于非对称算法的RSA算法。而随着我国密码学研究的进步，我国也自主创新研发出一套商用密码，统称国密算法，其算法复杂度、安全性、应用性均已到达甚至超过国外算法。

2.2 系统模型

在CAS系统的标准模型中，整个系统是一套由3条密钥共同组成的加密系统，这3条密钥分别为加扰控制字CW、SK及根密钥PDK，3条密钥层层加密，环环相扣，构建了条件接收系统的安全体系。CAS主要分为两大部分：一是信号加扰部分，它是通过一个随机码发生器所产生的随机码（称为控制字CW）来控制加扰器对信号的加扰；二是加密部分，要使加扰的信号在接收端成功地解扰，接收端也必须要有和加扰端一模一样的控制字来控制解扰器，所以，要将前端的CW传送到接收端，如果直接传送会很容易被黑客截获而使CAS失去作用，为此，要对CW进行加密传送，这种加密是一种多层加密机制，从而增加CW传送的安全性，直接对CW加密的第一层所产生的密文称为授权控制信息ECM，通过复用器与加扰的码流一起传送，ECM还含有时间、节目价格、节目授权控制等信息，因此ECM是面向节目的管理信息。对CW加密的密钥称为工作密钥SK，SK通常又叫月密钥，每月换一次，每换一次SK，系统都要重新对所有用户进行授权。第二层加密是用称为节目密钥PDK对SK进行加密，所产生的密文和从SMS获取的授权指令通过SAS生成的授权信息组成授权管理信息EMM，EMM还含有智能卡号、授权时间、授权等级等用户授权信息。这些信息主要是完成对用户的授权，因此EMM是面向用户的管理信息，EMM对用户在什么时间看、看什么频道进行授权，它也通过复用器与加扰码流一起传送，以上这些组成了CAS最基本的加密系统。

2.3 密码算法使用及过程

在朱泽智等人的方案中，使用了SM4和SM2国密算法，本次实验拟使用SM3、SM4和SM2算法，对朱泽智等人的方案进行改进。

（1）根密钥生成使用

SM2算法生成根密钥对，其中私钥作为PDK置于终端，公钥则置于前端。

（2）SK生成

使用128位的SM4算法密钥。

（3）ECM加解密

前端使用SM4算法及SK作为密钥对CW加密形成ECM，终端同样使用SK作为密钥以SM4算法进行解密。

（4）EMM加解密

前端使用根密钥生成中的公钥对SK进行SM2加密形成EMM，终端使用PDK即私钥进行SM2解密。

由于对称算法效率较高，因此一般用于数据量相对大且对实时性要求较高的实时信道传输中；而非对称算法效率相对较低，但安全性更高，一般用于对数据量较少的信息的保护。因此两种算法一般共同使用，用高效的对称算法进行内容保护在信道中传输，并且信道中同时传送有非对称算法加密过的对称算法的密钥，在终端先用非对称算法对密钥进行解密，然后在用密钥对内容进行对称算法的解密。在CAS系统的场景中，ECM的数据量较大，且发送/接收频率较高，因此使用属于对称算法的SM4算法，而EMM数据量较少，发送/接收频率较低，但对安全性的要求更高，因此使用非对称的SM2算法。

2.4 算法改进

（1）哈希值计算

使用SM3算法，生成CW的HASH值，发给前端。

（2）根密钥生成使用

SM2算法生成根密钥对，其中私钥使用HASH进行加密，并作为PDK置于后端，公钥则置于前端。

（3）SK生成

前端使用128位的SM4算法密钥。

（4）ECM加解密

前端使用SM4算法及SK作为密钥对CW加密形成ECM，后端同样使用SK作为密钥以SM4算法进行解密。

（5）EMM加解密

前端使用根密钥生成中的公钥对SK进行SM2加密形成EMM，后端使用HASH值和私钥PDK进行SM2解密。

（6）校验完整性

后端使用解密出的CW计算64位hash值，进行比对HASH文件进行完整性检验。

3 代码

3.1 算法流程

用户：后端

setup：

cw，cw的HASH值

sm2生成的私钥使用（cw的hash的前64位）加密（sm4）生成pdk

Front：

接收cw，cw的hash，公钥，加密后的私钥

生成sk（sm4的128位密钥）

生成iv：pdk的hash前32位

使用sk和iv加密cw得到ecm（sm4）

公钥加密sk得到emm

emm、ecm、cw的hash发给后端

Rear：

cw的hash和pdk解密emm得到sk

sk和pdk（iv）解密得到cw

计算cw的hash（-d），对比

3.2 代码

setup.sh

#! /bin/bash
cd ./src
./m1
./m2
cd ..
cp ./Rear/PDK.pem ./Front/PDK.pem
echo "Setup FINISHED"

all.sh

#! /bin/sh
sh setup.sh
cd ./Front
sh trans.sh
cd ..
cd ./Rear
sh decrypt.sh
cd ..

src/make_cw.c

/*
 *  Copyright 2014-2022 The GmSSL Project. All Rights Reserved.
 *
 *  Licensed under the Apache License, Version 2.0 (the License); you may
 *  not use this file except in compliance with the License.
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 */


#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <gmssl/mem.h>
#include <gmssl/rand.h>
#include <unistd.h>


static const char *options = "[-hex] [-rdrand] -outlen num [-out file]";

int gmrand(int argc, char **argv)
{
    int ret = 1;
    char *prog = argv[0];
    int hex = 0;
    int rdrand = 0;
    int outlen = 0;
    char *outfile = NULL;
    FILE *outfp = stdout;
    uint8_t buf[2048];

    argc--;
    argv++;

    if (argc < 1) {
        fprintf(stderr, "usage: %s %s\n", prog, options);
        return 1;
    }

    while (argc > 0) {
        if (!strcmp(*argv, "-help")) {
            printf("usage: %s %s\n", prog, options);
            ret = 0;
            goto end;
        } else if (!strcmp(*argv, "-hex")) {
            hex = 1;
        } else if (!strcmp(*argv, "-rdrand")) {
            rdrand = 1;
        } else if (!strcmp(*argv, "-outlen")) {
            if (--argc < 1) goto bad;
            outlen = atoi(*(++argv));
            if (outlen < 1 || outlen > INT_MAX) {
                fprintf(stderr, "%s: invalid outlen\n", prog);
                goto end;
            }
        } else if (!strcmp(*argv, "-out")) {
            if (--argc < 1) goto bad;
            outfile = *(++argv);
            if (!(outfp = fopen(outfile, "wb"))) {
                fprintf(stderr, "%s: open '%s' failure : %s\n", prog, outfile, strerror(errno));
                goto end;
            }
        } else {
            fprintf(stderr, "%s: illegal option '%s'\n", prog, *argv);
            goto end;
bad:
            fprintf(stderr, "%s: '%s' option value missing\n", prog, *argv);
            goto end;
        }

        argc--;
        argv++;
    }

    if (!outlen) {
        fprintf(stderr, "%s: option -outlen missing\n", prog);
        goto end;
    }

    while (outlen > 0) {
        size_t len = outlen < sizeof(buf) ? outlen : sizeof(buf);

        if (rdrand) {
/*
            if (rdrand_bytes(buf, len) != 1) {
                fprintf(stderr, "%s: inner error\n", prog);
                goto end;
            }
*/
        } else {
            if (rand_bytes(buf, len) != 1) {
                fprintf(stderr, "%s: inner error\n", prog);
                goto end;
            }
        }

        if (hex) {
            int i;
            for (i = 0; i < len; i++) {
                fprintf(outfp, "%02X", buf[i]);
            }
        } else {
            if (fwrite(buf, 1, len, outfp) != len) {
                fprintf(stderr, "%s: output failure : %s\n", prog, strerror(errno));
                goto end;
            }
        }
        outlen -= (int)len;
    }
    if (hex) {
        fprintf(outfp, "\n");
    }
    ret = 0;
end:
    gmssl_secure_clear(buf, sizeof(buf));
    if (outfile && outfp) fclose(outfp);
    return ret;
}

int main(){
    char **arg=(char **)malloc(6*sizeof(char*));
    for(int i=0;i<6;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"rand");
    //strcpy(arg[1],"-hex");
    strcpy(arg[1],"-outlen");
    strcpy(arg[2],"6");
    strcpy(arg[3],"-out");
    strcpy(arg[4],"../Front/cw");
    gmrand(5,arg);

    return 0;
}

src/make_sm2_key.c

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <gmssl/mem.h>
#include <gmssl/sm2.h>
#include <gmssl/sm3.h>
#include <gmssl/error.h>


static const char *usage_sm2 = "-pass str [-out pem] [-pubout pem]\n";

static const char *op_sm2 =
"Options\n"
"    -pass pass                  Password to encrypt the private key\n"
"    -out pem                    Output password-encrypted PKCS #8 private key in PEM format\n"
"    -pubout pem                 Output public key in PEM format\n"
"\n";

int sm2keygen(int argc, char **argv)
{
    int ret = 1;
    char *prog = argv[0];
    char *pass = NULL;
    char *outfile = NULL;
    char *puboutfile = NULL;
    FILE *outfp = stdout;
    FILE *puboutfp = stdout;
    SM2_KEY key;

    argc--;
    argv++;

    if (argc < 1) {
        fprintf(stderr, "usage_sm2: %s %s\n", prog, op_sm2);
        return 1;
    }

    while (argc > 0) {
        if (!strcmp(*argv, "-help")) {
            printf("usage_sm2: %s %s\n", prog, usage_sm2);
            printf("%s\n", op_sm2);
            ret = 0;
            goto end;
        } else if (!strcmp(*argv, "-pass")) {
            if (--argc < 1) goto bad;
            pass = *(++argv);
        } else if (!strcmp(*argv, "-out")) {
            if (--argc < 1) goto bad;
            outfile = *(++argv);
            if (!(outfp = fopen(outfile, "wb"))) {
                fprintf(stderr, "%s: open '%s' failure : %s\n", prog, outfile, strerror(errno));
                goto end;
            }
        } else if (!strcmp(*argv, "-pubout")) {
            if (--argc < 1) goto bad;
            puboutfile = *(++argv);
            if (!(puboutfp = fopen(puboutfile, "wb"))) {
                fprintf(stderr, "%s: open '%s' failure : %s\n", prog, outfile, strerror(errno));
                goto end;
            }
        } else {
            fprintf(stderr, "%s: illegal option '%s'\n", prog, *argv);
            goto end;
bad:
            fprintf(stderr, "%s: `%s` option value missing\n", prog, *argv);
            goto end;
        }

        argc--;
        argv++;
    }

    if (!pass) {
        fprintf(stderr, "%s: `-pass` option required\n", prog);
        goto end;
    }

    if (sm2_key_generate(&key) != 1
        || sm2_private_key_info_encrypt_to_pem(&key, pass, outfp) != 1
        || sm2_public_key_info_to_pem(&key, puboutfp) != 1) {
        fprintf(stderr, "%s: inner failure\n", prog);
        goto end;
    }
    ret = 0;

end:
    gmssl_secure_clear(&key, sizeof(key));
    if (outfile && outfp) fclose(outfp);
    if (puboutfile && puboutfp) fclose(puboutfp);
    return ret;
}

static const char *op_sm3 = "[-hex|-bin] [-pubkey pem [-id str]] [-in file] [-out file]";

int sm3(int argc, char **argv)
{
    int ret = 1;
    char *prog = argv[0];
    int bin = 0;
    char *pubkeyfile = NULL;
    char *infile = NULL;
    char *outfile = NULL;
    char *id = NULL;
    FILE *pubkeyfp = NULL;
    FILE *infp = stdin;
    FILE *outfp = stdout;
    SM3_CTX sm3_ctx;
    uint8_t dgst[32];
    uint8_t buf[4096];
    size_t len;
    int i;

    argc--;
    argv++;

    while (argc > 0) {
        if (!strcmp(*argv, "-help")) {
            printf("usage: %s %s\n", prog, op_sm3);
            printf("usage: echo -n \"abc\" | %s\n", prog);
            ret = 0;
            goto end;
        } else if (!strcmp(*argv, "-hex")) {
            if (bin) {
                error_print();
                goto end;
            }
            bin = 0;
        } else if (!strcmp(*argv, "-bin")) {
            bin = 1;
        } else if (!strcmp(*argv, "-pubkey")) {
            if (--argc < 1) goto bad;
            pubkeyfile = *(++argv);
            if (!(pubkeyfp = fopen(pubkeyfile, "rb"))) {
                fprintf(stderr, "%s: open '%s' failure : %s\n", prog, pubkeyfile, strerror(errno));
                goto end;
            }
        } else if (!strcmp(*argv, "-id")) {
            if (--argc < 1) goto bad;
            id = *(++argv);
        } else if (!strcmp(*argv, "-in")) {
            if (--argc < 1) goto bad;
            infile = *(++argv);
            if (!(infp = fopen(infile, "rb"))) {
                fprintf(stderr, "%s: open '%s' failure : %s\n", prog, infile, strerror(errno));
                goto end;
            }
        } else if (!strcmp(*argv, "-out")) {
            if (--argc < 1) goto bad;
            outfile = *(++argv);
            if (!(outfp = fopen(outfile, "wb"))) {
                fprintf(stderr, "%s: open '%s' failure : %s\n", prog, outfile, strerror(errno));
                goto end;
            }
        } else {
            fprintf(stderr, "%s: illegal option '%s'\n", prog, *argv);
            goto end;
bad:
            fprintf(stderr, "%s: '%s' option value missing\n", prog, *argv);
            goto end;
        }

        argc--;
        argv++;
    }

    sm3_init(&sm3_ctx);

    if (pubkeyfile) {
        SM2_KEY sm2_key;
        uint8_t z[32];

        if (sm2_public_key_info_from_pem(&sm2_key, pubkeyfp) != 1) {
            fprintf(stderr, "%s: parse public key failed\n", prog);
            goto end;
        }
        if (!id) {
            id = SM2_DEFAULT_ID;
        }

        sm2_compute_z(z, (SM2_POINT *)&sm2_key, id, strlen(id));
        sm3_update(&sm3_ctx, z, sizeof(z));
    } else {
        if (id) {
            fprintf(stderr, "%s: option '-id' must be with '-pubkey'\n", prog);
            goto end;
        }
    }

    while ((len = fread(buf, 1, sizeof(buf), infp)) > 0) {
        sm3_update(&sm3_ctx, buf, len);
    }
    sm3_finish(&sm3_ctx, dgst);

    if (bin) {
        if (fwrite(dgst, 1, sizeof(dgst), outfp) != sizeof(dgst)) {
            fprintf(stderr, "%s: output failure : %s\n", prog, strerror(errno));
            goto end;
        }
    } else {
        for (i = 0; i < sizeof(dgst); i++) {
            fprintf(outfp, "%02x", dgst[i]);
        }
        fprintf(outfp, "\n");
    }
    ret = 0;
end:
    if (pubkeyfp) fclose(pubkeyfp);
    if (infile && infp) fclose(infp);
    if (outfile && outfp) fclose(outfp);
    return ret;
}

int make_HASH(char *cw,char *HASH){
    char **arg=(char **)malloc(6*sizeof(char*));
    for(int i=0;i<6;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm3");
    strcpy(arg[1],"-hex");
    strcpy(arg[2],"-in");
    strcpy(arg[3],cw);
    strcpy(arg[4],"-out");
    strcpy(arg[5],"../Front/HASH");
    sm3(6, arg);

    FILE *f = fopen("../Front/HASH","r");
    fread(HASH,1,64,f);
    fclose(f);
    HASH[64]='\0';
}

int main()
{
    char *cw="../Front/cw";
    char **arg=(char **)malloc(7*sizeof(char*));
    for(int i=0;i<7;i++) arg[i]=(char*)malloc(65*sizeof(char));

    strcpy(arg[0],"sm2keygen");
    strcpy(arg[1],"-pass");
    make_HASH(cw,arg[2]);
    //printf("%s\n",arg[2]);
    strcpy(arg[3],"-out");
    strcpy(arg[4],"../Rear/PDK.pem");
    strcpy(arg[5],"-pubout");
    strcpy(arg[6],"../Front/PUBK.pem");
    sm2keygen(7,arg);
    return 0;
}

front/trans.sh

#! /bin/bash
cd ./src
./front
echo "Encrypt FINISHED"
cd ..
rm cw
rm PDK.pem
rm PUBK.pem
mv ECM ../Rear/ECM
mv EMM ../Rear/EMM
mv HASH ../Rear/HASH
echo "Transmitted"

front/src/front.c

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <gmssl/mem.h>
#include <gmssl/sm2.h>
#include <gmssl/sm3.h>
#include <gmssl/sm4.h>
#include <gmssl/hex.h>
#include <gmssl/aead.h>
#include <gmssl/error.h>
#include "../tools/sm2encrypt.c"
#include "../tools/rand.c"
#include "../tools/sm4.c"
#include "../tools/sm3.c"

static int iv_len=32;
static int key_len=32;
int make_SK(char *sk){
    char **arg=(char **)malloc(6*sizeof(char*));
    for(int i=0;i<6;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"rand");
    strcpy(arg[1],"-hex");
    strcpy(arg[2],"-outlen");
    strcpy(arg[3],"32");
    strcpy(arg[4],"-out");
    strcpy(arg[5],"sk");
    rand_main(6, arg);

    FILE *f = fopen("sk","r");
    fread(sk,1,key_len,f);
    fclose(f);
    sk[key_len]='\0';
}
int make_IV(char *PDK,char *iv){
    char **arg=(char **)malloc(6*sizeof(char*));
    for(int i=0;i<6;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm3");
    strcpy(arg[1],"-hex");
    strcpy(arg[2],"-in");
    strcpy(arg[3],PDK);
    strcpy(arg[4],"-out");
    strcpy(arg[5],"iv");
    sm3_main(6, arg);

    FILE *f = fopen("iv","r");
    fread(iv,1,iv_len,f);
    fclose(f);
    iv[iv_len]='\0';
    system("rm iv");
}
int encrypt_cw_bysm4(char *ECM,char *cw,char *iv,char *sk){
    char **arg=(char **)malloc(11*sizeof(char*));
    for(int i=0;i<11;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm4");
    strcpy(arg[1],"-gcm");
    strcpy(arg[2],"-encrypt");
    strcpy(arg[3],"-key");
    strcpy(arg[4],sk);
    strcpy(arg[5],"-iv");
    strcpy(arg[6],iv);
    strcpy(arg[7],"-in");
    strcpy(arg[8],cw);
    strcpy(arg[9],"-out");
    strcpy(arg[10],ECM);
    
    sm4_main(11, arg);
}
int encrypt_sk_bysm2(char *EMM,char *PUBK,char *sk){
    char **arg=(char **)malloc(7*sizeof(char*));
    for(int i=0;i<7;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm2encrypt");
    strcpy(arg[1],"-pubkey");
    strcpy(arg[2],PUBK);
    strcpy(arg[3],"-in");
    strcpy(arg[4],"sk");
    strcpy(arg[5],"-out");
    strcpy(arg[6],EMM);
    sm2encrypt_main(7, arg);
    system("rm sk");
}
int main(){
    char *sk;
    sk=(char*)malloc(32*sizeof(char));
    char *iv;
    iv=(char*)malloc(32*sizeof(char));
    char *cw="../cw";
    char *ECM="../ECM";
    char *EMM="../EMM";
    char *PUBK="../PUBK.pem";
    char *PDK="../PDK.pem";
    
    make_SK(sk);
    make_IV(PDK,iv);
    encrypt_cw_bysm4(ECM,cw,iv,sk);
    encrypt_sk_bysm2(EMM,PUBK,sk);

    return 0;
}

rear/decrypt.sh

#! /bin/sh
cd ./src
./rear
echo "Decrypt FINISHED"
cd ..
echo ""
echo "Integrity Verification:"
echo "  HASH:"
od -tx1 HASH
echo "  HASH_d:"
od -tx1 HASH_d
diff -c HASH HASH_d
rm cw
rm PDK.pem
rm HASH
rm HASH_d
rm ECM
rm EMM

rear/src/rear.c

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <gmssl/mem.h>
#include <gmssl/sm2.h>
#include <gmssl/sm3.h>
#include <gmssl/sm4.h>
#include <gmssl/hex.h>
#include <gmssl/aead.h>
#include <gmssl/error.h>
#include "../tools/sm2decrypt.c"
#include "../tools/rand.c"
#include "../tools/sm4.c"
#include "../tools/sm3.c"

static int iv_len=32;
static int key_len=32;
int make_IV(char *PDK,char *iv){
    char **arg=(char **)malloc(6*sizeof(char*));
    for(int i=0;i<6;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm3");
    strcpy(arg[1],"-hex");
    strcpy(arg[2],"-in");
    strcpy(arg[3],PDK);
    strcpy(arg[4],"-out");
    strcpy(arg[5],"iv");
    sm3_main(6, arg);

    FILE *f = fopen("iv","r");
    fread(iv,1,iv_len,f);
    fclose(f);
    iv[iv_len]='\0';
    system("rm iv");
}
int decrypt_cw_bysm4(char *ECM,char *cw,char *iv,char *sk){
    char **arg=(char **)malloc(11*sizeof(char*));
    for(int i=0;i<11;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm4");
    strcpy(arg[1],"-gcm");
    strcpy(arg[2],"-decrypt");
    strcpy(arg[3],"-key");
    strcpy(arg[4],sk);
    strcpy(arg[5],"-iv");
    strcpy(arg[6],iv);
    strcpy(arg[7],"-in");
    strcpy(arg[8],ECM);
    strcpy(arg[9],"-out");
    strcpy(arg[10],cw);
    
    sm4_main(11, arg);
}
int decrypt_sk_bysm2(char *EMM,char *PDK,char *sk,char *pass){
    char **arg=(char **)malloc(9*sizeof(char*));
    for(int i=0;i<9;i++) arg[i]=(char*)malloc(65*sizeof(char));

    strcpy(arg[0],"sm2decrypt");
    strcpy(arg[1],"-key");
    strcpy(arg[2],PDK);
    strcpy(arg[3],"-pass");
    FILE *f = fopen(pass,"r");
    fread(arg[4],1,64,f);
    fclose(f);
    arg[4][64] = '\0';
    strcpy(arg[5],"-in");
    strcpy(arg[6],EMM);
    strcpy(arg[7],"-out");
    strcpy(arg[8],"sk");
    
    sm2decrypt_main(9, arg);
    f = fopen("sk","r");
    fread(sk,1,32,f);
    fclose(f);
    system("rm sk");    
}
void HASH(char *cw){
    char **arg=(char **)malloc(6*sizeof(char*));
    for(int i=0;i<6;i++) arg[i]=(char*)malloc(33*sizeof(char));

    strcpy(arg[0],"sm3");
    strcpy(arg[1],"-hex");
    strcpy(arg[2],"-in");
    strcpy(arg[3],cw);
    strcpy(arg[4],"-out");
    strcpy(arg[5],"../HASH_d");
    sm3_main(6, arg);
}
int main(){
    char *sk;
    sk=(char*)malloc(key_len*sizeof(char));
    char *iv;
    iv=(char*)malloc(iv_len*sizeof(char));
    char *cw="../cw";
    char *ECM="../ECM";
    char *EMM="../EMM";
    char *PDK="../PDK.pem";
    char *pass="../HASH";
    
    make_IV(PDK,iv);
    decrypt_sk_bysm2(EMM,PDK,sk,pass); 
    decrypt_cw_bysm4(ECM,cw,iv,sk);
    HASH(cw);
    return 0;
}

tools文件夹：算法库（sm2、sm3、sm4等）

4 运行

sh all.sh

posted @ 2023-06-14 16:23 20201202史婧怡阅读(66) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

20201202史婧怡