vagrant 1.5.0 → 2.4.5

data/lib/vagrant/util/keypair.rb

@@ -0,0 +1,293 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "base64"
+require "ed25519"
+require "securerandom"
+
+require "vagrant/util/retryable"
+
+module Vagrant
+  module Util
+    class Keypair
+      # Magic string header
+      AUTH_MAGIC = "openssh-key-v1".freeze
+      # Header of private key file content
+      PRIVATE_KEY_START = "-----BEGIN OPENSSH PRIVATE KEY-----\n".freeze
+      # Footer of private key file content
+      PRIVATE_KEY_END = "-----END OPENSSH PRIVATE KEY-----\n".freeze
+
+      # Check if provided key is a supported key type
+      #
+      # @param [Symbol] key Key type to check
+      # @return [Boolean] key type is supported
+      def self.valid_type?(key)
+        VALID_TYPES.keys.include?(key)
+      end
+
+      # @return [Array<Symbol>] list of supported key types
+      def self.available_types
+        PREFER_KEY_TYPES.values
+      end
+
+      # Create a new keypair
+      #
+      # @param [String] password Password for the key or nil for no password (only supported for rsa type)
+      # @param [Symbol] type Key type to generate
+      # @return [Array<String, String, String>] Public key, openssh private key, openssh public key with comment
+      def self.create(password=nil, type: :rsa)
+        if !VALID_TYPES.key?(type)
+          raise ArgumentError,
+                "Invalid key type requested (supported types: #{available_types.map(&:inspect).join(", ")})"
+        end
+
+        VALID_TYPES[type].create(password)
+      end
+
+      class Ed25519
+        # Key type identifier
+        KEY_TYPE = "ssh-ed25519".freeze
+
+        # Encodes given string
+        #
+        # @param [String] s String to encode
+        # @return [String]
+        def self.string(s)
+          [s.length].pack("N") + s
+        end
+
+        # Encodes given string with padding to block size
+        #
+        # @param [String] s String to encode
+        # @param [Integer] blocksize Defined block size
+        # @return [String]
+        def self.padded_string(s, blocksize)
+          pad = blocksize - (s.length % blocksize)
+          string(s + Array(1..pad).pack("c*"))
+        end
+
+        # Creates an ed25519 SSH key pair
+        # @return [Array<String, String, String>] Public key, openssh private key, openssh public key with comment
+        # @note Password support was not included as it's not actively used anywhere. If it ends up being
+        # something that's needed, it can be revisited
+        def self.create(password=nil)
+          if password
+            raise NotImplementedError,
+                  "Ed25519 key pair generation does not support passwords"
+          end
+
+          # Generate the key
+          base_key = ::Ed25519::SigningKey.generate
+          # Define the comment used for the key
+          comment = "vagrant"
+
+          # Grab the raw public key
+          public_key = base_key.verify_key.to_bytes
+          # Encode the public key for use building the openssh private key
+          encoded_public_key = string(KEY_TYPE) + string(public_key)
+          # Format the public key into the openssh public key format for writing
+          openssh_public_key = "#{KEY_TYPE} #{Base64.encode64(encoded_public_key).gsub("\n", "")} #{comment}"
+
+          # Agent encoded private key is used when building the openssh private key
+          # (https://datatracker.ietf.org/doc/html/draft-miller-ssh-agent#section-4.2.3)
+          # (https://dnaeon.github.io/openssh-private-key-binary-format/)
+          agent_private_key = [
+            ([SecureRandom.random_number((2**32)-1)] * 2).pack("NN"), # checkint, random uint32 value, twice (used for encryption verification)
+            encoded_public_key, # includes the key type and public key
+            string(base_key.seed + public_key), # private key with public key concatenated
+            string(comment), # comment for the key
+          ].join
+
+          # Build openssh private key data (https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key)
+          private_key = [
+            AUTH_MAGIC + "\0", # Magic string
+            string("none"), # cipher name, no encryption, so none
+            string("none"), # kdf name, no encryption, so none
+            string(""), # kdf options/data, no encryption, so empty string
+            [1].pack("N"), # Number of keys (just one)
+            string(encoded_public_key), # The public key
+            padded_string(agent_private_key, 8) # Private key encoded with agent rules, padded for 8 byte block size
+          ].join
+
+          # Create the openssh private key content
+          openssh_private_key = [
+            PRIVATE_KEY_START,
+            Base64.encode64(private_key),
+            PRIVATE_KEY_END,
+          ].join
+
+          return [public_key, openssh_private_key, openssh_public_key]
+        end
+      end
+
+      class Rsa
+        extend Retryable
+
+        # Key type identifier
+        KEY_TYPE = "ssh-rsa"
+
+        # Creates an SSH keypair and returns it.
+        #
+        # @param [String] password Password for the key, or nil for no password.
+        # @return [Array<String, String, String>] PEM-encoded public and private key,
+        #   respectively. The final element is the OpenSSH encoded public
+        #   key.
+        def self.create(password=nil)
+          # This sometimes fails with RSAError. It is inconsistent and strangely
+          # sleeps seem to fix it. We just retry this a few times. See GH-5056
+          rsa_key = nil
+          retryable(on: OpenSSL::PKey::RSAError, sleep: 2, tries: 5) do
+            rsa_key = OpenSSL::PKey::RSA.new(2048)
+          end
+
+          public_key  = rsa_key.public_key
+          private_key = rsa_key.to_pem
+
+          if password
+            cipher      = OpenSSL::Cipher.new('des3')
+            private_key = rsa_key.to_pem(cipher, password)
+          end
+
+          # Generate the binary necessary for the OpenSSH public key.
+          binary = [7].pack("N")
+          binary += "ssh-rsa"
+          ["e", "n"].each do |m|
+            val  = public_key.send(m)
+            data = val.to_s(2)
+
+            first_byte = data[0,1].unpack("c").first
+            if val < 0
+              data[0] = [0x80 & first_byte].pack("c")
+            elsif first_byte < 0
+              data = 0.chr + data
+            end
+
+            binary += [data.length].pack("N") + data
+          end
+
+          openssh_key = "ssh-rsa #{Base64.encode64(binary).gsub("\n", "")} vagrant"
+          public_key  = public_key.to_pem
+          return [public_key, private_key, openssh_key]
+        end
+      end
+
+      # Base class for Ecdsa type keys to subclass
+      class Ecdsa
+        # Encodes given string
+        #
+        # @param [String] s String to encode
+        # @return [String]
+        def self.string(s)
+          [s.length].pack("N") + s
+        end
+
+        # Encodes given string with padding to block size
+        #
+        # @param [String] s String to encode
+        # @param [Integer] blocksize Defined block size
+        # @return [String]
+        def self.padded_string(s, blocksize)
+          pad = blocksize - (s.length % blocksize)
+          string(s + Array(1..pad).pack("c*"))
+        end
+
+        # Creates an ed25519 SSH key pair
+        # @return [Array<String, String, String>] Public key, openssh private key, openssh public key with comment
+        # @note Password support was not included as it's not actively used anywhere. If it ends up being
+        # something that's needed, it can be revisited
+        def self.create(password=nil)
+          if password
+            raise NotImplementedError,
+                  "Ecdsa key pair generation does not support passwords"
+          end
+
+          # Generate the key
+          base_key = OpenSSL::PKey::EC.generate(self.const_get(:OPENSSL_CURVE))
+          # Define the comment used for the key
+          comment = "vagrant"
+
+          # Grab the raw public key
+          public_key = base_key.public_key.to_bn.to_s(2)
+          # Encode the public key for use building the openssh private key
+          encoded_public_key = string(self.const_get(:KEY_TYPE)) + string(self.const_get(:OPENSSH_CURVE)) + string(public_key)
+          # Format the public key into the openssh public key format for writing
+          openssh_public_key = "#{self.const_get(:KEY_TYPE)} #{Base64.encode64(encoded_public_key).gsub("\n", "")} #{comment}"
+
+          pk_value = base_key.private_key.to_s(2)
+          # Pad the start of the key if required
+          if pk_value.length % 8 == 0
+            pk_value = "\0#{pk_value}"
+          end
+
+          # Agent encoded private key is used when building the openssh private key
+          # (https://datatracker.ietf.org/doc/html/draft-miller-ssh-agent#section-4.2.3)
+          # (https://dnaeon.github.io/openssh-private-key-binary-format/)
+          agent_private_key = [
+            ([SecureRandom.random_number((2**32)-1)] * 2).pack("NN"), # checkint, random uint32 value, twice (used for encryption verification)
+            encoded_public_key, # includes the key type and public key
+            string(pk_value), # private key
+            string(comment), # comment for the key
+          ].join
+
+          # Build openssh private key data (https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key)
+          private_key = [
+            AUTH_MAGIC + "\0", # Magic string
+            string("none"), # cipher name, no encryption, so none
+            string("none"), # kdf name, no encryption, so none
+            string(""), # kdf options/data, no encryption, so empty string
+            [1].pack("N"), # Number of keys (just one)
+            string(encoded_public_key), # The public key
+            padded_string(agent_private_key, 8) # Private key encoded with agent rules, padded for 8 byte block size
+          ].join
+
+          # Create the openssh private key content
+          openssh_private_key = [
+            PRIVATE_KEY_START,
+            Base64.encode64(private_key),
+            PRIVATE_KEY_END,
+          ].join
+
+          return [public_key, openssh_private_key, openssh_public_key]
+        end
+      end
+
+      class Ecdsa256 < Ecdsa
+        KEY_TYPE = "ecdsa-sha2-nistp256".freeze
+        OPENSSH_CURVE = "nistp256".freeze
+        OPENSSL_CURVE = "prime256v1".freeze
+      end
+
+      class Ecdsa384 < Ecdsa
+        KEY_TYPE = "ecdsa-sha2-nistp384".freeze
+        OPENSSH_CURVE = "nistp384".freeze
+        OPENSSL_CURVE = "secp384r1".freeze
+      end
+
+      class Ecdsa521 < Ecdsa
+        KEY_TYPE = "ecdsa-sha2-nistp521".freeze
+        OPENSSH_CURVE = "nistp521".freeze
+        OPENSSL_CURVE = "secp521r1".freeze
+      end
+
+      # Supported key types.
+      VALID_TYPES = {
+        ecdsa256: Ecdsa256,
+        ecdsa384: Ecdsa384,
+        ecdsa521: Ecdsa521,
+        ed25519: Ed25519,
+        rsa: Rsa
+      }.freeze
+
+      # Ordered mapping of openssh key type name to lookup name. The
+      # order defined here is based on preference. Note that ecdsa
+      # ordering is based on performance
+      PREFER_KEY_TYPES = {
+        Ed25519::KEY_TYPE => :ed25519,
+        Ecdsa256::KEY_TYPE => :ecdsa256,
+        Ecdsa521::KEY_TYPE => :ecdsa521,
+        Ecdsa384::KEY_TYPE => :ecdsa384,
+        Rsa::KEY_TYPE => :rsa,
+      }.freeze
+    end
+  end
+end

