Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 defaults.go // Package defaults is a collection of helpers to retrieve the SDK's default // configuration and handlers. // // Generally this package shouldn't be used directly, but session.Session // instead. This package is useful when you need to reset the defaults // of a session or service client to the SDK defaults before setting // additional parameters. package defaults import ( "fmt" "io/ioutil" "net" "net/http" "net/url" "os" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/corehandlers" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds" "github.com/aws/aws-sdk-go/aws/credentials/endpointcreds" "github.com/aws/aws-sdk-go/aws/ec2metadata" "github.com/aws/aws-sdk-go/aws/endpoints" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/internal/shareddefaults" ) // A Defaults provides a collection of default values for SDK clients. type Defaults struct { Config aws.Config Handlers request.Handlers } // Get returns the SDK's default values with Config and handlers pre-configured. func Get() Defaults { cfg := Config() handlers := Handlers() cfg.Credentials = CredChain(cfg, handlers) return Defaults{ Config: cfg, Handlers: handlers, } } // Config returns the default configuration without credentials. // To retrieve a config with credentials also included use // `defaults.Get().Config` instead. // // Generally you shouldn't need to use this method directly, but // is available if you need to reset the configuration of an // existing service client or session. func Config() aws.Config { return aws.NewConfig(). WithCredentials(credentials.AnonymousCredentials). WithRegion(os.Getenv("AWS_REGION")). WithHTTPClient(http.DefaultClient). WithMaxRetries(aws.UseServiceDefaultRetries). WithLogger(aws.NewDefaultLogger()). WithLogLevel(aws.LogOff). WithEndpointResolver(endpoints.DefaultResolver()) } // Handlers returns the default request handlers. // // Generally you shouldn't need to use this method directly, but // is available if you need to reset the request handlers of an // existing service client or session. func Handlers() request.Handlers { var handlers request.Handlers handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler) handlers.Validate.AfterEachFn = request.HandlerListStopOnError handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler) handlers.Build.PushBackNamed(corehandlers.AddAwsInternal) handlers.Build.PushBackNamed(corehandlers.AddHostExecEnvUserAgentHander) handlers.Build.AfterEachFn = request.HandlerListStopOnError handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler) handlers.Send.PushBackNamed(corehandlers.ValidateReqSigHandler) handlers.Send.PushBackNamed(corehandlers.SendHandler) handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler) handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler) return handlers } // CredChain returns the default credential chain. // // Generally you shouldn't need to use this method directly, but // is available if you need to reset the credentials of an // existing service client or session's Config. func CredChain(cfg aws.Config, handlers request.Handlers) credentials.Credentials { return credentials.NewCredentials(&credentials.ChainProvider{ VerboseErrors: aws.BoolValue(cfg.CredentialsChainVerboseErrors), Providers: CredProviders(cfg, handlers), }) } // CredProviders returns the slice of providers used in // the default credential chain. // // For applications that need to use some other provider (for example use // different environment variables for legacy reasons) but still fall back // on the default chain of providers. This allows that default chaint to be // automatically updated func CredProviders(cfg aws.Config, handlers request.Handlers) []credentials.Provider { return []credentials.Provider{ &credentials.EnvProvider{}, &credentials.SharedCredentialsProvider{Filename: "", Profile: ""}, RemoteCredProvider(cfg, handlers), } } const ( httpProviderAuthorizationEnvVar = "AWS_CONTAINER_AUTHORIZATION_TOKEN" httpProviderAuthFileEnvVar = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE" httpProviderEnvVar = "AWS_CONTAINER_CREDENTIALS_FULL_URI" ) // direct representation of the IPv4 address for the ECS container // "169.254.170.2" var ecsContainerIPv4 net.IP = []byte{ 169, 254, 170, 2, } // direct representation of the IPv4 address for the EKS container // "169.254.170.23" var eksContainerIPv4 net.IP = []byte{ 169, 254, 170, 23, } // direct representation of the IPv6 address for the EKS container // "fd00:ec2::23" var eksContainerIPv6 net.IP = []byte{ 0xFD, 0, 0xE, 0xC2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x23, } // RemoteCredProvider returns a credentials provider for the default remote // endpoints such as EC2 or ECS Roles. func RemoteCredProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider { if u := os.Getenv(httpProviderEnvVar); len(u) > 0 { return localHTTPCredProvider(cfg, handlers, u) } if uri := os.Getenv(shareddefaults.ECSCredsProviderEnvVar); len(uri) > 0 { u := fmt.Sprintf("%s%s", shareddefaults.ECSContainerCredentialsURI, uri) return httpCredProvider(cfg, handlers, u) } return ec2RoleProvider(cfg, handlers) } var lookupHostFn = net.LookupHost // isAllowedHost allows host to be loopback or known ECS/EKS container IPs // // host can either be an IP address OR an unresolved hostname - resolution will // be automatically performed in the latter case func isAllowedHost(host string) (bool, error) { if ip := net.ParseIP(host); ip != nil { return isIPAllowed(ip), nil } addrs, err := lookupHostFn(host) if err != nil { return false, err } for _, addr := range addrs { if ip := net.ParseIP(addr); ip == nil \|\| !isIPAllowed(ip) { return false, nil } } return true, nil } func isIPAllowed(ip net.IP) bool { return ip.IsLoopback() \|\| ip.Equal(ecsContainerIPv4) \|\| ip.Equal(eksContainerIPv4) \|\| ip.Equal(eksContainerIPv6) } func localHTTPCredProvider(cfg aws.Config, handlers request.Handlers, u string) credentials.Provider { var errMsg string parsed, err := url.Parse(u) if err != nil { errMsg = fmt.Sprintf("invalid URL, %v", err) } else { host := aws.URLHostname(parsed) if len(host) == 0 { errMsg = "unable to parse host from local HTTP cred provider URL" } else if parsed.Scheme == "http" { if isAllowedHost, allowHostErr := isAllowedHost(host); allowHostErr != nil { errMsg = fmt.Sprintf("failed to resolve host %q, %v", host, allowHostErr) } else if !isAllowedHost { errMsg = fmt.Sprintf("invalid endpoint host, %q, only loopback/ecs/eks hosts are allowed.", host) } } } if len(errMsg) > 0 { if cfg.Logger != nil { cfg.Logger.Log("Ignoring, HTTP credential provider", errMsg, err) } return credentials.ErrorProvider{ Err: awserr.New("CredentialsEndpointError", errMsg, err), ProviderName: endpointcreds.ProviderName, } } return httpCredProvider(cfg, handlers, u) } func httpCredProvider(cfg aws.Config, handlers request.Handlers, u string) credentials.Provider { return endpointcreds.NewProviderClient(cfg, handlers, u, func(p endpointcreds.Provider) { p.ExpiryWindow = 5 time.Minute p.AuthorizationToken = os.Getenv(httpProviderAuthorizationEnvVar) if authFilePath := os.Getenv(httpProviderAuthFileEnvVar); authFilePath != "" { p.AuthorizationTokenProvider = endpointcreds.TokenProviderFunc(func() (string, error) { if contents, err := ioutil.ReadFile(authFilePath); err != nil { return "", fmt.Errorf("failed to read authorization token from %v: %v", authFilePath, err) } else { return string(contents), nil } }) } }, ) } func ec2RoleProvider(cfg aws.Config, handlers request.Handlers) credentials.Provider { resolver := cfg.EndpointResolver if resolver == nil { resolver = endpoints.DefaultResolver() } e, _ := resolver.EndpointFor(endpoints.Ec2metadataServiceID, "") return &ec2rolecreds.EC2RoleProvider{ Client: ec2metadata.NewClient(cfg, handlers, e.URL, e.SigningRegion), ExpiryWindow: 5 * time.Minute, } }	8.09 KB	2025-05-25 12:27
📄 defaults_test.go package defaults import ( "fmt" "os" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds" "github.com/aws/aws-sdk-go/aws/credentials/endpointcreds" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/internal/sdktesting" "github.com/aws/aws-sdk-go/internal/shareddefaults" ) func TestHTTPCredProvider(t testing.T) { origFn := lookupHostFn defer func() { lookupHostFn = origFn }() lookupHostFn = func(host string) ([]string, error) { m := map[string]struct { Addrs []string Err error }{ "localhost": {Addrs: []string{"::1", "127.0.0.1"}}, "actuallylocal": {Addrs: []string{"127.0.0.2"}}, "notlocal": {Addrs: []string{"::1", "127.0.0.1", "192.168.1.10"}}, "www.example.com": {Addrs: []string{"10.10.10.10"}}, "www.eks.legit.com": {Addrs: []string{"fd00:ec2::23"}}, "www.eks.scary.com": {Addrs: []string{"fd00:ec3::23"}}, } h, ok := m[host] if !ok { t.Fatalf("unknown host in test, %v", host) return nil, fmt.Errorf("unknown host") } return h.Addrs, h.Err } cases := []struct { Host string AuthToken string Fail bool }{ {Host: "localhost", Fail: false}, {Host: "actuallylocal", Fail: false}, {Host: "127.0.0.1", Fail: false}, {Host: "127.1.1.1", Fail: false}, {Host: "[::1]", Fail: false}, {Host: "www.example.com", Fail: true}, {Host: "169.254.170.2", Fail: false}, {Host: "169.254.170.23", Fail: false}, {Host: "[fd00:ec2::23]", Fail: false}, {Host: "[fd00:ec2:0::23]", Fail: false}, {Host: "[fd00:ec2:0:1::23]", Fail: true}, {Host: "www.eks.legit.com", Fail: false}, {Host: "www.eks.scary.com", Fail: true}, {Host: "localhost", Fail: false, AuthToken: "Basic abc123"}, } restoreEnvFn := sdktesting.StashEnv() defer restoreEnvFn() for i, c := range cases { u := fmt.Sprintf("http://%s/abc/123", c.Host) os.Setenv(httpProviderEnvVar, u) os.Setenv(httpProviderAuthorizationEnvVar, c.AuthToken) provider := RemoteCredProvider(aws.Config{}, request.Handlers{}) if provider == nil { t.Fatalf("%d, expect provider not to be nil, but was", i) } if c.Fail { creds, err := provider.Retrieve() if err == nil { t.Fatalf("%d, expect error but got none", i) } else { aerr := err.(awserr.Error) if e, a := "CredentialsEndpointError", aerr.Code(); e != a { t.Errorf("%d, expect %s error code, got %s", i, e, a) } } if e, a := endpointcreds.ProviderName, creds.ProviderName; e != a { t.Errorf("%d, expect %s provider name got %s", i, e, a) } } else { httpProvider := provider.(endpointcreds.Provider) if e, a := u, httpProvider.Client.Endpoint; e != a { t.Errorf("%d, expect %q endpoint, got %q", i, e, a) } if e, a := c.AuthToken, httpProvider.AuthorizationToken; e != a { t.Errorf("%d, expect %q auth token, got %q", i, e, a) } } } } func TestHTTPAuthTokenFile(t testing.T) { restoreEnvFn := sdktesting.StashEnv() defer restoreEnvFn() os.Setenv(httpProviderAuthFileEnvVar, "path/to/file") os.Setenv(httpProviderEnvVar, "http://169.254.170.23/abc/123") provider := RemoteCredProvider(aws.Config{}, request.Handlers{}) if provider == nil { t.Fatalf("expect provider not to be nil, but was") } httpProvider := provider.(endpointcreds.Provider) if httpProvider == nil { t.Fatalf("expect provider not to be nil, but was") } if httpProvider.AuthorizationTokenProvider == nil { t.Fatalf("expect auth token provider no to be nil, but was") } } func TestECSCredProvider(t testing.T) { restoreEnvFn := sdktesting.StashEnv() defer restoreEnvFn() os.Setenv(shareddefaults.ECSCredsProviderEnvVar, "/abc/123") provider := RemoteCredProvider(aws.Config{}, request.Handlers{}) if provider == nil { t.Fatalf("expect provider not to be nil, but was") } httpProvider := provider.(endpointcreds.Provider) if httpProvider == nil { t.Fatalf("expect provider not to be nil, but was") } if e, a := "http://169.254.170.2/abc/123", httpProvider.Client.Endpoint; e != a { t.Errorf("expect %q endpoint, got %q", e, a) } } func TestDefaultEC2RoleProvider(t testing.T) { provider := RemoteCredProvider(aws.Config{}, request.Handlers{}) if provider == nil { t.Fatalf("expect provider not to be nil, but was") } ec2Provider := provider.(ec2rolecreds.EC2RoleProvider) if ec2Provider == nil { t.Fatalf("expect provider not to be nil, but was") } if e, a := "http://169.254.169.254", ec2Provider.Client.Endpoint; e != a { t.Errorf("expect %q endpoint, got %q", e, a) } }	4.51 KB	2025-05-25 12:27
📄 shared_config.go package defaults import ( "github.com/aws/aws-sdk-go/internal/shareddefaults" ) // SharedCredentialsFilename returns the SDK's default file path // for the shared credentials file. // // Builds the shared config file path based on the OS's platform. // // - Linux/Unix: $HOME/.aws/credentials // - Windows: %USERPROFILE%\.aws\credentials func SharedCredentialsFilename() string { return shareddefaults.SharedCredentialsFilename() } // SharedConfigFilename returns the SDK's default file path for // the shared config file. // // Builds the shared config file path based on the OS's platform. // // - Linux/Unix: $HOME/.aws/config // - Windows: %USERPROFILE%\.aws\config func SharedConfigFilename() string { return shareddefaults.SharedConfigFilename() }	768 B	2025-05-25 12:27

Terminal