You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

193 lines
5.8 KiB
Go

// Package protocol implements the authenticated wire protocol shared by PHP
// and the Agent Gateway.
package protocol
import (
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"regexp"
"strconv"
"strings"
"time"
)
const (
HeaderTimestamp = "X-Virt-Timestamp"
HeaderNonce = "X-Virt-Nonce"
HeaderBodyDigest = "X-Virt-Content-SHA256"
HeaderActor = "X-Virt-Actor"
HeaderSignature = "X-Virt-Signature"
)
var (
noncePattern = regexp.MustCompile(`^[A-Za-z0-9_-]{16,128}$`)
hexPattern = regexp.MustCompile(`^[0-9a-f]{64}$`)
ErrAuth = errors.New("request authentication failed")
ErrReplay = errors.New("request nonce was already used")
ErrNonceStore = errors.New("request nonce store unavailable")
)
// Actor is deliberately small. Public callers never choose service identities;
// each authenticated endpoint pins the exact service value it accepts.
type Actor struct {
UserID int64 `json:"user_id,omitempty"`
IsAdmin bool `json:"is_admin,omitempty"`
IsSuperAdmin bool `json:"is_super_admin,omitempty"`
CanManage bool `json:"can_manage,omitempty"`
Service string `json:"service,omitempty"`
}
type NonceStore interface {
UseNonce(nonce string, now, expiresAt time.Time) (bool, error)
}
type Authenticator struct {
secret []byte
skew time.Duration
ttl time.Duration
now func() time.Time
store NonceStore
}
func NewAuthenticator(secret []byte, skew, ttl time.Duration, store NonceStore) (*Authenticator, error) {
if len(secret) < 32 {
return nil, errors.New("HMAC secret must contain at least 32 bytes")
}
if skew <= 0 || ttl < skew || store == nil {
return nil, errors.New("invalid HMAC replay settings")
}
return &Authenticator{secret: append([]byte(nil), secret...), skew: skew, ttl: ttl, now: time.Now, store: store}, nil
}
func (a *Authenticator) SetClockForTesting(now func() time.Time) { a.now = now }
func BodyDigest(body []byte) string {
digest := sha256.Sum256(body)
return hex.EncodeToString(digest[:])
}
func RequestTarget(r *http.Request) string {
path := r.URL.EscapedPath()
if path == "" {
path = "/"
}
if r.URL.RawQuery != "" {
return path + "?" + r.URL.RawQuery
}
return path
}
func Canonical(method, target, digest, timestamp, nonce, actor string) string {
return strings.ToUpper(method) + "\n" + target + "\n" + strings.ToLower(digest) + "\n" +
timestamp + "\n" + nonce + "\n" + actor
}
func Signature(secret []byte, canonical string) string {
mac := hmac.New(sha256.New, secret)
_, _ = mac.Write([]byte(canonical))
return hex.EncodeToString(mac.Sum(nil))
}
func RandomNonce() (string, error) {
value := make([]byte, 16)
if _, err := rand.Read(value); err != nil {
return "", fmt.Errorf("generate nonce: %w", err)
}
return hex.EncodeToString(value), nil
}
func Sign(r *http.Request, body []byte, actor Actor, secret []byte, timestamp time.Time, nonce string) error {
if len(secret) < 32 || !noncePattern.MatchString(nonce) {
return errors.New("invalid signing parameters")
}
actorJSON, err := json.Marshal(actor)
if err != nil {
return err
}
actorHeader := base64.RawURLEncoding.EncodeToString(actorJSON)
digest := BodyDigest(body)
ts := strconv.FormatInt(timestamp.Unix(), 10)
r.Header.Set(HeaderTimestamp, ts)
r.Header.Set(HeaderNonce, nonce)
r.Header.Set(HeaderBodyDigest, digest)
r.Header.Set(HeaderActor, actorHeader)
r.Header.Set(HeaderSignature, Signature(secret, Canonical(r.Method, RequestTarget(r), digest, ts, nonce, actorHeader)))
return nil
}
func (a *Authenticator) Authenticate(r *http.Request, body []byte) (Actor, error) {
for _, name := range []string{HeaderTimestamp, HeaderNonce, HeaderBodyDigest, HeaderActor, HeaderSignature} {
values := r.Header.Values(name)
if len(values) != 1 || strings.Contains(values[0], ",") {
return Actor{}, ErrAuth
}
}
timestamp := r.Header.Get(HeaderTimestamp)
nonce := r.Header.Get(HeaderNonce)
digest := r.Header.Get(HeaderBodyDigest)
actorHeader := r.Header.Get(HeaderActor)
signature := r.Header.Get(HeaderSignature)
if !noncePattern.MatchString(nonce) || !hexPattern.MatchString(digest) ||
!hexPattern.MatchString(signature) || actorHeader == "" || len(actorHeader) > 4096 {
return Actor{}, ErrAuth
}
seconds, err := strconv.ParseInt(timestamp, 10, 64)
if err != nil || strconv.FormatInt(seconds, 10) != timestamp {
return Actor{}, ErrAuth
}
now := a.now().UTC()
requestedAt := time.Unix(seconds, 0)
if requestedAt.Before(now.Add(-a.skew)) || requestedAt.After(now.Add(a.skew)) {
return Actor{}, ErrAuth
}
if subtle.ConstantTimeCompare([]byte(BodyDigest(body)), []byte(digest)) != 1 {
return Actor{}, ErrAuth
}
expected := Signature(a.secret, Canonical(r.Method, RequestTarget(r), digest, timestamp, nonce, actorHeader))
if subtle.ConstantTimeCompare([]byte(expected), []byte(signature)) != 1 {
return Actor{}, ErrAuth
}
actor, err := decodeActor(actorHeader)
if err != nil {
return Actor{}, ErrAuth
}
accepted, err := a.store.UseNonce(nonce, now, now.Add(a.ttl))
if err != nil {
return Actor{}, fmt.Errorf("%w: %v", ErrNonceStore, err)
}
if !accepted {
return Actor{}, ErrReplay
}
return actor, nil
}
func decodeActor(value string) (Actor, error) {
raw, err := base64.RawURLEncoding.DecodeString(value)
if err != nil {
return Actor{}, err
}
decoder := json.NewDecoder(strings.NewReader(string(raw)))
decoder.DisallowUnknownFields()
var actor Actor
if err := decoder.Decode(&actor); err != nil {
return Actor{}, err
}
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
return Actor{}, errors.New("actor contains trailing data")
}
if actor.UserID < 0 || (actor.Service != "" && actor.Service != "agent-gateway" &&
actor.Service != "php-panel") {
return Actor{}, errors.New("invalid actor")
}
return actor, nil
}