evidence

type AttestRequest struct {
	// Subject is the OCI manifest digest the statement is about.
	Subject bundle.Digest
	// Statement is the statement to sign. The service builds it; an attester
	// supplies identity and signatures, and must not alter the payload.
	Statement *Statement
	// PayloadType is the DSSE payload type to sign under.
	PayloadType string
	// Payload is the exact serialized statement to sign. Signing these
	// bytes rather than re-serializing the statement is what guarantees the
	// signature covers what the envelope carries.
	Payload []byte
}

type Attester interface {
	// Name identifies the attester in diagnostics and results.
	Name() string
	// Attest returns signatures over the request's payload.
	Attest(ctx context.Context, req AttestRequest) ([]Signature, error)
}

type BuildDefinition struct {
	BuildType            string               `json:"buildType"`
	ExternalParameters   map[string]any       `json:"externalParameters"`
	InternalParameters   map[string]any       `json:"internalParameters,omitempty"`
	ResolvedDependencies []ResourceDescriptor `json:"resolvedDependencies,omitempty"`
}

type Builder struct {
	ID      string            `json:"id"`
	Version map[string]string `json:"version,omitempty"`
}

type DevProofProvenance struct {
	// FormatVersion is the bundle format the subject was built as.
	FormatVersion string `json:"formatVersion"`
	// ManifestDigest identifies the manifest that was built from.
	ManifestDigest string `json:"manifestDigest"`
	// LockDigest identifies the lock that was enforced or generated.
	LockDigest string `json:"lockDigest"`
	// TreeDigest is the payload identity, independent of encoding.
	TreeDigest string `json:"treeDigest"`
	// Sources describes each source's resolution.
	Sources []SourceProvenance `json:"sources"`
	// ToolVersion is the DevProof version that built the subject. It is
	// diagnostic: it never affects the subject digest (DP-012).
	ToolVersion string `json:"toolVersion,omitempty"`
}

type Envelope struct {
	PayloadType string      `json:"payloadType"`
	Payload     string      `json:"payload"`
	Signatures  []Signature `json:"signatures"`
}

type Identity struct {
	// KeyID identifies a bare public key.
	KeyID string `json:"keyId,omitempty"`
	// Issuer is the OIDC issuer, for a keyless identity.
	Issuer string `json:"issuer,omitempty"`
	// Subject is the OIDC subject, for a keyless identity.
	Subject string `json:"subject,omitempty"`
}

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

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

type Predicate struct {
	// BuildDefinition and RunDetails are SLSA Provenance v1, verbatim.
	BuildDefinition BuildDefinition `json:"buildDefinition"`
	RunDetails      RunDetails      `json:"runDetails"`

	// DevProof carries what SLSA cannot express.
	DevProof DevProofProvenance `json:"devproof"`
}

type ResourceDescriptor struct {
	Name        string            `json:"name,omitempty"`
	URI         string            `json:"uri,omitempty"`
	Digest      map[string]string `json:"digest,omitempty"`
	Annotations map[string]any    `json:"annotations,omitempty"`
}

type RunDetails struct {
	Builder  Builder     `json:"builder"`
	Metadata RunMetadata `json:"metadata,omitzero"`
}

type RunMetadata struct {
	InvocationID string     `json:"invocationId,omitempty"`
	StartedOn    *time.Time `json:"startedOn,omitempty"`
	FinishedOn   *time.Time `json:"finishedOn,omitempty"`
}

type Signature struct {
	// KeyID identifies the signing key or identity. Its meaning is the
	// attester's; policy matches on the verified identity, not on this.
	KeyID string `json:"keyid,omitempty"`
	// Sig is the base64 signature.
	Sig string `json:"sig"`
	// Certificate is the PEM signing certificate, when the attester uses
	// one. Present for keyless identities, absent for bare keys.
	Certificate string `json:"cert,omitempty"`
}

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

type SigstoreOptions struct {
	// FulcioURL issues the short-lived signing certificate. Empty uses the
	// public instance.
	FulcioURL string
	// RekorURL records the signature in a transparency log. Empty uses the
	// public instance.
	RekorURL string
	// IDToken is an OIDC identity token. Empty uses ambient detection.
	IDToken string
	// IDTokenProvider supplies a token on demand. Takes precedence over
	// IDToken, so a long-running process can refresh rather than hold one.
	IDTokenProvider func(ctx context.Context) (string, error)
	// TrustedRootJSON is a caller-supplied Sigstore trusted root. Empty
	// fetches and caches the public root over TUF.
	//
	// Supplying one is what makes offline verification possible: no network,
	// and trust material that came from somewhere the caller chose.
	TrustedRootJSON []byte
	// Timeout bounds a single network call to Fulcio or Rekor.
	Timeout time.Duration
}

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

type SourceProvenance struct {
	// Name is the logical source name from the manifest.
	Name string `json:"name"`
	// Type is the source type, such as "git" or "path".
	Type string `json:"type"`
	// Resolver identifies the implementation and version that resolved it,
	// so a resolver whose behavior changed is visible to policy.
	Resolver string `json:"resolver"`
	// Requested is what the manifest asked for, which may be mutable.
	Requested map[string]any `json:"requested,omitempty"`
	// Resolved is what it resolved to, which is not.
	Resolved map[string]any `json:"resolved,omitempty"`
	// TreeDigest is this source's filtered contribution, before mounting.
	TreeDigest string `json:"treeDigest"`
	// MountPath is where the contribution was placed.
	MountPath string `json:"mountPath,omitempty"`
}

type Statement struct {
	Type          string    `json:"_type"`
	Subject       []Subject `json:"subject"`
	PredicateType string    `json:"predicateType"`
	Predicate     Predicate `json:"predicate"`
}

type Subject struct {
	// Name is a label. It is not identity and is not matched against
	// anything; the digest is.
	Name string `json:"name,omitempty"`
	// Digest maps an algorithm to a hex value, per the in-toto spec.
	Digest map[string]string `json:"digest"`
}

type VerificationResult struct {
	// Identities are the signers whose signatures verified. An empty slice
	// with a nil error is a contradiction a verifier must not produce.
	Identities []Identity
	// TransparencyLogVerified reports whether inclusion in a transparency
	// log was proven. Policy may require it; absence is not an error here.
	TransparencyLogVerified bool
	// IntegratedTime is an authenticated signing time, when one was
	// established. A verifier must not populate it from the envelope or from
	// the local clock — an unauthenticated time cannot satisfy a rule that
	// requires one.
	IntegratedTime *int64
}

type Verifier interface {
	// Name identifies the verifier in diagnostics and results.
	Name() string
	// Verify checks an envelope's signatures.
	Verify(ctx context.Context, req VerifyRequest) (*VerificationResult, error)
}

type VerifyRequest struct {
	// Envelope is the DSSE envelope to verify.
	Envelope *Envelope
	// Payload is the decoded payload the signatures must cover.
	Payload []byte
	// BundleJSON is the stored evidence blob, when the object is a Sigstore
	// bundle. A keyless verifier needs the whole bundle — certificate,
	// transparency-log entry, timestamps — not just the envelope.
	BundleJSON []byte
	// TrustRoots is caller-supplied trust material. Its format is the
	// verifier's; the SDK never interprets it.
	TrustRoots [][]byte
}