puppet 5.0.0 → 6.0.0

data/spec/lib/puppet_spec/compiler.rb

@@ -82,4 +82,31 @@ module PuppetSpec::Compiler
       end
     end
   end
+
+  # Compiles a catalog, and if source is given evaluates it and returns its result.
+  # The catalog is returned if no source is given.
+  # Topscope variables are set before compilation
+  # Uses a created node 'testnode' if none is given.
+  # (Parameters given by name)
+  #
+  def evaluate(code: 'undef', source: nil, node: Puppet::Node.new('testnode'), variables: {})
+    source_location = caller[0]
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    unless variables.empty?
+      scope = compiler.topscope
+      variables.each {|k,v| scope.setvar(k, v) }
+    end
+
+    if source.nil?
+      compiler.compile
+      # see lib/puppet/indirector/catalog/compiler.rb#filter
+      return compiler.filter { |r| r.virtual? }
+    end
+
+    # evaluate given source is the context of the compiled state and return its result
+    compiler.compile do |catalog |
+      Puppet::Pops::Parser::EvaluatingParser.singleton.evaluate_string(compiler.topscope, source, source_location)
+    end
+  end
 end

data/spec/lib/puppet_spec/files.rb

@@ -17,36 +17,31 @@ module PuppetSpec::Files
     end
   end
 
-  def make_absolute(path) PuppetSpec::Files.make_absolute(path) end
-  def self.make_absolute(path)
+  module_function
+
+  def make_absolute(path)
     path = File.expand_path(path)
-    path[0] = 'c' if Puppet.features.microsoft_windows?
+    path[0] = 'c' if Puppet::Util::Platform.windows?
     path
   end
 
-  def tmpfile(name, dir = nil) PuppetSpec::Files.tmpfile(name, dir) end
-  def self.tmpfile(name, dir = nil)
-    # Generate a temporary file, just for the name...
-    source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
-    path = Puppet::FileSystem.expand_path(source.path.encode(Encoding::UTF_8))
-    source.close!
-
+  def tmpfile(name, dir = nil)
+    dir ||= Dir.tmpdir
+    path = Puppet::FileSystem.expand_path(make_tmpname(name, nil).encode(Encoding::UTF_8), dir)
     record_tmp(File.expand_path(path))
 
     path
   end
 
-  def file_containing(name, contents) PuppetSpec::Files.file_containing(name, contents) end
-  def self.file_containing(name, contents)
+  def file_containing(name, contents)
     file = tmpfile(name)
     File.open(file, 'wb') { |f| f.write(contents) }
     file
   end
 
-  def script_containing(name, contents) PuppetSpec::Files.script_containing(name, contents) end
-  def self.script_containing(name, contents)
+  def script_containing(name, contents)
     file = tmpfile(name)
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       file += '.bat'
       text = contents[:windows]
     else
@@ -57,8 +52,7 @@ module PuppetSpec::Files
     file
   end
 
-  def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
-  def self.tmpdir(name)
+  def tmpdir(name)
     dir = Puppet::FileSystem.expand_path(Dir.mktmpdir(name).encode!(Encoding::UTF_8))
 
     record_tmp(dir)
@@ -66,13 +60,24 @@ module PuppetSpec::Files
     dir
   end
 
-  def dir_containing(name, contents_hash) PuppetSpec::Files.dir_containing(name, contents_hash) end
-  def self.dir_containing(name, contents_hash)
+  # Copied from ruby 2.4 source
+  def make_tmpname((prefix, suffix), n)
+    prefix = (String.try_convert(prefix) or
+              raise ArgumentError, "unexpected prefix: #{prefix.inspect}")
+    suffix &&= (String.try_convert(suffix) or
+                raise ArgumentError, "unexpected suffix: #{suffix.inspect}")
+    t = Time.now.strftime("%Y%m%d")
+    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}".dup
+    path << "-#{n}" if n
+    path << suffix if suffix
+    path
+  end
+
+  def dir_containing(name, contents_hash)
     dir_contained_in(tmpdir(name), contents_hash)
   end
 
-  def dir_contained_in(dir, contents_hash) PuppetSpec::Files.dir_contained_in(dir, contents_hash) end
-  def self.dir_contained_in(dir, contents_hash)
+  def dir_contained_in(dir, contents_hash)
     contents_hash.each do |k,v|
       if v.is_a?(Hash)
         Dir.mkdir(tmp = File.join(dir,k))
