0
0
package requester
import (
"context"
"errors"
"fmt"
"net/http"
"regexp"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/cloudinit"
"github.com/johnandersen777/socialweb-computer-kcp/internal/sshtransport"
)
const (
SessionAtircEnv = "LC_ATIRC"
sessionAtircTokenEnv = "LC_ATIRC_TOKEN"
sessionAtircLabel = "ssh"
sessionAtircBinaryWaitSec = 180
sessionAgentCommand = "atirc agent run"
maxAtircSubhandle = 253
)
var atircSubhandleLabel = regexp.MustCompile(`^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$`)
type sessionAtirc struct {
token string
subhandle string
}
func sessionWantsAtirc(command string, lc map[string]string) bool {
if value, set := lc[SessionAtircEnv]; set {
return truthy(value)
}
fields := strings.Fields(command)
return len(fields) > 0 && fields[0] == "atirc"
}
func sessionAgentRun(command string) (string, bool) {
fields := strings.Fields(command)
if len(fields) != 4 || fields[0] != "atirc" || fields[1] != "agent" || fields[2] != "run" {
return "", false
}
return fields[3], true
}
func agentSubhandle(sub, handle string) (string, error) {
handle = strings.ToLower(strings.TrimSpace(handle))
if handle == "" {
return "", errors.New("the requester identity has no handle")
}
value := strings.ToLower(sub)
if value != handle && !strings.HasSuffix(value, "."+handle) {
value += "." + handle
}
bad := len(value) > maxAtircSubhandle
for _, label := range strings.Split(value, ".") {
bad = bad || !atircSubhandleLabel.MatchString(label)
}
if bad {
return "", fmt.Errorf("%q is not a subhandle atirc takes; use DNS labels of letters, digits and '-' below %s", sub, handle)
}
return value, nil
}
func sessionAtircUserData(userData string) (string, error) {
return cloudinit.BuildUserData(cloudinit.BuildOptions{Base: userData,
Modules: []any{cloudinit.AgentModule(cloudinit.AgentOptions{})}})
}
func atircCommand(command string) string {
if strings.TrimSpace(command) == "" {
return command
}
return fmt.Sprintf("i=0; while { [ ! -x %s ] || [ ! -x %s ]; } && [ \"$i\" -lt %d ]; do sleep 1; i=$((i+1)); done; export %s=\"$%s\"; unset %s; exec %s %s",
cloudinit.AtircBinary, cloudinit.AgentExecPath, sessionAtircBinaryWaitSec, AtircTokenEnv, sessionAtircTokenEnv, sessionAtircTokenEnv,
cloudinit.AgentExecPath, "'"+strings.ReplaceAll(command, "'", "'\"'\"'")+"'")
}
func (q *Requester) sessionAtircLifetime() time.Duration {
if q.cfg.SessionCap > 0 && q.cfg.SessionCap < AtircTokenLifetime {
return q.cfg.SessionCap
}
return AtircTokenLifetime
}
func (q *Requester) mintSessionAtirc(ctx context.Context, state *v1alpha1.NodeClaimContract, agent string) (*sessionAtirc, error) {
lease, err := contractLease(state, nil)
if err != nil {
return nil, err
}
issuer, err := q.serviceAtircIssuer(ctx)
if err != nil {
return nil, err
}
subhandle := agent
if subhandle == "" {
subhandle = atircChild(sessionAtircLabel, uriRKey(state.RFPURI), issuer.base)
}
if subhandle == "" {
return nil, fmt.Errorf("%q and %q make no subhandle", issuer.base, state.RFPURI)
}
exp := q.now().Add(q.sessionAtircLifetime())
mintCtx, cancel := context.WithTimeout(ctx, atircCallTimeout)
defer cancel()
var out struct {
Token string `json:"token"`
}
if err := q.postAtirc(mintCtx, AtircMintNSID, issuer.bearer, atircMintInput{Subhandle: subhandle, Exp: exp.Unix(), Lease: lease}, &out); err != nil {
return nil, fmt.Errorf("mint %s: %w", subhandle, err)
}
minted := &sessionAtirc{token: strings.TrimSpace(out.Token), subhandle: subhandle}
if minted.token == "" || strings.ContainsAny(minted.token, " \t\r\n") {
return nil, errors.New(q.atircBase() + " answered no token")
}
leases, ok := atircTokenLeases(minted.token)
if !ok {
q.revokeSessionAtirc(ctx, minted)
return nil, fmt.Errorf("mint %s: %w (%s)", subhandle, errAtircLeaseMissing, q.atircBase())
}
if err := checkLeaseChain(leases, issuer.leases, lease); err != nil {
q.revokeSessionAtirc(ctx, minted)
return nil, fmt.Errorf("mint %s: %w", subhandle, err)
}
return minted, nil
}
func (q *Requester) sessionAtirc(ctx context.Context, account sshtransport.AuthorizedAccount, want bool, agent string, state *v1alpha1.NodeClaimContract, io sshtransport.CommandIO) (*sessionAtirc, error) {
if !want {
return nil, nil
}
minted, err := q.mintSessionAtirc(ctx, state, agent)
switch {
case err != nil && agent != "":
q.log.Warn("requester_session_atirc_mint_failed", "did", account.DID, "subhandle", agent, "err", err.Error())
_ = io.WriteErr([]byte("atirc agent run: no token for " + agent + ": " + err.Error() + "\n"))
return nil, err
case err != nil:
q.log.Warn("requester_session_atirc_mint_failed", "did", account.DID, "err", err.Error())
_ = io.WriteErr([]byte("atirc: this session runs without an atirc token: " + err.Error() + "\n"))
return nil, nil
}
q.log.Info("requester_session_atirc_minted", "did", account.DID, "subhandle", minted.subhandle, "agent", agent != "")
return minted, nil
}
func (m *sessionAtirc) env() map[string]string {
if m == nil {
return nil
}
return map[string]string{sessionAtircTokenEnv: m.token}
}
func (q *Requester) revokeSessionAtirc(ctx context.Context, minted *sessionAtirc) {
if minted == nil {
return
}
ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), atircCallTimeout)
defer cancel()
var out struct {
RevokedAt int64 `json:"revokedAt"`
}
err := q.postAtirc(ctx, AtircRevokeNSID, minted.token, atircRevokeInput{Subhandle: minted.subhandle}, &out)
var xerr *atircError
switch {
case err == nil:
q.log.Info("requester_session_atirc_revoked", "subhandle", minted.subhandle)
case errors.As(err, &xerr) && xerr.status == http.StatusUnauthorized:
q.log.Info("requester_session_atirc_revoked", "subhandle", minted.subhandle, "already", true)
default:
q.log.Warn("requester_session_atirc_revoke_failed", "subhandle", minted.subhandle, "err", err.Error())
}
}