github.com/jlmucb/cloudproxy@v0.0.0-20170830161738-b5aa0b619bc4/go/tao/attestation.pb.go

// Code generated by protoc-gen-go.
// source: attestation.proto
// DO NOT EDIT!

/*
Package tao is a generated protocol buffer package.

It is generated from these files:
	attestation.proto

It has these top-level messages:
	Attestation
*/
package tao

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

// An Attestation is a key, a signature, and a statement, and it conveys:
//   signer says statement
// i.e.
//   signer says (issuer from time until exp says message)
// A valid Attestation encodes a public key, and it carries a signature that
// anyone can verify to (eventually) conclude:
//   issuer from time' until exp' says message
// Note: Because of time restrictions within attached delegations, restrictions
// time' and exp' here do not necessarily exactly match the restrictions time
// and exp on the original serialized statement.
// If the modified time restriction is met, then we can derive the same
// conclusion as we would for the included statement, e.g.:
//   delegate speaksfor issuer               (for a delegation statement)
// or:
//   issuer says Pred(arg_1, ..., arg_n)     (for a predicate statement)
// That is to say, a valid Attestation that meets its time restriction conveys
// exactly the same meaning as conveyed by the included statement.
//
// There are two categories of valid Attestations:
//
// (1) In cases where issuer is a subprincipal of (or identical to) signer, no
// delegation will be present. In these cases, signer speaksfor issuer, so from
// the attestation:
//   signer says (issuer says ...)
// we can derive:
//   issuer says (issuer says ...)
// and further:
//   issuer says ...
//
// Example of a category (1) attestation:
//   Attestation = {
//     statement = "H_aik.PCRs(...) says (H_os speaksfor H_aik.PCRs(...))"
//     signer = K_aik
//     signature = ...
//     delegation = nil
//   }
// Here, an OS has published a delegation statement establishing that key K_os
// speaks for the OS, and this statement was signed by the TPM K_aik on behalf
// of the OS. Note that the OS is a subprincipal of the TPM, so the TPM speaks
// for the OS.
//
// (2) In all other cases, a delegation will be present that, if valid, conveys:
//   issuer0 from time0 until exp0 says (delegate speaksfor issuer0)
// where issuer is a subprincipal of (or identical to) issuer0 and delegate is a
// subprincipal of (or identical to) signer. Such a valid
// delegation can be combined with:
//   signer says (issuer from time until exp says ...)
// to derive:
//   issuer0 from time0 until exp0 says (issuer from time until exp says ...)
// And because issuer0 speaks for issuer, we can further derive:
//   issuer from time' until exp' says ...
// where time' = max(time, time0) and exp = min(exp, exp0).
//
// Example of a category (2) attestation:
//   Attestation = {
//     statement = "H_aik.PCRs(...).Prog(...) says H_app speaksfor H_aik.PCRs(...).Prog(...)"
//     signer = K_os
//     signature = ...
//     delegation = {
//       statement = H_aik.PCRs(...) says H_os speaksfor H_aik.PCRs(...)
//       signer = K_aik
//       signature = ...
//       delegation = nil
//     }
//   }
// Here, the OS identified by H_aik.PCRs(...) has signed, using a
// seemingly unrelated key K_os, a statement on behalf of one of its hosted
// programs, H_aik.PCRs(...).Prog(...). The embedded delegation statement,
// signed by K_aik, binds that seemingly unrelated key K_os to the OS's actual
// identity, H_aik.PCRs(...).
//
// Verifying an attestation signature requires knowing how the signature was
// produced. We currently define two signature schemes:
//
// TODO(kwalsh): add tpm2 signature scheme here and in attestation.go
//
// (a) Some signatures are produced by the TPM, so here we are bound by the
// mechanisms implemented by the TPM. In this case, we encode the signer name as
//   tpm("..H..") where "..H.." is the hashed, serialized public half
// of the TPM's RSA key K. The TPM only ever signs things on behalf of its
// hosted programs, so the issuer used in the serialized statement will always
// have the form:
//   tpm("..H..").PCRs("..i..", "..h..")...
// where "..i.." is a sorted, comma-separated list of PCR numbers, and "..h.."
// is the corresponding, comma-separated list of hex-encoded PCR values. The
// signature is computed roughly as:
//   sig = rsa_sign(K, H( H(message) | pcrbuf(i, h) ))
// Here, we first hash the statement in a tpm-specific way, then sign the
// hash with RSA key K. To obtain the statement hash, first hash the serialized
// statement, including issuer, time, expiration and other information. This
// intermediate hash is then re-hashed with a tpm-specific encoding of the PCR
// numbers ("..i..") and values ("..h..") extracted from issuer.
//
// Note: The PCR values are effectively hashed twice, once as part of statement,
// and separately as part of the pcrbuf datastructure. See optimization note
// below.
//
// (b) Other signatures are produced in software, and here we have flexibility
// to use simpler signature schemes. In this case, we encode the signer name as
//   key("..H..") where "..H.." is the hashed, serialized public half
// of a DSA key K. The issuer used in the serialized statement can have any
// form. The signature is roughly:
//   sig = dsa_sign(K, H(context|message))
// Here, we simply hash the serialized statement, along with some context, then
// sign it with the private DSA key K. The context used for attestations is
// defined in Tao.AttestationSigningContext.
//
// Together, this results in four possible combinations:
//
// (1a) No delegation, Tao signature.
//      Historical note: This is the old "ROOT" attestation type.
//      Typically exaample: signer is the "domain policy" key.
//      The signer is always key("..H..").
// (1b) No delegation, TPM signature.
//      This is produced by tpm_tao.
//      The signer is always tpm("..H..") and the statement issuer is
//      always a tpm("..H..").PCRs("..i..", "..h..")... principal.
// (2a) Delegation, Tao signature.
//      Historical note: This is the old "INTERMEDIATE" attestation type.
//      The signer is always key("..H..").
//      The delegation is the head of a chain that eventually terminates in a
//      type (1a) or (1b) attestation.
// (2b) Delegation, TPM signature.
//      Historical note: This is the old "TPM_1_2_QUOTE" attestation type.
//      This combination is no longer used. If it were, the signer would be
//      tpm("..H..") and the statement issuer would be something like
//      H_policy.TrustedPlatform. The delegation would be the head of a chain
//      that eventually terminates in a type (1a) or (1b) attestation. The
//      issuer at the head of the chain would always be a
//      tpm("..H..").PCRs("..i..", "..h..") principal.
type Attestation struct {
	// A serialized statement. This is serialized to avoid canonicalization issues
	// when signing and verifying signatures. In Go, this is obtained using
	// cloudproxy/tao/auth.Marshal().
	SerializedStatement []byte `protobuf:"bytes,1,req,name=serialized_statement,json=serializedStatement" json:"serialized_statement,omitempty"`
	// The signature type, either "tpm", "tpm2", or "key". This must match
	// the type of the signer key, and it is also used to determine how to verify
	// signatures.
	SignerType *string `protobuf:"bytes,2,req,name=signer_type,json=signerType" json:"signer_type,omitempty"`
	// The signer's public key, i.e. the un-hashed key material used within
	// cloudproxy/tao/auth.New*Prin().
	SignerKey []byte `protobuf:"bytes,3,req,name=signer_key,json=signerKey" json:"signer_key,omitempty"`
	// Signature over the serialized statement using TPM or Tao signing.
	Signature []byte `protobuf:"bytes,4,req,name=signature" json:"signature,omitempty"`
	// A delegation attestation that conveys (eventually) that signer speaks for
	// the issuer in the serialized statement. If this is empty, then it must be
	// self evident that signer speaks for the issuer in the serialized statement.
	// This can be added, removed, or replaced without changing the attestation
	// signature, but verification may fail if a required delegation is missing.
	SerializedDelegation []byte `protobuf:"bytes,5,opt,name=serialized_delegation,json=serializedDelegation" json:"serialized_delegation,omitempty"`
	// An optional set of further attestations that may pertain, in some way, to
	// the the issuer or signer of this attestation. These can be added or removed
	// without changing the attestation signature. This allows attestations to be
	// piggy-backed, e.g. when an authorization guard requires multiple
	// attestations to check a policy.
	SerializedEndorsements [][]byte `protobuf:"bytes,6,rep,name=serialized_endorsements,json=serializedEndorsements" json:"serialized_endorsements,omitempty"`
	// This is the quote structure actually signed by the tpm 2.0.
	// TODO(kwalsh) remove this -- as for tpm1.2, the quote structure should be
	// recoverable from the principal names in the serialized statement.
	Tpm2QuoteStructure []byte `protobuf:"bytes,7,opt,name=tpm2_quote_structure,json=tpm2QuoteStructure" json:"tpm2_quote_structure,omitempty"`
	// This is a DER encoded X509 certificate certifying the key signing the
	// attestation. This is included in attestations signed by a root Tao
	// i.e. a TPM (1.2 or 2.0) Tao or a soft Tao, and forms the root of the
	// attestation chain. This certificate is signed by the policy key.
	RootEndorsement  []byte `protobuf:"bytes,8,opt,name=root_endorsement,json=rootEndorsement" json:"root_endorsement,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *Attestation) Reset()                    { *m = Attestation{} }
func (m *Attestation) String() string            { return proto.CompactTextString(m) }
func (*Attestation) ProtoMessage()               {}
func (*Attestation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *Attestation) GetSerializedStatement() []byte {
	if m != nil {
		return m.SerializedStatement
	}
	return nil
}

func (m *Attestation) GetSignerType() string {
	if m != nil && m.SignerType != nil {
		return *m.SignerType
	}
	return ""
}

func (m *Attestation) GetSignerKey() []byte {
	if m != nil {
		return m.SignerKey
	}
	return nil
}

func (m *Attestation) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *Attestation) GetSerializedDelegation() []byte {
	if m != nil {
		return m.SerializedDelegation
	}
	return nil
}

func (m *Attestation) GetSerializedEndorsements() [][]byte {
	if m != nil {
		return m.SerializedEndorsements
	}
	return nil
}

func (m *Attestation) GetTpm2QuoteStructure() []byte {
	if m != nil {
		return m.Tpm2QuoteStructure
	}
	return nil
}

func (m *Attestation) GetRootEndorsement() []byte {
	if m != nil {
		return m.RootEndorsement
	}
	return nil
}

func init() {
	proto.RegisterType((*Attestation)(nil), "tao.Attestation")
}

/*
func init() { proto.RegisterFile("attestation.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 246 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x4c, 0x8f, 0x3d, 0x4f, 0xc3, 0x40,
	0x0c, 0x86, 0xd5, 0x84, 0xaf, 0xba, 0x48, 0x80, 0x29, 0x70, 0x03, 0x88, 0x88, 0x09, 0x16, 0xc4,
	0xc7, 0xc0, 0x8c, 0x04, 0x13, 0x13, 0x2d, 0x7b, 0x74, 0x22, 0x56, 0x15, 0xd1, 0xc6, 0xe1, 0xce,
	0x19, 0xc2, 0x3f, 0xe6, 0x5f, 0x70, 0x71, 0x49, 0x73, 0xe3, 0x3d, 0xcf, 0x6b, 0xfb, 0x3d, 0x38,
	0xb2, 0x22, 0xe4, 0xc5, 0x4a, 0xc9, 0xd5, 0x6d, 0xed, 0x58, 0x18, 0x53, 0xb1, 0x7c, 0xf5, 0x9b,
	0xc0, 0xe4, 0x79, 0x50, 0x78, 0x0f, 0x53, 0x4f, 0xae, 0xb4, 0xcb, 0xf2, 0x87, 0x8a, 0xbc, 0xa3,
	0xb4, 0xa2, 0x4a, 0xcc, 0x28, 0x4b, 0xae, 0xf7, 0x67, 0xc7, 0x83, 0x9b, 0xf7, 0x0a, 0x2f, 0x61,
	0xe2, 0xcb, 0x45, 0x45, 0x2e, 0x97, 0xb6, 0x26, 0x93, 0x84, 0xe4, 0x78, 0x06, 0x6b, 0xf4, 0x11,
	0x08, 0x5e, 0xc0, 0xff, 0x2b, 0xff, 0xa2, 0xd6, 0xa4, 0xba, 0x69, 0xbc, 0x26, 0x6f, 0xd4, 0xe2,
	0x39, 0xe8, 0xc3, 0x4a, 0xe3, 0xc8, 0x6c, 0x0d, 0x56, 0x01, 0x3e, 0xc2, 0x49, 0x54, 0xa8, 0xa0,
	0x25, 0x2d, 0xb4, 0xa9, 0xd9, 0xce, 0x46, 0x21, 0x19, 0xb5, 0x7d, 0xd9, 0x38, 0x7c, 0x82, 0xb3,
	0x68, 0x88, 0xaa, 0x82, 0x9d, 0xd7, 0xb2, 0xde, 0xec, 0x64, 0x69, 0x18, 0x3b, 0x1d, 0xf4, 0x6b,
	0x64, 0xf1, 0x0e, 0xa6, 0x52, 0xaf, 0x1e, 0xf2, 0xef, 0x86, 0x85, 0xc2, 0xf7, 0x5d, 0xf3, 0xa9,
	0xb5, 0x76, 0xf5, 0x18, 0x76, 0xee, 0xbd, 0x53, 0xf3, 0xde, 0xe0, 0x0d, 0x1c, 0x3a, 0x66, 0x89,
	0x8f, 0x98, 0x3d, 0x4d, 0x1f, 0x74, 0x3c, 0xda, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x12, 0x38,
	0x5b, 0xa8, 0x84, 0x01, 0x00, 0x00,
}
*/