logstash-input-beats 0.9.2 → 0.9.3

data/vendor/jruby/1.9/gems/flores-0.0.6/lib/flores/pki.rb

@@ -1,297 +0,0 @@
-# encoding: utf-8
-# This file is part of ruby-flores.
-# Copyright (C) 2015 Jordan Sissel
-# 
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-# 
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require "flores/namespace"
-require "flores/random"
-require "English"
-require "openssl"
-
-module Flores::PKI
-  GENERATE_DEFAULT_KEY_SIZE = 1024
-  GENERATE_DEFAULT_EXPONENT = 65537
-  GENERATE_DEFAULT_DURATION_RANGE = 1..86400
-
-  class << self
-    # Generate a random serial number for a certificate.
-    def random_serial
-      # RFC5280 (X509) says:
-      # > 4.1.2.2.  Serial Number 
-      # > Certificate users MUST be able to handle serialNumber values up to 20 octets
-      Flores::Random.integer(1..9).to_s + Flores::Random.iterations(0..19).collect { Flores::Random.integer(0..9) }.join
-    end
-
-    # Generate a valid certificate with sane random values.
-    #
-    # By default this method use `CN=localhost` as the default subject and a 1024 bits encryption
-    # key for the certificate, you can override the defaults by specifying a subject and the
-    # key size in the options hash.
-    #
-    # Example:
-    #
-    #     Flores::PKI.generate("CN=localhost", { :key_size => 2048 }
-    # 
-    # @params subject [String] Certificate subject
-    # @params opts [Hash] Options
-    # @return [OpenSSL::X509::Certificate, OpenSSL::Pkey::RSA]
-    def generate(subject = "CN=localhost", opts = {})
-      key_size = opts.fetch(:key_size, GENERATE_DEFAULT_KEY_SIZE)
-      key = OpenSSL::PKey::RSA.generate(key_size, GENERATE_DEFAULT_EXPONENT)
-
-      certificate_duration = Flores::Random.number(GENERATE_DEFAULT_DURATION_RANGE)
-
-      csr = Flores::PKI::CertificateSigningRequest.new
-      csr.subject = subject
-      csr.public_key = key.public_key
-      csr.start_time = Time.now
-      csr.expire_time = csr.start_time + certificate_duration
-      csr.signing_key = key
-      csr.want_signature_ability = true
-      certificate = csr.create
-
-      return [certificate, key]
-    end
-  end
-
-  # A certificate signing request.
-  #
-  # From here, you can configure a certificate to be created based on your
-  # desired configuration.
-  #
-  # Example making a root CA:
-  #
-  #     key = OpenSSL::PKey::RSA.generate(4096, 65537)
-  #     csr = Flores::PKI::CertificateSigningRequest.new
-  #     csr.subject = "OU=Fancy Pants Inc."
-  #     certificate = csr.create_root(key)
-  #
-  # Example making an intermediate CA:
-  #     
-  #     root_key = OpenSSL::PKey::RSA.generate(4096, 65537)
-  #     root_csr = Flores::PKI::CertificateSigningRequest.new
-  #     root_csr.subject = "OU=Fancy Pants Inc."
-  #     root_csr.public_key = root_key.public
-  #     root_certificate = csr.create_root(root_key)
-  #
-  #     intermediate_key = OpenSSL::PKey::RSA.generate(4096, 65537)
-  #     intermediate_csr = Flores::PKI::CertificateSigningRequest.new
-  #     intermediate_csr.public_key = intermediate_key.public
-  #     intermediate_csr.subject = "OU=Fancy Pants Inc. Intermediate 1"
-  #     intermediate_certificate = csr.create_intermediate(root_certificate, root_key)
-  class CertificateSigningRequest
-    # raised when an invalid signing configuration is given
-    class InvalidRequest < StandardError; end
-
-    # raised when invalid data is present in a certificate request
-    class InvalidData < StandardError; end
-
-    # raised when an invalid subject (format, or whatever) is given in a certificate request
-    class InvalidSubject < InvalidData; end
-
-    # raised when an invalid time value is given for a certificate request
-    class InvalidTime < InvalidData; end
-
-    def initialize
-      self.serial = Flores::PKI.random_serial
-      self.digest_method = default_digest_method
-    end
-
-    private
-
-    def validate_subject(value)
-      OpenSSL::X509::Name.parse(value)
-    rescue OpenSSL::X509::NameError => e
-      raise InvalidSubject, "Invalid subject '#{value}'. (#{e})"
-    rescue TypeError => e
-      # Bug(?) in MRI 2.1.6(?)
-      raise InvalidSubject, "Invalid subject '#{value}'. (#{e})"
-    end
-
-    def subject=(value)
-      @subject = validate_subject(value)
-    end
-
-    attr_reader :subject
-
-    def subject_alternates=(values)
-      @subject_alternates = values
-    end
-
-    attr_reader :subject_alternates
-
-    def public_key=(value)
-      @public_key = validate_public_key(value)
-    end
-
-    def validate_public_key(value)
-      raise InvalidData, "public key must be a OpenSSL::PKey::PKey" unless value.is_a? OpenSSL::PKey::PKey
-      value
-    end
-
-    attr_reader :public_key
-
-    def start_time=(value)
-      @start_time = validate_time(value)
-    end
-
-    attr_reader :start_time
-
-    def expire_time=(value)
-      @expire_time = validate_time(value)
-    end
-
-    attr_reader :expire_time
-
-    def validate_time(value)
-      raise InvalidTime, "#{value.inspect} (class #{value.class.name})" unless value.is_a?(Time)
-      value
-    end
-
-    def certificate
-      return @certificate  if @certificate
-      @certificate = OpenSSL::X509::Certificate.new
-
-      # RFC5280
-      # > 4.1.2.1.  Version
-      # > version MUST be 3 (value is 2).
-      #
-      # Version value of '2' means a v3 certificate.
-      @certificate.version = 2
-
-      @certificate.subject = subject
-      @certificate.not_before = start_time
-      @certificate.not_after = expire_time
-      @certificate.public_key = public_key
-      @certificate
-    end
-
-    def default_digest_method
-      OpenSSL::Digest::SHA256.new
-    end
-
-    def self_signed?
-      @signing_certificate.nil?
-    end
-
-    def validate!
-      if self_signed?
-        if @signing_key.nil?
-          raise InvalidRequest, "No signing_key given. Cannot sign key."
-        end
-      elsif @signing_certificate.nil? && @signing_key
-        raise InvalidRequest, "signing_key given, but no signing_certificate is set"
-      elsif @signing_certificate && @signing_key.nil?
-        raise InvalidRequest, "signing_certificate given, but no signing_key is set"
-      end
-    end
-
-    def create
-      validate!
-      extensions = OpenSSL::X509::ExtensionFactory.new
-      extensions.subject_certificate = certificate
-      extensions.issuer_certificate = self_signed? ? certificate : signing_certificate
-
-      certificate.issuer = extensions.issuer_certificate.subject
-      certificate.add_extension(extensions.create_extension("subjectKeyIdentifier", "hash", false))
-
-      # RFC 5280 4.2.1.1. Authority Key Identifier
-      # This is "who signed this key"
-      certificate.add_extension(extensions.create_extension("authorityKeyIdentifier", "keyid:always", false))
-      #certificate.add_extension(extensions.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always", false))
-
-      if want_signature_ability?
-        # Create a CA.
-        certificate.add_extension(extensions.create_extension("basicConstraints", "CA:TRUE", true))
-        # Rough googling seems to indicate at least keyCertSign is required for CA and intermediate certs.
-        certificate.add_extension(extensions.create_extension("keyUsage", "keyCertSign, cRLSign, digitalSignature", true))
-      else
-        # Create a client+server certificate
-        #
-        # It feels weird to create a certificate that's valid as both server and client, but a brief inspection of major
-        # web properties (apple.com, google.com, yahoo.com, github.com, fastly.com, mozilla.com, amazon.com) reveals that
-        # major web properties have certificates with both clientAuth and serverAuth extended key usages. Further,
-        # these major server certificates all have digitalSignature and keyEncipherment for key usage.
-        #
-        # Here's the command I used to check this:
-        #    echo mozilla.com apple.com github.com google.com yahoo.com fastly.com elastic.co amazon.com \
-        #    | xargs -n1 sh -c 'openssl s_client -connect $1:443 \
-        #    | sed -ne "/-----BEGIN CERTIFICATE-----/,/-----END CERTIFICATE-----/p" \
-        #    | openssl x509 -text -noout | sed -ne "/X509v3 extensions/,/Signature Algorithm/p" | sed -e "s/^/$1 /"' - \
-        #    | grep -A2 'Key Usage'
-        certificate.add_extension(extensions.create_extension("keyUsage", "digitalSignature, keyEncipherment", true))
-        certificate.add_extension(extensions.create_extension("extendedKeyUsage", "clientAuth, serverAuth", false))
-      end
-
-      if @subject_alternates
-        certificate.add_extension(extensions.create_extension("subjectAltName", @subject_alternates.join(",")))
-      end
-        
-      certificate.serial = OpenSSL::BN.new(serial)
-      certificate.sign(signing_key, digest_method)
-      certificate
-    end
-
-    # Set the certificate which is going to be signing this request.
-    def signing_certificate=(certificate)
-      raise InvalidData, "signing_certificate must be an OpenSSL::X509::Certificate" unless certificate.is_a?(OpenSSL::X509::Certificate)
-      @signing_certificate = certificate
-    end
-    attr_reader :signing_certificate
-
-    attr_reader :signing_key
-    def signing_key=(private_key)
-      raise InvalidData, "signing_key must be an OpenSSL::PKey::PKey (or a subclass)" unless private_key.is_a?(OpenSSL::PKey::PKey)
-      @signing_key = private_key
-    end
-
-    def want_signature_ability=(value)
-      raise InvalidData, "want_signature_ability must be a boolean" unless value == true || value == false
-      @want_signature_ability = value
-    end
-
-    def want_signature_ability?
-      @want_signature_ability == true
-    end
-
-    attr_reader :digest_method
-    def digest_method=(value)
-      raise InvalidData, "digest_method must be a OpenSSL::Digest (or a subclass)" unless value.is_a?(OpenSSL::Digest)
-      @digest_method = value
-    end
-
-    attr_reader :serial
-    def serial=(value)
-      begin
-        Integer(value)
-      rescue
-        raise InvalidData, "Invalid serial value. Must be a number (or a String containing only nubers)"
-      end
-      @serial = value
-    end
-
-    public(:serial, :serial=)
-    public(:subject, :subject=)
-    public(:subject_alternates, :subject_alternates=)
-    public(:public_key, :public_key=)
-    public(:start_time, :start_time=)
-    public(:expire_time, :expire_time=)
-    public(:digest_method, :digest_method=)
-    public(:want_signature_ability?, :want_signature_ability=)
-    public(:signing_key, :signing_key=)
-    public(:signing_certificate, :signing_certificate=)
-    public(:create)
-  end # class CertificateSigningRequest
-end  # Flores::PKI

