EBS default encryption

aws/provider.go

@@ -426,6 +426,8 @@ func Provider() terraform.ResourceProvider {
 			"aws_dynamodb_table":                                      resourceAwsDynamoDbTable(),
 			"aws_dynamodb_table_item":                                 resourceAwsDynamoDbTableItem(),
 			"aws_dynamodb_global_table":                               resourceAwsDynamoDbGlobalTable(),
+			"aws_ebs_default_kms_key":                                 resourceAwsEbsDefaultKmsKey(),
+			"aws_ebs_encryption_by_default":                           resourceAwsEbsEncryptionByDefault(),
 			"aws_ebs_snapshot":                                        resourceAwsEbsSnapshot(),
 			"aws_ebs_snapshot_copy":                                   resourceAwsEbsSnapshotCopy(),
 			"aws_ebs_volume":                                          resourceAwsEbsVolume(),

aws/resource_aws_ebs_default_kms_key.go

@@ -0,0 +1,69 @@
+package aws
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAwsEbsDefaultKmsKey() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsEbsDefaultKmsKeyCreate,
+		Read:   resourceAwsEbsDefaultKmsKeyRead,
+		Delete: resourceAwsEbsDefaultKmsKeyDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"key_arn": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validateArn,
+			},
+		},
+	}
+}
+
+func resourceAwsEbsDefaultKmsKeyCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	resp, err := conn.ModifyEbsDefaultKmsKeyId(&ec2.ModifyEbsDefaultKmsKeyIdInput{
+		KmsKeyId: aws.String(d.Get("key_arn").(string)),
+	})
+	if err != nil {
+		return fmt.Errorf("error creating EBS default KMS key: %s", err)
+	}
+
+	d.SetId(aws.StringValue(resp.KmsKeyId))
+
+	return resourceAwsEbsDefaultKmsKeyRead(d, meta)
+}
+
+func resourceAwsEbsDefaultKmsKeyRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	resp, err := conn.GetEbsDefaultKmsKeyId(&ec2.GetEbsDefaultKmsKeyIdInput{})
+	if err != nil {
+		return fmt.Errorf("error reading EBS default KMS key: %s", err)
+	}
+
+	d.Set("key_arn", resp.KmsKeyId)
+
+	return nil
+}
+
+func resourceAwsEbsDefaultKmsKeyDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	_, err := conn.ResetEbsDefaultKmsKeyId(&ec2.ResetEbsDefaultKmsKeyIdInput{})
+	if err != nil {
+		return fmt.Errorf("error deleting EBS default KMS key: %s", err)
+	}
+
+	return nil
+}

aws/resource_aws_ebs_default_kms_key_test.go