@@ -85,7 +90,7 @@ module PuppetSpec::Files
     dir
   end
 
-  def self.record_tmp(tmp)
+  def record_tmp(tmp)
     # ...record it for cleanup,
     $global_tempfiles ||= []
     $global_tempfiles << tmp
@@ -93,7 +98,7 @@ module PuppetSpec::Files
 
   def expect_file_mode(file, mode)
     actual_mode = "%o" % Puppet::FileSystem.stat(file).mode
-    target_mode = if Puppet.features.microsoft_windows?
+    target_mode = if Puppet::Util::Platform.windows?
       mode
     else
       "10" + "%04i" % mode.to_i

data/spec/lib/puppet_spec/language.rb

@@ -9,50 +9,49 @@ module PuppetSpec::Language
     expectations.each do |manifest, resources|
       it "evaluates #{manifest} to produce #{resources}" do
         begin
-        case resources
-        when String
-          node = Puppet::Node.new('specification')
-          Puppet[:code] = manifest
-          compiler = Puppet::Parser::Compiler.new(node)
-          evaluator = Puppet::Pops::Parser::EvaluatingParser.new()
+          case resources
+          when String
+            node = Puppet::Node.new('specification')
+            Puppet[:code] = manifest
+            compiler = Puppet::Parser::Compiler.new(node)
+            evaluator = Puppet::Pops::Parser::EvaluatingParser.new()
 
-          # see lib/puppet/indirector/catalog/compiler.rb#filter
-          catalog = compiler.compile.filter { |r| r.virtual? }
+            # see lib/puppet/indirector/catalog/compiler.rb#filter
+            catalog = compiler.compile.filter { |r| r.virtual? }
 
-          compiler.send(:instance_variable_set, :@catalog, catalog)
+            compiler.send(:instance_variable_set, :@catalog, catalog)
 
-          Puppet.override(:loaders => compiler.loaders) do
-            expect(evaluator.evaluate_string(compiler.topscope, resources)).to eq(true)
-          end
-        when Array
-          catalog = PuppetSpec::Compiler.compile_to_catalog(manifest)
+            Puppet.override(:loaders => compiler.loaders) do
+              expect(evaluator.evaluate_string(compiler.topscope, resources)).to eq(true)
+            end
+          when Array
+            catalog = PuppetSpec::Compiler.compile_to_catalog(manifest)
 
-          if resources.empty?
-            base_resources = ["Class[Settings]", "Class[main]", "Stage[main]"]
-            expect(catalog.resources.collect(&:ref) - base_resources).to eq([])
-          else
-            resources.each do |reference|
-              if reference.is_a?(Array)
-                matcher = Matchers::Resource.have_resource(reference[0])
-                reference[1].each do |name, value|
-                  matcher = matcher.with_parameter(name, value)
+            if resources.empty?
+              base_resources = ["Class[Settings]", "Class[main]", "Stage[main]"]
+              expect(catalog.resources.collect(&:ref) - base_resources).to eq([])
+            else
+              resources.each do |reference|
+                if reference.is_a?(Array)
+                  matcher = Matchers::Resource.have_resource(reference[0])
+                  reference[1].each do |name, value|
+                    matcher = matcher.with_parameter(name, value)
+                  end
+                else
+                  matcher = Matchers::Resource.have_resource(reference)
                 end
-              else
-                matcher = Matchers::Resource.have_resource(reference)
-              end
 
-              expect(catalog).to matcher
+                expect(catalog).to matcher
+              end
             end
+          else
+            raise "Unsupported creates specification: #{resources.inspect}"
           end
-        else
-          raise "Unsupported creates specification: #{resources.inspect}"
+        rescue  Puppet::Error, RSpec::Expectations::ExpectationNotMetError => e
+          # provide the backtrace from the caller, or it is close to impossible to find some originators
+          e.set_backtrace(calledFrom)
+          raise
         end
-      rescue  Puppet::Error, RSpec::Expectations::ExpectationNotMetError => e
-        # provide the backtrace from the caller, or it is close to impossible to find some originators
-        e.set_backtrace(calledFrom)
-        raise
-      end
-
       end
     end
   end

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 module PuppetSpec
   module ModuleTool