data/vendor/jruby/1.9/gems/flores-0.0.6/lib/flores/random.rb

@@ -1,196 +0,0 @@
-# encoding: utf-8
-# This file is part of ruby-flores.
-# Copyright (C) 2015 Jordan Sissel
-# 
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-# 
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-require "flores/namespace"
-autoload :Socket, "socket"
-
-# A collection of methods intended for use in randomized testing.
-module Flores::Random
-  # A selection of UTF-8 characters
-  #
-  # I'd love to generate this, but I don't yet know enough about how unicode
-  # blocks are allocated to do that. For now, hardcode a set of possible
-  # characters.
-  CHARACTERS = [
-    # Basic Latin
-    *(32..126).map(&:chr).map { |c| c.force_encoding(Encoding.default_external) },
-
-    # hand-selected CJK Unified Ideographs Extension A
-    "㐤", "㐨", "㐻", "㑐",
-
-    # hand-selected Hebrew
-    "א", "ב", "ג", "ד", "ה",
-
-    # hand-selected Cyrillic
-    "Є", "Б", "Р", "н", "я"
-  ]
-
-  # Generates text with random characters of a given length (or within a length range)
-  #
-  # * The length can be a number or a range `x..y`. If a range, it must be ascending (x < y)
-  # * Negative lengths are not permitted and will raise an ArgumentError
-  #
-  # @param length [Fixnum or Range] the length of text to generate
-  # @return [String] the generated text
-  def self.text(length)
-    return text_range(length) if length.is_a?(Range)
-
-    raise ArgumentError, "A negative length is not permitted, I received #{length}" if length < 0
-    length.times.collect { character }.join
-  end # def text
-
-  # Generate text with random characters of a length within the given range.
-  #
-  # @param range [Range] the range of length to generate, inclusive
-  # @return [String] the generated text
-  def self.text_range(range)
-    raise ArgumentError, "Requires ascending range, you gave #{range}." if range.end < range.begin
-    raise ArgumentError, "A negative range values are not permitted, I received range #{range}" if range.begin < 0
-    text(integer(range))
-  end
-
-  # Generates a random character (A string of length 1)
-  #
-  # @return [String]
-  def self.character
-    return CHARACTERS[integer(0...CHARACTERS.length)]
-  end # def character
-
-  # Return a random integer value within a given range.
-  #
-  # @param range [Range]
-  def self.integer(range)
-    raise ArgumentError, "Range not given, got #{range.class}: #{range.inspect}" if !range.is_a?(Range)
-    rand(range)
-  end # def integer
-
-  # Return a random number within a given range.
-  #
-  # @param range [Range]
-  def self.number(range)
-    raise ArgumentError, "Range not given, got #{range.class}: #{range.inspect}" if !range.is_a?(Range)
-    # Ruby 1.9.3 and below do not have Enumerable#size, so we have to compute the size of the range
-    # ourselves.
-    rand * (range.end - range.begin) + range.begin
-  end # def number
-   
-  # Run a block a random number of times.
-  #
-  # @param range [Fixnum of Range] same meaning as #integer(range)
-  def self.iterations(range, &block)
-    range = 0..range if range.is_a?(Numeric)
-    if block_given?
-      integer(range).times(&block)
-      nil
-    else
-      integer(range).times
-    end
-  end # def iterations
-
-  # Return a random element from an array
-  def self.item(array)
-    array[integer(0...array.size)]
-  end
-
-  # Return a random IPv4 address as a string
-  def self.ipv4
-    # TODO(sissel): Support CIDR range restriction?
-    # TODO(sissel): Support netmask restriction?
-    [integer(0..IPV4_MAX)].pack("N").unpack("C4").join(".")
-  end
-
-  # Return a random IPv6 address as a string
-  #
-  # The address may be in abbreviated form (ABCD::01EF):w
-  def self.ipv6
-    # TODO(sissel): Support CIDR range restriction?
-    # TODO(sissel): Support netmask restriction?
-    length = integer(2..8)
-    if length == 8
-      # Full address; nothing to abbreviate
-      ipv6_pack(length)
-    else
-      abbreviation = ipv6_abbreviation(length)
-      if length == 2
-        first = 1
-        second = 1
-      else
-        first = integer(2...length)
-        second = length - first
-      end
-      ipv6_pack(first) + abbreviation + ipv6_pack(second)
-    end
-  end
-
-  # Get a TCP socket bound and listening on a random port.
-  #
-  # You are responsible for closing the socket.
-  #
-  # Returns [socket, address, port]
-  def self.tcp_listener(host = "127.0.0.1")
-    socket_listener(Socket::SOCK_STREAM, host)
-  end
-
-  # Get a UDP socket bound and listening on a random port.
-  #
-  # You are responsible for closing the socket.
-  #
-  # Returns [socket, address, port]
-  def self.udp_listener(host = "127.0.0.1")
-    socket_listener(Socket::SOCK_DGRAM, host)
-  end
-
-  private
-
-  IPV4_MAX = 1 << 32
-  IPV6_SEGMENT = 1 << 16
-
-  def self.ipv6_pack(length)
-    length.times.collect { integer(0..IPV6_SEGMENT).to_s(16) }.join(":")
-  end
-
-  def self.ipv6_abbreviation(length)
-    abbreviate = (integer(0..1) == 0)
-    if abbreviate
-      "::"
-    else
-      ":" + (8 - length).times.collect { "0" }.join(":") + ":"
-    end
-  end
-
-  LISTEN_BACKLOG = 5
-  def self.socket_listener(type, host)
-    socket = server_socket_class.new(Socket::AF_INET, type)
-    socket.bind(Socket.pack_sockaddr_in(0, host))
-    if type == Socket::SOCK_STREAM || type == Socket::SOCK_SEQPACKET
-      socket.listen(LISTEN_BACKLOG)
-    end
-
-    port = socket.local_address.ip_port
-    address = socket.local_address.ip_address
-    [socket, address, port]
-  end
-
-  def self.server_socket_class
-    if RUBY_ENGINE == 'jruby'
-      # https://github.com/jruby/jruby/wiki/ServerSocket
-      ServerSocket
-    else
-      Socket
-    end
-  end
-end # module Flores::Random

