gitee.com/ks-custle/core-gm@v0.0.0-20230922171213-b83bdd97b62c/txsec/xt_sec_lin.go

//go:build dragonfly || freebsd || linux || netbsd || openbsd
// +build dragonfly freebsd linux netbsd openbsd

package txsec

/*
#include <stdlib.h>
*/
import "C"
import (
	"encoding/hex"
	"fmt"
	"github.com/pkg/errors"
	"github.com/rainycape/dl"
	"unsafe"
)

var (
	lib *dl.DL = getXTSexLib()
)

func getXTSexLib() *dl.DL {
	lib, err := dl.Open("/opt/XTSec/lib/libXTSec.so", 0)
	if err != nil {
		panic(err)
	}
	defer lib.Close()
	return lib
}

type XTSecLinux struct {
}

func (sec *XTSecLinux) GenKeyPair(keyId string) ([]byte, error) {

	userLable := C.CString(keyId)
	defer C.free(unsafe.Pointer(userLable))

	cPublicKeyTemp := [256]byte{}
	puiPubLen := 0

	var genKeyPair func(szContId uintptr, pucPub uintptr, puiPubLen uintptr) uintptr
	lib.Sym("XT_GenKeyPair", &genKeyPair)
	ret := genKeyPair(uintptr(unsafe.Pointer(userLable)), uintptr(unsafe.Pointer(&cPublicKeyTemp[0])), uintptr(unsafe.Pointer(&puiPubLen)))
	fmt.Println("XtGenkeypair ret：", ret)
	//fmt.Println("XtGetpubkey puiPubLen：", puiPubLen)
	// 公钥
	cPublicKey := []byte{}
	for i := 0; i < puiPubLen; i++ {
		cPublicKey = append(cPublicKey, cPublicKeyTemp[i])
	}
	fmt.Println("XtGetpubkey cPublicKey:", hex.EncodeToString(cPublicKey))

	return cPublicKey, nil
}

func (sec *XTSecLinux) MakeP10(keyId string, dn string) ([]byte, error) {

	userLable := C.CString(keyId)
	defer C.free(unsafe.Pointer(userLable))

	userDn := C.CString(dn)
	defer C.free(unsafe.Pointer(userDn))

	pkcs10Temp := [256]byte{}
	puiPubLen := 0

	//typedef int(WINAPI *PFN_XT_MakeP10)(IN const char *szContId, IN const char *szDn, OUT unsigned char *pucP10, OUT unsigned int *puiP10Len);
	var makeP10 func(szContId uintptr, szDn uintptr, pucP10 uintptr, puiP10Len uintptr) uintptr
	lib.Sym("XT_MakeP10", &makeP10)
	ret := makeP10(uintptr(unsafe.Pointer(userLable)), uintptr(unsafe.Pointer(userDn)), uintptr(unsafe.Pointer(&pkcs10Temp[0])), uintptr(unsafe.Pointer(&puiPubLen)))
	fmt.Println("XtMakep10 ret : ", ret)

	// 证书申请文件
	pkcs10 := []byte{}
	for i := 0; i < puiPubLen; i++ {
		pkcs10 = append(pkcs10, pkcs10Temp[i])
	}
	fmt.Println("XtGetpubkey pkcs10:", hex.EncodeToString(pkcs10))

	return pkcs10, nil

}