@@ -15,7 +15,7 @@ module PuppetSpec
         moddir = File.join(options[:into], name)
         FileUtils.mkdir_p(moddir)
         File.open(File.join(moddir, 'metadata.json'), 'w') do |file|
-          file.puts(JSON.generate(release.metadata))
+          file.puts(Puppet::Util::Json.dump(release.metadata))
         end
       end
 

data/spec/lib/puppet_spec/modules.rb

@@ -20,6 +20,26 @@ module PuppetSpec::Modules
         end
       end
 
+      if tasks = options[:tasks]
+        tasks_dir = File.join(module_dir, 'tasks')
+        FileUtils.mkdir_p(tasks_dir)
+        tasks.each do |task_files|
+          task_files.each do |task_file|
+            if task_file.is_a?(String)
+              # default content to acceptable metadata
+              task_file = { :name => task_file, :content => "{}" }
+            end
+            File.write(File.join(tasks_dir, task_file[:name]), task_file[:content])
+          end
+        end
+      end
+
+      (options[:files] || {}).each do |fname, content|
+        path = File.join(module_dir, fname)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+      end
+
       Puppet::Module.new(name, module_dir, environment)
     end
 

data/spec/lib/puppet_spec/ssl.rb

@@ -0,0 +1,265 @@
+require 'openssl'
+
+module PuppetSpec
+  module SSL
+
+    PRIVATE_KEY_LENGTH = 2048
+    FIVE_YEARS = 5 * 365 * 24 * 60 * 60
+    CA_EXTENSIONS = [
+      ["basicConstraints", "CA:TRUE", true],
+      ["keyUsage", "keyCertSign, cRLSign", true],
+      ["subjectKeyIdentifier", "hash", false],
+      ["authorityKeyIdentifier", "keyid:always", false]
+    ]
+    NODE_EXTENSIONS = [
+      ["keyUsage", "digitalSignature", true],
+      ["subjectKeyIdentifier", "hash", false]
+    ]
+    DEFAULT_SIGNING_DIGEST = OpenSSL::Digest::SHA256.new
+    DEFAULT_REVOCATION_REASON = OpenSSL::OCSP::REVOKED_STATUS_KEYCOMPROMISE
+    ROOT_CA_NAME = "/CN=root-ca-\u{2070E}"
+    REVOKED_INT_CA_NAME = "/CN=revoked-int-ca-\u16A0"
+    INT_CA_NAME = "/CN=unrevoked-int-ca\u06FF\u16A0\u{2070E}"
+    LEAF_CA_NAME = "/CN=leaf-ca-\u06FF"
+    EXPLANATORY_TEXT = <<-EOT
+# Root Issuer: #{ROOT_CA_NAME}
+# Intermediate Issuer: #{INT_CA_NAME}
+# Leaf Issuer: #{LEAF_CA_NAME}
+EOT
+
+
+    def self.create_private_key(length = PRIVATE_KEY_LENGTH)
+      OpenSSL::PKey::RSA.new(length)
+    end
+
+    def self.self_signed_ca(key, name)
+      cert = OpenSSL::X509::Certificate.new
+
+      cert.public_key = key.public_key
+      cert.subject = OpenSSL::X509::Name.parse(name)
+      cert.issuer = cert.subject
+      cert.version = 2
+      cert.serial = rand(2**128)
+
+      not_before = just_now
+      cert.not_before = not_before
+      cert.not_after = not_before + FIVE_YEARS
+
+      ext_factory = extension_factory_for(cert, cert)
+      CA_EXTENSIONS.each do |ext|
+        extension = ext_factory.create_extension(*ext)
+        cert.add_extension(extension)
+      end
+
+      cert.sign(key, DEFAULT_SIGNING_DIGEST)
+
+      cert
+    end
+
+    def self.create_csr(key, name)
+      csr = OpenSSL::X509::Request.new
+
+      csr.public_key = key.public_key
+      csr.subject = OpenSSL::X509::Name.parse(name)
+      csr.version = 2
+      csr.sign(key, DEFAULT_SIGNING_DIGEST)
+
+      csr
+    end
+
+    def self.sign(ca_key, ca_cert, csr, extensions = NODE_EXTENSIONS)
+      cert = OpenSSL::X509::Certificate.new
+
+      cert.public_key = csr.public_key
+      cert.subject = csr.subject
+      cert.issuer = ca_cert.subject
+      cert.version = 2
+      cert.serial = rand(2**128)
+
+      not_before = just_now
+      cert.not_before = not_before
+      cert.not_after = not_before + FIVE_YEARS
+
+      ext_factory = extension_factory_for(ca_cert, cert)
+      extensions.each do |ext|
+        extension = ext_factory.create_extension(*ext)
+        cert.add_extension(extension)
+      end
+
+      cert.sign(ca_key, DEFAULT_SIGNING_DIGEST)
+
+      cert
+    end
+
+    def self.create_crl_for(ca_cert, ca_key)
+      crl = OpenSSL::X509::CRL.new
+      crl.version = 1
+      crl.issuer = ca_cert.subject
+
+      ef = extension_factory_for(ca_cert)
+      crl.add_extension(
+        ef.create_extension(["authorityKeyIdentifier", "keyid:always", false]))
+      crl.add_extension(
+        OpenSSL::X509::Extension.new("crlNumber", OpenSSL::ASN1::Integer(0)))
+
+      not_before = just_now
+      crl.last_update = not_before
+      crl.next_update = not_before + FIVE_YEARS
+      crl.sign(ca_key, DEFAULT_SIGNING_DIGEST)
+
+      crl
+    end
+
+    def self.revoke(serial, crl, ca_key)
+      revoked = OpenSSL::X509::Revoked.new
+      revoked.serial = serial
+      revoked.time = Time.now
+      revoked.add_extension(
+        OpenSSL::X509::Extension.new("CRLReason",
+                                     OpenSSL::ASN1::Enumerated(DEFAULT_REVOCATION_REASON)))
+
+      crl.add_revoked(revoked)
+      extensions = crl.extensions.group_by{|e| e.oid == 'crlNumber' }
+      crl_number = extensions[true].first
+      unchanged_exts = extensions[false]
+
+      next_crl_number = crl_number.value.to_i + 1
+      new_crl_number_ext = OpenSSL::X509::Extension.new("crlNumber",
+                                                        OpenSSL::ASN1::Integer(next_crl_number))
+
+      crl.extensions = unchanged_exts + [new_crl_number_ext]
+      crl.sign(ca_key, DEFAULT_SIGNING_DIGEST)
+
+      crl
+    end
+
+    # Creates a self-signed root ca, then signs two node certs, revoking one of them.
+    # Creates an intermediate CA and one node cert off of it.
+    # Creates a second intermediate CA and one node cert off if it.
+    # Creates a leaf CA off of the intermediate CA, then signs two node certs revoking one of them.
+    # Revokes an intermediate CA.
+    # Returns the ca bundle, crl chain, and all the node certs
+    #
+    #            -----
+    #           /     \
+    #          /       \
+    #          | root  +-------------------o------------------o
+    #          \  CA   /                   |                  |
+    #           \     /                    |                  |
+    #            --+--                     |                  |
+    #              |                       |                  |
+    #              |                       |                  |
+    #              |                       |                  |
+    #              |                     --+--              --+--
+    # +---------+  |   +---------+      /     \            /     \
+    # | revoked |  |   |         |     /revoked\          /       \
+    # |   node  +--o---+   node  |     |  int  |          | int   |
+    # |         |      |         |     \  CA   /          \  CA   /
+    # +---------+      +---------+      \     /            \     /
+    #                                    --+--              --+--
+    #                                      |                  |
+    #                                      |                  |
+    #                                      |                  |
+    #                                    --+--                |
+    #                                   /     \           +---+-----+
+    #                                  /       \          |         |
+    #                                  | leaf  |          |  node   |
+    #                                  \  CA   /          |         |
+    #                                   \     /           +---------+
+    #                                    --+--
+    #                                      |
+    #                                      |
+    #                         +---------+  |  +----------+
+    #                         | revoked |  |  |          |
+    #                         |   node  +--o--+  node    |
+    #                         |         |     |          |
+    #                         +---------+     +----------+
+    def self.create_chained_pki
+      root_key = create_private_key
+      root_cert = self_signed_ca(root_key, ROOT_CA_NAME)
+      root_crl = create_crl_for(root_cert, root_key)
+
+      unrevoked_root_node_key = create_private_key
+      unrevoked_root_node_csr = create_csr(unrevoked_root_node_key, "/CN=unrevoked-root-node")
+      unrevoked_root_node_cert = sign(root_key, root_cert, unrevoked_root_node_csr)
+
+      revoked_root_node_key = create_private_key
+      revoked_root_node_csr = create_csr(revoked_root_node_key, "/CN=revoked-root-node")
+      revoked_root_node_cert = sign(root_key, root_cert, revoked_root_node_csr)
+
+      revoke(revoked_root_node_cert.serial, root_crl, root_key)
+
+      revoked_int_key = create_private_key
+      revoked_int_csr = create_csr(revoked_int_key, REVOKED_INT_CA_NAME)
+      revoked_int_cert = sign(root_key, root_cert, revoked_int_csr, CA_EXTENSIONS)
+      revoked_int_crl = create_crl_for(revoked_int_cert, revoked_int_key)
+
+      int_key = create_private_key
+      int_csr = create_csr(int_key, INT_CA_NAME)
+      int_cert = sign(root_key, root_cert, int_csr, CA_EXTENSIONS)
+
+      int_node_key = create_private_key
+      int_node_csr = create_csr(int_node_key, "/CN=unrevoked-int-node")
+      int_node_cert = sign(int_key, int_cert, int_node_csr)
+
+      unrevoked_int_node_key = create_private_key
+      unrevoked_int_node_csr = create_csr(unrevoked_int_node_key, "/CN=unrevoked-int-node")
+      unrevoked_int_node_cert = sign(revoked_int_key, revoked_int_cert, unrevoked_int_node_csr)
+
+      leaf_key = create_private_key
+      leaf_csr = create_csr(leaf_key, LEAF_CA_NAME)
+      leaf_cert = sign(revoked_int_key, revoked_int_cert, leaf_csr, CA_EXTENSIONS)
+      leaf_crl = create_crl_for(leaf_cert, leaf_key)
+
+      revoke(revoked_int_cert.serial, root_crl, root_key)
+
+      unrevoked_leaf_node_key = create_private_key
+      unrevoked_leaf_node_csr = create_csr(unrevoked_leaf_node_key, "/CN=unrevoked-leaf-node")
+      unrevoked_leaf_node_cert = sign(leaf_key, leaf_cert, unrevoked_leaf_node_csr)
+
+      revoked_leaf_node_key = create_private_key
+      revoked_leaf_node_csr = create_csr(revoked_leaf_node_key, "/CN=revoked-leaf-node")
+      revoked_leaf_node_cert = sign(leaf_key, leaf_cert, revoked_leaf_node_csr)
+
+      revoke(revoked_leaf_node_cert.serial, leaf_crl, leaf_key)
+
+
+      ca_bundle = bundle(root_cert, revoked_int_cert, leaf_cert)
+      crl_chain = bundle(root_crl, revoked_int_crl, leaf_crl)
+
+      {
+        :root_cert => root_cert,
+        :int_cert => int_cert,
+        :int_node_cert => int_node_cert,
+        :leaf_cert => leaf_cert,
+        :leaf_key => leaf_key,
+        :revoked_root_node_cert => revoked_root_node_cert,
+        :revoked_int_cert => revoked_int_cert,
+        :revoked_leaf_node_cert => revoked_leaf_node_cert,
+        :unrevoked_root_node_cert => unrevoked_root_node_cert,
+        :unrevoked_int_node_cert  => unrevoked_int_node_cert,
+        :unrevoked_leaf_node_cert => unrevoked_leaf_node_cert,
+        :ca_bundle => ca_bundle,
+        :crl_chain => crl_chain,
+      }
+    end
+
+   private
+
+    def self.just_now
+      Time.now - 1
+    end
+
+    def self.extension_factory_for(ca, cert = nil)
+      ef = OpenSSL::X509::ExtensionFactory.new
+      ef.issuer_certificate  = ca
+      ef.subject_certificate = cert if cert
+
+      ef
+    end
+
+    def self.bundle(*items)
+      items.map {|i| EXPLANATORY_TEXT + i.to_pem }.join("\n")
+    end
+  end
+end