data/vendor/jruby/1.9/gems/flores-0.0.6/lib/flores/rspec/analyze.rb

@@ -1,158 +0,0 @@
-# encoding: utf-8
-# This file is part of ruby-flores.
-# Copyright (C) 2015 Jordan Sissel
-# 
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-# 
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-require "flores/namespace"
-require "flores/rspec"
-
-# RSpec helpers for stress testing examples
-#
-# Setting it up in rspec:
-#
-#     RSpec.configure do |c|
-#       c.extend RSpec::StressIt
-#     end
-#
-# TODO(sissel): Show an example of stress_it and analyze_it
-module Flores::RSpec::Analyze
-  # Save state after each example so it can be used in analysis after specs are completed.
-  #
-  # If you use this, you'll want to set your RSpec formatter to
-  # Flores::RSpec::Formatter::Analyze
-  #
-  # Let's show an example that fails sometimes.
-  #
-  #     describe "Addition of two numbers" do
-  #       context "positive numbers" do
-  #         analyze_results
-  #         let(:a) { Flores::Random.number(1..1000) }
-  #     
-  #         # Here we make negative numbers possible to cause failure in our test.
-  #         let(:b) { Flores::Random.number(-200..1000) }
-  #         subject { a + b }
-  #     
-  #         stress_it "should be positive" do
-  #           expect(subject).to(be > 0)
-  #         end
-  #       end
-  #     end
-  #
-  # And running it:
-  #
-  #     % rspec -f Flores::RSpec::Formatter::Analyze
-  #     Addition of two numbers positive numbers should be positive
-  #       98.20% tests successful of 3675 tests
-  #       Failure analysis:
-  #         1.80% -> [66] RSpec::Expectations::ExpectationNotMetError
-  #           Sample exception for {:a=>126.21705882478048, :b=>-139.54814492675024, :subject=>-13.33108610196976}
-  #             expected: > 0
-  #                  got:   -13.33108610196976
-  #           Samples causing RSpec::Expectations::ExpectationNotMetError:
-  #             {:a=>90.67298249206425, :b=>-136.6237821353908, :subject=>-45.95079964332655}
-  #             {:a=>20.35865155878871, :b=>-39.592417377658876, :subject=>-19.233765818870165}
-  #             {:a=>158.07905166101787, :b=>-177.5864470909581, :subject=>-19.50739542994023}
-  #             {:a=>31.80445518715138, :b=>-188.51942190504894, :subject=>-156.71496671789757}
-  #             {:a=>116.1479954937354, :b=>-146.18477887927958, :subject=>-30.036783385544183}
-  def analyze_results
-    # TODO(sissel): Would be lovely to figure out how to inject an 'after' for
-    # all examples if we are using the Analyze formatter.
-    # Then this method could be implied by using the right formatter, or something.
-    after do |example|
-      example.metadata[:values] = __memoized.clone
-    end
-  end
-
-  # A formatter to show analysis of an `analyze_it` example. 
-  class Analysis < StandardError
-    def initialize(results)
-      @results = results
-    end # def initialize
-
-    def total
-      @results.reduce(0) { |m, (_, v)| m + v.length }
-    end # def total
-
-    def success_count
-      if @results.include?(:passed)
-        @results[:passed].length
-      else
-        0
-      end
-    end # def success_count
-
-    def success_and_pending_count
-      count = 0
-      [:passed, :pending].each do |group|
-        count += @results[group].length
-      end
-      count
-    end # def success_count
-
-    def percent(count)
-      return (count + 0.0) / total
-    end # def percent
-
-    def percent_s(count)
-      return format("%.2f%%", percent(count) * 100)
-    end # def percent_s
-
-    def to_s # rubocop:disable Metrics/AbcSize
-      # This method is crazy complex for a formatter. Should refactor this significantly.
-      report = []
-      if @results[:pending].any?
-        # We have pending examples, put a clear message.
-        report << "#{percent_s(success_and_pending_count)} (of #{total} total) tests are successful or pending"
-      else
-        report << "#{percent_s(success_count)} (of #{total} total) tests are successful"
-      end
-      report += failure_summary if success_and_pending_count < total
-      report.join("\n")
-    end # def to_s
-
-    # TODO(sissel): All these report/summary/to_s things are an indication that the
-    # report formatting belongs in a separate class.
-    def failure_summary
-      report = ["Failure analysis:"]
-      report += @results.sort_by { |_, v| -v.length }.collect do |group, instances|
-        next if group == :passed
-        next if group == :pending
-        error_report(group, instances)
-      end.reject(&:nil?).flatten
-      report
-    end # def failure_summary
-
-    def error_report(error, instances)
-      report = error_summary(error, instances)
-      report += error_sample_states(error, instances) if instances.size > 1
-      report
-    end # def error_report
-
-    def error_summary(error, instances)
-      sample = instances.sample(1)
-      [ 
-        "  #{percent_s(instances.length)} -> [#{instances.length}] #{error}",
-        "    Sample exception for #{sample.first[0]}",
-        sample.first[1].to_s.gsub(/^/, "      ")
-      ]
-    end # def error_summary
-
-    def error_sample_states(error, instances)
-      [ 
-        "    Samples causing #{error}:",
-        *instances.sample(5).collect { |state, _exception| "      #{state}" }
-      ]
-    end # def error_sample_states
-  end # class Analysis
-end # Flores::RSpec::Analyze