keyspb.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: crypto/keyspb/keyspb.proto

package keyspb // import "github.com/google/trillian/crypto/keyspb"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package

// The supported elliptic curves.
type Specification_ECDSA_Curve int32

const (
	Specification_ECDSA_DEFAULT_CURVE Specification_ECDSA_Curve = 0
	Specification_ECDSA_P256          Specification_ECDSA_Curve = 1
	Specification_ECDSA_P384          Specification_ECDSA_Curve = 2
	Specification_ECDSA_P521          Specification_ECDSA_Curve = 3
)

var Specification_ECDSA_Curve_name = map[int32]string{
	0: "DEFAULT_CURVE",
	1: "P256",
	2: "P384",
	3: "P521",
}
var Specification_ECDSA_Curve_value = map[string]int32{
	"DEFAULT_CURVE": 0,
	"P256":          1,
	"P384":          2,
	"P521":          3,
}

func (x Specification_ECDSA_Curve) String() string {
	return proto.EnumName(Specification_ECDSA_Curve_name, int32(x))
}
func (Specification_ECDSA_Curve) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_keyspb_7c2a133bae564d06, []int{0, 0, 0}
}

// Specification for a private key.
type Specification struct {
	// The type of parameters provided determines the algorithm used for the key.
	//
	// Types that are valid to be assigned to Params:
	//	*Specification_EcdsaParams
	//	*Specification_RsaParams
	Params               isSpecification_Params `protobuf_oneof:"params"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *Specification) Reset()         { *m = Specification{} }
func (m *Specification) String() string { return proto.CompactTextString(m) }
func (*Specification) ProtoMessage()    {}
func (*Specification) Descriptor() ([]byte, []int) {
	return fileDescriptor_keyspb_7c2a133bae564d06, []int{0}
}
func (m *Specification) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Specification.Unmarshal(m, b)
}
func (m *Specification) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Specification.Marshal(b, m, deterministic)
}
func (dst *Specification) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Specification.Merge(dst, src)
}
func (m *Specification) XXX_Size() int {
	return xxx_messageInfo_Specification.Size(m)
}
func (m *Specification) XXX_DiscardUnknown() {
	xxx_messageInfo_Specification.DiscardUnknown(m)
}

var xxx_messageInfo_Specification proto.InternalMessageInfo

type isSpecification_Params interface {
	isSpecification_Params()
}

type Specification_EcdsaParams struct {
	EcdsaParams *Specification_ECDSA `protobuf:"bytes,1,opt,name=ecdsa_params,json=ecdsaParams,oneof"`
}
type Specification_RsaParams struct {
	RsaParams *Specification_RSA `protobuf:"bytes,2,opt,name=rsa_params,json=rsaParams,oneof"`
}

func (*Specification_EcdsaParams) isSpecification_Params() {}
func (*Specification_RsaParams) isSpecification_Params()   {}

func (m *Specification) GetParams() isSpecification_Params {
	if m != nil {
		return m.Params
	}
	return nil
}

func (m *Specification) GetEcdsaParams() *Specification_ECDSA {
	if x, ok := m.GetParams().(*Specification_EcdsaParams); ok {
		return x.EcdsaParams
	}
	return nil
}

func (m *Specification) GetRsaParams() *Specification_RSA {
	if x, ok := m.GetParams().(*Specification_RsaParams); ok {
		return x.RsaParams
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Specification) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Specification_OneofMarshaler, _Specification_OneofUnmarshaler, _Specification_OneofSizer, []interface{}{
		(*Specification_EcdsaParams)(nil),
		(*Specification_RsaParams)(nil),
	}
}

func _Specification_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Specification)
	// params
	switch x := m.Params.(type) {
	case *Specification_EcdsaParams:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.EcdsaParams); err != nil {
			return err
		}
	case *Specification_RsaParams:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RsaParams); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Specification.Params has unexpected type %T", x)
	}
	return nil
}

func _Specification_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Specification)
	switch tag {
	case 1: // params.ecdsa_params
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Specification_ECDSA)
		err := b.DecodeMessage(msg)
		m.Params = &Specification_EcdsaParams{msg}
		return true, err
	case 2: // params.rsa_params
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Specification_RSA)
		err := b.DecodeMessage(msg)
		m.Params = &Specification_RsaParams{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Specification_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Specification)
	// params
	switch x := m.Params.(type) {
	case *Specification_EcdsaParams:
		s := proto.Size(x.EcdsaParams)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Specification_RsaParams:
		s := proto.Size(x.RsaParams)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// / ECDSA defines parameters for an ECDSA key.
type Specification_ECDSA struct {
	// The elliptic curve to use.
	// Optional. If not set, the default curve will be used.
	Curve                Specification_ECDSA_Curve `protobuf:"varint,1,opt,name=curve,enum=keyspb.Specification_ECDSA_Curve" json:"curve,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *Specification_ECDSA) Reset()         { *m = Specification_ECDSA{} }
func (m *Specification_ECDSA) String() string { return proto.CompactTextString(m) }
func (*Specification_ECDSA) ProtoMessage()    {}
func (*Specification_ECDSA) Descriptor() ([]byte, []int) {
	return fileDescriptor_keyspb_7c2a133bae564d06, []int{0, 0}
}
func (m *Specification_ECDSA) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Specification_ECDSA.Unmarshal(m, b)
}
func (m *Specification_ECDSA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Specification_ECDSA.Marshal(b, m, deterministic)
}
func (dst *Specification_ECDSA) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Specification_ECDSA.Merge(dst, src)
}
func (m *Specification_ECDSA) XXX_Size() int {
	return xxx_messageInfo_Specification_ECDSA.Size(m)
}
func (m *Specification_ECDSA) XXX_DiscardUnknown() {
	xxx_messageInfo_Specification_ECDSA.DiscardUnknown(m)
}

