controller: handle attestation options across api

We can perform all attestation processing, handling how the sbom and
provenance arguments interact on the client, while applying defaults on
the server.

Additionally, this allows us to start pulling fields out of CommonOpts.

Signed-off-by: Justin Chadwell <me@jedevc.com>

bake/bake.go

@@ -1027,7 +1027,7 @@ func toBuildOpt(t *Target, inp *Input) (*build.Options, error) {
 	if err != nil {
 		return nil, err
 	}
-	bo.Attests = attests
+	bo.Attests = controllerapi.CreateAttestations(attests)
 
 	return bo, nil
 }

build/build.go

@@ -455,11 +455,11 @@ func toSolveOpt(ctx context.Context, node builder.Node, multiDriver bool, opt Op
 			return nil, nil, errors.Errorf("attestations are not supported by the current buildkitd")
 		}
 		for k, v := range attests {
-			so.FrontendAttrs[k] = v
+			so.FrontendAttrs["attest:"+k] = v
 		}
 	}
 
-	if _, ok := opt.Attests["attest:provenance"]; !ok && supportsAttestations {
+	if _, ok := opt.Attests["provenance"]; !ok && supportsAttestations {
 		const noAttestEnv = "BUILDX_NO_DEFAULT_ATTESTATIONS"
 		var noProv bool
 		if v, ok := os.LookupEnv(noAttestEnv); ok {

commands/bake.go

@@ -24,9 +24,11 @@ import (
 )
 
 type bakeOptions struct {
-	files     []string
+	files      []string
-	overrides []string
+	overrides  []string
-	printOnly bool
+	printOnly  bool
+	sbom       string
+	provenance string
 	controllerapi.CommonOptions
 }
 
@@ -76,11 +78,11 @@ func runBake(dockerCli command.Cli, targets []string, in bakeOptions, cFlags com
 	if cFlags.pull != nil {
 		overrides = append(overrides, fmt.Sprintf("*.pull=%t", *cFlags.pull))
 	}
-	if in.SBOM != "" {
+	if in.sbom != "" {
-		overrides = append(overrides, fmt.Sprintf("*.attest=%s", buildflags.CanonicalizeAttest("sbom", in.SBOM)))
+		overrides = append(overrides, fmt.Sprintf("*.attest=%s", buildflags.CanonicalizeAttest("sbom", in.sbom)))
 	}
-	if in.Provenance != "" {
+	if in.provenance != "" {
-		overrides = append(overrides, fmt.Sprintf("*.attest=%s", buildflags.CanonicalizeAttest("provenance", in.Provenance)))
+		overrides = append(overrides, fmt.Sprintf("*.attest=%s", buildflags.CanonicalizeAttest("provenance", in.provenance)))
 	}
 	contextPathHash, _ := os.Getwd()
 
@@ -220,8 +222,8 @@ func bakeCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 	flags.BoolVar(&options.ExportLoad, "load", false, `Shorthand for "--set=*.output=type=docker"`)
 	flags.BoolVar(&options.printOnly, "print", false, "Print the options without building")
 	flags.BoolVar(&options.ExportPush, "push", false, `Shorthand for "--set=*.output=type=registry"`)
-	flags.StringVar(&options.SBOM, "sbom", "", `Shorthand for "--set=*.attest=type=sbom"`)
+	flags.StringVar(&options.sbom, "sbom", "", `Shorthand for "--set=*.attest=type=sbom"`)
-	flags.StringVar(&options.Provenance, "provenance", "", `Shorthand for "--set=*.attest=type=provenance"`)
+	flags.StringVar(&options.provenance, "provenance", "", `Shorthand for "--set=*.attest=type=provenance"`)
 	flags.StringArrayVar(&options.overrides, "set", nil, `Override target value (e.g., "targetpattern.key=value")`)
 
 	commonBuildFlags(&cFlags, flags)

commands/build.go

@@ -42,7 +42,6 @@ import (
 
 type buildOptions struct {
 	allow          []string
-	attests        []string
 	buildArgs      []string
 	cacheFrom      []string
 	cacheTo        []string
@@ -67,6 +66,10 @@ type buildOptions struct {
 
 	invoke string
 
+	attests    []string
+	sbom       string
+	provenance string
+
 	progress string
 	quiet    bool
 
@@ -78,7 +81,6 @@ func (o *buildOptions) toControllerOptions() (controllerapi.BuildOptions, error)
 	var err error
 	opts := controllerapi.BuildOptions{
 		Allow:          o.allow,
-		Attests:        o.attests,
 		BuildArgs:      listToMap(o.buildArgs, true),
 		CgroupParent:   o.cgroupParent,
 		ContextPath:    o.contextPath,
@@ -96,6 +98,18 @@ func (o *buildOptions) toControllerOptions() (controllerapi.BuildOptions, error)
 		Opts:           &o.CommonOptions,
 	}
 
+	inAttests := append([]string{}, o.attests...)
+	if o.provenance != "" {
+		inAttests = append(inAttests, buildflags.CanonicalizeAttest("provenance", o.provenance))
+	}
+	if o.sbom != "" {
+		inAttests = append(inAttests, buildflags.CanonicalizeAttest("sbom", o.sbom))
+	}
+	opts.Attests, err = buildflags.ParseAttests(inAttests)
+	if err != nil {
+		return controllerapi.BuildOptions{}, err
+	}
+
 	opts.NamedContexts, err = buildflags.ParseContextNames(o.contexts)
 	if err != nil {
 		return controllerapi.BuildOptions{}, err
@@ -285,8 +299,8 @@ func buildCmd(dockerCli command.Cli, rootOpts *rootOptions) *cobra.Command {
 	flags.Var(options.ulimits, "ulimit", "Ulimit options")
 
 	flags.StringArrayVar(&options.attests, "attest", []string{}, `Attestation parameters (format: "type=sbom,generator=image")`)
-	flags.StringVar(&options.SBOM, "sbom", "", `Shorthand for "--attest=type=sbom"`)
+	flags.StringVar(&options.sbom, "sbom", "", `Shorthand for "--attest=type=sbom"`)
-	flags.StringVar(&options.Provenance, "provenance", "", `Shortand for "--attest=type=provenance"`)
+	flags.StringVar(&options.provenance, "provenance", "", `Shortand for "--attest=type=provenance"`)
 
 	if isExperimental() {
 		flags.StringVar(&options.invoke, "invoke", "", "Invoke a command after the build [experimental]")

controller/build/build.go

@@ -142,21 +142,11 @@ func RunBuild(ctx context.Context, dockerCli command.Cli, in controllerapi.Build
 	}
 	opts.Exports = outputs
 
-	inAttests := append([]string{}, in.Attests...)
-	if in.Opts.Provenance != "" {
-		inAttests = append(inAttests, buildflags.CanonicalizeAttest("provenance", in.Opts.Provenance))
-	}
-	if in.Opts.SBOM != "" {
-		inAttests = append(inAttests, buildflags.CanonicalizeAttest("sbom", in.Opts.SBOM))
-	}
-	opts.Attests, err = buildflags.ParseAttests(inAttests)
-	if err != nil {
-		return nil, nil, err
-	}
-
 	opts.CacheFrom = controllerapi.CreateCaches(in.CacheFrom)
 	opts.CacheTo = controllerapi.CreateCaches(in.CacheTo)
 
+	opts.Attests = controllerapi.CreateAttestations(in.Attests)
+
 	allow, err := buildflags.ParseEntitlements(in.Allow)
 	if err != nil {
 		return nil, nil, err

controller/pb/attest.go

@@ -0,0 +1,20 @@
+package pb
+
+func CreateAttestations(attests []*Attest) map[string]*string {
+	result := map[string]*string{}
+	for _, attest := range attests {
+		// ignore duplicates
+		if _, ok := result[attest.Type]; ok {
+			continue
+		}
+
+		if attest.Disabled {
+			result[attest.Type] = nil
+			continue
+		}
+
+		attrs := attest.Attrs
+		result[attest.Type] = &attrs
+	}
+	return result
+}

controller/pb/controller.pb.go

@@ -77,7 +77,7 @@ type BuildOptions struct {
 	PrintFunc            string               `protobuf:"bytes,3,opt,name=PrintFunc,proto3" json:"PrintFunc,omitempty"`
 	NamedContexts        map[string]string    `protobuf:"bytes,4,rep,name=NamedContexts,proto3" json:"NamedContexts,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	Allow                []string             `protobuf:"bytes,5,rep,name=Allow,proto3" json:"Allow,omitempty"`
-	Attests              []string             `protobuf:"bytes,6,rep,name=Attests,proto3" json:"Attests,omitempty"`
+	Attests              []*Attest            `protobuf:"bytes,6,rep,name=Attests,proto3" json:"Attests,omitempty"`
 	BuildArgs            map[string]string    `protobuf:"bytes,7,rep,name=BuildArgs,proto3" json:"BuildArgs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	CacheFrom            []*CacheOptionsEntry `protobuf:"bytes,8,rep,name=CacheFrom,proto3" json:"CacheFrom,omitempty"`
 	CacheTo              []*CacheOptionsEntry `protobuf:"bytes,9,rep,name=CacheTo,proto3" json:"CacheTo,omitempty"`
@@ -159,7 +159,7 @@ func (m *BuildOptions) GetAllow() []string {
 	return nil
 }
 
-func (m *BuildOptions) GetAttests() []string {
+func (m *BuildOptions) GetAttests() []*Attest {
 	if m != nil {
 		return m.Attests
 	}
@@ -385,6 +385,60 @@ func (m *CacheOptionsEntry) GetAttrs() map[string]string {
 	return nil
 }
 
+type Attest struct {
+	Type                 string   `protobuf:"bytes,1,opt,name=Type,proto3" json:"Type,omitempty"`
+	Disabled             bool     `protobuf:"varint,2,opt,name=Disabled,proto3" json:"Disabled,omitempty"`
+	Attrs                string   `protobuf:"bytes,3,opt,name=Attrs,proto3" json:"Attrs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Attest) Reset()         { *m = Attest{} }
+func (m *Attest) String() string { return proto.CompactTextString(m) }
+func (*Attest) ProtoMessage()    {}
+func (*Attest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ed7f10298fa1d90f, []int{4}
+}
+func (m *Attest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Attest.Unmarshal(m, b)
+}
+func (m *Attest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Attest.Marshal(b, m, deterministic)
+}
+func (m *Attest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Attest.Merge(m, src)
+}
+func (m *Attest) XXX_Size() int {
+	return xxx_messageInfo_Attest.Size(m)
+}
+func (m *Attest) XXX_DiscardUnknown() {
+	xxx_messageInfo_Attest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Attest proto.InternalMessageInfo
+
+func (m *Attest) GetType() string {
+	if m != nil {
+		return m.Type
+	}
+	return ""
+}
+
+func (m *Attest) GetDisabled() bool {
+	if m != nil {
+		return m.Disabled
+	}
+	return false
+}
+
+func (m *Attest) GetAttrs() string {
+	if m != nil {
+		return m.Attrs
+	}
+	return ""
+}
+
 type SSH struct {
 	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
 	Paths                []string `protobuf:"bytes,2,rep,name=Paths,proto3" json:"Paths,omitempty"`
@@ -397,7 +451,7 @@ func (m *SSH) Reset()         { *m = SSH{} }
 func (m *SSH) String() string { return proto.CompactTextString(m) }
 func (*SSH) ProtoMessage()    {}
 func (*SSH) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{4}
+	return fileDescriptor_ed7f10298fa1d90f, []int{5}
 }
 func (m *SSH) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SSH.Unmarshal(m, b)
@@ -444,7 +498,7 @@ func (m *Secret) Reset()         { *m = Secret{} }
 func (m *Secret) String() string { return proto.CompactTextString(m) }
 func (*Secret) ProtoMessage()    {}
 func (*Secret) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{5}
+	return fileDescriptor_ed7f10298fa1d90f, []int{6}
 }
 func (m *Secret) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Secret.Unmarshal(m, b)
@@ -496,7 +550,7 @@ func (m *UlimitOpt) Reset()         { *m = UlimitOpt{} }
 func (m *UlimitOpt) String() string { return proto.CompactTextString(m) }
 func (*UlimitOpt) ProtoMessage()    {}
 func (*UlimitOpt) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{6}
+	return fileDescriptor_ed7f10298fa1d90f, []int{7}
 }
 func (m *UlimitOpt) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UlimitOpt.Unmarshal(m, b)
@@ -536,7 +590,7 @@ func (m *Ulimit) Reset()         { *m = Ulimit{} }
 func (m *Ulimit) String() string { return proto.CompactTextString(m) }
 func (*Ulimit) ProtoMessage()    {}
 func (*Ulimit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{7}
+	return fileDescriptor_ed7f10298fa1d90f, []int{8}
 }
 func (m *Ulimit) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Ulimit.Unmarshal(m, b)
@@ -585,8 +639,6 @@ type CommonOptions struct {
 	Pull                 bool     `protobuf:"varint,4,opt,name=Pull,proto3" json:"Pull,omitempty"`
 	ExportPush           bool     `protobuf:"varint,5,opt,name=ExportPush,proto3" json:"ExportPush,omitempty"`
 	ExportLoad           bool     `protobuf:"varint,6,opt,name=ExportLoad,proto3" json:"ExportLoad,omitempty"`
-	SBOM                 string   `protobuf:"bytes,7,opt,name=SBOM,proto3" json:"SBOM,omitempty"`
-	Provenance           string   `protobuf:"bytes,8,opt,name=Provenance,proto3" json:"Provenance,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -596,7 +648,7 @@ func (m *CommonOptions) Reset()         { *m = CommonOptions{} }
 func (m *CommonOptions) String() string { return proto.CompactTextString(m) }
 func (*CommonOptions) ProtoMessage()    {}
 func (*CommonOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{8}
+	return fileDescriptor_ed7f10298fa1d90f, []int{9}
 }
 func (m *CommonOptions) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommonOptions.Unmarshal(m, b)
@@ -658,20 +710,6 @@ func (m *CommonOptions) GetExportLoad() bool {
 	return false
 }
 
-func (m *CommonOptions) GetSBOM() string {
-	if m != nil {
-		return m.SBOM
-	}
-	return ""
-}
-
-func (m *CommonOptions) GetProvenance() string {
-	if m != nil {
-		return m.Provenance
-	}
-	return ""
-}
-
 type BuildResponse struct {
 	ExporterResponse     map[string]string `protobuf:"bytes,1,rep,name=ExporterResponse,proto3" json:"ExporterResponse,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
@@ -683,7 +721,7 @@ func (m *BuildResponse) Reset()         { *m = BuildResponse{} }
 func (m *BuildResponse) String() string { return proto.CompactTextString(m) }
 func (*BuildResponse) ProtoMessage()    {}
 func (*BuildResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{9}
+	return fileDescriptor_ed7f10298fa1d90f, []int{10}
 }
 func (m *BuildResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BuildResponse.Unmarshal(m, b)
@@ -721,7 +759,7 @@ func (m *DisconnectRequest) Reset()         { *m = DisconnectRequest{} }
 func (m *DisconnectRequest) String() string { return proto.CompactTextString(m) }
 func (*DisconnectRequest) ProtoMessage()    {}
 func (*DisconnectRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{10}
+	return fileDescriptor_ed7f10298fa1d90f, []int{11}
 }
 func (m *DisconnectRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DisconnectRequest.Unmarshal(m, b)
@@ -758,7 +796,7 @@ func (m *DisconnectResponse) Reset()         { *m = DisconnectResponse{} }
 func (m *DisconnectResponse) String() string { return proto.CompactTextString(m) }
 func (*DisconnectResponse) ProtoMessage()    {}
 func (*DisconnectResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{11}
+	return fileDescriptor_ed7f10298fa1d90f, []int{12}
 }
 func (m *DisconnectResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DisconnectResponse.Unmarshal(m, b)
@@ -789,7 +827,7 @@ func (m *ListRequest) Reset()         { *m = ListRequest{} }
 func (m *ListRequest) String() string { return proto.CompactTextString(m) }
 func (*ListRequest) ProtoMessage()    {}
 func (*ListRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{12}
+	return fileDescriptor_ed7f10298fa1d90f, []int{13}
 }
 func (m *ListRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListRequest.Unmarshal(m, b)
@@ -827,7 +865,7 @@ func (m *ListResponse) Reset()         { *m = ListResponse{} }
 func (m *ListResponse) String() string { return proto.CompactTextString(m) }
 func (*ListResponse) ProtoMessage()    {}
 func (*ListResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{13}
+	return fileDescriptor_ed7f10298fa1d90f, []int{14}
 }
 func (m *ListResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListResponse.Unmarshal(m, b)
@@ -868,7 +906,7 @@ func (m *InputMessage) Reset()         { *m = InputMessage{} }
 func (m *InputMessage) String() string { return proto.CompactTextString(m) }
 func (*InputMessage) ProtoMessage()    {}
 func (*InputMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{14}
+	return fileDescriptor_ed7f10298fa1d90f, []int{15}
 }
 func (m *InputMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InputMessage.Unmarshal(m, b)
@@ -942,7 +980,7 @@ func (m *InputInitMessage) Reset()         { *m = InputInitMessage{} }
 func (m *InputInitMessage) String() string { return proto.CompactTextString(m) }
 func (*InputInitMessage) ProtoMessage()    {}
 func (*InputInitMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{15}
+	return fileDescriptor_ed7f10298fa1d90f, []int{16}
 }
 func (m *InputInitMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InputInitMessage.Unmarshal(m, b)
@@ -981,7 +1019,7 @@ func (m *DataMessage) Reset()         { *m = DataMessage{} }
 func (m *DataMessage) String() string { return proto.CompactTextString(m) }
 func (*DataMessage) ProtoMessage()    {}
 func (*DataMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{16}
+	return fileDescriptor_ed7f10298fa1d90f, []int{17}
 }
 func (m *DataMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DataMessage.Unmarshal(m, b)
@@ -1025,7 +1063,7 @@ func (m *InputResponse) Reset()         { *m = InputResponse{} }
 func (m *InputResponse) String() string { return proto.CompactTextString(m) }
 func (*InputResponse) ProtoMessage()    {}
 func (*InputResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{17}
+	return fileDescriptor_ed7f10298fa1d90f, []int{18}
 }
 func (m *InputResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InputResponse.Unmarshal(m, b)
@@ -1061,7 +1099,7 @@ func (m *Message) Reset()         { *m = Message{} }
 func (m *Message) String() string { return proto.CompactTextString(m) }
 func (*Message) ProtoMessage()    {}
 func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{18}
+	return fileDescriptor_ed7f10298fa1d90f, []int{19}
 }
 func (m *Message) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Message.Unmarshal(m, b)
@@ -1160,7 +1198,7 @@ func (m *InitMessage) Reset()         { *m = InitMessage{} }
 func (m *InitMessage) String() string { return proto.CompactTextString(m) }
 func (*InitMessage) ProtoMessage()    {}
 func (*InitMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{19}
+	return fileDescriptor_ed7f10298fa1d90f, []int{20}
 }
 func (m *InitMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InitMessage.Unmarshal(m, b)
@@ -1212,7 +1250,7 @@ func (m *ContainerConfig) Reset()         { *m = ContainerConfig{} }
 func (m *ContainerConfig) String() string { return proto.CompactTextString(m) }
 func (*ContainerConfig) ProtoMessage()    {}
 func (*ContainerConfig) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{20}
+	return fileDescriptor_ed7f10298fa1d90f, []int{21}
 }
 func (m *ContainerConfig) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ContainerConfig.Unmarshal(m, b)
@@ -1301,7 +1339,7 @@ func (m *FdMessage) Reset()         { *m = FdMessage{} }
 func (m *FdMessage) String() string { return proto.CompactTextString(m) }
 func (*FdMessage) ProtoMessage()    {}
 func (*FdMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{21}
+	return fileDescriptor_ed7f10298fa1d90f, []int{22}
 }
 func (m *FdMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FdMessage.Unmarshal(m, b)
@@ -1354,7 +1392,7 @@ func (m *ResizeMessage) Reset()         { *m = ResizeMessage{} }
 func (m *ResizeMessage) String() string { return proto.CompactTextString(m) }
 func (*ResizeMessage) ProtoMessage()    {}
 func (*ResizeMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{22}
+	return fileDescriptor_ed7f10298fa1d90f, []int{23}
 }
 func (m *ResizeMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResizeMessage.Unmarshal(m, b)
@@ -1401,7 +1439,7 @@ func (m *SignalMessage) Reset()         { *m = SignalMessage{} }
 func (m *SignalMessage) String() string { return proto.CompactTextString(m) }
 func (*SignalMessage) ProtoMessage()    {}
 func (*SignalMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{23}
+	return fileDescriptor_ed7f10298fa1d90f, []int{24}
 }
 func (m *SignalMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignalMessage.Unmarshal(m, b)
@@ -1439,7 +1477,7 @@ func (m *StatusRequest) Reset()         { *m = StatusRequest{} }
 func (m *StatusRequest) String() string { return proto.CompactTextString(m) }
 func (*StatusRequest) ProtoMessage()    {}
 func (*StatusRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{24}
+	return fileDescriptor_ed7f10298fa1d90f, []int{25}
 }
 func (m *StatusRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatusRequest.Unmarshal(m, b)
@@ -1480,7 +1518,7 @@ func (m *StatusResponse) Reset()         { *m = StatusResponse{} }
 func (m *StatusResponse) String() string { return proto.CompactTextString(m) }
 func (*StatusResponse) ProtoMessage()    {}
 func (*StatusResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{25}
+	return fileDescriptor_ed7f10298fa1d90f, []int{26}
 }
 func (m *StatusResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatusResponse.Unmarshal(m, b)
@@ -1538,7 +1576,7 @@ func (m *InfoRequest) Reset()         { *m = InfoRequest{} }
 func (m *InfoRequest) String() string { return proto.CompactTextString(m) }
 func (*InfoRequest) ProtoMessage()    {}
 func (*InfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{26}
+	return fileDescriptor_ed7f10298fa1d90f, []int{27}
 }
 func (m *InfoRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InfoRequest.Unmarshal(m, b)
@@ -1569,7 +1607,7 @@ func (m *InfoResponse) Reset()         { *m = InfoResponse{} }
 func (m *InfoResponse) String() string { return proto.CompactTextString(m) }
 func (*InfoResponse) ProtoMessage()    {}
 func (*InfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{27}
+	return fileDescriptor_ed7f10298fa1d90f, []int{28}
 }
 func (m *InfoResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InfoResponse.Unmarshal(m, b)
@@ -1609,7 +1647,7 @@ func (m *BuildxVersion) Reset()         { *m = BuildxVersion{} }
 func (m *BuildxVersion) String() string { return proto.CompactTextString(m) }
 func (*BuildxVersion) ProtoMessage()    {}
 func (*BuildxVersion) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ed7f10298fa1d90f, []int{28}
+	return fileDescriptor_ed7f10298fa1d90f, []int{29}
 }
 func (m *BuildxVersion) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BuildxVersion.Unmarshal(m, b)
@@ -1660,6 +1698,7 @@ func init() {
 	proto.RegisterMapType((map[string]string)(nil), "buildx.controller.v1.ExportEntry.AttrsEntry")
 	proto.RegisterType((*CacheOptionsEntry)(nil), "buildx.controller.v1.CacheOptionsEntry")
 	proto.RegisterMapType((map[string]string)(nil), "buildx.controller.v1.CacheOptionsEntry.AttrsEntry")
+	proto.RegisterType((*Attest)(nil), "buildx.controller.v1.Attest")
 	proto.RegisterType((*SSH)(nil), "buildx.controller.v1.SSH")
 	proto.RegisterType((*Secret)(nil), "buildx.controller.v1.Secret")
 	proto.RegisterType((*UlimitOpt)(nil), "buildx.controller.v1.UlimitOpt")
@@ -1692,111 +1731,111 @@ func init() {
 func init() { proto.RegisterFile("controller.proto", fileDescriptor_ed7f10298fa1d90f) }
 
 var fileDescriptor_ed7f10298fa1d90f = []byte{
-	// 1654 bytes of a gzipped FileDescriptorProto
+	// 1657 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xeb, 0x6e, 0x1b, 0x37,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xdd, 0x6e, 0xdb, 0xc6,
-	0x16, 0xde, 0x91, 0x64, 0x5d, 0x8e, 0x2c, 0xc7, 0xe1, 0x3a, 0x01, 0x57, 0x9b, 0x4d, 0x9c, 0xc9,
+	0x12, 0x3e, 0x94, 0x64, 0xfd, 0x8c, 0x2c, 0xc7, 0xd9, 0xe3, 0x04, 0x3c, 0x3a, 0x39, 0x89, 0xc3,
-	0x65, 0x05, 0x64, 0x21, 0x27, 0xce, 0xa6, 0xb9, 0x16, 0xa8, 0x2d, 0x5b, 0xb0, 0x0b, 0xdf, 0x30,
+	0xfc, 0x1c, 0x01, 0x29, 0xe4, 0xc4, 0x69, 0x9a, 0xdf, 0x02, 0xb5, 0x25, 0x0b, 0x76, 0xe1, 0x3f,
-	0x72, 0x12, 0xb4, 0x05, 0x1a, 0x8c, 0x25, 0x5a, 0x1e, 0x68, 0x34, 0x54, 0x87, 0x94, 0x6c, 0xf7,
+	0x50, 0x4e, 0x82, 0xb6, 0x40, 0x03, 0x5a, 0x5a, 0xcb, 0x84, 0x28, 0xae, 0xca, 0x5d, 0xc9, 0x56,
-	0x57, 0x9f, 0xa0, 0xef, 0x51, 0xf4, 0x11, 0xfa, 0xab, 0xef, 0xd0, 0x77, 0xe8, 0xcf, 0xf6, 0x11,
+	0xaf, 0x7a, 0xd3, 0xdb, 0xbe, 0x47, 0xd1, 0x47, 0xe8, 0x55, 0xdf, 0xa1, 0x0f, 0xd2, 0x47, 0x28,
-	0x0a, 0x1e, 0x72, 0xa4, 0x91, 0xa5, 0x91, 0x6d, 0xf4, 0x97, 0xc9, 0x33, 0xdf, 0x77, 0xce, 0xe1,
+	0x76, 0x76, 0x49, 0x51, 0x96, 0x28, 0xdb, 0xe8, 0x95, 0x77, 0x86, 0xdf, 0x37, 0xb3, 0x3b, 0x3b,
-	0xe1, 0xb9, 0x50, 0x86, 0xc5, 0x26, 0x0f, 0x64, 0xc8, 0x7d, 0x9f, 0x85, 0xd5, 0x5e, 0xc8, 0x25,
+	0x3f, 0x2b, 0xc3, 0x72, 0x8b, 0xf9, 0x22, 0x60, 0x9e, 0x47, 0x83, 0x6a, 0x3f, 0x60, 0x82, 0x91,
-	0x27, 0x4b, 0x47, 0x7d, 0xcf, 0x6f, 0x9d, 0x55, 0x63, 0x1f, 0x06, 0xcf, 0xca, 0x6f, 0xdb, 0x9e,
+	0x95, 0xe3, 0x81, 0xeb, 0xb5, 0xcf, 0xab, 0xb1, 0x0f, 0xc3, 0x67, 0xe5, 0xb7, 0x1d, 0x57, 0x9c,
-	0x3c, 0xe9, 0x1f, 0x55, 0x9b, 0xbc, 0xbb, 0xd2, 0xe5, 0x47, 0xe7, 0x2b, 0x88, 0xea, 0x78, 0x72,
+	0x0e, 0x8e, 0xab, 0x2d, 0xd6, 0x5b, 0xeb, 0xb1, 0xe3, 0xd1, 0x1a, 0xa2, 0xba, 0xae, 0x58, 0x73,
-	0xc5, 0xed, 0x79, 0x2b, 0x82, 0x85, 0x03, 0xaf, 0xc9, 0xc4, 0x8a, 0x21, 0x45, 0x7f, 0xb5, 0x4a,
+	0xfa, 0xee, 0x1a, 0xa7, 0xc1, 0xd0, 0x6d, 0x51, 0xbe, 0xa6, 0x49, 0xe1, 0x5f, 0x65, 0xd2, 0xfa,
-	0xfb, 0x5b, 0x98, 0x5f, 0x57, 0x70, 0x87, 0x7d, 0xd7, 0x67, 0x42, 0x92, 0x45, 0x48, 0x3b, 0xec,
+	0x1e, 0x16, 0x37, 0x25, 0xdc, 0xa6, 0x3f, 0x0c, 0x28, 0x17, 0x64, 0x19, 0xd2, 0x36, 0x3d, 0x31,
-	0x98, 0x5a, 0xcb, 0x56, 0xa5, 0xe0, 0xa8, 0x25, 0x79, 0x07, 0xb9, 0xfd, 0x9e, 0xf4, 0x78, 0x20,
+	0x8d, 0x55, 0xa3, 0x52, 0xb0, 0xe5, 0x92, 0xbc, 0x83, 0xdc, 0x41, 0x5f, 0xb8, 0xcc, 0xe7, 0x66,
-	0x68, 0x6a, 0xd9, 0xaa, 0x14, 0x57, 0xed, 0xea, 0x34, 0x37, 0xaa, 0xa8, 0xc6, 0x20, 0x9d, 0x88,
+	0x6a, 0xd5, 0xa8, 0x14, 0xd7, 0xad, 0xea, 0xac, 0x6d, 0x54, 0xd1, 0x8c, 0x46, 0xda, 0x21, 0xc5,
-	0x62, 0xff, 0x5e, 0x30, 0x06, 0x8c, 0x80, 0x2c, 0x43, 0xb1, 0xc6, 0x03, 0xc9, 0xce, 0xe4, 0x81,
+	0xfa, 0x19, 0xb4, 0x03, 0xad, 0x20, 0xab, 0x50, 0xac, 0x31, 0x5f, 0xd0, 0x73, 0x71, 0xe8, 0x88,
-	0x2b, 0x4f, 0x8c, 0xa1, 0xb8, 0x88, 0x3c, 0x86, 0x85, 0x0d, 0xde, 0xec, 0xb0, 0xf0, 0xd8, 0xf3,
+	0x53, 0xed, 0x28, 0xae, 0x22, 0x8f, 0x61, 0xa9, 0xce, 0x5a, 0x5d, 0x1a, 0x9c, 0xb8, 0x1e, 0xdd,
-	0xd9, 0x9e, 0xdb, 0x65, 0x68, 0xb7, 0xe0, 0x5c, 0x90, 0x92, 0x3b, 0x50, 0x38, 0x08, 0xbd, 0x40,
+	0x77, 0x7a, 0x14, 0xfd, 0x16, 0xec, 0x0b, 0x5a, 0x72, 0x07, 0x0a, 0x87, 0x81, 0xeb, 0x8b, 0xc6,
-	0xd6, 0xfb, 0x41, 0x93, 0xa6, 0x11, 0x32, 0x12, 0x90, 0x6f, 0xa0, 0xa4, 0x50, 0x2d, 0xa3, 0x59,
+	0xc0, 0x6f, 0x99, 0x69, 0x84, 0x8c, 0x15, 0xe4, 0x3b, 0x28, 0x49, 0x54, 0x5b, 0x5b, 0xe6, 0x66,
-	0xd0, 0xcc, 0x72, 0xba, 0x52, 0x5c, 0x7d, 0x71, 0xb9, 0xf3, 0xd5, 0x31, 0xde, 0x66, 0x20, 0xc3,
+	0x66, 0x35, 0x5d, 0x29, 0xae, 0xbf, 0xb8, 0x7c, 0xf3, 0xd5, 0x09, 0xde, 0x96, 0x2f, 0x82, 0x91,
-	0x73, 0x67, 0x5c, 0x17, 0x59, 0x82, 0xb9, 0x35, 0xdf, 0xe7, 0xa7, 0x74, 0x6e, 0x39, 0x5d, 0x29,
+	0x3d, 0x69, 0x8b, 0xac, 0xc0, 0xc2, 0x86, 0xe7, 0xb1, 0x33, 0x73, 0x61, 0x35, 0x5d, 0x29, 0xd8,
-	0x38, 0x7a, 0x43, 0x28, 0xe4, 0xd6, 0xa4, 0x64, 0x42, 0x0a, 0x9a, 0x45, 0x79, 0xb4, 0x25, 0xfb,
+	0x4a, 0x20, 0x5f, 0x40, 0x6e, 0x43, 0x08, 0xca, 0x05, 0x37, 0xb3, 0xe8, 0xec, 0xce, 0x6c, 0x67,
-	0x50, 0x40, 0x0b, 0x6b, 0x61, 0x5b, 0xd0, 0x1c, 0x3a, 0xf2, 0xec, 0x0a, 0x8e, 0x0c, 0x39, 0xda,
+	0x0a, 0x64, 0x87, 0x60, 0x72, 0x00, 0x05, 0xf4, 0xbf, 0x11, 0x74, 0xb8, 0x99, 0x43, 0xe6, 0xb3,
-	0x89, 0x91, 0x0e, 0xb2, 0x09, 0x85, 0x9a, 0xdb, 0x3c, 0x61, 0xf5, 0x90, 0x77, 0x69, 0x1e, 0x15,
+	0x2b, 0x6c, 0x33, 0xe2, 0xa8, 0x2d, 0x8e, 0x6d, 0x90, 0x2d, 0x28, 0xd4, 0x9c, 0xd6, 0x29, 0x6d,
-	0xfe, 0x77, 0xba, 0x42, 0x84, 0x19, 0x85, 0x46, 0xcd, 0x90, 0x49, 0xd6, 0x20, 0x87, 0x9b, 0x43,
+	0x04, 0xac, 0x67, 0xe6, 0xd1, 0xe0, 0xff, 0x67, 0x1b, 0x44, 0x98, 0x36, 0xa8, 0xcd, 0x44, 0x4c,
-	0x4e, 0x0b, 0xd7, 0x53, 0x12, 0xf1, 0x88, 0x0d, 0xf3, 0xb5, 0x76, 0xc8, 0xfb, 0xbd, 0x03, 0x37,
+	0xb2, 0x01, 0x39, 0x14, 0x8e, 0x98, 0x59, 0xb8, 0x9e, 0x91, 0x90, 0x47, 0x2c, 0x58, 0xac, 0x75,
-	0x64, 0x81, 0xa4, 0x80, 0x17, 0x31, 0x26, 0x23, 0x6f, 0x21, 0xb7, 0x79, 0xd6, 0xe3, 0xa1, 0x14,
+	0x02, 0x36, 0xe8, 0x1f, 0x3a, 0x01, 0xf5, 0x85, 0x09, 0x78, 0x4d, 0x13, 0x3a, 0xf2, 0x16, 0x72,
-	0xb4, 0x88, 0x66, 0xee, 0x4f, 0x37, 0xa3, 0x41, 0xc6, 0x80, 0x61, 0x90, 0xbb, 0x00, 0x9b, 0x67,
+	0x5b, 0xe7, 0x7d, 0x16, 0x08, 0x6e, 0x16, 0xd1, 0xcd, 0xfd, 0xd9, 0x6e, 0x14, 0x48, 0x3b, 0xd0,
-	0x32, 0x74, 0xb7, 0xb8, 0x0a, 0xec, 0x3c, 0x06, 0x36, 0x26, 0x21, 0x75, 0xc8, 0xee, 0xb8, 0x47,
+	0x0c, 0x72, 0x17, 0x60, 0xeb, 0x5c, 0x04, 0xce, 0x36, 0x93, 0x61, 0x5f, 0xc4, 0xeb, 0x88, 0x69,
-	0xcc, 0x17, 0xb4, 0x84, 0xba, 0xab, 0x57, 0x08, 0xac, 0x26, 0x68, 0x43, 0x86, 0xad, 0x12, 0x73,
+	0x48, 0x03, 0xb2, 0xbb, 0xce, 0x31, 0xf5, 0xb8, 0x59, 0x42, 0xdb, 0xd5, 0x2b, 0x04, 0x56, 0x11,
-	0x8f, 0xc9, 0x53, 0x1e, 0x76, 0x76, 0x79, 0x8b, 0xd1, 0x05, 0x9d, 0x98, 0x31, 0x11, 0x79, 0x08,
+	0x94, 0x23, 0xcd, 0x96, 0x69, 0xbb, 0x4f, 0xc5, 0x19, 0x0b, 0xba, 0x7b, 0xac, 0x4d, 0xcd, 0x25,
-	0xa5, 0x3d, 0xae, 0x83, 0xe7, 0xf9, 0x92, 0x85, 0xf4, 0x06, 0x3a, 0x33, 0x2e, 0xc4, 0xb4, 0xf4,
+	0x95, 0xb6, 0x31, 0x15, 0x79, 0x08, 0xa5, 0x7d, 0xa6, 0x82, 0xe7, 0x7a, 0x82, 0x06, 0xe6, 0x0d,
-	0x5d, 0x79, 0xcc, 0xc3, 0xae, 0xa0, 0x8b, 0x88, 0x18, 0x09, 0xc8, 0x67, 0x90, 0x6b, 0xb0, 0x66,
+	0xdc, 0xcc, 0xa4, 0x12, 0x93, 0xd6, 0x73, 0xc4, 0x09, 0x0b, 0x7a, 0xdc, 0x5c, 0x46, 0xc4, 0x58,
-	0xc8, 0xa4, 0xa0, 0x37, 0xd1, 0xdd, 0x3b, 0xd3, 0xdd, 0xd5, 0x20, 0x27, 0x02, 0xab, 0xdc, 0x6a,
+	0x21, 0x33, 0xa8, 0x49, 0x5b, 0x01, 0x15, 0xdc, 0xbc, 0x39, 0x2f, 0x83, 0x14, 0xc8, 0x0e, 0xc1,
-	0x9c, 0x74, 0x1b, 0xde, 0xf7, 0x8c, 0x92, 0x65, 0xab, 0x92, 0x76, 0xa2, 0x2d, 0x79, 0x02, 0xe9,
+	0xc4, 0x84, 0x5c, 0xf3, 0xb4, 0xd7, 0x74, 0x7f, 0xa4, 0x26, 0x59, 0x35, 0x2a, 0x69, 0x3b, 0x14,
-	0x46, 0x63, 0x8b, 0xfe, 0x13, 0xb5, 0xfd, 0x2b, 0x41, 0x5b, 0x63, 0xcb, 0x51, 0x28, 0x42, 0x20,
+	0xc9, 0x13, 0x48, 0x37, 0x9b, 0xdb, 0xe6, 0xbf, 0xd1, 0xda, 0x7f, 0x12, 0xac, 0x35, 0xb7, 0x6d,
-	0x73, 0xe8, 0xb6, 0x05, 0x5d, 0x42, 0xbf, 0x70, 0x4d, 0x6e, 0x43, 0xf6, 0xd0, 0x0d, 0xdb, 0x4c,
+	0x89, 0x22, 0x04, 0x32, 0x47, 0x4e, 0x87, 0x9b, 0x2b, 0xb8, 0x2f, 0x5c, 0x93, 0xdb, 0x90, 0x3d,
-	0xd2, 0x5b, 0x78, 0x66, 0xb3, 0x23, 0xaf, 0x21, 0xf7, 0xde, 0xf7, 0xba, 0x9e, 0x14, 0xf4, 0x36,
+	0x72, 0x82, 0x0e, 0x15, 0xe6, 0x2d, 0x3c, 0xb3, 0x96, 0xc8, 0x6b, 0xc8, 0xbd, 0xf7, 0xdc, 0x9e,
-	0x16, 0xfe, 0xbd, 0xe9, 0xca, 0x35, 0x68, 0xbf, 0x27, 0x9d, 0x08, 0x4f, 0x5e, 0x42, 0x66, 0xbf,
+	0x2b, 0xb8, 0x79, 0x1b, 0xdb, 0xc2, 0xbd, 0xd9, 0xc6, 0x15, 0xe8, 0xa0, 0x2f, 0xec, 0x10, 0x4f,
-	0x27, 0x05, 0xa5, 0xc8, 0x7b, 0x90, 0x90, 0x54, 0xbc, 0xdb, 0xe5, 0x41, 0xd4, 0x31, 0x90, 0x50,
+	0x5e, 0x42, 0xe6, 0xa0, 0x2f, 0xb8, 0x69, 0x22, 0xef, 0x41, 0x42, 0x52, 0xb1, 0x5e, 0x8f, 0xf9,
-	0xfe, 0x02, 0xc8, 0x64, 0xf5, 0xa9, 0xa6, 0xd4, 0x61, 0xe7, 0x51, 0x53, 0xea, 0xb0, 0x73, 0x55,
+	0x61, 0x3f, 0x41, 0x42, 0xf9, 0x2b, 0x20, 0xd3, 0xb5, 0x29, 0x5b, 0x56, 0x97, 0x8e, 0xc2, 0x96,
-	0x80, 0x03, 0xd7, 0xef, 0x47, 0xad, 0x41, 0x6f, 0xde, 0xa4, 0x5e, 0x59, 0xe5, 0x77, 0xb0, 0x30,
+	0xd5, 0xa5, 0x23, 0x59, 0x9e, 0x43, 0xc7, 0x1b, 0x84, 0x8d, 0x43, 0x09, 0x6f, 0x52, 0xaf, 0x8c,
-	0x5e, 0x36, 0xd7, 0x62, 0xbf, 0x86, 0x62, 0x2c, 0x37, 0xae, 0x43, 0xb5, 0x7f, 0xb5, 0xa0, 0x18,
+	0xf2, 0x3b, 0x58, 0x9a, 0x2c, 0x9b, 0x6b, 0xb1, 0x5f, 0x43, 0x31, 0x96, 0x1b, 0xd7, 0xa1, 0x5a,
-	0x4b, 0x60, 0x0c, 0xf5, 0x79, 0x8f, 0x19, 0x32, 0xae, 0xc9, 0x3a, 0xcc, 0xad, 0x49, 0x19, 0xaa,
+	0x7f, 0x18, 0x50, 0x8c, 0x25, 0x30, 0x86, 0x7a, 0xd4, 0xa7, 0x9a, 0x8c, 0x6b, 0xb2, 0x09, 0x0b,
-	0x4e, 0xaa, 0x6e, 0xeb, 0x7f, 0x97, 0x96, 0x41, 0x15, 0xe1, 0x3a, 0x51, 0x35, 0x55, 0xe5, 0xe9,
+	0x1b, 0x42, 0x04, 0xb2, 0xcf, 0xca, 0xdb, 0xfa, 0xec, 0xd2, 0x32, 0xa8, 0x22, 0x5c, 0x25, 0xaa,
-	0x06, 0x13, 0xd2, 0x0b, 0x5c, 0x15, 0x38, 0xd3, 0xf8, 0xe2, 0xa2, 0xf2, 0x2b, 0x80, 0x11, 0xed,
+	0xa2, 0xca, 0x3c, 0xad, 0x53, 0x2e, 0x5c, 0xdf, 0x91, 0x81, 0xd3, 0x6d, 0x31, 0xae, 0x2a, 0xbf,
-	0x5a, 0x67, 0xf8, 0xd9, 0x82, 0x9b, 0x13, 0xb5, 0x3e, 0xf5, 0x24, 0x5b, 0xe3, 0x27, 0x59, 0xbd,
+	0x02, 0x18, 0xd3, 0xae, 0x75, 0x86, 0xdf, 0x0c, 0xb8, 0x39, 0x55, 0xeb, 0x33, 0x4f, 0xb2, 0x3d,
-	0x62, 0xdf, 0x98, 0x3c, 0xcf, 0xdf, 0xf0, 0x56, 0x67, 0x3e, 0x59, 0x80, 0xd4, 0xf6, 0x86, 0x61,
+	0x79, 0x92, 0xf5, 0x2b, 0xf6, 0x8d, 0xe9, 0xf3, 0xfc, 0x83, 0xdd, 0xee, 0x43, 0x56, 0x35, 0xd8,
-	0xa4, 0xb6, 0x37, 0x14, 0x41, 0xcd, 0x11, 0xed, 0x5a, 0xc1, 0xd1, 0x1b, 0xbb, 0x0e, 0x59, 0x5d,
+	0x99, 0x3b, 0x2c, 0x43, 0xbe, 0xee, 0x72, 0xe7, 0xd8, 0xa3, 0x6d, 0xa4, 0xe6, 0xed, 0x48, 0xc6,
-	0x4b, 0x13, 0xf8, 0x32, 0xe4, 0xeb, 0x9e, 0xcf, 0x70, 0x1c, 0x69, 0x1b, 0xc3, 0xbd, 0x72, 0x67,
+	0xee, 0x8e, 0xbb, 0x57, 0xd1, 0x53, 0x82, 0xa5, 0x2a, 0x89, 0x2c, 0x41, 0x6a, 0xa7, 0xae, 0x4d,
-	0x33, 0x18, 0x98, 0x20, 0xab, 0xa5, 0xfd, 0x93, 0x05, 0x85, 0x61, 0xc6, 0x93, 0x1a, 0x64, 0xd1,
+	0xa5, 0x76, 0xea, 0x12, 0x2c, 0xa7, 0x96, 0x3a, 0x6a, 0xc1, 0x56, 0x82, 0xd5, 0x80, 0xac, 0xaa,
-	0x1f, 0x41, 0x2d, 0x8c, 0xc3, 0x93, 0x4b, 0x4a, 0xa4, 0xfa, 0x01, 0xd1, 0xa6, 0xf3, 0x68, 0x6a,
+	0xcd, 0x29, 0x7c, 0x19, 0xf2, 0x0d, 0xd7, 0xa3, 0x38, 0xfc, 0xd4, 0x9e, 0x23, 0x59, 0x1e, 0x6f,
-	0xf9, 0x23, 0x14, 0x63, 0xe2, 0x29, 0x21, 0x58, 0x8d, 0x87, 0x20, 0xb1, 0x65, 0x68, 0x23, 0xf1,
+	0xcb, 0x1f, 0x6a, 0xb7, 0x72, 0x69, 0xfd, 0x6a, 0x40, 0x21, 0xaa, 0x20, 0x52, 0x83, 0x2c, 0x9e,
-	0x00, 0x6d, 0x40, 0x56, 0x0b, 0xd5, 0x15, 0xe2, 0x24, 0x35, 0x57, 0x88, 0xf3, 0x93, 0x40, 0x66,
+	0x8f, 0x9b, 0x06, 0xc6, 0xf5, 0xc9, 0x25, 0x25, 0x57, 0xfd, 0x80, 0x68, 0xdd, 0xc9, 0x14, 0xb5,
-	0xcb, 0x0d, 0x5b, 0xa8, 0x34, 0xed, 0xe0, 0x5a, 0xc9, 0x1a, 0xfc, 0x58, 0xe2, 0x81, 0xd3, 0x0e,
+	0xfc, 0x11, 0x8a, 0x31, 0xf5, 0x8c, 0x90, 0xae, 0xc7, 0x43, 0x9a, 0xd8, 0x82, 0x94, 0x93, 0x78,
-	0xae, 0xed, 0x3f, 0x2c, 0x28, 0x8d, 0xd5, 0xaa, 0x6a, 0x46, 0x58, 0x63, 0x2c, 0x34, 0x0a, 0xa3,
+	0xc0, 0xeb, 0x90, 0x55, 0x4a, 0x19, 0x70, 0x9c, 0xdb, 0x3a, 0xe0, 0x38, 0xad, 0x09, 0x64, 0xb6,
-	0xad, 0x9a, 0x06, 0xbb, 0x4c, 0xba, 0x2d, 0x57, 0xba, 0x2a, 0x86, 0x26, 0x9e, 0x63, 0x32, 0xc5,
+	0x9d, 0x40, 0x05, 0x3b, 0x6d, 0xe3, 0x5a, 0xea, 0x9a, 0xec, 0x44, 0xe0, 0x81, 0xd3, 0x36, 0xae,
-	0x36, 0x1d, 0x13, 0xcd, 0xe4, 0x9d, 0x68, 0xab, 0xac, 0x1f, 0xf4, 0x7d, 0x9f, 0x66, 0x50, 0x8c,
+	0xad, 0xdf, 0x0d, 0x28, 0x4d, 0xd4, 0xbe, 0x6c, 0x6e, 0x58, 0xb3, 0x34, 0xd0, 0x06, 0x43, 0x51,
-	0x6b, 0xdd, 0xfe, 0x55, 0x3d, 0x1c, 0xf4, 0xc5, 0x09, 0x9d, 0xc3, 0x2f, 0x31, 0xc9, 0xe8, 0xfb,
+	0x4e, 0x97, 0x3d, 0x2a, 0x9c, 0xb6, 0x23, 0x1c, 0x19, 0x43, 0x1d, 0xcf, 0x09, 0x9d, 0x64, 0xeb,
-	0x0e, 0x77, 0x5b, 0x34, 0x1b, 0xff, 0xae, 0x24, 0x78, 0xa2, 0xf5, 0xfd, 0x5d, 0x9a, 0xd3, 0x27,
+	0x0e, 0x8c, 0x6e, 0xf2, 0x76, 0x28, 0x4a, 0xef, 0x87, 0x03, 0xcf, 0x33, 0x33, 0xa8, 0xc6, 0xb5,
-	0x57, 0x6b, 0xc5, 0x39, 0x08, 0xf9, 0x80, 0x05, 0x6e, 0xd0, 0x64, 0x34, 0x8f, 0x5f, 0x62, 0x12,
+	0x1a, 0x27, 0xb2, 0xbe, 0x0e, 0x07, 0xfc, 0xd4, 0x5c, 0xc0, 0x2f, 0x31, 0xcd, 0xf8, 0xfb, 0x2e,
-	0xfb, 0x17, 0x0b, 0x4a, 0xe6, 0x55, 0x24, 0x7a, 0x3c, 0x10, 0x8c, 0x30, 0x58, 0xd4, 0x3a, 0x59,
+	0x73, 0xda, 0x66, 0x36, 0xfe, 0x5d, 0x6a, 0x70, 0xf7, 0xfa, 0x3d, 0xc5, 0xfb, 0xcc, 0xe7, 0x94,
-	0x18, 0xc9, 0xcc, 0x8d, 0xbf, 0x9e, 0x31, 0x6e, 0x22, 0x68, 0xf5, 0x22, 0x57, 0xdf, 0xff, 0x84,
+	0x50, 0x58, 0x56, 0xdf, 0x69, 0x10, 0xea, 0xf4, 0xed, 0xbd, 0x9e, 0x33, 0x8a, 0x42, 0x68, 0xf5,
-	0xca, 0x72, 0x0d, 0x6e, 0x4d, 0x85, 0x5e, 0xab, 0x2c, 0x1e, 0xc1, 0xcd, 0x0d, 0x4f, 0x34, 0x79,
+	0x22, 0x57, 0xdd, 0xe5, 0x94, 0xc9, 0x72, 0x0d, 0x6e, 0xcd, 0x84, 0x5e, 0xab, 0x64, 0x1e, 0xc1,
-	0x10, 0xb0, 0xa6, 0x4c, 0x7c, 0xd7, 0xd9, 0x4b, 0x40, 0xe2, 0x30, 0x6d, 0xcd, 0xbe, 0x07, 0xc5,
+	0xcd, 0xba, 0xcb, 0x5b, 0xcc, 0xf7, 0x69, 0x4b, 0x24, 0xbe, 0x08, 0xad, 0x15, 0x20, 0x71, 0x98,
-	0x1d, 0x4f, 0xcc, 0xa0, 0xd9, 0x30, 0xaf, 0x01, 0x26, 0x32, 0x04, 0x32, 0x1d, 0x76, 0xae, 0xf3,
+	0xf2, 0x66, 0xdd, 0x83, 0xe2, 0xae, 0xcb, 0xe7, 0xd0, 0x2c, 0x58, 0x54, 0x00, 0x1d, 0x19, 0x02,
-	0xbf, 0xe0, 0xe0, 0xda, 0xfe, 0xd1, 0x82, 0xf9, 0xed, 0xa0, 0xd7, 0x97, 0xbb, 0x4c, 0x08, 0xb7,
+	0x99, 0x2e, 0x1d, 0xa9, 0x5c, 0x2e, 0xd8, 0xb8, 0xb6, 0x7e, 0x31, 0x60, 0x71, 0xc7, 0xef, 0x0f,
-	0xcd, 0xc8, 0x3b, 0xc8, 0x6c, 0x07, 0x9e, 0x44, 0x3d, 0xc5, 0xd5, 0xc7, 0xd3, 0x43, 0x86, 0x0c,
+	0xc4, 0x1e, 0xe5, 0xdc, 0xe9, 0x50, 0xf2, 0x0e, 0x32, 0x3b, 0xbe, 0x2b, 0xd0, 0x4e, 0x71, 0xfd,
-	0x05, 0x33, 0xac, 0xad, 0x7f, 0x38, 0xc8, 0x52, 0xd3, 0x64, 0xc3, 0x95, 0xae, 0xc9, 0xfe, 0x84,
+	0xf1, 0xec, 0x90, 0x21, 0x43, 0xc2, 0x34, 0x6b, 0xfb, 0x5f, 0x36, 0xb2, 0xe4, 0xa4, 0xa9, 0x3b,
-	0xb7, 0x83, 0x42, 0xc4, 0x88, 0x6a, 0xbb, 0x9e, 0x83, 0x39, 0x54, 0x6a, 0x3f, 0x84, 0xc5, 0x8b,
+	0xc2, 0xd1, 0x99, 0x9c, 0xf0, 0xae, 0x90, 0x88, 0x18, 0x51, 0x8a, 0x9b, 0x39, 0x58, 0x40, 0xa3,
-	0xda, 0xa7, 0x1c, 0xed, 0x39, 0x14, 0x63, 0x5a, 0xb0, 0xf6, 0xf7, 0xeb, 0x08, 0xc8, 0x3b, 0x6a,
+	0xd6, 0x43, 0x58, 0xbe, 0x68, 0x7d, 0xc6, 0xd1, 0x9e, 0x43, 0x31, 0x66, 0x05, 0xeb, 0xf8, 0xa0,
-	0xa9, 0xce, 0x3a, 0x74, 0x64, 0x5e, 0xdb, 0xb0, 0x6f, 0x40, 0x09, 0x55, 0x0f, 0x23, 0xf8, 0x43,
+	0x81, 0x80, 0xbc, 0x2d, 0x97, 0xf2, 0xac, 0xd1, 0x46, 0x16, 0x95, 0x0f, 0xeb, 0x06, 0x94, 0xd0,
-	0x0a, 0x72, 0x91, 0x8a, 0x97, 0x63, 0xe7, 0xbe, 0x9f, 0x74, 0xee, 0xc9, 0x23, 0xbf, 0x80, 0xcc,
+	0x74, 0x14, 0xc1, 0x9f, 0x52, 0x90, 0x0b, 0x4d, 0xbc, 0x9c, 0x38, 0xf7, 0xfd, 0xa4, 0x73, 0x4f,
-	0xb0, 0x7e, 0x12, 0x07, 0x6f, 0xbd, 0x15, 0xa3, 0x61, 0x69, 0x7d, 0x0e, 0x59, 0x87, 0x09, 0xf5,
+	0x1f, 0xf9, 0x05, 0x64, 0xa2, 0x5a, 0x48, 0x1c, 0xca, 0x8d, 0x76, 0x8c, 0x86, 0x65, 0xf2, 0x25,
-	0x48, 0x48, 0xcf, 0x9a, 0xbc, 0x1a, 0x33, 0x22, 0x1b, 0x92, 0xa2, 0x37, 0xbc, 0x76, 0xe0, 0xea,
+	0x64, 0x6d, 0xca, 0xe5, 0x03, 0x22, 0x3d, 0x6f, 0x2a, 0x2b, 0xcc, 0x98, 0xac, 0x49, 0x92, 0xde,
-	0x0a, 0x4c, 0xa4, 0x6b, 0x4c, 0x8c, 0xae, 0x05, 0xa3, 0x70, 0xf7, 0xa0, 0x38, 0x33, 0xd2, 0x64,
+	0x74, 0x3b, 0xbe, 0xa3, 0xaa, 0x29, 0x91, 0xae, 0x30, 0x31, 0xba, 0x52, 0x8c, 0xc3, 0xdd, 0x87,
-	0x1f, 0x6e, 0xa8, 0x09, 0xef, 0x7a, 0x01, 0x0b, 0x6b, 0x3c, 0x38, 0xf6, 0xda, 0xe6, 0xa4, 0x8f,
+	0xe2, 0xdc, 0x48, 0x93, 0x03, 0xb8, 0x21, 0xa7, 0xbf, 0xe3, 0xfa, 0x34, 0xa8, 0x31, 0xff, 0xc4,
-	0x92, 0x9e, 0x0a, 0x63, 0x60, 0xe7, 0x22, 0x5b, 0x55, 0xec, 0x45, 0x19, 0x76, 0x06, 0x55, 0x3c,
+	0xed, 0xe8, 0x93, 0x3e, 0x4a, 0x7a, 0x46, 0x4c, 0x80, 0xed, 0x8b, 0x6c, 0x59, 0xb1, 0x17, 0x75,
-	0x3d, 0xee, 0x05, 0xd2, 0xe4, 0x67, 0x4c, 0xa2, 0xdc, 0xaa, 0x75, 0x5b, 0x66, 0x4a, 0xa8, 0xe5,
+	0x58, 0xe5, 0xb2, 0x78, 0xfa, 0xcc, 0xf5, 0x85, 0xce, 0xcf, 0x98, 0x46, 0x6e, 0xab, 0xd6, 0x6b,
-	0xa8, 0xdb, 0xa7, 0x4d, 0xb7, 0x57, 0x37, 0xfe, 0x5e, 0xb0, 0x10, 0xe3, 0x51, 0x70, 0x70, 0xad,
+	0xeb, 0x8e, 0x2f, 0x97, 0xe3, 0xce, 0x9d, 0xd6, 0x9d, 0x5b, 0xde, 0xf8, 0x7b, 0x4e, 0x03, 0x8c,
-	0xde, 0x4b, 0x7b, 0x1c, 0xa5, 0xba, 0x1b, 0x99, 0x1d, 0xea, 0x3b, 0xd5, 0x2d, 0x48, 0xe9, 0x3b,
+	0x47, 0xc1, 0xc6, 0xb5, 0x7c, 0x4b, 0xed, 0x33, 0xd4, 0xaa, 0xce, 0xa2, 0x25, 0xb4, 0x77, 0xa6,
-	0x6d, 0xa9, 0x1a, 0xdd, 0xe3, 0x4a, 0x96, 0x43, 0xa0, 0xde, 0x28, 0xdc, 0xa1, 0x3c, 0xc7, 0xb6,
+	0xda, 0x89, 0xb4, 0x77, 0x86, 0x23, 0x68, 0x9f, 0x49, 0x5d, 0x0e, 0x81, 0x4a, 0x90, 0xb8, 0x23,
-	0x93, 0x77, 0xd4, 0xd2, 0x5e, 0x83, 0xc2, 0xf0, 0x2e, 0xd5, 0x78, 0xaa, 0xb7, 0x30, 0x58, 0x25,
+	0x31, 0x32, 0xf3, 0x2a, 0xaf, 0x8e, 0xc4, 0xc8, 0xda, 0x80, 0x42, 0x74, 0x97, 0x72, 0xd4, 0x34,
-	0x27, 0x55, 0x6f, 0x45, 0x69, 0x98, 0x9a, 0x4c, 0xc3, 0x74, 0x2c, 0x0d, 0x5f, 0x42, 0x69, 0xec,
+	0xda, 0x18, 0xac, 0x92, 0x9d, 0x6a, 0xb4, 0xc3, 0x34, 0x4c, 0x4d, 0xa7, 0x61, 0x3a, 0x96, 0x86,
-	0x56, 0x15, 0xc8, 0xe1, 0xa7, 0xc2, 0x28, 0xc2, 0xb5, 0x92, 0xd5, 0xb8, 0xaf, 0x7f, 0xc7, 0x95,
+	0x2f, 0xa1, 0x34, 0x71, 0xab, 0x12, 0x64, 0xb3, 0x33, 0xae, 0x0d, 0xe1, 0x5a, 0xea, 0x6a, 0xcc,
-	0x1c, 0x5c, 0xdb, 0x0f, 0xa0, 0x34, 0x76, 0x9f, 0xd3, 0x46, 0x85, 0x7d, 0x1f, 0x4a, 0x0d, 0xe9,
+	0x53, 0xbf, 0x00, 0x4b, 0x36, 0xae, 0xad, 0x07, 0x50, 0x9a, 0xb8, 0xcf, 0x59, 0x6d, 0xdf, 0xba,
-	0xca, 0xbe, 0x48, 0xee, 0x0b, 0x7f, 0x5a, 0xb0, 0x10, 0x61, 0x4c, 0x6b, 0xf8, 0x3f, 0xe4, 0x07,
+	0x0f, 0xa5, 0xa6, 0x70, 0xc4, 0x80, 0x27, 0xf7, 0x85, 0xbf, 0x0c, 0x58, 0x0a, 0x31, 0xba, 0x35,
-	0x2c, 0x94, 0xec, 0x6c, 0x38, 0x1e, 0x69, 0x55, 0xfd, 0x40, 0xad, 0x46, 0x3f, 0x50, 0xd5, 0xd5,
+	0x7c, 0x0e, 0xf9, 0x21, 0x0d, 0x04, 0x3d, 0x8f, 0x46, 0x9d, 0x59, 0x95, 0x3f, 0x6d, 0xab, 0xe1,
-	0x7e, 0x40, 0x84, 0x33, 0x44, 0x92, 0x37, 0x90, 0x17, 0xa8, 0x87, 0x45, 0x8f, 0x8b, 0xbb, 0x49,
+	0x4f, 0x5b, 0x79, 0xb5, 0x1f, 0x10, 0x61, 0x47, 0x48, 0xf2, 0x06, 0xf2, 0x1c, 0xed, 0xd0, 0xf0,
-	0x2c, 0x63, 0x6f, 0x88, 0x27, 0x2b, 0x90, 0xf1, 0x79, 0x5b, 0xe0, 0x0d, 0x16, 0x57, 0xff, 0x9d,
+	0xe1, 0x71, 0x37, 0x89, 0xa5, 0xfd, 0x45, 0x78, 0xb2, 0x06, 0x19, 0x8f, 0x75, 0x38, 0xde, 0x60,
-	0xc4, 0xdb, 0xe1, 0x6d, 0x07, 0x81, 0xe4, 0x2d, 0xe4, 0x4f, 0xdd, 0x30, 0xf0, 0x82, 0x76, 0xf4,
+	0x71, 0xfd, 0xbf, 0x49, 0xbc, 0x5d, 0xd6, 0xb1, 0x11, 0x48, 0xde, 0x42, 0xfe, 0xcc, 0x09, 0x7c,
-	0x03, 0xf1, 0x5e, 0x12, 0xe9, 0xa3, 0xc6, 0x39, 0x43, 0x82, 0x5d, 0x52, 0x69, 0x7e, 0xcc, 0x4d,
+	0xd7, 0xef, 0x84, 0x3f, 0x2d, 0xef, 0x25, 0x91, 0x3e, 0x2a, 0x9c, 0x1d, 0x11, 0xac, 0x92, 0x4c,
-	0x4c, 0xec, 0xaf, 0x54, 0xd3, 0x53, 0x5b, 0x73, 0xfc, 0x6d, 0x28, 0xe9, 0x64, 0xfe, 0xc0, 0x42,
+	0xf3, 0x13, 0xa6, 0x63, 0x62, 0x7d, 0x23, 0x9b, 0x9e, 0x14, 0xf5, 0xf1, 0x77, 0xa0, 0xa4, 0x92,
-	0xa1, 0x9e, 0x6a, 0xd6, 0xac, 0xa2, 0x5a, 0x8f, 0x43, 0x9d, 0x71, 0xa6, 0xfd, 0xc9, 0xcc, 0xa3,
+	0xf9, 0x03, 0x0d, 0xb8, 0x7c, 0xc6, 0x19, 0xf3, 0x8a, 0x6a, 0x33, 0x0e, 0xb5, 0x27, 0x99, 0xd6,
-	0x48, 0xa0, 0x66, 0x68, 0xcf, 0x6d, 0x76, 0xdc, 0x76, 0x74, 0x4f, 0xd1, 0x56, 0x7d, 0x19, 0x18,
+	0x27, 0x3d, 0x8f, 0x42, 0x85, 0x9c, 0x87, 0x7d, 0xa7, 0xd5, 0x75, 0x3a, 0xe1, 0x3d, 0x85, 0xa2,
-	0x7b, 0x7a, 0x32, 0x44, 0x5b, 0xf5, 0xce, 0x09, 0xd9, 0xc0, 0x13, 0xa3, 0x57, 0xe3, 0x70, 0xbf,
+	0xfc, 0x32, 0xd4, 0xfe, 0xd4, 0x64, 0x08, 0x45, 0xf9, 0x66, 0x09, 0xe8, 0xd0, 0xe5, 0xe3, 0x17,
-	0xfa, 0x5b, 0x06, 0xa0, 0x36, 0xf4, 0x87, 0x1c, 0xc0, 0x1c, 0xda, 0x23, 0xf6, 0xcc, 0xe9, 0x86,
+	0x65, 0x24, 0xaf, 0xff, 0x99, 0x01, 0xa8, 0x45, 0xfb, 0x21, 0x87, 0xb0, 0x80, 0xfe, 0x88, 0x35,
-	0xe7, 0x2e, 0x3f, 0xb8, 0xc2, 0x04, 0x24, 0xef, 0x21, 0xab, 0x6f, 0x8b, 0x24, 0x35, 0x95, 0x78,
+	0x77, 0xba, 0xe1, 0xb9, 0xcb, 0x0f, 0xae, 0x30, 0x01, 0xc9, 0x7b, 0xc8, 0xaa, 0xdb, 0x22, 0x49,
-	0x7e, 0x95, 0x1f, 0xce, 0x06, 0x69, 0xa5, 0x4f, 0x2d, 0xe2, 0x98, 0x96, 0x93, 0xe4, 0x68, 0x7c,
+	0x4d, 0x25, 0x9e, 0x5f, 0xe5, 0x87, 0xf3, 0x41, 0xca, 0xe8, 0x53, 0x83, 0xd8, 0xba, 0xe5, 0x24,
-	0x0a, 0x25, 0x39, 0x3a, 0xd6, 0xbe, 0x2b, 0x16, 0xf9, 0x12, 0xb2, 0xdb, 0xc1, 0x80, 0x77, 0x18,
+	0x6d, 0x34, 0x3e, 0x85, 0x92, 0x36, 0x3a, 0xd1, 0xbe, 0x2b, 0x06, 0xf9, 0x1a, 0xb2, 0x3b, 0xfe,
-	0xf9, 0xcf, 0x74, 0x42, 0xa4, 0x6f, 0xf6, 0xe7, 0x8a, 0xf5, 0xd4, 0x22, 0xbb, 0x90, 0x51, 0xd3,
+	0x90, 0x75, 0x29, 0xf9, 0xdf, 0x6c, 0x42, 0x68, 0x6f, 0xfe, 0xe7, 0x8a, 0xf1, 0xd4, 0x20, 0x7b,
-	0x92, 0x24, 0xb4, 0xfe, 0xd8, 0xa8, 0x2d, 0xdb, 0xb3, 0x20, 0x26, 0x8a, 0x9f, 0x00, 0x46, 0x33,
+	0x90, 0x91, 0xd3, 0x92, 0x24, 0xb4, 0xfe, 0xd8, 0xa8, 0x2d, 0x5b, 0xf3, 0x20, 0x3a, 0x8a, 0x9f,
-	0x9b, 0x24, 0xfc, 0x58, 0x9f, 0x18, 0xfe, 0xe5, 0xca, 0xe5, 0x40, 0x63, 0x60, 0x57, 0x0d, 0xac,
+	0x00, 0xc6, 0x33, 0x9b, 0x24, 0xfc, 0x90, 0x9f, 0x1a, 0xfe, 0xe5, 0xca, 0xe5, 0x40, 0xed, 0x60,
-	0x63, 0x4e, 0x12, 0x47, 0xd5, 0x30, 0xdd, 0xcb, 0xf6, 0x2c, 0x88, 0x56, 0xb7, 0x9e, 0xf9, 0x3a,
+	0x4f, 0x0e, 0xac, 0x13, 0x46, 0x12, 0x47, 0x55, 0x94, 0xee, 0x65, 0x6b, 0x1e, 0x44, 0x99, 0xdb,
-	0xd5, 0x3b, 0x3a, 0xca, 0xe2, 0xbf, 0x9a, 0x9e, 0xff, 0x15, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xd9,
+	0xcc, 0x7c, 0x9b, 0xea, 0x1f, 0x1f, 0x67, 0xf1, 0x9f, 0x54, 0xcf, 0xff, 0x0e, 0x00, 0x00, 0xff,
-	0xb0, 0xd0, 0xd1, 0x12, 0x00, 0x00,
+	0xff, 0xf4, 0x2e, 0xaa, 0xc4, 0x0b, 0x13, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

controller/pb/controller.proto

@@ -28,7 +28,7 @@ message BuildOptions {
   map<string, string> NamedContexts = 4;
 
   repeated string Allow = 5;
-  repeated string Attests = 6; // TODO
+  repeated Attest Attests = 6;
   map<string, string> BuildArgs = 7;
   repeated CacheOptionsEntry CacheFrom = 8;
   repeated CacheOptionsEntry CacheTo = 9;
@@ -60,6 +60,12 @@ message CacheOptionsEntry {
   map<string, string> Attrs = 2;
 }
 
+message Attest {
+  string Type = 1;
+  bool Disabled = 2;
+  string Attrs = 3;
+}
+
 message SSH {
   string ID = 1;
   repeated string Paths = 2;
@@ -89,8 +95,6 @@ message CommonOptions {
   bool Pull = 4;
   bool ExportPush = 5;
   bool ExportLoad = 6;
-  string SBOM       = 7; // TODO
-  string Provenance = 8; // TODO
 }
 
 message BuildResponse {

util/buildflags/attests.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	controllerapi "github.com/docker/buildx/controller/pb"
 	"github.com/pkg/errors"
 )
 
@@ -14,66 +15,66 @@ func CanonicalizeAttest(attestType string, in string) string {
 		return ""
 	}
 	if b, err := strconv.ParseBool(in); err == nil {
-		return fmt.Sprintf("type=%s,enabled=%t", attestType, b)
+		return fmt.Sprintf("type=%s,disabled=%t", attestType, !b)
 	}
 	return fmt.Sprintf("type=%s,%s", attestType, in)
 }
 
-func ParseAttests(in []string) (map[string]*string, error) {
+func ParseAttests(in []string) ([]*controllerapi.Attest, error) {
-	out := map[string]*string{}
+	out := []*controllerapi.Attest{}
+	found := map[string]struct{}{}
 	for _, in := range in {
 		in := in
-		attestType, enabled, err := parseAttest(in)
+		attest, err := parseAttest(in)
 		if err != nil {
 			return nil, err
 		}
 
-		k := "attest:" + attestType
+		if _, ok := found[attest.Type]; ok {
-		if _, ok := out[k]; ok {
+			return nil, errors.Errorf("duplicate attestation field %s", attest.Type)
-			return nil, errors.Errorf("duplicate attestation field %s", attestType)
-		}
-		if enabled {
-			out[k] = &in
-		} else {
-			out[k] = nil
 		}
+		found[attest.Type] = struct{}{}
+
+		out = append(out, attest)
 	}
 	return out, nil
 }
 
-func parseAttest(in string) (string, bool, error) {
+func parseAttest(in string) (*controllerapi.Attest, error) {
 	if in == "" {
-		return "", false, nil
+		return nil, nil
 	}
 
 	csvReader := csv.NewReader(strings.NewReader(in))
 	fields, err := csvReader.Read()
 	if err != nil {
-		return "", false, err
+		return nil, err
 	}
 
-	attestType := ""
+	attest := controllerapi.Attest{
-	enabled := true
+		Attrs: in,
+	}
 	for _, field := range fields {
 		key, value, ok := strings.Cut(field, "=")
 		if !ok {
-			return "", false, errors.Errorf("invalid value %s", field)
+			return nil, errors.Errorf("invalid value %s", field)
 		}
 		key = strings.TrimSpace(strings.ToLower(key))
 
 		switch key {
 		case "type":
-			attestType = value
+			attest.Type = value
-		case "enabled":
+		case "disabled":
-			enabled, err = strconv.ParseBool(value)
+			disabled, err := strconv.ParseBool(value)
 			if err != nil {
-				return "", false, err
+				return nil, errors.Wrapf(err, "invalid value %s", field)
 			}
+			attest.Disabled = disabled
 		}
 	}
-	if attestType == "" {
+	if attest.Type == "" {
-		return "", false, errors.Errorf("attestation type not specified")
+		return nil, errors.Errorf("attestation type not specified")
 	}
 
-	return attestType, enabled, nil
+	return &attest, nil
 }