data/spec/lib/puppet_spec/validators.rb

@@ -0,0 +1,37 @@
+class ConstantErrorValidator
+  def initialize(args)
+    @fails_with = args[:fails_with]
+    @error_string = args[:error_string] || ""
+    @peer_certs = args[:peer_certs] || []
+  end
+
+  def setup_connection(connection)
+    connection.stubs(:start).raises(OpenSSL::SSL::SSLError.new(@fails_with))
+  end
+
+  def peer_certs
+    @peer_certs
+  end
+
+  def verify_errors
+    [@error_string]
+  end
+end
+
+class NoProblemsValidator
+  def initialize(cert)
+    @cert = cert
+  end
+
+  def setup_connection(connection)
+  end
+
+  def peer_certs
+    [@cert]
+  end
+
+  def verify_errors
+    []
+  end
+end
+

data/spec/shared_behaviours/file_server_terminus.rb

@@ -34,8 +34,6 @@ shared_examples_for "Puppet::Indirector::FileServerTerminus" do
     @modules.stubs(:find).returns(nil)
     @terminus.indirection.stubs(:terminus).with(:modules).returns(@modules)
 
-    path = File.join(@path, "myfile")
-
     expect(@terminus.find(@request)).to be_instance_of(@test_class)
   end
 end

data/spec/shared_behaviours/file_serving_model.rb

