publickey

package
v2.1.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 7, 2024 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Overview

Package publickey facilitiates communication with Intel® AMT devices to access and configure Public Key Certificates and Public Key Management Service classes for AMT

Certificate: This class represents a X.509 Certificate in the Intel® AMT CertStore. Instances of this class can be created using the AMT_PublicKeyManagementService.AddCertificate and AMT_PublicKeyManagementService.AddTrustedRootCertificate methods. A certificate cannot be deleted while it is being used by any service (TLS/EAC).

Management Service: This service contains the information necessary to represent and manage the functionality provided by the Intel® AMT CertStore.

Index

Constants

View Source 
const (
	AMT_PublicKeyCertificate       string = "AMT_PublicKeyCertificate"
	AMT_PublicKeyManagementService string = "AMT_PublicKeyManagementService"
	GeneratePKCS10RequestEx        string = "GeneratePKCS10RequestEx"
	AddTrustedRootCertificate      string = "AddTrustedRootCertificate"
	AddCertificate                 string = "AddCertificate"
	GenerateKeyPair                string = "GenerateKeyPair"
	AddKey                         string = "AddKey"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AddCertificate_INPUT 

type AddCertificate_INPUT struct {
	XMLName         xml.Name `xml:"h:AddCertificate_INPUT"`
	H               string   `xml:"xmlns:h,attr"`
	CertificateBlob string   `xml:"h:CertificateBlob"` // The use of ECC 192/224 is blocked starting from Intel® CSME 18.0.
}

INPUTS Request Types

type AddCertificate_OUTPUT 

type AddCertificate_OUTPUT struct {
	XMLName            xml.Name                   `xml:"AddCertificate_OUTPUT"`
	CreatedCertificate CreatedCertificateResponse `xml:"CreatedCertificate,omitempty"`
	ReturnValue        int                        `xml:"ReturnValue,omitempty"`
}

OUTPUTS Response Types

type AddKey_INPUT 

type AddKey_INPUT struct {
	XMLName xml.Name `xml:"h:AddKey_INPUT"`
	H       string   `xml:"xmlns:h,attr"`
	KeyBlob string   `xml:"h:KeyBlob"` // The use of ECC 192/224 is blocked starting from Intel® CSME 18.0.
}

INPUTS Request Types

type AddKey_OUTPUT 

type AddKey_OUTPUT struct {
	XMLName     xml.Name           `xml:"AddKey_OUTPUT,omitempty"`
	CreatedKey  CreatedKeyResponse `xml:"CreatedKey,omitempty"`
	ReturnValue int                `xml:"ReturnValue,omitempty"`
}

OUTPUTS Response Types

type AddTrustedRootCertificate_INPUT 

type AddTrustedRootCertificate_INPUT struct {
	XMLName         xml.Name `xml:"h:AddTrustedRootCertificate_INPUT"`
	H               string   `xml:"xmlns:h,attr"`
	CertificateBlob string   `xml:"h:CertificateBlob"` // The use of ECC 192/224 is blocked starting from Intel® CSME 18.0.
}

INPUTS Request Types

type AddTrustedRootCertificate_OUTPUT 

type AddTrustedRootCertificate_OUTPUT struct {
	XMLName            xml.Name                   `xml:"AddTrustedRootCertificate_OUTPUT"`
	CreatedCertificate CreatedCertificateResponse `xml:"CreatedCertificate,omitempty"`
	ReturnValue        int                        `xml:"ReturnValue,omitempty"`
}

OUTPUTS Response Types

type Body 

type Body struct {
	XMLName                               xml.Name                         `xml:"Body"`
	AddTrustedRootCertificate_OUTPUT      AddTrustedRootCertificate_OUTPUT `xml:"AddTrustedRootCertificate_OUTPUT,omitempty"`
	AddCertificate_OUTPUT                 AddCertificate_OUTPUT            `xml:"AddCertificate_OUTPUT,omitempty"`
	AddKey_OUTPUT                         AddKey_OUTPUT                    `xml:"AddKey_OUTPUT,omitempty"`
	GenerateKeyPair_OUTPUT                GenerateKeyPair_OUTPUT           `xml:"GenerateKeyPair_OUTPUT,omitempty"`
	KeyManagementGetResponse              KeyManagementResponse            `xml:"AMT_PublicKeyManagementService,omitempty"`
	PublicKeyCertificateGetAndPutResponse PublicKeyCertificateResponse     `xml:"AMT_PublicKeyCertificate,omitempty"`
	EnumerateResponse                     common.EnumerateResponse
	PullResponse                          PullResponse
}

OUTPUTS Response Types

type Certificate 

type Certificate struct {
	// contains filtered or unexported fields
}

func NewPublicKeyCertificateWithClient 

func NewPublicKeyCertificateWithClient(wsmanMessageCreator *message.WSManMessageCreator, client client.WSMan) Certificate

NewPublicKeyCertificateWithClient instantiates a new Certificate

func (Certificate) Delete 

func (certificate Certificate) Delete(instanceID string) (response Response, err error)

Delete removes a the specified instance

func (Certificate) Enumerate 

func (certificate Certificate) Enumerate() (response Response, err error)

Enumerate returns an enumeration context which is used in a subsequent Pull call

func (Certificate) Get 

func (certificate Certificate) Get(handle int) (response Response, err error)

Get retrieves the representation of the instance

func (Certificate) Pull 

func (certificate Certificate) Pull(enumerationContext string) (response Response, err error)

Pull returns the instances of this class. An enumeration context provided by the Enumerate call is used as input.

func (Certificate) Put 

func (certificate Certificate) Put(handle int, cert string) (response Response, err error)

Put will change properties of the selected instance

type CreatedCertificateResponse 

type CreatedCertificateResponse struct {
	XMLName             xml.Name                    `xml:"CreatedCertificate,omitempty"`
	Address             string                      `xml:"Address,omitempty"`
	ReferenceParameters ReferenceParametersResponse `xml:"ReferenceParameters,omitempty"`
}

OUTPUTS Response Types

type CreatedKeyResponse 

type CreatedKeyResponse struct {
	XMLName             xml.Name                    `xml:"CreatedKey,omitempty"`
	Address             string                      `xml:"Address,omitempty"`
	ReferenceParameters ReferenceParametersResponse `xml:"ReferenceParameters,omitempty"`
}

OUTPUTS Response Types

type EnabledDefault 

type EnabledDefault int

An enumerated value indicating an administrator's default or startup configuration for the Enabled State of an element. By default, the element is "Enabled" (value=2).

ValueMap={2, 3, 5, 6, 7, 9, .., 32768..65535}

Values={Enabled, Disabled, Not Applicable, Enabled but Offline, No Default, Quiesce, DMTF Reserved, Vendor Reserved} 

const (
	EnabledDefaultEnabled           EnabledDefault = 2
	EnabledDefaultDisabled          EnabledDefault = 3
	EnabledDefaultNotApplicable     EnabledDefault = 5
	EnabledDefaultEnabledbutOffline EnabledDefault = 6
	EnabledDefaultNoDefault         EnabledDefault = 7
	EnabledDefaultQuiesce           EnabledDefault = 9
)

type EnabledState 

type EnabledState int

EnabledState is an integer enumeration that indicates the enabled and disabled states of an element. It can also indicate the transitions between these requested states. For example, shutting down (value=4) and starting (value=10) are transient states between enabled and disabled.

The following text briefly summarizes the various enabled and disabled states:

Enabled (2) indicates that the element is or could be executing commands, will process any queued commands, and queues new requests.

Disabled (3) indicates that the element will not execute commands and will drop any new requests.

Shutting Down (4) indicates that the element is in the process of going to a Disabled state.

Not Applicable (5) indicates the element does not support being enabled or disabled.

Enabled but Offline (6) indicates that the element might be completing commands, and will drop any new requests.

Test (7) indicates that the element is in a test state.

Deferred (8) indicates that the element might be completing commands, but will queue any new requests.

Quiesce (9) indicates that the element is enabled but in a restricted mode.

Starting (10) indicates that the element is in the process of going to an Enabled state. New requests are queued.

Value 6 ("Enabled but Offline") can be recieved also if the Audit Log is in locked state.

ValueMap={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11..32767, 32768..65535}

Values={Unknown, Other, Enabled, Disabled, Shutting Down, Not Applicable, Enabled but Offline, In Test, Deferred, Quiesce, Starting, DMTF Reserved, Vendor Reserved} 

const (
	EnabledStateUnknown EnabledState = iota
	EnabledStateOther
	EnabledStateEnabled
	EnabledStateDisabled
	EnabledStateShuttingDown
	EnabledStateNotApplicable
	EnabledStateEnabledbutOffline
	EnabledStateInTest
	EnabledStateDeferred
	EnabledStateQuiesce
	EnabledStateStarting
)

type GenerateKeyPair_INPUT 

type GenerateKeyPair_INPUT struct {
	XMLName      xml.Name     `xml:"h:GenerateKeyPair_INPUT"`
	H            string       `xml:"xmlns:h,attr"`
	KeyAlgorithm KeyAlgorithm `xml:"h:KeyAlgorithm"` // The algorithm of the generated key.
	KeyLength    KeyLength    `xml:"h:KeyLength"`    // The length of the generatd key in bits.
}

INPUTS Request Types

type GenerateKeyPair_OUTPUT 

type GenerateKeyPair_OUTPUT struct {
	XMLName     xml.Name        `xml:"GenerateKeyPair_OUTPUT,omitempty"`
	KeyPair     KeyPairResponse `xml:"KeyPair,omitempty"`
	ReturnValue int             `xml:"ReturnValue,omitempty"`
}

OUTPUTS Response Types

type KeyAlgorithm 

type KeyAlgorithm int

The algorithm of the generated key.

Required

ValueMap={0, ..}

Values={RSA, Reserved} 

const (
	RSA KeyAlgorithm = 0
)

type KeyLength 

type KeyLength int

The length of the generatd key in bits 

const (
	KeyLength2048 KeyLength = 2048
)

type KeyManagementResponse 

type KeyManagementResponse struct {
	XMLName                 xml.Name            `xml:"AMT_PublicKeyManagementService,omitempty"`
	CreationClassName       string              `xml:"CreationClassName,omitempty"`       // CreationClassName indicates the name of the class or the subclass that is used in the creation of an instance. When used with the other key properties of this class, this property allows all instances of this class and its subclasses to be uniquely identified.
	ElementName             string              `xml:"ElementName,omitempty"`             // A user-friendly name for the object. This property allows each instance to define a user-friendly name in addition to its key properties, identity data, and description information. Note that the Name property of ManagedSystemElement is also defined as a user-friendly name. But, it is often subclassed to be a Key. It is not reasonable that the same property can convey both identity and a user-friendly name, without inconsistencies. Where Name exists and is not a Key (such as for instances of LogicalDevice), the same information can be present in both the Name and ElementName properties. Note that if there is an associated instance of CIM_EnabledLogicalElementCapabilities, restrictions on this properties may exist as defined in ElementNameMask and MaxElementNameLen properties defined in that class.
	EnabledDefault          EnabledDefault      `xml:"EnabledDefault"`                    // An enumerated value indicating an administrator's default or startup configuration for the Enabled State of an element. By default, the element is "Enabled" (value=2).
	EnabledState            EnabledState        `xml:"EnabledState"`                      // EnabledState is an integer enumeration that indicates the enabled and disabled states of an element.
	Name                    string              `xml:"Name,omitempty"`                    // The Name property uniquely identifies the Service and provides an indication of the functionality that is managed. This functionality is described in more detail in the Description property of the object.
	OperationalStatus       []OperationalStatus `xml:"OperationalStatus,omitempty"`       // Indicates the current statuses of the element.
	RequestedState          RequestedState      `xml:"RequestedState"`                    // RequestedState is an integer enumeration that indicates the last requested or desired state for the element, irrespective of the mechanism through which it was requested.
	SystemCreationClassName string              `xml:"SystemCreationClassName,omitempty"` // The CreationClassName of the scoping System.
	SystemName              string              `xml:"SystemName,omitempty"`              // The Name of the scoping System.
}

OUTPUTS Response Types

type KeyPairResponse 

type KeyPairResponse struct {
	XMLName             xml.Name                    `xml:"KeyPair,omitempty"`
	Address             string                      `xml:"Address,omitempty"`
	ReferenceParameters ReferenceParametersResponse `xml:"ReferenceParameters,omitempty"`
}

OUTPUTS Response Types

type ManagementService 

type ManagementService struct {
	// contains filtered or unexported fields
}

func NewPublicKeyManagementServiceWithClient 

func NewPublicKeyManagementServiceWithClient(wsmanMessageCreator *message.WSManMessageCreator, client client.WSMan) ManagementService

NewPublicKeyManagementServiceWithClient instantiates a new ManagementService

func (ManagementService) AddCertificate 

func (managementService ManagementService) AddCertificate(certificateBlob string) (response Response, err error)

This function adds new certificate to the Intel® AMT CertStore. A certificate cannot be removed if it is referenced (for example, used by TLS, 802.1X or EAC).

func (ManagementService) AddKey 

func (managementService ManagementService) AddKey(keyBlob string) (response Response, err error)

This function adds new certificate key to the Intel® AMT CertStore. A key cannot be removed if its corresponding certificate is referenced (for example, used by TLS, 802.1X or EAC). After the method succeeds, a new instance of AMT_PublicPrivateKeyPair will be created. Possible return values are: PT_STATUS_SUCCESS(0), PT_STATUS_INTERNAL_ERROR(1), PT_STATUS_MAX_LIMIT_REACHED(23), PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED(38), PT_STATUS_DUPLICATE(2068), PT_STATUS_INVALID_KEY(2062).

func (ManagementService) AddTrustedRootCertificate 

func (managementService ManagementService) AddTrustedRootCertificate(certificateBlob string) (response Response, err error)

This function adds new root certificate to the Intel® AMT CertStore. A certificate cannot be removed if it is referenced (for example, used by TLS, 802.1X or EAC).

func (ManagementService) Delete 

func (managementService ManagementService) Delete(instanceID string) (response Response, err error)

Delete removes a the specified instance

func (ManagementService) Enumerate 

func (managementService ManagementService) Enumerate() (response Response, err error)

Enumerate returns an enumeration context which is used in a subsequent Pull call

func (ManagementService) GenerateKeyPair 

func (managementService ManagementService) GenerateKeyPair(keyAlgorithm KeyAlgorithm, keyLength KeyLength) (response Response, err error)

This API is used to generate a key in the FW

func (ManagementService) GeneratePKCS10RequestEx 

func (managementService ManagementService) GeneratePKCS10RequestEx(keyPair, nullSignedCertificateRequest string, signingAlgorithm SigningAlgorithm) (response Response, err error)

This API is used to create a PKCS#10 certificate signing request based on a key from the key store.

func (ManagementService) Get 

func (managementService ManagementService) Get() (response Response, err error)

Get retrieves the representation of the instance

func (ManagementService) Pull 

func (managementService ManagementService) Pull(enumerationContext string) (response Response, err error)

Pull returns the instances of this class. An enumeration context provided by the Enumerate call is used as input.

type OperationalStatus 

type OperationalStatus int

Indicates the current statuses of the element. Various operational statuses are defined. Many of the enumeration's values are self-explanatory. However, a few are not and are described here in more detail.

"Stressed" indicates that the element is functioning, but needs attention. Examples of "Stressed" states are overload, overheated, and so on.

"Predictive Failure" indicates that an element is functioning nominally but predicting a failure in the near future.

"In Service" describes an element being configured, maintained, cleaned, or otherwise administered.

"No Contact" indicates that the monitoring system has knowledge of this element, but has never been able to establish communications with it.

"Lost Communication" indicates that the ManagedSystem Element is known to exist and has been contacted successfully in the past, but is currently unreachable.

"Stopped" and "Aborted" are similar, although the former implies a clean and orderly stop, while the latter implies an abrupt stop where the state and configuration of the element might need to be updated.

"Dormant" indicates that the element is inactive or quiesced.

"Supporting Entity in Error" indicates that this element might be "OK" but that another element, on which it is dependent, is in error. An example is a network service or endpoint that cannot function due to lower-layer networking problems.

"Completed" indicates that the element has completed its operation. This value should be combined with either OK, Error, or Degraded so that a client can tell if the complete operation Completed with OK (passed), Completed with Error (failed), or Completed with Degraded (the operation finished, but it did not complete OK or did not report an error).

"Power Mode" indicates that the element has additional power model information contained in the Associated PowerManagementService association.

"Relocating" indicates the element is being relocated.

OperationalStatus replaces the Status property on ManagedSystemElement to provide a consistent approach to enumerations, to address implementation needs for an array property, and to provide a migration path from today's environment to the future. This change was not made earlier because it required the deprecated qualifier. Due to the widespread use of the existing Status property in management applications, it is strongly recommended that providers or instrumentation provide both the Status and OperationalStatus properties. Further, the first value of OperationalStatus should contain the primary status for the element. When instrumented, Status (because it is single-valued) should also provide the primary status of the element.

ValueMap={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, .., 0x8000..}

Values={Unknown, Other, OK, Degraded, Stressed, Predictive Failure, Error, Non-Recoverable Error, Starting, Stopping, Stopped, In Service, No Contact, Lost Communication, Aborted, Dormant, Supporting Entity in Error, Completed, Power Mode, Relocating, DMTF Reserved, Vendor Reserved}

type PKCS10Request 

type PKCS10Request struct {
	XMLName                      xml.Name         `xml:"h:GeneratePKCS10RequestEx_INPUT"`
	H                            string           `xml:"xmlns:h,attr"`
	KeyPair                      string           `xml:"h:KeyPair"`
	NullSignedCertificateRequest string           `xml:"h:NullSignedCertificateRequest"` // A binary representation of the null-signed PKCS#10 request.the request must include a valid PKCS10RequestInfo, that will be signed by AMT FW. The Public Key specified in the request must match the public key of the referenced KeyPair parameter.
	SigningAlgorithm             SigningAlgorithm `xml:"h:SigningAlgorithm"`             // The signing algorithm that the FW should use for signing the certificate request
}

INPUTS Request Types

type PublicKeyCertificateRequest 

type PublicKeyCertificateRequest struct {
	XMLName                xml.Name `xml:"h:AMT_PublicKeyCertificate"`
	H                      string   `xml:"xmlns:h,attr"`
	ElementName            string   `xml:"h:ElementName"`            // A user-friendly name for the object. This property allows each instance to define a user-friendly name in addition to its key properties, identity data, and description information. Note that the Name property of ManagedSystemElement is also defined as a user-friendly name. But, it is often subclassed to be a Key. It is not reasonable that the same property can convey both identity and a user-friendly name, without inconsistencies. Where Name exists and is not a Key (such as for instances of LogicalDevice), the same information can be present in both the Name and ElementName properties. Note that if there is an associated instance of CIM_EnabledLogicalElementCapabilities, restrictions on this properties may exist as defined in ElementNameMask and MaxElementNameLen properties defined in that class.
	InstanceID             string   `xml:"h:InstanceID"`             // Within the scope of the instantiating Namespace, InstanceID opaquely and uniquely identifies an instance of this class.
	X509Certificate        string   `xml:"h:X509Certificate"`        // uint8[4100] // The X.509 Certificate blob.
	TrustedRootCertificate bool     `xml:"h:TrustedRootCertificate"` // For root certificate [that were added by AMT_PublicKeyManagementService.AddTrustedRootCertificate()]this property will be true.
	Issuer                 string   `xml:"h:Issuer"`                 // The Issuer field of this certificate.
	Subject                string   `xml:"h:Subject"`                // The Subject field of this certificate.
	ReadOnlyCertificate    bool     `xml:"h:ReadOnlyCertificate"`    // Indicates whether the certificate is an Intel AMT self-signed certificate. If True, the certificate cannot be deleted.
}

INPUTS Request Types

type PublicKeyCertificateResponse 

type PublicKeyCertificateResponse struct {
	XMLName                xml.Name `xml:"AMT_PublicKeyCertificate,omitempty"`
	ElementName            string   `xml:"ElementName,omitempty"`     // A user-friendly name for the object . . .
	InstanceID             string   `xml:"InstanceID,omitempty"`      // Within the scope of the instantiating Namespace, InstanceID opaquely and uniquely identifies an instance of this class.
	X509Certificate        string   `xml:"X509Certificate,omitempty"` // uint8[4100] // The X.509 Certificate blob.
	TrustedRootCertificate bool     `xml:"TrustedRootCertficate"`     // For root certificate [that were added by AMT_PublicKeyManagementService.AddTrustedRootCertificate()]this property will be true. FYI Certificate is spelled wrong comimg from AMT.
	Issuer                 string   `xml:"Issuer,omitempty"`          // The Issuer field of this certificate.
	Subject                string   `xml:"Subject,omitempty"`         // The Subject field of this certificate.
	ReadOnlyCertificate    bool     `xml:"ReadOnlyCertificate"`       // Indicates whether the certificate is an Intel AMT self-signed certificate. If True, the certificate cannot be deleted.
}

OUTPUTS Response Types

type PullResponse 

type PullResponse struct {
	XMLName                   xml.Name                       `xml:"PullResponse,omitempty"`
	KeyManagementItems        []KeyManagementResponse        `xml:"Items>AMT_PublicKeyManagementService,omitempty"`
	PublicKeyCertificateItems []PublicKeyCertificateResponse `xml:"Items>AMT_PublicKeyCertificate,omitempty"`
}

OUTPUTS Response Types

type ReferenceParametersResponse 

type ReferenceParametersResponse struct {
	XMLName     xml.Name `xml:"ReferenceParameters,omitempty"`
	ResourceURI string
	SelectorSet SelectorSetResponse `xml:"SelectorSet,omitempty"`
}

OUTPUTS Response Types

type RequestedState 

type RequestedState int

RequestedState is an integer enumeration that indicates the last requested or desired state for the element, irrespective of the mechanism through which it was requested. The actual state of the element is represented by EnabledState. This property is provided to compare the last requested and current enabled or disabled states. Note that when EnabledState is set to 5 ("Not Applicable"), then this property has no meaning. Refer to the EnabledState property description for explanations of the values in the RequestedState enumeration.

"Unknown" (0) indicates the last requested state for the element is unknown.

Note that the value "No Change" (5) has been deprecated in lieu of indicating the last requested state is "Unknown" (0). If the last requested or desired state is unknown, RequestedState should have the value "Unknown" (0), but may have the value "No Change" (5).Offline (6) indicates that the element has been requested to transition to the Enabled but Offline EnabledState. It should be noted that there are two new values in RequestedState that build on the statuses of EnabledState. These are "Reboot" (10) and "Reset" (11). Reboot refers to doing a "Shut Down" and then moving to an "Enabled" state. Reset indicates that the element is first "Disabled" and then "Enabled". The distinction between requesting "Shut Down" and "Disabled" should also be noted. Shut Down requests an orderly transition to the Disabled state, and might involve removing power, to completely erase any existing state. The Disabled state requests an immediate disabling of the element, such that it will not execute or accept any commands or processing requests.

This property is set as the result of a method invocation (such as Start or StopService on CIM_Service), or can be overridden and defined as WRITEable in a subclass. The method approach is considered superior to a WRITEable property, because it allows an explicit invocation of the operation and the return of a result code.

If knowledge of the last RequestedState is not supported for the EnabledLogicalElement, the property shall be NULL or have the value 12 "Not Applicable".

ValueMap={0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, .., 32768..65535}

Values={Unknown, Enabled, Disabled, Shut Down, No Change, Offline, Test, Deferred, Quiesce, Reboot, Reset, Not Applicable, DMTF Reserved, Vendor Reserved} 

const (
	RequestedStateUnknown       RequestedState = 0
	RequestedStateEnabled       RequestedState = 2
	RequestedStateDisabled      RequestedState = 3
	RequestedStateShutDown      RequestedState = 4
	RequestedStateNoChange      RequestedState = 5
	RequestedStateOffline       RequestedState = 6
	RequestedStateTest          RequestedState = 7
	RequestedStateDeferred      RequestedState = 8
	RequestedStateQuiesce       RequestedState = 9
	RequestedStateReboot        RequestedState = 10
	RequestedStateReset         RequestedState = 11
	RequestedStateNotApplicable RequestedState = 12
)

type Response 

type Response struct {
	*client.Message
	XMLName xml.Name       `xml:"Envelope"`
	Header  message.Header `xml:"Header"`
	Body    Body           `xml:"Body"`
}

OUTPUTS Response Types

func (*Response) JSON 

func (r *Response) JSON() string

JSON marshals the type into JSON format

func (*Response) YAML 

func (r *Response) YAML() string

YAML marshals the type into YAML format

type SelectorResponse 

type SelectorResponse struct {
	XMLName xml.Name `xml:"Selector,omitempty"`
	Name    string   `xml:"Name,attr"`
	Text    string   `xml:",chardata"`
}

OUTPUTS Response Types

type SelectorSetResponse 

type SelectorSetResponse struct {
	XMLName   xml.Name           `xml:"SelectorSet,omitempty"`
	Selectors []SelectorResponse `xml:"Selector"`
}

OUTPUTS Response Types

type SigningAlgorithm 

type SigningAlgorithm int

The signing algorithm that the FW should use for signing the certificate request

Required

ValueMap={0, 1, ..}

Values={SHA1-RSA, SHA256-RSA, Reserved} Note: SHA1 is no longer available starting from Intel CSME 18.0. 

const (
	SHA1RSA SigningAlgorithm = iota
	SHA256RSA
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.