@@ -0,0 +1,123 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/arn"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSEBSDefaultKmsKey_basic(t *testing.T) {
+	resourceName := "aws_ebs_default_kms_key.test"
+	resourceNameKey := "aws_kms_key.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsEbsDefaultKmsKeyDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAwsEbsDefaultKmsKeyConfig_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsDefaultKmsKey(resourceName),
+					resource.TestCheckResourceAttrPair(resourceName, "key_arn", resourceNameKey, "arn"),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
+func testAccCheckAwsEbsDefaultKmsKeyDestroy(s *terraform.State) error {
+	arn, err := testAccAwsEbsDefaultKmsKeyAwsManagedDefaultKey()
+	if err != nil {
+		return err
+	}
+
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
+
+	resp, err := conn.GetEbsDefaultKmsKeyId(&ec2.GetEbsDefaultKmsKeyIdInput{})
+	if err != nil {
+		return err
+	}
+
+	// Verify that the default key is now the account's AWS-managed default CMK.
+	if aws.StringValue(resp.KmsKeyId) != arn.String() {
+		return fmt.Errorf("Default CMK (%s) is not the account's AWS-managed default CMK (%s)", aws.StringValue(resp.KmsKeyId), arn.String())
+	}
+
+	return nil
+}
+
+func testAccCheckEbsDefaultKmsKey(name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[name]
+		if !ok {
+			return fmt.Errorf("Not found: %s", name)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		arn, err := testAccAwsEbsDefaultKmsKeyAwsManagedDefaultKey()
+		if err != nil {
+			return err
+		}
+
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
+
+		resp, err := conn.GetEbsDefaultKmsKeyId(&ec2.GetEbsDefaultKmsKeyIdInput{})
+		if err != nil {
+			return err
+		}
+
+		// Verify that the default key is not the account's AWS-managed default CMK.
+		if aws.StringValue(resp.KmsKeyId) == arn.String() {
+			return fmt.Errorf("Default CMK (%s) is the account's AWS-managed default CMK (%s)", aws.StringValue(resp.KmsKeyId), arn.String())
+		}
+
+		return nil
+	}
+}
+
+// testAccAwsEbsDefaultKmsKeyAwsManagedDefaultKey returns' the account's AWS-managed default CMK.
+func testAccAwsEbsDefaultKmsKeyAwsManagedDefaultKey() (*arn.ARN, error) {
+	conn := testAccProvider.Meta().(*AWSClient).kmsconn
+
+	alias, err := findKmsAliasByName(conn, "alias/aws/ebs", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	aliasARN, err := arn.Parse(aws.StringValue(alias.AliasArn))
+	if err != nil {
+		return nil, err
+	}
+
+	arn := arn.ARN{
+		Partition: aliasARN.Partition,
+		Service:   aliasARN.Service,
+		Region:    aliasARN.Region,
+		AccountID: aliasARN.AccountID,
+		Resource:  fmt.Sprintf("key/%s", aws.StringValue(alias.TargetKeyId)),
+	}
+
+	return &arn, nil
+}
+
+const testAccAwsEbsDefaultKmsKeyConfig_basic = `
+resource "aws_kms_key" "test" {}
+
+resource "aws_ebs_default_kms_key" "test" {
+  key_arn = "${aws_kms_key.test.arn}"
+}
+`

aws/resource_aws_ebs_encryption_by_default.go

@@ -0,0 +1,88 @@
+package aws
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAwsEbsEncryptionByDefault() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsEbsEncryptionByDefaultCreate,
+		Read:   resourceAwsEbsEncryptionByDefaultRead,
+		Update: resourceAwsEbsEncryptionByDefaultUpdate,
+		Delete: resourceAwsEbsEncryptionByDefaultDelete,
+
+		Schema: map[string]*schema.Schema{
+			"enabled": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				Default:  true,
+			},
+		},
+	}
+}
+
+func resourceAwsEbsEncryptionByDefaultCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	enabled := d.Get("enabled").(bool)
+	if err := setEbsEncryptionByDefault(conn, enabled); err != nil {
+		return fmt.Errorf("error creating EBS encryption by default (%t): %s", enabled, err)
+	}
+
+	d.SetId(resource.UniqueId())
+
+	return resourceAwsEbsEncryptionByDefaultRead(d, meta)
+}
+
+func resourceAwsEbsEncryptionByDefaultRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	resp, err := conn.GetEbsEncryptionByDefault(&ec2.GetEbsEncryptionByDefaultInput{})
+	if err != nil {
+		return fmt.Errorf("error reading EBS encryption by default: %s", err)
+	}
+
+	d.Set("enabled", aws.BoolValue(resp.EbsEncryptionByDefault))
+
+	return nil
+}
+
+func resourceAwsEbsEncryptionByDefaultUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	enabled := d.Get("enabled").(bool)
+	if err := setEbsEncryptionByDefault(conn, enabled); err != nil {
+		return fmt.Errorf("error updating EBS encryption by default (%t): %s", enabled, err)
+	}
+
+	return resourceAwsEbsEncryptionByDefaultRead(d, meta)
+}
+
+func resourceAwsEbsEncryptionByDefaultDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	// Removing the resource disables default encryption.
+	if err := setEbsEncryptionByDefault(conn, false); err != nil {
+		return fmt.Errorf("error disabling EBS encryption by default: %s", err)
+	}
+
+	return nil
+}
+
+func setEbsEncryptionByDefault(conn *ec2.EC2, enabled bool) error {
+	var err error
+
+	if enabled {
+		_, err = conn.EnableEbsEncryptionByDefault(&ec2.EnableEbsEncryptionByDefaultInput{})
+	} else {
+		_, err = conn.DisableEbsEncryptionByDefault(&ec2.DisableEbsEncryptionByDefaultInput{})
+	}
+
+	return err
+}

aws/resource_aws_ebs_encryption_by_default_test.go

@@ -0,0 +1,86 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSEBSEncryptionByDefault_basic(t *testing.T) {
+	resourceName := "aws_ebs_encryption_by_default.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsEncryptionByDefaultDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAwsEbsEncryptionByDefaultConfig(false),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsEncryptionByDefault(resourceName, false),
+					resource.TestCheckResourceAttr(resourceName, "enabled", "false"),
+				),
+			},
+			{
+				Config: testAccAwsEbsEncryptionByDefaultConfig(true),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEbsEncryptionByDefault(resourceName, true),
+					resource.TestCheckResourceAttr(resourceName, "enabled", "true"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckAwsEncryptionByDefaultDestroy(s *terraform.State) error {
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
+
+	response, err := conn.GetEbsEncryptionByDefault(&ec2.GetEbsEncryptionByDefaultInput{})
+	if err != nil {
+		return err
+	}
+
+	if aws.BoolValue(response.EbsEncryptionByDefault) != false {
+		return fmt.Errorf("EBS encryption by default not disabled on resource removal")
+	}
+
+	return nil
+}
+
+func testAccCheckEbsEncryptionByDefault(n string, enabled bool) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
+
+		response, err := conn.GetEbsEncryptionByDefault(&ec2.GetEbsEncryptionByDefaultInput{})
+		if err != nil {
+			return err
+		}
+
+		if aws.BoolValue(response.EbsEncryptionByDefault) != enabled {
+			return fmt.Errorf("EBS encryption by default is not in expected state (%t)", enabled)
+		}
+
+		return nil
+	}
+}
+
+func testAccAwsEbsEncryptionByDefaultConfig(enabled bool) string {
+	return fmt.Sprintf(`
+resource "aws_ebs_encryption_by_default" "test" {
+  enabled = %[1]t
+}
+`, enabled)
+}

website/aws.erb

@@ -1135,6 +1135,14 @@
                             <a href="/docs/providers/aws/r/ami_launch_permission.html">aws_ami_launch_permission</a>
                         </li>
 
+                        <li>
+                          <a href="/docs/providers/aws/r/ebs_default_kms_key.html">aws_ebs_default_kms_key</a>
+                        </li>
+
+                        <li>
+                          <a href="/docs/providers/aws/r/ebs_encryption_by_default.html">aws_ebs_encryption_by_default</a>
+                        </li>
+
                         <li>
                           <a href="/docs/providers/aws/r/ebs_snapshot.html">aws_ebs_snapshot</a>
                         </li>