dpop

type JWK struct {
	Kty string `json:"kty"`           // Key type (EC)
	Crv string `json:"crv"`           // Curve (P-256)
	X   string `json:"x"`             // X coordinate
	Y   string `json:"y"`             // Y coordinate
	Alg string `json:"alg,omitempty"` // Algorithm (ES256)
}

type KeyPair struct {
	// PrivateKey is the ECDSA private key for signing proofs.
	PrivateKey *ecdsa.PrivateKey
	// Thumbprint is the JWK thumbprint (RFC 7638) of the public key.
	Thumbprint string
}

type MiddlewareConfig struct {
	// Verifier is the DPoP verifier to use.
	Verifier *Verifier
	// RequireDPoP when true rejects requests without DPoP proofs.
	// When false, requests without DPoP proofs are allowed through.
	RequireDPoP bool
	// ExtractAccessToken is a function to extract the access token from the request.
	// If nil, the middleware extracts from the Authorization header.
	ExtractAccessToken func(r *http.Request) string
	// OnError is called when verification fails.
	// If nil, a 401 Unauthorized response is sent.
	OnError func(w http.ResponseWriter, r *http.Request, err error)
}

type ParsedProof struct {
	// Claims contains the proof claims.
	Claims *ProofClaims
	// PublicKey is the public key extracted from the jwk header.
	PublicKey *ecdsa.PublicKey
	// Thumbprint is the JWK thumbprint of the public key.
	Thumbprint string
}

type ProofClaims struct {
	jwt.RegisteredClaims

	// HTTPMethod is the HTTP method of the request (htm claim).
	// REQUIRED. The value of the HTTP method of the request to which the JWT is attached.
	HTTPMethod string `json:"htm"`

	// HTTPURI is the HTTP URI of the request (htu claim).
	// REQUIRED. The HTTP target URI, without query and fragment parts.
	HTTPURI string `json:"htu"`

	// AccessTokenHash is the base64url-encoded SHA-256 hash of the access token (ath claim).
	// REQUIRED when the DPoP proof is sent with a request for a protected resource.
	AccessTokenHash string `json:"ath,omitempty"`

	// Nonce is the server-provided nonce value (nonce claim).
	// Used for replay protection when the server issues nonces.
	Nonce string `json:"nonce,omitempty"`
}

type ProofHeader struct {
	Algorithm string `json:"alg"` // Algorithm (ES256, ES384, ES512)
	Type      string `json:"typ"` // MUST be "dpop+jwt"
	JWK       *JWK   `json:"jwk"` // Public key
}

type ProofOptions struct {
	// AccessToken is the access token to bind to the proof (for ath claim).
	AccessToken string //nolint:gosec // G117: field holds runtime token value
	// Nonce is a server-provided nonce for replay protection.
	Nonce string
}

type SerializedKeyPair struct {
	PrivateKeyD string `json:"d"`          // Private key scalar
	PublicKeyX  string `json:"x"`          // Public key X coordinate
	PublicKeyY  string `json:"y"`          // Public key Y coordinate
	Curve       string `json:"crv"`        // Curve name
	Thumbprint  string `json:"thumbprint"` // JWK thumbprint
}

type VerificationConfig struct {
	// MaxAge is the maximum age of a DPoP proof (based on iat claim).
	// Default: 5 minutes.
	MaxAge time.Duration

	// AllowedClockSkew is the maximum clock skew to allow when validating iat.
	// Default: 30 seconds.
	AllowedClockSkew time.Duration

	// RequireAccessTokenBinding when true requires the ath claim to be present
	// and match the provided access token hash.
	RequireAccessTokenBinding bool

	// NonceValidator is an optional function to validate server-provided nonces.
	// If set and returns an error, verification fails with ErrNonceMismatch.
	NonceValidator func(ctx context.Context, nonce string) error
}

type VerificationRequest struct {
	// Proof is the DPoP proof JWT string.
	Proof string
	// Method is the HTTP method of the request (e.g., "POST").
	Method string
	// URI is the HTTP URI of the request (scheme + host + path, no query or fragment).
	URI string
	// AccessToken is the access token to verify binding against (optional).
	// Required if VerificationConfig.RequireAccessTokenBinding is true.
	AccessToken string //nolint:gosec // G117: field holds runtime token value
	// ExpectedNonce is the expected server-provided nonce (optional).
	ExpectedNonce string
}

type VerificationResult struct {
	// Thumbprint is the JWK thumbprint of the public key used to sign the proof.
	Thumbprint string
	// JTI is the unique identifier of the proof.
	JTI string
	// IssuedAt is when the proof was created.
	IssuedAt time.Time
}

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