func decryptConf(encryptedConf []byte) (decryptedConf []byte, err error) {
store := &sopsyaml.Store{}
metadata, err := store.UnmarshalMetadata(encryptedConf)
if err != nil {
return
}
key, err := metadata.GetDataKey()
if err != nil {
return
}
branch, err := store.Unmarshal(encryptedConf)
if err != nil {
return
}
tree := sops.Tree{Branch: branch, Metadata: metadata}
cipher := aes.Cipher{}
mac, err := tree.Decrypt(key, cipher)
if err != nil {
return
}
originalMac, err := cipher.Decrypt(
metadata.MessageAuthenticationCode,
key,
[]byte(metadata.LastModified.Format(time.RFC3339)),
)
if originalMac != mac {
return
}
return store.Marshal(tree.Branch)
}
func decryptFile(store sops.Store, fileBytes []byte, ignoreMac bool) (sops.Tree, error) {
var tree sops.Tree
metadata, err := store.UnmarshalMetadata(fileBytes)
if err != nil {
return tree, cli.NewExitError(fmt.Sprintf("Error loading file: %s", err), exitCouldNotReadInputFile)
}
key, err := metadata.GetDataKey()
if err != nil {
return tree, cli.NewExitError(err.Error(), exitCouldNotRetrieveKey)
}
branch, err := store.Unmarshal(fileBytes)
if err != nil {
return tree, cli.NewExitError(fmt.Sprintf("Error loading file: %s", err), exitCouldNotReadInputFile)
}
tree = sops.Tree{Branch: branch, Metadata: metadata}
cipher := aes.Cipher{}
mac, err := tree.Decrypt(key, cipher)
if err != nil {
return tree, cli.NewExitError(fmt.Sprintf("Error decrypting tree: %s", err), exitErrorDecryptingTree)
}
originalMac, err := cipher.Decrypt(metadata.MessageAuthenticationCode, key, []byte(metadata.LastModified.Format(time.RFC3339)))
if originalMac != mac && !ignoreMac {
return tree, cli.NewExitError(fmt.Sprintf("MAC mismatch. File has %s, computed %s", originalMac, mac), 9)
}
return tree, nil
}
func encryptTree(tree sops.Tree, stash map[string][]interface{}) (sops.Tree, error) {
cipher := aes.Cipher{}
key, err := tree.Metadata.GetDataKey()
if err != nil {
return tree, cli.NewExitError(err.Error(), exitCouldNotRetrieveKey)
}
computedMac, err := tree.Encrypt(key, cipher, stash)
if err != nil {
return tree, cli.NewExitError(fmt.Sprintf("Error encrypting tree: %s", err), exitErrorEncryptingTree)
}
encryptedMac, err := cipher.Encrypt(computedMac, key, tree.Metadata.LastModified.Format(time.RFC3339), nil)
if err != nil {
return tree, cli.NewExitError(fmt.Sprintf("Could not encrypt MAC: %s", err), exitErrorEncryptingMac)
}
tree.Metadata.MessageAuthenticationCode = encryptedMac
return tree, nil
}
func decryptTree(tree sops.Tree, ignoreMac bool) (sops.Tree, map[string][]interface{}, error) {
cipher := aes.Cipher{}
stash := make(map[string][]interface{})
key, err := tree.Metadata.GetDataKey()
if err != nil {
return tree, nil, cli.NewExitError(err.Error(), exitCouldNotRetrieveKey)
}
computedMac, err := tree.Decrypt(key, cipher, stash)
if err != nil {
return tree, nil, cli.NewExitError(fmt.Sprintf("Error decrypting tree: %s", err), exitErrorDecryptingTree)
}
fileMac, _, err := cipher.Decrypt(tree.Metadata.MessageAuthenticationCode, key, tree.Metadata.LastModified.Format(time.RFC3339))
if fileMac != computedMac && !ignoreMac {
return tree, nil, cli.NewExitError(fmt.Sprintf("MAC mismatch. File has %s, computed %s", fileMac, computedMac), exitMacMismatch)
}
return tree, stash, nil
}
func encrypt(c *cli.Context, file string, fileBytes []byte, output io.Writer) error {
store := store(file)
branch, err := store.Unmarshal(fileBytes)
if err != nil {
return cli.NewExitError(fmt.Sprintf("Error loading file: %s", err), exitCouldNotReadInputFile)
}
var metadata sops.Metadata
metadata.UnencryptedSuffix = c.String("unencrypted-suffix")
metadata.Version = "2.0.0"
var kmsKeys []sops.MasterKey
var pgpKeys []sops.MasterKey
if c.String("kms") != "" {
for _, k := range kms.MasterKeysFromArnString(c.String("kms")) {
kmsKeys = append(kmsKeys, &k)
}
}
if c.String("pgp") != "" {
for _, k := range pgp.MasterKeysFromFingerprintString(c.String("pgp")) {
pgpKeys = append(pgpKeys, &k)
}
}
if c.String("kms") == "" && c.String("pgp") == "" {
var confBytes []byte
if c.String("config") != "" {
confBytes, err = ioutil.ReadFile(c.String("config"))
if err != nil {
return cli.NewExitError(fmt.Sprintf("Error loading config file: %s", err), exitErrorReadingConfig)
}
}
kmsString, pgpString, err := yaml.MasterKeyStringsForFile(file, confBytes)
if err == nil {
for _, k := range pgp.MasterKeysFromFingerprintString(pgpString) {
pgpKeys = append(pgpKeys, &k)
}
for _, k := range kms.MasterKeysFromArnString(kmsString) {
kmsKeys = append(kmsKeys, &k)
}
}
}
kmsKs := sops.KeySource{Name: "kms", Keys: kmsKeys}
pgpKs := sops.KeySource{Name: "pgp", Keys: pgpKeys}
metadata.KeySources = append(metadata.KeySources, kmsKs)
metadata.KeySources = append(metadata.KeySources, pgpKs)
tree := sops.Tree{Branch: branch, Metadata: metadata}
key, err := tree.GenerateDataKey()
if err != nil {
return cli.NewExitError(err.Error(), exitCouldNotRetrieveKey)
}
cipher := aes.Cipher{}
mac, err := tree.Encrypt(key, cipher)
encryptedMac, err := cipher.Encrypt(mac, key, []byte(metadata.LastModified.Format(time.RFC3339)))
if err != nil {
return cli.NewExitError(fmt.Sprintf("Could not encrypt MAC: %s", err), exitErrorEncryptingTree)
}
metadata.MessageAuthenticationCode = encryptedMac
out, err := store.MarshalWithMetadata(tree.Branch, metadata)
_, err = output.Write([]byte(out))
if err != nil {
return cli.NewExitError(fmt.Sprintf("Could not write to output stream: %s", err), exitCouldNotWriteOutputFile)
}
return nil
}