mirror of
https://github.com/guanzhi/GmSSL.git
synced 2026-06-25 14:43:40 +08:00
update sm_standard
This commit is contained in:
[GGSuchao]
477
engines/sm_standard/sm9/sm9_standard_enc.c
Normal file
477
engines/sm_standard/sm9/sm9_standard_enc.c
Normal file
@@ -0,0 +1,477 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
|
||||
#include "sm9_standard.h"
|
||||
#include "sm4_standard.h"
|
||||
#include "miracl.h"
|
||||
#include "mirdef.h"
|
||||
|
||||
|
||||
void SM4_standard_block_encrypt(unsigned char key[], unsigned char * message, int mlen, unsigned char *cipher, int * cipher_len)
|
||||
{
|
||||
unsigned char mess[16];
|
||||
int i, rem = mlen % 16;
|
||||
|
||||
for(i = 0; i < mlen / 16; i++)
|
||||
SM4_encrypt(key, &message[i * 16], &cipher[i * 16]);
|
||||
//encrypt the last block
|
||||
memset(mess, 16 - rem, 16);
|
||||
if(rem)
|
||||
memcpy(mess, &message[i * 16], rem);
|
||||
SM4_encrypt(key, mess, &cipher[i*16]);
|
||||
}
|
||||
|
||||
|
||||
void SM4_standard_block_decrypt(unsigned char key[], unsigned char *cipher, int len, unsigned char *plain, int *plain_len)
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < len / 16; i++)
|
||||
SM4_decrypt(key, cipher + i * 16, plain + i * 16);
|
||||
*plain_len = len - plain[len - 1];
|
||||
}
|
||||
|
||||
|
||||
int SM9_standard_enc_mac(unsigned char *K, int Klen, unsigned char *M, int Mlen, unsigned char C[])
|
||||
{
|
||||
unsigned char *Z = NULL;
|
||||
int len = Klen + Mlen;
|
||||
Z = (char *)malloc(sizeof(char)*(len + 1));
|
||||
if(Z == NULL)
|
||||
return SM9_ASK_MEMORY_ERR;
|
||||
memcpy(Z, M, Mlen);
|
||||
memcpy(Z + Mlen, K, Klen);
|
||||
SM3_256(Z, len, C);
|
||||
|
||||
free(Z);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int SM9_standard_encrypt(unsigned char hid[], unsigned char *IDB, unsigned char *message, int mlen, unsigned char rand[],
|
||||
int EncID, int k1_len, int k2_len, unsigned char Ppub[], unsigned char C[], int *C_len)
|
||||
{
|
||||
big h, x, y, r;
|
||||
zzn12 g, w;
|
||||
epoint *Ppube, *QB, *C1;
|
||||
unsigned char *Z = NULL, *K = NULL, *C2 = NULL, C3[SM3_len / 8];
|
||||
int i = 0, j = 0, Zlen, buf, klen, C2_len;
|
||||
|
||||
//initiate
|
||||
h = mirvar(0);
|
||||
r = mirvar(0);
|
||||
x = mirvar(0);
|
||||
y = mirvar(0);
|
||||
QB = epoint_init();
|
||||
Ppube = epoint_init();
|
||||
C1 = epoint_init();
|
||||
zzn12_init(&g);
|
||||
zzn12_init(&w);
|
||||
|
||||
bytes_to_big(BNLEN, Ppub, x);
|
||||
bytes_to_big(BNLEN, Ppub + BNLEN, y);
|
||||
epoint_set(x, y, 0, Ppube);
|
||||
|
||||
//Step1:calculate QB=[H1(IDB||hid,N)]P1+Ppube
|
||||
Zlen = strlen(IDB) + 1;
|
||||
Z = (char *)malloc(sizeof(char)*(Zlen + 1));
|
||||
if(Z == NULL)
|
||||
return SM9_ASK_MEMORY_ERR;
|
||||
memcpy(Z, IDB, strlen(IDB));
|
||||
memcpy(Z + strlen(IDB), hid, 1);
|
||||
buf = SM9_standard_h1(Z, Zlen, N, h);
|
||||
if(buf)
|
||||
return buf;
|
||||
ecurve_mult(h, P1, QB);
|
||||
ecurve_add(Ppube, QB);
|
||||
|
||||
printf("\n*******************QB:=[H1(IDB||hid,N)]P1+Ppube*****************\n");
|
||||
epoint_get(QB, x, y);
|
||||
cotnum(x, stdout);
|
||||
cotnum(y, stdout);
|
||||
|
||||
//Step2:randnom
|
||||
bytes_to_big(BNLEN, rand, r);
|
||||
printf("\n***********************randnum r:********************************\n");
|
||||
cotnum(r, stdout);
|
||||
|
||||
//Step3:C1=[r]QB
|
||||
ecurve_mult(r, QB, C1);
|
||||
printf("\n*************************:C1=[r]QB*******************************\n");
|
||||
epoint_get(C1, x, y);
|
||||
cotnum(x, stdout);
|
||||
cotnum(y, stdout);
|
||||
big_to_bytes(BNLEN, x, C, 1);
|
||||
big_to_bytes(BNLEN, y, C + BNLEN, 1);
|
||||
|
||||
//Step4:g = e(P2, Ppub-e)
|
||||
if(!ecap(P2, Ppube, para_t, X, &g))
|
||||
return SM9_MY_ECAP_12A_ERR;
|
||||
//test if a ZZn12 element is of order q
|
||||
if(!member(g, para_t, X))
|
||||
return SM9_MEMBER_ERR;
|
||||
printf("\n***********************g=e(P2,Ppube):****************************\n");
|
||||
zzn12_ElementPrint(g);
|
||||
|
||||
//Step5:calculate w=g^r
|
||||
w = zzn12_pow(g, r);
|
||||
printf("\n***************************w=g^r:**********************************\n");
|
||||
zzn12_ElementPrint(w);
|
||||
|
||||
free(Z);
|
||||
//Step6:calculate C2
|
||||
if(EncID == 0)
|
||||
{
|
||||
C2_len = mlen;
|
||||
*C_len = BNLEN * 2 + SM3_len / 8 + C2_len;
|
||||
|
||||
//Step:6-1: calculate K=KDF(C1||w||IDB,klen)
|
||||
klen = mlen + k2_len;
|
||||
Zlen = strlen(IDB) + BNLEN * 14;
|
||||
Z = (char *)malloc(sizeof(char)*(Zlen + 1));
|
||||
K = (char *)malloc(sizeof(char)*(klen + 1));
|
||||
C2 = (char *)malloc(sizeof(char)*(mlen + 1));
|
||||
if(Z == NULL || K == NULL || C2 == NULL)
|
||||
return SM9_ASK_MEMORY_ERR;
|
||||
|
||||
LinkCharZzn12( C, BNLEN * 2, w, Z, (Zlen - strlen(IDB)));
|
||||
memcpy(Z + BNLEN * 14, IDB, strlen(IDB));
|
||||
SM3_kdf(Z, Zlen, klen, K);
|
||||
printf("\n*****************K=KDF(C1||w||IDB,klen):***********************\n");
|
||||
for(i = 0; i < klen; i++)
|
||||
printf("%02x", K[i]);
|
||||
|
||||
//Step:6-2: calculate C2=M^K1,and test if K1==0?
|
||||
for(i = 0; i < mlen; i++)
|
||||
{
|
||||
if(K[i] == 0)
|
||||
j = j + 1;
|
||||
C2[i] = message[i] ^ K[i];
|
||||
}
|
||||
if(j == mlen)
|
||||
return SM9_ERR_K1_ZERO;
|
||||
printf("\n************************* C2=M^K1 :***************************\n");
|
||||
for(i = 0; i < C2_len; i++)
|
||||
printf("%02x", C2[i]);
|
||||
|
||||
//Step7:calculate C3=MAC(K2,C2)
|
||||
SM9_standard_enc_mac(K + mlen, k2_len, C2, mlen, C3);
|
||||
printf("\n********************** C3=MAC(K2,C2):*************************\n");
|
||||
for(i = 0; i < 32; i++)
|
||||
printf("%02x", C3[i]);
|
||||
|
||||
memcpy(C + BNLEN * 2, C3, SM3_len / 8);
|
||||
memcpy(C + BNLEN * 2 + SM3_len / 8, C2, C2_len);
|
||||
free(Z);
|
||||
free(K);
|
||||
free(C2);
|
||||
}
|
||||
else
|
||||
{
|
||||
C2_len = (mlen / 16 + 1) * 16;
|
||||
*C_len = BNLEN * 2 + SM3_len / 8 + C2_len;
|
||||
|
||||
//Step:6-1: calculate K=KDF(C1||w||IDB,klen)
|
||||
klen = k1_len + k2_len;
|
||||
Zlen = strlen(IDB) + BNLEN * 14;
|
||||
Z = (char *)malloc(sizeof(char)*(Zlen + 1));
|
||||
K = (char *)malloc(sizeof(char)*(klen + 1));
|
||||
C2 = (char *)malloc(sizeof(char)*(C2_len + 1));
|
||||
if(Z == NULL || K == NULL || C2 == NULL)
|
||||
return SM9_ASK_MEMORY_ERR;
|
||||
|
||||
LinkCharZzn12(C, BNLEN * 2, w, Z, Zlen - strlen(IDB));
|
||||
memcpy(Z + BNLEN * 14, IDB, strlen(IDB));
|
||||
SM3_kdf(Z, Zlen, klen, K);
|
||||
printf("\n*****************K=KDF(C1||w||IDB,klen):***********************\n");
|
||||
for(i = 0; i < klen; i++)
|
||||
printf("%02x", K[i]);
|
||||
|
||||
//Step:6-2: calculate C2=Enc(K1,M),and also test if K1==0?
|
||||
for(i = 0; i < k1_len; i++)
|
||||
{
|
||||
if(K[i] == 0)
|
||||
j = j + 1;
|
||||
}
|
||||
if(j == k1_len)
|
||||
return SM9_ERR_K1_ZERO;
|
||||
|
||||
SM4_standard_block_encrypt(K, message, mlen, C2, &C2_len);
|
||||
printf("\n*********************** C2=Enc(K1,M) :*************************\n");
|
||||
for(i = 0; i < C2_len; i++)
|
||||
printf("%02x", C2[i]);
|
||||
|
||||
//Step7:calculate C3=MAC(K2,C2)
|
||||
SM9_standard_enc_mac(K + k1_len, k2_len, C2, C2_len, C3);
|
||||
printf("\n********************** C3=MAC(K2,C2):*************************\n");
|
||||
for(i = 0; i < 32; i++)
|
||||
printf("%02x", C3[i]);
|
||||
|
||||
memcpy(C + BNLEN * 2, C3, SM3_len / 8);
|
||||
memcpy(C + BNLEN * 2 + SM3_len / 8, C2, C2_len);
|
||||
free(Z);
|
||||
free(K);
|
||||
free(C2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int SM9_standard_decrypt (unsigned char C[], int C_len, unsigned char deB[], unsigned char *IDB, int EncID,
|
||||
int k1_len, int k2_len, unsigned char M[], int * Mlen)
|
||||
{
|
||||
big x, y;
|
||||
epoint *C1;
|
||||
zzn12 w;
|
||||
ecn2 dEB;
|
||||
int mlen, klen, Zlen, i, number = 0;
|
||||
unsigned char *Z = NULL, *K = NULL, *K1 = NULL, u[SM3_len / 8];
|
||||
|
||||
x = mirvar(0);
|
||||
y = mirvar(0);
|
||||
dEB.x.a = mirvar(0);
|
||||
dEB.x.b = mirvar(0);
|
||||
dEB.y.a = mirvar(0);
|
||||
dEB.y.b = mirvar(0);
|
||||
dEB.z.a = mirvar(0);
|
||||
dEB.z.b = mirvar(0);
|
||||
dEB.marker = MR_EPOINT_INFINITY;
|
||||
C1 = epoint_init();
|
||||
zzn12_init(&w);
|
||||
|
||||
bytes_to_big(BNLEN, C, x);
|
||||
bytes_to_big(BNLEN, C + BNLEN, y);
|
||||
bytes128_to_ecn2(deB, &dEB);
|
||||
|
||||
//Step1:get C1,and test if C1 is on G1
|
||||
epoint_set(x, y, 1, C1);
|
||||
if(Test_Point(C1))
|
||||
return SM9_C1_NOT_VALID_G1;
|
||||
|
||||
//Step2:w = e(C1, deB)
|
||||
if(!ecap(dEB, C1, para_t, X, &w))
|
||||
return SM9_MY_ECAP_12A_ERR;
|
||||
//test if a ZZn12 element is of order q
|
||||
if(!member(w, para_t, X)) return
|
||||
SM9_MEMBER_ERR;
|
||||
printf("\n*********************** w = e(C1, deB):****************************\n");
|
||||
zzn12_ElementPrint(w);
|
||||
|
||||
//Step3:Calculate plaintext
|
||||
mlen = C_len - BNLEN * 2 - SM3_len / 8;
|
||||
if(EncID == 0)
|
||||
{
|
||||
//Step3-1:calculate K=KDF(C1||w||IDB,klen)
|
||||
klen = mlen + k2_len;
|
||||
Zlen = strlen(IDB) + BNLEN * 14;
|
||||
Z = (char *)malloc(sizeof(char)*(Zlen + 1));
|
||||
K = (char *)malloc(sizeof(char)*(klen + 1));
|
||||
if(Z == NULL || K == NULL)
|
||||
return SM9_ASK_MEMORY_ERR;
|
||||
|
||||
LinkCharZzn12(C, BNLEN * 2, w, Z, Zlen - strlen(IDB));
|
||||
memcpy(Z + BNLEN * 14, IDB, strlen(IDB));
|
||||
SM3_kdf(Z, Zlen, klen, K);
|
||||
printf("\n*****************K=KDF(C1||w||IDB,klen):***********************\n");
|
||||
for(i = 0; i < klen; i++)
|
||||
printf("%02x", K[i]);
|
||||
|
||||
//Step:3-2: calculate M=C2^K1,and test if K1==0?
|
||||
for(i = 0; i < mlen; i++)
|
||||
{
|
||||
if(K[i] == 0)
|
||||
number += 1;
|
||||
M[i] = C[i + C_len - mlen] ^ K[i];
|
||||
}
|
||||
if(number == mlen)
|
||||
return SM9_ERR_K1_ZERO;
|
||||
*Mlen = mlen;
|
||||
|
||||
//Step4:calculate u=MAC(K2,C2)
|
||||
SM9_standard_enc_mac(K + mlen, k2_len, &C[C_len - mlen], mlen, u);
|
||||
if(memcmp(u, &C[BNLEN * 2], SM3_len / 8))
|
||||
return SM9_C3_MEMCMP_ERR;
|
||||
|
||||
printf("\n****************************** M:******************************\n");
|
||||
for(i = 0; i < mlen; i++)
|
||||
printf("%02x", M[i]);
|
||||
free(Z);
|
||||
free(K);
|
||||
}
|
||||
else
|
||||
{
|
||||
//Step:3-1: calculate K=KDF(C1||w||IDB,klen)
|
||||
klen = k1_len + k2_len;
|
||||
Zlen = strlen(IDB) + BNLEN * 14;
|
||||
Z = (char *)malloc(sizeof(char)*(Zlen + 1));
|
||||
K = (char *)malloc(sizeof(char)*(klen + 1));
|
||||
K1 = (char *)malloc(sizeof(char)*(k1_len + 1));
|
||||
if(Z == NULL || K == NULL || K1 == NULL)
|
||||
return SM9_ASK_MEMORY_ERR;
|
||||
|
||||
LinkCharZzn12(C, BNLEN * 2, w, Z, Zlen - strlen(IDB));
|
||||
memcpy(Z + BNLEN * 14, IDB, strlen(IDB));
|
||||
SM3_kdf(Z, Zlen, klen, K);
|
||||
printf("\n*****************K=KDF(C1||w||IDB,klen):***********************\n");
|
||||
for(i = 0; i < klen; i++)
|
||||
printf("%02x", K[i]);
|
||||
|
||||
//Step:3-2: calculate M=dec(K1,C2),and test if K1==0?
|
||||
for(i = 0; i < k1_len; i++)
|
||||
{
|
||||
if(K[i] == 0)
|
||||
number += 1;
|
||||
K1[i] = K[i];
|
||||
}
|
||||
if(number == k1_len)
|
||||
return SM9_ERR_K1_ZERO;
|
||||
SM4_standard_block_decrypt(K1, &C[C_len - mlen], mlen, M, Mlen);
|
||||
|
||||
//Step4:calculate u=MAC(K2,C2)
|
||||
SM9_standard_enc_mac(K + k1_len, k2_len, &C[C_len - mlen], mlen, u);
|
||||
if(memcmp(u, &C[BNLEN * 2], SM3_len / 8))
|
||||
return SM9_C3_MEMCMP_ERR;
|
||||
free(Z);
|
||||
free(K);
|
||||
free(K1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int SM9_standard_enc_selfcheck()
|
||||
{
|
||||
//the master private key
|
||||
unsigned char KE[32] = {0x00, 0x01, 0xED, 0xEE, 0x37, 0x78, 0xF4, 0x41, 0xF8, 0xDE, 0xA3, 0xD9, 0xFA, 0x0A, 0xCC, 0x4E,
|
||||
0x07, 0xEE, 0x36, 0xC9, 0x3F, 0x9A, 0x08, 0x61, 0x8A, 0xF4, 0xAD, 0x85, 0xCE, 0xDE, 0x1C, 0x22};
|
||||
unsigned char rand[32] = {0x00, 0x00, 0xAA, 0xC0, 0x54, 0x17, 0x79, 0xC8, 0xFC, 0x45, 0xE3, 0xE2, 0xCB, 0x25, 0xC1, 0x2B,
|
||||
0x5D, 0x25, 0x76, 0xB2, 0x12, 0x9A, 0xE8, 0xBB, 0x5E, 0xE2, 0xCB, 0xE5, 0xEC, 0x9E, 0x78, 0x5C};
|
||||
//standard datas
|
||||
unsigned char std_Ppub[64] = {0x78, 0x7E, 0xD7, 0xB8, 0xA5, 0x1F, 0x3A, 0xB8, 0x4E, 0x0A, 0x66, 0x00, 0x3F, 0x32, 0xDA, 0x5C,
|
||||
0x72, 0x0B, 0x17, 0xEC, 0xA7, 0x13, 0x7D, 0x39, 0xAB, 0xC6, 0x6E, 0x3C, 0x80, 0xA8, 0x92, 0xFF,
|
||||
0x76, 0x9D, 0xE6, 0x17, 0x91, 0xE5, 0xAD, 0xC4, 0xB9, 0xFF, 0x85, 0xA3, 0x13, 0x54, 0x90, 0x0B,
|
||||
0x20, 0x28, 0x71, 0x27, 0x9A, 0x8C, 0x49, 0xDC, 0x3F, 0x22, 0x0F, 0x64, 0x4C, 0x57, 0xA7, 0xB1};
|
||||
unsigned char std_deB[128] = {0x94, 0x73, 0x6A, 0xCD, 0x2C, 0x8C, 0x87, 0x96, 0xCC, 0x47, 0x85, 0xE9, 0x38, 0x30, 0x1A, 0x13,
|
||||
0x9A, 0x05, 0x9D, 0x35, 0x37, 0xB6, 0x41, 0x41, 0x40, 0xB2, 0xD3, 0x1E, 0xEC, 0xF4, 0x16, 0x83,
|
||||
0x11, 0x5B, 0xAE, 0x85, 0xF5, 0xD8, 0xBC, 0x6C, 0x3D, 0xBD, 0x9E, 0x53, 0x42, 0x97, 0x9A, 0xCC,
|
||||
0xCF, 0x3C, 0x2F, 0x4F, 0x28, 0x42, 0x0B, 0x1C, 0xB4, 0xF8, 0xC0, 0xB5, 0x9A, 0x19, 0xB1, 0x58,
|
||||
0x7A, 0xA5, 0xE4, 0x75, 0x70, 0xDA, 0x76, 0x00, 0xCD, 0x76, 0x0A, 0x0C, 0xF7, 0xBE, 0xAF, 0x71,
|
||||
0xC4, 0x47, 0xF3, 0x84, 0x47, 0x53, 0xFE, 0x74, 0xFA, 0x7B, 0xA9, 0x2C, 0xA7, 0xD3, 0xB5, 0x5F,
|
||||
0x27, 0x53, 0x8A, 0x62, 0xE7, 0xF7, 0xBF, 0xB5, 0x1D, 0xCE, 0x08, 0x70, 0x47, 0x96, 0xD9, 0x4C,
|
||||
0x9D, 0x56, 0x73, 0x4F, 0x11, 0x9E, 0xA4, 0x47, 0x32, 0xB5, 0x0E, 0x31, 0xCD, 0xEB, 0x75, 0xC1};
|
||||
unsigned char std_C_stream[116] = {0x24, 0x45, 0x47, 0x11, 0x64, 0x49, 0x06, 0x18, 0xE1, 0xEE, 0x20, 0x52, 0x8F, 0xF1, 0xD5, 0x45,
|
||||
0xB0, 0xF1, 0x4C, 0x8B, 0xCA, 0xA4, 0x45, 0x44, 0xF0, 0x3D, 0xAB, 0x5D, 0xAC, 0x07, 0xD8, 0xFF,
|
||||
0x42, 0xFF, 0xCA, 0x97, 0xD5, 0x7C, 0xDD, 0xC0, 0x5E, 0xA4, 0x05, 0xF2, 0xE5, 0x86, 0xFE, 0xB3,
|
||||
0xA6, 0x93, 0x07, 0x15, 0x53, 0x2B, 0x80, 0x00, 0x75, 0x9F, 0x13, 0x05, 0x9E, 0xD5, 0x9A, 0xC0,
|
||||
0xBA, 0x67, 0x23, 0x87, 0xBC, 0xD6, 0xDE, 0x50, 0x16, 0xA1, 0x58, 0xA5, 0x2B, 0xB2, 0xE7, 0xFC,
|
||||
0x42, 0x91, 0x97, 0xBC, 0xAB, 0x70, 0xB2, 0x5A, 0xFE, 0xE3, 0x7A, 0x2B, 0x9D, 0xB9, 0xF3, 0x67,
|
||||
0x1B, 0x5F, 0x5B, 0x0E, 0x95, 0x14, 0x89, 0x68, 0x2F, 0x3E, 0x64, 0xE1, 0x37, 0x8C, 0xDD, 0x5D,
|
||||
0xA9, 0x51, 0x3B, 0x1C};
|
||||
unsigned char std_C_cipher[128] = {0x24, 0x45, 0x47, 0x11, 0x64, 0x49, 0x06, 0x18, 0xE1, 0xEE, 0x20, 0x52, 0x8F, 0xF1, 0xD5, 0x45,
|
||||
0xB0, 0xF1, 0x4C, 0x8B, 0xCA, 0xA4, 0x45, 0x44, 0xF0, 0x3D, 0xAB, 0x5D, 0xAC, 0x07, 0xD8, 0xFF,
|
||||
0x42, 0xFF, 0xCA, 0x97, 0xD5, 0x7C, 0xDD, 0xC0, 0x5E, 0xA4, 0x05, 0xF2, 0xE5, 0x86, 0xFE, 0xB3,
|
||||
0xA6, 0x93, 0x07, 0x15, 0x53, 0x2B, 0x80, 0x00, 0x75, 0x9F, 0x13, 0x05, 0x9E, 0xD5, 0x9A, 0xC0,
|
||||
0xFD, 0x3C, 0x98, 0xDD, 0x92, 0xC4, 0x4C, 0x68, 0x33, 0x26, 0x75, 0xA3, 0x70, 0xCC, 0xEE, 0xDE,
|
||||
0x31, 0xE0, 0xC5, 0xCD, 0x20, 0x9C, 0x25, 0x76, 0x01, 0x14, 0x9D, 0x12, 0xB3, 0x94, 0xA2, 0xBE,
|
||||
0xE0, 0x5B, 0x6F, 0xAC, 0x6F, 0x11, 0xB9, 0x65, 0x26, 0x8C, 0x99, 0x4F, 0x00, 0xDB, 0xA7, 0xA8,
|
||||
0xBB, 0x00, 0xFD, 0x60, 0x58, 0x35, 0x46, 0xCB, 0xDF, 0x46, 0x49, 0x25, 0x08, 0x63, 0xF1, 0x0A};
|
||||
unsigned char *std_message = "Chinese IBE standard";
|
||||
unsigned char hid[] = {0x03};
|
||||
unsigned char *IDB = "Bob";
|
||||
|
||||
unsigned char Ppub[64], deB[128];
|
||||
unsigned char message[1000], C[1000];
|
||||
int M_len, C_len;//M_len the length of message //C_len the length of C
|
||||
int k1_len = 16, k2_len = 32;
|
||||
int EncID = 0;//0,stream //1 block
|
||||
int tmp, i;
|
||||
big ke;
|
||||
|
||||
tmp = SM9_standard_init();
|
||||
if(tmp != 0)
|
||||
return tmp;
|
||||
|
||||
ke = mirvar(0);
|
||||
bytes_to_big(32, KE, ke);
|
||||
|
||||
printf("\n*********************** SM9 key Generation ***************************\n");
|
||||
tmp = SM9_standard_generateencryptkey(hid, IDB, strlen(IDB), ke, Ppub, deB);
|
||||
if(tmp != 0)
|
||||
return tmp;
|
||||
if(memcmp(Ppub, std_Ppub, 64) != 0)
|
||||
return SM9_GEPUB_ERR;
|
||||
if(memcmp(deB, std_deB, 128) !=0)
|
||||
return SM9_GEPRI_ERR;
|
||||
|
||||
printf("\n*********************** SM9 encrypt algorithm **************************\n");
|
||||
tmp = SM9_standard_encrypt(hid, IDB, std_message, strlen(std_message), rand, EncID, k1_len, k2_len, Ppub, C, &C_len);
|
||||
if(tmp != 0)
|
||||
return tmp;
|
||||
printf("\n******************************Cipher:************************************\n");
|
||||
for(i = 0; i < C_len; i++)
|
||||
printf("%02x", C[i]);
|
||||
if(EncID == 0)
|
||||
tmp = memcmp(C, std_C_stream, C_len);
|
||||
else
|
||||
tmp = memcmp(C, std_C_cipher, C_len);
|
||||
if(tmp)
|
||||
return SM9_ENCRYPT_ERR;
|
||||
|
||||
printf("\n********************** SM9 Decrypt algorithm **************************\n");
|
||||
tmp = SM9_standard_decrypt(std_C_cipher, 128, deB, IDB, 2, k1_len, k2_len, message, &M_len);
|
||||
printf("\n**************************** Message:***********************************\n");
|
||||
for(i = 0; i < M_len; i++)
|
||||
printf("%02x", message[i]);
|
||||
if(tmp != 0)
|
||||
return tmp;
|
||||
if(memcmp(message, std_message, M_len) != 0)
|
||||
return SM9_DECRYPT_ERR;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user