data/lib/vagrant/util/line_buffer.rb

@@ -0,0 +1,63 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class LineBuffer
+
+      # Maximum number of characters to buffer before sending
+      # to callback without detecting a new line
+      MAX_LINE_LENGTH = 5000.freeze
+
+      # Create a new line buffer. The registered block
+      # will be called when a new line is encountered on
+      # provided input, or the max line length is reached
+      def initialize(&callback)
+        raise ArgumentError,
+          "Expected callback but received none" if callback.nil?
+        @mu = Mutex.new
+        @callback = callback
+        @buffer = ""
+      end
+
+      # Add string data to output
+      #
+      # @param [String] str String of data to output
+      # @return [self]
+      def <<(str)
+        @mu.synchronize do
+          while i = str.index("\n")
+            @callback.call((@buffer + str[0, i+1]).rstrip)
+            @buffer.clear
+            str = str[i+1, str.length].to_s
+          end
+
+          @buffer << str.to_s
+
+          if @buffer.length > MAX_LINE_LENGTH
+            @callback.call(@buffer.dup)
+            @buffer.clear
+          end
+        end
+        self
+      end
+
+      # Closes the buffer. Any remaining data that has
+      # been buffered will be given to the callback.
+      # Once closed the instance will no longer be usable.
+      #
+      # @return [self]
+      def close
+        @mu.synchronize do
+          # Send any remaining output on the buffer
+          @callback.call(@buffer.dup) if !@buffer.empty?
+          # Disable this buffer instance
+          @callback = nil
+          @buffer.clear
+          @buffer.freeze
+        end
+        self
+      end
+    end
+  end
+end

