// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: crypto.proto package crypto_pb import ( fmt "fmt" github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto" io "io" 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package type KeyType int32 const ( KeyType_RSA KeyType = 0 KeyType_Ed25519 KeyType = 1 KeyType_Secp256k1 KeyType = 2 KeyType_ECDSA KeyType = 3 ) var KeyType_name = map[int32]string{ 0: "RSA", 1: "Ed25519", 2: "Secp256k1", 3: "ECDSA", } var KeyType_value = map[string]int32{ "RSA": 0, "Ed25519": 1, "Secp256k1": 2, "ECDSA": 3, } func (x KeyType) Enum() *KeyType { p := new(KeyType) *p = x return p } func (x KeyType) String() string { return proto.EnumName(KeyType_name, int32(x)) } func (x *KeyType) UnmarshalJSON(data []byte) error { value, err := proto.UnmarshalJSONEnum(KeyType_value, data, "KeyType") if err != nil { return err } *x = KeyType(value) return nil } func (KeyType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_527278fb02d03321, []int{0} } type PublicKey struct { Type KeyType `protobuf:"varint,1,req,name=Type,enum=crypto.pb.KeyType" json:"Type"` Data []byte `protobuf:"bytes,2,req,name=Data" json:"Data"` } func (m *PublicKey) Reset() { *m = PublicKey{} } func (m *PublicKey) String() string { return proto.CompactTextString(m) } func (*PublicKey) ProtoMessage() {} func (*PublicKey) Descriptor() ([]byte, []int) { return fileDescriptor_527278fb02d03321, []int{0} } func (m *PublicKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PublicKey) XXX_Merge(src proto.Message) { xxx_messageInfo_PublicKey.Merge(m, src) } func (m *PublicKey) XXX_Size() int { return m.Size() } func (m *PublicKey) XXX_DiscardUnknown() { xxx_messageInfo_PublicKey.DiscardUnknown(m) } var xxx_messageInfo_PublicKey proto.InternalMessageInfo func (m *PublicKey) GetType() KeyType { if m != nil { return m.Type } return KeyType_RSA } func (m *PublicKey) GetData() []byte { if m != nil { return m.Data } return nil } type PrivateKey struct { Type KeyType `protobuf:"varint,1,req,name=Type,enum=crypto.pb.KeyType" json:"Type"` Data []byte `protobuf:"bytes,2,req,name=Data" json:"Data"` } func (m *PrivateKey) Reset() { *m = PrivateKey{} } func (m *PrivateKey) String() string { return proto.CompactTextString(m) } func (*PrivateKey) ProtoMessage() {} func (*PrivateKey) Descriptor() ([]byte, []int) { return fileDescriptor_527278fb02d03321, []int{1} } func (m *PrivateKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PrivateKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PrivateKey.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalTo(b) if err != nil { return nil, err } return b[:n], nil } } func (m *PrivateKey) XXX_Merge(src proto.Message) { xxx_messageInfo_PrivateKey.Merge(m, src) } func (m *PrivateKey) XXX_Size() int { return m.Size() } func (m *PrivateKey) XXX_DiscardUnknown() { xxx_messageInfo_PrivateKey.DiscardUnknown(m) } var xxx_messageInfo_PrivateKey proto.InternalMessageInfo func (m *PrivateKey) GetType() KeyType { if m != nil { return m.Type } return KeyType_RSA } func (m *PrivateKey) GetData() []byte { if m != nil { return m.Data } return nil } func init() { proto.RegisterEnum("crypto.pb.KeyType", KeyType_name, KeyType_value) proto.RegisterType((*PublicKey)(nil), "crypto.pb.PublicKey") proto.RegisterType((*PrivateKey)(nil), "crypto.pb.PrivateKey") } func init() { proto.RegisterFile("crypto.proto", fileDescriptor_527278fb02d03321) } var fileDescriptor_527278fb02d03321 = []byte{ // 203 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x49, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0xf1, 0x92, 0x94, 0x82, 0xb9, 0x38, 0x03, 0x4a, 0x93, 0x72, 0x32, 0x93, 0xbd, 0x53, 0x2b, 0x85, 0x74, 0xb8, 0x58, 0x42, 0x2a, 0x0b, 0x52, 0x25, 0x18, 0x15, 0x98, 0x34, 0xf8, 0x8c, 0x84, 0xf4, 0xe0, 0xca, 0xf4, 0xbc, 0x53, 0x2b, 0x41, 0x32, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x81, 0x55, 0x09, 0x49, 0x70, 0xb1, 0xb8, 0x24, 0x96, 0x24, 0x4a, 0x30, 0x29, 0x30, 0x69, 0xf0, 0xc0, 0x64, 0x40, 0x22, 0x4a, 0x21, 0x5c, 0x5c, 0x01, 0x45, 0x99, 0x65, 0x89, 0x25, 0xa9, 0x54, 0x34, 0x55, 0xcb, 0x92, 0x8b, 0x1d, 0xaa, 0x41, 0x88, 0x9d, 0x8b, 0x39, 0x28, 0xd8, 0x51, 0x80, 0x41, 0x88, 0x9b, 0x8b, 0xdd, 0x35, 0xc5, 0xc8, 0xd4, 0xd4, 0xd0, 0x52, 0x80, 0x51, 0x88, 0x97, 0x8b, 0x33, 0x38, 0x35, 0xb9, 0xc0, 0xc8, 0xd4, 0x2c, 0xdb, 0x50, 0x80, 0x49, 0x88, 0x93, 0x8b, 0xd5, 0xd5, 0xd9, 0x25, 0xd8, 0x51, 0x80, 0xd9, 0x49, 0xe2, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x13, 0xbe, 0xd4, 0xff, 0x19, 0x01, 0x00, 0x00, } func (m *PublicKey) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PublicKey) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0x8 i++ i = encodeVarintCrypto(dAtA, i, uint64(m.Type)) if m.Data != nil { dAtA[i] = 0x12 i++ i = encodeVarintCrypto(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } return i, nil } func (m *PrivateKey) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } return dAtA[:n], nil } func (m *PrivateKey) MarshalTo(dAtA []byte) (int, error) { var i int _ = i var l int _ = l dAtA[i] = 0x8 i++ i = encodeVarintCrypto(dAtA, i, uint64(m.Type)) if m.Data != nil { dAtA[i] = 0x12 i++ i = encodeVarintCrypto(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } return i, nil } func encodeVarintCrypto(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 *PublicKey) Size() (n int) { if m == nil { return 0 } var l int _ = l n += 1 + sovCrypto(uint64(m.Type)) if m.Data != nil { l = len(m.Data) n += 1 + l + sovCrypto(uint64(l)) } return n } func (m *PrivateKey) Size() (n int) { if m == nil { return 0 } var l int _ = l n += 1 + sovCrypto(uint64(m.Type)) if m.Data != nil { l = len(m.Data) n += 1 + l + sovCrypto(uint64(l)) } return n } func sovCrypto(x uint64) (n int) { for { n++ x >>= 7 if x == 0 { break } } return n } func sozCrypto(x uint64) (n int) { return sovCrypto(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *PublicKey) Unmarshal(dAtA []byte) error { var hasFields [1]uint64 l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCrypto } 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: PublicKey: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PublicKey: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCrypto } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= KeyType(b&0x7F) << shift if b < 0x80 { break } } hasFields[0] |= uint64(0x00000001) 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 ErrIntOverflowCrypto } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCrypto } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthCrypto } if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) if m.Data == nil { m.Data = []byte{} } iNdEx = postIndex hasFields[0] |= uint64(0x00000002) default: iNdEx = preIndex skippy, err := skipCrypto(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCrypto } if (iNdEx + skippy) < 0 { return ErrInvalidLengthCrypto } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } iNdEx += skippy } } if hasFields[0]&uint64(0x00000001) == 0 { return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Type") } if hasFields[0]&uint64(0x00000002) == 0 { return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Data") } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *PrivateKey) Unmarshal(dAtA []byte) error { var hasFields [1]uint64 l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCrypto } 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: PrivateKey: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PrivateKey: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowCrypto } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Type |= KeyType(b&0x7F) << shift if b < 0x80 { break } } hasFields[0] |= uint64(0x00000001) 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 ErrIntOverflowCrypto } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthCrypto } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthCrypto } if postIndex > l { return io.ErrUnexpectedEOF } m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) if m.Data == nil { m.Data = []byte{} } iNdEx = postIndex hasFields[0] |= uint64(0x00000002) default: iNdEx = preIndex skippy, err := skipCrypto(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthCrypto } if (iNdEx + skippy) < 0 { return ErrInvalidLengthCrypto } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } iNdEx += skippy } } if hasFields[0]&uint64(0x00000001) == 0 { return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Type") } if hasFields[0]&uint64(0x00000002) == 0 { return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Data") } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipCrypto(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCrypto } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCrypto } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } return iNdEx, nil case 1: iNdEx += 8 return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCrypto } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthCrypto } iNdEx += length if iNdEx < 0 { return 0, ErrInvalidLengthCrypto } return iNdEx, nil case 3: for { var innerWire uint64 var start int = iNdEx for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowCrypto } 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 := skipCrypto(dAtA[start:]) if err != nil { return 0, err } iNdEx = start + next if iNdEx < 0 { return 0, ErrInvalidLengthCrypto } } return iNdEx, nil case 4: return iNdEx, nil case 5: iNdEx += 4 return iNdEx, nil default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } } panic("unreachable") } var ( ErrInvalidLengthCrypto = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowCrypto = fmt.Errorf("proto: integer overflow") )