Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

4.0 KB
Raw Blame
package api

import (
	"context"
	"log/slog"

	"github.com/pkg/errors"

	"github.com/usememos/memos/internal/clientip"
	"github.com/usememos/memos/internal/ratelimit"
	"github.com/usememos/memos/server/auth"
	"github.com/usememos/memos/store"
)

// ErrUnauthenticated is returned by the Authorizer when a request must be rejected
// for lack of valid credentials. Each transport maps it to its own status code
// (Connect: CodeUnauthenticated, gRPC-Gateway: HTTP 401).
var ErrUnauthenticated = errors.New("authentication required")

// Authorizer is the single source of truth for method-level access control.
//
// It authenticates a request from its Authorization header and decides whether the
// (possibly anonymous) caller may reach a given RPC procedure. The Connect
// interceptor and the gRPC-Gateway middleware share one Authorizer so both
// transports enforce identical rules.
//
// Role-based authorization (admin checks) stays in the service layer; this type
// governs only authentication and anonymous access.
type Authorizer struct {
	authenticator *auth.Authenticator
	accessStore   anonymousAccessStore
	limiter       ratelimit.Limiter
}

type anonymousAccessStore interface {
	AllowsAnonymousAccess(ctx context.Context) (bool, error)
}

// NewAuthorizer creates an Authorizer backed by the given store and token secret.
func NewAuthorizer(store *store.Store, secret string) *Authorizer {
	return &Authorizer{
		authenticator: auth.NewAuthenticator(store, secret),
		accessStore:   store,
	}
}

// WithRateLimiter enables the catch-all request budgets. A nil limiter leaves
// every request unbounded.
func (a *Authorizer) WithRateLimiter(limiter ratelimit.Limiter) *Authorizer {
	a.limiter = limiter
	return a
}

// Throttle enforces the catch-all budget for a request that CheckAccess has
// already permitted: the authenticated budget keyed by user, or the anonymous
// budget keyed by client address. Every request costs one unit; batch
// handlers add their item count afterwards. It returns a RESOURCE_EXHAUSTED
// status when the budget is spent.
func (a *Authorizer) Throttle(ctx context.Context, _ string, result *auth.AuthResult) error {
	if a.limiter == nil {
		return nil
	}
	scope, key := ratelimit.ScopeAnonymous, clientip.FromContext(ctx)
	switch {
	case result == nil:
	case result.Claims != nil:
		scope, key = ratelimit.ScopeAuthenticated, userKey(result.Claims.UserID)
	case result.User != nil:
		scope, key = ratelimit.ScopeAuthenticated, userKey(result.User.ID)
	default:
	}
	if key == "" {
		return nil
	}
	decision := a.limiter.Consume(scope, key, 1)
	if !decision.Allowed {
		slog.Info("rate limit refused request", slog.String("scope", string(scope)), slog.String("key", key))
		return newRateLimitError(scope, decision)
	}
	return nil
}

// Authenticate resolves the caller from the Authorization header, returning nil for
// an anonymous request. It never enforces policy — pair it with CheckAccess.
func (a *Authorizer) Authenticate(ctx context.Context, authHeader string) *auth.AuthResult {
	return a.authenticator.Authenticate(ctx, authHeader)
}

// CheckAccess enforces method-level access policy for procedure given the
// authentication result (nil = anonymous). It returns nil when the request is
// permitted and ErrUnauthenticated otherwise.
//
// Policy:
//   - Authenticated caller (access token or PAT): always permitted here.
//   - Anonymous + protected method: denied.
//   - Anonymous + auth-bootstrap method: permitted on every instance.
//   - Anonymous + other public method: permitted only when the stored access mode
//     is PUBLIC.
func (a *Authorizer) CheckAccess(ctx context.Context, procedure string, result *auth.AuthResult) error {
	if result != nil {
		return nil
	}
	if !IsPublicMethod(procedure) {
		return ErrUnauthenticated
	}
	if IsAuthBootstrapMethod(procedure) {
		return nil
	}
	allowsAnonymous, err := a.accessStore.AllowsAnonymousAccess(ctx)
	if err != nil {
		return errors.Wrap(err, "failed to resolve instance access policy")
	}
	if allowsAnonymous {
		return nil
	}
	return ErrUnauthenticated
}