@@ -12,25 +12,6 @@ shared_examples_for "a file_serving model" do
       described_class.indirection.terminus(:rest).class.any_instance.stubs(:find)
     end
 
-    describe "when running the master application" do
-      before :each do
-        Puppet::Application[:master].setup_terminuses
-      end
-
-      {
-       localpath     => :file_server,
-       localurl => :file_server,
-       "puppet:///modules/foo/bar"       => :file_server,
-       "puppet://server/modules/foo/bar" => :file_server,
-      }.each do |key, terminus|
-        it "should use the #{terminus} terminus when requesting #{key.inspect}" do
-          described_class.indirection.terminus(terminus).class.any_instance.expects(:find)
-
-          described_class.indirection.find(key)
-        end
-      end
-    end
-
     describe "when running the apply application" do
       before :each do
         Puppet[:default_file_terminus] = 'file_server'

data/spec/shared_behaviours/path_parameters.rb

@@ -115,7 +115,7 @@ shared_examples_for "all path parameters" do |param, options|
     end
   end
 
-  describe "on a Windows-like platform it", :if => Puppet.features.microsoft_windows? do
+  describe "on a Windows-like platform it", :if => Puppet::Util::Platform.windows? do
     if array then
       it_should_behave_like "all pathname parameters with arrays", true
     end

