ruby_snowflake_client 1.0.0

data/ext/vendor/github.com/99designs/keyring/pass.go

@@ -0,0 +1,166 @@
+//go:build !windows
+// +build !windows
+
+package keyring
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func init() {
+	supportedBackends[PassBackend] = opener(func(cfg Config) (Keyring, error) {
+		var err error
+
+		pass := &passKeyring{
+			passcmd: cfg.PassCmd,
+			dir:     cfg.PassDir,
+			prefix:  cfg.PassPrefix,
+		}
+
+		if pass.passcmd == "" {
+			pass.passcmd = "pass"
+		}
+
+		if pass.dir == "" {
+			if passDir, found := os.LookupEnv("PASSWORD_STORE_DIR"); found {
+				pass.dir = passDir
+			} else {
+				homeDir, err := os.UserHomeDir()
+				if err != nil {
+					return nil, err
+				}
+				pass.dir = filepath.Join(homeDir, ".password-store")
+			}
+		}
+
+		pass.dir, err = ExpandTilde(pass.dir)
+		if err != nil {
+			return nil, err
+		}
+
+		// fail if the pass program is not available
+		_, err = exec.LookPath(pass.passcmd)
+		if err != nil {
+			return nil, errors.New("The pass program is not available")
+		}
+
+		return pass, nil
+	})
+}
+
+type passKeyring struct {
+	dir     string
+	passcmd string
+	prefix  string
+}
+
+func (k *passKeyring) pass(args ...string) *exec.Cmd {
+	cmd := exec.Command(k.passcmd, args...)
+	if k.dir != "" {
+		cmd.Env = append(os.Environ(), fmt.Sprintf("PASSWORD_STORE_DIR=%s", k.dir))
+	}
+	cmd.Stderr = os.Stderr
+
+	return cmd
+}
+
+func (k *passKeyring) Get(key string) (Item, error) {
+	if !k.itemExists(key) {
+		return Item{}, ErrKeyNotFound
+	}
+
+	name := filepath.Join(k.prefix, key)
+	cmd := k.pass("show", name)
+	output, err := cmd.Output()
+	if err != nil {
+		return Item{}, err
+	}
+
+	var decoded Item
+	err = json.Unmarshal(output, &decoded)
+
+	return decoded, err
+}
+
+func (k *passKeyring) GetMetadata(key string) (Metadata, error) {
+	return Metadata{}, nil
+}
+
+func (k *passKeyring) Set(i Item) error {
+	bytes, err := json.Marshal(i)
+	if err != nil {
+		return err
+	}
+
+	name := filepath.Join(k.prefix, i.Key)
+	cmd := k.pass("insert", "-m", "-f", name)
+	cmd.Stdin = strings.NewReader(string(bytes))
+
+	err = cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k *passKeyring) Remove(key string) error {
+	if !k.itemExists(key) {
+		return ErrKeyNotFound
+	}
+
+	name := filepath.Join(k.prefix, key)
+	cmd := k.pass("rm", "-f", name)
+	err := cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k *passKeyring) itemExists(key string) bool {
+	var path = filepath.Join(k.dir, k.prefix, key+".gpg")
+	_, err := os.Stat(path)
+
+	return err == nil
+}
+
+func (k *passKeyring) Keys() ([]string, error) {
+	var keys = []string{}
+	var path = filepath.Join(k.dir, k.prefix)
+
+	info, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return keys, nil
+		}
+		return keys, err
+	}
+	if !info.IsDir() {
+		return keys, fmt.Errorf("%s is not a directory", path)
+	}
+
+	err = filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && filepath.Ext(p) == ".gpg" {
+			name := strings.TrimPrefix(p, path)
+			if name[0] == os.PathSeparator {
+				name = name[1:]
+			}
+			keys = append(keys, name[:len(name)-4])
+		}
+		return nil
+	})
+
+	return keys, err
+}

data/ext/vendor/github.com/99designs/keyring/prompt.go

@@ -0,0 +1,27 @@
+package keyring
+
+import (
+	"fmt"
+	"os"
+
+	"golang.org/x/term"
+)
+
+// PromptFunc is a function used to prompt the user for a password.
+type PromptFunc func(string) (string, error)
+
+func TerminalPrompt(prompt string) (string, error) {
+	fmt.Printf("%s: ", prompt)
+	b, err := term.ReadPassword(int(os.Stdin.Fd()))
+	if err != nil {
+		return "", err
+	}
+	fmt.Println()
+	return string(b), nil
+}
+
+func FixedStringPrompt(value string) PromptFunc {
+	return func(_ string) (string, error) {
+		return value, nil
+	}
+}

data/ext/vendor/github.com/99designs/keyring/secretservice.go

