Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

5.9 KB
Raw Blame
package api

import (
	"context"
	"io"
	"net/http"
	"strings"
	"sync"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/config"
)

// retainTokenStreamAuthority runs AFTER the route's auth/admin/scope gates.
// Recheck the admitted credential at the actual writer, not just when an event
// is produced: replay and queued broadcasts can otherwise disclose after a
// credential is withdrawn. Session withdrawal is checked too; other
// authentication policy stays with the route.
func retainTokenStreamAuthority(cfg *config.Config, scope string, instanceAdmin bool, next http.HandlerFunc) http.HandlerFunc {
	return retainTokenStreamAuthorityForScopes(cfg, []string{scope}, instanceAdmin, next)
}

func retainTokenStreamAuthorityForScopes(cfg *config.Config, scopes []string, instanceAdmin bool, next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		revalidate := tokenStreamSnapshotRevalidator(cfg, r, scopes...)
		sessionAllowed := combineAuthorization(sessionReadRevalidator(r), orgAccessRevalidator(r))
		allowed := func() bool {
			if revalidate == nil {
				// Proxy/basic/bypass admission stays with the route. A
				// session read retains its exact admitted session instance,
				// and a signed-in user keeps the organization access policy.
				return sessionAllowed == nil || sessionAllowed()
			}
			current, ok := revalidate()
			return ok && (!instanceAdmin || tokenActsForInstance(current))
		}
		if !allowed() {
			http.Error(w, "Authentication required", http.StatusUnauthorized)
			return
		}
		flusher, ok := w.(http.Flusher)
		if !ok {
			// Do not turn a non-streaming writer into a streaming one. Leave
			// the handler's existing unsupported-transport response intact.
			next(w, r)
			return
		}

		// Only this read is cancelled. Updaters, Patrol runs and deployment
		// jobs retain their own lifetime; withdrawal is not a cancel action.
		ctx, cancel := context.WithCancel(r.Context())
		writer := &tokenStreamWriter{writer: w, flusher: flusher, ctx: ctx, cancel: cancel, allowed: allowed}
		watchDone := make(chan struct{})
		watch := func() {
			defer close(watchDone)
			ticker := time.NewTicker(15 * time.Second)
			defer ticker.Stop()
			for {
				select {
				case <-ctx.Done():
					return
				case <-ticker.C:
					if !writer.check() {
						return
					}
				}
			}
		}
		if revalidate != nil || sessionAllowed != nil {
			go watch()
		} else {
			// No new periodic authentication checks for other credentials.
			close(watchDone)
		}
		defer func() {
			// Join any in-flight broadcaster write before returning the HTTP
			// writer, and reject queued writes even after handler cleanup.
			writer.close()
			<-watchDone
		}()
		next(writer, r.WithContext(ctx))
	}
}

// tokenStreamWriter deliberately exposes no Unwrap/ReaderFrom escape around
// the guard. It serializes writes, flushes, idle checks and final closure;
// update broadcasts use a different goroutine from the HTTP handler.
type tokenStreamWriter struct {
	writer  http.ResponseWriter
	flusher http.Flusher
	ctx     context.Context
	cancel  context.CancelFunc
	allowed func() bool
	mu      sync.Mutex
	closed  bool
	started bool
}

func (w *tokenStreamWriter) Header() http.Header { return w.writer.Header() }

// Forward deadline control without exposing Unwrap, which would also let a
// caller bypass the disclosure guard. Assistant streams clear the server's
// initial deadlines and bound every subsequent write, including heartbeats.
func (w *tokenStreamWriter) SetWriteDeadline(deadline time.Time) error {
	w.mu.Lock()
	defer w.mu.Unlock()
	if !w.checkLocked() {
		return io.ErrClosedPipe
	}
	return http.NewResponseController(w.writer).SetWriteDeadline(deadline)
}

func (w *tokenStreamWriter) SetReadDeadline(deadline time.Time) error {
	w.mu.Lock()
	defer w.mu.Unlock()
	if !w.checkLocked() {
		return io.ErrClosedPipe
	}
	return http.NewResponseController(w.writer).SetReadDeadline(deadline)
}

func (w *tokenStreamWriter) checkLocked() bool {
	if w.closed {
		return false
	}
	if w.ctx.Err() != nil || !w.allowed() {
		w.closed = true
		w.cancel()
		return false
	}
	return true
}

func (w *tokenStreamWriter) check() bool {
	w.mu.Lock()
	defer w.mu.Unlock()
	return w.checkLocked()
}

// All guarded stream routes carry SSE data or structured/plain errors. Pin
// their media before any operation can commit the transport, including Flush.
func (w *tokenStreamWriter) prepareMediaLocked() string {
	header := w.writer.Header()
	contentType := responseContentType(header, responseMediaEventStream)
	for key := range header {
		if strings.EqualFold(key, "Content-Type") || strings.EqualFold(key, "X-Content-Type-Options") {
			delete(header, key)
		}
	}
	return contentType
}

func (w *tokenStreamWriter) Write(p []byte) (int, error) {
	w.mu.Lock()
	defer w.mu.Unlock()
	if !w.checkLocked() {
		return 0, io.ErrClosedPipe
	}
	if !w.started {
		contentType := w.prepareMediaLocked()
		w.writer.Header().Set("Content-Type", contentType)
		w.writer.Header().Set("X-Content-Type-Options", "nosniff")
		w.started = true
	}
	n, err := w.writer.Write(p)
	if err != nil {
		w.closed = true
		w.cancel()
	}
	return n, err
}

func (w *tokenStreamWriter) WriteHeader(status int) {
	w.mu.Lock()
	defer w.mu.Unlock()
	if w.checkLocked() {
		if !w.started {
			contentType := w.prepareMediaLocked()
			w.writer.Header().Set("Content-Type", contentType)
			w.writer.Header().Set("X-Content-Type-Options", "nosniff")
			w.started = status >= 200 || status == http.StatusSwitchingProtocols
		}
		w.writer.WriteHeader(status)
	}
}

func (w *tokenStreamWriter) Flush() {
	w.mu.Lock()
	defer w.mu.Unlock()
	if w.checkLocked() {
		if !w.started {
			contentType := w.prepareMediaLocked()
			w.writer.Header().Set("Content-Type", contentType)
			w.writer.Header().Set("X-Content-Type-Options", "nosniff")
			w.started = true
		}
		w.flusher.Flush()
	}
}

func (w *tokenStreamWriter) close() {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.closed = true
	w.cancel()
}