mirror of
https://github.com/guanzhi/GmSSL.git
synced 2026-06-21 12:44:15 +08:00
263 lines
7.8 KiB
C
Executable File
263 lines
7.8 KiB
C
Executable File
/*
|
|
* 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 <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <limits.h>
|
|
#include <gmssl/error.h>
|
|
#include "sdf_int.h"
|
|
#include "sdf_sansec.h"
|
|
|
|
|
|
#define SDFerr(a,b)
|
|
|
|
|
|
typedef struct {
|
|
ULONG id;
|
|
char *name;
|
|
} table_item_t;
|
|
|
|
static table_item_t sdf_cipher_caps[] = {
|
|
{ SGD_SM1_ECB, "sm1-ecb" },
|
|
{ SGD_SM1_CBC, "sm1-cbc" },
|
|
{ SGD_SM1_CFB, "sm1-cfb" },
|
|
{ SGD_SM1_OFB, "sm1-ofb128" },
|
|
{ SGD_SM1_MAC, "cbcmac-sm1" },
|
|
{ SGD_SSF33_ECB, "ssf33-ecb" },
|
|
{ SGD_SSF33_CBC, "ssf33-cbc" },
|
|
{ SGD_SSF33_CFB, "ssf33-cfb" },
|
|
{ SGD_SSF33_OFB, "ssf33-ofb128" },
|
|
{ SGD_SSF33_MAC, "cbcmac-ssf33" },
|
|
{ SGD_SM4_ECB, "sms4-ecb" },
|
|
{ SGD_SM4_CBC, "sms4-cbc" },
|
|
{ SGD_SM4_CFB, "sms4-cfb" },
|
|
{ SGD_SM4_OFB, "sms4-ofb128" },
|
|
{ SGD_SM4_MAC, "cbcmac-sms4" },
|
|
{ SGD_ZUC_EEA3, "zuc_128eea3" },
|
|
{ SGD_ZUC_EIA3, "zuc_128eia3" }
|
|
};
|
|
|
|
static table_item_t sdf_digest_caps[] = {
|
|
{ SGD_SM3, "sm3" },
|
|
{ SGD_SHA1, "sha1" },
|
|
{ SGD_SHA256, "sha256" },
|
|
};
|
|
|
|
static table_item_t sdf_pkey_caps[] = {
|
|
{ SGD_RSA_SIGN, "rsa" },
|
|
{ SGD_RSA_ENC, "rsaEncryption" },
|
|
{ SGD_SM2_1, "sm2sign" },
|
|
{ SGD_SM2_2, "sm2exchange" },
|
|
{ SGD_SM2_3, "sm2encrypt" }
|
|
};
|
|
|
|
int SDF_PrintDeviceInfo(FILE *fp, const DEVICEINFO *pstDeviceInfo)
|
|
{
|
|
size_t i, n;
|
|
DEVICEINFO buf;
|
|
DEVICEINFO *devInfo = &buf;
|
|
int fmt = 0, ind = 4;
|
|
|
|
memcpy(devInfo, pstDeviceInfo, sizeof(DEVICEINFO));
|
|
devInfo->IssuerName[39] = 0;
|
|
devInfo->DeviceName[15] = 0;
|
|
devInfo->DeviceSerial[15] = 0;
|
|
|
|
format_print(fp, fmt, ind, "%-18s: %s\n", "Device Name", devInfo->DeviceName);
|
|
format_print(fp, fmt, ind, "%-18s: %s\n", "Serial Number", devInfo->DeviceSerial);
|
|
format_print(fp, fmt, ind, "%-18s: %s\n", "Issuer", devInfo->IssuerName);
|
|
format_print(fp, fmt, ind, "%-18s: %u\n", "Hardware Version", devInfo->DeviceVersion);
|
|
format_print(fp, fmt, ind, "%-18s: %u\n", "Standard Version", devInfo->StandardVersion);
|
|
format_print(fp, fmt, ind, "%-18s: ", "Public Key Algors");
|
|
for (i = n = 0; i < sizeof(sdf_pkey_caps)/sizeof(sdf_pkey_caps[0]); i++) {
|
|
if ((devInfo->AsymAlgAbility[0] & sdf_pkey_caps[i].id) ==
|
|
sdf_pkey_caps[i].id) {
|
|
format_print(fp, fmt, 0, "%s%s", n ? "," : "", sdf_pkey_caps[i].name);
|
|
n++;
|
|
}
|
|
}
|
|
format_print(fp, fmt, 0, "\n");
|
|
|
|
format_print(fp, fmt, ind, "%-18s: ", "Ciphers");
|
|
for (i = n = 0; i < sizeof(sdf_cipher_caps)/sizeof(sdf_cipher_caps[0]); i++) {
|
|
if ((devInfo->SymAlgAbility & sdf_cipher_caps[i].id) ==
|
|
sdf_cipher_caps[i].id) {
|
|
format_print(fp, fmt, 0, "%s%s", n ? "," : "", sdf_cipher_caps[i].name);
|
|
n++;
|
|
}
|
|
}
|
|
format_print(fp, fmt, 0, "\n");
|
|
|
|
format_print(fp, fmt, ind, "%-18s: ", "Digests");
|
|
for (i = n = 0; i < sizeof(sdf_digest_caps)/sizeof(sdf_digest_caps[0]); i++) {
|
|
if ((devInfo->HashAlgAbility & sdf_digest_caps[i].id) ==
|
|
sdf_digest_caps[i].id) {
|
|
format_print(fp, fmt, 0, "%s%s", n ? "," : "", sdf_digest_caps[i].name);
|
|
n++;
|
|
}
|
|
}
|
|
format_print(fp, fmt, 0, "\n");
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_PrintRSAPublicKey(FILE *fp, const RSArefPublicKey *blob)
|
|
{
|
|
int fmt = 0, ind = 4;
|
|
(void)format_print(fp, fmt, ind, "bits: %d\n", blob->bits);
|
|
(void)format_bytes(fp, fmt, ind, "m", blob->m, sizeof(blob->m));
|
|
(void)format_bytes(fp, fmt, ind, "e", blob->e, sizeof(blob->e));
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_PrintRSAPrivateKey(FILE *fp, const RSArefPrivateKey *blob)
|
|
{
|
|
int fmt = 0, ind = 4;
|
|
(void)format_print(fp, fmt, ind, "bits: %d", blob->bits);
|
|
(void)format_bytes(fp, fmt, ind, "m", blob->m, sizeof(blob->m));
|
|
(void)format_bytes(fp, fmt, ind, "e", blob->e, sizeof(blob->e));
|
|
(void)format_bytes(fp, fmt, ind, "d", blob->d, sizeof(blob->d));
|
|
(void)format_bytes(fp, fmt, ind, "prime[0]", blob->prime[0], sizeof(blob->prime[0]));
|
|
(void)format_bytes(fp, fmt, ind, "prime[1]", blob->prime[1], sizeof(blob->prime[1]));
|
|
(void)format_bytes(fp, fmt, ind, "pexp[0]", blob->pexp[0], sizeof(blob->pexp[0]));
|
|
(void)format_bytes(fp, fmt, ind, "pexp[1]", blob->pexp[1], sizeof(blob->pexp[1]));
|
|
(void)format_bytes(fp, fmt, ind, "coef", blob->coef, sizeof(blob->coef));
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_PrintECCPublicKey(FILE *fp, const ECCrefPublicKey *blob)
|
|
{
|
|
int fmt = 0, ind = 4;
|
|
(void)format_print(fp, fmt, ind, "bits: %d", blob->bits);
|
|
(void)format_bytes(fp, fmt, ind, "x", blob->x, sizeof(blob->x));
|
|
(void)format_bytes(fp, fmt, ind, "y", blob->y, sizeof(blob->y));
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_PrintECCPrivateKey(FILE *fp, const ECCrefPrivateKey *blob)
|
|
{
|
|
int fmt = 0, ind = 4;
|
|
(void)format_print(fp, fmt, ind, "bits: %d", blob->bits);
|
|
(void)format_bytes(fp, fmt, ind, "K", blob->K, sizeof(blob->K));
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_PrintECCCipher(FILE *fp, const ECCCipher *blob)
|
|
{
|
|
int fmt = 0, ind = 4;
|
|
(void)format_bytes(fp, fmt, ind, "x", blob->x, sizeof(blob->x));
|
|
(void)format_bytes(fp, fmt, ind, "y", blob->y, sizeof(blob->y));
|
|
(void)format_bytes(fp, fmt, ind, "M", blob->M, sizeof(blob->M));
|
|
(void)format_print(fp, fmt, ind, "L: %d", blob->L);
|
|
(void)format_bytes(fp, fmt, ind, "C", blob->C, sizeof(blob->C));
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_PrintECCSignature(FILE *fp, const ECCSignature *blob)
|
|
{
|
|
int fmt = 0, ind = 4;
|
|
(void)format_bytes(fp, fmt, ind, "r", blob->r, sizeof(blob->r));
|
|
(void)format_bytes(fp, fmt, ind, "s", blob->s, sizeof(blob->s));
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_ImportKey(
|
|
void *hSessionHandle,
|
|
unsigned char *pucKey,
|
|
unsigned int uiKeyLength,
|
|
void **phKeyHandle)
|
|
{
|
|
(void)hSessionHandle;
|
|
(void)pucKey;
|
|
(void)uiKeyLength;
|
|
(void)phKeyHandle;
|
|
SDFerr(SDF_F_SDF_IMPORTKEY, SDF_R_NOT_IMPLEMENTED);
|
|
return SDR_NOTSUPPORT;
|
|
}
|
|
|
|
int SDF_NewECCCipher(ECCCipher **cipher, size_t ulDataLen)
|
|
{
|
|
ECCCipher *ecc_cipher = NULL;
|
|
size_t len;
|
|
|
|
if (!cipher) {
|
|
SDFerr(SDF_F_SDF_NEWECCCIPHER, ERR_R_PASSED_NULL_PARAMETER);
|
|
return SDR_INARGERR;
|
|
}
|
|
|
|
if (!ulDataLen || ulDataLen > INT_MAX) {
|
|
SDFerr(SDF_F_SDF_NEWECCCIPHER,
|
|
SDF_R_INVALID_SM2_CIPHERTEXT_LENGTH);
|
|
return SDR_INARGERR;
|
|
}
|
|
|
|
len = sizeof(ECCCipher) - 1 + ulDataLen;
|
|
if (len < sizeof(SANSEC_ECCCipher)) {
|
|
len = sizeof(SANSEC_ECCCipher);
|
|
}
|
|
|
|
if (!(ecc_cipher = malloc(len))) {
|
|
SDFerr(SDF_F_SDF_NEWECCCIPHER, ERR_R_MALLOC_FAILURE);
|
|
return SDR_NOBUFFER;
|
|
}
|
|
memset(ecc_cipher, 0, sizeof(*ecc_cipher));
|
|
|
|
ecc_cipher->L = (unsigned int)ulDataLen;
|
|
|
|
*cipher = ecc_cipher;
|
|
return SDR_OK;
|
|
}
|
|
|
|
int SDF_FreeECCCipher(ECCCipher *cipher)
|
|
{
|
|
free(cipher);
|
|
return SDR_OK;
|
|
}
|
|
|
|
const char *SDF_GetErrorReason(int err)
|
|
{
|
|
switch (err) {
|
|
case SDR_OK: return "SDR_OK";
|
|
case SDR_BASE: return "SDR_BASE";
|
|
case SDR_UNKNOWERR: return "SDR_UNKNOWERR";
|
|
case SDR_NOTSUPPORT: return "SDR_NOTSUPPORT";
|
|
case SDR_COMMFAIL: return "SDR_COMMFAIL";
|
|
case SDR_HARDFAIL: return "SDR_HARDFAIL";
|
|
case SDR_OPENDEVICE: return "SDR_OPENDEVICE";
|
|
case SDR_OPENSESSION: return "SDR_OPENSESSION";
|
|
case SDR_PARDENY: return "SDR_PARDENY";
|
|
case SDR_KEYNOTEXIST: return "SDR_KEYNOTEXIST";
|
|
case SDR_ALGNOTSUPPORT: return "SDR_ALGNOTSUPPORT";
|
|
case SDR_ALGMODNOTSUPPORT: return "SDR_ALGMODNOTSUPPORT";
|
|
case SDR_PKOPERR: return "SDR_PKOPERR";
|
|
case SDR_SKOPERR: return "SDR_SKOPERR";
|
|
case SDR_SIGNERR: return "SDR_SIGNERR";
|
|
case SDR_VERIFYERR: return "SDR_VERIFYERR";
|
|
case SDR_SYMOPERR: return "SDR_SYMOPERR";
|
|
case SDR_STEPERR: return "SDR_STEPERR";
|
|
case SDR_FILESIZEERR: return "SDR_FILESIZEERR";
|
|
case SDR_FILENOEXIST: return "SDR_FILENOEXIST";
|
|
case SDR_FILEOFSERR: return "SDR_FILEOFSERR";
|
|
case SDR_KEYTYPEERR: return "SDR_KEYTYPEERR";
|
|
case SDR_KEYERR: return "SDR_KEYERR";
|
|
case SDR_ENCDATAERR: return "SDR_ENCDATAERR";
|
|
case SDR_RANDERR: return "SDR_RANDERR";
|
|
case SDR_PRKRERR: return "SDR_PRKRERR";
|
|
case SDR_MACERR: return "SDR_MACERR";
|
|
case SDR_FILEEXSITS: return "SDR_FILEEXSITS";
|
|
case SDR_FILEWERR: return "SDR_FILEWERR";
|
|
case SDR_NOBUFFER: return "SDR_NOBUFFER";
|
|
case SDR_INARGERR: return "SDR_INARGERR";
|
|
case SDR_OUTARGERR: return "SDR_OUTARGERR";
|
|
}
|
|
return "(unknown)";
|
|
}
|