From 3a139cc77142a20260040f44ddfe7626b532aff6 Mon Sep 17 00:00:00 2001 From: Prabhat Ranjan Date: Mon, 15 Jun 2020 11:49:40 +0530 Subject: [PATCH 1/5] added mutual tls support for on prem in test --- golang/README.md | 20 +++++---------- golang/examples/credential.yaml | 9 +++++++ golang/examples/server_test.go | 43 ++++++++++++++++++++++++--------- 3 files changed, 47 insertions(+), 25 deletions(-) create mode 100644 golang/examples/credential.yaml diff --git a/golang/README.md b/golang/README.md index 8f0b066..7a2b829 100644 --- a/golang/README.md +++ b/golang/README.md @@ -1,22 +1,14 @@ # Overview 1. [Install Golang](https://golang.org/doc/install) and ensure that your cloned repository is in your GOPATH. -2. Update the following information in the [examples/server_test.go](examples/server_test.go#L20) file. +2. Update the following information in the [examples/credential.yaml](examples/credential.yaml) file. - *NOTE: This information can obtained by logging in to your IBM Cloud account and viewing your Hyper Protect Crypto Serverices (HPCS) instance and IAM information. See the [GREP11 API documentation](https://test.cloud.ibm.com/docs/services/hs-crypto?topic=hs-crypto-grep11-api-ref) for more information about GREP11*. - ```Golang - // The following IBM Cloud items need to be changed prior to running the sample program - const address = ":" - - var callOpts = []grpc.DialOption{ - grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})), - grpc.WithPerRPCCredentials(&util.IAMPerRPCCredentials{ - APIKey: "", - Endpoint: "", - Instance: "", - }), - } + ``` + url: "" + cert_path: "" + key_path: "" + cacert_path: "ca certificate path" ``` 3. `cd $GOPATH/src/github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/examples` diff --git a/golang/examples/credential.yaml b/golang/examples/credential.yaml new file mode 100644 index 0000000..85d3706 --- /dev/null +++ b/golang/examples/credential.yaml @@ -0,0 +1,9 @@ +# url: "zbcsora.hursley.ibm.com:9876" +# cert_path: "/Users/prabhat/hpvs_config/crypto/certs/client.pem" +# key_path: "/Users/prabhat/hpvs_config/crypto/certs/client-key.pem" +# cacert_path: "/Users/prabhat/hpvs_config/crypto/certs/ca.pem" + +url: "" +cert_path: "" +key_path: "" +cacert_path: "ca certificate path" diff --git a/golang/examples/server_test.go b/golang/examples/server_test.go index 706acb6..d196d96 100644 --- a/golang/examples/server_test.go +++ b/golang/examples/server_test.go @@ -1,6 +1,5 @@ /* Copyright IBM Corp. All Rights Reserved. - SPDX-License-Identifier: Apache-2.0 */ @@ -14,6 +13,10 @@ import ( "encoding/asn1" "fmt" "reflect" + "crypto/x509" + "io/ioutil" + + yaml "gopkg.in/yaml.v2" "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" @@ -23,22 +26,40 @@ import ( "google.golang.org/grpc/credentials" ) -// The following IBM Cloud items need to be changed prior to running the sample program -const address = ":" +// The following credential items need to be changed prior to running the sample program + + +var yamlConfig, _ = ioutil.ReadFile("credential.yaml") + +var m = make(map[interface{}]interface{}) +var err = yaml.Unmarshal([]byte(yamlConfig), &m) + +var address = m["url"].(string) +var ( + crt = m["cert_path"].(string) + key = m["key_path"].(string) + ca = m["cacert_path"].(string) +) + +var certificate, _ = tls.LoadX509KeyPair(crt, key) +var certPool = x509.NewCertPool() +var cacert, _ = ioutil.ReadFile(ca) +var a = certPool.AppendCertsFromPEM(cacert) + +var creds = credentials.NewTLS(&tls.Config{ + ServerName: address, // NOTE: this is required! + Certificates: []tls.Certificate{certificate}, + RootCAs: certPool, +}) var callOpts = []grpc.DialOption{ - grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})), - grpc.WithPerRPCCredentials(&util.IAMPerRPCCredentials{ - APIKey: "", - Endpoint: "", - Instance: "", - }), + grpc.WithTransportCredentials(creds), } // Example_getMechanismInfo retrieves a mechanism list and retrieves detailed information for the CKM_RSA_PKCS mechanism // Flow: connect, get mechanism list, get mechanism info func Example_getMechanismInfo() { - conn, err := grpc.Dial(address, callOpts...) + conn, err := grpc.Dial(address, grpc.WithTransportCredentials(creds)) if err != nil { panic(fmt.Errorf("Could not connect to server: %s", err)) } @@ -757,4 +778,4 @@ func Example_deriveKey() { // Generated Alice EC key pair // Generated Bob EC key pair // Alice and Bob get the same derived key -} +} \ No newline at end of file From 1ef116b12c619fb896da6cbd1e59503524557a54 Mon Sep 17 00:00:00 2001 From: Prabhat Ranjan Date: Mon, 15 Jun 2020 12:09:02 +0530 Subject: [PATCH 2/5] Changed author --- golang/examples/server_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/golang/examples/server_test.go b/golang/examples/server_test.go index d196d96..7f427e2 100644 --- a/golang/examples/server_test.go +++ b/golang/examples/server_test.go @@ -26,7 +26,7 @@ import ( "google.golang.org/grpc/credentials" ) -// The following credential items need to be changed prior to running the sample program +// The following credential items need to be changed prior to running the sample program. var yamlConfig, _ = ioutil.ReadFile("credential.yaml") From 9eab5215e9cddc4748243385671ea126b7e8541d Mon Sep 17 00:00:00 2001 From: Prabhat Ranjan Date: Mon, 28 Sep 2020 14:10:49 +0530 Subject: [PATCH 3/5] Added test case for ed25519 --- golang/ep11/header_consts.go | 3 + golang/examples/ed25519_test.go | 702 ++++++++++++++++++++++++++++++++ golang/mock/mock.go | 1 + golang/util/signer.go | 1 + golang/util/util.go | 2 + 5 files changed, 709 insertions(+) create mode 100644 golang/examples/ed25519_test.go diff --git a/golang/ep11/header_consts.go b/golang/ep11/header_consts.go index 58b2753..c7cf68c 100644 --- a/golang/ep11/header_consts.go +++ b/golang/ep11/header_consts.go @@ -593,6 +593,8 @@ const ( CKM_IBM_EPX Mechanism = CKM_VENDOR_DEFINED + 0x61100000 CKM_IBM_EPX_WPRM Mechanism = CKM_VENDOR_DEFINED + 0x61110000 + CKM_IBM_ED25519_SHA512 Mechanism = CKM_VENDOR_DEFINED + 0x1001c + CKF_DONT_BLOCK MechanismInfoFlag = 0x00000001 CKF_HW MechanismInfoFlag = 0x00000001 CKF_LIBRARY_CANT_CREATE_OS_THREADS MechanismInfoFlag = 0x00000001 @@ -2668,3 +2670,4 @@ func (c Return) String() string { func (c Return) Error() string { return c.String() } + diff --git a/golang/examples/ed25519_test.go b/golang/examples/ed25519_test.go new file mode 100644 index 0000000..9019770 --- /dev/null +++ b/golang/examples/ed25519_test.go @@ -0,0 +1,702 @@ +package examples + +import ( + "context" + "crypto/sha256" + "encoding/asn1" + "fmt" + "testing" + "crypto/tls" + "crypto/x509" + "io/ioutil" + yaml "gopkg.in/yaml.v2" + + "google.golang.org/grpc/credentials" + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" + pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/util" + "github.com/stretchr/testify/assert" + grpc "google.golang.org/grpc" +) + + +var yamlConfig, _ = ioutil.ReadFile("credential.yaml") + +var m = make(map[interface{}]interface{}) +var err = yaml.Unmarshal([]byte(yamlConfig), &m) + +var address = m["url"].(string) +var ( + crt = m["cert_path"].(string) + key = m["key_path"].(string) + ca = m["cacert_path"].(string) +) + +var certificate, _ = tls.LoadX509KeyPair(crt, key) +var certPool = x509.NewCertPool() +var cacert, _ = ioutil.ReadFile(ca) +var a = certPool.AppendCertsFromPEM(cacert) + +var creds = credentials.NewTLS(&tls.Config{ + ServerName: address, // NOTE: this is required! + Certificates: []tls.Certificate{certificate}, + RootCAs: certPool, +}) + +var callOpts = []grpc.DialOption{ + grpc.WithTransportCredentials(creds), +} + +// testingX is an interface wrapper around golang type *testing.T and *testing.B +type testingX interface { + Errorf(format string, args ...interface{}) + Logf(format string, args ...interface{}) +} + +func TestED25519NewMechanism(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + var newCKM map[string]ep11.Mechanism + newCKM = map[string]ep11.Mechanism{ + // Add more mechanisms here + "CKM_IBM_ED25519_SHA512": ep11.CKM_IBM_ED25519_SHA512, + } + + mechanismListRequest := &pb.GetMechanismListRequest{} + mechanismListResponse, err := cryptoClient.GetMechanismList(context.Background(), mechanismListRequest) + if err != nil { + t.Errorf("Get mechanism list error: %s", err) + } + for name, value := range newCKM { + ok := false + for _, v := range mechanismListResponse.Mechs { + if value == v { + ok = true + break + } + } + + if ok { + t.Logf("Testing GetMechanismList(), Checking [%s]: OK", name) + } else { + t.Errorf("Testing GetMechanismList(), Checking [%s]: FAILED", name) + } + } + + for name, value := range newCKM { + mechanismInfoRequest := &pb.GetMechanismInfoRequest{ + Mech: value, + } + _, err = cryptoClient.GetMechanismInfo(context.Background(), mechanismInfoRequest) + if err != nil { + t.Errorf("Testing GetMechanismInfo(), Checking [%s]: FAILED", name) + } else { + t.Logf("Testing GetMechanismInfo(), Checking [%s]: OK", name) + } + } +} + +func TestED25519SignVerify(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponse, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signature, err := ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.NoError(t, err) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + assert.NoError(t, err) +} + +func TestED25519SignVerifyMulti(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponse, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signature, err := ed25519KeySignMulti(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.Contains(t, err.Error(), "SignUpdate error") + + err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + assert.Contains(t, err.Error(), "VerifyUpdate error") +} + +func TestED25519SignVerifySingle(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponse, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.NoError(t, err) + + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + assert.NoError(t, err) +} + +func ed25519KeyGenerate(x testingX, cryptoClient pb.CryptoClient) (*pb.GenerateKeyPairResponse, error) { + ecParameters, err := asn1.Marshal(util.OIDNamedCurveED25519) + if err != nil { + return nil, fmt.Errorf("Unable to encode parameter OID: %s", err) + } + + publicKeyECTemplate := util.NewAttributeMap( + util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), + util.NewAttribute(ep11.CKA_VERIFY, true), + util.NewAttribute(ep11.CKA_EXTRACTABLE, false), + ) + privateKeyECTemplate := util.NewAttributeMap( + util.NewAttribute(ep11.CKA_SIGN, true), + util.NewAttribute(ep11.CKA_EXTRACTABLE, false), + ) + generateECKeypairRequest := &pb.GenerateKeyPairRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, + PubKeyTemplate: publicKeyECTemplate, + PrivKeyTemplate: privateKeyECTemplate, + } + generateKeyPairResponse, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) + if err != nil { + return nil, fmt.Errorf("GenerateKeyPair error: %s", err) + } + x.Logf("Testing GenerateKeyPair(), Generated ED25519 PKCS key pair") + + return generateKeyPairResponse, nil +} + +func ed25519KeySignSingle(x testingX, cryptoClient pb.CryptoClient, privKey []byte, signData []byte) (signature []byte, err error) { + signSingleRequest := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_IBM_ED25519_SHA512}, + PrivKey: privKey, + Data: signData, + } + signSingleResponse, err := cryptoClient.SignSingle(context.Background(), signSingleRequest) + if err != nil { + return nil, fmt.Errorf("SignSingle error: %s", err) + } + x.Logf("Testing SignSingle(), Data signed by using SignSingle() with ED25519 PKCS key pair") + + return signSingleResponse.Signature, nil +} + +func ed25519KeyVerifySingle(x testingX, cryptoClient pb.CryptoClient, pubKey []byte, signData []byte, signature []byte) error { + verifySingleRequest := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_IBM_ED25519_SHA512}, + PubKey: pubKey, + Data: signData, + Signature: signature, + } + + _, err := cryptoClient.VerifySingle(context.Background(), verifySingleRequest) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + return fmt.Errorf("VerifySingle: Invalid signature") + } else { + return fmt.Errorf("VerifySingle error: [%d]: %s", ep11Status.Code, ep11Status.Detail) + } + } + x.Logf("Testing VerifySingle(), ED25519 signature verified by using VerifySingle()") + + return nil +} + +func ed25519KeySign(x testingX, cryptoClient pb.CryptoClient, privKey []byte, signData []byte) (signature []byte, err error) { + signInitRequest := &pb.SignInitRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_IBM_ED25519_SHA512}, + PrivKey: privKey, + } + signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) + if err != nil { + return nil, fmt.Errorf("SignInit error: %s", err) + } + signRequest := &pb.SignRequest{ + State: signInitResponse.State, + Data: signData, + } + SignResponse, err := cryptoClient.Sign(context.Background(), signRequest) + if err != nil { + return nil, fmt.Errorf("Sign error: %s", err) + } + x.Logf("Testing SignInit() and Sign(), Data signed by using SignInit() and Sign() with ED25519 PKCS key pair") + + return SignResponse.Signature, nil +} + +func ed25519KeySignMulti(x testingX, cryptoClient pb.CryptoClient, privKey []byte, signData []byte) (signature []byte, err error) { + signInitRequest := &pb.SignInitRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_IBM_ED25519_SHA512}, + PrivKey: privKey, + } + signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) + if err != nil { + return nil, fmt.Errorf("SignInit error: %s", err) + } + + signUpdateRequest := &pb.SignUpdateRequest{ + State: signInitResponse.State, + Data: signData, + } + signUpdateResponse, err := cryptoClient.SignUpdate(context.Background(), signUpdateRequest) + if err != nil { + return nil, fmt.Errorf("SignUpdate error: %s", err) + } + + signFinalRequest := &pb.SignFinalRequest{ + State: signUpdateResponse.State, + } + signFinalResponse, err := cryptoClient.SignFinal(context.Background(), signFinalRequest) + if err != nil { + return nil, fmt.Errorf("SignFinal error: %s", err) + } + + x.Logf("Testing SignInit(), SignUpdate() and SignFinal(), Data signed by using SignInit(), SignUpdate() and SignFinal() with ED25519 PKCS key pair") + + return signFinalResponse.Signature, nil +} + +func ed25519KeyVerify(x testingX, cryptoClient pb.CryptoClient, pubKey []byte, signData []byte, signature []byte) error { + verifyInitRequest := &pb.VerifyInitRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_IBM_ED25519_SHA512}, + PubKey: pubKey, + } + verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) + if err != nil { + return fmt.Errorf("VerifyInit error: %s", err) + } + verifyRequest := &pb.VerifyRequest{ + State: verifyInitResponse.State, + Data: signData, + Signature: signature, + } + _, err = cryptoClient.Verify(context.Background(), verifyRequest) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + return fmt.Errorf("Verify: Invalid signature") + } else { + return fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail) + } + } + x.Logf("Testing VerifyInit() and Verify(), ED25519 signature verified by using VerifyInit() and Verify()") + + return nil +} + +func ed25519KeyVerifyMulti(x testingX, cryptoClient pb.CryptoClient, pubKey []byte, signData []byte, signature []byte) error { + verifyInitRequest := &pb.VerifyInitRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_IBM_ED25519_SHA512}, + PubKey: pubKey, + } + verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) + if err != nil { + return fmt.Errorf("VerifyInit error: %s", err) + } + + verifyUpdateRequest := &pb.VerifyUpdateRequest{ + State: verifyInitResponse.State, + Data: signData, + } + verifyUpdateResponse, err := cryptoClient.VerifyUpdate(context.Background(), verifyUpdateRequest) + if err != nil { + return fmt.Errorf("VerifyUpdate error: %s", err) + } + + verifyFinalRequest := &pb.VerifyFinalRequest{ + State: verifyUpdateResponse.State, + Signature: signature, + } + _, err = cryptoClient.VerifyFinal(context.Background(), verifyFinalRequest) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + return fmt.Errorf("VerifyFinal: Invalid signature") + } else { + return fmt.Errorf("VerifyFinal error: [%d]: %s", ep11Status.Code, ep11Status.Detail) + } + } + + x.Logf("Testing VerifyInit(), VerifyUpdate() and VerifyFinal(), ED25519 signature verified by using VerifyInit(), VerifyUpdate() and VerifyFinal()") + return nil +} + +func TestED25519SignVerifyCrosstest(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponse, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.NoError(t, err) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + assert.NoError(t, err) + + signData = sha256.New().Sum([]byte("This data needs to be signed")) + signature, err = ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.NoError(t, err) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + assert.NoError(t, err) +} + +// For negative test +func ecdsaKeyGenerate(x testingX, cryptoClient pb.CryptoClient) (*pb.GenerateKeyPairResponse, error) { + ecParameters, err := asn1.Marshal(util.OIDNamedCurveP256) + if err != nil { + return nil, fmt.Errorf("Unable to encode parameter OID: %s", err) + } + + publicKeyECTemplate := util.NewAttributeMap( + util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), + util.NewAttribute(ep11.CKA_VERIFY, true), + util.NewAttribute(ep11.CKA_EXTRACTABLE, false), + ) + privateKeyECTemplate := util.NewAttributeMap( + util.NewAttribute(ep11.CKA_SIGN, true), + util.NewAttribute(ep11.CKA_EXTRACTABLE, false), + ) + generateECKeypairRequest := &pb.GenerateKeyPairRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, + PubKeyTemplate: publicKeyECTemplate, + PrivKeyTemplate: privateKeyECTemplate, + } + generateKeyPairResponse, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) + if err != nil { + return nil, fmt.Errorf("GenerateKeyPair error: %s", err) + } + x.Logf("Testing GenerateKeyPair(), Generated ECDSA PKCS key pair for negative test") + + return generateKeyPairResponse, nil +} + +// For negative test +func ecdsaKeySignSingle(x testingX, cryptoClient pb.CryptoClient, privKey []byte, signData []byte) (signature []byte, err error) { + signSingleRequest := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PrivKey: privKey, + Data: signData, + } + signSingleResponse, err := cryptoClient.SignSingle(context.Background(), signSingleRequest) + if err != nil { + return nil, fmt.Errorf("SignSingle error: %s", err) + } + x.Logf("Testing SignSingle(), Data signed by using SignSingle() with ECDSA PKCS key pair for negative test") + + return signSingleResponse.Signature, nil +} + +func TestED25519InvalidKeyType(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponseECDSA, err := ecdsaKeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + // Sign with the wrong key type + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + assert.Error(t, err) + assert.Contains(t, err.Error(), "SignSingle error") + assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") + + signature, err = ed25519KeySign(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + assert.Error(t, err) + assert.Contains(t, err.Error(), "SignInit error") + assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") + + signature, err = ed25519KeySignMulti(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + assert.Error(t, err) + assert.Contains(t, err.Error(), "SignInit error") + assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") + + // Verify with the wrong key type + generateKeyPairResponseED25519, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + signature, err = ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKey, signData) + assert.NoError(t, err) + + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseECDSA.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifySingle error") + + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseECDSA.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifyInit error") + assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") + + err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponseECDSA.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifyInit error") + assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") +} + +func TestED25519InvalidKeys(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + keysWrong := []string{"wrong key", "", "~!@#$%^&*()_+-=|}{[';\":?/,.<>", "wrong key longggggggggggggggggggggggggggggggggg"} + for _, keyWrong := range keysWrong { + // Sign with the wrong key type + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signature, err := ed25519KeySignSingle(t, cryptoClient, []byte(keyWrong), signData) + assert.Error(t, err) + assert.Contains(t, err.Error(), "SignSingle error") + + signature, err = ed25519KeySign(t, cryptoClient, []byte(keyWrong), signData) + assert.Error(t, err) + assert.Contains(t, err.Error(), "SignInit error") + + signature, err = ed25519KeySignMulti(t, cryptoClient, []byte(keyWrong), signData) + assert.Error(t, err) + assert.Contains(t, err.Error(), "SignInit error") + + // Verify with the wrong key + generateKeyPairResponseED25519, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + signature, err = ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKey, signData) + assert.NoError(t, err) + + err = ed25519KeyVerifySingle(t, cryptoClient, []byte(keyWrong), signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifySingle error") + + err = ed25519KeyVerify(t, cryptoClient, []byte(keyWrong), signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifyInit error") + + err = ed25519KeyVerifyMulti(t, cryptoClient, []byte(keyWrong), signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifyInit error") + } +} + +func TestED25519InvalidSignature(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + generateKeyPairResponseED25519, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKey, signData) + assert.NoError(t, err) + + signatureWrong := []([]byte){ + []byte(""), + []byte("Invalid signature..."), + []byte("~!@#$%^&*()_{}|:\"<>?/.,["), + signature[:32], + append(signature, signature...), + } + + for _, signature := range signatureWrong { + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "Verify error") + + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifySingle error") + } + + rngTemplate := &pb.GenerateRandomRequest{Len: (uint64)(64)} + rng, err := cryptoClient.GenerateRandom(context.Background(), rngTemplate) + assert.NoError(t, err) + + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, rng.Rnd[:64]) + assert.Error(t, err) + assert.Contains(t, err.Error(), "Verify: Invalid signature") + + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, rng.Rnd[:64]) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifySingle: Invalid signature") + + generateKeyPairResponseECDSA, err := ecdsaKeyGenerate(t, cryptoClient) + assert.NoError(t, err) + + signature, err = ecdsaKeySignSingle(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + assert.NoError(t, err) + + // Verify a ECDSA signature with ED25519 public key + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "Invalid signature") + + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + assert.Error(t, err) + assert.Contains(t, err.Error(), "Invalid signature") + + //err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + //assert.Error(t, err) + //assert.Contains(t, err.Error(), "Invalid signature") + + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, nil) + assert.Error(t, err) + assert.Contains(t, err.Error(), "Verify error") + + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, nil) + assert.Error(t, err) + assert.Contains(t, err.Error(), "VerifySingle error") + +} + +func ed25519KeyGenerateChanWrap(t *testing.T, cryptoClient pb.CryptoClient, ch chan error) { + _, err := ed25519KeyGenerate(t, cryptoClient) + ch <- err +} + +func ed25519KeySignChanWrap(t *testing.T, cryptoClient pb.CryptoClient, ch chan error, privKey []byte, signData []byte) { + _, err := ed25519KeySign(t, cryptoClient, privKey, signData) + ch <- err +} + +func ed25519KeyVerifyChanWrap(t *testing.T, cryptoClient pb.CryptoClient, ch chan error, pubKey []byte, signData []byte, signature []byte) { + err := ed25519KeyVerify(t, cryptoClient, pubKey, signData, signature) + ch <- err +} + +func ed25519KeySignSingleChanWrap(t *testing.T, cryptoClient pb.CryptoClient, ch chan error, privKey []byte, signData []byte) { + _, err := ed25519KeySignSingle(t, cryptoClient, privKey, signData) + ch <- err +} + +func ed25519KeyVerifySingleChanWrap(t *testing.T, cryptoClient pb.CryptoClient, ch chan error, pubKey []byte, signData []byte, signature []byte) { + err := ed25519KeyVerifySingle(t, cryptoClient, pubKey, signData, signature) + ch <- err +} + +func TestED25519ParallelGenerateKey(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + t.Errorf("Could not connect to server: %s", err) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + chs := make([]chan error, 10) + for i := 0; i < 10; i++ { + chs[i] = make(chan error) + go ed25519KeyGenerateChanWrap(t, cryptoClient, chs[i]) + } + + for _, ch := range chs { + assert.NoError(t, <-ch) + } +} + +func TestED25519ParallelSignVerify(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + t.Errorf("Could not connect to server: %s", err) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponse, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + signData := sha256.New().Sum([]byte("This data needs to be signed")) + + chs := make([]chan error, 10) + for i := 0; i < 10; i++ { + chs[i] = make(chan error) + go ed25519KeySignChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PrivKey, signData) + } + + for _, ch := range chs { + assert.NoError(t, <-ch) + } + + signature, err := ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.NoError(t, err) + + for i := 0; i < 10; i++ { + chs[i] = make(chan error) + go ed25519KeyVerifyChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PubKey, signData, signature) + } + + for _, ch := range chs { + assert.NoError(t, <-ch) + } +} + +func TestED25519ParallelSignVerifySingle(t *testing.T) { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + t.Errorf("Could not connect to server: %s", err) + } + defer conn.Close() + + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyPairResponse, err := ed25519KeyGenerate(t, cryptoClient) + assert.NoError(t, err) + signData := sha256.New().Sum([]byte("This data needs to be signed")) + + chs := make([]chan error, 10) + for i := 0; i < 10; i++ { + chs[i] = make(chan error) + go ed25519KeySignSingleChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PrivKey, signData) + } + + for _, ch := range chs { + assert.NoError(t, <-ch) + } + + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + assert.NoError(t, err) + + for i := 0; i < 10; i++ { + chs[i] = make(chan error) + go ed25519KeyVerifySingleChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PubKey, signData, signature) + } + + for _, ch := range chs { + assert.NoError(t, <-ch) + } +} + diff --git a/golang/mock/mock.go b/golang/mock/mock.go index 95ea6d8..45a445b 100644 --- a/golang/mock/mock.go +++ b/golang/mock/mock.go @@ -754,3 +754,4 @@ func (mr *MockCryptoClientMockRecorder) WrapKey(arg0, arg1 interface{}, arg2 ... varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WrapKey", reflect.TypeOf((*MockCryptoClient)(nil).WrapKey), varargs...) } + diff --git a/golang/util/signer.go b/golang/util/signer.go index a5638e3..e76490a 100644 --- a/golang/util/signer.go +++ b/golang/util/signer.go @@ -80,3 +80,4 @@ func NewEP11Signer(cryptoClient pb.CryptoClient, privKeyBlob []byte, spki []byte } return priv, nil } + diff --git a/golang/util/util.go b/golang/util/util.go index c568b09..f8adbd5 100644 --- a/golang/util/util.go +++ b/golang/util/util.go @@ -134,6 +134,7 @@ var ( OIDNamedCurveP521 = asn1.ObjectIdentifier{1, 3, 132, 0, 35} oidECPublicKey = asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1} oidRSAPublicKey = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1} + OIDNamedCurveED25519 = asn1.ObjectIdentifier{1, 3, 101, 112} ) // GetNamedCurveFromOID returns an elliptic curve from the specified curve OID @@ -292,3 +293,4 @@ func (cr *IAMPerRPCCredentials) getToken(ctx context.Context) (err error) { return nil } + From 316012b52c8da33bd81da7c16b0c98b0487a04b9 Mon Sep 17 00:00:00 2001 From: Prabhat Ranjan Date: Wed, 4 Nov 2020 15:29:01 +0530 Subject: [PATCH 4/5] Added test for bip32 and slip10 --- golang/ep11/header_consts.go | 2272 +++- golang/examples/bip32_test.go | 815 ++ golang/examples/slip10_test.go | 898 ++ golang/grpc/server.pb.go | 20019 ++++++++++++++++++++----------- golang/mock/mock.go | 1 - golang/util/signer.go | 1 - golang/util/util.go | 95 +- 7 files changed, 16539 insertions(+), 7562 deletions(-) create mode 100644 golang/examples/bip32_test.go create mode 100644 golang/examples/slip10_test.go diff --git a/golang/ep11/header_consts.go b/golang/ep11/header_consts.go index c7cf68c..e7c37b4 100644 --- a/golang/ep11/header_consts.go +++ b/golang/ep11/header_consts.go @@ -13,143 +13,359 @@ import ( "fmt" "github.com/gogo/protobuf/jsonpb" "strconv" + "strings" ) +type AdminCommand uint32 type Attribute uint64 +type CardAttributeFlags uint32 +type CardAttributeKey uint32 +type ControlPoint uint32 +type FunctionID uint32 +type ImporterKeyType uint32 type KeyType uint64 type Mechanism uint64 type MechanismInfoFlag uint64 type ObjectClass uint64 type Return uint64 +type EP11Attributes map[Attribute]interface{} + type AttributeStruct struct { Type Attribute Value []byte } const ( - CKA_CLASS Attribute = 0x00000000 - CKA_TOKEN Attribute = 0x00000001 - CKA_PRIVATE Attribute = 0x00000002 - CKA_LABEL Attribute = 0x00000003 - CKA_APPLICATION Attribute = 0x00000010 - CKA_VALUE Attribute = 0x00000011 - CKA_OBJECT_ID Attribute = 0x00000012 - CKA_CERTIFICATE_TYPE Attribute = 0x00000080 - CKA_ISSUER Attribute = 0x00000081 - CKA_SERIAL_NUMBER Attribute = 0x00000082 - CKA_AC_ISSUER Attribute = 0x00000083 - CKA_OWNER Attribute = 0x00000084 - CKA_ATTR_TYPES Attribute = 0x00000085 - CKA_TRUSTED Attribute = 0x00000086 - CKA_CERTIFICATE_CATEGORY Attribute = 0x00000087 - CKA_JAVA_MIDP_SECURITY_DOMAIN Attribute = 0x00000088 - CKA_URL Attribute = 0x00000089 - CKA_HASH_OF_SUBJECT_PUBLIC_KEY Attribute = 0x0000008a - CKA_HASH_OF_ISSUER_PUBLIC_KEY Attribute = 0x0000008b - CKA_NAME_HASH_ALGORITHM Attribute = 0x0000008c - CKA_CHECK_VALUE Attribute = 0x00000090 - CKA_KEY_TYPE Attribute = 0x00000100 - CKA_SUBJECT Attribute = 0x00000101 - CKA_ID Attribute = 0x00000102 - CKA_SENSITIVE Attribute = 0x00000103 - CKA_ENCRYPT Attribute = 0x00000104 - CKA_DECRYPT Attribute = 0x00000105 - CKA_WRAP Attribute = 0x00000106 - CKA_UNWRAP Attribute = 0x00000107 - CKA_SIGN Attribute = 0x00000108 - CKA_SIGN_RECOVER Attribute = 0x00000109 - CKA_VERIFY Attribute = 0x0000010a - CKA_VERIFY_RECOVER Attribute = 0x0000010b - CKA_DERIVE Attribute = 0x0000010c - CKA_START_DATE Attribute = 0x00000110 - CKA_END_DATE Attribute = 0x00000111 - CKA_MODULUS Attribute = 0x00000120 - CKA_MODULUS_BITS Attribute = 0x00000121 - CKA_PUBLIC_EXPONENT Attribute = 0x00000122 - CKA_PRIVATE_EXPONENT Attribute = 0x00000123 - CKA_PRIME_1 Attribute = 0x00000124 - CKA_PRIME_2 Attribute = 0x00000125 - CKA_EXPONENT_1 Attribute = 0x00000126 - CKA_EXPONENT_2 Attribute = 0x00000127 - CKA_COEFFICIENT Attribute = 0x00000128 - CKA_PUBLIC_KEY_INFO Attribute = 0x00000129 - CKA_PRIME Attribute = 0x00000130 - CKA_SUBPRIME Attribute = 0x00000131 - CKA_BASE Attribute = 0x00000132 - CKA_PRIME_BITS Attribute = 0x00000133 - CKA_SUBPRIME_BITS Attribute = 0x00000134 - CKA_SUB_PRIME_BITS Attribute = 0x00000134 - CKA_VALUE_BITS Attribute = 0x00000160 - CKA_VALUE_LEN Attribute = 0x00000161 - CKA_EXTRACTABLE Attribute = 0x00000162 - CKA_LOCAL Attribute = 0x00000163 - CKA_NEVER_EXTRACTABLE Attribute = 0x00000164 - CKA_ALWAYS_SENSITIVE Attribute = 0x00000165 - CKA_KEY_GEN_MECHANISM Attribute = 0x00000166 - CKA_MODIFIABLE Attribute = 0x00000170 - CKA_COPYABLE Attribute = 0x00000171 - CKA_DESTROYABLE Attribute = 0x00000172 - CKA_ECDSA_PARAMS Attribute = 0x00000180 - CKA_EC_PARAMS Attribute = 0x00000180 - CKA_EC_POINT Attribute = 0x00000181 - CKA_SECONDARY_AUTH Attribute = 0x00000200 - CKA_AUTH_PIN_FLAGS Attribute = 0x00000201 - CKA_ALWAYS_AUTHENTICATE Attribute = 0x00000202 - CKA_WRAP_WITH_TRUSTED Attribute = 0x00000210 - CKA_OTP_FORMAT Attribute = 0x00000220 - CKA_OTP_LENGTH Attribute = 0x00000221 - CKA_OTP_TIME_INTERVAL Attribute = 0x00000222 - CKA_OTP_USER_FRIENDLY_MODE Attribute = 0x00000223 - CKA_OTP_CHALLENGE_REQUIREMENT Attribute = 0x00000224 - CKA_OTP_TIME_REQUIREMENT Attribute = 0x00000225 - CKA_OTP_COUNTER_REQUIREMENT Attribute = 0x00000226 - CKA_OTP_PIN_REQUIREMENT Attribute = 0x00000227 - CKA_OTP_USER_IDENTIFIER Attribute = 0x0000022a - CKA_OTP_SERVICE_IDENTIFIER Attribute = 0x0000022b - CKA_OTP_SERVICE_LOGO Attribute = 0x0000022c - CKA_OTP_SERVICE_LOGO_TYPE Attribute = 0x0000022d - CKA_OTP_COUNTER Attribute = 0x0000022e - CKA_OTP_TIME Attribute = 0x0000022f - CKA_GOSTR3410_PARAMS Attribute = 0x00000250 - CKA_GOSTR3411_PARAMS Attribute = 0x00000251 - CKA_GOST28147_PARAMS Attribute = 0x00000252 - CKA_HW_FEATURE_TYPE Attribute = 0x00000300 - CKA_RESET_ON_INIT Attribute = 0x00000301 - CKA_HAS_RESET Attribute = 0x00000302 - CKA_PIXEL_X Attribute = 0x00000400 - CKA_PIXEL_Y Attribute = 0x00000401 - CKA_RESOLUTION Attribute = 0x00000402 - CKA_CHAR_ROWS Attribute = 0x00000403 - CKA_CHAR_COLUMNS Attribute = 0x00000404 - CKA_COLOR Attribute = 0x00000405 - CKA_BITS_PER_PIXEL Attribute = 0x00000406 - CKA_CHAR_SETS Attribute = 0x00000480 - CKA_ENCODING_METHODS Attribute = 0x00000481 - CKA_MIME_TYPES Attribute = 0x00000482 - CKA_MECHANISM_TYPE Attribute = 0x00000500 - CKA_REQUIRED_CMS_ATTRIBUTES Attribute = 0x00000501 - CKA_DEFAULT_CMS_ATTRIBUTES Attribute = 0x00000502 - CKA_SUPPORTED_CMS_ATTRIBUTES Attribute = 0x00000503 - CKA_WRAP_TEMPLATE Attribute = 0x40000211 - CKA_UNWRAP_TEMPLATE Attribute = 0x40000212 - CKA_ALLOWED_MECHANISMS Attribute = 0x40000600 - CKA_VENDOR_DEFINED Attribute = 0x80000000 - CKA_IBM_RESTRICTABLE Attribute = CKA_VENDOR_DEFINED + 0x10001 - CKA_IBM_NEVER_MODIFIABLE Attribute = CKA_VENDOR_DEFINED + 0x10002 - CKA_IBM_RETAINKEY Attribute = CKA_VENDOR_DEFINED + 0x10003 - CKA_IBM_ATTRBOUND Attribute = CKA_VENDOR_DEFINED + 0x10004 - CKA_IBM_KEYTYPE Attribute = CKA_VENDOR_DEFINED + 0x10005 - CKA_IBM_CV Attribute = CKA_VENDOR_DEFINED + 0x10006 - CKA_IBM_MACKEY Attribute = CKA_VENDOR_DEFINED + 0x10007 - CKA_IBM_USE_AS_DATA Attribute = CKA_VENDOR_DEFINED + 0x10008 - CKA_IBM_STRUCT_PARAMS Attribute = CKA_VENDOR_DEFINED + 0x10009 - CKA_IBM_STD_COMPLIANCE1 Attribute = CKA_VENDOR_DEFINED + 0x1000a - CKA_IBM_MLS_TYPE Attribute = CKA_VENDOR_DEFINED + 0x1000b - CKA_IBM_WIRETEST Attribute = CKA_VENDOR_DEFINED + 0x20001 - CKA_VENDOR_DEFINED_GREP11 Attribute = CKA_VENDOR_DEFINED + 0x40000 - CKA_GREP11_RAW_KEYBLOB Attribute = CKA_VENDOR_DEFINED_GREP11 + 0x1 - CKA_IBM_EPX Attribute = CKA_VENDOR_DEFINED_GREP11 + 0x61100000 + XCP_ADM_ADMIN_LOGIN AdminCommand = 0x00000001 + XCP_ADM_DOM_ADMIN_LOGIN AdminCommand = 0x00000002 + XCP_ADM_ADMIN_LOGOUT AdminCommand = 0x00000003 + XCP_ADM_DOM_ADMIN_LOGOUT AdminCommand = 0x00000004 + XCP_ADM_ADMIN_REPLACE AdminCommand = 0x00000005 + XCP_ADM_DOM_ADMIN_REPLACE AdminCommand = 0x00000006 + XCP_ADM_SET_ATTR AdminCommand = 0x00000007 + XCP_ADM_DOM_SET_ATTR AdminCommand = 0x00000008 + XCP_ADM_GEN_DOM_IMPORTER AdminCommand = 0x00000009 + XCP_ADM_GEN_WK AdminCommand = 0x0000000a + XCP_ADM_EXPORT_WK AdminCommand = 0x0000000b + XCP_ADM_IMPORT_WK AdminCommand = 0x0000000c + XCP_ADM_COMMIT_WK AdminCommand = 0x0000000d + XCP_ADM_FINALIZE_WK AdminCommand = 0x0000000e + XCP_ADM_ZEROIZE AdminCommand = 0x0000000f + XCP_ADM_DOM_ZEROIZE AdminCommand = 0x00000010 + XCP_ADM_DOM_CTRLPOINT_SET AdminCommand = 0x00000011 + XCP_ADM_DOM_CTRLPOINT_ADD AdminCommand = 0x00000012 + XCP_ADM_DOM_CTRLPOINT_DEL AdminCommand = 0x00000013 + XCP_ADM_SET_CLOCK AdminCommand = 0x00000014 + XCP_ADM_SET_FCV AdminCommand = 0x00000015 + XCP_ADM_CTRLPOINT_SET AdminCommand = 0x00000016 + XCP_ADM_CTRLPOINT_ADD AdminCommand = 0x00000017 + XCP_ADM_CTRLPOINT_DEL AdminCommand = 0x00000018 + XCP_ADM_REENCRYPT AdminCommand = 0x00000019 + XCP_ADM_RK_REMOVE AdminCommand = 0x0000001a + XCP_ADM_CLEAR_WK AdminCommand = 0x0000001b + XCP_ADM_CLEAR_NEXT_WK AdminCommand = 0x0000001c + XCP_ADM_SYSTEM_ZEROIZE AdminCommand = 0x0000001d + XCP_ADM_EXPORT_STATE AdminCommand = 0x0000001e + XCP_ADM_IMPORT_STATE AdminCommand = 0x0000001f + XCP_ADM_COMMIT_STATE AdminCommand = 0x00000020 + XCP_ADM_REMOVE_STATE AdminCommand = 0x00000021 + XCP_ADM_GEN_MODULE_IMPORTER AdminCommand = 0x00000022 + XCP_ADM_SET_TRUSTED AdminCommand = 0x00000023 + XCP_ADM_DOMAINS_ZEROIZE AdminCommand = 0x00000024 + XCP_ADM_SESSION_REMOVE AdminCommand = 0x00000025 + XCP_ADM_EXPORT_NEXT_WK AdminCommand = 0x00000026 + XCP_ADMQ_ADMIN AdminCommand = 0x00010001 + XCP_ADMQ_DOMADMIN AdminCommand = 0x00010002 + XCP_ADMQ_DEVICE_CERT AdminCommand = 0x00010003 + XCP_ADMQ_DOM_IMPORTER_CERT AdminCommand = 0x00010004 + XCP_ADMQ_CTRLPOINTS AdminCommand = 0x00010005 + XCP_ADMQ_DOM_CTRLPOINTS AdminCommand = 0x00010006 + XCP_ADMQ_WK AdminCommand = 0x00010007 + XCP_ADMQ_NEXT_WK AdminCommand = 0x00010008 + XCP_ADMQ_ATTRS AdminCommand = 0x00010009 + XCP_ADMQ_DOM_ATTRS AdminCommand = 0x0001000a + XCP_ADMQ_FCV AdminCommand = 0x0001000b + XCP_ADMQ_WK_ORIGINS AdminCommand = 0x0001000c + XCP_ADMQ_RKLIST AdminCommand = 0x0001000d + XCP_ADMQ_INTERNAL_STATE AdminCommand = 0x0001000e + XCP_ADMQ_IMPORTER_CERT AdminCommand = 0x0001000f + XCP_ADMQ_AUDIT_STATE AdminCommand = 0x00010010 + XCP_ADMQ_LASTCMD_DOM_MASK AdminCommand = 0x00010011 + + CKA_CLASS Attribute = 0x00000000 + CKA_TOKEN Attribute = 0x00000001 + CKA_PRIVATE Attribute = 0x00000002 + CKA_LABEL Attribute = 0x00000003 + CKA_APPLICATION Attribute = 0x00000010 + CKA_VALUE Attribute = 0x00000011 + CKA_OBJECT_ID Attribute = 0x00000012 + CKA_CERTIFICATE_TYPE Attribute = 0x00000080 + CKA_ISSUER Attribute = 0x00000081 + CKA_SERIAL_NUMBER Attribute = 0x00000082 + CKA_AC_ISSUER Attribute = 0x00000083 + CKA_OWNER Attribute = 0x00000084 + CKA_ATTR_TYPES Attribute = 0x00000085 + CKA_TRUSTED Attribute = 0x00000086 + CKA_CERTIFICATE_CATEGORY Attribute = 0x00000087 + CKA_JAVA_MIDP_SECURITY_DOMAIN Attribute = 0x00000088 + CKA_URL Attribute = 0x00000089 + CKA_HASH_OF_SUBJECT_PUBLIC_KEY Attribute = 0x0000008a + CKA_HASH_OF_ISSUER_PUBLIC_KEY Attribute = 0x0000008b + CKA_NAME_HASH_ALGORITHM Attribute = 0x0000008c + CKA_CHECK_VALUE Attribute = 0x00000090 + CKA_KEY_TYPE Attribute = 0x00000100 + CKA_SUBJECT Attribute = 0x00000101 + CKA_ID Attribute = 0x00000102 + CKA_SENSITIVE Attribute = 0x00000103 + CKA_ENCRYPT Attribute = 0x00000104 + CKA_DECRYPT Attribute = 0x00000105 + CKA_WRAP Attribute = 0x00000106 + CKA_UNWRAP Attribute = 0x00000107 + CKA_SIGN Attribute = 0x00000108 + CKA_SIGN_RECOVER Attribute = 0x00000109 + CKA_VERIFY Attribute = 0x0000010a + CKA_VERIFY_RECOVER Attribute = 0x0000010b + CKA_DERIVE Attribute = 0x0000010c + CKA_START_DATE Attribute = 0x00000110 + CKA_END_DATE Attribute = 0x00000111 + CKA_MODULUS Attribute = 0x00000120 + CKA_MODULUS_BITS Attribute = 0x00000121 + CKA_PUBLIC_EXPONENT Attribute = 0x00000122 + CKA_PRIVATE_EXPONENT Attribute = 0x00000123 + CKA_PRIME_1 Attribute = 0x00000124 + CKA_PRIME_2 Attribute = 0x00000125 + CKA_EXPONENT_1 Attribute = 0x00000126 + CKA_EXPONENT_2 Attribute = 0x00000127 + CKA_COEFFICIENT Attribute = 0x00000128 + CKA_PUBLIC_KEY_INFO Attribute = 0x00000129 + CKA_PRIME Attribute = 0x00000130 + CKA_SUBPRIME Attribute = 0x00000131 + CKA_BASE Attribute = 0x00000132 + CKA_PRIME_BITS Attribute = 0x00000133 + CKA_SUBPRIME_BITS Attribute = 0x00000134 + CKA_SUB_PRIME_BITS Attribute = 0x00000134 + CKA_VALUE_BITS Attribute = 0x00000160 + CKA_VALUE_LEN Attribute = 0x00000161 + CKA_EXTRACTABLE Attribute = 0x00000162 + CKA_LOCAL Attribute = 0x00000163 + CKA_NEVER_EXTRACTABLE Attribute = 0x00000164 + CKA_ALWAYS_SENSITIVE Attribute = 0x00000165 + CKA_KEY_GEN_MECHANISM Attribute = 0x00000166 + CKA_MODIFIABLE Attribute = 0x00000170 + CKA_COPYABLE Attribute = 0x00000171 + CKA_DESTROYABLE Attribute = 0x00000172 + CKA_ECDSA_PARAMS Attribute = 0x00000180 + CKA_EC_PARAMS Attribute = 0x00000180 + CKA_EC_POINT Attribute = 0x00000181 + CKA_SECONDARY_AUTH Attribute = 0x00000200 + CKA_AUTH_PIN_FLAGS Attribute = 0x00000201 + CKA_ALWAYS_AUTHENTICATE Attribute = 0x00000202 + CKA_WRAP_WITH_TRUSTED Attribute = 0x00000210 + CKA_OTP_FORMAT Attribute = 0x00000220 + CKA_OTP_LENGTH Attribute = 0x00000221 + CKA_OTP_TIME_INTERVAL Attribute = 0x00000222 + CKA_OTP_USER_FRIENDLY_MODE Attribute = 0x00000223 + CKA_OTP_CHALLENGE_REQUIREMENT Attribute = 0x00000224 + CKA_OTP_TIME_REQUIREMENT Attribute = 0x00000225 + CKA_OTP_COUNTER_REQUIREMENT Attribute = 0x00000226 + CKA_OTP_PIN_REQUIREMENT Attribute = 0x00000227 + CKA_OTP_USER_IDENTIFIER Attribute = 0x0000022a + CKA_OTP_SERVICE_IDENTIFIER Attribute = 0x0000022b + CKA_OTP_SERVICE_LOGO Attribute = 0x0000022c + CKA_OTP_SERVICE_LOGO_TYPE Attribute = 0x0000022d + CKA_OTP_COUNTER Attribute = 0x0000022e + CKA_OTP_TIME Attribute = 0x0000022f + CKA_GOSTR3410_PARAMS Attribute = 0x00000250 + CKA_GOSTR3411_PARAMS Attribute = 0x00000251 + CKA_GOST28147_PARAMS Attribute = 0x00000252 + CKA_HW_FEATURE_TYPE Attribute = 0x00000300 + CKA_RESET_ON_INIT Attribute = 0x00000301 + CKA_HAS_RESET Attribute = 0x00000302 + CKA_PIXEL_X Attribute = 0x00000400 + CKA_PIXEL_Y Attribute = 0x00000401 + CKA_RESOLUTION Attribute = 0x00000402 + CKA_CHAR_ROWS Attribute = 0x00000403 + CKA_CHAR_COLUMNS Attribute = 0x00000404 + CKA_COLOR Attribute = 0x00000405 + CKA_BITS_PER_PIXEL Attribute = 0x00000406 + CKA_CHAR_SETS Attribute = 0x00000480 + CKA_ENCODING_METHODS Attribute = 0x00000481 + CKA_MIME_TYPES Attribute = 0x00000482 + CKA_MECHANISM_TYPE Attribute = 0x00000500 + CKA_REQUIRED_CMS_ATTRIBUTES Attribute = 0x00000501 + CKA_DEFAULT_CMS_ATTRIBUTES Attribute = 0x00000502 + CKA_SUPPORTED_CMS_ATTRIBUTES Attribute = 0x00000503 + CKA_WRAP_TEMPLATE Attribute = 0x40000211 + CKA_UNWRAP_TEMPLATE Attribute = 0x40000212 + CKA_DERIVE_TEMPLATE Attribute = 0x40000213 + CKA_ALLOWED_MECHANISMS Attribute = 0x40000600 + CKA_VENDOR_DEFINED Attribute = 0x80000000 + CKA_IBM_RESTRICTABLE Attribute = CKA_VENDOR_DEFINED + 0x10001 + CKA_IBM_NEVER_MODIFIABLE Attribute = CKA_VENDOR_DEFINED + 0x10002 + CKA_IBM_RETAINKEY Attribute = CKA_VENDOR_DEFINED + 0x10003 + CKA_IBM_ATTRBOUND Attribute = CKA_VENDOR_DEFINED + 0x10004 + CKA_IBM_KEYTYPE Attribute = CKA_VENDOR_DEFINED + 0x10005 + CKA_IBM_CV Attribute = CKA_VENDOR_DEFINED + 0x10006 + CKA_IBM_MACKEY Attribute = CKA_VENDOR_DEFINED + 0x10007 + CKA_IBM_USE_AS_DATA Attribute = CKA_VENDOR_DEFINED + 0x10008 + CKA_IBM_STRUCT_PARAMS Attribute = CKA_VENDOR_DEFINED + 0x10009 + CKA_IBM_STD_COMPLIANCE1 Attribute = CKA_VENDOR_DEFINED + 0x1000a + CKA_IBM_MLS_TYPE Attribute = CKA_VENDOR_DEFINED + 0x1000b + CKA_IBM_PROTKEY_EXTRACTABLE Attribute = CKA_VENDOR_DEFINED + 0x1000c + CKA_IBM_PROTKEY_NEVER_EXTRACTABLE Attribute = CKA_VENDOR_DEFINED + 0x1000d + CKA_IBM_PQC_PARAMS Attribute = CKA_VENDOR_DEFINED + 0x1000e + CKA_IBM_WIRETEST Attribute = CKA_VENDOR_DEFINED + 0x20001 + CKA_VENDOR_DEFINED_GREP11 Attribute = CKA_VENDOR_DEFINED + 0x40000 + CKA_GREP11_RAW_KEYBLOB Attribute = CKA_VENDOR_DEFINED_GREP11 + 0x1 + CKA_GREP11_VOTE_VERSION Attribute = CKA_VENDOR_DEFINED_GREP11 + 0x2 + CKA_IBM_EPX Attribute = CKA_VENDOR_DEFINED_GREP11 + 0x61100000 + + XCP_ADMP_WK_IMPORT CardAttributeFlags = 0x00000001 + XCP_ADMP_WK_EXPORT CardAttributeFlags = 0x00000002 + XCP_ADMP_WK_1PART CardAttributeFlags = 0x00000004 + XCP_ADMP_WK_RANDOM CardAttributeFlags = 0x00000008 + XCP_ADMP_1SIGN CardAttributeFlags = 0x00000010 + XCP_ADMP_CP_1SIGN CardAttributeFlags = 0x00000020 + XCP_ADMP_ZERO_1SIGN CardAttributeFlags = 0x00000040 + XCP_ADMP_NO_DOMAIN_IMPRINT CardAttributeFlags = 0x00000080 + XCP_ADMP_STATE_IMPORT CardAttributeFlags = 0x00000100 + XCP_ADMP_STATE_EXPORT CardAttributeFlags = 0x00000200 + XCP_ADMP_STATE_1PART CardAttributeFlags = 0x00000400 + XCP_ADMP_NO_EPX CardAttributeFlags = 0x00000800 + XCP_ADMP_NO_EPXVM CardAttributeFlags = 0x00001000 + XCP_ADMP_DO_NOT_DISTURB CardAttributeFlags = 0x00002000 + XCP_ADMP__PERMS CardAttributeFlags = 0x00003fff + XCP_ADMP_CHG_WK_IMPORT CardAttributeFlags = 0x00010000 + XCP_ADMP_CHG_WK_EXPORT CardAttributeFlags = 0x00020000 + XCP_ADMP_CHG_WK_1PART CardAttributeFlags = 0x00040000 + XCP_ADMP_CHG_WK_RANDOM CardAttributeFlags = 0x00080000 + XCP_ADMP_CHG_SIGN_THR CardAttributeFlags = 0x00100000 + XCP_ADMP_CHG_REVOKE_THR CardAttributeFlags = 0x00200000 + XCP_ADMP_CHG_1SIGN CardAttributeFlags = 0x00400000 + XCP_ADMP_CHG_CP_1SIGN CardAttributeFlags = 0x00800000 + XCP_ADMP_CHG_ZERO_1SIGN CardAttributeFlags = 0x01000000 + XCP_ADMP_CHG_ST_IMPORT CardAttributeFlags = 0x02000000 + XCP_ADMP_CHG_ST_EXPORT CardAttributeFlags = 0x04000000 + XCP_ADMP_CHG_ST_1PART CardAttributeFlags = 0x08000000 + XCP_ADMP_CHG_NO_EPX CardAttributeFlags = 0x20000000 + XCP_ADMP_CHG_NO_EPXVM CardAttributeFlags = 0x40000000 + XCP_ADMP_NOT_SUP CardAttributeFlags = 0x60001800 + XCP_ADMP_CHG_DO_NOT_DISTURB CardAttributeFlags = 0x80000000 + XCP_ADMP__CHGBITS CardAttributeFlags = XCP_ADMP_CHG_DO_NOT_DISTURB + 0x6fff0000 + XCP_ADMP__DEFAULT CardAttributeFlags = XCP_ADMP_CHG_DO_NOT_DISTURB + 0x6fff0011 + + XCP_ADMINT_SIGN_THR CardAttributeKey = 0x00000001 + XCP_ADMINT_REVOKE_THR CardAttributeKey = 0x00000002 + XCP_ADMINT_PERMS CardAttributeKey = 0x00000003 + XCP_ADMINT_MODE CardAttributeKey = 0x00000004 + XCP_ADMINT_STD CardAttributeKey = 0x00000005 + + XCP_CPB_ADD_CPBS ControlPoint = 0x00000000 + XCP_CPB_DELETE_CPBS ControlPoint = 0x00000001 + XCP_CPB_SIGN_ASYMM ControlPoint = 0x00000002 + XCP_CPB_SIGN_SYMM ControlPoint = 0x00000003 + XCP_CPB_SIGVERIFY_SYMM ControlPoint = 0x00000004 + XCP_CPB_ENCRYPT_SYMM ControlPoint = 0x00000005 + XCP_CPB_DECRYPT_ASYMM ControlPoint = 0x00000006 + XCP_CPB_DECRYPT_SYMM ControlPoint = 0x00000007 + XCP_CPB_WRAP_ASYMM ControlPoint = 0x00000008 + XCP_CPB_WRAP_SYMM ControlPoint = 0x00000009 + XCP_CPB_UNWRAP_ASYMM ControlPoint = 0x0000000a + XCP_CPB_UNWRAP_SYMM ControlPoint = 0x0000000b + XCP_CPB_KEYGEN_ASYMM ControlPoint = 0x0000000c + XCP_CPB_KEYGEN_SYMM ControlPoint = 0x0000000d + XCP_CPB_RETAINKEYS ControlPoint = 0x0000000e + XCP_CPB_SKIP_KEYTESTS ControlPoint = 0x0000000f + XCP_CPB_NON_ATTRBOUND ControlPoint = 0x00000010 + XCP_CPB_MODIFY_OBJECTS ControlPoint = 0x00000011 + XCP_CPB_RNG_SEED ControlPoint = 0x00000012 + XCP_CPB_ALG_RAW_RSA ControlPoint = 0x00000013 + XCP_CPB_ALG_NFIPS2009 ControlPoint = 0x00000014 + XCP_CPB_ALG_NBSI2009 ControlPoint = 0x00000015 + XCP_CPB_KEYSZ_HMAC_ANY ControlPoint = 0x00000016 + XCP_CPB_KEYSZ_BELOW80BIT ControlPoint = 0x00000017 + XCP_CPB_KEYSZ_80BIT ControlPoint = 0x00000018 + XCP_CPB_KEYSZ_112BIT ControlPoint = 0x00000019 + XCP_CPB_KEYSZ_128BIT ControlPoint = 0x0000001a + XCP_CPB_KEYSZ_192BIT ControlPoint = 0x0000001b + XCP_CPB_KEYSZ_256BIT ControlPoint = 0x0000001c + XCP_CPB_KEYSZ_RSA65536 ControlPoint = 0x0000001d + XCP_CPB_ALG_RSA ControlPoint = 0x0000001e + XCP_CPB_ALG_DSA ControlPoint = 0x0000001f + XCP_CPB_ALG_EC ControlPoint = 0x00000020 + XCP_CPB_ALG_EC_BPOOLCRV ControlPoint = 0x00000021 + XCP_CPB_ALG_EC_NISTCRV ControlPoint = 0x00000022 + XCP_CPB_ALG_NFIPS2011 ControlPoint = 0x00000023 + XCP_CPB_ALG_NBSI2011 ControlPoint = 0x00000024 + XCP_CPB_USER_SET_TRUSTED ControlPoint = 0x00000025 + XCP_CPB_ALG_SKIP_CROSSCHK ControlPoint = 0x00000026 + XCP_CPB_WRAP_CRYPT_KEYS ControlPoint = 0x00000027 + XCP_CPB_SIGN_CRYPT_KEYS ControlPoint = 0x00000028 + XCP_CPB_WRAP_SIGN_KEYS ControlPoint = 0x00000029 + XCP_CPB_USER_SET_ATTRBOUND ControlPoint = 0x0000002a + XCP_CPB_ALLOW_PASSPHRASE ControlPoint = 0x0000002b + XCP_CPB_WRAP_STRONGER_KEY ControlPoint = 0x0000002c + XCP_CPB_WRAP_WITH_RAW_SPKI ControlPoint = 0x0000002d + XCP_CPB_ALG_DH ControlPoint = 0x0000002e + XCP_CPB_DERIVE ControlPoint = 0x0000002f + XCP_CPB_ALG_EC_25519 ControlPoint = 0x00000037 + XCP_CPB_ALG_NBSI2017 ControlPoint = 0x0000003d + XCP_CPB_EMV ControlPoint = 0x0000003e + XCP_CPB_EMV_MIX ControlPoint = 0x0000003f + XCP_CPB_CPACF_PK ControlPoint = 0x00000040 + XCP_CPB_ALG_PQC ControlPoint = 0x00000041 + XCP_CPB_BTC ControlPoint = 0x00000042 + + FNID_Login FunctionID = 0x00000001 + FNID_Logout FunctionID = 0x00000002 + FNID_SeedRandom FunctionID = 0x00000003 + FNID_GenerateRandom FunctionID = 0x00000004 + FNID_DigestInit FunctionID = 0x00000005 + FNID_DigestUpdate FunctionID = 0x00000006 + FNID_DigestKey FunctionID = 0x00000007 + FNID_DigestFinal FunctionID = 0x00000008 + FNID_Digest FunctionID = 0x00000009 + FNID_DigestSingle FunctionID = 0x0000000a + FNID_EncryptInit FunctionID = 0x0000000b + FNID_DecryptInit FunctionID = 0x0000000c + FNID_EncryptUpdate FunctionID = 0x0000000d + FNID_DecryptUpdate FunctionID = 0x0000000e + FNID_EncryptFinal FunctionID = 0x0000000f + FNID_DecryptFinal FunctionID = 0x00000010 + FNID_Encrypt FunctionID = 0x00000011 + FNID_Decrypt FunctionID = 0x00000012 + FNID_EncryptSingle FunctionID = 0x00000013 + FNID_DecryptSingle FunctionID = 0x00000014 + FNID_GenerateKey FunctionID = 0x00000015 + FNID_GenerateKeyPair FunctionID = 0x00000016 + FNID_SignInit FunctionID = 0x00000017 + FNID_SignUpdate FunctionID = 0x00000018 + FNID_SignFinal FunctionID = 0x00000019 + FNID_Sign FunctionID = 0x0000001a + FNID_VerifyInit FunctionID = 0x0000001b + FNID_VerifyUpdate FunctionID = 0x0000001c + FNID_VerifyFinal FunctionID = 0x0000001d + FNID_Verify FunctionID = 0x0000001e + FNID_SignSingle FunctionID = 0x0000001f + FNID_VerifySingle FunctionID = 0x00000020 + FNID_WrapKey FunctionID = 0x00000021 + FNID_UnwrapKey FunctionID = 0x00000022 + FNID_DeriveKey FunctionID = 0x00000023 + FNID_GetMechanismList FunctionID = 0x00000024 + FNID_GetMechanismInfo FunctionID = 0x00000025 + FNID_get_xcp_info FunctionID = 0x00000026 + FNID_GetAttributeValue FunctionID = 0x00000027 + FNID_SetAttributeValue FunctionID = 0x00000028 + FNID_admin FunctionID = 0x00000029 + FNID_ReencryptSingle FunctionID = 0x0000002a + FNID_NEXT_AVAILABLE FunctionID = 0x0000002b + + XCP_IMPRKEY_RSA_2048 ImporterKeyType = 0x00000000 + XCP_IMPRKEY_RSA_4096 ImporterKeyType = 0x00000001 + XCP_IMPRKEY_EC_P256 ImporterKeyType = 0x00000002 + XCP_IMPRKEY_EC_P521 ImporterKeyType = 0x00000003 + XCP_IMPRKEY_RSA_3072 ImporterKeyType = 0x00000007 CKK_RSA KeyType = 0x00000000 CKK_DSA KeyType = 0x00000001 @@ -182,19 +398,20 @@ const ( CKK_ACTI KeyType = 0x00000024 CKK_CAMELLIA KeyType = 0x00000025 CKK_ARIA KeyType = 0x00000026 - CKK_SHA512_224_HMAC KeyType = 0x00000027 - CKK_SHA512_256_HMAC KeyType = 0x00000028 - CKK_SHA512_T_HMAC KeyType = 0x00000029 - CKK_SHA_1_HMAC KeyType = 0x00000040 - CKK_SHA224_HMAC KeyType = 0x00000041 - CKK_SHA256_HMAC KeyType = 0x00000042 - CKK_SHA384_HMAC KeyType = 0x00000043 - CKK_SHA512_HMAC KeyType = 0x00000044 - CKK_SEED KeyType = 0x00000050 - CKK_GOSTR3410 KeyType = 0x00000060 - CKK_GOSTR3411 KeyType = 0x00000061 - CKK_GOST28147 KeyType = 0x00000062 + CKK_MD5_HMAC KeyType = 0x00000027 + CKK_SHA_1_HMAC KeyType = 0x00000028 + CKK_RIPEMD128_HMAC KeyType = 0x00000029 + CKK_RIPEMD160_HMAC KeyType = 0x0000002a + CKK_SHA256_HMAC KeyType = 0x0000002b + CKK_SHA384_HMAC KeyType = 0x0000002c + CKK_SHA512_HMAC KeyType = 0x0000002d + CKK_SHA224_HMAC KeyType = 0x0000002e + CKK_SEED KeyType = 0x0000002f + CKK_GOSTR3410 KeyType = 0x00000030 + CKK_GOSTR3411 KeyType = 0x00000031 + CKK_GOST28147 KeyType = 0x00000032 CKK_VENDOR_DEFINED KeyType = 0x80000000 + CKK_IBM_PQC_DILITHIUM KeyType = CKK_VENDOR_DEFINED + 0x10023 CKK_IBM_SM4 KeyType = CKK_VENDOR_DEFINED + 0x50001 CKK_IBM_SM2 KeyType = CKK_VENDOR_DEFINED + 0x50002 CKK_IBM_EPX_SYMM KeyType = CKK_VENDOR_DEFINED + 0x61120000 @@ -220,11 +437,10 @@ const ( CKM_DSA_KEY_PAIR_GEN Mechanism = 0x00000010 CKM_DSA Mechanism = 0x00000011 CKM_DSA_SHA1 Mechanism = 0x00000012 - CKM_DSA_FIPS_G_GEN Mechanism = 0x00000013 - CKM_DSA_SHA224 Mechanism = 0x00000014 - CKM_DSA_SHA256 Mechanism = 0x00000015 - CKM_DSA_SHA384 Mechanism = 0x00000016 - CKM_DSA_SHA512 Mechanism = 0x00000017 + CKM_DSA_SHA224 Mechanism = 0x00000013 + CKM_DSA_SHA256 Mechanism = 0x00000014 + CKM_DSA_SHA384 Mechanism = 0x00000015 + CKM_DSA_SHA512 Mechanism = 0x00000016 CKM_DH_PKCS_KEY_PAIR_GEN Mechanism = 0x00000020 CKM_DH_PKCS_DERIVE Mechanism = 0x00000021 CKM_X9_42_DH_KEY_PAIR_GEN Mechanism = 0x00000030 @@ -466,6 +682,10 @@ const ( CKM_EC_KEY_PAIR_GEN Mechanism = 0x00001040 CKM_ECDSA Mechanism = 0x00001041 CKM_ECDSA_SHA1 Mechanism = 0x00001042 + CKM_ECDSA_SHA224 Mechanism = 0x00001043 + CKM_ECDSA_SHA256 Mechanism = 0x00001044 + CKM_ECDSA_SHA384 Mechanism = 0x00001045 + CKM_ECDSA_SHA512 Mechanism = 0x00001046 CKM_ECDH1_DERIVE Mechanism = 0x00001050 CKM_ECDH1_COFACTOR_DERIVE Mechanism = 0x00001051 CKM_ECMQV_DERIVE Mechanism = 0x00001052 @@ -487,9 +707,9 @@ const ( CKM_AES_CTR Mechanism = 0x00001086 CKM_AES_GCM Mechanism = 0x00001087 CKM_AES_CCM Mechanism = 0x00001088 - CKM_AES_CMAC_GENERAL Mechanism = 0x00001089 + CKM_AES_CTS Mechanism = 0x00001089 CKM_AES_CMAC Mechanism = 0x0000108a - CKM_AES_CTS Mechanism = 0x0000108b + CKM_AES_CMAC_GENERAL Mechanism = 0x0000108b CKM_AES_XCBC_MAC Mechanism = 0x0000108c CKM_AES_XCBC_MAC_96 Mechanism = 0x0000108d CKM_AES_GMAC Mechanism = 0x0000108e @@ -558,18 +778,28 @@ const ( CKM_IBM_SHA512_224_HMAC_GENERAL Mechanism = CKM_VENDOR_DEFINED + 0x10018 CKM_IBM_SHA512_256_KEY_DERIVATION Mechanism = CKM_VENDOR_DEFINED + 0x10019 CKM_IBM_SHA512_224_KEY_DERIVATION Mechanism = CKM_VENDOR_DEFINED + 0x1001a - CKM_IBM_EC_C25519 Mechanism = CKM_VENDOR_DEFINED + 0x1001b - CKM_IBM_EDDSA_SHA512 Mechanism = CKM_VENDOR_DEFINED + 0x1001c - CKM_IBM_EDDSA_PH_SHA512 Mechanism = CKM_VENDOR_DEFINED + 0x1001d - CKM_IBM_EC_C448 Mechanism = CKM_VENDOR_DEFINED + 0x1001e + CKM_IBM_EC_X25519 Mechanism = CKM_VENDOR_DEFINED + 0x1001b + CKM_IBM_ED25519_SHA512 Mechanism = CKM_VENDOR_DEFINED + 0x1001c + CKM_IBM_ED25519_PH_SHA512 Mechanism = CKM_VENDOR_DEFINED + 0x1001d + CKM_IBM_EC_X448 Mechanism = CKM_VENDOR_DEFINED + 0x1001e CKM_IBM_ED448_SHA3 Mechanism = CKM_VENDOR_DEFINED + 0x1001f CKM_IBM_ED448_PH_SHA3 Mechanism = CKM_VENDOR_DEFINED + 0x10020 CKM_IBM_SIPHASH Mechanism = CKM_VENDOR_DEFINED + 0x10021 + CKM_IBM_ZK Mechanism = CKM_VENDOR_DEFINED + 0x10022 + CKM_IBM_DILITHIUM Mechanism = CKM_VENDOR_DEFINED + 0x10023 + CKM_IBM_SHA3_224_HMAC Mechanism = CKM_VENDOR_DEFINED + 0x10025 + CKM_IBM_SHA3_256_HMAC Mechanism = CKM_VENDOR_DEFINED + 0x10026 + CKM_IBM_SHA3_384_HMAC Mechanism = CKM_VENDOR_DEFINED + 0x10027 + CKM_IBM_SHA3_512_HMAC Mechanism = CKM_VENDOR_DEFINED + 0x10028 + CKM_IBM_EC_X25519_RAW Mechanism = CKM_VENDOR_DEFINED + 0x10029 + CKM_IBM_EC_X448_RAW Mechanism = CKM_VENDOR_DEFINED + 0x10030 CKM_IBM_CLEARKEY_TRANSPORT Mechanism = CKM_VENDOR_DEFINED + 0x20001 CKM_IBM_ATTRIBUTEBOUND_WRAP Mechanism = CKM_VENDOR_DEFINED + 0x20004 CKM_IBM_TRANSPORTKEY Mechanism = CKM_VENDOR_DEFINED + 0x20005 CKM_IBM_DH_PKCS_DERIVE_RAW Mechanism = CKM_VENDOR_DEFINED + 0x20006 CKM_IBM_ECDH1_DERIVE_RAW Mechanism = CKM_VENDOR_DEFINED + 0x20007 + CKM_IBM_POLY1305 Mechanism = CKM_VENDOR_DEFINED + 0x20008 + CKM_IBM_CHACHA20 Mechanism = CKM_VENDOR_DEFINED + 0x20009 CKM_IBM_FILE Mechanism = CKM_VENDOR_DEFINED + 0x30003 CKM_IBM_WIRETEST Mechanism = CKM_VENDOR_DEFINED + 0x30004 CKM_IBM_RETAINKEY Mechanism = CKM_VENDOR_DEFINED + 0x40001 @@ -590,11 +820,11 @@ const ( CKM_IBM_SM2_SM3_RFC Mechanism = CKM_VENDOR_DEFINED + 0x5000f CKM_IBM_SM4_MAC Mechanism = CKM_VENDOR_DEFINED + 0x58007 CKM_IBM_ISO2_SM4_MAC Mechanism = CKM_VENDOR_DEFINED + 0x58008 + CKM_IBM_CPACF_WRAP Mechanism = CKM_VENDOR_DEFINED + 0x60001 + CKM_IBM_BTC_DERIVE Mechanism = CKM_VENDOR_DEFINED + 0x70001 CKM_IBM_EPX Mechanism = CKM_VENDOR_DEFINED + 0x61100000 CKM_IBM_EPX_WPRM Mechanism = CKM_VENDOR_DEFINED + 0x61110000 - CKM_IBM_ED25519_SHA512 Mechanism = CKM_VENDOR_DEFINED + 0x1001c - CKF_DONT_BLOCK MechanismInfoFlag = 0x00000001 CKF_HW MechanismInfoFlag = 0x00000001 CKF_LIBRARY_CANT_CREATE_OS_THREADS MechanismInfoFlag = 0x00000001 @@ -749,11 +979,11 @@ const ( CKR_MUTEX_NOT_LOCKED Return = 0x000001a1 CKR_NEW_PIN_MODE Return = 0x000001b0 CKR_NEXT_OTP Return = 0x000001b1 - CKR_EXCEEDED_MAX_ITERATIONS Return = 0x000001c0 - CKR_FIPS_SELF_TEST_FAILED Return = 0x000001c1 - CKR_LIBRARY_LOAD_FAILED Return = 0x000001c2 - CKR_PIN_TOO_WEAK Return = 0x000001c3 - CKR_PUBLIC_KEY_INVALID Return = 0x000001c4 + CKR_EXCEEDED_MAX_ITERATIONS Return = 0x000001b5 + CKR_FIPS_SELF_TEST_FAILED Return = 0x000001b6 + CKR_LIBRARY_LOAD_FAILED Return = 0x000001b7 + CKR_PIN_TOO_WEAK Return = 0x000001b8 + CKR_PUBLIC_KEY_INVALID Return = 0x000001b9 CKR_FUNCTION_REJECTED Return = 0x00000200 CKR_VENDOR_DEFINED Return = 0x80000000 CKR_IBM_WKID_MISMATCH Return = CKR_VENDOR_DEFINED + 0x10001 @@ -772,6 +1002,9 @@ const ( CKR_IBM_EMBED_GENERIC Return = CKR_VENDOR_DEFINED + 0x1000f CKR_IBM_TRANSPORT_LIMIT Return = CKR_VENDOR_DEFINED + 0x10010 CKR_IBM_FCV_NOT_SET Return = CKR_VENDOR_DEFINED + 0x10011 + CKR_IBM_PERF_CATEGORY_INVALID Return = CKR_VENDOR_DEFINED + 0x10012 + CKR_IBM_API_MISMATCH Return = CKR_VENDOR_DEFINED + 0x10013 + CKR_IBM_TARGET_INVALID Return = CKR_VENDOR_DEFINED + 0x10030 CKR_VENDOR_DEFINED_GREP11 Return = CKR_VENDOR_DEFINED + 0x40000 CKR_IBM_GREP11_NOT_AUTHENTICATED Return = CKR_VENDOR_DEFINED_GREP11 + 0x1 CKR_IBM_GREP11_CANNOT_UNMARSHAL Return = CKR_VENDOR_DEFINED_GREP11 + 0x2 @@ -801,253 +1034,679 @@ const ( ) var ( - _AttributeNameToValue = map[string]Attribute{ - "CKA_CLASS": CKA_CLASS, - "CKA_TOKEN": CKA_TOKEN, - "CKA_PRIVATE": CKA_PRIVATE, - "CKA_LABEL": CKA_LABEL, - "CKA_APPLICATION": CKA_APPLICATION, - "CKA_VALUE": CKA_VALUE, - "CKA_OBJECT_ID": CKA_OBJECT_ID, - "CKA_CERTIFICATE_TYPE": CKA_CERTIFICATE_TYPE, - "CKA_ISSUER": CKA_ISSUER, - "CKA_SERIAL_NUMBER": CKA_SERIAL_NUMBER, - "CKA_AC_ISSUER": CKA_AC_ISSUER, - "CKA_OWNER": CKA_OWNER, - "CKA_ATTR_TYPES": CKA_ATTR_TYPES, - "CKA_TRUSTED": CKA_TRUSTED, - "CKA_CERTIFICATE_CATEGORY": CKA_CERTIFICATE_CATEGORY, - "CKA_JAVA_MIDP_SECURITY_DOMAIN": CKA_JAVA_MIDP_SECURITY_DOMAIN, - "CKA_URL": CKA_URL, - "CKA_HASH_OF_SUBJECT_PUBLIC_KEY": CKA_HASH_OF_SUBJECT_PUBLIC_KEY, - "CKA_HASH_OF_ISSUER_PUBLIC_KEY": CKA_HASH_OF_ISSUER_PUBLIC_KEY, - "CKA_NAME_HASH_ALGORITHM": CKA_NAME_HASH_ALGORITHM, - "CKA_CHECK_VALUE": CKA_CHECK_VALUE, - "CKA_KEY_TYPE": CKA_KEY_TYPE, - "CKA_SUBJECT": CKA_SUBJECT, - "CKA_ID": CKA_ID, - "CKA_SENSITIVE": CKA_SENSITIVE, - "CKA_ENCRYPT": CKA_ENCRYPT, - "CKA_DECRYPT": CKA_DECRYPT, - "CKA_WRAP": CKA_WRAP, - "CKA_UNWRAP": CKA_UNWRAP, - "CKA_SIGN": CKA_SIGN, - "CKA_SIGN_RECOVER": CKA_SIGN_RECOVER, - "CKA_VERIFY": CKA_VERIFY, - "CKA_VERIFY_RECOVER": CKA_VERIFY_RECOVER, - "CKA_DERIVE": CKA_DERIVE, - "CKA_START_DATE": CKA_START_DATE, - "CKA_END_DATE": CKA_END_DATE, - "CKA_MODULUS": CKA_MODULUS, - "CKA_MODULUS_BITS": CKA_MODULUS_BITS, - "CKA_PUBLIC_EXPONENT": CKA_PUBLIC_EXPONENT, - "CKA_PRIVATE_EXPONENT": CKA_PRIVATE_EXPONENT, - "CKA_PRIME_1": CKA_PRIME_1, - "CKA_PRIME_2": CKA_PRIME_2, - "CKA_EXPONENT_1": CKA_EXPONENT_1, - "CKA_EXPONENT_2": CKA_EXPONENT_2, - "CKA_COEFFICIENT": CKA_COEFFICIENT, - "CKA_PUBLIC_KEY_INFO": CKA_PUBLIC_KEY_INFO, - "CKA_PRIME": CKA_PRIME, - "CKA_SUBPRIME": CKA_SUBPRIME, - "CKA_BASE": CKA_BASE, - "CKA_PRIME_BITS": CKA_PRIME_BITS, - "CKA_SUBPRIME_BITS": CKA_SUBPRIME_BITS, - "CKA_SUB_PRIME_BITS": CKA_SUB_PRIME_BITS, - "CKA_VALUE_BITS": CKA_VALUE_BITS, - "CKA_VALUE_LEN": CKA_VALUE_LEN, - "CKA_EXTRACTABLE": CKA_EXTRACTABLE, - "CKA_LOCAL": CKA_LOCAL, - "CKA_NEVER_EXTRACTABLE": CKA_NEVER_EXTRACTABLE, - "CKA_ALWAYS_SENSITIVE": CKA_ALWAYS_SENSITIVE, - "CKA_KEY_GEN_MECHANISM": CKA_KEY_GEN_MECHANISM, - "CKA_MODIFIABLE": CKA_MODIFIABLE, - "CKA_COPYABLE": CKA_COPYABLE, - "CKA_DESTROYABLE": CKA_DESTROYABLE, - "CKA_ECDSA_PARAMS": CKA_ECDSA_PARAMS, - "CKA_EC_PARAMS": CKA_EC_PARAMS, - "CKA_EC_POINT": CKA_EC_POINT, - "CKA_SECONDARY_AUTH": CKA_SECONDARY_AUTH, - "CKA_AUTH_PIN_FLAGS": CKA_AUTH_PIN_FLAGS, - "CKA_ALWAYS_AUTHENTICATE": CKA_ALWAYS_AUTHENTICATE, - "CKA_WRAP_WITH_TRUSTED": CKA_WRAP_WITH_TRUSTED, - "CKA_OTP_FORMAT": CKA_OTP_FORMAT, - "CKA_OTP_LENGTH": CKA_OTP_LENGTH, - "CKA_OTP_TIME_INTERVAL": CKA_OTP_TIME_INTERVAL, - "CKA_OTP_USER_FRIENDLY_MODE": CKA_OTP_USER_FRIENDLY_MODE, - "CKA_OTP_CHALLENGE_REQUIREMENT": CKA_OTP_CHALLENGE_REQUIREMENT, - "CKA_OTP_TIME_REQUIREMENT": CKA_OTP_TIME_REQUIREMENT, - "CKA_OTP_COUNTER_REQUIREMENT": CKA_OTP_COUNTER_REQUIREMENT, - "CKA_OTP_PIN_REQUIREMENT": CKA_OTP_PIN_REQUIREMENT, - "CKA_OTP_USER_IDENTIFIER": CKA_OTP_USER_IDENTIFIER, - "CKA_OTP_SERVICE_IDENTIFIER": CKA_OTP_SERVICE_IDENTIFIER, - "CKA_OTP_SERVICE_LOGO": CKA_OTP_SERVICE_LOGO, - "CKA_OTP_SERVICE_LOGO_TYPE": CKA_OTP_SERVICE_LOGO_TYPE, - "CKA_OTP_COUNTER": CKA_OTP_COUNTER, - "CKA_OTP_TIME": CKA_OTP_TIME, - "CKA_GOSTR3410_PARAMS": CKA_GOSTR3410_PARAMS, - "CKA_GOSTR3411_PARAMS": CKA_GOSTR3411_PARAMS, - "CKA_GOST28147_PARAMS": CKA_GOST28147_PARAMS, - "CKA_HW_FEATURE_TYPE": CKA_HW_FEATURE_TYPE, - "CKA_RESET_ON_INIT": CKA_RESET_ON_INIT, - "CKA_HAS_RESET": CKA_HAS_RESET, - "CKA_PIXEL_X": CKA_PIXEL_X, - "CKA_PIXEL_Y": CKA_PIXEL_Y, - "CKA_RESOLUTION": CKA_RESOLUTION, - "CKA_CHAR_ROWS": CKA_CHAR_ROWS, - "CKA_CHAR_COLUMNS": CKA_CHAR_COLUMNS, - "CKA_COLOR": CKA_COLOR, - "CKA_BITS_PER_PIXEL": CKA_BITS_PER_PIXEL, - "CKA_CHAR_SETS": CKA_CHAR_SETS, - "CKA_ENCODING_METHODS": CKA_ENCODING_METHODS, - "CKA_MIME_TYPES": CKA_MIME_TYPES, - "CKA_MECHANISM_TYPE": CKA_MECHANISM_TYPE, - "CKA_REQUIRED_CMS_ATTRIBUTES": CKA_REQUIRED_CMS_ATTRIBUTES, - "CKA_DEFAULT_CMS_ATTRIBUTES": CKA_DEFAULT_CMS_ATTRIBUTES, - "CKA_SUPPORTED_CMS_ATTRIBUTES": CKA_SUPPORTED_CMS_ATTRIBUTES, - "CKA_WRAP_TEMPLATE": CKA_WRAP_TEMPLATE, - "CKA_UNWRAP_TEMPLATE": CKA_UNWRAP_TEMPLATE, - "CKA_ALLOWED_MECHANISMS": CKA_ALLOWED_MECHANISMS, - "CKA_VENDOR_DEFINED": CKA_VENDOR_DEFINED, - "CKA_IBM_RESTRICTABLE": CKA_IBM_RESTRICTABLE, - "CKA_IBM_NEVER_MODIFIABLE": CKA_IBM_NEVER_MODIFIABLE, - "CKA_IBM_RETAINKEY": CKA_IBM_RETAINKEY, - "CKA_IBM_ATTRBOUND": CKA_IBM_ATTRBOUND, - "CKA_IBM_KEYTYPE": CKA_IBM_KEYTYPE, - "CKA_IBM_CV": CKA_IBM_CV, - "CKA_IBM_MACKEY": CKA_IBM_MACKEY, - "CKA_IBM_USE_AS_DATA": CKA_IBM_USE_AS_DATA, - "CKA_IBM_STRUCT_PARAMS": CKA_IBM_STRUCT_PARAMS, - "CKA_IBM_STD_COMPLIANCE1": CKA_IBM_STD_COMPLIANCE1, - "CKA_IBM_MLS_TYPE": CKA_IBM_MLS_TYPE, - "CKA_IBM_WIRETEST": CKA_IBM_WIRETEST, - "CKA_VENDOR_DEFINED_GREP11": CKA_VENDOR_DEFINED_GREP11, - "CKA_GREP11_RAW_KEYBLOB": CKA_GREP11_RAW_KEYBLOB, - "CKA_IBM_EPX": CKA_IBM_EPX, - } - _AttributeValueToName = map[Attribute]string{ - CKA_CLASS: "CKA_CLASS", - CKA_TOKEN: "CKA_TOKEN", - CKA_PRIVATE: "CKA_PRIVATE", - CKA_LABEL: "CKA_LABEL", - CKA_APPLICATION: "CKA_APPLICATION", - CKA_VALUE: "CKA_VALUE", - CKA_OBJECT_ID: "CKA_OBJECT_ID", - CKA_CERTIFICATE_TYPE: "CKA_CERTIFICATE_TYPE", - CKA_ISSUER: "CKA_ISSUER", - CKA_SERIAL_NUMBER: "CKA_SERIAL_NUMBER", - CKA_AC_ISSUER: "CKA_AC_ISSUER", - CKA_OWNER: "CKA_OWNER", - CKA_ATTR_TYPES: "CKA_ATTR_TYPES", - CKA_TRUSTED: "CKA_TRUSTED", - CKA_CERTIFICATE_CATEGORY: "CKA_CERTIFICATE_CATEGORY", - CKA_JAVA_MIDP_SECURITY_DOMAIN: "CKA_JAVA_MIDP_SECURITY_DOMAIN", - CKA_URL: "CKA_URL", - CKA_HASH_OF_SUBJECT_PUBLIC_KEY: "CKA_HASH_OF_SUBJECT_PUBLIC_KEY", - CKA_HASH_OF_ISSUER_PUBLIC_KEY: "CKA_HASH_OF_ISSUER_PUBLIC_KEY", - CKA_NAME_HASH_ALGORITHM: "CKA_NAME_HASH_ALGORITHM", - CKA_CHECK_VALUE: "CKA_CHECK_VALUE", - CKA_KEY_TYPE: "CKA_KEY_TYPE", - CKA_SUBJECT: "CKA_SUBJECT", - CKA_ID: "CKA_ID", - CKA_SENSITIVE: "CKA_SENSITIVE", - CKA_ENCRYPT: "CKA_ENCRYPT", - CKA_DECRYPT: "CKA_DECRYPT", - CKA_WRAP: "CKA_WRAP", - CKA_UNWRAP: "CKA_UNWRAP", - CKA_SIGN: "CKA_SIGN", - CKA_SIGN_RECOVER: "CKA_SIGN_RECOVER", - CKA_VERIFY: "CKA_VERIFY", - CKA_VERIFY_RECOVER: "CKA_VERIFY_RECOVER", - CKA_DERIVE: "CKA_DERIVE", - CKA_START_DATE: "CKA_START_DATE", - CKA_END_DATE: "CKA_END_DATE", - CKA_MODULUS: "CKA_MODULUS", - CKA_MODULUS_BITS: "CKA_MODULUS_BITS", - CKA_PUBLIC_EXPONENT: "CKA_PUBLIC_EXPONENT", - CKA_PRIVATE_EXPONENT: "CKA_PRIVATE_EXPONENT", - CKA_PRIME_1: "CKA_PRIME_1", - CKA_PRIME_2: "CKA_PRIME_2", - CKA_EXPONENT_1: "CKA_EXPONENT_1", - CKA_EXPONENT_2: "CKA_EXPONENT_2", - CKA_COEFFICIENT: "CKA_COEFFICIENT", - CKA_PUBLIC_KEY_INFO: "CKA_PUBLIC_KEY_INFO", - CKA_PRIME: "CKA_PRIME", - CKA_SUBPRIME: "CKA_SUBPRIME", - CKA_BASE: "CKA_BASE", - CKA_PRIME_BITS: "CKA_PRIME_BITS", - CKA_SUBPRIME_BITS: "CKA_SUBPRIME_BITS", - CKA_VALUE_BITS: "CKA_VALUE_BITS", - CKA_VALUE_LEN: "CKA_VALUE_LEN", - CKA_EXTRACTABLE: "CKA_EXTRACTABLE", - CKA_LOCAL: "CKA_LOCAL", - CKA_NEVER_EXTRACTABLE: "CKA_NEVER_EXTRACTABLE", - CKA_ALWAYS_SENSITIVE: "CKA_ALWAYS_SENSITIVE", - CKA_KEY_GEN_MECHANISM: "CKA_KEY_GEN_MECHANISM", - CKA_MODIFIABLE: "CKA_MODIFIABLE", - CKA_COPYABLE: "CKA_COPYABLE", - CKA_DESTROYABLE: "CKA_DESTROYABLE", - CKA_EC_PARAMS: "CKA_EC_PARAMS", - CKA_EC_POINT: "CKA_EC_POINT", - CKA_SECONDARY_AUTH: "CKA_SECONDARY_AUTH", - CKA_AUTH_PIN_FLAGS: "CKA_AUTH_PIN_FLAGS", - CKA_ALWAYS_AUTHENTICATE: "CKA_ALWAYS_AUTHENTICATE", - CKA_WRAP_WITH_TRUSTED: "CKA_WRAP_WITH_TRUSTED", - CKA_OTP_FORMAT: "CKA_OTP_FORMAT", - CKA_OTP_LENGTH: "CKA_OTP_LENGTH", - CKA_OTP_TIME_INTERVAL: "CKA_OTP_TIME_INTERVAL", - CKA_OTP_USER_FRIENDLY_MODE: "CKA_OTP_USER_FRIENDLY_MODE", - CKA_OTP_CHALLENGE_REQUIREMENT: "CKA_OTP_CHALLENGE_REQUIREMENT", - CKA_OTP_TIME_REQUIREMENT: "CKA_OTP_TIME_REQUIREMENT", - CKA_OTP_COUNTER_REQUIREMENT: "CKA_OTP_COUNTER_REQUIREMENT", - CKA_OTP_PIN_REQUIREMENT: "CKA_OTP_PIN_REQUIREMENT", - CKA_OTP_USER_IDENTIFIER: "CKA_OTP_USER_IDENTIFIER", - CKA_OTP_SERVICE_IDENTIFIER: "CKA_OTP_SERVICE_IDENTIFIER", - CKA_OTP_SERVICE_LOGO: "CKA_OTP_SERVICE_LOGO", - CKA_OTP_SERVICE_LOGO_TYPE: "CKA_OTP_SERVICE_LOGO_TYPE", - CKA_OTP_COUNTER: "CKA_OTP_COUNTER", - CKA_OTP_TIME: "CKA_OTP_TIME", - CKA_GOSTR3410_PARAMS: "CKA_GOSTR3410_PARAMS", - CKA_GOSTR3411_PARAMS: "CKA_GOSTR3411_PARAMS", - CKA_GOST28147_PARAMS: "CKA_GOST28147_PARAMS", - CKA_HW_FEATURE_TYPE: "CKA_HW_FEATURE_TYPE", - CKA_RESET_ON_INIT: "CKA_RESET_ON_INIT", - CKA_HAS_RESET: "CKA_HAS_RESET", - CKA_PIXEL_X: "CKA_PIXEL_X", - CKA_PIXEL_Y: "CKA_PIXEL_Y", - CKA_RESOLUTION: "CKA_RESOLUTION", - CKA_CHAR_ROWS: "CKA_CHAR_ROWS", - CKA_CHAR_COLUMNS: "CKA_CHAR_COLUMNS", - CKA_COLOR: "CKA_COLOR", - CKA_BITS_PER_PIXEL: "CKA_BITS_PER_PIXEL", - CKA_CHAR_SETS: "CKA_CHAR_SETS", - CKA_ENCODING_METHODS: "CKA_ENCODING_METHODS", - CKA_MIME_TYPES: "CKA_MIME_TYPES", - CKA_MECHANISM_TYPE: "CKA_MECHANISM_TYPE", - CKA_REQUIRED_CMS_ATTRIBUTES: "CKA_REQUIRED_CMS_ATTRIBUTES", - CKA_DEFAULT_CMS_ATTRIBUTES: "CKA_DEFAULT_CMS_ATTRIBUTES", - CKA_SUPPORTED_CMS_ATTRIBUTES: "CKA_SUPPORTED_CMS_ATTRIBUTES", - CKA_WRAP_TEMPLATE: "CKA_WRAP_TEMPLATE", - CKA_UNWRAP_TEMPLATE: "CKA_UNWRAP_TEMPLATE", - CKA_ALLOWED_MECHANISMS: "CKA_ALLOWED_MECHANISMS", - CKA_VENDOR_DEFINED: "CKA_VENDOR_DEFINED", - CKA_IBM_RESTRICTABLE: "CKA_IBM_RESTRICTABLE", - CKA_IBM_NEVER_MODIFIABLE: "CKA_IBM_NEVER_MODIFIABLE", - CKA_IBM_RETAINKEY: "CKA_IBM_RETAINKEY", - CKA_IBM_ATTRBOUND: "CKA_IBM_ATTRBOUND", - CKA_IBM_KEYTYPE: "CKA_IBM_KEYTYPE", - CKA_IBM_CV: "CKA_IBM_CV", - CKA_IBM_MACKEY: "CKA_IBM_MACKEY", - CKA_IBM_USE_AS_DATA: "CKA_IBM_USE_AS_DATA", - CKA_IBM_STRUCT_PARAMS: "CKA_IBM_STRUCT_PARAMS", - CKA_IBM_STD_COMPLIANCE1: "CKA_IBM_STD_COMPLIANCE1", - CKA_IBM_MLS_TYPE: "CKA_IBM_MLS_TYPE", - CKA_IBM_WIRETEST: "CKA_IBM_WIRETEST", - CKA_VENDOR_DEFINED_GREP11: "CKA_VENDOR_DEFINED_GREP11", - CKA_GREP11_RAW_KEYBLOB: "CKA_GREP11_RAW_KEYBLOB", - CKA_IBM_EPX: "CKA_IBM_EPX", - } - _KeyTypeNameToValue = map[string]KeyType{ + AdminCommandNameToValue = map[string]AdminCommand{ + "XCP_ADM_ADMIN_LOGIN": XCP_ADM_ADMIN_LOGIN, + "XCP_ADM_DOM_ADMIN_LOGIN": XCP_ADM_DOM_ADMIN_LOGIN, + "XCP_ADM_ADMIN_LOGOUT": XCP_ADM_ADMIN_LOGOUT, + "XCP_ADM_DOM_ADMIN_LOGOUT": XCP_ADM_DOM_ADMIN_LOGOUT, + "XCP_ADM_ADMIN_REPLACE": XCP_ADM_ADMIN_REPLACE, + "XCP_ADM_DOM_ADMIN_REPLACE": XCP_ADM_DOM_ADMIN_REPLACE, + "XCP_ADM_SET_ATTR": XCP_ADM_SET_ATTR, + "XCP_ADM_DOM_SET_ATTR": XCP_ADM_DOM_SET_ATTR, + "XCP_ADM_GEN_DOM_IMPORTER": XCP_ADM_GEN_DOM_IMPORTER, + "XCP_ADM_GEN_WK": XCP_ADM_GEN_WK, + "XCP_ADM_EXPORT_WK": XCP_ADM_EXPORT_WK, + "XCP_ADM_IMPORT_WK": XCP_ADM_IMPORT_WK, + "XCP_ADM_COMMIT_WK": XCP_ADM_COMMIT_WK, + "XCP_ADM_FINALIZE_WK": XCP_ADM_FINALIZE_WK, + "XCP_ADM_ZEROIZE": XCP_ADM_ZEROIZE, + "XCP_ADM_DOM_ZEROIZE": XCP_ADM_DOM_ZEROIZE, + "XCP_ADM_DOM_CTRLPOINT_SET": XCP_ADM_DOM_CTRLPOINT_SET, + "XCP_ADM_DOM_CTRLPOINT_ADD": XCP_ADM_DOM_CTRLPOINT_ADD, + "XCP_ADM_DOM_CTRLPOINT_DEL": XCP_ADM_DOM_CTRLPOINT_DEL, + "XCP_ADM_SET_CLOCK": XCP_ADM_SET_CLOCK, + "XCP_ADM_SET_FCV": XCP_ADM_SET_FCV, + "XCP_ADM_CTRLPOINT_SET": XCP_ADM_CTRLPOINT_SET, + "XCP_ADM_CTRLPOINT_ADD": XCP_ADM_CTRLPOINT_ADD, + "XCP_ADM_CTRLPOINT_DEL": XCP_ADM_CTRLPOINT_DEL, + "XCP_ADM_REENCRYPT": XCP_ADM_REENCRYPT, + "XCP_ADM_RK_REMOVE": XCP_ADM_RK_REMOVE, + "XCP_ADM_CLEAR_WK": XCP_ADM_CLEAR_WK, + "XCP_ADM_CLEAR_NEXT_WK": XCP_ADM_CLEAR_NEXT_WK, + "XCP_ADM_SYSTEM_ZEROIZE": XCP_ADM_SYSTEM_ZEROIZE, + "XCP_ADM_EXPORT_STATE": XCP_ADM_EXPORT_STATE, + "XCP_ADM_IMPORT_STATE": XCP_ADM_IMPORT_STATE, + "XCP_ADM_COMMIT_STATE": XCP_ADM_COMMIT_STATE, + "XCP_ADM_REMOVE_STATE": XCP_ADM_REMOVE_STATE, + "XCP_ADM_GEN_MODULE_IMPORTER": XCP_ADM_GEN_MODULE_IMPORTER, + "XCP_ADM_SET_TRUSTED": XCP_ADM_SET_TRUSTED, + "XCP_ADM_DOMAINS_ZEROIZE": XCP_ADM_DOMAINS_ZEROIZE, + "XCP_ADM_SESSION_REMOVE": XCP_ADM_SESSION_REMOVE, + "XCP_ADM_EXPORT_NEXT_WK": XCP_ADM_EXPORT_NEXT_WK, + "XCP_ADMQ_ADMIN": XCP_ADMQ_ADMIN, + "XCP_ADMQ_DOMADMIN": XCP_ADMQ_DOMADMIN, + "XCP_ADMQ_DEVICE_CERT": XCP_ADMQ_DEVICE_CERT, + "XCP_ADMQ_DOM_IMPORTER_CERT": XCP_ADMQ_DOM_IMPORTER_CERT, + "XCP_ADMQ_CTRLPOINTS": XCP_ADMQ_CTRLPOINTS, + "XCP_ADMQ_DOM_CTRLPOINTS": XCP_ADMQ_DOM_CTRLPOINTS, + "XCP_ADMQ_WK": XCP_ADMQ_WK, + "XCP_ADMQ_NEXT_WK": XCP_ADMQ_NEXT_WK, + "XCP_ADMQ_ATTRS": XCP_ADMQ_ATTRS, + "XCP_ADMQ_DOM_ATTRS": XCP_ADMQ_DOM_ATTRS, + "XCP_ADMQ_FCV": XCP_ADMQ_FCV, + "XCP_ADMQ_WK_ORIGINS": XCP_ADMQ_WK_ORIGINS, + "XCP_ADMQ_RKLIST": XCP_ADMQ_RKLIST, + "XCP_ADMQ_INTERNAL_STATE": XCP_ADMQ_INTERNAL_STATE, + "XCP_ADMQ_IMPORTER_CERT": XCP_ADMQ_IMPORTER_CERT, + "XCP_ADMQ_AUDIT_STATE": XCP_ADMQ_AUDIT_STATE, + "XCP_ADMQ_LASTCMD_DOM_MASK": XCP_ADMQ_LASTCMD_DOM_MASK, + } + AdminCommandValueToName = map[AdminCommand]string{ + XCP_ADM_ADMIN_LOGIN: "XCP_ADM_ADMIN_LOGIN", + XCP_ADM_DOM_ADMIN_LOGIN: "XCP_ADM_DOM_ADMIN_LOGIN", + XCP_ADM_ADMIN_LOGOUT: "XCP_ADM_ADMIN_LOGOUT", + XCP_ADM_DOM_ADMIN_LOGOUT: "XCP_ADM_DOM_ADMIN_LOGOUT", + XCP_ADM_ADMIN_REPLACE: "XCP_ADM_ADMIN_REPLACE", + XCP_ADM_DOM_ADMIN_REPLACE: "XCP_ADM_DOM_ADMIN_REPLACE", + XCP_ADM_SET_ATTR: "XCP_ADM_SET_ATTR", + XCP_ADM_DOM_SET_ATTR: "XCP_ADM_DOM_SET_ATTR", + XCP_ADM_GEN_DOM_IMPORTER: "XCP_ADM_GEN_DOM_IMPORTER", + XCP_ADM_GEN_WK: "XCP_ADM_GEN_WK", + XCP_ADM_EXPORT_WK: "XCP_ADM_EXPORT_WK", + XCP_ADM_IMPORT_WK: "XCP_ADM_IMPORT_WK", + XCP_ADM_COMMIT_WK: "XCP_ADM_COMMIT_WK", + XCP_ADM_FINALIZE_WK: "XCP_ADM_FINALIZE_WK", + XCP_ADM_ZEROIZE: "XCP_ADM_ZEROIZE", + XCP_ADM_DOM_ZEROIZE: "XCP_ADM_DOM_ZEROIZE", + XCP_ADM_DOM_CTRLPOINT_SET: "XCP_ADM_DOM_CTRLPOINT_SET", + XCP_ADM_DOM_CTRLPOINT_ADD: "XCP_ADM_DOM_CTRLPOINT_ADD", + XCP_ADM_DOM_CTRLPOINT_DEL: "XCP_ADM_DOM_CTRLPOINT_DEL", + XCP_ADM_SET_CLOCK: "XCP_ADM_SET_CLOCK", + XCP_ADM_SET_FCV: "XCP_ADM_SET_FCV", + XCP_ADM_CTRLPOINT_SET: "XCP_ADM_CTRLPOINT_SET", + XCP_ADM_CTRLPOINT_ADD: "XCP_ADM_CTRLPOINT_ADD", + XCP_ADM_CTRLPOINT_DEL: "XCP_ADM_CTRLPOINT_DEL", + XCP_ADM_REENCRYPT: "XCP_ADM_REENCRYPT", + XCP_ADM_RK_REMOVE: "XCP_ADM_RK_REMOVE", + XCP_ADM_CLEAR_WK: "XCP_ADM_CLEAR_WK", + XCP_ADM_CLEAR_NEXT_WK: "XCP_ADM_CLEAR_NEXT_WK", + XCP_ADM_SYSTEM_ZEROIZE: "XCP_ADM_SYSTEM_ZEROIZE", + XCP_ADM_EXPORT_STATE: "XCP_ADM_EXPORT_STATE", + XCP_ADM_IMPORT_STATE: "XCP_ADM_IMPORT_STATE", + XCP_ADM_COMMIT_STATE: "XCP_ADM_COMMIT_STATE", + XCP_ADM_REMOVE_STATE: "XCP_ADM_REMOVE_STATE", + XCP_ADM_GEN_MODULE_IMPORTER: "XCP_ADM_GEN_MODULE_IMPORTER", + XCP_ADM_SET_TRUSTED: "XCP_ADM_SET_TRUSTED", + XCP_ADM_DOMAINS_ZEROIZE: "XCP_ADM_DOMAINS_ZEROIZE", + XCP_ADM_SESSION_REMOVE: "XCP_ADM_SESSION_REMOVE", + XCP_ADM_EXPORT_NEXT_WK: "XCP_ADM_EXPORT_NEXT_WK", + XCP_ADMQ_ADMIN: "XCP_ADMQ_ADMIN", + XCP_ADMQ_DOMADMIN: "XCP_ADMQ_DOMADMIN", + XCP_ADMQ_DEVICE_CERT: "XCP_ADMQ_DEVICE_CERT", + XCP_ADMQ_DOM_IMPORTER_CERT: "XCP_ADMQ_DOM_IMPORTER_CERT", + XCP_ADMQ_CTRLPOINTS: "XCP_ADMQ_CTRLPOINTS", + XCP_ADMQ_DOM_CTRLPOINTS: "XCP_ADMQ_DOM_CTRLPOINTS", + XCP_ADMQ_WK: "XCP_ADMQ_WK", + XCP_ADMQ_NEXT_WK: "XCP_ADMQ_NEXT_WK", + XCP_ADMQ_ATTRS: "XCP_ADMQ_ATTRS", + XCP_ADMQ_DOM_ATTRS: "XCP_ADMQ_DOM_ATTRS", + XCP_ADMQ_FCV: "XCP_ADMQ_FCV", + XCP_ADMQ_WK_ORIGINS: "XCP_ADMQ_WK_ORIGINS", + XCP_ADMQ_RKLIST: "XCP_ADMQ_RKLIST", + XCP_ADMQ_INTERNAL_STATE: "XCP_ADMQ_INTERNAL_STATE", + XCP_ADMQ_IMPORTER_CERT: "XCP_ADMQ_IMPORTER_CERT", + XCP_ADMQ_AUDIT_STATE: "XCP_ADMQ_AUDIT_STATE", + XCP_ADMQ_LASTCMD_DOM_MASK: "XCP_ADMQ_LASTCMD_DOM_MASK", + } + AttributeNameToValue = map[string]Attribute{ + "CKA_CLASS": CKA_CLASS, + "CKA_TOKEN": CKA_TOKEN, + "CKA_PRIVATE": CKA_PRIVATE, + "CKA_LABEL": CKA_LABEL, + "CKA_APPLICATION": CKA_APPLICATION, + "CKA_VALUE": CKA_VALUE, + "CKA_OBJECT_ID": CKA_OBJECT_ID, + "CKA_CERTIFICATE_TYPE": CKA_CERTIFICATE_TYPE, + "CKA_ISSUER": CKA_ISSUER, + "CKA_SERIAL_NUMBER": CKA_SERIAL_NUMBER, + "CKA_AC_ISSUER": CKA_AC_ISSUER, + "CKA_OWNER": CKA_OWNER, + "CKA_ATTR_TYPES": CKA_ATTR_TYPES, + "CKA_TRUSTED": CKA_TRUSTED, + "CKA_CERTIFICATE_CATEGORY": CKA_CERTIFICATE_CATEGORY, + "CKA_JAVA_MIDP_SECURITY_DOMAIN": CKA_JAVA_MIDP_SECURITY_DOMAIN, + "CKA_URL": CKA_URL, + "CKA_HASH_OF_SUBJECT_PUBLIC_KEY": CKA_HASH_OF_SUBJECT_PUBLIC_KEY, + "CKA_HASH_OF_ISSUER_PUBLIC_KEY": CKA_HASH_OF_ISSUER_PUBLIC_KEY, + "CKA_NAME_HASH_ALGORITHM": CKA_NAME_HASH_ALGORITHM, + "CKA_CHECK_VALUE": CKA_CHECK_VALUE, + "CKA_KEY_TYPE": CKA_KEY_TYPE, + "CKA_SUBJECT": CKA_SUBJECT, + "CKA_ID": CKA_ID, + "CKA_SENSITIVE": CKA_SENSITIVE, + "CKA_ENCRYPT": CKA_ENCRYPT, + "CKA_DECRYPT": CKA_DECRYPT, + "CKA_WRAP": CKA_WRAP, + "CKA_UNWRAP": CKA_UNWRAP, + "CKA_SIGN": CKA_SIGN, + "CKA_SIGN_RECOVER": CKA_SIGN_RECOVER, + "CKA_VERIFY": CKA_VERIFY, + "CKA_VERIFY_RECOVER": CKA_VERIFY_RECOVER, + "CKA_DERIVE": CKA_DERIVE, + "CKA_START_DATE": CKA_START_DATE, + "CKA_END_DATE": CKA_END_DATE, + "CKA_MODULUS": CKA_MODULUS, + "CKA_MODULUS_BITS": CKA_MODULUS_BITS, + "CKA_PUBLIC_EXPONENT": CKA_PUBLIC_EXPONENT, + "CKA_PRIVATE_EXPONENT": CKA_PRIVATE_EXPONENT, + "CKA_PRIME_1": CKA_PRIME_1, + "CKA_PRIME_2": CKA_PRIME_2, + "CKA_EXPONENT_1": CKA_EXPONENT_1, + "CKA_EXPONENT_2": CKA_EXPONENT_2, + "CKA_COEFFICIENT": CKA_COEFFICIENT, + "CKA_PUBLIC_KEY_INFO": CKA_PUBLIC_KEY_INFO, + "CKA_PRIME": CKA_PRIME, + "CKA_SUBPRIME": CKA_SUBPRIME, + "CKA_BASE": CKA_BASE, + "CKA_PRIME_BITS": CKA_PRIME_BITS, + "CKA_SUBPRIME_BITS": CKA_SUBPRIME_BITS, + "CKA_SUB_PRIME_BITS": CKA_SUB_PRIME_BITS, + "CKA_VALUE_BITS": CKA_VALUE_BITS, + "CKA_VALUE_LEN": CKA_VALUE_LEN, + "CKA_EXTRACTABLE": CKA_EXTRACTABLE, + "CKA_LOCAL": CKA_LOCAL, + "CKA_NEVER_EXTRACTABLE": CKA_NEVER_EXTRACTABLE, + "CKA_ALWAYS_SENSITIVE": CKA_ALWAYS_SENSITIVE, + "CKA_KEY_GEN_MECHANISM": CKA_KEY_GEN_MECHANISM, + "CKA_MODIFIABLE": CKA_MODIFIABLE, + "CKA_COPYABLE": CKA_COPYABLE, + "CKA_DESTROYABLE": CKA_DESTROYABLE, + "CKA_ECDSA_PARAMS": CKA_ECDSA_PARAMS, + "CKA_EC_PARAMS": CKA_EC_PARAMS, + "CKA_EC_POINT": CKA_EC_POINT, + "CKA_SECONDARY_AUTH": CKA_SECONDARY_AUTH, + "CKA_AUTH_PIN_FLAGS": CKA_AUTH_PIN_FLAGS, + "CKA_ALWAYS_AUTHENTICATE": CKA_ALWAYS_AUTHENTICATE, + "CKA_WRAP_WITH_TRUSTED": CKA_WRAP_WITH_TRUSTED, + "CKA_OTP_FORMAT": CKA_OTP_FORMAT, + "CKA_OTP_LENGTH": CKA_OTP_LENGTH, + "CKA_OTP_TIME_INTERVAL": CKA_OTP_TIME_INTERVAL, + "CKA_OTP_USER_FRIENDLY_MODE": CKA_OTP_USER_FRIENDLY_MODE, + "CKA_OTP_CHALLENGE_REQUIREMENT": CKA_OTP_CHALLENGE_REQUIREMENT, + "CKA_OTP_TIME_REQUIREMENT": CKA_OTP_TIME_REQUIREMENT, + "CKA_OTP_COUNTER_REQUIREMENT": CKA_OTP_COUNTER_REQUIREMENT, + "CKA_OTP_PIN_REQUIREMENT": CKA_OTP_PIN_REQUIREMENT, + "CKA_OTP_USER_IDENTIFIER": CKA_OTP_USER_IDENTIFIER, + "CKA_OTP_SERVICE_IDENTIFIER": CKA_OTP_SERVICE_IDENTIFIER, + "CKA_OTP_SERVICE_LOGO": CKA_OTP_SERVICE_LOGO, + "CKA_OTP_SERVICE_LOGO_TYPE": CKA_OTP_SERVICE_LOGO_TYPE, + "CKA_OTP_COUNTER": CKA_OTP_COUNTER, + "CKA_OTP_TIME": CKA_OTP_TIME, + "CKA_GOSTR3410_PARAMS": CKA_GOSTR3410_PARAMS, + "CKA_GOSTR3411_PARAMS": CKA_GOSTR3411_PARAMS, + "CKA_GOST28147_PARAMS": CKA_GOST28147_PARAMS, + "CKA_HW_FEATURE_TYPE": CKA_HW_FEATURE_TYPE, + "CKA_RESET_ON_INIT": CKA_RESET_ON_INIT, + "CKA_HAS_RESET": CKA_HAS_RESET, + "CKA_PIXEL_X": CKA_PIXEL_X, + "CKA_PIXEL_Y": CKA_PIXEL_Y, + "CKA_RESOLUTION": CKA_RESOLUTION, + "CKA_CHAR_ROWS": CKA_CHAR_ROWS, + "CKA_CHAR_COLUMNS": CKA_CHAR_COLUMNS, + "CKA_COLOR": CKA_COLOR, + "CKA_BITS_PER_PIXEL": CKA_BITS_PER_PIXEL, + "CKA_CHAR_SETS": CKA_CHAR_SETS, + "CKA_ENCODING_METHODS": CKA_ENCODING_METHODS, + "CKA_MIME_TYPES": CKA_MIME_TYPES, + "CKA_MECHANISM_TYPE": CKA_MECHANISM_TYPE, + "CKA_REQUIRED_CMS_ATTRIBUTES": CKA_REQUIRED_CMS_ATTRIBUTES, + "CKA_DEFAULT_CMS_ATTRIBUTES": CKA_DEFAULT_CMS_ATTRIBUTES, + "CKA_SUPPORTED_CMS_ATTRIBUTES": CKA_SUPPORTED_CMS_ATTRIBUTES, + "CKA_WRAP_TEMPLATE": CKA_WRAP_TEMPLATE, + "CKA_UNWRAP_TEMPLATE": CKA_UNWRAP_TEMPLATE, + "CKA_DERIVE_TEMPLATE": CKA_DERIVE_TEMPLATE, + "CKA_ALLOWED_MECHANISMS": CKA_ALLOWED_MECHANISMS, + "CKA_VENDOR_DEFINED": CKA_VENDOR_DEFINED, + "CKA_IBM_RESTRICTABLE": CKA_IBM_RESTRICTABLE, + "CKA_IBM_NEVER_MODIFIABLE": CKA_IBM_NEVER_MODIFIABLE, + "CKA_IBM_RETAINKEY": CKA_IBM_RETAINKEY, + "CKA_IBM_ATTRBOUND": CKA_IBM_ATTRBOUND, + "CKA_IBM_KEYTYPE": CKA_IBM_KEYTYPE, + "CKA_IBM_CV": CKA_IBM_CV, + "CKA_IBM_MACKEY": CKA_IBM_MACKEY, + "CKA_IBM_USE_AS_DATA": CKA_IBM_USE_AS_DATA, + "CKA_IBM_STRUCT_PARAMS": CKA_IBM_STRUCT_PARAMS, + "CKA_IBM_STD_COMPLIANCE1": CKA_IBM_STD_COMPLIANCE1, + "CKA_IBM_MLS_TYPE": CKA_IBM_MLS_TYPE, + "CKA_IBM_PROTKEY_EXTRACTABLE": CKA_IBM_PROTKEY_EXTRACTABLE, + "CKA_IBM_PROTKEY_NEVER_EXTRACTABLE": CKA_IBM_PROTKEY_NEVER_EXTRACTABLE, + "CKA_IBM_PQC_PARAMS": CKA_IBM_PQC_PARAMS, + "CKA_IBM_WIRETEST": CKA_IBM_WIRETEST, + "CKA_VENDOR_DEFINED_GREP11": CKA_VENDOR_DEFINED_GREP11, + "CKA_GREP11_RAW_KEYBLOB": CKA_GREP11_RAW_KEYBLOB, + "CKA_GREP11_VOTE_VERSION": CKA_GREP11_VOTE_VERSION, + "CKA_IBM_EPX": CKA_IBM_EPX, + } + AttributeValueToName = map[Attribute]string{ + CKA_CLASS: "CKA_CLASS", + CKA_TOKEN: "CKA_TOKEN", + CKA_PRIVATE: "CKA_PRIVATE", + CKA_LABEL: "CKA_LABEL", + CKA_APPLICATION: "CKA_APPLICATION", + CKA_VALUE: "CKA_VALUE", + CKA_OBJECT_ID: "CKA_OBJECT_ID", + CKA_CERTIFICATE_TYPE: "CKA_CERTIFICATE_TYPE", + CKA_ISSUER: "CKA_ISSUER", + CKA_SERIAL_NUMBER: "CKA_SERIAL_NUMBER", + CKA_AC_ISSUER: "CKA_AC_ISSUER", + CKA_OWNER: "CKA_OWNER", + CKA_ATTR_TYPES: "CKA_ATTR_TYPES", + CKA_TRUSTED: "CKA_TRUSTED", + CKA_CERTIFICATE_CATEGORY: "CKA_CERTIFICATE_CATEGORY", + CKA_JAVA_MIDP_SECURITY_DOMAIN: "CKA_JAVA_MIDP_SECURITY_DOMAIN", + CKA_URL: "CKA_URL", + CKA_HASH_OF_SUBJECT_PUBLIC_KEY: "CKA_HASH_OF_SUBJECT_PUBLIC_KEY", + CKA_HASH_OF_ISSUER_PUBLIC_KEY: "CKA_HASH_OF_ISSUER_PUBLIC_KEY", + CKA_NAME_HASH_ALGORITHM: "CKA_NAME_HASH_ALGORITHM", + CKA_CHECK_VALUE: "CKA_CHECK_VALUE", + CKA_KEY_TYPE: "CKA_KEY_TYPE", + CKA_SUBJECT: "CKA_SUBJECT", + CKA_ID: "CKA_ID", + CKA_SENSITIVE: "CKA_SENSITIVE", + CKA_ENCRYPT: "CKA_ENCRYPT", + CKA_DECRYPT: "CKA_DECRYPT", + CKA_WRAP: "CKA_WRAP", + CKA_UNWRAP: "CKA_UNWRAP", + CKA_SIGN: "CKA_SIGN", + CKA_SIGN_RECOVER: "CKA_SIGN_RECOVER", + CKA_VERIFY: "CKA_VERIFY", + CKA_VERIFY_RECOVER: "CKA_VERIFY_RECOVER", + CKA_DERIVE: "CKA_DERIVE", + CKA_START_DATE: "CKA_START_DATE", + CKA_END_DATE: "CKA_END_DATE", + CKA_MODULUS: "CKA_MODULUS", + CKA_MODULUS_BITS: "CKA_MODULUS_BITS", + CKA_PUBLIC_EXPONENT: "CKA_PUBLIC_EXPONENT", + CKA_PRIVATE_EXPONENT: "CKA_PRIVATE_EXPONENT", + CKA_PRIME_1: "CKA_PRIME_1", + CKA_PRIME_2: "CKA_PRIME_2", + CKA_EXPONENT_1: "CKA_EXPONENT_1", + CKA_EXPONENT_2: "CKA_EXPONENT_2", + CKA_COEFFICIENT: "CKA_COEFFICIENT", + CKA_PUBLIC_KEY_INFO: "CKA_PUBLIC_KEY_INFO", + CKA_PRIME: "CKA_PRIME", + CKA_SUBPRIME: "CKA_SUBPRIME", + CKA_BASE: "CKA_BASE", + CKA_PRIME_BITS: "CKA_PRIME_BITS", + CKA_SUBPRIME_BITS: "CKA_SUBPRIME_BITS", + CKA_VALUE_BITS: "CKA_VALUE_BITS", + CKA_VALUE_LEN: "CKA_VALUE_LEN", + CKA_EXTRACTABLE: "CKA_EXTRACTABLE", + CKA_LOCAL: "CKA_LOCAL", + CKA_NEVER_EXTRACTABLE: "CKA_NEVER_EXTRACTABLE", + CKA_ALWAYS_SENSITIVE: "CKA_ALWAYS_SENSITIVE", + CKA_KEY_GEN_MECHANISM: "CKA_KEY_GEN_MECHANISM", + CKA_MODIFIABLE: "CKA_MODIFIABLE", + CKA_COPYABLE: "CKA_COPYABLE", + CKA_DESTROYABLE: "CKA_DESTROYABLE", + CKA_EC_PARAMS: "CKA_EC_PARAMS", + CKA_EC_POINT: "CKA_EC_POINT", + CKA_SECONDARY_AUTH: "CKA_SECONDARY_AUTH", + CKA_AUTH_PIN_FLAGS: "CKA_AUTH_PIN_FLAGS", + CKA_ALWAYS_AUTHENTICATE: "CKA_ALWAYS_AUTHENTICATE", + CKA_WRAP_WITH_TRUSTED: "CKA_WRAP_WITH_TRUSTED", + CKA_OTP_FORMAT: "CKA_OTP_FORMAT", + CKA_OTP_LENGTH: "CKA_OTP_LENGTH", + CKA_OTP_TIME_INTERVAL: "CKA_OTP_TIME_INTERVAL", + CKA_OTP_USER_FRIENDLY_MODE: "CKA_OTP_USER_FRIENDLY_MODE", + CKA_OTP_CHALLENGE_REQUIREMENT: "CKA_OTP_CHALLENGE_REQUIREMENT", + CKA_OTP_TIME_REQUIREMENT: "CKA_OTP_TIME_REQUIREMENT", + CKA_OTP_COUNTER_REQUIREMENT: "CKA_OTP_COUNTER_REQUIREMENT", + CKA_OTP_PIN_REQUIREMENT: "CKA_OTP_PIN_REQUIREMENT", + CKA_OTP_USER_IDENTIFIER: "CKA_OTP_USER_IDENTIFIER", + CKA_OTP_SERVICE_IDENTIFIER: "CKA_OTP_SERVICE_IDENTIFIER", + CKA_OTP_SERVICE_LOGO: "CKA_OTP_SERVICE_LOGO", + CKA_OTP_SERVICE_LOGO_TYPE: "CKA_OTP_SERVICE_LOGO_TYPE", + CKA_OTP_COUNTER: "CKA_OTP_COUNTER", + CKA_OTP_TIME: "CKA_OTP_TIME", + CKA_GOSTR3410_PARAMS: "CKA_GOSTR3410_PARAMS", + CKA_GOSTR3411_PARAMS: "CKA_GOSTR3411_PARAMS", + CKA_GOST28147_PARAMS: "CKA_GOST28147_PARAMS", + CKA_HW_FEATURE_TYPE: "CKA_HW_FEATURE_TYPE", + CKA_RESET_ON_INIT: "CKA_RESET_ON_INIT", + CKA_HAS_RESET: "CKA_HAS_RESET", + CKA_PIXEL_X: "CKA_PIXEL_X", + CKA_PIXEL_Y: "CKA_PIXEL_Y", + CKA_RESOLUTION: "CKA_RESOLUTION", + CKA_CHAR_ROWS: "CKA_CHAR_ROWS", + CKA_CHAR_COLUMNS: "CKA_CHAR_COLUMNS", + CKA_COLOR: "CKA_COLOR", + CKA_BITS_PER_PIXEL: "CKA_BITS_PER_PIXEL", + CKA_CHAR_SETS: "CKA_CHAR_SETS", + CKA_ENCODING_METHODS: "CKA_ENCODING_METHODS", + CKA_MIME_TYPES: "CKA_MIME_TYPES", + CKA_MECHANISM_TYPE: "CKA_MECHANISM_TYPE", + CKA_REQUIRED_CMS_ATTRIBUTES: "CKA_REQUIRED_CMS_ATTRIBUTES", + CKA_DEFAULT_CMS_ATTRIBUTES: "CKA_DEFAULT_CMS_ATTRIBUTES", + CKA_SUPPORTED_CMS_ATTRIBUTES: "CKA_SUPPORTED_CMS_ATTRIBUTES", + CKA_WRAP_TEMPLATE: "CKA_WRAP_TEMPLATE", + CKA_UNWRAP_TEMPLATE: "CKA_UNWRAP_TEMPLATE", + CKA_DERIVE_TEMPLATE: "CKA_DERIVE_TEMPLATE", + CKA_ALLOWED_MECHANISMS: "CKA_ALLOWED_MECHANISMS", + CKA_VENDOR_DEFINED: "CKA_VENDOR_DEFINED", + CKA_IBM_RESTRICTABLE: "CKA_IBM_RESTRICTABLE", + CKA_IBM_NEVER_MODIFIABLE: "CKA_IBM_NEVER_MODIFIABLE", + CKA_IBM_RETAINKEY: "CKA_IBM_RETAINKEY", + CKA_IBM_ATTRBOUND: "CKA_IBM_ATTRBOUND", + CKA_IBM_KEYTYPE: "CKA_IBM_KEYTYPE", + CKA_IBM_CV: "CKA_IBM_CV", + CKA_IBM_MACKEY: "CKA_IBM_MACKEY", + CKA_IBM_USE_AS_DATA: "CKA_IBM_USE_AS_DATA", + CKA_IBM_STRUCT_PARAMS: "CKA_IBM_STRUCT_PARAMS", + CKA_IBM_STD_COMPLIANCE1: "CKA_IBM_STD_COMPLIANCE1", + CKA_IBM_MLS_TYPE: "CKA_IBM_MLS_TYPE", + CKA_IBM_PROTKEY_EXTRACTABLE: "CKA_IBM_PROTKEY_EXTRACTABLE", + CKA_IBM_PROTKEY_NEVER_EXTRACTABLE: "CKA_IBM_PROTKEY_NEVER_EXTRACTABLE", + CKA_IBM_PQC_PARAMS: "CKA_IBM_PQC_PARAMS", + CKA_IBM_WIRETEST: "CKA_IBM_WIRETEST", + CKA_VENDOR_DEFINED_GREP11: "CKA_VENDOR_DEFINED_GREP11", + CKA_GREP11_RAW_KEYBLOB: "CKA_GREP11_RAW_KEYBLOB", + CKA_GREP11_VOTE_VERSION: "CKA_GREP11_VOTE_VERSION", + CKA_IBM_EPX: "CKA_IBM_EPX", + } + CardAttributeFlagsNameToValue = map[string]CardAttributeFlags{ + "XCP_ADMP_WK_IMPORT": XCP_ADMP_WK_IMPORT, + "XCP_ADMP_WK_EXPORT": XCP_ADMP_WK_EXPORT, + "XCP_ADMP_WK_1PART": XCP_ADMP_WK_1PART, + "XCP_ADMP_WK_RANDOM": XCP_ADMP_WK_RANDOM, + "XCP_ADMP_1SIGN": XCP_ADMP_1SIGN, + "XCP_ADMP_CP_1SIGN": XCP_ADMP_CP_1SIGN, + "XCP_ADMP_ZERO_1SIGN": XCP_ADMP_ZERO_1SIGN, + "XCP_ADMP_NO_DOMAIN_IMPRINT": XCP_ADMP_NO_DOMAIN_IMPRINT, + "XCP_ADMP_STATE_IMPORT": XCP_ADMP_STATE_IMPORT, + "XCP_ADMP_STATE_EXPORT": XCP_ADMP_STATE_EXPORT, + "XCP_ADMP_STATE_1PART": XCP_ADMP_STATE_1PART, + "XCP_ADMP_NO_EPX": XCP_ADMP_NO_EPX, + "XCP_ADMP_NO_EPXVM": XCP_ADMP_NO_EPXVM, + "XCP_ADMP_DO_NOT_DISTURB": XCP_ADMP_DO_NOT_DISTURB, + "XCP_ADMP__PERMS": XCP_ADMP__PERMS, + "XCP_ADMP_CHG_WK_IMPORT": XCP_ADMP_CHG_WK_IMPORT, + "XCP_ADMP_CHG_WK_EXPORT": XCP_ADMP_CHG_WK_EXPORT, + "XCP_ADMP_CHG_WK_1PART": XCP_ADMP_CHG_WK_1PART, + "XCP_ADMP_CHG_WK_RANDOM": XCP_ADMP_CHG_WK_RANDOM, + "XCP_ADMP_CHG_SIGN_THR": XCP_ADMP_CHG_SIGN_THR, + "XCP_ADMP_CHG_REVOKE_THR": XCP_ADMP_CHG_REVOKE_THR, + "XCP_ADMP_CHG_1SIGN": XCP_ADMP_CHG_1SIGN, + "XCP_ADMP_CHG_CP_1SIGN": XCP_ADMP_CHG_CP_1SIGN, + "XCP_ADMP_CHG_ZERO_1SIGN": XCP_ADMP_CHG_ZERO_1SIGN, + "XCP_ADMP_CHG_ST_IMPORT": XCP_ADMP_CHG_ST_IMPORT, + "XCP_ADMP_CHG_ST_EXPORT": XCP_ADMP_CHG_ST_EXPORT, + "XCP_ADMP_CHG_ST_1PART": XCP_ADMP_CHG_ST_1PART, + "XCP_ADMP_CHG_NO_EPX": XCP_ADMP_CHG_NO_EPX, + "XCP_ADMP_CHG_NO_EPXVM": XCP_ADMP_CHG_NO_EPXVM, + "XCP_ADMP_NOT_SUP": XCP_ADMP_NOT_SUP, + "XCP_ADMP_CHG_DO_NOT_DISTURB": XCP_ADMP_CHG_DO_NOT_DISTURB, + "XCP_ADMP__CHGBITS": XCP_ADMP__CHGBITS, + "XCP_ADMP__DEFAULT": XCP_ADMP__DEFAULT, + } + CardAttributeFlagsValueToName = map[CardAttributeFlags]string{ + XCP_ADMP_WK_IMPORT: "XCP_ADMP_WK_IMPORT", + XCP_ADMP_WK_EXPORT: "XCP_ADMP_WK_EXPORT", + XCP_ADMP_WK_1PART: "XCP_ADMP_WK_1PART", + XCP_ADMP_WK_RANDOM: "XCP_ADMP_WK_RANDOM", + XCP_ADMP_1SIGN: "XCP_ADMP_1SIGN", + XCP_ADMP_CP_1SIGN: "XCP_ADMP_CP_1SIGN", + XCP_ADMP_ZERO_1SIGN: "XCP_ADMP_ZERO_1SIGN", + XCP_ADMP_NO_DOMAIN_IMPRINT: "XCP_ADMP_NO_DOMAIN_IMPRINT", + XCP_ADMP_STATE_IMPORT: "XCP_ADMP_STATE_IMPORT", + XCP_ADMP_STATE_EXPORT: "XCP_ADMP_STATE_EXPORT", + XCP_ADMP_STATE_1PART: "XCP_ADMP_STATE_1PART", + XCP_ADMP_NO_EPX: "XCP_ADMP_NO_EPX", + XCP_ADMP_NO_EPXVM: "XCP_ADMP_NO_EPXVM", + XCP_ADMP_DO_NOT_DISTURB: "XCP_ADMP_DO_NOT_DISTURB", + XCP_ADMP__PERMS: "XCP_ADMP__PERMS", + XCP_ADMP_CHG_WK_IMPORT: "XCP_ADMP_CHG_WK_IMPORT", + XCP_ADMP_CHG_WK_EXPORT: "XCP_ADMP_CHG_WK_EXPORT", + XCP_ADMP_CHG_WK_1PART: "XCP_ADMP_CHG_WK_1PART", + XCP_ADMP_CHG_WK_RANDOM: "XCP_ADMP_CHG_WK_RANDOM", + XCP_ADMP_CHG_SIGN_THR: "XCP_ADMP_CHG_SIGN_THR", + XCP_ADMP_CHG_REVOKE_THR: "XCP_ADMP_CHG_REVOKE_THR", + XCP_ADMP_CHG_1SIGN: "XCP_ADMP_CHG_1SIGN", + XCP_ADMP_CHG_CP_1SIGN: "XCP_ADMP_CHG_CP_1SIGN", + XCP_ADMP_CHG_ZERO_1SIGN: "XCP_ADMP_CHG_ZERO_1SIGN", + XCP_ADMP_CHG_ST_IMPORT: "XCP_ADMP_CHG_ST_IMPORT", + XCP_ADMP_CHG_ST_EXPORT: "XCP_ADMP_CHG_ST_EXPORT", + XCP_ADMP_CHG_ST_1PART: "XCP_ADMP_CHG_ST_1PART", + XCP_ADMP_CHG_NO_EPX: "XCP_ADMP_CHG_NO_EPX", + XCP_ADMP_CHG_NO_EPXVM: "XCP_ADMP_CHG_NO_EPXVM", + XCP_ADMP_NOT_SUP: "XCP_ADMP_NOT_SUP", + XCP_ADMP_CHG_DO_NOT_DISTURB: "XCP_ADMP_CHG_DO_NOT_DISTURB", + XCP_ADMP__CHGBITS: "XCP_ADMP__CHGBITS", + XCP_ADMP__DEFAULT: "XCP_ADMP__DEFAULT", + } + CardAttributeKeyNameToValue = map[string]CardAttributeKey{ + "XCP_ADMINT_SIGN_THR": XCP_ADMINT_SIGN_THR, + "XCP_ADMINT_REVOKE_THR": XCP_ADMINT_REVOKE_THR, + "XCP_ADMINT_PERMS": XCP_ADMINT_PERMS, + "XCP_ADMINT_MODE": XCP_ADMINT_MODE, + "XCP_ADMINT_STD": XCP_ADMINT_STD, + } + CardAttributeKeyValueToName = map[CardAttributeKey]string{ + XCP_ADMINT_SIGN_THR: "XCP_ADMINT_SIGN_THR", + XCP_ADMINT_REVOKE_THR: "XCP_ADMINT_REVOKE_THR", + XCP_ADMINT_PERMS: "XCP_ADMINT_PERMS", + XCP_ADMINT_MODE: "XCP_ADMINT_MODE", + XCP_ADMINT_STD: "XCP_ADMINT_STD", + } + ControlPointNameToValue = map[string]ControlPoint{ + "XCP_CPB_ADD_CPBS": XCP_CPB_ADD_CPBS, + "XCP_CPB_DELETE_CPBS": XCP_CPB_DELETE_CPBS, + "XCP_CPB_SIGN_ASYMM": XCP_CPB_SIGN_ASYMM, + "XCP_CPB_SIGN_SYMM": XCP_CPB_SIGN_SYMM, + "XCP_CPB_SIGVERIFY_SYMM": XCP_CPB_SIGVERIFY_SYMM, + "XCP_CPB_ENCRYPT_SYMM": XCP_CPB_ENCRYPT_SYMM, + "XCP_CPB_DECRYPT_ASYMM": XCP_CPB_DECRYPT_ASYMM, + "XCP_CPB_DECRYPT_SYMM": XCP_CPB_DECRYPT_SYMM, + "XCP_CPB_WRAP_ASYMM": XCP_CPB_WRAP_ASYMM, + "XCP_CPB_WRAP_SYMM": XCP_CPB_WRAP_SYMM, + "XCP_CPB_UNWRAP_ASYMM": XCP_CPB_UNWRAP_ASYMM, + "XCP_CPB_UNWRAP_SYMM": XCP_CPB_UNWRAP_SYMM, + "XCP_CPB_KEYGEN_ASYMM": XCP_CPB_KEYGEN_ASYMM, + "XCP_CPB_KEYGEN_SYMM": XCP_CPB_KEYGEN_SYMM, + "XCP_CPB_RETAINKEYS": XCP_CPB_RETAINKEYS, + "XCP_CPB_SKIP_KEYTESTS": XCP_CPB_SKIP_KEYTESTS, + "XCP_CPB_NON_ATTRBOUND": XCP_CPB_NON_ATTRBOUND, + "XCP_CPB_MODIFY_OBJECTS": XCP_CPB_MODIFY_OBJECTS, + "XCP_CPB_RNG_SEED": XCP_CPB_RNG_SEED, + "XCP_CPB_ALG_RAW_RSA": XCP_CPB_ALG_RAW_RSA, + "XCP_CPB_ALG_NFIPS2009": XCP_CPB_ALG_NFIPS2009, + "XCP_CPB_ALG_NBSI2009": XCP_CPB_ALG_NBSI2009, + "XCP_CPB_KEYSZ_HMAC_ANY": XCP_CPB_KEYSZ_HMAC_ANY, + "XCP_CPB_KEYSZ_BELOW80BIT": XCP_CPB_KEYSZ_BELOW80BIT, + "XCP_CPB_KEYSZ_80BIT": XCP_CPB_KEYSZ_80BIT, + "XCP_CPB_KEYSZ_112BIT": XCP_CPB_KEYSZ_112BIT, + "XCP_CPB_KEYSZ_128BIT": XCP_CPB_KEYSZ_128BIT, + "XCP_CPB_KEYSZ_192BIT": XCP_CPB_KEYSZ_192BIT, + "XCP_CPB_KEYSZ_256BIT": XCP_CPB_KEYSZ_256BIT, + "XCP_CPB_KEYSZ_RSA65536": XCP_CPB_KEYSZ_RSA65536, + "XCP_CPB_ALG_RSA": XCP_CPB_ALG_RSA, + "XCP_CPB_ALG_DSA": XCP_CPB_ALG_DSA, + "XCP_CPB_ALG_EC": XCP_CPB_ALG_EC, + "XCP_CPB_ALG_EC_BPOOLCRV": XCP_CPB_ALG_EC_BPOOLCRV, + "XCP_CPB_ALG_EC_NISTCRV": XCP_CPB_ALG_EC_NISTCRV, + "XCP_CPB_ALG_NFIPS2011": XCP_CPB_ALG_NFIPS2011, + "XCP_CPB_ALG_NBSI2011": XCP_CPB_ALG_NBSI2011, + "XCP_CPB_USER_SET_TRUSTED": XCP_CPB_USER_SET_TRUSTED, + "XCP_CPB_ALG_SKIP_CROSSCHK": XCP_CPB_ALG_SKIP_CROSSCHK, + "XCP_CPB_WRAP_CRYPT_KEYS": XCP_CPB_WRAP_CRYPT_KEYS, + "XCP_CPB_SIGN_CRYPT_KEYS": XCP_CPB_SIGN_CRYPT_KEYS, + "XCP_CPB_WRAP_SIGN_KEYS": XCP_CPB_WRAP_SIGN_KEYS, + "XCP_CPB_USER_SET_ATTRBOUND": XCP_CPB_USER_SET_ATTRBOUND, + "XCP_CPB_ALLOW_PASSPHRASE": XCP_CPB_ALLOW_PASSPHRASE, + "XCP_CPB_WRAP_STRONGER_KEY": XCP_CPB_WRAP_STRONGER_KEY, + "XCP_CPB_WRAP_WITH_RAW_SPKI": XCP_CPB_WRAP_WITH_RAW_SPKI, + "XCP_CPB_ALG_DH": XCP_CPB_ALG_DH, + "XCP_CPB_DERIVE": XCP_CPB_DERIVE, + "XCP_CPB_ALG_EC_25519": XCP_CPB_ALG_EC_25519, + "XCP_CPB_ALG_NBSI2017": XCP_CPB_ALG_NBSI2017, + "XCP_CPB_EMV": XCP_CPB_EMV, + "XCP_CPB_EMV_MIX": XCP_CPB_EMV_MIX, + "XCP_CPB_CPACF_PK": XCP_CPB_CPACF_PK, + "XCP_CPB_ALG_PQC": XCP_CPB_ALG_PQC, + "XCP_CPB_BTC": XCP_CPB_BTC, + } + ControlPointValueToName = map[ControlPoint]string{ + XCP_CPB_ADD_CPBS: "XCP_CPB_ADD_CPBS", + XCP_CPB_DELETE_CPBS: "XCP_CPB_DELETE_CPBS", + XCP_CPB_SIGN_ASYMM: "XCP_CPB_SIGN_ASYMM", + XCP_CPB_SIGN_SYMM: "XCP_CPB_SIGN_SYMM", + XCP_CPB_SIGVERIFY_SYMM: "XCP_CPB_SIGVERIFY_SYMM", + XCP_CPB_ENCRYPT_SYMM: "XCP_CPB_ENCRYPT_SYMM", + XCP_CPB_DECRYPT_ASYMM: "XCP_CPB_DECRYPT_ASYMM", + XCP_CPB_DECRYPT_SYMM: "XCP_CPB_DECRYPT_SYMM", + XCP_CPB_WRAP_ASYMM: "XCP_CPB_WRAP_ASYMM", + XCP_CPB_WRAP_SYMM: "XCP_CPB_WRAP_SYMM", + XCP_CPB_UNWRAP_ASYMM: "XCP_CPB_UNWRAP_ASYMM", + XCP_CPB_UNWRAP_SYMM: "XCP_CPB_UNWRAP_SYMM", + XCP_CPB_KEYGEN_ASYMM: "XCP_CPB_KEYGEN_ASYMM", + XCP_CPB_KEYGEN_SYMM: "XCP_CPB_KEYGEN_SYMM", + XCP_CPB_RETAINKEYS: "XCP_CPB_RETAINKEYS", + XCP_CPB_SKIP_KEYTESTS: "XCP_CPB_SKIP_KEYTESTS", + XCP_CPB_NON_ATTRBOUND: "XCP_CPB_NON_ATTRBOUND", + XCP_CPB_MODIFY_OBJECTS: "XCP_CPB_MODIFY_OBJECTS", + XCP_CPB_RNG_SEED: "XCP_CPB_RNG_SEED", + XCP_CPB_ALG_RAW_RSA: "XCP_CPB_ALG_RAW_RSA", + XCP_CPB_ALG_NFIPS2009: "XCP_CPB_ALG_NFIPS2009", + XCP_CPB_ALG_NBSI2009: "XCP_CPB_ALG_NBSI2009", + XCP_CPB_KEYSZ_HMAC_ANY: "XCP_CPB_KEYSZ_HMAC_ANY", + XCP_CPB_KEYSZ_BELOW80BIT: "XCP_CPB_KEYSZ_BELOW80BIT", + XCP_CPB_KEYSZ_80BIT: "XCP_CPB_KEYSZ_80BIT", + XCP_CPB_KEYSZ_112BIT: "XCP_CPB_KEYSZ_112BIT", + XCP_CPB_KEYSZ_128BIT: "XCP_CPB_KEYSZ_128BIT", + XCP_CPB_KEYSZ_192BIT: "XCP_CPB_KEYSZ_192BIT", + XCP_CPB_KEYSZ_256BIT: "XCP_CPB_KEYSZ_256BIT", + XCP_CPB_KEYSZ_RSA65536: "XCP_CPB_KEYSZ_RSA65536", + XCP_CPB_ALG_RSA: "XCP_CPB_ALG_RSA", + XCP_CPB_ALG_DSA: "XCP_CPB_ALG_DSA", + XCP_CPB_ALG_EC: "XCP_CPB_ALG_EC", + XCP_CPB_ALG_EC_BPOOLCRV: "XCP_CPB_ALG_EC_BPOOLCRV", + XCP_CPB_ALG_EC_NISTCRV: "XCP_CPB_ALG_EC_NISTCRV", + XCP_CPB_ALG_NFIPS2011: "XCP_CPB_ALG_NFIPS2011", + XCP_CPB_ALG_NBSI2011: "XCP_CPB_ALG_NBSI2011", + XCP_CPB_USER_SET_TRUSTED: "XCP_CPB_USER_SET_TRUSTED", + XCP_CPB_ALG_SKIP_CROSSCHK: "XCP_CPB_ALG_SKIP_CROSSCHK", + XCP_CPB_WRAP_CRYPT_KEYS: "XCP_CPB_WRAP_CRYPT_KEYS", + XCP_CPB_SIGN_CRYPT_KEYS: "XCP_CPB_SIGN_CRYPT_KEYS", + XCP_CPB_WRAP_SIGN_KEYS: "XCP_CPB_WRAP_SIGN_KEYS", + XCP_CPB_USER_SET_ATTRBOUND: "XCP_CPB_USER_SET_ATTRBOUND", + XCP_CPB_ALLOW_PASSPHRASE: "XCP_CPB_ALLOW_PASSPHRASE", + XCP_CPB_WRAP_STRONGER_KEY: "XCP_CPB_WRAP_STRONGER_KEY", + XCP_CPB_WRAP_WITH_RAW_SPKI: "XCP_CPB_WRAP_WITH_RAW_SPKI", + XCP_CPB_ALG_DH: "XCP_CPB_ALG_DH", + XCP_CPB_DERIVE: "XCP_CPB_DERIVE", + XCP_CPB_ALG_EC_25519: "XCP_CPB_ALG_EC_25519", + XCP_CPB_ALG_NBSI2017: "XCP_CPB_ALG_NBSI2017", + XCP_CPB_EMV: "XCP_CPB_EMV", + XCP_CPB_EMV_MIX: "XCP_CPB_EMV_MIX", + XCP_CPB_CPACF_PK: "XCP_CPB_CPACF_PK", + XCP_CPB_ALG_PQC: "XCP_CPB_ALG_PQC", + XCP_CPB_BTC: "XCP_CPB_BTC", + } + FunctionIDNameToValue = map[string]FunctionID{ + "FNID_Login": FNID_Login, + "FNID_Logout": FNID_Logout, + "FNID_SeedRandom": FNID_SeedRandom, + "FNID_GenerateRandom": FNID_GenerateRandom, + "FNID_DigestInit": FNID_DigestInit, + "FNID_DigestUpdate": FNID_DigestUpdate, + "FNID_DigestKey": FNID_DigestKey, + "FNID_DigestFinal": FNID_DigestFinal, + "FNID_Digest": FNID_Digest, + "FNID_DigestSingle": FNID_DigestSingle, + "FNID_EncryptInit": FNID_EncryptInit, + "FNID_DecryptInit": FNID_DecryptInit, + "FNID_EncryptUpdate": FNID_EncryptUpdate, + "FNID_DecryptUpdate": FNID_DecryptUpdate, + "FNID_EncryptFinal": FNID_EncryptFinal, + "FNID_DecryptFinal": FNID_DecryptFinal, + "FNID_Encrypt": FNID_Encrypt, + "FNID_Decrypt": FNID_Decrypt, + "FNID_EncryptSingle": FNID_EncryptSingle, + "FNID_DecryptSingle": FNID_DecryptSingle, + "FNID_GenerateKey": FNID_GenerateKey, + "FNID_GenerateKeyPair": FNID_GenerateKeyPair, + "FNID_SignInit": FNID_SignInit, + "FNID_SignUpdate": FNID_SignUpdate, + "FNID_SignFinal": FNID_SignFinal, + "FNID_Sign": FNID_Sign, + "FNID_VerifyInit": FNID_VerifyInit, + "FNID_VerifyUpdate": FNID_VerifyUpdate, + "FNID_VerifyFinal": FNID_VerifyFinal, + "FNID_Verify": FNID_Verify, + "FNID_SignSingle": FNID_SignSingle, + "FNID_VerifySingle": FNID_VerifySingle, + "FNID_WrapKey": FNID_WrapKey, + "FNID_UnwrapKey": FNID_UnwrapKey, + "FNID_DeriveKey": FNID_DeriveKey, + "FNID_GetMechanismList": FNID_GetMechanismList, + "FNID_GetMechanismInfo": FNID_GetMechanismInfo, + "FNID_get_xcp_info": FNID_get_xcp_info, + "FNID_GetAttributeValue": FNID_GetAttributeValue, + "FNID_SetAttributeValue": FNID_SetAttributeValue, + "FNID_admin": FNID_admin, + "FNID_ReencryptSingle": FNID_ReencryptSingle, + "FNID_NEXT_AVAILABLE": FNID_NEXT_AVAILABLE, + } + FunctionIDValueToName = map[FunctionID]string{ + FNID_Login: "FNID_Login", + FNID_Logout: "FNID_Logout", + FNID_SeedRandom: "FNID_SeedRandom", + FNID_GenerateRandom: "FNID_GenerateRandom", + FNID_DigestInit: "FNID_DigestInit", + FNID_DigestUpdate: "FNID_DigestUpdate", + FNID_DigestKey: "FNID_DigestKey", + FNID_DigestFinal: "FNID_DigestFinal", + FNID_Digest: "FNID_Digest", + FNID_DigestSingle: "FNID_DigestSingle", + FNID_EncryptInit: "FNID_EncryptInit", + FNID_DecryptInit: "FNID_DecryptInit", + FNID_EncryptUpdate: "FNID_EncryptUpdate", + FNID_DecryptUpdate: "FNID_DecryptUpdate", + FNID_EncryptFinal: "FNID_EncryptFinal", + FNID_DecryptFinal: "FNID_DecryptFinal", + FNID_Encrypt: "FNID_Encrypt", + FNID_Decrypt: "FNID_Decrypt", + FNID_EncryptSingle: "FNID_EncryptSingle", + FNID_DecryptSingle: "FNID_DecryptSingle", + FNID_GenerateKey: "FNID_GenerateKey", + FNID_GenerateKeyPair: "FNID_GenerateKeyPair", + FNID_SignInit: "FNID_SignInit", + FNID_SignUpdate: "FNID_SignUpdate", + FNID_SignFinal: "FNID_SignFinal", + FNID_Sign: "FNID_Sign", + FNID_VerifyInit: "FNID_VerifyInit", + FNID_VerifyUpdate: "FNID_VerifyUpdate", + FNID_VerifyFinal: "FNID_VerifyFinal", + FNID_Verify: "FNID_Verify", + FNID_SignSingle: "FNID_SignSingle", + FNID_VerifySingle: "FNID_VerifySingle", + FNID_WrapKey: "FNID_WrapKey", + FNID_UnwrapKey: "FNID_UnwrapKey", + FNID_DeriveKey: "FNID_DeriveKey", + FNID_GetMechanismList: "FNID_GetMechanismList", + FNID_GetMechanismInfo: "FNID_GetMechanismInfo", + FNID_get_xcp_info: "FNID_get_xcp_info", + FNID_GetAttributeValue: "FNID_GetAttributeValue", + FNID_SetAttributeValue: "FNID_SetAttributeValue", + FNID_admin: "FNID_admin", + FNID_ReencryptSingle: "FNID_ReencryptSingle", + FNID_NEXT_AVAILABLE: "FNID_NEXT_AVAILABLE", + } + ImporterKeyTypeNameToValue = map[string]ImporterKeyType{ + "XCP_IMPRKEY_RSA_2048": XCP_IMPRKEY_RSA_2048, + "XCP_IMPRKEY_RSA_4096": XCP_IMPRKEY_RSA_4096, + "XCP_IMPRKEY_EC_P256": XCP_IMPRKEY_EC_P256, + "XCP_IMPRKEY_EC_P521": XCP_IMPRKEY_EC_P521, + "XCP_IMPRKEY_RSA_3072": XCP_IMPRKEY_RSA_3072, + } + ImporterKeyTypeValueToName = map[ImporterKeyType]string{ + XCP_IMPRKEY_RSA_2048: "XCP_IMPRKEY_RSA_2048", + XCP_IMPRKEY_RSA_4096: "XCP_IMPRKEY_RSA_4096", + XCP_IMPRKEY_EC_P256: "XCP_IMPRKEY_EC_P256", + XCP_IMPRKEY_EC_P521: "XCP_IMPRKEY_EC_P521", + XCP_IMPRKEY_RSA_3072: "XCP_IMPRKEY_RSA_3072", + } + KeyTypeNameToValue = map[string]KeyType{ "CKK_RSA": CKK_RSA, "CKK_DSA": CKK_DSA, "CKK_DH": CKK_DH, @@ -1079,19 +1738,20 @@ var ( "CKK_ACTI": CKK_ACTI, "CKK_CAMELLIA": CKK_CAMELLIA, "CKK_ARIA": CKK_ARIA, - "CKK_SHA512_224_HMAC": CKK_SHA512_224_HMAC, - "CKK_SHA512_256_HMAC": CKK_SHA512_256_HMAC, - "CKK_SHA512_T_HMAC": CKK_SHA512_T_HMAC, + "CKK_MD5_HMAC": CKK_MD5_HMAC, "CKK_SHA_1_HMAC": CKK_SHA_1_HMAC, - "CKK_SHA224_HMAC": CKK_SHA224_HMAC, + "CKK_RIPEMD128_HMAC": CKK_RIPEMD128_HMAC, + "CKK_RIPEMD160_HMAC": CKK_RIPEMD160_HMAC, "CKK_SHA256_HMAC": CKK_SHA256_HMAC, "CKK_SHA384_HMAC": CKK_SHA384_HMAC, "CKK_SHA512_HMAC": CKK_SHA512_HMAC, + "CKK_SHA224_HMAC": CKK_SHA224_HMAC, "CKK_SEED": CKK_SEED, "CKK_GOSTR3410": CKK_GOSTR3410, "CKK_GOSTR3411": CKK_GOSTR3411, "CKK_GOST28147": CKK_GOST28147, "CKK_VENDOR_DEFINED": CKK_VENDOR_DEFINED, + "CKK_IBM_PQC_DILITHIUM": CKK_IBM_PQC_DILITHIUM, "CKK_IBM_SM4": CKK_IBM_SM4, "CKK_IBM_SM2": CKK_IBM_SM2, "CKK_IBM_EPX_SYMM": CKK_IBM_EPX_SYMM, @@ -1099,7 +1759,7 @@ var ( "CKK_IBM_EPX_ASYMM_PRIV": CKK_IBM_EPX_ASYMM_PRIV, "CKK_IBM_EPX_ASYMM_PUB": CKK_IBM_EPX_ASYMM_PUB, } - _KeyTypeValueToName = map[KeyType]string{ + KeyTypeValueToName = map[KeyType]string{ CKK_RSA: "CKK_RSA", CKK_DSA: "CKK_DSA", CKK_DH: "CKK_DH", @@ -1129,19 +1789,20 @@ var ( CKK_ACTI: "CKK_ACTI", CKK_CAMELLIA: "CKK_CAMELLIA", CKK_ARIA: "CKK_ARIA", - CKK_SHA512_224_HMAC: "CKK_SHA512_224_HMAC", - CKK_SHA512_256_HMAC: "CKK_SHA512_256_HMAC", - CKK_SHA512_T_HMAC: "CKK_SHA512_T_HMAC", + CKK_MD5_HMAC: "CKK_MD5_HMAC", CKK_SHA_1_HMAC: "CKK_SHA_1_HMAC", - CKK_SHA224_HMAC: "CKK_SHA224_HMAC", + CKK_RIPEMD128_HMAC: "CKK_RIPEMD128_HMAC", + CKK_RIPEMD160_HMAC: "CKK_RIPEMD160_HMAC", CKK_SHA256_HMAC: "CKK_SHA256_HMAC", CKK_SHA384_HMAC: "CKK_SHA384_HMAC", CKK_SHA512_HMAC: "CKK_SHA512_HMAC", + CKK_SHA224_HMAC: "CKK_SHA224_HMAC", CKK_SEED: "CKK_SEED", CKK_GOSTR3410: "CKK_GOSTR3410", CKK_GOSTR3411: "CKK_GOSTR3411", CKK_GOST28147: "CKK_GOST28147", CKK_VENDOR_DEFINED: "CKK_VENDOR_DEFINED", + CKK_IBM_PQC_DILITHIUM: "CKK_IBM_PQC_DILITHIUM", CKK_IBM_SM4: "CKK_IBM_SM4", CKK_IBM_SM2: "CKK_IBM_SM2", CKK_IBM_EPX_SYMM: "CKK_IBM_EPX_SYMM", @@ -1149,7 +1810,7 @@ var ( CKK_IBM_EPX_ASYMM_PRIV: "CKK_IBM_EPX_ASYMM_PRIV", CKK_IBM_EPX_ASYMM_PUB: "CKK_IBM_EPX_ASYMM_PUB", } - _MechanismNameToValue = map[string]Mechanism{ + MechanismNameToValue = map[string]Mechanism{ "CKM_RSA_PKCS_KEY_PAIR_GEN": CKM_RSA_PKCS_KEY_PAIR_GEN, "CKM_RSA_PKCS": CKM_RSA_PKCS, "CKM_RSA_9796": CKM_RSA_9796, @@ -1168,7 +1829,6 @@ var ( "CKM_DSA_KEY_PAIR_GEN": CKM_DSA_KEY_PAIR_GEN, "CKM_DSA": CKM_DSA, "CKM_DSA_SHA1": CKM_DSA_SHA1, - "CKM_DSA_FIPS_G_GEN": CKM_DSA_FIPS_G_GEN, "CKM_DSA_SHA224": CKM_DSA_SHA224, "CKM_DSA_SHA256": CKM_DSA_SHA256, "CKM_DSA_SHA384": CKM_DSA_SHA384, @@ -1414,6 +2074,10 @@ var ( "CKM_EC_KEY_PAIR_GEN": CKM_EC_KEY_PAIR_GEN, "CKM_ECDSA": CKM_ECDSA, "CKM_ECDSA_SHA1": CKM_ECDSA_SHA1, + "CKM_ECDSA_SHA224": CKM_ECDSA_SHA224, + "CKM_ECDSA_SHA256": CKM_ECDSA_SHA256, + "CKM_ECDSA_SHA384": CKM_ECDSA_SHA384, + "CKM_ECDSA_SHA512": CKM_ECDSA_SHA512, "CKM_ECDH1_DERIVE": CKM_ECDH1_DERIVE, "CKM_ECDH1_COFACTOR_DERIVE": CKM_ECDH1_COFACTOR_DERIVE, "CKM_ECMQV_DERIVE": CKM_ECMQV_DERIVE, @@ -1435,9 +2099,9 @@ var ( "CKM_AES_CTR": CKM_AES_CTR, "CKM_AES_GCM": CKM_AES_GCM, "CKM_AES_CCM": CKM_AES_CCM, - "CKM_AES_CMAC_GENERAL": CKM_AES_CMAC_GENERAL, - "CKM_AES_CMAC": CKM_AES_CMAC, "CKM_AES_CTS": CKM_AES_CTS, + "CKM_AES_CMAC": CKM_AES_CMAC, + "CKM_AES_CMAC_GENERAL": CKM_AES_CMAC_GENERAL, "CKM_AES_XCBC_MAC": CKM_AES_XCBC_MAC, "CKM_AES_XCBC_MAC_96": CKM_AES_XCBC_MAC_96, "CKM_AES_GMAC": CKM_AES_GMAC, @@ -1506,18 +2170,28 @@ var ( "CKM_IBM_SHA512_224_HMAC_GENERAL": CKM_IBM_SHA512_224_HMAC_GENERAL, "CKM_IBM_SHA512_256_KEY_DERIVATION": CKM_IBM_SHA512_256_KEY_DERIVATION, "CKM_IBM_SHA512_224_KEY_DERIVATION": CKM_IBM_SHA512_224_KEY_DERIVATION, - "CKM_IBM_EC_C25519": CKM_IBM_EC_C25519, - "CKM_IBM_EDDSA_SHA512": CKM_IBM_EDDSA_SHA512, - "CKM_IBM_EDDSA_PH_SHA512": CKM_IBM_EDDSA_PH_SHA512, - "CKM_IBM_EC_C448": CKM_IBM_EC_C448, + "CKM_IBM_EC_X25519": CKM_IBM_EC_X25519, + "CKM_IBM_ED25519_SHA512": CKM_IBM_ED25519_SHA512, + "CKM_IBM_ED25519_PH_SHA512": CKM_IBM_ED25519_PH_SHA512, + "CKM_IBM_EC_X448": CKM_IBM_EC_X448, "CKM_IBM_ED448_SHA3": CKM_IBM_ED448_SHA3, "CKM_IBM_ED448_PH_SHA3": CKM_IBM_ED448_PH_SHA3, "CKM_IBM_SIPHASH": CKM_IBM_SIPHASH, + "CKM_IBM_ZK": CKM_IBM_ZK, + "CKM_IBM_DILITHIUM": CKM_IBM_DILITHIUM, + "CKM_IBM_SHA3_224_HMAC": CKM_IBM_SHA3_224_HMAC, + "CKM_IBM_SHA3_256_HMAC": CKM_IBM_SHA3_256_HMAC, + "CKM_IBM_SHA3_384_HMAC": CKM_IBM_SHA3_384_HMAC, + "CKM_IBM_SHA3_512_HMAC": CKM_IBM_SHA3_512_HMAC, + "CKM_IBM_EC_X25519_RAW": CKM_IBM_EC_X25519_RAW, + "CKM_IBM_EC_X448_RAW": CKM_IBM_EC_X448_RAW, "CKM_IBM_CLEARKEY_TRANSPORT": CKM_IBM_CLEARKEY_TRANSPORT, "CKM_IBM_ATTRIBUTEBOUND_WRAP": CKM_IBM_ATTRIBUTEBOUND_WRAP, "CKM_IBM_TRANSPORTKEY": CKM_IBM_TRANSPORTKEY, "CKM_IBM_DH_PKCS_DERIVE_RAW": CKM_IBM_DH_PKCS_DERIVE_RAW, "CKM_IBM_ECDH1_DERIVE_RAW": CKM_IBM_ECDH1_DERIVE_RAW, + "CKM_IBM_POLY1305": CKM_IBM_POLY1305, + "CKM_IBM_CHACHA20": CKM_IBM_CHACHA20, "CKM_IBM_FILE": CKM_IBM_FILE, "CKM_IBM_WIRETEST": CKM_IBM_WIRETEST, "CKM_IBM_RETAINKEY": CKM_IBM_RETAINKEY, @@ -1538,10 +2212,12 @@ var ( "CKM_IBM_SM2_SM3_RFC": CKM_IBM_SM2_SM3_RFC, "CKM_IBM_SM4_MAC": CKM_IBM_SM4_MAC, "CKM_IBM_ISO2_SM4_MAC": CKM_IBM_ISO2_SM4_MAC, + "CKM_IBM_CPACF_WRAP": CKM_IBM_CPACF_WRAP, + "CKM_IBM_BTC_DERIVE": CKM_IBM_BTC_DERIVE, "CKM_IBM_EPX": CKM_IBM_EPX, "CKM_IBM_EPX_WPRM": CKM_IBM_EPX_WPRM, } - _MechanismValueToName = map[Mechanism]string{ + MechanismValueToName = map[Mechanism]string{ CKM_RSA_PKCS_KEY_PAIR_GEN: "CKM_RSA_PKCS_KEY_PAIR_GEN", CKM_RSA_PKCS: "CKM_RSA_PKCS", CKM_RSA_9796: "CKM_RSA_9796", @@ -1560,7 +2236,6 @@ var ( CKM_DSA_KEY_PAIR_GEN: "CKM_DSA_KEY_PAIR_GEN", CKM_DSA: "CKM_DSA", CKM_DSA_SHA1: "CKM_DSA_SHA1", - CKM_DSA_FIPS_G_GEN: "CKM_DSA_FIPS_G_GEN", CKM_DSA_SHA224: "CKM_DSA_SHA224", CKM_DSA_SHA256: "CKM_DSA_SHA256", CKM_DSA_SHA384: "CKM_DSA_SHA384", @@ -1797,6 +2472,10 @@ var ( CKM_EC_KEY_PAIR_GEN: "CKM_EC_KEY_PAIR_GEN", CKM_ECDSA: "CKM_ECDSA", CKM_ECDSA_SHA1: "CKM_ECDSA_SHA1", + CKM_ECDSA_SHA224: "CKM_ECDSA_SHA224", + CKM_ECDSA_SHA256: "CKM_ECDSA_SHA256", + CKM_ECDSA_SHA384: "CKM_ECDSA_SHA384", + CKM_ECDSA_SHA512: "CKM_ECDSA_SHA512", CKM_ECDH1_DERIVE: "CKM_ECDH1_DERIVE", CKM_ECDH1_COFACTOR_DERIVE: "CKM_ECDH1_COFACTOR_DERIVE", CKM_ECMQV_DERIVE: "CKM_ECMQV_DERIVE", @@ -1818,9 +2497,9 @@ var ( CKM_AES_CTR: "CKM_AES_CTR", CKM_AES_GCM: "CKM_AES_GCM", CKM_AES_CCM: "CKM_AES_CCM", - CKM_AES_CMAC_GENERAL: "CKM_AES_CMAC_GENERAL", - CKM_AES_CMAC: "CKM_AES_CMAC", CKM_AES_CTS: "CKM_AES_CTS", + CKM_AES_CMAC: "CKM_AES_CMAC", + CKM_AES_CMAC_GENERAL: "CKM_AES_CMAC_GENERAL", CKM_AES_XCBC_MAC: "CKM_AES_XCBC_MAC", CKM_AES_XCBC_MAC_96: "CKM_AES_XCBC_MAC_96", CKM_AES_GMAC: "CKM_AES_GMAC", @@ -1889,18 +2568,28 @@ var ( CKM_IBM_SHA512_224_HMAC_GENERAL: "CKM_IBM_SHA512_224_HMAC_GENERAL", CKM_IBM_SHA512_256_KEY_DERIVATION: "CKM_IBM_SHA512_256_KEY_DERIVATION", CKM_IBM_SHA512_224_KEY_DERIVATION: "CKM_IBM_SHA512_224_KEY_DERIVATION", - CKM_IBM_EC_C25519: "CKM_IBM_EC_C25519", - CKM_IBM_EDDSA_SHA512: "CKM_IBM_EDDSA_SHA512", - CKM_IBM_EDDSA_PH_SHA512: "CKM_IBM_EDDSA_PH_SHA512", - CKM_IBM_EC_C448: "CKM_IBM_EC_C448", + CKM_IBM_EC_X25519: "CKM_IBM_EC_X25519", + CKM_IBM_ED25519_SHA512: "CKM_IBM_ED25519_SHA512", + CKM_IBM_ED25519_PH_SHA512: "CKM_IBM_ED25519_PH_SHA512", + CKM_IBM_EC_X448: "CKM_IBM_EC_X448", CKM_IBM_ED448_SHA3: "CKM_IBM_ED448_SHA3", CKM_IBM_ED448_PH_SHA3: "CKM_IBM_ED448_PH_SHA3", CKM_IBM_SIPHASH: "CKM_IBM_SIPHASH", + CKM_IBM_ZK: "CKM_IBM_ZK", + CKM_IBM_DILITHIUM: "CKM_IBM_DILITHIUM", + CKM_IBM_SHA3_224_HMAC: "CKM_IBM_SHA3_224_HMAC", + CKM_IBM_SHA3_256_HMAC: "CKM_IBM_SHA3_256_HMAC", + CKM_IBM_SHA3_384_HMAC: "CKM_IBM_SHA3_384_HMAC", + CKM_IBM_SHA3_512_HMAC: "CKM_IBM_SHA3_512_HMAC", + CKM_IBM_EC_X25519_RAW: "CKM_IBM_EC_X25519_RAW", + CKM_IBM_EC_X448_RAW: "CKM_IBM_EC_X448_RAW", CKM_IBM_CLEARKEY_TRANSPORT: "CKM_IBM_CLEARKEY_TRANSPORT", CKM_IBM_ATTRIBUTEBOUND_WRAP: "CKM_IBM_ATTRIBUTEBOUND_WRAP", CKM_IBM_TRANSPORTKEY: "CKM_IBM_TRANSPORTKEY", CKM_IBM_DH_PKCS_DERIVE_RAW: "CKM_IBM_DH_PKCS_DERIVE_RAW", CKM_IBM_ECDH1_DERIVE_RAW: "CKM_IBM_ECDH1_DERIVE_RAW", + CKM_IBM_POLY1305: "CKM_IBM_POLY1305", + CKM_IBM_CHACHA20: "CKM_IBM_CHACHA20", CKM_IBM_FILE: "CKM_IBM_FILE", CKM_IBM_WIRETEST: "CKM_IBM_WIRETEST", CKM_IBM_RETAINKEY: "CKM_IBM_RETAINKEY", @@ -1921,10 +2610,12 @@ var ( CKM_IBM_SM2_SM3_RFC: "CKM_IBM_SM2_SM3_RFC", CKM_IBM_SM4_MAC: "CKM_IBM_SM4_MAC", CKM_IBM_ISO2_SM4_MAC: "CKM_IBM_ISO2_SM4_MAC", + CKM_IBM_CPACF_WRAP: "CKM_IBM_CPACF_WRAP", + CKM_IBM_BTC_DERIVE: "CKM_IBM_BTC_DERIVE", CKM_IBM_EPX: "CKM_IBM_EPX", CKM_IBM_EPX_WPRM: "CKM_IBM_EPX_WPRM", } - _MechanismInfoFlagNameToValue = map[string]MechanismInfoFlag{ + MechanismInfoFlagNameToValue = map[string]MechanismInfoFlag{ "CKF_DONT_BLOCK": CKF_DONT_BLOCK, "CKF_HW": CKF_HW, "CKF_LIBRARY_CANT_CREATE_OS_THREADS": CKF_LIBRARY_CANT_CREATE_OS_THREADS, @@ -1980,8 +2671,8 @@ var ( "CKF_ARRAY_ATTRIBUTE": CKF_ARRAY_ATTRIBUTE, "CKF_EXTENSION": CKF_EXTENSION, } - _MechanismInfoFlagValueToName = map[MechanismInfoFlag]string{} - _ObjectClassNameToValue = map[string]ObjectClass{ + MechanismInfoFlagValueToName = map[MechanismInfoFlag]string{} + ObjectClassNameToValue = map[string]ObjectClass{ "CKO_DATA": CKO_DATA, "CKO_CERTIFICATE": CKO_CERTIFICATE, "CKO_PUBLIC_KEY": CKO_PUBLIC_KEY, @@ -1993,7 +2684,7 @@ var ( "CKO_OTP_KEY": CKO_OTP_KEY, "CKO_VENDOR_DEFINED": CKO_VENDOR_DEFINED, } - _ObjectClassValueToName = map[ObjectClass]string{ + ObjectClassValueToName = map[ObjectClass]string{ CKO_DATA: "CKO_DATA", CKO_CERTIFICATE: "CKO_CERTIFICATE", CKO_PUBLIC_KEY: "CKO_PUBLIC_KEY", @@ -2005,7 +2696,7 @@ var ( CKO_OTP_KEY: "CKO_OTP_KEY", CKO_VENDOR_DEFINED: "CKO_VENDOR_DEFINED", } - _ReturnNameToValue = map[string]Return{ + ReturnNameToValue = map[string]Return{ "CKR_OK": CKR_OK, "CKR_CANCEL": CKR_CANCEL, "CKR_HOST_MEMORY": CKR_HOST_MEMORY, @@ -2117,6 +2808,9 @@ var ( "CKR_IBM_EMBED_GENERIC": CKR_IBM_EMBED_GENERIC, "CKR_IBM_TRANSPORT_LIMIT": CKR_IBM_TRANSPORT_LIMIT, "CKR_IBM_FCV_NOT_SET": CKR_IBM_FCV_NOT_SET, + "CKR_IBM_PERF_CATEGORY_INVALID": CKR_IBM_PERF_CATEGORY_INVALID, + "CKR_IBM_API_MISMATCH": CKR_IBM_API_MISMATCH, + "CKR_IBM_TARGET_INVALID": CKR_IBM_TARGET_INVALID, "CKR_VENDOR_DEFINED_GREP11": CKR_VENDOR_DEFINED_GREP11, "CKR_IBM_GREP11_NOT_AUTHENTICATED": CKR_IBM_GREP11_NOT_AUTHENTICATED, "CKR_IBM_GREP11_CANNOT_UNMARSHAL": CKR_IBM_GREP11_CANNOT_UNMARSHAL, @@ -2125,7 +2819,7 @@ var ( "CKR_IBM_GREP11_DBINTERNAL": CKR_IBM_GREP11_DBINTERNAL, "CKR_IBM_GREP11_SERVER_INTERNAL": CKR_IBM_GREP11_SERVER_INTERNAL, } - _ReturnValueToName = map[Return]string{ + ReturnValueToName = map[Return]string{ CKR_OK: "CKR_OK", CKR_CANCEL: "CKR_CANCEL", CKR_HOST_MEMORY: "CKR_HOST_MEMORY", @@ -2237,6 +2931,9 @@ var ( CKR_IBM_EMBED_GENERIC: "CKR_IBM_EMBED_GENERIC", CKR_IBM_TRANSPORT_LIMIT: "CKR_IBM_TRANSPORT_LIMIT", CKR_IBM_FCV_NOT_SET: "CKR_IBM_FCV_NOT_SET", + CKR_IBM_PERF_CATEGORY_INVALID: "CKR_IBM_PERF_CATEGORY_INVALID", + CKR_IBM_API_MISMATCH: "CKR_IBM_API_MISMATCH", + CKR_IBM_TARGET_INVALID: "CKR_IBM_TARGET_INVALID", CKR_VENDOR_DEFINED_GREP11: "CKR_VENDOR_DEFINED_GREP11", CKR_IBM_GREP11_NOT_AUTHENTICATED: "CKR_IBM_GREP11_NOT_AUTHENTICATED", CKR_IBM_GREP11_CANNOT_UNMARSHAL: "CKR_IBM_GREP11_CANNOT_UNMARSHAL", @@ -2247,11 +2944,85 @@ var ( } ) +// MarshalJSON is generated so AdminCommand satisfies json.Marshaler. +func (c AdminCommand) MarshalJSON() ([]byte, error) { + s, ok := AdminCommandValueToName[c] + if !ok { + s = c.String() + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so AdminCommand satisfies json.Unmarshaler. +func (c *AdminCommand) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("AdminCommand should be a string, got %s", data) + } + + return c.FromString(s) +} + +// Workaround for a strange Map behaviour +func (c AdminCommand) MarshalText() (text []byte, err error) { + return []byte(c.String()), nil +} + +func (c *AdminCommand) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +func (c AdminCommand) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { + return c.MarshalJSON() +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +func (c *AdminCommand) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { + err := c.UnmarshalJSON(d) + if err == nil { + return nil + } + + return c.FromString(string(d)) +} + +func (c AdminCommand) String() string { + if str, ok := AdminCommandValueToName[c]; ok { + return str + } + return "AdminCommand(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *AdminCommand) FromString(s string) error { + v, ok := AdminCommandNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "AdminCommand(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid AdminCommand %q", s) + } + + *c = AdminCommand(vv) + return nil +} + // MarshalJSON is generated so Attribute satisfies json.Marshaler. func (c Attribute) MarshalJSON() ([]byte, error) { - s, ok := _AttributeValueToName[c] + s, ok := AttributeValueToName[c] if !ok { - return nil, fmt.Errorf("invalid Attribute: %d", c) + s = c.String() } return json.Marshal(s) } @@ -2262,33 +3033,246 @@ func (c *Attribute) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s); err != nil { return fmt.Errorf("Attribute should be a string, got %s", data) } - v, ok := _AttributeNameToValue[s] - if !ok { + + return c.FromString(s) +} + +// Workaround for a strange Map behaviour +func (c Attribute) MarshalText() (text []byte, err error) { + return []byte(c.String()), nil +} + +func (c *Attribute) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +func (c Attribute) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { + return c.MarshalJSON() +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +func (c *Attribute) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { + err := c.UnmarshalJSON(d) + if err == nil { + return nil + } + + return c.FromString(string(d)) +} + +func (c Attribute) String() string { + if str, ok := AttributeValueToName[c]; ok { + return str + } + return "Attribute(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *Attribute) FromString(s string) error { + v, ok := AttributeNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "Attribute(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { return fmt.Errorf("invalid Attribute %q", s) } - *c = v + + *c = Attribute(vv) return nil } +// MarshalJSON is generated so CardAttributeFlags satisfies json.Marshaler. +func (c CardAttributeFlags) MarshalJSON() ([]byte, error) { + s, ok := CardAttributeFlagsValueToName[c] + if !ok { + s = c.String() + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so CardAttributeFlags satisfies json.Unmarshaler. +func (c *CardAttributeFlags) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("CardAttributeFlags should be a string, got %s", data) + } + + return c.FromString(s) +} + // Workaround for a strange Map behaviour -func (c Attribute) MarshalText() (text []byte, err error) { +func (c CardAttributeFlags) MarshalText() (text []byte, err error) { return []byte(c.String()), nil } -func (c *Attribute) UnmarshalText(text []byte) error { - v, ok := _AttributeNameToValue[string(text)] +func (c *CardAttributeFlags) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +func (c CardAttributeFlags) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { + return c.MarshalJSON() +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +func (c *CardAttributeFlags) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { + err := c.UnmarshalJSON(d) + if err == nil { + return nil + } + + return c.FromString(string(d)) +} + +func (c CardAttributeFlags) String() string { + if str, ok := CardAttributeFlagsValueToName[c]; ok { + return str + } + return "CardAttributeFlags(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *CardAttributeFlags) FromString(s string) error { + v, ok := CardAttributeFlagsNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "CardAttributeFlags(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid CardAttributeFlags %q", s) + } + + *c = CardAttributeFlags(vv) + return nil +} + +// MarshalJSON is generated so CardAttributeKey satisfies json.Marshaler. +func (c CardAttributeKey) MarshalJSON() ([]byte, error) { + s, ok := CardAttributeKeyValueToName[c] if !ok { - return fmt.Errorf("invalid Attribute %q", string(text)) + s = c.String() + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so CardAttributeKey satisfies json.Unmarshaler. +func (c *CardAttributeKey) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("CardAttributeKey should be a string, got %s", data) } - *c = v + + return c.FromString(s) +} + +// Workaround for a strange Map behaviour +func (c CardAttributeKey) MarshalText() (text []byte, err error) { + return []byte(c.String()), nil +} + +func (c *CardAttributeKey) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +func (c CardAttributeKey) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { + return c.MarshalJSON() +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +func (c *CardAttributeKey) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { + err := c.UnmarshalJSON(d) + if err == nil { + return nil + } + + return c.FromString(string(d)) +} + +func (c CardAttributeKey) String() string { + if str, ok := CardAttributeKeyValueToName[c]; ok { + return str + } + return "CardAttributeKey(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *CardAttributeKey) FromString(s string) error { + v, ok := CardAttributeKeyNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "CardAttributeKey(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid CardAttributeKey %q", s) + } + + *c = CardAttributeKey(vv) return nil } +// MarshalJSON is generated so ControlPoint satisfies json.Marshaler. +func (c ControlPoint) MarshalJSON() ([]byte, error) { + s, ok := ControlPointValueToName[c] + if !ok { + s = c.String() + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so ControlPoint satisfies json.Unmarshaler. +func (c *ControlPoint) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("ControlPoint should be a string, got %s", data) + } + + return c.FromString(s) +} + +// Workaround for a strange Map behaviour +func (c ControlPoint) MarshalText() (text []byte, err error) { + return []byte(c.String()), nil +} + +func (c *ControlPoint) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + // JSONPBMarshaler is implemented by protobuf messages that customize the // way they are marshaled to JSON. Messages that implement this should // also implement JSONPBUnmarshaler so that the custom format can be // parsed. -func (c Attribute) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { +func (c ControlPoint) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { return c.MarshalJSON() } @@ -2296,32 +3280,193 @@ func (c Attribute) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { // the way they are unmarshaled from JSON. Messages that implement this // should also implement JSONPBMarshaler so that the custom format can be // produced. -func (c *Attribute) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { +func (c *ControlPoint) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { err := c.UnmarshalJSON(d) if err == nil { return nil } - v, ok := _AttributeNameToValue[string(d)] + return c.FromString(string(d)) +} + +func (c ControlPoint) String() string { + if str, ok := ControlPointValueToName[c]; ok { + return str + } + return "ControlPoint(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *ControlPoint) FromString(s string) error { + v, ok := ControlPointNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "ControlPoint(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid ControlPoint %q", s) + } + + *c = ControlPoint(vv) + return nil +} + +// MarshalJSON is generated so FunctionID satisfies json.Marshaler. +func (c FunctionID) MarshalJSON() ([]byte, error) { + s, ok := FunctionIDValueToName[c] if !ok { - return err + s = c.String() + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so FunctionID satisfies json.Unmarshaler. +func (c *FunctionID) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("FunctionID should be a string, got %s", data) } - *c = v + + return c.FromString(s) +} + +// Workaround for a strange Map behaviour +func (c FunctionID) MarshalText() (text []byte, err error) { + return []byte(c.String()), nil +} + +func (c *FunctionID) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +func (c FunctionID) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { + return c.MarshalJSON() +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +func (c *FunctionID) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { + err := c.UnmarshalJSON(d) + if err == nil { + return nil + } + + return c.FromString(string(d)) +} + +func (c FunctionID) String() string { + if str, ok := FunctionIDValueToName[c]; ok { + return str + } + return "FunctionID(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *FunctionID) FromString(s string) error { + v, ok := FunctionIDNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "FunctionID(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid FunctionID %q", s) + } + + *c = FunctionID(vv) return nil } -func (c Attribute) String() string { - if str, ok := _AttributeValueToName[c]; ok { +// MarshalJSON is generated so ImporterKeyType satisfies json.Marshaler. +func (c ImporterKeyType) MarshalJSON() ([]byte, error) { + s, ok := ImporterKeyTypeValueToName[c] + if !ok { + s = c.String() + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so ImporterKeyType satisfies json.Unmarshaler. +func (c *ImporterKeyType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("ImporterKeyType should be a string, got %s", data) + } + + return c.FromString(s) +} + +// Workaround for a strange Map behaviour +func (c ImporterKeyType) MarshalText() (text []byte, err error) { + return []byte(c.String()), nil +} + +func (c *ImporterKeyType) UnmarshalText(text []byte) error { + return c.FromString(string(text)) +} + +// JSONPBMarshaler is implemented by protobuf messages that customize the +// way they are marshaled to JSON. Messages that implement this should +// also implement JSONPBUnmarshaler so that the custom format can be +// parsed. +func (c ImporterKeyType) MarshalJSONPB(*jsonpb.Marshaler) ([]byte, error) { + return c.MarshalJSON() +} + +// JSONPBUnmarshaler is implemented by protobuf messages that customize +// the way they are unmarshaled from JSON. Messages that implement this +// should also implement JSONPBMarshaler so that the custom format can be +// produced. +func (c *ImporterKeyType) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { + err := c.UnmarshalJSON(d) + if err == nil { + return nil + } + + return c.FromString(string(d)) +} + +func (c ImporterKeyType) String() string { + if str, ok := ImporterKeyTypeValueToName[c]; ok { return str } - return "Attribute(0x" + strconv.FormatUint(uint64(c), 16) + ")" + return "ImporterKeyType(0x" + strconv.FormatUint(uint64(c), 16) + ")" +} + +func (c *ImporterKeyType) FromString(s string) error { + v, ok := ImporterKeyTypeNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "ImporterKeyType(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid ImporterKeyType %q", s) + } + + *c = ImporterKeyType(vv) + return nil } // MarshalJSON is generated so KeyType satisfies json.Marshaler. func (c KeyType) MarshalJSON() ([]byte, error) { - s, ok := _KeyTypeValueToName[c] + s, ok := KeyTypeValueToName[c] if !ok { - return nil, fmt.Errorf("invalid KeyType: %d", c) + s = c.String() } return json.Marshal(s) } @@ -2332,12 +3477,8 @@ func (c *KeyType) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s); err != nil { return fmt.Errorf("KeyType should be a string, got %s", data) } - v, ok := _KeyTypeNameToValue[s] - if !ok { - return fmt.Errorf("invalid KeyType %q", s) - } - *c = v - return nil + + return c.FromString(s) } // Workaround for a strange Map behaviour @@ -2346,12 +3487,7 @@ func (c KeyType) MarshalText() (text []byte, err error) { } func (c *KeyType) UnmarshalText(text []byte) error { - v, ok := _KeyTypeNameToValue[string(text)] - if !ok { - return fmt.Errorf("invalid KeyType %q", string(text)) - } - *c = v - return nil + return c.FromString(string(text)) } // JSONPBMarshaler is implemented by protobuf messages that customize the @@ -2372,26 +3508,39 @@ func (c *KeyType) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { return nil } - v, ok := _KeyTypeNameToValue[string(d)] - if !ok { - return err - } - *c = v - return nil + return c.FromString(string(d)) } func (c KeyType) String() string { - if str, ok := _KeyTypeValueToName[c]; ok { + if str, ok := KeyTypeValueToName[c]; ok { return str } return "KeyType(0x" + strconv.FormatUint(uint64(c), 16) + ")" } +func (c *KeyType) FromString(s string) error { + v, ok := KeyTypeNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "KeyType(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid KeyType %q", s) + } + + *c = KeyType(vv) + return nil +} + // MarshalJSON is generated so Mechanism satisfies json.Marshaler. func (c Mechanism) MarshalJSON() ([]byte, error) { - s, ok := _MechanismValueToName[c] + s, ok := MechanismValueToName[c] if !ok { - return nil, fmt.Errorf("invalid Mechanism: %d", c) + s = c.String() } return json.Marshal(s) } @@ -2402,12 +3551,8 @@ func (c *Mechanism) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s); err != nil { return fmt.Errorf("Mechanism should be a string, got %s", data) } - v, ok := _MechanismNameToValue[s] - if !ok { - return fmt.Errorf("invalid Mechanism %q", s) - } - *c = v - return nil + + return c.FromString(s) } // Workaround for a strange Map behaviour @@ -2416,12 +3561,7 @@ func (c Mechanism) MarshalText() (text []byte, err error) { } func (c *Mechanism) UnmarshalText(text []byte) error { - v, ok := _MechanismNameToValue[string(text)] - if !ok { - return fmt.Errorf("invalid Mechanism %q", string(text)) - } - *c = v - return nil + return c.FromString(string(text)) } // JSONPBMarshaler is implemented by protobuf messages that customize the @@ -2442,26 +3582,39 @@ func (c *Mechanism) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { return nil } - v, ok := _MechanismNameToValue[string(d)] - if !ok { - return err - } - *c = v - return nil + return c.FromString(string(d)) } func (c Mechanism) String() string { - if str, ok := _MechanismValueToName[c]; ok { + if str, ok := MechanismValueToName[c]; ok { return str } return "Mechanism(0x" + strconv.FormatUint(uint64(c), 16) + ")" } +func (c *Mechanism) FromString(s string) error { + v, ok := MechanismNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "Mechanism(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid Mechanism %q", s) + } + + *c = Mechanism(vv) + return nil +} + // MarshalJSON is generated so MechanismInfoFlag satisfies json.Marshaler. func (c MechanismInfoFlag) MarshalJSON() ([]byte, error) { - s, ok := _MechanismInfoFlagValueToName[c] + s, ok := MechanismInfoFlagValueToName[c] if !ok { - return nil, fmt.Errorf("invalid MechanismInfoFlag: %d", c) + s = c.String() } return json.Marshal(s) } @@ -2472,12 +3625,8 @@ func (c *MechanismInfoFlag) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s); err != nil { return fmt.Errorf("MechanismInfoFlag should be a string, got %s", data) } - v, ok := _MechanismInfoFlagNameToValue[s] - if !ok { - return fmt.Errorf("invalid MechanismInfoFlag %q", s) - } - *c = v - return nil + + return c.FromString(s) } // Workaround for a strange Map behaviour @@ -2486,12 +3635,7 @@ func (c MechanismInfoFlag) MarshalText() (text []byte, err error) { } func (c *MechanismInfoFlag) UnmarshalText(text []byte) error { - v, ok := _MechanismInfoFlagNameToValue[string(text)] - if !ok { - return fmt.Errorf("invalid MechanismInfoFlag %q", string(text)) - } - *c = v - return nil + return c.FromString(string(text)) } // JSONPBMarshaler is implemented by protobuf messages that customize the @@ -2512,26 +3656,39 @@ func (c *MechanismInfoFlag) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) err return nil } - v, ok := _MechanismInfoFlagNameToValue[string(d)] - if !ok { - return err - } - *c = v - return nil + return c.FromString(string(d)) } func (c MechanismInfoFlag) String() string { - if str, ok := _MechanismInfoFlagValueToName[c]; ok { + if str, ok := MechanismInfoFlagValueToName[c]; ok { return str } return "MechanismInfoFlag(0x" + strconv.FormatUint(uint64(c), 16) + ")" } +func (c *MechanismInfoFlag) FromString(s string) error { + v, ok := MechanismInfoFlagNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "MechanismInfoFlag(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid MechanismInfoFlag %q", s) + } + + *c = MechanismInfoFlag(vv) + return nil +} + // MarshalJSON is generated so ObjectClass satisfies json.Marshaler. func (c ObjectClass) MarshalJSON() ([]byte, error) { - s, ok := _ObjectClassValueToName[c] + s, ok := ObjectClassValueToName[c] if !ok { - return nil, fmt.Errorf("invalid ObjectClass: %d", c) + s = c.String() } return json.Marshal(s) } @@ -2542,12 +3699,8 @@ func (c *ObjectClass) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s); err != nil { return fmt.Errorf("ObjectClass should be a string, got %s", data) } - v, ok := _ObjectClassNameToValue[s] - if !ok { - return fmt.Errorf("invalid ObjectClass %q", s) - } - *c = v - return nil + + return c.FromString(s) } // Workaround for a strange Map behaviour @@ -2556,12 +3709,7 @@ func (c ObjectClass) MarshalText() (text []byte, err error) { } func (c *ObjectClass) UnmarshalText(text []byte) error { - v, ok := _ObjectClassNameToValue[string(text)] - if !ok { - return fmt.Errorf("invalid ObjectClass %q", string(text)) - } - *c = v - return nil + return c.FromString(string(text)) } // JSONPBMarshaler is implemented by protobuf messages that customize the @@ -2582,26 +3730,39 @@ func (c *ObjectClass) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { return nil } - v, ok := _ObjectClassNameToValue[string(d)] - if !ok { - return err - } - *c = v - return nil + return c.FromString(string(d)) } func (c ObjectClass) String() string { - if str, ok := _ObjectClassValueToName[c]; ok { + if str, ok := ObjectClassValueToName[c]; ok { return str } return "ObjectClass(0x" + strconv.FormatUint(uint64(c), 16) + ")" } +func (c *ObjectClass) FromString(s string) error { + v, ok := ObjectClassNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "ObjectClass(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid ObjectClass %q", s) + } + + *c = ObjectClass(vv) + return nil +} + // MarshalJSON is generated so Return satisfies json.Marshaler. func (c Return) MarshalJSON() ([]byte, error) { - s, ok := _ReturnValueToName[c] + s, ok := ReturnValueToName[c] if !ok { - return nil, fmt.Errorf("invalid Return: %d", c) + s = c.String() } return json.Marshal(s) } @@ -2612,12 +3773,8 @@ func (c *Return) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s); err != nil { return fmt.Errorf("Return should be a string, got %s", data) } - v, ok := _ReturnNameToValue[s] - if !ok { - return fmt.Errorf("invalid Return %q", s) - } - *c = v - return nil + + return c.FromString(s) } // Workaround for a strange Map behaviour @@ -2626,12 +3783,7 @@ func (c Return) MarshalText() (text []byte, err error) { } func (c *Return) UnmarshalText(text []byte) error { - v, ok := _ReturnNameToValue[string(text)] - if !ok { - return fmt.Errorf("invalid Return %q", string(text)) - } - *c = v - return nil + return c.FromString(string(text)) } // JSONPBMarshaler is implemented by protobuf messages that customize the @@ -2652,22 +3804,34 @@ func (c *Return) UnmarshalJSONPB(m *jsonpb.Unmarshaler, d []byte) error { return nil } - v, ok := _ReturnNameToValue[string(d)] - if !ok { - return err - } - *c = v - return nil + return c.FromString(string(d)) } func (c Return) String() string { - if str, ok := _ReturnValueToName[c]; ok { + if str, ok := ReturnValueToName[c]; ok { return str } return "Return(0x" + strconv.FormatUint(uint64(c), 16) + ")" } +func (c *Return) FromString(s string) error { + v, ok := ReturnNameToValue[s] + if ok { + *c = v + return nil + } + + ss := strings.TrimPrefix(s, "Return(0x") + ss = strings.TrimSuffix(ss, ")") + vv, err := strconv.ParseUint(ss, 16, 64) + if err != nil { + return fmt.Errorf("invalid Return %q", s) + } + + *c = Return(vv) + return nil +} + func (c Return) Error() string { return c.String() } - diff --git a/golang/examples/bip32_test.go b/golang/examples/bip32_test.go new file mode 100644 index 0000000..00b7afc --- /dev/null +++ b/golang/examples/bip32_test.go @@ -0,0 +1,815 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package examples + +import ( + "context" + "crypto/sha256" + "encoding/asn1" + "fmt" + "crypto/tls" + "crypto/x509" + "io/ioutil" + yaml "gopkg.in/yaml.v2" + "google.golang.org/grpc/credentials" + + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" + pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/util" + grpc "google.golang.org/grpc" +) + +var yamlConfig, _ = ioutil.ReadFile("credential.yaml") + +var m = make(map[interface{}]interface{}) +var err = yaml.Unmarshal([]byte(yamlConfig), &m) + +var address = m["url"].(string) +var ( + crt = m["cert_path"].(string) + key = m["key_path"].(string) + ca = m["cacert_path"].(string) +) + +var certificate, _ = tls.LoadX509KeyPair(crt, key) +var certPool = x509.NewCertPool() +var cacert, _ = ioutil.ReadFile(ca) +var a = certPool.AppendCertsFromPEM(cacert) + +var creds = credentials.NewTLS(&tls.Config{ + ServerName: address, // NOTE: this is required! + Certificates: []tls.Certificate{certificate}, + RootCAs: certPool, +}) + +var callOpts = []grpc.DialOption{ + grpc.WithTransportCredentials(creds), +} + +func Example_bip32DeriveKey() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } else { + fmt.Println("Generated Generic Secret Key") + } + masterSecretKey, masterChainCode := bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032MASTERK, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + + const maxDepth = 3 + const maxChild = 3 + var privateKey [maxDepth][maxChild][]byte + var privateChainCode [maxDepth][maxChild][]byte + var publicKey [maxDepth][maxChild][]byte + var publicChainCode [maxDepth][maxChild][]byte + var child, depth uint64 + + for child = 0; child < maxChild; child++ { + privateKey[0][child], privateChainCode[0][child] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + child, + masterSecretKey, + masterChainCode, + ) + publicKey[0][child], publicChainCode[0][child] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + child, + masterSecretKey, + masterChainCode, + ) + } + for depth = 1; depth < maxDepth; depth++ { + for child = 0; child < maxChild; child++ { + privateKey[depth][child], privateChainCode[depth][child] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + child, + privateKey[depth-1][child], + privateChainCode[depth-1][child], + ) + publicKey[depth][child], publicChainCode[depth][child] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + child, + privateKey[depth-1][child], + privateChainCode[depth-1][child], + ) + // PUB2PUB is not supported yet + /* + publicKey[depth][child], publicChainCode[depth][child] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PUB2PUB, + child, + publicKey[depth-1][child], + publicChainCode[depth-1][child], + ) + */ + } + } + for depth = 0; depth < maxDepth; depth++ { + for child = 0; child < maxChild; child++ { + bip32_signAndVerifySingle(cryptoClient, privateKey[depth][child], publicKey[depth][child]) + } + } + + // Output: + // Generated Generic Secret Key + // Derived Key type=CkBIP0032MASTERK index=0 + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Derived Key type=CkBIP0032PRV2PRV index=1 + // Derived Key type=CkBIP0032PRV2PUB index=1 + // Derived Key type=CkBIP0032PRV2PRV index=2 + // Derived Key type=CkBIP0032PRV2PUB index=2 + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Derived Key type=CkBIP0032PRV2PRV index=1 + // Derived Key type=CkBIP0032PRV2PUB index=1 + // Derived Key type=CkBIP0032PRV2PRV index=2 + // Derived Key type=CkBIP0032PRV2PUB index=2 + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Derived Key type=CkBIP0032PRV2PRV index=1 + // Derived Key type=CkBIP0032PRV2PUB index=1 + // Derived Key type=CkBIP0032PRV2PRV index=2 + // Derived Key type=CkBIP0032PRV2PUB index=2 + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified +} + +func bip32_deriveKey(cryptoClient pb.CryptoClient, deriveType pb.BTCDeriveParm_BTCDeriveType, childKeyIndex uint64, baseKey []byte, chainCode []byte) ([]byte, []byte) { + + ecParameters, err := asn1.Marshal(util.OIDNamedCurveSecp256k1) + if err != nil { + panic(fmt.Errorf("Unable to encode parameter OID: %s", err)) + } + + deriveKeyRequest := &pb.DeriveKeyRequest{ + Mech: &pb.Mechanism{ + Mechanism: ep11.CKM_IBM_BTC_DERIVE, + Parameter: &pb.Mechanism_BTCDeriveParameter{ + BTCDeriveParameter: &pb.BTCDeriveParm{ + Type: deriveType, + ChildKeyIndex: childKeyIndex, + ChainCode: chainCode, + Version: 1, + }, + }, + }, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_KEY_TYPE: ep11.CKK_ECDSA, + ep11.CKA_VALUE_LEN: (uint64)(0), + ep11.CKA_IBM_USE_AS_DATA: true, + ep11.CKA_EC_PARAMS: ecParameters, + }, + ), + BaseKey: baseKey, + } + deriveKeyResponse, err := cryptoClient.DeriveKey(context.Background(), deriveKeyRequest) + if err != nil { + panic(fmt.Errorf("Derived Child Key request: %+v error: %s", deriveKeyRequest, err)) + } else { + fmt.Printf("Derived Key type=%s index=%d\n", + pb.BTCDeriveParm_BTCDeriveType_name[(int32)(deriveType)], childKeyIndex) + } + + return deriveKeyResponse.NewKeyBytes, deriveKeyResponse.CheckSum +} + +func bip32_signAndVerify(cryptoClient pb.CryptoClient, privateKey []byte, publicKey []byte) bool { + + signInitRequest := &pb.SignInitRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PrivKey: privateKey, + } + signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) + if err != nil { + panic(fmt.Errorf("SignInit error: %s", err)) + } + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signRequest := &pb.SignRequest{ + State: signInitResponse.State, + Data: signData, + } + signResponse, err := cryptoClient.Sign(context.Background(), signRequest) + for { + if err == nil { + break + } + fmt.Printf("Failed Sign [%s]", err) + signResponse, err = cryptoClient.Sign(context.Background(), signRequest) + } + if err != nil { + panic(fmt.Errorf("Sign error: %s", err)) + } + fmt.Println("Data signed") + + // Modify signature to force returned error code + //SignResponse.Signature[0] = 255 + + verifyInitRequest := &pb.VerifyInitRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PubKey: publicKey, + } + verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) + if err != nil { + panic(fmt.Errorf("VerifyInit error: %s", err)) + } + verifyRequest := &pb.VerifyRequest{ + State: verifyInitResponse.State, + Data: signData, + Signature: signResponse.Signature, + } + _, err = cryptoClient.Verify(context.Background(), verifyRequest) + + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Printf("Invalid signature\n") + return false + } + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + return false + } + fmt.Println("Signature verified") + return true +} + +func bip32_signAndVerifySingle(cryptoClient pb.CryptoClient, privateKey []byte, publicKey []byte) bool { + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signSingleRequest := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PrivKey: privateKey, + Data: signData, + } + signSingleResponse, err := cryptoClient.SignSingle(context.Background(), signSingleRequest) + if err != nil { + panic(fmt.Errorf("SignSingle error: %s", err)) + } else { + fmt.Println("Data signed") + } + + verifySingleRequest := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PubKey: publicKey, + Data: signData, + Signature: signSingleResponse.Signature, + } + _, err = cryptoClient.VerifySingle(context.Background(), verifySingleRequest) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + panic(fmt.Errorf("Invalid signature")) + } else { + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + } + return false + } + fmt.Println("Signature verified") + return true +} + +//general tests cases +func Example_bip32_Base() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + fmt.Printf("Generating random seed key...\n") + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } + const max_depth = 3 + const max_child = 1 + + var privateKey [max_depth][max_child][]byte + var privateChainCode [max_depth][max_child][]byte + var publicKey [max_depth][max_child][]byte + var publicChainCode [max_depth][max_child][]byte + var child, depth uint64 + + fmt.Println("Depth0: Generating master key and master chaincode...") + masterSecretKey, masterChainCode := bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032MASTERK, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + fmt.Println("Depth0: Generated master key from random seed and master chaincode") + + fmt.Println("Depth1: Generating Wallets accounts...") + privateKey[0][0], privateChainCode[0][0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + 0, + masterSecretKey, + masterChainCode, + ) + publicKey[0][0], publicChainCode[0][0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + masterSecretKey, + masterChainCode, + ) + + fmt.Println("Depth1: Generated external and internal Wallet accout") + + fmt.Println("Depth2: Generating Wallets chains...") + privateKey[1][0], privateChainCode[1][0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + 0, + privateKey[0][0], + privateChainCode[0][0], + ) + publicKey[1][0], publicChainCode[1][0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + privateKey[0][0], + privateChainCode[0][0], + ) + + fmt.Println("Depth2: Generated internal and external wallet chain successfully") + + fmt.Println("Depth3: Generating Wallets addresses...") + privateKey[2][0], privateChainCode[2][0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + 0, + privateKey[1][0], + privateChainCode[1][0], + ) + publicKey[2][0], publicChainCode[2][0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + privateKey[1][0], + privateChainCode[1][0], + ) + fmt.Println("Depth3: Generated external and internal addresses successfully.") + + for depth = 0; depth < max_depth; depth++ { + for child = 0; child < max_child; child++ { + bip32_signAndVerify(cryptoClient, privateKey[depth][child], publicKey[depth][child]) + } + } + fmt.Println("Sign and verify") + + for depth = 0; depth < max_depth; depth++ { + for child = 0; child < max_child; child++ { + bip32_signAndVerifySingle(cryptoClient, privateKey[depth][child], publicKey[depth][child]) + } + } + fmt.Println("SignSingle and verifySingle") + + // Output: + // Generating random seed key... + // Depth0: Generating master key and master chaincode... + // Derived Key type=CkBIP0032MASTERK index=0 + // Depth0: Generated master key from random seed and master chaincode + // Depth1: Generating Wallets accounts... + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Depth1: Generated external and internal Wallet accout + // Depth2: Generating Wallets chains... + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Depth2: Generated internal and external wallet chain successfully + // Depth3: Generating Wallets addresses... + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Depth3: Generated external and internal addresses successfully. + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Sign and verify + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // SignSingle and verifySingle +} + +//cover private->private public->public key derivation +func Example_bip32_KeyDerivation() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + fmt.Printf("Generating random seed key...\n") + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } + + var publicKey []byte + var publicChainCode []byte + + fmt.Println("Generating master key and master chaincode...") + masterSecretKey, masterChainCode := bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032MASTERK, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + fmt.Println("Generated master key from random seed and master chaincode") + + fmt.Println("Generating Wallets accounts...") + ecParameters, err := asn1.Marshal(util.OIDNamedCurveSecp256k1) + if err != nil { + panic(fmt.Errorf("Unable to encode parameter OID: %s", err)) + } + publicKey, publicChainCode = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + masterSecretKey, + masterChainCode, + ) + fmt.Println("Derive key from private -> public") + deriveKeyRequestPri := &pb.DeriveKeyRequest{ + Mech: &pb.Mechanism{ + Mechanism: ep11.CKM_IBM_BTC_DERIVE, + Parameter: &pb.Mechanism_BTCDeriveParameter{ + BTCDeriveParameter: &pb.BTCDeriveParm{ + Type: pb.BTCDeriveParm_CkBIP0032PRV2PRV, + ChildKeyIndex: 0, + ChainCode: masterChainCode, + Version: 1, + }, + }, + }, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_KEY_TYPE: ep11.CKK_ECDSA, + ep11.CKA_VALUE_LEN: (uint64)(0), + ep11.CKA_IBM_USE_AS_DATA: true, + ep11.CKA_EC_PARAMS: ecParameters, + }, + ), + BaseKey: masterSecretKey, + } + _, err = cryptoClient.DeriveKey(context.Background(), deriveKeyRequestPri) + if err != nil { + fmt.Println("Don't supporte deriving key from pulic to public in current soft-hsm version") + } else { + fmt.Println("Derive key from private -> private") + } + + deriveKeyRequestPub := &pb.DeriveKeyRequest{ + Mech: &pb.Mechanism{ + Mechanism: ep11.CKM_IBM_BTC_DERIVE, + Parameter: &pb.Mechanism_BTCDeriveParameter{ + BTCDeriveParameter: &pb.BTCDeriveParm{ + Type: pb.BTCDeriveParm_CkBIP0032PUB2PUB, + ChildKeyIndex: 0, + ChainCode: publicChainCode, + Version: 1, + }, + }, + }, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_KEY_TYPE: ep11.CKK_ECDSA, + ep11.CKA_VALUE_LEN: (uint64)(0), + ep11.CKA_IBM_USE_AS_DATA: true, + ep11.CKA_EC_PARAMS: ecParameters, + }, + ), + BaseKey: publicKey, + } + deriveKeyResponsePub, err := cryptoClient.DeriveKey(context.Background(), deriveKeyRequestPub) + if err != nil { + fmt.Println("Don't supporte deriving key from pulic -> public in current soft-hsm version") + } else { + fmt.Printf("Derive key from public to public successfully %v", deriveKeyResponsePub) + } + + // Output: + // Generating random seed key... + // Generating master key and master chaincode... + // Derived Key type=CkBIP0032MASTERK index=0 + // Generated master key from random seed and master chaincode + // Generating Wallets accounts... + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Derive key from private -> public + // Derive key from private -> private + // Don't supporte deriving key from pulic -> public in current soft-hsm version +} + +//cross sign and verification +func Example_bip32_Cross_SignVerify() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + fmt.Printf("Generating random seed key...\n") + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } + + fmt.Println("Generating master key and master chaincode...") + masterSecretKey, masterChainCode := bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032MASTERK, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + fmt.Println("Generated master key from random seed and master chaincode") + + var privateKey_w [3][]byte + var privateChainCode_w [3][]byte + var publicKey_w [3][]byte + var publicChainCode_w [3][]byte + + privateKey_w[0], privateChainCode_w[0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + 0, + masterSecretKey, + masterChainCode, + ) + publicKey_w[0], publicChainCode_w[0] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + masterSecretKey, + masterChainCode, + ) + fmt.Println("Depth1: Generated external and internal Wallet accout") + bip32_signAndVerifySingle(cryptoClient, privateKey_w[0], publicKey_w[0]) + + privateKey_w[1], privateChainCode_w[1] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + 0, + privateKey_w[0], + privateChainCode_w[0], + ) + publicKey_w[1], publicChainCode_w[1] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + privateKey_w[0], + privateChainCode_w[0], + ) + fmt.Println("Depth2: Generated internal and external wallet chain successfully") + bip32_signAndVerifySingle(cryptoClient, privateKey_w[1], publicKey_w[1]) + + privateKey_w[2], privateChainCode_w[2] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PRV, + 0, + privateKey_w[1], + privateChainCode_w[1], + ) + publicKey_w[2], publicChainCode_w[2] = bip32_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkBIP0032PRV2PUB, + 0, + privateKey_w[1], + privateChainCode_w[1], + ) + fmt.Println("Depth3: Generated external and internal addresses successfully.") + bip32_signAndVerifySingle(cryptoClient, privateKey_w[2], publicKey_w[2]) + + fmt.Println("Round 1: Cross verification") + signData_1 := sha256.New().Sum([]byte("This data needs to be signed")) + signSingleRequest_1 := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PrivKey: privateKey_w[2], + Data: signData_1, + } + signSingleResponse_1, err := cryptoClient.SignSingle(context.Background(), signSingleRequest_1) + if err != nil { + panic(fmt.Errorf("SignSingle error: %s", err)) + } + + verifySingleRequest_1 := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PubKey: publicKey_w[1], + Data: signData_1, + Signature: signSingleResponse_1.Signature, + } + _, err = cryptoClient.VerifySingle(context.Background(), verifySingleRequest_1) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Println("Round 1: Invalid signature") + } else { + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + } + } + + fmt.Println("Round 2: Cross verification") + signData_2 := sha256.New().Sum([]byte("This data needs to be signed")) + signSingleRequest_2 := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PrivKey: privateKey_w[1], + Data: signData_2, + } + signSingleResponse_2, err := cryptoClient.SignSingle(context.Background(), signSingleRequest_2) + if err != nil { + panic(fmt.Errorf("SignSingle error: %s", err)) + } + + verifySingleRequest_2 := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PubKey: publicKey_w[0], + Data: signData_2, + Signature: signSingleResponse_2.Signature, + } + _, err = cryptoClient.VerifySingle(context.Background(), verifySingleRequest_2) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Println("Round 2: Invalid signature") + } else { + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + } + } + + fmt.Println("Round 3: Cross verification") + signData_3 := sha256.New().Sum([]byte("This data needs to be signed")) + signSingleRequest_3 := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PrivKey: privateKey_w[0], + Data: signData_3, + } + signSingleResponse_3, err := cryptoClient.SignSingle(context.Background(), signSingleRequest_3) + if err != nil { + panic(fmt.Errorf("SignSingle error: %s", err)) + } + + verifySingleRequest_3 := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, + PubKey: publicKey_w[2], + Data: signData_3, + Signature: signSingleResponse_3.Signature, + } + _, err = cryptoClient.VerifySingle(context.Background(), verifySingleRequest_3) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Println("Round 3: Invalid signature") + } else { + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + } + } + + //Output: + // Generating random seed key... + // Generating master key and master chaincode... + // Derived Key type=CkBIP0032MASTERK index=0 + // Generated master key from random seed and master chaincode + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Depth1: Generated external and internal Wallet accout + // Data signed + // Signature verified + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Depth2: Generated internal and external wallet chain successfully + // Data signed + // Signature verified + // Derived Key type=CkBIP0032PRV2PRV index=0 + // Derived Key type=CkBIP0032PRV2PUB index=0 + // Depth3: Generated external and internal addresses successfully. + // Data signed + // Signature verified + // Round 1: Cross verification + // Round 1: Invalid signature + // Round 2: Cross verification + // Round 2: Invalid signature + // Round 3: Cross verification + // Round 3: Invalid signature +} diff --git a/golang/examples/slip10_test.go b/golang/examples/slip10_test.go new file mode 100644 index 0000000..e0238ba --- /dev/null +++ b/golang/examples/slip10_test.go @@ -0,0 +1,898 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package examples + +import ( + "context" + "crypto/sha256" + "encoding/asn1" + "fmt" + "io/ioutil" + "crypto/tls" + "crypto/x509" + yaml "gopkg.in/yaml.v2" + + "google.golang.org/grpc/credentials" + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" + pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/util" + grpc "google.golang.org/grpc" +) + +var yamlConfig, _ = ioutil.ReadFile("credential.yaml") + +var m = make(map[interface{}]interface{}) +var err = yaml.Unmarshal([]byte(yamlConfig), &m) + +var address = m["url"].(string) +var ( + crt = m["cert_path"].(string) + key = m["key_path"].(string) + ca = m["cacert_path"].(string) +) + +var certificate, _ = tls.LoadX509KeyPair(crt, key) +var certPool = x509.NewCertPool() +var cacert, _ = ioutil.ReadFile(ca) +var a = certPool.AppendCertsFromPEM(cacert) + +var creds = credentials.NewTLS(&tls.Config{ + ServerName: address, // NOTE: this is required! + Certificates: []tls.Certificate{certificate}, + RootCAs: certPool, +}) + +var callOpts = []grpc.DialOption{ + grpc.WithTransportCredentials(creds), +} + +func Example_slip10DeriveKey() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + // SLIP10 has been verified for NIST P-256 and Secp256k1 + supportedCurves := []asn1.ObjectIdentifier{util.OIDNamedCurveP256, util.OIDNamedCurveSecp256k1, util.OIDNamedCurveED25519} + for _, oid := range supportedCurves { + fmt.Printf("Curve: %+v\n", oid) + slip10_testCurve(cryptoClient, oid) + } + + // Output: + // Curve: 1.2.840.10045.3.1.7 + // Generated Generic Secret Key + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Curve: 1.3.132.0.10 + // Generated Generic Secret Key + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Curve: 1.3.101.112 + // Generated Generic Secret Key + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483649 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483649 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483650 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483650 + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified + // Data signed + // Signature verified +} + +func slip10_testCurve(cryptoClient pb.CryptoClient, oid asn1.ObjectIdentifier) { + + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } else { + fmt.Println("Generated Generic Secret Key") + } + + masterSecretKey, masterChainCode := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + oid, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + + const maxDepth = 3 + const maxChild = 3 + const hardened = 0x80000000 // For ed25519 only hardened key generation from Private parent key to private child key is supported. + var privateKey [maxDepth][maxChild][]byte + var privateChainCode [maxDepth][maxChild][]byte + var publicKey [maxDepth][maxChild][]byte + var publicChainCode [maxDepth][maxChild][]byte + var child, depth uint64 + + for child = 0; child < maxChild; child++ { + privateKey[0][child], privateChainCode[0][child] = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + oid, + child+hardened, + masterSecretKey, + masterChainCode, + ) + publicKey[0][child], publicChainCode[0][child] = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + oid, + child+hardened, + masterSecretKey, + masterChainCode, + ) + } + for depth = 1; depth < maxDepth; depth++ { + for child = 0; child < maxChild; child++ { + privateKey[depth][child], privateChainCode[depth][child] = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + oid, + child+hardened, + privateKey[depth-1][child], + privateChainCode[depth-1][child], + ) + publicKey[depth][child], publicChainCode[depth][child] = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + oid, + child+hardened, + privateKey[depth-1][child], + privateChainCode[depth-1][child], + ) + // PUB2PUB is not supported yet + /* + publicKey[depth][child], publicChainCode[depth][child] = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PUB2PUB, + oid, + child, + publicKey[depth-1][child], + publicChainCode[depth-1][child], + ) + */ + } + } + for depth = 0; depth < maxDepth; depth++ { + for child = 0; child < maxChild; child++ { + slip10_signAndVerifySingle(cryptoClient, oid, privateKey[depth][child], publicKey[depth][child]) + } + } +} + +func slip10_deriveKey(cryptoClient pb.CryptoClient, deriveType pb.BTCDeriveParm_BTCDeriveType, oid asn1.ObjectIdentifier, childKeyIndex uint64, baseKey []byte, chainCode []byte) ([]byte, []byte) { + + ecParameters, err := asn1.Marshal(oid) + if err != nil { + panic(fmt.Errorf("Unable to encode parameter OID: %s", err)) + } + + deriveKeyRequest := &pb.DeriveKeyRequest{ + Mech: &pb.Mechanism{ + Mechanism: ep11.CKM_IBM_BTC_DERIVE, + Parameter: &pb.Mechanism_BTCDeriveParameter{ + BTCDeriveParameter: &pb.BTCDeriveParm{ + Type: deriveType, + ChildKeyIndex: childKeyIndex, + ChainCode: chainCode, + Version: 1, + }, + }, + }, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_KEY_TYPE: ep11.CKK_ECDSA, + ep11.CKA_VALUE_LEN: (uint64)(0), + ep11.CKA_IBM_USE_AS_DATA: true, + ep11.CKA_EC_PARAMS: ecParameters, + }, + ), + BaseKey: baseKey, + } + deriveKeyResponse, err := cryptoClient.DeriveKey(context.Background(), deriveKeyRequest) + if err != nil { + panic(fmt.Errorf("Derived Child Key request: %+v error: %s", deriveKeyRequest, err)) + } else { + fmt.Printf("Derived Key type=%s index=%d\n", + pb.BTCDeriveParm_BTCDeriveType_name[(int32)(deriveType)], childKeyIndex) + } + + return deriveKeyResponse.NewKeyBytes, deriveKeyResponse.CheckSum +} + +func slip10_signAndVerify(cryptoClient pb.CryptoClient, oid asn1.ObjectIdentifier, privateKey []byte, publicKey []byte) bool { + + mech := GetSignMechanismFromOID(oid) + + signInitRequest := &pb.SignInitRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PrivKey: privateKey, + } + signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) + if err != nil { + panic(fmt.Errorf("SignInit error: %s", err)) + } + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signRequest := &pb.SignRequest{ + State: signInitResponse.State, + Data: signData, + } + signResponse, err := cryptoClient.Sign(context.Background(), signRequest) + for { + if err == nil { + break + } + fmt.Printf("Failed Sign [%s]", err) + signResponse, err = cryptoClient.Sign(context.Background(), signRequest) + } + if err != nil { + panic(fmt.Errorf("Sign error: %s", err)) + } + fmt.Println("Data signed") + + // Modify signature to force returned error code + //SignResponse.Signature[0] = 255 + + verifyInitRequest := &pb.VerifyInitRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PubKey: publicKey, + } + verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) + if err != nil { + panic(fmt.Errorf("VerifyInit error: %s", err)) + } + verifyRequest := &pb.VerifyRequest{ + State: verifyInitResponse.State, + Data: signData, + Signature: signResponse.Signature, + } + _, err = cryptoClient.Verify(context.Background(), verifyRequest) + + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Printf("Invalid signature\n") + return false + } + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + return false + } + fmt.Println("Signature verified") + return true +} + +func slip10_signAndVerifySingle(cryptoClient pb.CryptoClient, oid asn1.ObjectIdentifier, privateKey []byte, publicKey []byte) bool { + + mech := GetSignMechanismFromOID(oid) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signSingleRequest := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PrivKey: privateKey, + Data: signData, + } + signSingleResponse, err := cryptoClient.SignSingle(context.Background(), signSingleRequest) + if err != nil { + panic(fmt.Errorf("SignSingle error: %s", err)) + } else { + fmt.Println("Data signed") + } + + verifySingleRequest := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PubKey: publicKey, + Data: signData, + Signature: signSingleResponse.Signature, + } + _, err = cryptoClient.VerifySingle(context.Background(), verifySingleRequest) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + panic(fmt.Errorf("Invalid signature")) + } else { + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + } + return false + } + fmt.Println("Signature verified") + return true +} + +func GetSignMechanismFromOID(oid asn1.ObjectIdentifier) ep11.Mechanism { + switch { + case oid.Equal(util.OIDNamedCurveED25519): + return ep11.CKM_IBM_ED25519_SHA512 + case oid.Equal(util.OIDNamedCurveP256): + return ep11.CKM_ECDSA + case oid.Equal(util.OIDNamedCurveSecp256k1): + return ep11.CKM_ECDSA + } + panic(fmt.Errorf("Unexpected OID: %+v", oid)) +} + +func Example_slip10_invalid_signAndVerify() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + // SLIP10 has been verified for NIST P-256 and Secp256k1 + //util.OIDNamedCurveP256, util.OIDNamedCurveSecp256k1, util.OIDNamedCurveED25519 + + //generate random seed key + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } else { + fmt.Println("Generated Generic Secret Key") + } + + const hardened = 0x80000000 + + //keys of NIST P-256 + var publicKey_p256, privateKey_p256 []byte + masterSecretKey_p256, masterChainCode_p256 := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + util.OIDNamedCurveP256, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + privateKey_p256, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + util.OIDNamedCurveP256, + hardened, + masterSecretKey_p256, + masterChainCode_p256, + ) + publicKey_p256, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + util.OIDNamedCurveP256, + hardened, + masterSecretKey_p256, + masterChainCode_p256, + ) + + //keys of Secp256k1 + var privateKey_256k1, publicKey_256k1 []byte + masterSecretKey_256k1, masterChainCode_256k1 := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + util.OIDNamedCurveSecp256k1, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + privateKey_256k1, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + util.OIDNamedCurveSecp256k1, + hardened, + masterSecretKey_256k1, + masterChainCode_256k1, + ) + publicKey_256k1, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + util.OIDNamedCurveSecp256k1, + hardened, + masterSecretKey_256k1, + masterChainCode_256k1, + ) + + //keys of ED25519 + var privateKey_ed25519, publicKey_ed25519 []byte + masterSecretKey_ed25519, masterChainCode_ed25519 := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + util.OIDNamedCurveED25519, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + privateKey_ed25519, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + util.OIDNamedCurveED25519, + hardened, + masterSecretKey_ed25519, + masterChainCode_ed25519, + ) + publicKey_ed25519, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + util.OIDNamedCurveED25519, + hardened, + masterSecretKey_ed25519, + masterChainCode_ed25519, + ) + //invalid sign with incorrect curve - NIST P-256 curve + slip10_signAndVerify_crossErr(cryptoClient, util.OIDNamedCurveED25519, privateKey_p256, publicKey_p256) + //nvalid sign with incorrect curve - secp256k1 curve + slip10_signAndVerify_crossErr(cryptoClient, util.OIDNamedCurveED25519, privateKey_256k1, publicKey_256k1) + //invalid sign with incorrect curve- ED25519 curve + slip10_signAndVerify_crossErr(cryptoClient, util.OIDNamedCurveP256, privateKey_ed25519, publicKey_ed25519) + //invalid verification + slip10_signAndVerify_crossErr(cryptoClient, util.OIDNamedCurveP256, privateKey_p256, publicKey_256k1) + slip10_signAndVerify_crossErr(cryptoClient, util.OIDNamedCurveSecp256k1, privateKey_256k1, publicKey_p256) + slip10_signAndVerify_crossErr(cryptoClient, util.OIDNamedCurveED25519, privateKey_ed25519, publicKey_p256) + + // Output: + // Generated Generic Secret Key + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // SignInit error with invalid Mechanism - 1.3.101.112 + // SignInit error with invalid Mechanism - 1.3.101.112 + // SignInit error with invalid Mechanism - 1.2.840.10045.3.1.7 + // Data signed + // Invalid signature + // Data signed + // Invalid signature + // Data signed + // VerifyInit error with invalid Mechanism - 1.3.101.112 +} + +func slip10_signAndVerify_crossErr(cryptoClient pb.CryptoClient, oid asn1.ObjectIdentifier, privateKey []byte, publicKey []byte) bool { + + mech := GetSignMechanismFromOID(oid) + + signInitRequest := &pb.SignInitRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PrivKey: privateKey, + } + signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) + if err != nil { + fmt.Printf("SignInit error with invalid Mechanism - %s\n", oid) + return false + } + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signRequest := &pb.SignRequest{ + State: signInitResponse.State, + Data: signData, + } + signResponse, err := cryptoClient.Sign(context.Background(), signRequest) + for { + if err == nil { + break + } + fmt.Printf("Failed Sign [%s]", err) + signResponse, err = cryptoClient.Sign(context.Background(), signRequest) + } + if err != nil { + fmt.Printf("Sign error with invalid Mechanism - %s\n", oid) + } + fmt.Println("Data signed") + + // Modify signature to force returned error code + //SignResponse.Signature[0] = 255 + + verifyInitRequest := &pb.VerifyInitRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PubKey: publicKey, + } + verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) + if err != nil { + fmt.Printf("VerifyInit error with invalid Mechanism - %s\n", oid) + return false + } + verifyRequest := &pb.VerifyRequest{ + State: verifyInitResponse.State, + Data: signData, + Signature: signResponse.Signature, + } + _, err = cryptoClient.Verify(context.Background(), verifyRequest) + + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Printf("Invalid signature\n") + return false + } + fmt.Printf("Signature error with invalid Mechanism - %s\n", oid) + } + fmt.Println("Signature verified") + return true +} + +func Example_slip10_cross_signAndVerify() { + conn, err := grpc.Dial(address, callOpts...) + if err != nil { + panic(fmt.Errorf("Could not connect to server: %s", err)) + } + defer conn.Close() + cryptoClient := pb.NewCryptoClient(conn) + + // SLIP10 has been verified for NIST P-256 and Secp256k1 + //util.OIDNamedCurveP256, util.OIDNamedCurveSecp256k1, util.OIDNamedCurveED25519 + + //generate random seed key + generateKeyRequest := &pb.GenerateKeyRequest{ + Mech: &pb.Mechanism{Mechanism: ep11.CKM_GENERIC_SECRET_KEY_GEN}, + Template: util.AttributeMap( + ep11.EP11Attributes{ + ep11.CKA_KEY_TYPE: ep11.CKK_GENERIC_SECRET, + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_VALUE_LEN: (uint64)(256 / 8), + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_SIGN: true, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + ep11.CKA_DERIVE: true, + ep11.CKA_IBM_USE_AS_DATA: true, + }, + ), + } + generateKeyResponse, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) + if err != nil { + panic(fmt.Errorf("Generated Generic Secret Key error: %+v %s", generateKeyRequest, err)) + } else { + fmt.Println("Generated Generic Secret Key") + } + + const hardened = 0x80000000 + + //keys of NIST P-256 + var publicKey_p256, privateKey_p256 []byte + masterSecretKey_p256, masterChainCode_p256 := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + util.OIDNamedCurveP256, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + privateKey_p256, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + util.OIDNamedCurveP256, + hardened, + masterSecretKey_p256, + masterChainCode_p256, + ) + publicKey_p256, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + util.OIDNamedCurveP256, + hardened, + masterSecretKey_p256, + masterChainCode_p256, + ) + + //keys of Secp256k1 + var privateKey_256k1, publicKey_256k1 []byte + masterSecretKey_256k1, masterChainCode_256k1 := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + util.OIDNamedCurveSecp256k1, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + privateKey_256k1, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + util.OIDNamedCurveSecp256k1, + hardened, + masterSecretKey_256k1, + masterChainCode_256k1, + ) + publicKey_256k1, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + util.OIDNamedCurveSecp256k1, + hardened, + masterSecretKey_256k1, + masterChainCode_256k1, + ) + + //keys of ED25519 + var privateKey_ed25519, publicKey_ed25519 []byte + masterSecretKey_ed25519, masterChainCode_ed25519 := slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010MASTERK, + util.OIDNamedCurveED25519, + 0, + generateKeyResponse.KeyBytes, + nil, + ) + privateKey_ed25519, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PRV, + util.OIDNamedCurveED25519, + hardened, + masterSecretKey_ed25519, + masterChainCode_ed25519, + ) + publicKey_ed25519, _ = slip10_deriveKey( + cryptoClient, + pb.BTCDeriveParm_CkSLIP0010PRV2PUB, + util.OIDNamedCurveED25519, + hardened, + masterSecretKey_ed25519, + masterChainCode_ed25519, + ) + + //signSingle, and verifyInit/verify + slip10_signSingleAndVerify(cryptoClient, util.OIDNamedCurveP256, privateKey_p256, publicKey_p256) + slip10_signSingleAndVerify(cryptoClient, util.OIDNamedCurveSecp256k1, privateKey_256k1, publicKey_256k1) + slip10_signSingleAndVerify(cryptoClient, util.OIDNamedCurveED25519, privateKey_ed25519, publicKey_ed25519) + //signInit/sign, verifySingle + slip10_signAndVerifyInitAndSingle(cryptoClient, util.OIDNamedCurveP256, privateKey_p256, publicKey_p256) + slip10_signAndVerifyInitAndSingle(cryptoClient, util.OIDNamedCurveSecp256k1, privateKey_256k1, publicKey_256k1) + slip10_signAndVerifyInitAndSingle(cryptoClient, util.OIDNamedCurveED25519, privateKey_ed25519, publicKey_ed25519) + + // Output: + // Generated Generic Secret Key + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Derived Key type=CkSLIP0010MASTERK index=0 + // Derived Key type=CkSLIP0010PRV2PRV index=2147483648 + // Derived Key type=CkSLIP0010PRV2PUB index=2147483648 + // Data signed - 1.2.840.10045.3.1.7 + // Signature verified - 1.2.840.10045.3.1.7 + // Data signed - 1.3.132.0.10 + // Signature verified - 1.3.132.0.10 + // Data signed - 1.3.101.112 + // Signature verified - 1.3.101.112 + // Data signed - 1.2.840.10045.3.1.7 + // Signature verified - 1.2.840.10045.3.1.7 + // Data signed - 1.3.132.0.10 + // Signature verified - 1.3.132.0.10 + // Data signed - 1.3.101.112 + // Signature verified - 1.3.101.112 +} + +func slip10_signSingleAndVerify(cryptoClient pb.CryptoClient, oid asn1.ObjectIdentifier, privateKey []byte, publicKey []byte) bool { + + mech := GetSignMechanismFromOID(oid) + + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signSingleRequest := &pb.SignSingleRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PrivKey: privateKey, + Data: signData, + } + signSingleResponse, err := cryptoClient.SignSingle(context.Background(), signSingleRequest) + if err != nil { + panic(fmt.Errorf("SignSingle error: %s", err)) + } + fmt.Printf("Data signed - %s\n", oid) + + // Modify signature to force returned error code + //SignResponse.Signature[0] = 255 + + verifyInitRequest := &pb.VerifyInitRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PubKey: publicKey, + } + verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) + if err != nil { + panic(fmt.Errorf("VerifyInit error: %s", err)) + } + verifyRequest := &pb.VerifyRequest{ + State: verifyInitResponse.State, + Data: signData, + Signature: signSingleResponse.Signature, + } + _, err = cryptoClient.Verify(context.Background(), verifyRequest) + + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + fmt.Printf("Invalid signature\n") + return false + } + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + return false + } + fmt.Printf("Signature verified - %s\n", oid) + return true +} + +func slip10_signAndVerifyInitAndSingle(cryptoClient pb.CryptoClient, oid asn1.ObjectIdentifier, privateKey []byte, publicKey []byte) bool { + + mech := GetSignMechanismFromOID(oid) + + signInitRequest := &pb.SignInitRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PrivKey: privateKey, + } + signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) + if err != nil { + panic(fmt.Errorf("SignInit error: %s", err)) + } + signData := sha256.New().Sum([]byte("This data needs to be signed")) + signRequest := &pb.SignRequest{ + State: signInitResponse.State, + Data: signData, + } + signResponse, err := cryptoClient.Sign(context.Background(), signRequest) + for { + if err == nil { + break + } + fmt.Printf("Failed Sign [%s]", err) + signResponse, err = cryptoClient.Sign(context.Background(), signRequest) + } + if err != nil { + panic(fmt.Errorf("Sign error: %s", err)) + } + fmt.Printf("Data signed - %s\n", oid) + + verifySingleRequest := &pb.VerifySingleRequest{ + Mech: &pb.Mechanism{Mechanism: mech}, + PubKey: publicKey, + Data: signData, + Signature: signResponse.Signature, + } + _, err = cryptoClient.VerifySingle(context.Background(), verifySingleRequest) + if ok, ep11Status := util.Convert(err); !ok { + if ep11Status.Code == ep11.CKR_SIGNATURE_INVALID { + panic(fmt.Errorf("Invalid signature")) + } else { + panic(fmt.Errorf("Verify error: [%d]: %s", ep11Status.Code, ep11Status.Detail)) + } + return false + } + fmt.Printf("Signature verified - %s\n", oid) + return true +} diff --git a/golang/grpc/server.pb.go b/golang/grpc/server.pb.go index 7c5e29c..2b4db65 100644 --- a/golang/grpc/server.pb.go +++ b/golang/grpc/server.pb.go @@ -3,20 +3,21 @@ package grep11 -import proto "github.com/gogo/protobuf/proto" -import fmt "fmt" -import math "math" -import _ "github.com/gogo/protobuf/gogoproto" - -import github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11 "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" - import ( - context "golang.org/x/net/context" + context "context" + fmt "fmt" + _ "github.com/gogo/googleapis/google/api" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + ep11 "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" ) -import io "io" - // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf @@ -26,7 +27,198 @@ var _ = math.Inf // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package +//const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type RSAOAEPParm_Mask int32 + +const ( + RSAOAEPParm_CkgMgf1None RSAOAEPParm_Mask = 0 + RSAOAEPParm_CkgMgf1Sha1 RSAOAEPParm_Mask = 1 + RSAOAEPParm_CkgMgf1Sha256 RSAOAEPParm_Mask = 2 + RSAOAEPParm_CkgMgf1Sha384 RSAOAEPParm_Mask = 3 + RSAOAEPParm_CkgMgf1Sha512 RSAOAEPParm_Mask = 4 + RSAOAEPParm_CkgMgf1Sha224 RSAOAEPParm_Mask = 5 +) + +var RSAOAEPParm_Mask_name = map[int32]string{ + 0: "CkgMgf1None", + 1: "CkgMgf1Sha1", + 2: "CkgMgf1Sha256", + 3: "CkgMgf1Sha384", + 4: "CkgMgf1Sha512", + 5: "CkgMgf1Sha224", +} + +var RSAOAEPParm_Mask_value = map[string]int32{ + "CkgMgf1None": 0, + "CkgMgf1Sha1": 1, + "CkgMgf1Sha256": 2, + "CkgMgf1Sha384": 3, + "CkgMgf1Sha512": 4, + "CkgMgf1Sha224": 5, +} + +func (x RSAOAEPParm_Mask) String() string { + return proto.EnumName(RSAOAEPParm_Mask_name, int32(x)) +} + +func (RSAOAEPParm_Mask) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{75, 0} +} + +type RSAOAEPParm_ParmType int32 + +const ( + RSAOAEPParm_CkzNoDataSpecified RSAOAEPParm_ParmType = 0 + RSAOAEPParm_CkzDataSpecifiied RSAOAEPParm_ParmType = 1 +) + +var RSAOAEPParm_ParmType_name = map[int32]string{ + 0: "CkzNoDataSpecified", + 1: "CkzDataSpecifiied", +} + +var RSAOAEPParm_ParmType_value = map[string]int32{ + "CkzNoDataSpecified": 0, + "CkzDataSpecifiied": 1, +} + +func (x RSAOAEPParm_ParmType) String() string { + return proto.EnumName(RSAOAEPParm_ParmType_name, int32(x)) +} + +func (RSAOAEPParm_ParmType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{75, 1} +} + +type RSAPSSParm_Mask int32 + +const ( + RSAPSSParm_CkgMgf1None RSAPSSParm_Mask = 0 + RSAPSSParm_CkgMgf1Sha1 RSAPSSParm_Mask = 1 + RSAPSSParm_CkgMgf1Sha256 RSAPSSParm_Mask = 2 + RSAPSSParm_CkgMgf1Sha384 RSAPSSParm_Mask = 3 + RSAPSSParm_CkgMgf1Sha512 RSAPSSParm_Mask = 4 + RSAPSSParm_CkgMgf1Sha224 RSAPSSParm_Mask = 5 +) + +var RSAPSSParm_Mask_name = map[int32]string{ + 0: "CkgMgf1None", + 1: "CkgMgf1Sha1", + 2: "CkgMgf1Sha256", + 3: "CkgMgf1Sha384", + 4: "CkgMgf1Sha512", + 5: "CkgMgf1Sha224", +} + +var RSAPSSParm_Mask_value = map[string]int32{ + "CkgMgf1None": 0, + "CkgMgf1Sha1": 1, + "CkgMgf1Sha256": 2, + "CkgMgf1Sha384": 3, + "CkgMgf1Sha512": 4, + "CkgMgf1Sha224": 5, +} + +func (x RSAPSSParm_Mask) String() string { + return proto.EnumName(RSAPSSParm_Mask_name, int32(x)) +} + +func (RSAPSSParm_Mask) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{76, 0} +} + +type ECDH1DeriveParm_KeyDerivationFunction int32 + +const ( + ECDH1DeriveParm_CkdNotUsed0 ECDH1DeriveParm_KeyDerivationFunction = 0 + ECDH1DeriveParm_CkdNull ECDH1DeriveParm_KeyDerivationFunction = 1 + ECDH1DeriveParm_CkdSha1Kdf ECDH1DeriveParm_KeyDerivationFunction = 2 + ECDH1DeriveParm_CkdNotUsed3 ECDH1DeriveParm_KeyDerivationFunction = 3 + ECDH1DeriveParm_CkdNotUsed4 ECDH1DeriveParm_KeyDerivationFunction = 4 + ECDH1DeriveParm_CkdSha224Kdf ECDH1DeriveParm_KeyDerivationFunction = 5 + ECDH1DeriveParm_CkdSha256Kdf ECDH1DeriveParm_KeyDerivationFunction = 6 + ECDH1DeriveParm_CkdSha384Kdf ECDH1DeriveParm_KeyDerivationFunction = 7 + ECDH1DeriveParm_CkdSha512Kdf ECDH1DeriveParm_KeyDerivationFunction = 8 +) + +var ECDH1DeriveParm_KeyDerivationFunction_name = map[int32]string{ + 0: "CkdNotUsed0", + 1: "CkdNull", + 2: "CkdSha1Kdf", + 3: "CkdNotUsed3", + 4: "CkdNotUsed4", + 5: "CkdSha224Kdf", + 6: "CkdSha256Kdf", + 7: "CkdSha384Kdf", + 8: "CkdSha512Kdf", +} + +var ECDH1DeriveParm_KeyDerivationFunction_value = map[string]int32{ + "CkdNotUsed0": 0, + "CkdNull": 1, + "CkdSha1Kdf": 2, + "CkdNotUsed3": 3, + "CkdNotUsed4": 4, + "CkdSha224Kdf": 5, + "CkdSha256Kdf": 6, + "CkdSha384Kdf": 7, + "CkdSha512Kdf": 8, +} + +func (x ECDH1DeriveParm_KeyDerivationFunction) String() string { + return proto.EnumName(ECDH1DeriveParm_KeyDerivationFunction_name, int32(x)) +} + +func (ECDH1DeriveParm_KeyDerivationFunction) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{77, 0} +} + +type BTCDeriveParm_BTCDeriveType int32 + +const ( + BTCDeriveParm_CkBIP0032NotUsed BTCDeriveParm_BTCDeriveType = 0 + BTCDeriveParm_CkBIP0032PRV2PRV BTCDeriveParm_BTCDeriveType = 1 + BTCDeriveParm_CkBIP0032PRV2PUB BTCDeriveParm_BTCDeriveType = 2 + BTCDeriveParm_CkBIP0032PUB2PUB BTCDeriveParm_BTCDeriveType = 3 + BTCDeriveParm_CkBIP0032MASTERK BTCDeriveParm_BTCDeriveType = 4 + BTCDeriveParm_CkSLIP0010PRV2PRV BTCDeriveParm_BTCDeriveType = 5 + BTCDeriveParm_CkSLIP0010PRV2PUB BTCDeriveParm_BTCDeriveType = 6 + BTCDeriveParm_CkSLIP0010PUB2PUB BTCDeriveParm_BTCDeriveType = 7 + BTCDeriveParm_CkSLIP0010MASTERK BTCDeriveParm_BTCDeriveType = 8 +) + +var BTCDeriveParm_BTCDeriveType_name = map[int32]string{ + 0: "CkBIP0032NotUsed", + 1: "CkBIP0032PRV2PRV", + 2: "CkBIP0032PRV2PUB", + 3: "CkBIP0032PUB2PUB", + 4: "CkBIP0032MASTERK", + 5: "CkSLIP0010PRV2PRV", + 6: "CkSLIP0010PRV2PUB", + 7: "CkSLIP0010PUB2PUB", + 8: "CkSLIP0010MASTERK", +} + +var BTCDeriveParm_BTCDeriveType_value = map[string]int32{ + "CkBIP0032NotUsed": 0, + "CkBIP0032PRV2PRV": 1, + "CkBIP0032PRV2PUB": 2, + "CkBIP0032PUB2PUB": 3, + "CkBIP0032MASTERK": 4, + "CkSLIP0010PRV2PRV": 5, + "CkSLIP0010PRV2PUB": 6, + "CkSLIP0010PUB2PUB": 7, + "CkSLIP0010MASTERK": 8, +} + +func (x BTCDeriveParm_BTCDeriveType) String() string { + return proto.EnumName(BTCDeriveParm_BTCDeriveType_name, int32(x)) +} + +func (BTCDeriveParm_BTCDeriveType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{78, 0} +} type GenerateRandomRequest struct { Len uint64 `protobuf:"varint,1,opt,name=Len,proto3" json:"Len,omitempty"` @@ -39,7 +231,7 @@ func (m *GenerateRandomRequest) Reset() { *m = GenerateRandomRequest{} } func (m *GenerateRandomRequest) String() string { return proto.CompactTextString(m) } func (*GenerateRandomRequest) ProtoMessage() {} func (*GenerateRandomRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{0} + return fileDescriptor_ad098daeda4239f7, []int{0} } func (m *GenerateRandomRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -49,15 +241,15 @@ func (m *GenerateRandomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byt return xxx_messageInfo_GenerateRandomRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GenerateRandomRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenerateRandomRequest.Merge(dst, src) +func (m *GenerateRandomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenerateRandomRequest.Merge(m, src) } func (m *GenerateRandomRequest) XXX_Size() int { return m.Size() @@ -86,7 +278,7 @@ func (m *GenerateRandomResponse) Reset() { *m = GenerateRandomResponse{} func (m *GenerateRandomResponse) String() string { return proto.CompactTextString(m) } func (*GenerateRandomResponse) ProtoMessage() {} func (*GenerateRandomResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{1} + return fileDescriptor_ad098daeda4239f7, []int{1} } func (m *GenerateRandomResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -96,15 +288,15 @@ func (m *GenerateRandomResponse) XXX_Marshal(b []byte, deterministic bool) ([]by return xxx_messageInfo_GenerateRandomResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GenerateRandomResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenerateRandomResponse.Merge(dst, src) +func (m *GenerateRandomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenerateRandomResponse.Merge(m, src) } func (m *GenerateRandomResponse) XXX_Size() int { return m.Size() @@ -123,7 +315,7 @@ func (m *GenerateRandomResponse) GetRnd() []byte { } type DigestInitRequest struct { - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -133,7 +325,7 @@ func (m *DigestInitRequest) Reset() { *m = DigestInitRequest{} } func (m *DigestInitRequest) String() string { return proto.CompactTextString(m) } func (*DigestInitRequest) ProtoMessage() {} func (*DigestInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{2} + return fileDescriptor_ad098daeda4239f7, []int{2} } func (m *DigestInitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -143,15 +335,15 @@ func (m *DigestInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_DigestInitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestInitRequest.Merge(dst, src) +func (m *DigestInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestInitRequest.Merge(m, src) } func (m *DigestInitRequest) XXX_Size() int { return m.Size() @@ -180,7 +372,7 @@ func (m *DigestInitResponse) Reset() { *m = DigestInitResponse{} } func (m *DigestInitResponse) String() string { return proto.CompactTextString(m) } func (*DigestInitResponse) ProtoMessage() {} func (*DigestInitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{3} + return fileDescriptor_ad098daeda4239f7, []int{3} } func (m *DigestInitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -190,15 +382,15 @@ func (m *DigestInitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DigestInitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestInitResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestInitResponse.Merge(dst, src) +func (m *DigestInitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestInitResponse.Merge(m, src) } func (m *DigestInitResponse) XXX_Size() int { return m.Size() @@ -228,7 +420,7 @@ func (m *DigestRequest) Reset() { *m = DigestRequest{} } func (m *DigestRequest) String() string { return proto.CompactTextString(m) } func (*DigestRequest) ProtoMessage() {} func (*DigestRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{4} + return fileDescriptor_ad098daeda4239f7, []int{4} } func (m *DigestRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -238,15 +430,15 @@ func (m *DigestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return xxx_messageInfo_DigestRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestRequest.Merge(dst, src) +func (m *DigestRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestRequest.Merge(m, src) } func (m *DigestRequest) XXX_Size() int { return m.Size() @@ -282,7 +474,7 @@ func (m *DigestResponse) Reset() { *m = DigestResponse{} } func (m *DigestResponse) String() string { return proto.CompactTextString(m) } func (*DigestResponse) ProtoMessage() {} func (*DigestResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{5} + return fileDescriptor_ad098daeda4239f7, []int{5} } func (m *DigestResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -292,15 +484,15 @@ func (m *DigestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return xxx_messageInfo_DigestResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestResponse.Merge(dst, src) +func (m *DigestResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestResponse.Merge(m, src) } func (m *DigestResponse) XXX_Size() int { return m.Size() @@ -330,7 +522,7 @@ func (m *DigestUpdateRequest) Reset() { *m = DigestUpdateRequest{} } func (m *DigestUpdateRequest) String() string { return proto.CompactTextString(m) } func (*DigestUpdateRequest) ProtoMessage() {} func (*DigestUpdateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{6} + return fileDescriptor_ad098daeda4239f7, []int{6} } func (m *DigestUpdateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -340,15 +532,15 @@ func (m *DigestUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DigestUpdateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestUpdateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestUpdateRequest.Merge(dst, src) +func (m *DigestUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestUpdateRequest.Merge(m, src) } func (m *DigestUpdateRequest) XXX_Size() int { return m.Size() @@ -384,7 +576,7 @@ func (m *DigestUpdateResponse) Reset() { *m = DigestUpdateResponse{} } func (m *DigestUpdateResponse) String() string { return proto.CompactTextString(m) } func (*DigestUpdateResponse) ProtoMessage() {} func (*DigestUpdateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{7} + return fileDescriptor_ad098daeda4239f7, []int{7} } func (m *DigestUpdateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -394,15 +586,15 @@ func (m *DigestUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_DigestUpdateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestUpdateResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestUpdateResponse.Merge(dst, src) +func (m *DigestUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestUpdateResponse.Merge(m, src) } func (m *DigestUpdateResponse) XXX_Size() int { return m.Size() @@ -432,7 +624,7 @@ func (m *DigestKeyRequest) Reset() { *m = DigestKeyRequest{} } func (m *DigestKeyRequest) String() string { return proto.CompactTextString(m) } func (*DigestKeyRequest) ProtoMessage() {} func (*DigestKeyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{8} + return fileDescriptor_ad098daeda4239f7, []int{8} } func (m *DigestKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -442,15 +634,15 @@ func (m *DigestKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return xxx_messageInfo_DigestKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestKeyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestKeyRequest.Merge(dst, src) +func (m *DigestKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestKeyRequest.Merge(m, src) } func (m *DigestKeyRequest) XXX_Size() int { return m.Size() @@ -486,7 +678,7 @@ func (m *DigestKeyResponse) Reset() { *m = DigestKeyResponse{} } func (m *DigestKeyResponse) String() string { return proto.CompactTextString(m) } func (*DigestKeyResponse) ProtoMessage() {} func (*DigestKeyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{9} + return fileDescriptor_ad098daeda4239f7, []int{9} } func (m *DigestKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -496,15 +688,15 @@ func (m *DigestKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_DigestKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestKeyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestKeyResponse.Merge(dst, src) +func (m *DigestKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestKeyResponse.Merge(m, src) } func (m *DigestKeyResponse) XXX_Size() int { return m.Size() @@ -533,7 +725,7 @@ func (m *DigestFinalRequest) Reset() { *m = DigestFinalRequest{} } func (m *DigestFinalRequest) String() string { return proto.CompactTextString(m) } func (*DigestFinalRequest) ProtoMessage() {} func (*DigestFinalRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{10} + return fileDescriptor_ad098daeda4239f7, []int{10} } func (m *DigestFinalRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -543,15 +735,15 @@ func (m *DigestFinalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DigestFinalRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestFinalRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestFinalRequest.Merge(dst, src) +func (m *DigestFinalRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestFinalRequest.Merge(m, src) } func (m *DigestFinalRequest) XXX_Size() int { return m.Size() @@ -580,7 +772,7 @@ func (m *DigestFinalResponse) Reset() { *m = DigestFinalResponse{} } func (m *DigestFinalResponse) String() string { return proto.CompactTextString(m) } func (*DigestFinalResponse) ProtoMessage() {} func (*DigestFinalResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{11} + return fileDescriptor_ad098daeda4239f7, []int{11} } func (m *DigestFinalResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -590,15 +782,15 @@ func (m *DigestFinalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DigestFinalResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestFinalResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestFinalResponse.Merge(dst, src) +func (m *DigestFinalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestFinalResponse.Merge(m, src) } func (m *DigestFinalResponse) XXX_Size() int { return m.Size() @@ -617,7 +809,7 @@ func (m *DigestFinalResponse) GetDigest() []byte { } type DigestSingleRequest struct { - Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech,proto3" json:"Mech,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -628,7 +820,7 @@ func (m *DigestSingleRequest) Reset() { *m = DigestSingleRequest{} } func (m *DigestSingleRequest) String() string { return proto.CompactTextString(m) } func (*DigestSingleRequest) ProtoMessage() {} func (*DigestSingleRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{12} + return fileDescriptor_ad098daeda4239f7, []int{12} } func (m *DigestSingleRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -638,15 +830,15 @@ func (m *DigestSingleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DigestSingleRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestSingleRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestSingleRequest.Merge(dst, src) +func (m *DigestSingleRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestSingleRequest.Merge(m, src) } func (m *DigestSingleRequest) XXX_Size() int { return m.Size() @@ -682,7 +874,7 @@ func (m *DigestSingleResponse) Reset() { *m = DigestSingleResponse{} } func (m *DigestSingleResponse) String() string { return proto.CompactTextString(m) } func (*DigestSingleResponse) ProtoMessage() {} func (*DigestSingleResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{13} + return fileDescriptor_ad098daeda4239f7, []int{13} } func (m *DigestSingleResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -692,15 +884,15 @@ func (m *DigestSingleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_DigestSingleResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DigestSingleResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DigestSingleResponse.Merge(dst, src) +func (m *DigestSingleResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DigestSingleResponse.Merge(m, src) } func (m *DigestSingleResponse) XXX_Size() int { return m.Size() @@ -719,7 +911,7 @@ func (m *DigestSingleResponse) GetDigest() []byte { } type EncryptInitRequest struct { - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -730,7 +922,7 @@ func (m *EncryptInitRequest) Reset() { *m = EncryptInitRequest{} } func (m *EncryptInitRequest) String() string { return proto.CompactTextString(m) } func (*EncryptInitRequest) ProtoMessage() {} func (*EncryptInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{14} + return fileDescriptor_ad098daeda4239f7, []int{14} } func (m *EncryptInitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -740,15 +932,15 @@ func (m *EncryptInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_EncryptInitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptInitRequest.Merge(dst, src) +func (m *EncryptInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptInitRequest.Merge(m, src) } func (m *EncryptInitRequest) XXX_Size() int { return m.Size() @@ -784,7 +976,7 @@ func (m *EncryptInitResponse) Reset() { *m = EncryptInitResponse{} } func (m *EncryptInitResponse) String() string { return proto.CompactTextString(m) } func (*EncryptInitResponse) ProtoMessage() {} func (*EncryptInitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{15} + return fileDescriptor_ad098daeda4239f7, []int{15} } func (m *EncryptInitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -794,15 +986,15 @@ func (m *EncryptInitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_EncryptInitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptInitResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptInitResponse.Merge(dst, src) +func (m *EncryptInitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptInitResponse.Merge(m, src) } func (m *EncryptInitResponse) XXX_Size() int { return m.Size() @@ -821,7 +1013,7 @@ func (m *EncryptInitResponse) GetState() []byte { } type DecryptInitRequest struct { - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=Key,proto3" json:"Key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -832,7 +1024,7 @@ func (m *DecryptInitRequest) Reset() { *m = DecryptInitRequest{} } func (m *DecryptInitRequest) String() string { return proto.CompactTextString(m) } func (*DecryptInitRequest) ProtoMessage() {} func (*DecryptInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{16} + return fileDescriptor_ad098daeda4239f7, []int{16} } func (m *DecryptInitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -842,15 +1034,15 @@ func (m *DecryptInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DecryptInitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptInitRequest.Merge(dst, src) +func (m *DecryptInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptInitRequest.Merge(m, src) } func (m *DecryptInitRequest) XXX_Size() int { return m.Size() @@ -886,7 +1078,7 @@ func (m *DecryptInitResponse) Reset() { *m = DecryptInitResponse{} } func (m *DecryptInitResponse) String() string { return proto.CompactTextString(m) } func (*DecryptInitResponse) ProtoMessage() {} func (*DecryptInitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{17} + return fileDescriptor_ad098daeda4239f7, []int{17} } func (m *DecryptInitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -896,15 +1088,15 @@ func (m *DecryptInitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DecryptInitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptInitResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptInitResponse.Merge(dst, src) +func (m *DecryptInitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptInitResponse.Merge(m, src) } func (m *DecryptInitResponse) XXX_Size() int { return m.Size() @@ -934,7 +1126,7 @@ func (m *EncryptUpdateRequest) Reset() { *m = EncryptUpdateRequest{} } func (m *EncryptUpdateRequest) String() string { return proto.CompactTextString(m) } func (*EncryptUpdateRequest) ProtoMessage() {} func (*EncryptUpdateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{18} + return fileDescriptor_ad098daeda4239f7, []int{18} } func (m *EncryptUpdateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -944,15 +1136,15 @@ func (m *EncryptUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_EncryptUpdateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptUpdateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptUpdateRequest.Merge(dst, src) +func (m *EncryptUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptUpdateRequest.Merge(m, src) } func (m *EncryptUpdateRequest) XXX_Size() int { return m.Size() @@ -989,7 +1181,7 @@ func (m *EncryptUpdateResponse) Reset() { *m = EncryptUpdateResponse{} } func (m *EncryptUpdateResponse) String() string { return proto.CompactTextString(m) } func (*EncryptUpdateResponse) ProtoMessage() {} func (*EncryptUpdateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{19} + return fileDescriptor_ad098daeda4239f7, []int{19} } func (m *EncryptUpdateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -999,15 +1191,15 @@ func (m *EncryptUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return xxx_messageInfo_EncryptUpdateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptUpdateResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptUpdateResponse.Merge(dst, src) +func (m *EncryptUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptUpdateResponse.Merge(m, src) } func (m *EncryptUpdateResponse) XXX_Size() int { return m.Size() @@ -1044,7 +1236,7 @@ func (m *DecryptUpdateRequest) Reset() { *m = DecryptUpdateRequest{} } func (m *DecryptUpdateRequest) String() string { return proto.CompactTextString(m) } func (*DecryptUpdateRequest) ProtoMessage() {} func (*DecryptUpdateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{20} + return fileDescriptor_ad098daeda4239f7, []int{20} } func (m *DecryptUpdateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1054,15 +1246,15 @@ func (m *DecryptUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_DecryptUpdateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptUpdateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptUpdateRequest.Merge(dst, src) +func (m *DecryptUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptUpdateRequest.Merge(m, src) } func (m *DecryptUpdateRequest) XXX_Size() int { return m.Size() @@ -1099,7 +1291,7 @@ func (m *DecryptUpdateResponse) Reset() { *m = DecryptUpdateResponse{} } func (m *DecryptUpdateResponse) String() string { return proto.CompactTextString(m) } func (*DecryptUpdateResponse) ProtoMessage() {} func (*DecryptUpdateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{21} + return fileDescriptor_ad098daeda4239f7, []int{21} } func (m *DecryptUpdateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1109,15 +1301,15 @@ func (m *DecryptUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return xxx_messageInfo_DecryptUpdateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptUpdateResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptUpdateResponse.Merge(dst, src) +func (m *DecryptUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptUpdateResponse.Merge(m, src) } func (m *DecryptUpdateResponse) XXX_Size() int { return m.Size() @@ -1154,7 +1346,7 @@ func (m *EncryptRequest) Reset() { *m = EncryptRequest{} } func (m *EncryptRequest) String() string { return proto.CompactTextString(m) } func (*EncryptRequest) ProtoMessage() {} func (*EncryptRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{22} + return fileDescriptor_ad098daeda4239f7, []int{22} } func (m *EncryptRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1164,15 +1356,15 @@ func (m *EncryptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return xxx_messageInfo_EncryptRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptRequest.Merge(dst, src) +func (m *EncryptRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptRequest.Merge(m, src) } func (m *EncryptRequest) XXX_Size() int { return m.Size() @@ -1208,7 +1400,7 @@ func (m *EncryptResponse) Reset() { *m = EncryptResponse{} } func (m *EncryptResponse) String() string { return proto.CompactTextString(m) } func (*EncryptResponse) ProtoMessage() {} func (*EncryptResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{23} + return fileDescriptor_ad098daeda4239f7, []int{23} } func (m *EncryptResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1218,15 +1410,15 @@ func (m *EncryptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return xxx_messageInfo_EncryptResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptResponse.Merge(dst, src) +func (m *EncryptResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptResponse.Merge(m, src) } func (m *EncryptResponse) XXX_Size() int { return m.Size() @@ -1256,7 +1448,7 @@ func (m *DecryptRequest) Reset() { *m = DecryptRequest{} } func (m *DecryptRequest) String() string { return proto.CompactTextString(m) } func (*DecryptRequest) ProtoMessage() {} func (*DecryptRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{24} + return fileDescriptor_ad098daeda4239f7, []int{24} } func (m *DecryptRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1266,15 +1458,15 @@ func (m *DecryptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return xxx_messageInfo_DecryptRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptRequest.Merge(dst, src) +func (m *DecryptRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptRequest.Merge(m, src) } func (m *DecryptRequest) XXX_Size() int { return m.Size() @@ -1310,7 +1502,7 @@ func (m *DecryptResponse) Reset() { *m = DecryptResponse{} } func (m *DecryptResponse) String() string { return proto.CompactTextString(m) } func (*DecryptResponse) ProtoMessage() {} func (*DecryptResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{25} + return fileDescriptor_ad098daeda4239f7, []int{25} } func (m *DecryptResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1320,15 +1512,15 @@ func (m *DecryptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return xxx_messageInfo_DecryptResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptResponse.Merge(dst, src) +func (m *DecryptResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptResponse.Merge(m, src) } func (m *DecryptResponse) XXX_Size() int { return m.Size() @@ -1357,7 +1549,7 @@ func (m *EncryptFinalRequest) Reset() { *m = EncryptFinalRequest{} } func (m *EncryptFinalRequest) String() string { return proto.CompactTextString(m) } func (*EncryptFinalRequest) ProtoMessage() {} func (*EncryptFinalRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{26} + return fileDescriptor_ad098daeda4239f7, []int{26} } func (m *EncryptFinalRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1367,15 +1559,15 @@ func (m *EncryptFinalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_EncryptFinalRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptFinalRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptFinalRequest.Merge(dst, src) +func (m *EncryptFinalRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptFinalRequest.Merge(m, src) } func (m *EncryptFinalRequest) XXX_Size() int { return m.Size() @@ -1404,7 +1596,7 @@ func (m *EncryptFinalResponse) Reset() { *m = EncryptFinalResponse{} } func (m *EncryptFinalResponse) String() string { return proto.CompactTextString(m) } func (*EncryptFinalResponse) ProtoMessage() {} func (*EncryptFinalResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{27} + return fileDescriptor_ad098daeda4239f7, []int{27} } func (m *EncryptFinalResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1414,15 +1606,15 @@ func (m *EncryptFinalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_EncryptFinalResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptFinalResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptFinalResponse.Merge(dst, src) +func (m *EncryptFinalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptFinalResponse.Merge(m, src) } func (m *EncryptFinalResponse) XXX_Size() int { return m.Size() @@ -1451,7 +1643,7 @@ func (m *DecryptFinalRequest) Reset() { *m = DecryptFinalRequest{} } func (m *DecryptFinalRequest) String() string { return proto.CompactTextString(m) } func (*DecryptFinalRequest) ProtoMessage() {} func (*DecryptFinalRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{28} + return fileDescriptor_ad098daeda4239f7, []int{28} } func (m *DecryptFinalRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1461,15 +1653,15 @@ func (m *DecryptFinalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_DecryptFinalRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptFinalRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptFinalRequest.Merge(dst, src) +func (m *DecryptFinalRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptFinalRequest.Merge(m, src) } func (m *DecryptFinalRequest) XXX_Size() int { return m.Size() @@ -1498,7 +1690,7 @@ func (m *DecryptFinalResponse) Reset() { *m = DecryptFinalResponse{} } func (m *DecryptFinalResponse) String() string { return proto.CompactTextString(m) } func (*DecryptFinalResponse) ProtoMessage() {} func (*DecryptFinalResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{29} + return fileDescriptor_ad098daeda4239f7, []int{29} } func (m *DecryptFinalResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1508,15 +1700,15 @@ func (m *DecryptFinalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_DecryptFinalResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptFinalResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptFinalResponse.Merge(dst, src) +func (m *DecryptFinalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptFinalResponse.Merge(m, src) } func (m *DecryptFinalResponse) XXX_Size() int { return m.Size() @@ -1536,7 +1728,7 @@ func (m *DecryptFinalResponse) GetPlain() []byte { type EncryptSingleRequest struct { Key []byte `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"` - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` Plain []byte `protobuf:"bytes,3,opt,name=Plain,proto3" json:"Plain,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -1547,7 +1739,7 @@ func (m *EncryptSingleRequest) Reset() { *m = EncryptSingleRequest{} } func (m *EncryptSingleRequest) String() string { return proto.CompactTextString(m) } func (*EncryptSingleRequest) ProtoMessage() {} func (*EncryptSingleRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{30} + return fileDescriptor_ad098daeda4239f7, []int{30} } func (m *EncryptSingleRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1557,15 +1749,15 @@ func (m *EncryptSingleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_EncryptSingleRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptSingleRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptSingleRequest.Merge(dst, src) +func (m *EncryptSingleRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptSingleRequest.Merge(m, src) } func (m *EncryptSingleRequest) XXX_Size() int { return m.Size() @@ -1608,7 +1800,7 @@ func (m *EncryptSingleResponse) Reset() { *m = EncryptSingleResponse{} } func (m *EncryptSingleResponse) String() string { return proto.CompactTextString(m) } func (*EncryptSingleResponse) ProtoMessage() {} func (*EncryptSingleResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{31} + return fileDescriptor_ad098daeda4239f7, []int{31} } func (m *EncryptSingleResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1618,15 +1810,15 @@ func (m *EncryptSingleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return xxx_messageInfo_EncryptSingleResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *EncryptSingleResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_EncryptSingleResponse.Merge(dst, src) +func (m *EncryptSingleResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EncryptSingleResponse.Merge(m, src) } func (m *EncryptSingleResponse) XXX_Size() int { return m.Size() @@ -1646,7 +1838,7 @@ func (m *EncryptSingleResponse) GetCiphered() []byte { type DecryptSingleRequest struct { Key []byte `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"` - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` Ciphered []byte `protobuf:"bytes,3,opt,name=Ciphered,proto3" json:"Ciphered,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -1657,7 +1849,7 @@ func (m *DecryptSingleRequest) Reset() { *m = DecryptSingleRequest{} } func (m *DecryptSingleRequest) String() string { return proto.CompactTextString(m) } func (*DecryptSingleRequest) ProtoMessage() {} func (*DecryptSingleRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{32} + return fileDescriptor_ad098daeda4239f7, []int{32} } func (m *DecryptSingleRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1667,15 +1859,15 @@ func (m *DecryptSingleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_DecryptSingleRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptSingleRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptSingleRequest.Merge(dst, src) +func (m *DecryptSingleRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptSingleRequest.Merge(m, src) } func (m *DecryptSingleRequest) XXX_Size() int { return m.Size() @@ -1718,7 +1910,7 @@ func (m *DecryptSingleResponse) Reset() { *m = DecryptSingleResponse{} } func (m *DecryptSingleResponse) String() string { return proto.CompactTextString(m) } func (*DecryptSingleResponse) ProtoMessage() {} func (*DecryptSingleResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{33} + return fileDescriptor_ad098daeda4239f7, []int{33} } func (m *DecryptSingleResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1728,15 +1920,15 @@ func (m *DecryptSingleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return xxx_messageInfo_DecryptSingleResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DecryptSingleResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DecryptSingleResponse.Merge(dst, src) +func (m *DecryptSingleResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DecryptSingleResponse.Merge(m, src) } func (m *DecryptSingleResponse) XXX_Size() int { return m.Size() @@ -1755,7 +1947,7 @@ func (m *DecryptSingleResponse) GetPlain() []byte { } type SignInitRequest struct { - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` PrivKey []byte `protobuf:"bytes,3,opt,name=PrivKey,proto3" json:"PrivKey,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -1766,7 +1958,7 @@ func (m *SignInitRequest) Reset() { *m = SignInitRequest{} } func (m *SignInitRequest) String() string { return proto.CompactTextString(m) } func (*SignInitRequest) ProtoMessage() {} func (*SignInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{34} + return fileDescriptor_ad098daeda4239f7, []int{34} } func (m *SignInitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1776,15 +1968,15 @@ func (m *SignInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return xxx_messageInfo_SignInitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignInitRequest.Merge(dst, src) +func (m *SignInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignInitRequest.Merge(m, src) } func (m *SignInitRequest) XXX_Size() int { return m.Size() @@ -1820,7 +2012,7 @@ func (m *SignInitResponse) Reset() { *m = SignInitResponse{} } func (m *SignInitResponse) String() string { return proto.CompactTextString(m) } func (*SignInitResponse) ProtoMessage() {} func (*SignInitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{35} + return fileDescriptor_ad098daeda4239f7, []int{35} } func (m *SignInitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1830,15 +2022,15 @@ func (m *SignInitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return xxx_messageInfo_SignInitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignInitResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignInitResponse.Merge(dst, src) +func (m *SignInitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignInitResponse.Merge(m, src) } func (m *SignInitResponse) XXX_Size() int { return m.Size() @@ -1857,7 +2049,7 @@ func (m *SignInitResponse) GetState() []byte { } type VerifyInitRequest struct { - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` PubKey []byte `protobuf:"bytes,3,opt,name=PubKey,proto3" json:"PubKey,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -1868,7 +2060,7 @@ func (m *VerifyInitRequest) Reset() { *m = VerifyInitRequest{} } func (m *VerifyInitRequest) String() string { return proto.CompactTextString(m) } func (*VerifyInitRequest) ProtoMessage() {} func (*VerifyInitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{36} + return fileDescriptor_ad098daeda4239f7, []int{36} } func (m *VerifyInitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1878,15 +2070,15 @@ func (m *VerifyInitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_VerifyInitRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyInitRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyInitRequest.Merge(dst, src) +func (m *VerifyInitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyInitRequest.Merge(m, src) } func (m *VerifyInitRequest) XXX_Size() int { return m.Size() @@ -1922,7 +2114,7 @@ func (m *VerifyInitResponse) Reset() { *m = VerifyInitResponse{} } func (m *VerifyInitResponse) String() string { return proto.CompactTextString(m) } func (*VerifyInitResponse) ProtoMessage() {} func (*VerifyInitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{37} + return fileDescriptor_ad098daeda4239f7, []int{37} } func (m *VerifyInitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1932,15 +2124,15 @@ func (m *VerifyInitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_VerifyInitResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyInitResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyInitResponse.Merge(dst, src) +func (m *VerifyInitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyInitResponse.Merge(m, src) } func (m *VerifyInitResponse) XXX_Size() int { return m.Size() @@ -1970,7 +2162,7 @@ func (m *SignUpdateRequest) Reset() { *m = SignUpdateRequest{} } func (m *SignUpdateRequest) String() string { return proto.CompactTextString(m) } func (*SignUpdateRequest) ProtoMessage() {} func (*SignUpdateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{38} + return fileDescriptor_ad098daeda4239f7, []int{38} } func (m *SignUpdateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1980,15 +2172,15 @@ func (m *SignUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_SignUpdateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignUpdateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignUpdateRequest.Merge(dst, src) +func (m *SignUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignUpdateRequest.Merge(m, src) } func (m *SignUpdateRequest) XXX_Size() int { return m.Size() @@ -2024,7 +2216,7 @@ func (m *SignUpdateResponse) Reset() { *m = SignUpdateResponse{} } func (m *SignUpdateResponse) String() string { return proto.CompactTextString(m) } func (*SignUpdateResponse) ProtoMessage() {} func (*SignUpdateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{39} + return fileDescriptor_ad098daeda4239f7, []int{39} } func (m *SignUpdateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2034,15 +2226,15 @@ func (m *SignUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_SignUpdateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignUpdateResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignUpdateResponse.Merge(dst, src) +func (m *SignUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignUpdateResponse.Merge(m, src) } func (m *SignUpdateResponse) XXX_Size() int { return m.Size() @@ -2072,7 +2264,7 @@ func (m *VerifyUpdateRequest) Reset() { *m = VerifyUpdateRequest{} } func (m *VerifyUpdateRequest) String() string { return proto.CompactTextString(m) } func (*VerifyUpdateRequest) ProtoMessage() {} func (*VerifyUpdateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{40} + return fileDescriptor_ad098daeda4239f7, []int{40} } func (m *VerifyUpdateRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2082,15 +2274,15 @@ func (m *VerifyUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_VerifyUpdateRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyUpdateRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyUpdateRequest.Merge(dst, src) +func (m *VerifyUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyUpdateRequest.Merge(m, src) } func (m *VerifyUpdateRequest) XXX_Size() int { return m.Size() @@ -2126,7 +2318,7 @@ func (m *VerifyUpdateResponse) Reset() { *m = VerifyUpdateResponse{} } func (m *VerifyUpdateResponse) String() string { return proto.CompactTextString(m) } func (*VerifyUpdateResponse) ProtoMessage() {} func (*VerifyUpdateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{41} + return fileDescriptor_ad098daeda4239f7, []int{41} } func (m *VerifyUpdateResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2136,15 +2328,15 @@ func (m *VerifyUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_VerifyUpdateResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyUpdateResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyUpdateResponse.Merge(dst, src) +func (m *VerifyUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyUpdateResponse.Merge(m, src) } func (m *VerifyUpdateResponse) XXX_Size() int { return m.Size() @@ -2173,7 +2365,7 @@ func (m *SignFinalRequest) Reset() { *m = SignFinalRequest{} } func (m *SignFinalRequest) String() string { return proto.CompactTextString(m) } func (*SignFinalRequest) ProtoMessage() {} func (*SignFinalRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{42} + return fileDescriptor_ad098daeda4239f7, []int{42} } func (m *SignFinalRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2183,15 +2375,15 @@ func (m *SignFinalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return xxx_messageInfo_SignFinalRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignFinalRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignFinalRequest.Merge(dst, src) +func (m *SignFinalRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignFinalRequest.Merge(m, src) } func (m *SignFinalRequest) XXX_Size() int { return m.Size() @@ -2220,7 +2412,7 @@ func (m *SignFinalResponse) Reset() { *m = SignFinalResponse{} } func (m *SignFinalResponse) String() string { return proto.CompactTextString(m) } func (*SignFinalResponse) ProtoMessage() {} func (*SignFinalResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{43} + return fileDescriptor_ad098daeda4239f7, []int{43} } func (m *SignFinalResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2230,15 +2422,15 @@ func (m *SignFinalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_SignFinalResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignFinalResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignFinalResponse.Merge(dst, src) +func (m *SignFinalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignFinalResponse.Merge(m, src) } func (m *SignFinalResponse) XXX_Size() int { return m.Size() @@ -2268,7 +2460,7 @@ func (m *VerifyFinalRequest) Reset() { *m = VerifyFinalRequest{} } func (m *VerifyFinalRequest) String() string { return proto.CompactTextString(m) } func (*VerifyFinalRequest) ProtoMessage() {} func (*VerifyFinalRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{44} + return fileDescriptor_ad098daeda4239f7, []int{44} } func (m *VerifyFinalRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2278,15 +2470,15 @@ func (m *VerifyFinalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_VerifyFinalRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyFinalRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyFinalRequest.Merge(dst, src) +func (m *VerifyFinalRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyFinalRequest.Merge(m, src) } func (m *VerifyFinalRequest) XXX_Size() int { return m.Size() @@ -2321,7 +2513,7 @@ func (m *VerifyFinalResponse) Reset() { *m = VerifyFinalResponse{} } func (m *VerifyFinalResponse) String() string { return proto.CompactTextString(m) } func (*VerifyFinalResponse) ProtoMessage() {} func (*VerifyFinalResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{45} + return fileDescriptor_ad098daeda4239f7, []int{45} } func (m *VerifyFinalResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2331,15 +2523,15 @@ func (m *VerifyFinalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_VerifyFinalResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyFinalResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyFinalResponse.Merge(dst, src) +func (m *VerifyFinalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyFinalResponse.Merge(m, src) } func (m *VerifyFinalResponse) XXX_Size() int { return m.Size() @@ -2362,7 +2554,7 @@ func (m *SignRequest) Reset() { *m = SignRequest{} } func (m *SignRequest) String() string { return proto.CompactTextString(m) } func (*SignRequest) ProtoMessage() {} func (*SignRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{46} + return fileDescriptor_ad098daeda4239f7, []int{46} } func (m *SignRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2372,15 +2564,15 @@ func (m *SignRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return xxx_messageInfo_SignRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignRequest.Merge(dst, src) +func (m *SignRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignRequest.Merge(m, src) } func (m *SignRequest) XXX_Size() int { return m.Size() @@ -2416,7 +2608,7 @@ func (m *SignResponse) Reset() { *m = SignResponse{} } func (m *SignResponse) String() string { return proto.CompactTextString(m) } func (*SignResponse) ProtoMessage() {} func (*SignResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{47} + return fileDescriptor_ad098daeda4239f7, []int{47} } func (m *SignResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2426,15 +2618,15 @@ func (m *SignResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return xxx_messageInfo_SignResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignResponse.Merge(dst, src) +func (m *SignResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignResponse.Merge(m, src) } func (m *SignResponse) XXX_Size() int { return m.Size() @@ -2465,7 +2657,7 @@ func (m *VerifyRequest) Reset() { *m = VerifyRequest{} } func (m *VerifyRequest) String() string { return proto.CompactTextString(m) } func (*VerifyRequest) ProtoMessage() {} func (*VerifyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{48} + return fileDescriptor_ad098daeda4239f7, []int{48} } func (m *VerifyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2475,15 +2667,15 @@ func (m *VerifyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return xxx_messageInfo_VerifyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyRequest.Merge(dst, src) +func (m *VerifyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyRequest.Merge(m, src) } func (m *VerifyRequest) XXX_Size() int { return m.Size() @@ -2525,7 +2717,7 @@ func (m *VerifyResponse) Reset() { *m = VerifyResponse{} } func (m *VerifyResponse) String() string { return proto.CompactTextString(m) } func (*VerifyResponse) ProtoMessage() {} func (*VerifyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{49} + return fileDescriptor_ad098daeda4239f7, []int{49} } func (m *VerifyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2535,15 +2727,15 @@ func (m *VerifyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return xxx_messageInfo_VerifyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifyResponse.Merge(dst, src) +func (m *VerifyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyResponse.Merge(m, src) } func (m *VerifyResponse) XXX_Size() int { return m.Size() @@ -2556,7 +2748,7 @@ var xxx_messageInfo_VerifyResponse proto.InternalMessageInfo type SignSingleRequest struct { PrivKey []byte `protobuf:"bytes,1,opt,name=PrivKey,proto3" json:"PrivKey,omitempty"` - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` Data []byte `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -2567,7 +2759,7 @@ func (m *SignSingleRequest) Reset() { *m = SignSingleRequest{} } func (m *SignSingleRequest) String() string { return proto.CompactTextString(m) } func (*SignSingleRequest) ProtoMessage() {} func (*SignSingleRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{50} + return fileDescriptor_ad098daeda4239f7, []int{50} } func (m *SignSingleRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2577,15 +2769,15 @@ func (m *SignSingleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_SignSingleRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignSingleRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignSingleRequest.Merge(dst, src) +func (m *SignSingleRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignSingleRequest.Merge(m, src) } func (m *SignSingleRequest) XXX_Size() int { return m.Size() @@ -2628,7 +2820,7 @@ func (m *SignSingleResponse) Reset() { *m = SignSingleResponse{} } func (m *SignSingleResponse) String() string { return proto.CompactTextString(m) } func (*SignSingleResponse) ProtoMessage() {} func (*SignSingleResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{51} + return fileDescriptor_ad098daeda4239f7, []int{51} } func (m *SignSingleResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2638,15 +2830,15 @@ func (m *SignSingleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_SignSingleResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SignSingleResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SignSingleResponse.Merge(dst, src) +func (m *SignSingleResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignSingleResponse.Merge(m, src) } func (m *SignSingleResponse) XXX_Size() int { return m.Size() @@ -2666,7 +2858,7 @@ func (m *SignSingleResponse) GetSignature() []byte { type VerifySingleRequest struct { PubKey []byte `protobuf:"bytes,1,opt,name=PubKey,proto3" json:"PubKey,omitempty"` - Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,2,opt,name=Mech,proto3" json:"Mech,omitempty"` Data []byte `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"` Signature []byte `protobuf:"bytes,4,opt,name=Signature,proto3" json:"Signature,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -2678,7 +2870,7 @@ func (m *VerifySingleRequest) Reset() { *m = VerifySingleRequest{} } func (m *VerifySingleRequest) String() string { return proto.CompactTextString(m) } func (*VerifySingleRequest) ProtoMessage() {} func (*VerifySingleRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{52} + return fileDescriptor_ad098daeda4239f7, []int{52} } func (m *VerifySingleRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2688,15 +2880,15 @@ func (m *VerifySingleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_VerifySingleRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifySingleRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifySingleRequest.Merge(dst, src) +func (m *VerifySingleRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifySingleRequest.Merge(m, src) } func (m *VerifySingleRequest) XXX_Size() int { return m.Size() @@ -2745,7 +2937,7 @@ func (m *VerifySingleResponse) Reset() { *m = VerifySingleResponse{} } func (m *VerifySingleResponse) String() string { return proto.CompactTextString(m) } func (*VerifySingleResponse) ProtoMessage() {} func (*VerifySingleResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{53} + return fileDescriptor_ad098daeda4239f7, []int{53} } func (m *VerifySingleResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2755,15 +2947,15 @@ func (m *VerifySingleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return xxx_messageInfo_VerifySingleResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *VerifySingleResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_VerifySingleResponse.Merge(dst, src) +func (m *VerifySingleResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifySingleResponse.Merge(m, src) } func (m *VerifySingleResponse) XXX_Size() int { return m.Size() @@ -2775,19 +2967,19 @@ func (m *VerifySingleResponse) XXX_DiscardUnknown() { var xxx_messageInfo_VerifySingleResponse proto.InternalMessageInfo type GenerateKeyRequest struct { - Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech" json:"Mech,omitempty"` - Template map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=Template,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Template,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - KeyId string `protobuf:"bytes,4,opt,name=KeyId,proto3" json:"KeyId,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech,proto3" json:"Mech,omitempty"` + TemplateBytes map[ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=TemplateBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"TemplateBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Template map[ep11.Attribute]*AttributeValue `protobuf:"bytes,6,rep,name=Template,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Template,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GenerateKeyRequest) Reset() { *m = GenerateKeyRequest{} } func (m *GenerateKeyRequest) String() string { return proto.CompactTextString(m) } func (*GenerateKeyRequest) ProtoMessage() {} func (*GenerateKeyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{54} + return fileDescriptor_ad098daeda4239f7, []int{54} } func (m *GenerateKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2797,15 +2989,15 @@ func (m *GenerateKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_GenerateKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GenerateKeyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenerateKeyRequest.Merge(dst, src) +func (m *GenerateKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenerateKeyRequest.Merge(m, src) } func (m *GenerateKeyRequest) XXX_Size() int { return m.Size() @@ -2823,23 +3015,24 @@ func (m *GenerateKeyRequest) GetMech() *Mechanism { return nil } -func (m *GenerateKeyRequest) GetTemplate() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *GenerateKeyRequest) GetTemplateBytes() map[ep11.Attribute][]byte { if m != nil { - return m.Template + return m.TemplateBytes } return nil } -func (m *GenerateKeyRequest) GetKeyId() string { +func (m *GenerateKeyRequest) GetTemplate() map[ep11.Attribute]*AttributeValue { if m != nil { - return m.KeyId + return m.Template } - return "" + return nil } type GenerateKeyResponse struct { - Key []byte `protobuf:"bytes,4,opt,name=Key,proto3" json:"Key,omitempty"` + KeyBytes []byte `protobuf:"bytes,4,opt,name=KeyBytes,proto3" json:"KeyBytes,omitempty"` CheckSum []byte `protobuf:"bytes,5,opt,name=CheckSum,proto3" json:"CheckSum,omitempty"` + Key *KeyBlob `protobuf:"bytes,7,opt,name=Key,proto3" json:"Key,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -2849,7 +3042,7 @@ func (m *GenerateKeyResponse) Reset() { *m = GenerateKeyResponse{} } func (m *GenerateKeyResponse) String() string { return proto.CompactTextString(m) } func (*GenerateKeyResponse) ProtoMessage() {} func (*GenerateKeyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{55} + return fileDescriptor_ad098daeda4239f7, []int{55} } func (m *GenerateKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2859,15 +3052,15 @@ func (m *GenerateKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return xxx_messageInfo_GenerateKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GenerateKeyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenerateKeyResponse.Merge(dst, src) +func (m *GenerateKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenerateKeyResponse.Merge(m, src) } func (m *GenerateKeyResponse) XXX_Size() int { return m.Size() @@ -2878,9 +3071,9 @@ func (m *GenerateKeyResponse) XXX_DiscardUnknown() { var xxx_messageInfo_GenerateKeyResponse proto.InternalMessageInfo -func (m *GenerateKeyResponse) GetKey() []byte { +func (m *GenerateKeyResponse) GetKeyBytes() []byte { if m != nil { - return m.Key + return m.KeyBytes } return nil } @@ -2892,22 +3085,29 @@ func (m *GenerateKeyResponse) GetCheckSum() []byte { return nil } +func (m *GenerateKeyResponse) GetKey() *KeyBlob { + if m != nil { + return m.Key + } + return nil +} + type GenerateKeyPairRequest struct { - Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech" json:"Mech,omitempty"` - PubKeyTemplate map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=PubKeyTemplate,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"PubKeyTemplate,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - PrivKeyTemplate map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,3,rep,name=PrivKeyTemplate,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"PrivKeyTemplate,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - PrivKeyId string `protobuf:"bytes,5,opt,name=PrivKeyId,proto3" json:"PrivKeyId,omitempty"` - PubKeyId string `protobuf:"bytes,6,opt,name=PubKeyId,proto3" json:"PubKeyId,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech,proto3" json:"Mech,omitempty"` + PubKeyTemplateBytes map[ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=PubKeyTemplateBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"PubKeyTemplateBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + PrivKeyTemplateBytes map[ep11.Attribute][]byte `protobuf:"bytes,3,rep,name=PrivKeyTemplateBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"PrivKeyTemplateBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + PrivKeyTemplate map[ep11.Attribute]*AttributeValue `protobuf:"bytes,7,rep,name=PrivKeyTemplate,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"PrivKeyTemplate,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + PubKeyTemplate map[ep11.Attribute]*AttributeValue `protobuf:"bytes,8,rep,name=PubKeyTemplate,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"PubKeyTemplate,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GenerateKeyPairRequest) Reset() { *m = GenerateKeyPairRequest{} } func (m *GenerateKeyPairRequest) String() string { return proto.CompactTextString(m) } func (*GenerateKeyPairRequest) ProtoMessage() {} func (*GenerateKeyPairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{56} + return fileDescriptor_ad098daeda4239f7, []int{56} } func (m *GenerateKeyPairRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2917,15 +3117,15 @@ func (m *GenerateKeyPairRequest) XXX_Marshal(b []byte, deterministic bool) ([]by return xxx_messageInfo_GenerateKeyPairRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GenerateKeyPairRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenerateKeyPairRequest.Merge(dst, src) +func (m *GenerateKeyPairRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenerateKeyPairRequest.Merge(m, src) } func (m *GenerateKeyPairRequest) XXX_Size() int { return m.Size() @@ -2943,37 +3143,39 @@ func (m *GenerateKeyPairRequest) GetMech() *Mechanism { return nil } -func (m *GenerateKeyPairRequest) GetPubKeyTemplate() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *GenerateKeyPairRequest) GetPubKeyTemplateBytes() map[ep11.Attribute][]byte { if m != nil { - return m.PubKeyTemplate + return m.PubKeyTemplateBytes } return nil } -func (m *GenerateKeyPairRequest) GetPrivKeyTemplate() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *GenerateKeyPairRequest) GetPrivKeyTemplateBytes() map[ep11.Attribute][]byte { if m != nil { - return m.PrivKeyTemplate + return m.PrivKeyTemplateBytes } return nil } -func (m *GenerateKeyPairRequest) GetPrivKeyId() string { +func (m *GenerateKeyPairRequest) GetPrivKeyTemplate() map[ep11.Attribute]*AttributeValue { if m != nil { - return m.PrivKeyId + return m.PrivKeyTemplate } - return "" + return nil } -func (m *GenerateKeyPairRequest) GetPubKeyId() string { +func (m *GenerateKeyPairRequest) GetPubKeyTemplate() map[ep11.Attribute]*AttributeValue { if m != nil { - return m.PubKeyId + return m.PubKeyTemplate } - return "" + return nil } type GenerateKeyPairResponse struct { - PrivKey []byte `protobuf:"bytes,5,opt,name=PrivKey,proto3" json:"PrivKey,omitempty"` - PubKey []byte `protobuf:"bytes,6,opt,name=PubKey,proto3" json:"PubKey,omitempty"` + PrivKeyBytes []byte `protobuf:"bytes,5,opt,name=PrivKeyBytes,proto3" json:"PrivKeyBytes,omitempty"` + PubKeyBytes []byte `protobuf:"bytes,6,opt,name=PubKeyBytes,proto3" json:"PubKeyBytes,omitempty"` + PrivKey *KeyBlob `protobuf:"bytes,9,opt,name=PrivKey,proto3" json:"PrivKey,omitempty"` + PubKey *KeyBlob `protobuf:"bytes,10,opt,name=PubKey,proto3" json:"PubKey,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -2983,7 +3185,7 @@ func (m *GenerateKeyPairResponse) Reset() { *m = GenerateKeyPairResponse func (m *GenerateKeyPairResponse) String() string { return proto.CompactTextString(m) } func (*GenerateKeyPairResponse) ProtoMessage() {} func (*GenerateKeyPairResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{57} + return fileDescriptor_ad098daeda4239f7, []int{57} } func (m *GenerateKeyPairResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2993,15 +3195,15 @@ func (m *GenerateKeyPairResponse) XXX_Marshal(b []byte, deterministic bool) ([]b return xxx_messageInfo_GenerateKeyPairResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GenerateKeyPairResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenerateKeyPairResponse.Merge(dst, src) +func (m *GenerateKeyPairResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenerateKeyPairResponse.Merge(m, src) } func (m *GenerateKeyPairResponse) XXX_Size() int { return m.Size() @@ -3012,14 +3214,28 @@ func (m *GenerateKeyPairResponse) XXX_DiscardUnknown() { var xxx_messageInfo_GenerateKeyPairResponse proto.InternalMessageInfo -func (m *GenerateKeyPairResponse) GetPrivKey() []byte { +func (m *GenerateKeyPairResponse) GetPrivKeyBytes() []byte { + if m != nil { + return m.PrivKeyBytes + } + return nil +} + +func (m *GenerateKeyPairResponse) GetPubKeyBytes() []byte { + if m != nil { + return m.PubKeyBytes + } + return nil +} + +func (m *GenerateKeyPairResponse) GetPrivKey() *KeyBlob { if m != nil { return m.PrivKey } return nil } -func (m *GenerateKeyPairResponse) GetPubKey() []byte { +func (m *GenerateKeyPairResponse) GetPubKey() *KeyBlob { if m != nil { return m.PubKey } @@ -3030,7 +3246,7 @@ type WrapKeyRequest struct { Key []byte `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"` KeK []byte `protobuf:"bytes,2,opt,name=KeK,proto3" json:"KeK,omitempty"` MacKey []byte `protobuf:"bytes,3,opt,name=MacKey,proto3" json:"MacKey,omitempty"` - Mech *Mechanism `protobuf:"bytes,4,opt,name=Mech" json:"Mech,omitempty"` + Mech *Mechanism `protobuf:"bytes,4,opt,name=Mech,proto3" json:"Mech,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -3040,7 +3256,7 @@ func (m *WrapKeyRequest) Reset() { *m = WrapKeyRequest{} } func (m *WrapKeyRequest) String() string { return proto.CompactTextString(m) } func (*WrapKeyRequest) ProtoMessage() {} func (*WrapKeyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{58} + return fileDescriptor_ad098daeda4239f7, []int{58} } func (m *WrapKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3050,15 +3266,15 @@ func (m *WrapKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro return xxx_messageInfo_WrapKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *WrapKeyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_WrapKeyRequest.Merge(dst, src) +func (m *WrapKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WrapKeyRequest.Merge(m, src) } func (m *WrapKeyRequest) XXX_Size() int { return m.Size() @@ -3108,7 +3324,7 @@ func (m *WrapKeyResponse) Reset() { *m = WrapKeyResponse{} } func (m *WrapKeyResponse) String() string { return proto.CompactTextString(m) } func (*WrapKeyResponse) ProtoMessage() {} func (*WrapKeyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{59} + return fileDescriptor_ad098daeda4239f7, []int{59} } func (m *WrapKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3118,15 +3334,15 @@ func (m *WrapKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, err return xxx_messageInfo_WrapKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *WrapKeyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_WrapKeyResponse.Merge(dst, src) +func (m *WrapKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_WrapKeyResponse.Merge(m, src) } func (m *WrapKeyResponse) XXX_Size() int { return m.Size() @@ -3145,22 +3361,22 @@ func (m *WrapKeyResponse) GetWrapped() []byte { } type UnwrapKeyRequest struct { - Wrapped []byte `protobuf:"bytes,1,opt,name=Wrapped,proto3" json:"Wrapped,omitempty"` - KeK []byte `protobuf:"bytes,2,opt,name=KeK,proto3" json:"KeK,omitempty"` - MacKey []byte `protobuf:"bytes,3,opt,name=MacKey,proto3" json:"MacKey,omitempty"` - Mech *Mechanism `protobuf:"bytes,5,opt,name=Mech" json:"Mech,omitempty"` - Template map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,6,rep,name=Template,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Template,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - UnwrappedId string `protobuf:"bytes,7,opt,name=UnwrappedId,proto3" json:"UnwrappedId,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Wrapped []byte `protobuf:"bytes,1,opt,name=Wrapped,proto3" json:"Wrapped,omitempty"` + KeK []byte `protobuf:"bytes,2,opt,name=KeK,proto3" json:"KeK,omitempty"` + MacKey []byte `protobuf:"bytes,3,opt,name=MacKey,proto3" json:"MacKey,omitempty"` + Mech *Mechanism `protobuf:"bytes,5,opt,name=Mech,proto3" json:"Mech,omitempty"` + TemplateBytes map[ep11.Attribute][]byte `protobuf:"bytes,6,rep,name=TemplateBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"TemplateBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Template map[ep11.Attribute]*AttributeValue `protobuf:"bytes,9,rep,name=Template,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Template,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *UnwrapKeyRequest) Reset() { *m = UnwrapKeyRequest{} } func (m *UnwrapKeyRequest) String() string { return proto.CompactTextString(m) } func (*UnwrapKeyRequest) ProtoMessage() {} func (*UnwrapKeyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{60} + return fileDescriptor_ad098daeda4239f7, []int{60} } func (m *UnwrapKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3170,15 +3386,15 @@ func (m *UnwrapKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return xxx_messageInfo_UnwrapKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *UnwrapKeyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_UnwrapKeyRequest.Merge(dst, src) +func (m *UnwrapKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnwrapKeyRequest.Merge(m, src) } func (m *UnwrapKeyRequest) XXX_Size() int { return m.Size() @@ -3217,23 +3433,24 @@ func (m *UnwrapKeyRequest) GetMech() *Mechanism { return nil } -func (m *UnwrapKeyRequest) GetTemplate() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *UnwrapKeyRequest) GetTemplateBytes() map[ep11.Attribute][]byte { if m != nil { - return m.Template + return m.TemplateBytes } return nil } -func (m *UnwrapKeyRequest) GetUnwrappedId() string { +func (m *UnwrapKeyRequest) GetTemplate() map[ep11.Attribute]*AttributeValue { if m != nil { - return m.UnwrappedId + return m.Template } - return "" + return nil } type UnwrapKeyResponse struct { - Unwrapped []byte `protobuf:"bytes,7,opt,name=Unwrapped,proto3" json:"Unwrapped,omitempty"` + UnwrappedBytes []byte `protobuf:"bytes,7,opt,name=UnwrappedBytes,proto3" json:"UnwrappedBytes,omitempty"` CheckSum []byte `protobuf:"bytes,8,opt,name=CheckSum,proto3" json:"CheckSum,omitempty"` + Unwrapped *KeyBlob `protobuf:"bytes,10,opt,name=Unwrapped,proto3" json:"Unwrapped,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -3243,7 +3460,7 @@ func (m *UnwrapKeyResponse) Reset() { *m = UnwrapKeyResponse{} } func (m *UnwrapKeyResponse) String() string { return proto.CompactTextString(m) } func (*UnwrapKeyResponse) ProtoMessage() {} func (*UnwrapKeyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{61} + return fileDescriptor_ad098daeda4239f7, []int{61} } func (m *UnwrapKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3253,15 +3470,15 @@ func (m *UnwrapKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_UnwrapKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *UnwrapKeyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_UnwrapKeyResponse.Merge(dst, src) +func (m *UnwrapKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnwrapKeyResponse.Merge(m, src) } func (m *UnwrapKeyResponse) XXX_Size() int { return m.Size() @@ -3272,9 +3489,9 @@ func (m *UnwrapKeyResponse) XXX_DiscardUnknown() { var xxx_messageInfo_UnwrapKeyResponse proto.InternalMessageInfo -func (m *UnwrapKeyResponse) GetUnwrapped() []byte { +func (m *UnwrapKeyResponse) GetUnwrappedBytes() []byte { if m != nil { - return m.Unwrapped + return m.UnwrappedBytes } return nil } @@ -3286,22 +3503,29 @@ func (m *UnwrapKeyResponse) GetCheckSum() []byte { return nil } +func (m *UnwrapKeyResponse) GetUnwrapped() *KeyBlob { + if m != nil { + return m.Unwrapped + } + return nil +} + type DeriveKeyRequest struct { - Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech" json:"Mech,omitempty"` - Template map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=Template,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Template,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - BaseKey []byte `protobuf:"bytes,3,opt,name=BaseKey,proto3" json:"BaseKey,omitempty"` - Data []byte `protobuf:"bytes,4,opt,name=Data,proto3" json:"Data,omitempty"` - NewKeyId string `protobuf:"bytes,6,opt,name=NewKeyId,proto3" json:"NewKeyId,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Mech *Mechanism `protobuf:"bytes,1,opt,name=Mech,proto3" json:"Mech,omitempty"` + TemplateBytes map[ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=TemplateBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"TemplateBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + BaseKey []byte `protobuf:"bytes,3,opt,name=BaseKey,proto3" json:"BaseKey,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=Data,proto3" json:"Data,omitempty"` + Template map[ep11.Attribute]*AttributeValue `protobuf:"bytes,8,rep,name=Template,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Template,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *DeriveKeyRequest) Reset() { *m = DeriveKeyRequest{} } func (m *DeriveKeyRequest) String() string { return proto.CompactTextString(m) } func (*DeriveKeyRequest) ProtoMessage() {} func (*DeriveKeyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{62} + return fileDescriptor_ad098daeda4239f7, []int{62} } func (m *DeriveKeyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3311,15 +3535,15 @@ func (m *DeriveKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return xxx_messageInfo_DeriveKeyRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DeriveKeyRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeriveKeyRequest.Merge(dst, src) +func (m *DeriveKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeriveKeyRequest.Merge(m, src) } func (m *DeriveKeyRequest) XXX_Size() int { return m.Size() @@ -3337,9 +3561,9 @@ func (m *DeriveKeyRequest) GetMech() *Mechanism { return nil } -func (m *DeriveKeyRequest) GetTemplate() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *DeriveKeyRequest) GetTemplateBytes() map[ep11.Attribute][]byte { if m != nil { - return m.Template + return m.TemplateBytes } return nil } @@ -3358,16 +3582,17 @@ func (m *DeriveKeyRequest) GetData() []byte { return nil } -func (m *DeriveKeyRequest) GetNewKeyId() string { +func (m *DeriveKeyRequest) GetTemplate() map[ep11.Attribute]*AttributeValue { if m != nil { - return m.NewKeyId + return m.Template } - return "" + return nil } type DeriveKeyResponse struct { - NewKey []byte `protobuf:"bytes,6,opt,name=NewKey,proto3" json:"NewKey,omitempty"` + NewKeyBytes []byte `protobuf:"bytes,6,opt,name=NewKeyBytes,proto3" json:"NewKeyBytes,omitempty"` CheckSum []byte `protobuf:"bytes,7,opt,name=CheckSum,proto3" json:"CheckSum,omitempty"` + NewKey *KeyBlob `protobuf:"bytes,9,opt,name=NewKey,proto3" json:"NewKey,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -3377,7 +3602,7 @@ func (m *DeriveKeyResponse) Reset() { *m = DeriveKeyResponse{} } func (m *DeriveKeyResponse) String() string { return proto.CompactTextString(m) } func (*DeriveKeyResponse) ProtoMessage() {} func (*DeriveKeyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{63} + return fileDescriptor_ad098daeda4239f7, []int{63} } func (m *DeriveKeyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3387,15 +3612,15 @@ func (m *DeriveKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return xxx_messageInfo_DeriveKeyResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *DeriveKeyResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeriveKeyResponse.Merge(dst, src) +func (m *DeriveKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeriveKeyResponse.Merge(m, src) } func (m *DeriveKeyResponse) XXX_Size() int { return m.Size() @@ -3406,9 +3631,9 @@ func (m *DeriveKeyResponse) XXX_DiscardUnknown() { var xxx_messageInfo_DeriveKeyResponse proto.InternalMessageInfo -func (m *DeriveKeyResponse) GetNewKey() []byte { +func (m *DeriveKeyResponse) GetNewKeyBytes() []byte { if m != nil { - return m.NewKey + return m.NewKeyBytes } return nil } @@ -3420,6 +3645,13 @@ func (m *DeriveKeyResponse) GetCheckSum() []byte { return nil } +func (m *DeriveKeyResponse) GetNewKey() *KeyBlob { + if m != nil { + return m.NewKey + } + return nil +} + type GetMechanismListRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -3430,7 +3662,7 @@ func (m *GetMechanismListRequest) Reset() { *m = GetMechanismListRequest func (m *GetMechanismListRequest) String() string { return proto.CompactTextString(m) } func (*GetMechanismListRequest) ProtoMessage() {} func (*GetMechanismListRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{64} + return fileDescriptor_ad098daeda4239f7, []int{64} } func (m *GetMechanismListRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3440,15 +3672,15 @@ func (m *GetMechanismListRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return xxx_messageInfo_GetMechanismListRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GetMechanismListRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMechanismListRequest.Merge(dst, src) +func (m *GetMechanismListRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMechanismListRequest.Merge(m, src) } func (m *GetMechanismListRequest) XXX_Size() int { return m.Size() @@ -3460,17 +3692,17 @@ func (m *GetMechanismListRequest) XXX_DiscardUnknown() { var xxx_messageInfo_GetMechanismListRequest proto.InternalMessageInfo type GetMechanismListResponse struct { - Mechs []github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism `protobuf:"varint,2,rep,packed,name=Mechs,casttype=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"Mechs,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Mechs []ep11.Mechanism `protobuf:"varint,2,rep,packed,name=Mechs,proto3,casttype=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"Mechs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetMechanismListResponse) Reset() { *m = GetMechanismListResponse{} } func (m *GetMechanismListResponse) String() string { return proto.CompactTextString(m) } func (*GetMechanismListResponse) ProtoMessage() {} func (*GetMechanismListResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{65} + return fileDescriptor_ad098daeda4239f7, []int{65} } func (m *GetMechanismListResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3480,15 +3712,15 @@ func (m *GetMechanismListResponse) XXX_Marshal(b []byte, deterministic bool) ([] return xxx_messageInfo_GetMechanismListResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GetMechanismListResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMechanismListResponse.Merge(dst, src) +func (m *GetMechanismListResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMechanismListResponse.Merge(m, src) } func (m *GetMechanismListResponse) XXX_Size() int { return m.Size() @@ -3499,7 +3731,7 @@ func (m *GetMechanismListResponse) XXX_DiscardUnknown() { var xxx_messageInfo_GetMechanismListResponse proto.InternalMessageInfo -func (m *GetMechanismListResponse) GetMechs() []github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism { +func (m *GetMechanismListResponse) GetMechs() []ep11.Mechanism { if m != nil { return m.Mechs } @@ -3507,17 +3739,17 @@ func (m *GetMechanismListResponse) GetMechs() []github_com_ibm_developer_ibm_clo } type GetMechanismInfoRequest struct { - Mech github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism `protobuf:"varint,2,opt,name=Mech,proto3,casttype=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"Mech,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Mech ep11.Mechanism `protobuf:"varint,2,opt,name=Mech,proto3,casttype=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"Mech,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetMechanismInfoRequest) Reset() { *m = GetMechanismInfoRequest{} } func (m *GetMechanismInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetMechanismInfoRequest) ProtoMessage() {} func (*GetMechanismInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{66} + return fileDescriptor_ad098daeda4239f7, []int{66} } func (m *GetMechanismInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3527,15 +3759,15 @@ func (m *GetMechanismInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]b return xxx_messageInfo_GetMechanismInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GetMechanismInfoRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMechanismInfoRequest.Merge(dst, src) +func (m *GetMechanismInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMechanismInfoRequest.Merge(m, src) } func (m *GetMechanismInfoRequest) XXX_Size() int { return m.Size() @@ -3546,7 +3778,7 @@ func (m *GetMechanismInfoRequest) XXX_DiscardUnknown() { var xxx_messageInfo_GetMechanismInfoRequest proto.InternalMessageInfo -func (m *GetMechanismInfoRequest) GetMech() github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism { +func (m *GetMechanismInfoRequest) GetMech() ep11.Mechanism { if m != nil { return m.Mech } @@ -3554,7 +3786,7 @@ func (m *GetMechanismInfoRequest) GetMech() github_com_ibm_developer_ibm_cloud_h } type GetMechanismInfoResponse struct { - MechInfo *MechanismInfo `protobuf:"bytes,3,opt,name=MechInfo" json:"MechInfo,omitempty"` + MechInfo *MechanismInfo `protobuf:"bytes,3,opt,name=MechInfo,proto3" json:"MechInfo,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -3564,7 +3796,7 @@ func (m *GetMechanismInfoResponse) Reset() { *m = GetMechanismInfoRespon func (m *GetMechanismInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetMechanismInfoResponse) ProtoMessage() {} func (*GetMechanismInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{67} + return fileDescriptor_ad098daeda4239f7, []int{67} } func (m *GetMechanismInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3574,15 +3806,15 @@ func (m *GetMechanismInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([] return xxx_messageInfo_GetMechanismInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GetMechanismInfoResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMechanismInfoResponse.Merge(dst, src) +func (m *GetMechanismInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMechanismInfoResponse.Merge(m, src) } func (m *GetMechanismInfoResponse) XXX_Size() int { return m.Size() @@ -3601,18 +3833,19 @@ func (m *GetMechanismInfoResponse) GetMechInfo() *MechanismInfo { } type GetAttributeValueRequest struct { - Object []byte `protobuf:"bytes,1,opt,name=Object,proto3" json:"Object,omitempty"` - Attributes map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=Attributes,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Attributes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Object []byte `protobuf:"bytes,1,opt,name=Object,proto3" json:"Object,omitempty"` + AttributesBytes map[ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=AttributesBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"AttributesBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Attributes map[ep11.Attribute]*AttributeValue `protobuf:"bytes,3,rep,name=Attributes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Attributes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetAttributeValueRequest) Reset() { *m = GetAttributeValueRequest{} } func (m *GetAttributeValueRequest) String() string { return proto.CompactTextString(m) } func (*GetAttributeValueRequest) ProtoMessage() {} func (*GetAttributeValueRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{68} + return fileDescriptor_ad098daeda4239f7, []int{68} } func (m *GetAttributeValueRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3622,15 +3855,15 @@ func (m *GetAttributeValueRequest) XXX_Marshal(b []byte, deterministic bool) ([] return xxx_messageInfo_GetAttributeValueRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GetAttributeValueRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAttributeValueRequest.Merge(dst, src) +func (m *GetAttributeValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAttributeValueRequest.Merge(m, src) } func (m *GetAttributeValueRequest) XXX_Size() int { return m.Size() @@ -3648,7 +3881,14 @@ func (m *GetAttributeValueRequest) GetObject() []byte { return nil } -func (m *GetAttributeValueRequest) GetAttributes() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *GetAttributeValueRequest) GetAttributesBytes() map[ep11.Attribute][]byte { + if m != nil { + return m.AttributesBytes + } + return nil +} + +func (m *GetAttributeValueRequest) GetAttributes() map[ep11.Attribute]*AttributeValue { if m != nil { return m.Attributes } @@ -3656,17 +3896,17 @@ func (m *GetAttributeValueRequest) GetAttributes() map[github_com_ibm_developer_ } type GetAttributeValueResponse struct { - Attributes map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=Attributes,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Attributes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + AttributesBytes map[ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=AttributesBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"AttributesBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetAttributeValueResponse) Reset() { *m = GetAttributeValueResponse{} } func (m *GetAttributeValueResponse) String() string { return proto.CompactTextString(m) } func (*GetAttributeValueResponse) ProtoMessage() {} func (*GetAttributeValueResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{69} + return fileDescriptor_ad098daeda4239f7, []int{69} } func (m *GetAttributeValueResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3676,15 +3916,15 @@ func (m *GetAttributeValueResponse) XXX_Marshal(b []byte, deterministic bool) ([ return xxx_messageInfo_GetAttributeValueResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *GetAttributeValueResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAttributeValueResponse.Merge(dst, src) +func (m *GetAttributeValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAttributeValueResponse.Merge(m, src) } func (m *GetAttributeValueResponse) XXX_Size() int { return m.Size() @@ -3695,26 +3935,27 @@ func (m *GetAttributeValueResponse) XXX_DiscardUnknown() { var xxx_messageInfo_GetAttributeValueResponse proto.InternalMessageInfo -func (m *GetAttributeValueResponse) GetAttributes() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *GetAttributeValueResponse) GetAttributesBytes() map[ep11.Attribute][]byte { if m != nil { - return m.Attributes + return m.AttributesBytes } return nil } type SetAttributeValueRequest struct { - Object []byte `protobuf:"bytes,1,opt,name=Object,proto3" json:"Object,omitempty"` - Attributes map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=Attributes,castkey=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Attributes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Object []byte `protobuf:"bytes,1,opt,name=Object,proto3" json:"Object,omitempty"` + AttributesBytes map[ep11.Attribute][]byte `protobuf:"bytes,2,rep,name=AttributesBytes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"AttributesBytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Attributes map[ep11.Attribute]*AttributeValue `protobuf:"bytes,3,rep,name=Attributes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Attributes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *SetAttributeValueRequest) Reset() { *m = SetAttributeValueRequest{} } func (m *SetAttributeValueRequest) String() string { return proto.CompactTextString(m) } func (*SetAttributeValueRequest) ProtoMessage() {} func (*SetAttributeValueRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{70} + return fileDescriptor_ad098daeda4239f7, []int{70} } func (m *SetAttributeValueRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3724,15 +3965,15 @@ func (m *SetAttributeValueRequest) XXX_Marshal(b []byte, deterministic bool) ([] return xxx_messageInfo_SetAttributeValueRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SetAttributeValueRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetAttributeValueRequest.Merge(dst, src) +func (m *SetAttributeValueRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetAttributeValueRequest.Merge(m, src) } func (m *SetAttributeValueRequest) XXX_Size() int { return m.Size() @@ -3750,7 +3991,14 @@ func (m *SetAttributeValueRequest) GetObject() []byte { return nil } -func (m *SetAttributeValueRequest) GetAttributes() map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte { +func (m *SetAttributeValueRequest) GetAttributesBytes() map[ep11.Attribute][]byte { + if m != nil { + return m.AttributesBytes + } + return nil +} + +func (m *SetAttributeValueRequest) GetAttributes() map[ep11.Attribute]*AttributeValue { if m != nil { return m.Attributes } @@ -3768,7 +4016,7 @@ func (m *SetAttributeValueResponse) Reset() { *m = SetAttributeValueResp func (m *SetAttributeValueResponse) String() string { return proto.CompactTextString(m) } func (*SetAttributeValueResponse) ProtoMessage() {} func (*SetAttributeValueResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{71} + return fileDescriptor_ad098daeda4239f7, []int{71} } func (m *SetAttributeValueResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3778,15 +4026,15 @@ func (m *SetAttributeValueResponse) XXX_Marshal(b []byte, deterministic bool) ([ return xxx_messageInfo_SetAttributeValueResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *SetAttributeValueResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetAttributeValueResponse.Merge(dst, src) +func (m *SetAttributeValueResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetAttributeValueResponse.Merge(m, src) } func (m *SetAttributeValueResponse) XXX_Size() int { return m.Size() @@ -3805,18 +4053,24 @@ func (m *SetAttributeValueResponse) GetObject() []byte { } type Mechanism struct { - Mechanism github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism `protobuf:"varint,1,opt,name=Mechanism,proto3,casttype=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"Mechanism,omitempty"` - Parameter []byte `protobuf:"bytes,2,opt,name=Parameter,proto3" json:"Parameter,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Mechanism ep11.Mechanism `protobuf:"varint,1,opt,name=Mechanism,proto3,casttype=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"Mechanism,omitempty"` + // Types that are valid to be assigned to Parameter: + // *Mechanism_ParameterB + // *Mechanism_RSAOAEPParameter + // *Mechanism_RSAPSSParameter + // *Mechanism_ECDH1DeriveParameter + // *Mechanism_BTCDeriveParameter + Parameter isMechanism_Parameter `protobuf_oneof:"Parameter"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *Mechanism) Reset() { *m = Mechanism{} } func (m *Mechanism) String() string { return proto.CompactTextString(m) } func (*Mechanism) ProtoMessage() {} func (*Mechanism) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{72} + return fileDescriptor_ad098daeda4239f7, []int{72} } func (m *Mechanism) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3826,15 +4080,15 @@ func (m *Mechanism) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return xxx_messageInfo_Mechanism.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *Mechanism) XXX_Merge(src proto.Message) { - xxx_messageInfo_Mechanism.Merge(dst, src) +func (m *Mechanism) XXX_Merge(src proto.Message) { + xxx_messageInfo_Mechanism.Merge(m, src) } func (m *Mechanism) XXX_Size() int { return m.Size() @@ -3845,20 +4099,94 @@ func (m *Mechanism) XXX_DiscardUnknown() { var xxx_messageInfo_Mechanism proto.InternalMessageInfo -func (m *Mechanism) GetMechanism() github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism { +type isMechanism_Parameter interface { + isMechanism_Parameter() + MarshalTo([]byte) (int, error) + Size() int +} + +type Mechanism_ParameterB struct { + ParameterB []byte `protobuf:"bytes,2,opt,name=ParameterB,proto3,oneof" json:"ParameterB,omitempty"` +} +type Mechanism_RSAOAEPParameter struct { + RSAOAEPParameter *RSAOAEPParm `protobuf:"bytes,3,opt,name=RSAOAEPParameter,proto3,oneof" json:"RSAOAEPParameter,omitempty"` +} +type Mechanism_RSAPSSParameter struct { + RSAPSSParameter *RSAPSSParm `protobuf:"bytes,4,opt,name=RSAPSSParameter,proto3,oneof" json:"RSAPSSParameter,omitempty"` +} +type Mechanism_ECDH1DeriveParameter struct { + ECDH1DeriveParameter *ECDH1DeriveParm `protobuf:"bytes,5,opt,name=ECDH1DeriveParameter,proto3,oneof" json:"ECDH1DeriveParameter,omitempty"` +} +type Mechanism_BTCDeriveParameter struct { + BTCDeriveParameter *BTCDeriveParm `protobuf:"bytes,6,opt,name=BTCDeriveParameter,proto3,oneof" json:"BTCDeriveParameter,omitempty"` +} + +func (*Mechanism_ParameterB) isMechanism_Parameter() {} +func (*Mechanism_RSAOAEPParameter) isMechanism_Parameter() {} +func (*Mechanism_RSAPSSParameter) isMechanism_Parameter() {} +func (*Mechanism_ECDH1DeriveParameter) isMechanism_Parameter() {} +func (*Mechanism_BTCDeriveParameter) isMechanism_Parameter() {} + +func (m *Mechanism) GetParameter() isMechanism_Parameter { + if m != nil { + return m.Parameter + } + return nil +} + +func (m *Mechanism) GetMechanism() ep11.Mechanism { if m != nil { return m.Mechanism } return 0 } -func (m *Mechanism) GetParameter() []byte { - if m != nil { - return m.Parameter +func (m *Mechanism) GetParameterB() []byte { + if x, ok := m.GetParameter().(*Mechanism_ParameterB); ok { + return x.ParameterB + } + return nil +} + +func (m *Mechanism) GetRSAOAEPParameter() *RSAOAEPParm { + if x, ok := m.GetParameter().(*Mechanism_RSAOAEPParameter); ok { + return x.RSAOAEPParameter + } + return nil +} + +func (m *Mechanism) GetRSAPSSParameter() *RSAPSSParm { + if x, ok := m.GetParameter().(*Mechanism_RSAPSSParameter); ok { + return x.RSAPSSParameter + } + return nil +} + +func (m *Mechanism) GetECDH1DeriveParameter() *ECDH1DeriveParm { + if x, ok := m.GetParameter().(*Mechanism_ECDH1DeriveParameter); ok { + return x.ECDH1DeriveParameter + } + return nil +} + +func (m *Mechanism) GetBTCDeriveParameter() *BTCDeriveParm { + if x, ok := m.GetParameter().(*Mechanism_BTCDeriveParameter); ok { + return x.BTCDeriveParameter } return nil } +// XXX_OneofWrappers is for the internal use of the proto package. +func (*Mechanism) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*Mechanism_ParameterB)(nil), + (*Mechanism_RSAOAEPParameter)(nil), + (*Mechanism_RSAPSSParameter)(nil), + (*Mechanism_ECDH1DeriveParameter)(nil), + (*Mechanism_BTCDeriveParameter)(nil), + } +} + type MechanismInfo struct { MinKeySize uint64 `protobuf:"varint,1,opt,name=MinKeySize,proto3" json:"MinKeySize,omitempty"` MaxKeySize uint64 `protobuf:"varint,2,opt,name=MaxKeySize,proto3" json:"MaxKeySize,omitempty"` @@ -3872,7 +4200,7 @@ func (m *MechanismInfo) Reset() { *m = MechanismInfo{} } func (m *MechanismInfo) String() string { return proto.CompactTextString(m) } func (*MechanismInfo) ProtoMessage() {} func (*MechanismInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{73} + return fileDescriptor_ad098daeda4239f7, []int{73} } func (m *MechanismInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3882,15 +4210,15 @@ func (m *MechanismInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error return xxx_messageInfo_MechanismInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *MechanismInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_MechanismInfo.Merge(dst, src) +func (m *MechanismInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_MechanismInfo.Merge(m, src) } func (m *MechanismInfo) XXX_Size() int { return m.Size() @@ -3923,19 +4251,19 @@ func (m *MechanismInfo) GetFlags() uint64 { } type Grep11Error struct { - Code github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Return `protobuf:"varint,1,opt,name=Code,proto3,casttype=github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11.Return" json:"Code,omitempty"` - Detail string `protobuf:"bytes,2,opt,name=Detail,proto3" json:"Detail,omitempty"` - Retry bool `protobuf:"varint,3,opt,name=Retry,proto3" json:"Retry,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Code ep11.Return `protobuf:"varint,1,opt,name=Code,proto3,casttype=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Return" json:"Code,omitempty"` + Detail string `protobuf:"bytes,2,opt,name=Detail,proto3" json:"Detail,omitempty"` + Retry bool `protobuf:"varint,3,opt,name=Retry,proto3" json:"Retry,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *Grep11Error) Reset() { *m = Grep11Error{} } func (m *Grep11Error) String() string { return proto.CompactTextString(m) } func (*Grep11Error) ProtoMessage() {} func (*Grep11Error) Descriptor() ([]byte, []int) { - return fileDescriptor_server_2b449d55aaf66cf7, []int{74} + return fileDescriptor_ad098daeda4239f7, []int{74} } func (m *Grep11Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3945,15 +4273,15 @@ func (m *Grep11Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return xxx_messageInfo_Grep11Error.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalTo(b) + n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } -func (dst *Grep11Error) XXX_Merge(src proto.Message) { - xxx_messageInfo_Grep11Error.Merge(dst, src) +func (m *Grep11Error) XXX_Merge(src proto.Message) { + xxx_messageInfo_Grep11Error.Merge(m, src) } func (m *Grep11Error) XXX_Size() int { return m.Size() @@ -3964,7 +4292,7 @@ func (m *Grep11Error) XXX_DiscardUnknown() { var xxx_messageInfo_Grep11Error proto.InternalMessageInfo -func (m *Grep11Error) GetCode() github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Return { +func (m *Grep11Error) GetCode() ep11.Return { if m != nil { return m.Code } @@ -3985,4255 +4313,7586 @@ func (m *Grep11Error) GetRetry() bool { return false } -func init() { - proto.RegisterType((*GenerateRandomRequest)(nil), "grep11.GenerateRandomRequest") - proto.RegisterType((*GenerateRandomResponse)(nil), "grep11.GenerateRandomResponse") - proto.RegisterType((*DigestInitRequest)(nil), "grep11.DigestInitRequest") - proto.RegisterType((*DigestInitResponse)(nil), "grep11.DigestInitResponse") - proto.RegisterType((*DigestRequest)(nil), "grep11.DigestRequest") - proto.RegisterType((*DigestResponse)(nil), "grep11.DigestResponse") - proto.RegisterType((*DigestUpdateRequest)(nil), "grep11.DigestUpdateRequest") - proto.RegisterType((*DigestUpdateResponse)(nil), "grep11.DigestUpdateResponse") - proto.RegisterType((*DigestKeyRequest)(nil), "grep11.DigestKeyRequest") - proto.RegisterType((*DigestKeyResponse)(nil), "grep11.DigestKeyResponse") - proto.RegisterType((*DigestFinalRequest)(nil), "grep11.DigestFinalRequest") - proto.RegisterType((*DigestFinalResponse)(nil), "grep11.DigestFinalResponse") - proto.RegisterType((*DigestSingleRequest)(nil), "grep11.DigestSingleRequest") - proto.RegisterType((*DigestSingleResponse)(nil), "grep11.DigestSingleResponse") - proto.RegisterType((*EncryptInitRequest)(nil), "grep11.EncryptInitRequest") - proto.RegisterType((*EncryptInitResponse)(nil), "grep11.EncryptInitResponse") - proto.RegisterType((*DecryptInitRequest)(nil), "grep11.DecryptInitRequest") - proto.RegisterType((*DecryptInitResponse)(nil), "grep11.DecryptInitResponse") - proto.RegisterType((*EncryptUpdateRequest)(nil), "grep11.EncryptUpdateRequest") - proto.RegisterType((*EncryptUpdateResponse)(nil), "grep11.EncryptUpdateResponse") - proto.RegisterType((*DecryptUpdateRequest)(nil), "grep11.DecryptUpdateRequest") - proto.RegisterType((*DecryptUpdateResponse)(nil), "grep11.DecryptUpdateResponse") - proto.RegisterType((*EncryptRequest)(nil), "grep11.EncryptRequest") - proto.RegisterType((*EncryptResponse)(nil), "grep11.EncryptResponse") - proto.RegisterType((*DecryptRequest)(nil), "grep11.DecryptRequest") - proto.RegisterType((*DecryptResponse)(nil), "grep11.DecryptResponse") - proto.RegisterType((*EncryptFinalRequest)(nil), "grep11.EncryptFinalRequest") - proto.RegisterType((*EncryptFinalResponse)(nil), "grep11.EncryptFinalResponse") - proto.RegisterType((*DecryptFinalRequest)(nil), "grep11.DecryptFinalRequest") - proto.RegisterType((*DecryptFinalResponse)(nil), "grep11.DecryptFinalResponse") - proto.RegisterType((*EncryptSingleRequest)(nil), "grep11.EncryptSingleRequest") - proto.RegisterType((*EncryptSingleResponse)(nil), "grep11.EncryptSingleResponse") - proto.RegisterType((*DecryptSingleRequest)(nil), "grep11.DecryptSingleRequest") - proto.RegisterType((*DecryptSingleResponse)(nil), "grep11.DecryptSingleResponse") - proto.RegisterType((*SignInitRequest)(nil), "grep11.SignInitRequest") - proto.RegisterType((*SignInitResponse)(nil), "grep11.SignInitResponse") - proto.RegisterType((*VerifyInitRequest)(nil), "grep11.VerifyInitRequest") - proto.RegisterType((*VerifyInitResponse)(nil), "grep11.VerifyInitResponse") - proto.RegisterType((*SignUpdateRequest)(nil), "grep11.SignUpdateRequest") - proto.RegisterType((*SignUpdateResponse)(nil), "grep11.SignUpdateResponse") - proto.RegisterType((*VerifyUpdateRequest)(nil), "grep11.VerifyUpdateRequest") - proto.RegisterType((*VerifyUpdateResponse)(nil), "grep11.VerifyUpdateResponse") - proto.RegisterType((*SignFinalRequest)(nil), "grep11.SignFinalRequest") - proto.RegisterType((*SignFinalResponse)(nil), "grep11.SignFinalResponse") - proto.RegisterType((*VerifyFinalRequest)(nil), "grep11.VerifyFinalRequest") - proto.RegisterType((*VerifyFinalResponse)(nil), "grep11.VerifyFinalResponse") - proto.RegisterType((*SignRequest)(nil), "grep11.SignRequest") - proto.RegisterType((*SignResponse)(nil), "grep11.SignResponse") - proto.RegisterType((*VerifyRequest)(nil), "grep11.VerifyRequest") - proto.RegisterType((*VerifyResponse)(nil), "grep11.VerifyResponse") - proto.RegisterType((*SignSingleRequest)(nil), "grep11.SignSingleRequest") - proto.RegisterType((*SignSingleResponse)(nil), "grep11.SignSingleResponse") - proto.RegisterType((*VerifySingleRequest)(nil), "grep11.VerifySingleRequest") - proto.RegisterType((*VerifySingleResponse)(nil), "grep11.VerifySingleResponse") - proto.RegisterType((*GenerateKeyRequest)(nil), "grep11.GenerateKeyRequest") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.GenerateKeyRequest.TemplateEntry") - proto.RegisterType((*GenerateKeyResponse)(nil), "grep11.GenerateKeyResponse") - proto.RegisterType((*GenerateKeyPairRequest)(nil), "grep11.GenerateKeyPairRequest") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.GenerateKeyPairRequest.PrivKeyTemplateEntry") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.GenerateKeyPairRequest.PubKeyTemplateEntry") - proto.RegisterType((*GenerateKeyPairResponse)(nil), "grep11.GenerateKeyPairResponse") - proto.RegisterType((*WrapKeyRequest)(nil), "grep11.WrapKeyRequest") - proto.RegisterType((*WrapKeyResponse)(nil), "grep11.WrapKeyResponse") - proto.RegisterType((*UnwrapKeyRequest)(nil), "grep11.UnwrapKeyRequest") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.UnwrapKeyRequest.TemplateEntry") - proto.RegisterType((*UnwrapKeyResponse)(nil), "grep11.UnwrapKeyResponse") - proto.RegisterType((*DeriveKeyRequest)(nil), "grep11.DeriveKeyRequest") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.DeriveKeyRequest.TemplateEntry") - proto.RegisterType((*DeriveKeyResponse)(nil), "grep11.DeriveKeyResponse") - proto.RegisterType((*GetMechanismListRequest)(nil), "grep11.GetMechanismListRequest") - proto.RegisterType((*GetMechanismListResponse)(nil), "grep11.GetMechanismListResponse") - proto.RegisterType((*GetMechanismInfoRequest)(nil), "grep11.GetMechanismInfoRequest") - proto.RegisterType((*GetMechanismInfoResponse)(nil), "grep11.GetMechanismInfoResponse") - proto.RegisterType((*GetAttributeValueRequest)(nil), "grep11.GetAttributeValueRequest") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.GetAttributeValueRequest.AttributesEntry") - proto.RegisterType((*GetAttributeValueResponse)(nil), "grep11.GetAttributeValueResponse") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.GetAttributeValueResponse.AttributesEntry") - proto.RegisterType((*SetAttributeValueRequest)(nil), "grep11.SetAttributeValueRequest") - proto.RegisterMapType((map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte)(nil), "grep11.SetAttributeValueRequest.AttributesEntry") - proto.RegisterType((*SetAttributeValueResponse)(nil), "grep11.SetAttributeValueResponse") - proto.RegisterType((*Mechanism)(nil), "grep11.Mechanism") - proto.RegisterType((*MechanismInfo)(nil), "grep11.MechanismInfo") - proto.RegisterType((*Grep11Error)(nil), "grep11.Grep11Error") +type RSAOAEPParm struct { + HashMech ep11.Mechanism `protobuf:"varint,1,opt,name=HashMech,proto3,casttype=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"HashMech,omitempty"` + Mgf RSAOAEPParm_Mask `protobuf:"varint,2,opt,name=Mgf,proto3,enum=grep11.RSAOAEPParm_Mask" json:"Mgf,omitempty"` + EncodingParmType RSAOAEPParm_ParmType `protobuf:"varint,3,opt,name=EncodingParmType,proto3,enum=grep11.RSAOAEPParm_ParmType" json:"EncodingParmType,omitempty"` + EncodingParm []byte `protobuf:"bytes,4,opt,name=EncodingParm,proto3" json:"EncodingParm,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn +func (m *RSAOAEPParm) Reset() { *m = RSAOAEPParm{} } +func (m *RSAOAEPParm) String() string { return proto.CompactTextString(m) } +func (*RSAOAEPParm) ProtoMessage() {} +func (*RSAOAEPParm) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{75} +} +func (m *RSAOAEPParm) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RSAOAEPParm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RSAOAEPParm.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RSAOAEPParm) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSAOAEPParm.Merge(m, src) +} +func (m *RSAOAEPParm) XXX_Size() int { + return m.Size() +} +func (m *RSAOAEPParm) XXX_DiscardUnknown() { + xxx_messageInfo_RSAOAEPParm.DiscardUnknown(m) +} -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 +var xxx_messageInfo_RSAOAEPParm proto.InternalMessageInfo -// CryptoClient is the client API for Crypto service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type CryptoClient interface { - // CK_RV m_GenerateRandom ( - // CK_BYTE_PTR rnd, CK_ULONG rndlen, - // target_t target) ; - GenerateRandom(ctx context.Context, in *GenerateRandomRequest, opts ...grpc.CallOption) (*GenerateRandomResponse, error) - // CK_RV m_DigestInit ( - // unsigned char *state, size_t *statelen, - // const CK_MECHANISM_PTR mech, - // target_t target) ; - DigestInit(ctx context.Context, in *DigestInitRequest, opts ...grpc.CallOption) (*DigestInitResponse, error) - // CK_RV m_Digest ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, - // target_t target) ; - Digest(ctx context.Context, in *DigestRequest, opts ...grpc.CallOption) (*DigestResponse, error) - // CK_RV m_DigestUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // target_t target) ; - DigestUpdate(ctx context.Context, in *DigestUpdateRequest, opts ...grpc.CallOption) (*DigestUpdateResponse, error) - // CK_RV m_DigestKey ( - // unsigned char *state, size_t statelen, - // const unsigned char *key, size_t keylen, - // target_t target) ; - DigestKey(ctx context.Context, in *DigestKeyRequest, opts ...grpc.CallOption) (*DigestKeyResponse, error) - // CK_RV m_DigestFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, - // target_t target) ; - DigestFinal(ctx context.Context, in *DigestFinalRequest, opts ...grpc.CallOption) (*DigestFinalResponse, error) - // CK_RV m_DigestSingle ( - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, - // target_t target) ; - DigestSingle(ctx context.Context, in *DigestSingleRequest, opts ...grpc.CallOption) (*DigestSingleResponse, error) - // CK_RV m_EncryptInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *key, size_t keylen, - // target_t target) ; - EncryptInit(ctx context.Context, in *EncryptInitRequest, opts ...grpc.CallOption) (*EncryptInitResponse, error) - // CK_RV m_DecryptInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *key, size_t keylen, - // target_t target) ; - DecryptInit(ctx context.Context, in *DecryptInitRequest, opts ...grpc.CallOption) (*DecryptInitResponse, error) - // CK_RV m_EncryptUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR plain, CK_ULONG plainlen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - EncryptUpdate(ctx context.Context, in *EncryptUpdateRequest, opts ...grpc.CallOption) (*EncryptUpdateResponse, error) - // CK_RV m_DecryptUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - DecryptUpdate(ctx context.Context, in *DecryptUpdateRequest, opts ...grpc.CallOption) (*DecryptUpdateResponse, error) - // CK_RV m_Encrypt ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR plain, CK_ULONG plainlen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - Encrypt(ctx context.Context, in *EncryptRequest, opts ...grpc.CallOption) (*EncryptResponse, error) - // CK_RV m_Decrypt ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - Decrypt(ctx context.Context, in *DecryptRequest, opts ...grpc.CallOption) (*DecryptResponse, error) - // CK_RV m_EncryptFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - EncryptFinal(ctx context.Context, in *EncryptFinalRequest, opts ...grpc.CallOption) (*EncryptFinalResponse, error) - // CK_RV m_DecryptFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - DecryptFinal(ctx context.Context, in *DecryptFinalRequest, opts ...grpc.CallOption) (*DecryptFinalResponse, error) - // CK_RV m_EncryptSingle ( - // const unsigned char *key, size_t keylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR plain, CK_ULONG plainlen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - EncryptSingle(ctx context.Context, in *EncryptSingleRequest, opts ...grpc.CallOption) (*EncryptSingleResponse, error) - // CK_RV m_DecryptSingle ( - // const unsigned char *key, size_t keylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - DecryptSingle(ctx context.Context, in *DecryptSingleRequest, opts ...grpc.CallOption) (*DecryptSingleResponse, error) - // CK_RV m_SignInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *privKey, size_t privKeylen, - // target_t target) ; - SignInit(ctx context.Context, in *SignInitRequest, opts ...grpc.CallOption) (*SignInitResponse, error) - // CK_RV m_VerifyInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *pubKey, size_t pubKeylen, - // target_t target) ; - VerifyInit(ctx context.Context, in *VerifyInitRequest, opts ...grpc.CallOption) (*VerifyInitResponse, error) - // CK_RV m_SignUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // target_t target) ; - SignUpdate(ctx context.Context, in *SignUpdateRequest, opts ...grpc.CallOption) (*SignUpdateResponse, error) - // CK_RV m_VerifyUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // target_t target) ; - VerifyUpdate(ctx context.Context, in *VerifyUpdateRequest, opts ...grpc.CallOption) (*VerifyUpdateResponse, error) - // CK_RV m_SignFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, - // target_t target) ; - SignFinal(ctx context.Context, in *SignFinalRequest, opts ...grpc.CallOption) (*SignFinalResponse, error) - // CK_RV m_VerifyFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR signature, CK_ULONG signaturelen, - // target_t target) ; - VerifyFinal(ctx context.Context, in *VerifyFinalRequest, opts ...grpc.CallOption) (*VerifyFinalResponse, error) - // CK_RV m_Sign ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, - // target_t target) ; - Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) - // CK_RV m_Verify ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG signaturelen, - // target_t target) ; - Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) - // CK_RV m_SignSingle ( - // const unsigned char *privKey, size_t privKeylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, - // target_t target) ; - SignSingle(ctx context.Context, in *SignSingleRequest, opts ...grpc.CallOption) (*SignSingleResponse, error) - // CK_RV m_VerifySingle ( - // const unsigned char *pubKey, size_t pubKeylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG signaturelen, - // target_t target) ; - VerifySingle(ctx context.Context, in *VerifySingleRequest, opts ...grpc.CallOption) (*VerifySingleResponse, error) - // CK_RV m_GenerateKey ( - // CK_MECHANISM_PTR mech, - // CK_ATTRIBUTE_PTR template, CK_ULONG templatelen, - // const unsigned char *pin, size_t pinlen, - // unsigned char *key, size_t *keylen, - // unsigned char *checkSum, size_t *checkSumlen, - // target_t target) ; - GenerateKey(ctx context.Context, in *GenerateKeyRequest, opts ...grpc.CallOption) (*GenerateKeyResponse, error) - // CK_RV m_GenerateKeyPair ( - // CK_MECHANISM_PTR mech, - // CK_ATTRIBUTE_PTR pubKeyTemplate, CK_ULONG pubKeyTemplatelen, - // CK_ATTRIBUTE_PTR privKeyTemplate, CK_ULONG privKeyTemplatelen, - // const unsigned char *pin, size_t pinlen, - // unsigned char *privKey, size_t *privKeylen, - // unsigned char *pubKey, size_t *pubKeylen, - // target_t target) ; - GenerateKeyPair(ctx context.Context, in *GenerateKeyPairRequest, opts ...grpc.CallOption) (*GenerateKeyPairResponse, error) - // CK_RV m_WrapKey ( - // const unsigned char *key, size_t keylen, - // const unsigned char *keK, size_t keKlen, - // const unsigned char *macKey, size_t macKeylen, - // const CK_MECHANISM_PTR mech, - // CK_BYTE_PTR wrapped, CK_ULONG_PTR wrappedlen, - // target_t target) ; - WrapKey(ctx context.Context, in *WrapKeyRequest, opts ...grpc.CallOption) (*WrapKeyResponse, error) - // CK_RV m_UnwrapKey ( - // const CK_BYTE_PTR wrapped, CK_ULONG wrappedlen, - // const unsigned char *keK, size_t keKlen, - // const unsigned char *macKey, size_t macKeylen, - // const unsigned char *pin, size_t pinlen, - // const CK_MECHANISM_PTR mech, - // const CK_ATTRIBUTE_PTR template, CK_ULONG templatelen, - // unsigned char *unwrapped, size_t *unwrappedlen, - // CK_BYTE_PTR checkSum, CK_ULONG *checkSumlen, - // target_t target) ; - UnwrapKey(ctx context.Context, in *UnwrapKeyRequest, opts ...grpc.CallOption) (*UnwrapKeyResponse, error) - // CK_RV m_DeriveKey ( - // CK_MECHANISM_PTR mech, - // CK_ATTRIBUTE_PTR template, CK_ULONG templatelen, - // const unsigned char *baseKey, size_t baseKeylen, - // const unsigned char *data, size_t datalen, - // const unsigned char *pin, size_t pinlen, - // unsigned char *newKey, size_t *newKeylen, - // unsigned char *checkSum, size_t *checkSumlen, - // target_t target) ; - DeriveKey(ctx context.Context, in *DeriveKeyRequest, opts ...grpc.CallOption) (*DeriveKeyResponse, error) - // CK_RV m_GetMechanismList ( - // CK_SLOT_ID slot, - // CK_MECHANISM_TYPE_PTR mechs, CK_ULONG_PTR mechslen, - // target_t target) ; - GetMechanismList(ctx context.Context, in *GetMechanismListRequest, opts ...grpc.CallOption) (*GetMechanismListResponse, error) - // CK_RV m_GetMechanismInfo ( - // CK_SLOT_ID slot, - // CK_MECHANISM_TYPE mech, - // CK_MECHANISM_INFO_PTR mechInfo, - // target_t target) ; - GetMechanismInfo(ctx context.Context, in *GetMechanismInfoRequest, opts ...grpc.CallOption) (*GetMechanismInfoResponse, error) - // CK_RV m_GetAttributeValue ( - // const unsigned char *object, size_t objectlen, - // CK_ATTRIBUTE_PTR attributes, CK_ULONG attributeslen, - // target_t target) ; - GetAttributeValue(ctx context.Context, in *GetAttributeValueRequest, opts ...grpc.CallOption) (*GetAttributeValueResponse, error) - // CK_RV m_SetAttributeValue ( - // unsigned char *object, size_t objectlen, - // CK_ATTRIBUTE_PTR attributes, CK_ULONG attributeslen, - // target_t target) ; - SetAttributeValue(ctx context.Context, in *SetAttributeValueRequest, opts ...grpc.CallOption) (*SetAttributeValueResponse, error) +func (m *RSAOAEPParm) GetHashMech() ep11.Mechanism { + if m != nil { + return m.HashMech + } + return 0 } -type cryptoClient struct { - cc *grpc.ClientConn +func (m *RSAOAEPParm) GetMgf() RSAOAEPParm_Mask { + if m != nil { + return m.Mgf + } + return RSAOAEPParm_CkgMgf1None } -func NewCryptoClient(cc *grpc.ClientConn) CryptoClient { - return &cryptoClient{cc} +func (m *RSAOAEPParm) GetEncodingParmType() RSAOAEPParm_ParmType { + if m != nil { + return m.EncodingParmType + } + return RSAOAEPParm_CkzNoDataSpecified } -func (c *cryptoClient) GenerateRandom(ctx context.Context, in *GenerateRandomRequest, opts ...grpc.CallOption) (*GenerateRandomResponse, error) { - out := new(GenerateRandomResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/GenerateRandom", in, out, opts...) - if err != nil { - return nil, err +func (m *RSAOAEPParm) GetEncodingParm() []byte { + if m != nil { + return m.EncodingParm } - return out, nil + return nil } -func (c *cryptoClient) DigestInit(ctx context.Context, in *DigestInitRequest, opts ...grpc.CallOption) (*DigestInitResponse, error) { - out := new(DigestInitResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestInit", in, out, opts...) - if err != nil { - return nil, err +type RSAPSSParm struct { + HashMech ep11.Mechanism `protobuf:"varint,1,opt,name=HashMech,proto3,casttype=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Mechanism" json:"HashMech,omitempty"` + Mgf RSAPSSParm_Mask `protobuf:"varint,2,opt,name=Mgf,proto3,enum=grep11.RSAPSSParm_Mask" json:"Mgf,omitempty"` + SaltByteCount uint64 `protobuf:"varint,3,opt,name=SaltByteCount,proto3" json:"SaltByteCount,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RSAPSSParm) Reset() { *m = RSAPSSParm{} } +func (m *RSAPSSParm) String() string { return proto.CompactTextString(m) } +func (*RSAPSSParm) ProtoMessage() {} +func (*RSAPSSParm) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{76} +} +func (m *RSAPSSParm) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RSAPSSParm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RSAPSSParm.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *RSAPSSParm) XXX_Merge(src proto.Message) { + xxx_messageInfo_RSAPSSParm.Merge(m, src) +} +func (m *RSAPSSParm) XXX_Size() int { + return m.Size() +} +func (m *RSAPSSParm) XXX_DiscardUnknown() { + xxx_messageInfo_RSAPSSParm.DiscardUnknown(m) } -func (c *cryptoClient) Digest(ctx context.Context, in *DigestRequest, opts ...grpc.CallOption) (*DigestResponse, error) { - out := new(DigestResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/Digest", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_RSAPSSParm proto.InternalMessageInfo + +func (m *RSAPSSParm) GetHashMech() ep11.Mechanism { + if m != nil { + return m.HashMech } - return out, nil + return 0 } -func (c *cryptoClient) DigestUpdate(ctx context.Context, in *DigestUpdateRequest, opts ...grpc.CallOption) (*DigestUpdateResponse, error) { - out := new(DigestUpdateResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestUpdate", in, out, opts...) - if err != nil { - return nil, err +func (m *RSAPSSParm) GetMgf() RSAPSSParm_Mask { + if m != nil { + return m.Mgf } - return out, nil + return RSAPSSParm_CkgMgf1None } -func (c *cryptoClient) DigestKey(ctx context.Context, in *DigestKeyRequest, opts ...grpc.CallOption) (*DigestKeyResponse, error) { - out := new(DigestKeyResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestKey", in, out, opts...) - if err != nil { - return nil, err +func (m *RSAPSSParm) GetSaltByteCount() uint64 { + if m != nil { + return m.SaltByteCount } - return out, nil + return 0 } -func (c *cryptoClient) DigestFinal(ctx context.Context, in *DigestFinalRequest, opts ...grpc.CallOption) (*DigestFinalResponse, error) { - out := new(DigestFinalResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestFinal", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type ECDH1DeriveParm struct { + Kdf ECDH1DeriveParm_KeyDerivationFunction `protobuf:"varint,1,opt,name=Kdf,proto3,enum=grep11.ECDH1DeriveParm_KeyDerivationFunction" json:"Kdf,omitempty"` + SharedData []byte `protobuf:"bytes,2,opt,name=SharedData,proto3" json:"SharedData,omitempty"` + PublicData []byte `protobuf:"bytes,3,opt,name=PublicData,proto3" json:"PublicData,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *cryptoClient) DigestSingle(ctx context.Context, in *DigestSingleRequest, opts ...grpc.CallOption) (*DigestSingleResponse, error) { - out := new(DigestSingleResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestSingle", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *ECDH1DeriveParm) Reset() { *m = ECDH1DeriveParm{} } +func (m *ECDH1DeriveParm) String() string { return proto.CompactTextString(m) } +func (*ECDH1DeriveParm) ProtoMessage() {} +func (*ECDH1DeriveParm) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{77} } - -func (c *cryptoClient) EncryptInit(ctx context.Context, in *EncryptInitRequest, opts ...grpc.CallOption) (*EncryptInitResponse, error) { - out := new(EncryptInitResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptInit", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *ECDH1DeriveParm) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *cryptoClient) DecryptInit(ctx context.Context, in *DecryptInitRequest, opts ...grpc.CallOption) (*DecryptInitResponse, error) { - out := new(DecryptInitResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptInit", in, out, opts...) - if err != nil { - return nil, err +func (m *ECDH1DeriveParm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ECDH1DeriveParm.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *ECDH1DeriveParm) XXX_Merge(src proto.Message) { + xxx_messageInfo_ECDH1DeriveParm.Merge(m, src) +} +func (m *ECDH1DeriveParm) XXX_Size() int { + return m.Size() +} +func (m *ECDH1DeriveParm) XXX_DiscardUnknown() { + xxx_messageInfo_ECDH1DeriveParm.DiscardUnknown(m) } -func (c *cryptoClient) EncryptUpdate(ctx context.Context, in *EncryptUpdateRequest, opts ...grpc.CallOption) (*EncryptUpdateResponse, error) { - out := new(EncryptUpdateResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptUpdate", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_ECDH1DeriveParm proto.InternalMessageInfo + +func (m *ECDH1DeriveParm) GetKdf() ECDH1DeriveParm_KeyDerivationFunction { + if m != nil { + return m.Kdf } - return out, nil + return ECDH1DeriveParm_CkdNotUsed0 } -func (c *cryptoClient) DecryptUpdate(ctx context.Context, in *DecryptUpdateRequest, opts ...grpc.CallOption) (*DecryptUpdateResponse, error) { - out := new(DecryptUpdateResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptUpdate", in, out, opts...) - if err != nil { - return nil, err +func (m *ECDH1DeriveParm) GetSharedData() []byte { + if m != nil { + return m.SharedData } - return out, nil + return nil } -func (c *cryptoClient) Encrypt(ctx context.Context, in *EncryptRequest, opts ...grpc.CallOption) (*EncryptResponse, error) { - out := new(EncryptResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/Encrypt", in, out, opts...) - if err != nil { - return nil, err +func (m *ECDH1DeriveParm) GetPublicData() []byte { + if m != nil { + return m.PublicData } - return out, nil + return nil } -func (c *cryptoClient) Decrypt(ctx context.Context, in *DecryptRequest, opts ...grpc.CallOption) (*DecryptResponse, error) { - out := new(DecryptResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/Decrypt", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type BTCDeriveParm struct { + Type BTCDeriveParm_BTCDeriveType `protobuf:"varint,1,opt,name=Type,proto3,enum=grep11.BTCDeriveParm_BTCDeriveType" json:"Type,omitempty"` + ChildKeyIndex uint64 `protobuf:"varint,2,opt,name=ChildKeyIndex,proto3" json:"ChildKeyIndex,omitempty"` + ChainCode []byte `protobuf:"bytes,3,opt,name=ChainCode,proto3" json:"ChainCode,omitempty"` + Version uint64 `protobuf:"varint,4,opt,name=Version,proto3" json:"Version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *cryptoClient) EncryptFinal(ctx context.Context, in *EncryptFinalRequest, opts ...grpc.CallOption) (*EncryptFinalResponse, error) { - out := new(EncryptFinalResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptFinal", in, out, opts...) - if err != nil { - return nil, err +func (m *BTCDeriveParm) Reset() { *m = BTCDeriveParm{} } +func (m *BTCDeriveParm) String() string { return proto.CompactTextString(m) } +func (*BTCDeriveParm) ProtoMessage() {} +func (*BTCDeriveParm) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{78} +} +func (m *BTCDeriveParm) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BTCDeriveParm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BTCDeriveParm.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *BTCDeriveParm) XXX_Merge(src proto.Message) { + xxx_messageInfo_BTCDeriveParm.Merge(m, src) +} +func (m *BTCDeriveParm) XXX_Size() int { + return m.Size() +} +func (m *BTCDeriveParm) XXX_DiscardUnknown() { + xxx_messageInfo_BTCDeriveParm.DiscardUnknown(m) } -func (c *cryptoClient) DecryptFinal(ctx context.Context, in *DecryptFinalRequest, opts ...grpc.CallOption) (*DecryptFinalResponse, error) { - out := new(DecryptFinalResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptFinal", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_BTCDeriveParm proto.InternalMessageInfo + +func (m *BTCDeriveParm) GetType() BTCDeriveParm_BTCDeriveType { + if m != nil { + return m.Type } - return out, nil + return BTCDeriveParm_CkBIP0032NotUsed } -func (c *cryptoClient) EncryptSingle(ctx context.Context, in *EncryptSingleRequest, opts ...grpc.CallOption) (*EncryptSingleResponse, error) { - out := new(EncryptSingleResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptSingle", in, out, opts...) - if err != nil { - return nil, err +func (m *BTCDeriveParm) GetChildKeyIndex() uint64 { + if m != nil { + return m.ChildKeyIndex } - return out, nil + return 0 } -func (c *cryptoClient) DecryptSingle(ctx context.Context, in *DecryptSingleRequest, opts ...grpc.CallOption) (*DecryptSingleResponse, error) { - out := new(DecryptSingleResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptSingle", in, out, opts...) - if err != nil { - return nil, err +func (m *BTCDeriveParm) GetChainCode() []byte { + if m != nil { + return m.ChainCode } - return out, nil + return nil } -func (c *cryptoClient) SignInit(ctx context.Context, in *SignInitRequest, opts ...grpc.CallOption) (*SignInitResponse, error) { - out := new(SignInitResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/SignInit", in, out, opts...) - if err != nil { - return nil, err +func (m *BTCDeriveParm) GetVersion() uint64 { + if m != nil { + return m.Version } - return out, nil + return 0 } -func (c *cryptoClient) VerifyInit(ctx context.Context, in *VerifyInitRequest, opts ...grpc.CallOption) (*VerifyInitResponse, error) { - out := new(VerifyInitResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifyInit", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type HMACGeneralParm struct { + ReturnByteCount uint32 `protobuf:"varint,1,opt,name=ReturnByteCount,proto3" json:"ReturnByteCount,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *cryptoClient) SignUpdate(ctx context.Context, in *SignUpdateRequest, opts ...grpc.CallOption) (*SignUpdateResponse, error) { - out := new(SignUpdateResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/SignUpdate", in, out, opts...) - if err != nil { - return nil, err +func (m *HMACGeneralParm) Reset() { *m = HMACGeneralParm{} } +func (m *HMACGeneralParm) String() string { return proto.CompactTextString(m) } +func (*HMACGeneralParm) ProtoMessage() {} +func (*HMACGeneralParm) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{79} +} +func (m *HMACGeneralParm) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HMACGeneralParm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HMACGeneralParm.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *HMACGeneralParm) XXX_Merge(src proto.Message) { + xxx_messageInfo_HMACGeneralParm.Merge(m, src) +} +func (m *HMACGeneralParm) XXX_Size() int { + return m.Size() +} +func (m *HMACGeneralParm) XXX_DiscardUnknown() { + xxx_messageInfo_HMACGeneralParm.DiscardUnknown(m) } -func (c *cryptoClient) VerifyUpdate(ctx context.Context, in *VerifyUpdateRequest, opts ...grpc.CallOption) (*VerifyUpdateResponse, error) { - out := new(VerifyUpdateResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifyUpdate", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_HMACGeneralParm proto.InternalMessageInfo + +func (m *HMACGeneralParm) GetReturnByteCount() uint32 { + if m != nil { + return m.ReturnByteCount } - return out, nil + return 0 } -func (c *cryptoClient) SignFinal(ctx context.Context, in *SignFinalRequest, opts ...grpc.CallOption) (*SignFinalResponse, error) { - out := new(SignFinalResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/SignFinal", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type ReEncryptRequest struct { + WrappedKey []byte `protobuf:"bytes,1,opt,name=WrappedKey,proto3" json:"WrappedKey,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *cryptoClient) VerifyFinal(ctx context.Context, in *VerifyFinalRequest, opts ...grpc.CallOption) (*VerifyFinalResponse, error) { - out := new(VerifyFinalResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifyFinal", in, out, opts...) - if err != nil { - return nil, err +func (m *ReEncryptRequest) Reset() { *m = ReEncryptRequest{} } +func (m *ReEncryptRequest) String() string { return proto.CompactTextString(m) } +func (*ReEncryptRequest) ProtoMessage() {} +func (*ReEncryptRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{80} +} +func (m *ReEncryptRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReEncryptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReEncryptRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *ReEncryptRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReEncryptRequest.Merge(m, src) +} +func (m *ReEncryptRequest) XXX_Size() int { + return m.Size() +} +func (m *ReEncryptRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReEncryptRequest.DiscardUnknown(m) } -func (c *cryptoClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) { - out := new(SignResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/Sign", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_ReEncryptRequest proto.InternalMessageInfo + +func (m *ReEncryptRequest) GetWrappedKey() []byte { + if m != nil { + return m.WrappedKey } - return out, nil + return nil } -func (c *cryptoClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) { - out := new(VerifyResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/Verify", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type ReEncryptResponse struct { + RewrappedKey []byte `protobuf:"bytes,1,opt,name=RewrappedKey,proto3" json:"RewrappedKey,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *cryptoClient) SignSingle(ctx context.Context, in *SignSingleRequest, opts ...grpc.CallOption) (*SignSingleResponse, error) { - out := new(SignSingleResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/SignSingle", in, out, opts...) - if err != nil { - return nil, err +func (m *ReEncryptResponse) Reset() { *m = ReEncryptResponse{} } +func (m *ReEncryptResponse) String() string { return proto.CompactTextString(m) } +func (*ReEncryptResponse) ProtoMessage() {} +func (*ReEncryptResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{81} +} +func (m *ReEncryptResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReEncryptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReEncryptResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *ReEncryptResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReEncryptResponse.Merge(m, src) +} +func (m *ReEncryptResponse) XXX_Size() int { + return m.Size() +} +func (m *ReEncryptResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReEncryptResponse.DiscardUnknown(m) } -func (c *cryptoClient) VerifySingle(ctx context.Context, in *VerifySingleRequest, opts ...grpc.CallOption) (*VerifySingleResponse, error) { - out := new(VerifySingleResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifySingle", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_ReEncryptResponse proto.InternalMessageInfo + +func (m *ReEncryptResponse) GetRewrappedKey() []byte { + if m != nil { + return m.RewrappedKey } - return out, nil + return nil } -func (c *cryptoClient) GenerateKey(ctx context.Context, in *GenerateKeyRequest, opts ...grpc.CallOption) (*GenerateKeyResponse, error) { - out := new(GenerateKeyResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/GenerateKey", in, out, opts...) - if err != nil { - return nil, err +type RewrapKeyBlobRequest struct { + WrappedKey []byte `protobuf:"bytes,1,opt,name=WrappedKey,proto3" json:"WrappedKey,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RewrapKeyBlobRequest) Reset() { *m = RewrapKeyBlobRequest{} } +func (m *RewrapKeyBlobRequest) String() string { return proto.CompactTextString(m) } +func (*RewrapKeyBlobRequest) ProtoMessage() {} +func (*RewrapKeyBlobRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{82} +} +func (m *RewrapKeyBlobRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RewrapKeyBlobRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RewrapKeyBlobRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *RewrapKeyBlobRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RewrapKeyBlobRequest.Merge(m, src) +} +func (m *RewrapKeyBlobRequest) XXX_Size() int { + return m.Size() +} +func (m *RewrapKeyBlobRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RewrapKeyBlobRequest.DiscardUnknown(m) } -func (c *cryptoClient) GenerateKeyPair(ctx context.Context, in *GenerateKeyPairRequest, opts ...grpc.CallOption) (*GenerateKeyPairResponse, error) { - out := new(GenerateKeyPairResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/GenerateKeyPair", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_RewrapKeyBlobRequest proto.InternalMessageInfo + +func (m *RewrapKeyBlobRequest) GetWrappedKey() []byte { + if m != nil { + return m.WrappedKey } - return out, nil + return nil } -func (c *cryptoClient) WrapKey(ctx context.Context, in *WrapKeyRequest, opts ...grpc.CallOption) (*WrapKeyResponse, error) { - out := new(WrapKeyResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/WrapKey", in, out, opts...) - if err != nil { - return nil, err +type RewrapKeyBlobResponse struct { + RewrappedKey []byte `protobuf:"bytes,1,opt,name=RewrappedKey,proto3" json:"RewrappedKey,omitempty"` + KeyBlob *KeyBlob `protobuf:"bytes,2,opt,name=KeyBlob,proto3" json:"KeyBlob,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RewrapKeyBlobResponse) Reset() { *m = RewrapKeyBlobResponse{} } +func (m *RewrapKeyBlobResponse) String() string { return proto.CompactTextString(m) } +func (*RewrapKeyBlobResponse) ProtoMessage() {} +func (*RewrapKeyBlobResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{83} +} +func (m *RewrapKeyBlobResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RewrapKeyBlobResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RewrapKeyBlobResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *RewrapKeyBlobResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RewrapKeyBlobResponse.Merge(m, src) +} +func (m *RewrapKeyBlobResponse) XXX_Size() int { + return m.Size() +} +func (m *RewrapKeyBlobResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RewrapKeyBlobResponse.DiscardUnknown(m) } -func (c *cryptoClient) UnwrapKey(ctx context.Context, in *UnwrapKeyRequest, opts ...grpc.CallOption) (*UnwrapKeyResponse, error) { - out := new(UnwrapKeyResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/UnwrapKey", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_RewrapKeyBlobResponse proto.InternalMessageInfo + +func (m *RewrapKeyBlobResponse) GetRewrappedKey() []byte { + if m != nil { + return m.RewrappedKey } - return out, nil + return nil } -func (c *cryptoClient) DeriveKey(ctx context.Context, in *DeriveKeyRequest, opts ...grpc.CallOption) (*DeriveKeyResponse, error) { - out := new(DeriveKeyResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/DeriveKey", in, out, opts...) - if err != nil { - return nil, err +func (m *RewrapKeyBlobResponse) GetKeyBlob() *KeyBlob { + if m != nil { + return m.KeyBlob } - return out, nil + return nil } -func (c *cryptoClient) GetMechanismList(ctx context.Context, in *GetMechanismListRequest, opts ...grpc.CallOption) (*GetMechanismListResponse, error) { - out := new(GetMechanismListResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/GetMechanismList", in, out, opts...) - if err != nil { - return nil, err +type AttributeValue struct { + // Types that are valid to be assigned to OneAttr: + // *AttributeValue_AttributeB + // *AttributeValue_AttributeTF + // *AttributeValue_AttributeI + OneAttr isAttributeValue_OneAttr `protobuf_oneof:"one_attr"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AttributeValue) Reset() { *m = AttributeValue{} } +func (m *AttributeValue) String() string { return proto.CompactTextString(m) } +func (*AttributeValue) ProtoMessage() {} +func (*AttributeValue) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{84} +} +func (m *AttributeValue) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AttributeValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AttributeValue.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *AttributeValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_AttributeValue.Merge(m, src) +} +func (m *AttributeValue) XXX_Size() int { + return m.Size() +} +func (m *AttributeValue) XXX_DiscardUnknown() { + xxx_messageInfo_AttributeValue.DiscardUnknown(m) } -func (c *cryptoClient) GetMechanismInfo(ctx context.Context, in *GetMechanismInfoRequest, opts ...grpc.CallOption) (*GetMechanismInfoResponse, error) { - out := new(GetMechanismInfoResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/GetMechanismInfo", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_AttributeValue proto.InternalMessageInfo + +type isAttributeValue_OneAttr interface { + isAttributeValue_OneAttr() + MarshalTo([]byte) (int, error) + Size() int +} + +type AttributeValue_AttributeB struct { + AttributeB []byte `protobuf:"bytes,1,opt,name=AttributeB,proto3,oneof" json:"AttributeB,omitempty"` +} +type AttributeValue_AttributeTF struct { + AttributeTF bool `protobuf:"varint,2,opt,name=AttributeTF,proto3,oneof" json:"AttributeTF,omitempty"` +} +type AttributeValue_AttributeI struct { + AttributeI int64 `protobuf:"varint,3,opt,name=AttributeI,proto3,oneof" json:"AttributeI,omitempty"` +} + +func (*AttributeValue_AttributeB) isAttributeValue_OneAttr() {} +func (*AttributeValue_AttributeTF) isAttributeValue_OneAttr() {} +func (*AttributeValue_AttributeI) isAttributeValue_OneAttr() {} + +func (m *AttributeValue) GetOneAttr() isAttributeValue_OneAttr { + if m != nil { + return m.OneAttr } - return out, nil + return nil } -func (c *cryptoClient) GetAttributeValue(ctx context.Context, in *GetAttributeValueRequest, opts ...grpc.CallOption) (*GetAttributeValueResponse, error) { - out := new(GetAttributeValueResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/GetAttributeValue", in, out, opts...) - if err != nil { - return nil, err +func (m *AttributeValue) GetAttributeB() []byte { + if x, ok := m.GetOneAttr().(*AttributeValue_AttributeB); ok { + return x.AttributeB } - return out, nil + return nil } -func (c *cryptoClient) SetAttributeValue(ctx context.Context, in *SetAttributeValueRequest, opts ...grpc.CallOption) (*SetAttributeValueResponse, error) { - out := new(SetAttributeValueResponse) - err := c.cc.Invoke(ctx, "/grep11.Crypto/SetAttributeValue", in, out, opts...) - if err != nil { - return nil, err +func (m *AttributeValue) GetAttributeTF() bool { + if x, ok := m.GetOneAttr().(*AttributeValue_AttributeTF); ok { + return x.AttributeTF } - return out, nil + return false } -// CryptoServer is the server API for Crypto service. -type CryptoServer interface { - // CK_RV m_GenerateRandom ( - // CK_BYTE_PTR rnd, CK_ULONG rndlen, - // target_t target) ; - GenerateRandom(context.Context, *GenerateRandomRequest) (*GenerateRandomResponse, error) - // CK_RV m_DigestInit ( - // unsigned char *state, size_t *statelen, - // const CK_MECHANISM_PTR mech, - // target_t target) ; - DigestInit(context.Context, *DigestInitRequest) (*DigestInitResponse, error) - // CK_RV m_Digest ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, - // target_t target) ; - Digest(context.Context, *DigestRequest) (*DigestResponse, error) - // CK_RV m_DigestUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // target_t target) ; - DigestUpdate(context.Context, *DigestUpdateRequest) (*DigestUpdateResponse, error) - // CK_RV m_DigestKey ( - // unsigned char *state, size_t statelen, - // const unsigned char *key, size_t keylen, - // target_t target) ; - DigestKey(context.Context, *DigestKeyRequest) (*DigestKeyResponse, error) - // CK_RV m_DigestFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, - // target_t target) ; - DigestFinal(context.Context, *DigestFinalRequest) (*DigestFinalResponse, error) - // CK_RV m_DigestSingle ( - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, - // target_t target) ; - DigestSingle(context.Context, *DigestSingleRequest) (*DigestSingleResponse, error) - // CK_RV m_EncryptInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *key, size_t keylen, - // target_t target) ; - EncryptInit(context.Context, *EncryptInitRequest) (*EncryptInitResponse, error) - // CK_RV m_DecryptInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *key, size_t keylen, - // target_t target) ; - DecryptInit(context.Context, *DecryptInitRequest) (*DecryptInitResponse, error) - // CK_RV m_EncryptUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR plain, CK_ULONG plainlen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - EncryptUpdate(context.Context, *EncryptUpdateRequest) (*EncryptUpdateResponse, error) - // CK_RV m_DecryptUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - DecryptUpdate(context.Context, *DecryptUpdateRequest) (*DecryptUpdateResponse, error) - // CK_RV m_Encrypt ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR plain, CK_ULONG plainlen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - Encrypt(context.Context, *EncryptRequest) (*EncryptResponse, error) - // CK_RV m_Decrypt ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - Decrypt(context.Context, *DecryptRequest) (*DecryptResponse, error) - // CK_RV m_EncryptFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - EncryptFinal(context.Context, *EncryptFinalRequest) (*EncryptFinalResponse, error) - // CK_RV m_DecryptFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - DecryptFinal(context.Context, *DecryptFinalRequest) (*DecryptFinalResponse, error) - // CK_RV m_EncryptSingle ( - // const unsigned char *key, size_t keylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR plain, CK_ULONG plainlen, - // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, - // target_t target) ; - EncryptSingle(context.Context, *EncryptSingleRequest) (*EncryptSingleResponse, error) - // CK_RV m_DecryptSingle ( - // const unsigned char *key, size_t keylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, - // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, - // target_t target) ; - DecryptSingle(context.Context, *DecryptSingleRequest) (*DecryptSingleResponse, error) - // CK_RV m_SignInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *privKey, size_t privKeylen, - // target_t target) ; - SignInit(context.Context, *SignInitRequest) (*SignInitResponse, error) - // CK_RV m_VerifyInit ( - // unsigned char *state, size_t *statelen, - // CK_MECHANISM_PTR mech, - // const unsigned char *pubKey, size_t pubKeylen, - // target_t target) ; - VerifyInit(context.Context, *VerifyInitRequest) (*VerifyInitResponse, error) - // CK_RV m_SignUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // target_t target) ; - SignUpdate(context.Context, *SignUpdateRequest) (*SignUpdateResponse, error) - // CK_RV m_VerifyUpdate ( - // unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // target_t target) ; - VerifyUpdate(context.Context, *VerifyUpdateRequest) (*VerifyUpdateResponse, error) - // CK_RV m_SignFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, - // target_t target) ; - SignFinal(context.Context, *SignFinalRequest) (*SignFinalResponse, error) - // CK_RV m_VerifyFinal ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR signature, CK_ULONG signaturelen, - // target_t target) ; - VerifyFinal(context.Context, *VerifyFinalRequest) (*VerifyFinalResponse, error) - // CK_RV m_Sign ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, - // target_t target) ; - Sign(context.Context, *SignRequest) (*SignResponse, error) - // CK_RV m_Verify ( - // const unsigned char *state, size_t statelen, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG signaturelen, - // target_t target) ; - Verify(context.Context, *VerifyRequest) (*VerifyResponse, error) - // CK_RV m_SignSingle ( - // const unsigned char *privKey, size_t privKeylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, - // target_t target) ; - SignSingle(context.Context, *SignSingleRequest) (*SignSingleResponse, error) - // CK_RV m_VerifySingle ( - // const unsigned char *pubKey, size_t pubKeylen, - // CK_MECHANISM_PTR mech, - // CK_BYTE_PTR data, CK_ULONG datalen, - // CK_BYTE_PTR signature, CK_ULONG signaturelen, - // target_t target) ; - VerifySingle(context.Context, *VerifySingleRequest) (*VerifySingleResponse, error) - // CK_RV m_GenerateKey ( - // CK_MECHANISM_PTR mech, - // CK_ATTRIBUTE_PTR template, CK_ULONG templatelen, - // const unsigned char *pin, size_t pinlen, - // unsigned char *key, size_t *keylen, - // unsigned char *checkSum, size_t *checkSumlen, - // target_t target) ; - GenerateKey(context.Context, *GenerateKeyRequest) (*GenerateKeyResponse, error) - // CK_RV m_GenerateKeyPair ( - // CK_MECHANISM_PTR mech, - // CK_ATTRIBUTE_PTR pubKeyTemplate, CK_ULONG pubKeyTemplatelen, - // CK_ATTRIBUTE_PTR privKeyTemplate, CK_ULONG privKeyTemplatelen, - // const unsigned char *pin, size_t pinlen, - // unsigned char *privKey, size_t *privKeylen, - // unsigned char *pubKey, size_t *pubKeylen, - // target_t target) ; - GenerateKeyPair(context.Context, *GenerateKeyPairRequest) (*GenerateKeyPairResponse, error) - // CK_RV m_WrapKey ( - // const unsigned char *key, size_t keylen, - // const unsigned char *keK, size_t keKlen, - // const unsigned char *macKey, size_t macKeylen, - // const CK_MECHANISM_PTR mech, - // CK_BYTE_PTR wrapped, CK_ULONG_PTR wrappedlen, - // target_t target) ; - WrapKey(context.Context, *WrapKeyRequest) (*WrapKeyResponse, error) - // CK_RV m_UnwrapKey ( - // const CK_BYTE_PTR wrapped, CK_ULONG wrappedlen, - // const unsigned char *keK, size_t keKlen, - // const unsigned char *macKey, size_t macKeylen, - // const unsigned char *pin, size_t pinlen, - // const CK_MECHANISM_PTR mech, - // const CK_ATTRIBUTE_PTR template, CK_ULONG templatelen, - // unsigned char *unwrapped, size_t *unwrappedlen, - // CK_BYTE_PTR checkSum, CK_ULONG *checkSumlen, - // target_t target) ; - UnwrapKey(context.Context, *UnwrapKeyRequest) (*UnwrapKeyResponse, error) - // CK_RV m_DeriveKey ( - // CK_MECHANISM_PTR mech, - // CK_ATTRIBUTE_PTR template, CK_ULONG templatelen, - // const unsigned char *baseKey, size_t baseKeylen, - // const unsigned char *data, size_t datalen, - // const unsigned char *pin, size_t pinlen, - // unsigned char *newKey, size_t *newKeylen, - // unsigned char *checkSum, size_t *checkSumlen, - // target_t target) ; - DeriveKey(context.Context, *DeriveKeyRequest) (*DeriveKeyResponse, error) - // CK_RV m_GetMechanismList ( - // CK_SLOT_ID slot, - // CK_MECHANISM_TYPE_PTR mechs, CK_ULONG_PTR mechslen, - // target_t target) ; - GetMechanismList(context.Context, *GetMechanismListRequest) (*GetMechanismListResponse, error) - // CK_RV m_GetMechanismInfo ( - // CK_SLOT_ID slot, - // CK_MECHANISM_TYPE mech, - // CK_MECHANISM_INFO_PTR mechInfo, - // target_t target) ; - GetMechanismInfo(context.Context, *GetMechanismInfoRequest) (*GetMechanismInfoResponse, error) - // CK_RV m_GetAttributeValue ( - // const unsigned char *object, size_t objectlen, - // CK_ATTRIBUTE_PTR attributes, CK_ULONG attributeslen, - // target_t target) ; - GetAttributeValue(context.Context, *GetAttributeValueRequest) (*GetAttributeValueResponse, error) - // CK_RV m_SetAttributeValue ( - // unsigned char *object, size_t objectlen, - // CK_ATTRIBUTE_PTR attributes, CK_ULONG attributeslen, - // target_t target) ; - SetAttributeValue(context.Context, *SetAttributeValueRequest) (*SetAttributeValueResponse, error) -} - -func RegisterCryptoServer(s *grpc.Server, srv CryptoServer) { - s.RegisterService(&_Crypto_serviceDesc, srv) -} - -func _Crypto_GenerateRandom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GenerateRandomRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).GenerateRandom(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/GenerateRandom", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).GenerateRandom(ctx, req.(*GenerateRandomRequest)) +func (m *AttributeValue) GetAttributeI() int64 { + if x, ok := m.GetOneAttr().(*AttributeValue_AttributeI); ok { + return x.AttributeI } - return interceptor(ctx, in, info, handler) + return 0 } -func _Crypto_DigestInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DigestInitRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).DigestInit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DigestInit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DigestInit(ctx, req.(*DigestInitRequest)) +// XXX_OneofWrappers is for the internal use of the proto package. +func (*AttributeValue) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*AttributeValue_AttributeB)(nil), + (*AttributeValue_AttributeTF)(nil), + (*AttributeValue_AttributeI)(nil), } - return interceptor(ctx, in, info, handler) } -func _Crypto_Digest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DigestRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).Digest(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/Digest", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).Digest(ctx, req.(*DigestRequest)) - } - return interceptor(ctx, in, info, handler) +type KeyBlob struct { + KeyBlobID []byte `protobuf:"bytes,1,opt,name=KeyBlobID,proto3" json:"KeyBlobID,omitempty"` + Version int64 `protobuf:"varint,2,opt,name=Version,proto3" json:"Version,omitempty"` + TxID []byte `protobuf:"bytes,3,opt,name=TxID,proto3" json:"TxID,omitempty"` + Attributes map[ep11.Attribute]*AttributeValue `protobuf:"bytes,4,rep,name=Attributes,proto3,castkey=github.com/ibm-hyper-protect/ibm-cloud-hyperprotectcrypto/golang/ep11.Attribute" json:"Attributes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + KeyBlobs [][]byte `protobuf:"bytes,5,rep,name=KeyBlobs,proto3" json:"KeyBlobs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func _Crypto_DigestUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DigestUpdateRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).DigestUpdate(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DigestUpdate", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DigestUpdate(ctx, req.(*DigestUpdateRequest)) +func (m *KeyBlob) Reset() { *m = KeyBlob{} } +func (m *KeyBlob) String() string { return proto.CompactTextString(m) } +func (*KeyBlob) ProtoMessage() {} +func (*KeyBlob) Descriptor() ([]byte, []int) { + return fileDescriptor_ad098daeda4239f7, []int{85} +} +func (m *KeyBlob) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyBlob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyBlob.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return interceptor(ctx, in, info, handler) +} +func (m *KeyBlob) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyBlob.Merge(m, src) +} +func (m *KeyBlob) XXX_Size() int { + return m.Size() +} +func (m *KeyBlob) XXX_DiscardUnknown() { + xxx_messageInfo_KeyBlob.DiscardUnknown(m) } -func _Crypto_DigestKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DigestKeyRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).DigestKey(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DigestKey", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DigestKey(ctx, req.(*DigestKeyRequest)) +var xxx_messageInfo_KeyBlob proto.InternalMessageInfo + +func (m *KeyBlob) GetKeyBlobID() []byte { + if m != nil { + return m.KeyBlobID } - return interceptor(ctx, in, info, handler) + return nil } -func _Crypto_DigestFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DigestFinalRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).DigestFinal(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DigestFinal", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DigestFinal(ctx, req.(*DigestFinalRequest)) +func (m *KeyBlob) GetVersion() int64 { + if m != nil { + return m.Version } - return interceptor(ctx, in, info, handler) + return 0 } -func _Crypto_DigestSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DigestSingleRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).DigestSingle(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DigestSingle", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DigestSingle(ctx, req.(*DigestSingleRequest)) +func (m *KeyBlob) GetTxID() []byte { + if m != nil { + return m.TxID } - return interceptor(ctx, in, info, handler) + return nil } -func _Crypto_EncryptInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(EncryptInitRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).EncryptInit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/EncryptInit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).EncryptInit(ctx, req.(*EncryptInitRequest)) +func (m *KeyBlob) GetAttributes() map[ep11.Attribute]*AttributeValue { + if m != nil { + return m.Attributes } - return interceptor(ctx, in, info, handler) + return nil } -func _Crypto_DecryptInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DecryptInitRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).DecryptInit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DecryptInit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DecryptInit(ctx, req.(*DecryptInitRequest)) +func (m *KeyBlob) GetKeyBlobs() [][]byte { + if m != nil { + return m.KeyBlobs } - return interceptor(ctx, in, info, handler) + return nil } -func _Crypto_EncryptUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(EncryptUpdateRequest) - if err := dec(in); err != nil { - return nil, err - } +func init() { + proto.RegisterEnum("grep11.RSAOAEPParm_Mask", RSAOAEPParm_Mask_name, RSAOAEPParm_Mask_value) + proto.RegisterEnum("grep11.RSAOAEPParm_ParmType", RSAOAEPParm_ParmType_name, RSAOAEPParm_ParmType_value) + proto.RegisterEnum("grep11.RSAPSSParm_Mask", RSAPSSParm_Mask_name, RSAPSSParm_Mask_value) + proto.RegisterEnum("grep11.ECDH1DeriveParm_KeyDerivationFunction", ECDH1DeriveParm_KeyDerivationFunction_name, ECDH1DeriveParm_KeyDerivationFunction_value) + proto.RegisterEnum("grep11.BTCDeriveParm_BTCDeriveType", BTCDeriveParm_BTCDeriveType_name, BTCDeriveParm_BTCDeriveType_value) + proto.RegisterType((*GenerateRandomRequest)(nil), "grep11.GenerateRandomRequest") + proto.RegisterType((*GenerateRandomResponse)(nil), "grep11.GenerateRandomResponse") + proto.RegisterType((*DigestInitRequest)(nil), "grep11.DigestInitRequest") + proto.RegisterType((*DigestInitResponse)(nil), "grep11.DigestInitResponse") + proto.RegisterType((*DigestRequest)(nil), "grep11.DigestRequest") + proto.RegisterType((*DigestResponse)(nil), "grep11.DigestResponse") + proto.RegisterType((*DigestUpdateRequest)(nil), "grep11.DigestUpdateRequest") + proto.RegisterType((*DigestUpdateResponse)(nil), "grep11.DigestUpdateResponse") + proto.RegisterType((*DigestKeyRequest)(nil), "grep11.DigestKeyRequest") + proto.RegisterType((*DigestKeyResponse)(nil), "grep11.DigestKeyResponse") + proto.RegisterType((*DigestFinalRequest)(nil), "grep11.DigestFinalRequest") + proto.RegisterType((*DigestFinalResponse)(nil), "grep11.DigestFinalResponse") + proto.RegisterType((*DigestSingleRequest)(nil), "grep11.DigestSingleRequest") + proto.RegisterType((*DigestSingleResponse)(nil), "grep11.DigestSingleResponse") + proto.RegisterType((*EncryptInitRequest)(nil), "grep11.EncryptInitRequest") + proto.RegisterType((*EncryptInitResponse)(nil), "grep11.EncryptInitResponse") + proto.RegisterType((*DecryptInitRequest)(nil), "grep11.DecryptInitRequest") + proto.RegisterType((*DecryptInitResponse)(nil), "grep11.DecryptInitResponse") + proto.RegisterType((*EncryptUpdateRequest)(nil), "grep11.EncryptUpdateRequest") + proto.RegisterType((*EncryptUpdateResponse)(nil), "grep11.EncryptUpdateResponse") + proto.RegisterType((*DecryptUpdateRequest)(nil), "grep11.DecryptUpdateRequest") + proto.RegisterType((*DecryptUpdateResponse)(nil), "grep11.DecryptUpdateResponse") + proto.RegisterType((*EncryptRequest)(nil), "grep11.EncryptRequest") + proto.RegisterType((*EncryptResponse)(nil), "grep11.EncryptResponse") + proto.RegisterType((*DecryptRequest)(nil), "grep11.DecryptRequest") + proto.RegisterType((*DecryptResponse)(nil), "grep11.DecryptResponse") + proto.RegisterType((*EncryptFinalRequest)(nil), "grep11.EncryptFinalRequest") + proto.RegisterType((*EncryptFinalResponse)(nil), "grep11.EncryptFinalResponse") + proto.RegisterType((*DecryptFinalRequest)(nil), "grep11.DecryptFinalRequest") + proto.RegisterType((*DecryptFinalResponse)(nil), "grep11.DecryptFinalResponse") + proto.RegisterType((*EncryptSingleRequest)(nil), "grep11.EncryptSingleRequest") + proto.RegisterType((*EncryptSingleResponse)(nil), "grep11.EncryptSingleResponse") + proto.RegisterType((*DecryptSingleRequest)(nil), "grep11.DecryptSingleRequest") + proto.RegisterType((*DecryptSingleResponse)(nil), "grep11.DecryptSingleResponse") + proto.RegisterType((*SignInitRequest)(nil), "grep11.SignInitRequest") + proto.RegisterType((*SignInitResponse)(nil), "grep11.SignInitResponse") + proto.RegisterType((*VerifyInitRequest)(nil), "grep11.VerifyInitRequest") + proto.RegisterType((*VerifyInitResponse)(nil), "grep11.VerifyInitResponse") + proto.RegisterType((*SignUpdateRequest)(nil), "grep11.SignUpdateRequest") + proto.RegisterType((*SignUpdateResponse)(nil), "grep11.SignUpdateResponse") + proto.RegisterType((*VerifyUpdateRequest)(nil), "grep11.VerifyUpdateRequest") + proto.RegisterType((*VerifyUpdateResponse)(nil), "grep11.VerifyUpdateResponse") + proto.RegisterType((*SignFinalRequest)(nil), "grep11.SignFinalRequest") + proto.RegisterType((*SignFinalResponse)(nil), "grep11.SignFinalResponse") + proto.RegisterType((*VerifyFinalRequest)(nil), "grep11.VerifyFinalRequest") + proto.RegisterType((*VerifyFinalResponse)(nil), "grep11.VerifyFinalResponse") + proto.RegisterType((*SignRequest)(nil), "grep11.SignRequest") + proto.RegisterType((*SignResponse)(nil), "grep11.SignResponse") + proto.RegisterType((*VerifyRequest)(nil), "grep11.VerifyRequest") + proto.RegisterType((*VerifyResponse)(nil), "grep11.VerifyResponse") + proto.RegisterType((*SignSingleRequest)(nil), "grep11.SignSingleRequest") + proto.RegisterType((*SignSingleResponse)(nil), "grep11.SignSingleResponse") + proto.RegisterType((*VerifySingleRequest)(nil), "grep11.VerifySingleRequest") + proto.RegisterType((*VerifySingleResponse)(nil), "grep11.VerifySingleResponse") + proto.RegisterType((*GenerateKeyRequest)(nil), "grep11.GenerateKeyRequest") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.GenerateKeyRequest.TemplateBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.GenerateKeyRequest.TemplateEntry") + proto.RegisterType((*GenerateKeyResponse)(nil), "grep11.GenerateKeyResponse") + proto.RegisterType((*GenerateKeyPairRequest)(nil), "grep11.GenerateKeyPairRequest") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.GenerateKeyPairRequest.PrivKeyTemplateBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.GenerateKeyPairRequest.PrivKeyTemplateEntry") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.GenerateKeyPairRequest.PubKeyTemplateBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.GenerateKeyPairRequest.PubKeyTemplateEntry") + proto.RegisterType((*GenerateKeyPairResponse)(nil), "grep11.GenerateKeyPairResponse") + proto.RegisterType((*WrapKeyRequest)(nil), "grep11.WrapKeyRequest") + proto.RegisterType((*WrapKeyResponse)(nil), "grep11.WrapKeyResponse") + proto.RegisterType((*UnwrapKeyRequest)(nil), "grep11.UnwrapKeyRequest") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.UnwrapKeyRequest.TemplateBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.UnwrapKeyRequest.TemplateEntry") + proto.RegisterType((*UnwrapKeyResponse)(nil), "grep11.UnwrapKeyResponse") + proto.RegisterType((*DeriveKeyRequest)(nil), "grep11.DeriveKeyRequest") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.DeriveKeyRequest.TemplateBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.DeriveKeyRequest.TemplateEntry") + proto.RegisterType((*DeriveKeyResponse)(nil), "grep11.DeriveKeyResponse") + proto.RegisterType((*GetMechanismListRequest)(nil), "grep11.GetMechanismListRequest") + proto.RegisterType((*GetMechanismListResponse)(nil), "grep11.GetMechanismListResponse") + proto.RegisterType((*GetMechanismInfoRequest)(nil), "grep11.GetMechanismInfoRequest") + proto.RegisterType((*GetMechanismInfoResponse)(nil), "grep11.GetMechanismInfoResponse") + proto.RegisterType((*GetAttributeValueRequest)(nil), "grep11.GetAttributeValueRequest") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.GetAttributeValueRequest.AttributesBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.GetAttributeValueRequest.AttributesEntry") + proto.RegisterType((*GetAttributeValueResponse)(nil), "grep11.GetAttributeValueResponse") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.GetAttributeValueResponse.AttributesBytesEntry") + proto.RegisterType((*SetAttributeValueRequest)(nil), "grep11.SetAttributeValueRequest") + proto.RegisterMapType((map[ep11.Attribute][]byte)(nil), "grep11.SetAttributeValueRequest.AttributesBytesEntry") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.SetAttributeValueRequest.AttributesEntry") + proto.RegisterType((*SetAttributeValueResponse)(nil), "grep11.SetAttributeValueResponse") + proto.RegisterType((*Mechanism)(nil), "grep11.Mechanism") + proto.RegisterType((*MechanismInfo)(nil), "grep11.MechanismInfo") + proto.RegisterType((*Grep11Error)(nil), "grep11.Grep11Error") + proto.RegisterType((*RSAOAEPParm)(nil), "grep11.RSAOAEPParm") + proto.RegisterType((*RSAPSSParm)(nil), "grep11.RSAPSSParm") + proto.RegisterType((*ECDH1DeriveParm)(nil), "grep11.ECDH1DeriveParm") + proto.RegisterType((*BTCDeriveParm)(nil), "grep11.BTCDeriveParm") + proto.RegisterType((*HMACGeneralParm)(nil), "grep11.HMACGeneralParm") + proto.RegisterType((*ReEncryptRequest)(nil), "grep11.ReEncryptRequest") + proto.RegisterType((*ReEncryptResponse)(nil), "grep11.ReEncryptResponse") + proto.RegisterType((*RewrapKeyBlobRequest)(nil), "grep11.RewrapKeyBlobRequest") + proto.RegisterType((*RewrapKeyBlobResponse)(nil), "grep11.RewrapKeyBlobResponse") + proto.RegisterType((*AttributeValue)(nil), "grep11.AttributeValue") + proto.RegisterType((*KeyBlob)(nil), "grep11.KeyBlob") + proto.RegisterMapType((map[ep11.Attribute]*AttributeValue)(nil), "grep11.KeyBlob.AttributesEntry") +} + +func init() { proto.RegisterFile("server.proto", fileDescriptor_ad098daeda4239f7) } + +var fileDescriptor_ad098daeda4239f7 = []byte{ + // 3361 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcd, 0x6f, 0x1b, 0xc7, + 0x15, 0xf7, 0x8a, 0x94, 0x44, 0x3d, 0x7d, 0xad, 0x46, 0x1f, 0xa6, 0x68, 0x59, 0x96, 0x37, 0x1f, + 0xfe, 0x48, 0x2c, 0x59, 0x94, 0xbf, 0xe2, 0x7e, 0xa4, 0x26, 0xfd, 0x21, 0x41, 0xa1, 0x23, 0x2c, + 0x2d, 0x07, 0x09, 0x50, 0x14, 0x2b, 0x71, 0x44, 0x6d, 0x45, 0x2d, 0x19, 0x72, 0xe5, 0x98, 0x2e, + 0x72, 0x68, 0xda, 0x06, 0x6d, 0xd0, 0x5b, 0x80, 0xa2, 0xbd, 0xf4, 0x50, 0xa0, 0x40, 0x0f, 0x2d, + 0x7a, 0xe8, 0x7f, 0x50, 0xf4, 0xd0, 0x63, 0x81, 0x9e, 0x7a, 0x49, 0x83, 0xa0, 0xc7, 0x1e, 0x7b, + 0x4a, 0x2f, 0xc5, 0x7c, 0xec, 0xce, 0xc7, 0x0e, 0x29, 0x4a, 0xb2, 0xd1, 0x22, 0xe8, 0xc1, 0x30, + 0xe7, 0xcd, 0x9b, 0xf7, 0x7b, 0xf3, 0xe6, 0xbd, 0x79, 0xb3, 0x33, 0x4f, 0x30, 0xd2, 0xc2, 0xcd, + 0x27, 0xb8, 0xb9, 0xd8, 0x68, 0xd6, 0xc3, 0x3a, 0x1a, 0xa8, 0x36, 0x71, 0x63, 0x79, 0x39, 0x07, + 0xd5, 0x7a, 0xb5, 0xce, 0x68, 0xb9, 0xb9, 0x6a, 0xbd, 0x5e, 0xad, 0xe1, 0x25, 0xaf, 0xe1, 0x2f, + 0x79, 0x41, 0x50, 0x0f, 0xbd, 0xd0, 0xaf, 0x07, 0x2d, 0xd6, 0xeb, 0x5c, 0x82, 0xe9, 0x07, 0x38, + 0xc0, 0x4d, 0x2f, 0xc4, 0xae, 0x17, 0x54, 0xea, 0xfb, 0x2e, 0x7e, 0xff, 0x00, 0xb7, 0x42, 0x64, + 0x43, 0xea, 0x2d, 0x1c, 0x64, 0xad, 0x05, 0xeb, 0x62, 0xda, 0x25, 0x3f, 0x9d, 0xcb, 0x30, 0xa3, + 0xb3, 0xb6, 0x1a, 0xf5, 0xa0, 0x85, 0x09, 0xaf, 0x1b, 0x54, 0x28, 0xef, 0x88, 0x4b, 0x7e, 0x3a, + 0xb7, 0x61, 0xe2, 0xae, 0x5f, 0xc5, 0xad, 0x70, 0x2d, 0xf0, 0xc3, 0x48, 0xe4, 0x2b, 0x90, 0x2e, + 0xe1, 0xed, 0xdd, 0x6c, 0xdf, 0x82, 0x75, 0x71, 0x38, 0x3f, 0xb1, 0xc8, 0x94, 0x5d, 0x24, 0x34, + 0x2f, 0xf0, 0x5b, 0xfb, 0x2e, 0xed, 0x76, 0x2e, 0x03, 0x92, 0xc7, 0x72, 0x8c, 0x29, 0xe8, 0x2f, + 0x87, 0x5e, 0x88, 0x39, 0x0a, 0x6b, 0x38, 0x6f, 0xc0, 0x28, 0xe3, 0x8d, 0x30, 0x8c, 0x6c, 0x08, + 0x41, 0xfa, 0xae, 0x17, 0x7a, 0x14, 0x79, 0xc4, 0xa5, 0xbf, 0x9d, 0x8b, 0x30, 0x16, 0x0d, 0xe5, + 0x10, 0x33, 0x30, 0xc0, 0x28, 0xd9, 0x14, 0xe5, 0xe3, 0x2d, 0xe7, 0x4d, 0x98, 0x64, 0xbf, 0x36, + 0x1b, 0x15, 0x32, 0xf9, 0x23, 0x43, 0xbd, 0x0e, 0x53, 0xaa, 0x80, 0xae, 0x73, 0xba, 0x0d, 0x36, + 0xe3, 0x5e, 0xc7, 0xed, 0xee, 0x58, 0x36, 0xa4, 0xd6, 0x71, 0x9b, 0x43, 0x91, 0x9f, 0xce, 0xa5, + 0xc8, 0xee, 0x74, 0x6c, 0x57, 0x98, 0xd8, 0xcc, 0xf7, 0xfd, 0xc0, 0xab, 0x75, 0x05, 0x72, 0xae, + 0x44, 0x16, 0xe0, 0xbc, 0x09, 0x83, 0xf5, 0x29, 0x06, 0xdb, 0x88, 0xd8, 0xcb, 0x7e, 0x50, 0xad, + 0x61, 0x7d, 0xfd, 0xad, 0xae, 0xeb, 0x6f, 0xb4, 0xe0, 0x62, 0x64, 0xc1, 0x48, 0xe2, 0x21, 0x4b, + 0x56, 0x02, 0x74, 0x2f, 0xd8, 0x6e, 0xb6, 0x1b, 0xc7, 0x70, 0xc0, 0xc8, 0xac, 0x29, 0x61, 0xd6, + 0xd7, 0x60, 0x52, 0x11, 0xd7, 0xd5, 0xb0, 0x25, 0x40, 0x77, 0xf1, 0x73, 0xc5, 0x56, 0xc4, 0x75, + 0xc5, 0x2e, 0xc0, 0x14, 0x57, 0xb4, 0x17, 0x5f, 0x9d, 0x82, 0xfe, 0x8d, 0x9a, 0xe7, 0x07, 0xdc, + 0xd4, 0xac, 0xe1, 0xac, 0xc1, 0xb4, 0x26, 0xa3, 0x1b, 0x24, 0xca, 0x41, 0xa6, 0xe8, 0x37, 0x76, + 0x71, 0x13, 0x57, 0xb8, 0xda, 0x71, 0xdb, 0x59, 0x85, 0x29, 0xae, 0x7b, 0x2f, 0xea, 0xc8, 0x92, + 0xfa, 0x34, 0x49, 0x45, 0x98, 0xd6, 0x24, 0x75, 0x55, 0x2a, 0x9e, 0x59, 0x4a, 0x9e, 0xd9, 0xd7, + 0x61, 0x8c, 0xcf, 0xec, 0x38, 0x76, 0xb9, 0x02, 0xe3, 0xf1, 0x68, 0x0e, 0xde, 0x6d, 0xee, 0x05, + 0x18, 0xe3, 0x1a, 0x1f, 0x7f, 0xd6, 0x17, 0x60, 0x3c, 0x96, 0x21, 0xe6, 0x6b, 0x98, 0x99, 0x70, + 0xd0, 0x1e, 0xa2, 0x39, 0x1f, 0x3b, 0x89, 0x1a, 0xce, 0xdd, 0x34, 0x11, 0x5e, 0xd8, 0x03, 0xc0, + 0xeb, 0xf1, 0xb2, 0xab, 0x00, 0x66, 0xbb, 0xe2, 0x58, 0x1d, 0x75, 0xbb, 0xe0, 0xa1, 0x60, 0xc5, + 0xa1, 0xd0, 0x6b, 0x0c, 0x99, 0x4d, 0xb4, 0x12, 0xbb, 0xb5, 0xb6, 0x87, 0xc8, 0xd3, 0x4e, 0x6b, + 0xd3, 0xde, 0x8b, 0x67, 0xf2, 0x9c, 0x74, 0xeb, 0xe6, 0x31, 0x57, 0x62, 0x1f, 0xd7, 0x34, 0x8c, + 0x27, 0x94, 0x96, 0x27, 0xe4, 0xc2, 0x78, 0xd9, 0xaf, 0x06, 0xc7, 0xd8, 0x64, 0xb2, 0x30, 0xb8, + 0xd1, 0xf4, 0x9f, 0x88, 0x8d, 0x26, 0x6a, 0x3a, 0x17, 0xc1, 0x16, 0x32, 0xbb, 0xee, 0x34, 0x2e, + 0x4c, 0x3c, 0xc6, 0x4d, 0x7f, 0xa7, 0x7d, 0x0c, 0xfc, 0x19, 0x18, 0xd8, 0x38, 0xd8, 0x12, 0xf0, + 0xbc, 0x45, 0x52, 0x92, 0x2c, 0xb3, 0x2b, 0xfe, 0x37, 0x60, 0x82, 0x68, 0x7a, 0xdc, 0x94, 0x7c, + 0x19, 0x90, 0x3c, 0xbc, 0x2b, 0xd4, 0x9b, 0x30, 0xc9, 0xd4, 0x3a, 0x41, 0xfe, 0x57, 0x05, 0x74, + 0x85, 0xe3, 0x6b, 0xd0, 0x43, 0x9c, 0x2d, 0x33, 0x1b, 0xa8, 0x41, 0x36, 0x07, 0x43, 0x84, 0xe8, + 0x85, 0x07, 0x4d, 0xcc, 0xb5, 0x10, 0x04, 0x67, 0x35, 0x32, 0xf1, 0xe1, 0xe2, 0x0f, 0x91, 0x34, + 0x1d, 0x59, 0x45, 0x81, 0x77, 0x6e, 0xc2, 0x30, 0xe1, 0x39, 0x8e, 0x91, 0x46, 0xd8, 0x40, 0xd3, + 0x3c, 0x52, 0x3a, 0xfa, 0x3b, 0x30, 0xca, 0xd0, 0x8f, 0x0c, 0x74, 0x88, 0x60, 0x1b, 0xc6, 0x22, + 0xc1, 0x7c, 0x46, 0xbb, 0xcc, 0xca, 0xea, 0x06, 0x20, 0x85, 0x90, 0xa5, 0x84, 0x50, 0xaf, 0x31, + 0x10, 0x69, 0x96, 0x92, 0x4c, 0x90, 0x67, 0x4e, 0xa9, 0x45, 0xbf, 0xa2, 0x6f, 0x5a, 0xd7, 0xf7, + 0x63, 0x2b, 0x5a, 0x07, 0x55, 0x41, 0x11, 0x63, 0x96, 0x1c, 0x63, 0x27, 0x50, 0xef, 0x10, 0x45, + 0x66, 0x22, 0x27, 0x57, 0xd5, 0x77, 0x3e, 0x4f, 0x01, 0x8a, 0xbe, 0x1b, 0xa4, 0x13, 0x6d, 0x8f, + 0x87, 0xc1, 0x9f, 0x5a, 0x30, 0xfa, 0x08, 0xef, 0x37, 0x6a, 0x5e, 0x88, 0x0b, 0xed, 0x10, 0xb7, + 0xb2, 0x7d, 0x0b, 0xa9, 0x8b, 0xc3, 0xf9, 0x2b, 0xd1, 0x80, 0xa4, 0xe8, 0x45, 0x85, 0xff, 0x5e, + 0x10, 0x36, 0xdb, 0x85, 0x9b, 0x1f, 0xfd, 0xfd, 0xdc, 0x4a, 0xd5, 0x0f, 0x77, 0x0f, 0xb6, 0x16, + 0xfd, 0xad, 0xfd, 0xc5, 0xed, 0xfa, 0xfe, 0xd2, 0x7b, 0x9e, 0x57, 0x5e, 0x62, 0x52, 0x96, 0xaa, + 0x5c, 0x4a, 0x65, 0x89, 0x0a, 0xbd, 0x13, 0x86, 0x4d, 0x7f, 0xeb, 0x20, 0xc4, 0xae, 0x0a, 0x8e, + 0x3e, 0x84, 0x4c, 0x44, 0xc8, 0x0e, 0x50, 0x45, 0x2e, 0xf6, 0xa0, 0xc8, 0x09, 0x75, 0x88, 0x21, + 0x73, 0xdf, 0x02, 0x94, 0x9c, 0x1c, 0x49, 0x46, 0x7b, 0x7c, 0x9d, 0xd3, 0x2e, 0xf9, 0x49, 0x82, + 0xe1, 0x89, 0x57, 0x3b, 0x88, 0xa2, 0x96, 0x35, 0x6e, 0xf7, 0xdd, 0xb2, 0x72, 0x65, 0x61, 0xce, + 0x4e, 0x83, 0x5f, 0x97, 0x07, 0x0f, 0xe7, 0x67, 0xa2, 0x09, 0xc6, 0x0a, 0x3d, 0x26, 0xbd, 0x92, + 0x50, 0xa7, 0x01, 0x93, 0xca, 0xec, 0x45, 0x62, 0x5d, 0xc7, 0x6d, 0xb6, 0x6a, 0x3c, 0xb1, 0x46, + 0x6d, 0x9a, 0x07, 0x77, 0xf1, 0xf6, 0x5e, 0xf9, 0x60, 0x3f, 0xdb, 0xcf, 0xf3, 0x20, 0x6f, 0xa3, + 0xf3, 0x2c, 0xb9, 0x0e, 0x52, 0xf8, 0xf1, 0x08, 0x9e, 0x0c, 0xad, 0xd5, 0xb7, 0xd8, 0xa1, 0xf8, + 0x07, 0x19, 0xf1, 0x31, 0xba, 0x8e, 0xdb, 0x1b, 0x9e, 0xdf, 0x3c, 0xa2, 0x63, 0xfd, 0xca, 0x82, + 0x49, 0x16, 0x12, 0x26, 0xf7, 0xba, 0x69, 0x58, 0x55, 0x09, 0x64, 0xd1, 0x30, 0xf2, 0x84, 0x8b, + 0x6c, 0x52, 0x06, 0xfd, 0xda, 0x82, 0x29, 0xbe, 0xaf, 0xa8, 0x5a, 0xa6, 0xa8, 0x96, 0xb7, 0x0e, + 0xd3, 0xd2, 0x30, 0xf4, 0x84, 0x6a, 0x1a, 0xd5, 0x41, 0x3f, 0xb3, 0x60, 0x5c, 0xeb, 0xc8, 0x0e, + 0x52, 0x15, 0x57, 0x8e, 0xa6, 0xe2, 0x09, 0xb5, 0xd3, 0x95, 0x40, 0x9f, 0x5a, 0x30, 0xa6, 0x1a, + 0x36, 0x9b, 0xa1, 0x7a, 0xe5, 0x8f, 0xb4, 0xc0, 0x27, 0x54, 0x4b, 0x53, 0x21, 0x77, 0x1f, 0xb2, + 0x9d, 0x1c, 0xe8, 0x48, 0xc1, 0xfc, 0x00, 0x66, 0x3b, 0x2e, 0xf1, 0x91, 0x04, 0xbd, 0x97, 0x70, + 0xb3, 0xe7, 0xb6, 0x39, 0xe4, 0xde, 0xd5, 0xe3, 0xec, 0xf9, 0xed, 0x3b, 0x7f, 0xb0, 0xe0, 0x74, + 0x62, 0xfd, 0xf8, 0xe6, 0xe3, 0xc0, 0x08, 0x9f, 0x12, 0x8b, 0x18, 0xb6, 0xc9, 0x28, 0x34, 0xb4, + 0x00, 0xc3, 0x4c, 0x35, 0xc6, 0x32, 0x40, 0x59, 0x64, 0x12, 0xba, 0x24, 0xd2, 0xfc, 0x90, 0x79, + 0x3b, 0x8a, 0xf3, 0xfe, 0x85, 0x38, 0xe1, 0x82, 0x99, 0x33, 0x3a, 0xe5, 0xb6, 0x60, 0xec, 0x9d, + 0xa6, 0xd7, 0x90, 0x72, 0x61, 0xf2, 0x6b, 0x82, 0x52, 0xd6, 0xc5, 0xcd, 0xce, 0x3a, 0xc9, 0xe7, + 0x25, 0x6f, 0x5b, 0x3a, 0x33, 0xb3, 0x56, 0xbc, 0xdd, 0xa5, 0xbb, 0x5f, 0xaa, 0xbd, 0x06, 0xe3, + 0x31, 0x28, 0xb7, 0x50, 0x16, 0x06, 0x09, 0xa9, 0x81, 0x2b, 0xdc, 0x38, 0x51, 0xd3, 0xf9, 0x65, + 0x1a, 0xec, 0xcd, 0xe0, 0x03, 0x55, 0x49, 0x89, 0xdd, 0x52, 0xd8, 0x8f, 0xa1, 0x6c, 0x7f, 0xf7, + 0xbd, 0xf9, 0x93, 0x44, 0xd2, 0x67, 0xb9, 0xf6, 0xb5, 0x68, 0x80, 0xae, 0xdc, 0x8b, 0x4c, 0xf9, + 0xdf, 0x93, 0x52, 0xfe, 0x10, 0x55, 0xe3, 0xd5, 0x43, 0xd5, 0xf8, 0xaa, 0x27, 0xfc, 0x8f, 0x2d, + 0x98, 0x90, 0x26, 0xcf, 0x1d, 0xea, 0x55, 0x18, 0x63, 0xc4, 0x06, 0xae, 0xb0, 0x65, 0x1b, 0xa4, + 0xda, 0x68, 0x54, 0x25, 0xf7, 0x67, 0xb4, 0xdc, 0x7f, 0x05, 0x86, 0x62, 0xee, 0x4e, 0x81, 0x24, + 0x38, 0x9c, 0x1f, 0xa7, 0xc1, 0xbe, 0x8b, 0x9b, 0xfe, 0x93, 0x63, 0x1c, 0x2d, 0x3f, 0xe9, 0x70, + 0xb4, 0x8c, 0xbd, 0x4c, 0x17, 0xfc, 0x22, 0xbd, 0x2c, 0x0b, 0x83, 0x05, 0xaf, 0x85, 0xa5, 0x4f, + 0x72, 0xde, 0x8c, 0x4f, 0xe2, 0x69, 0xe9, 0x24, 0x2e, 0xfb, 0x64, 0x46, 0xf5, 0xc9, 0x8e, 0x4a, + 0x7f, 0xd5, 0x7d, 0xf2, 0x19, 0x4c, 0x48, 0x73, 0xe7, 0x2e, 0xb9, 0x00, 0xc3, 0x0f, 0xf1, 0x07, + 0xfa, 0x0e, 0x2f, 0x91, 0x14, 0x67, 0x1c, 0xd4, 0x9c, 0xf1, 0x02, 0x0c, 0x30, 0xd6, 0x4e, 0x9b, + 0x3f, 0xef, 0x76, 0x66, 0x49, 0x1e, 0x0a, 0x63, 0x07, 0x7b, 0xcb, 0x8f, 0x1f, 0x24, 0x1c, 0x1f, + 0xb2, 0xc9, 0x2e, 0xae, 0x5d, 0x09, 0xfa, 0x49, 0x07, 0x73, 0xbc, 0x74, 0xe1, 0xe6, 0x97, 0x9f, + 0x1d, 0x65, 0x6d, 0x84, 0x3f, 0x33, 0x29, 0xce, 0x8e, 0xaa, 0xc5, 0x5a, 0xb0, 0x53, 0x8f, 0x42, + 0x62, 0x5d, 0xfa, 0xea, 0x3b, 0x01, 0x10, 0xcb, 0x25, 0x25, 0x75, 0x4a, 0x0c, 0x87, 0x4f, 0x69, + 0x19, 0x32, 0xa4, 0x83, 0xd0, 0xa8, 0x23, 0x0f, 0xe7, 0xa7, 0x13, 0xf1, 0x47, 0x07, 0xc4, 0x6c, + 0xce, 0xbf, 0x52, 0x54, 0x9e, 0xb6, 0xb2, 0xe2, 0x33, 0xf6, 0xed, 0xad, 0xef, 0xe2, 0xed, 0x30, + 0xfa, 0x8c, 0x65, 0x2d, 0xf4, 0x73, 0x0b, 0xc6, 0xe3, 0x11, 0x2d, 0x39, 0x7c, 0xaf, 0x8b, 0x93, + 0x9d, 0x59, 0xe6, 0xa2, 0x36, 0xee, 0xa4, 0x67, 0x4e, 0x4d, 0x1c, 0xfa, 0x89, 0x05, 0x20, 0x68, + 0xfc, 0xa8, 0x7e, 0xf5, 0x08, 0x5a, 0x9d, 0x50, 0x21, 0x09, 0x3c, 0x57, 0x80, 0x29, 0xd3, 0x6c, + 0x8f, 0x14, 0xad, 0x9b, 0xb2, 0xa5, 0x9f, 0x5f, 0xbc, 0xfe, 0xdb, 0x82, 0x59, 0x83, 0x31, 0xb8, + 0x1f, 0xfd, 0xa2, 0xe3, 0xfa, 0xde, 0xe8, 0x62, 0x49, 0x36, 0xf8, 0x05, 0x2f, 0xf0, 0xf3, 0x30, + 0x2a, 0x75, 0xfa, 0xf2, 0x0b, 0x70, 0xfa, 0xf2, 0xff, 0xa4, 0xd3, 0x97, 0xff, 0xef, 0xf4, 0x6c, + 0xd9, 0x57, 0x60, 0xb6, 0xdc, 0xd1, 0xe7, 0x3b, 0x2c, 0xbb, 0xf3, 0xdb, 0x14, 0x0c, 0xc5, 0x9b, + 0x27, 0xda, 0x94, 0x1a, 0x4c, 0x99, 0xe3, 0xef, 0xe7, 0x92, 0xd8, 0x05, 0x80, 0x0d, 0xaf, 0xe9, + 0xed, 0xe3, 0x10, 0x37, 0x0b, 0xcc, 0x1e, 0xab, 0xa7, 0x5c, 0x89, 0x86, 0xee, 0x80, 0xed, 0x96, + 0xef, 0xbc, 0x7d, 0xe7, 0xde, 0x46, 0x4c, 0xe4, 0x5b, 0xfc, 0x64, 0x34, 0x71, 0xd1, 0xbf, 0xbf, + 0x7a, 0xca, 0x4d, 0xb0, 0xa3, 0x6f, 0xc2, 0xb8, 0x5b, 0xbe, 0xb3, 0x51, 0x2e, 0x0b, 0x09, 0xec, + 0xbb, 0x05, 0x49, 0x12, 0x58, 0x37, 0x11, 0xa0, 0x33, 0xa3, 0x12, 0x4c, 0xdd, 0x2b, 0xde, 0x5d, + 0x5d, 0x66, 0x89, 0x5e, 0x08, 0x61, 0xdf, 0x13, 0xa7, 0x23, 0x21, 0x2a, 0x0f, 0x91, 0x64, 0x1c, + 0x86, 0x1e, 0x00, 0x2a, 0x3c, 0x2a, 0xea, 0xc2, 0x06, 0xd4, 0xb4, 0x25, 0x73, 0x10, 0x51, 0x86, + 0x21, 0x85, 0x61, 0x18, 0x8a, 0x1b, 0x0e, 0x86, 0x51, 0x25, 0xd5, 0xa1, 0x79, 0x80, 0x92, 0x1f, + 0xac, 0xe3, 0x76, 0xd9, 0x7f, 0x86, 0xb9, 0xff, 0x48, 0x14, 0xda, 0xef, 0x3d, 0x8d, 0xfa, 0xfb, + 0x78, 0x7f, 0x4c, 0x21, 0x5e, 0x7a, 0xbf, 0xe6, 0x55, 0x5b, 0xd4, 0xda, 0x69, 0x97, 0x35, 0x9c, + 0x1f, 0x59, 0x30, 0xfc, 0x80, 0xaa, 0x78, 0xaf, 0xd9, 0xac, 0x37, 0xd1, 0x2a, 0xa4, 0x8b, 0xf5, + 0x0a, 0x97, 0x5f, 0xb8, 0xf6, 0xe5, 0x67, 0xe7, 0xae, 0xf6, 0xee, 0x12, 0x2e, 0x0e, 0x0f, 0x9a, + 0x81, 0x4b, 0x25, 0xd0, 0x47, 0x75, 0x1c, 0x7a, 0x7e, 0x8d, 0xea, 0x32, 0xe4, 0xf2, 0x16, 0xd1, + 0xc3, 0xc5, 0x61, 0x93, 0x9d, 0x50, 0x33, 0x2e, 0x6b, 0x38, 0xbf, 0x4b, 0xc1, 0xb0, 0xb4, 0xee, + 0xa8, 0x0c, 0x99, 0x55, 0xaf, 0xb5, 0x1b, 0x9f, 0xc0, 0x4f, 0xe0, 0x9e, 0xb1, 0x20, 0x74, 0x19, + 0x52, 0xa5, 0xea, 0x0e, 0xd5, 0x67, 0x2c, 0x9f, 0x35, 0xb8, 0xdb, 0x62, 0xc9, 0x6b, 0xed, 0xb9, + 0x84, 0x09, 0xad, 0x82, 0x7d, 0x2f, 0xd8, 0xae, 0x57, 0xfc, 0xa0, 0x4a, 0x7a, 0x1e, 0xb5, 0x1b, + 0xec, 0x9a, 0x7f, 0x2c, 0x3f, 0x67, 0x1a, 0x18, 0xf1, 0xb8, 0x89, 0x51, 0xc8, 0x81, 0x11, 0x99, + 0xc6, 0x8f, 0xe0, 0x0a, 0xcd, 0x09, 0x21, 0x4d, 0xa0, 0xd1, 0x38, 0x0c, 0x17, 0xf7, 0xaa, 0xa5, + 0xea, 0xce, 0xf2, 0xc3, 0x7a, 0x80, 0xed, 0x53, 0x12, 0xa1, 0xbc, 0xeb, 0x2d, 0xdb, 0x16, 0x9a, + 0x80, 0x51, 0x41, 0xc8, 0x5f, 0xbf, 0x61, 0xf7, 0xa9, 0xa4, 0x95, 0x5b, 0xd7, 0xec, 0x94, 0x4a, + 0xba, 0xbe, 0x9c, 0xb7, 0xd3, 0xda, 0xc0, 0xfc, 0x35, 0xbb, 0xdf, 0x79, 0x03, 0x32, 0xb1, 0x96, + 0x33, 0x80, 0x8a, 0x7b, 0xcf, 0x1e, 0xd6, 0xc9, 0x97, 0x41, 0xb9, 0x81, 0xb7, 0xfd, 0x1d, 0x1f, + 0x57, 0xec, 0x53, 0x68, 0x1a, 0x26, 0x8a, 0x7b, 0xcf, 0x24, 0x2a, 0x21, 0x5b, 0xce, 0x6f, 0xfa, + 0x00, 0x44, 0x94, 0xbd, 0x98, 0xe5, 0xba, 0x24, 0x2f, 0xd7, 0xe9, 0x64, 0x6c, 0x4b, 0xab, 0xf5, + 0x32, 0x8c, 0x96, 0xbd, 0x5a, 0x48, 0xb6, 0xe9, 0x62, 0xfd, 0x20, 0x08, 0xb9, 0x93, 0xab, 0xc4, + 0xff, 0x92, 0x95, 0xff, 0xd4, 0x07, 0xe3, 0xda, 0x5e, 0x82, 0xde, 0x84, 0xd4, 0x7a, 0x65, 0x87, + 0x9a, 0x6a, 0x4c, 0xbc, 0x42, 0x68, 0x5c, 0xe4, 0x03, 0x81, 0xb6, 0x68, 0xad, 0xd5, 0xfd, 0x83, + 0x60, 0x9b, 0xfc, 0xef, 0x92, 0x91, 0x24, 0xda, 0xcb, 0xbb, 0x5e, 0x13, 0x57, 0xa4, 0x87, 0x29, + 0x89, 0x42, 0xfa, 0x37, 0x0e, 0xb6, 0x6a, 0xfe, 0xb6, 0xf4, 0xfe, 0x22, 0x51, 0x9c, 0xdf, 0x5b, + 0x30, 0x6d, 0x14, 0xcf, 0x6c, 0x51, 0x79, 0x58, 0x0f, 0x37, 0x5b, 0xb8, 0x72, 0xd5, 0x3e, 0x85, + 0x86, 0x61, 0x90, 0x10, 0x0e, 0x6a, 0x35, 0xdb, 0x42, 0x63, 0x00, 0xc5, 0xbd, 0x0a, 0xb1, 0xd2, + 0x7a, 0x65, 0xc7, 0xee, 0x53, 0xb9, 0x57, 0xec, 0x94, 0x4a, 0xb8, 0x66, 0xa7, 0x91, 0x0d, 0x23, + 0x6c, 0x44, 0x3e, 0x7f, 0x8d, 0x8c, 0xe9, 0x97, 0x28, 0xd7, 0x6f, 0x10, 0xca, 0x80, 0xa0, 0xac, + 0xdc, 0xa2, 0x3c, 0x83, 0x82, 0x72, 0x7d, 0x39, 0x4f, 0x28, 0x19, 0xe7, 0xa3, 0x14, 0x8c, 0x2a, + 0xbb, 0x28, 0xba, 0x09, 0x69, 0x1a, 0x96, 0xcc, 0x8a, 0x2f, 0x19, 0xb7, 0x5a, 0xd1, 0xa2, 0xd1, + 0x49, 0x07, 0x10, 0x6f, 0x29, 0xee, 0xfa, 0xb5, 0xca, 0x3a, 0x6e, 0xaf, 0x05, 0x15, 0xfc, 0x94, + 0xef, 0x96, 0x2a, 0x11, 0xcd, 0xc1, 0x50, 0x71, 0xd7, 0xf3, 0x03, 0xba, 0x1f, 0xf2, 0x17, 0xbe, + 0x98, 0x40, 0x3e, 0xb5, 0x1f, 0xe3, 0x66, 0xcb, 0xaf, 0xb3, 0xf7, 0xf4, 0xb4, 0x1b, 0x35, 0x9d, + 0xbf, 0x59, 0x92, 0xa2, 0x14, 0x6f, 0x0a, 0xec, 0xe2, 0x5e, 0x61, 0x6d, 0xe3, 0xea, 0xd5, 0x95, + 0x3c, 0xb7, 0x8c, 0x7d, 0x4a, 0xa1, 0x6e, 0xb8, 0x8f, 0xc9, 0x3f, 0xdb, 0x4a, 0x52, 0x37, 0x0b, + 0x76, 0x9f, 0x4a, 0xdd, 0x2c, 0x50, 0x6a, 0x4a, 0xa1, 0x96, 0xee, 0x94, 0x1f, 0xdd, 0x73, 0xd7, + 0xed, 0x34, 0x8b, 0xd8, 0xf2, 0x5b, 0x84, 0xbc, 0x7c, 0x35, 0x12, 0xdc, 0x6f, 0x20, 0x6f, 0x16, + 0xec, 0x01, 0x8d, 0xcc, 0x45, 0x0f, 0xaa, 0xe4, 0x48, 0x76, 0xc6, 0xf9, 0x1a, 0x8c, 0xaf, 0x96, + 0xee, 0x14, 0xd9, 0x75, 0x69, 0x8d, 0xae, 0xc2, 0x45, 0x18, 0x67, 0xfb, 0xbe, 0x08, 0x3e, 0xb2, + 0x20, 0xa3, 0xae, 0x4e, 0x76, 0xf2, 0x60, 0xbb, 0x58, 0x2b, 0x9d, 0x99, 0x07, 0xe0, 0x17, 0x80, + 0xe2, 0xee, 0x52, 0xa2, 0x38, 0x37, 0x61, 0x42, 0x1a, 0x23, 0x6e, 0x65, 0x5d, 0xfc, 0x81, 0x3e, + 0x4c, 0xa1, 0x39, 0x37, 0x60, 0x8a, 0xb5, 0xa3, 0xaf, 0xec, 0x1e, 0x01, 0x77, 0x60, 0x5a, 0x1b, + 0xd7, 0x3b, 0x28, 0xba, 0x04, 0x83, 0x7c, 0x18, 0x3f, 0xcc, 0x25, 0x2f, 0x7a, 0xf9, 0x0f, 0xe7, + 0x87, 0x16, 0x8c, 0xa9, 0x27, 0x38, 0x72, 0x78, 0x8a, 0x29, 0x05, 0x26, 0x9f, 0x1c, 0x9e, 0x04, + 0x0d, 0x39, 0x30, 0x1c, 0xb7, 0x1e, 0xdd, 0xa7, 0x18, 0x99, 0xd5, 0x53, 0xae, 0x4c, 0x54, 0xa4, + 0xac, 0x51, 0xbf, 0x4d, 0x29, 0x52, 0xd6, 0x0a, 0x00, 0x99, 0x7a, 0x80, 0xbf, 0xe3, 0x85, 0x61, + 0xd3, 0xf9, 0x63, 0x5f, 0xac, 0x32, 0x71, 0x78, 0xfe, 0x73, 0xed, 0x2e, 0x9f, 0x9e, 0x20, 0xc8, + 0x0e, 0x4f, 0x70, 0x53, 0xb1, 0xc3, 0x23, 0x04, 0xe9, 0x47, 0x4f, 0xd7, 0xee, 0x46, 0xaf, 0xbc, + 0xe4, 0x37, 0x7a, 0xaa, 0x1c, 0xe4, 0xd3, 0xf4, 0x20, 0x7f, 0x4e, 0x33, 0xc6, 0x0b, 0x39, 0xb7, + 0x47, 0xef, 0x85, 0xb5, 0xfa, 0x56, 0x2b, 0xdb, 0xbf, 0x90, 0x8a, 0xde, 0x0b, 0x49, 0xfb, 0x05, + 0x9d, 0xc7, 0xf3, 0xff, 0x3c, 0x07, 0x03, 0x45, 0xe2, 0xa1, 0x75, 0x74, 0x00, 0x63, 0x6a, 0x79, + 0x2b, 0x3a, 0xab, 0xbf, 0x11, 0x29, 0x15, 0xb2, 0xb9, 0xf9, 0x4e, 0xdd, 0xfc, 0xe1, 0xfb, 0xe5, + 0x8f, 0xfe, 0xfa, 0x8f, 0x4f, 0xfb, 0xe6, 0x9d, 0xd9, 0xa5, 0x27, 0xcb, 0x4b, 0x34, 0x0c, 0xea, + 0x4b, 0x2a, 0xeb, 0x6d, 0xeb, 0x32, 0xc2, 0x00, 0xa2, 0xda, 0x15, 0xcd, 0xc6, 0xd7, 0x78, 0x7a, + 0xf5, 0x6c, 0x2e, 0x67, 0xea, 0xe2, 0x50, 0x0b, 0x14, 0x2a, 0xe7, 0x4c, 0x4b, 0x50, 0x82, 0x8d, + 0xc0, 0x6c, 0x46, 0x85, 0x92, 0x68, 0x5a, 0x95, 0x13, 0x89, 0x9f, 0xd1, 0xc9, 0x5c, 0xf4, 0x1c, + 0x15, 0x3d, 0xe3, 0x4c, 0x24, 0x44, 0x13, 0xb1, 0xfb, 0x30, 0x22, 0x57, 0xb6, 0xa2, 0x33, 0xaa, + 0x14, 0xa5, 0x60, 0x26, 0x37, 0x67, 0xee, 0xe4, 0x40, 0x0e, 0x05, 0x9a, 0x73, 0x4e, 0x27, 0x80, + 0x18, 0x23, 0x81, 0xf3, 0x60, 0x28, 0x2e, 0x6f, 0x45, 0x59, 0x55, 0x9c, 0xb8, 0xf2, 0xcc, 0xcd, + 0x1a, 0x7a, 0x38, 0xca, 0x39, 0x8a, 0x32, 0xeb, 0x4c, 0x25, 0x50, 0xd6, 0x71, 0x9b, 0x40, 0xf8, + 0x30, 0x2c, 0x95, 0xba, 0x22, 0xcd, 0xea, 0x72, 0xd5, 0x4c, 0xee, 0x8c, 0xb1, 0x8f, 0x03, 0x9d, + 0xa7, 0x40, 0x67, 0x9c, 0x99, 0x04, 0x10, 0xe5, 0x53, 0x8c, 0xc7, 0x2a, 0x26, 0x74, 0xe3, 0x29, + 0xf5, 0x1c, 0xba, 0xf1, 0xb4, 0x22, 0x8b, 0xce, 0xc6, 0x63, 0x8c, 0x7c, 0x66, 0x52, 0x11, 0xab, + 0x98, 0x59, 0xb2, 0x50, 0x56, 0xcc, 0xcc, 0x50, 0xf5, 0x6a, 0x9c, 0x99, 0xc4, 0x17, 0x19, 0x11, + 0x1b, 0xa0, 0x92, 0x75, 0xb1, 0x92, 0x11, 0x71, 0x6f, 0x50, 0x12, 0x1f, 0x81, 0x7a, 0x1f, 0x46, + 0x95, 0x6a, 0x55, 0x34, 0xa7, 0xe9, 0xae, 0xfa, 0xe0, 0xd9, 0x0e, 0xbd, 0x1c, 0xf0, 0x25, 0x0a, + 0x78, 0xd6, 0xc9, 0x26, 0xe7, 0x26, 0xbc, 0xf0, 0x7d, 0x18, 0x55, 0x6a, 0x51, 0x05, 0xa4, 0xa9, + 0xd8, 0x55, 0x40, 0x1a, 0x0b, 0x58, 0x8d, 0x90, 0x0a, 0x27, 0x81, 0x7c, 0x17, 0x06, 0xb9, 0x1a, + 0x68, 0x46, 0x9b, 0x41, 0x04, 0x73, 0x3a, 0x41, 0xe7, 0x00, 0x67, 0x29, 0xc0, 0x69, 0x07, 0x25, + 0xe7, 0xc4, 0x45, 0x73, 0x38, 0x21, 0x5a, 0x2d, 0x5c, 0x15, 0xa2, 0xb5, 0x62, 0x54, 0xa3, 0x68, + 0xce, 0xc3, 0x1d, 0x5c, 0x2e, 0x34, 0x45, 0xba, 0x5b, 0x29, 0xd1, 0x34, 0x67, 0xee, 0xec, 0xe2, + 0xe0, 0x32, 0x63, 0x14, 0x4f, 0xd8, 0x04, 0x67, 0xa8, 0x5c, 0xcd, 0xcd, 0x99, 0x3b, 0xbb, 0xc5, + 0x13, 0x56, 0xe1, 0x84, 0xe7, 0xf1, 0xf8, 0xd5, 0x67, 0xa0, 0x06, 0xf0, 0xd9, 0x0e, 0xbd, 0x87, + 0x7b, 0x9e, 0x08, 0x61, 0xe1, 0x79, 0x3a, 0xa4, 0xa9, 0x4a, 0x35, 0xe1, 0x79, 0x3d, 0x40, 0x2a, + 0x9c, 0x04, 0xf2, 0xdb, 0x90, 0x89, 0x2a, 0x42, 0x51, 0xec, 0x07, 0x5a, 0xdd, 0x69, 0x2e, 0x9b, + 0xec, 0xe0, 0x18, 0xf3, 0x14, 0x23, 0xeb, 0x4c, 0x4a, 0x18, 0x11, 0x13, 0x4f, 0x7f, 0xa2, 0xe4, + 0x53, 0xa4, 0xbf, 0x44, 0x69, 0xa9, 0x48, 0x7f, 0xc9, 0x0a, 0x51, 0x63, 0xfa, 0x13, 0x6c, 0x1c, + 0x46, 0x94, 0x7b, 0x0a, 0x98, 0x44, 0x05, 0xa9, 0x80, 0x49, 0x56, 0x87, 0x1a, 0x61, 0x04, 0x1b, + 0xf7, 0x40, 0xb9, 0xd0, 0x53, 0x78, 0xa0, 0xa1, 0x7e, 0x54, 0x78, 0xa0, 0xa9, 0x36, 0xd4, 0xe8, + 0x81, 0x32, 0x23, 0x4f, 0x87, 0x71, 0xfd, 0x27, 0x52, 0xd6, 0x40, 0x71, 0xf5, 0x59, 0x43, 0x4f, + 0x97, 0x74, 0x18, 0x73, 0xf1, 0x9d, 0x5c, 0xaa, 0xf2, 0x44, 0xda, 0x2a, 0x98, 0xd3, 0xa1, 0xa9, + 0x2c, 0xd4, 0xb4, 0x93, 0x4b, 0x7c, 0x04, 0xaa, 0x04, 0x69, 0x02, 0x8d, 0x26, 0x65, 0x75, 0x23, + 0xe1, 0x53, 0x2a, 0x91, 0x4b, 0xcd, 0x51, 0xa9, 0x53, 0xce, 0xb8, 0xa6, 0x3e, 0x3f, 0xf1, 0x30, + 0x00, 0x71, 0xe2, 0x51, 0x2a, 0x46, 0xc5, 0x89, 0x47, 0xab, 0xf7, 0x34, 0x9d, 0x78, 0x18, 0x8b, + 0xe4, 0x49, 0x3c, 0xfe, 0x14, 0xd3, 0xaa, 0xc1, 0x97, 0x33, 0x75, 0x1d, 0xe2, 0x49, 0x22, 0xec, + 0x62, 0x4f, 0xd2, 0xcf, 0x06, 0x86, 0x5a, 0x4f, 0xdd, 0x93, 0x7a, 0x38, 0x1b, 0xc8, 0x8c, 0x7c, + 0x99, 0xa5, 0x42, 0x1a, 0xb1, 0xcc, 0xc9, 0xa2, 0x46, 0xb1, 0xcc, 0x86, 0x92, 0x3f, 0xe3, 0x32, + 0x4b, 0x7c, 0x04, 0xaa, 0x0d, 0xe3, 0x5a, 0xcd, 0x0e, 0x9a, 0xef, 0x5e, 0x8c, 0x95, 0x3b, 0xd7, + 0xb1, 0x9f, 0xc3, 0xbe, 0x42, 0x61, 0xcf, 0x39, 0x39, 0x33, 0x2c, 0xe1, 0xe5, 0xa9, 0x8e, 0x17, + 0xc1, 0x88, 0x54, 0xa7, 0x96, 0xe2, 0x88, 0x54, 0xa7, 0x55, 0xcb, 0x18, 0x53, 0x1d, 0xe7, 0xe1, + 0xa1, 0x18, 0x17, 0x44, 0x88, 0x50, 0xd4, 0x0b, 0x44, 0x44, 0x28, 0x26, 0xaa, 0x27, 0x8c, 0xa1, + 0x18, 0x73, 0x45, 0x87, 0xdf, 0xe8, 0x81, 0x5b, 0x3a, 0xfc, 0x6a, 0xef, 0xfd, 0xd2, 0xe1, 0x57, + 0x7f, 0x0d, 0x37, 0x1f, 0x7e, 0x23, 0x2e, 0x02, 0xf1, 0x21, 0xd8, 0xfa, 0x63, 0x35, 0x92, 0x8c, + 0x6f, 0x7c, 0xe1, 0xce, 0x2d, 0x74, 0x66, 0xe0, 0xb8, 0xaf, 0x52, 0xdc, 0x05, 0xe7, 0x8c, 0xb2, + 0x3c, 0x2a, 0xb3, 0x01, 0x9e, 0x5e, 0x9e, 0x1b, 0xe1, 0xa5, 0xa7, 0x6d, 0x33, 0xbc, 0xfc, 0x26, + 0x7d, 0x28, 0x3c, 0x61, 0x26, 0xf0, 0xdf, 0xb7, 0x60, 0x22, 0xf1, 0xa8, 0x88, 0x16, 0x0e, 0x7b, + 0xb9, 0xcd, 0x9d, 0x3f, 0xf4, 0x45, 0xd2, 0xb9, 0x40, 0x55, 0x38, 0xef, 0xcc, 0xa9, 0x2a, 0xa8, + 0xdc, 0x91, 0x0e, 0xe5, 0xce, 0x3a, 0x94, 0x0f, 0xd5, 0xa1, 0x7c, 0x24, 0x1d, 0xca, 0x26, 0x1d, + 0x5a, 0x30, 0xaa, 0x5c, 0xa4, 0x88, 0x53, 0x86, 0xe9, 0x5e, 0x46, 0x9c, 0x32, 0x8c, 0xb7, 0x2f, + 0x71, 0x6c, 0x9e, 0x25, 0xb0, 0x95, 0xfa, 0xbe, 0xe7, 0x07, 0x5e, 0x65, 0xdf, 0x0f, 0x96, 0x9a, + 0x94, 0x7d, 0x0f, 0xb7, 0xb7, 0x08, 0xc6, 0x36, 0x0c, 0xc5, 0xd7, 0x45, 0xc2, 0xbb, 0xf5, 0x5b, + 0x27, 0xe1, 0xdd, 0x89, 0xbb, 0xa5, 0x78, 0xef, 0x99, 0x4d, 0x02, 0x61, 0xc6, 0x5a, 0xb8, 0xfc, + 0xe7, 0x2f, 0xe6, 0xad, 0xbf, 0x7c, 0x31, 0x6f, 0x7d, 0xfe, 0xc5, 0xbc, 0x05, 0xb9, 0xed, 0xfa, + 0x3e, 0xbb, 0xad, 0xa0, 0xc6, 0x88, 0x24, 0x57, 0x9b, 0x8d, 0xed, 0x0d, 0x6b, 0x6b, 0x80, 0xfe, + 0x81, 0xec, 0xca, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x79, 0x6d, 0x36, 0x62, 0x3b, 0x00, + 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// CryptoClient is the client API for Crypto service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type CryptoClient interface { + // CK_RV m_GenerateRandom ( + // CK_BYTE_PTR rnd, CK_ULONG rndlen, + // target_t target) ; + GenerateRandom(ctx context.Context, in *GenerateRandomRequest, opts ...grpc.CallOption) (*GenerateRandomResponse, error) + // CK_RV m_DigestInit ( + // unsigned char *state, size_t *statelen, + // const CK_MECHANISM_PTR mech, + // target_t target) ; + DigestInit(ctx context.Context, in *DigestInitRequest, opts ...grpc.CallOption) (*DigestInitResponse, error) + // CK_RV m_Digest ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, + // target_t target) ; + Digest(ctx context.Context, in *DigestRequest, opts ...grpc.CallOption) (*DigestResponse, error) + // CK_RV m_DigestUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // target_t target) ; + DigestUpdate(ctx context.Context, in *DigestUpdateRequest, opts ...grpc.CallOption) (*DigestUpdateResponse, error) + // CK_RV m_DigestKey ( + // unsigned char *state, size_t statelen, + // const unsigned char *key, size_t keylen, + // target_t target) ; + DigestKey(ctx context.Context, in *DigestKeyRequest, opts ...grpc.CallOption) (*DigestKeyResponse, error) + // CK_RV m_DigestFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, + // target_t target) ; + DigestFinal(ctx context.Context, in *DigestFinalRequest, opts ...grpc.CallOption) (*DigestFinalResponse, error) + // CK_RV m_DigestSingle ( + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, + // target_t target) ; + DigestSingle(ctx context.Context, in *DigestSingleRequest, opts ...grpc.CallOption) (*DigestSingleResponse, error) + // CK_RV m_EncryptInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *key, size_t keylen, + // target_t target) ; + EncryptInit(ctx context.Context, in *EncryptInitRequest, opts ...grpc.CallOption) (*EncryptInitResponse, error) + // CK_RV m_DecryptInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *key, size_t keylen, + // target_t target) ; + DecryptInit(ctx context.Context, in *DecryptInitRequest, opts ...grpc.CallOption) (*DecryptInitResponse, error) + // CK_RV m_EncryptUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR plain, CK_ULONG plainlen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + EncryptUpdate(ctx context.Context, in *EncryptUpdateRequest, opts ...grpc.CallOption) (*EncryptUpdateResponse, error) + // CK_RV m_DecryptUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + DecryptUpdate(ctx context.Context, in *DecryptUpdateRequest, opts ...grpc.CallOption) (*DecryptUpdateResponse, error) + // CK_RV m_Encrypt ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR plain, CK_ULONG plainlen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + Encrypt(ctx context.Context, in *EncryptRequest, opts ...grpc.CallOption) (*EncryptResponse, error) + // CK_RV m_Decrypt ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + Decrypt(ctx context.Context, in *DecryptRequest, opts ...grpc.CallOption) (*DecryptResponse, error) + // CK_RV m_EncryptFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + EncryptFinal(ctx context.Context, in *EncryptFinalRequest, opts ...grpc.CallOption) (*EncryptFinalResponse, error) + // CK_RV m_DecryptFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + DecryptFinal(ctx context.Context, in *DecryptFinalRequest, opts ...grpc.CallOption) (*DecryptFinalResponse, error) + // CK_RV m_EncryptSingle ( + // const unsigned char *key, size_t keylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR plain, CK_ULONG plainlen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + EncryptSingle(ctx context.Context, in *EncryptSingleRequest, opts ...grpc.CallOption) (*EncryptSingleResponse, error) + // CK_RV m_DecryptSingle ( + // const unsigned char *key, size_t keylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + DecryptSingle(ctx context.Context, in *DecryptSingleRequest, opts ...grpc.CallOption) (*DecryptSingleResponse, error) + // CK_RV m_SignInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *privKey, size_t privKeylen, + // target_t target) ; + SignInit(ctx context.Context, in *SignInitRequest, opts ...grpc.CallOption) (*SignInitResponse, error) + // CK_RV m_VerifyInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *pubKey, size_t pubKeylen, + // target_t target) ; + VerifyInit(ctx context.Context, in *VerifyInitRequest, opts ...grpc.CallOption) (*VerifyInitResponse, error) + // CK_RV m_SignUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // target_t target) ; + SignUpdate(ctx context.Context, in *SignUpdateRequest, opts ...grpc.CallOption) (*SignUpdateResponse, error) + // CK_RV m_VerifyUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // target_t target) ; + VerifyUpdate(ctx context.Context, in *VerifyUpdateRequest, opts ...grpc.CallOption) (*VerifyUpdateResponse, error) + // CK_RV m_SignFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, + // target_t target) ; + SignFinal(ctx context.Context, in *SignFinalRequest, opts ...grpc.CallOption) (*SignFinalResponse, error) + // CK_RV m_VerifyFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR signature, CK_ULONG signaturelen, + // target_t target) ; + VerifyFinal(ctx context.Context, in *VerifyFinalRequest, opts ...grpc.CallOption) (*VerifyFinalResponse, error) + // CK_RV m_Sign ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, + // target_t target) ; + Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) + // CK_RV m_Verify ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG signaturelen, + // target_t target) ; + Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) + // CK_RV m_SignSingle ( + // const unsigned char *privKey, size_t privKeylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, + // target_t target) ; + SignSingle(ctx context.Context, in *SignSingleRequest, opts ...grpc.CallOption) (*SignSingleResponse, error) + // CK_RV m_VerifySingle ( + // const unsigned char *pubKey, size_t pubKeylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG signaturelen, + // target_t target) ; + VerifySingle(ctx context.Context, in *VerifySingleRequest, opts ...grpc.CallOption) (*VerifySingleResponse, error) + // CK_RV m_GenerateKey ( + // CK_MECHANISM_PTR mech, + // CK_ATTRIBUTE_PTR templateBytes, CK_ULONG templateByteslen, + // const unsigned char *pin, size_t pinlen, + // unsigned char *keyBytes, size_t *keyByteslen, + // unsigned char *checkSum, size_t *checkSumlen, + // target_t target) ; + GenerateKey(ctx context.Context, in *GenerateKeyRequest, opts ...grpc.CallOption) (*GenerateKeyResponse, error) + // CK_RV m_GenerateKeyPair ( + // CK_MECHANISM_PTR mech, + // CK_ATTRIBUTE_PTR pubKeyTemplateBytes, CK_ULONG pubKeyTemplateByteslen, + // CK_ATTRIBUTE_PTR privKeyTemplateBytes, CK_ULONG privKeyTemplateByteslen, + // const unsigned char *pin, size_t pinlen, + // unsigned char *privKeyBytes, size_t *privKeyByteslen, + // unsigned char *pubKeyBytes, size_t *pubKeyByteslen, + // target_t target) ; + GenerateKeyPair(ctx context.Context, in *GenerateKeyPairRequest, opts ...grpc.CallOption) (*GenerateKeyPairResponse, error) + // CK_RV m_WrapKey ( + // const unsigned char *key, size_t keylen, + // const unsigned char *keK, size_t keKlen, + // const unsigned char *macKey, size_t macKeylen, + // const CK_MECHANISM_PTR mech, + // CK_BYTE_PTR wrapped, CK_ULONG_PTR wrappedlen, + // target_t target) ; + WrapKey(ctx context.Context, in *WrapKeyRequest, opts ...grpc.CallOption) (*WrapKeyResponse, error) + // CK_RV m_UnwrapKey ( + // const CK_BYTE_PTR wrapped, CK_ULONG wrappedlen, + // const unsigned char *keK, size_t keKlen, + // const unsigned char *macKey, size_t macKeylen, + // const unsigned char *pin, size_t pinlen, + // const CK_MECHANISM_PTR mech, + // const CK_ATTRIBUTE_PTR templateBytes, CK_ULONG templateByteslen, + // unsigned char *unwrappedBytes, size_t *unwrappedByteslen, + // CK_BYTE_PTR checkSum, CK_ULONG *checkSumlen, + // target_t target) ; + UnwrapKey(ctx context.Context, in *UnwrapKeyRequest, opts ...grpc.CallOption) (*UnwrapKeyResponse, error) + // CK_RV m_DeriveKey ( + // CK_MECHANISM_PTR mech, + // CK_ATTRIBUTE_PTR templateBytes, CK_ULONG templateByteslen, + // const unsigned char *baseKey, size_t baseKeylen, + // const unsigned char *data, size_t datalen, + // const unsigned char *pin, size_t pinlen, + // unsigned char *newKeyBytes, size_t *newKeyByteslen, + // unsigned char *checkSum, size_t *checkSumlen, + // target_t target) ; + DeriveKey(ctx context.Context, in *DeriveKeyRequest, opts ...grpc.CallOption) (*DeriveKeyResponse, error) + // CK_RV m_GetMechanismList ( + // CK_SLOT_ID slot, + // CK_MECHANISM_TYPE_PTR mechs, CK_ULONG_PTR mechslen, + // target_t target) ; + GetMechanismList(ctx context.Context, in *GetMechanismListRequest, opts ...grpc.CallOption) (*GetMechanismListResponse, error) + // CK_RV m_GetMechanismInfo ( + // CK_SLOT_ID slot, + // CK_MECHANISM_TYPE mech, + // CK_MECHANISM_INFO_PTR mechInfo, + // target_t target) ; + GetMechanismInfo(ctx context.Context, in *GetMechanismInfoRequest, opts ...grpc.CallOption) (*GetMechanismInfoResponse, error) + // CK_RV m_GetAttributeValue ( + // const unsigned char *object, size_t objectlen, + // CK_ATTRIBUTE_PTR attributesBytes, CK_ULONG attributesByteslen, + // target_t target) ; + GetAttributeValue(ctx context.Context, in *GetAttributeValueRequest, opts ...grpc.CallOption) (*GetAttributeValueResponse, error) + // CK_RV m_SetAttributeValue ( + // unsigned char *object, size_t objectlen, + // CK_ATTRIBUTE_PTR attributesBytes, CK_ULONG attributesByteslen, + // target_t target) ; + SetAttributeValue(ctx context.Context, in *SetAttributeValueRequest, opts ...grpc.CallOption) (*SetAttributeValueResponse, error) + RewrapKeyBlob(ctx context.Context, in *RewrapKeyBlobRequest, opts ...grpc.CallOption) (*RewrapKeyBlobResponse, error) + ReEncrypt(ctx context.Context, in *ReEncryptRequest, opts ...grpc.CallOption) (*ReEncryptResponse, error) +} + +type cryptoClient struct { + cc *grpc.ClientConn +} + +func NewCryptoClient(cc *grpc.ClientConn) CryptoClient { + return &cryptoClient{cc} +} + +func (c *cryptoClient) GenerateRandom(ctx context.Context, in *GenerateRandomRequest, opts ...grpc.CallOption) (*GenerateRandomResponse, error) { + out := new(GenerateRandomResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/GenerateRandom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DigestInit(ctx context.Context, in *DigestInitRequest, opts ...grpc.CallOption) (*DigestInitResponse, error) { + out := new(DigestInitResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestInit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) Digest(ctx context.Context, in *DigestRequest, opts ...grpc.CallOption) (*DigestResponse, error) { + out := new(DigestResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/Digest", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DigestUpdate(ctx context.Context, in *DigestUpdateRequest, opts ...grpc.CallOption) (*DigestUpdateResponse, error) { + out := new(DigestUpdateResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DigestKey(ctx context.Context, in *DigestKeyRequest, opts ...grpc.CallOption) (*DigestKeyResponse, error) { + out := new(DigestKeyResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestKey", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DigestFinal(ctx context.Context, in *DigestFinalRequest, opts ...grpc.CallOption) (*DigestFinalResponse, error) { + out := new(DigestFinalResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestFinal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DigestSingle(ctx context.Context, in *DigestSingleRequest, opts ...grpc.CallOption) (*DigestSingleResponse, error) { + out := new(DigestSingleResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DigestSingle", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) EncryptInit(ctx context.Context, in *EncryptInitRequest, opts ...grpc.CallOption) (*EncryptInitResponse, error) { + out := new(EncryptInitResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptInit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DecryptInit(ctx context.Context, in *DecryptInitRequest, opts ...grpc.CallOption) (*DecryptInitResponse, error) { + out := new(DecryptInitResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptInit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) EncryptUpdate(ctx context.Context, in *EncryptUpdateRequest, opts ...grpc.CallOption) (*EncryptUpdateResponse, error) { + out := new(EncryptUpdateResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DecryptUpdate(ctx context.Context, in *DecryptUpdateRequest, opts ...grpc.CallOption) (*DecryptUpdateResponse, error) { + out := new(DecryptUpdateResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) Encrypt(ctx context.Context, in *EncryptRequest, opts ...grpc.CallOption) (*EncryptResponse, error) { + out := new(EncryptResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/Encrypt", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) Decrypt(ctx context.Context, in *DecryptRequest, opts ...grpc.CallOption) (*DecryptResponse, error) { + out := new(DecryptResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/Decrypt", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) EncryptFinal(ctx context.Context, in *EncryptFinalRequest, opts ...grpc.CallOption) (*EncryptFinalResponse, error) { + out := new(EncryptFinalResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptFinal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DecryptFinal(ctx context.Context, in *DecryptFinalRequest, opts ...grpc.CallOption) (*DecryptFinalResponse, error) { + out := new(DecryptFinalResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptFinal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) EncryptSingle(ctx context.Context, in *EncryptSingleRequest, opts ...grpc.CallOption) (*EncryptSingleResponse, error) { + out := new(EncryptSingleResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/EncryptSingle", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DecryptSingle(ctx context.Context, in *DecryptSingleRequest, opts ...grpc.CallOption) (*DecryptSingleResponse, error) { + out := new(DecryptSingleResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DecryptSingle", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) SignInit(ctx context.Context, in *SignInitRequest, opts ...grpc.CallOption) (*SignInitResponse, error) { + out := new(SignInitResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/SignInit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) VerifyInit(ctx context.Context, in *VerifyInitRequest, opts ...grpc.CallOption) (*VerifyInitResponse, error) { + out := new(VerifyInitResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifyInit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) SignUpdate(ctx context.Context, in *SignUpdateRequest, opts ...grpc.CallOption) (*SignUpdateResponse, error) { + out := new(SignUpdateResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/SignUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) VerifyUpdate(ctx context.Context, in *VerifyUpdateRequest, opts ...grpc.CallOption) (*VerifyUpdateResponse, error) { + out := new(VerifyUpdateResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifyUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) SignFinal(ctx context.Context, in *SignFinalRequest, opts ...grpc.CallOption) (*SignFinalResponse, error) { + out := new(SignFinalResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/SignFinal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) VerifyFinal(ctx context.Context, in *VerifyFinalRequest, opts ...grpc.CallOption) (*VerifyFinalResponse, error) { + out := new(VerifyFinalResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifyFinal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) { + out := new(SignResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/Sign", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) { + out := new(VerifyResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/Verify", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) SignSingle(ctx context.Context, in *SignSingleRequest, opts ...grpc.CallOption) (*SignSingleResponse, error) { + out := new(SignSingleResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/SignSingle", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) VerifySingle(ctx context.Context, in *VerifySingleRequest, opts ...grpc.CallOption) (*VerifySingleResponse, error) { + out := new(VerifySingleResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/VerifySingle", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) GenerateKey(ctx context.Context, in *GenerateKeyRequest, opts ...grpc.CallOption) (*GenerateKeyResponse, error) { + out := new(GenerateKeyResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/GenerateKey", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) GenerateKeyPair(ctx context.Context, in *GenerateKeyPairRequest, opts ...grpc.CallOption) (*GenerateKeyPairResponse, error) { + out := new(GenerateKeyPairResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/GenerateKeyPair", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) WrapKey(ctx context.Context, in *WrapKeyRequest, opts ...grpc.CallOption) (*WrapKeyResponse, error) { + out := new(WrapKeyResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/WrapKey", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) UnwrapKey(ctx context.Context, in *UnwrapKeyRequest, opts ...grpc.CallOption) (*UnwrapKeyResponse, error) { + out := new(UnwrapKeyResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/UnwrapKey", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) DeriveKey(ctx context.Context, in *DeriveKeyRequest, opts ...grpc.CallOption) (*DeriveKeyResponse, error) { + out := new(DeriveKeyResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/DeriveKey", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) GetMechanismList(ctx context.Context, in *GetMechanismListRequest, opts ...grpc.CallOption) (*GetMechanismListResponse, error) { + out := new(GetMechanismListResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/GetMechanismList", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) GetMechanismInfo(ctx context.Context, in *GetMechanismInfoRequest, opts ...grpc.CallOption) (*GetMechanismInfoResponse, error) { + out := new(GetMechanismInfoResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/GetMechanismInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) GetAttributeValue(ctx context.Context, in *GetAttributeValueRequest, opts ...grpc.CallOption) (*GetAttributeValueResponse, error) { + out := new(GetAttributeValueResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/GetAttributeValue", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) SetAttributeValue(ctx context.Context, in *SetAttributeValueRequest, opts ...grpc.CallOption) (*SetAttributeValueResponse, error) { + out := new(SetAttributeValueResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/SetAttributeValue", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) RewrapKeyBlob(ctx context.Context, in *RewrapKeyBlobRequest, opts ...grpc.CallOption) (*RewrapKeyBlobResponse, error) { + out := new(RewrapKeyBlobResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/RewrapKeyBlob", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *cryptoClient) ReEncrypt(ctx context.Context, in *ReEncryptRequest, opts ...grpc.CallOption) (*ReEncryptResponse, error) { + out := new(ReEncryptResponse) + err := c.cc.Invoke(ctx, "/grep11.Crypto/ReEncrypt", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// CryptoServer is the server API for Crypto service. +type CryptoServer interface { + // CK_RV m_GenerateRandom ( + // CK_BYTE_PTR rnd, CK_ULONG rndlen, + // target_t target) ; + GenerateRandom(context.Context, *GenerateRandomRequest) (*GenerateRandomResponse, error) + // CK_RV m_DigestInit ( + // unsigned char *state, size_t *statelen, + // const CK_MECHANISM_PTR mech, + // target_t target) ; + DigestInit(context.Context, *DigestInitRequest) (*DigestInitResponse, error) + // CK_RV m_Digest ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, + // target_t target) ; + Digest(context.Context, *DigestRequest) (*DigestResponse, error) + // CK_RV m_DigestUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // target_t target) ; + DigestUpdate(context.Context, *DigestUpdateRequest) (*DigestUpdateResponse, error) + // CK_RV m_DigestKey ( + // unsigned char *state, size_t statelen, + // const unsigned char *key, size_t keylen, + // target_t target) ; + DigestKey(context.Context, *DigestKeyRequest) (*DigestKeyResponse, error) + // CK_RV m_DigestFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, + // target_t target) ; + DigestFinal(context.Context, *DigestFinalRequest) (*DigestFinalResponse, error) + // CK_RV m_DigestSingle ( + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR digest, CK_ULONG_PTR digestlen, + // target_t target) ; + DigestSingle(context.Context, *DigestSingleRequest) (*DigestSingleResponse, error) + // CK_RV m_EncryptInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *key, size_t keylen, + // target_t target) ; + EncryptInit(context.Context, *EncryptInitRequest) (*EncryptInitResponse, error) + // CK_RV m_DecryptInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *key, size_t keylen, + // target_t target) ; + DecryptInit(context.Context, *DecryptInitRequest) (*DecryptInitResponse, error) + // CK_RV m_EncryptUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR plain, CK_ULONG plainlen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + EncryptUpdate(context.Context, *EncryptUpdateRequest) (*EncryptUpdateResponse, error) + // CK_RV m_DecryptUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + DecryptUpdate(context.Context, *DecryptUpdateRequest) (*DecryptUpdateResponse, error) + // CK_RV m_Encrypt ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR plain, CK_ULONG plainlen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + Encrypt(context.Context, *EncryptRequest) (*EncryptResponse, error) + // CK_RV m_Decrypt ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + Decrypt(context.Context, *DecryptRequest) (*DecryptResponse, error) + // CK_RV m_EncryptFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + EncryptFinal(context.Context, *EncryptFinalRequest) (*EncryptFinalResponse, error) + // CK_RV m_DecryptFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + DecryptFinal(context.Context, *DecryptFinalRequest) (*DecryptFinalResponse, error) + // CK_RV m_EncryptSingle ( + // const unsigned char *key, size_t keylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR plain, CK_ULONG plainlen, + // CK_BYTE_PTR ciphered, CK_ULONG_PTR cipheredlen, + // target_t target) ; + EncryptSingle(context.Context, *EncryptSingleRequest) (*EncryptSingleResponse, error) + // CK_RV m_DecryptSingle ( + // const unsigned char *key, size_t keylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR ciphered, CK_ULONG cipheredlen, + // CK_BYTE_PTR plain, CK_ULONG_PTR plainlen, + // target_t target) ; + DecryptSingle(context.Context, *DecryptSingleRequest) (*DecryptSingleResponse, error) + // CK_RV m_SignInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *privKey, size_t privKeylen, + // target_t target) ; + SignInit(context.Context, *SignInitRequest) (*SignInitResponse, error) + // CK_RV m_VerifyInit ( + // unsigned char *state, size_t *statelen, + // CK_MECHANISM_PTR mech, + // const unsigned char *pubKey, size_t pubKeylen, + // target_t target) ; + VerifyInit(context.Context, *VerifyInitRequest) (*VerifyInitResponse, error) + // CK_RV m_SignUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // target_t target) ; + SignUpdate(context.Context, *SignUpdateRequest) (*SignUpdateResponse, error) + // CK_RV m_VerifyUpdate ( + // unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // target_t target) ; + VerifyUpdate(context.Context, *VerifyUpdateRequest) (*VerifyUpdateResponse, error) + // CK_RV m_SignFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, + // target_t target) ; + SignFinal(context.Context, *SignFinalRequest) (*SignFinalResponse, error) + // CK_RV m_VerifyFinal ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR signature, CK_ULONG signaturelen, + // target_t target) ; + VerifyFinal(context.Context, *VerifyFinalRequest) (*VerifyFinalResponse, error) + // CK_RV m_Sign ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, + // target_t target) ; + Sign(context.Context, *SignRequest) (*SignResponse, error) + // CK_RV m_Verify ( + // const unsigned char *state, size_t statelen, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG signaturelen, + // target_t target) ; + Verify(context.Context, *VerifyRequest) (*VerifyResponse, error) + // CK_RV m_SignSingle ( + // const unsigned char *privKey, size_t privKeylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG_PTR signaturelen, + // target_t target) ; + SignSingle(context.Context, *SignSingleRequest) (*SignSingleResponse, error) + // CK_RV m_VerifySingle ( + // const unsigned char *pubKey, size_t pubKeylen, + // CK_MECHANISM_PTR mech, + // CK_BYTE_PTR data, CK_ULONG datalen, + // CK_BYTE_PTR signature, CK_ULONG signaturelen, + // target_t target) ; + VerifySingle(context.Context, *VerifySingleRequest) (*VerifySingleResponse, error) + // CK_RV m_GenerateKey ( + // CK_MECHANISM_PTR mech, + // CK_ATTRIBUTE_PTR templateBytes, CK_ULONG templateByteslen, + // const unsigned char *pin, size_t pinlen, + // unsigned char *keyBytes, size_t *keyByteslen, + // unsigned char *checkSum, size_t *checkSumlen, + // target_t target) ; + GenerateKey(context.Context, *GenerateKeyRequest) (*GenerateKeyResponse, error) + // CK_RV m_GenerateKeyPair ( + // CK_MECHANISM_PTR mech, + // CK_ATTRIBUTE_PTR pubKeyTemplateBytes, CK_ULONG pubKeyTemplateByteslen, + // CK_ATTRIBUTE_PTR privKeyTemplateBytes, CK_ULONG privKeyTemplateByteslen, + // const unsigned char *pin, size_t pinlen, + // unsigned char *privKeyBytes, size_t *privKeyByteslen, + // unsigned char *pubKeyBytes, size_t *pubKeyByteslen, + // target_t target) ; + GenerateKeyPair(context.Context, *GenerateKeyPairRequest) (*GenerateKeyPairResponse, error) + // CK_RV m_WrapKey ( + // const unsigned char *key, size_t keylen, + // const unsigned char *keK, size_t keKlen, + // const unsigned char *macKey, size_t macKeylen, + // const CK_MECHANISM_PTR mech, + // CK_BYTE_PTR wrapped, CK_ULONG_PTR wrappedlen, + // target_t target) ; + WrapKey(context.Context, *WrapKeyRequest) (*WrapKeyResponse, error) + // CK_RV m_UnwrapKey ( + // const CK_BYTE_PTR wrapped, CK_ULONG wrappedlen, + // const unsigned char *keK, size_t keKlen, + // const unsigned char *macKey, size_t macKeylen, + // const unsigned char *pin, size_t pinlen, + // const CK_MECHANISM_PTR mech, + // const CK_ATTRIBUTE_PTR templateBytes, CK_ULONG templateByteslen, + // unsigned char *unwrappedBytes, size_t *unwrappedByteslen, + // CK_BYTE_PTR checkSum, CK_ULONG *checkSumlen, + // target_t target) ; + UnwrapKey(context.Context, *UnwrapKeyRequest) (*UnwrapKeyResponse, error) + // CK_RV m_DeriveKey ( + // CK_MECHANISM_PTR mech, + // CK_ATTRIBUTE_PTR templateBytes, CK_ULONG templateByteslen, + // const unsigned char *baseKey, size_t baseKeylen, + // const unsigned char *data, size_t datalen, + // const unsigned char *pin, size_t pinlen, + // unsigned char *newKeyBytes, size_t *newKeyByteslen, + // unsigned char *checkSum, size_t *checkSumlen, + // target_t target) ; + DeriveKey(context.Context, *DeriveKeyRequest) (*DeriveKeyResponse, error) + // CK_RV m_GetMechanismList ( + // CK_SLOT_ID slot, + // CK_MECHANISM_TYPE_PTR mechs, CK_ULONG_PTR mechslen, + // target_t target) ; + GetMechanismList(context.Context, *GetMechanismListRequest) (*GetMechanismListResponse, error) + // CK_RV m_GetMechanismInfo ( + // CK_SLOT_ID slot, + // CK_MECHANISM_TYPE mech, + // CK_MECHANISM_INFO_PTR mechInfo, + // target_t target) ; + GetMechanismInfo(context.Context, *GetMechanismInfoRequest) (*GetMechanismInfoResponse, error) + // CK_RV m_GetAttributeValue ( + // const unsigned char *object, size_t objectlen, + // CK_ATTRIBUTE_PTR attributesBytes, CK_ULONG attributesByteslen, + // target_t target) ; + GetAttributeValue(context.Context, *GetAttributeValueRequest) (*GetAttributeValueResponse, error) + // CK_RV m_SetAttributeValue ( + // unsigned char *object, size_t objectlen, + // CK_ATTRIBUTE_PTR attributesBytes, CK_ULONG attributesByteslen, + // target_t target) ; + SetAttributeValue(context.Context, *SetAttributeValueRequest) (*SetAttributeValueResponse, error) + RewrapKeyBlob(context.Context, *RewrapKeyBlobRequest) (*RewrapKeyBlobResponse, error) + ReEncrypt(context.Context, *ReEncryptRequest) (*ReEncryptResponse, error) +} + +// UnimplementedCryptoServer can be embedded to have forward compatible implementations. +type UnimplementedCryptoServer struct { +} + +func (*UnimplementedCryptoServer) GenerateRandom(ctx context.Context, req *GenerateRandomRequest) (*GenerateRandomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GenerateRandom not implemented") +} +func (*UnimplementedCryptoServer) DigestInit(ctx context.Context, req *DigestInitRequest) (*DigestInitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DigestInit not implemented") +} +func (*UnimplementedCryptoServer) Digest(ctx context.Context, req *DigestRequest) (*DigestResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Digest not implemented") +} +func (*UnimplementedCryptoServer) DigestUpdate(ctx context.Context, req *DigestUpdateRequest) (*DigestUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DigestUpdate not implemented") +} +func (*UnimplementedCryptoServer) DigestKey(ctx context.Context, req *DigestKeyRequest) (*DigestKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DigestKey not implemented") +} +func (*UnimplementedCryptoServer) DigestFinal(ctx context.Context, req *DigestFinalRequest) (*DigestFinalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DigestFinal not implemented") +} +func (*UnimplementedCryptoServer) DigestSingle(ctx context.Context, req *DigestSingleRequest) (*DigestSingleResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DigestSingle not implemented") +} +func (*UnimplementedCryptoServer) EncryptInit(ctx context.Context, req *EncryptInitRequest) (*EncryptInitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EncryptInit not implemented") +} +func (*UnimplementedCryptoServer) DecryptInit(ctx context.Context, req *DecryptInitRequest) (*DecryptInitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DecryptInit not implemented") +} +func (*UnimplementedCryptoServer) EncryptUpdate(ctx context.Context, req *EncryptUpdateRequest) (*EncryptUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EncryptUpdate not implemented") +} +func (*UnimplementedCryptoServer) DecryptUpdate(ctx context.Context, req *DecryptUpdateRequest) (*DecryptUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DecryptUpdate not implemented") +} +func (*UnimplementedCryptoServer) Encrypt(ctx context.Context, req *EncryptRequest) (*EncryptResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Encrypt not implemented") +} +func (*UnimplementedCryptoServer) Decrypt(ctx context.Context, req *DecryptRequest) (*DecryptResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Decrypt not implemented") +} +func (*UnimplementedCryptoServer) EncryptFinal(ctx context.Context, req *EncryptFinalRequest) (*EncryptFinalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EncryptFinal not implemented") +} +func (*UnimplementedCryptoServer) DecryptFinal(ctx context.Context, req *DecryptFinalRequest) (*DecryptFinalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DecryptFinal not implemented") +} +func (*UnimplementedCryptoServer) EncryptSingle(ctx context.Context, req *EncryptSingleRequest) (*EncryptSingleResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EncryptSingle not implemented") +} +func (*UnimplementedCryptoServer) DecryptSingle(ctx context.Context, req *DecryptSingleRequest) (*DecryptSingleResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DecryptSingle not implemented") +} +func (*UnimplementedCryptoServer) SignInit(ctx context.Context, req *SignInitRequest) (*SignInitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SignInit not implemented") +} +func (*UnimplementedCryptoServer) VerifyInit(ctx context.Context, req *VerifyInitRequest) (*VerifyInitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method VerifyInit not implemented") +} +func (*UnimplementedCryptoServer) SignUpdate(ctx context.Context, req *SignUpdateRequest) (*SignUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SignUpdate not implemented") +} +func (*UnimplementedCryptoServer) VerifyUpdate(ctx context.Context, req *VerifyUpdateRequest) (*VerifyUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method VerifyUpdate not implemented") +} +func (*UnimplementedCryptoServer) SignFinal(ctx context.Context, req *SignFinalRequest) (*SignFinalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SignFinal not implemented") +} +func (*UnimplementedCryptoServer) VerifyFinal(ctx context.Context, req *VerifyFinalRequest) (*VerifyFinalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method VerifyFinal not implemented") +} +func (*UnimplementedCryptoServer) Sign(ctx context.Context, req *SignRequest) (*SignResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented") +} +func (*UnimplementedCryptoServer) Verify(ctx context.Context, req *VerifyRequest) (*VerifyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Verify not implemented") +} +func (*UnimplementedCryptoServer) SignSingle(ctx context.Context, req *SignSingleRequest) (*SignSingleResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SignSingle not implemented") +} +func (*UnimplementedCryptoServer) VerifySingle(ctx context.Context, req *VerifySingleRequest) (*VerifySingleResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method VerifySingle not implemented") +} +func (*UnimplementedCryptoServer) GenerateKey(ctx context.Context, req *GenerateKeyRequest) (*GenerateKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GenerateKey not implemented") +} +func (*UnimplementedCryptoServer) GenerateKeyPair(ctx context.Context, req *GenerateKeyPairRequest) (*GenerateKeyPairResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GenerateKeyPair not implemented") +} +func (*UnimplementedCryptoServer) WrapKey(ctx context.Context, req *WrapKeyRequest) (*WrapKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WrapKey not implemented") +} +func (*UnimplementedCryptoServer) UnwrapKey(ctx context.Context, req *UnwrapKeyRequest) (*UnwrapKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnwrapKey not implemented") +} +func (*UnimplementedCryptoServer) DeriveKey(ctx context.Context, req *DeriveKeyRequest) (*DeriveKeyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeriveKey not implemented") +} +func (*UnimplementedCryptoServer) GetMechanismList(ctx context.Context, req *GetMechanismListRequest) (*GetMechanismListResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetMechanismList not implemented") +} +func (*UnimplementedCryptoServer) GetMechanismInfo(ctx context.Context, req *GetMechanismInfoRequest) (*GetMechanismInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetMechanismInfo not implemented") +} +func (*UnimplementedCryptoServer) GetAttributeValue(ctx context.Context, req *GetAttributeValueRequest) (*GetAttributeValueResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetAttributeValue not implemented") +} +func (*UnimplementedCryptoServer) SetAttributeValue(ctx context.Context, req *SetAttributeValueRequest) (*SetAttributeValueResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetAttributeValue not implemented") +} +func (*UnimplementedCryptoServer) RewrapKeyBlob(ctx context.Context, req *RewrapKeyBlobRequest) (*RewrapKeyBlobResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RewrapKeyBlob not implemented") +} +func (*UnimplementedCryptoServer) ReEncrypt(ctx context.Context, req *ReEncryptRequest) (*ReEncryptResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReEncrypt not implemented") +} + +func RegisterCryptoServer(s *grpc.Server, srv CryptoServer) { + s.RegisterService(&_Crypto_serviceDesc, srv) +} + +func _Crypto_GenerateRandom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GenerateRandomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).GenerateRandom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/GenerateRandom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).GenerateRandom(ctx, req.(*GenerateRandomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DigestInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DigestInitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DigestInit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DigestInit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DigestInit(ctx, req.(*DigestInitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_Digest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DigestRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).Digest(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/Digest", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).Digest(ctx, req.(*DigestRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DigestUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DigestUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DigestUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DigestUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DigestUpdate(ctx, req.(*DigestUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DigestKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DigestKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DigestKey(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DigestKey", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DigestKey(ctx, req.(*DigestKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DigestFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DigestFinalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DigestFinal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DigestFinal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DigestFinal(ctx, req.(*DigestFinalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DigestSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DigestSingleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DigestSingle(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DigestSingle", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DigestSingle(ctx, req.(*DigestSingleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_EncryptInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EncryptInitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).EncryptInit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/EncryptInit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).EncryptInit(ctx, req.(*EncryptInitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DecryptInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DecryptInitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DecryptInit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DecryptInit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DecryptInit(ctx, req.(*DecryptInitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_EncryptUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EncryptUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).EncryptUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/EncryptUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).EncryptUpdate(ctx, req.(*EncryptUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DecryptUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DecryptUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DecryptUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DecryptUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DecryptUpdate(ctx, req.(*DecryptUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_Encrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EncryptRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).Encrypt(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/Encrypt", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).Encrypt(ctx, req.(*EncryptRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_Decrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DecryptRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).Decrypt(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/Decrypt", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).Decrypt(ctx, req.(*DecryptRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_EncryptFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EncryptFinalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).EncryptFinal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/EncryptFinal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).EncryptFinal(ctx, req.(*EncryptFinalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DecryptFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DecryptFinalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DecryptFinal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DecryptFinal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DecryptFinal(ctx, req.(*DecryptFinalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_EncryptSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EncryptSingleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).EncryptSingle(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/EncryptSingle", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).EncryptSingle(ctx, req.(*EncryptSingleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DecryptSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DecryptSingleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DecryptSingle(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DecryptSingle", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DecryptSingle(ctx, req.(*DecryptSingleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_SignInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SignInitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).SignInit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/SignInit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).SignInit(ctx, req.(*SignInitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_VerifyInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifyInitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).VerifyInit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/VerifyInit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).VerifyInit(ctx, req.(*VerifyInitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_SignUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SignUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).SignUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/SignUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).SignUpdate(ctx, req.(*SignUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_VerifyUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifyUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).VerifyUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/VerifyUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).VerifyUpdate(ctx, req.(*VerifyUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_SignFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SignFinalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).SignFinal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/SignFinal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).SignFinal(ctx, req.(*SignFinalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_VerifyFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifyFinalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).VerifyFinal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/VerifyFinal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).VerifyFinal(ctx, req.(*VerifyFinalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SignRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).Sign(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/Sign", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).Sign(ctx, req.(*SignRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_Verify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).Verify(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/Verify", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).Verify(ctx, req.(*VerifyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_SignSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SignSingleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).SignSingle(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/SignSingle", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).SignSingle(ctx, req.(*SignSingleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_VerifySingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifySingleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).VerifySingle(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/VerifySingle", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).VerifySingle(ctx, req.(*VerifySingleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_GenerateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GenerateKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).GenerateKey(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/GenerateKey", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).GenerateKey(ctx, req.(*GenerateKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_GenerateKeyPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GenerateKeyPairRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).GenerateKeyPair(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/GenerateKeyPair", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).GenerateKeyPair(ctx, req.(*GenerateKeyPairRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_WrapKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WrapKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).WrapKey(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/WrapKey", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).WrapKey(ctx, req.(*WrapKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_UnwrapKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnwrapKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).UnwrapKey(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/UnwrapKey", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).UnwrapKey(ctx, req.(*UnwrapKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_DeriveKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeriveKeyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).DeriveKey(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/DeriveKey", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).DeriveKey(ctx, req.(*DeriveKeyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_GetMechanismList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetMechanismListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).GetMechanismList(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/GetMechanismList", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).GetMechanismList(ctx, req.(*GetMechanismListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_GetMechanismInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetMechanismInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).GetMechanismInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/GetMechanismInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).GetMechanismInfo(ctx, req.(*GetMechanismInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_GetAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetAttributeValueRequest) + if err := dec(in); err != nil { + return nil, err + } if interceptor == nil { - return srv.(CryptoServer).EncryptUpdate(ctx, in) + return srv.(CryptoServer).GetAttributeValue(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/GetAttributeValue", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).GetAttributeValue(ctx, req.(*GetAttributeValueRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_SetAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetAttributeValueRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).SetAttributeValue(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/SetAttributeValue", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).SetAttributeValue(ctx, req.(*SetAttributeValueRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_RewrapKeyBlob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RewrapKeyBlobRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).RewrapKeyBlob(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/RewrapKeyBlob", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).RewrapKeyBlob(ctx, req.(*RewrapKeyBlobRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Crypto_ReEncrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReEncryptRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CryptoServer).ReEncrypt(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/grep11.Crypto/ReEncrypt", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CryptoServer).ReEncrypt(ctx, req.(*ReEncryptRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Crypto_serviceDesc = grpc.ServiceDesc{ + ServiceName: "grep11.Crypto", + HandlerType: (*CryptoServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GenerateRandom", + Handler: _Crypto_GenerateRandom_Handler, + }, + { + MethodName: "DigestInit", + Handler: _Crypto_DigestInit_Handler, + }, + { + MethodName: "Digest", + Handler: _Crypto_Digest_Handler, + }, + { + MethodName: "DigestUpdate", + Handler: _Crypto_DigestUpdate_Handler, + }, + { + MethodName: "DigestKey", + Handler: _Crypto_DigestKey_Handler, + }, + { + MethodName: "DigestFinal", + Handler: _Crypto_DigestFinal_Handler, + }, + { + MethodName: "DigestSingle", + Handler: _Crypto_DigestSingle_Handler, + }, + { + MethodName: "EncryptInit", + Handler: _Crypto_EncryptInit_Handler, + }, + { + MethodName: "DecryptInit", + Handler: _Crypto_DecryptInit_Handler, + }, + { + MethodName: "EncryptUpdate", + Handler: _Crypto_EncryptUpdate_Handler, + }, + { + MethodName: "DecryptUpdate", + Handler: _Crypto_DecryptUpdate_Handler, + }, + { + MethodName: "Encrypt", + Handler: _Crypto_Encrypt_Handler, + }, + { + MethodName: "Decrypt", + Handler: _Crypto_Decrypt_Handler, + }, + { + MethodName: "EncryptFinal", + Handler: _Crypto_EncryptFinal_Handler, + }, + { + MethodName: "DecryptFinal", + Handler: _Crypto_DecryptFinal_Handler, + }, + { + MethodName: "EncryptSingle", + Handler: _Crypto_EncryptSingle_Handler, + }, + { + MethodName: "DecryptSingle", + Handler: _Crypto_DecryptSingle_Handler, + }, + { + MethodName: "SignInit", + Handler: _Crypto_SignInit_Handler, + }, + { + MethodName: "VerifyInit", + Handler: _Crypto_VerifyInit_Handler, + }, + { + MethodName: "SignUpdate", + Handler: _Crypto_SignUpdate_Handler, + }, + { + MethodName: "VerifyUpdate", + Handler: _Crypto_VerifyUpdate_Handler, + }, + { + MethodName: "SignFinal", + Handler: _Crypto_SignFinal_Handler, + }, + { + MethodName: "VerifyFinal", + Handler: _Crypto_VerifyFinal_Handler, + }, + { + MethodName: "Sign", + Handler: _Crypto_Sign_Handler, + }, + { + MethodName: "Verify", + Handler: _Crypto_Verify_Handler, + }, + { + MethodName: "SignSingle", + Handler: _Crypto_SignSingle_Handler, + }, + { + MethodName: "VerifySingle", + Handler: _Crypto_VerifySingle_Handler, + }, + { + MethodName: "GenerateKey", + Handler: _Crypto_GenerateKey_Handler, + }, + { + MethodName: "GenerateKeyPair", + Handler: _Crypto_GenerateKeyPair_Handler, + }, + { + MethodName: "WrapKey", + Handler: _Crypto_WrapKey_Handler, + }, + { + MethodName: "UnwrapKey", + Handler: _Crypto_UnwrapKey_Handler, + }, + { + MethodName: "DeriveKey", + Handler: _Crypto_DeriveKey_Handler, + }, + { + MethodName: "GetMechanismList", + Handler: _Crypto_GetMechanismList_Handler, + }, + { + MethodName: "GetMechanismInfo", + Handler: _Crypto_GetMechanismInfo_Handler, + }, + { + MethodName: "GetAttributeValue", + Handler: _Crypto_GetAttributeValue_Handler, + }, + { + MethodName: "SetAttributeValue", + Handler: _Crypto_SetAttributeValue_Handler, + }, + { + MethodName: "RewrapKeyBlob", + Handler: _Crypto_RewrapKeyBlob_Handler, + }, + { + MethodName: "ReEncrypt", + Handler: _Crypto_ReEncrypt_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "server.proto", +} + +func (m *GenerateRandomRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GenerateRandomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenerateRandomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Len != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Len)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *GenerateRandomResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GenerateRandomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenerateRandomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Rnd) > 0 { + i -= len(m.Rnd) + copy(dAtA[i:], m.Rnd) + i = encodeVarintServer(dAtA, i, uint64(len(m.Rnd))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestInitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestInitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestInitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *DigestInitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestInitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestInitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Digest) > 0 { + i -= len(m.Digest) + copy(dAtA[i:], m.Digest) + i = encodeVarintServer(dAtA, i, uint64(len(m.Digest))) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} + +func (m *DigestUpdateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestUpdateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestUpdateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestUpdateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestKeyRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestKeyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestKeyResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestKeyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestFinalRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestFinalRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestFinalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestFinalResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestFinalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestFinalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Digest) > 0 { + i -= len(m.Digest) + copy(dAtA[i:], m.Digest) + i = encodeVarintServer(dAtA, i, uint64(len(m.Digest))) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *DigestSingleRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestSingleRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestSingleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DigestSingleResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DigestSingleResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DigestSingleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Digest) > 0 { + i -= len(m.Digest) + copy(dAtA[i:], m.Digest) + i = encodeVarintServer(dAtA, i, uint64(len(m.Digest))) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} + +func (m *EncryptInitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EncryptInitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptInitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x1a + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *EncryptInitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EncryptInitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptInitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DecryptInitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DecryptInitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptInitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x1a + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *DecryptInitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DecryptInitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptInitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EncryptUpdateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EncryptUpdateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x12 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EncryptUpdateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EncryptUpdateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x1a + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DecryptUpdateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DecryptUpdateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/EncryptUpdate", + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).EncryptUpdate(ctx, req.(*EncryptUpdateRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_DecryptUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DecryptUpdateRequest) - if err := dec(in); err != nil { +func (m *DecryptUpdateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).DecryptUpdate(ctx, in) + return dAtA[:n], nil +} + +func (m *DecryptUpdateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DecryptUpdate", + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x1a } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DecryptUpdate(ctx, req.(*DecryptUpdateRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_Encrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(EncryptRequest) - if err := dec(in); err != nil { +func (m *EncryptRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).Encrypt(ctx, in) + return dAtA[:n], nil +} + +func (m *EncryptRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/Encrypt", + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).Encrypt(ctx, req.(*EncryptRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_Decrypt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DecryptRequest) - if err := dec(in); err != nil { +func (m *EncryptResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).Decrypt(ctx, in) + return dAtA[:n], nil +} + +func (m *EncryptResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/Decrypt", + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x1a } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).Decrypt(ctx, req.(*DecryptRequest)) + return len(dAtA) - i, nil +} + +func (m *DecryptRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return interceptor(ctx, in, info, handler) + return dAtA[:n], nil } -func _Crypto_EncryptFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(EncryptFinalRequest) - if err := dec(in); err != nil { +func (m *DecryptRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x12 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DecryptResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).EncryptFinal(ctx, in) + return dAtA[:n], nil +} + +func (m *DecryptResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/EncryptFinal", + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x1a } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).EncryptFinal(ctx, req.(*EncryptFinalRequest)) + return len(dAtA) - i, nil +} + +func (m *EncryptFinalRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return interceptor(ctx, in, info, handler) + return dAtA[:n], nil } -func _Crypto_DecryptFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DecryptFinalRequest) - if err := dec(in); err != nil { +func (m *EncryptFinalRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptFinalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EncryptFinalResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).DecryptFinal(ctx, in) + return dAtA[:n], nil +} + +func (m *EncryptFinalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptFinalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DecryptFinal", + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x12 + } + return len(dAtA) - i, nil +} + +func (m *DecryptFinalRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DecryptFinalRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptFinalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DecryptFinalResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DecryptFinalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptFinalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DecryptFinal(ctx, req.(*DecryptFinalRequest)) + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x12 } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_EncryptSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(EncryptSingleRequest) - if err := dec(in); err != nil { +func (m *EncryptSingleRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).EncryptSingle(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/EncryptSingle", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).EncryptSingle(ctx, req.(*EncryptSingleRequest)) - } - return interceptor(ctx, in, info, handler) + return dAtA[:n], nil } -func _Crypto_DecryptSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DecryptSingleRequest) - if err := dec(in); err != nil { - return nil, err +func (m *EncryptSingleRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptSingleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if interceptor == nil { - return srv.(CryptoServer).DecryptSingle(ctx, in) + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x1a } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DecryptSingle", + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DecryptSingle(ctx, req.(*DecryptSingleRequest)) + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_SignInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SignInitRequest) - if err := dec(in); err != nil { +func (m *EncryptSingleResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).SignInit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/SignInit", + return dAtA[:n], nil +} + +func (m *EncryptSingleResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EncryptSingleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).SignInit(ctx, req.(*SignInitRequest)) + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x22 } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_VerifyInit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(VerifyInitRequest) - if err := dec(in); err != nil { +func (m *DecryptSingleRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).VerifyInit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/VerifyInit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).VerifyInit(ctx, req.(*VerifyInitRequest)) - } - return interceptor(ctx, in, info, handler) + return dAtA[:n], nil } -func _Crypto_SignUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SignUpdateRequest) - if err := dec(in); err != nil { - return nil, err +func (m *DecryptSingleRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptSingleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if interceptor == nil { - return srv.(CryptoServer).SignUpdate(ctx, in) + if len(m.Ciphered) > 0 { + i -= len(m.Ciphered) + copy(dAtA[i:], m.Ciphered) + i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) + i-- + dAtA[i] = 0x1a } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/SignUpdate", + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).SignUpdate(ctx, req.(*SignUpdateRequest)) + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_VerifyUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(VerifyUpdateRequest) - if err := dec(in); err != nil { +func (m *DecryptSingleResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).VerifyUpdate(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/VerifyUpdate", + return dAtA[:n], nil +} + +func (m *DecryptSingleResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DecryptSingleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).VerifyUpdate(ctx, req.(*VerifyUpdateRequest)) + if len(m.Plain) > 0 { + i -= len(m.Plain) + copy(dAtA[i:], m.Plain) + i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) + i-- + dAtA[i] = 0x22 } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_SignFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SignFinalRequest) - if err := dec(in); err != nil { +func (m *SignInitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).SignFinal(ctx, in) + return dAtA[:n], nil +} + +func (m *SignInitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignInitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/SignFinal", + if len(m.PrivKey) > 0 { + i -= len(m.PrivKey) + copy(dAtA[i:], m.PrivKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKey))) + i-- + dAtA[i] = 0x1a } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).SignFinal(ctx, req.(*SignFinalRequest)) + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_VerifyFinal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(VerifyFinalRequest) - if err := dec(in); err != nil { +func (m *SignInitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).VerifyFinal(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/VerifyFinal", + return dAtA[:n], nil +} + +func (m *SignInitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignInitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).VerifyFinal(ctx, req.(*VerifyFinalRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SignRequest) - if err := dec(in); err != nil { +func (m *VerifyInitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).Sign(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/Sign", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).Sign(ctx, req.(*SignRequest)) - } - return interceptor(ctx, in, info, handler) + return dAtA[:n], nil +} + +func (m *VerifyInitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func _Crypto_Verify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(VerifyRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(CryptoServer).Verify(ctx, in) +func (m *VerifyInitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/Verify", + if len(m.PubKey) > 0 { + i -= len(m.PubKey) + copy(dAtA[i:], m.PubKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.PubKey))) + i-- + dAtA[i] = 0x1a } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).Verify(ctx, req.(*VerifyRequest)) + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_SignSingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SignSingleRequest) - if err := dec(in); err != nil { +func (m *VerifyInitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).SignSingle(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/SignSingle", + return dAtA[:n], nil +} + +func (m *VerifyInitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyInitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).SignSingle(ctx, req.(*SignSingleRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_VerifySingle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(VerifySingleRequest) - if err := dec(in); err != nil { +func (m *SignUpdateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).VerifySingle(ctx, in) + return dAtA[:n], nil +} + +func (m *SignUpdateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/VerifySingle", + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).VerifySingle(ctx, req.(*VerifySingleRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_GenerateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GenerateKeyRequest) - if err := dec(in); err != nil { +func (m *SignUpdateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).GenerateKey(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/GenerateKey", + return dAtA[:n], nil +} + +func (m *SignUpdateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).GenerateKey(ctx, req.(*GenerateKeyRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_GenerateKeyPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GenerateKeyPairRequest) - if err := dec(in); err != nil { +func (m *VerifyUpdateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).GenerateKeyPair(ctx, in) + return dAtA[:n], nil +} + +func (m *VerifyUpdateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/GenerateKeyPair", + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).GenerateKeyPair(ctx, req.(*GenerateKeyPairRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_WrapKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(WrapKeyRequest) - if err := dec(in); err != nil { +func (m *VerifyUpdateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).WrapKey(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/WrapKey", + return dAtA[:n], nil +} + +func (m *VerifyUpdateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).WrapKey(ctx, req.(*WrapKeyRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_UnwrapKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UnwrapKeyRequest) - if err := dec(in); err != nil { +func (m *SignFinalRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).UnwrapKey(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/UnwrapKey", + return dAtA[:n], nil +} + +func (m *SignFinalRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignFinalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).UnwrapKey(ctx, req.(*UnwrapKeyRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_DeriveKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DeriveKeyRequest) - if err := dec(in); err != nil { +func (m *SignFinalResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).DeriveKey(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/DeriveKey", + return dAtA[:n], nil +} + +func (m *SignFinalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignFinalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).DeriveKey(ctx, req.(*DeriveKeyRequest)) + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_GetMechanismList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetMechanismListRequest) - if err := dec(in); err != nil { +func (m *VerifyFinalRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).GetMechanismList(ctx, in) + return dAtA[:n], nil +} + +func (m *VerifyFinalRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyFinalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/GetMechanismList", + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).GetMechanismList(ctx, req.(*GetMechanismListRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_GetMechanismInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetMechanismInfoRequest) - if err := dec(in); err != nil { +func (m *VerifyFinalResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).GetMechanismInfo(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/GetMechanismInfo", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).GetMechanismInfo(ctx, req.(*GetMechanismInfoRequest)) + return dAtA[:n], nil +} + +func (m *VerifyFinalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyFinalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_GetAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetAttributeValueRequest) - if err := dec(in); err != nil { +func (m *SignRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).GetAttributeValue(ctx, in) + return dAtA[:n], nil +} + +func (m *SignRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/GetAttributeValue", + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).GetAttributeValue(ctx, req.(*GetAttributeValueRequest)) + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return interceptor(ctx, in, info, handler) + return len(dAtA) - i, nil } -func _Crypto_SetAttributeValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SetAttributeValueRequest) - if err := dec(in); err != nil { +func (m *SignResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(CryptoServer).SetAttributeValue(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/grep11.Crypto/SetAttributeValue", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(CryptoServer).SetAttributeValue(ctx, req.(*SetAttributeValueRequest)) - } - return interceptor(ctx, in, info, handler) + return dAtA[:n], nil } -var _Crypto_serviceDesc = grpc.ServiceDesc{ - ServiceName: "grep11.Crypto", - HandlerType: (*CryptoServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "GenerateRandom", - Handler: _Crypto_GenerateRandom_Handler, - }, - { - MethodName: "DigestInit", - Handler: _Crypto_DigestInit_Handler, - }, - { - MethodName: "Digest", - Handler: _Crypto_Digest_Handler, - }, - { - MethodName: "DigestUpdate", - Handler: _Crypto_DigestUpdate_Handler, - }, - { - MethodName: "DigestKey", - Handler: _Crypto_DigestKey_Handler, - }, - { - MethodName: "DigestFinal", - Handler: _Crypto_DigestFinal_Handler, - }, - { - MethodName: "DigestSingle", - Handler: _Crypto_DigestSingle_Handler, - }, - { - MethodName: "EncryptInit", - Handler: _Crypto_EncryptInit_Handler, - }, - { - MethodName: "DecryptInit", - Handler: _Crypto_DecryptInit_Handler, - }, - { - MethodName: "EncryptUpdate", - Handler: _Crypto_EncryptUpdate_Handler, - }, - { - MethodName: "DecryptUpdate", - Handler: _Crypto_DecryptUpdate_Handler, - }, - { - MethodName: "Encrypt", - Handler: _Crypto_Encrypt_Handler, - }, - { - MethodName: "Decrypt", - Handler: _Crypto_Decrypt_Handler, - }, - { - MethodName: "EncryptFinal", - Handler: _Crypto_EncryptFinal_Handler, - }, - { - MethodName: "DecryptFinal", - Handler: _Crypto_DecryptFinal_Handler, - }, - { - MethodName: "EncryptSingle", - Handler: _Crypto_EncryptSingle_Handler, - }, - { - MethodName: "DecryptSingle", - Handler: _Crypto_DecryptSingle_Handler, - }, - { - MethodName: "SignInit", - Handler: _Crypto_SignInit_Handler, - }, - { - MethodName: "VerifyInit", - Handler: _Crypto_VerifyInit_Handler, - }, - { - MethodName: "SignUpdate", - Handler: _Crypto_SignUpdate_Handler, - }, - { - MethodName: "VerifyUpdate", - Handler: _Crypto_VerifyUpdate_Handler, - }, - { - MethodName: "SignFinal", - Handler: _Crypto_SignFinal_Handler, - }, - { - MethodName: "VerifyFinal", - Handler: _Crypto_VerifyFinal_Handler, - }, - { - MethodName: "Sign", - Handler: _Crypto_Sign_Handler, - }, - { - MethodName: "Verify", - Handler: _Crypto_Verify_Handler, - }, - { - MethodName: "SignSingle", - Handler: _Crypto_SignSingle_Handler, - }, - { - MethodName: "VerifySingle", - Handler: _Crypto_VerifySingle_Handler, - }, - { - MethodName: "GenerateKey", - Handler: _Crypto_GenerateKey_Handler, - }, - { - MethodName: "GenerateKeyPair", - Handler: _Crypto_GenerateKeyPair_Handler, - }, - { - MethodName: "WrapKey", - Handler: _Crypto_WrapKey_Handler, - }, - { - MethodName: "UnwrapKey", - Handler: _Crypto_UnwrapKey_Handler, - }, - { - MethodName: "DeriveKey", - Handler: _Crypto_DeriveKey_Handler, - }, - { - MethodName: "GetMechanismList", - Handler: _Crypto_GetMechanismList_Handler, - }, - { - MethodName: "GetMechanismInfo", - Handler: _Crypto_GetMechanismInfo_Handler, - }, - { - MethodName: "GetAttributeValue", - Handler: _Crypto_GetAttributeValue_Handler, - }, - { - MethodName: "SetAttributeValue", - Handler: _Crypto_SetAttributeValue_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "server.proto", +func (m *SignResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil } -func (m *GenerateRandomRequest) Marshal() (dAtA []byte, err error) { +func (m *VerifyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *GenerateRandomRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *VerifyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if m.Len != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Len)) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x1a + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 + } + if len(m.State) > 0 { + i -= len(m.State) + copy(dAtA[i:], m.State) + i = encodeVarintServer(dAtA, i, uint64(len(m.State))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *GenerateRandomResponse) Marshal() (dAtA []byte, err error) { +func (m *VerifyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *GenerateRandomResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *VerifyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Rnd) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Rnd))) - i += copy(dAtA[i:], m.Rnd) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestInitRequest) Marshal() (dAtA []byte, err error) { +func (m *SignSingleRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestInitRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *SignSingleRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignSingleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x1a + } if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n1, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) } - i += n1 + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if len(m.PrivKey) > 0 { + i -= len(m.PrivKey) + copy(dAtA[i:], m.PrivKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKey))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestInitResponse) Marshal() (dAtA []byte, err error) { +func (m *SignSingleResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestInitResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *SignSingleResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignSingleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestRequest) Marshal() (dAtA []byte, err error) { +func (m *VerifySingleRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *VerifySingleRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifySingleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 } if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ + i -= len(m.Data) + copy(dAtA[i:], m.Data) i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + i-- + dAtA[i] = 0x1a } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.PubKey) > 0 { + i -= len(m.PubKey) + copy(dAtA[i:], m.PubKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.PubKey))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestResponse) Marshal() (dAtA []byte, err error) { +func (m *VerifySingleResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *VerifySingleResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VerifySingleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Digest) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Digest))) - i += copy(dAtA[i:], m.Digest) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestUpdateRequest) Marshal() (dAtA []byte, err error) { +func (m *GenerateKeyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestUpdateRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GenerateKeyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenerateKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Template) > 0 { + for k := range m.Template { + v := m.Template[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.TemplateBytes) > 0 { + for k := range m.TemplateBytes { + v := m.TemplateBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) } - if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + return len(dAtA) - i, nil +} + +func (m *GenerateKeyResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GenerateKeyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenerateKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Key != nil { + { + size, err := m.Key.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if len(m.CheckSum) > 0 { + i -= len(m.CheckSum) + copy(dAtA[i:], m.CheckSum) + i = encodeVarintServer(dAtA, i, uint64(len(m.CheckSum))) + i-- + dAtA[i] = 0x2a + } + if len(m.KeyBytes) > 0 { + i -= len(m.KeyBytes) + copy(dAtA[i:], m.KeyBytes) + i = encodeVarintServer(dAtA, i, uint64(len(m.KeyBytes))) + i-- + dAtA[i] = 0x22 } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestUpdateResponse) Marshal() (dAtA []byte, err error) { +func (m *GenerateKeyPairRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GenerateKeyPairRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenerateKeyPairRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.PubKeyTemplate) > 0 { + for k := range m.PubKeyTemplate { + v := m.PubKeyTemplate[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x42 + } + } + if len(m.PrivKeyTemplate) > 0 { + for k := range m.PrivKeyTemplate { + v := m.PrivKeyTemplate[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x3a + } + } + if len(m.PrivKeyTemplateBytes) > 0 { + for k := range m.PrivKeyTemplateBytes { + v := m.PrivKeyTemplateBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.PubKeyTemplateBytes) > 0 { + for k := range m.PubKeyTemplateBytes { + v := m.PubKeyTemplateBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GenerateKeyPairResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestUpdateResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GenerateKeyPairResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenerateKeyPairResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.PubKey != nil { + { + size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.PrivKey != nil { + { + size, err := m.PrivKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if len(m.PubKeyBytes) > 0 { + i -= len(m.PubKeyBytes) + copy(dAtA[i:], m.PubKeyBytes) + i = encodeVarintServer(dAtA, i, uint64(len(m.PubKeyBytes))) + i-- + dAtA[i] = 0x32 + } + if len(m.PrivKeyBytes) > 0 { + i -= len(m.PrivKeyBytes) + copy(dAtA[i:], m.PrivKeyBytes) + i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKeyBytes))) + i-- + dAtA[i] = 0x2a } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestKeyRequest) Marshal() (dAtA []byte, err error) { +func (m *WrapKeyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestKeyRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *WrapKeyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WrapKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Key) > 0 { + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.MacKey) > 0 { + i -= len(m.MacKey) + copy(dAtA[i:], m.MacKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.MacKey))) + i-- + dAtA[i] = 0x1a + } + if len(m.KeK) > 0 { + i -= len(m.KeK) + copy(dAtA[i:], m.KeK) + i = encodeVarintServer(dAtA, i, uint64(len(m.KeK))) + i-- dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestKeyResponse) Marshal() (dAtA []byte, err error) { +func (m *WrapKeyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestKeyResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *WrapKeyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WrapKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Wrapped) > 0 { + i -= len(m.Wrapped) + copy(dAtA[i:], m.Wrapped) + i = encodeVarintServer(dAtA, i, uint64(len(m.Wrapped))) + i-- + dAtA[i] = 0x2a } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestFinalRequest) Marshal() (dAtA []byte, err error) { +func (m *UnwrapKeyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestFinalRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *UnwrapKeyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UnwrapKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Template) > 0 { + for k := range m.Template { + v := m.Template[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x4a + } + } + if len(m.TemplateBytes) > 0 { + for k := range m.TemplateBytes { + v := m.TemplateBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x32 + } + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if len(m.MacKey) > 0 { + i -= len(m.MacKey) + copy(dAtA[i:], m.MacKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.MacKey))) + i-- + dAtA[i] = 0x1a + } + if len(m.KeK) > 0 { + i -= len(m.KeK) + copy(dAtA[i:], m.KeK) + i = encodeVarintServer(dAtA, i, uint64(len(m.KeK))) + i-- + dAtA[i] = 0x12 + } + if len(m.Wrapped) > 0 { + i -= len(m.Wrapped) + copy(dAtA[i:], m.Wrapped) + i = encodeVarintServer(dAtA, i, uint64(len(m.Wrapped))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestFinalResponse) Marshal() (dAtA []byte, err error) { +func (m *UnwrapKeyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestFinalResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *UnwrapKeyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UnwrapKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Digest) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Digest))) - i += copy(dAtA[i:], m.Digest) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Unwrapped != nil { + { + size, err := m.Unwrapped.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if len(m.CheckSum) > 0 { + i -= len(m.CheckSum) + copy(dAtA[i:], m.CheckSum) + i = encodeVarintServer(dAtA, i, uint64(len(m.CheckSum))) + i-- + dAtA[i] = 0x42 + } + if len(m.UnwrappedBytes) > 0 { + i -= len(m.UnwrappedBytes) + copy(dAtA[i:], m.UnwrappedBytes) + i = encodeVarintServer(dAtA, i, uint64(len(m.UnwrappedBytes))) + i-- + dAtA[i] = 0x3a } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestSingleRequest) Marshal() (dAtA []byte, err error) { +func (m *DeriveKeyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestSingleRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *DeriveKeyRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DeriveKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n2, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Template) > 0 { + for k := range m.Template { + v := m.Template[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x42 } - i += n2 } if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ + i -= len(m.Data) + copy(dAtA[i:], m.Data) i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + i-- + dAtA[i] = 0x22 } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if len(m.BaseKey) > 0 { + i -= len(m.BaseKey) + copy(dAtA[i:], m.BaseKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.BaseKey))) + i-- + dAtA[i] = 0x1a + } + if len(m.TemplateBytes) > 0 { + for k := range m.TemplateBytes { + v := m.TemplateBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if m.Mech != nil { + { + size, err := m.Mech.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DigestSingleResponse) Marshal() (dAtA []byte, err error) { +func (m *DeriveKeyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DigestSingleResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *DeriveKeyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DeriveKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Digest) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Digest))) - i += copy(dAtA[i:], m.Digest) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.NewKey != nil { + { + size, err := m.NewKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if len(m.CheckSum) > 0 { + i -= len(m.CheckSum) + copy(dAtA[i:], m.CheckSum) + i = encodeVarintServer(dAtA, i, uint64(len(m.CheckSum))) + i-- + dAtA[i] = 0x3a + } + if len(m.NewKeyBytes) > 0 { + i -= len(m.NewKeyBytes) + copy(dAtA[i:], m.NewKeyBytes) + i = encodeVarintServer(dAtA, i, uint64(len(m.NewKeyBytes))) + i-- + dAtA[i] = 0x32 } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptInitRequest) Marshal() (dAtA []byte, err error) { +func (m *GetMechanismListRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptInitRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GetMechanismListRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetMechanismListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n3, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n3 - } - if len(m.Key) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptInitResponse) Marshal() (dAtA []byte, err error) { +func (m *GetMechanismListResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptInitResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GetMechanismListResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetMechanismListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Mechs) > 0 { + dAtA27 := make([]byte, len(m.Mechs)*10) + var j26 int + for _, num := range m.Mechs { + for num >= 1<<7 { + dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j26++ + } + dAtA27[j26] = uint8(num) + j26++ + } + i -= j26 + copy(dAtA[i:], dAtA27[:j26]) + i = encodeVarintServer(dAtA, i, uint64(j26)) + i-- + dAtA[i] = 0x12 } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptInitRequest) Marshal() (dAtA []byte, err error) { +func (m *GetMechanismInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptInitRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GetMechanismInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetMechanismInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n4, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n4 - } - if len(m.Key) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Mech != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Mech)) + i-- + dAtA[i] = 0x10 } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptInitResponse) Marshal() (dAtA []byte, err error) { +func (m *GetMechanismInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptInitResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GetMechanismInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetMechanismInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.MechInfo != nil { + { + size, err := m.MechInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptUpdateRequest) Marshal() (dAtA []byte, err error) { +func (m *GetAttributeValueRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptUpdateRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GetAttributeValueRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetAttributeValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Plain) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) + if len(m.Attributes) > 0 { + for k := range m.Attributes { + v := m.Attributes[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if len(m.AttributesBytes) > 0 { + for k := range m.AttributesBytes { + v := m.AttributesBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Object) > 0 { + i -= len(m.Object) + copy(dAtA[i:], m.Object) + i = encodeVarintServer(dAtA, i, uint64(len(m.Object))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptUpdateResponse) Marshal() (dAtA []byte, err error) { +func (m *GetAttributeValueResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptUpdateResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *GetAttributeValueResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetAttributeValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } - if len(m.Ciphered) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.AttributesBytes) > 0 { + for k := range m.AttributesBytes { + v := m.AttributesBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptUpdateRequest) Marshal() (dAtA []byte, err error) { +func (m *SetAttributeValueRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptUpdateRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *SetAttributeValueRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetAttributeValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Ciphered) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) + if len(m.Attributes) > 0 { + for k := range m.Attributes { + v := m.Attributes[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x1a + } } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if len(m.AttributesBytes) > 0 { + for k := range m.AttributesBytes { + v := m.AttributesBytes[k] + baseI := i + if len(v) > 0 { + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarintServer(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Object) > 0 { + i -= len(m.Object) + copy(dAtA[i:], m.Object) + i = encodeVarintServer(dAtA, i, uint64(len(m.Object))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptUpdateResponse) Marshal() (dAtA []byte, err error) { +func (m *SetAttributeValueResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptUpdateResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *SetAttributeValueResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetAttributeValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } - if len(m.Plain) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Object) > 0 { + i -= len(m.Object) + copy(dAtA[i:], m.Object) + i = encodeVarintServer(dAtA, i, uint64(len(m.Object))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptRequest) Marshal() (dAtA []byte, err error) { +func (m *Mechanism) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *Mechanism) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Mechanism) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Plain) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) + if m.Parameter != nil { + { + size := m.Parameter.Size() + i -= size + if _, err := m.Parameter.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if m.Mechanism != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Mechanism)) + i-- + dAtA[i] = 0x8 } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptResponse) Marshal() (dAtA []byte, err error) { +func (m *Mechanism_ParameterB) MarshalTo(dAtA []byte) (int, error) { size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Mechanism_ParameterB) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ParameterB != nil { + i -= len(m.ParameterB) + copy(dAtA[i:], m.ParameterB) + i = encodeVarintServer(dAtA, i, uint64(len(m.ParameterB))) + i-- + dAtA[i] = 0x12 } - return dAtA[:n], nil + return len(dAtA) - i, nil +} +func (m *Mechanism_RSAOAEPParameter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *EncryptResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.Ciphered) > 0 { +func (m *Mechanism_RSAOAEPParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.RSAOAEPParameter != nil { + { + size, err := m.RSAOAEPParameter.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + return len(dAtA) - i, nil +} +func (m *Mechanism_RSAPSSParameter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Mechanism_RSAPSSParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.RSAPSSParameter != nil { + { + size, err := m.RSAPSSParameter.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - return i, nil + return len(dAtA) - i, nil +} +func (m *Mechanism_ECDH1DeriveParameter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DecryptRequest) Marshal() (dAtA []byte, err error) { +func (m *Mechanism_ECDH1DeriveParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ECDH1DeriveParameter != nil { + { + size, err := m.ECDH1DeriveParameter.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *Mechanism_BTCDeriveParameter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Mechanism_BTCDeriveParameter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.BTCDeriveParameter != nil { + { + size, err := m.BTCDeriveParameter.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + return len(dAtA) - i, nil +} +func (m *MechanismInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *MechanismInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MechanismInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Ciphered) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) + if m.Flags != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Flags)) + i-- + dAtA[i] = 0x18 } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if m.MaxKeySize != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.MaxKeySize)) + i-- + dAtA[i] = 0x10 + } + if m.MinKeySize != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.MinKeySize)) + i-- + dAtA[i] = 0x8 } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptResponse) Marshal() (dAtA []byte, err error) { +func (m *Grep11Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *Grep11Error) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Grep11Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Plain) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Retry { + i-- + if m.Retry { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Detail) > 0 { + i -= len(m.Detail) + copy(dAtA[i:], m.Detail) + i = encodeVarintServer(dAtA, i, uint64(len(m.Detail))) + i-- + dAtA[i] = 0x12 + } + if m.Code != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Code)) + i-- + dAtA[i] = 0x8 } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptFinalRequest) Marshal() (dAtA []byte, err error) { +func (m *RSAOAEPParm) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptFinalRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *RSAOAEPParm) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSAOAEPParm) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.EncodingParm) > 0 { + i -= len(m.EncodingParm) + copy(dAtA[i:], m.EncodingParm) + i = encodeVarintServer(dAtA, i, uint64(len(m.EncodingParm))) + i-- + dAtA[i] = 0x22 + } + if m.EncodingParmType != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.EncodingParmType)) + i-- + dAtA[i] = 0x18 + } + if m.Mgf != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Mgf)) + i-- + dAtA[i] = 0x10 + } + if m.HashMech != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.HashMech)) + i-- + dAtA[i] = 0x8 } - return i, nil + return len(dAtA) - i, nil } -func (m *EncryptFinalResponse) Marshal() (dAtA []byte, err error) { +func (m *RSAPSSParm) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptFinalResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *RSAPSSParm) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RSAPSSParm) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Ciphered) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.SaltByteCount != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.SaltByteCount)) + i-- + dAtA[i] = 0x18 + } + if m.Mgf != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Mgf)) + i-- + dAtA[i] = 0x10 } - return i, nil + if m.HashMech != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.HashMech)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *DecryptFinalRequest) Marshal() (dAtA []byte, err error) { +func (m *ECDH1DeriveParm) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptFinalRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *ECDH1DeriveParm) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ECDH1DeriveParm) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.PublicData) > 0 { + i -= len(m.PublicData) + copy(dAtA[i:], m.PublicData) + i = encodeVarintServer(dAtA, i, uint64(len(m.PublicData))) + i-- + dAtA[i] = 0x1a + } + if len(m.SharedData) > 0 { + i -= len(m.SharedData) + copy(dAtA[i:], m.SharedData) + i = encodeVarintServer(dAtA, i, uint64(len(m.SharedData))) + i-- + dAtA[i] = 0x12 + } + if m.Kdf != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Kdf)) + i-- + dAtA[i] = 0x8 } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptFinalResponse) Marshal() (dAtA []byte, err error) { +func (m *BTCDeriveParm) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptFinalResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *BTCDeriveParm) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BTCDeriveParm) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Plain) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Version != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x20 + } + if len(m.ChainCode) > 0 { + i -= len(m.ChainCode) + copy(dAtA[i:], m.ChainCode) + i = encodeVarintServer(dAtA, i, uint64(len(m.ChainCode))) + i-- + dAtA[i] = 0x1a + } + if m.ChildKeyIndex != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.ChildKeyIndex)) + i-- + dAtA[i] = 0x10 } - return i, nil + if m.Type != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *EncryptSingleRequest) Marshal() (dAtA []byte, err error) { +func (m *HMACGeneralParm) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptSingleRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *HMACGeneralParm) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HMACGeneralParm) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Key) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) - } - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n5, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n5 - } - if len(m.Plain) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return i, nil + if m.ReturnByteCount != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.ReturnByteCount)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *EncryptSingleResponse) Marshal() (dAtA []byte, err error) { +func (m *ReEncryptRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *EncryptSingleResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *ReEncryptRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReEncryptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Ciphered) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.WrappedKey) > 0 { + i -= len(m.WrappedKey) + copy(dAtA[i:], m.WrappedKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.WrappedKey))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptSingleRequest) Marshal() (dAtA []byte, err error) { +func (m *ReEncryptResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptSingleRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *ReEncryptResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReEncryptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Key) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) - } - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n6, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n6 - } - if len(m.Ciphered) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Ciphered))) - i += copy(dAtA[i:], m.Ciphered) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.RewrappedKey) > 0 { + i -= len(m.RewrappedKey) + copy(dAtA[i:], m.RewrappedKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.RewrappedKey))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *DecryptSingleResponse) Marshal() (dAtA []byte, err error) { +func (m *RewrapKeyBlobRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *DecryptSingleResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *RewrapKeyBlobRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RewrapKeyBlobRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.Plain) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Plain))) - i += copy(dAtA[i:], m.Plain) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.WrappedKey) > 0 { + i -= len(m.WrappedKey) + copy(dAtA[i:], m.WrappedKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.WrappedKey))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *SignInitRequest) Marshal() (dAtA []byte, err error) { +func (m *RewrapKeyBlobResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *SignInitRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *RewrapKeyBlobResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RewrapKeyBlobResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n7, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n7 + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.PrivKey) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKey))) - i += copy(dAtA[i:], m.PrivKey) + if m.KeyBlob != nil { + { + size, err := m.KeyBlob.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if len(m.RewrappedKey) > 0 { + i -= len(m.RewrappedKey) + copy(dAtA[i:], m.RewrappedKey) + i = encodeVarintServer(dAtA, i, uint64(len(m.RewrappedKey))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *SignInitResponse) Marshal() (dAtA []byte, err error) { +func (m *AttributeValue) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *SignInitResponse) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *AttributeValue) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AttributeValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if len(m.State) > 0 { + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.OneAttr != nil { + { + size := m.OneAttr.Size() + i -= size + if _, err := m.OneAttr.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + } + } + return len(dAtA) - i, nil +} + +func (m *AttributeValue_AttributeB) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AttributeValue_AttributeB) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.AttributeB != nil { + i -= len(m.AttributeB) + copy(dAtA[i:], m.AttributeB) + i = encodeVarintServer(dAtA, i, uint64(len(m.AttributeB))) + i-- dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + return len(dAtA) - i, nil +} +func (m *AttributeValue_AttributeTF) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AttributeValue_AttributeTF) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i-- + if m.AttributeTF { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } - return i, nil + i-- + dAtA[i] = 0x10 + return len(dAtA) - i, nil +} +func (m *AttributeValue_AttributeI) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *VerifyInitRequest) Marshal() (dAtA []byte, err error) { +func (m *AttributeValue_AttributeI) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + i = encodeVarintServer(dAtA, i, uint64(m.AttributeI)) + i-- + dAtA[i] = 0x18 + return len(dAtA) - i, nil +} +func (m *KeyBlob) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *VerifyInitRequest) MarshalTo(dAtA []byte) (int, error) { - var i int +func (m *KeyBlob) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *KeyBlob) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n8, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.KeyBlobs) > 0 { + for iNdEx := len(m.KeyBlobs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.KeyBlobs[iNdEx]) + copy(dAtA[i:], m.KeyBlobs[iNdEx]) + i = encodeVarintServer(dAtA, i, uint64(len(m.KeyBlobs[iNdEx]))) + i-- + dAtA[i] = 0x2a } - i += n8 } - if len(m.PubKey) > 0 { + if len(m.Attributes) > 0 { + for k := range m.Attributes { + v := m.Attributes[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintServer(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i = encodeVarintServer(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = encodeVarintServer(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.TxID) > 0 { + i -= len(m.TxID) + copy(dAtA[i:], m.TxID) + i = encodeVarintServer(dAtA, i, uint64(len(m.TxID))) + i-- dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PubKey))) - i += copy(dAtA[i:], m.PubKey) } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + if m.Version != 0 { + i = encodeVarintServer(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x10 + } + if len(m.KeyBlobID) > 0 { + i -= len(m.KeyBlobID) + copy(dAtA[i:], m.KeyBlobID) + i = encodeVarintServer(dAtA, i, uint64(len(m.KeyBlobID))) + i-- + dAtA[i] = 0xa } - return i, nil + return len(dAtA) - i, nil } -func (m *VerifyInitResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func encodeVarintServer(dAtA []byte, offset int, v uint64) int { + offset -= sovServer(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ } - return dAtA[:n], nil + dAtA[offset] = uint8(v) + return base } - -func (m *VerifyInitResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i +func (m *GenerateRandomRequest) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + if m.Len != 0 { + n += 1 + sovServer(uint64(m.Len)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignUpdateRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *GenerateRandomResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + l = len(m.Rnd) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n } -func (m *SignUpdateRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i +func (m *DigestInitRequest) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } - if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignUpdateResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestInitResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignUpdateResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifyUpdateRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifyUpdateRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifyUpdateResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifyUpdateResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + l = len(m.Digest) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignFinalRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestUpdateRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignFinalRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignFinalResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestUpdateResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignFinalResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Signature) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) - i += copy(dAtA[i:], m.Signature) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifyFinalRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestKeyRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifyFinalRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.Signature) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) - i += copy(dAtA[i:], m.Signature) + l = len(m.Key) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifyFinalResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestKeyResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifyFinalResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestFinalRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) - } - if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestFinalResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Signature) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) - i += copy(dAtA[i:], m.Signature) + l = len(m.Digest) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifyRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DigestSingleRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n } -func (m *VerifyRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i +func (m *DigestSingleResponse) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.State) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.State))) - i += copy(dAtA[i:], m.State) + l = len(m.Digest) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.Data) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *EncryptInitRequest) Size() (n int) { + if m == nil { + return 0 } - if len(m.Signature) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) - i += copy(dAtA[i:], m.Signature) + var l int + _ = l + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifyResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptInitResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifyResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignSingleRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptInitRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignSingleRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.PrivKey) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKey))) - i += copy(dAtA[i:], m.PrivKey) - } if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n9, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n9 + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) } - if len(m.Data) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + l = len(m.Key) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SignSingleResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptInitResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SignSingleResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Signature) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) - i += copy(dAtA[i:], m.Signature) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifySingleRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptUpdateRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifySingleRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.PubKey) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PubKey))) - i += copy(dAtA[i:], m.PubKey) - } - if m.Mech != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n10, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n10 - } - if len(m.Data) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.Signature) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Signature))) - i += copy(dAtA[i:], m.Signature) + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *VerifySingleResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptUpdateResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *VerifySingleResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GenerateKeyRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptUpdateRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GenerateKeyRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n11, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n11 - } - if len(m.Template) > 0 { - for k, _ := range m.Template { - dAtA[i] = 0x12 - i++ - v := m.Template[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.KeyId) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.KeyId))) - i += copy(dAtA[i:], m.KeyId) + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GenerateKeyResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptUpdateResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GenerateKeyResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Key) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.CheckSum) > 0 { - dAtA[i] = 0x2a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.CheckSum))) - i += copy(dAtA[i:], m.CheckSum) + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GenerateKeyPairRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GenerateKeyPairRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.Mech != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n12, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n12 - } - if len(m.PubKeyTemplate) > 0 { - for k, _ := range m.PubKeyTemplate { - dAtA[i] = 0x12 - i++ - v := m.PubKeyTemplate[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } - } - if len(m.PrivKeyTemplate) > 0 { - for k, _ := range m.PrivKeyTemplate { - dAtA[i] = 0x1a - i++ - v := m.PrivKeyTemplate[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } - } - if len(m.PrivKeyId) > 0 { - dAtA[i] = 0x2a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKeyId))) - i += copy(dAtA[i:], m.PrivKeyId) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.PubKeyId) > 0 { - dAtA[i] = 0x32 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PubKeyId))) - i += copy(dAtA[i:], m.PubKeyId) + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GenerateKeyPairResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n } -func (m *GenerateKeyPairResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i +func (m *DecryptRequest) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.PrivKey) > 0 { - dAtA[i] = 0x2a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PrivKey))) - i += copy(dAtA[i:], m.PrivKey) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.PubKey) > 0 { - dAtA[i] = 0x32 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.PubKey))) - i += copy(dAtA[i:], m.PubKey) + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *WrapKeyRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *WrapKeyRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Key) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Key))) - i += copy(dAtA[i:], m.Key) + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.KeK) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.KeK))) - i += copy(dAtA[i:], m.KeK) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } - if len(m.MacKey) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.MacKey))) - i += copy(dAtA[i:], m.MacKey) + return n +} + +func (m *EncryptFinalRequest) Size() (n int) { + if m == nil { + return 0 } - if m.Mech != nil { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n13, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n13 + var l int + _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *WrapKeyResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptFinalResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *WrapKeyResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Wrapped) > 0 { - dAtA[i] = 0x2a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Wrapped))) - i += copy(dAtA[i:], m.Wrapped) + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *UnwrapKeyRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptFinalRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n } -func (m *UnwrapKeyRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i +func (m *DecryptFinalResponse) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.Wrapped) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Wrapped))) - i += copy(dAtA[i:], m.Wrapped) + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.KeK) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.KeK))) - i += copy(dAtA[i:], m.KeK) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } - if len(m.MacKey) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.MacKey))) - i += copy(dAtA[i:], m.MacKey) + return n +} + +func (m *EncryptSingleRequest) Size() (n int) { + if m == nil { + return 0 } - if m.Mech != nil { - dAtA[i] = 0x2a - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n14, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n14 + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.Template) > 0 { - for k, _ := range m.Template { - dAtA[i] = 0x32 - i++ - v := m.Template[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) } - if len(m.UnwrappedId) > 0 { - dAtA[i] = 0x3a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.UnwrappedId))) - i += copy(dAtA[i:], m.UnwrappedId) + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *UnwrapKeyResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *EncryptSingleResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *UnwrapKeyResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Unwrapped) > 0 { - dAtA[i] = 0x3a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Unwrapped))) - i += copy(dAtA[i:], m.Unwrapped) - } - if len(m.CheckSum) > 0 { - dAtA[i] = 0x42 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.CheckSum))) - i += copy(dAtA[i:], m.CheckSum) + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *DeriveKeyRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *DecryptSingleRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *DeriveKeyRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.Mech != nil { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech.Size())) - n15, err := m.Mech.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n15 + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) } - if len(m.Template) > 0 { - for k, _ := range m.Template { - dAtA[i] = 0x12 - i++ - v := m.Template[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } + l = len(m.Ciphered) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.BaseKey) > 0 { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.BaseKey))) - i += copy(dAtA[i:], m.BaseKey) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } - if len(m.Data) > 0 { - dAtA[i] = 0x22 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Data))) - i += copy(dAtA[i:], m.Data) + return n +} + +func (m *DecryptSingleResponse) Size() (n int) { + if m == nil { + return 0 } - if len(m.NewKeyId) > 0 { - dAtA[i] = 0x32 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.NewKeyId))) - i += copy(dAtA[i:], m.NewKeyId) + var l int + _ = l + l = len(m.Plain) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *DeriveKeyResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *SignInitRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *DeriveKeyResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.NewKey) > 0 { - dAtA[i] = 0x32 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.NewKey))) - i += copy(dAtA[i:], m.NewKey) + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) } - if len(m.CheckSum) > 0 { - dAtA[i] = 0x3a - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.CheckSum))) - i += copy(dAtA[i:], m.CheckSum) + l = len(m.PrivKey) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GetMechanismListRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *SignInitResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GetMechanismListRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GetMechanismListResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *VerifyInitRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GetMechanismListResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Mechs) > 0 { - dAtA17 := make([]byte, len(m.Mechs)*10) - var j16 int - for _, num := range m.Mechs { - for num >= 1<<7 { - dAtA17[j16] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j16++ - } - dAtA17[j16] = uint8(num) - j16++ - } - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(j16)) - i += copy(dAtA[i:], dAtA17[:j16]) + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.PubKey) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GetMechanismInfoRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *VerifyInitResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GetMechanismInfoRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.Mech != 0 { - dAtA[i] = 0x10 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mech)) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GetMechanismInfoResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *SignUpdateRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GetMechanismInfoResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.MechInfo != nil { - dAtA[i] = 0x1a - i++ - i = encodeVarintServer(dAtA, i, uint64(m.MechInfo.Size())) - n18, err := m.MechInfo.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n18 + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GetAttributeValueRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *SignUpdateResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GetAttributeValueRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Object) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Object))) - i += copy(dAtA[i:], m.Object) - } - if len(m.Attributes) > 0 { - for k, _ := range m.Attributes { - dAtA[i] = 0x12 - i++ - v := m.Attributes[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *GetAttributeValueResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *VerifyUpdateRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *GetAttributeValueResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Attributes) > 0 { - for k, _ := range m.Attributes { - dAtA[i] = 0x12 - i++ - v := m.Attributes[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SetAttributeValueRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *VerifyUpdateResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *SetAttributeValueRequest) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if len(m.Object) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Object))) - i += copy(dAtA[i:], m.Object) - } - if len(m.Attributes) > 0 { - for k, _ := range m.Attributes { - dAtA[i] = 0x12 - i++ - v := m.Attributes[k] - byteSize := 0 - if len(v) > 0 { - byteSize = 1 + len(v) + sovServer(uint64(len(v))) - } - mapSize := 1 + sovServer(uint64(k)) + byteSize - i = encodeVarintServer(dAtA, i, uint64(mapSize)) - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(k)) - if len(v) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(v))) - i += copy(dAtA[i:], v) - } - } + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *SetAttributeValueResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *SignFinalRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil + var l int + _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n } -func (m *SetAttributeValueResponse) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i +func (m *SignFinalResponse) Size() (n int) { + if m == nil { + return 0 + } var l int _ = l - if len(m.Object) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Object))) - i += copy(dAtA[i:], m.Object) + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *Mechanism) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *VerifyFinalRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *Mechanism) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.Mechanism != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Mechanism)) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if len(m.Parameter) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Parameter))) - i += copy(dAtA[i:], m.Parameter) + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *MechanismInfo) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *VerifyFinalResponse) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *MechanismInfo) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.MinKeySize != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.MinKeySize)) - } - if m.MaxKeySize != 0 { - dAtA[i] = 0x10 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.MaxKeySize)) - } - if m.Flags != 0 { - dAtA[i] = 0x18 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Flags)) - } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func (m *Grep11Error) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err +func (m *SignRequest) Size() (n int) { + if m == nil { + return 0 } - return dAtA[:n], nil -} - -func (m *Grep11Error) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i var l int _ = l - if m.Code != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintServer(dAtA, i, uint64(m.Code)) - } - if len(m.Detail) > 0 { - dAtA[i] = 0x12 - i++ - i = encodeVarintServer(dAtA, i, uint64(len(m.Detail))) - i += copy(dAtA[i:], m.Detail) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - if m.Retry { - dAtA[i] = 0x18 - i++ - if m.Retry { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i++ + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) + n += len(m.XXX_unrecognized) } - return i, nil + return n } -func encodeVarintServer(dAtA []byte, offset int, v uint64) int { - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return offset + 1 -} -func (m *GenerateRandomRequest) Size() (n int) { +func (m *SignResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Len != 0 { - n += 1 + sovServer(uint64(m.Len)) + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8241,13 +11900,21 @@ func (m *GenerateRandomRequest) Size() (n int) { return n } -func (m *GenerateRandomResponse) Size() (n int) { +func (m *VerifyRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Rnd) + l = len(m.State) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Signature) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8257,29 +11924,49 @@ func (m *GenerateRandomResponse) Size() (n int) { return n } -func (m *DigestInitRequest) Size() (n int) { +func (m *VerifyResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SignSingleRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l + l = len(m.PrivKey) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.Mech != nil { l = m.Mech.Size() n += 1 + l + sovServer(uint64(l)) } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestInitResponse) Size() (n int) { +func (m *SignSingleResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.Signature) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8289,121 +11976,240 @@ func (m *DigestInitResponse) Size() (n int) { return n } -func (m *DigestRequest) Size() (n int) { +func (m *VerifySingleRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.PubKey) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) + } l = len(m.Data) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestResponse) Size() (n int) { +func (m *VerifySingleResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Digest) - if l > 0 { + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GenerateKeyRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Mech != nil { + l = m.Mech.Size() n += 1 + l + sovServer(uint64(l)) } + if len(m.TemplateBytes) > 0 { + for k, v := range m.TemplateBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.Template) > 0 { + for k, v := range m.Template { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestUpdateRequest) Size() (n int) { +func (m *GenerateKeyResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.KeyBytes) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.Data) + l = len(m.CheckSum) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.Key != nil { + l = m.Key.Size() + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestUpdateResponse) Size() (n int) { +func (m *GenerateKeyPairRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { + if m.Mech != nil { + l = m.Mech.Size() n += 1 + l + sovServer(uint64(l)) } + if len(m.PubKeyTemplateBytes) > 0 { + for k, v := range m.PubKeyTemplateBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.PrivKeyTemplateBytes) > 0 { + for k, v := range m.PrivKeyTemplateBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.PrivKeyTemplate) > 0 { + for k, v := range m.PrivKeyTemplate { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.PubKeyTemplate) > 0 { + for k, v := range m.PubKeyTemplate { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestKeyRequest) Size() (n int) { +func (m *GenerateKeyPairResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.PrivKeyBytes) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.Key) + l = len(m.PubKeyBytes) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.PrivKey != nil { + l = m.PrivKey.Size() + n += 1 + l + sovServer(uint64(l)) + } + if m.PubKey != nil { + l = m.PubKey.Size() + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestKeyResponse) Size() (n int) { +func (m *WrapKeyRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.Key) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.KeK) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.MacKey) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.Mech != nil { + l = m.Mech.Size() + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DigestFinalRequest) Size() (n int) { +func (m *WrapKeyResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.Wrapped) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8413,35 +12219,52 @@ func (m *DigestFinalRequest) Size() (n int) { return n } -func (m *DigestFinalResponse) Size() (n int) { +func (m *UnwrapKeyRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Digest) + l = len(m.Wrapped) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + l = len(m.KeK) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - return n -} - -func (m *DigestSingleRequest) Size() (n int) { - if m == nil { - return 0 + l = len(m.MacKey) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) } - var l int - _ = l if m.Mech != nil { l = m.Mech.Size() n += 1 + l + sovServer(uint64(l)) } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if len(m.TemplateBytes) > 0 { + for k, v := range m.TemplateBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.Template) > 0 { + for k, v := range m.Template { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8449,23 +12272,31 @@ func (m *DigestSingleRequest) Size() (n int) { return n } -func (m *DigestSingleResponse) Size() (n int) { +func (m *UnwrapKeyResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Digest) + l = len(m.UnwrappedBytes) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.CheckSum) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.Unwrapped != nil { + l = m.Unwrapped.Size() + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *EncryptInitRequest) Size() (n int) { +func (m *DeriveKeyRequest) Size() (n int) { if m == nil { return 0 } @@ -8475,61 +12306,93 @@ func (m *EncryptInitRequest) Size() (n int) { l = m.Mech.Size() n += 1 + l + sovServer(uint64(l)) } - l = len(m.Key) + if len(m.TemplateBytes) > 0 { + for k, v := range m.TemplateBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + l = len(m.BaseKey) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.Data) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if len(m.Template) > 0 { + for k, v := range m.Template { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *EncryptInitResponse) Size() (n int) { +func (m *DeriveKeyResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.NewKeyBytes) + if l > 0 { + n += 1 + l + sovServer(uint64(l)) + } + l = len(m.CheckSum) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.NewKey != nil { + l = m.NewKey.Size() + n += 1 + l + sovServer(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DecryptInitRequest) Size() (n int) { +func (m *GetMechanismListRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Key) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DecryptInitResponse) Size() (n int) { +func (m *GetMechanismListResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if len(m.Mechs) > 0 { + l = 0 + for _, e := range m.Mechs { + l += sovServer(uint64(e)) + } + n += 1 + sovServer(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8537,19 +12400,14 @@ func (m *DecryptInitResponse) Size() (n int) { return n } -func (m *EncryptUpdateRequest) Size() (n int) { +func (m *GetMechanismInfoRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Plain) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.Mech != 0 { + n += 1 + sovServer(uint64(m.Mech)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8557,18 +12415,14 @@ func (m *EncryptUpdateRequest) Size() (n int) { return n } -func (m *EncryptUpdateResponse) Size() (n int) { +func (m *GetMechanismInfoResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Ciphered) - if l > 0 { + if m.MechInfo != nil { + l = m.MechInfo.Size() n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { @@ -8577,19 +12431,40 @@ func (m *EncryptUpdateResponse) Size() (n int) { return n } -func (m *DecryptUpdateRequest) Size() (n int) { +func (m *GetAttributeValueRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.Object) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.Ciphered) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if len(m.AttributesBytes) > 0 { + for k, v := range m.AttributesBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.Attributes) > 0 { + for k, v := range m.Attributes { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8597,19 +12472,23 @@ func (m *DecryptUpdateRequest) Size() (n int) { return n } -func (m *DecryptUpdateResponse) Size() (n int) { +func (m *GetAttributeValueResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Plain) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if len(m.AttributesBytes) > 0 { + for k, v := range m.AttributesBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8617,19 +12496,40 @@ func (m *DecryptUpdateResponse) Size() (n int) { return n } -func (m *EncryptRequest) Size() (n int) { +func (m *SetAttributeValueRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.Object) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.Plain) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if len(m.AttributesBytes) > 0 { + for k, v := range m.AttributesBytes { + _ = k + _ = v + l = 0 + if len(v) > 0 { + l = 1 + len(v) + sovServer(uint64(len(v))) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.Attributes) > 0 { + for k, v := range m.Attributes { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8637,13 +12537,13 @@ func (m *EncryptRequest) Size() (n int) { return n } -func (m *EncryptResponse) Size() (n int) { +func (m *SetAttributeValueResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Ciphered) + l = len(m.Object) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8653,19 +12553,17 @@ func (m *EncryptResponse) Size() (n int) { return n } -func (m *DecryptRequest) Size() (n int) { +func (m *Mechanism) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.Mechanism != 0 { + n += 1 + sovServer(uint64(m.Mechanism)) } - l = len(m.Ciphered) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.Parameter != nil { + n += m.Parameter.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8673,103 +12571,80 @@ func (m *DecryptRequest) Size() (n int) { return n } -func (m *DecryptResponse) Size() (n int) { +func (m *Mechanism_ParameterB) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Plain) - if l > 0 { + if m.ParameterB != nil { + l = len(m.ParameterB) n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } return n } - -func (m *EncryptFinalRequest) Size() (n int) { +func (m *Mechanism_RSAOAEPParameter) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { + if m.RSAOAEPParameter != nil { + l = m.RSAOAEPParameter.Size() n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } return n -} - -func (m *EncryptFinalResponse) Size() (n int) { +} +func (m *Mechanism_RSAPSSParameter) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Ciphered) - if l > 0 { + if m.RSAPSSParameter != nil { + l = m.RSAPSSParameter.Size() n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } return n } - -func (m *DecryptFinalRequest) Size() (n int) { +func (m *Mechanism_ECDH1DeriveParameter) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { + if m.ECDH1DeriveParameter != nil { + l = m.ECDH1DeriveParameter.Size() n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } return n } - -func (m *DecryptFinalResponse) Size() (n int) { +func (m *Mechanism_BTCDeriveParameter) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Plain) - if l > 0 { + if m.BTCDeriveParameter != nil { + l = m.BTCDeriveParameter.Size() n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } return n } - -func (m *EncryptSingleRequest) Size() (n int) { +func (m *MechanismInfo) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Key) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.MinKeySize != 0 { + n += 1 + sovServer(uint64(m.MinKeySize)) } - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) + if m.MaxKeySize != 0 { + n += 1 + sovServer(uint64(m.MaxKeySize)) } - l = len(m.Plain) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.Flags != 0 { + n += 1 + sovServer(uint64(m.Flags)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8777,37 +12652,44 @@ func (m *EncryptSingleRequest) Size() (n int) { return n } -func (m *EncryptSingleResponse) Size() (n int) { +func (m *Grep11Error) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Ciphered) + if m.Code != 0 { + n += 1 + sovServer(uint64(m.Code)) + } + l = len(m.Detail) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.Retry { + n += 2 + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *DecryptSingleRequest) Size() (n int) { +func (m *RSAOAEPParm) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Key) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.HashMech != 0 { + n += 1 + sovServer(uint64(m.HashMech)) } - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) + if m.Mgf != 0 { + n += 1 + sovServer(uint64(m.Mgf)) } - l = len(m.Ciphered) + if m.EncodingParmType != 0 { + n += 1 + sovServer(uint64(m.EncodingParmType)) + } + l = len(m.EncodingParm) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8817,15 +12699,20 @@ func (m *DecryptSingleRequest) Size() (n int) { return n } -func (m *DecryptSingleResponse) Size() (n int) { +func (m *RSAPSSParm) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Plain) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.HashMech != 0 { + n += 1 + sovServer(uint64(m.HashMech)) + } + if m.Mgf != 0 { + n += 1 + sovServer(uint64(m.Mgf)) + } + if m.SaltByteCount != 0 { + n += 1 + sovServer(uint64(m.SaltByteCount)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8833,17 +12720,20 @@ func (m *DecryptSingleResponse) Size() (n int) { return n } -func (m *SignInitRequest) Size() (n int) { +func (m *ECDH1DeriveParm) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Mech != nil { - l = m.Mech.Size() + if m.Kdf != 0 { + n += 1 + sovServer(uint64(m.Kdf)) + } + l = len(m.SharedData) + if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.PrivKey) + l = len(m.PublicData) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8853,35 +12743,39 @@ func (m *SignInitRequest) Size() (n int) { return n } -func (m *SignInitResponse) Size() (n int) { +func (m *BTCDeriveParm) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + if m.Type != 0 { + n += 1 + sovServer(uint64(m.Type)) + } + if m.ChildKeyIndex != 0 { + n += 1 + sovServer(uint64(m.ChildKeyIndex)) + } + l = len(m.ChainCode) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if m.Version != 0 { + n += 1 + sovServer(uint64(m.Version)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *VerifyInitRequest) Size() (n int) { +func (m *HMACGeneralParm) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.PubKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.ReturnByteCount != 0 { + n += 1 + sovServer(uint64(m.ReturnByteCount)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8889,13 +12783,13 @@ func (m *VerifyInitRequest) Size() (n int) { return n } -func (m *VerifyInitResponse) Size() (n int) { +func (m *ReEncryptRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.WrappedKey) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8905,17 +12799,13 @@ func (m *VerifyInitResponse) Size() (n int) { return n } -func (m *SignUpdateRequest) Size() (n int) { +func (m *ReEncryptResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Data) + l = len(m.RewrappedKey) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8925,13 +12815,13 @@ func (m *SignUpdateRequest) Size() (n int) { return n } -func (m *SignUpdateResponse) Size() (n int) { +func (m *RewrapKeyBlobRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.WrappedKey) if l > 0 { n += 1 + l + sovServer(uint64(l)) } @@ -8941,18 +12831,18 @@ func (m *SignUpdateResponse) Size() (n int) { return n } -func (m *VerifyUpdateRequest) Size() (n int) { +func (m *RewrapKeyBlobResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.RewrappedKey) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.Data) - if l > 0 { + if m.KeyBlob != nil { + l = m.KeyBlob.Size() n += 1 + l + sovServer(uint64(l)) } if m.XXX_unrecognized != nil { @@ -8961,15 +12851,14 @@ func (m *VerifyUpdateRequest) Size() (n int) { return n } -func (m *VerifyUpdateResponse) Size() (n int) { +func (m *AttributeValue) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if m.OneAttr != nil { + n += m.OneAttr.Size() } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8977,744 +12866,1866 @@ func (m *VerifyUpdateResponse) Size() (n int) { return n } -func (m *SignFinalRequest) Size() (n int) { +func (m *AttributeValue_AttributeB) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) - if l > 0 { + if m.AttributeB != nil { + l = len(m.AttributeB) n += 1 + l + sovServer(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } return n } - -func (m *SignFinalResponse) Size() (n int) { +func (m *AttributeValue_AttributeTF) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + n += 2 + return n +} +func (m *AttributeValue_AttributeI) Size() (n int) { + if m == nil { + return 0 } + var l int + _ = l + n += 1 + sovServer(uint64(m.AttributeI)) return n } - -func (m *VerifyFinalRequest) Size() (n int) { +func (m *KeyBlob) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.State) + l = len(m.KeyBlobID) if l > 0 { n += 1 + l + sovServer(uint64(l)) } - l = len(m.Signature) + if m.Version != 0 { + n += 1 + sovServer(uint64(m.Version)) + } + l = len(m.TxID) if l > 0 { n += 1 + l + sovServer(uint64(l)) } + if len(m.Attributes) > 0 { + for k, v := range m.Attributes { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovServer(uint64(l)) + } + mapEntrySize := 1 + sovServer(uint64(k)) + l + n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + } + if len(m.KeyBlobs) > 0 { + for _, b := range m.KeyBlobs { + l = len(b) + n += 1 + l + sovServer(uint64(l)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *VerifyFinalResponse) Size() (n int) { - if m == nil { - return 0 +func sovServer(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozServer(x uint64) (n int) { + return sovServer(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GenerateRandomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenerateRandomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Len", wireType) + } + m.Len = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Len |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GenerateRandomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenerateRandomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rnd", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rnd = append(m.Rnd[:0], dAtA[iNdEx:postIndex]...) + if m.Rnd == nil { + m.Rnd = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *SignRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *SignResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestInitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *VerifyRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.State) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *VerifyResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestInitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *SignSingleRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.PrivKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *SignSingleResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DigestRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *VerifySingleRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.PubKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if iNdEx > l { + return io.ErrUnexpectedEOF } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + return nil +} +func (m *DigestResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...) + if m.Digest == nil { + m.Digest = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *VerifySingleResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *GenerateKeyRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - if len(m.Template) > 0 { - for k, v := range m.Template { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) +func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestUpdateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - l = len(m.KeyId) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} -func (m *GenerateKeyResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Key) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.CheckSum) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *GenerateKeyPairRequest) Size() (n int) { - if m == nil { - return 0 +func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestUpdateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - var l int - _ = l - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) + + if iNdEx > l { + return io.ErrUnexpectedEOF } - if len(m.PubKeyTemplate) > 0 { - for k, v := range m.PubKeyTemplate { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) + return nil +} +func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) } - } - if len(m.PrivKeyTemplate) > 0 { - for k, v := range m.PrivKeyTemplate { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestKeyRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - l = len(m.PrivKeyId) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.PubKeyId) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} -func (m *GenerateKeyPairResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.PrivKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.PubKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *WrapKeyRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Key) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.KeK) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.MacKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestKeyResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *WrapKeyResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Wrapped) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *UnwrapKeyRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Wrapped) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.KeK) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.MacKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - if len(m.Template) > 0 { - for k, v := range m.Template { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) +func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestFinalRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - l = len(m.UnwrappedId) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} -func (m *UnwrapKeyResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Unwrapped) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.CheckSum) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *DeriveKeyRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Mech != nil { - l = m.Mech.Size() - n += 1 + l + sovServer(uint64(l)) - } - if len(m.Template) > 0 { - for k, v := range m.Template { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) +func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestFinalResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...) + if m.Digest == nil { + m.Digest = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - l = len(m.BaseKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.NewKeyId) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *DeriveKeyResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.NewKey) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - l = len(m.CheckSum) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} -func (m *GetMechanismListRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *GetMechanismListResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Mechs) > 0 { - l = 0 - for _, e := range m.Mechs { - l += sovServer(uint64(e)) +func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestSingleRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } - n += 1 + sovServer(uint64(l)) + l - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) } - return n -} -func (m *GetMechanismInfoRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Mech != 0 { - n += 1 + sovServer(uint64(m.Mech)) + if iNdEx > l { + return io.ErrUnexpectedEOF } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + return nil +} +func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DigestSingleResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DigestSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...) + if m.Digest == nil { + m.Digest = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *GetMechanismInfoResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.MechInfo != nil { - l = m.MechInfo.Size() - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *GetAttributeValueRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Object) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if len(m.Attributes) > 0 { - for k, v := range m.Attributes { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) +func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) } - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *GetAttributeValueResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Attributes) > 0 { - for k, v := range m.Attributes { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EncryptInitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EncryptInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} -func (m *SetAttributeValueRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Object) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) + if iNdEx > l { + return io.ErrUnexpectedEOF } - if len(m.Attributes) > 0 { - for k, v := range m.Attributes { - _ = k - _ = v - l = 0 - if len(v) > 0 { - l = 1 + len(v) + sovServer(uint64(len(v))) + return nil +} +func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EncryptInitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EncryptInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF } - mapEntrySize := 1 + sovServer(uint64(k)) + l - n += mapEntrySize + 1 + sovServer(uint64(mapEntrySize)) + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} -func (m *SetAttributeValueResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Object) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *Mechanism) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Mechanism != 0 { - n += 1 + sovServer(uint64(m.Mechanism)) - } - l = len(m.Parameter) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DecryptInitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DecryptInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func (m *MechanismInfo) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.MinKeySize != 0 { - n += 1 + sovServer(uint64(m.MinKeySize)) - } - if m.MaxKeySize != 0 { - n += 1 + sovServer(uint64(m.MaxKeySize)) - } - if m.Flags != 0 { - n += 1 + sovServer(uint64(m.Flags)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n + return nil } - -func (m *Grep11Error) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Code != 0 { - n += 1 + sovServer(uint64(m.Code)) - } - l = len(m.Detail) - if l > 0 { - n += 1 + l + sovServer(uint64(l)) - } - if m.Retry { - n += 2 - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DecryptInitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DecryptInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } } - return n -} -func sovServer(x uint64) (n int) { - for { - n++ - x >>= 7 - if x == 0 { - break - } + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n -} -func sozServer(x uint64) (n int) { - return sovServer(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return nil } -func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { +func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9729,7 +14740,7 @@ func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -9737,17 +14748,51 @@ func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GenerateRandomRequest: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptUpdateRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GenerateRandomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Len", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } - m.Len = 0 + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + } + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -9757,11 +14802,26 @@ func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Len |= (uint64(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -9771,6 +14831,9 @@ func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -9784,7 +14847,7 @@ func (m *GenerateRandomRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { +func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9799,7 +14862,7 @@ func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -9807,15 +14870,15 @@ func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GenerateRandomResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptUpdateResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GenerateRandomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Rnd", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -9827,7 +14890,7 @@ func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -9836,12 +14899,49 @@ func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Rnd = append(m.Rnd[:0], dAtA[iNdEx:postIndex]...) - if m.Rnd == nil { - m.Rnd = []byte{} + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -9853,6 +14953,9 @@ func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -9866,7 +14969,7 @@ func (m *GenerateRandomResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { +func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9881,7 +14984,7 @@ func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -9889,17 +14992,17 @@ func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestInitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptUpdateRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -9909,23 +15012,58 @@ func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -9937,6 +15075,9 @@ func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -9950,7 +15091,7 @@ func (m *DigestInitRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { +func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9965,7 +15106,7 @@ func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -9973,10 +15114,10 @@ func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestInitResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptUpdateResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -9993,7 +15134,41 @@ func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10002,12 +15177,15 @@ func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} } iNdEx = postIndex default: @@ -10019,6 +15197,9 @@ func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10032,7 +15213,7 @@ func (m *DigestInitResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestRequest) Unmarshal(dAtA []byte) error { +func (m *EncryptRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10047,7 +15228,7 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10055,10 +15236,10 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestRequest: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10075,7 +15256,7 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10084,6 +15265,9 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -10094,7 +15278,7 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10106,7 +15290,7 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10115,12 +15299,15 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} } iNdEx = postIndex default: @@ -10132,6 +15319,9 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10145,7 +15335,7 @@ func (m *DigestRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestResponse) Unmarshal(dAtA []byte) error { +func (m *EncryptResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10160,7 +15350,7 @@ func (m *DigestResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10168,15 +15358,15 @@ func (m *DigestResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10188,7 +15378,7 @@ func (m *DigestResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10197,12 +15387,15 @@ func (m *DigestResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...) - if m.Digest == nil { - m.Digest = []byte{} + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -10214,6 +15407,9 @@ func (m *DigestResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10227,7 +15423,7 @@ func (m *DigestResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { +func (m *DecryptRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10242,7 +15438,7 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10250,10 +15446,10 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestUpdateRequest: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10270,7 +15466,7 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10279,6 +15475,9 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -10289,7 +15488,7 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10301,7 +15500,7 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10310,12 +15509,15 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -10327,6 +15529,9 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10340,7 +15545,7 @@ func (m *DigestUpdateRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { +func (m *DecryptResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10355,7 +15560,7 @@ func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10363,15 +15568,15 @@ func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestUpdateResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10383,7 +15588,7 @@ func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10392,12 +15597,15 @@ func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} } iNdEx = postIndex default: @@ -10409,6 +15617,9 @@ func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10422,7 +15633,7 @@ func (m *DigestUpdateResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { +func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10437,7 +15648,7 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10445,10 +15656,10 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestKeyRequest: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptFinalRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10465,7 +15676,7 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10474,6 +15685,9 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -10482,37 +15696,6 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { m.State = []byte{} } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -10522,6 +15705,9 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10535,7 +15721,7 @@ func (m *DigestKeyRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { +func (m *EncryptFinalResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10550,7 +15736,7 @@ func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10558,15 +15744,15 @@ func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestKeyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptFinalResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10578,7 +15764,7 @@ func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10587,12 +15773,15 @@ func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -10604,6 +15793,9 @@ func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10617,7 +15809,7 @@ func (m *DigestKeyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { +func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10632,7 +15824,7 @@ func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10640,10 +15832,10 @@ func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestFinalRequest: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptFinalRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10660,7 +15852,7 @@ func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10669,6 +15861,9 @@ func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -10686,6 +15881,9 @@ func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10699,7 +15897,7 @@ func (m *DigestFinalRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { +func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10714,7 +15912,7 @@ func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10722,15 +15920,15 @@ func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestFinalResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptFinalResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10742,7 +15940,7 @@ func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10751,12 +15949,15 @@ func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...) - if m.Digest == nil { - m.Digest = []byte{} + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} } iNdEx = postIndex default: @@ -10768,6 +15969,9 @@ func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10781,7 +15985,7 @@ func (m *DigestFinalResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { +func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10796,7 +16000,7 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10804,13 +16008,47 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestSingleRequest: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptSingleRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) } @@ -10824,7 +16062,7 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10833,6 +16071,9 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -10843,9 +16084,9 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10857,7 +16098,7 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10866,12 +16107,15 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} } iNdEx = postIndex default: @@ -10883,6 +16127,9 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10896,7 +16143,7 @@ func (m *DigestSingleRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { +func (m *EncryptSingleResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10911,7 +16158,7 @@ func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -10919,15 +16166,15 @@ func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DigestSingleResponse: wiretype end group for non-group") + return fmt.Errorf("proto: EncryptSingleResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DigestSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: EncryptSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10939,7 +16186,7 @@ func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -10948,12 +16195,15 @@ func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Digest = append(m.Digest[:0], dAtA[iNdEx:postIndex]...) - if m.Digest == nil { - m.Digest = []byte{} + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -10965,6 +16215,9 @@ func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -10978,7 +16231,7 @@ func (m *DigestSingleResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { +func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10993,7 +16246,7 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11001,12 +16254,46 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptInitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptSingleRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) @@ -11021,7 +16308,7 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11030,6 +16317,9 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -11042,7 +16332,7 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11054,7 +16344,7 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11063,12 +16353,15 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} + m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) + if m.Ciphered == nil { + m.Ciphered = []byte{} } iNdEx = postIndex default: @@ -11080,6 +16373,9 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11093,7 +16389,7 @@ func (m *EncryptInitRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { +func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11108,7 +16404,7 @@ func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11116,15 +16412,15 @@ func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptInitResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DecryptSingleResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DecryptSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11136,7 +16432,7 @@ func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11145,12 +16441,15 @@ func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) + if m.Plain == nil { + m.Plain = []byte{} } iNdEx = postIndex default: @@ -11162,6 +16461,9 @@ func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11175,7 +16477,7 @@ func (m *EncryptInitResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { +func (m *SignInitRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11190,7 +16492,7 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11198,10 +16500,10 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptInitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SignInitRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 2: @@ -11218,7 +16520,7 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11227,6 +16529,9 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -11239,7 +16544,7 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11251,7 +16556,7 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11260,12 +16565,15 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} + m.PrivKey = append(m.PrivKey[:0], dAtA[iNdEx:postIndex]...) + if m.PrivKey == nil { + m.PrivKey = []byte{} } iNdEx = postIndex default: @@ -11277,6 +16585,9 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11290,7 +16601,7 @@ func (m *DecryptInitRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { +func (m *SignInitResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11305,7 +16616,7 @@ func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11313,10 +16624,10 @@ func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptInitResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SignInitResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11333,7 +16644,7 @@ func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11342,6 +16653,9 @@ func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -11359,6 +16673,9 @@ func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11372,7 +16689,7 @@ func (m *DecryptInitResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { +func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11387,7 +16704,7 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11395,17 +16712,17 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptUpdateRequest: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyInitRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -11415,26 +16732,31 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11446,7 +16768,7 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11455,12 +16777,15 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...) + if m.PubKey == nil { + m.PubKey = []byte{} } iNdEx = postIndex default: @@ -11472,6 +16797,9 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11485,7 +16813,7 @@ func (m *EncryptUpdateRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { +func (m *VerifyInitResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11500,7 +16828,7 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11508,10 +16836,10 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptUpdateResponse: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyInitResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11528,7 +16856,7 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11537,6 +16865,9 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -11545,37 +16876,6 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { m.State = []byte{} } iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -11585,6 +16885,9 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11598,7 +16901,7 @@ func (m *EncryptUpdateResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { +func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11613,7 +16916,7 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11621,10 +16924,10 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptUpdateRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SignUpdateRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11641,7 +16944,7 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11650,6 +16953,9 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -11660,7 +16966,7 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11672,7 +16978,7 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11681,12 +16987,15 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex default: @@ -11698,6 +17007,9 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11711,7 +17023,7 @@ func (m *DecryptUpdateRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { +func (m *SignUpdateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11724,56 +17036,25 @@ func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { if iNdEx >= l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: DecryptUpdateResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 3: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SignUpdateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SignUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11785,7 +17066,7 @@ func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11794,12 +17075,15 @@ func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} } iNdEx = postIndex default: @@ -11811,6 +17095,9 @@ func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11824,7 +17111,7 @@ func (m *DecryptUpdateResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptRequest) Unmarshal(dAtA []byte) error { +func (m *VerifyUpdateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11839,7 +17126,7 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11847,10 +17134,10 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptRequest: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyUpdateRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11867,7 +17154,7 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11876,6 +17163,9 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -11886,7 +17176,7 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11898,7 +17188,7 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11907,12 +17197,15 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex default: @@ -11924,6 +17217,9 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -11937,7 +17233,7 @@ func (m *EncryptRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptResponse) Unmarshal(dAtA []byte) error { +func (m *VerifyUpdateResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11952,7 +17248,7 @@ func (m *EncryptResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -11960,15 +17256,15 @@ func (m *EncryptResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptResponse: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyUpdateResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 3: + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11980,7 +17276,7 @@ func (m *EncryptResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -11989,12 +17285,15 @@ func (m *EncryptResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} } iNdEx = postIndex default: @@ -12006,6 +17305,9 @@ func (m *EncryptResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12019,7 +17321,7 @@ func (m *EncryptResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptRequest) Unmarshal(dAtA []byte) error { +func (m *SignFinalRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12034,7 +17336,7 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12042,10 +17344,10 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SignFinalRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -12062,7 +17364,7 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12071,6 +17373,9 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -12079,37 +17384,6 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { m.State = []byte{} } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -12119,6 +17393,9 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12132,7 +17409,7 @@ func (m *DecryptRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptResponse) Unmarshal(dAtA []byte) error { +func (m *SignFinalResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12147,7 +17424,7 @@ func (m *DecryptResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12155,15 +17432,15 @@ func (m *DecryptResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SignFinalResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12175,7 +17452,7 @@ func (m *DecryptResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12184,12 +17461,15 @@ func (m *DecryptResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex default: @@ -12201,6 +17481,9 @@ func (m *DecryptResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12214,7 +17497,7 @@ func (m *DecryptResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { +func (m *VerifyFinalRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12229,7 +17512,7 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12237,10 +17520,10 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptFinalRequest: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyFinalRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -12257,7 +17540,7 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12266,6 +17549,9 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -12274,6 +17560,40 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { m.State = []byte{} } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -12283,6 +17603,9 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12296,7 +17619,7 @@ func (m *EncryptFinalRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptFinalResponse) Unmarshal(dAtA []byte) error { +func (m *VerifyFinalResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12311,7 +17634,7 @@ func (m *EncryptFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12319,43 +17642,12 @@ func (m *EncryptFinalResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptFinalResponse: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyFinalResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -12365,6 +17657,9 @@ func (m *EncryptFinalResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12378,7 +17673,7 @@ func (m *EncryptFinalResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { +func (m *SignRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12393,7 +17688,7 @@ func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12401,15 +17696,49 @@ func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptFinalRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SignRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12421,7 +17750,7 @@ func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12430,12 +17759,15 @@ func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex default: @@ -12447,6 +17779,9 @@ func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12460,7 +17795,7 @@ func (m *DecryptFinalRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { +func (m *SignResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12475,7 +17810,7 @@ func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12483,15 +17818,15 @@ func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptFinalResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SignResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12503,7 +17838,7 @@ func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12512,12 +17847,15 @@ func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex default: @@ -12529,6 +17867,9 @@ func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12542,7 +17883,7 @@ func (m *DecryptFinalResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { +func (m *VerifyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12557,7 +17898,7 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12565,15 +17906,15 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptSingleRequest: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12585,7 +17926,7 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12594,19 +17935,22 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} + m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) + if m.State == nil { + m.State = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -12616,28 +17960,29 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} - } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12649,7 +17994,7 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12658,12 +18003,15 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex default: @@ -12675,6 +18023,9 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12688,7 +18039,7 @@ func (m *EncryptSingleRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *EncryptSingleResponse) Unmarshal(dAtA []byte) error { +func (m *VerifyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12703,7 +18054,7 @@ func (m *EncryptSingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12711,43 +18062,12 @@ func (m *EncryptSingleResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: EncryptSingleResponse: wiretype end group for non-group") + return fmt.Errorf("proto: VerifyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: EncryptSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -12757,6 +18077,9 @@ func (m *EncryptSingleResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12770,7 +18093,7 @@ func (m *EncryptSingleResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { +func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12785,7 +18108,7 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12793,15 +18116,15 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptSingleRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SignSingleRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12813,7 +18136,7 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12822,12 +18145,15 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} + m.PrivKey = append(m.PrivKey[:0], dAtA[iNdEx:postIndex]...) + if m.PrivKey == nil { + m.PrivKey = []byte{} } iNdEx = postIndex case 2: @@ -12844,7 +18170,7 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12853,6 +18179,9 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -12865,7 +18194,7 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ciphered", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12877,7 +18206,7 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12886,12 +18215,15 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Ciphered = append(m.Ciphered[:0], dAtA[iNdEx:postIndex]...) - if m.Ciphered == nil { - m.Ciphered = []byte{} + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex default: @@ -12903,6 +18235,9 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12916,7 +18251,7 @@ func (m *DecryptSingleRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { +func (m *SignSingleResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12931,7 +18266,7 @@ func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -12939,15 +18274,15 @@ func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DecryptSingleResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SignSingleResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DecryptSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -12959,7 +18294,7 @@ func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -12968,12 +18303,15 @@ func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Plain = append(m.Plain[:0], dAtA[iNdEx:postIndex]...) - if m.Plain == nil { - m.Plain = []byte{} + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex default: @@ -12985,6 +18323,9 @@ func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -12998,7 +18339,7 @@ func (m *DecryptSingleResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignInitRequest) Unmarshal(dAtA []byte) error { +func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13013,7 +18354,7 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -13021,12 +18362,46 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignInitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: VerifySingleRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifySingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...) + if m.PubKey == nil { + m.PubKey = []byte{} + } + iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) @@ -13041,7 +18416,7 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13050,6 +18425,9 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -13062,7 +18440,7 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -13074,7 +18452,7 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13083,12 +18461,49 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.PrivKey = append(m.PrivKey[:0], dAtA[iNdEx:postIndex]...) - if m.PrivKey == nil { - m.PrivKey = []byte{} + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex default: @@ -13097,7 +18512,10 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { if err != nil { return err } - if skippy < 0 { + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthServer } if (iNdEx + skippy) > l { @@ -13113,7 +18531,7 @@ func (m *SignInitRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignInitResponse) Unmarshal(dAtA []byte) error { +func (m *VerifySingleResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13128,7 +18546,7 @@ func (m *SignInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -13136,43 +18554,12 @@ func (m *SignInitResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignInitResponse: wiretype end group for non-group") + return fmt.Errorf("proto: VerifySingleResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: VerifySingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -13182,6 +18569,9 @@ func (m *SignInitResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -13195,7 +18585,7 @@ func (m *SignInitResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { +func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13210,7 +18600,7 @@ func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -13218,13 +18608,13 @@ func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: VerifyInitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GenerateKeyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyInitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GenerateKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: + case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) } @@ -13238,7 +18628,7 @@ func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13247,6 +18637,9 @@ func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -13257,11 +18650,11 @@ func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TemplateBytes", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13271,79 +18664,111 @@ func (m *VerifyInitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...) - if m.PubKey == nil { - m.PubKey = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *VerifyInitResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.TemplateBytes == nil { + m.TemplateBytes = make(map[ep11.Attribute][]byte) } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: VerifyInitResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyInitResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.TemplateBytes[ep11.Attribute(mapkey)] = mapvalue + iNdEx = postIndex + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13353,22 +18778,106 @@ func (m *VerifyInitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} - } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Template == nil { + m.Template = make(map[ep11.Attribute]*AttributeValue) + } + var mapkey uint64 + var mapvalue *AttributeValue + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthServer + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Template[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -13379,6 +18888,9 @@ func (m *VerifyInitResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -13392,7 +18904,7 @@ func (m *VerifyInitResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { +func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13407,7 +18919,7 @@ func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -13415,15 +18927,15 @@ func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignUpdateRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GenerateKeyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GenerateKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KeyBytes", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -13435,7 +18947,7 @@ func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13444,17 +18956,20 @@ func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.KeyBytes = append(m.KeyBytes[:0], dAtA[iNdEx:postIndex]...) + if m.KeyBytes == nil { + m.KeyBytes = []byte{} } iNdEx = postIndex - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CheckSum", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -13466,7 +18981,7 @@ func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13475,70 +18990,22 @@ func (m *SignUpdateRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { + if postIndex < 0 { return ErrInvalidLengthServer } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SignUpdateResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + m.CheckSum = append(m.CheckSum[:0], dAtA[iNdEx:postIndex]...) + if m.CheckSum == nil { + m.CheckSum = []byte{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SignUpdateResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SignUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13548,21 +19015,26 @@ func (m *SignUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + if m.Key == nil { + m.Key = &KeyBlob{} + } + if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -13574,6 +19046,9 @@ func (m *SignUpdateResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -13587,7 +19062,7 @@ func (m *SignUpdateResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *VerifyUpdateRequest) Unmarshal(dAtA []byte) error { +func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13602,7 +19077,7 @@ func (m *VerifyUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -13610,17 +19085,17 @@ func (m *VerifyUpdateRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: VerifyUpdateRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GenerateKeyPairRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GenerateKeyPairRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13630,28 +19105,33 @@ func (m *VerifyUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PubKeyTemplateBytes", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13661,79 +19141,111 @@ func (m *VerifyUpdateRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *VerifyUpdateResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.PubKeyTemplateBytes == nil { + m.PubKeyTemplateBytes = make(map[ep11.Attribute][]byte) } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: VerifyUpdateResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.PubKeyTemplateBytes[ep11.Attribute(mapkey)] = mapvalue + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PrivKeyTemplateBytes", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13743,79 +19255,226 @@ func (m *VerifyUpdateResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + if m.PrivKeyTemplateBytes == nil { + m.PrivKeyTemplateBytes = make(map[ep11.Attribute][]byte) + } + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.PrivKeyTemplateBytes[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrivKeyTemplate", wireType) } - if skippy < 0 { - return ErrInvalidLengthServer + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthServer } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SignFinalRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + if m.PrivKeyTemplate == nil { + m.PrivKeyTemplate = make(map[ep11.Attribute]*AttributeValue) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SignFinalRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SignFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + var mapkey uint64 + var mapvalue *AttributeValue + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthServer + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.PrivKeyTemplate[ep11.Attribute(mapkey)] = mapvalue + iNdEx = postIndex + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PubKeyTemplate", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -13825,22 +19484,106 @@ func (m *SignFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + if m.PubKeyTemplate == nil { + m.PubKeyTemplate = make(map[ep11.Attribute]*AttributeValue) + } + var mapkey uint64 + var mapvalue *AttributeValue + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthServer + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.PubKeyTemplate[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -13851,6 +19594,9 @@ func (m *SignFinalRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -13864,7 +19610,7 @@ func (m *SignFinalRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignFinalResponse) Unmarshal(dAtA []byte) error { +func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13879,7 +19625,7 @@ func (m *SignFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -13887,15 +19633,15 @@ func (m *SignFinalResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignFinalResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GenerateKeyPairResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GenerateKeyPairResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PrivKeyBytes", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -13907,7 +19653,7 @@ func (m *SignFinalResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13916,68 +19662,20 @@ func (m *SignFinalResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { + if postIndex < 0 { return ErrInvalidLengthServer } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *VerifyFinalRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + m.PrivKeyBytes = append(m.PrivKeyBytes[:0], dAtA[iNdEx:postIndex]...) + if m.PrivKeyBytes == nil { + m.PrivKeyBytes = []byte{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: VerifyFinalRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyFinalRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PubKeyBytes", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -13989,7 +19687,7 @@ func (m *VerifyFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -13998,19 +19696,22 @@ func (m *VerifyFinalRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.PubKeyBytes = append(m.PubKeyBytes[:0], dAtA[iNdEx:postIndex]...) + if m.PubKeyBytes == nil { + m.PubKeyBytes = []byte{} } iNdEx = postIndex - case 2: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -14020,81 +19721,74 @@ func (m *VerifyFinalRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} + if m.PrivKey == nil { + m.PrivKey = &KeyBlob{} } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { + if err := m.PrivKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { - return ErrInvalidLengthServer + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *VerifyFinalResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer + if msglen < 0 { + return ErrInvalidLengthServer } - if iNdEx >= l { + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + if m.PubKey == nil { + m.PubKey = &KeyBlob{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: VerifyFinalResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyFinalResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) if err != nil { return err } - if skippy < 0 { + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthServer } if (iNdEx + skippy) > l { @@ -14110,7 +19804,7 @@ func (m *VerifyFinalResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignRequest) Unmarshal(dAtA []byte) error { +func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14125,7 +19819,7 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -14133,15 +19827,15 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignRequest: wiretype end group for non-group") + return fmt.Errorf("proto: WrapKeyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WrapKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14153,7 +19847,7 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14162,17 +19856,20 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KeK", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14184,7 +19881,7 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14193,12 +19890,85 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + m.KeK = append(m.KeK[:0], dAtA[iNdEx:postIndex]...) + if m.KeK == nil { + m.KeK = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MacKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MacKey = append(m.MacKey[:0], dAtA[iNdEx:postIndex]...) + if m.MacKey == nil { + m.MacKey = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -14210,6 +19980,9 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -14223,7 +19996,7 @@ func (m *SignRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignResponse) Unmarshal(dAtA []byte) error { +func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14238,7 +20011,7 @@ func (m *SignResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -14246,15 +20019,15 @@ func (m *SignResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignResponse: wiretype end group for non-group") + return fmt.Errorf("proto: WrapKeyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WrapKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 3: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Wrapped", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14266,7 +20039,7 @@ func (m *SignResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14275,12 +20048,15 @@ func (m *SignResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} + m.Wrapped = append(m.Wrapped[:0], dAtA[iNdEx:postIndex]...) + if m.Wrapped == nil { + m.Wrapped = []byte{} } iNdEx = postIndex default: @@ -14292,6 +20068,9 @@ func (m *SignResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -14305,7 +20084,7 @@ func (m *SignResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *VerifyRequest) Unmarshal(dAtA []byte) error { +func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14320,7 +20099,7 @@ func (m *VerifyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -14328,15 +20107,15 @@ func (m *VerifyRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: VerifyRequest: wiretype end group for non-group") + return fmt.Errorf("proto: UnwrapKeyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UnwrapKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Wrapped", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14348,7 +20127,7 @@ func (m *VerifyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14357,48 +20136,20 @@ func (m *VerifyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.State = append(m.State[:0], dAtA[iNdEx:postIndex]...) - if m.State == nil { - m.State = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + m.Wrapped = append(m.Wrapped[:0], dAtA[iNdEx:postIndex]...) + if m.Wrapped == nil { + m.Wrapped = []byte{} } iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KeK", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14410,7 +20161,7 @@ func (m *VerifyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14418,120 +20169,21 @@ func (m *VerifyRequest) Unmarshal(dAtA []byte) error { if byteLen < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *VerifyResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: VerifyResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: VerifyResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + m.KeK = append(m.KeK[:0], dAtA[iNdEx:postIndex]...) + if m.KeK == nil { + m.KeK = []byte{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SignSingleRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SignSingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MacKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14543,7 +20195,7 @@ func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14552,15 +20204,18 @@ func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.PrivKey = append(m.PrivKey[:0], dAtA[iNdEx:postIndex]...) - if m.PrivKey == nil { - m.PrivKey = []byte{} + m.MacKey = append(m.MacKey[:0], dAtA[iNdEx:postIndex]...) + if m.MacKey == nil { + m.MacKey = []byte{} } iNdEx = postIndex - case 2: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) } @@ -14574,7 +20229,7 @@ func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14583,6 +20238,9 @@ func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -14593,11 +20251,11 @@ func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 3: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TemplateBytes", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -14607,79 +20265,111 @@ func (m *SignSingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SignSingleResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.TemplateBytes == nil { + m.TemplateBytes = make(map[ep11.Attribute][]byte) } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SignSingleResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SignSingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 4: + m.TemplateBytes[ep11.Attribute(mapkey)] = mapvalue + iNdEx = postIndex + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -14689,22 +20379,106 @@ func (m *SignSingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} - } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Template == nil { + m.Template = make(map[ep11.Attribute]*AttributeValue) + } + var mapkey uint64 + var mapvalue *AttributeValue + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthServer + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Template[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -14715,6 +20489,9 @@ func (m *SignSingleResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -14728,7 +20505,7 @@ func (m *SignSingleResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { +func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14743,7 +20520,7 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -14751,15 +20528,15 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: VerifySingleRequest: wiretype end group for non-group") + return fmt.Errorf("proto: UnwrapKeyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: VerifySingleRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UnwrapKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UnwrappedBytes", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14771,7 +20548,7 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14780,50 +20557,20 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...) - if m.PubKey == nil { - m.PubKey = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} - } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.UnwrappedBytes = append(m.UnwrappedBytes[:0], dAtA[iNdEx:postIndex]...) + if m.UnwrappedBytes == nil { + m.UnwrappedBytes = []byte{} } iNdEx = postIndex - case 3: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CheckSum", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -14835,7 +20582,7 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -14844,19 +20591,22 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + m.CheckSum = append(m.CheckSum[:0], dAtA[iNdEx:postIndex]...) + if m.CheckSum == nil { + m.CheckSum = []byte{} } iNdEx = postIndex - case 4: + case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Unwrapped", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -14866,21 +20616,26 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} + if m.Unwrapped == nil { + m.Unwrapped = &KeyBlob{} + } + if err := m.Unwrapped.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -14892,6 +20647,9 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -14905,7 +20663,7 @@ func (m *VerifySingleRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *VerifySingleResponse) Unmarshal(dAtA []byte) error { +func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14920,7 +20678,7 @@ func (m *VerifySingleResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -14928,68 +20686,201 @@ func (m *VerifySingleResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: VerifySingleResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DeriveKeyRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: VerifySingleResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DeriveKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Mech == nil { + m.Mech = &Mechanism{} + } + if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if skippy < 0 { + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TemplateBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TemplateBytes == nil { + m.TemplateBytes = make(map[ep11.Attribute][]byte) + } + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.TemplateBytes[ep11.Attribute(mapkey)] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { return ErrInvalidLengthServer } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + m.BaseKey = append(m.BaseKey[:0], dAtA[iNdEx:postIndex]...) + if m.BaseKey == nil { + m.BaseKey = []byte{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: GenerateKeyRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GenerateKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -14999,26 +20890,27 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} - } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex - case 2: + case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) } @@ -15032,7 +20924,7 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -15041,14 +20933,17 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } if m.Template == nil { - m.Template = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) + m.Template = make(map[ep11.Attribute]*AttributeValue) } var mapkey uint64 - mapvalue := []byte{} + var mapvalue *AttributeValue for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 @@ -15061,7 +20956,7 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -15077,13 +20972,13 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift + mapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } } else if fieldNum == 2 { - var mapbyteLen uint64 + var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15093,22 +20988,26 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift + mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { + if mapmsglen < 0 { return ErrInvalidLengthServer } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { return io.ErrUnexpectedEOF } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -15124,36 +21023,7 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { iNdEx += skippy } } - m.Template[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KeyId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.KeyId = string(dAtA[iNdEx:postIndex]) + m.Template[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -15164,6 +21034,9 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -15177,7 +21050,7 @@ func (m *GenerateKeyRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { +func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15192,7 +21065,7 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -15200,15 +21073,15 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GenerateKeyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DeriveKeyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GenerateKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DeriveKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 4: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NewKeyBytes", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -15220,7 +21093,7 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -15229,15 +21102,18 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} + m.NewKeyBytes = append(m.NewKeyBytes[:0], dAtA[iNdEx:postIndex]...) + if m.NewKeyBytes == nil { + m.NewKeyBytes = []byte{} } iNdEx = postIndex - case 5: + case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CheckSum", wireType) } @@ -15251,7 +21127,7 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -15260,6 +21136,9 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } @@ -15268,6 +21147,42 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { m.CheckSum = []byte{} } iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NewKey == nil { + m.NewKey = &KeyBlob{} + } + if err := m.NewKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -15277,6 +21192,9 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -15290,7 +21208,7 @@ func (m *GenerateKeyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { +func (m *GetMechanismListRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15305,7 +21223,7 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -15313,79 +21231,69 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GenerateKeyPairRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetMechanismListRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GenerateKeyPairRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetMechanismListRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } + if skippy < 0 { + return ErrInvalidLengthServer } - if msglen < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} - } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PubKeyTemplate", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthServer + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetMechanismListResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - postIndex := iNdEx + msglen - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - if m.PubKeyTemplate == nil { - m.PubKeyTemplate = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - var mapkey uint64 - mapvalue := []byte{} - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetMechanismListResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetMechanismListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType == 0 { + var v ep11.Mechanism for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15395,105 +21303,14 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + v |= ep11.Mechanism(b&0x7F) << shift if b < 0x80 { break } } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - } else if fieldNum == 2 { - var mapbyteLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { - return ErrInvalidLengthServer - } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - m.PubKeyTemplate[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivKeyTemplate", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PrivKeyTemplate == nil { - m.PrivKeyTemplate = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) - } - var mapkey uint64 - mapvalue := []byte{} - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 + m.Mechs = append(m.Mechs, v) + } else if wireType == 2 { + var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15503,29 +21320,34 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + packedLen |= int(b&0x7F) << shift if b < 0x80 { break } } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } + if packedLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ } - } else if fieldNum == 2 { - var mapbyteLen uint64 + } + elementCount = count + if elementCount != 0 && len(m.Mechs) == 0 { + m.Mechs = make([]ep11.Mechanism, 0, elementCount) + } + for iNdEx < postIndex { + var v ep11.Mechanism for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15535,73 +21357,75 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift + v |= ep11.Mechanism(b&0x7F) << shift if b < 0x80 { break } } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { - return ErrInvalidLengthServer - } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy + m.Mechs = append(m.Mechs, v) } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Mechs", wireType) } - m.PrivKeyTemplate[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivKeyId", wireType) + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } + if skippy < 0 { + return ErrInvalidLengthServer } - intStringLen := int(stringLen) - if intStringLen < 0 { + if (iNdEx + skippy) < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + intStringLen - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.PrivKeyId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PubKeyId", wireType) + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - var stringLen uint64 + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetMechanismInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetMechanismInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + } + m.Mech = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15611,28 +21435,21 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + m.Mech |= ep11.Mechanism(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PubKeyId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) if err != nil { return err } - if skippy < 0 { + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthServer } if (iNdEx + skippy) > l { @@ -15648,7 +21465,7 @@ func (m *GenerateKeyPairRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { +func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15663,7 +21480,7 @@ func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -15671,17 +21488,17 @@ func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GenerateKeyPairResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetMechanismInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GenerateKeyPairResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetMechanismInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 5: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MechInfo", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15691,52 +21508,26 @@ func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PrivKey = append(m.PrivKey[:0], dAtA[iNdEx:postIndex]...) - if m.PrivKey == nil { - m.PrivKey = []byte{} - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...) - if m.PubKey == nil { - m.PubKey = []byte{} + if m.MechInfo == nil { + m.MechInfo = &MechanismInfo{} + } + if err := m.MechInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -15748,6 +21539,9 @@ func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -15761,7 +21555,7 @@ func (m *GenerateKeyPairResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { +func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15776,7 +21570,7 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -15784,15 +21578,15 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: WrapKeyRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetAttributeValueRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: WrapKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetAttributeValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -15804,7 +21598,7 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -15813,19 +21607,22 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) - if m.Key == nil { - m.Key = []byte{} + m.Object = append(m.Object[:0], dAtA[iNdEx:postIndex]...) + if m.Object == nil { + m.Object = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KeK", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AttributesBytes", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15835,57 +21632,109 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.KeK = append(m.KeK[:0], dAtA[iNdEx:postIndex]...) - if m.KeK == nil { - m.KeK = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MacKey", wireType) + if m.AttributesBytes == nil { + m.AttributesBytes = make(map[ep11.Attribute][]byte) } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy } } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.MacKey = append(m.MacKey[:0], dAtA[iNdEx:postIndex]...) - if m.MacKey == nil { - m.MacKey = []byte{} - } + m.AttributesBytes[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15897,7 +21746,7 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -15906,15 +21755,97 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} + if m.Attributes == nil { + m.Attributes = make(map[ep11.Attribute]*AttributeValue) } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + var mapkey uint64 + var mapvalue *AttributeValue + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthServer + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.Attributes[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -15925,6 +21856,9 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -15938,7 +21872,7 @@ func (m *WrapKeyRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { +func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15953,7 +21887,7 @@ func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -15961,17 +21895,17 @@ func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: WrapKeyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetAttributeValueResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: WrapKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetAttributeValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Wrapped", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AttributesBytes", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -15981,22 +21915,105 @@ func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Wrapped = append(m.Wrapped[:0], dAtA[iNdEx:postIndex]...) - if m.Wrapped == nil { - m.Wrapped = []byte{} + if m.AttributesBytes == nil { + m.AttributesBytes = make(map[ep11.Attribute][]byte) + } + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.AttributesBytes[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -16007,6 +22024,9 @@ func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -16020,7 +22040,7 @@ func (m *WrapKeyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { +func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16035,7 +22055,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16043,46 +22063,15 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UnwrapKeyRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SetAttributeValueRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UnwrapKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SetAttributeValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Wrapped", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Wrapped = append(m.Wrapped[:0], dAtA[iNdEx:postIndex]...) - if m.Wrapped == nil { - m.Wrapped = []byte{} - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KeK", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -16094,7 +22083,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -16103,48 +22092,20 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.KeK = append(m.KeK[:0], dAtA[iNdEx:postIndex]...) - if m.KeK == nil { - m.KeK = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MacKey", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.MacKey = append(m.MacKey[:0], dAtA[iNdEx:postIndex]...) - if m.MacKey == nil { - m.MacKey = []byte{} + m.Object = append(m.Object[:0], dAtA[iNdEx:postIndex]...) + if m.Object == nil { + m.Object = []byte{} } iNdEx = postIndex - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AttributesBytes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16156,7 +22117,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -16165,19 +22126,100 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} + if m.AttributesBytes == nil { + m.AttributesBytes = make(map[ep11.Attribute][]byte) } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + var mapkey uint64 + mapvalue := []byte{} + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapbyteLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthServer + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex < 0 { + return ErrInvalidLengthServer + } + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = make([]byte, mapbyteLen) + copy(mapvalue, dAtA[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } } + m.AttributesBytes[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex - case 6: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16189,7 +22231,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -16198,14 +22240,17 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Template == nil { - m.Template = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) + if m.Attributes == nil { + m.Attributes = make(map[ep11.Attribute]*AttributeValue) } var mapkey uint64 - mapvalue := []byte{} + var mapvalue *AttributeValue for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 @@ -16218,7 +22263,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16234,13 +22279,13 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift + mapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } } else if fieldNum == 2 { - var mapbyteLen uint64 + var mapmsglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16250,22 +22295,26 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift + mapmsglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { + if mapmsglen < 0 { return ErrInvalidLengthServer } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { return io.ErrUnexpectedEOF } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex } else { iNdEx = entryPreIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -16281,36 +22330,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { iNdEx += skippy } } - m.Template[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UnwrappedId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.UnwrappedId = string(dAtA[iNdEx:postIndex]) + m.Attributes[ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -16321,6 +22341,9 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -16334,7 +22357,7 @@ func (m *UnwrapKeyRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { +func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16349,7 +22372,7 @@ func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16357,15 +22380,15 @@ func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UnwrapKeyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SetAttributeValueResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UnwrapKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SetAttributeValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 7: + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Unwrapped", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -16377,7 +22400,7 @@ func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -16386,43 +22409,15 @@ func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Unwrapped = append(m.Unwrapped[:0], dAtA[iNdEx:postIndex]...) - if m.Unwrapped == nil { - m.Unwrapped = []byte{} - } - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CheckSum", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.CheckSum = append(m.CheckSum[:0], dAtA[iNdEx:postIndex]...) - if m.CheckSum == nil { - m.CheckSum = []byte{} + m.Object = append(m.Object[:0], dAtA[iNdEx:postIndex]...) + if m.Object == nil { + m.Object = []byte{} } iNdEx = postIndex default: @@ -16434,6 +22429,9 @@ func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -16447,7 +22445,7 @@ func (m *UnwrapKeyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { +func (m *Mechanism) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16462,7 +22460,7 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16470,17 +22468,36 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DeriveKeyRequest: wiretype end group for non-group") + return fmt.Errorf("proto: Mechanism: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DeriveKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Mechanism: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mechanism", wireType) + } + m.Mechanism = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mechanism |= ep11.Mechanism(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ParameterB", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16490,28 +22507,28 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Mech == nil { - m.Mech = &Mechanism{} - } - if err := m.Mech.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + v := make([]byte, postIndex-iNdEx) + copy(v, dAtA[iNdEx:postIndex]) + m.Parameter = &Mechanism_ParameterB{v} iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RSAOAEPParameter", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16523,7 +22540,7 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -16532,96 +22549,23 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Template == nil { - m.Template = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) - } - var mapkey uint64 - mapvalue := []byte{} - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - } else if fieldNum == 2 { - var mapbyteLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { - return ErrInvalidLengthServer - } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + v := &RSAOAEPParm{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.Template[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue + m.Parameter = &Mechanism_RSAOAEPParameter{v} iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BaseKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RSAPSSParameter", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16631,28 +22575,32 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.BaseKey = append(m.BaseKey[:0], dAtA[iNdEx:postIndex]...) - if m.BaseKey == nil { - m.BaseKey = []byte{} + v := &RSAPSSParm{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + m.Parameter = &Mechanism_RSAPSSParameter{v} iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ECDH1DeriveParameter", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16662,28 +22610,32 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} + v := &ECDH1DeriveParm{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + m.Parameter = &Mechanism_ECDH1DeriveParameter{v} iNdEx = postIndex case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NewKeyId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BTCDeriveParameter", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16693,20 +22645,26 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } - m.NewKeyId = string(dAtA[iNdEx:postIndex]) + v := &BTCDeriveParm{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Parameter = &Mechanism_BTCDeriveParameter{v} iNdEx = postIndex default: iNdEx = preIndex @@ -16717,6 +22675,9 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -16730,7 +22691,7 @@ func (m *DeriveKeyRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { +func (m *MechanismInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16745,7 +22706,7 @@ func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16753,17 +22714,17 @@ func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DeriveKeyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MechanismInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DeriveKeyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MechanismInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NewKey", wireType) + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinKeySize", wireType) } - var byteLen int + m.MinKeySize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16773,28 +22734,16 @@ func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + m.MinKeySize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.NewKey = append(m.NewKey[:0], dAtA[iNdEx:postIndex]...) - if m.NewKey == nil { - m.NewKey = []byte{} - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CheckSum", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxKeySize", wireType) } - var byteLen int + m.MaxKeySize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -16804,23 +22753,30 @@ func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + m.MaxKeySize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) } - m.CheckSum = append(m.CheckSum[:0], dAtA[iNdEx:postIndex]...) - if m.CheckSum == nil { - m.CheckSum = []byte{} + m.Flags = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Flags |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -16830,6 +22786,9 @@ func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -16843,7 +22802,7 @@ func (m *DeriveKeyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetMechanismListRequest) Unmarshal(dAtA []byte) error { +func (m *Grep11Error) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16858,7 +22817,7 @@ func (m *GetMechanismListRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16866,12 +22825,83 @@ func (m *GetMechanismListRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetMechanismListRequest: wiretype end group for non-group") + return fmt.Errorf("proto: Grep11Error: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetMechanismListRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Grep11Error: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= ep11.Return(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Detail = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Retry", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Retry = bool(v != 0) default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -16881,6 +22911,9 @@ func (m *GetMechanismListRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -16894,7 +22927,7 @@ func (m *GetMechanismListRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetMechanismListResponse) Unmarshal(dAtA []byte) error { +func (m *RSAOAEPParm) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16909,7 +22942,7 @@ func (m *GetMechanismListResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16917,85 +22950,103 @@ func (m *GetMechanismListResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetMechanismListResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RSAOAEPParm: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetMechanismListResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RSAOAEPParm: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: - if wireType == 0 { - var v github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= (github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism(b) & 0x7F) << shift - if b < 0x80 { - break - } + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HashMech", wireType) + } + m.HashMech = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - m.Mechs = append(m.Mechs, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } + if iNdEx >= l { + return io.ErrUnexpectedEOF } - if packedLen < 0 { - return ErrInvalidLengthServer + b := dAtA[iNdEx] + iNdEx++ + m.HashMech |= ep11.Mechanism(b&0x7F) << shift + if b < 0x80 { + break } - postIndex := iNdEx + packedLen - if postIndex > l { + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mgf", wireType) + } + m.Mgf = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - var elementCount int - var count int - for _, integer := range dAtA { - if integer < 128 { - count++ - } + b := dAtA[iNdEx] + iNdEx++ + m.Mgf |= RSAOAEPParm_Mask(b&0x7F) << shift + if b < 0x80 { + break } - elementCount = count - if elementCount != 0 && len(m.Mechs) == 0 { - m.Mechs = make([]github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism, 0, elementCount) + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EncodingParmType", wireType) + } + m.EncodingParmType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - for iNdEx < postIndex { - var v github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= (github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - m.Mechs = append(m.Mechs, v) + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EncodingParmType |= RSAOAEPParm_ParmType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EncodingParm", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field Mechs", wireType) + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EncodingParm = append(m.EncodingParm[:0], dAtA[iNdEx:postIndex]...) + if m.EncodingParm == nil { + m.EncodingParm = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -17005,6 +23056,9 @@ func (m *GetMechanismListResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17018,7 +23072,7 @@ func (m *GetMechanismListResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { +func (m *RSAPSSParm) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17033,7 +23087,7 @@ func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17041,17 +23095,55 @@ func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetMechanismInfoRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RSAPSSParm: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetMechanismInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RSAPSSParm: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HashMech", wireType) + } + m.HashMech = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HashMech |= ep11.Mechanism(b&0x7F) << shift + if b < 0x80 { + break + } + } case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mech", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Mgf", wireType) } - m.Mech = 0 + m.Mgf = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mgf |= RSAPSSParm_Mask(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SaltByteCount", wireType) + } + m.SaltByteCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17061,7 +23153,7 @@ func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mech |= (github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism(b) & 0x7F) << shift + m.SaltByteCount |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17075,6 +23167,9 @@ func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17088,7 +23183,7 @@ func (m *GetMechanismInfoRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { +func (m *ECDH1DeriveParm) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17103,7 +23198,7 @@ func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17111,17 +23206,36 @@ func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetMechanismInfoResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ECDH1DeriveParm: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetMechanismInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ECDH1DeriveParm: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 3: + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Kdf", wireType) + } + m.Kdf = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Kdf |= ECDH1DeriveParm_KeyDerivationFunction(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MechInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SharedData", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17131,23 +23245,58 @@ func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.MechInfo == nil { - m.MechInfo = &MechanismInfo{} + m.SharedData = append(m.SharedData[:0], dAtA[iNdEx:postIndex]...) + if m.SharedData == nil { + m.SharedData = []byte{} } - if err := m.MechInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PublicData", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PublicData = append(m.PublicData[:0], dAtA[iNdEx:postIndex]...) + if m.PublicData == nil { + m.PublicData = []byte{} } iNdEx = postIndex default: @@ -17159,6 +23308,9 @@ func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17172,7 +23324,7 @@ func (m *GetMechanismInfoResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { +func (m *BTCDeriveParm) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17187,7 +23339,7 @@ func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17195,17 +23347,17 @@ func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetAttributeValueRequest: wiretype end group for non-group") + return fmt.Errorf("proto: BTCDeriveParm: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetAttributeValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BTCDeriveParm: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - var byteLen int + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17215,28 +23367,35 @@ func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + m.Type |= BTCDeriveParm_BTCDeriveType(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ChildKeyIndex", wireType) } - m.Object = append(m.Object[:0], dAtA[iNdEx:postIndex]...) - if m.Object == nil { - m.Object = []byte{} + m.ChildKeyIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ChildKeyIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChainCode", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17246,100 +23405,45 @@ func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Attributes == nil { - m.Attributes = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) + m.ChainCode = append(m.ChainCode[:0], dAtA[iNdEx:postIndex]...) + if m.ChainCode == nil { + m.ChainCode = []byte{} } - var mapkey uint64 - mapvalue := []byte{} - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - } else if fieldNum == 2 { - var mapbyteLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { - return ErrInvalidLengthServer - } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint64(b&0x7F) << shift + if b < 0x80 { + break } } - m.Attributes[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -17349,6 +23453,9 @@ func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17362,7 +23469,7 @@ func (m *GetAttributeValueRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { +func (m *HMACGeneralParm) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17377,7 +23484,7 @@ func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17385,17 +23492,17 @@ func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetAttributeValueResponse: wiretype end group for non-group") + return fmt.Errorf("proto: HMACGeneralParm: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetAttributeValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HMACGeneralParm: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReturnByteCount", wireType) } - var msglen int + m.ReturnByteCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17405,100 +23512,11 @@ func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + m.ReturnByteCount |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthServer - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Attributes == nil { - m.Attributes = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) - } - var mapkey uint64 - mapvalue := []byte{} - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - } else if fieldNum == 2 { - var mapbyteLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { - return ErrInvalidLengthServer - } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - m.Attributes[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -17508,6 +23526,9 @@ func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17521,7 +23542,7 @@ func (m *GetAttributeValueResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { +func (m *ReEncryptRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17536,7 +23557,7 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17544,15 +23565,15 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SetAttributeValueRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ReEncryptRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SetAttributeValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ReEncryptRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WrappedKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -17564,7 +23585,7 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -17573,19 +23594,76 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Object = append(m.Object[:0], dAtA[iNdEx:postIndex]...) - if m.Object == nil { - m.Object = []byte{} + m.WrappedKey = append(m.WrappedKey[:0], dAtA[iNdEx:postIndex]...) + if m.WrappedKey == nil { + m.WrappedKey = []byte{} } iNdEx = postIndex - case 2: + default: + iNdEx = preIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ReEncryptResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ReEncryptResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReEncryptResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RewrappedKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17595,99 +23673,25 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + msglen if postIndex > l { return io.ErrUnexpectedEOF } - if m.Attributes == nil { - m.Attributes = make(map[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute][]byte) - } - var mapkey uint64 - mapvalue := []byte{} - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapkey |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - } else if fieldNum == 2 { - var mapbyteLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowServer - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapbyteLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intMapbyteLen := int(mapbyteLen) - if intMapbyteLen < 0 { - return ErrInvalidLengthServer - } - postbytesIndex := iNdEx + intMapbyteLen - if postbytesIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = make([]byte, mapbyteLen) - copy(mapvalue, dAtA[iNdEx:postbytesIndex]) - iNdEx = postbytesIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipServer(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthServer - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + m.RewrappedKey = append(m.RewrappedKey[:0], dAtA[iNdEx:postIndex]...) + if m.RewrappedKey == nil { + m.RewrappedKey = []byte{} } - m.Attributes[github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Attribute(mapkey)] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -17698,6 +23702,9 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17711,7 +23718,7 @@ func (m *SetAttributeValueRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { +func (m *RewrapKeyBlobRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17726,7 +23733,7 @@ func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17734,15 +23741,15 @@ func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SetAttributeValueResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RewrapKeyBlobRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SetAttributeValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RewrapKeyBlobRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WrappedKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -17754,7 +23761,7 @@ func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } @@ -17763,12 +23770,15 @@ func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { return ErrInvalidLengthServer } postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } if postIndex > l { return io.ErrUnexpectedEOF } - m.Object = append(m.Object[:0], dAtA[iNdEx:postIndex]...) - if m.Object == nil { - m.Object = []byte{} + m.WrappedKey = append(m.WrappedKey[:0], dAtA[iNdEx:postIndex]...) + if m.WrappedKey == nil { + m.WrappedKey = []byte{} } iNdEx = postIndex default: @@ -17780,6 +23790,9 @@ func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17793,7 +23806,7 @@ func (m *SetAttributeValueResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *Mechanism) Unmarshal(dAtA []byte) error { +func (m *RewrapKeyBlobResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17808,7 +23821,7 @@ func (m *Mechanism) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17816,17 +23829,17 @@ func (m *Mechanism) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Mechanism: wiretype end group for non-group") + return fmt.Errorf("proto: RewrapKeyBlobResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Mechanism: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RewrapKeyBlobResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mechanism", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RewrappedKey", wireType) } - m.Mechanism = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17836,16 +23849,31 @@ func (m *Mechanism) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mechanism |= (github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Mechanism(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RewrappedKey = append(m.RewrappedKey[:0], dAtA[iNdEx:postIndex]...) + if m.RewrappedKey == nil { + m.RewrappedKey = []byte{} + } + iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Parameter", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KeyBlob", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17855,21 +23883,26 @@ func (m *Mechanism) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + byteLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Parameter = append(m.Parameter[:0], dAtA[iNdEx:postIndex]...) - if m.Parameter == nil { - m.Parameter = []byte{} + if m.KeyBlob == nil { + m.KeyBlob = &KeyBlob{} + } + if err := m.KeyBlob.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -17881,6 +23914,9 @@ func (m *Mechanism) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -17894,7 +23930,7 @@ func (m *Mechanism) Unmarshal(dAtA []byte) error { } return nil } -func (m *MechanismInfo) Unmarshal(dAtA []byte) error { +func (m *AttributeValue) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17909,7 +23945,7 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17917,17 +23953,17 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MechanismInfo: wiretype end group for non-group") + return fmt.Errorf("proto: AttributeValue: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MechanismInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AttributeValue: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinKeySize", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttributeB", wireType) } - m.MinKeySize = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17937,16 +23973,30 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MinKeySize |= (uint64(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, dAtA[iNdEx:postIndex]) + m.OneAttr = &AttributeValue_AttributeB{v} + iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxKeySize", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AttributeTF", wireType) } - m.MaxKeySize = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17956,16 +24006,18 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MaxKeySize |= (uint64(b) & 0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } + b := bool(v != 0) + m.OneAttr = &AttributeValue_AttributeTF{b} case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AttributeI", wireType) } - m.Flags = 0 + var v int64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -17975,11 +24027,12 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Flags |= (uint64(b) & 0x7F) << shift + v |= int64(b&0x7F) << shift if b < 0x80 { break } } + m.OneAttr = &AttributeValue_AttributeI{v} default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -17989,6 +24042,9 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -18002,7 +24058,7 @@ func (m *MechanismInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *Grep11Error) Unmarshal(dAtA []byte) error { +func (m *KeyBlob) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18017,7 +24073,7 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - wire |= (uint64(b) & 0x7F) << shift + wire |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -18025,17 +24081,17 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Grep11Error: wiretype end group for non-group") + return fmt.Errorf("proto: KeyBlob: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Grep11Error: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: KeyBlob: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyBlobID", wireType) } - m.Code = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -18045,16 +24101,50 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Code |= (github_com_ibm_developer_ibm_cloud_hyperprotectcrypto_golang_ep11.Return(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KeyBlobID = append(m.KeyBlobID[:0], dAtA[iNdEx:postIndex]...) + if m.KeyBlobID == nil { + m.KeyBlobID = []byte{} + } + iNdEx = postIndex case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TxID", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -18064,26 +24154,31 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { return ErrInvalidLengthServer } - postIndex := iNdEx + intStringLen if postIndex > l { return io.ErrUnexpectedEOF } - m.Detail = string(dAtA[iNdEx:postIndex]) + m.TxID = append(m.TxID[:0], dAtA[iNdEx:postIndex]...) + if m.TxID == nil { + m.TxID = []byte{} + } iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Retry", wireType) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } - var v int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowServer @@ -18093,12 +24188,139 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= (int(b) & 0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.Retry = bool(v != 0) + if msglen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Attributes == nil { + m.Attributes = make(map[ep11.Attribute]*AttributeValue) + } + var mapkey uint64 + var mapvalue *AttributeValue + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthServer + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthServer + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &AttributeValue{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipServer(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthServer + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Attributes[ep11.Attribute(mapkey)] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyBlobs", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowServer + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthServer + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthServer + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.KeyBlobs = append(m.KeyBlobs, make([]byte, postIndex-iNdEx)) + copy(m.KeyBlobs[len(m.KeyBlobs)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipServer(dAtA[iNdEx:]) @@ -18108,6 +24330,9 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { if skippy < 0 { return ErrInvalidLengthServer } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthServer + } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } @@ -18124,6 +24349,7 @@ func (m *Grep11Error) Unmarshal(dAtA []byte) error { func skipServer(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 + depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { @@ -18155,10 +24381,8 @@ func skipServer(dAtA []byte) (n int, err error) { break } } - return iNdEx, nil case 1: iNdEx += 8 - return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { @@ -18175,189 +24399,34 @@ func skipServer(dAtA []byte) (n int, err error) { break } } - iNdEx += length if length < 0 { return 0, ErrInvalidLengthServer } - return iNdEx, nil + iNdEx += length case 3: - for { - var innerWire uint64 - var start int = iNdEx - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowServer - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - innerWire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - innerWireType := int(innerWire & 0x7) - if innerWireType == 4 { - break - } - next, err := skipServer(dAtA[start:]) - if err != nil { - return 0, err - } - iNdEx = start + next - } - return iNdEx, nil + depth++ case 4: - return iNdEx, nil + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupServer + } + depth-- case 5: iNdEx += 4 - return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } + if iNdEx < 0 { + return 0, ErrInvalidLengthServer + } + if depth == 0 { + return iNdEx, nil + } } - panic("unreachable") + return 0, io.ErrUnexpectedEOF } var ( - ErrInvalidLengthServer = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowServer = fmt.Errorf("proto: integer overflow") + ErrInvalidLengthServer = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowServer = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupServer = fmt.Errorf("proto: unexpected end of group") ) - -func init() { proto.RegisterFile("server.proto", fileDescriptor_server_2b449d55aaf66cf7) } - -var fileDescriptor_server_2b449d55aaf66cf7 = []byte{ - // 2080 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5a, 0xcd, 0x73, 0x23, 0x47, - 0x15, 0xf7, 0x48, 0xf2, 0xd7, 0xf3, 0x97, 0xdc, 0x96, 0x1d, 0x79, 0xe2, 0xf5, 0x9a, 0xa9, 0x02, - 0x9c, 0x4d, 0xac, 0xc5, 0xf6, 0x01, 0xb2, 0x24, 0xb5, 0x15, 0x79, 0x37, 0xbb, 0x2e, 0xad, 0xb3, - 0x66, 0x94, 0x64, 0xab, 0x38, 0x31, 0x96, 0x3a, 0xf2, 0xb0, 0xd2, 0x48, 0x8c, 0x46, 0x0e, 0xe2, - 0x40, 0x15, 0x1c, 0xf8, 0x07, 0x52, 0xa9, 0xe2, 0xc2, 0x01, 0x0e, 0x5c, 0xa8, 0xe2, 0xef, 0xe0, - 0xc8, 0x89, 0x63, 0x42, 0xed, 0x9d, 0x0b, 0xc7, 0x5c, 0xa0, 0x66, 0xfa, 0xbb, 0xa7, 0x35, 0x92, - 0x65, 0x6f, 0xaa, 0xe0, 0xa6, 0xfe, 0xfa, 0xbd, 0xcf, 0x7e, 0x6f, 0xfa, 0x3d, 0xc1, 0x72, 0x1f, - 0x87, 0x57, 0x38, 0xac, 0xf4, 0xc2, 0x6e, 0xd4, 0x45, 0x73, 0xad, 0x10, 0xf7, 0x0e, 0x0f, 0x6d, - 0x68, 0x75, 0x5b, 0x5d, 0x32, 0xe7, 0xbc, 0x05, 0x9b, 0x4f, 0x70, 0x80, 0x43, 0x2f, 0xc2, 0xae, - 0x17, 0x34, 0xbb, 0x1d, 0x17, 0xff, 0x62, 0x80, 0xfb, 0x11, 0x2a, 0x42, 0xfe, 0x19, 0x0e, 0xca, - 0xd6, 0x9e, 0xb5, 0x5f, 0x70, 0xe3, 0x9f, 0xce, 0x3d, 0xd8, 0xd2, 0xb7, 0xf6, 0x7b, 0xdd, 0xa0, - 0x8f, 0xe3, 0xbd, 0x6e, 0xd0, 0x4c, 0xf6, 0x2e, 0xbb, 0xf1, 0x4f, 0xe7, 0x01, 0xac, 0x3f, 0xf2, - 0x5b, 0xb8, 0x1f, 0x9d, 0x06, 0x7e, 0xc4, 0x20, 0xbf, 0x0b, 0x85, 0x33, 0xdc, 0xb8, 0x2c, 0xe7, - 0xf6, 0xac, 0xfd, 0xa5, 0xa3, 0xf5, 0x0a, 0x61, 0xa7, 0x12, 0xcf, 0x79, 0x81, 0xdf, 0xef, 0xb8, - 0xc9, 0xb2, 0x73, 0x0f, 0x90, 0x7c, 0x96, 0xd2, 0x28, 0xc1, 0x6c, 0x3d, 0xf2, 0x22, 0x4c, 0xa9, - 0x90, 0x81, 0xf3, 0x2e, 0xac, 0x90, 0xbd, 0x8c, 0x86, 0x71, 0x1b, 0x42, 0x50, 0x78, 0xe4, 0x45, - 0x5e, 0x42, 0x79, 0xd9, 0x4d, 0x7e, 0x3b, 0xfb, 0xb0, 0xca, 0x8e, 0x52, 0x12, 0x5b, 0x30, 0x47, - 0x66, 0xca, 0xf9, 0x64, 0x1f, 0x1d, 0x39, 0x0f, 0x61, 0x83, 0xfc, 0xfa, 0xa4, 0xd7, 0x8c, 0x85, - 0xbf, 0x36, 0xa9, 0x77, 0xa0, 0xa4, 0x02, 0x64, 0xca, 0xf4, 0x00, 0x8a, 0x64, 0x77, 0x0d, 0x0f, - 0xb3, 0x69, 0x15, 0x21, 0x5f, 0xc3, 0x43, 0x4a, 0x2a, 0xfe, 0xe9, 0xbc, 0xc5, 0xf4, 0x9e, 0x9c, - 0xcd, 0x24, 0xc3, 0xd5, 0xfc, 0xa1, 0x1f, 0x78, 0xed, 0x4c, 0x42, 0xce, 0x01, 0xd3, 0x00, 0xdd, - 0x9b, 0x52, 0x58, 0x4e, 0x51, 0xd8, 0x39, 0xdb, 0x5e, 0xf7, 0x83, 0x56, 0x1b, 0xeb, 0xf6, 0xb7, - 0x32, 0xed, 0x6f, 0xd4, 0x60, 0x85, 0x69, 0x90, 0x21, 0x8e, 0x31, 0xd9, 0x19, 0xa0, 0xc7, 0x41, - 0x23, 0x1c, 0xf6, 0xa6, 0x70, 0x40, 0xa6, 0xd6, 0xbc, 0x50, 0xeb, 0xdb, 0xb0, 0xa1, 0xc0, 0x65, - 0x2a, 0xf6, 0x0c, 0xd0, 0x23, 0x7c, 0xab, 0xb4, 0x15, 0xb8, 0x4c, 0xda, 0x55, 0x28, 0x51, 0x46, - 0x27, 0xf1, 0xd5, 0x12, 0xcc, 0x9e, 0xb7, 0x3d, 0x3f, 0xa0, 0xaa, 0x26, 0x03, 0xe7, 0x14, 0x36, - 0x35, 0x8c, 0x2c, 0x92, 0xc8, 0x86, 0x85, 0x13, 0xbf, 0x77, 0x89, 0x43, 0xdc, 0xa4, 0x6c, 0xf3, - 0xb1, 0xf3, 0x14, 0x4a, 0x94, 0xf7, 0x49, 0xd8, 0x91, 0x91, 0x72, 0x1a, 0xd2, 0x09, 0x6c, 0x6a, - 0x48, 0x99, 0x4c, 0x71, 0xc9, 0xf2, 0xb2, 0x64, 0xef, 0xc1, 0x2a, 0x95, 0x6c, 0x1a, 0xbd, 0x1c, - 0xc0, 0x1a, 0x3f, 0x4d, 0x89, 0x67, 0xc9, 0x5e, 0x85, 0x55, 0xca, 0xf1, 0xf4, 0x52, 0x7f, 0x1f, - 0xd6, 0x38, 0x86, 0x90, 0xd7, 0x20, 0x99, 0x70, 0xd0, 0x09, 0x6e, 0xf3, 0x11, 0x77, 0x12, 0xf5, - 0x3a, 0x67, 0x71, 0x22, 0xbc, 0x70, 0x02, 0x02, 0xef, 0x70, 0xb3, 0xab, 0x04, 0xcc, 0x7a, 0xc5, - 0x9c, 0x1d, 0x35, 0x5c, 0xd0, 0xab, 0x60, 0xf1, 0xab, 0x30, 0xe9, 0x1d, 0x32, 0xab, 0xe8, 0x98, - 0xbb, 0xb5, 0x16, 0x43, 0x64, 0xb1, 0x0b, 0x9a, 0xd8, 0x2f, 0xb9, 0x24, 0xb7, 0xc4, 0x5b, 0x96, - 0xc7, 0x1c, 0x70, 0x1f, 0xd7, 0x38, 0xe4, 0x02, 0x15, 0x64, 0x81, 0x5c, 0x58, 0xab, 0xfb, 0xad, - 0x60, 0x8a, 0x20, 0x53, 0x86, 0xf9, 0xf3, 0xd0, 0xbf, 0x12, 0x81, 0x86, 0x0d, 0x9d, 0x7d, 0x28, - 0x0a, 0xcc, 0xcc, 0x48, 0xe3, 0xc2, 0xfa, 0xa7, 0x38, 0xf4, 0x3f, 0x1b, 0x4e, 0x41, 0x7f, 0x0b, - 0xe6, 0xce, 0x07, 0x17, 0x82, 0x3c, 0x1d, 0xc5, 0x29, 0x49, 0xc6, 0xcc, 0xa4, 0xff, 0x3e, 0xac, - 0xc7, 0x9c, 0x4e, 0x9b, 0x92, 0xef, 0x01, 0x92, 0x8f, 0x67, 0x92, 0x7a, 0x08, 0x1b, 0x84, 0xad, - 0x1b, 0xe4, 0x7f, 0x15, 0x20, 0x93, 0x1c, 0xb5, 0xc1, 0x04, 0xf7, 0xec, 0x90, 0xe8, 0x40, 0xbd, - 0x64, 0x3b, 0xb0, 0x18, 0x4f, 0x7a, 0xd1, 0x20, 0xc4, 0x94, 0x0b, 0x31, 0xe1, 0x3c, 0x65, 0x2a, - 0x1e, 0x0f, 0x3f, 0x06, 0x69, 0x93, 0x69, 0x45, 0x21, 0xef, 0xfc, 0x10, 0x96, 0xe2, 0x3d, 0xd3, - 0x28, 0x69, 0x99, 0x1c, 0x34, 0xc9, 0x91, 0xd7, 0xa9, 0xbf, 0x80, 0x15, 0x42, 0xfd, 0xda, 0x84, - 0xc6, 0x00, 0x17, 0x61, 0x95, 0x01, 0x53, 0x89, 0x2e, 0x89, 0x96, 0xd5, 0x00, 0x20, 0x5d, 0x21, - 0x4b, 0xb9, 0x42, 0x93, 0xde, 0x01, 0xc6, 0x59, 0x5e, 0x52, 0xc1, 0x11, 0x71, 0x4a, 0xed, 0xf6, - 0x2b, 0xfc, 0x16, 0x74, 0x7e, 0x7f, 0x67, 0x31, 0x3b, 0xa8, 0x0c, 0x8a, 0x3b, 0x66, 0xc9, 0x77, - 0xec, 0x06, 0xec, 0x8d, 0x61, 0x64, 0x8b, 0x39, 0xb9, 0xca, 0xbe, 0xf3, 0xe7, 0x1c, 0x20, 0xf6, - 0x6e, 0x90, 0xbe, 0x68, 0x27, 0xfc, 0x18, 0xfc, 0xd2, 0x82, 0x85, 0x8f, 0x71, 0xa7, 0xd7, 0x8e, - 0x4d, 0x9b, 0xdb, 0xcb, 0xef, 0x2f, 0x1d, 0xed, 0xb3, 0xbd, 0x69, 0xd4, 0x0a, 0xdb, 0xfa, 0x38, - 0x88, 0xc2, 0x61, 0xf5, 0xf9, 0x6f, 0xbf, 0xbe, 0x5b, 0x6b, 0xf9, 0xd1, 0xe5, 0xe0, 0xa2, 0xd2, - 0xe8, 0x76, 0xee, 0xfb, 0x17, 0x9d, 0x83, 0x26, 0xbe, 0xc2, 0xed, 0x6e, 0x0f, 0x87, 0xc9, 0xa8, - 0xd1, 0xee, 0x0e, 0x9a, 0x07, 0x97, 0xc3, 0x1e, 0x0e, 0xe3, 0xf7, 0x10, 0x6e, 0x44, 0x49, 0xfc, - 0xed, 0xde, 0x6f, 0x75, 0xdb, 0x5e, 0xd0, 0xba, 0x9f, 0xd0, 0xf9, 0x20, 0x8a, 0x42, 0xff, 0x62, - 0x10, 0x61, 0x97, 0xb3, 0x12, 0xbb, 0x5b, 0x0d, 0x0f, 0x4f, 0x49, 0xc6, 0x58, 0x74, 0xc9, 0xc0, - 0xfe, 0x31, 0xac, 0x28, 0x1c, 0xc4, 0x79, 0xe2, 0x25, 0x35, 0x41, 0xc1, 0x8d, 0x7f, 0xc6, 0x07, - 0xaf, 0xbc, 0xf6, 0x80, 0x5d, 0x28, 0x32, 0x78, 0x90, 0xfb, 0x91, 0xe5, 0x9c, 0xc0, 0x86, 0x22, - 0x91, 0x78, 0x5c, 0xc5, 0x56, 0x2c, 0x88, 0x54, 0x13, 0xe7, 0x90, 0x4b, 0xdc, 0x78, 0x59, 0x1f, - 0x74, 0xca, 0xb3, 0x34, 0x87, 0xd0, 0xb1, 0xf3, 0x75, 0x41, 0xbc, 0xd2, 0x6a, 0x78, 0x78, 0xee, - 0xf9, 0xe1, 0x35, 0x35, 0xfe, 0x17, 0x0b, 0x56, 0x89, 0xaf, 0x68, 0x7a, 0x3f, 0x32, 0xe8, 0x5d, - 0xc2, 0xaf, 0xa8, 0x87, 0x5e, 0x93, 0x05, 0x34, 0xd6, 0xd0, 0x5f, 0x2d, 0x58, 0xa3, 0x37, 0x8f, - 0xb3, 0x9b, 0x4f, 0xd8, 0x3d, 0x1e, 0xc7, 0xae, 0x7a, 0xea, 0x35, 0xf1, 0xab, 0x33, 0x17, 0x5f, - 0x22, 0x3a, 0x75, 0xda, 0x4c, 0xac, 0xb7, 0xe8, 0x8a, 0x89, 0xd8, 0xb4, 0x44, 0xc0, 0xd3, 0x66, - 0x79, 0x2e, 0x59, 0xe4, 0x63, 0xfb, 0x03, 0xd8, 0x30, 0xa8, 0xf8, 0x3a, 0x2e, 0x66, 0x57, 0xa1, - 0x64, 0x12, 0xfb, 0x5a, 0x6e, 0x5a, 0x83, 0x37, 0x52, 0x1a, 0xa5, 0xae, 0x2a, 0x05, 0xc5, 0x59, - 0x35, 0x28, 0x8a, 0x68, 0x34, 0xa7, 0x64, 0xfc, 0x3e, 0xac, 0xbe, 0x08, 0xbd, 0x9e, 0x14, 0x17, - 0xd2, 0x5f, 0x56, 0xc9, 0x4c, 0x4d, 0xbc, 0x72, 0x6b, 0x31, 0xda, 0x99, 0xd7, 0x90, 0xbe, 0x1f, - 0xc8, 0x88, 0x7b, 0x78, 0x21, 0xbb, 0xc0, 0xf0, 0x36, 0xac, 0x71, 0xa2, 0x82, 0xf3, 0x78, 0xaa, - 0x87, 0x9b, 0x8c, 0x73, 0x3a, 0x74, 0xfe, 0x9d, 0x83, 0xe2, 0x27, 0xc1, 0xe7, 0x2a, 0x93, 0xd2, - 0x76, 0x4b, 0xd9, 0x3e, 0x05, 0xb3, 0xb3, 0xd9, 0xd7, 0xf1, 0x0b, 0x39, 0x00, 0xce, 0x25, 0x9e, - 0xfd, 0x3d, 0xb6, 0x57, 0xe7, 0xeb, 0xdb, 0x0b, 0x7f, 0x7b, 0xb0, 0x44, 0x88, 0xf7, 0x70, 0xf3, - 0xb4, 0x59, 0x9e, 0x4f, 0x5c, 0x55, 0x9e, 0xba, 0x59, 0x28, 0x3c, 0x83, 0x75, 0x49, 0x36, 0x91, - 0x07, 0x39, 0x81, 0x84, 0xe2, 0xb2, 0x2b, 0x26, 0x94, 0xa0, 0xb8, 0xa0, 0x05, 0xc5, 0x7f, 0xe4, - 0xa0, 0xf8, 0x08, 0x87, 0xfe, 0xd5, 0x14, 0x09, 0xe8, 0x8b, 0x74, 0x02, 0xe2, 0xfa, 0xd7, 0x31, - 0xbf, 0x3d, 0xfd, 0x97, 0x61, 0xbe, 0xea, 0xf5, 0xb1, 0xf4, 0x05, 0x4f, 0x87, 0x3c, 0x71, 0x17, - 0xa4, 0xc4, 0x6d, 0xc3, 0xc2, 0x47, 0xf8, 0x73, 0x25, 0xaa, 0xb0, 0xf1, 0xcd, 0xec, 0xf4, 0x04, - 0xd6, 0x25, 0x1d, 0x88, 0x9a, 0x0c, 0x41, 0x67, 0x77, 0x9d, 0x8c, 0x14, 0x0b, 0xcd, 0x6b, 0x16, - 0xda, 0x8e, 0x83, 0x4a, 0xc4, 0x75, 0xff, 0xcc, 0xe7, 0x15, 0x3d, 0xe7, 0x37, 0x16, 0x94, 0xd3, - 0x6b, 0x94, 0x16, 0x86, 0xd9, 0x78, 0xa1, 0x9f, 0x58, 0xa6, 0x50, 0x7d, 0xfe, 0xcd, 0x57, 0xb7, - 0xa1, 0x71, 0xe1, 0x03, 0x04, 0xdd, 0xf9, 0xb5, 0xca, 0xde, 0x69, 0xf0, 0x59, 0x97, 0xb9, 0x51, - 0x43, 0xfa, 0x9e, 0x7a, 0x0d, 0x0c, 0x90, 0x88, 0x75, 0xa6, 0xaa, 0x80, 0xd0, 0xa7, 0x2a, 0x38, - 0x84, 0x85, 0x78, 0x21, 0x9e, 0x4b, 0x7c, 0x61, 0xe9, 0x68, 0x33, 0xe5, 0xcb, 0xc9, 0x01, 0xbe, - 0xcd, 0xf9, 0x32, 0x97, 0xe0, 0x71, 0xc7, 0xfa, 0x34, 0x36, 0xa8, 0xf4, 0xe1, 0xf8, 0xfc, 0xe2, - 0xe7, 0xb8, 0x11, 0xb1, 0x0f, 0x47, 0x32, 0x42, 0x7f, 0xb4, 0x00, 0xf8, 0x89, 0x3e, 0xbd, 0x0a, - 0x3f, 0x10, 0x49, 0xd6, 0x0c, 0x27, 0xbc, 0xb7, 0xff, 0x9a, 0x2e, 0x85, 0xc4, 0x94, 0xfd, 0x3e, - 0xac, 0x69, 0xf4, 0xae, 0xe5, 0xce, 0xff, 0xb1, 0x60, 0xdb, 0x20, 0x08, 0x55, 0xf4, 0x9f, 0x4c, - 0x0a, 0x38, 0xcc, 0x50, 0x00, 0x39, 0xf7, 0x3f, 0xa5, 0x81, 0xd8, 0x33, 0xea, 0xb7, 0xeb, 0x19, - 0xf5, 0xff, 0x07, 0xcf, 0x38, 0x86, 0xed, 0xfa, 0x48, 0xc7, 0x18, 0xa1, 0x17, 0xe7, 0xf7, 0x16, - 0x2c, 0xf2, 0x2b, 0x88, 0x3a, 0xd2, 0x80, 0x10, 0xbd, 0xfd, 0x68, 0x21, 0x91, 0x8b, 0xbf, 0x33, - 0xbd, 0xd0, 0xeb, 0xe0, 0x08, 0x87, 0xec, 0xf1, 0xce, 0x27, 0x1c, 0x0c, 0x2b, 0x4a, 0x70, 0x40, - 0xbb, 0x00, 0x67, 0x7e, 0x50, 0xc3, 0xc3, 0xba, 0xff, 0x2b, 0x4c, 0x75, 0x22, 0xcd, 0x24, 0xeb, - 0xde, 0x2f, 0xd9, 0x7a, 0x8e, 0xae, 0xf3, 0x99, 0x58, 0x75, 0x1f, 0xb6, 0xbd, 0x56, 0x3f, 0x09, - 0x41, 0x05, 0x97, 0x0c, 0x9c, 0x3f, 0x58, 0xb0, 0xf4, 0x24, 0x71, 0x83, 0xc7, 0x61, 0xd8, 0x0d, - 0xd1, 0xcf, 0xa0, 0x70, 0xd2, 0x6d, 0x52, 0xfc, 0xea, 0xb3, 0x6f, 0xbe, 0xba, 0xfb, 0xf4, 0xe6, - 0xe2, 0xbb, 0x38, 0x1a, 0x84, 0x81, 0x9b, 0x20, 0x27, 0x0d, 0x01, 0x1c, 0x79, 0x7e, 0x3b, 0xe1, - 0x71, 0xd1, 0xa5, 0xa3, 0x98, 0x3f, 0x17, 0x47, 0x21, 0x49, 0x97, 0x0b, 0x2e, 0x19, 0x1c, 0xfd, - 0xab, 0x04, 0x73, 0x27, 0x09, 0x22, 0xfa, 0x09, 0xac, 0xaa, 0xdd, 0x2d, 0x74, 0x47, 0x7f, 0x40, - 0x28, 0x0d, 0x32, 0x7b, 0x77, 0xd4, 0x32, 0x7d, 0xf7, 0xce, 0xa0, 0xc7, 0x00, 0xa2, 0x91, 0x85, - 0xb6, 0xf9, 0x57, 0x83, 0xde, 0x18, 0xb3, 0x6d, 0xd3, 0x12, 0x87, 0x79, 0x97, 0xf5, 0x38, 0xd0, - 0xa6, 0xba, 0x8f, 0x1d, 0xdf, 0xd2, 0xa7, 0xf9, 0xd1, 0x1a, 0x2c, 0xcb, 0x8d, 0x27, 0xf4, 0xa6, - 0xba, 0x53, 0xa9, 0x67, 0xd9, 0x3b, 0xe6, 0x45, 0x0e, 0x56, 0x85, 0x45, 0xde, 0x5b, 0x42, 0x65, - 0x75, 0xb3, 0xf8, 0x06, 0xb2, 0xb7, 0x0d, 0x2b, 0x1c, 0xe3, 0x29, 0x2c, 0x49, 0x8d, 0x24, 0xa4, - 0x09, 0x2e, 0xd7, 0xa4, 0xec, 0x37, 0x8d, 0x6b, 0x69, 0xd1, 0x48, 0xb9, 0x41, 0x17, 0x4d, 0x29, - 0x86, 0xe8, 0xa2, 0x69, 0x15, 0x8a, 0x84, 0x2d, 0xa9, 0xbf, 0x23, 0xd8, 0x4a, 0xf7, 0x90, 0x04, - 0x5b, 0x86, 0x86, 0x10, 0x15, 0x10, 0x1b, 0x90, 0xd2, 0x1d, 0x21, 0x49, 0x40, 0x6c, 0x42, 0xfa, - 0x08, 0x56, 0x94, 0x36, 0x0c, 0xda, 0xd1, 0x28, 0xab, 0xd6, 0xbb, 0x33, 0x62, 0x55, 0xc6, 0x53, - 0x3a, 0x28, 0x02, 0xcf, 0xd4, 0xa2, 0x11, 0x78, 0xc6, 0xb6, 0x8b, 0x33, 0x83, 0xde, 0x83, 0x79, - 0x4a, 0x0a, 0x6d, 0x69, 0xb4, 0x19, 0xc6, 0x1b, 0xa9, 0x79, 0xf9, 0x34, 0x05, 0x16, 0xa7, 0xd5, - 0x76, 0x89, 0x38, 0xad, 0xb5, 0x40, 0x88, 0xf1, 0xe5, 0x0e, 0x06, 0xd2, 0x8d, 0xa2, 0x38, 0xd2, - 0x8e, 0x79, 0x51, 0xf1, 0x24, 0x6c, 0x02, 0x33, 0x34, 0x3c, 0xec, 0x1d, 0xf3, 0xa2, 0xc1, 0x6a, - 0xd4, 0x2f, 0x75, 0xea, 0xaa, 0x63, 0xde, 0x19, 0xb1, 0x6a, 0xb0, 0x9a, 0x8e, 0x67, 0xea, 0x4b, - 0xa4, 0xac, 0x96, 0xc2, 0x7b, 0x08, 0x0b, 0xac, 0xc0, 0x8f, 0xb8, 0x82, 0xb5, 0x36, 0x82, 0x5d, - 0x4e, 0x2f, 0xc8, 0x41, 0x4d, 0xd4, 0xe8, 0x45, 0x50, 0x4b, 0xf5, 0x02, 0x44, 0x50, 0x4b, 0x97, - 0xf4, 0x09, 0x8c, 0xa8, 0xbf, 0x0b, 0x98, 0x54, 0x49, 0x5f, 0xc0, 0xa4, 0xcb, 0xf5, 0xc4, 0x76, - 0x72, 0x65, 0x5d, 0xd8, 0xce, 0x50, 0xb0, 0x17, 0xb6, 0x33, 0x15, 0xe3, 0x49, 0x80, 0xe3, 0xe5, - 0x74, 0xa4, 0xe8, 0x40, 0x71, 0x81, 0x6d, 0xc3, 0x8a, 0x7c, 0xff, 0xa5, 0xaa, 0x38, 0xd2, 0x94, - 0x60, 0x0e, 0x70, 0xa6, 0x32, 0xfa, 0x0c, 0x3a, 0x86, 0x42, 0x4c, 0x00, 0x6d, 0xc8, 0xe4, 0xd8, - 0xd9, 0x92, 0x3a, 0x29, 0xe7, 0x0a, 0x82, 0x26, 0x72, 0x85, 0x52, 0x26, 0x17, 0xb9, 0x42, 0x2b, - 0x72, 0x73, 0x8b, 0x50, 0x37, 0x53, 0x84, 0x54, 0x7d, 0xcc, 0x36, 0x2d, 0xa5, 0x2d, 0xa2, 0xc7, - 0x65, 0x43, 0x91, 0x5a, 0xb7, 0x88, 0x29, 0x2e, 0x4b, 0xb5, 0x26, 0xa1, 0xcd, 0x74, 0xe5, 0x57, - 0x68, 0xd3, 0x50, 0x43, 0x75, 0x66, 0xd0, 0xc7, 0xb0, 0xa6, 0x55, 0xad, 0xd0, 0x6e, 0x76, 0x81, - 0xd0, 0xbe, 0x3b, 0x72, 0x5d, 0x8e, 0x62, 0xb4, 0x92, 0x24, 0xa2, 0x98, 0x5a, 0xcf, 0x12, 0x51, - 0x4c, 0x2b, 0x39, 0x11, 0x7f, 0xe3, 0x55, 0x0e, 0xe1, 0x6f, 0x7a, 0x51, 0x47, 0xf8, 0x5b, 0xaa, - 0x24, 0x42, 0x93, 0x32, 0x7b, 0x81, 0x4b, 0x49, 0x59, 0x2b, 0x4c, 0x48, 0x49, 0x59, 0x7f, 0xae, - 0x3b, 0x33, 0xe8, 0x05, 0x14, 0xf5, 0x07, 0x36, 0x92, 0x84, 0x37, 0x3e, 0xcb, 0xed, 0xbd, 0xd1, - 0x1b, 0x46, 0x01, 0x27, 0x1f, 0x9a, 0x46, 0x60, 0xe9, 0x41, 0x6d, 0x06, 0x96, 0x5f, 0xbc, 0xce, - 0x0c, 0xfa, 0x29, 0xac, 0xa7, 0xde, 0x5b, 0x68, 0x6f, 0xdc, 0x5b, 0xd4, 0xfe, 0xce, 0xd8, 0xc7, - 0x1a, 0xc1, 0xae, 0x8f, 0xc6, 0xae, 0x8f, 0xc5, 0xae, 0x8f, 0xc6, 0xae, 0xde, 0xfb, 0xdb, 0xab, - 0x5d, 0xeb, 0xef, 0xaf, 0x76, 0xad, 0x7f, 0xbe, 0xda, 0xb5, 0xc0, 0x6e, 0x74, 0x3b, 0x15, 0xff, - 0xa2, 0x53, 0x21, 0x1f, 0xb5, 0x0c, 0xa0, 0x15, 0xf6, 0x1a, 0xe7, 0xd6, 0xc5, 0x5c, 0xf2, 0x07, - 0xad, 0xe3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xfd, 0xed, 0xed, 0xcc, 0xc4, 0x25, 0x00, 0x00, -} diff --git a/golang/mock/mock.go b/golang/mock/mock.go index 45a445b..95ea6d8 100644 --- a/golang/mock/mock.go +++ b/golang/mock/mock.go @@ -754,4 +754,3 @@ func (mr *MockCryptoClientMockRecorder) WrapKey(arg0, arg1 interface{}, arg2 ... varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WrapKey", reflect.TypeOf((*MockCryptoClient)(nil).WrapKey), varargs...) } - diff --git a/golang/util/signer.go b/golang/util/signer.go index e76490a..a5638e3 100644 --- a/golang/util/signer.go +++ b/golang/util/signer.go @@ -80,4 +80,3 @@ func NewEP11Signer(cryptoClient pb.CryptoClient, privKeyBlob []byte, spki []byte } return priv, nil } - diff --git a/golang/util/util.go b/golang/util/util.go index f8adbd5..04120ad 100644 --- a/golang/util/util.go +++ b/golang/util/util.go @@ -19,6 +19,7 @@ import ( "fmt" "io/ioutil" "net/http" + "os" "reflect" "sync" "time" @@ -46,51 +47,68 @@ func DumpAttributes(attrs map[ep11.Attribute][]byte) string { return buffer.String() } -// NewAttribute is a convenience function to make conversions to []C.CK_ATTRIBUTE more convenient -func NewAttribute(aType ep11.Attribute, val interface{}) *ep11.AttributeStruct { - return &ep11.AttributeStruct{ - Type: aType, - Value: NewAttributeValue(val), +// AttributeMap is a map conversion helper function +func AttributeMap(attrs ep11.EP11Attributes) map[ep11.Attribute]*pb.AttributeValue { + rc := make(map[ep11.Attribute]*pb.AttributeValue) + for attr, val := range attrs { + rc[attr] = AttributeValue(val) } + + return rc } -// NewAttributeMap creates a map of ep11 attributes -func NewAttributeMap(attrs ...*ep11.AttributeStruct) map[ep11.Attribute][]byte { - rc := make(map[ep11.Attribute][]byte) - for _, val := range attrs { - rc[val.Type] = val.Value +// AttributeValue converts a standard Golang type into an AttributeValue structure +func AttributeValue(v interface{}) *pb.AttributeValue { + if v == nil { + return &pb.AttributeValue{} } - return rc + val := reflect.ValueOf(v) + switch val.Kind() { + case reflect.Bool: + return &pb.AttributeValue{OneAttr: &pb.AttributeValue_AttributeTF{AttributeTF: val.Bool()}} + case reflect.String: + return &pb.AttributeValue{OneAttr: &pb.AttributeValue_AttributeB{AttributeB: []byte(val.String())}} + case reflect.Slice: + return &pb.AttributeValue{OneAttr: &pb.AttributeValue_AttributeB{AttributeB: val.Bytes()}} + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return &pb.AttributeValue{OneAttr: &pb.AttributeValue_AttributeI{AttributeI: val.Int()}} + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return &pb.AttributeValue{OneAttr: &pb.AttributeValue_AttributeI{AttributeI: int64(val.Uint())}} + default: + buf := new(bytes.Buffer) + binary.Write(buf, binary.BigEndian, val) + return &pb.AttributeValue{OneAttr: &pb.AttributeValue_AttributeB{AttributeB: buf.Bytes()}} + } } -// NewAttributeValue converts a Golang-based attribute type to a C-based attribute type -func NewAttributeValue(val interface{}) []byte { +// GetAttributeByteValue obtains the byte slice equivalent of an attribute struct +func GetAttributeByteValue(val interface{}) ([]byte, error) { if val == nil { - return nil + return nil, fmt.Errorf("value for attribute processing is nil") } switch v := val.(type) { case bool: if v { - return []byte{1} + return []byte{1}, nil + } else { + return []byte{0}, nil } - return []byte{0} case string: - return []byte(v) + return []byte(v), nil case []byte: - return v + return v, nil default: buf := new(bytes.Buffer) err := binary.Write(buf, binary.BigEndian, val) if err != nil { - panic("PKCS11: Unhandled attribute type " + err.Error()) + return nil, fmt.Errorf("unhandled attribute type: %s", err) } - return buf.Bytes() + return buf.Bytes(), nil } } -// Convert returns a formatted GREP11 error message -// The contents of the error message depend on the source of the error +// Convert is a helper function for generating proper Grep11Error structures func Convert(err error) (bool, *pb.Grep11Error) { if err == nil { return true, nil @@ -109,7 +127,7 @@ func Convert(err error) (bool, *pb.Grep11Error) { if len(detail) != 1 { return false, &pb.Grep11Error{ Code: ep11.CKR_GENERAL_ERROR, - Detail: fmt.Sprintf("Expected only one error: [%s]", err), + Detail: fmt.Sprintf("Error: [%s]", err), Retry: true, } } @@ -118,7 +136,7 @@ func Convert(err error) (bool, *pb.Grep11Error) { if !ok { return false, &pb.Grep11Error{ Code: ep11.CKR_GENERAL_ERROR, - Detail: fmt.Sprintf("Detail is the wrong type [%s]: [%s]", reflect.TypeOf(detail[0]), err), + Detail: fmt.Sprintf("Error [%s]: [%s]", reflect.TypeOf(detail[0]), err), Retry: true, } } @@ -128,13 +146,14 @@ func Convert(err error) (bool, *pb.Grep11Error) { var ( // The following variables are standardized elliptic curve definitions - OIDNamedCurveP224 = asn1.ObjectIdentifier{1, 3, 132, 0, 33} - OIDNamedCurveP256 = asn1.ObjectIdentifier{1, 2, 840, 10045, 3, 1, 7} - OIDNamedCurveP384 = asn1.ObjectIdentifier{1, 3, 132, 0, 34} - OIDNamedCurveP521 = asn1.ObjectIdentifier{1, 3, 132, 0, 35} - oidECPublicKey = asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1} - oidRSAPublicKey = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1} - OIDNamedCurveED25519 = asn1.ObjectIdentifier{1, 3, 101, 112} + OIDNamedCurveP224 = asn1.ObjectIdentifier{1, 3, 132, 0, 33} + OIDNamedCurveP256 = asn1.ObjectIdentifier{1, 2, 840, 10045, 3, 1, 7} + OIDNamedCurveP384 = asn1.ObjectIdentifier{1, 3, 132, 0, 34} + OIDNamedCurveP521 = asn1.ObjectIdentifier{1, 3, 132, 0, 35} + oidECPublicKey = asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1} + oidRSAPublicKey = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1} + OIDNamedCurveSecp256k1 = asn1.ObjectIdentifier{1, 3, 132, 0, 10} + OIDNamedCurveED25519 = asn1.ObjectIdentifier{1, 3, 101, 112} ) // GetNamedCurveFromOID returns an elliptic curve from the specified curve OID @@ -294,3 +313,17 @@ func (cr *IAMPerRPCCredentials) getToken(ctx context.Context) (err error) { return nil } +// Pause is a helper function that pauses test execution until the user types CTRL-c +func Pause(m chan string, sigs chan os.Signal, message string) { + os.Stderr.WriteString("\n" + message + "\n") +loop: + for { + select { + case <-sigs: + fmt.Println("") + break loop + case <-m: + } + } + return +} From f19b50cd7ab5b092fea1aee9ecca7474b8025c60 Mon Sep 17 00:00:00 2001 From: Prabhat Ranjan Date: Mon, 9 Nov 2020 17:04:17 +0530 Subject: [PATCH 5/5] fixed --- golang/examples/ed25519_test.go | 149 ++++++------- golang/examples/server_test.go | 378 +++++++++++--------------------- 2 files changed, 199 insertions(+), 328 deletions(-) diff --git a/golang/examples/ed25519_test.go b/golang/examples/ed25519_test.go index 9019770..93b479f 100644 --- a/golang/examples/ed25519_test.go +++ b/golang/examples/ed25519_test.go @@ -1,25 +1,24 @@ package examples import ( - "context" - "crypto/sha256" - "encoding/asn1" - "fmt" - "testing" - "crypto/tls" - "crypto/x509" - "io/ioutil" - yaml "gopkg.in/yaml.v2" - - "google.golang.org/grpc/credentials" - "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" - pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" - "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/util" - "github.com/stretchr/testify/assert" - grpc "google.golang.org/grpc" + "context" + "crypto/sha256" + "encoding/asn1" + "fmt" + "testing" + "crypto/x509" + "io/ioutil" + "crypto/tls" + yaml "gopkg.in/yaml.v2" + + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" + pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" + "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/util" + "github.com/stretchr/testify/assert" + grpc "google.golang.org/grpc" + "google.golang.org/grpc/credentials" ) - var yamlConfig, _ = ioutil.ReadFile("credential.yaml") var m = make(map[interface{}]interface{}) @@ -44,6 +43,7 @@ var creds = credentials.NewTLS(&tls.Config{ }) var callOpts = []grpc.DialOption{ + //grpc.WithInsecure(), grpc.WithTransportCredentials(creds), } @@ -114,9 +114,9 @@ func TestED25519SignVerify(t *testing.T) { assert.NoError(t, err) signData := sha256.New().Sum([]byte("This data needs to be signed")) - signature, err := ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err := ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) assert.NoError(t, err) - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponse.PubKeyBytes, signData, signature) assert.NoError(t, err) } @@ -133,10 +133,12 @@ func TestED25519SignVerifyMulti(t *testing.T) { assert.NoError(t, err) signData := sha256.New().Sum([]byte("This data needs to be signed")) - signature, err := ed25519KeySignMulti(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err := ed25519KeySignMulti(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) + // An error is expected: SignUpdate is not supported for ed25519 assert.Contains(t, err.Error(), "SignUpdate error") - err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponse.PubKeyBytes, signData, signature) + // An error is expected: VerifyUpdate is not supported for ed25519 assert.Contains(t, err.Error(), "VerifyUpdate error") } @@ -153,10 +155,10 @@ func TestED25519SignVerifySingle(t *testing.T) { assert.NoError(t, err) signData := sha256.New().Sum([]byte("This data needs to be signed")) - signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) assert.NoError(t, err) - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponse.PubKeyBytes, signData, signature) assert.NoError(t, err) } @@ -166,19 +168,19 @@ func ed25519KeyGenerate(x testingX, cryptoClient pb.CryptoClient) (*pb.GenerateK return nil, fmt.Errorf("Unable to encode parameter OID: %s", err) } - publicKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), - util.NewAttribute(ep11.CKA_VERIFY, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_SIGN, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) + publicKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_EC_PARAMS: ecParameters, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + } + privateKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_SIGN: true, + ep11.CKA_EXTRACTABLE: false, + } generateECKeypairRequest := &pb.GenerateKeyPairRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyECTemplate, - PrivKeyTemplate: privateKeyECTemplate, + PubKeyTemplate: util.AttributeMap(publicKeyECTemplate), + PrivKeyTemplate: util.AttributeMap(privateKeyECTemplate), } generateKeyPairResponse, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) if err != nil { @@ -355,15 +357,15 @@ func TestED25519SignVerifyCrosstest(t *testing.T) { assert.NoError(t, err) signData := sha256.New().Sum([]byte("This data needs to be signed")) - signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) assert.NoError(t, err) - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponse.PubKeyBytes, signData, signature) assert.NoError(t, err) signData = sha256.New().Sum([]byte("This data needs to be signed")) - signature, err = ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err = ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) assert.NoError(t, err) - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponse.PubKey, signData, signature) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponse.PubKeyBytes, signData, signature) assert.NoError(t, err) } @@ -374,19 +376,19 @@ func ecdsaKeyGenerate(x testingX, cryptoClient pb.CryptoClient) (*pb.GenerateKey return nil, fmt.Errorf("Unable to encode parameter OID: %s", err) } - publicKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), - util.NewAttribute(ep11.CKA_VERIFY, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_SIGN, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) + publicKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_EC_PARAMS: ecParameters, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + } + privateKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_SIGN: true, + ep11.CKA_EXTRACTABLE: false, + } generateECKeypairRequest := &pb.GenerateKeyPairRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyECTemplate, - PrivKeyTemplate: privateKeyECTemplate, + PubKeyTemplate: util.AttributeMap(publicKeyECTemplate), + PrivKeyTemplate: util.AttributeMap(privateKeyECTemplate), } generateKeyPairResponse, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) if err != nil { @@ -427,17 +429,17 @@ func TestED25519InvalidKeyType(t *testing.T) { // Sign with the wrong key type signData := sha256.New().Sum([]byte("This data needs to be signed")) - signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseECDSA.PrivKeyBytes, signData) assert.Error(t, err) assert.Contains(t, err.Error(), "SignSingle error") assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") - signature, err = ed25519KeySign(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + signature, err = ed25519KeySign(t, cryptoClient, generateKeyPairResponseECDSA.PrivKeyBytes, signData) assert.Error(t, err) assert.Contains(t, err.Error(), "SignInit error") assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") - signature, err = ed25519KeySignMulti(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + signature, err = ed25519KeySignMulti(t, cryptoClient, generateKeyPairResponseECDSA.PrivKeyBytes, signData) assert.Error(t, err) assert.Contains(t, err.Error(), "SignInit error") assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") @@ -445,19 +447,19 @@ func TestED25519InvalidKeyType(t *testing.T) { // Verify with the wrong key type generateKeyPairResponseED25519, err := ed25519KeyGenerate(t, cryptoClient) assert.NoError(t, err) - signature, err = ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKey, signData) + signature, err = ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKeyBytes, signData) assert.NoError(t, err) - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseECDSA.PubKey, signData, signature) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseECDSA.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "VerifySingle error") - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseECDSA.PubKey, signData, signature) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseECDSA.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "VerifyInit error") assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") - err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponseECDSA.PubKey, signData, signature) + err = ed25519KeyVerifyMulti(t, cryptoClient, generateKeyPairResponseECDSA.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "VerifyInit error") assert.Contains(t, err.Error(), "CKR_MECHANISM_INVALID") @@ -491,7 +493,7 @@ func TestED25519InvalidKeys(t *testing.T) { // Verify with the wrong key generateKeyPairResponseED25519, err := ed25519KeyGenerate(t, cryptoClient) assert.NoError(t, err) - signature, err = ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKey, signData) + signature, err = ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKeyBytes, signData) assert.NoError(t, err) err = ed25519KeyVerifySingle(t, cryptoClient, []byte(keyWrong), signData, signature) @@ -521,7 +523,7 @@ func TestED25519InvalidSignature(t *testing.T) { generateKeyPairResponseED25519, err := ed25519KeyGenerate(t, cryptoClient) assert.NoError(t, err) - signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKey, signData) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponseED25519.PrivKeyBytes, signData) assert.NoError(t, err) signatureWrong := []([]byte){ @@ -533,11 +535,11 @@ func TestED25519InvalidSignature(t *testing.T) { } for _, signature := range signatureWrong { - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "Verify error") - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "VerifySingle error") } @@ -546,26 +548,26 @@ func TestED25519InvalidSignature(t *testing.T) { rng, err := cryptoClient.GenerateRandom(context.Background(), rngTemplate) assert.NoError(t, err) - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, rng.Rnd[:64]) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, rng.Rnd[:64]) assert.Error(t, err) assert.Contains(t, err.Error(), "Verify: Invalid signature") - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, rng.Rnd[:64]) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, rng.Rnd[:64]) assert.Error(t, err) assert.Contains(t, err.Error(), "VerifySingle: Invalid signature") generateKeyPairResponseECDSA, err := ecdsaKeyGenerate(t, cryptoClient) assert.NoError(t, err) - signature, err = ecdsaKeySignSingle(t, cryptoClient, generateKeyPairResponseECDSA.PrivKey, signData) + signature, err = ecdsaKeySignSingle(t, cryptoClient, generateKeyPairResponseECDSA.PrivKeyBytes, signData) assert.NoError(t, err) // Verify a ECDSA signature with ED25519 public key - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "Invalid signature") - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, signature) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, signature) assert.Error(t, err) assert.Contains(t, err.Error(), "Invalid signature") @@ -573,11 +575,11 @@ func TestED25519InvalidSignature(t *testing.T) { //assert.Error(t, err) //assert.Contains(t, err.Error(), "Invalid signature") - err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, nil) + err = ed25519KeyVerify(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, nil) assert.Error(t, err) assert.Contains(t, err.Error(), "Verify error") - err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKey, signData, nil) + err = ed25519KeyVerifySingle(t, cryptoClient, generateKeyPairResponseED25519.PubKeyBytes, signData, nil) assert.Error(t, err) assert.Contains(t, err.Error(), "VerifySingle error") @@ -644,19 +646,19 @@ func TestED25519ParallelSignVerify(t *testing.T) { chs := make([]chan error, 10) for i := 0; i < 10; i++ { chs[i] = make(chan error) - go ed25519KeySignChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PrivKey, signData) + go ed25519KeySignChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PrivKeyBytes, signData) } for _, ch := range chs { assert.NoError(t, <-ch) } - signature, err := ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err := ed25519KeySign(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) assert.NoError(t, err) for i := 0; i < 10; i++ { chs[i] = make(chan error) - go ed25519KeyVerifyChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PubKey, signData, signature) + go ed25519KeyVerifyChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PubKeyBytes, signData, signature) } for _, ch := range chs { @@ -680,23 +682,22 @@ func TestED25519ParallelSignVerifySingle(t *testing.T) { chs := make([]chan error, 10) for i := 0; i < 10; i++ { chs[i] = make(chan error) - go ed25519KeySignSingleChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PrivKey, signData) + go ed25519KeySignSingleChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PrivKeyBytes, signData) } for _, ch := range chs { assert.NoError(t, <-ch) } - signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKey, signData) + signature, err := ed25519KeySignSingle(t, cryptoClient, generateKeyPairResponse.PrivKeyBytes, signData) assert.NoError(t, err) for i := 0; i < 10; i++ { chs[i] = make(chan error) - go ed25519KeyVerifySingleChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PubKey, signData, signature) + go ed25519KeyVerifySingleChanWrap(t, cryptoClient, chs[i], generateKeyPairResponse.PubKeyBytes, signData, signature) } for _, ch := range chs { assert.NoError(t, <-ch) } } - diff --git a/golang/examples/server_test.go b/golang/examples/server_test.go index 7f427e2..fa43742 100644 --- a/golang/examples/server_test.go +++ b/golang/examples/server_test.go @@ -1,5 +1,6 @@ /* Copyright IBM Corp. All Rights Reserved. + SPDX-License-Identifier: Apache-2.0 */ @@ -13,32 +14,29 @@ import ( "encoding/asn1" "fmt" "reflect" - "crypto/x509" - "io/ioutil" + "crypto/x509" + "io/ioutil" + yaml "gopkg.in/yaml.v2" - yaml "gopkg.in/yaml.v2" "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/ep11" pb "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/grpc" "github.com/ibm-developer/ibm-cloud-hyperprotectcrypto/golang/util" - uuid "github.com/satori/go.uuid" grpc "google.golang.org/grpc" +// "github.com/stretchr/testify/assert" "google.golang.org/grpc/credentials" ) -// The following credential items need to be changed prior to running the sample program. - - var yamlConfig, _ = ioutil.ReadFile("credential.yaml") -var m = make(map[interface{}]interface{}) +var m = make(map[interface{}]interface{}) var err = yaml.Unmarshal([]byte(yamlConfig), &m) -var address = m["url"].(string) +var address = m["url"].(string) var ( - crt = m["cert_path"].(string) - key = m["key_path"].(string) - ca = m["cacert_path"].(string) + crt = m["cert_path"].(string) + key = m["key_path"].(string) + ca = m["cacert_path"].(string) ) var certificate, _ = tls.LoadX509KeyPair(crt, key) @@ -53,13 +51,14 @@ var creds = credentials.NewTLS(&tls.Config{ }) var callOpts = []grpc.DialOption{ - grpc.WithTransportCredentials(creds), + //grpc.WithInsecure(), + grpc.WithTransportCredentials(creds), } // Example_getMechanismInfo retrieves a mechanism list and retrieves detailed information for the CKM_RSA_PKCS mechanism // Flow: connect, get mechanism list, get mechanism info func Example_getMechanismInfo() { - conn, err := grpc.Dial(address, grpc.WithTransportCredentials(creds)) + conn, err := grpc.Dial(address, callOpts...) if err != nil { panic(fmt.Errorf("Could not connect to server: %s", err)) } @@ -98,23 +97,22 @@ func Example_encryptAndDecrypt() { cryptoClient := pb.NewCryptoClient(conn) keyLen := 128 - keyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_VALUE_LEN, (uint64)(keyLen/8)), - util.NewAttribute(ep11.CKA_WRAP, false), - util.NewAttribute(ep11.CKA_UNWRAP, false), - util.NewAttribute(ep11.CKA_ENCRYPT, true), - util.NewAttribute(ep11.CKA_DECRYPT, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), // set to false! - util.NewAttribute(ep11.CKA_TOKEN, true), // ignored by EP11 - ) - - keygenmsg := &pb.GenerateKeyRequest{ + keyTemplate := ep11.EP11Attributes{ + ep11.CKA_VALUE_LEN: keyLen / 8, + ep11.CKA_WRAP: false, + ep11.CKA_UNWRAP: false, + ep11.CKA_ENCRYPT: true, + ep11.CKA_DECRYPT: true, + ep11.CKA_EXTRACTABLE: false, // set to false! + ep11.CKA_TOKEN: true, // ignored by EP11 + } + + keyGenMsg := &pb.GenerateKeyRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_KEY_GEN}, - Template: keyTemplate, - KeyId: uuid.NewV4().String(), // optional + Template: util.AttributeMap(keyTemplate), } - generateKeyStatus, err := cryptoClient.GenerateKey(context.Background(), keygenmsg) + generateKeyStatus, err := cryptoClient.GenerateKey(context.Background(), keyGenMsg) if err != nil { panic(fmt.Errorf("GenerateKey Error: %s", err)) } @@ -131,8 +129,8 @@ func Example_encryptAndDecrypt() { fmt.Println("Generated IV") encipherInitInfo := &pb.EncryptInitRequest{ - Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_CBC_PAD, Parameter: iv}, - Key: generateKeyStatus.Key, // you may want to store this + Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_CBC_PAD, Parameter: &pb.Mechanism_ParameterB{ParameterB: iv}}, + Key: generateKeyStatus.KeyBytes, // you may want to store this } cipherStateInit, err := cryptoClient.EncryptInit(context.Background(), encipherInitInfo) if err != nil { @@ -173,8 +171,8 @@ func Example_encryptAndDecrypt() { fmt.Println("Encrypted message") decipherInitInfo := &pb.DecryptInitRequest{ - Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_CBC_PAD, Parameter: iv}, - Key: generateKeyStatus.Key, // you may want to store this + Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_CBC_PAD, Parameter: &pb.Mechanism_ParameterB{ParameterB: iv}}, + Key: generateKeyStatus.KeyBytes, // you may want to store this } decipherStateInit, err := cryptoClient.DecryptInit(context.Background(), decipherInitInfo) if err != nil { @@ -303,26 +301,24 @@ func Example_signAndVerifyUsingRSAKeyPair() { // Generate RSA key pairs publicExponent := []byte{0x11} - publicKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_ENCRYPT, true), - util.NewAttribute(ep11.CKA_VERIFY, true), // to verify a signature - util.NewAttribute(ep11.CKA_MODULUS_BITS, uint64(2048)), - util.NewAttribute(ep11.CKA_PUBLIC_EXPONENT, publicExponent), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_PRIVATE, true), - util.NewAttribute(ep11.CKA_SENSITIVE, true), - util.NewAttribute(ep11.CKA_DECRYPT, true), - util.NewAttribute(ep11.CKA_SIGN, true), // to generate a signature - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) + publicKeyTemplate := ep11.EP11Attributes{ + ep11.CKA_ENCRYPT: true, + ep11.CKA_VERIFY: true, // to verify a signature + ep11.CKA_MODULUS_BITS: 2048, + ep11.CKA_PUBLIC_EXPONENT: publicExponent, + ep11.CKA_EXTRACTABLE: false, + } + privateKeyTemplate := ep11.EP11Attributes{ + ep11.CKA_PRIVATE: true, + ep11.CKA_SENSITIVE: true, + ep11.CKA_DECRYPT: true, + ep11.CKA_SIGN: true, // to generate a signature + ep11.CKA_EXTRACTABLE: false, + } generateKeypairRequest := &pb.GenerateKeyPairRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_RSA_PKCS_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyTemplate, - PrivKeyTemplate: privateKeyTemplate, - PrivKeyId: uuid.NewV4().String(), - PubKeyId: uuid.NewV4().String(), + PubKeyTemplate: util.AttributeMap(publicKeyTemplate), + PrivKeyTemplate: util.AttributeMap(privateKeyTemplate), } generateKeyPairStatus, err := cryptoClient.GenerateKeyPair(context.Background(), generateKeypairRequest) if err != nil { @@ -333,17 +329,17 @@ func Example_signAndVerifyUsingRSAKeyPair() { // Sign data signInitRequest := &pb.SignInitRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_SHA1_RSA_PKCS}, - PrivKey: generateKeyPairStatus.PrivKey, + PrivKey: generateKeyPairStatus.PrivKeyBytes, } signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) if err != nil { panic(fmt.Errorf("SignInit error: %s", err)) } - signData := sha256.New().Sum([]byte("This data needs to be signed")) + signData := sha256.Sum256([]byte("This data needs to be signed")) signRequest := &pb.SignRequest{ State: signInitResponse.State, - Data: signData, + Data: []byte(signData[:]), } SignResponse, err := cryptoClient.Sign(context.Background(), signRequest) if err != nil { @@ -353,7 +349,7 @@ func Example_signAndVerifyUsingRSAKeyPair() { verifyInitRequest := &pb.VerifyInitRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_SHA1_RSA_PKCS}, - PubKey: generateKeyPairStatus.PubKey, + PubKey: generateKeyPairStatus.PubKeyBytes, } verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) if err != nil { @@ -361,7 +357,7 @@ func Example_signAndVerifyUsingRSAKeyPair() { } verifyRequest := &pb.VerifyRequest{ State: verifyInitResponse.State, - Data: signData, + Data: []byte(signData[:]), Signature: SignResponse.Signature, } _, err = cryptoClient.Verify(context.Background(), verifyRequest) @@ -396,19 +392,19 @@ func Example_signAndVerifyUsingECDSAKeyPair() { panic(fmt.Errorf("Unable to encode parameter OID: %s", err)) } - publicKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), - util.NewAttribute(ep11.CKA_VERIFY, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_SIGN, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) + publicKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_EC_PARAMS: ecParameters, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + } + privateKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_SIGN: true, + ep11.CKA_EXTRACTABLE: false, + } generateECKeypairRequest := &pb.GenerateKeyPairRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyECTemplate, - PrivKeyTemplate: privateKeyECTemplate, + PubKeyTemplate: util.AttributeMap(publicKeyECTemplate), + PrivKeyTemplate: util.AttributeMap(privateKeyECTemplate), } generateKeyPairStatus, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) if err != nil { @@ -420,16 +416,16 @@ func Example_signAndVerifyUsingECDSAKeyPair() { // Sign data signInitRequest := &pb.SignInitRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, - PrivKey: generateKeyPairStatus.PrivKey, + PrivKey: generateKeyPairStatus.PrivKeyBytes, } signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) if err != nil { panic(fmt.Errorf("SignInit error: %s", err)) } - signData := sha256.New().Sum([]byte("This data needs to be signed")) + signData := sha256.Sum256([]byte("This data needs to be signed")) signRequest := &pb.SignRequest{ State: signInitResponse.State, - Data: signData, + Data: signData[:], } SignResponse, err := cryptoClient.Sign(context.Background(), signRequest) if err != nil { @@ -439,7 +435,7 @@ func Example_signAndVerifyUsingECDSAKeyPair() { verifyInitRequest := &pb.VerifyInitRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, - PubKey: generateKeyPairStatus.PubKey, + PubKey: generateKeyPairStatus.PubKeyBytes, } verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) if err != nil { @@ -447,7 +443,7 @@ func Example_signAndVerifyUsingECDSAKeyPair() { } verifyRequest := &pb.VerifyRequest{ State: verifyInitResponse.State, - Data: signData, + Data: []byte(signData[:]), Signature: SignResponse.Signature, } _, err = cryptoClient.Verify(context.Background(), verifyRequest) @@ -483,19 +479,19 @@ func Example_signAndVerifyToTestErrorHandling() { panic(fmt.Errorf("Unable to encode parameter OID: %s", err)) } - publicKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), - util.NewAttribute(ep11.CKA_VERIFY, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_SIGN, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) + publicKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_EC_PARAMS: ecParameters, + ep11.CKA_VERIFY: true, + ep11.CKA_EXTRACTABLE: false, + } + privateKeyECTemplate := ep11.EP11Attributes{ + ep11.CKA_SIGN: true, + ep11.CKA_EXTRACTABLE: false, + } generateECKeypairRequest := &pb.GenerateKeyPairRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyECTemplate, - PrivKeyTemplate: privateKeyECTemplate, + PubKeyTemplate: util.AttributeMap(publicKeyECTemplate), + PrivKeyTemplate: util.AttributeMap(privateKeyECTemplate), } generateKeyPairStatus, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) if err != nil { @@ -507,16 +503,16 @@ func Example_signAndVerifyToTestErrorHandling() { // Sign data signInitRequest := &pb.SignInitRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, - PrivKey: generateKeyPairStatus.PrivKey, + PrivKey: generateKeyPairStatus.PrivKeyBytes, } signInitResponse, err := cryptoClient.SignInit(context.Background(), signInitRequest) if err != nil { panic(fmt.Errorf("SignInit error: %s", err)) } - signData := sha256.New().Sum([]byte("This data needs to be signed")) + signData := sha256.Sum256([]byte("This data needs to be signed")) signRequest := &pb.SignRequest{ State: signInitResponse.State, - Data: signData, + Data: signData[:], } SignResponse, err := cryptoClient.Sign(context.Background(), signRequest) if err != nil { @@ -529,7 +525,7 @@ func Example_signAndVerifyToTestErrorHandling() { verifyInitRequest := &pb.VerifyInitRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDSA}, - PubKey: generateKeyPairStatus.PubKey, + PubKey: generateKeyPairStatus.PubKeyBytes, } verifyInitResponse, err := cryptoClient.VerifyInit(context.Background(), verifyInitRequest) if err != nil { @@ -537,7 +533,7 @@ func Example_signAndVerifyToTestErrorHandling() { } verifyRequest := &pb.VerifyRequest{ State: verifyInitResponse.State, - Data: signData, + Data: []byte(signData[:]), Signature: SignResponse.Signature, } _, err = cryptoClient.Verify(context.Background(), verifyRequest) @@ -568,16 +564,15 @@ func Example_wrapAndUnwrapKey() { cryptoClient := pb.NewCryptoClient(conn) // Generate a AES key - desKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_VALUE_LEN, (uint64)(128/8)), - util.NewAttribute(ep11.CKA_ENCRYPT, true), - util.NewAttribute(ep11.CKA_DECRYPT, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, true), // must be true to be wrapped - ) + desKeyTemplate := ep11.EP11Attributes{ + ep11.CKA_VALUE_LEN: 128 / 8, + ep11.CKA_ENCRYPT: true, + ep11.CKA_DECRYPT: true, + ep11.CKA_EXTRACTABLE: true, // must be true to be wrapped + } generateKeyRequest := &pb.GenerateKeyRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_KEY_GEN}, - Template: desKeyTemplate, - KeyId: uuid.NewV4().String(), // optional + Template: util.AttributeMap(desKeyTemplate), } generateNewKeyStatus, err := cryptoClient.GenerateKey(context.Background(), generateKeyRequest) if err != nil { @@ -588,26 +583,24 @@ func Example_wrapAndUnwrapKey() { // Generate RSA key pairs publicExponent := []byte{0x11} - publicKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_ENCRYPT, true), - util.NewAttribute(ep11.CKA_WRAP, true), // to wrap a key - util.NewAttribute(ep11.CKA_MODULUS_BITS, uint64(2048)), - util.NewAttribute(ep11.CKA_PUBLIC_EXPONENT, publicExponent), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_PRIVATE, true), - util.NewAttribute(ep11.CKA_SENSITIVE, true), - util.NewAttribute(ep11.CKA_DECRYPT, true), - util.NewAttribute(ep11.CKA_UNWRAP, true), // to unwrap a key - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) + publicKeyTemplate := ep11.EP11Attributes{ + ep11.CKA_ENCRYPT: true, + ep11.CKA_WRAP: true, // to wrap a key + ep11.CKA_MODULUS_BITS: 2048, + ep11.CKA_PUBLIC_EXPONENT: publicExponent, + ep11.CKA_EXTRACTABLE: false, + } + privateKeyTemplate := ep11.EP11Attributes{ + ep11.CKA_PRIVATE: true, + ep11.CKA_SENSITIVE: true, + ep11.CKA_DECRYPT: true, + ep11.CKA_UNWRAP: true, // to unwrap a key + ep11.CKA_EXTRACTABLE: false, + } generateKeypairRequest := &pb.GenerateKeyPairRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_RSA_PKCS_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyTemplate, - PrivKeyTemplate: privateKeyTemplate, - PrivKeyId: uuid.NewV4().String(), - PubKeyId: uuid.NewV4().String(), + PubKeyTemplate: util.AttributeMap(publicKeyTemplate), + PrivKeyTemplate: util.AttributeMap(privateKeyTemplate), } generateKeyPairStatus, err := cryptoClient.GenerateKeyPair(context.Background(), generateKeypairRequest) if err != nil { @@ -617,165 +610,42 @@ func Example_wrapAndUnwrapKey() { wrapKeyRequest := &pb.WrapKeyRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_RSA_PKCS}, - KeK: generateKeyPairStatus.PubKey, - Key: generateNewKeyStatus.Key, + KeK: generateKeyPairStatus.PubKeyBytes, + Key: generateNewKeyStatus.KeyBytes, } wrapKeyResponse, err := cryptoClient.WrapKey(context.Background(), wrapKeyRequest) if err != nil { panic(fmt.Errorf("Wrap AES key error: %s", err)) } - fmt.Println("Wraped AES key") + fmt.Println("Wrapped AES key") - desUnwrapKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_CLASS, ep11.CKO_SECRET_KEY), - util.NewAttribute(ep11.CKA_KEY_TYPE, ep11.CKK_AES), - util.NewAttribute(ep11.CKA_VALUE_LEN, (uint64)(128/8)), - util.NewAttribute(ep11.CKA_ENCRYPT, true), - util.NewAttribute(ep11.CKA_DECRYPT, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, true), // must be true to be wrapped - ) + desUnwrapKeyTemplate := ep11.EP11Attributes{ + ep11.CKA_CLASS: ep11.CKO_SECRET_KEY, + ep11.CKA_KEY_TYPE: ep11.CKK_AES, + ep11.CKA_VALUE_LEN: 128 / 8, + ep11.CKA_ENCRYPT: true, + ep11.CKA_DECRYPT: true, + ep11.CKA_EXTRACTABLE: true, // must be true to be wrapped + } unwrapRequest := &pb.UnwrapKeyRequest{ Mech: &pb.Mechanism{Mechanism: ep11.CKM_RSA_PKCS}, - KeK: generateKeyPairStatus.PrivKey, + KeK: generateKeyPairStatus.PrivKeyBytes, Wrapped: wrapKeyResponse.Wrapped, - Template: desUnwrapKeyTemplate, + Template: util.AttributeMap(desUnwrapKeyTemplate), } - unWrapedResponse, err := cryptoClient.UnwrapKey(context.Background(), unwrapRequest) + unWrappedResponse, err := cryptoClient.UnwrapKey(context.Background(), unwrapRequest) if err != nil { panic(fmt.Errorf("Unwrap AES key error: %s", err)) } - if !bytes.Equal(generateNewKeyStatus.GetCheckSum()[:3], unWrapedResponse.GetCheckSum()[:3]) { + if !bytes.Equal(generateNewKeyStatus.GetCheckSum()[:3], unWrappedResponse.GetCheckSum()[:3]) { panic(fmt.Errorf("Unwrap AES key has a different checksum than the original key")) } else { - fmt.Println("Unwraped AES key") + fmt.Println("Unwrapped AES key") } // Output: // Generated AES key // Generated PKCS key pair - // Wraped AES key - // Unwraped AES key + // Wrapped AES key + // Unwrapped AES key } - -// Example_deriveKey generates ECDHE key pairs for Bob and Alice and then generates AES keys for both of them. -// The names Alice and Bob are described in https://en.wikipedia.org/wiki/Diffie–Hellman_key_exchange. -// Flow: connect, generate key pairs, derive AES key for Bob, derive AES key for Alice, encrypt with Alice's AES key and decrypt with Bob's AES key -func Example_deriveKey() { - conn, err := grpc.Dial(address, callOpts...) - if err != nil { - panic(fmt.Errorf("Could not connect to server: %s", err)) - } - defer conn.Close() - cryptoClient := pb.NewCryptoClient(conn) - - // Generate ECDH key pairs for Alice and Bob - ecParameters, err := asn1.Marshal(util.OIDNamedCurveP256) - if err != nil { - panic(fmt.Errorf("Unable to encode parameter OID: %s", err)) - } - - publicKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_EC_PARAMS, ecParameters), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - privateKeyECTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_DERIVE, true), - util.NewAttribute(ep11.CKA_EXTRACTABLE, false), - ) - generateECKeypairRequest := &pb.GenerateKeyPairRequest{ - Mech: &pb.Mechanism{Mechanism: ep11.CKM_EC_KEY_PAIR_GEN}, - PubKeyTemplate: publicKeyECTemplate, - PrivKeyTemplate: privateKeyECTemplate, - } - aliceECKeypairResponse, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) - if err != nil { - panic(fmt.Errorf("Generate Alice EC key pair error: %s", err)) - } - fmt.Println("Generated Alice EC key pair") - - bobECKeypairResponse, err := cryptoClient.GenerateKeyPair(context.Background(), generateECKeypairRequest) - if err != nil { - panic(fmt.Errorf("Generate Bob EC key pair error: %s", err)) - } - fmt.Println("Generated Bob EC key pair") - - // Derive AES key for Alice - deriveKeyTemplate := util.NewAttributeMap( - util.NewAttribute(ep11.CKA_CLASS, uint64(ep11.CKO_SECRET_KEY)), - util.NewAttribute(ep11.CKA_KEY_TYPE, uint64(ep11.CKK_AES)), - util.NewAttribute(ep11.CKA_VALUE_LEN, (uint64)(128/8)), - util.NewAttribute(ep11.CKA_ENCRYPT, true), - util.NewAttribute(ep11.CKA_DECRYPT, true), - ) - combinedCoordinates, err := util.GetPubkeyBytesFromSPKI(bobECKeypairResponse.PubKey) - if err != nil { - panic(fmt.Errorf("Bob's EC key cannot obtain coordinates: %s", err)) - } - aliceDerivekeyRequest := &pb.DeriveKeyRequest{ - Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDH1_DERIVE, Parameter: combinedCoordinates}, - Template: deriveKeyTemplate, - BaseKey: aliceECKeypairResponse.PrivKey, - } - aliceDerivekeyResponse, err := cryptoClient.DeriveKey(context.Background(), aliceDerivekeyRequest) - if err != nil { - panic(fmt.Errorf("Alice EC key derive error: %s", err)) - } - - // Derive AES key for Bob - combinedCoordinates, err = util.GetPubkeyBytesFromSPKI(aliceECKeypairResponse.PubKey) - if err != nil { - panic(fmt.Errorf("Alice's EC key cannot obtain coordinates: %s", err)) - } - bobDerivekeyRequest := &pb.DeriveKeyRequest{ - Mech: &pb.Mechanism{Mechanism: ep11.CKM_ECDH1_DERIVE, Parameter: combinedCoordinates}, - Template: deriveKeyTemplate, - BaseKey: bobECKeypairResponse.PrivKey, - } - bobDerivekeyResponse, err := cryptoClient.DeriveKey(context.Background(), bobDerivekeyRequest) - if err != nil { - panic(fmt.Errorf("Bob EC Key Derive Error: %s", err)) - } - - // Encrypt with Alice's key and decrypt with Bob's key - var msg = []byte("hello world!") - rngTemplate := &pb.GenerateRandomRequest{ - Len: (uint64)(ep11.AES_BLOCK_SIZE), - } - rng, err := cryptoClient.GenerateRandom(context.Background(), rngTemplate) - if err != nil { - panic(fmt.Errorf("GenerateRandom error: %s", err)) - } - iv := rng.Rnd[:ep11.AES_BLOCK_SIZE] - encryptRequest := &pb.EncryptSingleRequest{ - Key: aliceDerivekeyResponse.NewKey, - Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_CBC_PAD, Parameter: iv}, - Plain: msg, - } - encryptResponse, err := cryptoClient.EncryptSingle(context.Background(), encryptRequest) - if err != nil { - panic(fmt.Errorf("Encrypt error: %s", err)) - } - - decryptRequest := &pb.DecryptSingleRequest{ - Key: bobDerivekeyResponse.NewKey, - Mech: &pb.Mechanism{Mechanism: ep11.CKM_AES_CBC_PAD, Parameter: iv}, - Ciphered: encryptResponse.Ciphered, - } - decryptResponse, err := cryptoClient.DecryptSingle(context.Background(), decryptRequest) - if err != nil { - panic(fmt.Errorf("Decrypt error: %s", err)) - } - - if !bytes.Equal(decryptResponse.Plain, msg) { - panic(fmt.Errorf("Decrypted message[%v] is different from the original message: [%v]", decryptResponse.Plain, msg)) - } else { - fmt.Println("Alice and Bob get the same derived key") - } - - return - - // Output: - // Generated Alice EC key pair - // Generated Bob EC key pair - // Alice and Bob get the same derived key -} \ No newline at end of file