chef 12.7.2-universal-mingw32 → 12.8.1-universal-mingw32

data/spec/unit/dsl/resources_spec.rb

@@ -1,85 +1,85 @@
-#
-# Author:: Noah Kantrowitz (<noah@coderanger.net>)
-# Copyright:: Copyright 2015-2016, Noah Kantrowitz
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/dsl/resources"
-
-describe Chef::DSL::Resources do
-  let(:declared_resources) { [] }
-  let(:test_class) do
-    r = declared_resources
-    Class.new do
-      include Chef::DSL::Resources
-      define_method(:declare_resource) do |dsl_name, name, _created_at, &_block|
-        r << [dsl_name, name]
-      end
-    end
-  end
-  subject { declared_resources }
-  after do
-    # Always clean up after ourselves.
-    described_class.remove_resource_dsl(:test_resource)
-  end
-
-  context "with a resource added" do
-    before do
-      Chef::DSL::Resources.add_resource_dsl(:test_resource)
-      test_class.new.instance_eval do
-        test_resource "test_name" do
-        end
-      end
-    end
-    it { is_expected.to eq [[:test_resource, "test_name"]] }
-  end
-
-  context "with no resource added" do
-    subject do
-      test_class.new.instance_eval do
-        test_resource "test_name" do
-        end
-      end
-    end
-
-    it { expect { subject }.to raise_error NoMethodError }
-  end
-
-  context "with a resource added and removed" do
-    before do
-      Chef::DSL::Resources.add_resource_dsl(:test_resource)
-      Chef::DSL::Resources.remove_resource_dsl(:test_resource)
-    end
-    subject do
-      test_class.new.instance_eval do
-        test_resource "test_name" do
-        end
-      end
-    end
-
-    it { expect { subject }.to raise_error NoMethodError }
-  end
-
-  context "with a nameless resource" do
-    before do
-      Chef::DSL::Resources.add_resource_dsl(:test_resource)
-      test_class.new.instance_eval do
-        test_resource {}
-      end
-    end
-    it { is_expected.to eq [[:test_resource, nil]] }
-  end
-end
+#
+# Author:: Noah Kantrowitz (<noah@coderanger.net>)
+# Copyright:: Copyright 2015-2016, Noah Kantrowitz
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/dsl/resources"
+
+describe Chef::DSL::Resources do
+  let(:declared_resources) { [] }
+  let(:test_class) do
+    r = declared_resources
+    Class.new do
+      include Chef::DSL::Resources
+      define_method(:declare_resource) do |dsl_name, name, _created_at|
+        r << [dsl_name, name]
+      end
+    end
+  end
+  subject { declared_resources }
+  after do
+    # Always clean up after ourselves.
+    described_class.remove_resource_dsl(:test_resource)
+  end
+
+  context "with a resource added" do
+    before do
+      Chef::DSL::Resources.add_resource_dsl(:test_resource)
+      test_class.new.instance_eval do
+        test_resource "test_name" do
+        end
+      end
+    end
+    it { is_expected.to eq [[:test_resource, "test_name"]] }
+  end
+
+  context "with no resource added" do
+    subject do
+      test_class.new.instance_eval do
+        test_resource "test_name" do
+        end
+      end
+    end
+
+    it { expect { subject }.to raise_error NoMethodError }
+  end
+
+  context "with a resource added and removed" do
+    before do
+      Chef::DSL::Resources.add_resource_dsl(:test_resource)
+      Chef::DSL::Resources.remove_resource_dsl(:test_resource)
+    end
+    subject do
+      test_class.new.instance_eval do
+        test_resource "test_name" do
+        end
+      end
+    end
+
+    it { expect { subject }.to raise_error NoMethodError }
+  end
+
+  context "with a nameless resource" do
+    before do
+      Chef::DSL::Resources.add_resource_dsl(:test_resource)
+      test_class.new.instance_eval do
+        test_resource {}
+      end
+    end
+    it { is_expected.to eq [[:test_resource, nil]] }
+  end
+end

data/spec/unit/encrypted_data_bag_item/check_encrypted_spec.rb