var xxx_messageInfo_Specification_ECDSA proto.InternalMessageInfo

func (m *Specification_ECDSA) GetCurve() Specification_ECDSA_Curve {
	if m != nil {
		return m.Curve
	}
	return Specification_ECDSA_DEFAULT_CURVE
}

// RSA defines parameters for an RSA key.
type Specification_RSA struct {
	// Size of the keys in bits. Must be sufficiently large to allow two primes
	// to be generated.
	// Optional. If not set, the key size will be chosen by Trillian.
	Bits                 int32    `protobuf:"varint,1,opt,name=bits" json:"bits,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Specification_RSA) Reset()         { *m = Specification_RSA{} }
func (m *Specification_RSA) String() string { return proto.CompactTextString(m) }
func (*Specification_RSA) ProtoMessage()    {}
func (*Specification_RSA) Descriptor() ([]byte, []int) {
	return fileDescriptor_keyspb_7c2a133bae564d06, []int{0, 1}
}
func (m *Specification_RSA) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Specification_RSA.Unmarshal(m, b)
}
func (m *Specification_RSA) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Specification_RSA.Marshal(b, m, deterministic)
}
func (dst *Specification_RSA) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Specification_RSA.Merge(dst, src)
}
func (m *Specification_RSA) XXX_Size() int {
	return xxx_messageInfo_Specification_RSA.Size(m)
}
func (m *Specification_RSA) XXX_DiscardUnknown() {
	xxx_messageInfo_Specification_RSA.DiscardUnknown(m)
}

var xxx_messageInfo_Specification_RSA proto.InternalMessageInfo

func (m *Specification_RSA) GetBits() int32 {
	if m != nil {
		return m.Bits
	}
	return 0
}

// PEMKeyFile identifies a private key stored in a PEM-encoded file.
type PEMKeyFile struct {
	// File path of the private key.
	Path string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	// Password for decrypting the private key.
	// If empty, indicates that the private key is not encrypted.
	Password             string   `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PEMKeyFile) Reset()         { *m = PEMKeyFile{} }
func (m *PEMKeyFile) String() string { return proto.CompactTextString(m) }
func (*PEMKeyFile) ProtoMessage()    {}
func (*PEMKeyFile) Descriptor() ([]byte, []int) {
	return fileDescriptor_keyspb_7c2a133bae564d06, []int{1}
}
func (m *PEMKeyFile) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PEMKeyFile.Unmarshal(m, b)
}
func (m *PEMKeyFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PEMKeyFile.Marshal(b, m, deterministic)
}
func (dst *PEMKeyFile) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PEMKeyFile.Merge(dst, src)
}
func (m *PEMKeyFile) XXX_Size() int {
	return xxx_messageInfo_PEMKeyFile.Size(m)
}
func (m *PEMKeyFile) XXX_DiscardUnknown() {
	xxx_messageInfo_PEMKeyFile.DiscardUnknown(m)
}

var xxx_messageInfo_PEMKeyFile proto.InternalMessageInfo

func (m *PEMKeyFile) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *PEMKeyFile) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

