sgx_server

type A struct {
	Gb   *PublicKey `protobuf:"bytes,1,opt,name=gb,proto3" json:"gb,omitempty"`
	Spid []byte     `protobuf:"bytes,2,opt,name=spid,proto3" json:"spid,omitempty"`
	// quote_type and kdf_id are actually uint16_t,
	// but protobufs don't have such types, so keep as bytes
	QuoteType            []byte     `protobuf:"bytes,3,opt,name=quote_type,json=quoteType,proto3" json:"quote_type,omitempty"`
	KdfId                []byte     `protobuf:"bytes,4,opt,name=kdf_id,json=kdfId,proto3" json:"kdf_id,omitempty"`
	Signature            *Signature `protobuf:"bytes,5,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

type AttestationClient interface {
	StartAttestation(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Challenge, error)
	SendMsg1(ctx context.Context, in *Msg1, opts ...grpc.CallOption) (*Msg2, error)
	SendMsg3(ctx context.Context, in *Msg3, opts ...grpc.CallOption) (*Msg4, error)
}

type AttestationResult struct {
	EnclaveTrusted bool `protobuf:"varint,1,opt,name=enclave_trusted,json=enclaveTrusted,proto3" json:"enclave_trusted,omitempty"`
	PseTrusted     bool `protobuf:"varint,2,opt,name=pse_trusted,json=pseTrusted,proto3" json:"pse_trusted,omitempty"`
	// only sent on error
	Pib                  []byte   `protobuf:"bytes,3,opt,name=pib,proto3" json:"pib,omitempty"`
	Advisories           []string `protobuf:"bytes,4,rep,name=advisories,proto3" json:"advisories,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type AttestationServer interface {
	StartAttestation(context.Context, *Request) (*Challenge, error)
	SendMsg1(context.Context, *Msg1) (*Msg2, error)
	SendMsg3(context.Context, *Msg3) (*Msg4, error)
}

type Cache interface {
	// Store the session under id key.
	Set(key string, session Session)

	// Get fetches the session correspoding to the session id key,
	// and returns (point to the session, true) if the id exsits.
	// Otherwise, Get returns (nil, false).
	Get(key string) (Session, bool)

	// Delete the entry if the key exists.
	Delete(key string)
}