data/lib/vagrant/util/line_ending_helpers.rb

@@ -0,0 +1,17 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    module LineEndingHelpers
+      # Converts line endings to unix-style line endings in the
+      # given string.
+      #
+      # @param [String] string Original string
+      # @return [String] The fixed string
+      def dos_to_unix(string)
+        string.gsub("\r\n", "\n")
+      end
+    end
+  end
+end

data/lib/vagrant/util/logging_formatter.rb

@@ -0,0 +1,70 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/util/credential_scrubber"
+require "log4r/formatter/formatter"
+
+module Vagrant
+  module Util
+    # Wrapper for logging formatting to provide
+    # information scrubbing prior to being written
+    # to output target
+    class LoggingFormatter < Log4r::BasicFormatter
+      # @return [Log4r::PatternFormatter]
+      attr_reader :formatter
+
+      # Creates a new formatter wrapper instance.
+      #
+      # @param [Log4r::Formatter]
+      def initialize(formatter)
+        @formatter = formatter
+      end
+
+      # Format event and scrub output
+      def format(event)
+        msg = formatter.format(event)
+        CredentialScrubber.desensitize(msg)
+      end
+    end
+
+    class HCLogFormatter < Log4r::BasicFormatter
+      MAX_MESSAGE_LENGTH = 4096
+
+      def format(event)
+        message = format_object(event.data).
+          force_encoding('UTF-8').
+          scrub("?")
+        if message.length > MAX_MESSAGE_LENGTH
+          message = Array.new.tap { |a|
+            until message.empty?
+              a << "continued..." unless a.empty?
+              a << message.slice!(0, MAX_MESSAGE_LENGTH)
+            end
+          }
+        else
+          message = [message]
+        end
+
+        message.map do |msg|
+          d = {
+            "@timestamp" => Time.now.strftime("%Y-%m-%dT%H:%M:%S.%6N%:z"),
+            "@level" => Log4r::LNAMES[event.level].downcase,
+            "@module" => event.fullname,
+            "@name" => event.name,
+            "@message" => msg,
+          }
+          d["@caller"] = event.tracer[0] if event.tracer
+          d.to_json + "\n"
+        end
+      end
+    end
+
+    class HCLogOutputter < Log4r::StderrOutputter
+      def write(data)
+        data.each do |d|
+          super(d)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/map_command_options.rb

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module Vagrant
+  module Util
+    class MapCommandOptions
+      # Given a hash map of user specified argments, will generate
+      # a list. Set the key to the command flag, and the value to 
+      # it's value. If the value is boolean (true), only the flag is
+      # added. eg.
+      # {a: "opt-a", b: true} -> ["--a", "opt-a", "--b"]
+      #
+      # @param [Hash]   map of commands
+      # @param [String] string prepended to cmd line flags (keys)
+      #
+      # @return[Array<String>] commands in list form
+      def self.map_to_command_options(map, cmd_flag="--")
+        opt_list = []
+        if map == nil
+          return opt_list
+        end
+        map.each do |k, v|
+          # If the value is true (bool) add the key as the cmd flag
+          if v.is_a?(TrueClass)
+            opt_list.push("#{cmd_flag}#{k}")
+          # If the value is a string, add the key as the flag, and value as the flags argument
+          elsif v.is_a?(String)
+            opt_list.push("#{cmd_flag}#{k}")
+            opt_list.push(v)
+          end
+        end
+        return opt_list
+      end
+    end
+  end
+end

