fix for #548 - handle .ini files in decrypt.Data, add other helper

cmd/sops/common/common.go

@@ -5,13 +5,13 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"
 
 	"github.com/fatih/color"
 	wordwrap "github.com/mitchellh/go-wordwrap"
 	"go.mozilla.org/sops"
 	"go.mozilla.org/sops/cmd/sops/codes"
+	. "go.mozilla.org/sops/cmd/sops/formats"
 	"go.mozilla.org/sops/keys"
 	"go.mozilla.org/sops/keyservice"
 	"go.mozilla.org/sops/kms"
@@ -36,6 +36,36 @@ type Store interface {
 	ExampleFileEmitter
 }
 
+type storeConstructor = func() Store
+
+func newBinaryStore() Store {
+	return &json.BinaryStore{}
+}
+
+func newDotenvStore() Store {
+	return &dotenv.Store{}
+}
+
+func newIniStore() Store {
+	return &ini.Store{}
+}
+
+func newJsonStore() Store {
+	return &json.Store{}
+}
+
+func newYamlStore() Store {
+	return &yaml.Store{}
+}
+
+var storeConstructors = map[Format]storeConstructor{
+	Binary: newBinaryStore,
+	Dotenv: newDotenvStore,
+	Ini:    newIniStore,
+	Json:   newJsonStore,
+	Yaml:   newYamlStore,
+}
+
 // DecryptTreeOpts are the options needed to decrypt a tree
 type DecryptTreeOpts struct {
 	// Tree is the tree to be decrypted
@@ -119,39 +149,29 @@ func NewExitError(i interface{}, exitCode int) *cli.ExitError {
 	return cli.NewExitError(i, exitCode)
 }
 
-// IsYAMLFile returns true if a given file path corresponds to a YAML file
-func IsYAMLFile(path string) bool {
-	return strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml")
-}
-
-// IsJSONFile returns true if a given file path corresponds to a JSON file
-func IsJSONFile(path string) bool {
-	return strings.HasSuffix(path, ".json")
-}
-
-// IsEnvFile returns true if a given file path corresponds to a .env file
-func IsEnvFile(path string) bool {
-	return strings.HasSuffix(path, ".env")
-}
-
-// IsIniFile returns true if a given file path corresponds to a INI file
-func IsIniFile(path string) bool {
-	return strings.HasSuffix(path, ".ini")
+// StoreForFormat returns the correct format-specific implementation
+// of the Store interface given the format.
+func StoreForFormat(format Format) Store {
+	storeConst, found := storeConstructors[format]
+	if !found {
+		storeConst = storeConstructors[Binary] // default
+	}
+	return storeConst()
 }
 
 // DefaultStoreForPath returns the correct format-specific implementation
 // of the Store interface given the path to a file
 func DefaultStoreForPath(path string) Store {
-	if IsYAMLFile(path) {
-		return &yaml.Store{}
-	} else if IsJSONFile(path) {
-		return &json.Store{}
-	} else if IsEnvFile(path) {
-		return &dotenv.Store{}
-	} else if IsIniFile(path) {
-		return &ini.Store{}
-	}
-	return &json.BinaryStore{}
+	format := FormatForPath(path)
+	return StoreForFormat(format)
+}
+
+// DefaultStoreForPathOrFormat returns the correct format-specific implementation
+// of the Store interface given the formatString if specified, or the path to a file.
+// This is to support the cli, where both are provided.
+func DefaultStoreForPathOrFormat(path, format string) Store {
+	formatFmt := FormatForPathOrString(path, format)
+	return StoreForFormat(formatFmt)
 }
 
 // KMS_ENC_CTX_BUG_FIXED_VERSION represents the SOPS version in which the

cmd/sops/formats/formats.go

@@ -0,0 +1,78 @@
+package formats
+
+import "strings"
+
+// Format is an enum type
+type Format int
+
+const (
+	Binary Format = iota
+	Dotenv
+	Ini
+	Json
+	Yaml
+)
+
+var stringToFormat = map[string]Format{
+	"binary": Binary,
+	"dotenv": Dotenv,
+	"ini":    Ini,
+	"json":   Json,
+	"yaml":   Yaml,
+}
+
+// FormatFromString returns a Format from a string.
+// This is used for converting string cli options.
+func FormatFromString(formatString string) Format {
+	format, found := stringToFormat[formatString]
+	if !found {
+		return Binary
+	}
+	return format
+}
+
+// IsYAMLFile returns true if a given file path corresponds to a YAML file
+func IsYAMLFile(path string) bool {
+	return strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml")
+}
+
+// IsJSONFile returns true if a given file path corresponds to a JSON file
+func IsJSONFile(path string) bool {
+	return strings.HasSuffix(path, ".json")
+}
+
+// IsEnvFile returns true if a given file path corresponds to a .env file
+func IsEnvFile(path string) bool {
+	return strings.HasSuffix(path, ".env")
+}
+
+// IsIniFile returns true if a given file path corresponds to a INI file
+func IsIniFile(path string) bool {
+	return strings.HasSuffix(path, ".ini")
+}
+
+// FormatForPath returns the correct format given the path to a file
+func FormatForPath(path string) Format {
+	format := Binary // default
+	if IsYAMLFile(path) {
+		format = Yaml
+	} else if IsJSONFile(path) {
+		format = Json
+	} else if IsEnvFile(path) {
+		format = Dotenv
+	} else if IsIniFile(path) {
+		format = Ini
+	}
+	return format
+}
+
+// FormatForPathOrString returns the correct format-specific implementation
+// of the Store interface given the formatString if specified, or the path to a file.
+// This is to support the cli, where both are provided.
+func FormatForPathOrString(path, format string) Format {
+	formatFmt, found := stringToFormat[format]
+	if !found {
+		formatFmt = FormatForPath(path)
+	}
+	return formatFmt
+}

cmd/sops/formats/formats_test.go

@@ -0,0 +1,39 @@
+package formats
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormatFromString(t *testing.T) {
+	assert.Equal(t, Binary, FormatFromString("foobar"))
+	assert.Equal(t, Dotenv, FormatFromString("dotenv"))
+	assert.Equal(t, Ini, FormatFromString("ini"))
+	assert.Equal(t, Yaml, FormatFromString("yaml"))
+	assert.Equal(t, Json, FormatFromString("json"))
+}
+
+func TestFormatForPath(t *testing.T) {
+	assert.Equal(t, Binary, FormatForPath("/path/to/foobar"))
+	assert.Equal(t, Dotenv, FormatForPath("/path/to/foobar.env"))
+	assert.Equal(t, Ini, FormatForPath("/path/to/foobar.ini"))
+	assert.Equal(t, Json, FormatForPath("/path/to/foobar.json"))
+	assert.Equal(t, Yaml, FormatForPath("/path/to/foobar.yml"))
+	assert.Equal(t, Yaml, FormatForPath("/path/to/foobar.yaml"))
+}
+
+func TestFormatForPathOrString(t *testing.T) {
+	assert.Equal(t, Binary, FormatForPathOrString("/path/to/foobar", ""))
+	assert.Equal(t, Dotenv, FormatForPathOrString("/path/to/foobar", "dotenv"))
+	assert.Equal(t, Dotenv, FormatForPathOrString("/path/to/foobar.env", ""))
+	assert.Equal(t, Ini, FormatForPathOrString("/path/to/foobar", "ini"))
+	assert.Equal(t, Ini, FormatForPathOrString("/path/to/foobar.ini", ""))
+	assert.Equal(t, Json, FormatForPathOrString("/path/to/foobar", "json"))
+	assert.Equal(t, Json, FormatForPathOrString("/path/to/foobar.json", ""))
+	assert.Equal(t, Yaml, FormatForPathOrString("/path/to/foobar", "yaml"))
+	assert.Equal(t, Yaml, FormatForPathOrString("/path/to/foobar.yml", ""))
+
+	assert.Equal(t, Ini, FormatForPathOrString("/path/to/foobar.yml", "ini"))
+	assert.Equal(t, Binary, FormatForPathOrString("/path/to/foobar.yml", "binary"))
+}

cmd/sops/main.go

@@ -32,9 +32,7 @@ import (
 	"go.mozilla.org/sops/logging"
 	"go.mozilla.org/sops/pgp"
 	"go.mozilla.org/sops/stores/dotenv"
-	"go.mozilla.org/sops/stores/ini"
 	"go.mozilla.org/sops/stores/json"
-	yamlstores "go.mozilla.org/sops/stores/yaml"
 	"go.mozilla.org/sops/version"
 	"google.golang.org/grpc"
 	"gopkg.in/urfave/cli.v1"
@@ -875,37 +873,11 @@ func keyservices(c *cli.Context) (svcs []keyservice.KeyServiceClient) {
 }
 
 func inputStore(context *cli.Context, path string) common.Store {
-	switch context.String("input-type") {
-	case "yaml":
-		return &yamlstores.Store{}
-	case "json":
-		return &json.Store{}
-	case "dotenv":
-		return &dotenv.Store{}
-	case "ini":
-		return &ini.Store{}
-	case "binary":
-		return &json.BinaryStore{}
-	default:
-		return common.DefaultStoreForPath(path)
-	}
+	return common.DefaultStoreForPathOrFormat(path, context.String("input-type"))
 }
 
 func outputStore(context *cli.Context, path string) common.Store {
-	switch context.String("output-type") {
-	case "yaml":
-		return &yamlstores.Store{}
-	case "json":
-		return &json.Store{}
-	case "dotenv":
-		return &dotenv.Store{}
-	case "ini":
-		return &ini.Store{}
-	case "binary":
-		return &json.BinaryStore{}
-	default:
-		return common.DefaultStoreForPath(path)
-	}
+	return common.DefaultStoreForPathOrFormat(path, context.String("output-type"))
 }
 
 func parseTreePath(arg string) ([]interface{}, error) {

decrypt/decrypt.go

@@ -9,11 +9,9 @@ import (
 	"io/ioutil"
 	"time"
 
-	"go.mozilla.org/sops"
 	"go.mozilla.org/sops/aes"
-	sopsdotenv "go.mozilla.org/sops/stores/dotenv"
-	sopsjson "go.mozilla.org/sops/stores/json"
-	sopsyaml "go.mozilla.org/sops/stores/yaml"
+	"go.mozilla.org/sops/cmd/sops/common"
+	. "go.mozilla.org/sops/cmd/sops/formats" // Re-export
 )
 
 // File is a wrapper around Data that reads a local encrypted
@@ -24,26 +22,18 @@ func File(path, format string) (cleartext []byte, err error) {
 	if err != nil {
 		return nil, fmt.Errorf("Failed to read %q: %v", path, err)
 	}
-	return Data(encryptedData, format)
+
+	// uses same logic as cli.
+	formatFmt := FormatForPathOrString(path, format)
+	return DataWithFormat(encryptedData, formatFmt)
 }
 
-// Data is a helper that takes encrypted data and a format string,
+// DataWithFormat is a helper that takes encrypted data, and a format enum value,
 // decrypts the data and returns its cleartext in an []byte.
-// The format string can be `json`, `yaml`, `dotenv` or `binary`.
-// If the format string is empty, binary format is assumed.
-func Data(data []byte, format string) (cleartext []byte, err error) {
-	// Initialize a Sops JSON store
-	var store sops.Store
-	switch format {
-	case "json":
-		store = &sopsjson.Store{}
-	case "yaml":
-		store = &sopsyaml.Store{}
-	case "dotenv":
-		store = &sopsdotenv.Store{}
-	default:
-		store = &sopsjson.BinaryStore{}
-	}
+func DataWithFormat(data []byte, format Format) (cleartext []byte, err error) {
+
+	store := common.StoreForFormat(format)
+
 	// Load SOPS file and access the data key
 	tree, err := store.LoadEncryptedFile(data)
 	if err != nil {
@@ -75,3 +65,12 @@ func Data(data []byte, format string) (cleartext []byte, err error) {
 
 	return store.EmitPlainFile(tree.Branches)
 }
+
+// Data is a helper that takes encrypted data and a format string,
+// decrypts the data and returns its cleartext in an []byte.
+// The format string can be `json`, `yaml`, `ini`, `dotenv` or `binary`.
+// If the format string is empty, binary format is assumed.
+func Data(data []byte, format string) (cleartext []byte, err error) {
+	formatFmt := FormatFromString(format)
+	return DataWithFormat(data, formatFmt)
+}