From af90b449d81423913de49313f5643837bd5a0390 Mon Sep 17 00:00:00 2001 From: sjmiller609 <7516283+sjmiller609@users.noreply.github.com> Date: Mon, 16 Nov 2026 15:57:02 +0000 Subject: [PATCH 1/3] Support borrowed registry credentials for builds --- .../api/build_registry_credentials_test.go | 71 ++ cmd/api/api/builds.go | 28 +- lib/builds/README.md | 44 + lib/builds/builder_agent/main.go | 190 +++-- lib/builds/builder_agent/registry_auth.go | 65 ++ .../registry_auth_integration_test.go | 74 ++ .../builder_agent/registry_auth_test.go | 96 +++ lib/builds/images/generic/Dockerfile | 1 + lib/builds/manager.go | 108 ++- lib/builds/registry_credentials.go | 61 ++ lib/builds/registry_credentials_test.go | 160 ++++ lib/builds/registryauth/credentials.go | 101 +++ lib/builds/registryauth/credentials_test.go | 41 + lib/builds/types.go | 8 + lib/builds/vsock_handler.go | 4 + lib/oapi/oapi.go | 803 +++++++++--------- openapi.yaml | 19 + 17 files changed, 1387 insertions(+), 487 deletions(-) create mode 100644 cmd/api/api/build_registry_credentials_test.go create mode 100644 lib/builds/builder_agent/registry_auth.go create mode 100644 lib/builds/builder_agent/registry_auth_integration_test.go create mode 100644 lib/builds/builder_agent/registry_auth_test.go create mode 100644 lib/builds/registry_credentials.go create mode 100644 lib/builds/registry_credentials_test.go create mode 100644 lib/builds/registryauth/credentials.go create mode 100644 lib/builds/registryauth/credentials_test.go diff --git a/cmd/api/api/build_registry_credentials_test.go b/cmd/api/api/build_registry_credentials_test.go new file mode 100644 index 000000000..8ed4eafbf --- /dev/null +++ b/cmd/api/api/build_registry_credentials_test.go @@ -0,0 +1,71 @@ +package api + +import ( + "bytes" + "context" + "encoding/json" + "mime/multipart" + "strings" + "testing" + "time" + + "github.com/kernel/hypeman/lib/builds" + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/kernel/hypeman/lib/oapi" + "github.com/stretchr/testify/require" +) + +type registryCredentialBuildManager struct { + builds.Manager + request builds.CreateBuildRequest +} + +func (m *registryCredentialBuildManager) CreateBuild(_ context.Context, req builds.CreateBuildRequest, _ []byte) (*builds.Build, error) { + m.request = req + if _, err := registryauth.Normalize(req.RegistryCredentials, "local.example:4973", time.Now()); err != nil { + return nil, err + } + return &builds.Build{ID: "test-build", Status: builds.StatusQueued}, nil +} + +func TestCreateBuildRegistryCredentials(t *testing.T) { + for _, tc := range []struct { + name, data string + valid bool + }{ + {"valid", `{"registry.example":{"username":"AWS","password":"synthetic-token"}}`, true}, + {"omitted", "", true}, + {"malformed", `{"password":"synthetic-token"`, false}, + {"bad-host", `{"https://registry.example":{"username":"AWS","password":"synthetic-token"}}`, false}, + {"local-registry", `{"local.example:4973":{"username":"AWS","password":"synthetic-token"}}`, false}, + {"expired", `{"registry.example":{"username":"AWS","password":"synthetic-token","expires_at":"2000-01-01T00:00:00Z"}}`, false}, + {"oversized", strings.Repeat("x", registryauth.MaxBytes+1), false}, + } { + t.Run(tc.name, func(t *testing.T) { + manager := ®istryCredentialBuildManager{} + svc := &ApiService{BuildManager: manager} + var body bytes.Buffer + writer := multipart.NewWriter(&body) + require.NoError(t, writer.WriteField("source", "source")) + if tc.data != "" { + require.NoError(t, writer.WriteField("registry_credentials", tc.data)) + } + require.NoError(t, writer.Close()) + response, err := svc.CreateBuild(context.Background(), oapi.CreateBuildRequestObject{Body: multipart.NewReader(&body, writer.Boundary())}) + require.NoError(t, err) + if tc.valid { + _, ok := response.(oapi.CreateBuild202JSONResponse) + require.True(t, ok) + if tc.data != "" { + require.Equal(t, "synthetic-token", manager.request.RegistryCredentials["registry.example"].Password) + } + } else { + _, ok := response.(oapi.CreateBuild400JSONResponse) + require.True(t, ok) + } + encoded, err := json.Marshal(response) + require.NoError(t, err) + require.NotContains(t, string(encoded), "synthetic-token") + }) + } +} diff --git a/cmd/api/api/builds.go b/cmd/api/api/builds.go index ae8e74c27..0830d98bc 100644 --- a/cmd/api/api/builds.go +++ b/cmd/api/api/builds.go @@ -11,6 +11,7 @@ import ( "github.com/kernel/hypeman/lib/builders" "github.com/kernel/hypeman/lib/builds" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/kernel/hypeman/lib/images" "github.com/kernel/hypeman/lib/logger" "github.com/kernel/hypeman/lib/oapi" @@ -55,6 +56,7 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe var isAdminBuild bool var secrets []builds.SecretRef var resourceTags map[string]string + var registryCredentials map[string]registryauth.Credential for { part, err := request.Body.NextPart() @@ -69,6 +71,11 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe } switch part.FormName() { + case "registry_credentials": + data, err := io.ReadAll(io.LimitReader(part, registryauth.MaxBytes+1)) + if err != nil || len(data) > registryauth.MaxBytes || json.Unmarshal(data, ®istryCredentials) != nil { + return oapi.CreateBuild400JSONResponse{Code: "invalid_request", Message: registryauth.ErrInvalid.Error()}, nil + } case "source": sourceData, err = io.ReadAll(part) if err != nil { @@ -230,15 +237,16 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe // Build domain request domainReq := builds.CreateBuildRequest{ - BaseImageDigest: baseImageDigest, - BuilderID: builderID, - CacheScope: cacheScope, - Dockerfile: dockerfile, - Secrets: secrets, - IsAdminBuild: isAdminBuild, - GlobalCacheKey: globalCacheKey, - ImageName: imageName, - Tags: resourceTags, + BaseImageDigest: baseImageDigest, + RegistryCredentials: registryCredentials, + BuilderID: builderID, + CacheScope: cacheScope, + Dockerfile: dockerfile, + Secrets: secrets, + IsAdminBuild: isAdminBuild, + GlobalCacheKey: globalCacheKey, + ImageName: imageName, + Tags: resourceTags, } // Apply build policy if any field was provided @@ -259,6 +267,8 @@ func (s *ApiService) CreateBuild(ctx context.Context, request oapi.CreateBuildRe build, err := s.BuildManager.CreateBuild(ctx, domainReq, sourceData) if err != nil { switch { + case errors.Is(err, registryauth.ErrInvalid): + return oapi.CreateBuild400JSONResponse{Code: "invalid_request", Message: registryauth.ErrInvalid.Error()}, nil case errors.Is(err, tags.ErrInvalidTags): return oapi.CreateBuild400JSONResponse{ Code: "invalid_request", diff --git a/lib/builds/README.md b/lib/builds/README.md index 796da60eb..372cd8707 100644 --- a/lib/builds/README.md +++ b/lib/builds/README.md @@ -230,6 +230,50 @@ Builder VMs authenticate to the registry using short-lived JWT tokens: 3. **Token TTL**: Matches build timeout (minimum 30 minutes) 4. **Authentication**: Builder agent sends token via Basic auth (`token:` format) +### Borrowed upstream credentials + +`POST /builds` accepts an optional `registry_credentials` multipart string: +a JSON object keyed by exact registry host, with `username`, `password`, and +optional RFC3339 `expires_at`. This supports private `FROM` images without +installing a shared upstream credential on the host. + +```json +{"registry.example":{"username":"AWS","password":"","expires_at":"2030-01-01T12:00:00Z"}} +``` + +Submit the JSON from a protected file rather than exposing the token in process arguments: + +```sh +curl -H "Authorization: Bearer $HYPEMAN_TOKEN" \ + -F "source=@source.tar.gz" \ + -F "registry_credentials=<$REGISTRY_CREDENTIALS_FILE" \ + "$HYPEMAN_URL/builds" +``` + +- Use pull-only credentials limited to the needed repositories. The registry/IAM + policy grants permissions; this field does not narrow the token itself. +- The API accepts at most 16 registry hosts and 64 KiB of JSON. Schemes, paths, + duplicate normalized hosts, local-output-registry overrides, CR/LF in + credentials, and expired credentials are rejected. Only username/password + authentication is supported for builds; do not pass `registry_token`. +- Hypeman keeps these credentials in memory, not metadata or the config disk. + They are sent only to that build's VM over vsock. The guest adds them beside + local-registry auth in its existing mode-0600 Docker config files, outside + the source context and persistent BuildKit cache, and deletes them afterward. +- Credentialed builds skip host base-image prefetching and the guest's Docker Hub + mirror, preventing private bases from entering the shared host mirror. +- Borrowing is bounded to **30 minutes from submission**, including queue time, + or the earliest caller expiry. Active builds are bounded by the same deadline. + Completion/cancellation/expiry releases host references. This does not revoke + the token at the upstream registry. +- There is no refresh or durable replay. After a restart, credentialed builds fail + and their old builder VM is deleted; resubmit with fresh credentials. +- Rebuild and deploy the generic builder image before enabling callers. + Older builders are rejected rather than accepting a credentialed build silently. + CLI/SDK caller wiring is a separate change; no new CLI flags exist yet. + +Omitting the field (or sending `{}`) preserves existing behavior. + ## Build Status Flow ``` diff --git a/lib/builds/builder_agent/main.go b/lib/builds/builder_agent/main.go index 6138144a9..bf4e9c081 100644 --- a/lib/builds/builder_agent/main.go +++ b/lib/builds/builder_agent/main.go @@ -13,7 +13,6 @@ import ( "bytes" "context" "crypto/sha256" - "encoding/base64" "encoding/hex" "encoding/json" "fmt" @@ -27,6 +26,7 @@ import ( "sync" "time" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/mdlayher/vsock" ) @@ -37,6 +37,8 @@ const ( // BuildConfig matches the BuildConfig type from lib/builds/types.go type BuildConfig struct { + RegistryCredentialsRequired bool `json:"registry_credentials_required,omitempty"` + JobID string `json:"job_id"` BaseImageDigest string `json:"base_image_digest,omitempty"` RegistryURL string `json:"registry_url"` @@ -88,6 +90,8 @@ type BuildProvenance struct { // VsockMessage is the envelope for vsock communication type VsockMessage struct { + RegistryCredentials map[string]registryauth.Credential `json:"registry_credentials,omitempty"` + Type string `json:"type"` Result *BuildResult `json:"result,omitempty"` Log string `json:"log,omitempty"` @@ -107,6 +111,9 @@ var ( secretsReady = make(chan struct{}) secretsOnce sync.Once + buildRegistryCredentials map[string]registryauth.Credential + buildCredentialsError error + // Encoder lock protects concurrent access to json.Encoder // (the goroutine sending build_result and the main loop handling get_status) encoderLock sync.Mutex @@ -120,6 +127,8 @@ var ( // It also writes to a buffer to include all logs in the final result. type streamingLogWriter struct { buffer *bytes.Buffer + pending []byte + redact func(string) string mu sync.Mutex closed bool closedMu sync.RWMutex @@ -133,9 +142,23 @@ func newStreamingLogWriter() *streamingLogWriter { func (w *streamingLogWriter) Write(p []byte) (n int, err error) { w.mu.Lock() - w.buffer.Write(p) - w.mu.Unlock() + defer w.mu.Unlock() + n = len(p) + if w.redact != nil { + w.pending = append(w.pending, p...) + end := bytes.LastIndexByte(w.pending, '\n') + if end < 0 { + return n, nil + } + p = []byte(w.redact(string(w.pending[:end+1]))) + w.pending = append(w.pending[:0], w.pending[end+1:]...) + } + w.emit(p) + return n, nil +} +func (w *streamingLogWriter) emit(p []byte) { + w.buffer.Write(p) // Hold RLock through the send to prevent markClosed()+close(logChan) // from racing between the check and the channel send. w.closedMu.RLock() @@ -151,11 +174,15 @@ func (w *streamingLogWriter) Write(p []byte) (n int, err error) { // Also write to stdout for local debugging os.Stdout.Write(p) - - return len(p), nil } func (w *streamingLogWriter) markClosed() { + w.mu.Lock() + defer w.mu.Unlock() + if len(w.pending) > 0 { + w.emit([]byte(w.redact(string(w.pending)))) + w.pending = nil + } w.closedMu.Lock() w.closed = true w.closedMu.Unlock() @@ -164,9 +191,27 @@ func (w *streamingLogWriter) markClosed() { func (w *streamingLogWriter) String() string { w.mu.Lock() defer w.mu.Unlock() + if w.redact != nil { + return w.buffer.String() + w.redact(string(w.pending)) + } return w.buffer.String() } +func (w *streamingLogWriter) setRedactor(redact func(string) string) { + w.mu.Lock() + defer w.mu.Unlock() + w.redact = redact +} + +func (w *streamingLogWriter) redactText(value string) string { + w.mu.Lock() + defer w.mu.Unlock() + if w.redact != nil { + return w.redact(value) + } + return value +} + func main() { log.Println("=== Builder Agent Starting ===") @@ -266,11 +311,13 @@ func handleHostConnection(conn net.Conn) { case "host_ready": // Host is ready to handle requests // Request secrets if we have any configured - if err := handleSecretsRequest(encoder, decoder); err != nil { - log.Printf("Failed to fetch secrets: %v", err) + credentials, err := handleSecretsRequest(encoder, decoder) + if err != nil { + log.Printf("Failed to fetch build credentials or secrets: %s", registryauth.Redactor(credentials)(err.Error())) } - // Signal that secrets are ready (even if failed, build can proceed) secretsOnce.Do(func() { + buildRegistryCredentials = credentials + buildCredentialsError = err close(secretsReady) }) @@ -349,7 +396,8 @@ func handleHostConnection(conn net.Conn) { } // handleSecretsRequest requests secrets from the host and writes them to /run/secrets/ -func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) error { +func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) (map[string]registryauth.Credential, error) { + var credentials map[string]registryauth.Credential // Wait for config to be loaded var config *BuildConfig for i := 0; i < 30; i++ { @@ -364,12 +412,19 @@ func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) error { if config == nil { log.Printf("Config not loaded yet, skipping secrets") - return nil + return credentials, nil } + if config.RegistryCredentialsRequired { + var err error + credentials, err = fetchRegistryCredentials(encoder, decoder, config.RegistryURL) + if err != nil { + return nil, err + } + } if len(config.Secrets) == 0 { log.Printf("No secrets configured") - return nil + return credentials, nil } // Extract secret IDs @@ -389,34 +444,34 @@ func handleSecretsRequest(encoder *json.Encoder, decoder *json.Decoder) error { err := encoder.Encode(req) encoderLock.Unlock() if err != nil { - return fmt.Errorf("send get_secrets: %w", err) + return credentials, fmt.Errorf("send get_secrets: %w", err) } // Wait for secrets_response var resp VsockMessage if err := decoder.Decode(&resp); err != nil { - return fmt.Errorf("receive secrets_response: %w", err) + return credentials, fmt.Errorf("receive secrets_response: %w", err) } if resp.Type != "secrets_response" { - return fmt.Errorf("unexpected response type: %s", resp.Type) + return credentials, fmt.Errorf("unexpected response type: %s", resp.Type) } // Write secrets to /run/secrets/ if err := os.MkdirAll("/run/secrets", 0700); err != nil { - return fmt.Errorf("create secrets dir: %w", err) + return credentials, fmt.Errorf("create secrets dir: %w", err) } for id, value := range resp.Secrets { secretPath := fmt.Sprintf("/run/secrets/%s", id) if err := os.WriteFile(secretPath, []byte(value), 0600); err != nil { - return fmt.Errorf("write secret %s: %w", id, err) + return credentials, fmt.Errorf("write secret %s: %w", id, err) } log.Printf("Wrote secret: %s", id) } log.Printf("Received %d secrets", len(resp.Secrets)) - return nil + return credentials, nil } // runBuildProcess runs the actual build and stores the result @@ -454,17 +509,6 @@ func runBuildProcess() { buildConfig = config buildConfigLock.Unlock() - // Setup registry authentication before running the build - if err := setupRegistryAuth(config); err != nil { - setResult(BuildResult{ - Success: false, - Error: fmt.Sprintf("setup registry auth: %v", err), - Logs: logWriter.String(), - DurationMS: time.Since(start).Milliseconds(), - }) - return - } - // Setup timeout context ctx := context.Background() if config.TimeoutSeconds > 0 { @@ -473,13 +517,17 @@ func runBuildProcess() { defer cancel() } - // Wait for secrets if any are configured - if len(config.Secrets) > 0 { + // Borrowed registry credentials must arrive before BuildKit can start. + if len(config.Secrets) > 0 || config.RegistryCredentialsRequired { log.Printf("Waiting for secrets from host...") select { case <-secretsReady: log.Printf("Secrets ready, proceeding with build") case <-time.After(30 * time.Second): + if config.RegistryCredentialsRequired { + setResult(BuildResult{Error: "timed out waiting for registry credentials", Logs: logWriter.String()}) + return + } log.Printf("Warning: Timeout waiting for secrets, proceeding anyway") // Signal secrets ready to avoid blocking other goroutines secretsOnce.Do(func() { @@ -496,6 +544,28 @@ func runBuildProcess() { } } + var credentials map[string]registryauth.Credential + if config.RegistryCredentialsRequired { + if buildCredentialsError != nil || len(buildRegistryCredentials) == 0 { + setResult(BuildResult{Error: "registry credentials unavailable", Logs: logWriter.String()}) + return + } + credentials = buildRegistryCredentials + for _, credential := range credentials { + if credential.ExpiresAt != nil { + var cancel context.CancelFunc + ctx, cancel = context.WithDeadline(ctx, *credential.ExpiresAt) + defer cancel() + } + } + logWriter.setRedactor(registryauth.Redactor(credentials)) + defer cleanupRegistryAuth("/home/builder/.docker", "/root/.docker") + } + if err := setupRegistryAuth(config, credentials); err != nil { + setResult(BuildResult{Error: "setup registry auth: " + logWriter.redactText(err.Error()), Logs: logWriter.String()}) + return + } + // Ensure Dockerfile exists (either in source or provided via config) dockerfilePath := filepath.Join(config.SourcePath, "Dockerfile") if _, err := os.Stat(dockerfilePath); os.IsNotExist(err) { @@ -536,7 +606,7 @@ func runBuildProcess() { if err != nil { setResult(BuildResult{ Success: false, - Error: err.Error(), + Error: logWriter.redactText(err.Error()), Logs: logWriter.String(), Provenance: provenance, DurationMS: duration, @@ -579,7 +649,7 @@ func loadConfig() (*BuildConfig, error) { // setupRegistryAuth creates a Docker config.json with the registry token for authentication, // and a buildkitd.toml for TLS configuration. // BuildKit uses these files to authenticate and configure TLS when pushing images. -func setupRegistryAuth(config *BuildConfig) error { +func setupRegistryAuth(config *BuildConfig, credentials map[string]registryauth.Credential) error { // Parse registry host (strip any scheme prefix for backwards compatibility) registryHost := config.RegistryURL if strings.HasPrefix(registryHost, "https://") { @@ -591,60 +661,32 @@ func setupRegistryAuth(config *BuildConfig) error { token := config.RegistryToken if token == "" { + if config.RegistryCredentialsRequired { + return fmt.Errorf("local registry token is missing") + } log.Println("No registry token provided, skipping auth setup") return nil } - // Docker config format expects base64-encoded "username:password" or just the token - // For bearer tokens, we use the token directly as the "auth" value - // Format: base64(token + ":") - empty password - authValue := base64.StdEncoding.EncodeToString([]byte(token + ":")) - - // Create the Docker config structure - // Note: Docker config uses host without scheme (e.g., "10.102.0.1:8443") - // We use both auth (Basic) and identitytoken (JWT) to support different BuildKit versions dockerConfig := map[string]interface{}{ - "auths": map[string]interface{}{ - registryHost: map[string]string{ - "auth": authValue, // Basic auth: base64(jwt:) - "identitytoken": token, // JWT directly for OAuth2-style auth - }, - }, + "auths": registryAuthEntries(registryHost, token, credentials), "credsStore": "", "credHelpers": map[string]string{}, } - configData, err := json.MarshalIndent(dockerConfig, "", " ") if err != nil { return fmt.Errorf("marshal docker config: %w", err) } - - // Ensure ~/.docker directory exists - dockerDir := "/home/builder/.docker" - if err := os.MkdirAll(dockerDir, 0700); err != nil { - return fmt.Errorf("create docker config dir: %w", err) - } - - // Write config.json - configPath := filepath.Join(dockerDir, "config.json") - if err := os.WriteFile(configPath, configData, 0600); err != nil { + if err := writeRegistryConfig("/home/builder/.docker", configData); err != nil { return fmt.Errorf("write docker config: %w", err) } - - log.Printf("Docker config created for registry %s (auth length: %d)", registryHost, len(authValue)) - - // Also write to /root/.docker for rootless buildkit that may run as root - rootDockerDir := "/root/.docker" - if err := os.MkdirAll(rootDockerDir, 0700); err == nil { - rootConfigPath := filepath.Join(rootDockerDir, "config.json") - if err := os.WriteFile(rootConfigPath, configData, 0600); err != nil { - log.Printf("Warning: failed to write root docker config: %v", err) - } else { - log.Printf("Registry auth configured at %s", rootConfigPath) + if err := writeRegistryConfig("/root/.docker", configData); err != nil { + if config.RegistryCredentialsRequired { + return fmt.Errorf("write root docker config: %w", err) } + log.Printf("Warning: failed to write root docker config: %v", err) } - - log.Printf("Registry auth configured at %s", configPath) + log.Printf("Registry auth configured for %s", registryHost) // Setup buildkitd.toml for TLS configuration if err := setupBuildkitdConfig(config); err != nil { @@ -737,9 +779,11 @@ func setupBuildkitdConfig(config *BuildConfig) error { // BuildKit will try the mirror first for FROM pulls. Since base images // are pre-cached server-side via mirrorBaseImagesForBuild(), the mirror // will have them and serve them directly without pulling from Docker Hub. - tomlContent.WriteString("\n") - tomlContent.WriteString("[registry.\"docker.io\"]\n") - tomlContent.WriteString(fmt.Sprintf(" mirrors = [\"%s\"]\n", registryHost)) + if !config.RegistryCredentialsRequired { + tomlContent.WriteString("\n") + tomlContent.WriteString("[registry.\"docker.io\"]\n") + tomlContent.WriteString(fmt.Sprintf(" mirrors = [\"%s\"]\n", registryHost)) + } tomlContent.WriteString(gcConfig) diff --git a/lib/builds/builder_agent/registry_auth.go b/lib/builds/builder_agent/registry_auth.go new file mode 100644 index 000000000..1a3c99f11 --- /dev/null +++ b/lib/builds/builder_agent/registry_auth.go @@ -0,0 +1,65 @@ +package main + +import ( + "encoding/base64" + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "time" + + "github.com/kernel/hypeman/lib/builds/registryauth" +) + +func fetchRegistryCredentials(encoder *json.Encoder, decoder *json.Decoder, localRegistry string) (map[string]registryauth.Credential, error) { + encoderLock.Lock() + err := encoder.Encode(VsockMessage{Type: "get_registry_credentials"}) + encoderLock.Unlock() + if err != nil { + return nil, fmt.Errorf("request registry credentials") + } + var response VsockMessage + if err := decoder.Decode(&response); err != nil || response.Type != "registry_credentials" || len(response.RegistryCredentials) == 0 { + return nil, fmt.Errorf("receive registry credentials") + } + return registryauth.Normalize(response.RegistryCredentials, localRegistry, time.Now()) +} + +func registryAuthEntries(host, token string, credentials map[string]registryauth.Credential) map[string]map[string]string { + auths := map[string]map[string]string{ + host: {"auth": base64.StdEncoding.EncodeToString([]byte(token + ":")), "identitytoken": token}, + } + for host, credential := range credentials { + auths[registryauth.DockerKey(host)] = map[string]string{"auth": credential.Auth()} + } + return auths +} + +func writeRegistryConfig(directory string, data []byte) error { + if err := os.MkdirAll(directory, 0700); err != nil { + return err + } + if err := os.Chmod(directory, 0700); err != nil { + return err + } + file, err := os.OpenFile(filepath.Join(directory, "config.json"), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0600) + if err != nil { + return err + } + defer file.Close() + if err := file.Chmod(0600); err != nil { + return err + } + _, err = file.Write(data) + return err +} + +func cleanupRegistryAuth(directories ...string) { + for _, directory := range directories { + path := filepath.Join(directory, "config.json") + if err := os.Remove(path); err != nil && !os.IsNotExist(err) { + log.Printf("Failed to clean up registry auth file: %s", path) + } + } +} diff --git a/lib/builds/builder_agent/registry_auth_integration_test.go b/lib/builds/builder_agent/registry_auth_integration_test.go new file mode 100644 index 000000000..a1fbda1a7 --- /dev/null +++ b/lib/builds/builder_agent/registry_auth_integration_test.go @@ -0,0 +1,74 @@ +package main + +import ( + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "os" + "os/exec" + "path/filepath" + "runtime" + "strconv" + "strings" + "testing" + "time" + + "github.com/google/go-containerregistry/pkg/authn" + "github.com/google/go-containerregistry/pkg/name" + "github.com/google/go-containerregistry/pkg/registry" + v1 "github.com/google/go-containerregistry/pkg/v1" + "github.com/google/go-containerregistry/pkg/v1/empty" + "github.com/google/go-containerregistry/pkg/v1/mutate" + "github.com/google/go-containerregistry/pkg/v1/remote" + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/stretchr/testify/require" +) + +func TestBuildKitUsesBorrowedRegistryConfig(t *testing.T) { + if os.Getenv("HYPEMAN_BUILD_AUTH_DOCKER_TEST") != "1" { + t.Skip("set HYPEMAN_BUILD_AUTH_DOCKER_TEST=1 with Docker available") + } + credential := registryauth.Credential{Username: "AWS", Password: "synthetic-registry-password"} + handler := registry.New() + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + user, password, _ := r.BasicAuth() + if user != credential.Username || password != credential.Password { + w.Header().Set("WWW-Authenticate", `Basic realm="private"`) + w.WriteHeader(http.StatusUnauthorized) + return + } + handler.ServeHTTP(w, r) + })) + defer server.Close() + host := strings.TrimPrefix(server.URL, "http://") + ref, err := name.ParseReference(host + "/private/base:latest") + require.NoError(t, err) + img, err := mutate.ConfigFile(empty.Image, &v1.ConfigFile{Architecture: runtime.GOARCH, OS: "linux"}) + require.NoError(t, err) + require.NoError(t, remote.Write(ref, img, remote.WithAuth(authn.FromConfig(authn.AuthConfig{Username: credential.Username, Password: credential.Password})))) + contextDir, authDir := t.TempDir(), t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(contextDir, "Dockerfile"), []byte("FROM "+ref.Name()+"\n"), 0600)) + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + tag := "hypeman-registry-auth-test:" + strconv.FormatInt(time.Now().UnixNano(), 10) + build := func() ([]byte, error) { + cmd := exec.CommandContext(ctx, "docker", "build", "--progress=plain", "--no-cache", "--pull", "-t", tag, contextDir) + cmd.Env = append(os.Environ(), "DOCKER_CONFIG="+authDir) + return cmd.CombinedOutput() + } + _, err = build() + require.Error(t, err, "private base must reject unauthenticated builds") + config, err := json.Marshal(map[string]any{"auths": registryAuthEntries("local.example:4973", "local-token", map[string]registryauth.Credential{host: credential})}) + require.NoError(t, err) + require.NoError(t, writeRegistryConfig(authDir, config)) + defer exec.Command("docker", "image", "rm", "-f", tag).Run() + output, err := build() + require.NoError(t, err, "%s", output) + require.NotContains(t, string(output), credential.Password) + require.NotContains(t, string(output), credential.Auth()) + inspect, err := exec.CommandContext(ctx, "docker", "image", "inspect", tag).Output() + require.NoError(t, err) + require.NotContains(t, string(inspect), credential.Password) + require.NotContains(t, string(inspect), credential.Auth()) +} diff --git a/lib/builds/builder_agent/registry_auth_test.go b/lib/builds/builder_agent/registry_auth_test.go new file mode 100644 index 000000000..ffa773fbe --- /dev/null +++ b/lib/builds/builder_agent/registry_auth_test.go @@ -0,0 +1,96 @@ +package main + +import ( + "encoding/base64" + "encoding/json" + "io" + "net" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/stretchr/testify/require" +) + +func TestRegistryCredentialHandoffAndConfig(t *testing.T) { + host, guest := net.Pipe() + defer host.Close() + defer guest.Close() + credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: "synthetic-token"}} + done := make(chan error, 1) + go func() { + var request VsockMessage + if err := json.NewDecoder(host).Decode(&request); err != nil { + done <- err + return + } + if request.Type != "get_registry_credentials" { + done <- registryauth.ErrInvalid + return + } + done <- json.NewEncoder(host).Encode(VsockMessage{Type: "registry_credentials", RegistryCredentials: credentials}) + }() + got, err := fetchRegistryCredentials(json.NewEncoder(guest), json.NewDecoder(guest), "local.example:4973") + require.NoError(t, err) + require.NoError(t, <-done) + auths := registryAuthEntries("local.example:4973", "local-token", got) + require.Equal(t, "local-token", auths["local.example:4973"]["identitytoken"]) + require.Equal(t, base64.StdEncoding.EncodeToString([]byte("AWS:synthetic-token")), auths["registry.example"]["auth"]) + require.Len(t, auths, 2) + data, err := json.Marshal(map[string]any{"auths": auths}) + require.NoError(t, err) + directory := filepath.Join(t.TempDir(), ".docker") + require.NoError(t, writeRegistryConfig(directory, data)) + info, err := os.Stat(filepath.Join(directory, "config.json")) + require.NoError(t, err) + require.Equal(t, os.FileMode(0600), info.Mode().Perm()) + info, err = os.Stat(directory) + require.NoError(t, err) + require.Equal(t, os.FileMode(0700), info.Mode().Perm()) + // Rewriting config must not retain a previous build's external credentials. + data, err = json.Marshal(map[string]any{"auths": registryAuthEntries("local.example:4973", "next-local-token", nil)}) + require.NoError(t, err) + require.NoError(t, writeRegistryConfig(directory, data)) + written, err := os.ReadFile(filepath.Join(directory, "config.json")) + require.NoError(t, err) + require.NotContains(t, string(written), got["registry.example"].Auth()) + cleanupRegistryAuth(directory) + require.NoFileExists(t, filepath.Join(directory, "config.json")) +} + +func TestRegistryCredentialLogRedactionAcrossWrites(t *testing.T) { + oldStdout := os.Stdout + read, write, err := os.Pipe() + require.NoError(t, err) + os.Stdout = write + defer func() { os.Stdout = oldStdout; read.Close(); write.Close() }() + oldChan := logChan + logChan = make(chan string, 100) + defer func() { logChan = oldChan }() + credential := registryauth.Credential{Username: "AWS", Password: `synthetic-"secret"/+=`} + writer := newStreamingLogWriter() + writer.setRedactor(registryauth.Redactor(map[string]registryauth.Credential{"registry.example": credential})) + quoted, err := json.Marshal(credential.Password) + require.NoError(t, err) + input := "pull " + credential.Password + "\nconfig " + credential.Auth() + "\nquoted " + string(quoted) + for _, b := range []byte(input) { + _, err = writer.Write([]byte{b}) + require.NoError(t, err) + } + writer.markClosed() + require.NoError(t, write.Close()) + stdout, err := io.ReadAll(read) + require.NoError(t, err) + streamed := "" + for len(logChan) > 0 { + streamed += <-logChan + } + for _, output := range []string{string(stdout), streamed, writer.String(), writer.redactText(input)} { + require.NotContains(t, output, credential.Password) + require.NotContains(t, output, credential.Auth()) + require.NotContains(t, output, string(quoted)) + require.Equal(t, 3, strings.Count(output, "[REDACTED]")) + } +} diff --git a/lib/builds/images/generic/Dockerfile b/lib/builds/images/generic/Dockerfile index 937efb68e..3ea20e1f2 100644 --- a/lib/builds/images/generic/Dockerfile +++ b/lib/builds/images/generic/Dockerfile @@ -16,6 +16,7 @@ RUN go mod download # Copy the builder_agent and guest_agent sources COPY lib/builds/builder_agent/ ./lib/builds/builder_agent/ +COPY lib/builds/registryauth/ ./lib/builds/registryauth/ COPY lib/system/guest_agent/ ./lib/system/guest_agent/ # Only copy proto files for guest-agent (not client.go which has host-side deps) COPY lib/guest/guest.pb.go lib/guest/guest_grpc.pb.go ./lib/guest/ diff --git a/lib/builds/manager.go b/lib/builds/manager.go index 3e429bfe0..f7b3fb6a2 100644 --- a/lib/builds/manager.go +++ b/lib/builds/manager.go @@ -19,6 +19,7 @@ import ( "github.com/google/go-containerregistry/pkg/v1/tarball" "github.com/kernel/hypeman/lib/builders" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/kernel/hypeman/lib/images" "github.com/kernel/hypeman/lib/instances" "github.com/kernel/hypeman/lib/ocicache" @@ -143,6 +144,9 @@ func stripRegistryScheme(registryURL string) string { } type manager struct { + credentialsMu sync.Mutex + registryCredentials map[string]*borrowedBuildCredentials + config Config paths *paths.Paths queue *BuildQueue @@ -451,6 +455,12 @@ func (m *manager) CreateBuild(ctx context.Context, req CreateBuildRequest, sourc return nil, err } req.Tags = tags.Clone(req.Tags) + credentials, err := registryauth.Normalize(req.RegistryCredentials, m.config.RegistryURL, time.Now()) + if err != nil { + return nil, err + } + req.RequiresRegistryCredentials = len(credentials) > 0 + req.RegistryCredentials = nil // Apply defaults to build policy policy := req.BuildPolicy @@ -585,7 +595,9 @@ func (m *manager) CreateBuild(ctx context.Context, req CreateBuildRequest, sourc // Write build config for the builder agent buildConfig := &BuildConfig{ - JobID: id, + JobID: id, + RegistryCredentialsRequired: req.RequiresRegistryCredentials, + BaseImageDigest: req.BaseImageDigest, RegistryURL: m.config.RegistryURL, RegistryToken: registryToken, @@ -610,6 +622,10 @@ func (m *manager) CreateBuild(ctx context.Context, req CreateBuildRequest, sourc return nil, fmt.Errorf("write build config: %w", err) } + if req.RequiresRegistryCredentials { + m.holdRegistryCredentials(id, credentials) + } + // Enqueue the build. Builds sharing a builder are serialized by builder // ID so a waiting same-builder build stays pending instead of holding a // global concurrency slot while blocked on the builder's disk. @@ -740,6 +756,7 @@ func (m *manager) gcFinishedBuilds() { // runBuild executes a build in a builder VM func (m *manager) runBuild(ctx context.Context, id string, req CreateBuildRequest, policy *BuildPolicy) { start := time.Now() + defer m.releaseRegistryCredentials(id) m.logger.Info("starting build", "id", id) // Update status to building @@ -749,15 +766,33 @@ func (m *manager) runBuild(ctx context.Context, id string, req CreateBuildReques buildCtx, cancel := context.WithTimeout(ctx, time.Duration(policy.TimeoutSeconds)*time.Second) defer cancel() - // Mirror base images to the local registry before launching the VM. - // BuildKit is configured with our registry as a mirror for docker.io, - // so pre-cached images will be served locally without pulling from Docker Hub. - if err := m.mirrorBaseImagesForBuild(buildCtx, id, req); err != nil { - m.logger.Warn("failed to mirror base images", "id", id, "error", err) + redact := func(value string) string { return value } + var err error + if req.RequiresRegistryCredentials { + var credentials map[string]registryauth.Credential + var expires time.Time + credentials, expires, err = m.borrowRegistryCredentials(id) + if err == nil { + redact = registryauth.Redactor(credentials) + var deadlineCancel context.CancelFunc + buildCtx, deadlineCancel = context.WithDeadline(buildCtx, expires) + defer deadlineCancel() + } + } else if mirrorErr := m.mirrorBaseImagesForBuild(buildCtx, id, req); mirrorErr != nil { + m.logger.Warn("failed to mirror base images", "id", id, "error", mirrorErr) + } + // Private bases stay inside this build rather than entering the shared mirror. + var result *BuildResult + if err == nil { + result, err = m.executeBuild(buildCtx, id, req, policy) + } + if err != nil { + err = errors.New(redact(err.Error())) + } + if result != nil { + result.Logs = redact(result.Logs) + result.Error = redact(result.Error) } - - // Run the build in a builder VM - result, err := m.executeBuild(buildCtx, id, req, policy) // executeBuild's defers release the builder acquisition when it returns, // so same-builder builds may start while this build waits for image @@ -1002,7 +1037,7 @@ func (m *manager) executeBuild(ctx context.Context, id string, req CreateBuildRe // Wait for build result via vsock // The builder agent will send the result when complete - result, err := m.waitForResult(ctx, id, inst) + result, err := m.waitForResult(ctx, id, inst, req.RequiresRegistryCredentials) if err != nil { return nil, fmt.Errorf("wait for result: %w", err) } @@ -1011,7 +1046,7 @@ func (m *manager) executeBuild(ctx context.Context, id string, req CreateBuildRe } // waitForResult waits for the build result from the builder agent via vsock -func (m *manager) waitForResult(ctx context.Context, buildID string, inst *instances.Instance) (*BuildResult, error) { +func (m *manager) waitForResult(ctx context.Context, buildID string, inst *instances.Instance, requiresRegistryCredentials bool) (*BuildResult, error) { // Wait a bit for the VM to start and the builder agent to listen on vsock time.Sleep(3 * time.Second) @@ -1073,6 +1108,15 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta } m.logger.Debug("host_ready sent, waiting for agent messages", "instance", inst.Id) + credentialsDelivered := false + redact := func(value string) string { return value } + if requiresRegistryCredentials { + credentials, _, err := m.borrowRegistryCredentials(buildID) + if err != nil { + return nil, err + } + redact = registryauth.Redactor(credentials) + } // Handle messages from agent until we get the build result for { // Use a goroutine for decoding so we can respect context cancellation. @@ -1101,9 +1145,26 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta } } + if requiresRegistryCredentials && !credentialsDelivered && dr.response.Type != "get_registry_credentials" { + return nil, fmt.Errorf("builder does not support borrowed registry credentials; update the builder image") + } + dr.response.Log = redact(dr.response.Log) + if dr.response.Result != nil { + dr.response.Result.Logs = redact(dr.response.Result.Logs) + dr.response.Result.Error = redact(dr.response.Result.Error) + } // Handle message based on type - m.logger.Debug("received message from agent", "type", dr.response.Type, "instance", inst.Id) + m.logger.Debug("received message from agent", "type", redact(dr.response.Type), "instance", inst.Id) switch dr.response.Type { + case "get_registry_credentials": + credentials, _, err := m.borrowRegistryCredentials(buildID) + if err != nil { + return nil, err + } + if err := encoder.Encode(VsockMessage{Type: "registry_credentials", RegistryCredentials: credentials}); err != nil { + return nil, fmt.Errorf("send registry credentials: %w", err) + } + credentialsDelivered = true case "get_secrets": // Agent is requesting secrets m.logger.Debug("agent requesting secrets", "instance", inst.Id, "secret_ids", dr.response.SecretIDs) @@ -1137,7 +1198,7 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta return dr.response.Result, nil default: - m.logger.Warn("unexpected message type from agent", "type", dr.response.Type) + m.logger.Warn("unexpected message type from agent", "type", redact(dr.response.Type)) } } } @@ -1179,6 +1240,7 @@ func (m *manager) updateStatus(id string, status string, err error) error { // updateBuildComplete updates the build with final results func (m *manager) updateBuildComplete(id string, status string, digest *string, errMsg *string, provenance *BuildProvenance, durationMS *int64) { + m.releaseRegistryCredentials(id) meta, readErr := readMetadata(m.paths, id) if readErr != nil { m.logger.Error("read metadata for completion", "id", id, "error", readErr) @@ -1328,6 +1390,7 @@ func (m *manager) CancelBuild(ctx context.Context, id string) error { if !cancelled { return ErrBuildInProgress // Was already picked up } + m.releaseRegistryCredentials(id) return nil case StatusBuilding, StatusPushing: @@ -1336,7 +1399,11 @@ func (m *manager) CancelBuild(ctx context.Context, id string) error { if meta.BuilderInstance != nil { m.instanceManager.DeleteInstance(ctx, *meta.BuilderInstance) } - return m.updateStatus(id, StatusCancelled, nil) + err := m.updateStatus(id, StatusCancelled, nil) + if err == nil { + m.releaseRegistryCredentials(id) + } + return err case StatusReady, StatusFailed, StatusCancelled: return fmt.Errorf("build already completed with status: %s", meta.Status) @@ -1536,6 +1603,19 @@ func (m *manager) RecoverPendingBuilds() { for _, meta := range pending { meta := meta // Shadow loop variable for closure capture m.logger.Info("recovering build", "id", meta.ID, "status", meta.Status) + if meta.Request != nil && meta.Request.RequiresRegistryCredentials { + if _, _, err := m.borrowRegistryCredentials(meta.ID); err == nil { + continue // Already queued in this process with live credentials. + } + if meta.BuilderInstance != nil { + if err := m.instanceManager.DeleteInstance(context.Background(), *meta.BuilderInstance); err != nil { + m.logger.Error("delete interrupted credentialed builder", "id", meta.ID, "error", err) + } + } + errMsg := errRegistryCredentialsUnavailable.Error() + m.updateBuildComplete(meta.ID, StatusFailed, nil, &errMsg, nil, nil) + continue + } // Re-enqueue the build if meta.Request != nil { diff --git a/lib/builds/registry_credentials.go b/lib/builds/registry_credentials.go new file mode 100644 index 000000000..51f316620 --- /dev/null +++ b/lib/builds/registry_credentials.go @@ -0,0 +1,61 @@ +package builds + +import ( + "errors" + "maps" + "time" + + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/kernel/hypeman/lib/images" +) + +var errRegistryCredentialsUnavailable = errors.New("build registry credentials expired or unavailable; submit a new build with fresh credentials") + +type borrowedBuildCredentials struct { + credentials map[string]registryauth.Credential + expiresAt time.Time + timer *time.Timer +} + +func (m *manager) holdRegistryCredentials(id string, credentials map[string]registryauth.Credential) { + expires := time.Now().Add(images.DefaultBorrowedCredentialsTimeout) + for _, c := range credentials { + if c.ExpiresAt != nil && c.ExpiresAt.Before(expires) { + expires = *c.ExpiresAt + } + } + m.credentialsMu.Lock() + defer m.credentialsMu.Unlock() + if m.registryCredentials == nil { + m.registryCredentials = make(map[string]*borrowedBuildCredentials) + } + entry := &borrowedBuildCredentials{credentials: credentials, expiresAt: expires} + m.registryCredentials[id] = entry + entry.timer = time.AfterFunc(time.Until(expires), func() { m.releaseRegistryCredentials(id) }) +} + +func (m *manager) borrowRegistryCredentials(id string) (map[string]registryauth.Credential, time.Time, error) { + m.credentialsMu.Lock() + defer m.credentialsMu.Unlock() + entry := m.registryCredentials[id] + if entry == nil || !time.Now().Before(entry.expiresAt) { + return nil, time.Time{}, errRegistryCredentialsUnavailable + } + credentials := maps.Clone(entry.credentials) + for host, credential := range credentials { + expires := entry.expiresAt + credential.ExpiresAt = &expires + credentials[host] = credential + } + return credentials, entry.expiresAt, nil +} + +func (m *manager) releaseRegistryCredentials(id string) { + m.credentialsMu.Lock() + defer m.credentialsMu.Unlock() + if entry := m.registryCredentials[id]; entry != nil { + entry.timer.Stop() + entry.credentials = nil + delete(m.registryCredentials, id) + } +} diff --git a/lib/builds/registry_credentials_test.go b/lib/builds/registry_credentials_test.go new file mode 100644 index 000000000..645ecf806 --- /dev/null +++ b/lib/builds/registry_credentials_test.go @@ -0,0 +1,160 @@ +package builds + +import ( + "context" + "encoding/json" + "net" + "os" + "strings" + "testing" + "time" + + "github.com/kernel/hypeman/lib/builds/registryauth" + "github.com/kernel/hypeman/lib/hypervisor" + "github.com/kernel/hypeman/lib/instances" + "github.com/stretchr/testify/require" +) + +func TestBuildRegistryCredentialsLifetime(t *testing.T) { + for _, outcome := range []string{"cancel", "complete", "expire", "restart"} { + t.Run(outcome, func(t *testing.T) { + mgr, instanceMgr, _, dir := setupTestManager(t) + defer os.RemoveAll(dir) + mgr.queue = NewBuildQueue(1) + mgr.queue.active["occupied"] = true + const secret = "synthetic-build-secret" + credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: secret}} + build, err := mgr.CreateBuild(context.Background(), CreateBuildRequest{ + Dockerfile: "FROM registry.example/base:1", RegistryCredentials: credentials, + }, []byte("source")) + require.NoError(t, err) + t.Cleanup(func() { mgr.releaseRegistryCredentials(build.ID) }) + credentials["registry.example"] = registryauth.Credential{} + borrowed, deadline, err := mgr.borrowRegistryCredentials(build.ID) + require.NoError(t, err) + require.Equal(t, secret, borrowed["registry.example"].Password) + require.WithinDuration(t, time.Now().Add(30*time.Minute), deadline, time.Second) + for _, path := range []string{mgr.paths.BuildMetadata(build.ID), mgr.paths.BuildConfig(build.ID)} { + data, err := os.ReadFile(path) + require.NoError(t, err) + require.NotContains(t, string(data), secret) + require.NotContains(t, string(data), borrowed["registry.example"].Auth()) + } + config, err := readBuildConfig(mgr.paths, build.ID) + require.NoError(t, err) + require.True(t, config.RegistryCredentialsRequired) + mgr.RecoverPendingBuilds() + fresh, err := mgr.GetBuild(context.Background(), build.ID) + require.NoError(t, err) + require.Equal(t, StatusQueued, fresh.Status) + switch outcome { + case "cancel": + require.NoError(t, mgr.CancelBuild(context.Background(), build.ID)) + case "complete": + mgr.updateBuildComplete(build.ID, StatusReady, nil, nil, nil, nil) + case "expire": + mgr.credentialsMu.Lock() + mgr.registryCredentials[build.ID].expiresAt = time.Now().Add(-time.Second) + mgr.credentialsMu.Unlock() + meta, err := readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + mgr.instanceManager = nil // Must fail before any VM can launch. + mgr.runBuild(context.Background(), build.ID, *meta.Request, &BuildPolicy{TimeoutSeconds: 5}) + meta, err = readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + require.Equal(t, StatusFailed, meta.Status) + case "restart": + mgr.releaseRegistryCredentials(build.ID) + meta, err := readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + instanceID := "old-builder" + meta.BuilderInstance = &instanceID + require.NoError(t, writeMetadata(mgr.paths, meta)) + mgr.queue = NewBuildQueue(1) + mgr.RecoverPendingBuilds() + meta, err = readMetadata(mgr.paths, build.ID) + require.NoError(t, err) + require.Equal(t, StatusFailed, meta.Status) + require.Equal(t, 1, instanceMgr.deleteCallCount) + require.Zero(t, mgr.queue.QueueLength()) + } + _, _, err = mgr.borrowRegistryCredentials(build.ID) + require.ErrorIs(t, err, errRegistryCredentialsUnavailable) + }) + } +} + +func TestRegistryCredentialExpiryReleasesMemory(t *testing.T) { + mgr, _, _, dir := setupTestManager(t) + defer os.RemoveAll(dir) + expires := time.Now().Add(50 * time.Millisecond) + mgr.holdRegistryCredentials("expired", map[string]registryauth.Credential{ + "registry.example": {Username: "AWS", Password: "synthetic-token", ExpiresAt: &expires}, + }) + defer mgr.releaseRegistryCredentials("expired") + require.Eventually(t, func() bool { + mgr.credentialsMu.Lock() + defer mgr.credentialsMu.Unlock() + return mgr.registryCredentials["expired"] == nil + }, time.Second, 5*time.Millisecond) +} + +type credentialTestDialer struct{ net.Conn } + +func (d credentialTestDialer) DialVsock(context.Context, int) (net.Conn, error) { return d.Conn, nil } +func (d credentialTestDialer) Key() string { return "registry-auth-test" } + +func TestRegistryCredentialsVsock(t *testing.T) { + for _, supported := range []bool{true, false} { + t.Run(map[bool]string{true: "handoff", false: "old-builder"}[supported], func(t *testing.T) { + mgr, instanceMgr, _, dir := setupTestManager(t) + defer os.RemoveAll(dir) + credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: `synthetic-"secret"`}} + mgr.holdRegistryCredentials("build", credentials) + defer mgr.releaseRegistryCredentials("build") + require.NoError(t, os.MkdirAll(mgr.paths.BuildDir("build"), 0755)) + host, guest := net.Pipe() + defer guest.Close() + instanceMgr.vsockDialerFunc = func(context.Context, string) (hypervisor.VsockDialer, error) { return credentialTestDialer{host}, nil } + done := make(chan error, 1) + go func() { + decoder, encoder := json.NewDecoder(guest), json.NewEncoder(guest) + var message VsockMessage + if err := decoder.Decode(&message); err != nil { + done <- err + return + } + if supported { + if err := encoder.Encode(VsockMessage{Type: "get_registry_credentials"}); err != nil { + done <- err + return + } + if err := decoder.Decode(&message); err != nil { + done <- err + return + } + if message.RegistryCredentials["registry.example"].Password != credentials["registry.example"].Password { + done <- registryauth.ErrInvalid + return + } + if err := encoder.Encode(VsockMessage{Type: "log", Log: credentials["registry.example"].Auth()}); err != nil { + done <- err + return + } + } + done <- encoder.Encode(VsockMessage{Type: "build_result", Result: &BuildResult{Success: true, Logs: credentials["registry.example"].Password}}) + }() + result, err := mgr.waitForResult(context.Background(), "build", &instances.Instance{StoredMetadata: instances.StoredMetadata{Id: "vm"}}, true) + require.NoError(t, <-done) + if !supported { + require.ErrorContains(t, err, "update the builder image") + return + } + require.NoError(t, err) + require.Equal(t, "[REDACTED]", result.Logs) + data, err := os.ReadFile(mgr.paths.BuildLog("build")) + require.NoError(t, err) + require.False(t, strings.Contains(string(data), credentials["registry.example"].Auth())) + }) + } +} diff --git a/lib/builds/registryauth/credentials.go b/lib/builds/registryauth/credentials.go new file mode 100644 index 000000000..93f51d835 --- /dev/null +++ b/lib/builds/registryauth/credentials.go @@ -0,0 +1,101 @@ +// Package registryauth describes credentials borrowed by a single build. +package registryauth + +import ( + "encoding/base64" + "encoding/json" + "errors" + "net/url" + "sort" + "strings" + "time" + + "github.com/google/go-containerregistry/pkg/name" +) + +const MaxBytes = 64 * 1024 + +var ErrInvalid = errors.New("invalid registry_credentials: use registry hosts and nonempty username/password pairs with a future expires_at") + +type Credential struct { + Username string `json:"username"` + Password string `json:"password"` + ExpiresAt *time.Time `json:"expires_at,omitempty"` +} + +// String prevents accidental formatting of a credential from disclosing its value. +func (Credential) String() string { return "[registry credential]" } + +// Normalize validates hosts, rejects local-registry overrides, and copies caller-owned values. +func Normalize(credentials map[string]Credential, localRegistry string, now time.Time) (map[string]Credential, error) { + if len(credentials) == 0 { + return make(map[string]Credential), nil + } + if len(credentials) > 16 { + return nil, ErrInvalid + } + localRegistry = strings.TrimPrefix(strings.TrimPrefix(localRegistry, "https://"), "http://") + local, err := name.NewRegistry(strings.ToLower(localRegistry)) + if err != nil { + return nil, ErrInvalid + } + out := make(map[string]Credential, len(credentials)) + size := 0 + for host, credential := range credentials { + size += len(host) + len(credential.Username) + len(credential.Password) + u, err := url.Parse("https://" + host) + if err != nil || u.Host != host || u.Hostname() == "" || u.User != nil || u.Path != "" || u.RawQuery != "" || u.Fragment != "" || strings.ContainsAny(host, " \t\r\n") { + return nil, ErrInvalid + } + registry, err := name.NewRegistry(strings.ToLower(host)) + if err != nil || registry.Name() == local.Name() || size > MaxBytes || credential.Username == "" || credential.Password == "" || strings.ContainsAny(credential.Username+credential.Password, "\r\n") { + return nil, ErrInvalid + } + if credential.ExpiresAt != nil { + expires := *credential.ExpiresAt + if !expires.After(now) { + return nil, ErrInvalid + } + credential.ExpiresAt = &expires + } + if _, exists := out[registry.Name()]; exists { + return nil, ErrInvalid + } + out[registry.Name()] = credential + } + return out, nil +} + +func DockerKey(host string) string { + if host == name.DefaultRegistry { + return "https://index.docker.io/v1/" + } + return host +} + +func (c Credential) Auth() string { + return base64.StdEncoding.EncodeToString([]byte(c.Username + ":" + c.Password)) +} + +// Redactor covers raw, JSON-escaped, URL-encoded, and Docker-config representations. +func Redactor(credentials map[string]Credential) func(string) string { + values := make(map[string]bool) + for _, c := range credentials { + quoted, _ := json.Marshal(c.Password) + for _, value := range []string{c.Password, c.Auth(), base64.StdEncoding.EncodeToString([]byte(c.Password)), string(quoted[1 : len(quoted)-1]), url.QueryEscape(c.Password), url.PathEscape(c.Password)} { + if value != "" { + values[value] = true + } + } + } + keys := make([]string, 0, len(values)) + for key := range values { + keys = append(keys, key) + } + sort.Slice(keys, func(i, j int) bool { return len(keys[i]) > len(keys[j]) }) + pairs := make([]string, 0, len(keys)*2) + for _, key := range keys { + pairs = append(pairs, key, "[REDACTED]") + } + return strings.NewReplacer(pairs...).Replace +} diff --git a/lib/builds/registryauth/credentials_test.go b/lib/builds/registryauth/credentials_test.go new file mode 100644 index 000000000..064aaba0a --- /dev/null +++ b/lib/builds/registryauth/credentials_test.go @@ -0,0 +1,41 @@ +package registryauth + +import ( + "encoding/base64" + "encoding/json" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +func TestNormalizeAndRedact(t *testing.T) { + expires := time.Now().Add(time.Hour) + password := `synthetic-"secret"/+=` + input := map[string]Credential{"REGISTRY.EXAMPLE": {Username: "AWS", Password: password, ExpiresAt: &expires}} + got, err := Normalize(input, "http://local.example:4973", time.Now()) + require.NoError(t, err) + require.Equal(t, password, got["registry.example"].Password) + input["REGISTRY.EXAMPLE"] = Credential{} + expires = time.Time{} + require.True(t, got["registry.example"].ExpiresAt.After(time.Now())) + redact := Redactor(got) + quoted, err := json.Marshal(password) + require.NoError(t, err) + for _, value := range []string{password, string(quoted), base64.StdEncoding.EncodeToString([]byte("AWS:" + password))} { + require.NotContains(t, redact("before "+value+" after"), value) + require.Contains(t, redact(value), "[REDACTED]") + } + for _, host := range []string{"https://registry.example", "registry.example/path", "registry.example?x=y", "user:pass@registry.example", "local.example:4973", "registry.example\n"} { + _, err := Normalize(map[string]Credential{host: {Username: "AWS", Password: password}}, "local.example:4973", time.Now()) + require.ErrorIs(t, err, ErrInvalid) + require.NotContains(t, err.Error(), password) + } + for _, credential := range []Credential{{Username: "AWS"}, {Password: password}, {Username: "AWS", Password: "line\nbreak"}, {Username: "AWS", Password: password, ExpiresAt: &expires}, {Username: "AWS", Password: strings.Repeat("x", MaxBytes+1)}} { + _, err := Normalize(map[string]Credential{"registry.example": credential}, "local.example:4973", time.Now()) + require.ErrorIs(t, err, ErrInvalid) + } + _, err = Normalize(map[string]Credential{"docker.io": {Username: "u", Password: "p"}, "index.docker.io": {Username: "u", Password: "p"}}, "local.example:4973", time.Now()) + require.ErrorIs(t, err, ErrInvalid) +} diff --git a/lib/builds/types.go b/lib/builds/types.go index 4ad6008e9..f79edff71 100644 --- a/lib/builds/types.go +++ b/lib/builds/types.go @@ -6,6 +6,7 @@ import ( "fmt" "time" + "github.com/kernel/hypeman/lib/builds/registryauth" "github.com/kernel/hypeman/lib/tags" ) @@ -39,6 +40,11 @@ type Build struct { // CreateBuildRequest represents a request to create a new build type CreateBuildRequest struct { + // RegistryCredentials are borrowed for this build and never serialized to disk. + RegistryCredentials map[string]registryauth.Credential `json:"-"` + // RequiresRegistryCredentials makes interrupted builds fail closed on recovery. + RequiresRegistryCredentials bool `json:"requires_registry_credentials,omitempty"` + // Dockerfile content. Required if not included in the source tarball. // The Dockerfile specifies the runtime (e.g., FROM node:20-alpine). Dockerfile string `json:"dockerfile,omitempty"` @@ -133,6 +139,8 @@ type BuildProvenance struct { // BuildConfig is the configuration passed to the builder VM via config disk // This is read by the builder agent inside the guest type BuildConfig struct { + RegistryCredentialsRequired bool `json:"registry_credentials_required,omitempty"` + // JobID is the build job identifier JobID string `json:"job_id"` diff --git a/lib/builds/vsock_handler.go b/lib/builds/vsock_handler.go index f5aebfcd9..c0815ab0c 100644 --- a/lib/builds/vsock_handler.go +++ b/lib/builds/vsock_handler.go @@ -2,6 +2,8 @@ package builds import ( "context" + + "github.com/kernel/hypeman/lib/builds/registryauth" ) const ( @@ -14,6 +16,8 @@ const ( // VsockMessage is the envelope for vsock communication with builder agents type VsockMessage struct { + RegistryCredentials map[string]registryauth.Credential `json:"registry_credentials,omitempty"` + Type string `json:"type"` Result *BuildResult `json:"result,omitempty"` Log string `json:"log,omitempty"` diff --git a/lib/oapi/oapi.go b/lib/oapi/oapi.go index 4c604c755..fba91d5ad 100644 --- a/lib/oapi/oapi.go +++ b/lib/oapi/oapi.go @@ -2005,6 +2005,20 @@ type CreateBuildMultipartBody struct { // MemoryMb Memory limit for builder VM in MB (default 2048) MemoryMb *int `json:"memory_mb,omitempty"` + // RegistryCredentials JSON object mapping exact registry hosts (no scheme or path) to + // objects with required username/password strings and optional RFC3339 + // expires_at. At most 16 registries; credentials + // cannot override Hypeman's local output registry. No CR/LF in values. + // Held in host memory for at most 30 minutes from submission, or the + // earliest expires_at, including queue time. Passed to the ephemeral + // builder's Docker auth config over vsock, never saved in host build + // metadata/config, and removed at build completion/cancellation. + // Requires an updated builder image. No automatic refresh or restart + // recovery: resubmit interrupted/expired builds with fresh credentials. + // Credentialed builds pull directly in BuildKit rather than populating + // the shared base-image mirror. Omit or use {} for existing behavior. + RegistryCredentials *string `json:"registry_credentials,omitempty"` + // Secrets JSON array of secret references to inject during build. // Each object has "id" (required) for use with --mount=type=secret,id=... // Example: [{"id": "npm_token"}, {"id": "github_token"}] @@ -19326,397 +19340,404 @@ func (sh *strictHandler) GetVolume(w http.ResponseWriter, r *http.Request, id st // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+y9+3IbN7Y3+ioonv1VpD0kRV18Uyr1Hcd2HO1EsbZle749oQ8FdoMkRt1AB0DTZlKu", - "On/NA0ydJ5wnObUWgL4RTbZkS7InrqmayGw0GpeFhXX9rT96kUwzKZgwunf8R09HC5ZS/POxMTRavJFJ", - "nrKX7LecaQM/Z0pmTBnOsFEqc2EmGTUL+FfMdKR4ZrgUvePeGTUL8m7BFCNL7IXohcyTmEwZwfdY3Ov3", - "2HuaZgnrHff2UmH2Ympor98zqwx+0kZxMe996PcUo7EUycp+ZkbzxPSOZzTRrN/47Cl0Tagm8MoA3yn6", - "m0qZMCp6H7DH33KuWNw7/rU6jbdFYzn9O4sMfPxxbuS5oSKers5kwqPV+mR/5iJ/j18jNDcypYZHRNt3", - "SIYvkSnVLCZSEBoZvmSEi6nMRUxePTkjkRSCRdCZHgs51UwtWUxmSqbELBhZSG2wjVE0uiSGThM2HIte", - "v7EfTMCTePsq/XXBzIKpwGC5Jq4XMpOKmAXXhAt4GrFhdcOMytn6yvZ7PE7YxPCUydysL9SP8h1JpJjj", - "tHy/JM21IQu6ZOR3piT5LacJn624mLcv0pTNpGLkx1XGUipIltCIacIN4cJIPxu7RiWN3UtDxMXnQio2", - "iZk2XFDof5JJZfT66F/gHzQhlbY4NGxPzIIaT+VCGnLJWFafKH1HL+vL+OvBQf/RaDR62+9xw1J7rOh7", - "nuZp7/j+vXuH9/q9lAv77/1i9FwYNmeq96H4hSpFV5XpaJmriE0iHqtNM4kSzoQhT06evrzmBHr7oyH+", - "b+9hr9/bf3Qw3L//EP+9f79XndbawtdH/mHz0Ts31OR6nQfZ0zRxhDKpEMn6rH/J0ylTRM5IlCvFhElW", - "BI8UizsQXW3ao9BWRFLM+DxXLF7/tj9yteVcUE2osExj0OAXZWedzl0ETCyW78REsZRyAWu8NoiX/hGB", - "E0rcIYIhRVIYJZMEmIIxLM2M9qeoD2xcEJplCY+Q9dQO1VE60r1+T+RJQqdrIyx3myV8zrFBp6XhurJJ", - "/l1iJGHCMFWc8C5LU2OLbR8ulzu4GyVf7PTJhUziSS4MT9a/+hp+dmta/RLXZMGSmMjZrE/4jFACvcDP", - "lsbry34wOrg/GB0NRvdf7T84Hj06Ht37W6/fm0mVUtM77sXUsAHscpe9QaatuYjCuyOaJJLChaRYZHen", - "uLBqGzhlkUwZga43jvzo40feet08KTcVGhLXsLxZA1s9bFwZ3ag7odoUTAj3i5vVhAbG9IqnTBuaZsCH", - "YAyVxWzjQr7D5j74ld+4wPsftcCCvTcTt0LB+YTog73PWAQ3ovTcpBAwoD9H3gXLuhUaV4xqKayYBJfp", - "r71c6DyDq5vFkyyhBvrt9XuWDCYp1xpeLX6IubZ8pN/zRD4R0kxULoRtKJh5J9VltaXrZcKzXr+3oHqy", - "nGd5r7/p2qoTNX6CJTTT2J/bcTVhSknVs6LxajKTym9S7211CTd0tbZCurhiAyvU6/dqC1Cwcz8XP+5i", - "V4OD6/fcXxNltQrszk5mfeDVvtaHWwxtM2O3t4gVov02E/eyrnOAmNO5kNrwSHdi8yg8wPamMg6wzqdF", - "d4THTBg+40w5uZoRBfdDyojvhEAnhAuS68Y5KET/CVsyYfRkeTQxUba+KA3Fprp5FdmkvBErt3Kx/cVJ", - "2UKk9bkHFacl5Xgmn7Ilj9i67Oa2ZhIrvmQqwL4LAcCyQtuO7MBZBxYipGC7tZUSSx5z2oUdxDimCQ9Q", - "z9mTE2Ifk5OnZGfB3tc/cvBg+rDX3qWgaYAWfsxTKgZwIGBYvn9sW+3756NQz1ymaT6ZK5ln6z2fvDg9", - "fU3wIREo4VZ7fHgQklSziE9oHCumdXj+/mF1bKPRaHRMD45Ho+EoNMolE7FUrUtqH4eXdH8Usw1ddlpS", - "1//akv7y5uTpyWPyRKpMKtTZth6c6vJU51Ulm/quhOj/+5wn8TrVT+Fn1rJOTGmuDROGfG+bEcWsKkfe", - "LaRmJKLRgpGpVVpQPcf+upB88WF/e4VG8JTrTCKfJ29OS2kOVUP2nkW5qX33WxJzbbiInFBVmVyHEYH5", - "KWFw/4YkC1wB4tpwKYjxotO1hYBIMbrlc9Ci08fWz39uyWuS6rbefRPCBUl5knDNIiliXf0GF+b+Uftk", - "KqfYXptrn3oGP5OUaU3njOygWQrVDcvhCddkRnnC4t1uEnbbZP4up5V7rXbmkAwGdBrtHxwGGVpK52wS", - "87mzKzZpEH4H+Rj6MYSnrRNBCaPbPPCTis3Wv/cD3if4EcVmTDERffTnMiWXTFCnUv0Hfrf3f+2VBtc9", - "Z23dw8U8K5t/6Pd+y1nOJpnU3I5wjU24J0BGuNQE3wiPGR/Fu50oShuqNp8PbPEJTmIpbG5dG2f6AXmL", - "zre+8graNBk6sqNCwKlwgVa+/QwkrYDIIoVhIrA6P8s5SbiwahATxu0FCnurjH2XyPlu75OtQ7H864cf", - "xn0N5mV/aOkNnvULrSCR8+pqLhhVZspqi9lyr7qOytG1Lv9Z7fg0LlCq2WQzBznjQrAYbe7uYNuWIFsH", - "dR88RZfcTJZwA4fOHA7rJ26Ia9HaVSKjyxlP2GRB9cKOmMYxtwbXs9pMAiJkzZlB0UjgO0TRBpXq8x8f", - "H9y7T9wHAmvorL/QYH0mlbehe9uWGKqmNEmCtNFOble/o9cpJEwBpcG37e4pKNATpuV0PbebTnnP9cL+", - "hbwbRoV3X6/fi4C8Evh7jXD7vfcD6HWwpApXHbqvDOu//Zcqv31ffrTy61nx/cqPL91QKj/94EdV+e1J", - "OUC/KkytnwenpuGkw1Kl5MIMuMAtAAHcWZ6mdvMKLctZMogUFQmPqS7sfJNg9WRNpCI7L394cnh4+Gi3", - "u3DF9eVE89/ZZD7dKDe7QTtBGV4j8Brhgsz5nE5XhukheUKFkAackdGCijmLCZ0ZeMuNtaaA3xttc8K0", - "CklMtYlI5vcj+ujh+/fUPLrP3+lHv6dTNf/7Ie21WRdz3bK+aIGjbjehKVFUBDbxehd1St+D5m+pJOT8", - "PLXuKlI0cnugm0MYklKhn/H3sOaG7NdWOri4Ye2vcGEJKQa54L/luNtZQlfrOqBhNB0gRYSW1/INe4D0", - "9uOj4fzYd/xM31Fu4OQUPlM35T6RSQz3zowrbXrdvWFXEgyY+lQiUu2UhSWmdYpoLmDrpV6Ms/WsJHzG", - "olWUsHXm7tl3pnJnbo0Z3Dn4Z2FA7MrGmQpwYv/jWfGJ2s9Py+/Vfn9mP/6h33tCMzrlCfecuc6nnU9+", - "4gx/23ap2tlT++pL9+aHfm/GqMkVC6zlOcYHEGsnHiRsyRLiWgPxHpPHZydE52qGLnOkVtsWzPZSMz0W", - "is2pihOmkdTfLXi0KMyVYHrQhIoyLIA8Tt7RlSaZYpoJczwW48JCrse9Phlb5cv9banE/m1DQ3wjMVdM", - "u3+ArWHc60NfiZzrcW9IfpTaDEBddrLUMRk7e4we98iO/ZNkVGuzUDKfL8YipYLOWcqE6RMM0kAzMHCm", - "ZLVLqIjJuKekZsbQAUvzBHk/dPY4yxI2Fuc84ZEUJKXRi3P37jtuFuSlfalyeeKM4bLuk8yZnjVN2VhQ", - "awaFnVyRTMkpIwnNRbRgmjAxkypiu0NyxtTAL7HfW0IVg82wRlySCzgijJaboX99S5gwykU6dGcuMJOr", - "0B8sfaFE66u8eWLf+FB4R67y8i/uFWBVbsZBHUWtSmt6hZ7tjViY+v11VPME9McCVxR3lUOrd4LUtmyW", - "0DmSSuUQWWLUYxHJNEVFz32FaLZkiibFDsEdJ9GeAHeDu5HGIkpkHg8Wq4ypJddS9eGGYBEGI6g++Y2l", - "eR8/Cn8NUh4puUyJFGORABnv0TS+f7Q7JI9JwjUQh58/t8TtSAw5AdoDOIx23KPeJj/u2YlxTeDiH5Jn", - "wihuaY5oS3BTe5M2iKvr5lWY1drdhvtzlc7O7RtrHg77syPo/hqLrdBNSYAFGVe4aOjO2sCA12Vwv66b", - "nVFufMVuRVS4napR5zHhhtAsY1RpwsVYlNQkYqRS91KmGC6H5sZtXcoM2UmpQfYCVtuxQA7xjSa13d8d", - "EpQbbXxYyZHgFaJYsrIDYmPhx/yOJwkaDkmOEQzI4exBQ8tYJYICDxMVBe9LSm+Xc345v2htArUjYr/9", - "389OXxO90oalZMoFVatdwnXJay1prjvmwiKj2z3U3FFUq886lhj1BO8SKeoCZPO8bnUhOBG0pIttFPaj", - "DIVYUhUtQmF02pAnZ68JPOaGRUDEtfFSld4PupKkbukOvkpRiLXrXesOmc7WOUs4UjjibZM9Ke6RsIhU", - "uOPXvV3wZsWPyxIWAa+y8TRWf2PEOZeJTJGlC7Y+m73WJfKd621f12RH6j2Y8G7lZoEzrXIxJC8EQTGC", - "1KSIscCmXERJHjNNKvyclOZbL1/UwqAKsh+Lf/2//5+VJWKy5LSQNsgbrgzEkPxutdiZoikDple/0qIF", - "iy7HoimGEOhVS0L9pVIsM9fVC0Xx+cIQId8Nx+LEjqkY8I6WM/OOKpZnoGaSwcCNeuDkrF0bxIUdcdMI", - "0fy1sTeVxbliLGHNnVdsaH+dwraR6i+l2FKn1Tk17B0NKMTPgfQGS64xZA1pwrUlJ2dDgo/RlRAt7FPg", - "oiDFkh1LFVzMxwKfOJF4lziJ1pKZc00OyYuUm4L4hSyuF3fTjQUEGE4ZE+hFTJY2ALkk1RVrbgBEc+6D", - "g3e4Hzoacxj7xMjJPA/aXf1dF3PFIkPenA6MHLw5JUbR2YxHQEcZU27U9oJpDjrIzyHGIGlZaf+iD6FI", - "hqBkKB7PQciB5XKiv/3NXk4ZUzCuV4/P4ILD1f+WjHuCGvtOyekH4MnhMYvJL49fwdUavTjfdavmVFPb", - "cQ+unZARvN/T+VQw0zZ++xRjcMNbgaG025ivXaK1LdpG3h8n0cDFbzv4ZoNMUnIwkE5AiC1IcEh+rsmv", - "9oUicAVE0HWJvujBH+JvSTHa71CgISmjQhPqZP3KiAjXY+Glj5rAAZI2cSsKr6pcWC5l78NBhfuiWGLl", - "EZTIiiD9Jfz/YKlldOlCPKyWWXBaQVM83dWlW5OsuOkk5Gw1AVQUlsCS+q/XBE/QEbSgmV5Ig1q1/8ee", - "YtpIxXZBOXfxUvA8o7lm5C8kZalUq7Hw7fv2nCXU2BiG4t0ZMKYe2YkSKVjVjmADCOhYaCOzjMXOMfEt", - "mbnDTYsgQqkKW7VtNBbuE3rPSgCaFLPADSg9MMmq3OTKTHbR1ICzKaYFc85TO+yFNFmSzwdunj2yk/Al", - "c9OGCfLfme0DvChSioGLh4Smpe0EHxFD1ZwZZ3rW2D/SzLg3Fjt4bgn+GxwraS54hLc5tptn+aBq4uiR", - "nednr/fKmKWxqDzGV8CoN+BykPCUA3vbgR/Iyd4LouCGxp+5mNvRY2M7nWKS2N5NcUje0CR35xSpHdZ3", - "LLz0jyMdGJWbxSxPjsnydyeE1fej2MlCKto/7DtLU4IWplZJ5s0p0XTJPEHiW6BSawPHiMZLpgzXzhp7", - "SXYcOQ2cnwvpThPBWEyEHItqX3CQkUxhiE2Rn1hDjCaNRRqLUmxrRJL7q827DAtThBd8ultsNms0LT6G", - "j9darqAinxdKfeMiyXi7VxVskXhQaFQuU0V/ZeRFxgS0imWUp0wYwsVM+qb1KLLR8KAtMq3l8+fVa6X4", - "vF5IZcicG6IYiHFSOG427g1irgwcf53PZvw9apE5WoGsTIM96T5wqHEvF5dCvhPjXn2YD+7Tg1k8Pdy6", - "G37Y/doaBvcBmZ6zSrfm6232oT3Z6DADUZMYCbpzVfN3FP4J3GVlShJcemoAZyXhLK7Qdt9G686ZYMC5", - "YhsDaoiX0FpcPoOgKHvjXqUreWJadtRGzrZu6JY5zBM5xQvPT6QMOh2Sk/ra9QnFBygw11e5yJaoBIaS", - "HTacD+F2ySI+gMjQAT0YjEaDUZPak6OBDXnPqDFMwQD/n1/p4PfHg7+NBo/eln9OhoO3f/mPoELeMVrV", - "+7XdPHf8WeoTP9hqCGtzoNvCW6/tWasOv/3wommhdacjxfAY0GTrGCDi4EmleTutPzlZj3qzKxVLsEMP", - "udxL+FRRtdoTcy7eH4M4p0193Ta33WRgCSTHWMHINyBUE2dh+XVvSRWnwry1YyTjqnEA5DeCtwbc+09x", - "RGQw8P049uUj72sOgCH5RRpCnUcaVLpjbLT+3bmiaUrR2rmkCY/xcDg3m+Yxs8ZZgc/I0kpJiplcCXI0", - "Gvknk8qgQG6Q2k9l3HOGUxUtiDMIKYKmEJshE7EMPmlkTBtpSpWlWD9pcMz+slf8teP/HL79y+7//o9P", - "SupIaBto3JozrsjPGnHe0IjsJPIdUxHVjCQMZqv7JOZzbrQV3mIMjUKD2rckssEeNnRRKsKEN1Fjuzo5", - "p6sBzfjAWV6su/tnJuZm0Tu+fxhc3B33x+Dtf/qfWhZW5UlIX3spc7S84uNq4rUfQyfni1/dPEGnS8rF", - "iX1tf12c/Lgd9hPZtNNWqWvdarhjiqygLQNZz8CHiKM0JEQsmVJwFC1fe3L6FFSYS+YYGmiNZJyPRocR", - "NsA/mfsFhDhQZfC33brEY7sLCTu/9li0kBgGmSTyKkbKfpOpt0UJbvSRhVa75P7rMYXoRLducQx2dw3J", - "VMlLptAlA0vMmSaXbGXNBfOaQZOJJVlS5V2DrzAtAZv4R+gNYqgegxKLyfmQy8qUY4tOZ7NpUIwmJbdM", - "Kbi7UK/UkcwYMFTXDKdGLphYXpCUZlatV8wazVNqmOKgLpaGxZTFHHj0WDA8GCSjcOajSCowscLeog22", - "XIVvNLmwauIFdn/BBZD1hT2YDVPpH70Xr199/+L1L08nL86e/fL4ZPLTs/+Bn+1LveNf/+hZMI0i8Op7", - "RhVT5D/+wPl+sMGzGNMHqe4LqZy26130GK9CMz6UGROUDyOZ9vq9/6z+8+2Htz7c02buLXvHwYF9CIqZ", - "zvYZiMH3CVCaSFVGnlLEBUEW5c0OFXNDw5RvJb8rHQlUUbicTDMdzE1p2i1KOXR/NDr9fs9Fj9zz/9gd", - "Eue6xeEDD5LKicd6AeRT4HKgPy1JZOQyNGZtKfj+UyEGj77WTHJhtjKnsuk6jxoMyqdXYEV7Uy72NGzD", - "ILrauiPdXDtQ+ZlYciUFqucoLk0Tputn5ZcXT59Nnv3ypncMF0GcYx5hr987e/HyVe+4dzgajXohAmXv", - "M66YDgY+Pp5qmeSGEWxUxpgOyWmuMbjTMY9ZjnZQlM80SXMwLCUrwt5HSa6BT6E0YEwSyj9+ODjYf7X/", - "8Hg0Oh6N/tY5YBVIfwvzfn722mao43lnNDGLCbrmtr34I7Z9gk0/9L1tElX7wCoVe+qtlXB63TtkZ1GX", - "ruzkCBLkuHf4/Ht7oPafj3sVQnSpwEUvtuPG6j3/PrQuFWvUuqRXPLMZbiL2VL8ORmPt9bl2ZqKqJ3wg", - "KELsQMuYqphMJVXxt/VYGnwTDPnfaILWCpo4P5EVvfEdK0tKplFX9jE+pbFV9xtLgJaf1JoSqSAMPaVL", - "DixnkKZc+vfqbMkZU2o21GHFwRSw41XChXr9HszM/cdPsNfvLX+v51RvNwe60JhOuuIWJZAmGRdsgxb4", - "mQj7YFNOJI0H+59Y1q/EuzVgaOyD+nYXyqkn8DV0pykV8Tsem8UEMuJhyIEb0j0hRePimnwPM6HJv/7x", - "zzenpUFk//k0c3fm/sG9j7wzG7ckdB3MtSkmkmfhabzOwpN4c/qvf/zTz+RuJ2FFymuJ527/n9kemgA1", - "DrfLRuO3+F0LOazMz5UtvvQtGAahK1cumUroqnKduDH19kfI0xujUty6G917FRPy5ssFevPiWvV6ATY/", - "4yyxMVo29Bb1C+09RNZ3iKcFeNI32mcgMTKV0tgRwNowuoaNEr6VPs4kNXQ3RySFoVww5cZb3Bj2SrEa", - "S3r/aEievc+Y4iAw0YTEVL3jwga9+Dedzk2oAECghAs24Knz4NolsZNEngwdg6PNBxxpG3C0brVHY3VM", - "3P1oX5aqYRC7ScuSYsiYJ1mBpLfp+Ly0rUulP0CSAYr8nurCM9uFDgsy3D84dX8eWIKsEl9xuOxZ46og", - "Pvupb0EMBdXZ4Ee1hbWbMgJfYlQbckSe8+8JF5DKnzByyr8n1N1OXJA3f7P7gLxOd5Kl9CXPbJzHhM6L", - "tNRNyH/nlzxz+jy+4aMM7B0U59AznqHhWFhkH2AbSDsQke99twaSCLQNXIDbFu+zdRkNrAPljWabWzet", - "ykWfTHMDKr80jDjji4MYgLFg4ykjeRlE2lDA3QTXAyNwWS6ZEiyZWAVbd1wZ+xJxL7UuDk51RrVDIlMm", - "z+rr9fSn03Oy83QlaMoj8pPt9VTGOUQDWp6wW1+9/lhkCuFd4CNwFrj7rpwRmZuBnA2MYswPMcXOCj+M", - "A7lYPj977WBSNAQpvWSwsEzELuDVCztFxKv4xlhXeK3b6vcbi94GhePd+x1P9rlrXh7t7hbJfs+YJARu", - "l1i2BklENo8CHFcF9fnUvj6cwOeyxGKw3GBIXmvgBiMIe5EKoxbIVJpFVbvEa0lXNaASQrNsBvpnWMUs", - "tdnG+T5aBP3WUZbXSfeg34ppuLQBEyDO6K6cawmNK4wLAZcCnOugI6MKgs24JJ/1HbPwslW7kh1guWfU", - "1AE5uprCbc8IBrs1OtRZtHFJulu0KzbWNdu2NwD+0TFpYnP/J8IPZKNFv7QBfsS3zm0nzSVyfff9zK6x", - "SifFmjT8AJ9meR7ris20E26rlXmsPKPJzgWYWR0dg2H1ok8u/rP2A/BTL0+BuvCO2NVAHi3gp2r/ei2y", - "eYsd99rRzVRffz8e61bULbLcJ0ZRoW2c/YJmbEh+xIuRGJaCtAg3Fa+GFgr57lsirY7iXx0LGJqux1p6", - "a77mcwGhZxg0Dwwnjq3J31nsfPyNDsEdezvcmsRuR+dAi5CXuWh7cuFN7xd1/rtumF+3WzlL/ZrBAn+3", - "hgo05Zi9NDfweau9OJ+0zI0FMXNTbwh4dfP/tsAgN5bCFHmN/T8v2EUTQ3oZsFjA5OSs9NdUHEdt/hkn", - "/IV9R5dshVvu/UR0zVNUdRGFHTkupN2JMpVX0XZorxKuK/4l6ylyziEMPq4f0aDbZNtWwHp1Xv665h/M", - "wxn4yZYU45R5j0/quRBMzn4PjY6a4eKjJeHYpnVd9K3pg6F9kQgglsTH5je7x7BkDGK8cL8MXW8XRZLg", - "p8AcL7M/qltLKjvrRWnsxotihsX9umwA6NR6+6RseOqixe2p2DvFPSPzAJcdRV6XNZM6xevj7EDPKp1t", - "CAjr2sV6lqxd38qYHT1ZYGefRGL3A/1fNcTjJvB/3FDDLXJM/ZMXNEkuyI5rtEsU+zuiwrq9ggi7YvsB", - "5daRQBFu9ua0PxaWC1wsjMkm8H96Aqf4otmZe9ef8BKU/eEIRdejo8N6zoYdcKPburk8iIbTvjUQd3VD", - "8VstRnmPfo+PixsIEG/IjqFzODoO9gjuid2PNdhzoVmUK7b9rD9G8chB7+CYEsrF4MdXr86IYnOuMdU4", - "mNRgQ+NbMNqcsaAMV/PTNbJutT04PLp3/8HDR8P4Ug1ZpIa5HoAiM9gf0pT+LgV9p0Hs2ktXNMuOl/tb", - "+bzdgmJ87Szfa7btpCBTYMk+ILmLlvykfKV0GF5yEXft4Cdouz3o1SvxN+12yRQb5Nlc0Zh9YqfLteOa", - "cDXbd3VLJZTNAc25NmCIKCGAdzbHMdcXaymTQUwNvUoYsx3uesRyurJdWZU81F9rePh5Mya8htsTrIfw", - "sUFmfiyhbWnDFLaGBBZPjAyk73rZ4eQprLlv2wk8FSGQjZwsZ1xuS/KHodVTd/F1b96ALgZZxJ2lzns1", - "eGH1t8a6N6fV2JrhWAxQCjsmT4sPFN0WXVJUMWhsvfw7UtXyh9ERMAXoE/LmdEheFaP9RnungB0TKTJH", - "c3QoolA0sCJZdQA5Jtpw03zdmSUtHvMuhhBJ92xYVG1BA2hhQEN72ZQ35mPzunGj3F1ShZ7paBDehE72", - "0t5HmxDKahEh9waj/cH+vVf7o6tGhNwA5HSor8d13uJi/6vc58nrk6cHzuy5e21Qsk8OSh1mZU/LpAWy", - "k2tWSciVKpiqUMkIaElFuHaGwQ0lDJTwm5va2pV4BS1vAm07hAeGTfrXwMNuMsytoKuVya0bdFYZmh/K", - "U1IR5O2OZhEPZl5DyOD3itFLrCKwfm8jDsXE3mfheEMEC5muEBwLjVxKSjPTpMCQKY3f+0cPjh4e3j96", - "OBoF8JzXCV5GfIIe2U4DgBCchK4KaMMdDGOIyTSR0zqh3zu8//DB6NH+QddxWMd9t3Uo9G//FtlxK/IX", - "X+nNP6kN6uDgwf3Dw8PR/fsHR51GZTvrNijXti6SPDh8cLT/8OCo0yqE9LpnHl+7KcCHij08tvWR4F8D", - "nbGIz3hEEJeOwAuIHLAAN773QtfP5JTGviRG+O4wlCd6Y3Sf/Zhrae2taZ4YniXMPsMN6eSSwJk/xZ6C", - "NcaEKEqQXK0nh0q+Ne7Lz6VoguJMzKb5fO4g/4qlO3XZ/KXwxFkSH5NCZdvI53A3y4G9baMDN4eO1PCz", - "fFeA71WIwF5dFqlCMVLQid202qx8uhAXWR4kidal/CFXFoQDOyV0KnNjPfiuZkz5EYtnI9CjnYu4m7nj", - "B6kut+Z3wE1clMbpaDDwif4zBAJopPhXhb7C027jEdxzTV7aN6yhsPw5y+t1Afv4JWdQFB6dIC7sxq6b", - "rtJlWG5Bm7kP6rPfK3nnLUU0DmY2COzTathqzrAklNkqsQCl2Pipc2zeOV0MXtxqSOmw7oK9u41Fx4TH", - "AZDtAEwoN7PimwKnC1tD2YhIl24A+Jww87gCL9U4aececcMt+XAsXL5V8ZMLCoAX7TrYQAKp+JzXP1y3", - "s95i6PJVKNMT17Wps/piW8ygLtyAIR5gAadnNhLYRi9W8W7dnvT6vfOidpZjTPWl8T8GVqRMMFiHHjp7", - "fdUA5EzJGQ/hAWHUkXvqFDUfmvvz0eh8sP/fNroTyA8lNi5spBL4EYaN+kfYvttF9Pzs9VnbmIriU6Q6", - "urU5bUA5KiNryqyYYnFcrjnXvudKoV4qiKGXDCxMeOJqzSx8F4uH5ImNtUG5hs/Qom18MwuvAgzIfnvJ", - "jmtQORATJljRqXWlxjlQVRXnDZqBKKC91xMx4p6fva7jNTwKid8IuDLNYWCTNGAP/AGeE9ugAIw4/b4u", - "gh8chboOM+6zGgGhpj+jEUQHdKaQgA2xMY1tiIzPz16/dAWX2rCqgZyKokwWpnpIfilKksHy6hKPahgw", - "LjZI0IaeQ4OJTmQogOUHxRjBZ2UpVKAbdHpbdOMi0IDGiG4lhS/ICLH/Dmvwt5wqKgwXLCZvftDfkpHz", - "sr/5gdj8I8ezuK7GXdaVywehLW3NIzxbrDTY9uyy2KIoXFQNm8gFOmsmZ+WLzgQc0E/C5fg8xyE7UIQR", - "F/D85eDkxZu9NGbLfm1M8NBG6T4/e71bYctLD2ZRtK1z42WbhclvVVEdclJWpGweBMTRdqbPJnXA3ozI", - "lEXUB3U3Ny8qCjhPMVwDDWXg5jZMEEWdnZqKWifIuiDwPk+SoeOZfsgELdMzZN0V7Fd7uzmmplhGUfkq", - "JK/3Bj/KiM6jiLG4EfHSHHWF3o5JLlKq9IImzckdFwAL0YIqGhmmyDfvv+mFKzAhK+16N1Sos7icOpNl", - "5SoK0GPl3LUd8Tc/1I+nlQ5sWrWzqXPBDcLEITb4TjFIi2Y+JKd05UwvGV6zjl7KHaOzmQVLLe4RxRJG", - "NVZO1+TND9tjOY00NGmbwyt46PjUDkwIThEMs0+yGhuA36soZdXP3g9eGeV8Ap4p/GDTzTEkJyLM9mzA", - "EOIMWsgwrflcgDqoXcwQ3Kd+Jdf2rn53Bi1JTVzGXn3hatPpBy6AEMWEbiubB7quGa1XcpWXdTYlL7dX", - "D7WdtH/3iU9VbbjCnPrpzy1mtPrgJWJfdRzDGlQ1y6iihiUrq48U1FmvBsHW41AgW+AKubLPoPkHWwEo", - "V2xiFoppiBmrGSgO++tVpDVmJSyZK5xn51Rx1xlJUqou8ZR59Zvkwq5APS/2cBs41sKY7AqTgqAKa5Mz", - "TC1p0szY0mtxOU8ZZGlNmXnHmPBToZrQalR8M+NdtxQvg1weprisr2HvMPDdc5spQeaKRozYt3wN+oKt", - "wdHrupS9w5ZhwYWjdcv+7m/aX/fqLE+67XFoWPvbdthEV9ngV0/OfBGuosi5X+aD9VWGQhL2yLk3tmzt", - "gd5cDs5/SlgU7TWZfcqwPpzLNatmsfuoRKx/JzBjr5I5XmEOuprr7L6Dp8AuVd+e87eddMLmcQ+F30Cm", - "UahYPD5wWXpzBBvE3ASVo+bFYysp2Tu5cj+7TCqQtLgAXOZ63HeUq6TX7w1mblbHe3vA7xPEWz063H+4", - "tzn4e2PUvwtynMR8k1XItXLBch4CwIJV4qTrJLFHs6yD3Rzf3HY/IHta2wRbIB7utoqS5VNcwF/TCF58", - "TyPjS1qiIb0WKEGrxxZR0euCDHSY2ipVoO0+qp7PUTByBcJQ6+S/t0b7MDMbiQw0Yo2UjXW0RP57UDqV", - "KlS3UCrj0pWnzCvtxX3oA4E9/nfNpT56WJ3l/Xv3Du9t40PIbBrH3J27wFRt6zogA6sstzu/rgP4j67L", - "HO7JZrLCddlCU6+eBEhq84LKjIkrree9o8ODq61n14mc+GDOBl8K4VkBgBXKRGVmccoMjamhdSaDFmjg", - "MlgYi7IUEwdn325mLS1RT1WAqutW9ftUMTMtBT5fejz7lAo+QyXJtqx+WS/owb37x7YMccxmR/fuD4fD", - "q8L2PCuedduKPRtaW0HwGerFx+3DDaDzdJnLH72zx69+BEaWa2UvrT095eK48u/in+UD/MP+c8pFGNWn", - "S+VqPlurWF3b3ix3sOksPoaZCJeM5SWlDlF9LS4kzClAKLEgRmYttvrmwDALGuf1midXAMXckMoP4gpY", - "5FvX5tpFqEVhCzWV4tNVu0KHQtQQ+rkp8sNbnLGN+6a1dBQ1utfjYa5VZV1vLES7VqcwY6IoPZsk9q9I", - "CkQlD9WhrV2R/lmHMoZ4jbh6hcUnqz8WX6/8+KQ6kMrvvgxi5SdXkPbtFQPZNgqkf12XQ7dzIS+ObjnM", - "YfN/cSt0Lf7tQDSDGRx3fBdeJ9iz/vUX8//67f/oswd/3//t5zdv/mf5/L+e/sL/501y9uKjAJo246fe", - "KQjqJ8M9xQjHGvhpV1I6Bc/MOj2B+teywu6JtTiYaIHlismUHUMI9s/cMGWLXzZSlqFeA0NNCd8iUmCV", - "QodmsQsvn9k4BHj5Dy8Gf2j2ETvYCuU2pABK0vk0linlYncsxsL1RfxENOoF8FdMIprZCpZcgGEWArsV", - "lht1juHy433yB82yD7tQEoUawt7bUgAZxYqNs8I3IXxYhxuVDV53zVmBt2zziMeiuK0LAFEbHTAsq41w", - "ljQz/VoWZbP+5jSnh6MQ1CpmocFGYkUtVEEKygYyKtLjyMPR7ro+t0XHKGhoA/m58BmbpgxpxgFSbElt", - "fspiHiFf8dm9tmUlsdpSmjPiZUq+X+HevLQppzGhuVkwYVxgZJ9EUl5y1sct7RNwzmK8Fr5po3AWMhtM", - "V4OFzAoYlsIXbuNY6kr2/xm4iQ7eMMVn7ktBNA0gkYDQiUfGzQzblNaFtYm9ssWIhEanvGtuq1ppW8jI", - "JmCYXAlfa4dhxV0EGyqoj4Vk8m9JlHC0OukF+vAWiBZqoJsQ4GdvVCS60WkUs1nz3/VApIN791GD9f8+", - "POicZ26XbhOV5UlAp0096+vAsS2bxAFY8WDiDeFbQgfhBrScmKCdwkj87znxHZUnrmAk1tNnM1+1K92S", - "6ErO624wOdEdAwcqNKG56Tq79VNYy3Xs0IONKcLXkg5wRs9wHuTVz+fEMJV61IudCHYHT4nFrhlwrXNX", - "RfDxk9Nnu8NeECWu5tLCrdqYC1kfdAAhxZ6D1tCp0kZDU9YnJ08xx91dK6UuhklJP0hFEnsrlpfRMcL5", - "1M091NYfPXnqBNBkVQYqWbFl3Nv1PWbN6+2YvPSfJbQYSpGtXNKW77K8TLBbF7ZqM6bWem8kt6N/zKl/", - "7j7G/Cgszmp5MSLdtt5f3W2ObsXhYdNCduULqfJiu/2rsvefGhP+08voh1eT0Z0XepItqA5R96Lq1cRG", - "a/tedWTX2b1qj/SrfXeiefBs/dWXqKpcQ4bBPVd7PQSCfG+wv/9q/+jq5rurwnnXkfoqGJ8Fond3KO6b", - "gLQOAFRzM2lNCSHw2CWAeLvIm1PIrgTkNXjYsI7sHz7oYpTAr3ZNpqg8BJEah1RwKY+8VyQBWADES54k", - "VoDRfC5oQh6RnfOT5z+d/PzzLhmQFy9Om1ux6Y3g/lwD2RtvAVxHGxwVAF+rAXmQIuP31auf4UmUMEya", - "snL45fXxvreaFjvgf/vBPT97DW8sqJ74cOv2DGNaZumz91wbvY672Clr4WPwxu2rpWGsyyRtHy6ocito", - "+Y81VO0giufuDaCN+5STteW8AyDuu0zt/fxAwDfCdn8s9razM9wQ9HbrlRaCrW7gmNxru92uD6J9I8Op", - "wUCF2FZVwvG4C9dGre73eCDn/LGL4yMnZ2WZutIZ4btvzOnRwXD//kOstLw/6sLYUxpt+Pbp4yfdPz46", - "sLfMMZ0eR/ExKuzX9Vk5wrYqCE3eQWbu2CuJ4569MCvabeXY2jbdci7WwcGvhwXeFONaYLlRnPWBS3qS", - "biyU1CGpuAl1mOYONDblScI1i6SIdV1GXlBNdGaxkm3BoEKCHwscYJ8UddtRSiE0ilRemh6ddO3k/Txz", - "dI9FizMpNHNVS35iK01Sjk7Q4vMY+qhJkbsWj8WO8nmORUIj1iuO4QfMGuoTpwr1MWoYCyPBC2OhF7kB", - "JrYLCSgCyhsrZ5UlU44eo12ic6vS4nhxNVbAMDWPmRoLaBZAY/6jUE+O7wMyQr9XaHJQ3GU0ClHTjTo/", - "hw52HXvAFBgqXDk9jHZXuSC5iJkiL6VmxlDCLDk0Q+Su6Dj9SIxz/3o38cq9XspV4YO5DRK9kzD10RjP", - "ONQW/RyjQ6+hnN+7vojeKVPQy68uR9C9NblKBINLyQCNbwq3nTXIsdiZITVzuR5F7s1rWzi4PnUXemwk", - "ONXVirw5Pa2FPbgMjW4TRy7Rsg8yu9I2HGyxkWwdzVXcyxVE7O0o2B+PTN2UVCoS4ifHoa56GD10gaXQ", - "mmGrpjhvsq+BVhnMgeLC7hMQzYYJNmpHW6CXMjCy2qte6ZlDZXWitM+pcIj0BWhL6dTXK703zfVeFvE9", - "+1zvIaLOQ0TUOQpCHsRsOcnzkGoEj9x3yOvXAHuDvyAitE2QqX2e0vv7D0cPHw0eTvfvD47i0f6A7h/e", - "Hxzco6PZYfTgcP/gcENSUYcc2OuntQY15kAccxG1PvHR86Gg5rbchYZs4uKx33ERy3e16y8YIFv9ugu+", - "3fb59dD6zkMIpgQlVBtrvmjhZKd4ybMI+sZ2Ps+6qBMXNnTefzXa/1jrDw6u5Y54pXJh3arYoHQhpJUB", - "VzerPs7rsXwckE982bZa1Y93X7TR8b1Hx/c+dtF88sa2MTbJ6RY3ty0izCOnN7JDfJJwxY7kDZQ9JxNZ", - "q75tvur1e7mo/o3CQCOWunjcKYmr7cD2w2xk07XSAnlwUtNXMFLFImfGxyCpeH0Ea74UwBogAj0BWxip", - "2OIskCD64U4qugt0g24xZ6Kzics2GQMzI7l2+XxcACNG/yN04vARjslzbIuPaGrVOjcIW7i76nqj8crG", - "y8D58p+2StbmIZ87/QrfAWWLwL9w2rAMzmS7uQsrnR2TXyS+U2h7QjZtv7Y5qlnrzRttyY4D2fd4N/gx", - "J2oekx8K8bIQUJ1AuqOZ+3PiGFYJM7VbA/twOw6BhJWdqwBX9Ht2RXv9nl8o+DMAdfG6pPq181clxVAg", - "GaMJnuUyTT83PHHg+jgTrg2PtEsegc1tE3tcbiaLJ1Z5aotJtamvtg0pXvJS1ZtTsoP4qX8hzrAN/9ot", - "4ldrd93Bo6NH9x8cPLrfCSWtHOB20fgJIhOsD26rnBxl+cTZRtqmDkX0cM0ja1UoYl/A21WSeaYksB6Y", - "ue+w+vFHw0dVcLhY5sCHiyE5JEmLRY0bFsQ/LHhRSxzkbzxZ8tlM/PZ7dHnwd8XT/ff39cF0vwX02n4o", - "bHY7qQYXrNmo2XRgS3uG8buQoJRuhbh7yTTOgJwzQ5B+BoRGqN4U+dSO5HJdW/EgYR0dHh4+fHDvoBNd", - "udFVDs4EjXCBS9mNoGxJsCXZeXl+TvYqBGf79EgwWQDmoHHOiCvQPqoLpMP90WGISlou7pJqXN/LtHXJ", - "3zj10U3KLTombxeq5dopD6724eHowdG9h/e6HWNnHp6o95s5jGtnv+fLZ1R3fgelyVePzwj0rmY0glr2", - "j609eNRaUTHXjPzy+JWFdhKSZEwNyhvR91RPc3WxZlean7nS/LCIjC3+sGWKtUiVB/che2u/G+pjKHzF", - "4ZnWjn6dCwaOb4C8AvsaWIp1Jt5vu3dCgpkl1ZcsSihPH0c+WaNxj9kiDxNlm5Wb0OWKcbr82hXY4d1O", - "ZrLC+GVTffAdIhXJRVFaaLjduftJfLTt/N9eNNvvh1CCj4DVc/BktlzjNZYyU2zJZa4/QUfS2OzbWSKl", - "utK7barPS6bBg+dBsd6cfqOJozWiDcvq2pijxg0gbtec3JXOc41EwkTetliddqPL1m+acL/l1PY3QXPU", - "uEErdGIMnCsX28NIn9AkyrGYFi32E2aFFwWCC2RZsrJZAkkipSDRggp0tyhXuk/MCSWAwjAMxtTCk8ks", - "GJ8h35FEWtB3KPbj6kzZQcBrIAyBZWmnWs3RklKj/PO91DIZV0moTo330nCl2jA6U5FUD+tJjazgkdtX", - "ajbVRM41qpcG8x+GzTIYGVU2rYEKWzdtmVqtNBC6HRhig5mHblR8CAfTqspOeMGUdbuSNFJSV4DF3pzq", - "YdfsuSIfentoaH2wHUjXukYDVxlecbpzecXQ/RjIDPqYGxJpGLMPNwRdejNnSkWOlacqhOxM+sPOgZVg", - "154UgFlXHKw2EywnA6bAwgdW5O8XliXfJngvetZ2neVyEczXenuNqsJdtQ2wnacGVzS8Wv2CBkNkvI5Q", - "txEUr4QKbMJiXQWssqw/wjX2yisYhGQHs2cqbKmCJbnbJdwmrPzCd9b0XleJGDweXTEaN0MynlGzOBEz", - "uc4JruKD9TZtF/eaMeVhEmMmOIu9Vlo4Y53RjGtXhy7OmVs5/GwNSA+DJShqTs7aBslCdV7f/GAXQ7Md", - "w+ZqM/hd17DDTnIdTs19pXJcKyQgIJ4ySbdTOCnXk7BjbL1jxeZ5QhVCB3Ycsl6lCReXXXrXq3QqEx4R", - "eKHpYZ9JSCGbwCP9Hc5lt9Ps4IVJW2myczs4l2FoN6Tx3XIK38Esdxv5zWjT2bPv78H7neLQgjHnP/CE", - "OZTL14K/rxB6vRzD0cGoLe++pdNaxv06zOtVObcj2eCJz3UgS3GjlOOLqrHY1cjA1lgcDo9ah1vJgzB7", - "Z+L1fEP1FJSPAzl5Yvl1A+KETBlmEPmprXXXhS12mUqwtAxU2/u7nNZNq10DiAMFC3dECbah2CyYKYA7", - "utG0bVusrUlld6+CZoFsFSaKL10RJGJbaccyUquNn7xcq3K4YG7JuJ+jrXjYoYKPjyQpgBDcV7sjIjTr", - "UQYinxHvRpsVVnbGclqrSpFVKFOmFCLQg4QjhZ8NArhIZdfaI2hBXveKKJZSLsaCi8LcirBsjAi2ZKqS", - "bysVKFlzSPb4a0XFg99ZmpmVKwaBZvhvNAFnnB/jWFQHCZ2DGX1IHgtrWVR5ZmrlYlnstD4gFF8kXzGj", - "sH4qNwsyU0wvqnMP1cwFGe+dVHFrMbIV8U1gGhS9tcTISyaqrKzoJqga2o4m9q31eEBb8BqfOv2T1GpQ", - "k2aN6c3fyzVTYSGxmFLRpFMQTOWoVJQTPJAwAFdb1P1lWXyBp9IBPaXs/r99l+VPZ0Xn9d8azSoIKR4z", - "/LE12wZNsFGWr69Owye3NegFE+o24eKseyXIjg/G9gWa9G5LoaRO92S3nL5m2oEfzZ5mUf3rRw/vPbjf", - "sVLVR7n9LA7Yp3byLdMNzr2WnTrt4kF6eO/ho0eHR/ceHVzJw+IzVFr2py1Lpbo/ACNi4LAm//rHP9+c", - "1qnl4B5Gc4+uNKg8ax/S66zDgN6c/usf//SjuvaAQoxmHe6/JQKgNd4nqe6kDzmoOwO7Ock26PePa0YC", - "WrAZssMQ1BvCd+y6DcrBNABFuknBNKMRN6sAI6fvfIEL16SB2t2h98ZgQyKv7dvhqwLn0vm0aAExLK7B", - "f1ovc4MWHnYueKfzaZtH+0Xzq9iOlF6LarREh2AFSxFhA3cxn3dU10LDY2b9Dv0iV209b8e22Izf20yq", - "gKEgJG+tryhUtaAhT7qXqtvf2M6K37Jm1mmu+NsN57D9CF7J6hu4kQNG3yjLu3ZUyu1wAV7vrcm0Wopy", - "Y63PWt3K8ta9+nc75CGvFz0pbrCrf6+SenmVFxu0ZunRjcEtedl3v0YSLdRUyaoJGNBkwgaVMgjYmujc", - "egThzDvA+kAuaHQpZ7M6au69dpR1BBDCtDH/FWoMaCZ9sPo7m0UTotuiBY179/S4R6SClMx03Gu4rYKJ", - "mCl9P3EfqKPEjDbBnpeJ9I1Baj+DaSKjS1tlEYv3D8mIpIwKTXKBh7/hVdsfbfYO9XtZZW/8OqJyt7aU", - "bjPJlC3okmNlFudTmddCOtl7bjSGnmI/xySWFjeqVmLazRCa2TTJ43LSeOlQsXIdQ4fQTgofG1u2RQPf", - "DAtbi9+Zkn0HewAc+8WL074NYMAgRjuwWqSkn6gdQa/fKz/RKNRQ/h6ORAZnBY67Cfyfrq9jNbsdPauK", - "aWa0QwIvyaFBBJC+JEyzIkDaTZGrJ6itX0m5wLBBF/4BC+q/bgmExCzCE6nXz2Kd0K9B3I0MBLfSoRSE", - "wxAJ46HYUMnnpXMINwdgjQ2V6vC2n2qEuPUSTrSRWa9+qifsfcRY3IQODTfpGnXv3gxG3f9MHdpQUbjd", - "tcbI6fXZDW8uVQzH2rba1ewAIcUATl2xpfZwWuQ6j3pTJ7Tq6lfBMSYhoNZQgw7jF+z95rX+hb03iLQe", - "5wmL19e2OJKWVbnLaNuKXztHsu1AS8W2lue8gbKVNnL9WoUr7avsLmpXulY3Uq9ybXfOmfFtzx0Zte5Q", - "vWRMzaXluiC+ST3GxpJSn7gLnuynuw0SPFqErSIO3rdjtifYW8D5PuPvNxCPbWAV4zpASnmQPDUQi1S6", - "k9L35OgBFhHTjbELPl+YZFUPwDkKoDJ9VFFXxQwT3lDYZefL3fQvrke7ue2s9h4Sjs8rIENrxVGcSDrZ", - "hMD9pGjmrfMZXaEVp9VJ+ODwaDQ6PBhdC4LbD+sKy/WkfMWVQK3305acV3mPsKrHzHKgag9FuvZ6XW1b", - "+K5cTaKNYjQ9xhSejEaMJGyGcHtFaux2z2Lz05sH7wQql49b0L/fKLdv3gdfL75TfErMK/+ypg+cax3N", - "qPp8i0O0hc1Ea+B8gey9w8Ho/qv9w+N794/3928CNrtYpLa8kQe/7797kBzQ2VHycPXgt/3Fg/lBehjU", - "wy65iLvS6k/QtjXKprwk66hINZZGdtwcMqaaBdPrViNAc064YANd5FptT3jcwAus/33r+b+and/OYKPs", - "cF6fZFWEoIboIGXdDZKXm8xG30VzNidPN8/iWrlMzYGE6a05FGjVcTBY62K/95EYD7noeA29rjTsfBFt", - "zK/bdhWFPOx40oO73LLiIfJuQDxUZr3pAl+/5AK207lU3CzSzbdF0awAJMe46d+1ievIUUNyMhdSsfrP", - "RZhcVYmCl3v9XvL7Uf3MuN+7Y4g5LOOCAN1WV6WCDmFkCVuyZPMqYJNS8VA2kp0qhgvx3f5g/xHGISS/", - "H303GjyqRxz07WpVl2/ft679OuqyhtVigr4I1f6jK0Vc+/XcREE/8VApvPJedijHjsbL2vT+6vCpu7UN", - "Lh+v7XEDE6hVAP1YSc9dbpOq0BSDRTaEcl8x1OqG9lglMjJlcy50F7vt4agw3N4Dwy157KDGbUF4WXyn", - "2j3QSpVOeJqymFODo1JmQwbDQUdbXFOXuFqVE/9WQFobhsW1R9vBFrYlXG27Jocfkdn7UdpvN413Ew4I", - "2tW8iopoZNiwT/gMbND1/n3Za6t0YGIkxqsde8i3kmQdD9ClHOjtJH0yl4aUyfgd7W25aLcLFuOHGp35", - "RvQNSxAHnwRapYAi45vY18lTkikZ51GZP5rgoEvsEJWLYVchf+vQbtS+gSneYOTYbt9oM2h0s0+27XfD", - "NgkE277V+6PtW30jRpF+L8/i7TzMNurGwa6EAb8lBTFgoqkve0MSrEzmbQeO/rK6gus6r7UlRyAS5Zl3", - "sABNrVNSwN2CLoZQXO9TljDDQp0QmcRllgTXJRfdzlL37z9ctLk40SO1PpCfGMsINRZJCb+XgjcvNDBf", - "wLS4S3ZGHjdcW4fXwBY+cqtVH9yDrZJY61ZVTbhtxRgsl2/YvC3yymXF/O1nUxPN1rFUPMOvCWkv24sJ", - "uDd92Fur/fgmzHJ3KaS9cK6HBgCshycucNb998tYYBDr6sR7FHLPh8jiFZ1j1b0tfpRWUglVqEQnByWG", - "ujJZWKoT/kmwHqn20C9eQMDXfUavK1tIuCF0Tps1KNoKXFpP9PYYovaSMa/ofCO6bzMdtmp+fzz4mzW3", - "k8nweO+7v/zfg7f/GTS7NwwImqlBzGYYcXXJVgNbzwmMFcM6ti0Wk+hpQ+fuzDCaojENceMdV6qO996o", - "4J6rX2i6NgUMVasUY9rfOqG//Ed7oFdlGV/jhbH17H50rZWbqElrpL+Xd1Km5j6o3mfU7Q7HApP0LtlK", - "k0qJt+mqdmK/0cUrlVB8cmHJfcjE8oJMOdbM1GMB6j2NIpaBWuWqBnEci5LIhhWjSbUfV2rOnxfnmbWB", - "FZA+vQaM/OL1q+9fvP7l6eTF2bNfHp9Mfnr2P73jnmDvBvYL8QBo7+jefVfuvbqS+8GSI1evnDEkpy5f", - "wcU8zHLU7BH6DHykkIKWrAh7HyW5hrAJXHpjkuvXyFjPWr5+zYmPBFU2JgmFZzjwbwD0hjHbe9VFF3Ht", - "iZFrrJPvrDxckHXRxRLOuIdXipFekghWKIGtCK92ubH1Rb+/6HaXWLjZwGHH1F84bAEr6s9cI3CHD4Kp", - "NCY7mELji/naJzYM9Qrwt4+LDoMhmJ+4ZtPo0aeoq/p6YyHVpUwGoOe1FJ8ImtXtWgRTCLArm5rRa/O+", - "zKcBZcbZuOd8TgMOl5Bj5ZPUP/UD2po6trb/rYXgwgkdT5uVOeyxtEvVqCTRsJZoM2jP90hBvG/BMkaw", - "ZpvEyytBhrXu91Jh9lyd4hBwSCwRH35T2nZ5yjzg5ABf2p6NvFHBrMysMpL2vTmVeWhbNi0Q5OMDj1Ss", - "shH4AouvuWQuQakDHA3SWx2dzL2M4jn63TXZKUxgfgmKtOt1v8Dmihan9H3xBWgB2kTTEYvzKCtq7T//", - "HqsPvHS7BOzTdYHDaGi5Yaz9OhVtWhNPVeubUaWq9Xnb9sGD53jVBu7XdrYaxFl+o0aaIXr8K+XmB6lQ", - "L24Hf7lxyH68/GOmEFavCcjfCc2epyyeyNxsPv/QDKRHe+UXlWbLSsXeBkCRiKNaXnMbL/DwJOUY1lca", - "loNFueJmBUYjp5lMMR/UlwfGhcQP4c/lh7Ek64cPaD2fBTJnnjPBFI+w4K2FGhSoMQFsX1n30JbAXIPA", - "RRHoxZMTZ3fxKMqoR3ODpOcDUB+fnYAznilre+iNhofDER7mjAma8d5x73C4Pxz1UKta4BT3plCw3yWS", - "O4260OBPYicJfe8bwZuKpszgG78GIBEwANM1RxWEzitKZEa5clpklsi4IBgOb2MFB3+hHttbuW+XvbPx", - "GPOtMQ2IZS/c5r5FQRnPDk7zYDRyWPHGXb+YxGQzJ/b+7sJoy+92kurcEgUKGqypeV62LJb+Q793NNq/", - "0pg2DQXPbujDrwV12cwMtfN7o9HNf/RE2PxEl23u4sKqJw4JqXrWfn0Le6bzNKVq5ResulqZ1G2CMQO7", - "lmtr9TijSQSsAssuAaANs8/BJEptCLfKBVar9i8ChdZPge3bb3KB1vS9jFefbAlr3/A2ig91dgbH5cMa", - "PX862inIeH0j3SMPWm6p9hYI6HtalFq/s5NyNHp08x8F22/CI8hW9QTsArO5xtinBCHYPQiTVOS3XBpK", - "iryGL+hIO5l1WpBbv7yK9v7g8Qd7vBMW8gecMZVSYbNEbJsth37tOFvfTHmcN95qnvBPnvbcTeXRiOxF", - "hYJc/YhWr62mMLh+HR31jtu+aacX3yHhH93CCXeTLart3uWRwxqn4Ff+ko6T8zVOSyEkKMs9Z+ZzofnR", - "bV5Zri7Dn/AUfSkE/JwVEl65W2uXwl6mcmEV4KAE+LLM3HTvfVMX/l6VTyrhQujXgK6xQoixDmYar4bE", - "r6lV+sHoqy1Ev1racLP6+TqD4X0uJ+zgNk4YzrjwFH29pr5eU5tOuaUWPwU8mJVT3sEGcSULxJ/P/nBl", - "68NX20N320Mny4Ng72xrwIMcEheaG8mYEb2AeqfgbLbATz4Ix1A1nP9OqIoWfMkQ3Q/r3uWJ4RlVGGKT", - "EvASWB96q2Fio1mi6G4Puhv4gMxygZuAHppNMARm0gbEWYZiciHAWEu1j5opcRXXKrTbsx80sBcdllcj", - "ebeQmhXAhsJUbnPM89ZWO8Zuh2PxyiHewgJiVLnnNZoliNu7wf4jBaFj4V741rMQHxGnaVpyLqoQPJFb", - "iE67LWtTxZFOdCRDoEOvmKDCDHTGIj6D6EOc1iVbucDWYIedSlnBgP04oS6MD9Q62A0D12HoUhil+Gnx", - "jDhKqvtvhDSuyHfp5PJYSlRB7YNghZJ5Iqc0mdj1uWQBn+BzbOEWpXS4lN4kIWNmq/JnK7OQwv6dT3Nh", - "cvv3VMl3minwOY0FZqS4tYZohUJAJO+wNl6aSWVsnAN+c88Oce+PS7b6MByLx3HKhX1D21dooiW4KeA9", - "Iz14iOVeLfRgT1PYD/4k10amVQhYT3d2mDI3WW5cao1mph+CPx0LI8kfHuTyw94f5Rc/oLOY0RjopNLE", - "Tgll67ZR6wmF2U+wacDdznABxj24SG2Yx1xRYXBMJUonmVe3dKcoE4FFaJsrHFFBMpnZEhtIVAsKJFfr", - "A0EraJIQg0fJvwuCO+5ky3wcBmE6bQUgtIhxjWPEBTn9vnKYRkcPw+dJs0ixUETJf52/+IXgrQx7YJuV", - "4Vq4RlyAwABRNFg7xPG0ZwCTZB1VWJ9x3OPxuFe4c+NdHGuuXbjMYIA+xe9gaN/Zz/R5/N1wCF1Zd+Ux", - "+fUP28sxnKUstYCo496HPqk8mHOzyKfFs7fhBW3DcTuvMQKyY6+5XeQklCPkTuXGt1ckmO6kuwUAQJCU", - "HKgauDLlgqrVpozKwNK7FZQzG8lYWYw/xhi5OO4dj33s4rjXH/eYWOJvLsBx3PsQXgHntWwvBoj3WeHc", - "LIjo/mi0ux0S3K1vwGfZwTHwiXXAVq2oqGQKO+jwaP9c/oF/a/3z+0JjE/DxEqPJKv7e+H7Xcj18/RY2", - "/xcQe4B1pAwjSgbVmmxwU2AtQbzasOjAtTwjFVWiqiIHfCMNfYCKiCVeH9hugbp9rwZQUcSS5LZPzl2d", - "m8JvV9RS+KIcdbhZ5fne6Fe4Y4ob3dZtV/Mn3A39fnGG/YBZ3xn12dLHYIcrySBKkNPxiW0MlpNzHNPg", - "nAlDnuGvQ/dfr5Qi6uVFIucXx9amAEURSMKFS1SoRFCD3OLWEl+yQEHFe/afRRm/HSvi/Osf/8RBcTH/", - "1z/+6dD3//WPf+Jx37MAeFhP/GLBqDJTRs3FMYF0vAFNIL7dTQYr/rIlUytyOHLOCHwEQxIsKqK9ZQ6I", - "mWPxkplciUpCh62op12HzocB8+EiZ9oBLUFDPnPlfmzQZcCg5M+yXcpbPdH9AGAlzqAyAbgVPQ0g2h+3", - "RdWditwL23LtnGvW3Gb86FoU4Xb+Yth7Y6l3YAd4RQaDSxw6d/jATZrsnJ8/2x0SVAMtVWBJJ1Rqym6c", - "fjP8ypO28yTLUeoMBVfZ8qaIZnTKE+5toS31aOwRTGm0AOCoIvC5QIP3XRz7kQKPgRhQF6HZx6Zj8eJ8", - "D22/hkUmV6zvOIFyGLBlwTrpEnDwC8i/uMGwtYFrOxYzRqEPcvLUMoEKTHqRsVl0LBBqBYNvuanVxuuP", - "hcX6ddjScPBAkk3wJfz+nBr2jq76pCL52vo1CTWgqes+NB4LmwPp1mCAYDKkMswh8jM7pIEPMXbJZIrN", - "wGqLE3El3vHbO2DwcKHX/TLh1X/OpsHaYRHpxHGY3xxVVGkNldjTi3O/G7t9oiWJEo7UEFExFnOMUPLw", - "ylLUdrXIdFtQFQ8iCZdAFW4LQqMTFs/beOyTSl+9G5Rkat8JHKcfm+T6pQkXi/UJwCG2EIKbXYpPXZtu", - "PkXX45/JqWgX6CpeRWtaZpbf2NX96mHs4GEMr5v3NoZcfk89RubNhSLbT9xRJLKnvfU1t08qS3YXpkay", - "48GH0F0jFTl7ckJoHCum9e6/tyESZmqptJT/4H4EVnwXMTFuLFLZvfD2ljqBfCns4KUbNaF+Xs0KyNX7", - "ba9WHqn1pisqJZVX3s3fHo2PXuUaKYXekta+3iRbo4C5jiCnskotAxSNElaIL8U5rVLRNquyjS8urpyN", - "4pJtBcEb7kDenn3ZfToXzbvhFpji0wZDvENGWM8Br9Y1/5Ko+XWxi25em8zPnxdpjm5PCrptU3SIzL8k", - "dTFuLBtwQYvA0nqBPmfG4q7cpJ7uvhCYONi53am2A13ZWRfTsq8SCyCDE0JLzGbd98Q26ab62v7+TJov", - "Ls9VJBa35F9FlA7KbrlWmxTcE1ek++b02xrE3C3H0zgCCywyPHC2acRrgrqXVK9EtPs1pOaTUzQudkWJ", - "VX7eLC4s2fi81LNuS66DgutlRXiuC72WCzJLAL7WOgFiPsMgQlOtsI6jPLiFURaVzBU1zMVOfokJyWd5", - "Yr0bkRRLpioQktUrde8PjKbdrip55rXxdn398ucBE5GMC+dJu0zqnnxihcnSfy3J+PZP3ReYaMu9eNAm", - "MH7E/tsod1Jgiv6vgx8cquj/OviBJhkX7H8dPk6oYdrs3hixjG7rprttBeYLJj7QX3h90dZY056h82qC", - "bJ0yPa7uVSizhofrjd1Fhs8no75PL+Q1QYQ7SXi3RvegSd02lMqJr5dgt1QqD6vVwEr+9xb6zmsEfev2", - "utrnucYRoGD3BeK3SOXhYKnD0+aeuB1vEnPFtN5mjChadbRH+PZ/KpOEnfSVjBLFun61S3SxS1SXa6Np", - "wja8WeOE/cYded8LYgutNj76igN2Cw4dR5EVHLCah7tEAltIbfDR5wEK8e+UicOLo1C9zzq6TEtOsfFe", - "82fq5Gkfd7gPe3rytEwGvyUHqh/HrVsE3HdvXxp7nE75PJe5ruaZp9REC6YdBkPC6jfDl2arKOWGVmvF", - "Z0ylo9u8027dGPGV7m/ITNLcUMu8bRTENmXEt+qqjLj2oIxYfGqHU+GqSfV9pcHdluwUj1DdlYxrQN4f", - "+l3GFVKSoDqHJqUeQ1C1OR6L/w2K0a+G0fTtdz4hPh+NDu7j70ws337nc+LFqScVJozirjDs41+eYujJ", - "HLMLsHZsCb/RHAdJc20s6fkiMf92mlsZfdNddfNU+FV166S6VZZrs+pmG96w7lYvNHXrypunt9CC22d/", - "UvXtT+5TrqmWOp/NeMSZwHJdaJXUa0HUVsX86k6+nn2UChfEUYnArEkindXIgmttkdCLGtCfNMSx31q1", - "QxJqDEszA7BPEYPqwTZ1UC9yE8t3whfxwAn6enC8nE/oevddTXwn4czdcFH7rppuUcjytlVd9+EvNHVW", - "Zq4mu1MuS9GmXbu8W+K9WZ2yw1V7+1rll0xiVn1bX7oMNIRAUTrrf0pzm2dcvFniWQ7Jq1c/+5xiUE+U", - "L3FopK9r6Gtfj0W1ruGQPCsLRtoGvgdQH1jsMAjgfV8pMGY0TrhgmITBdCj9t16N9E6PxaeXgMOlVm/b", - "997lWNoNvUMJ+M5Ywa3ImkWwgXGe4uJoVqqwFqfFy5t4ar4ofuUYUIDxhGS9PZobOXAoBXsLaTE1w7DC", - "ZwmNEFUYmlnASwcMYxFuq10h2ouSScKUBTLNcuPFLcAUdoPjwsiiVLeTzC6g+0kuDE8u+jYGEtommkCZ", - "eAt1Mxa1jzmZD8EbEJgER6hYZkfcqDsMg+ZgaoRWiLNQ/SShyTu60mPh4B7s61isXrHIYv4myZD8KBFp", - "x9bfrjBeW/z2Gz0WFzxO2MQB5VwQroleSGWYYDFJ5ZLp+ncZVQlnCifxhMLKaZLSFUJpWlRhuz4yYxau", - "sgbHI+HfVMQcy6jCl4spH48FJQejEUkZFdqBa2g6wwvH9UFwELUBfUsoORo9cm819g3h3v3y78BpUoot", - "ZUSnUDEXqNiWJ9/FDUxdWWNbJx+2b8aVtvtV2DddvcraxnLtq/TGfZKLEj4Ebf0V7xpsl8mVwHk69yTj", - "qrgGHWLSlEUU1lPI+ncQRFdGUa5CFyRsdaW+9r+j4FiZ3jkuVRicI0GTQQQ5ABKRHxd4piUepd1vW6iq", - "JKo/x0UTPCRSEUoqdF1aNFiUI2vcQdDZi7JYrPDF3y92v/VnB46vYwT++Iv5l3Q/IRHJ2ax2ALdfTfYA", - "b0qKWyfhP+s5feKYXo3FxZzOhdSGR54ZekzvqtL8VSHspBBuXtkgNc+kumyPhP5BqsuuGpiP2PyyFLHq", - "DD9DRwQMD4N07t4fgdZwq6wA0dy6ktakr+KUotDFjS5ilUkixZypqlX+1t0GVa1uxyJtwmWqrLO7wEUD", - "JWTifrSFxivx5uhiiFyvf9pgNSQ22OwyZm26sqpHiSR3NV4Jp6oK+GB1QW3jD/peHEK68hu2g9L7+nYF", - "mSoAjW5Fai0+7mFJA1CtY/Fa2+IOF9b1dEEKHgwCrS3YQt4teLSAfvA37N+iutIsuyig9HePyXM8yJVt", - "sx/fsWVagNa0TJhFY12m6cXxeqntN6en+BK2Wdii2hfHxJfXLu4PDa2qMKwwi4RqQ35x4LI7hTKOO3oB", - "NszK/HYdQGtZ6mAsQmCtgHVqO+QzclHBbb1oARX0/PZnOdefjauoLFBj52Ikcaoj0iYTca8tyIMnYcfP", - "/mgUqpvQET7WDuOG0WPXBvOznBfFcWqkTLOsK/m6YSIVL9N0Aw2TnZKDEG1imZu/aBMzpfBlR91txE12", - "aGT/YeglEKpDHvUHe3csWpbKzjC8VMBUe/0eE3naO/7V/WuZpr1+z40H3ntnsrRS7eIKQv4WON5mhx/6", - "oR2qYO7+icXzO7sSXSGl4qjEktnoSJR4nAYFUK54XnBLrwP9W7+hKti/jevO2QDa1YiXtsGf3sXpDY23", - "Jr47jaYhPgXp485OMYpZDVv45yTJV8Zbt5sJWaAq48ge3cbIEHqZRInUrOYn+3KAG529sCF6t9vb/BoP", - "YHhx7kvwdQkEOnevnvs3PwMTxraQGz9m4qd767E36yP4kkEo9NpsgP010P62BeV89oT06bZkbapdKOQr", - "bV7dWNuJMEHdWmcR7oXYlmSluZEpNTzCcoDRQkpdIfsCmt8W7nQ2+IIy0UJljQUuEeMCSPXCWfMvnIh5", - "7CyPhFYfuW8M8XWXvhF+wz8q3/ihYlwpOH7fa1BYmUZDyTTF2YxkNNcM5MwcLGKrKGG+/iMDv3pEM5Mr", - "hqVtGUm54GmeVmsuwI4tKeJDXeynF30yzQ1JwMqmioc+ZimSacpEbOWksVgwuuRMwaIk1DARrQaaYUn8", - "JSNQ9iGRNEZLTRZTdJhhIqViQIFYwCJlhsbUUBR0LuDET2wu2EVRJd9aRwR7X1ID+I5z8a2tpgPdXviB", - "XhCG5SK4XhTVlCMaMxEFyyicf95s7NOb9M+ZaU70jgKsrsVL7zLiqmq69sP5PIKxvljIjw5sfoPQq9uV", - "6noSjSejf88jbefq53hHfrpiiTed4s/DQVcQ3WfjpLt7L5xUJM7t5yqnEsn8z2pHLBhKDRECEnTtNl7X", - "v1ZUZy2W+Uo8b+8P/+fJNayLnwkn7Lcq9m11AMtJfw4s163qtXjuHZlVnS2papO7OxbsBnV34pNUFS73", - "pRhba8h7Bd+uciejKGpfUnxl20227eJGrsu2vW12LTKiwsi5GGCobZiDOzNuK6t2poN/06SexuwqLPPO", - "WWTpubh1GE3PGjO6AlPJnyHWeoP/KJJKWRQRatiXBf1dsRpWsyzQNlcWGO37pNc3p6e7bVxCmY08Qpkv", - "mENUMpvgtTReN+C+WDKleOzhTZ+cPi19sioXQ/Ii5YYYSS4Zy8rEIEzOBNTOAk+lMewmcEq/x4RRq0xy", - "YbaOomx6M4Mpf5AOVuYzFCVdLYmv7vDO7nC07H957Ay5DKHFBDZrpoaarTWuuZhJlVq5jE5lDr0DD4Jl", - "gv20wRYznjC90oalNrgToCDguGFdIld73r1nd7mPoc1wcmzWYcZUyrXmUuixcCk3GVPwbXgd+q/EqQUd", - "AoYW/PXMMsnPIwYSBmPD/qhpWzVEvsKa1r3j3h7Nsr2YGtoSZ+eG9xFD+gGDGolepVNIoISoyEtNdhJ+", - "adUTstQkgT92N0ZFTvC9T11Z//onC1b6RMxksG6ppdmCmP9UyXGOrXnH5GfB1u5Iz/zoKMLnrHpwPS+c", - "yVYWq7fyWMVoMsC6/B6LieSGJ/x3y3ahE64Nj2wWGS328c1pweCHY3HKjOKR9fdGEH+OIBWo6e5lSkZ7", - "gON3GGUcAf0OGQ4OmW/74xS/+OTsNbZLWSrVqj8WVLiOXz0+s57mGY1Yc6CCGfAkk5O9F1ti1s9xmf6N", - "4yftBDcCUgQ3/Kt78uqwMa1nSLccUZltUttk9qcP8HXS5Fcbx5dp4wAaLmezU2C1eYC1sD1jKZM8hX/Y", - "P062QdUZGi3eYNPPRvK2w9n6GT/BL+JQujnFzNZ4vhMHjF2wLzV+FhbOTwGFmFpkYvAWeGz+jNT96V0J", - "1XX8DF2vbkV9/fTP5mzd9s3nxuBBU6rr8aUcc0tpfiZGbraEvaO83RL2fSKjS+3QdaomTKIYRch8+LGE", - "OHfuShQTMNmXOFQqi33GdH8sGsZQC+KkCSWGqZQLmuzhnG0nCNbuLWp0KTnm3EeYMzPQYOrOZJIgIjsi", - "GsJsoMXMd1DxLmtXYbLapuoYNRJgm2TKPID9bkh1+yvl5gep6mj0nwtffFVZf0R5pBxt/1sA+Nu/+FGA", - "/Kf0PYZtx7lzbvsR7TyX5Y/WLNUnuDfj3uFIj3t9Mu4dpOMe7MATiuZcasg9knKRG0C2fGptbZhVfX9E", - "NIukiLXH0ffWxMORbpm5I8uWhN37+N5tij2OqnApX7qPhNgDtCPwPiYQkZ3qgXNnMu7joYuJzI11Pbhz", - "5VrFzKB5ZPfW/caVM/JVt+/Cyf/qjm+NR+EuA7usbL3l7FmuF6zd5PazLZqVmymsQ1FkWy/I3+VU9yHr", - "wFrmATFvje/B22f2A7dROwI+dZW6EW7uX4tGdCgaUa5VGH/TBnvCleypw4JwsveZVAZ+d7gFjoZQk0Aw", - "ECyF+eLJyVhEwIosWqRiqUTu5CDu7S38+K/n5NmTl33yFAs+kx/z6e6QvIBMG+xVO3/RWFhJzDKviAKw", - "up1BHLqe7diRem4ycB0+cCUp/uDTeXrwZAS8PH6vfMB6v7dgNEaJ5I/ez9J+LAAk/fJnOECwf+7NYtt7", - "G4UPsOGr1eDxzDC13u2py9kSBQyKu6Q9qqAT3PDD+EHtwfTKb1rZwKKdHB70AuAnH77W8bj5QuG347HD", - "77rSjpDN96XWCMaDWDDHEAusXtdFJYy2jGXHyzYqGPjJk6efRKm4US/1Jt5VKxfw73q6cKZfrKMpq+0T", - "EHFRQWerp9cnKi8swrV9jUQ0oxE3qz6hSeLuKHcTFNExg0L8nSpGL8FuPwQUMvdln1wMvtq+d9SSmOtL", - "24PzxQ4JhMfpfFoMjuBBs15jXHNI0TWSRDSJ8oQaRthsxiLMC8aSPLrFl1sMpXeDZ6f8SBAWphJhn39x", - "ZQvDNIG7V5JFk+L27FbvKRYllKftePJOUMPgRww1mEKnUkDsQmIpjkZKak1cVwOW8DmHshoYKQGVNMDM", - "RVM2FllChWCK5NpG6MPQB5liWueK+Q7g7nIU1SclVmSmpHGhCYmUSo+Fp/A3p0Qblm0gs5e251Oc8w3J", - "trZz96U7MlI3xtBuCnFNCGyIpRS74EBHYBq6g7B4O6C7lhK/lIP/SvE5xL5mSlLLZG1ckj3Wfjntoa9l", - "T7eWMD0vWnUrYVr0WsmQrGQPbsT6m5Tw6XHvahGIgY9f8lY4SPfoahnNP8FLHb9dz5wND8I9+shZhqqx", - "/jsWPj2vJCx2NWCVFP6lmZMqI68d1VrS73aIr85ZvjeZddsZy+vOILy+ZOQuWkvlbVN4Pz9CGN0u4sRt", - "1837smmrhrxV001b4Ae2F0j4LCjwZioj3DHiyjUqI3xWGABAO3eIxRI8qHeV01/zPUv1tbjBjaby2woH", - "CA3XlspvuZ4LXt2oKL1xbbqpSa7HP5MEbxfoKvK7X/avWn8HlaGyWNtc0EDwLM3Myr3kfZVl0Jnmv7Nh", - "iyO4iFu9OVfwNUI6Px15eDptDei8Q/SyO3Tk3EnMqKsGyTWE+ZVV93xi9xeGd1g9c7WLZQ9unQFV0YIv", - "WbvRvX6C3RJlig0ymaFzJbYL5tbD32WGquH8d+K6d/iv7l9YThQLGbCYxFyxyEC0iDASOYL9xjeaKCmN", - "ey7Vqj1KxB6RH5RMH7vZbLkP3ZlyxrAyzjBdDWJq6GDpuc0GE9pHRHf6eEpgeIQL8vx7ssPeG2WLlpAZ", - "aD6Qbe6XlL2PGIs10uRudcD7o/AQoePJfNpllBvKz7zAP2hColwbmfq9P3lKdrCc3ZwJ2AsQ9WcoyWZK", - "LnnM4toYIXjfrup+y4Je1e4KQkVRi9ArF3ZwdyLDdLmQ5r/zrM4WipCYKRcUB7e1wEv9TFlAAfge5cIH", - "4Lg98qP4eoU5zW/HKztAiVha1S2ikdLCTe9+vea+5Guumgzl77TabefDczYbr7vlR3VMW7qJIhRF7tzt", - "mq3ffD4pPVx/kdk8znS+LBTSNrP550WCo9u7H27bXP7mC04BBWP5srFstgO1DBPMzxjTHbMlS2SWYol7", - "bNvr93KV9I57C2Oy4709jP1eSG2Ojx49OOx9ePvh/x8AJoyqeVL+AQA=", + "H4sIAAAAAAAC/+y9+3IbN7Y3+ioonv1VpD0kRV0s20qlvuPYjqMdK9a2bM+3J8yhwG6QxKgb6ABoyUzK", + "VeeveYCp84TzJKfWAtA3osmWbEn2xDVVE5mNOxYWFtblt/7oRTLNpGDC6N7RHz0dLVhK8c8nxtBo8U4m", + "ecpes99ypg38nCmZMWU4w0KpzIWZZNQs4F8x05HimeFS9I56p9QsyNWCKUYusRWiFzJPYjJlBOuxuNfv", + "sfc0zRLWO+rtpMLsxNTQXr9nlhn8pI3iYt770O8pRmMpkqXtZkbzxPSOZjTRrN/o9gSaJlQTqDLAOkV7", + "UykTRkXvA7b4W84Vi3tHv1Sn8WtRWE7/ziIDnT/JjTwzVMTT5alMeLRcnexLLvL32BuhuZEpNTwi2tYh", + "GVYiU6pZTKQgNDL8khEupjIXMXnz9JREUggWQWN6LORUM3XJYjJTMiVmwchCaoNljKLRBTF0mrDhWPT6", + "jf1gAr7Em1fprwtmFkwFBss1ca2QmVTELLgmXMDXiA2rG2ZUzlZXtt/jccImhqdM5mZ1oX6UVySRYo7T", + "8u2SNNeGLOglI78zJclvOU34bMnFvH2RpmwmFSM/LjOWUkGyhEZME24IF0b62dg1KmnsQRoiLj4XUrFJ", + "zLThgkL7k0wqo1dH/wr/oAmplMWhYXliFtR4KhfSkAvGsvpE6RW9qC/jL3t7/cej0ejXfo8bltpjRd/z", + "NE97R4cPHuw/6PdSLuy/d4vRc2HYnKneh+IXqhRdVqajZa4iNol4rNbNJEo4E4Y8PX72+oYT6O2Ohvi/", + "nUe9fm/38d5w9/AR/nv3sFed1srC10f+Yf3ROzPU5HqVB9nTNHGEMqkQyeqsf87TKVNEzkiUK8WESZYE", + "jxSLOxBdbdqj0FZEUsz4PFcsXu3bH7naci6oJlRYpjFo8IuysU7nLgImFssrMVEspVzAGq8M4rX/ROCE", + "EneIYEiRFEbJJAGmYAxLM6P9KeoDGxeEZlnCI2Q9tUN1kI50r98TeZLQ6coIy91mCZ9zLNBpabiubJKv", + "S4wkTBimihPeZWlqbLGt43K5g7tR8sVOXS5kEk9yYXiy2utb+NmtabUnrsmCJTGRs1mf8BmhBFqBny2N", + "15d9b7R3OBgdDEaHb3YfHo0eH40e/K3X782kSqnpHfViatgAdrnL3iDT1lxE4d0RTRJJ4UJSLLK7U1xY", + "tQ2cskimjEDTa0d+8PEjb71unpabCgWJK1jerIGtHjaujG7UnVBtCiaE+8XNckIDY3rDU6YNTTPgQzCG", + "ymK2cSHfYHMf/MqvXeDdj1pgwd6biVuh4HxC9MHeZyyCG1F6blIIGNCeI++CZd0JjStGtRRWTILL9Jde", + "LnSewdXN4kmWUAPt9vo9SwaTlGsNVYsfYq4tH+n3PJFPhDQTlQthCwpmrqS6qJZ0rUx41uv3FlRPLudZ", + "3uuvu7bqRI1dsIRmGttzO64mTCmpelY0Xk5mUvlN6v1aXcI1Ta2skC6u2MAK9fq92gIU7NzPxY+72NXg", + "4Po999dE2VcFNmcnszrwalurwy2Gtp6x21vECtF+m4mrrOscIOZ0LqQ2PNKd2DwKD7C9qYwDrPNZ0Rzh", + "MROGzzhTTq5mRMH9kDLiGyHQCOGC5LpxDgrRf8IumTB6cnkwMVG2uiiNh0118yqySXkjVm7lYvuLk7KB", + "SOtzDz6cLinHM/mMXfKIrcpubmsmseKXTAXYdyEAWFZoy5EtOOvAQoQUbLu2UuKSx5x2YQcxjmnCA9Rz", + "+vSY2M/k+BnZWrD39U72Hk4f9dqbFDQN0MKPeUrFAA4EDMu3j2Wrbb88CLXMZZrmk7mSebba8vGrk5O3", + "BD8SgRJutcVHeyFJNYv4hMaxYlqH5+8/Vsc2Go1GR3TvaDQajkKjvGQilqp1Se3n8JLujmK2pslOS+ra", + "X1nSn98dPzt+Qp5KlUmFb7aNB6e6PNV5Vcmmvish+v8+50m8SvVT+Jm1rBNTmmvDhCHf22JEMfuUI1cL", + "qRmJaLRgZGofLfg8x/a6kHzRsb+9QiN4xnUmkc+TdyelNIdPQ/aeRbmp9fstibk2XEROqKpMrsOIQP2U", + "MLh/Q5IFrgBxZbgUxHjR6cZCQKQY3dAdlOjU2er5zy15TVLd1rovQrggKU8SrlkkRayrfXBhDg/aJ1M5", + "xfbaXOnqOfxMUqY1nTOyhWopfG5YDk+4JjPKExZvd5Ow2ybzdzmt3Gu1M4dkMKDTaHdvP8jQUjpnk5jP", + "nV6xSYPwO8jH0I4hPG2dCEoY3eaBXSo2W+3vB7xPsBPFZkwxEX10d5mSl0xQ96T6D+y393/tlArXHadt", + "3cHFPC2Lf+j3fstZziaZ1NyOcIVNuC9ARrjUBGuEx4yf4u1OFKUNVevPB5b4BCexFDY3ro1T/YC8Recb", + "q7yBMk2GjuyoEHAqXKCVbz8HSSsgskhhmAiszks5JwkX9hnEhHF7gcLeMmPfJXK+3ftk61As/+rhh3Hf", + "gHnZH1pag2/94lWQyHl1NReMKjNltcVsuVddQ+XoWpf/tHZ8Ghco1WyynoOcciFYjDp3d7BtSZCtg28f", + "PEUX3Ewu4QYOnTkc1k/cEFeitalERhcznrDJguqFHTGNY24Vrqe1mQREyJoxg6KSwDeIog0+qs9+fLL3", + "4JC4DgJr6LS/UGB1JpXa0LwtSwxVU5okQdpoJ7fr39GrFBKmgFLh23b3FBToCdNyup7bTfd4z/XC/oW8", + "G0aFd1+v34uAvBL4e4Vw+733A2h1cEkVrjo0XxnWf/ueKr99X3Za+fW06L/y42s3lMpPP/hRVX57Wg7Q", + "rwpTq+fBPdNw0mGpUnJhBlzgFoAA7jRPU7t5xSvLaTKIFBUJj6ku7HydYPV0RaQiW69/eLq/v/94u7tw", + "xfXFRPPf2WQ+XSs3u0E7QRmqEahGuCBzPqfTpWF6SJ5SIaQBY2S0oGLOYkJnBmq5sdYe4A9Gm4wwrUIS", + "U20ikvn9gD5+9P49NY8P+ZV+/Hs6VfO/79Nem3Yx1y3rixo46nYTihJFRWATb3ZRp/Q9vPwtlYSMnyfW", + "XEWKQm4PdHMIQ1I+6Gf8Pay5Ibu1lQ4ubvj1V5iwhBSDXPDfctztLKHL1TegYTQdIEWEltfyDXuA9Obj", + "o+H82Dp+pleUGzg5hc3UTblPZBLDvTPjSpted2vYtQQDpj6ViFQ7ZWGJaZUimgvYeqkX42w9KwmfsWgZ", + "JWyVuXv2nancqVtjBncO/lkoELuycaYCnNj/eFp0Ufv5Wdlf7ffntvMP/d5TmtEpT7jnzHU+7WzyE6f4", + "27RL1cae2aqvXc0P/d6MUZMrFljLM/QPIFZPPEjYJUuIKw3Ee0SenB4TnasZmsyRWm1ZUNtLzfRYKDan", + "Kk6YRlK/WvBoUagrQfWgCRWlWwB5klzRpSaZYpoJczQW40JDrse9Phnbx5f721KJ/du6hvhCYq6Ydv8A", + "XcO414e2EjnX496Q/Ci1GcBz2clSR2Ts9DF63CNb9k+SUa3NQsl8vhiLlAo6ZykTpk/QSQPVwMCZkuU2", + "oSIm456SmhlDByzNE+T90NiTLEvYWJzxhEdSkJRGr85c3StuFuS1rVS5PHHGcFn3SeZUz5qmbCyoVYPC", + "Ti5JpuSUkYTmIlowTZiYSRWx7SE5ZWrgl9jvLaGKwWZYJS7JBRwRRsvN0L/8Spgwynk6dGcuMJPr0B8s", + "ffGI1tepeWxrfCisI9ep/LOrAqzKzTj4RlHLUpteoWd7Ixaqfn8d1SwB/bHAFcVd5VDqSpDals0SOkdS", + "qRwiS4x6LCKZpvjQc70QzS6ZokmxQ3DHSdQnwN3gbqSxiBKZx4PFMmPqkmup+nBDsAidEVSf/MbSvI+d", + "wl+DlEdKXqZEirFIgIx3aBofHmwPyROScA3E4efPLXE7EkNOgPoADqMd96jXyY97dmJcE7j4h+S5MIpb", + "miPaEtzU3qQN4uq6eRVmtXK34f5cp7EzW2PFwmF/dgTdX2GxFbopCbAg4woXDd1Zaxjwqgzu13W9McqN", + "r9itiAq3UzXqPCLcEJpljCpNuBiLkppEjFTqKmWK4XJobtzWpcyQrZQaZC+gtR0L5BDfaFLb/e0hQbnR", + "+oeVHAmqEMWSpR0QGws/5iueJKg4JDl6MCCHswcNNWMVDwo8TFQUvC8prV3O+OXsorUJ1I6I7fu/n5+8", + "JXqpDUvJlAuqltuE65LXWtJcNcyFRUa3e/hyR1GtPutYotcT1CVS1AXI5nndaEJwImhJF5so7EcZcrGk", + "KlqE3Oi0IU9P3xL4zA2LgIhr46UqPQyakqRuaQ56pSjE2vWuNYdMZ+OcJRwpHPGmyR4X90hYRCrM8avW", + "LqhZseOyhEXAq6w/jX2/MeKMy0SmyNIFW53NTusS+cb1pt412ZJ6Bya8XblZ4EyrXAzJK0FQjCA1KWIs", + "sCgXUZLHTJMKPyel+tbLFzU3qILsx+Jf/+//Z2WJmFxyWkgb5B1XBnxIfrev2JmiKQOmV7/SogWLLsai", + "KYYQaFVLQv2lUiwz19ULRfH5whAhr4ZjcWzHVAx4S8uZuaKK5Rk8M8lg4EY9cHLWtnXiwoa4abho/tLY", + "m8riXNOXsGbOKza0v0phm0j151JsqdPqnBp2RQMP4hdAeoNLrtFlDWnClSXHp0OCn9GUEC3sV+CiIMWS", + "LUsVXMzHAr84kXibOInWkpkzTQ7Jq5SbgviFLK4Xd9ONBTgYThkTaEVMLq0DckmqS9bcAPDm3AUD73A3", + "dDTmMPaJkZN5HtS7+rsu5opFhrw7GRg5eHdCjKKzGY+AjjKm3KjtBdMcdJCfg49B0rLSvqJ3oUiG8MhQ", + "PJ6DkAPL5UR/+5u9nDKmYFxvnpzCBYer/y0Z9wQ1tk7J6QdgyeExi8nPT97A1Rq9Ott2q+aeprbhHlw7", + "ISV4v6fzqWCmbfz2K/rghrcCXWk3MV+7RCtbtIm8P06igYvfNvDNGpmk5GAgnYAQW5DgkLysya+2QuG4", + "AiLoqkRftOAP8bekGO13KNCQlFGhCXWyfmVEhOux8NJHTeAASZu4FYWqKheWS9n7cFDhviiWWHkEJbLC", + "Sf8S/n9wqWV04Vw87Cuz4LSCpni6q0u3Illx00nI2agCqDxYAkvqe68JnvBG0IJmeiENvqr9P3YU00Yq", + "tg2Pc+cvBd8zmmtG/kJSlkq1HAtfvm/PWUKN9WEo6s6AMfXIVpRIwap6BOtAQMdCG5llLHaGiW/JzB1u", + "WjgRSlXoqm2hsXBd6B0rAWhSzAI3oLTAJMtykysz2UZVA86mmBbMOU/tsBfSZEk+H7h59shWwi+ZmzZM", + "kP/ObBtgRZFSDJw/JBQtdSf4iRiq5sw41bPG9pFmxr2x2MJzS/DfYFhJc8EjvM2x3DzLB1UVR49svTh9", + "u1P6LI1F5TNWAaXegMtBwlMO7G0LfiDHO6+Ighsaf+ZibkePhe10iklieTfFIXlHk9ydU6R2WN+x8NI/", + "jnRgVG4Wszw5Ipe/OyGsvh/FThZS0e5+32maEtQwtUoy706IppfMEyTWgie1NnCMaHzJlOHaaWMvyJYj", + "p4GzcyHdaSIYi4mQY1FtCw4ykikMsSnyE6uI0aSxSGNRim0NT3J/tXmTYaGK8IJPd43N+hdNi43h418t", + "13ginxWP+sZFkvF2qyroIvGg0Khcpsr7lZFXGRNQKpZRnjJhCBcz6YvWvchGw702z7SW7s+q10rRvV5I", + "ZcicG6IYiHFSOG427g1irgwcf53PZvw9viJz1AJZmQZb0n3gUONeLi6EvBLjXn2YDw/p3iye7m/cDT/s", + "fm0Ng/uATM9ppVvj9dbb0J6uNZiBqEmMhLdz9eXvKPwTmMvKkCS49NQAzkrCWVyh7b711p0zwYBzxdYH", + "1BAvobWYfAZBUfbWrUrXssS07Kj1nG3d0A1zmCdyiheen0jpdDokx/W16xOKH1Bgrq9yES1RcQwlW2w4", + "H8LtkkV8AJ6hA7o3GI0Goya1JwcD6/KeUWOYggH+P7/Qwe9PBn8bDR7/Wv45GQ5+/ct/BB/kHb1VvV3b", + "zXPLn6U+8YOturA2B7rJvfXGlrXq8NsPL6oWWnc6UgyPAU02jgE8Dp5WirfT+tPjVa83u1KxBD30kMud", + "hE8VVcsdMefi/RGIc9rU12192XUKlkBwjBWMfAFCNXEall92LqniVJhf7RjJuKocAPmN4K0B9/4zHBEZ", + "DHw7jn15z/uaAWBIfpaGUGeRhifdERZa7XeuaJpS1HZe0oTHeDicmU3zmFnlrMBv5NJKSYqZXAlyMBr5", + "L5PKoEBukNpPZdxzilMVLYhTCCmCqhAbIROxDLo0MqaNMKXKUqyeNDhmf9kp/tryfw5//cv2//6PT0rq", + "SGhraNyqM67Jzxp+3lCIbCXyiqmIakYSBrPVfRLzOTfaCm8xukahQu1bEllnD+u6KBVhwquosVydnNPl", + "gGZ84DQv1tz9kom5WfSODveDi7vl/hj8+p/+p5aFVXkSeq+9ljlqXvFzNfDaj6GT8cWvbp6g0SXl4thW", + "210VJz9uh/1E1u20fdS1bjXcMUVU0IaBrEbgg8dRGhIiLplScBQtX3t68gyeMBfMMTR4NZJxPhrtR1gA", + "/2TuFxDi4CmDv23XJR7bXEjY+aXHooVEN8gkkddRUvabTL3NS3CtjSy02iX3X/UpRCO6NYujs7srSKZK", + "XjCFJhlYYs40uWBLqy6Y1xSaTFySS6q8afANhiVgEf8JrUEMn8fwiMXgfIhlZcqxRfdms2FQjCYlt0wp", + "mLvwXakjmTFgqK4YTo2cM3F5TlKa2We9YlZpnlLDFIfnYqlYTFnMgUePBcODQTIKZz6KpAIVK+wt6mDL", + "VfhGk3P7TDzH5s+5ALI+twezoSr9o/fq7ZvvX739+dnk1enzn58cT356/j/ws63UO/rlj54F0ygcr75n", + "VDFF/uMPnO8H6zyLPn0Q6r6Qyr12vYke/VVoxocyY4LyYSTTXr/3n9V//vrhV+/uaSP3LntHwYF9CIqZ", + "TvcZ8MH3AVCaSFV6nlLEBUEW5dUOFXVDQ5VvJb9rHQl8onA5mWY6GJvS1FuUcujuaHTy/Y7zHnng/7E9", + "JM50i8MHHiSVE4/1AsinwOVAe1qSyMhFaMzaQvB9VyEGj7bWTHJhNjKnsugqjxoMyq/XYEU7Uy52NGzD", + "ILreuiPd3NhR+bm45EoKfJ6juDRNmK6flZ9fPXs+ef7zu94RXARxjnGEvX7v9NXrN72j3v5oNOqFCJS9", + "z7hiOuj4+GSqZZIbRrBQ6WM6JCe5RudOxzxmOepBUT7TJM1BsZQsCXsfJbkGPoXSgDFJKP740WBv983u", + "o6PR6Gg0+ltnh1Ug/Q3M+8XpWxuhjued0cQsJmia21TxRyz7FIt+6HvdJD7tA6tU7KnXVsLpdXXI1qIu", + "XdnJESTIcW//xff2QO2+GPcqhOhCgYtWbMON1XvxfWhdKtqoVUmv+GYj3ETsqX4VjMbq63Pt1ERVS/hA", + "UITYgZIxVTGZSqrib+u+NFgTFPnfaILaCpo4O5EVvbGOlSUl0/hW9j4+pbJV9xtLgJqf1KoSqSAMLaWX", + "HFjOIE259PXqbMkpU2o61GHFwBTQ41XchXr9HszM/cdPsNfvXf5ej6nerA50rjGd3oobHoE0ybhga16B", + "n4mwDzrlRNJ4sPuJZf2Kv1sDhsZ+qG938Tj1BL6C7jSlIr7isVlMICIehhy4Id0XUhQursn3MBOa/Osf", + "/3x3UipEdl9MM3dn7u49+Mg7s3FLQtPBWJtiInkWnsbbLDyJdyf/+sc//UzudxJWpLyReO72/7ltoQlQ", + "43C7rDd+i921kMPK+FzZYkvfgGEQunLlJVMJXVauEzem3u4IeXpjVIpbc6OrV1Ehr79coDUvrlWvF2Dz", + "M84S66NlXW/xfaG9hcjaDvG0AE/6RvsIJEamUho7AlgbRlewUcK30seppIbu5oikMJQLptx4ixvDXin2", + "xZIeHgzJ8/cZUxwEJpqQmKorLqzTi6/p3tyECgAESrhgA546C65dEjtJ5MnQMBjavMORtg5Hq1p7VFbH", + "xN2PtrJUDYXYbWqWFEPGPMkKJL11x+e1LV0++gMkGaDI76kuLLNd6LAgw929E/fnniXIKvEVh8ueNa4K", + "4rNdfQtiKDydDXaqLazdlBHoiVFtyAF5wb8nXEAof8LICf+eUHc7cUHe/c3uA/I63UmW0hc8s34eEzov", + "wlLXIf+dXfDMveexhvcysHdQnEPLeIaGY2GRfYBtIO2AR7633RoIItDWcQFuW7zPVmU00A6UN5otbs20", + "Khd9Ms0NPPmlYcQpXxzEAIwFC08ZyUsn0sYD3E1w1TECl+WCKcGSiX1g644rYysRV6l1cXCqM6odEpky", + "eVZfr2c/nZyRrWdLQVMekZ9sqycyzsEb0PKE7frq9cciUwjvAp3AWeCuXzkjMjcDORsYxZgfYoqNFXYY", + "B3Jx+eL0rYNJ0eCk9JrBwjIRO4dXL+wUHq/iG2NN4bVmq/03Fr0NCseb9zue7DNXvDza3TWS/Z4xSQjc", + "LrFsDYKIbBwFGK4K6vOhfX04gS9kicVgucGQvNXADUbg9iIVei2QqTSL6usSryVdfQGVEJplMXh/hp+Y", + "5Wu2cb4PFkG7dZTlddLd67diGl5ahwkQZ3RXznUJhSuMCwGXApxrryOjCoLNuCCf1R2z8LJVvZIdYLln", + "1NQBObqqwm3LCAa70TvUabRxSbprtCs61hXdtlcA/tExaGJ9+8fCD2StRr/UAX5EX2e2keYSubb7fmY3", + "WKXjYk0adoBPszxPdEVn2gm31co8Vp7RZOsc1KyOjkGxet4n5/9Z+wH4qZen4LlwRexqII8W8FO1fb3i", + "2bxBj3tj72aqb74fT3Qr6ha53CVGUaGtn/2CZmxIfsSLkRiWgrQINxWvuhYKefUtkfaN4quOBQxN130t", + "vTZf87kA1zN0mgeGE8dW5e80dt7/Rofgjr0ebkVit6NzoEXIy5y3PTn3qvfzOv9dVcyv6q2cpn5FYYG/", + "W0UFqnLMTpob6N6+XpxNWubGgpi5qTcEvLr6f5NjkBtLoYq8wf6fFeyiiSF9GdBYwOTkrLTXVAxHbfYZ", + "J/yFbUcXbIlb7u1EdMVSVDURhQ05zqXdiTKVqqg7tFcJ1xX7krUUOeMQOh/Xj2jQbLJpK2C9Oi9//eUf", + "jMMZ+MmWFOMe8x6f1HMhmJztD5WOmuHioybhyIZ1nfet6oOhfpEIIJbE++Y3m0e3ZHRiPHe/DF1r50WQ", + "4KfAHC+jP6pbSyo760VpbMaLYobF/bpsAOjUevOkrHvqosXsqdiV4p6ReYDLjiKvi5pJ3cPr4/RAzyuN", + "rXEI69rEapSsXd/KmB09WWBnH0Ri9wPtXzXE4ybwf9x4hlvkmHqX5zRJzsmWK7RNFPs7osK6vQIPu2L7", + "AeXWkUDhbvbupD8WlgucL4zJJvB/egKn+LzZmKvrT3gJyv5ohKLrwcF+PWbDDrjRbF1dHkTDad8a8Lu6", + "Jf+tFqW8R7/Hz8UNBIg3ZMvQORwdB3sE98T2xyrsudAsyhXbfNafoHjkoHdwTAnlYvDjmzenRLE51xhq", + "HAxqsK7xLRhtTllQuqv56RpZ19ru7R88OHz46PEwvlBDFqlhrgfwkBnsDmlKf5eCXmkQu3bSJc2yo8vd", + "jXzebkExvnaW71+27aQgU2DJ3iG5yyv5aVmlNBhecBF3beAnKLvZ6dU/4m/b7JIpNsizuaIx+8RGlxv7", + "NeFqtu/qhkwo6x2ac21AEVFCAG+t92OuL9alTAYxNfQ6bsx2uKsey+nSNmWf5KH2Wt3Dz5o+4TXcnmA+", + "hI91MvNjCW1LG6awVSSweGJkIHzXyw7Hz2DNfdlO4KkIgWzk5HLG5aYgfxhaPXQXq3v1BjQxyCLuNHXe", + "qsELrb9V1r07qfrWDMdigFLYEXlWdFA0WzRJ8YlBY2vl35KqFj+MhoApQJ+QdydD8qYY7TfaGwXsmEgR", + "OZqjQRGFooEVyaoDyDHQhptmdaeWtHjM2+hCJN23YZG1BRWghQIN9WVT3piPjevGjXJ3SRV6pqNCeB06", + "2Wt7H61DKKt5hDwYjHYHuw/e7I6u6xFyC5DTobae1HmL8/2vcp+nb4+f7Tm15/aNQck+OSh1mJU9K4MW", + "yFauWSUgV6pgqEIlIqAlFOHGEQa3FDBQwm+uK2tX4g2UvA207RAeGBbp3wAPu8kwN4KuVia3qtBZZqh+", + "KE9JRZC3O5pFPBh5DS6D3ytGLzCLwOq9jTgUE3ufhf0NESxkukRwLFRyKSnNTJMCQ6ZUfu8ePDx4tH94", + "8Gg0CuA5rxK8jPgELbKdBgAuOAldFtCGW+jGEJNpIqd1Qn+wf/jo4ejx7l7XcVjDfbd1KN7fvhbZcivy", + "F5/pzX+pDWpv7+Hh/v7+6PBw76DTqGxj3QblytZFkof7Dw92H+0ddFqF0LvuucfXbgrwoWQPT2x+JPjX", + "QGcs4jMeEcSlI1ABkQMWYMb3Vuj6mZzS2KfECN8dhvJEr/Xus525klbfmuaJ4VnC7DfckE4mCZz5M2wp", + "mGNMiCIFyfVacqjkG/2+/FyKIijOxGyaz+cO8q9YuhMXzV8KT5wl8REpnmxr+RzuZjmwX9vowM2hIzW8", + "lFcF+F6FCOzVZZEqFCMFndhNq83KhwtxkeVBkmhdyh9yZUE4sFFCpzI31oLvcsaUnVg8G4EW7VzE3dQd", + "P0h1sTG+A27iIjVOR4WBD/SfIRBAI8S/KvQVlnbrj+C+a/La1rCKwvLnLK/nBexjT06hKDw6QVzojV0z", + "XaXLsNyCOnPv1Gf7K3nnHXk0DmbWCezTvrDVnGFKKLNRYgFKsf5TZ1i8c7gYVNyoSOmw7oJd3cWiY8Dj", + "AMh2ACqU21nxdY7Tha6hLESkCzcAfE6YeVyBl2qctDOPuOGWfDgWLt6q+Mk5BUBFuw7WkUAqPuf1jut6", + "1jt0Xb4OZXriujF1Viu2+QzqwgwY4gEWcHpmPYGt92IV79btSa/fOytyZznGVF8a/2NgRcoAg1XoodO3", + "13VAzpSc8RAeEHodua/uoeZdc18ejM4Gu/9tvTuB/FBi48J6KoEdYdjIf4Tlu11EL07fnraNqUg+Raqj", + "W5nTGpSj0rOmjIopFsfFmnPtW64k6qWCGHrBQMOEJ65WzMJ3sXhInlpfG5Rr+Aw12sYXs/AqwIBs35fs", + "qAaVAz5hghWNWlNqnANVVXHeoBiIAtpbPREj7sXp2zpew+OQ+I2AK9McBjZJA/rAH+A7sQUKwIiT7+si", + "+N5BqOkw4z6tERC+9Gc0Au+AzhQS0CE2prEJkfHF6dvXLuFSG1Y1kFORlMnCVA/Jz0VKMlheXeJRDQPK", + "xQYJWtdzKDDRiQw5sPygGCP4rUyFCnSDRm+Lblw4GtAY0a2k8AkZwfffYQ3+llNFheGCxeTdD/pbMnJW", + "9nc/EBt/5HgW11W/y/rj8mFoS1vjCE8XSw26PbssNikKF1XFJnKBzi+T07KiUwEH3ifhdHye45AtSMKI", + "C3j2enD86t1OGrPLfm1M8NF66b44fbtdYcuXHsyiKFvnxpdtGia/VUV2yEmZkbJ5EBBH26k+m9QBezMi", + "UxZR79Td3LyoSOA8RXcNVJSBmdswQRR1emoqao0g6wLH+zxJho5n+iET1EzPkHVXsF/t7eaYmmIZxcdX", + "IXm9N9gpIzqPIsbihsdLc9QVejsiuUip0guaNCd3VAAsRAuqaGSYIt+8/6YXzsCErLTr3VChzuJy6kyW", + "lasoQI+Vc9d2xN/9UD+eVjqwYdVOp84FNwgTh9jgW8UgLZr5kJzQpVO9ZHjNOnopd4zOZhYstbhHFEsY", + "1Zg5XZN3P2z25TTS0KRtDm/go+NTWzAhOEUwzD7JamwAfq+ilFW7PQxeGeV8ApYp7LBp5hiSYxFme9Zh", + "CHEGLWSY1nwu4Dmonc8Q3Kd+JVf2rn53BjVJTVzGXn3hatPpBy6AEMWEbisbB7r6MlrN5Cov6mxKXmzO", + "Hmobae/3qQ9VbZjC3PPTn1uMaPXOS8RWdRzDKlQ1y6iihiVL+x4pqLOeDYKt+qFAtMA1YmWfQ/EPNgNQ", + "rtjELBTT4DNWU1Ds91ezSGuMSrhkLnGenVPFXGckSam6wFPmn98kF3YF6nGx+5vAsRbGZNeYFDhVWJ2c", + "YeqSJs2ILb3il/OMQZTWlJkrxoSfCtWEVr3imxHvuiV5GcTyMMVlfQ17+4F+z2ykBJkrGjFia/kc9AVb", + "g6PXdSl7+y3DggtH65b93V23v67qLE+67XFoWLubdthE19ngN09PfRKuIsm5X+a91VWGRBL2yLkaG7Z2", + "T69PB+e7EhZFe0VmnzLMD+dizapR7N4rEfPfCYzYq0SOV5iDrsY6u37wFNil6ttz/munN2HzuIfcbyDS", + "KJQsHj+4KL05gg1ibILK8eXFYysp2Tu5cj+7SCqQtLgAXOa633eUq6TX7w1mblZHOzvA7xPEWz3Y3320", + "s975e63Xv3NynMR8nVbIlXLOch4CwIJV4qTrJLFDs6yD3hxrbrofkD2tbIJNEA93W+WR5UNcwF7TcF58", + "TyPjU1qiIr3mKEGrxxZR0euCDDSY2ixV8Np9XD2fo6DnCrih1sl/Z4X2YWbWExloxCopG+toifz3oHQq", + "VShvoVTGhStPmX+0F/ehdwT2+N81k/roUXWWhw8e7D/YxIeQ2TSOuTt3gana0nVABlZZbnd+XQPwH12X", + "OdyX9WSF67KBpt48DZDU+gWVGRPXWs8HB/t711vPrhM59s6cDb4UwrMCACuUicrI4pQZGlND60wGNdDA", + "ZTAxFmUpBg7Ovl3PWlq8nqoAVTfN6vepfGZaEny+9nj2KRV8ho8kW7Las17QvQeHRzYNccxmBw8Oh8Ph", + "dWF7nhffum3FjnWtrSD4DPXi4/bhFtB5uszlj97pkzc/AiPLtbKX1o6ecnFU+Xfxz/ID/mH/OeUijOrT", + "JXM1n61krK5tb5Y72HQWH8FMhAvG8pJSB6++FhMSxhQglFgQI7PmW317YJgFjfN6zpNrgGKuCeUHcQU0", + "8q1rc+Mk1KLQhZpK8umqXqFDImpw/Vzn+eE1zljG9Wk1HUWO7lV/mBtlWddrE9Gu5CnMmChSzyaJ/SuS", + "AlHJQ3loa1ek/9YhjSFeIy5fYdFl9cei98qPT6sDqfzu0yBWfnIJaX+9piPbWoH0r6ty6GYu5MXRDYc5", + "rP4vboWuyb8diGYwguOe78KbOHvWe381/6/f/o8+ffj33d9evnv3P5cv/uvZz/x/3iWnrz4KoGk9fuq9", + "gqB+MtxT9HCsgZ92JaUTsMys0hM8/1pW2H2xGgcTLTBdMZmyI3DBfskNUzb5ZSNkGfI1MHwpYS0iBWYp", + "dGgW21D51PohQOU/vBj8odlG7GArlNuQAihJ59NYppSL7bEYC9cW8RPR+C6Av2IS0cxmsOQCFLPg2K0w", + "3agzDJed98kfNMs+bENKFGoIe29TAWQUMzbOCtuE8G4dblTWed0VZwXeso0jHoviti4ARK13wLDMNsJZ", + "0oz0a1mU9e8393J6NApBrWIUGmwkZtTCJ0hB2UBGRXgceTTaXn3PbXhjFDS0hvyc+4wNU4Yw4wAptoQ2", + "P2Mxj5Cv+OheW7ISWG0pzSnxMiXfL3FvXtuQ05jQ3CyYMM4xsk8iKS846+OW9gkYZ9FfC2taL5yFzAbT", + "5WAhswKGpbCFWz+W+iP7/wzcRAfvmOIz11MQTQNIJCB04pFxM8MypXZhZWJvbDIiodEo74rbrFbaJjKy", + "ARgmV8Ln2mGYcRfBhgrqYyGZ/FsSJRy1TnqBNrwFooUaaCYE+NkbFYFudBrFbNb8d90Rae/BIb5g/b/3", + "9zrHmdulW0dleRJ406ae9XXg2JZN4gCseDDxivANroNwA1pOTFBPYST+94z4hsoTVzASa+mzka/apW5J", + "dCXmdTsYnOiOgQMVmtDcdJ3d6imsxTp2aMH6FGG1pAOc0XOcB3nz8owYplKPerEVwe7gKbHYNQOude6y", + "CD55evJ8e9gLosTVTFq4VWtjIeuDDiCk2HPQ6jpV6mhoyvrk+BnGuLtrpXyLYVDSD1KRxN6K5WV0hHA+", + "dXUPtflHj585ATRZlo5KVmwZ97Z9i1nzejsir323hBZDKaKVS9ryTZaXCTbr3FZtxNRK643gdrSPueef", + "u48xPgqTs1pejEi3rfdXd52jW3H42NSQXftCqlRs139V9v5TY8J/ehl9/3oyurNCT7IF1SHqXlStmlho", + "Zd+rhuw6u1ftnn61fieaB8/WX32Kqso1ZBjcc7XqIRDkB4Pd3Te7B9dX310XzruO1FfB+CwQvbtDcd8G", + "pHUAoJqbSWtICIHPLgDE60XenUB0JSCvwceGdmR3/2EXpQT22jWYovIRRGocUsGlPPJeEQRgARAveJJY", + "AUbzuaAJeUy2zo5f/HT88uU2GZBXr06aW7GuRnB/boDsjbcArqN1jgqAr9WAPEgR8fvmzUv4EiUMg6as", + "HH5xc7zvjarFDvjffnAvTt9CjQXVE+9u3R5hTMsoffaea6NXcRc7RS18DN64rVoqxrpM0rbhnCo3gpb/", + "WEPVDqJ4bt8C2rgPOVlZznsA4r7P0N7PDwR8LWz3x2JvOz3DLUFvt15pIdjqBo7Jg7bb7eYg2rcynBoM", + "VIhtVSUcj7twY9Tqfo8HYs6fOD8+cnxapqkrjRG++cacHu8Ndw8fYabl3VEXxp7SaE3fJ0+edu98tGdv", + "mSM6PYriI3yw39Rm5QjbPkFocgWRuWP/SBz37IVZed1Wjq0t0y3mYhUc/GZY4E0xrgWWG8VZ77ikJ+na", + "REkdgoqbUIdp7kBjU54kXLNIiljXZeQF1URnFivZJgwqJPixwAH2SZG3HaUUQqNI5aXq0UnXTt7PM0f3", + "mLQ4k0Izl7XkJ7bUJOVoBC26R9dHTYrYtXgstpSPcywCGjFfcQw/YNRQn7inUB+9hjExElQYC73IDTCx", + "bQhAEZDeWDmtLJlytBhtE53bJy2OF1djCQxT85ipsYBiATTmP4rnydEhICP0e8VLDpK7jEYharpV4+fQ", + "wa5jCxgCQ4VLp4fe7ioXJBcxU+S11MwYSpglh6aL3DUNpx+Jce6rdxOvXPVSrgofzE2Q6J2EqY/GeMah", + "trzP0Tv0Bo/zBzcX0TtFCnr51cUIulqT63gwuJAMePFN4bazCjkWOzWkZi7Wo4i9eWsTB9en7lyPjQSj", + "ulqSdycnNbcHF6HRbeLIJVr2QWbX2oa9DTqSjaO5jnm5goi9GQX745Gpm5JKRUL85DjUVQujhy6wFFpT", + "bNUezuv0a/CqDMZAcWH3CYhmzQQbuaMt0EvpGFltVS/1zKGyOlHax1Q4RPoCtKU06uul3pnmeieL+I79", + "rncQUecRIuocBCEPYnY5yfPQ0wg+uX7I27cAe4O/ICK0DZCpdU/p4e6j0aPHg0fT3cPBQTzaHdDd/cPB", + "3gM6mu1HD/d39/bXBBV1iIG9eVhr8MUc8GMuvNYn3ns+5NTcFrvQkE2cP/YVF7G8ql1/QQfZau/O+XZT", + "96uu9Z2HEAwJSqg2Vn3RwslO8JJnEbSN5XycdZEnLqzoPHwz2v1Y7Q8OruWOeKNyYc2qWKA0IaSVAVc3", + "qz7Om7F8HJAPfNm0WtXOuy/a6OjB46MHH7toPnhj0xib5HSHm9vmEeaR0xvRIT5IuKJH8grKnpOJrFbf", + "Fl/2+r1cVP9GYaDhS1187hTE1XZg+2E2su5aaYE8OK69V9BTxSJnxkcgqfj3COZ8KYA1QAR6CrowUtHF", + "WSBBtMMdV94u0AyaxZyKzgYu22AMjIzk2sXzcQGMGO2P0IjDRzgiL7AsfqKpfda5QdjE3VXTG42X1l8G", + "zpfv2j6y1g/5zL2vsA48tgj8C6cNy+BUtuubsNLZEflZYp3itSdkU/dri+Mza7V4oyzZciD7Hu8GO3Oi", + "5hH5oRAvCwHVCaRbmrk/J45hlTBT2zWwD7fj4EhY2bkKcEW/Z1e01+/5hYI/A1AXb0uqXzl/VVIMOZIx", + "muBZLsP0c8MTB66PM+Ha8Ei74BHY3Daxx8VmsnhiH09tPqk29NWWIUUlL1W9OyFbiJ/6F+IU2/Cv7cJ/", + "tXbX7T0+eHz4cO/xYSeUtHKAm0Xjp4hMsDq4jXJylOUTpxtpmzok0cM1j6xWofB9AWtXSeaZksB6YOa+", + "wWrnj4ePq+BwscyBDxdDckiSFosaNyyIf1jwohY/yN94cslnM/Hb79HF3t8VT3ffH+q96W4L6LXtKKx2", + "O646F6zoqNl0YFN7hvG7kKCUboW4e800zoCcMUOQfgaERvi8KeKpHcnlurbiQcI62N/ff/TwwV4nunKj", + "qxycCSrhApeyG0FZkmBJsvX67IzsVAjOtumRYLIAzEHjnBGXoH1UF0iHu6P9EJW0XNwl1bi2L9PWJX/n", + "no9uUm7RMXi7eFqunPLgau/vjx4ePHj0oNsxdurhiXq/nsO4crY/nz6juvNbKE2+eXJKoHU1oxHksn9i", + "9cGj1oyKuWbk5ydvLLSTkCRjalDeiL6lepir8zW71vzMteaHSWRs8ocNU6x5qjw8hOit3W6ojyH3FYdn", + "Wjv6dS4YOL4B8grsa2ApVpl4v+3eCQlmllRfsyihPH0S+WCNxj1mkzxMlC1WbkKXK8a95VeuwA51O6nJ", + "CuWXDfXBOkQqkositdBws3H3k9ho2/m/vWg23w+hAB8Bq+fgyWy6xhssZabYJZe5/gQNSWOjb2eJlOpa", + "dduePq+ZBgueB8V6d/KNJo7WiDYsq7/GHDWuAXG74eSudZ5rJBIm8rbF6rQbXbZ+3YT7Lae2vw6ao8YN", + "WqETY+BcudjsRvqUJlGOybRosZ8wK7woEFwgy5KljRJIEikFiRZUoLlFudR9Yk4oARSGYdCnFr5MZkH/", + "DHlFEmlB3yHZj8szZQcB1UAYAs3SVjWboyWlRvrnB6llMi6TUJ0aH6ThTLVhdKYiqB7WkxpZwSO3VWo6", + "1UTONT4vDcY/DJtpMDKqbFgDFTZv2mVqX6UB1+3AEBvMPHSj4kc4mPap7IQXDFm3K0kjJXUFWOzdiR52", + "jZ4r4qE3u4bWB9uBdK1pNHCV4RWnO6dXDN2Pgcigj7khkYYx+nCN06VXc6ZU5Jh5qkLITqU/7OxYCXrt", + "SQGYdc3BajPBdDKgCixsYEX8fqFZ8mWC96JnbTdZLufBfKPaK1QVbqptgO08Nbii4dXqFzQYIuNVhLq1", + "oHglVGATFus6YJVl/hGusVVewSAkWxg9U2FLFSzJ7S7uNuHHL/Sz8u51mYjB4tEVo3E9JOMpNYtjMZOr", + "nOA6Nliv03Z+rxlTHiYxZoKz2L9KC2OsU5px7fLQxTlzK4fd1oD00FmC4svJadsgWKjO65sddlE02zGs", + "zzaD/bqCHXaS63Bo7huV41ohAQHxlEG6ndxJuZ6EDWOrDSs2zxOqEDqw45D1Mk24uOjSul6mU5nwiECF", + "poV9JiGEbAKf9Hc4l+1Os4MKk7bUZGd2cC7C0G5Io99yCt/BLLcb8c2o09mx9Xegfic/tKDP+Q88YQ7l", + "8q3g7yuEXk/HcLA3aou7b2m0FnG/CvN6Xc7tSDZ44nMdiFJcK+X4pGosdjkysDQmh8Oj1uFW8iDM3ph4", + "M9tQPQTl40BOnlp+3YA4IVOGEUR+aivNdWGLXaYSTC0D2fb+Lqd11WpXB+JAwsItUYJtKDYLRgrgjq5V", + "bdsSK2tS2d3roFkgW4WJYqVrgkRsSu1Yemq18ZPXK1kOF8wtGfdztBkPO2Tw8Z4kBRCC67U7IkIzH2XA", + "8xnxbrRZYmZnTKe1rCRZhTRlSiECPUg4UvjZIICLVHatPYIWxHUviWIp5WIsuCjUrQjLxohgl0xV4m2l", + "gkfWHII9/lp54sHvLM3M0iWDQDX8N5qAMc6PcSyqg4TGQY0+JE+E1SyqPDO1dLEsdq8+IBSfJF8xozB/", + "KjcLMlNML6pzD+XMBRnvSqq4NRnZkvgiMA2K1lpi5AUTVVZWNBN8GtqGJrbWqj+gTXiNX937k9RyUJNm", + "jun1/eWaqbCQWEypKNLJCaZyVCqPEzyQMACXW9T9ZVl8gafSAT2lbP6/fZPlT6dF4/XfGsUqCCkeM/yJ", + "VdsGVbBRlq+uTsMmt9HpBQPq1uHirFolyJZ3xvYJmvR2S6KkTvdkt5i+ZtiBH82OZlG994NHDx4edsxU", + "9VFmP4sD9qmNfJfpGuNey06ddLEgPXrw6PHj/YMHj/euZWHxESot+9MWpVLdH4ARMXBYk3/945/vTurU", + "svcAvblH1xpUnrUP6W3WYUDvTv71j3/6Ud14QCFGswr33+IB0Orvk1R30rsc1I2B3Yxka973T2pKAlqw", + "GbLFENQb3Hfsug3KwTQARbpJwTSjETfLACOnVz7BhSvSQO3u0HpjsCGR17bt8FWBc+l8WpQAHxZX4D+t", + "lblBC486J7zT+bTNov2q2SuWI6XVouot0cFZwVJEWMFdzOeK6ppreMys3aFfxKqtxu3YEuvxe5tBFTAU", + "hOSttRWFshY05ElXqbr9je2s2C1rap3miv+65hy2H8FraX0DN3JA6RtledeGSrkdLsCb1ZpMq6ko1+b6", + "rOWtLG/d6/fbIQ55NelJcYNdv79K6OV1KjZozdKjG4Nb8rLtfo0kWqipElUTUKDJhA0qaRCwNNG5tQjC", + "mXeA9YFY0OhCzmZ11NwH7SjrCCCEYWO+F2oMvEz6oPV3OosmRLdFCxr3Huhxj0gFIZnpuNcwWwUDMVP6", + "fuI6qKPEjNbBnpeB9I1Baj+DaSKjC5tlEZP3D8mIpIwKTXKBh79hVdsdrbcO9XtZZW/8OuLjbmUp3WaS", + "KVvQS46ZWZxNZV5z6WTvudHoeortHJFYWtyoWoppN0MoZsMkj8pJ46VDxdI1DA1COSm8b2xZFhV8M0xs", + "LX5nSvYd7AFw7FevTvrWgQGdGO3Aap6SfqJ2BL1+r+yikaih/D3siQzGChx3E/g/XV3HanQ7WlYV08xo", + "hwRekkODCCB8SZhmRoC020OuHqC2eiXlAt0GnfsHLKjv3RIIiVmEJ1KvnsU6od+AuBsRCG6lQyEI+yES", + "xkOxJpPPa2cQbg7AKhsq2eFtO1UPcWslnGgjs179VE/Y+4ixuAkdGi7S1eve1Qx63b+kDm2oSNzuSqPn", + "9OrshrcXKoZjbVvtanSAkGIAp67YUns4LXKdR72pE1p19avgGJMQUGuoQIfxC/Z+/Vr/zN4bRFqP84TF", + "q2tbHEnLqtxltGnFbxwj2XagpWIb03PeQtpK67l+o8SVtiq7j9yVrtSt5Ktc2Z0zZnzZM0dGrTtUTxlT", + "M2m5JogvUvexsaTUJ+6CJ7vpdoMEDxZhrYiD9+0Y7Qn6FjC+z/j7NcRjC9iHcR0gpTxInhqIRSrdSul7", + "cvAQk4jpxtgFny9Msqw74BwEUJk+KqmrYoYJryjssvPlbvqKq95ubjurrYeE47MKyNBKchQnkk7WIXA/", + "LYp57XxGl6jFaTUSPtw/GI3290Y3guD2w7rGcj0tq7gUqPV22oLzKvUIq1rMLAeqtlCEa6/m1baJ78rV", + "JNooRtMjDOHJaMRIwmYIt1eExm62LDa7Xj94J1C5eNyC/v1GuX3zNvh68p2iKzGv/MuqPnCudTSj6vcN", + "BtEWNhOtgPMFovf2B6PDN7v7Rw8Oj3Z3bwM2u1iktriRh7/vXj1M9ujsIHm0fPjb7uLhfC/dD77DLriI", + "u9LqT1C21cumvCTrqEg1lka23BwyppoJ0+taI0BzTrhgA13EWm0OeFzDC6z9feP5v56e385grexwVp9k", + "VYSghuggZd0PkpebzFrbRXM2x8/Wz+JGsUzNgYTprTkUKNVxMJjrYrf3kRgPueh4Db2tFOx8Ea2Nr9t0", + "FYUs7HjSg7vcsuIh8m5APFRmve4CX73kArrTuVTcLNL1t0VRrAAkR7/p37WJ68hRQ3I8F1Kx+s+Fm1z1", + "EQWVe/1e8vtB/cy437tjiDks44IA3VZXpYIObmQJu2TJ+lXAIuXDQ1lPdqoYLsR3u4Pdx+iHkPx+8N1o", + "8LjucdC3q1Vdvl1fuvbrqMsaVpMJ+iRUu4+v5XHt13MdBf3EQ6nwynvZoRw7Gi9z0/urw4fu1ja4/Lyy", + "xw1MoFYB9GMlPXe5TapCUwwa2RDKfUVRqxuvxyqRkSmbc6G76G33R4Xi9gEobskTBzVuE8LLop9q80Ar", + "VTrhacpiTg2OSpk1EQx7HXVxzbfE9bKc+FoBaW0YFtcebwZb2BRwtemaHH5EZO9HvX67vXjX4YCgXs0/", + "URGNDAv2CZ+BDrrevk97bR8dGBiJ/mpHHvKtJFnHA3QpB3o9SZ/MpSFlMH5HfVsu2vWCxfghR2e+Fn3D", + "EsTeJ4FWKaDI+Dr2dfyMZErGeVTGjyY46BI7ROVi2FXI3zi0W9VvYIg3KDk26zfaFBrd9JNt+93QTQLB", + "tm/17mjzVt+KUqTfy7N4Mw+zhbpxsGthwG8IQQyoaOrL3pAEK5P5tQNHf11dwdU3r9UlRyAS5Zk3sABN", + "rVJSwNyCJoaQX+8zljDDQo0QmcRllATXJRfdzFJ3Dx8t2kycaJFaHchPjGWEGoukhP2lYM0LDcwnMC3u", + "kq2Rxw3X1uA1sImP3GrVB/dwoyTWulVVFW5bMgbL5Rs6b4u8clFRf/vZ1ESzVSwVz/BrQtrr9mQCrqZ3", + "e2vVH9+GWu4+hbRXzvTQAID18MQFzrrvv/QFBrGuTrwHIfN8iCze0Dlm3dtgR2kllVCGSjRyUGKoS5OF", + "qTrhnwTzkWoP/eIFBKzuI3pd2kLCDaFz2sxB0Zbg0lqiN/sQtaeMeUPna9F9m+GwVfX7k8HfrLqdTIZH", + "O9/95f8e/PqfQbV7Q4GgmRrEbIYeVxdsObD5nEBZMaxj22IyiZ42dO7ODKMpKtMQN95xpep4H4wK7rn8", + "maYrU0BXtUoypt2NE/rLf7Q7elWW8S1eGBvP7kfnWrmNnLRG+nt5K2Vq7p3qfUTd9nAsMEjvgi01qaR4", + "my5rJ/YbXVSpuOKTc0vuQyYuz8mUY85MPRbwvKdRxMCePXRZgziORUlkw4rRpNqOSzXnz4uzzFrHCgif", + "XgFGfvX2zfev3v78bPLq9PnPT44nPz3/n95RT7Crge0hHgDtHTw4dOneqyu5G0w5cv3MGUNy4uIVnM/D", + "LMeXPUKfgY0UQtCSJWHvoyTX4DaBS29McvMcGatRyzfPOfGRoMrGJCH3DAf+DYDeMGZ7rzrvIq49MXKN", + "efKdlocLsiq6WMIZ9/BKMdJLEsEMJbAV4dUuN7a+6IeLbneJhZsNHHYM/YXDFtCivuQagTu8E0ylMNnC", + "EBqfzNdHEG9fD/72SdFg0AXzE+dsGj3+FHlV365NpHopkwG881qSTwTV6nYtgiEE2JQNzei1WV/m08Bj", + "xum453xOAwaXkGHlk+Q/9QPaGDq2sv+tieDCAR3Pmpk57LG0S9XIJNHQlmgzaI/3SEG8b8EyRrBmG8TL", + "K06GteZ3UmF2XJ7iEHBILBEffl3YdnnKPODkACttjkZe+8CszKwykva9OZF5aFvWLRDE4wOPVKyyEViB", + "xTdcMheg1AGOBumtjk7mKqN4jnZ3TbYKFZhfgiLsetUusD6jxQl9X/QAJeA10TTE4jzKjFq7L77H7AOv", + "3S4B+3RN4DAar9ww1n6ditatiaeq1c2oUtXqvG354MFzvGoN92s7Ww3iLPuokWaIHv9KuflBKnwXt4O/", + "3DpkP17+MVMIq9cE5O+EZs9TFk9kbtaffygG0qO98otMs2WmYq8DoEjEUS2uuY0XeHiScgyrKw3LwaJc", + "cbMEpZF7mUwxHtSnB8aFxI7w57JjTMn64QNqz2eByJkXTDDFI0x4a6EGBb6YALavzHtoU2CuQOCiCPTq", + "6bHTu3gUZXxHc4Ok5x1Qn5wegzGeKat76I2G+8MRHuaMCZrx3lFvf7g7HPXwVbXAKe5MIWG/CyR3L+ri", + "BX8cO0noe18IaiqaMoM1fglAIqADpiuOTxA6rzwiM8qVe0VmiYwLguFQGzM4+Av1yN7KfbvsnZXHGG+N", + "YUAse+U291cUlPHs4DT3RiOHFW/c9YtBTDZyYufvzo227LeTVOeWKJDQYOWZ52XLYuk/9HsHo91rjWnd", + "UPDshjp+K6iLZmb4On8wGt1+p8fCxie6aHPnF1Y9cUhI1bP2y6+wZzpPU6qWfsGqq5VJ3SYYM9BrubL2", + "HWc0iYBVYNolALRh9juoRKl14Va5wGzVviJQaP0U2Lb9JhdoTd/LePnJlrDWh9dRfKizMzguH1bo+dPR", + "TkHGqxvpPnnQcku1d0BA39Mi1fq9nZSD0ePb7xR0vwmPIFrVE7BzzOYafZ8ShGD3IExSkd9yaSgp4hq+", + "oCPtZNZpQW798ira+YPHH+zxTljIHnDKVEqFjRKxZTYc+pXjbG0z5XFee6t5wj9+1nM3lUcjshcVCnL1", + "I1q9tprC4Op1dNA7auvTTi++R8I/uIMT7iZbZNu9zyOHOU7BrvwlHSdna5yWQkhQlnvBzOdC86O7vLJc", + "XoY/4Sn6Ugj4BSskvHK3Vi6FnUzlwj6AgxLg6zJy09X7pi78vSm/VNyF0K4BTWOGEGMNzDReDolfU/vo", + "B6WvthD96tK6m9XP1ykM73M5YXt3ccJwxoWl6Os19fWaWnfKLbX4KeDBrJzyDjqIa2kg/nz6h2trH77q", + "HrrrHjppHgS7sqUBD3JInGtuJGNG9ALynYKx2QI/eSccQ9Vw/juhKlrwS4bofpj3Lk8Mz6hCF5uUgJXA", + "2tBbFRNr1RJFczvQ3MA7ZJYL3AT00GyCLjCTNiDO0hWTCwHKWqq910yJq7iSod2e/aCCvWiwvBrJ1UJq", + "VgAbClO5zTHOW9vXMTY7HIs3DvEWFhC9yj2v0SxB3N41+h8pCB0LV+Fbz0K8R5ymacm5qELwRG4hOu22", + "rEwVRzrRkQyBDr1hggoz0BmL+IxHbloXbOkcW4MNdkplBQP244S8MN5Ra287DFyHrkthlOJnxTfiKKlu", + "vxHSuCTfpZHLYylRBbkPghlK5omc0mRi1+eCBWyCL7CEW5TS4FJak4SMmc3Kny3NQgr7dz7Nhcnt31Ml", + "rzRTYHMaC4xIcWsN3gqFgEiuMDdemkllrJ8D9rljh7jzxwVbfhiOxZM45cLW0LYKTbQEMwXUM9KDh1ju", + "1UIP9jSF7eBPc21kWoWA9XRnhylzk+XGhdZoZvoh+NOxMJL84UEuP+z8Ufb4AY3FjMZAJ5UidkooW7eN", + "Wk8ozH6CRQPmdoYLMO7BRWrdPOaKCoNjKlE6yby6pVtFmghMQttc4YgKksnMpthAolpQILlaGwhaQZOE", + "GDxKvi4I7riTLfNxGITptBWA0CLGNY4RF+Tk+8phGh082m6B8XcYo9E6dNj/Onv1M7HGJ5LSLAPTD3tP", + "I1NCxdokvVtCEmt4QkxYahbbxMixsHWtv5WPbYgLNNGdAinVTtxm25CevzpvkbGouNaQJ85BePfQj4Ez", + "/W0VtXUsIirgzHs0Cg998o12zpSWTIs5DCH74tPXOy9/gPWzHmLDsfiRJcguYIZFyLWNUMUR7I9IykUO", + "FyoeSZ1PHVo34geZBRsLRlXCLRqRn0Lf8SJYS4REdS5ekHqgTOzHMlhMRZOC1X+jiWV04Je0cMByOEdy", + "qWV00XfouppesnLcWHksfHDDjq3Wx4VWLJVQlrpilSysOxEVEUsSzyhee5s8Fc6xKi5FfDi+uIZVxBML", + "plsiAo2FYhGMdokwTLBWporUu1MYUz37akHkfVpF9HWFEYzYYt4nS5g7Xs0/cVND+ndnlYv5WFSOKwgE", + "A8ujUq4UXr4wOKmAUMkfH3DXC6dED2TV8BTs/TEuDtXQ/TruHf0xLuB1x72jce/JX8/Gvf64wOPFHzFT", + "XmQY8HeqlgNE9sUf2bj34UMLjm/FIfXwwYP9w1XsXPSoeIWOCM4go1mkmGk76SiMA+u1xUovTRvSJpAP", + "xLnCZXCizHNAR3MsYkE1Gfd4PO4VXhzxNpm5hcQdHQzQleA7GOp3tps+j78bDqEpu2pH5Jc/bCtHcIVm", + "qcVBHvc+9Enlw5ybRT4tvv0a5qNt8I1ntfufbFnpdhsFCMoRaasi6FvJuMqcADeUlIJHdYumXFC1XBdI", + "3c5k5cw6MFcW448xOiwjoTiXZaQgJi7xN+fXPO59CK+Ac1ZozwGKZ6XwaSjujsPRaHtzJgC3vgFXhQ72", + "wE+s+mlVhhQJjGEHHQz1n8ss+G+tdvq+UNTgtV9Cs1l9n7e53fdzHnq/g83/WRp4KSQsZehINqimYoS7", + "EVOIokSLuUZuZBCtaBCqmrGASbShBkCxwqsBNiue796YSZzkc9cn577OTWGuL1KofFH2edys8nyvNSfe", + "M8WN7uq2q5kR74d+vzh7XsCa52x57NKHXoQTSCE4mFPtEVsYFKZnOKbBGROGPMdfh+6/XheFYLfniZyf", + "H9n3CuRCIQkXLj6pEjgBcotbS6xk8cGKevafRfbOLSvi/Osf/8RBcTH/1z/+6ZJu/Osf/8TjvmNxL7ex", + "uQWjykwZNedHBKJwBzSBsBY3GUz0DU/LJdkfORskfoIhCRYVQR4yN3os4LFociUqcVw2kaZ2DTrTJcyH", + "i5xph68GBfnMZfmyvtYBPbI/y3Yp7/RE9wM4tTiDygTgVvQ0gCCfXHDDC5VDL2zCsXOuGXGabuMrzsOb", + "+Yth742l3oEd4DUZDC5x6NzhBzdpsnV29nx7SPAZaKkCM7nho6Zsxr1vhl950maeZDlKnaHgKlveFNGM", + "TnnCvQmkJQ2VPYIpjRaAF1fEOxRJIHwTR36kwGPA9ds5Zvex6Fi8OttBk49hkckV6ztOoBz0c5mnUrq4", + "O+wB+Rc36K06cGXHYsYotEGOn1kmUMmOUARqFw0LRFhC7Q03tZSY/bGwEN8OUh4OHkiyCVbC/ufUsCu6", + "7JOK5GvTViXUwEtdowpsLGzos1uDAWJIkcowh8jP7JAGPrLAxZAqNgNjDU7EZgG0fW9ZdRE+3/tlnLvv", + "zka/22ER6cRxmN8cn6jS2iewpVdnfje2+0RLEiUcqSGiYizm6JjoUdWlqO1qEeC6oCoeRBK1jRWUPYiI", + "SFg8b+OxTytt9W5Rkqn1EzhOPzbJ9UsTLharE4BDbJFD13sSPHNlurkSuBb/TL4EdoGu40xgFbTM8hu7", + "ul8dCzo4FoTXzTsZhCz9zzw07u1FINgu7ikAwdPe6prbL5Uluw9VI9nymGNopZWKnD49JjSOFdN6+99b", + "EQkztVRayn9wPwIrvg9XODcWqexeeH1LnUC+FHbw2o2aUD+vZuLz6v22U8uK1nrTFQnSyivv9m+PRqfX", + "uUZKobekta83yUbnf67RAFyllgGKRgkrxJfinFapaJNW2YYVFFfOWnHJlgKfLXcg706/7LrORfNuuAOm", + "+KzBEO+REdahHwgVBULEl0TNb4tddPNap37+vEhzdHdS0F2rokNk/iU9F+PGsgEXtMBLrRfoC2Ys3NJt", + "vtNdD4GJg57bnWo70KWddTEtW5VY3CicEGpi1r99j22Rbk9f296f6eWLy3MdicUt+VcRpcNjt1yrdQ/c", + "Y5eb//betzVkyTv2p3EEFlhk+OB00+jXB+luqV6KaPurS80np2hc7MojVvl5s7jQZOP38p11V3LdE+E1", + "6uB7yXXxruWCzBJArbZGgJjP0InQVN04cZR7dzDK195NWVHDnMv0l4hDcJon1roRSXHJVAU5tnql7vyB", + "TvSbn0qeea29Xd++fjlgIpJxYTxpl0ndl0/8YLL0X8MWuPtT9wXG13MvHrQJjB+x/za4hRRQwv9r7wcH", + "Jvy/9n6gScYF+1/7TxJqmDbbt0Yso7u66e76AfMFEx+8X3h90VZY046h82pcfJ0yPZz2dSizBoPtld1F", + "YN8no75PL+Q1scM7SXh3RvfwkrprBKVjnybFbqlUHk2vAZH+7y30ndUI+s71dbXuucYRoGD3BcI2SeVR", + "oKmL/OKeuB1vEnPFtN6kjChKddRH+PJ/KpWEnfS1lBLFun7VS3TRS1SXa61qwha8XeWE7eOerO8FsYVW", + "Gz99hf+7A4OOo8gK/F/Nwl0CAC6kNvjp88CC+XeKxOHFUajeZx1NpiWnWHuv+TN1/KyPO4zxzcfPSgyI", + "OzKg+nHcuUbA9Xv30tiTdMrnucx1FV4ipSZaMO2gVxJWvxm+NF1FKTe0ais+Yyod3eWddufKiK90f0tq", + "kuaGWuZtvSA2PUZ8qa6PEVceHiMWlt7B07gkcn2fYHS7JTrFA9N3JeMafv+HfpdxhR5JkJRHk/IdQ/Bp", + "czQW/xseRr8YRtNfv/MB8flotHeIvzNx+et3PiZenHhSYcIo7vJBP/n5GbqezDG6AFNGl6g7zXGQNNfG", + "kp5HfPi3e7mV3jfdn26eCr8+3To93SrLtf7pZgve8tutnl/uzh9vnt5CC26//Umfb39ym3Ltaanz2YxH", + "nAnM0odaSb3iRG2fmF/NyTfTj1LhnDgqHpg1SaTzM7LgWhsk9CL1+yd1cey3JuuRhBrD0swA2lvEIGm4", + "DR3Ui9zE8kr43D04QZ8GkpfzCV3vvqmJbyQcuVvLMbQucDf40i3y1971U9d1/IWGzkobLB/7x2Up2rS/", + "Lu+XeG/3Tdnhqr37V+WXTGL2+ba6dBm8EAK5KK39Kc1tnHFRs4SxHZI3b176mGJ4niif2dRIn87Up7wf", + "i2o60yF5XuaJtQV8C/B8YLHDIID6PkFozGiccMEwCIPpUPhvPQnxvR6LTy8BhzMs37XtvcuxtBt6jxLw", + "vbGCO5E1C2cD4yzFxdGsJF8uTouXN/HUfFH8yjGgAOMJyXo7NDdy4FAKdhbSQumG0cRPExohmDgUszi3", + "DhjGAltXm0K0FyWThCkLlprlxotbACXuBseFkUWGfieZnUPzk1wYnpxb3FKL0KUJFUuH5jcWtc6czIfg", + "DQhMgiNULLMjbqQbh0FzUDVCKcRZqHZJaHJFl3osHNyDrY4AsIpFFuo7SYbkR4lIOzbtfoXx2pzX3+ix", + "OOdxwiYOKOeccE30QirDBIsJALHqer8WOlbhJJ5SWDlNUrpEKE0LJm7XR2bMwlXW4Hgk/JuKmGP2ZOi5", + "mPLRWFCyNxqRlFGhHbiGpjO8cFwbBAdRG9C3hJKD0WNXq7FvmOXBL/8WnCal2KWM6BQSZQMVwxC52cYN", + "TF02c8W0kQq2b8aVtvtV6DddmtraxnLtk3PHfZKLEj4Edf0V6xpsl8mVwHk68yTjqrgGHWLSlEUU1lPI", + "ej+InS2jKFehCxK2upJW/99RcKxM7wyXKgzOkaDKIIIYAInIjws80xKP0va3LVRVEtWf46IJHhKpCCUV", + "ui41GizKkTVuIejseZkjWkxc+fPtb/3ZgePrGIE//mL+Jd1PSERyNqsdwM1Xkz3A64LiVkn4z3pOnzqm", + "V2NxMadzIbXhkWeGHsq/+mj++iDs9CBcv7JBap5JddHuCf2DVBddX2DeY/PLeohVZ/gZGiJgeOikc//2", + "CNSG28cKEM2dP9Ka9FWcUhS6uNGFrzJJpJgzVdXK37nZoPqq2yozLShr7C5w0eARMnE/ItjkdsXfHE0M", + "kWv1T+ushsQGm136rE2X9ulRIsldj1fCqaoCPrjEGdb/oO/FIaQrv2FbLhFEc7uCTBWARjcitRade1jS", + "AFTrWLzVNqfLuTU9nZOCB4NAa/M0kasFjxbQDv6G7VtUV5pl5wWU/vYReYEHubJttvMtm50JaE3LhFk0", + "1ss0PT9azbD/7uQEK2GZhc1ocn7kc5uQ4v7QUKoKwwqzSKg25GcHLrtVPMZxR89Bh1mZ37YDaC1THYxF", + "CKwVsE5tg3xGziu4rectoIKe376Uc/3ZmIrKvFR2LkYS93RE2mQi7rU5efAkbPjZHY1CeRM6wsfaYdwy", + "euzKYF7KeZETq0bKNMu6kq8bJlLxZZquoWGyVXIQok0sc/MXbWKmFFZ21N1G3GSLRvYfhl4AoTrkUX+w", + "t8eiZansDMNLBUy11+8xkae9o1/cvy7TtNfvufFAvSuTpZVsF9cQ8jfA8TYb/NAP7VAFc/dPLJ7f25Xo", + "8qcVRyWWzHpHosTjXlAA5YrnBbf0JtC/9Ruqgv3buO6cDqD9GfHaFvjTmzi9ovHOxHf3ommIT0H6uLdT", + "7LOUVXXhn5MkXxlvXW8mZIGqjCN7fBcjQ+hlEiVSs5qd7MsBbnT6wobo3a5v82s8gOHFuc+82cUR6MxV", + "PfM1PwMVxiaXGz9m4qd75743qyP4kkEo9MpsgP010P42OeV89oT06bZkZapdKOQrbV5fWduJMOG5tcoi", + "XIXYZmIu0l1iOsBoIaWukH0BzW/z9TodfEGZqKGyygIXiHEOpHrutPnnTsQ8cppHQqufXB9DrO7CN8I1", + "/Keyxg8V5UrB8fv+BYWZaTSkTFOczUhGc81AzsxBI7aMEubzPzKwq0c0M7limNGakZQLnuZpNecC7Ngl", + "RXyo8930vE+muSEJaNlU8dH7LEUyTZmIrZw0FgtGLzlTsCgJNUxEy4FmQnN0jYK0D4mkMWpqshiTetpM", + "2ooBBWICC5/0FAWdczjxExsLdk4yxZCIrHZEsPclNYDtOBff2mw60Oy5H+g5YZgugutFkUQ9ojETUTCN", + "wtnnzcY+vUr/jJnmRO/JwepGvPQ+Pa6qqms/nM/DGeuLhfzowObXCL26/VFdD6LxZPTveaTtXP0c78lO", + "VyzxulP8eRjoCqL7bIx092+Fk4rEue2uciqRzP+sesSCodQQISBA127jTe1rRXbWYpmvxfN2/vB/Ht9A", + "u/iZcMJ+68O+LQ9gOenPgeW6Vb0Rz70ntarTJVV1cvfHgt2g7k98kqrC5b4UZWsNea/g21XuZBTF15cU", + "X9l2k207v5Gbsm2vm13xjKgwci4G6Gob5uBOjdvKqp3q4N80qKcxuwrLvHcWWVou7hxG07PGjC5BVfJn", + "8LVeYz+KpFIWRYQa9mVBf1e0htUoC9TNlQlG+z7o9d3JyXYbl1BmLY9Q5gvmEJXIJqiWxqsK3FeXTCke", + "e3jTpyfPSpusysWQvEq5IUaSC8ayMjAIgzMBtbPAU2kMuwmc0u8xYdQyk1yYjaMoi97OYMofpIOV+QxF", + "SZdL4qs5vLM5HDX7Xx47Qy5DaDGB9S9TQ83GHNdczKRKrVxGpzKH1oEHwTLBflpnixlPmF5qw1Lr3AlQ", + "EHDcMC+Ryz3v6tld7qNrM5wcG3WYMZVyrbkUeixcyE3GFPQN1aH9ip9a0CBgaMFfTy2T/Dx8IGEw1u2P", + "mrZVQ+QrzGndO+rt0CzbiamhLX52bngfMaQf0KmR6GU6hQBK8Iq80GQr4Rf2eUIuNUngj+21XpETrPep", + "M+vf/GTBSh+LmQzmLbU0WxDznyo4zrE1b5j8LNjaPb0zP9qL8AWrHlzPC2eylcXqjTxWMZoMMC+/x2Ii", + "ueEJ/92yXWiEa8MjG0VGi318d1Iw+OFYnDCjeGTtvRH4nyNIBb50dzIlox3A8duPMo6AfvsMB4fMt/1z", + "ij0+PX2L5VKWSrXsjwUVruE3T06tpXlGI9YcqGAGLMnkeOfVBp/1M1ymf2P/STvBtYAUwQ3/ap68PmxM", + "6xnSLUdUZuuebTL70zv4Omnyq47jy9RxAA2Xs9kqsNo8wFpYn3EpkzyFf9g/jjdB1RkaLd5h0c9G8rbD", + "2diNn+AXcSjdnGJmczzfiwHGLtiX6j8LC+engEJMzTMxeAs8MX9G6v70poTqOn6Gple3oj5/+mdztu76", + "5nNj8KAp1fX4Uo65pTQ/EyPXa8KuKG/XhH2fyOhCO3SdqgqTKEYRMh9+LCHOnbkSxQQM9iUOlcpinzHd", + "H4uGMtSCOGlCiWEq5YImOzhn2wiCtXuNGr2UHGPuI4yZGWhQdWcySRCRHRENYTZQYuYbqFiXtcswWS1T", + "NYwaCbBNMmUewH479HT7K+XmB6nqaPSfC198U1l/RHmkHHX/GwD423v8KED+E/oe3bbj3Bm3/Yi2Xsjy", + "R6uW6hPcm3Fvf6THvT4Z9/bScQ924ClFdS415AFJucgNIFs+s7o2jKo+HBHNIili7XH0vTZxf6RbZu7I", + "siVg9xDr3aXY46gKl/K16yTEHqAcgfoYQES2qgfOncm4j4cuJjI31vTgzpUrFTOD6pHtO7cbV87I17d9", + "F07+V3d8azwKdxnYZWXrLWfPcr1g7Sq3lzZpVm6msA5Fkm29IH+XU92HqAOrmQfEvBW+B7VPbQd3kTsC", + "urpO3gg3969JIzokjSjXKoy/aZ094Ur21GFBONn7TCoDvzvcAkdD+JJAMBBMhfnq6fFYRMCKLFqkYqlE", + "7uQg7u0t/OSvZ+T509d98gwTPpMf8+n2kLyCSBtsVTt70VhYScwyr4gCsLqdQRy6nu3YkXpu03EdOriW", + "FL/36Sw9eDICVh6/V95hvd9bMBqjRPJH76W0nQWApF+/hAME++dqFtveWyt8gA5fLQdPZoap1WZPXMyW", + "KGBQ3CXtUQWd4IYdY4fag+mVfVrZwKKd7O/1AuAnH77m8bj9ROF3Y7HDfl1qR4jm+1JzBONBLJhjiAVW", + "r+siE0ZbxLLjZWsfGNjl8bNP8qi4VSv1Ot5VSxfw73q6cKZfrKEpq+0TEHGRQWejpdcHKi8swrWtRiKa", + "0YibZZ/QJHF3lLsJCu+YQSH+ThWjF6C3HwIKmevZBxeDrbbvDbUk5vrCtuBssUMC7nE6nxaDI3jQrNUY", + "1xxCdI0kEU2iPKGGETabsQjjgjElj26x5RZD6d3i2Sk7CcLCVDzs8y8ubWGYJnD3SrJoUtyO3eodxaKE", + "8rQdT94Jauj8iK4GU2hUCvBdSCzF0UhJrYlrasASPueQVgM9JSCTBqi5aMrGIkuoEEyRXFsPfRj6IFNM", + "61wx3wDcXY6i+qTEisyUNM41IZFS6bHwFP7uhGjDsjVk9tq2fIJzviXZ1jbueronJXVjDO2qEFeEwIZY", + "SrELDnQEqqF7cIu3A7pvKfFLOfhvFJ+D72umJLVM1vol2WPtl9Me+lr0dGsK07OiVLcUpkWrlQjJSvTg", + "Wqy/SQmfHveu54EY6PyCt8JBuk/Xi2j+CSp17LseORsehPv0kbMMZWP9d0x8elYJWOyqwCop/EtTJ1VG", + "XjuqtaDfzRBfnaN8bzPqtjOW171BeH3JyF20Fsrb9uD9/AhhdLeIE3edN+/Lpq0a8lbtbdoCP7A5QcJn", + "QYG3kxnhnhFXbpAZ4bPCAADauUcsluBBva+Y/prtWaqvyQ1uNZTfZjhAaLi2UH7L9Zzz6tqH0jtXptsz", + "ybX4Z5Lg7QJdR373y/711d/hyVBZrE0maCB4lmZm6Sp5W2XpdKb572zYYggu/FZvzxR8A5fOT0cenk5b", + "HTrvEb3sHg059+Iz6rJBcg1ufmXWPR/Y/YXhHVbPXO1i2YFbZ0BVtOCXrF3pXj/BbokyxQaZzNC4EtsF", + "c+vh7zJD1XD+O3HNO/xX9y9MJ4qJDFhMYq5YZMBbRBiJHMH28Y0mSkrjvku1bPcSsUfkByXTJ242G+5D", + "d6acMqz0M0yXg5gaOrj03GaNCu0jvDu9PyUwPMIFefE92WLvjbJJS8gMXj4Qbe6XlL2PGIs10uR2dcC7", + "o/AQoeHJfNpllGvSz7zCP2hColwbmfq9P35GtjCd3ZwJ2AsQ9WcoyWZKXvKYxbUxgvO+XdXdlgW9rt4V", + "hIoiF6F/XNjB3YsM0+VCmv/OszpbKFxiplxQHNzGBC/1M2UBBaA/yoV3wHF75Efx9QpzL78t/9gBSsTU", + "qm4RjZQWbnr76zX3JV9z1WAof6fVbjvvnrNeed0tPqpj2NJtJKEoYufuVm397vMJ6eH6i4zmcarzy+JB", + "2qY2/7xIcHR398Ndq8vffcEhoKAsv2wsm21AXYYJ5iX6dMfskiUySzHFPZbt9Xu5SnpHvYUx2dHODvp+", + "L6Q2RwePH+73Pvz64f8fANOMOMlJAgIA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/openapi.yaml b/openapi.yaml index 73aa90cde..e8c8bf0d7 100644 --- a/openapi.yaml +++ b/openapi.yaml @@ -4683,6 +4683,25 @@ paths: dockerfile: type: string description: Dockerfile content. Required if not included in the source tarball. + registry_credentials: + type: string + format: password + maxLength: 65536 + writeOnly: true + description: | + JSON object mapping exact registry hosts (no scheme or path) to + objects with required username/password strings and optional RFC3339 + expires_at. At most 16 registries; credentials + cannot override Hypeman's local output registry. No CR/LF in values. + Held in host memory for at most 30 minutes from submission, or the + earliest expires_at, including queue time. Passed to the ephemeral + builder's Docker auth config over vsock, never saved in host build + metadata/config, and removed at build completion/cancellation. + Requires an updated builder image. No automatic refresh or restart + recovery: resubmit interrupted/expired builds with fresh credentials. + Credentialed builds pull directly in BuildKit rather than populating + the shared base-image mirror. Omit or use {} for existing behavior. + example: '{"registry.example":{"username":"AWS","password":""}}' base_image_digest: type: string description: Optional pinned base image digest From f9e7b1f2bec2e7430948027fa1131d52db4168b7 Mon Sep 17 00:00:00 2001 From: sjmiller609 <7516283+sjmiller609@users.noreply.github.com> Date: Mon, 16 Nov 2026 19:30:50 +0000 Subject: [PATCH 2/3] Include registry auth in the builder integration context --- integration/builder_cache_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/integration/builder_cache_test.go b/integration/builder_cache_test.go index d01b49696..62ee77215 100644 --- a/integration/builder_cache_test.go +++ b/integration/builder_cache_test.go @@ -171,7 +171,7 @@ func builderIntegrationDockerContext(t *testing.T, repoRoot string) string { for _, path := range []string{"go.mod", "go.sum", "lib/guest/guest.pb.go", "lib/guest/guest_grpc.pb.go"} { copyBuilderIntegrationFile(t, repoRoot, contextDir, path) } - for _, dir := range []string{"lib/builds/builder_agent", "lib/system/guest_agent"} { + for _, dir := range []string{"lib/builds/builder_agent", "lib/builds/registryauth", "lib/system/guest_agent"} { err := filepath.WalkDir(filepath.Join(repoRoot, dir), func(path string, entry os.DirEntry, err error) error { if err != nil { return err From 93d1461ee4cad6e575de955fabe04dd6f23bd30e Mon Sep 17 00:00:00 2001 From: sjmiller609 <7516283+sjmiller609@users.noreply.github.com> Date: Mon, 16 Nov 2026 19:43:27 +0000 Subject: [PATCH 3/3] Preserve build failure diagnostics and redact JSON variants --- lib/builds/builder_agent/main.go | 4 +- .../builder_agent/registry_auth_test.go | 55 ++++++++++++++++++- lib/builds/manager.go | 3 +- lib/builds/registry_credentials_test.go | 24 ++++++-- lib/builds/registryauth/credentials.go | 7 ++- lib/builds/registryauth/credentials_test.go | 5 +- 6 files changed, 84 insertions(+), 14 deletions(-) diff --git a/lib/builds/builder_agent/main.go b/lib/builds/builder_agent/main.go index bf4e9c081..31630b901 100644 --- a/lib/builds/builder_agent/main.go +++ b/lib/builds/builder_agent/main.go @@ -112,7 +112,6 @@ var ( secretsOnce sync.Once buildRegistryCredentials map[string]registryauth.Credential - buildCredentialsError error // Encoder lock protects concurrent access to json.Encoder // (the goroutine sending build_result and the main loop handling get_status) @@ -317,7 +316,6 @@ func handleHostConnection(conn net.Conn) { } secretsOnce.Do(func() { buildRegistryCredentials = credentials - buildCredentialsError = err close(secretsReady) }) @@ -546,7 +544,7 @@ func runBuildProcess() { var credentials map[string]registryauth.Credential if config.RegistryCredentialsRequired { - if buildCredentialsError != nil || len(buildRegistryCredentials) == 0 { + if len(buildRegistryCredentials) == 0 { setResult(BuildResult{Error: "registry credentials unavailable", Logs: logWriter.String()}) return } diff --git a/lib/builds/builder_agent/registry_auth_test.go b/lib/builds/builder_agent/registry_auth_test.go index ffa773fbe..0b9a04edb 100644 --- a/lib/builds/builder_agent/registry_auth_test.go +++ b/lib/builds/builder_agent/registry_auth_test.go @@ -7,6 +7,7 @@ import ( "net" "os" "path/filepath" + "strconv" "strings" "testing" @@ -60,6 +61,54 @@ func TestRegistryCredentialHandoffAndConfig(t *testing.T) { require.NoFileExists(t, filepath.Join(directory, "config.json")) } +func TestRegistryCredentialsSurviveSecretsHandshakeError(t *testing.T) { + buildConfigLock.Lock() + previous := buildConfig + buildConfig = &BuildConfig{RegistryCredentialsRequired: true, RegistryURL: "local.example:4973", Secrets: []SecretRef{{ID: "missing"}}} + buildConfigLock.Unlock() + defer func() { + buildConfigLock.Lock() + buildConfig = previous + buildConfigLock.Unlock() + }() + host, guest := net.Pipe() + defer host.Close() + defer guest.Close() + done := make(chan error, 1) + go func() { + defer host.Close() + decoder, encoder := json.NewDecoder(host), json.NewEncoder(host) + var request VsockMessage + if err := decoder.Decode(&request); err != nil { + done <- err + return + } + if request.Type != "get_registry_credentials" { + done <- registryauth.ErrInvalid + return + } + if err := encoder.Encode(VsockMessage{Type: "registry_credentials", RegistryCredentials: map[string]registryauth.Credential{ + "registry.example": {Username: "AWS", Password: "synthetic-token"}, + }}); err != nil { + done <- err + return + } + if err := decoder.Decode(&request); err != nil { + done <- err + return + } + if request.Type != "get_secrets" { + done <- registryauth.ErrInvalid + return + } + done <- nil + }() + credentials, err := handleSecretsRequest(json.NewEncoder(guest), json.NewDecoder(guest)) + require.ErrorContains(t, err, "receive secrets_response") + require.Equal(t, "synthetic-token", credentials["registry.example"].Password) + require.NoError(t, <-done) +} + func TestRegistryCredentialLogRedactionAcrossWrites(t *testing.T) { oldStdout := os.Stdout read, write, err := os.Pipe() @@ -69,12 +118,12 @@ func TestRegistryCredentialLogRedactionAcrossWrites(t *testing.T) { oldChan := logChan logChan = make(chan string, 100) defer func() { logChan = oldChan }() - credential := registryauth.Credential{Username: "AWS", Password: `synthetic-"secret"/+=`} + credential := registryauth.Credential{Username: "AWS", Password: `synthetic-"secret"/+=<&>`} writer := newStreamingLogWriter() writer.setRedactor(registryauth.Redactor(map[string]registryauth.Credential{"registry.example": credential})) quoted, err := json.Marshal(credential.Password) require.NoError(t, err) - input := "pull " + credential.Password + "\nconfig " + credential.Auth() + "\nquoted " + string(quoted) + input := "pull " + credential.Password + "\nconfig " + credential.Auth() + "\nquoted " + string(quoted) + "\nplain-quoted " + strconv.Quote(credential.Password) for _, b := range []byte(input) { _, err = writer.Write([]byte{b}) require.NoError(t, err) @@ -91,6 +140,6 @@ func TestRegistryCredentialLogRedactionAcrossWrites(t *testing.T) { require.NotContains(t, output, credential.Password) require.NotContains(t, output, credential.Auth()) require.NotContains(t, output, string(quoted)) - require.Equal(t, 3, strings.Count(output, "[REDACTED]")) + require.Equal(t, 4, strings.Count(output, "[REDACTED]")) } } diff --git a/lib/builds/manager.go b/lib/builds/manager.go index f7b3fb6a2..924f1578a 100644 --- a/lib/builds/manager.go +++ b/lib/builds/manager.go @@ -1145,7 +1145,8 @@ func (m *manager) waitForResult(ctx context.Context, buildID string, inst *insta } } - if requiresRegistryCredentials && !credentialsDelivered && dr.response.Type != "get_registry_credentials" { + failedResult := dr.response.Type == "build_result" && dr.response.Result != nil && !dr.response.Result.Success + if requiresRegistryCredentials && !credentialsDelivered && dr.response.Type != "get_registry_credentials" && dr.response.Type != "log" && !failedResult { return nil, fmt.Errorf("builder does not support borrowed registry credentials; update the builder image") } dr.response.Log = redact(dr.response.Log) diff --git a/lib/builds/registry_credentials_test.go b/lib/builds/registry_credentials_test.go index 645ecf806..e54ee119c 100644 --- a/lib/builds/registry_credentials_test.go +++ b/lib/builds/registry_credentials_test.go @@ -105,8 +105,9 @@ func (d credentialTestDialer) DialVsock(context.Context, int) (net.Conn, error) func (d credentialTestDialer) Key() string { return "registry-auth-test" } func TestRegistryCredentialsVsock(t *testing.T) { - for _, supported := range []bool{true, false} { - t.Run(map[bool]string{true: "handoff", false: "old-builder"}[supported], func(t *testing.T) { + for _, scenario := range []string{"handoff", "old-builder", "startup-failure"} { + t.Run(scenario, func(t *testing.T) { + supported := scenario == "handoff" mgr, instanceMgr, _, dir := setupTestManager(t) defer os.RemoveAll(dir) credentials := map[string]registryauth.Credential{"registry.example": {Username: "AWS", Password: `synthetic-"secret"`}} @@ -142,16 +143,31 @@ func TestRegistryCredentialsVsock(t *testing.T) { return } } - done <- encoder.Encode(VsockMessage{Type: "build_result", Result: &BuildResult{Success: true, Logs: credentials["registry.example"].Password}}) + if !supported { + if err := encoder.Encode(VsockMessage{Type: "log", Log: credentials["registry.example"].Auth()}); err != nil { + done <- err + return + } + } + result := &BuildResult{Success: true, Logs: credentials["registry.example"].Password} + if scenario == "startup-failure" { + result.Success = false + result.Error = "load config: missing build.json" + } + done <- encoder.Encode(VsockMessage{Type: "build_result", Result: result}) }() result, err := mgr.waitForResult(context.Background(), "build", &instances.Instance{StoredMetadata: instances.StoredMetadata{Id: "vm"}}, true) require.NoError(t, <-done) - if !supported { + if scenario == "old-builder" { require.ErrorContains(t, err, "update the builder image") return } require.NoError(t, err) require.Equal(t, "[REDACTED]", result.Logs) + if scenario == "startup-failure" { + require.False(t, result.Success) + require.Equal(t, "load config: missing build.json", result.Error) + } data, err := os.ReadFile(mgr.paths.BuildLog("build")) require.NoError(t, err) require.False(t, strings.Contains(string(data), credentials["registry.example"].Auth())) diff --git a/lib/builds/registryauth/credentials.go b/lib/builds/registryauth/credentials.go index 93f51d835..576207ac7 100644 --- a/lib/builds/registryauth/credentials.go +++ b/lib/builds/registryauth/credentials.go @@ -82,7 +82,12 @@ func Redactor(credentials map[string]Credential) func(string) string { values := make(map[string]bool) for _, c := range credentials { quoted, _ := json.Marshal(c.Password) - for _, value := range []string{c.Password, c.Auth(), base64.StdEncoding.EncodeToString([]byte(c.Password)), string(quoted[1 : len(quoted)-1]), url.QueryEscape(c.Password), url.PathEscape(c.Password)} { + var plain strings.Builder + encoder := json.NewEncoder(&plain) + encoder.SetEscapeHTML(false) + _ = encoder.Encode(c.Password) + plainQuoted := strings.TrimSuffix(plain.String(), "\n") + for _, value := range []string{c.Password, c.Auth(), base64.StdEncoding.EncodeToString([]byte(c.Password)), string(quoted[1 : len(quoted)-1]), plainQuoted[1 : len(plainQuoted)-1], url.QueryEscape(c.Password), url.PathEscape(c.Password)} { if value != "" { values[value] = true } diff --git a/lib/builds/registryauth/credentials_test.go b/lib/builds/registryauth/credentials_test.go index 064aaba0a..04b951c07 100644 --- a/lib/builds/registryauth/credentials_test.go +++ b/lib/builds/registryauth/credentials_test.go @@ -3,6 +3,7 @@ package registryauth import ( "encoding/base64" "encoding/json" + "strconv" "strings" "testing" "time" @@ -12,7 +13,7 @@ import ( func TestNormalizeAndRedact(t *testing.T) { expires := time.Now().Add(time.Hour) - password := `synthetic-"secret"/+=` + password := `synthetic-"secret"/+=<&>` input := map[string]Credential{"REGISTRY.EXAMPLE": {Username: "AWS", Password: password, ExpiresAt: &expires}} got, err := Normalize(input, "http://local.example:4973", time.Now()) require.NoError(t, err) @@ -23,7 +24,7 @@ func TestNormalizeAndRedact(t *testing.T) { redact := Redactor(got) quoted, err := json.Marshal(password) require.NoError(t, err) - for _, value := range []string{password, string(quoted), base64.StdEncoding.EncodeToString([]byte("AWS:" + password))} { + for _, value := range []string{password, string(quoted), strconv.Quote(password), base64.StdEncoding.EncodeToString([]byte("AWS:" + password))} { require.NotContains(t, redact("before "+value+" after"), value) require.Contains(t, redact(value), "[REDACTED]") }