data/spec/shared_behaviours/things_that_declare_options.rb

@@ -87,8 +87,8 @@ shared_examples_for "things that declare options" do
     it "should detect conflicts between #{base.inspect} and #{conflict.inspect}" do
       expect {
         add_options_to do
-          option *base
-          option *conflict
+          option(*base)
+          option(*conflict)
         end
       }.to raise_error ArgumentError, /conflicts with existing option/
     end

data/spec/shared_contexts/checksum.rb

@@ -11,7 +11,10 @@ CHECKSUM_TYPES_TO_TRY = [
   ['md5', 'a7a169ac84bb863b30484d0aa03139c1'],
   ['md5lite', '22b4182363e81b326e98231fde616782'],
   ['sha256', '47fcae62967db2fb5cba2fc0d9cf3e6767035d763d825ecda535a7b1928b9746'],
-  ['sha256lite', 'fd50217a2b0286ba25121bf2297bbe6c197933992de67e4e568f19861444ecf8']
+  ['sha256lite', 'fd50217a2b0286ba25121bf2297bbe6c197933992de67e4e568f19861444ecf8'],
+  ['sha224', '6894cd976b60b2caa825bc699b54f715853659f0243f67cda4dd7ac4'],
+  ['sha384', 'afc3d952fe1a4d3aa083d438ea464f6e7456c048d34ff554340721b463b38547e5ee7c964513dfba0d65dd91ac97deb5'],
+  ['sha512', 'a953dcd95824cfa2a555651585d3980b1091a740a785d52ee5e72a55c9038242433e55026758636b0a29d0e5f9e77f24bc888ea5d5e01ab36d2bbcb3d3163859']
 ]
 
 CHECKSUM_STAT_TIME = Time.now