sig

type Algorithm string

type Bundle struct {
	// MediaType identifies this as a docker-security verification bundle.
	MediaType string `json:"mediaType"`
	// SubjectDigest is the image manifest digest ("sha256:<hex>") the entries
	// pertain to. Verifiers cross-check this against the digest under test.
	SubjectDigest string `json:"subjectDigest"`
	// Entries holds the signatures/attestations.
	Entries []BundleEntry `json:"entries"`
}

type BundleEntry struct {
	// Kind is "signature" or "attestation" (informational; verification keys off
	// the envelope's payload type, not this tag).
	Kind string `json:"kind"`
	// Envelope is the DSSE envelope.
	Envelope *Envelope `json:"envelope"`
	// Inclusion is the transparency-log proof for Envelope, if logged.
	Inclusion *InclusionRecord `json:"inclusion,omitempty"`
}

type Checkpoint struct {
	// LogID identifies the log instance (hex SHA-256 of its public key).
	LogID string `json:"log_id"`
	Size  int    `json:"size"`
	// RootHash is the hex Merkle root over the first Size entries.
	RootHash string `json:"root_hash"`
	// Signature is the log key's signature over the canonical checkpoint body.
	Signature string `json:"signature"` // base64
}

type CosignIdentity struct {
	// SubjectID is the SAN identity: an email, a SPIFFE ID, or a URI (e.g. a
	// GitHub Actions workflow ref). It is what a policy's certificate-identity is
	// matched against.
	SubjectID string
	// Issuer is the OIDC issuer URL from the Fulcio extension (e.g.
	// "https://token.actions.githubusercontent.com").
	Issuer string
	// NotBefore/NotAfter are the certificate's validity window.
	NotBefore, NotAfter time.Time
}

type CosignPolicy struct {
	// CertificateIdentity, if set, must equal the certificate SAN identity, or —
	// when it ends with "*" — be a prefix match (for workflow-ref families).
	CertificateIdentity string
	// CertificateOIDCIssuer, if set, must equal the certificate's OIDC issuer.
	CertificateOIDCIssuer string
}

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

type Critical struct {
	Identity CriticalIdentity `json:"identity"`
	Image    CriticalImage    `json:"image"`
	Type     string           `json:"type"`
}

type CriticalIdentity struct {
	DockerReference string `json:"docker-reference"`
}

type CriticalImage struct {
	DockerManifestDigest string `json:"docker-manifest-digest"`
}

type Envelope struct {
	// Payload is the base64 (standard, padded) encoding of the raw payload.
	Payload string `json:"payload"`
	// PayloadType is the payload's type URI (e.g. an in-toto or simple-signing
	// media type). It is authenticated: it is part of the signed PAE.
	PayloadType string `json:"payloadType"`
	// Signatures holds one entry per signer.
	Signatures []Signature `json:"signatures"`
}

type InclusionRecord struct {
	Entry      LogEntry   `json:"entry"`
	Checkpoint Checkpoint `json:"checkpoint"`
	// Proof is the audit path (bottom-up sibling hashes), hex-encoded.
	Proof []string `json:"proof"`
}

type LogEntry struct {
	Index int    `json:"index"`
	Hash  string `json:"hash"` // hex SHA-256 of the logged bytes
}

type Policy struct {
	// Identities, if non-empty, is the allow-list of acceptable signer
	// identities. A signer whose identity is not listed fails ErrPolicy.
	Identities []string
	// Issuers, if non-empty, is the allow-list of acceptable OIDC issuers/CAs.
	Issuers []string
}

type PolicyConfig struct {
	Identities []string `json:"identities,omitempty"`
	Issuers    []string `json:"issuers,omitempty"`
}

type Signature struct {
	// KeyID identifies the signing key (content-addressed; see KeyID).
	KeyID string `json:"keyid,omitempty"`
	// Sig is the base64 (standard, padded) signature over the PAE.
	Sig string `json:"sig"`
}

type Signer interface {
	// Sign returns a signature over msg. For ed25519 msg is signed directly; for
	// ECDSA msg is hashed with SHA-256 first. Callers pass the raw message (e.g.
	// a DSSE PAE), not a pre-hash.
	Sign(msg []byte) ([]byte, error)
	// Verifier returns the public verifier matching this signer.
	Verifier() Verifier
	// KeyID is the content-addressed identifier of the public key.
	KeyID() string
	// Algorithm reports the signature scheme.
	Algorithm() Algorithm
}

type SimpleSigning struct {
	Critical Critical          `json:"critical"`
	Optional map[string]string `json:"optional,omitempty"`
}

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

type TrustConfig struct {
	Keys   []TrustConfigKey `json:"keys"`
	Policy PolicyConfig     `json:"policy,omitempty"`
}

type TrustConfigKey struct {
	// PublicKeyPEM is a PKIX PEM public key.
	PublicKeyPEM string `json:"public_key_pem"`
	Identity     string `json:"identity,omitempty"`
	Issuer       string `json:"issuer,omitempty"`
}

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

type TrustedKey struct {
	Verifier Verifier
	// Identity is the signer identity (email, SPIFFE ID, or builder URI).
	Identity string
	// Issuer is the OIDC issuer or CA that vouches for the identity, if any.
	Issuer string
}

type Verifier interface {
	// Verify returns nil if sig is a valid signature over msg for this key, and
	// an error wrapping ErrVerify otherwise.
	Verify(msg, sig []byte) error
	// KeyID is the content-addressed identifier of the public key.
	KeyID() string
	// Algorithm reports the signature scheme.
	Algorithm() Algorithm
	// PublicKey returns the underlying crypto.PublicKey, for serialization.
	PublicKey() crypto.PublicKey
}

type VerifyResult struct {
	// KeyID is the trusted key that verified the envelope.
	KeyID string
	// Identity and Issuer are the labels bound to that key.
	Identity string
	Issuer   string
}