data/lib/vagrant/util/mime.rb

@@ -0,0 +1,95 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'mime/types'
+require 'securerandom'
+
+module Vagrant
+  module Util
+    module Mime
+      class Multipart
+
+        # @return [Array<String>] collection of content part of the multipart mime
+        attr_accessor :content
+
+        # @return [String] type of the content
+        attr_accessor :content_type
+
+        # @return [Hash] headers for the mime
+        attr_accessor :headers
+
+        # @param [String] (optional) mime content type
+        # @param [String] (optional) mime version
+        def initialize(content_type="multipart/mixed")
+          @content_id = "#{Time.now.to_i}@#{SecureRandom.alphanumeric(24)}.local"
+          @boundary = "Boundary_#{SecureRandom.alphanumeric(24)}"
+          @content_type = MIME::Types[content_type].first
+          @content = []
+          @headers = {
+            "Content-ID"=> "<#{@content_id}>",
+            "Content-Type"=> "#{content_type}; boundary=#{@boundary}",
+          }
+        end
+
+        # Add an entry to the multipart mime
+        #
+        # @param entry to add
+        def add(entry)
+          content << entry
+        end
+
+        # Output MimeEntity as a string
+        #
+        # @return [String] mime data
+        def to_s
+          output_string = ""
+          headers.each do |k, v|
+            output_string += "#{k}: #{v}\n"
+          end
+          output_string += "\n--#{@boundary}\n"
+          @content.each do |entry|
+            output_string += entry.to_s
+            output_string += "\n--#{@boundary}\n"
+          end
+          output_string
+        end
+      end
+
+      class Entity
+
+        # @return [String] entity content 
+        attr_reader :content
+
+        # @return [String] type of the entity content
+        attr_reader :content_type
+
+        # @return [String] content disposition
+        attr_accessor :disposition
+
+        # @param [String] entity content
+        # @param [String] type of the entity content
+        def initialize(content, content_type)
+          if !MIME::Types.include?(content_type)
+            MIME::Types.add(MIME::Type.new(content_type))
+          end
+          @content = content
+          @content_type = MIME::Types[content_type].first
+          @content_id = "#{Time.now.to_i}@#{SecureRandom.alphanumeric(24)}.local"
+        end
+
+        # Output MimeEntity as a string
+        #
+        # @return [String] mime data
+        def to_s
+          output_string = "Content-ID: <#{@content_id}>\n"
+          output_string += "Content-Type: #{@content_type}\n"
+          if disposition
+            output_string += "Content-Disposition: #{@disposition}\n"
+          end
+          output_string += "\n#{content}"
+          output_string
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/network_ip.rb