type Challenge struct {
	SessionId            string   `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Configuration struct {
	// If true, the session manager will start in release mode,
	// meaning it will connect to the production version of IAS.
	Release bool

	// The subscription key for IAS API. This can be found at
	// https://api.portal.trustedservices.intel.com
	Subscription string

	// The directory that contains all the MREnclave files
	// that are acceptable for this session manager.
	Mrenclaves string

	// The directory that contains all the MRSigner files
	// that are acceptable for this session manager.
	Mrsigners string

	// Hex encoded SPID for IAS API. This can be found at
	// https://api.portal.trustedservices.intel.com
	Spid string

	// The file that contains a PEM encoded long-term ECDSA P-256
	// (SECP256R1) private key for establishing the session. The
	// public key component of this key should be built-in to the
	// client enclave.
	LongTermKey string

	// If True, then it will either prompt the user to type in the
	// password, or use LongTermKeyPassword field to decrypt the
	// long term key.
	LongTermKeyEncrypted bool

	// If LongTermKeyEncrypted is true, and this password is set
	// to an empty string, the program will prompt user for
	// input. Otherwise, LongTermKeyPassword is used as the
	// password.
	LongTermKeyPassword string

	// AllowedAdvisories maps an error during quote verification
	// to which advisories we are allowed to ignore. Current valid
	// keys are: ["CONFIGURATION_NEEDED", "GROUP_OUT_OF_DATE"].
	// Be careful to not set this too liberally.
	AllowedAdvisories map[string][]string

	// ProdID is the enclave production ID set by the entity
	// generating the enclave. It must be a 16-bit int.
	ProdID int

	// ProdSVN is the enclave security version number set by the
	// entity generating the enclave. This is used as the minimum
	// acceptable security version number, meaning any enclave
	// with higher SVN is accepted. It must be a 16-bit int.
	ProdSVN int

	// The maximum number of concurrent sessions the session
	// manager will keep alive. If MaxSessions is -1, then we
	// allow unlimited number of sessions.
	MaxSessions int

	// A session times out after Timeout minutes.
	// If there is no activity for this session within the past
	// Timeout minutes, the manager will remove the session,
	// and the client will have to reauthenticate itself.
	// If Timeout is -1, then a session will never expire.
	// except if there are more than MaxSessions sessions,
	// then the oldest ones will be removed.
	Timeout int
}

type IAS interface {
	// GetRevocationList takes in the gid from Msg1 of the SGX
	// attestation, and talks to the IAS to fetch and return the
	// corresponding revocation list.
	GetRevocationList(gid []byte) ([]byte, error)

	// VerifyQuote takes in the SGX platform security property
	// descruotor and the attestation quote from Msg3 of the SGX
	// attestation, and talks to the IAS to request the quote
	// verification. The IAS can return many advisories
	// depending on the quote, which is included in the error
	// returned. Returns if the PSE can be trusted, the platform
	// information blob, a list of security advisories from Intel,
	// and any error during quote verification.
	VerifyQuoteAndPSE(quote, pse []byte) (bool, []byte, []string, error)
}

type M struct {
	Ga                   *PublicKey `protobuf:"bytes,1,opt,name=ga,proto3" json:"ga,omitempty"`
	PsSecurityProp       []byte     `protobuf:"bytes,2,opt,name=ps_security_prop,json=psSecurityProp,proto3" json:"ps_security_prop,omitempty"`
	Quote                []byte     `protobuf:"bytes,3,opt,name=quote,proto3" json:"quote,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

type Msg0 struct {
	Exgid                uint32   `protobuf:"varint,1,opt,name=exgid,proto3" json:"exgid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Msg1 struct {
	Msg0                 *Msg0      `protobuf:"bytes,1,opt,name=msg0,proto3" json:"msg0,omitempty"`
	Ga                   *PublicKey `protobuf:"bytes,2,opt,name=ga,proto3" json:"ga,omitempty"`
	Gid                  []byte     `protobuf:"bytes,3,opt,name=gid,proto3" json:"gid,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

type Msg2 struct {
	A                    *A       `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	CmacA                []byte   `protobuf:"bytes,2,opt,name=cmac_a,json=cmacA,proto3" json:"cmac_a,omitempty"`
	SigRlSize            uint32   `protobuf:"varint,3,opt,name=sig_rl_size,json=sigRlSize,proto3" json:"sig_rl_size,omitempty"`
	SigRl                []byte   `protobuf:"bytes,4,opt,name=sig_rl,json=sigRl,proto3" json:"sig_rl,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Msg3 struct {
	CmacM                []byte   `protobuf:"bytes,1,opt,name=cmac_m,json=cmacM,proto3" json:"cmac_m,omitempty"`
	M                    *M       `protobuf:"bytes,2,opt,name=m,proto3" json:"m,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Msg4 struct {
	Result               *AttestationResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	Secret               []byte             `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
	Cmac                 []byte             `protobuf:"bytes,3,opt,name=cmac,proto3" json:"cmac,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

type PublicKey struct {
	X                    []byte   `protobuf:"bytes,1,opt,name=x,proto3" json:"x,omitempty"`
	Y                    []byte   `protobuf:"bytes,2,opt,name=y,proto3" json:"y,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Session interface {
	// Id returns the id associated with this session.
	// Usually hex encoded 16 byte random value, if created using
	// the default SessionManager provided in this module.
	Id() string

	// ProcessMsg1 processes the SGX message 1 (which actually
	// contains SGX message 0 as well), and updates the internal
	// states of the session.
	ProcessMsg1(msg1 *Msg1) error

	// CreateMsg2 returns the message 2 after processing
	// message 1.
	CreateMsg2() (*Msg2, error)

	// ProcessMsg3 receives the SGX message 3 (which contains
	// things like the enclave quote), and verifies the validity
	// of the message with the Intel Attestation Service.
	ProcessMsg3(msg3 *Msg3) error

	// CreateMsg4 returns the last message in SGX attestation.
	CreateMsg4() (*Msg4, error)

	// Authenticated returns if the session has been
	// authenticated.
	Authenticated() bool

	// Seal uses authenticated encryption to encrypt msg for the
	// SGX client. It uses AES GCM to encrypt the message with
	// a random nonce, and it prepends the nonce the resulting
	// ciphertext. The key used is SK derived during the
	// attestation process. This function MUST be called AFTER
	// ProcessMsg3 returns no error.
	Seal(msg []byte) ([]byte, error)

	// Open decrypts and verifies the integrity of a ciphertext
	// generated using Seal. In practice, the ciphertext will
	// be generated by the client which implements the same
	// Seal and Open protocol.
	Open(ciphertext []byte) ([]byte, error)

	// MAC generates a message authentication code using MK
	// derived during the attestation process. It uses CMAC
	// based on AES to genearate the MAC, which is the standard
	// for SGX.
	MAC(msg []byte) []byte

	// Expires returns an error if the sesion is expired already.
	Expired() error
}

type SessionManager interface {
	// GetSession returns (Session, true) if there exists a
	// session that matches id. Otherwise, it returns
	// (nil, false).
	GetSession(id string) (Session, bool)

	// NewSession creates a new session. This generates a new
	// unique session id for the session, and returns the id
	// and a random challenge.
	NewSession(in *Request) (*Challenge, error)

	// Msg1ToMsg3 processes SGX message 1 and generates SGX
	// message 2 for the session matching id.
	Msg1ToMsg2(id string, msg1 *Msg1) (*Msg2, error)

	// Msg3ToMsg4 processes SGX message 3 and generates SGX
	// message 4 for the session matching id.
	Msg3ToMsg4(id string, msg3 *Msg3) (*Msg4, error)
}

type Signature struct {
	R                    []byte   `protobuf:"bytes,1,opt,name=r,proto3" json:"r,omitempty"`
	S                    []byte   `protobuf:"bytes,2,opt,name=s,proto3" json:"s,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type UnimplementedAttestationServer struct {
}