The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
package cloudshuttle
import (
"bytes"
"compress/gzip"
"context"
"crypto"
"crypto/hmac"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/hex"
"encoding/json"
"encoding/pem"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"os"
"path"
"path/filepath"
"sort"
"strings"
"time"
"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve/filelock"
"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve/objectkey"
)
const (
defaultLogName = "runtime.jsonl"
defaultStateName = "shuttle-state.json"
defaultTokenURI = "https://oauth2.googleapis.com/token"
defaultGCSEndpoint = "https://storage.googleapis.com"
defaultS3Region = "us-east-1"
contentTypeJSONL = "application/x-ndjson"
contentEncoding = "gzip"
uploadGCS = "gcs"
uploadS3 = "s3"
)
var httpClient = http.DefaultClient
// SandboxDir is the cloud sandbox's Beacon directory. The shuttle reads and writes only under it,
// so an environment a repository supplies cannot select a host log to upload. Tests point it
// elsewhere.
var SandboxDir = "/tmp/beacon"
var nowUTC = func() time.Time { return time.Now().UTC() }
type Config struct {
Upload string
LogPath string
StatePath string
Bucket string
Prefix string
CredentialsB64 string
Provider string
RunID string
UserID string
Repository string
GCSEndpoint string
S3Region string
S3AccessKeyID string
S3SecretKey string
S3SessionToken string
S3Endpoint string
// Asymptote managed ingest target (Upload == "asymptote").
IngestURL string
DeviceKey string
}
type serviceAccount struct {
ClientEmail string `json:"client_email"`
PrivateKey string `json:"private_key"`
TokenURI string `json:"token_uri"`
}
type state struct {
LastUpload string `json:"last_upload,omitempty"`
LastSize int64 `json:"last_size,omitempty"`
LastObject string `json:"last_object,omitempty"`
Provider string `json:"provider,omitempty"`
RunID string `json:"run_id,omitempty"`
}
type tokenResponse struct {
AccessToken string `json:"access_token"`
TokenType string `json:"token_type"`
ExpiresIn int `json:"expires_in"`
}
func ConfigFromEnv() Config {
statePath := inSandbox("state path", firstEnv("BEACON_CLOUD_SHUTTLE_STATE"), defaultStateName)
upload := cloudUploadFromEnv()
bucket := strings.TrimSpace(os.Getenv("BEACON_CLOUD_GCS_BUCKET"))
prefix := strings.Trim(strings.TrimSpace(os.Getenv("BEACON_CLOUD_GCS_PREFIX")), "/")
if upload == uploadS3 {
bucket = strings.TrimSpace(os.Getenv("BEACON_CLOUD_S3_BUCKET"))
prefix = strings.Trim(strings.TrimSpace(os.Getenv("BEACON_CLOUD_S3_PREFIX")), "/")
}
return Config{
Upload: upload,
LogPath: inSandbox("log path", firstEnv("BEACON_CLOUD_LOG_PATH", "BEACON_ENDPOINT_LOG", "BEACON_LOG_PATH", "BEACON_RUNTIME_LOG"), defaultLogName),
StatePath: statePath,
Bucket: bucket,
Prefix: prefix,
CredentialsB64: strings.TrimSpace(os.Getenv("BEACON_CLOUD_GCS_CREDENTIALS_B64")),
Provider: firstEnvDefault("claude_code_web", "BEACON_RUN_PROVIDER"),
RunID: resolveRunID(),
UserID: firstEnvDefault("unknown", "BEACON_CLOUD_USER_ID_HASH", "BEACON_CLOUD_USER_ID"),
Repository: firstEnv("BEACON_RUN_REPOSITORY"),
GCSEndpoint: firstEnvDefault(defaultGCSEndpoint, "BEACON_CLOUD_GCS_ENDPOINT"),
S3Region: firstEnvDefault(defaultS3Region, "BEACON_CLOUD_S3_REGION", "AWS_REGION", "AWS_DEFAULT_REGION"),
S3AccessKeyID: firstEnv("AWS_ACCESS_KEY_ID"),
S3SecretKey: firstEnv("AWS_SECRET_ACCESS_KEY"),
S3SessionToken: firstEnv("AWS_SESSION_TOKEN"),
S3Endpoint: firstEnv("BEACON_CLOUD_S3_ENDPOINT"),
IngestURL: strings.TrimRight(firstEnv("BEACON_CLOUD_INGEST_URL"), "/"),
DeviceKey: firstEnv("BEACON_CLOUD_DEVICE_KEY"),
}
}
// inSandbox is p when it lies under SandboxDir, else the default file there. A refused p is
// reported on stderr, never stdout, which some runtimes add to the model's context, and only
// under BEACON_ORIGIN=cloud: local installs always set BEACON_ENDPOINT_LOG outside the sandbox
// and reach this through every SessionStart, Stop and SessionEnd, where the shuttle is inert.
func inSandbox(label, p, name string) string {
fallback := filepath.Join(SandboxDir, name)
if p == "" {
return fallback
}
if filepath.IsAbs(p) {
rel, err := filepath.Rel(SandboxDir, p)
if err == nil && rel != "." && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
return p
}
}
if inCloudSandbox() {
fmt.Fprintf(os.Stderr, "beacon-hooks: cloud shuttle ignores %s %s outside %s; using %s\n", label, p, SandboxDir, fallback)
}
return fallback
}
// inCloudSandbox reports whether the hook says it runs in a cloud sandbox (BEACON_ORIGIN=cloud),
// the only place the shuttle acts. The marker comes from the same environment as BEACON_CLOUD_*,
// so it keeps a local install that happens to carry those variables from uploading; it does not
// stop a repository that sets both. That case is bounded by inSandbox, which keeps the shuttle to
// the sandbox's own files.
func inCloudSandbox() bool {
return strings.TrimSpace(os.Getenv("BEACON_ORIGIN")) == "cloud"
}
func MaybeUpload(ctx context.Context, force bool) error {
if !inCloudSandbox() {
return nil
}
return Upload(ctx, ConfigFromEnv(), force)
}
func ResetFromEnv() error {
if !inCloudSandbox() {
return nil
}
cfg := ConfigFromEnv()
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
release, err := lockUpload(ctx, cfg.StatePath)
if err != nil {
return err
}
defer release()
if err := preserveExistingLogLocked(ctx, cfg); err != nil {
return err
}
// Lock files are stable protocol identities: unlinking one lets another process
// lock a new inode while an existing holder still owns the old inode.
if err := os.Remove(cfg.StatePath); err != nil && !os.IsNotExist(err) {
return err
}
return nil
}
func Upload(ctx context.Context, cfg Config, force bool) error {
cfg = normalizeConfig(cfg)
if !uploadConfigured(cfg) || strings.TrimSpace(cfg.RunID) == "" || !force {
return nil
}
release, err := lockUpload(ctx, cfg.StatePath)
if err != nil {
return err
}
defer release()
snapshot, cleanup, err := snapshotLog(ctx, cfg.LogPath)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
defer cleanup()
if snapshot.info.Size() == 0 {
return nil
}
if cfg.Upload == uploadAsymptote {
return uploadAsymptoteIncremental(ctx, cfg, snapshot.path, snapshot.info.Size())
}
objectName := uploadObjectName(cfg)
if err := uploadSnapshot(ctx, cfg, objectName, snapshot.path); err != nil {
return err
}
return writeState(cfg.StatePath, state{
LastUpload: time.Now().UTC().Format(time.RFC3339),
LastSize: snapshot.info.Size(),
LastObject: objectName,
Provider: cfg.Provider,
RunID: cfg.RunID,
})
}
func uploadObjectName(cfg Config) string {
st, err := readState(cfg.StatePath)
if err == nil && stateObjectMatchesConfig(st, cfg) {
return strings.TrimSpace(st.LastObject)
}
return ObjectName(cfg)
}
// stateObjectMatchesConfig reports whether the state's object is this log's, so the upload rewrites
// it rather than starting another.
//
// The state follows the log, not the run id. A sandbox runs one agent, and a new run in it starts at
// a session start, which removes the log and the state (ResetFromEnv). Within a run the run id can
// still change: Cursor gives each subagent a conversation id of its own, and BEACON_RUN_ID is seeded
// from the conversation id of each hook. Matching the run id started a new object, holding the whole
// log again, every time the agent and a subagent took turns.
func stateObjectMatchesConfig(st state, cfg Config) bool {
objectName := strings.TrimSpace(st.LastObject)
if objectName == "" {
return false
}
if st.Provider != "" || st.RunID != "" {
return st.Provider == cfg.Provider
}
provider := objectkey.CleanPart(defaultString(cfg.Provider, "unknown"))
runID := objectkey.CleanPart(defaultString(cfg.RunID, "unknown"))
return strings.HasSuffix(path.Base(objectName), "-"+provider+"-"+runID+".jsonl.gz")
}
func ObjectName(cfg Config) string {
now := nowUTC()
parts := objectkey.CleanParts(cfg.Prefix)
parts = append(parts, "runtime", "date="+now.Format("2006-01-02"))
filename := strings.Join([]string{
fmt.Sprintf("%d", now.Unix()),
objectkey.CleanPart(defaultString(cfg.Provider, "unknown")),
objectkey.CleanPart(defaultString(cfg.RunID, "unknown")),
}, "-") + ".jsonl.gz"
parts = append(parts, filename)
return path.Join(parts...)
}
type logSnapshot struct {
path string
info os.FileInfo
}
func snapshotLog(ctx context.Context, logPath string) (logSnapshot, func(), error) {
lock, err := os.OpenFile(logPath+".lock", os.O_CREATE|os.O_RDWR, 0644)
if err != nil {
return logSnapshot{}, func() {}, err
}
defer lock.Close()
held, err := filelock.SharedContext(ctx, lock)
if err != nil {
return logSnapshot{}, func() {}, err
}
defer held.Release()
source, err := os.Open(logPath)
if err != nil {
return logSnapshot{}, func() {}, err
}
defer source.Close()
// Identity and length belong to the same opened source under the writer lock.
// A separate pre-lock Stat can describe a different generation or older size.
info, err := source.Stat()
if err != nil {
return logSnapshot{}, func() {}, err
}
temp, err := os.CreateTemp(filepath.Dir(logPath), "beacon-cloud-*.jsonl")
if err != nil {
return logSnapshot{}, func() {}, err
}
cleanup := func() { _ = os.Remove(temp.Name()) }
if _, err := io.CopyN(temp, source, info.Size()); err != nil {
_ = temp.Close()
cleanup()
return logSnapshot{}, func() {}, err
}
if err := temp.Close(); err != nil {
cleanup()
return logSnapshot{}, func() {}, err
}
if err := ctx.Err(); err != nil {
cleanup()
return logSnapshot{}, func() {}, err
}
return logSnapshot{path: temp.Name(), info: info}, cleanup, nil
}
func accessToken(ctx context.Context, credentialsB64 string) (string, error) {
decoded, err := base64.StdEncoding.DecodeString(credentialsB64)
if err != nil {
return "", fmt.Errorf("decode GCS credentials: %w", err)
}
var account serviceAccount
if err := json.Unmarshal(decoded, &account); err != nil {
return "", fmt.Errorf("parse GCS credentials: %w", err)
}
if account.ClientEmail == "" || account.PrivateKey == "" {
return "", errors.New("GCS credentials missing client_email or private_key")
}
if account.TokenURI == "" {
account.TokenURI = defaultTokenURI
}
assertion, err := signedJWT(account)
if err != nil {
return "", err
}
form := url.Values{}
form.Set("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer")
form.Set("assertion", assertion)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, account.TokenURI, strings.NewReader(form.Encode()))
if err != nil {
return "", err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
resp, err := httpClient.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
body, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return "", fmt.Errorf("GCS token exchange failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
}
var token tokenResponse
if err := json.Unmarshal(body, &token); err != nil {
return "", fmt.Errorf("parse GCS token response: %w", err)
}
if token.AccessToken == "" {
return "", errors.New("GCS token response missing access_token")
}
return token.AccessToken, nil
}
func signedJWT(account serviceAccount) (string, error) {
now := time.Now().Unix()
header := map[string]string{"alg": "RS256", "typ": "JWT"}
claims := map[string]interface{}{
"iss": account.ClientEmail,
"scope": "https://www.googleapis.com/auth/devstorage.read_write",
"aud": account.TokenURI,
"iat": now,
"exp": now + 3600,
}
encodedHeader, err := encodeJSONSegment(header)
if err != nil {
return "", err
}
encodedClaims, err := encodeJSONSegment(claims)
if err != nil {
return "", err
}
signingInput := encodedHeader + "." + encodedClaims
privateKey, err := parseRSAPrivateKey(account.PrivateKey)
if err != nil {
return "", err
}
sum := sha256.Sum256([]byte(signingInput))
signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, sum[:])
if err != nil {
return "", err
}
return signingInput + "." + base64.RawURLEncoding.EncodeToString(signature), nil
}
func encodeJSONSegment(value interface{}) (string, error) {
data, err := json.Marshal(value)
if err != nil {
return "", err
}
return base64.RawURLEncoding.EncodeToString(data), nil
}
func parseRSAPrivateKey(raw string) (*rsa.PrivateKey, error) {
block, _ := pem.Decode([]byte(raw))
if block == nil {
return nil, errors.New("GCS private key is not PEM encoded")
}
if key, err := x509.ParsePKCS8PrivateKey(block.Bytes); err == nil {
if rsaKey, ok := key.(*rsa.PrivateKey); ok {
return rsaKey, nil
}
return nil, errors.New("GCS private key is not RSA")
}
if key, err := x509.ParsePKCS1PrivateKey(block.Bytes); err == nil {
return key, nil
}
return nil, errors.New("parse GCS private key")
}
func uploadSnapshot(ctx context.Context, cfg Config, objectName, filePath string) error {
compressedPath, cleanup, err := gzipSnapshot(filePath)
if err != nil {
return err
}
defer cleanup()
switch cfg.Upload {
case uploadS3:
return uploadS3Object(ctx, cfg, objectName, compressedPath)
default:
token, err := accessToken(ctx, cfg.CredentialsB64)
if err != nil {
return err
}
return uploadGCSObject(ctx, cfg.GCSEndpoint, cfg.Bucket, objectName, compressedPath, token)
}
}
func gzipSnapshot(filePath string) (string, func(), error) {
source, err := os.Open(filePath)
if err != nil {
return "", func() {}, err
}
defer source.Close()
temp, err := os.CreateTemp(filepath.Dir(filePath), "beacon-cloud-*.jsonl.gz")
if err != nil {
return "", func() {}, err
}
tempPath := temp.Name()
cleanup := func() { _ = os.Remove(tempPath) }
gz := gzip.NewWriter(temp)
if _, err := io.Copy(gz, source); err != nil {
_ = gz.Close()
_ = temp.Close()
cleanup()
return "", func() {}, err
}
if err := gz.Close(); err != nil {
_ = temp.Close()
cleanup()
return "", func() {}, err
}
if err := temp.Close(); err != nil {
cleanup()
return "", func() {}, err
}
return tempPath, cleanup, nil
}
func uploadGCSObject(ctx context.Context, endpoint, bucket, objectName, filePath, token string) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
uploadURL := strings.TrimRight(endpoint, "/") + "/" + objectkey.EscapeName(bucket) + "/" + objectkey.EscapeName(objectName)
req, err := http.NewRequestWithContext(ctx, http.MethodPut, uploadURL, file)
if err != nil {
return err
}
if info, err := file.Stat(); err == nil {
req.ContentLength = info.Size()
}
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", contentTypeJSONL)
req.Header.Set("Content-Encoding", contentEncoding)
resp, err := httpClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
body, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return fmt.Errorf("GCS upload failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
}
return nil
}
func uploadS3Object(ctx context.Context, cfg Config, objectName, filePath string) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
payloadHash, err := hashOpenFile(file)
if err != nil {
return err
}
if _, err := file.Seek(0, io.SeekStart); err != nil {
return err
}
endpoint := strings.TrimRight(cfg.S3Endpoint, "/")
if endpoint == "" {
endpoint = "https://s3." + cfg.S3Region + ".amazonaws.com"
}
uploadURL := endpoint + "/" + objectkey.EscapeName(cfg.Bucket) + "/" + objectkey.EscapeName(objectName)
req, err := http.NewRequestWithContext(ctx, http.MethodPut, uploadURL, file)
if err != nil {
return err
}
if info, err := file.Stat(); err == nil {
req.ContentLength = info.Size()
}
req.Header.Set("Content-Type", contentTypeJSONL)
req.Header.Set("Content-Encoding", contentEncoding)
req.Header.Set("X-Amz-Content-Sha256", payloadHash)
req.Header.Set("X-Amz-Date", time.Now().UTC().Format("20060102T150405Z"))
if cfg.S3SessionToken != "" {
req.Header.Set("X-Amz-Security-Token", cfg.S3SessionToken)
}
signS3Request(req, cfg, payloadHash)
resp, err := httpClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
body, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return fmt.Errorf("S3 upload failed: %s: %s", resp.Status, strings.TrimSpace(string(body)))
}
return nil
}
func signS3Request(req *http.Request, cfg Config, payloadHash string) {
amzDate := req.Header.Get("X-Amz-Date")
dateStamp := amzDate[:8]
credentialScope := dateStamp + "/" + cfg.S3Region + "/s3/aws4_request"
headers := map[string]string{
"content-encoding": req.Header.Get("Content-Encoding"),
"content-type": req.Header.Get("Content-Type"),
"host": req.URL.Host,
"x-amz-content-sha256": payloadHash,
"x-amz-date": amzDate,
}
if token := req.Header.Get("X-Amz-Security-Token"); token != "" {
headers["x-amz-security-token"] = token
}
keys := make([]string, 0, len(headers))
for key := range headers {
keys = append(keys, key)
}
sort.Strings(keys)
var canonicalHeaders strings.Builder
for _, key := range keys {
canonicalHeaders.WriteString(key)
canonicalHeaders.WriteString(":")
canonicalHeaders.WriteString(strings.TrimSpace(headers[key]))
canonicalHeaders.WriteString("\n")
}
signedHeaders := strings.Join(keys, ";")
canonicalRequest := strings.Join([]string{
req.Method,
awsCanonicalURI(req.URL.Path),
req.URL.RawQuery,
canonicalHeaders.String(),
signedHeaders,
payloadHash,
}, "\n")
stringToSign := strings.Join([]string{
"AWS4-HMAC-SHA256",
amzDate,
credentialScope,
sha256Hex([]byte(canonicalRequest)),
}, "\n")
signature := hex.EncodeToString(hmacSHA256(s3SigningKey(cfg.S3SecretKey, dateStamp, cfg.S3Region), stringToSign))
req.Header.Set("Authorization", "AWS4-HMAC-SHA256 Credential="+cfg.S3AccessKeyID+"/"+credentialScope+", SignedHeaders="+signedHeaders+", Signature="+signature)
}
func readState(path string) (state, error) {
var st state
data, err := os.ReadFile(path)
if err != nil {
return st, err
}
err = json.Unmarshal(data, &st)
return st, err
}
func writeState(path string, st state) error {
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
return err
}
data, err := json.Marshal(st)
if err != nil {
return err
}
return os.WriteFile(path, data, 0644)
}
func preserveExistingLog(cfg Config) error {
cfg = normalizeConfig(cfg)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
release, err := lockUpload(ctx, cfg.StatePath)
if err != nil {
return err
}
defer release()
return preserveExistingLogLocked(ctx, cfg)
}
// The caller owns the upload transaction; this must never acquire that lock again.
func preserveExistingLogLocked(ctx context.Context, cfg Config) error {
snapshot, cleanup, err := snapshotLog(ctx, cfg.LogPath)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
defer cleanup()
uploaded := snapshot.info.Size() == 0
st, stateErr := readState(cfg.StatePath)
hasState := stateErr == nil && st.LastObject != ""
// Bucket targets retain their previous run object. Managed ingest can ship a
// never-uploaded run because each line carries its own session identity.
if !uploaded && uploadConfigured(cfg) && (hasState || cfg.Upload == uploadAsymptote) {
var uploadErr error
if cfg.Upload == uploadAsymptote {
previous := cfg
if hasState {
previous.Provider, previous.RunID = st.Provider, st.RunID
}
uploadErr = uploadAsymptoteIncremental(ctx, previous, snapshot.path, snapshot.info.Size())
} else {
uploadErr = uploadSnapshot(ctx, cfg, st.LastObject, snapshot.path)
}
uploaded = uploadErr == nil
}
if uploaded {
return os.Remove(cfg.LogPath)
}
preservedPath := fmt.Sprintf("%s.previous-%d", cfg.LogPath, time.Now().UTC().UnixNano())
if err := os.Rename(cfg.LogPath, preservedPath); err != nil && !os.IsNotExist(err) {
return err
}
return nil
}
func resolveRunID() string {
return firstEnv("BEACON_RUN_ID", "CLAUDE_CODE_REMOTE_SESSION_ID")
}
func cloudUploadFromEnv() string {
value := strings.ToLower(strings.TrimSpace(os.Getenv("BEACON_CLOUD_UPLOAD")))
switch value {
case uploadS3:
return uploadS3
case uploadGCS:
return uploadGCS
case uploadAsymptote:
return uploadAsymptote
}
return uploadGCS
}
func normalizeConfig(cfg Config) Config {
cfg.Upload = strings.ToLower(strings.TrimSpace(cfg.Upload))
if cfg.Upload == "" {
if cfg.S3AccessKeyID != "" || cfg.S3SecretKey != "" || cfg.S3Region != "" || strings.Contains(cfg.S3Endpoint, "s3") {
cfg.Upload = uploadS3
} else {
cfg.Upload = uploadGCS
}
}
if cfg.LogPath == "" {
cfg.LogPath = filepath.Join(SandboxDir, defaultLogName)
}
if cfg.StatePath == "" {
cfg.StatePath = filepath.Join(SandboxDir, defaultStateName)
}
if cfg.GCSEndpoint == "" {
cfg.GCSEndpoint = defaultGCSEndpoint
}
if cfg.S3Region == "" {
cfg.S3Region = defaultS3Region
}
cfg.Prefix = strings.Trim(cfg.Prefix, "/")
return cfg
}
func uploadConfigured(cfg Config) bool {
if cfg.Upload == uploadAsymptote {
return asymptoteConfigured(cfg)
}
if strings.TrimSpace(cfg.Bucket) == "" {
return false
}
switch cfg.Upload {
case uploadS3:
return strings.TrimSpace(cfg.S3AccessKeyID) != "" && strings.TrimSpace(cfg.S3SecretKey) != ""
default:
return strings.TrimSpace(cfg.CredentialsB64) != ""
}
}
func hashOpenFile(file *os.File) (string, error) {
hash := sha256.New()
if _, err := io.Copy(hash, file); err != nil {
return "", err
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
func sha256Hex(data []byte) string {
sum := sha256.Sum256(data)
return hex.EncodeToString(sum[:])
}
func s3SigningKey(secret, dateStamp, region string) []byte {
dateKey := hmacSHA256([]byte("AWS4"+secret), dateStamp)
regionKey := hmacSHA256(dateKey, region)
serviceKey := hmacSHA256(regionKey, "s3")
return hmacSHA256(serviceKey, "aws4_request")
}
func hmacSHA256(key []byte, value string) []byte {
mac := hmac.New(sha256.New, key)
mac.Write([]byte(value))
return mac.Sum(nil)
}
func awsCanonicalURI(pathValue string) string {
if pathValue == "" {
return "/"
}
var out strings.Builder
for i := 0; i < len(pathValue); i++ {
b := pathValue[i]
switch {
case b == '/':
out.WriteByte('/')
case (b >= 'A' && b <= 'Z') ||
(b >= 'a' && b <= 'z') ||
(b >= '0' && b <= '9') ||
b == '-' || b == '_' || b == '.' || b == '~':
out.WriteByte(b)
default:
out.WriteByte('%')
out.WriteByte("0123456789ABCDEF"[b>>4])
out.WriteByte("0123456789ABCDEF"[b&0x0f])
}
}
return out.String()
}
func defaultString(value, fallback string) string {
if strings.TrimSpace(value) == "" {
return fallback
}
return value
}
func firstEnv(keys ...string) string {
for _, key := range keys {
if value := strings.TrimSpace(os.Getenv(key)); value != "" {
return value
}
}
return ""
}
func firstEnvDefault(defaultValue string, keys ...string) string {
if value := firstEnv(keys...); value != "" {
return value
}
return defaultValue
}
func EncodeCredentialsForEnv(data []byte) string {
return base64.StdEncoding.EncodeToString(bytes.TrimSpace(data))
}