@@ -0,0 +1,27 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "ipaddr"
+
+module Vagrant
+  module Util
+    module NetworkIP
+
+      DEFAULT_MASK = "255.255.255.0".freeze
+
+      LOGGER = Log4r::Logger.new("vagrant::util::NetworkIP")
+
+      # Returns the network address of the given IP and subnet.
+      #
+      # @return [String]
+      def network_address(ip, subnet)
+        begin
+          IPAddr.new(ip).mask(subnet).to_s
+        rescue IPAddr::InvalidPrefixError
+          LOGGER.warn("Provided mask '#{subnet}' is invalid. Falling back to using mask '#{DEFAULT_MASK}'")
+          IPAddr.new(ip).mask(DEFAULT_MASK).to_s
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/numeric.rb

@@ -0,0 +1,92 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module Vagrant
+  module Util
+    class Numeric
+
+      # Authors Note: This conversion has been borrowed from the ActiveSupport Numeric class
+      # Conversion helper constants
+      KILOBYTE = 1024
+      MEGABYTE = KILOBYTE * 1024
+      GIGABYTE = MEGABYTE * 1024
+      TERABYTE = GIGABYTE * 1024
+      PETABYTE = TERABYTE * 1024
+      EXABYTE  = PETABYTE * 1024
+
+      BYTES_CONVERSION_MAP = {KB: KILOBYTE, MB: MEGABYTE, GB: GIGABYTE, TB: TERABYTE,
+                              PB: PETABYTE, EB: EXABYTE}
+
+      # Regex borrowed from the vagrant-disksize config class
+      SHORTHAND_MATCH_REGEX = /^(?<number>[0-9]+)\s?(?<unit>KB|MB|GB|TB)?$/
+
+      class << self
+        LOGGER = Log4r::Logger.new("vagrant::util::numeric")
+
+        # A helper that converts a shortcut string to its bytes representation.
+        # The expected format of `str` is essentially: "<Number>XX"
+        # Where `XX` is shorthand for KB, MB, GB, TB, PB, or EB. For example, 50 megabytes:
+        #
+        # str = "50MB"
+        #
+        # @param [String] - str
+        # @return [Integer,nil] - bytes - returns nil if method fails to convert to bytes
+        def string_to_bytes(str)
+          bytes = nil
+
+          str = str.to_s.strip
+          matches = SHORTHAND_MATCH_REGEX.match(str)
+          if matches
+            number = matches[:number].to_i
+            unit = matches[:unit].to_sym
+
+            if BYTES_CONVERSION_MAP.key?(unit)
+              bytes = number * BYTES_CONVERSION_MAP[unit]
+            else
+              LOGGER.error("An invalid unit or format was given, string_to_bytes cannot convert #{str}")
+            end
+          end
+
+          bytes
+        end
+
+        # Convert bytes to a user friendly string representation
+        #
+        # @param [Numeric] bytes Number of bytes to represent
+        # @return [String] user friendly output
+        def bytes_to_string(bytes)
+          # We want to locate the size that will return the
+          # smallest whole value number
+          BYTES_CONVERSION_MAP.sort { |a, b|
+            b.last <=> a.last
+          }.each do |suffix, size|
+            val = bytes.to_f / size
+            next if val < 1
+            val = sprintf("%.2f", val)
+            val.slice!(-1, 1) while val.end_with?("0")
+            val.slice!(-1, 1) if val.end_with?(".")
+            return "#{val}#{suffix}"
+          end
+          "#{bytes} byte#{"s" if bytes > 1}"
+        end
+
+        # Rounds actual value to two decimal places
+        #
+        # @param [Integer] bytes
+        # @return [Integer] megabytes - bytes representation in megabytes
+        def bytes_to_megabytes(bytes)
+          (bytes / MEGABYTE.to_f).round(2)
+        end
+
+        # @private
+        # Reset the cached values for platform. This is not considered a public
+        # API and should only be used for testing.
+        def reset!
+          instance_variables.each(&method(:remove_instance_variable))
+        end
+      end
+    end
+  end
+end