func (sec *XTSecLinux) SaveCert(keyId string, signCert []byte, signCertLen int) error {

	userLable := C.CString(keyId)
	defer C.free(unsafe.Pointer(userLable))

	empty := []byte{0}

	//typedef int(WINAPI *PFN_XT_SaveCert)(IN const char *szContId, IN unsigned char *pucSignCert, IN unsigned int uiSignCertLen, IN unsigned char *pucEncKey, IN unsigned int uiEncKeyLen, IN unsigned char *pucEncCert, IN unsigned int uiEncCertLen);
	var saveCert func(szContId uintptr, pucSignCert uintptr, uiSignCertLen uintptr, pucEncKey uintptr, uiEncKeyLen uintptr, pucEncCert uintptr, uiEncCertLen uintptr) uintptr
	lib.Sym("XT_SaveCert", &saveCert)
	ret := saveCert(uintptr(unsafe.Pointer(userLable)), uintptr(unsafe.Pointer(&signCert[0])),
		uintptr(signCertLen), uintptr(unsafe.Pointer(&empty[0])), 0, uintptr(unsafe.Pointer(&empty[0])), 0)

	if ret != 0 {
		return errors.New("XtSavecert save error")
	}
	fmt.Println("XtSavecert ret : ", ret)
	return nil
}

func (sec *XTSecLinux) GetPubKey(keyId string) ([]byte, error) {

	userLable := C.CString(keyId)
	defer C.free(unsafe.Pointer(userLable))

	cPublicKeyTemp := [256]byte{}
	puiPubLen := 0

	//typedef int(WINAPI *PFN_XT_GetPubKey)(IN const char *szContId, IN int iType, OUT unsigned char *pucPub, OUT unsigned int *puiPubLen);
	var getPubKey func(szContId uintptr, iType uintptr, pucPub uintptr, puiPubLen uintptr) uintptr
	lib.Sym("XT_GetPubKey", &getPubKey)
	ret := getPubKey(uintptr(unsafe.Pointer(userLable)), uintptr(0), uintptr(unsafe.Pointer(&cPublicKeyTemp[0])), uintptr(unsafe.Pointer(&puiPubLen)))
	fmt.Println("XtGetpubkey ret：", ret)
	//fmt.Println("XtGetpubkey puiPubLen：", puiPubLen)
	// 公钥
	cPublicKey := []byte{}
	for i := 0; i < puiPubLen; i++ {
		cPublicKey = append(cPublicKey, cPublicKeyTemp[i])
	}
	fmt.Println("XtGetpubkey cPublicKey:", hex.EncodeToString(cPublicKey))

	return cPublicKey, nil

}

func (sec *XTSecLinux) Sign(keyId string, msg []byte) ([]byte, error) {

	userLable := C.CString(keyId)
	defer C.free(unsafe.Pointer(userLable))

	signDataTemp := [256]byte{}
	signDataLen := 0

	//typedef int(WINAPI *PFN_XT_Sign)(IN const char *szContId, IN unsigned char *pucIn, IN unsigned int uiInLen, OUT unsigned char *pucSign, OUT unsigned int *puiSignLen);
	var sign func(szContId uintptr, pucIn uintptr, uiInLen uintptr, pucSign uintptr, puiSignLen uintptr) uintptr
	lib.Sym("XT_Sign", &sign)
	ret := sign(uintptr(unsafe.Pointer(userLable)), uintptr(unsafe.Pointer(&msg[0])), uintptr(len(msg)),
		uintptr(unsafe.Pointer(&signDataTemp[0])), uintptr(unsafe.Pointer(&signDataLen)))

	fmt.Println("XtSign ret：", ret)
	fmt.Println("XtSign signDataLen：", signDataLen)

	// 签名值
	signData := []byte{}
	for i := 0; i < signDataLen; i++ {
		signData = append(signData, signDataTemp[i])
	}
	fmt.Println("XtSign signData:", hex.EncodeToString(signData))

	return signData, nil
}

func (sec *XTSecLinux) VerifySign(publicKey []byte, msg []byte, signData []byte) bool {

	//typedef int(WINAPI *PFN_XT_VerifySign)(IN unsigned char *pucPub, IN unsigned int uiPubLen, IN unsigned char *pucIn, IN unsigned int uiInLen, IN unsigned char *pucSign, IN unsigned int uiSignLen);
	var verifySign func(pucPub uintptr, uiPubLen uintptr, pucIn uintptr, uiInLen uintptr, pucSign uintptr, uiSignLen uintptr) uintptr
	lib.Sym("XT_VerifySign", &verifySign)
	ret := verifySign(uintptr(unsafe.Pointer(&publicKey[0])), uintptr(len(publicKey)), uintptr(unsafe.Pointer(&msg[0])), uintptr(len(msg)), uintptr(unsafe.Pointer(&signData[0])), uintptr(len(signData)))
	fmt.Println("XtVerifysign ret：", ret)
	return ret == 0
}

