| // Copyright 2018 Google Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // source: third_party/tink/proto/tink.proto |
| |
| package tink_go_proto |
| |
| import ( |
| fmt "fmt" |
| proto "github.com/golang/protobuf/proto" |
| math "math" |
| ) |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // 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.ProtoPackageIsVersion3 // please upgrade the proto package |
| |
| type KeyStatusType int32 |
| |
| const ( |
| KeyStatusType_UNKNOWN_STATUS KeyStatusType = 0 |
| KeyStatusType_ENABLED KeyStatusType = 1 |
| KeyStatusType_DISABLED KeyStatusType = 2 |
| KeyStatusType_DESTROYED KeyStatusType = 3 |
| ) |
| |
| var KeyStatusType_name = map[int32]string{ |
| 0: "UNKNOWN_STATUS", |
| 1: "ENABLED", |
| 2: "DISABLED", |
| 3: "DESTROYED", |
| } |
| |
| var KeyStatusType_value = map[string]int32{ |
| "UNKNOWN_STATUS": 0, |
| "ENABLED": 1, |
| "DISABLED": 2, |
| "DESTROYED": 3, |
| } |
| |
| func (x KeyStatusType) String() string { |
| return proto.EnumName(KeyStatusType_name, int32(x)) |
| } |
| |
| func (KeyStatusType) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{0} |
| } |
| |
| // Tink produces and accepts ciphertexts or signatures that consist |
| // of a prefix and a payload. The payload and its format is determined |
| // entirely by the primitive, but the prefix has to be one of the following |
| // 4 types: |
| // - Legacy: prefix is 5 bytes, starts with \x00 and followed by a 4-byte |
| // key id that is computed from the key material. |
| // - Crunchy: prefix is 5 bytes, starts with \x00 and followed by a 4-byte |
| // key id that is generated randomly. |
| // - Tink : prefix is 5 bytes, starts with \x01 and followed by 4-byte |
| // key id that is generated randomly. |
| // - Raw : prefix is 0 byte, i.e., empty. |
| type OutputPrefixType int32 |
| |
| const ( |
| OutputPrefixType_UNKNOWN_PREFIX OutputPrefixType = 0 |
| OutputPrefixType_TINK OutputPrefixType = 1 |
| OutputPrefixType_LEGACY OutputPrefixType = 2 |
| OutputPrefixType_RAW OutputPrefixType = 3 |
| // CRUNCHY is like LEGACY, but with two differences: |
| // - Its key id is generated randomly (like TINK) |
| // - Its signature schemes don't append zero to sign messages |
| OutputPrefixType_CRUNCHY OutputPrefixType = 4 |
| ) |
| |
| var OutputPrefixType_name = map[int32]string{ |
| 0: "UNKNOWN_PREFIX", |
| 1: "TINK", |
| 2: "LEGACY", |
| 3: "RAW", |
| 4: "CRUNCHY", |
| } |
| |
| var OutputPrefixType_value = map[string]int32{ |
| "UNKNOWN_PREFIX": 0, |
| "TINK": 1, |
| "LEGACY": 2, |
| "RAW": 3, |
| "CRUNCHY": 4, |
| } |
| |
| func (x OutputPrefixType) String() string { |
| return proto.EnumName(OutputPrefixType_name, int32(x)) |
| } |
| |
| func (OutputPrefixType) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{1} |
| } |
| |
| type KeyData_KeyMaterialType int32 |
| |
| const ( |
| KeyData_UNKNOWN_KEYMATERIAL KeyData_KeyMaterialType = 0 |
| KeyData_SYMMETRIC KeyData_KeyMaterialType = 1 |
| KeyData_ASYMMETRIC_PRIVATE KeyData_KeyMaterialType = 2 |
| KeyData_ASYMMETRIC_PUBLIC KeyData_KeyMaterialType = 3 |
| KeyData_REMOTE KeyData_KeyMaterialType = 4 |
| ) |
| |
| var KeyData_KeyMaterialType_name = map[int32]string{ |
| 0: "UNKNOWN_KEYMATERIAL", |
| 1: "SYMMETRIC", |
| 2: "ASYMMETRIC_PRIVATE", |
| 3: "ASYMMETRIC_PUBLIC", |
| 4: "REMOTE", |
| } |
| |
| var KeyData_KeyMaterialType_value = map[string]int32{ |
| "UNKNOWN_KEYMATERIAL": 0, |
| "SYMMETRIC": 1, |
| "ASYMMETRIC_PRIVATE": 2, |
| "ASYMMETRIC_PUBLIC": 3, |
| "REMOTE": 4, |
| } |
| |
| func (x KeyData_KeyMaterialType) String() string { |
| return proto.EnumName(KeyData_KeyMaterialType_name, int32(x)) |
| } |
| |
| func (KeyData_KeyMaterialType) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{1, 0} |
| } |
| |
| type KeyTemplate struct { |
| // Required. |
| TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"` |
| // Optional. |
| // If missing, it means the key type doesn't require a *KeyFormat proto. |
| Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` |
| // Optional. |
| // If missing, uses OutputPrefixType.TINK. |
| OutputPrefixType OutputPrefixType `protobuf:"varint,3,opt,name=output_prefix_type,json=outputPrefixType,proto3,enum=google.crypto.tink.OutputPrefixType" json:"output_prefix_type,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *KeyTemplate) Reset() { *m = KeyTemplate{} } |
| func (m *KeyTemplate) String() string { return proto.CompactTextString(m) } |
| func (*KeyTemplate) ProtoMessage() {} |
| func (*KeyTemplate) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{0} |
| } |
| |
| func (m *KeyTemplate) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_KeyTemplate.Unmarshal(m, b) |
| } |
| func (m *KeyTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_KeyTemplate.Marshal(b, m, deterministic) |
| } |
| func (m *KeyTemplate) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_KeyTemplate.Merge(m, src) |
| } |
| func (m *KeyTemplate) XXX_Size() int { |
| return xxx_messageInfo_KeyTemplate.Size(m) |
| } |
| func (m *KeyTemplate) XXX_DiscardUnknown() { |
| xxx_messageInfo_KeyTemplate.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_KeyTemplate proto.InternalMessageInfo |
| |
| func (m *KeyTemplate) GetTypeUrl() string { |
| if m != nil { |
| return m.TypeUrl |
| } |
| return "" |
| } |
| |
| func (m *KeyTemplate) GetValue() []byte { |
| if m != nil { |
| return m.Value |
| } |
| return nil |
| } |
| |
| func (m *KeyTemplate) GetOutputPrefixType() OutputPrefixType { |
| if m != nil { |
| return m.OutputPrefixType |
| } |
| return OutputPrefixType_UNKNOWN_PREFIX |
| } |
| |
| // The actual *Key-proto is wrapped in a KeyData message, which in addition |
| // to this serialized proto contains also type_url identifying the |
| // definition of *Key-proto (as in KeyFormat-message), and some extra metadata |
| // about the type key material. |
| type KeyData struct { |
| // Required. |
| TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"` |
| // Required. |
| Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` |
| // Required. |
| KeyMaterialType KeyData_KeyMaterialType `protobuf:"varint,3,opt,name=key_material_type,json=keyMaterialType,proto3,enum=google.crypto.tink.KeyData_KeyMaterialType" json:"key_material_type,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *KeyData) Reset() { *m = KeyData{} } |
| func (m *KeyData) String() string { return proto.CompactTextString(m) } |
| func (*KeyData) ProtoMessage() {} |
| func (*KeyData) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{1} |
| } |
| |
| func (m *KeyData) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_KeyData.Unmarshal(m, b) |
| } |
| func (m *KeyData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_KeyData.Marshal(b, m, deterministic) |
| } |
| func (m *KeyData) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_KeyData.Merge(m, src) |
| } |
| func (m *KeyData) XXX_Size() int { |
| return xxx_messageInfo_KeyData.Size(m) |
| } |
| func (m *KeyData) XXX_DiscardUnknown() { |
| xxx_messageInfo_KeyData.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_KeyData proto.InternalMessageInfo |
| |
| func (m *KeyData) GetTypeUrl() string { |
| if m != nil { |
| return m.TypeUrl |
| } |
| return "" |
| } |
| |
| func (m *KeyData) GetValue() []byte { |
| if m != nil { |
| return m.Value |
| } |
| return nil |
| } |
| |
| func (m *KeyData) GetKeyMaterialType() KeyData_KeyMaterialType { |
| if m != nil { |
| return m.KeyMaterialType |
| } |
| return KeyData_UNKNOWN_KEYMATERIAL |
| } |
| |
| // A Tink user works usually not with single keys, but with keysets, |
| // to enable key rotation. The keys in a keyset can belong to different |
| // implementations/key types, but must all implement the same primitive. |
| // Any given keyset (and any given key) can be used for one primitive only. |
| type Keyset struct { |
| // Identifies key used to generate new crypto data (encrypt, sign). |
| // Required. |
| PrimaryKeyId uint32 `protobuf:"varint,1,opt,name=primary_key_id,json=primaryKeyId,proto3" json:"primary_key_id,omitempty"` |
| // Actual keys in the Keyset. |
| // Required. |
| Key []*Keyset_Key `protobuf:"bytes,2,rep,name=key,proto3" json:"key,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Keyset) Reset() { *m = Keyset{} } |
| func (m *Keyset) String() string { return proto.CompactTextString(m) } |
| func (*Keyset) ProtoMessage() {} |
| func (*Keyset) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{2} |
| } |
| |
| func (m *Keyset) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Keyset.Unmarshal(m, b) |
| } |
| func (m *Keyset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Keyset.Marshal(b, m, deterministic) |
| } |
| func (m *Keyset) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Keyset.Merge(m, src) |
| } |
| func (m *Keyset) XXX_Size() int { |
| return xxx_messageInfo_Keyset.Size(m) |
| } |
| func (m *Keyset) XXX_DiscardUnknown() { |
| xxx_messageInfo_Keyset.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Keyset proto.InternalMessageInfo |
| |
| func (m *Keyset) GetPrimaryKeyId() uint32 { |
| if m != nil { |
| return m.PrimaryKeyId |
| } |
| return 0 |
| } |
| |
| func (m *Keyset) GetKey() []*Keyset_Key { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| type Keyset_Key struct { |
| // Contains the actual, instantiation specific key proto. |
| // By convention, each key proto contains a version field. |
| KeyData *KeyData `protobuf:"bytes,1,opt,name=key_data,json=keyData,proto3" json:"key_data,omitempty"` |
| Status KeyStatusType `protobuf:"varint,2,opt,name=status,proto3,enum=google.crypto.tink.KeyStatusType" json:"status,omitempty"` |
| // Identifies a key within a keyset, is a part of metadata |
| // of a ciphertext/signature. |
| KeyId uint32 `protobuf:"varint,3,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"` |
| // Determines the prefix of the ciphertexts/signatures produced by this key. |
| // This value is copied verbatim from the key template. |
| OutputPrefixType OutputPrefixType `protobuf:"varint,4,opt,name=output_prefix_type,json=outputPrefixType,proto3,enum=google.crypto.tink.OutputPrefixType" json:"output_prefix_type,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Keyset_Key) Reset() { *m = Keyset_Key{} } |
| func (m *Keyset_Key) String() string { return proto.CompactTextString(m) } |
| func (*Keyset_Key) ProtoMessage() {} |
| func (*Keyset_Key) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{2, 0} |
| } |
| |
| func (m *Keyset_Key) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Keyset_Key.Unmarshal(m, b) |
| } |
| func (m *Keyset_Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Keyset_Key.Marshal(b, m, deterministic) |
| } |
| func (m *Keyset_Key) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Keyset_Key.Merge(m, src) |
| } |
| func (m *Keyset_Key) XXX_Size() int { |
| return xxx_messageInfo_Keyset_Key.Size(m) |
| } |
| func (m *Keyset_Key) XXX_DiscardUnknown() { |
| xxx_messageInfo_Keyset_Key.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Keyset_Key proto.InternalMessageInfo |
| |
| func (m *Keyset_Key) GetKeyData() *KeyData { |
| if m != nil { |
| return m.KeyData |
| } |
| return nil |
| } |
| |
| func (m *Keyset_Key) GetStatus() KeyStatusType { |
| if m != nil { |
| return m.Status |
| } |
| return KeyStatusType_UNKNOWN_STATUS |
| } |
| |
| func (m *Keyset_Key) GetKeyId() uint32 { |
| if m != nil { |
| return m.KeyId |
| } |
| return 0 |
| } |
| |
| func (m *Keyset_Key) GetOutputPrefixType() OutputPrefixType { |
| if m != nil { |
| return m.OutputPrefixType |
| } |
| return OutputPrefixType_UNKNOWN_PREFIX |
| } |
| |
| // Represents a "safe" Keyset that doesn't contain any actual key material, |
| // thus can be used for logging or monitoring. Most fields are copied from |
| // Keyset. |
| type KeysetInfo struct { |
| // See Keyset.primary_key_id. |
| PrimaryKeyId uint32 `protobuf:"varint,1,opt,name=primary_key_id,json=primaryKeyId,proto3" json:"primary_key_id,omitempty"` |
| // KeyInfos in the KeysetInfo. |
| // Each KeyInfo is corresponding to a Key in the corresponding Keyset. |
| KeyInfo []*KeysetInfo_KeyInfo `protobuf:"bytes,2,rep,name=key_info,json=keyInfo,proto3" json:"key_info,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *KeysetInfo) Reset() { *m = KeysetInfo{} } |
| func (m *KeysetInfo) String() string { return proto.CompactTextString(m) } |
| func (*KeysetInfo) ProtoMessage() {} |
| func (*KeysetInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{3} |
| } |
| |
| func (m *KeysetInfo) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_KeysetInfo.Unmarshal(m, b) |
| } |
| func (m *KeysetInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_KeysetInfo.Marshal(b, m, deterministic) |
| } |
| func (m *KeysetInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_KeysetInfo.Merge(m, src) |
| } |
| func (m *KeysetInfo) XXX_Size() int { |
| return xxx_messageInfo_KeysetInfo.Size(m) |
| } |
| func (m *KeysetInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_KeysetInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_KeysetInfo proto.InternalMessageInfo |
| |
| func (m *KeysetInfo) GetPrimaryKeyId() uint32 { |
| if m != nil { |
| return m.PrimaryKeyId |
| } |
| return 0 |
| } |
| |
| func (m *KeysetInfo) GetKeyInfo() []*KeysetInfo_KeyInfo { |
| if m != nil { |
| return m.KeyInfo |
| } |
| return nil |
| } |
| |
| type KeysetInfo_KeyInfo struct { |
| // the type url of this key, |
| // e.g., type.googleapis.com/google.crypto.tink.HmacKey. |
| TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"` |
| // See Keyset.Key.status. |
| Status KeyStatusType `protobuf:"varint,2,opt,name=status,proto3,enum=google.crypto.tink.KeyStatusType" json:"status,omitempty"` |
| // See Keyset.Key.key_id. |
| KeyId uint32 `protobuf:"varint,3,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"` |
| // See Keyset.Key.output_prefix_type. |
| OutputPrefixType OutputPrefixType `protobuf:"varint,4,opt,name=output_prefix_type,json=outputPrefixType,proto3,enum=google.crypto.tink.OutputPrefixType" json:"output_prefix_type,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *KeysetInfo_KeyInfo) Reset() { *m = KeysetInfo_KeyInfo{} } |
| func (m *KeysetInfo_KeyInfo) String() string { return proto.CompactTextString(m) } |
| func (*KeysetInfo_KeyInfo) ProtoMessage() {} |
| func (*KeysetInfo_KeyInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{3, 0} |
| } |
| |
| func (m *KeysetInfo_KeyInfo) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_KeysetInfo_KeyInfo.Unmarshal(m, b) |
| } |
| func (m *KeysetInfo_KeyInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_KeysetInfo_KeyInfo.Marshal(b, m, deterministic) |
| } |
| func (m *KeysetInfo_KeyInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_KeysetInfo_KeyInfo.Merge(m, src) |
| } |
| func (m *KeysetInfo_KeyInfo) XXX_Size() int { |
| return xxx_messageInfo_KeysetInfo_KeyInfo.Size(m) |
| } |
| func (m *KeysetInfo_KeyInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_KeysetInfo_KeyInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_KeysetInfo_KeyInfo proto.InternalMessageInfo |
| |
| func (m *KeysetInfo_KeyInfo) GetTypeUrl() string { |
| if m != nil { |
| return m.TypeUrl |
| } |
| return "" |
| } |
| |
| func (m *KeysetInfo_KeyInfo) GetStatus() KeyStatusType { |
| if m != nil { |
| return m.Status |
| } |
| return KeyStatusType_UNKNOWN_STATUS |
| } |
| |
| func (m *KeysetInfo_KeyInfo) GetKeyId() uint32 { |
| if m != nil { |
| return m.KeyId |
| } |
| return 0 |
| } |
| |
| func (m *KeysetInfo_KeyInfo) GetOutputPrefixType() OutputPrefixType { |
| if m != nil { |
| return m.OutputPrefixType |
| } |
| return OutputPrefixType_UNKNOWN_PREFIX |
| } |
| |
| // Represents a keyset that is encrypted with a master key. |
| type EncryptedKeyset struct { |
| // Required. |
| EncryptedKeyset []byte `protobuf:"bytes,2,opt,name=encrypted_keyset,json=encryptedKeyset,proto3" json:"encrypted_keyset,omitempty"` |
| // Optional. |
| KeysetInfo *KeysetInfo `protobuf:"bytes,3,opt,name=keyset_info,json=keysetInfo,proto3" json:"keyset_info,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *EncryptedKeyset) Reset() { *m = EncryptedKeyset{} } |
| func (m *EncryptedKeyset) String() string { return proto.CompactTextString(m) } |
| func (*EncryptedKeyset) ProtoMessage() {} |
| func (*EncryptedKeyset) Descriptor() ([]byte, []int) { |
| return fileDescriptor_a580d178bdd2ec8a, []int{4} |
| } |
| |
| func (m *EncryptedKeyset) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_EncryptedKeyset.Unmarshal(m, b) |
| } |
| func (m *EncryptedKeyset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_EncryptedKeyset.Marshal(b, m, deterministic) |
| } |
| func (m *EncryptedKeyset) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_EncryptedKeyset.Merge(m, src) |
| } |
| func (m *EncryptedKeyset) XXX_Size() int { |
| return xxx_messageInfo_EncryptedKeyset.Size(m) |
| } |
| func (m *EncryptedKeyset) XXX_DiscardUnknown() { |
| xxx_messageInfo_EncryptedKeyset.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_EncryptedKeyset proto.InternalMessageInfo |
| |
| func (m *EncryptedKeyset) GetEncryptedKeyset() []byte { |
| if m != nil { |
| return m.EncryptedKeyset |
| } |
| return nil |
| } |
| |
| func (m *EncryptedKeyset) GetKeysetInfo() *KeysetInfo { |
| if m != nil { |
| return m.KeysetInfo |
| } |
| return nil |
| } |
| |
| func init() { |
| proto.RegisterEnum("google.crypto.tink.KeyStatusType", KeyStatusType_name, KeyStatusType_value) |
| proto.RegisterEnum("google.crypto.tink.OutputPrefixType", OutputPrefixType_name, OutputPrefixType_value) |
| proto.RegisterEnum("google.crypto.tink.KeyData_KeyMaterialType", KeyData_KeyMaterialType_name, KeyData_KeyMaterialType_value) |
| proto.RegisterType((*KeyTemplate)(nil), "google.crypto.tink.KeyTemplate") |
| proto.RegisterType((*KeyData)(nil), "google.crypto.tink.KeyData") |
| proto.RegisterType((*Keyset)(nil), "google.crypto.tink.Keyset") |
| proto.RegisterType((*Keyset_Key)(nil), "google.crypto.tink.Keyset.Key") |
| proto.RegisterType((*KeysetInfo)(nil), "google.crypto.tink.KeysetInfo") |
| proto.RegisterType((*KeysetInfo_KeyInfo)(nil), "google.crypto.tink.KeysetInfo.KeyInfo") |
| proto.RegisterType((*EncryptedKeyset)(nil), "google.crypto.tink.EncryptedKeyset") |
| } |
| |
| func init() { proto.RegisterFile("proto/tink.proto", fileDescriptor_a580d178bdd2ec8a) } |
| |
| var fileDescriptor_a580d178bdd2ec8a = []byte{ |
| // 667 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x54, 0xcf, 0x6e, 0xd3, 0x4e, |
| 0x10, 0xae, 0xed, 0x34, 0x49, 0x27, 0x6d, 0xb2, 0xdd, 0xdf, 0xaf, 0x10, 0x0a, 0xaa, 0xd2, 0xa8, |
| 0x42, 0xa1, 0x48, 0x29, 0x0a, 0x12, 0x12, 0x27, 0xe4, 0x24, 0x0b, 0x58, 0xce, 0x3f, 0x6d, 0x1c, |
| 0x4a, 0xb8, 0x58, 0x6e, 0xb3, 0x4d, 0x2d, 0x27, 0xb1, 0xe5, 0x6c, 0x10, 0x3e, 0xf0, 0x00, 0x5c, |
| 0x79, 0x04, 0x1e, 0x85, 0x03, 0x07, 0x5e, 0x83, 0x17, 0x41, 0xbb, 0x76, 0xab, 0x36, 0xb4, 0x11, |
| 0x88, 0x13, 0xa7, 0x9d, 0x19, 0x7f, 0x3b, 0x33, 0xdf, 0xe7, 0x99, 0x85, 0x7d, 0x7e, 0xee, 0x86, |
| 0x23, 0x3b, 0x70, 0x42, 0x1e, 0x1d, 0x71, 0x77, 0xe6, 0x1d, 0x05, 0xa1, 0xcf, 0x7d, 0x69, 0x56, |
| 0xa5, 0x89, 0xf1, 0xd8, 0xf7, 0xc7, 0x13, 0x56, 0x3d, 0x0d, 0xa3, 0x80, 0xfb, 0x55, 0xf1, 0xa5, |
| 0xfc, 0x59, 0x81, 0x9c, 0xc9, 0x22, 0x8b, 0x4d, 0x83, 0x89, 0xc3, 0x19, 0xbe, 0x07, 0x59, 0x1e, |
| 0x05, 0xcc, 0x5e, 0x84, 0x93, 0xa2, 0x52, 0x52, 0x2a, 0x1b, 0x34, 0x23, 0xfc, 0x41, 0x38, 0xc1, |
| 0xff, 0xc3, 0xfa, 0x7b, 0x67, 0xb2, 0x60, 0x45, 0xb5, 0xa4, 0x54, 0x36, 0x69, 0xec, 0x60, 0x0a, |
| 0xd8, 0x5f, 0xf0, 0x60, 0xc1, 0xed, 0x20, 0x64, 0x67, 0xee, 0x07, 0x5b, 0xc0, 0x8b, 0x5a, 0x49, |
| 0xa9, 0xe4, 0x6b, 0x07, 0xd5, 0x5f, 0x2b, 0x56, 0xbb, 0x12, 0xdd, 0x93, 0x60, 0x2b, 0x0a, 0x18, |
| 0x45, 0xfe, 0x52, 0xa4, 0xfc, 0x49, 0x85, 0x8c, 0xc9, 0xa2, 0xa6, 0xc3, 0x9d, 0x3f, 0x6f, 0xe8, |
| 0x18, 0xb6, 0x3d, 0x16, 0xd9, 0x53, 0x87, 0xb3, 0xd0, 0x75, 0x26, 0x57, 0xfb, 0x79, 0x7c, 0x53, |
| 0x3f, 0x49, 0x21, 0x71, 0xb6, 0x93, 0x3b, 0xb2, 0xad, 0x82, 0x77, 0x3d, 0x50, 0xe6, 0x50, 0x58, |
| 0xc2, 0xe0, 0xbb, 0xf0, 0xdf, 0xa0, 0x63, 0x76, 0xba, 0xc7, 0x1d, 0xdb, 0x24, 0xc3, 0xb6, 0x6e, |
| 0x11, 0x6a, 0xe8, 0x2d, 0xb4, 0x86, 0xb7, 0x60, 0xa3, 0x3f, 0x6c, 0xb7, 0x89, 0x45, 0x8d, 0x06, |
| 0x52, 0xf0, 0x1d, 0xc0, 0xfa, 0xa5, 0x6f, 0xf7, 0xa8, 0xf1, 0x46, 0xb7, 0x08, 0x52, 0xf1, 0x0e, |
| 0x6c, 0x5f, 0x8d, 0x0f, 0xea, 0x2d, 0xa3, 0x81, 0x34, 0x0c, 0x90, 0xa6, 0xa4, 0xdd, 0xb5, 0x08, |
| 0x4a, 0x95, 0xbf, 0xa9, 0x90, 0x36, 0x59, 0x34, 0x67, 0x1c, 0x1f, 0x40, 0x3e, 0x08, 0xdd, 0xa9, |
| 0x13, 0x46, 0xb6, 0x60, 0xe8, 0x8e, 0xa4, 0x20, 0x5b, 0x74, 0x33, 0x89, 0x9a, 0x2c, 0x32, 0x46, |
| 0xf8, 0x09, 0x68, 0x1e, 0x8b, 0x8a, 0x6a, 0x49, 0xab, 0xe4, 0x6a, 0x7b, 0xb7, 0x30, 0x9e, 0x33, |
| 0x2e, 0x0e, 0x2a, 0xa0, 0xbb, 0x3f, 0x14, 0xd0, 0x4c, 0x16, 0xe1, 0x67, 0x90, 0x15, 0x79, 0x47, |
| 0x0e, 0x77, 0x64, 0xe6, 0x5c, 0xed, 0xfe, 0x0a, 0xc1, 0x68, 0xc6, 0x4b, 0x7e, 0xd1, 0x73, 0x48, |
| 0xcf, 0xb9, 0xc3, 0x17, 0x73, 0xf9, 0x23, 0xf2, 0xb5, 0xfd, 0x5b, 0x6e, 0xf5, 0x25, 0x48, 0x8a, |
| 0x9b, 0x5c, 0xc0, 0x3b, 0x90, 0x4e, 0xa8, 0x68, 0x92, 0xca, 0xba, 0x27, 0x39, 0xdc, 0x3c, 0x54, |
| 0xa9, 0xbf, 0x1a, 0xaa, 0xaf, 0x2a, 0x40, 0xcc, 0xdc, 0x98, 0x9d, 0xf9, 0xbf, 0x29, 0xa6, 0x1e, |
| 0x4b, 0xe2, 0xce, 0xce, 0xfc, 0x44, 0xd1, 0x87, 0xb7, 0x2b, 0x2a, 0xf2, 0x0a, 0x53, 0x9c, 0x52, |
| 0x1d, 0x61, 0xec, 0x7e, 0x57, 0xe4, 0x30, 0xcb, 0xa2, 0x2b, 0x86, 0xf9, 0xdf, 0x10, 0xf1, 0x23, |
| 0x14, 0xc8, 0x4c, 0xde, 0x61, 0xa3, 0x64, 0x2a, 0x1f, 0x01, 0x62, 0x17, 0x21, 0x21, 0xe5, 0x9c, |
| 0xf1, 0x64, 0x21, 0x0b, 0x6c, 0x09, 0xfa, 0x02, 0x72, 0x31, 0x20, 0x16, 0x54, 0x93, 0x33, 0xb6, |
| 0xb7, 0x5a, 0x50, 0x0a, 0xde, 0xa5, 0x7d, 0xd8, 0x86, 0xad, 0x6b, 0x12, 0x60, 0x0c, 0xf9, 0x8b, |
| 0x05, 0xec, 0x5b, 0xba, 0x35, 0xe8, 0xa3, 0x35, 0x9c, 0x83, 0x0c, 0xe9, 0xe8, 0xf5, 0x16, 0x69, |
| 0x22, 0x05, 0x6f, 0x42, 0xb6, 0x69, 0xf4, 0x63, 0x4f, 0x15, 0x6b, 0xd9, 0x24, 0x7d, 0x8b, 0x76, |
| 0x87, 0xa4, 0x89, 0xb4, 0x43, 0x0a, 0x68, 0x99, 0xf3, 0xd5, 0x8c, 0x3d, 0x4a, 0x5e, 0x1a, 0x6f, |
| 0xd1, 0x1a, 0xce, 0x42, 0xca, 0x32, 0x3a, 0x26, 0x52, 0xc4, 0x66, 0xb6, 0xc8, 0x2b, 0xbd, 0x31, |
| 0x44, 0x2a, 0xce, 0x80, 0x46, 0xf5, 0x63, 0xa4, 0x89, 0x82, 0x0d, 0x3a, 0xe8, 0x34, 0x5e, 0x0f, |
| 0x51, 0xaa, 0x3e, 0x80, 0x07, 0xa7, 0xfe, 0xf4, 0x26, 0x4e, 0xf2, 0x11, 0xee, 0x29, 0xef, 0x0e, |
| 0xc7, 0x2e, 0x3f, 0x5f, 0x9c, 0x54, 0x4f, 0xfd, 0xe9, 0x51, 0x0c, 0x5b, 0x7e, 0xaf, 0xed, 0xb1, |
| 0x6f, 0x4b, 0xef, 0x8b, 0x9a, 0x16, 0x85, 0x7b, 0xf5, 0x93, 0xb4, 0xf4, 0x9f, 0xfe, 0x0c, 0x00, |
| 0x00, 0xff, 0xff, 0x8a, 0x74, 0x7a, 0x5d, 0xe7, 0x05, 0x00, 0x00, |
| } |