@@ -0,0 +1,293 @@
+//go:build linux
+// +build linux
+
+package keyring
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+
+	"strings"
+
+	"github.com/godbus/dbus"
+	"github.com/gsterjov/go-libsecret"
+)
+
+func init() {
+	// silently fail if dbus isn't available
+	_, err := dbus.SessionBus()
+	if err != nil {
+		return
+	}
+
+	supportedBackends[SecretServiceBackend] = opener(func(cfg Config) (Keyring, error) {
+		if cfg.ServiceName == "" {
+			cfg.ServiceName = "secret-service"
+		}
+		if cfg.LibSecretCollectionName == "" {
+			cfg.LibSecretCollectionName = cfg.ServiceName
+		}
+
+		service, err := libsecret.NewService()
+		if err != nil {
+			return &secretsKeyring{}, err
+		}
+
+		ring := &secretsKeyring{
+			name:    cfg.LibSecretCollectionName,
+			service: service,
+		}
+
+		return ring, ring.openSecrets()
+	})
+}
+
+type secretsKeyring struct {
+	name       string
+	service    *libsecret.Service
+	collection *libsecret.Collection
+	session    *libsecret.Session
+}
+
+var errCollectionNotFound = errors.New("The collection does not exist. Please add a key first")
+
+func decodeKeyringString(src string) string {
+	var dst strings.Builder
+	for i := 0; i < len(src); i++ {
+		if src[i] != '_' {
+			dst.WriteString(string(src[i]))
+		} else {
+			if i+3 > len(src) {
+				return src
+			}
+			hexstring := src[i+1 : i+3]
+			decoded, err := hex.DecodeString(hexstring)
+			if err != nil {
+				return src
+			}
+			dst.Write(decoded)
+			i += 2
+		}
+	}
+	return dst.String()
+}
+
+func (k *secretsKeyring) openSecrets() error {
+	session, err := k.service.Open()
+	if err != nil {
+		return err
+	}
+	k.session = session
+
+	// get the collection if it already exists
+	collections, err := k.service.Collections()
+	if err != nil {
+		return err
+	}
+
+	path := libsecret.DBusPath + "/collection/" + k.name
+
+	for _, collection := range collections {
+		if decodeKeyringString(string(collection.Path())) == path {
+			c := collection // fix variable into the local variable to ensure it's referenced correctly, see https://github.com/kyoh86/exportloopref
+			k.collection = &c
+			return nil
+		}
+	}
+
+	return nil
+}
+
+func (k *secretsKeyring) openCollection() error {
+	if err := k.openSecrets(); err != nil {
+		return err
+	}
+
+	if k.collection == nil {
+		return errCollectionNotFound
+		// return &secretsError{fmt.Sprintf(
+		// 	"The collection %q does not exist. Please add a key first",
+		// 	k.name,
+		// )}
+	}
+
+	return nil
+}
+
+func (k *secretsKeyring) Get(key string) (Item, error) {
+	if err := k.openCollection(); err != nil {
+		if err == errCollectionNotFound {
+			return Item{}, ErrKeyNotFound
+		}
+		return Item{}, err
+	}
+
+	items, err := k.collection.SearchItems(key)
+	if err != nil {
+		return Item{}, err
+	}
+
+	if len(items) == 0 {
+		return Item{}, ErrKeyNotFound
+	}
+
+	// use the first item whenever there are multiples
+	// with the same profile name
+	item := items[0]
+
+	locked, err := item.Locked()
+	if err != nil {
+		return Item{}, err
+	}
+
+	if locked {
+		if err := k.service.Unlock(item); err != nil {
+			return Item{}, err
+		}
+	}
+
+	secret, err := item.GetSecret(k.session)
+	if err != nil {
+		return Item{}, err
+	}
+
+	// pack the secret into the item
+	var ret Item
+	if err = json.Unmarshal(secret.Value, &ret); err != nil {
+		return Item{}, err
+	}
+
+	return ret, err
+}
+
+// GetMetadata for libsecret returns an error indicating that it's unsupported
+// for this backend.
+//
+// libsecret actually implements a metadata system which we could use, "Secret
+// Attributes"; I found no indication in documentation of anything like an
+// automatically maintained last-modification timestamp, so to use this we'd
+// need to have a SetMetadata API too.  Which we're not yet doing, but feel
+// free to contribute patches.
+func (k *secretsKeyring) GetMetadata(key string) (Metadata, error) {
+	return Metadata{}, ErrMetadataNeedsCredentials
+}
+
+func (k *secretsKeyring) Set(item Item) error {
+	err := k.openSecrets()
+	if err != nil {
+		return err
+	}
+
+	// create the collection if it doesn't already exist
+	if k.collection == nil {
+		collection, err := k.service.CreateCollection(k.name)
+		if err != nil {
+			return err
+		}
+
+		k.collection = collection
+	}
+
+	if err := k.ensureCollectionUnlocked(); err != nil {
+		return err
+	}
+
+	// create the new item
+	data, err := json.Marshal(item)
+	if err != nil {
+		return err
+	}
+
+	secret := libsecret.NewSecret(k.session, []byte{}, data, "application/json")
+
+	if _, err := k.collection.CreateItem(item.Key, secret, true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k *secretsKeyring) Remove(key string) error {
+	if err := k.openCollection(); err != nil {
+		if err == errCollectionNotFound {
+			return ErrKeyNotFound
+		}
+		return err
+	}
+
+	items, err := k.collection.SearchItems(key)
+	if err != nil {
+		return err
+	}
+
+	// nothing to delete
+	if len(items) == 0 {
+		return nil
+	}
+
+	// we dont want to delete more than one anyway
+	// so just get the first item found
+	item := items[0]
+
+	locked, err := item.Locked()
+	if err != nil {
+		return err
+	}
+
+	if locked {
+		if err := k.service.Unlock(item); err != nil {
+			return err
+		}
+	}
+
+	if err := item.Delete(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k *secretsKeyring) Keys() ([]string, error) {
+	if err := k.openCollection(); err != nil {
+		if err == errCollectionNotFound {
+			return []string{}, nil
+		}
+		return nil, err
+	}
+	if err := k.ensureCollectionUnlocked(); err != nil {
+		return nil, err
+	}
+	items, err := k.collection.Items()
+	if err != nil {
+		return nil, err
+	}
+	keys := []string{}
+	for _, item := range items {
+		label, err := item.Label() // FIXME: err is being silently ignored
+		if err == nil {
+			keys = append(keys, label)
+		}
+	}
+	return keys, nil
+}
+
+// deleteCollection deletes the keyring's collection if it exists. This is mainly to support testing.
+func (k *secretsKeyring) deleteCollection() error {
+	if err := k.openCollection(); err != nil {
+		return err
+	}
+	return k.collection.Delete()
+}
+
+// unlock the collection if it's locked
+func (k *secretsKeyring) ensureCollectionUnlocked() error {
+	locked, err := k.collection.Locked()
+	if err != nil {
+		return err
+	}
+	if !locked {
+		return nil
+	}
+	return k.service.Unlock(k.collection)
+}

data/ext/vendor/github.com/99designs/keyring/tilde.go

@@ -0,0 +1,22 @@
+package keyring
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var tildePrefix = string([]rune{'~', filepath.Separator})
+
+// ExpandTilde will expand tilde (~/ or ~\ depending on OS) for the user home directory.
+func ExpandTilde(dir string) (string, error) {
+	if strings.HasPrefix(dir, tildePrefix) {
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		dir = strings.Replace(dir, "~", homeDir, 1)
+		debugf("Expanded file dir to %s", dir)
+	}
+	return dir, nil
+}

data/ext/vendor/github.com/99designs/keyring/wincred.go

@@ -0,0 +1,98 @@
+//go:build windows
+// +build windows
+
+package keyring
+
+import (
+	"strings"
+	"syscall"
+
+	"github.com/danieljoos/wincred"
+)
+
+// ERROR_NOT_FOUND from https://docs.microsoft.com/en-us/windows/win32/debug/system-error-codes--1000-1299-
+const elementNotFoundError = syscall.Errno(1168)
+
+type windowsKeyring struct {
+	name   string
+	prefix string
+}
+
+func init() {
+	supportedBackends[WinCredBackend] = opener(func(cfg Config) (Keyring, error) {
+		name := cfg.ServiceName
+		if name == "" {
+			name = "default"
+		}
+
+		prefix := cfg.WinCredPrefix
+		if prefix == "" {
+			prefix = "keyring"
+		}
+
+		return &windowsKeyring{
+			name:   name,
+			prefix: prefix,
+		}, nil
+	})
+}
+
+func (k *windowsKeyring) Get(key string) (Item, error) {
+	cred, err := wincred.GetGenericCredential(k.credentialName(key))
+	if err != nil {
+		if err == elementNotFoundError {
+			return Item{}, ErrKeyNotFound
+		}
+		return Item{}, err
+	}
+
+	item := Item{
+		Key:  key,
+		Data: cred.CredentialBlob,
+	}
+
+	return item, nil
+}
+
+// GetMetadata for pass returns an error indicating that it's unsupported
+// for this backend.
+// TODO: This is a stub. Look into whether pass would support metadata in a usable way for keyring.
+func (k *windowsKeyring) GetMetadata(_ string) (Metadata, error) {
+	return Metadata{}, ErrMetadataNotSupported
+}
+
+func (k *windowsKeyring) Set(item Item) error {
+	cred := wincred.NewGenericCredential(k.credentialName(item.Key))
+	cred.CredentialBlob = item.Data
+	return cred.Write()
+}
+
+func (k *windowsKeyring) Remove(key string) error {
+	cred, err := wincred.GetGenericCredential(k.credentialName(key))
+	if err != nil {
+		if err == elementNotFoundError {
+			return ErrKeyNotFound
+		}
+		return err
+	}
+	return cred.Delete()
+}
+
+func (k *windowsKeyring) Keys() ([]string, error) {
+	results := []string{}
+
+	if creds, err := wincred.List(); err == nil {
+		for _, cred := range creds {
+			prefix := k.credentialName("")
+			if strings.HasPrefix(cred.TargetName, prefix) {
+				results = append(results, strings.TrimPrefix(cred.TargetName, prefix))
+			}
+		}
+	}
+
+	return results, nil
+}
+
+func (k *windowsKeyring) credentialName(key string) string {
+	return k.prefix + ":" + k.name + ":" + key
+}