import 'dart:ffi';
import 'dart:io';
import 'package:ffi/ffi.dart';
import 'package:flutter/cupertino.dart';
/// SM3 算法定义
///
/// \# define SGD_SM3 0x00000001
// ignore: constant_identifier_names
const SGD_SM3 = 0x00000001;
/// 异常错误
///
/// \# define SAR_UNKNOWNERR 0x0A000002
// ignore: constant_identifier_names
const SAR_UNKNOWNERR = 0x0A000002;
/// 对象未导出
///
/// \# define SAR_NOTEXPORTERR 0x0A00001D
// ignore: constant_identifier_names
const SAR_NOTEXPORTERR = 0x0A00001D;
/// ECC 签名结构体
///
/// 信息安全技术 智能密码钥匙应用接口规范 GB/T 35291-2017
///
/// #define ECC_MAX_XCOORDINATE_BITS_LEN 512
///
/// typedef struct Struct_ECCSIGNATUREBLOB {
///
/// BYTE r[ECC_MAX_XCOORDINATE_BITS_LEN/8];
///
/// BYTE s[ECC_MAX_XCOORDINATE_BITS_LEN/8];
///
/// } ECCSIGNATUREBLOB, *PECCSIGNATUREBLOB
// ignore: constant_identifier_names
const ECC_MAX_XCOORDINATE_BITS_LEN = 512;
@Packed(8)
// ignore: camel_case_types
final class Struct_ECCSIGNATUREBLOB extends Struct {
@Array(ECC_MAX_XCOORDINATE_BITS_LEN ~/ 8)
external Array<Uint8> r;
@Array(ECC_MAX_XCOORDINATE_BITS_LEN ~/ 8)
external Array<Uint8> s;
}
// ignore: constant_identifier_names
const TRUE = 0x00000001;
// ignore: constant_identifier_names
const FALSE = 0x00000000;
/// ECC 公钥结构体
///
/// 信息安全技术 智能密码钥匙应用接口规范 GB/T 35291-2017
@Packed(8)
// ignore: camel_case_types
final class Struct_ECCPUBLICKEYBLOB extends Struct {
/*
* 官方文档是C语言的 ULONG，不管操作系统是32位还是64位，都要求是 4个字节。
**/
@Uint32()
external int bitLen;
@Array(64)
external Array<Uint8> xCoordinate;
@Array(64)
external Array<Uint8> yCoordinate;
int lengthInBytes() {
return sizeOf<Struct_ECCPUBLICKEYBLOB>();
}
}
/// 密文数据结构，经典的Flutter变长结构体处理
///
/// 信息安全技术 智能密码钥匙应用接口规范 GB/T 35291-2017
@Packed(8)
// ignore: camel_case_types
final class Struct_ECCCIPHERBLOB extends Struct {
/*
* 官方文档是C语言的 ULONG，不管操作系统是32位还是64位，都要求是 4个字节。
**/
@Array(64)
external Array<Uint8> xCoordinate;
@Array(64)
external Array<Uint8> yCoordinate;
@Array(32)
external Array<Uint8> hash;
@Uint32()
external int cipherLen;
@Array.variable()
external Array<Uint8> cipher;
static Pointer<Struct_ECCCIPHERBLOB> allocate(final int length) {
final lengthInBytes = lengthBytes(length);
final result = calloc.allocate<Struct_ECCCIPHERBLOB>(lengthInBytes);
result.ref.cipherLen = length;
return result;
}
static int lengthBytes(final int length) {
return sizeOf<Struct_ECCCIPHERBLOB>() + sizeOf<Uint8>() * length;
}
int lengthInBytes() {
return lengthBytes(cipherLen);
}
}
class SkfLib {
/// 动态库加载
late final DynamicLibrary? _skfLib;
late final int Function(
int bPresent, Pointer<Uint8> szNameList, Pointer<Uint32> pulSize)?
_skfEnumDev;
late final int Function(Pointer<Utf8> szName, Pointer<Pointer<Void>> phDev)?
_skfConnectDev;
late final int Function(Pointer<Void> hDev)? _skfDisConnectDev;
late final int Function(Pointer<Void> hDev, Pointer<Utf8> szAppName,
Pointer<Pointer<Void>> phApplication)? _skfOpenApplication;
late final int Function(Pointer<Void> hDev, Pointer<Uint8> szAppName,
Pointer<Uint32> pulSize)? _skfEnumApplication;
late final int Function(Pointer<Void> hApplication)? _skfCloseApplication;
late final int Function(
Pointer<Void> hApplication,
Pointer<Uint8> szContainerName,
Pointer<Uint32> pulSize)? _skfEnumContainer;
late final int Function(
Pointer<Void> hApplication,
Pointer<Utf8> szContainerName,
Pointer<Pointer<Void>> phContainer)? _skfOpenContainer;
late final int Function(Pointer<Void> hContainer)? _skfCloseContainer;
late final int Function(
Pointer<Void> hContainer,
int bSignFlag,
Pointer<Struct_ECCPUBLICKEYBLOB> pbBlob,
Pointer<Uint32> pulBlobLen)? _skfExportPublicKey;
late final int Function(Pointer<Void> hContainer, int bSignFlag,
Pointer<Uint8> pbCert, Pointer<Uint32> pulCertLen)? _skfExportCertificate;
late final int Function(
Pointer<Void> hDev,
Pointer<Struct_ECCPUBLICKEYBLOB> pECCPubKeyBlob,
Pointer<Utf8> pbPlainText,
int ulPlainTextLen,
Pointer<Struct_ECCCIPHERBLOB> pCipherText)? _skfExtECCEncrypt;
late final int Function(
Pointer<Void> hContainer,
int bSignFlag,
Pointer<Struct_ECCCIPHERBLOB> pCipherText,
Pointer<Uint8> pbData,
Pointer<Uint32> pbDataLen)? _skfECCDecrypt;
late final int Function(
Pointer<Void> hContainer,
int ulAlgID,
Pointer<Utf8> pbPlainText,
int ulPlainTextLen,
Pointer<Struct_ECCSIGNATUREBLOB> pSignature)? _skfECCDigestSignData;
late final int Function(
Pointer<Void> hContainer,
int ulAlgID,
Pointer<Utf8> pbPlainText,
int ulPlainTextLen,
Pointer<Struct_ECCSIGNATUREBLOB> pSignature)? _skfECCSignDataEx;
late final int Function(Pointer<Void> hApplication, int ulPINType,
Pointer<Utf8> szPIN, Pointer<Uint32> pulRetryCount)? _skfVerifyPIN;
SkfLib(final String dllPath) {
try {
_skfLib = Platform.isMacOS || Platform.isIOS
? DynamicLibrary.process()
: DynamicLibrary.open(dllPath); // 加载dll,获取句柄
} catch (e) {
_skfLib = null;
debugPrint('SkfLib Load Failed: $e');
}
// 获取函数指针
const fnEnumDev = "SKF_EnumDev";
if (_providesSymbol(fnEnumDev)) {
_skfEnumDev = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(
Uint32, Pointer<Uint8>, Pointer<Uint32>)>>(fnEnumDev)
.asFunction();
} else {
_skfEnumDev = null;
}
const fnConnectDev = "SKF_ConnectDev";
if (_providesSymbol(fnConnectDev)) {
_skfConnectDev = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(
Pointer<Utf8>, Pointer<Pointer<Void>>)>>(fnConnectDev)
.asFunction();
} else {
_skfConnectDev = null;
}
const fnDisConnectDev = "SKF_DisConnectDev";
if (_providesSymbol(fnDisConnectDev)) {
_skfDisConnectDev = _skfLib!
.lookup<NativeFunction<Uint32 Function(Pointer<Void>)>>(
fnDisConnectDev)
.asFunction();
} else {
_skfDisConnectDev = null;
}
const fnEnumApplication = "SKF_EnumApplication";
if (_providesSymbol(fnEnumApplication)) {
_skfEnumApplication = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Pointer<Uint8>,
Pointer<Uint32>)>>(fnEnumApplication)
.asFunction();
} else {
_skfEnumApplication = null;
}
const fnOpenApplication = "SKF_OpenApplication";
if (_providesSymbol(fnOpenApplication)) {
_skfOpenApplication = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Pointer<Utf8>,
Pointer<Pointer<Void>>)>>(fnOpenApplication)
.asFunction();
} else {
_skfOpenApplication = null;
}
const fnCloseApplication = "SKF_CloseApplication";
if (_providesSymbol(fnCloseApplication)) {
_skfCloseApplication = _skfLib!
.lookup<NativeFunction<Uint32 Function(Pointer<Void>)>>(
fnCloseApplication)
.asFunction();
} else {
_skfCloseApplication = null;
}
const fnEnumContainer = "SKF_EnumContainer";
if (_providesSymbol(fnEnumContainer)) {
_skfEnumContainer = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Pointer<Uint8>,
Pointer<Uint32>)>>(fnEnumContainer)
.asFunction();
} else {
_skfEnumContainer = null;
}
const fnOpenContainer = "SKF_OpenContainer";
if (_providesSymbol(fnOpenContainer)) {
_skfOpenContainer = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Pointer<Utf8>,
Pointer<Pointer<Void>>)>>(fnOpenContainer)
.asFunction();
} else {
_skfOpenContainer = null;
}
const fnCloseContainer = "SKF_CloseContainer";
if (_providesSymbol(fnCloseContainer)) {
_skfCloseContainer = _skfLib!
.lookup<NativeFunction<Uint32 Function(Pointer<Void>)>>(
fnCloseContainer)
.asFunction();
} else {
_skfCloseContainer = null;
}
const fnExportPublicKey = "SKF_ExportPublicKey";
if (_providesSymbol(fnExportPublicKey)) {
_skfExportPublicKey = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(
Pointer<Void>,
Uint32,
Pointer<Struct_ECCPUBLICKEYBLOB>,
Pointer<Uint32>)>>(fnExportPublicKey)
.asFunction();
} else {
_skfExportPublicKey = null;
}
const fnExportCertificate = "SKF_ExportCertificate";
if (_providesSymbol(fnExportCertificate)) {
_skfExportCertificate = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Uint32, Pointer<Uint8>,
Pointer<Uint32>)>>(fnExportCertificate)
.asFunction();
} else {
_skfExportCertificate = null;
}
const fnExtECCEncrypt = "SKF_ExtECCEncrypt";
if (_providesSymbol(fnExtECCEncrypt)) {
_skfExtECCEncrypt = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(
Pointer<Void>,
Pointer<Struct_ECCPUBLICKEYBLOB>,
Pointer<Utf8>,
Uint32,
Pointer<Struct_ECCCIPHERBLOB>)>>(fnExtECCEncrypt)
.asFunction();
} else {
_skfExtECCEncrypt = null;
}
const fnECCDecrypt = "SKF_ECCDecrypt";
if (_providesSymbol(fnECCDecrypt)) {
_skfECCDecrypt = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(
Pointer<Void>,
Uint32,
Pointer<Struct_ECCCIPHERBLOB>,
Pointer<Uint8>,
Pointer<Uint32>)>>(fnECCDecrypt)
.asFunction();
} else {
_skfECCDecrypt = null;
}
const fnECCDigestSignData = "SKF_ECCDigestSignData";
if (_providesSymbol(fnECCDigestSignData)) {
_skfECCDigestSignData = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Uint32, Pointer<Utf8>, Uint32,
Pointer<Struct_ECCSIGNATUREBLOB>)>>(fnECCDigestSignData)
.asFunction();
} else {
_skfECCDigestSignData = null;
}
const fnECCSignDataEx = "SKF_ECCSignDataEx";
if (_providesSymbol(fnECCSignDataEx)) {
_skfECCSignDataEx = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Uint32, Pointer<Utf8>, Uint32,
Pointer<Struct_ECCSIGNATUREBLOB>)>>(fnECCSignDataEx)
.asFunction();
} else {
_skfECCSignDataEx = null;
}
const fnVerifyPIN = "SKF_VerifyPIN";
if (_providesSymbol(fnVerifyPIN)) {
_skfVerifyPIN = _skfLib!
.lookup<
NativeFunction<
Uint32 Function(Pointer<Void>, Uint32, Pointer<Utf8>,
Pointer<Uint32>)>>(fnVerifyPIN)
.asFunction();
} else {
_skfVerifyPIN = null;
}
}
/// Checks whether this dynamic library provides a symbol with the given name.
bool _providesSymbol(final String symbolName) {
return _skfLib?.providesSymbol(symbolName) ?? false;
}
@mustCallSuper
void close() {
_skfLib?.close();
}
/// 功能描述：
///
/// 获得当前系统中的设备列表。
///
/// 参数：
///
/// [bPresent] [IN] 为 TRUE 表示获取当前设备状态为存在的设备列表。
/// 为 FALSE 表示取当前取得支持的设备列表。
///
/// [szNameList] [OUT] 设备名称列表。如果该参数为 NULL ，将由 pulSize 返回所需要的内存空间大小。
/// 每个设备的名称以单个 '\0' 结束，以双 '\0' 表示列表结束。
///
/// [pulSize] [IN, OUT] 输入时表示设备名称列表的缓冲区长度，输出时表示 szNameList 所占用的空间大小。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_EnumDev(final int bPresent, final Pointer<Uint8> szNameList,
final Pointer<Uint32> pulSize) {
if (null != _skfEnumDev) {
return _skfEnumDev(bPresent, szNameList, pulSize);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 通过设备名称连接设备，返回设备的句柄。
///
/// 参数：
///
/// [szName] [IN] 设备名称。
///
/// [phDev] [OUT] 返回设备操作句柄。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_ConnectDev(
final Pointer<Utf8> szName, final Pointer<Pointer<Void>> phDev) {
if (null != _skfConnectDev) {
return _skfConnectDev(szName, phDev);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 断开一个已经连接的设备，并释放句柄。
///
/// 参数：
///
/// [hDev] [IN] 连接设备时返回的设备句柄。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_DisConnectDev(final Pointer<Void> hDev) {
if (null != _skfDisConnectDev) {
return _skfDisConnectDev(hDev);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 枚举设备中存在的所有应用。
///
/// 参数：
///
/// [hDev] [IN] 连接设备时返回的设备句柄。
///
/// [szAppName] [OUT] 返回应用名称列表，如果该参数为空，将由 pulSize 返回所需要的内存空间大小。
/// 每个应用的名称以单个 '\0' 结束，以双 '\0' 表示列表结束。
///
/// [pulSize] [IN, OUT] 输入时表示应用名称列表的缓冲区长度，输出时表示 szAppName 所占用的空间大小。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_EnumApplication(final Pointer<Void> hDev,
final Pointer<Uint8> szAppName, final Pointer<Uint32> pulSize) {
if (null != _skfEnumApplication) {
return _skfEnumApplication(hDev, szAppName, pulSize);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 打开指定的应用。
///
/// 参数：
///
/// [hDev] [IN] 连接设备时返回的设备句柄。
///
/// [szAppName] [IN] 应用名称。
///
/// [phApplication] [OUT] 应用的句柄。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_OpenApplication(
final Pointer<Void> hDev,
final Pointer<Utf8> szAppName,
final Pointer<Pointer<Void>> phApplication) {
if (null != _skfOpenApplication) {
return _skfOpenApplication(hDev, szAppName, phApplication);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 关闭应用并释放应用句柄。
///
/// 参数：
///
/// [hApplication] [IN] 应用句柄。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_CloseApplication(final Pointer<Void> hApplication) {
if (null != _skfCloseApplication) {
return _skfCloseApplication(hApplication);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 枚举容器下所有容器并返回容器名称列表。
///
/// 参数：
///
/// [hApplication] [IN] 应用句柄。
///
/// [szContainerName] [OUT] 指向容器名称列表缓冲区，如果该参数为 NULL 时，pulSize 表示返回数据所需缓冲区的长度，
/// 如果此参数不为 NULL 时，返回容器名称列表，每个容器名以 '\0' 结束，列表以双 '\0' 结束。
///
/// [pulSize] [IN, OUT] 输入时表示 szContainerName 缓冲区长度，输出时表示容器名称列表的长度。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_EnumContainer(final Pointer<Void> hApplication,
final Pointer<Uint8> szContainerName, final Pointer<Uint32> pulSize) {
if (null != _skfEnumContainer) {
return _skfEnumContainer(hApplication, szContainerName, pulSize);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 获取容器句柄。
///
/// 参数：
///
/// [hApplication] [IN] 应用句柄。
///
/// [szContainerName] [IN] 容器的名称。
///
/// [phContainer] [OUT] 返回所打开容器的句柄。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_OpenContainer(
final Pointer<Void> hApplication,
final Pointer<Utf8> szContainerName,
final Pointer<Pointer<Void>> phContainer) {
if (null != _skfOpenContainer) {
return _skfOpenContainer(hApplication, szContainerName, phContainer);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 关闭容器句柄，并释放容器句柄相关资源。
///
/// 参数：
///
/// [hContainer] [IN] 容器句柄。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_CloseContainer(final Pointer<Void> hContainer) {
if (null != _skfCloseContainer) {
return _skfCloseContainer(hContainer);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 从导出公钥。
///
/// 参数：
///
/// [hContainer] [IN] 容器句柄。
///
/// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。
///
/// [pbBlob] [OUT] 指向公钥内容缓冲区，如果此参数为 NULL 时，pulBlobLen 返回数据所需要
/// 缓冲区长度，如果此参数不为 NULL 时，返回公钥内容。
///
/// [pulBlobLen] [IN/OUT] 输入时表示 pbBlob 缓冲区的长度，输出时表示证书内容的长度。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_ExportPublicKey(
final Pointer<Void> hContainer,
final int bSignFlag,
final Pointer<Struct_ECCPUBLICKEYBLOB> pbBlob,
final Pointer<Uint32> pulBlobLen) {
if (null != _skfExportPublicKey) {
return _skfExportPublicKey(hContainer, bSignFlag, pbBlob, pulBlobLen);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 从容器内导出数字证书。
///
/// 参数：
///
/// [hContainer] [IN] 容器句柄。
///
/// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。
///
/// [pbCert] [OUT] 指向证书内容缓冲区，如果此参数为 NULL 时，pulCertLen 返回数据所需要
/// 缓冲区长度，如果此参数不为 NULL 时，返回数字证书内容。
///
/// [pulCertLen] [IN/OUT] 输入时表示 pbCert 缓冲区的长度，输出时表示证书内容的长度。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_ExportCertificate(final Pointer<Void> hContainer, final int bSignFlag,
final Pointer<Uint8> pbCert, final Pointer<Uint32> pulCertLen) {
if (null != _skfExportCertificate) {
return _skfExportCertificate(hContainer, bSignFlag, pbCert, pulCertLen);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 使用外部传入的 ECC 公钥对输入数据做加密运算并输出结果。
///
/// 参数：
///
/// [hDev] [IN] 设备句柄。
///
/// [pECCPubKeyBlob] [IN] ECC公钥数据结构。
///
/// [pbPlainText] [IN] 待加密的明文数据。
///
/// [ulPlainTextLen] [IN] 待加密的明文数据长度。
///
/// [pCipherText] [OUT] 密文数据。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_ExtECCEncrypt(
final Pointer<Void> hDev,
final Pointer<Struct_ECCPUBLICKEYBLOB> pECCPubKeyBlob,
final Pointer<Utf8> pbPlainText,
final int ulPlainTextLen,
final Pointer<Struct_ECCCIPHERBLOB> pCipherText) {
if (null != _skfExtECCEncrypt) {
return _skfExtECCEncrypt(
hDev, pECCPubKeyBlob, pbPlainText, ulPlainTextLen, pCipherText);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 私钥解密。
///
/// 参数：
///
/// [hContainer] [IN] 密钥容器句柄。
///
/// [bSignFlag] [IN] TRUE 表示签名证书，FALSE 表示加密证书。
///
/// [pCipherText] [IN] 加密数据的结构。
///
/// [pbData] [OUT] 解密后的明文数据。
///
/// [pbDataLen] [OUT] 明文数据长度。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_ECCDecrypt(
final Pointer<Void> hContainer,
final int bSignFlag,
final Pointer<Struct_ECCCIPHERBLOB> pCipherText,
final Pointer<Uint8> pbData,
final Pointer<Uint32> pbDataLen) {
if (null != _skfECCDecrypt) {
return _skfECCDecrypt(
hContainer, bSignFlag, pCipherText, pbData, pbDataLen);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 厂商实现的 ECC 数据签名扩展。
///
/// 参数：
///
/// [hContainer] [IN] 密钥容器句柄。
///
/// [ulAlgID] [IN] 杂凑算法标识，这里选择SGD_SM3（0x00000001），表明使用SM3算法。
///
/// [pbPlainText] [IN] 待签名的明文数据。
///
/// [ulPlainTextLen] [IN] 待签名的明文数据长度。
///
/// [pSignature] [OUT] 签名结果。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_ECCSignDataEx(
final Pointer<Void> hContainer,
final int ulAlgID,
final Pointer<Utf8> pbPlainText,
final int ulPlainTextLen,
final Pointer<Struct_ECCSIGNATUREBLOB> pSignature) {
// WQ 扩展接口 SKF_ECCSignDataEx
// FT/HB 扩展接口 SKF_ECCDigestSignData
if (null != _skfECCDigestSignData) {
return _skfECCDigestSignData(
hContainer, ulAlgID, pbPlainText, ulPlainTextLen, pSignature);
} else if (null != _skfECCSignDataEx) {
return _skfECCSignDataEx(
hContainer, ulAlgID, pbPlainText, ulPlainTextLen, pSignature);
}
return SAR_NOTEXPORTERR;
}
/// 功能描述：
///
/// 校验 PIN 码。校验成功后，会获得相应的权限，如果 PIN 码错误，会返回 PIN 码的重试次数，
/// 当重试次数为 0 时表示 PIN 码已经锁死。
///
/// 参数：
///
/// [hApplication] [IN] 应用句柄。
///
/// [ulPINType] [IN] PIN 类型。 0 是管理员账户，1 为普通用户，这个参数一般选择 1。
///
/// [szPIN] [IN] PIN 值。
///
/// [pulRetryCount] [OUT] 出错后返回的重试次数。
///
/// 返回值：
///
/// SAR_OK : 成功。
///
/// 其他： 错误码。
// ignore: non_constant_identifier_names
int SKF_VerifyPIN(final Pointer<Void> hApplication, final int ulPINType,
final Pointer<Utf8> szPIN, final Pointer<Uint32> pulRetryCount) {
if (null != _skfVerifyPIN) {
return _skfVerifyPIN(hApplication, ulPINType, szPIN, pulRetryCount);
}
return SAR_NOTEXPORTERR;
}
}