// PrivateKey is a private key, used for generating signatures.
type PrivateKey struct {
	// The key in DER-encoded form.
	// The specific format (e.g. PKCS8) is not specified.
	Der                  []byte   `protobuf:"bytes,1,opt,name=der,proto3" json:"der,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_keyspb_7c2a133bae564d06, []int{2}
}
func (m *PrivateKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrivateKey.Unmarshal(m, b)
}
func (m *PrivateKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrivateKey.Marshal(b, m, deterministic)
}
func (dst *PrivateKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrivateKey.Merge(dst, src)
}
func (m *PrivateKey) XXX_Size() int {
	return xxx_messageInfo_PrivateKey.Size(m)
}
func (m *PrivateKey) XXX_DiscardUnknown() {
	xxx_messageInfo_PrivateKey.DiscardUnknown(m)
}

var xxx_messageInfo_PrivateKey proto.InternalMessageInfo

func (m *PrivateKey) GetDer() []byte {
	if m != nil {
		return m.Der
	}
	return nil
}

// PublicKey is a public key, used for verifying signatures.
type PublicKey struct {
	// The key in DER-encoded PKIX form.
	Der                  []byte   `protobuf:"bytes,1,opt,name=der,proto3" json:"der,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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_keyspb_7c2a133bae564d06, []int{3}
}
func (m *PublicKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublicKey.Unmarshal(m, b)
}
func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic)
}
func (dst *PublicKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublicKey.Merge(dst, src)
}
func (m *PublicKey) XXX_Size() int {
	return xxx_messageInfo_PublicKey.Size(m)
}
func (m *PublicKey) XXX_DiscardUnknown() {
	xxx_messageInfo_PublicKey.DiscardUnknown(m)
}

var xxx_messageInfo_PublicKey proto.InternalMessageInfo

func (m *PublicKey) GetDer() []byte {
	if m != nil {
		return m.Der
	}
	return nil
}

