yaole
1115 lines
34 KiB
Go
1115 lines
34 KiB
Go
package sdf
|
|
|
|
import (
|
|
"crypto/cipher"
|
|
"hash"
|
|
"io"
|
|
|
|
"xdx.jelly/xgcl/api/common"
|
|
"xdx.jelly/xgcl/grand"
|
|
"xdx.jelly/xgcl/identifier"
|
|
"xdx.jelly/xgcl/mac"
|
|
"xdx.jelly/xgcl/mac/cbcmac"
|
|
"xdx.jelly/xgcl/rsa"
|
|
"xdx.jelly/xgcl/sm/sm1"
|
|
"xdx.jelly/xgcl/sm/sm2"
|
|
"xdx.jelly/xgcl/sm/sm3"
|
|
"xdx.jelly/xgcl/sm/sm4"
|
|
)
|
|
|
|
type Handle uint32
|
|
type KeyType int
|
|
|
|
const (
|
|
// internal use
|
|
KeyTypeUnknow KeyType = 0
|
|
KeyTypeBlock KeyType = 0x10 // 对称密钥，SM1 or SM4
|
|
KeyTypeSm1 KeyType = 0x11
|
|
KeyTypeSm4 KeyType = 0x14
|
|
KeyTypeSm2Sign KeyType = 0x21
|
|
KeyTypeSm2Enc KeyType = 0x22
|
|
KeyTypeSm9MasterSign KeyType = 0x90
|
|
KeyTypeSm9MasterEnc KeyType = 0x91
|
|
KeyTypeSm9UserSign KeyType = 0x92
|
|
KeyTypeSm9UserEnc KeyType = 0x93
|
|
|
|
KeyTypeRsa KeyType = 0x100
|
|
)
|
|
|
|
func (k KeyType) String() string {
|
|
switch k {
|
|
case KeyTypeBlock:
|
|
return "BlockKey"
|
|
case KeyTypeSm1:
|
|
return "Sm1Key"
|
|
case KeyTypeSm2Sign:
|
|
return "Sm2SignKey"
|
|
case KeyTypeSm2Enc:
|
|
return "Sm2EncKey"
|
|
case KeyTypeSm4:
|
|
return "Sm4Key"
|
|
case KeyTypeSm9MasterSign:
|
|
return "Sm9MasterSignKey"
|
|
case KeyTypeSm9MasterEnc:
|
|
return "Sm9MasterEncKey"
|
|
case KeyTypeSm9UserSign:
|
|
return "Sm9UserSignKey"
|
|
case KeyTypeSm9UserEnc:
|
|
return "Sm9UserEncKey"
|
|
case KeyTypeRsa:
|
|
return "RsaKey"
|
|
default:
|
|
// Panic?
|
|
return "unknown"
|
|
}
|
|
}
|
|
|
|
func GetKeyType(s string) KeyType {
|
|
switch {
|
|
case s == "BlockKey":
|
|
return KeyTypeBlock
|
|
case s == "Sm1Key":
|
|
return KeyTypeSm1
|
|
case s == "Sm2SignKey":
|
|
return KeyTypeSm2Sign
|
|
case s == "Sm2EncKey":
|
|
return KeyTypeSm2Enc
|
|
case s == "Sm4Key":
|
|
return KeyTypeSm4
|
|
case s == "Sm9MasterSignKey":
|
|
return KeyTypeSm9MasterSign
|
|
case s == "Sm9MasterEncKey":
|
|
return KeyTypeSm9MasterEnc
|
|
case s == "Sm9UserSignKey":
|
|
return KeyTypeSm9UserSign
|
|
case s == "Sm9UserEncKey":
|
|
return KeyTypeSm9UserEnc
|
|
case s == "RsaKey":
|
|
return KeyTypeRsa
|
|
default:
|
|
return KeyTypeUnknow
|
|
}
|
|
}
|
|
|
|
type SymKey struct {
|
|
keyType KeyType
|
|
key []byte
|
|
}
|
|
|
|
type Sm2Key struct {
|
|
signKey *sm2.PrivateKey
|
|
encKey *sm2.PrivateKey
|
|
}
|
|
|
|
func (k *Sm2Key) Key(tpe KeyType) *sm2.PrivateKey {
|
|
if tpe == KeyTypeSm2Sign {
|
|
return k.signKey
|
|
}
|
|
return k.encKey
|
|
}
|
|
|
|
type RsaKey struct {
|
|
signKey *rsa.PrivateKey
|
|
encKey *rsa.PrivateKey
|
|
}
|
|
|
|
type Sm2Agreement struct {
|
|
param *sm2.ExchgParameters
|
|
sk *sm2.PrivateKey
|
|
keyBits int
|
|
sponsorID []byte
|
|
}
|
|
|
|
var _ Sdfable = &SdfNoLock{}
|
|
|
|
// SdfNoLock 无锁的SDFable实现。
|
|
// GCL作为软算法实例，应看做是一个device。需要进行加锁同步，可多线程共用一个实例。
|
|
// 这里的SdfNoLock，避免加锁，适用于单线程中调用。
|
|
//
|
|
// 若是密码卡的SdfNoLock实例，则看做session，不需加锁，不能多线程共用一个实例。
|
|
type SdfNoLock struct {
|
|
rand io.Reader //随机数发生器
|
|
|
|
RsaKey map[uint32]*RsaKey // RSAKey -- TODO
|
|
Sm2Key map[uint32]*Sm2Key // SM2Key
|
|
SymKey map[uint32]*SymKey // KEK
|
|
|
|
SessionKey map[Handle]*SymKey
|
|
Sm2Agreement map[Handle]*Sm2Agreement // Sm2密钥交换句柄
|
|
|
|
hash hash.Hash
|
|
}
|
|
|
|
var reader = grand.Reader
|
|
|
|
func (s *SdfNoLock) Marshal() []byte {
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) Unmarshal(data []byte) {
|
|
|
|
}
|
|
|
|
// //////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Helper function to use gcl with Sdfable interface
|
|
//
|
|
// /////////////////////////////////////////////////////////////////////////
|
|
const (
|
|
minIndex uint32 = 1000
|
|
maxIndex uint32 = 10000
|
|
NilIndex uint32 = ^uint32(0)
|
|
minHandle Handle = 1000
|
|
maxHandle Handle = 10000
|
|
NilHandle Handle = ^Handle(0)
|
|
)
|
|
|
|
func (s *SdfNoLock) GenerateKekAtIndex(keyIndex uint32) error {
|
|
if s.SymKey == nil {
|
|
s.SymKey = make(map[uint32]*SymKey)
|
|
}
|
|
|
|
k := &SymKey{
|
|
keyType: KeyTypeBlock,
|
|
key: make([]byte, sm4.BlockSize),
|
|
}
|
|
s.reader().Read(k.key)
|
|
s.SymKey[keyIndex] = k
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) ImportSm2KeyAtIndex(index uint32, tpe KeyType, key *common.ECCrefPrivateKey) (err error) {
|
|
if s.Sm2Key == nil {
|
|
s.Sm2Key = make(map[uint32]*Sm2Key)
|
|
}
|
|
|
|
k := &sm2.PrivateKey{}
|
|
if err = k.UnmarshalSDF(key); err != nil {
|
|
return err
|
|
}
|
|
sm2Key, ok := s.Sm2Key[index]
|
|
if !ok {
|
|
sm2Key = new(Sm2Key)
|
|
}
|
|
switch tpe {
|
|
case KeyTypeSm2Sign:
|
|
sm2Key.signKey = k
|
|
case KeyTypeSm2Enc:
|
|
sm2Key.encKey = k
|
|
default:
|
|
return common.SDR_INARGERR
|
|
}
|
|
s.Sm2Key[index] = sm2Key
|
|
return
|
|
}
|
|
|
|
func (s *SdfNoLock) ImportSm2Key(tpe KeyType, key *common.ECCrefPrivateKey) (index uint32, err error) {
|
|
if s.Sm2Key == nil {
|
|
s.Sm2Key = make(map[uint32]*Sm2Key)
|
|
}
|
|
|
|
index = minIndex
|
|
var sm2Key *Sm2Key
|
|
var ok bool
|
|
for index < maxIndex {
|
|
if sm2Key, ok = s.Sm2Key[index]; !ok {
|
|
sm2Key = new(Sm2Key)
|
|
break
|
|
} else if sm2Key.Key(tpe) == nil {
|
|
break
|
|
}
|
|
index++
|
|
}
|
|
if index == maxIndex {
|
|
return NilIndex, common.SDR_NOBUFFER
|
|
}
|
|
|
|
k := &sm2.PrivateKey{}
|
|
if err = k.UnmarshalSDF(key); err != nil {
|
|
return NilIndex, err
|
|
}
|
|
switch tpe {
|
|
case KeyTypeSm2Sign:
|
|
sm2Key.signKey = k
|
|
case KeyTypeSm2Enc:
|
|
sm2Key.encKey = k
|
|
default:
|
|
return NilIndex, common.SDR_INARGERR
|
|
}
|
|
s.Sm2Key[index] = sm2Key
|
|
return
|
|
}
|
|
|
|
// ImportSessionKey 将key存入s中
|
|
// movable, key是否可移动
|
|
func (s *SdfNoLock) ImportSessionKey(tpe KeyType, key []byte, movable bool) (handle Handle, err error) {
|
|
if s.SessionKey == nil {
|
|
s.SessionKey = make(map[Handle]*SymKey)
|
|
}
|
|
handle = minHandle
|
|
var ok bool
|
|
for handle < maxHandle {
|
|
if _, ok = s.SessionKey[handle]; !ok {
|
|
break
|
|
}
|
|
handle++
|
|
}
|
|
if handle == maxHandle {
|
|
return NilHandle, common.SDR_NOBUFFER
|
|
}
|
|
if movable {
|
|
s.SessionKey[handle] = &SymKey{
|
|
keyType: tpe,
|
|
key: key,
|
|
}
|
|
} else {
|
|
s.SessionKey[handle] = &SymKey{
|
|
keyType: tpe,
|
|
key: append([]byte{}, key...), // make a new one
|
|
}
|
|
}
|
|
return handle, nil
|
|
}
|
|
|
|
// ImportSm2Agreement 将agreement存入s中
|
|
func (s *SdfNoLock) ImportSm2Agreement(agreement *Sm2Agreement) (handle Handle, err error) {
|
|
if s.Sm2Agreement == nil {
|
|
s.Sm2Agreement = make(map[Handle]*Sm2Agreement)
|
|
}
|
|
handle = minHandle
|
|
var ok bool
|
|
for handle < maxHandle {
|
|
if _, ok = s.Sm2Agreement[handle]; !ok {
|
|
break
|
|
}
|
|
handle++
|
|
}
|
|
|
|
s.Sm2Agreement[handle] = agreement
|
|
return handle, nil
|
|
}
|
|
|
|
func (s *SdfNoLock) reader() io.Reader {
|
|
if s.rand == nil {
|
|
s.rand = reader
|
|
}
|
|
return s.rand
|
|
}
|
|
|
|
func (s *SdfNoLock) getSm2KeyWith(tpe KeyType, index uint32) (*sm2.PrivateKey, bool) {
|
|
if s.Sm2Key == nil {
|
|
return nil, false
|
|
}
|
|
sm2Key, ok := s.Sm2Key[index]
|
|
if !ok {
|
|
return nil, ok
|
|
}
|
|
switch tpe {
|
|
case KeyTypeSm2Sign:
|
|
if sm2Key.signKey != nil {
|
|
return sm2Key.signKey, true
|
|
}
|
|
case KeyTypeSm2Enc:
|
|
if sm2Key.encKey != nil {
|
|
return sm2Key.encKey, true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
func (s *SdfNoLock) getKEKWith(index uint32) ([]byte, bool) {
|
|
if s.SymKey == nil {
|
|
return nil, false
|
|
}
|
|
key, ok := s.SymKey[index]
|
|
return key.key, ok
|
|
}
|
|
|
|
func (s *SdfNoLock) getSessionKeyWith(handle Handle) ([]byte, bool) {
|
|
if s.SessionKey == nil {
|
|
return nil, false
|
|
}
|
|
|
|
key, ok := s.SessionKey[handle]
|
|
return key.key, ok
|
|
}
|
|
|
|
// //////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Implements of Sdfable functions
|
|
//
|
|
// /////////////////////////////////////////////////////////////////////////
|
|
func (s *SdfNoLock) SDF_OpenSession() error {
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_CloseSession() error {
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GetDeviceInfo() (*DeviceInfo, error) {
|
|
return devInfo, nil
|
|
}
|
|
|
|
// To be simple, no password
|
|
func (s *SdfNoLock) SDF_GetPrivateKeyAccessRight(keyIndex uint32, password []byte) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ReleasePrivateKeyAccessRight(keyIndex uint32) error {
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateRandom(buffer []byte) (n uint32, err error) {
|
|
if uint32(len(buffer)) > devInfo.BufferSize {
|
|
return 0, common.SDR_INARGERR
|
|
}
|
|
m, err := io.ReadAtLeast(s.reader(), buffer, int(len(buffer)))
|
|
return uint32(m), err
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExportSignPublicKey_RSA(uiKeyIndex uint32) (*rsa.PublicKey, error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExportEncPublicKey_RSA(uiKeyIndex uint32) (*rsa.PublicKey, error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyPair_RSA(uiKeyBits uint32) (*rsa.PublicKey, *rsa.PrivateKey, error) {
|
|
return nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyWithIPK_RSA(uiIPKIndex uint32, uiKeyBits uint32) (pucKey []byte, phKeyHandle interface{}, err error) {
|
|
return nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyWithEPK_RSA(uiKeyBits uint32, pucPublicKey *rsa.PublicKey) (Key []byte, phKeyHandle interface{}, err error) {
|
|
return nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ImportKeyWithISK_RSA(uiISKIndex uint32, pucKey []byte) (phKeyHandle interface{}, err error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExchangeDigitEnvelopeBaseOnRSA(uiKeyIndex uint32, pucPublicKey *rsa.PublicKey, pucDEInput []byte) (pucDEOutput []byte, err error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_DecryptPublicKeyOperation_RSA(uiKeyIndex uint32, pucDataInput []byte) (pucDataOutput []byte, err error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
func (s *SdfNoLock) SDF_ExportSignPublicKey_ECC(keyIndex uint32) (*sm2.PublicKey, error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Sign, keyIndex)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
return &sk.PublicKey, nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExportEncPublicKey_ECC(keyIndex uint32) (*sm2.PublicKey, error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, keyIndex)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
return &sk.PublicKey, nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyPair_ECC(algID, keyBits uint32) (*sm2.PublicKey, *sm2.PrivateKey, error) {
|
|
// we do not check the params
|
|
sk, err := sm2.GenerateKey(sm2.Curve(), s.reader())
|
|
if err != nil {
|
|
return nil, nil, common.SDR_RANDERR
|
|
}
|
|
return &sk.PublicKey, sk, nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyWithIPK_ECC(uiIPKIndex uint32, uiKeyBits uint32) (pucKey *sm2.Cipher, phKeyHandle interface{}, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, uiIPKIndex)
|
|
if !ok {
|
|
return nil, nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
return s.SDF_GenerateKeyWithEPK_ECC(uiKeyBits, identifier.SGDSM23, &sk.PublicKey)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyWithEPK_ECC(uiKeyBits uint32, uiAlgID uint32, pucPublicKey *sm2.PublicKey) (pucKey *sm2.Cipher, phKeyHandle interface{}, err error) {
|
|
keyBytes := (uiKeyBits + 7) / 8
|
|
buf := make([]byte, sm2.ByteSize())
|
|
if n, err := s.SDF_GenerateRandom(buf); err != nil || n != uint32(len(buf)) {
|
|
return nil, nil, common.SDR_RANDERR
|
|
}
|
|
key := make([]byte, keyBytes)
|
|
if n, err := s.SDF_GenerateRandom(key); err != nil || n != keyBytes {
|
|
return nil, nil, common.SDR_RANDERR
|
|
}
|
|
|
|
handle, err := s.ImportSessionKey(KeyTypeBlock, key, true)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
pucKey, err = sm2.Encrypt(pucPublicKey, key, buf[keyBytes:])
|
|
if err != nil {
|
|
delete(s.SessionKey, handle)
|
|
if !pucPublicKey.IsValid() {
|
|
return nil, nil, common.SDR_KEYERR
|
|
}
|
|
return nil, nil, common.SDR_INARGERR
|
|
}
|
|
|
|
return pucKey, handle, nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ImportKeyWithISK_ECC(uiISKIndex uint32, pucKey *sm2.Cipher) (phKeyHandle interface{}, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, uiISKIndex)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
key, err := s.SDF_ExternalDecrypt_ECC(identifier.SGDSM23, sk, pucKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.ImportSessionKey(KeyTypeBlock, key, true)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateAgreementDataWithECC(uiISKIndex uint32, uiKeyBits uint32, pucSponsorID []byte) (pucSponsorPublicKey *sm2.PublicKey, pucSponsorTmpPublicKey *sm2.PublicKey, phAgreementHandle interface{}, err error) {
|
|
return s.SDFEXT_GenerateAgreementDataWithECC(uiISKIndex, uiKeyBits, pucSponsorID)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyWithECC(pucResponseID []byte, pucResponsePublicKey *sm2.PublicKey, pucResponseTmpPublicKey *sm2.PublicKey, hAgreementHandle interface{}) (phKeyHandle interface{}, err error) {
|
|
key, err := s.SDFEXT_GenerateKeyWithECC(pucResponseID, pucResponsePublicKey, pucResponseTmpPublicKey, hAgreementHandle)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.ImportSessionKey(KeyTypeBlock, key, true)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateAgreementDataAndKeyWithECC(uiISKIndex uint32, uiKeyBits uint32, pucResponseID []byte, pucSponsorID []byte, pucSponsorPublicKey, pucSponsorTmpPublicKey *sm2.PublicKey) (pucResponsePublicKey *sm2.PublicKey, pucResponseTmpPublicKey *sm2.PublicKey, phKeyHandle interface{}, err error) {
|
|
return s.SDFEXT_GenerateAgreementDataAndKeyWithECC(uiISKIndex, uiKeyBits, pucResponseID, pucSponsorID, pucSponsorPublicKey, pucSponsorTmpPublicKey)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExchangeDigitEnvelopeBaseOnECC(uiKeyIndex uint32, uiAlgID uint32, pucPublicKey *sm2.PublicKey, pucEncDataIn *sm2.Cipher) (pucEncDataOut *sm2.Cipher, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, uiKeyIndex)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
data, err := sm2.Decrypt(sk, pucEncDataIn)
|
|
if err != nil {
|
|
if !pucPublicKey.IsValid() {
|
|
// pucPublicKey 错误
|
|
return nil, common.SDR_KEYERR
|
|
}
|
|
return nil, common.SDR_ENCDATAERR
|
|
}
|
|
|
|
rand := make([]byte, sm2.ByteSize())
|
|
if n, err := s.SDF_GenerateRandom(rand); err != nil || n < uint32(len(rand)) {
|
|
return nil, common.SDR_RANDERR
|
|
}
|
|
return sm2.Encrypt(pucPublicKey, data, rand)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeyWithKEK(uiKeyBits uint32, uiAlgID uint32, uiKEKIndex uint32) (pucKey []byte, phKeyHandle interface{}, err error) {
|
|
kek, ok := s.getKEKWith(uiKEKIndex)
|
|
if !ok {
|
|
return nil, nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
keyBytes := (uiKeyBits + 7) / 8
|
|
|
|
// 必须是16的倍数。要用SM4ECB加密
|
|
if keyBytes&0xf != 0 {
|
|
return nil, nil, common.SDR_INARGERR
|
|
}
|
|
|
|
key := make([]byte, keyBytes)
|
|
|
|
if n, err := s.SDF_GenerateRandom(key); err != nil || n != keyBytes {
|
|
return nil, nil, common.SDR_RANDERR
|
|
}
|
|
|
|
handle, err := s.ImportSessionKey(KeyTypeBlock, key, true)
|
|
pucKey = make([]byte, len(key))
|
|
|
|
// kek should always be 16 bytes. so no err will occure here.
|
|
switch uiAlgID {
|
|
case identifier.SGDSM1ECB:
|
|
_, _ = sm1.EncryptECB(pucKey, kek, key)
|
|
case identifier.SGDSM4ECB:
|
|
_, _ = sm4.EncryptECB(pucKey, kek, key)
|
|
default:
|
|
// 算法id错误
|
|
return nil, nil, common.SDR_ALGNOTSUPPORT
|
|
}
|
|
|
|
return pucKey, handle, nil
|
|
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ImportKeyWithKEK(uiAlgID uint32, uiKEKIndex uint32, pucKey []byte) (phKeyHandle interface{}, err error) {
|
|
kek, ok := s.getKEKWith(uiKEKIndex)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
if len(pucKey)&0xf != 0 {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
|
|
key := make([]byte, len(pucKey))
|
|
// kek should always be 16 bytes. so no err will occure here.
|
|
switch uiAlgID {
|
|
case identifier.SGDSM1ECB:
|
|
_, _ = sm1.DecryptECB(key, kek, pucKey)
|
|
case identifier.SGDSM4ECB:
|
|
_, _ = sm4.DecryptECB(key, kek, pucKey)
|
|
default:
|
|
// 算法id错误
|
|
return nil, common.SDR_ALGNOTSUPPORT
|
|
}
|
|
|
|
return s.ImportSessionKey(KeyTypeBlock, key, true)
|
|
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithIKE(pucSponsorNonce []byte, pucResponseNonce []byte, pucSponsorCookie []byte, pucResponseCookie []byte, uiPrfAlgID uint32, uiKeyBitsD, uiKeyBitsA, uiKeyBitsE uint32) (phKeyHandleD interface{}, phKeyHandleA interface{}, phKeyHandleE interface{}, err error) {
|
|
return nil, nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithEPK_IKE(pucSponsorNonce []byte, pucResponseNonce []byte, pucSponsorCookie []byte, pucResponseCookie []byte, uiPrfAlgID, uiEccAlgID uint32, pucPublicKey sm2.PublicKey, uiKeyBitsD, uiKeyBitsA, uiKeyBitsE uint32) (pucKeyD *sm2.Cipher, phKeyHandleD interface{}, pucKeyA *sm2.Cipher, phKeyHandleA interface{}, pucKeyE *sm2.Cipher, phKeyHandleE interface{}, err error) {
|
|
return nil, nil, nil, nil, nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithIPSEC(pucProtocolID []byte, pucSpi []byte, pucSponsorNonce []byte, pucResponseNonce []byte, hKeyHandle interface{}, uiPrfAlgID uint32, uiKeyBitsEnc, uiKeyBitsMac uint32) (phKeyHandleEnc interface{}, phKeyHandleMac interface{}, err error) {
|
|
return nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithEPK_IPSEC(pucProtocolID []byte, pucSpi []byte, pucSponsorNonce []byte, pucResponseNonce []byte, hKeyHandle interface{}, uiPrfAlgID uint32, uiEccAlgID uint32, pucPublicKey *sm2.PublicKey, uiKeyBitsEnc, uiKeyBitsMac uint32) (pucKeyEnc *sm2.Cipher, phKeyHandleEnc interface{}, pucKeyMac *sm2.Cipher, phKeyHandleMac interface{}, err error) {
|
|
return nil, nil, nil, nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithSSL(pucKeyPremaster, pucClientRandom, pucServerRandom []byte, uiPrfAlgID uint32, uiKeyBitsClientMac, uiKeyBitsServerMac, uiKeyBitsClientEnc, uiKeyBitsServerEnc uint32) (phKeyHandleClientMac, phKeyHandleServerMac, phKeyHandleClientEnc, phKeyHandleServerEnc interface{}, pucClientIV, pucServerIV []byte, err error) {
|
|
|
|
clientMAC, serverMAC, clientKey, serverKey, pucClientIV, pucServerIV := KeysFromPreMasterSecretTLCP(pucKeyPremaster, pucClientRandom, pucServerRandom, sm4.BlockSize, sm4.BlockSize, sm4.BlockSize)
|
|
|
|
phKeyHandleClientMac, err = s.ImportSessionKey(KeyTypeBlock, clientMAC, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
phKeyHandleServerMac, err = s.ImportSessionKey(KeyTypeBlock, serverMAC, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
phKeyHandleClientEnc, err = s.ImportSessionKey(KeyTypeBlock, clientKey, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
phKeyHandleServerEnc, err = s.ImportSessionKey(KeyTypeBlock, serverKey, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithEPK_SSL(pucKeyPremaster, pucClientRandom, pucServerRandom []byte, uiPrfAlgID uint32, uiEccAlgID uint32, pucPublicKey *sm2.PublicKey, uiKeyBitsClientMac, uiKeyBitsServerMac, uiKeyBitsClientEnc, uiKeyBitsServerEnc uint32) (pucKeyClientMac *sm2.Cipher, phKeyHandleClientMac interface{}, pucKeyServerMac *sm2.Cipher, phKeyHandleServerMac interface{}, pucKeyClientEnc *sm2.Cipher, phKeyHandleClientEnc interface{}, pucKeyServerEnc *sm2.Cipher, phKeyHandleServerEnc interface{}, pucClientIV, pucServerIV []byte, err error) {
|
|
|
|
masterSecret := masterFromPreMasterSecretTLCP(pucKeyPremaster, pucClientRandom, pucServerRandom)
|
|
clientMAC, serverMAC, clientKey, serverKey, pucClientIV, pucServerIV := keysFromMasterSecretTLCP(masterSecret, pucClientRandom, pucServerRandom, sm4.BlockSize, sm4.BlockSize, sm4.BlockSize)
|
|
|
|
rnd := make([]byte, sm2.ByteSize())
|
|
|
|
if n, err := s.reader().Read(rnd); err != nil || n < len(rnd) {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
pucKeyClientMac, err = sm2.Encrypt(pucPublicKey, clientMAC, rnd)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
phKeyHandleClientMac, err = s.ImportSessionKey(KeyTypeBlock, clientMAC, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
if n, err := s.reader().Read(rnd); err != nil || n < len(rnd) {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
pucKeyServerMac, err = sm2.Encrypt(pucPublicKey, serverMAC, rnd)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
phKeyHandleServerMac, err = s.ImportSessionKey(KeyTypeBlock, serverMAC, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
if n, err := s.reader().Read(rnd); err != nil || n < len(rnd) {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
pucKeyClientEnc, err = sm2.Encrypt(pucPublicKey, clientKey, rnd)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
phKeyHandleClientEnc, err = s.ImportSessionKey(KeyTypeBlock, clientKey, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
if n, err := s.reader().Read(rnd); err != nil || n < len(rnd) {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
pucKeyServerEnc, err = sm2.Encrypt(pucPublicKey, serverKey, rnd)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
phKeyHandleServerEnc, err = s.ImportSessionKey(KeyTypeBlock, serverKey, true)
|
|
if err != nil {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithECDHE_SSL(phKeyHandlePremaster interface{}, pucClientRandom, pucServerRandom []byte, uiPrfAlgID uint32, uiKeyBitsClientMac, uiKeyBitsServerMac, uiKeyBitsClientEnc, uiKeyBitsServerEnc uint32) (phKeyHandleClientMac, phKeyHandleServerMac, phKeyHandleClientEnc, phKeyHandleServerEnc interface{}, pucClientIV, pucServerIV []byte, err error) {
|
|
handle, ok := phKeyHandlePremaster.(Handle)
|
|
if !ok {
|
|
return nil, nil, nil, nil, nil, nil, common.SDR_INARGERR
|
|
}
|
|
preMasterSecret, ok := s.getSessionKeyWith(handle)
|
|
if !ok {
|
|
return nil, nil, nil, nil, nil, nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
return s.SDF_GenerateKeywithSSL(preMasterSecret, pucClientRandom, pucServerRandom, uiPrfAlgID, uiKeyBitsClientEnc, uiKeyBitsServerMac, uiKeyBitsClientEnc, uiKeyBitsServerEnc)
|
|
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_GenerateKeywithEPK_ECDHE_SSL(phKeyHandlePremaster interface{}, pucClientRandom, pucServerRandom []byte, uiPrfAlgID uint32, uiEccAlgID uint32, pucPublicKey *sm2.PublicKey, uiKeyBitsClientMac, uiKeyBitsServerMac, uiKeyBitsClientEnc, uiKeyBitsServerEnc uint32) (pucKeyClientMac *sm2.Cipher, phKeyHandleClientMac interface{}, pucKeyServerMac *sm2.Cipher, phKeyHandleServerMac interface{}, pucKeyClientEnc *sm2.Cipher, phKeyHandleClientEnc interface{}, pucKeyServerEnc *sm2.Cipher, phKeyHandleServerEnc interface{}, pucClientIV, pucServerIV []byte, err error) {
|
|
handle, ok := phKeyHandlePremaster.(Handle)
|
|
if !ok {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, common.SDR_INARGERR
|
|
}
|
|
preMasterSecret := [48]byte{1, 1}
|
|
|
|
preMasterSecretRandom, ok := s.getSessionKeyWith(handle)
|
|
if !ok {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
if len(preMasterSecretRandom) != 46 {
|
|
return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, common.SDR_KEYERR
|
|
}
|
|
copy(preMasterSecret[2:], preMasterSecretRandom)
|
|
return s.SDF_GenerateKeywithEPK_SSL(preMasterSecret[:], pucClientRandom, pucServerRandom, uiPrfAlgID, uiEccAlgID, pucPublicKey, uiKeyBitsClientEnc, uiKeyBitsServerMac, uiKeyBitsClientEnc, uiKeyBitsServerEnc)
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_DestroyKey(hKeyHandle interface{}) error {
|
|
handle, ok := hKeyHandle.(Handle)
|
|
if !ok {
|
|
return common.SDR_INARGERR
|
|
}
|
|
if key, ok := s.SessionKey[handle]; ok {
|
|
// 内存置0
|
|
for i := range key.key {
|
|
key.key[i] = 0
|
|
}
|
|
delete(s.SessionKey, handle)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 非对称算法运算类函数
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
func (s *SdfNoLock) SDF_ExternalPublicKeyOperation_RSA(pucPublicKey *rsa.PublicKey, pucDataInput []byte) (pucDataOutput []byte, err error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_InternalPublicKeyOperation_RSA(uiKeyIndex uint32, pucDataInput []byte) (pucDataOutput []byte, err error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_InternalPrivateKeyOperation_RSA(uiKeyIndex uint32, pucDataInput []byte) (pucDataOutput []byte, err error) {
|
|
return nil, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExternalSign_ECC(uiAlgID uint32, pucPrivateKey *sm2.PrivateKey, pucData []byte) (*sm2.Signature, error) {
|
|
if len(pucData) != sm3.Size {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
|
|
r, S, err := sm2.SignWithReader(s.reader(), pucPrivateKey, pucData)
|
|
return &sm2.Signature{R: r, S: S}, err
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExternalVerify_ECC(uiAlgID uint32,
|
|
pucPublicKey *sm2.PublicKey, pucDataInput []byte,
|
|
pucSignature *sm2.Signature) error {
|
|
if len(pucDataInput) != sm3.Size {
|
|
return common.SDR_INARGERR
|
|
}
|
|
if sm2.Verify(pucDataInput, pucPublicKey, pucSignature) {
|
|
return nil
|
|
} else {
|
|
return common.SDR_VERIFYERR
|
|
}
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_InternalSign_ECC(iskIndex uint32, data []byte) (signature *sm2.Signature, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Sign, iskIndex)
|
|
if !ok {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
|
|
r, S, err := sm2.SignWithReader(s.reader(), sk, data)
|
|
return &sm2.Signature{R: r, S: S}, err
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_InternalVerify_ECC(iskIndex uint32, data []byte, signature *sm2.Signature) error {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Sign, iskIndex)
|
|
if !ok {
|
|
return common.SDR_INARGERR
|
|
}
|
|
ok = sm2.Verify(data, &sk.PublicKey, signature)
|
|
if ok {
|
|
return nil
|
|
} else {
|
|
return common.SDR_SIGNERR
|
|
}
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ExternalEncrypt_ECC(
|
|
uiAlgID uint32,
|
|
pucPublicKey *sm2.PublicKey,
|
|
pucData []byte) (pucEncData *sm2.Cipher, err error) {
|
|
|
|
// omit the check of uiAlgID
|
|
buf := make([]byte, sm2.ByteSize())
|
|
if n, err := s.SDF_GenerateRandom(buf); err != nil || n < uint32(len(buf)) {
|
|
return nil, common.SDR_RANDERR
|
|
}
|
|
pucEncData, err = sm2.Encrypt(pucPublicKey, pucData, buf)
|
|
if err != nil {
|
|
if !pucPublicKey.IsValid() {
|
|
return nil, common.SDR_KEYERR
|
|
}
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
return
|
|
}
|
|
|
|
// 外部ECC私钥解密，GMT0018有，36322没有。
|
|
func (s *SdfNoLock) SDF_ExternalDecrypt_ECC(uiAlgID uint32, pucPrivateKey *sm2.PrivateKey, pucEncData *sm2.Cipher) (pucData []byte, err error) {
|
|
pucData, err = sm2.Decrypt(pucPrivateKey, pucEncData)
|
|
if err != nil {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_Encrypt(hKeyHandle interface{}, uiAlgID uint32, pucIV []byte, pucData []byte, pucEncData *[]byte) (err error) {
|
|
h, ok := hKeyHandle.(Handle)
|
|
if !ok {
|
|
return common.SDR_KEYERR
|
|
}
|
|
key, ok := s.getSessionKeyWith(h)
|
|
if !ok {
|
|
return common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
if len(pucData)&0xf != 0 {
|
|
return common.SDR_INARGERR
|
|
}
|
|
|
|
// expand pucEncData
|
|
for len(pucData) > len(*pucEncData) {
|
|
*pucEncData = append(*pucEncData, 0)
|
|
}
|
|
|
|
switch uiAlgID {
|
|
case identifier.SGDSM1ECB:
|
|
sm1.EncryptECB(*pucEncData, key, pucData)
|
|
|
|
case identifier.SGDSM1CBC:
|
|
if pucIV == nil || len(pucIV) < sm1.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm1.EncryptCBC(*pucEncData, pucIV, key, pucData)
|
|
|
|
case identifier.SGDSM1CFB:
|
|
if pucIV == nil || len(pucIV) < sm1.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm1.EncryptCFB(*pucEncData, pucIV, key, pucData)
|
|
|
|
case identifier.SGDSM1OFB:
|
|
if pucIV == nil || len(pucIV) < sm1.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm1.EncryptOFB(*pucEncData, pucIV, key, pucData)
|
|
|
|
case identifier.SGDSM4ECB:
|
|
sm4.EncryptECB(*pucEncData, key, pucData)
|
|
case identifier.SGDSM4CBC:
|
|
if pucIV == nil || len(pucIV) < sm4.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm4.EncryptCBC(*pucEncData, pucIV, key, pucData)
|
|
|
|
case identifier.SGDSM4CFB:
|
|
if pucIV == nil || len(pucIV) < sm4.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm4.EncryptCFB(*pucEncData, pucIV, key, pucData)
|
|
case identifier.SGDSM4OFB:
|
|
if pucIV == nil || len(pucIV) < sm4.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm4.EncryptOFB(*pucEncData, pucIV, key, pucData)
|
|
default:
|
|
return common.SDR_ALGMODNOTSUPPORT
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_Decrypt(hKeyHandle interface{}, uiAlgID uint32, pucIV []byte, pucEncData []byte, pucData *[]byte) (err error) {
|
|
h, ok := hKeyHandle.(Handle)
|
|
if !ok {
|
|
return common.SDR_KEYERR
|
|
}
|
|
key, ok := s.getSessionKeyWith(h)
|
|
if !ok {
|
|
return common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
if len(pucEncData)&0xf != 0 {
|
|
return common.SDR_INARGERR
|
|
}
|
|
|
|
// expand pucEncData
|
|
for len(pucEncData) > len(*pucData) {
|
|
*pucData = append(*pucData, 0)
|
|
}
|
|
|
|
switch uiAlgID {
|
|
case identifier.SGDSM1ECB:
|
|
sm1.DecryptECB(*pucData, key, pucEncData)
|
|
|
|
case identifier.SGDSM1CBC:
|
|
if pucIV == nil || len(pucIV) < sm1.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm1.DecryptCBC(*pucData, pucIV, key, pucEncData)
|
|
|
|
case identifier.SGDSM1CFB:
|
|
if pucIV == nil || len(pucIV) < sm1.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm1.DecryptCFB(*pucData, pucIV, key, pucEncData)
|
|
|
|
case identifier.SGDSM1OFB:
|
|
if pucIV == nil || len(pucIV) < sm1.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm1.DecryptOFB(*pucData, pucIV, key, pucEncData)
|
|
|
|
case identifier.SGDSM4ECB:
|
|
sm4.DecryptECB(*pucData, key, pucEncData)
|
|
case identifier.SGDSM4CBC:
|
|
if pucIV == nil || len(pucIV) < sm4.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm4.DecryptCBC(*pucData, pucIV, key, pucEncData)
|
|
|
|
case identifier.SGDSM4CFB:
|
|
if pucIV == nil || len(pucIV) < sm4.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm4.DecryptCFB(*pucData, pucIV, key, pucEncData)
|
|
case identifier.SGDSM4OFB:
|
|
if pucIV == nil || len(pucIV) < sm4.BlockSize {
|
|
return common.SDR_INARGERR
|
|
}
|
|
sm4.DecryptOFB(*pucData, pucIV, key, pucEncData)
|
|
default:
|
|
return common.SDR_ALGMODNOTSUPPORT
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_CalculateMAC(hKeyHandle interface{}, uiAlgID uint32, pucIV []byte, pucData []byte) (pucMAC []byte, err error) {
|
|
h, ok := hKeyHandle.(Handle)
|
|
if !ok {
|
|
return nil, common.SDR_KEYERR
|
|
}
|
|
key, ok := s.getSessionKeyWith(h)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
if uiAlgID == identifier.SGDSM3 {
|
|
// SM3-HMAC
|
|
h, err := mac.NewMac(mac.HMAC_SM3, key)
|
|
if err != nil {
|
|
return nil, common.SDR_KEYERR
|
|
}
|
|
pucMAC, err := h.ComputeMAC(pucData)
|
|
if err != nil {
|
|
return nil, common.SDR_KEYERR
|
|
}
|
|
return pucMAC, err
|
|
} else {
|
|
// CBC-MAC
|
|
var block cipher.Block
|
|
switch uiAlgID {
|
|
case identifier.SGDSM1Mac:
|
|
block, err = sm1.NewCipher(key)
|
|
case identifier.SGDSM4Mac:
|
|
block, err = sm4.NewCipher(key)
|
|
default:
|
|
return nil, common.SDR_ALGNOTSUPPORT
|
|
}
|
|
if err != nil {
|
|
return nil, common.SDR_KEYERR
|
|
}
|
|
|
|
pucMAC = make([]byte, block.BlockSize())
|
|
err := cbcmac.CalculateMAC(pucData, pucIV, block, pucMAC)
|
|
if err != nil {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
return pucMAC, nil
|
|
}
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_HashInit(uiAlgID uint32, pucPublicKey *sm2.PublicKey, pucID []byte) (err error) {
|
|
if len(pucID) > 0 && pucPublicKey != nil {
|
|
z := sm2.PreComputeWithIdAndPubkey(pucID, pucPublicKey)
|
|
s.hash = sm3.New()
|
|
s.hash.Write(z)
|
|
} else {
|
|
s.hash = sm3.New()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_HashUpdate(pucData []byte) (err error) {
|
|
if s.hash == nil {
|
|
return common.SDR_STEPERR
|
|
}
|
|
s.hash.Write(pucData)
|
|
return nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_HashFinal() (pucHash []byte, err error) {
|
|
if s.hash == nil {
|
|
return nil, common.SDR_STEPERR
|
|
}
|
|
pucHash = s.hash.Sum(nil)
|
|
s.hash = nil
|
|
return pucHash, nil
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_CreateFile(pucFileName string, uiFileSize uint32) error {
|
|
return common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_ReadFile(pucFileName string, uiOffset uint32, pucBuffer []byte) (n uint32, err error) {
|
|
return 0, common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_WriteFile(pucFileName string, uiOffset uint32, pucBuffer []byte) error {
|
|
return common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
func (s *SdfNoLock) SDF_DeleteFile(pucFileName string) error {
|
|
return common.SDR_NOTSUPPORT
|
|
}
|
|
|
|
// 内部sm2私钥解密
|
|
func (s *SdfNoLock) SDFEXT_InternalDecryptECC(uiKeyIndex uint32, pucEncData *sm2.Cipher) (pucData []byte, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, uiKeyIndex)
|
|
if !ok {
|
|
return nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
pucData, err = sm2.Decrypt(sk, pucEncData)
|
|
if err != nil {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
return pucData, nil
|
|
}
|
|
|
|
// 6.3.14 生成密钥协商参数并输出-这个与标准接口一致
|
|
// 描述： 使用ECC密钥协商算法, 为计算会话密钥而产生协商参数, 同时返回指定索引位置的ECC公钥、临时ECC密钥对的公钥及协商句柄。
|
|
func (s *SdfNoLock) SDFEXT_GenerateAgreementDataWithECC(uiISKIndex uint32, uiKeyBits uint32, pucSponsorID []byte) (pucSponsorPublicKey *sm2.PublicKey, pucSponsorTmpPublicKey *sm2.PublicKey, phAgreementHandle interface{}, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, uiISKIndex)
|
|
if !ok {
|
|
return nil, nil, nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
param, err := sm2.GenerateAgreementData(s.reader())
|
|
if err != nil {
|
|
return nil, nil, nil, common.SDR_RANDERR
|
|
}
|
|
|
|
handle, err := s.ImportSm2Agreement(&Sm2Agreement{
|
|
param: param,
|
|
sk: sk,
|
|
keyBits: int(uiKeyBits),
|
|
sponsorID: append([]byte{}, pucSponsorID...), // make a new one
|
|
})
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
return &sk.PublicKey, ¶m.PrivateKey.PublicKey, handle, nil
|
|
}
|
|
|
|
// 6.3.15 计算会话密钥变体
|
|
// 描述： 使用ECC密钥协商算法, 使用自身协商句柄和响应方的协商参数计算会话密钥, 同时返回会话密钥。
|
|
// 备注： 协商的发起方获得响应方的协商参数后调用本函数, 计算会话密钥。使用SM2算法计算会话密钥的过程见GM/T 0009。
|
|
func (s *SdfNoLock) SDFEXT_GenerateKeyWithECC(pucResponseID []byte, pucResponsePublicKey *sm2.PublicKey, pucResponseTmpPublicKey *sm2.PublicKey, hAgreementHandle interface{}) (agreementKey []byte, err error) {
|
|
if s.Sm2Agreement == nil {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
handle, ok := hAgreementHandle.(Handle)
|
|
if !ok {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
agreement, ok := s.Sm2Agreement[handle]
|
|
if !ok {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
|
|
key, err := sm2.GenerateSharedKey(agreement.param, agreement.sponsorID, agreement.sk, pucResponseID, pucResponsePublicKey, pucResponseTmpPublicKey, (agreement.keyBits+7)/8)
|
|
|
|
if err != nil {
|
|
return nil, common.SDR_INARGERR
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
// 6.3.16 产生协商数据并计算会话密钥
|
|
// 描述： 使用ECC密钥协商算法, 产生协商参数并计算会话密钥, 同时返回产生的协商参数和密钥。
|
|
func (s *SdfNoLock) SDFEXT_GenerateAgreementDataAndKeyWithECC(uiISKIndex uint32, uiKeyBits uint32, pucResponseID []byte, pucSponsorID []byte, pucSponsorPublicKey, pucSponsorTmpPublicKey *sm2.PublicKey) (pucResponsePublicKey *sm2.PublicKey, pucResponseTmpPublicKey *sm2.PublicKey, agreementKey []byte, err error) {
|
|
sk, ok := s.getSm2KeyWith(KeyTypeSm2Enc, uiISKIndex)
|
|
if !ok {
|
|
return nil, nil, nil, common.SDR_KEYNOTEXIST
|
|
}
|
|
|
|
key, param, err := sm2.GenerateAgreementDataAndKey(pucResponseID, sk, pucSponsorID, pucSponsorPublicKey, pucSponsorTmpPublicKey, int((uiKeyBits+7)/8), s.reader())
|
|
|
|
if err != nil {
|
|
return nil, nil, nil, common.SDR_UNKNOWERR
|
|
}
|
|
|
|
return &sk.PublicKey, ¶m.PrivateKey.PublicKey, key, nil
|
|
}
|