func (sec *XTSecLinux) Encrypt(publicKey []byte, msg []byte) ([]byte, error) {

	encDataTemp := [10000]byte{}
	encDataLen := 10000

	//typedef int(WINAPI *PFN_XT_Encrypt)(IN unsigned char *pucPub, IN unsigned int uiPubLen, IN unsigned char *pucIn, IN unsigned int uiInLen, OUT unsigned char *pucOut, OUT unsigned int *puiOutLen);
	var encrypt func(pucPub uintptr, uiPubLen uintptr, pucIn uintptr, uiInLen uintptr, pucOut uintptr, puiOutLen uintptr) uintptr
	lib.Sym("XT_Encrypt", &encrypt)
	ret := encrypt(uintptr(unsafe.Pointer(&publicKey[0])), uintptr(len(publicKey)), uintptr(unsafe.Pointer(&msg[0])), uintptr(len(msg)), uintptr(unsafe.Pointer(&encDataTemp[0])), uintptr(unsafe.Pointer(&encDataLen)))
	fmt.Println("XtEncrypt ret：", ret)
	fmt.Println("XtEncrypt encDataLen：", encDataLen)

	// 密文数据
	encData := []byte{}
	for i := 0; i < encDataLen; i++ {
		encData = append(encData, encDataTemp[i])
	}
	fmt.Println("XtEncrypt encData:", hex.EncodeToString(encData))

	return encData, nil

}

func (sec *XTSecLinux) Decrypt(keyId string, encData []byte) ([]byte, error) {

	userLable := C.CString(keyId)

	msgTemp := [10000]byte{}
	msgLen := 10000

	//typedef int(WINAPI *PFN_XT_Decrypt)(IN const char *szContId, IN unsigned char *pucIn, IN unsigned int uiInLen, OUT unsigned char *pucOut, OUT unsigned int *puiOutLen);
	var decrypt func(szContId uintptr, pucIn uintptr, uiInLen uintptr, pucOut uintptr, puiOutLen uintptr) uintptr
	lib.Sym("XT_Decrypt", &decrypt)
	ret := decrypt(uintptr(unsafe.Pointer(userLable)), uintptr(unsafe.Pointer(&encData[0])), uintptr(len(encData)), uintptr(unsafe.Pointer(&msgTemp[0])), uintptr(unsafe.Pointer(&msgLen)))
	fmt.Println("XtDecrypt ret：", ret)
	fmt.Println("XtDecrypt msgLen：", msgLen)
	// 解密后数据
	msg := []byte{}
	for i := 0; i < msgLen; i++ {
		msg = append(msg, msgTemp[i])
	}
	fmt.Println("XtDecrypt msg:", hex.EncodeToString(msg))
	return msg, nil
}

func (sec *XTSecLinux) ChangeContId(keyId string, newKeyId string) error {

	userLable := C.CString(keyId)
	defer C.free(unsafe.Pointer(userLable))

	newUserLable := C.CString(newKeyId)
	defer C.free(unsafe.Pointer(newUserLable))

	//XT_API int XT_CALL XT_ChangeContId(IN const char *szContId, IN const char *szNewContId);
	var changeContId func(szContId uintptr, pucIn uintptr) uintptr
	lib.Sym("XT_ChangeContId", &changeContId)
	ret := changeContId(uintptr(unsafe.Pointer(userLable)), uintptr(unsafe.Pointer(newUserLable)))
	fmt.Println("XtChangeContId ret：", ret)

	if ret != 0 {
		return errors.New("change contId error")
	}
	return nil
}