// PKCS11Config identifies a private key accessed using PKCS #11.
type PKCS11Config struct {
	// The label of the PKCS#11 token.
	TokenLabel string `protobuf:"bytes,1,opt,name=token_label,json=tokenLabel" json:"token_label,omitempty"`
	// The PIN for the specific token.
	Pin string `protobuf:"bytes,2,opt,name=pin" json:"pin,omitempty"`
	// The PEM public key assosciated with the private key to be used.
	PublicKey            string   `protobuf:"bytes,3,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PKCS11Config) Reset()         { *m = PKCS11Config{} }
func (m *PKCS11Config) String() string { return proto.CompactTextString(m) }
func (*PKCS11Config) ProtoMessage()    {}
func (*PKCS11Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_keyspb_7c2a133bae564d06, []int{4}
}
func (m *PKCS11Config) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PKCS11Config.Unmarshal(m, b)
}
func (m *PKCS11Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PKCS11Config.Marshal(b, m, deterministic)
}
func (dst *PKCS11Config) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PKCS11Config.Merge(dst, src)
}
func (m *PKCS11Config) XXX_Size() int {
	return xxx_messageInfo_PKCS11Config.Size(m)
}
func (m *PKCS11Config) XXX_DiscardUnknown() {
	xxx_messageInfo_PKCS11Config.DiscardUnknown(m)
}

var xxx_messageInfo_PKCS11Config proto.InternalMessageInfo

func (m *PKCS11Config) GetTokenLabel() string {
	if m != nil {
		return m.TokenLabel
	}
	return ""
}

func (m *PKCS11Config) GetPin() string {
	if m != nil {
		return m.Pin
	}
	return ""
}

func (m *PKCS11Config) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

func init() {
	proto.RegisterType((*Specification)(nil), "keyspb.Specification")
	proto.RegisterType((*Specification_ECDSA)(nil), "keyspb.Specification.ECDSA")
	proto.RegisterType((*Specification_RSA)(nil), "keyspb.Specification.RSA")
	proto.RegisterType((*PEMKeyFile)(nil), "keyspb.PEMKeyFile")
	proto.RegisterType((*PrivateKey)(nil), "keyspb.PrivateKey")
	proto.RegisterType((*PublicKey)(nil), "keyspb.PublicKey")
	proto.RegisterType((*PKCS11Config)(nil), "keyspb.PKCS11Config")
	proto.RegisterEnum("keyspb.Specification_ECDSA_Curve", Specification_ECDSA_Curve_name, Specification_ECDSA_Curve_value)
}

func init() { proto.RegisterFile("crypto/keyspb/keyspb.proto", fileDescriptor_keyspb_7c2a133bae564d06) }

var fileDescriptor_keyspb_7c2a133bae564d06 = []byte{
	// 403 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0x5f, 0x6f, 0xd3, 0x30,
	0x14, 0xc5, 0xd7, 0x76, 0xad, 0x9a, 0xdb, 0x0e, 0x05, 0x3f, 0x6d, 0x41, 0xe3, 0x4f, 0x9e, 0x26,
	0x1e, 0x12, 0x35, 0x63, 0x30, 0x21, 0x1e, 0xe8, 0xb2, 0x4c, 0x48, 0x1d, 0x52, 0xe4, 0x30, 0x1e,
	0x78, 0x09, 0x4e, 0xea, 0x65, 0x56, 0xb3, 0xd8, 0x72, 0xdc, 0xa1, 0xf0, 0xa1, 0xf8, 0x8c, 0x28,
	0x37, 0x19, 0x68, 0xd2, 0xb4, 0x27, 0x9f, 0x6b, 0x9f, 0x9f, 0xcf, 0xbd, 0xd2, 0x05, 0x27, 0xd7,
	0x8d, 0x32, 0xd2, 0xdf, 0xf0, 0xa6, 0x56, 0x59, 0x7f, 0x78, 0x4a, 0x4b, 0x23, 0xc9, 0xa4, 0xab,
	0xdc, 0x3f, 0x43, 0xd8, 0x4b, 0x14, 0xcf, 0xc5, 0xb5, 0xc8, 0x99, 0x11, 0xb2, 0x22, 0x9f, 0x61,
	0xce, 0xf3, 0x75, 0xcd, 0x52, 0xc5, 0x34, 0xbb, 0xad, 0xf7, 0x07, 0xaf, 0x07, 0x47, 0xb3, 0xe0,
	0x85, 0xd7, 0xe3, 0x0f, 0xcc, 0x5e, 0x14, 0x9e, 0x27, 0xcb, 0x2f, 0x3b, 0x74, 0x86, 0x48, 0x8c,
	0x04, 0xf9, 0x08, 0xa0, 0xff, 0xf3, 0x43, 0xe4, 0x0f, 0x1e, 0xe7, 0x29, 0xd2, 0x96, 0xbe, 0x67,
	0x9d, 0xdf, 0x30, 0xc6, 0x3f, 0xc9, 0x07, 0x18, 0xe7, 0x5b, 0x7d, 0xc7, 0x31, 0xff, 0x59, 0xf0,
	0xe6, 0x89, 0x7c, 0x2f, 0x6c, 0x8d, 0xb4, 0xf3, 0xbb, 0xa7, 0x30, 0xc6, 0x9a, 0x3c, 0x87, 0xbd,
	0xf3, 0xe8, 0x62, 0x79, 0x75, 0xf9, 0x2d, 0x0d, 0xaf, 0xe8, 0xf7, 0xc8, 0xde, 0x21, 0x53, 0xd8,
	0x8d, 0x83, 0x93, 0xf7, 0xf6, 0x00, 0xd5, 0xf1, 0xe9, 0x3b, 0x7b, 0x88, 0xea, 0x24, 0x58, 0xd8,
	0x23, 0xe7, 0x00, 0x46, 0x34, 0x59, 0x12, 0x02, 0xbb, 0x99, 0x30, 0xdd, 0xe0, 0x63, 0x8a, 0xfa,
	0x6c, 0x0a, 0x93, 0x6e, 0x1c, 0xf7, 0x13, 0x40, 0x1c, 0x7d, 0x5d, 0xf1, 0xe6, 0x42, 0x94, 0xbc,
	0xf5, 0x2a, 0x66, 0x6e, 0xd0, 0x6b, 0x51, 0xd4, 0xc4, 0x81, 0xa9, 0x62, 0x75, 0xfd, 0x4b, 0xea,
	0x35, 0x0e, 0x6f, 0xd1, 0x7f, 0xb5, 0xfb, 0x12, 0x20, 0xd6, 0xe2, 0x8e, 0x19, 0xbe, 0xe2, 0x0d,
	0xb1, 0x61, 0xb4, 0xe6, 0x1a, 0xe1, 0x39, 0x6d, 0xa5, 0x7b, 0x08, 0x56, 0xbc, 0xcd, 0x4a, 0x91,
	0x3f, 0xfe, 0xfc, 0x13, 0xe6, 0xf1, 0x2a, 0x4c, 0x16, 0x8b, 0x50, 0x56, 0xd7, 0xa2, 0x20, 0xaf,
	0x60, 0x66, 0xe4, 0x86, 0x57, 0x69, 0xc9, 0x32, 0x5e, 0xf6, 0x5d, 0x00, 0x5e, 0x5d, 0xb6, 0x37,
	0xed, 0x17, 0x4a, 0x54, 0x7d, 0x1b, 0xad, 0x24, 0x87, 0x00, 0x0a, 0x13, 0xd2, 0x0d, 0x6f, 0xf6,
	0x47, 0xf8, 0x60, 0xa9, 0xfb, 0xcc, 0xb3, 0xb7, 0x3f, 0x8e, 0x0a, 0x61, 0x6e, 0xb6, 0x99, 0x97,
	0xcb, 0x5b, 0xbf, 0x90, 0xb2, 0x28, 0xb9, 0x6f, 0xb4, 0x28, 0x4b, 0xc1, 0x2a, 0xff, 0xc1, 0x42,
	0x65, 0x13, 0x5c, 0xa5, 0xe3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x64, 0xdf, 0x9a, 0x68,
	0x02, 0x00, 0x00,
}