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
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
|
|
}
|