@@ -1,95 +1,95 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/encrypted_data_bag_item/check_encrypted"
-
-class CheckEncryptedTester
-  include Chef::EncryptedDataBagItem::CheckEncrypted
-end
-
-describe Chef::EncryptedDataBagItem::CheckEncrypted do
-
-  let(:tester) { CheckEncryptedTester.new }
-
-  it "detects the item is not encrypted when the data is empty" do
-    expect(tester.encrypted?({})).to eq(false)
-  end
-
-  it "detects the item is not encrypted when the data only contains an id" do
-    expect(tester.encrypted?({ id: "foo" })).to eq(false)
-  end
-
-  context "when the item is encrypted" do
-
-    let(:default_secret) { "abc123SECRET" }
-    let(:item_name) { "item_name" }
-    let(:raw_data) {{
-        "id" => item_name,
-        "greeting" => "hello",
-        "nested" => {
-            "a1" => [1, 2, 3],
-            "a2" => { "b1" => true },
-        },
-    }}
-
-    let(:version) { 1 }
-    let(:encoded_data) do
-      Chef::Config[:data_bag_encrypt_version] = version
-      Chef::EncryptedDataBagItem.encrypt_data_bag_item(raw_data, default_secret)
-    end
-
-    it "does not detect encryption when the item version is unknown" do
-      # It shouldn't be possible for someone to normally encrypt an item with an unknown version - they would have to
-      # do something funky like encrypting it and then manually changing the version
-      modified_encoded_data = encoded_data
-      modified_encoded_data["greeting"]["version"] = 4
-      expect(tester.encrypted?(modified_encoded_data)).to eq(false)
-    end
-
-    shared_examples_for "encryption detected" do
-      it "detects encrypted data bag" do
-        expect( encryptor ).to receive(:encryptor_keys).at_least(:once).and_call_original
-        expect(tester.encrypted?(encoded_data)).to eq(true)
-      end
-    end
-
-    context "when encryption version is 1" do
-      include_examples "encryption detected" do
-        let(:version) { 1 }
-        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor }
-      end
-    end
-
-    context "when encryption version is 2" do
-      include_examples "encryption detected" do
-        let(:version) { 2 }
-        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor }
-      end
-    end
-
-    context "when encryption version is 3", :aes_256_gcm_only, :ruby_20_only do
-      include_examples "encryption detected" do
-        let(:version) { 3 }
-        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor }
-      end
-    end
-
-  end
-
-end
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/encrypted_data_bag_item/check_encrypted"
+
+class CheckEncryptedTester
+  include Chef::EncryptedDataBagItem::CheckEncrypted
+end
+
+describe Chef::EncryptedDataBagItem::CheckEncrypted do
+
+  let(:tester) { CheckEncryptedTester.new }
+
+  it "detects the item is not encrypted when the data is empty" do
+    expect(tester.encrypted?({})).to eq(false)
+  end
+
+  it "detects the item is not encrypted when the data only contains an id" do
+    expect(tester.encrypted?({ id: "foo" })).to eq(false)
+  end
+
+  context "when the item is encrypted" do
+
+    let(:default_secret) { "abc123SECRET" }
+    let(:item_name) { "item_name" }
+    let(:raw_data) {{
+        "id" => item_name,
+        "greeting" => "hello",
+        "nested" => {
+            "a1" => [1, 2, 3],
+            "a2" => { "b1" => true },
+        },
+    }}
+
+    let(:version) { 1 }
+    let(:encoded_data) do
+      Chef::Config[:data_bag_encrypt_version] = version
+      Chef::EncryptedDataBagItem.encrypt_data_bag_item(raw_data, default_secret)
+    end
+
+    it "does not detect encryption when the item version is unknown" do
+      # It shouldn't be possible for someone to normally encrypt an item with an unknown version - they would have to
+      # do something funky like encrypting it and then manually changing the version
+      modified_encoded_data = encoded_data
+      modified_encoded_data["greeting"]["version"] = 4
+      expect(tester.encrypted?(modified_encoded_data)).to eq(false)
+    end
+
+    shared_examples_for "encryption detected" do
+      it "detects encrypted data bag" do
+        expect( encryptor ).to receive(:encryptor_keys).at_least(:once).and_call_original
+        expect(tester.encrypted?(encoded_data)).to eq(true)
+      end
+    end
+
+    context "when encryption version is 1" do
+      include_examples "encryption detected" do
+        let(:version) { 1 }
+        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor }
+      end
+    end
+
+    context "when encryption version is 2" do
+      include_examples "encryption detected" do
+        let(:version) { 2 }
+        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor }
+      end
+    end
+
+    context "when encryption version is 3", :aes_256_gcm_only, ruby: "~> 2.0.0" do
+      include_examples "encryption detected" do
+        let(:version) { 3 }
+        let(:encryptor) { Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor }
+      end
+    end
+
+  end
+
+end

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -1,437 +1,437 @@
-#
-# Author:: Seth Falcon (<seth@chef.io>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/encrypted_data_bag_item"
-
-module Version0Encryptor
-  def self.encrypt_value(plaintext_data, key)
-    data = plaintext_data.to_yaml
-
-    cipher = OpenSSL::Cipher.new("aes-256-cbc")
-    cipher.encrypt
-    cipher.pkcs5_keyivgen(key)
-    encrypted_bytes = cipher.update(data)
-    encrypted_bytes << cipher.final
-    Base64.encode64(encrypted_bytes)
-  end
-end
-
-describe Chef::EncryptedDataBagItem::Encryptor do
-
-  subject(:encryptor) { described_class.new(plaintext_data, key) }
-  let(:plaintext_data) { { "foo" => "bar" } }
-  let(:key) { "passwd" }
-
-  it "encrypts to format version 1 by default" do
-    expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor)
-  end
-
-  describe "generating a random IV" do
-    it "generates a new IV for each encryption pass" do
-      encryptor2 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
-
-      # No API in ruby OpenSSL to get the iv is used for the encryption back
-      # out. Instead we test if the encrypted data is the same. If it *is* the
-      # same, we assume the IV was the same each time.
-      expect(encryptor.encrypted_data).not_to eq encryptor2.encrypted_data
-    end
-  end
-
-  describe "when encrypting a non-hash non-array value" do
-    let(:plaintext_data) { 5 }
-    it "serializes the value in a de-serializable way" do
-      expect(Chef::JSONCompat.from_json(encryptor.serialized_data)["json_wrapper"]).to eq 5
-    end
-
-  end
-
-  describe "wrapping secret values in an envelope" do
-    it "wraps the encrypted data in an envelope with the iv and version" do
-      final_data = encryptor.for_encrypted_item
-      expect(final_data["encrypted_data"]).to eq encryptor.encrypted_data
-      expect(final_data["iv"]).to eq Base64.encode64(encryptor.iv)
-      expect(final_data["version"]).to eq 1
-      expect(final_data["cipher"]).to eq "aes-256-cbc"
-    end
-  end
-
-  describe "when using version 2 format" do
-
-    before do
-      Chef::Config[:data_bag_encrypt_version] = 2
-    end
-
-    it "creates a version 2 encryptor" do
-      expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor)
-    end
-
-    it "generates an hmac based on ciphertext with different iv" do
-      encryptor2 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
-      expect(encryptor.hmac).not_to eq(encryptor2.hmac)
-    end
-
-    it "includes the hmac in the envelope" do
-      final_data = encryptor.for_encrypted_item
-      expect(final_data["hmac"]).to eq(encryptor.hmac)
-    end
-  end
-
-  describe "when using version 3 format" do
-    before do
-      Chef::Config[:data_bag_encrypt_version] = 3
-    end
-
-    context "on supported platforms", :aes_256_gcm_only, :ruby_20_only do
-
-      it "creates a version 3 encryptor" do
-        expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor)
-      end
-
-      it "generates different authentication tags" do
-        encryptor3 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
-        encryptor.for_encrypted_item # required to generate the auth_tag
-        encryptor3.for_encrypted_item
-        expect(encryptor.auth_tag).not_to eq(encryptor3.auth_tag)
-      end
-
-      it "includes the auth_tag in the envelope" do
-        final_data = encryptor.for_encrypted_item
-        expect(final_data["auth_tag"]).to eq(Base64::encode64(encryptor.auth_tag))
-      end
-
-      it "throws an error if auth tag is read before encrypting the data" do
-        expect { encryptor.auth_tag }.to raise_error(Chef::EncryptedDataBagItem::EncryptionFailure)
-      end
-
-    end # context on supported platforms
-
-    context "on unsupported platforms" do
-      let(:aead_algorithm) { Chef::EncryptedDataBagItem::AEAD_ALGORITHM }
-
-      it "throws an error warning about the OpenSSL version if it has no GCM support" do
-        # Force Ruby with AEAD support
-        allow(OpenSSL::Cipher).to receive(:method_defined?).with(:auth_data=).and_return(true)
-        # OpenSSL without AEAD support
-        expect(OpenSSL::Cipher).to receive(:ciphers).and_return([])
-        expect { encryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
-      end
-
-      context "on platforms with old OpenSSL", :openssl_lt_101 do
-
-        it "throws an error warning about the OpenSSL version" do
-          expect { encryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
-        end
-
-      end # context on platforms with old OpenSSL
-
-    end # context on unsupported platforms
-
-  end # when using version 3 format
-
-end
-
-describe Chef::EncryptedDataBagItem::Decryptor do
-
-  subject(:decryptor) { described_class.for(encrypted_value, decryption_key) }
-  let(:plaintext_data) { { "foo" => "bar" } }
-  let(:encryption_key) { "passwd" }
-  let(:decryption_key) { encryption_key }
-  let(:json_wrapped_data) { Chef::JSONCompat.to_json({ "json_wrapper" => plaintext_data }) }
-
-  shared_examples "decryption examples" do
-    it "decrypts the encrypted value" do
-      expect(decryptor.decrypted_data).to eq(json_wrapped_data)
-    end
-
-    it "unwraps the encrypted data and returns it" do
-      expect(decryptor.for_decrypted_item).to eq plaintext_data
-    end
-  end
-
-  context "when decrypting a version 3 (JSON+aes-256-gcm+random iv+auth tag) encrypted value" do
-
-    context "on supported platforms", :aes_256_gcm_only, :ruby_20_only do
-
-      let(:encrypted_value) do
-        Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
-      end
-
-      let(:bogus_auth_tag) { "bogus_auth_tag" }
-
-      include_examples "decryption examples"
-
-      it "rejects the data if the authentication tag is wrong" do
-        encrypted_value["auth_tag"] = bogus_auth_tag
-        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
-      end
-
-      it "rejects the data if the authentication tag is missing" do
-        encrypted_value.delete("auth_tag")
-        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
-      end
-
-    end # context on supported platforms
-
-    context "on unsupported platforms" do
-      let(:encrypted_value) do
-        {
-          "encrypted_data" => "",
-          "iv" => "",
-          "version" => 3,
-          "cipher" => "aes-256-cbc",
-        }
-      end
-
-      context "on platforms with old OpenSSL", :openssl_lt_101 do
-
-        it "throws an error warning about the OpenSSL version" do
-          expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
-        end
-
-      end # context on unsupported platforms
-
-    end # context on platforms with old OpenSSL
-
-  end # context when decrypting a version 3
-
-  context "when decrypting a version 2 (JSON+aes-256-cbc+hmac-sha256+random iv) encrypted value" do
-    let(:encrypted_value) do
-      Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
-    end
-
-    let(:bogus_hmac) do
-      digest = OpenSSL::Digest.new("sha256")
-      raw_hmac = OpenSSL::HMAC.digest(digest, "WRONG", encrypted_value["encrypted_data"])
-      Base64.encode64(raw_hmac)
-    end
-
-    include_examples "decryption examples"
-
-    it "rejects the data if the hmac is wrong" do
-      encrypted_value["hmac"] = bogus_hmac
-      expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
-    end
-
-    it "rejects the data if the hmac is missing" do
-      encrypted_value.delete("hmac")
-      expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
-    end
-
-  end
-
-  context "when decrypting a version 1 (JSON+aes-256-cbc+random iv) encrypted value" do
-
-    let(:encrypted_value) do
-      Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
-    end
-
-    it "selects the correct strategy for version 1" do
-      expect(decryptor).to be_a_instance_of Chef::EncryptedDataBagItem::Decryptor::Version1Decryptor
-    end
-
-    include_examples "decryption examples"
-
-    describe "and the decryption step returns invalid data" do
-      it "raises a decryption failure error" do
-        # Over a large number of tests on a variety of systems, we occasionally
-        # see the decryption step "succeed" but return invalid data (e.g., not
-        # the original plain text) [CHEF-3858]
-        expect(decryptor).to receive(:decrypted_data).and_return("lksajdf")
-        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
-      end
-    end
-
-    context "and the provided key is incorrect" do
-      let(:decryption_key) { "wrong-passwd" }
-
-      it "raises a sensible error" do
-        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
-      end
-    end
-
-    context "and the cipher is not supported" do
-      let(:encrypted_value) do
-        ev = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
-        ev["cipher"] = "aes-256-foo"
-        ev
-      end
-
-      it "raises a sensible error" do
-        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::UnsupportedCipher)
-      end
-    end
-
-    context "and version 2 format is required" do
-      before do
-        Chef::Config[:data_bag_decrypt_minimum_version] = 2
-      end
-
-      it "raises an error attempting to decrypt" do
-        expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
-      end
-
-    end
-
-  end
-
-  context "when decrypting a version 0 (YAML+aes-256-cbc+no iv) encrypted value", :not_supported_under_fips do
-    let(:encrypted_value) do
-      Version0Encryptor.encrypt_value(plaintext_data, encryption_key)
-    end
-
-    it "selects the correct strategy for version 0" do
-      expect(decryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Decryptor::Version0Decryptor)
-    end
-
-    it "decrypts the encrypted value" do
-      expect(decryptor.for_decrypted_item).to eq plaintext_data
-    end
-
-    context "and version 1 format is required" do
-      before do
-        Chef::Config[:data_bag_decrypt_minimum_version] = 1
-      end
-
-      it "raises an error attempting to decrypt" do
-        expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
-      end
-
-    end
-
-  end
-end
-
-describe Chef::EncryptedDataBagItem do
-  subject { described_class }
-  let(:encrypted_data_bag_item) { subject.new(encoded_data, secret) }
-  let(:plaintext_data) {{
-      "id" => "item_name",
-      "greeting" => "hello",
-      "nested" => { "a1" => [1, 2, 3], "a2" => { "b1" => true } },
-  }}
-  let(:secret) { "abc123SECRET" }
-  let(:encoded_data) { subject.encrypt_data_bag_item(plaintext_data, secret) }
-
-  describe "encrypting" do
-
-    it "doesn't encrypt the 'id' key" do
-      expect(encoded_data["id"]).to eq "item_name"
-    end
-
-    it "encrypts non-collection objects" do
-      expect(encoded_data["greeting"]["version"]).to eq 1
-      expect(encoded_data["greeting"]).to have_key("iv")
-
-      iv = encoded_data["greeting"]["iv"]
-      encryptor = Chef::EncryptedDataBagItem::Encryptor.new("hello", secret, iv)
-
-      expect(encoded_data["greeting"]["encrypted_data"]).to eq(encryptor.for_encrypted_item["encrypted_data"])
-    end
-
-    it "encrypts nested values" do
-      expect(encoded_data["nested"]["version"]).to eq 1
-      expect(encoded_data["nested"]).to have_key("iv")
-
-      iv = encoded_data["nested"]["iv"]
-      encryptor = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data["nested"], secret, iv)
-
-      expect(encoded_data["nested"]["encrypted_data"]).to eq(encryptor.for_encrypted_item["encrypted_data"])
-    end
-
-  end
-
-  describe "decrypting" do
-
-    it "doesn't try to decrypt 'id'" do
-      expect(encrypted_data_bag_item["id"]).to eq(plaintext_data["id"])
-    end
-
-    it "decrypts 'greeting'" do
-      expect(encrypted_data_bag_item["greeting"]).to eq(plaintext_data["greeting"])
-    end
-
-    it "decrypts 'nested'" do
-      expect(encrypted_data_bag_item["nested"]).to eq(plaintext_data["nested"])
-    end
-
-    it "decrypts everyting via to_hash" do
-      expect(encrypted_data_bag_item.to_hash).to eq(plaintext_data)
-    end
-
-    it "handles missing keys gracefully" do
-      expect(encrypted_data_bag_item["no-such-key"]).to be_nil
-    end
-  end
-
-  describe "loading" do
-    it "should defer to Chef::DataBagItem.load" do
-      allow(Chef::DataBagItem).to receive(:load).with(:the_bag, "my_codes").and_return(encoded_data)
-      edbi = Chef::EncryptedDataBagItem.load(:the_bag, "my_codes", secret)
-      expect(edbi["greeting"]).to eq(plaintext_data["greeting"])
-    end
-  end
-
-  describe ".load_secret" do
-    let(:secret) { "opensesame" }
-
-    context "when /var/mysecret exists" do
-      before do
-        allow(::File).to receive(:exist?).with("/var/mysecret").and_return(true)
-        allow(IO).to receive(:read).with("/var/mysecret").and_return(secret)
-      end
-
-      it "load_secret('/var/mysecret') reads the secret" do
-        expect(Chef::EncryptedDataBagItem.load_secret("/var/mysecret")).to eq secret
-      end
-    end
-
-    context "when /etc/chef/encrypted_data_bag_secret exists" do
-      before do
-        path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
-        allow(::File).to receive(:exist?).with(path).and_return(true)
-        allow(IO).to receive(:read).with(path).and_return(secret)
-      end
-
-      it "load_secret(nil) reads the secret" do
-        expect(Chef::EncryptedDataBagItem.load_secret(nil)).to eq secret
-      end
-    end
-
-    context "when /etc/chef/encrypted_data_bag_secret does not exist" do
-      before do
-        path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
-        allow(::File).to receive(:exist?).with(path).and_return(false)
-      end
-
-      it "load_secret(nil) emits a reasonable error message" do
-        expect { Chef::EncryptedDataBagItem.load_secret(nil) }.to raise_error(ArgumentError, /No secret specified and no secret found at #{Chef::Config[:encrypted_data_bag_secret]}/)
-      end
-    end
-
-    context "path argument is a URL" do
-      before do
-        allow(Kernel).to receive(:open).with("http://www.opscode.com/").and_return(StringIO.new(secret))
-      end
-
-      it "reads from the URL" do
-        expect(Chef::EncryptedDataBagItem.load_secret("http://www.opscode.com/")).to eq secret
-      end
-    end
-  end
-end
+#
+# Author:: Seth Falcon (<seth@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/encrypted_data_bag_item"
+
+module Version0Encryptor
+  def self.encrypt_value(plaintext_data, key)
+    data = plaintext_data.to_yaml
+
+    cipher = OpenSSL::Cipher.new("aes-256-cbc")
+    cipher.encrypt
+    cipher.pkcs5_keyivgen(key)
+    encrypted_bytes = cipher.update(data)
+    encrypted_bytes << cipher.final
+    Base64.encode64(encrypted_bytes)
+  end
+end
+
+describe Chef::EncryptedDataBagItem::Encryptor do
+
+  subject(:encryptor) { described_class.new(plaintext_data, key) }
+  let(:plaintext_data) { { "foo" => "bar" } }
+  let(:key) { "passwd" }
+
+  it "encrypts to format version 1 by default" do
+    expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor)
+  end
+
+  describe "generating a random IV" do
+    it "generates a new IV for each encryption pass" do
+      encryptor2 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
+
+      # No API in ruby OpenSSL to get the iv is used for the encryption back
+      # out. Instead we test if the encrypted data is the same. If it *is* the
+      # same, we assume the IV was the same each time.
+      expect(encryptor.encrypted_data).not_to eq encryptor2.encrypted_data
+    end
+  end
+
+  describe "when encrypting a non-hash non-array value" do
+    let(:plaintext_data) { 5 }
+    it "serializes the value in a de-serializable way" do
+      expect(Chef::JSONCompat.from_json(encryptor.serialized_data)["json_wrapper"]).to eq 5
+    end
+
+  end
+
+  describe "wrapping secret values in an envelope" do
+    it "wraps the encrypted data in an envelope with the iv and version" do
+      final_data = encryptor.for_encrypted_item
+      expect(final_data["encrypted_data"]).to eq encryptor.encrypted_data
+      expect(final_data["iv"]).to eq Base64.encode64(encryptor.iv)
+      expect(final_data["version"]).to eq 1
+      expect(final_data["cipher"]).to eq "aes-256-cbc"
+    end
+  end
+
+  describe "when using version 2 format" do
+
+    before do
+      Chef::Config[:data_bag_encrypt_version] = 2
+    end
+
+    it "creates a version 2 encryptor" do
+      expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor)
+    end
+
+    it "generates an hmac based on ciphertext with different iv" do
+      encryptor2 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
+      expect(encryptor.hmac).not_to eq(encryptor2.hmac)
+    end
+
+    it "includes the hmac in the envelope" do
+      final_data = encryptor.for_encrypted_item
+      expect(final_data["hmac"]).to eq(encryptor.hmac)
+    end
+  end
+
+  describe "when using version 3 format" do
+    before do
+      Chef::Config[:data_bag_encrypt_version] = 3
+    end
+
+    context "on supported platforms", :aes_256_gcm_only, ruby: "~> 2.0.0" do
+
+      it "creates a version 3 encryptor" do
+        expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor)
+      end
+
+      it "generates different authentication tags" do
+        encryptor3 = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, key)
+        encryptor.for_encrypted_item # required to generate the auth_tag
+        encryptor3.for_encrypted_item
+        expect(encryptor.auth_tag).not_to eq(encryptor3.auth_tag)
+      end
+
+      it "includes the auth_tag in the envelope" do
+        final_data = encryptor.for_encrypted_item
+        expect(final_data["auth_tag"]).to eq(Base64.encode64(encryptor.auth_tag))
+      end
+
+      it "throws an error if auth tag is read before encrypting the data" do
+        expect { encryptor.auth_tag }.to raise_error(Chef::EncryptedDataBagItem::EncryptionFailure)
+      end
+
+    end # context on supported platforms
+
+    context "on unsupported platforms" do
+      let(:aead_algorithm) { Chef::EncryptedDataBagItem::AEAD_ALGORITHM }
+
+      it "throws an error warning about the OpenSSL version if it has no GCM support" do
+        # Force Ruby with AEAD support
+        allow(OpenSSL::Cipher).to receive(:method_defined?).with(:auth_data=).and_return(true)
+        # OpenSSL without AEAD support
+        expect(OpenSSL::Cipher).to receive(:ciphers).and_return([])
+        expect { encryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
+      end
+
+      context "on platforms with old OpenSSL", :openssl_lt_101 do
+
+        it "throws an error warning about the OpenSSL version" do
+          expect { encryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
+        end
+
+      end # context on platforms with old OpenSSL
+
+    end # context on unsupported platforms
+
+  end # when using version 3 format
+
+end
+
+describe Chef::EncryptedDataBagItem::Decryptor do
+
+  subject(:decryptor) { described_class.for(encrypted_value, decryption_key) }
+  let(:plaintext_data) { { "foo" => "bar" } }
+  let(:encryption_key) { "passwd" }
+  let(:decryption_key) { encryption_key }
+  let(:json_wrapped_data) { Chef::JSONCompat.to_json({ "json_wrapper" => plaintext_data }) }
+
+  shared_examples "decryption examples" do
+    it "decrypts the encrypted value" do
+      expect(decryptor.decrypted_data).to eq(json_wrapped_data)
+    end
+
+    it "unwraps the encrypted data and returns it" do
+      expect(decryptor.for_decrypted_item).to eq plaintext_data
+    end
+  end
+
+  context "when decrypting a version 3 (JSON+aes-256-gcm+random iv+auth tag) encrypted value" do
+
+    context "on supported platforms", :aes_256_gcm_only, ruby: "~> 2.0.0" do
+
+      let(:encrypted_value) do
+        Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
+      end
+
+      let(:bogus_auth_tag) { "bogus_auth_tag" }
+
+      include_examples "decryption examples"
+
+      it "rejects the data if the authentication tag is wrong" do
+        encrypted_value["auth_tag"] = bogus_auth_tag
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+      end
+
+      it "rejects the data if the authentication tag is missing" do
+        encrypted_value.delete("auth_tag")
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+      end
+
+    end # context on supported platforms
+
+    context "on unsupported platforms" do
+      let(:encrypted_value) do
+        {
+          "encrypted_data" => "",
+          "iv" => "",
+          "version" => 3,
+          "cipher" => "aes-256-cbc",
+        }
+      end
+
+      context "on platforms with old OpenSSL", :openssl_lt_101 do
+
+        it "throws an error warning about the OpenSSL version" do
+          expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::EncryptedDataBagRequirementsFailure, /requires an OpenSSL/)
+        end
+
+      end # context on unsupported platforms
+
+    end # context on platforms with old OpenSSL
+
+  end # context when decrypting a version 3
+
+  context "when decrypting a version 2 (JSON+aes-256-cbc+hmac-sha256+random iv) encrypted value" do
+    let(:encrypted_value) do
+      Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
+    end
+
+    let(:bogus_hmac) do
+      digest = OpenSSL::Digest.new("sha256")
+      raw_hmac = OpenSSL::HMAC.digest(digest, "WRONG", encrypted_value["encrypted_data"])
+      Base64.encode64(raw_hmac)
+    end
+
+    include_examples "decryption examples"
+
+    it "rejects the data if the hmac is wrong" do
+      encrypted_value["hmac"] = bogus_hmac
+      expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+    end
+
+    it "rejects the data if the hmac is missing" do
+      encrypted_value.delete("hmac")
+      expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+    end
+
+  end
+
+  context "when decrypting a version 1 (JSON+aes-256-cbc+random iv) encrypted value" do
+
+    let(:encrypted_value) do
+      Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
+    end
+
+    it "selects the correct strategy for version 1" do
+      expect(decryptor).to be_a_instance_of Chef::EncryptedDataBagItem::Decryptor::Version1Decryptor
+    end
+
+    include_examples "decryption examples"
+
+    describe "and the decryption step returns invalid data" do
+      it "raises a decryption failure error" do
+        # Over a large number of tests on a variety of systems, we occasionally
+        # see the decryption step "succeed" but return invalid data (e.g., not
+        # the original plain text) [CHEF-3858]
+        expect(decryptor).to receive(:decrypted_data).and_return("lksajdf")
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+      end
+    end
+
+    context "and the provided key is incorrect" do
+      let(:decryption_key) { "wrong-passwd" }
+
+      it "raises a sensible error" do
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::DecryptionFailure)
+      end
+    end
+
+    context "and the cipher is not supported" do
+      let(:encrypted_value) do
+        ev = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
+        ev["cipher"] = "aes-256-foo"
+        ev
+      end
+
+      it "raises a sensible error" do
+        expect { decryptor.for_decrypted_item }.to raise_error(Chef::EncryptedDataBagItem::UnsupportedCipher)
+      end
+    end
+
+    context "and version 2 format is required" do
+      before do
+        Chef::Config[:data_bag_decrypt_minimum_version] = 2
+      end
+
+      it "raises an error attempting to decrypt" do
+        expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
+      end
+
+    end
+
+  end
+
+  context "when decrypting a version 0 (YAML+aes-256-cbc+no iv) encrypted value", :not_supported_under_fips do
+    let(:encrypted_value) do
+      Version0Encryptor.encrypt_value(plaintext_data, encryption_key)
+    end
+
+    it "selects the correct strategy for version 0" do
+      expect(decryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Decryptor::Version0Decryptor)
+    end
+
+    it "decrypts the encrypted value" do
+      expect(decryptor.for_decrypted_item).to eq plaintext_data
+    end
+
+    context "and version 1 format is required" do
+      before do
+        Chef::Config[:data_bag_decrypt_minimum_version] = 1
+      end
+
+      it "raises an error attempting to decrypt" do
+        expect { decryptor }.to raise_error(Chef::EncryptedDataBagItem::UnacceptableEncryptedDataBagItemFormat)
+      end
+
+    end
+
+  end
+end
+
+describe Chef::EncryptedDataBagItem do
+  subject { described_class }
+  let(:encrypted_data_bag_item) { subject.new(encoded_data, secret) }
+  let(:plaintext_data) {{
+      "id" => "item_name",
+      "greeting" => "hello",
+      "nested" => { "a1" => [1, 2, 3], "a2" => { "b1" => true } },
+  }}
+  let(:secret) { "abc123SECRET" }
+  let(:encoded_data) { subject.encrypt_data_bag_item(plaintext_data, secret) }
+
+  describe "encrypting" do
+
+    it "doesn't encrypt the 'id' key" do
+      expect(encoded_data["id"]).to eq "item_name"
+    end
+
+    it "encrypts non-collection objects" do
+      expect(encoded_data["greeting"]["version"]).to eq 1
+      expect(encoded_data["greeting"]).to have_key("iv")
+
+      iv = encoded_data["greeting"]["iv"]
+      encryptor = Chef::EncryptedDataBagItem::Encryptor.new("hello", secret, iv)
+
+      expect(encoded_data["greeting"]["encrypted_data"]).to eq(encryptor.for_encrypted_item["encrypted_data"])
+    end
+
+    it "encrypts nested values" do
+      expect(encoded_data["nested"]["version"]).to eq 1
+      expect(encoded_data["nested"]).to have_key("iv")
+
+      iv = encoded_data["nested"]["iv"]
+      encryptor = Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data["nested"], secret, iv)
+
+      expect(encoded_data["nested"]["encrypted_data"]).to eq(encryptor.for_encrypted_item["encrypted_data"])
+    end
+
+  end
+
+  describe "decrypting" do
+
+    it "doesn't try to decrypt 'id'" do
+      expect(encrypted_data_bag_item["id"]).to eq(plaintext_data["id"])
+    end
+
+    it "decrypts 'greeting'" do
+      expect(encrypted_data_bag_item["greeting"]).to eq(plaintext_data["greeting"])
+    end
+
+    it "decrypts 'nested'" do
+      expect(encrypted_data_bag_item["nested"]).to eq(plaintext_data["nested"])
+    end
+
+    it "decrypts everyting via to_hash" do
+      expect(encrypted_data_bag_item.to_hash).to eq(plaintext_data)
+    end
+
+    it "handles missing keys gracefully" do
+      expect(encrypted_data_bag_item["no-such-key"]).to be_nil
+    end
+  end
+
+  describe "loading" do
+    it "should defer to Chef::DataBagItem.load" do
+      allow(Chef::DataBagItem).to receive(:load).with(:the_bag, "my_codes").and_return(encoded_data)
+      edbi = Chef::EncryptedDataBagItem.load(:the_bag, "my_codes", secret)
+      expect(edbi["greeting"]).to eq(plaintext_data["greeting"])
+    end
+  end
+
+  describe ".load_secret" do
+    let(:secret) { "opensesame" }
+
+    context "when /var/mysecret exists" do
+      before do
+        allow(::File).to receive(:exist?).with("/var/mysecret").and_return(true)
+        allow(IO).to receive(:read).with("/var/mysecret").and_return(secret)
+      end
+
+      it "load_secret('/var/mysecret') reads the secret" do
+        expect(Chef::EncryptedDataBagItem.load_secret("/var/mysecret")).to eq secret
+      end
+    end
+
+    context "when /etc/chef/encrypted_data_bag_secret exists" do
+      before do
+        path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
+        allow(::File).to receive(:exist?).with(path).and_return(true)
+        allow(IO).to receive(:read).with(path).and_return(secret)
+      end
+
+      it "load_secret(nil) reads the secret" do
+        expect(Chef::EncryptedDataBagItem.load_secret(nil)).to eq secret
+      end
+    end
+
+    context "when /etc/chef/encrypted_data_bag_secret does not exist" do
+      before do
+        path = Chef::Config.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
+        allow(::File).to receive(:exist?).with(path).and_return(false)
+      end
+
+      it "load_secret(nil) emits a reasonable error message" do
+        expect { Chef::EncryptedDataBagItem.load_secret(nil) }.to raise_error(ArgumentError, /No secret specified and no secret found at #{Chef::Config[:encrypted_data_bag_secret]}/)
+      end
+    end
+
+    context "path argument is a URL" do
+      before do
+        allow(Kernel).to receive(:open).with("http://www.opscode.com/").and_return(StringIO.new(secret))
+      end
+
+      it "reads from the URL" do
+        expect(Chef::EncryptedDataBagItem.load_secret("http://www.opscode.com/")).to eq secret
+      end
+    end
+  end
+end