pwn 0.5.509 → 0.5.510

data/lib/pwn/plugins/slack_client.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'slack-ruby-client'
+
+module PWN
+  module Plugins
+    # This plugin is used for interacting w/ Slack over the Web API.
+    module SlackClient
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # PWN::Plugins::SlackClient.login(
+      #   api_token: 'required slack api token'
+      # )
+
+      public_class_method def self.login(opts = {})
+        api_token = opts[:api_token]
+
+        if opts[:api_token].nil?
+          api_token = PWN::Plugins::AuthenticationHelper.mask_password
+        else
+          api_token = opts[:api_token].to_s.scrub
+        end
+
+        @@logger.info('Logging into Slack...')
+        slack_obj = Slack::Web::Client.new
+        slack_obj.token = api_token
+        slack_obj.auth_test
+
+        slack_obj
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::SlackClient.post_message(
+      #   slack_obj: 'required slack_obj returned from login method',
+      #   channel: 'required #channel to post message',
+      #   message: 'required message to post'
+      # )
+
+      public_class_method def self.post_message(opts = {})
+        slack_obj = opts[:slack_obj]
+        channel = opts[:channel].to_s.scrub
+        message = opts[:message].to_s.scrub
+
+        slack_obj.chat_postMessage(
+          channel: channel,
+          text: message,
+          as_user: true
+        )
+
+        slack_obj
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::SlackClient.logout(
+      #   slack_obj: 'required slack_obj returned from login method'
+      # )
+
+      public_class_method def self.logout(opts = {})
+        slack_obj = opts[:slack_obj]
+        @@logger.info('Logging out...')
+        slack_obj.token = nil
+        slack_obj = nil
+        @@logger.info('Complete.')
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: 0day Inc. <support@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <support@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          slack_obj = #{self}.login(
+            api_token: 'optional slack api token (will prompt if blank)'
+          )
+
+          #{self}.post_message(
+            slack_obj: 'required slack_obj returned from login method',
+            channel: 'required #channel to post message',
+            message: 'required message to post'
+          )
+
+          #{self}.logout(
+            slack_obj: 'required slack_obj returned from login method'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/sock.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'openssl'
+
+module PWN
+  module Plugins
+    # This plugin was created to support fuzzing various networking protocols
+    module Sock
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # sock_obj = PWN::Plugins::Sock.connect(
+      #   target: 'required - target host or ip',
+      #   port: 'required - target port',
+      #   protocol: 'optional - :tcp || :udp (defaults to :tcp)',
+      #   tls: 'optional - boolean connect to target socket using TLS (defaults to false)'
+      # )
+
+      public_class_method def self.connect(opts = {})
+        target = opts[:target].to_s.scrub
+        port = opts[:port].to_i
+
+        protocol = opts[:protocol]
+        protocol ||= :tcp
+
+        # TODO: Add proxy support
+
+        tls = true if opts[:tls]
+        tls ||= false
+
+        tls_min_version = OpenSSL::SSL::TLS1_VERSION if tls_min_version.nil?
+
+        case protocol.to_s.to_sym
+        when :tcp
+          if tls
+            sock = TCPSocket.open(target, port)
+            tls_context = OpenSSL::SSL::SSLContext.new
+            tls_context.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)
+            tls_context.min_version = tls_min_version
+            # tls_context.ciphers = tls_context.ciphers.select do |cipher|
+            #   cipher[1] == cipher_tls
+            # end
+            tls_sock = OpenSSL::SSL::SSLSocket.new(sock, tls_context)
+            tls_sock.hostname = target
+            sock_obj = tls_sock.connect
+            sock_obj.sync_close = true
+          else
+            sock_obj = TCPSocket.open(target, port)
+          end
+        when :udp
+          sock_obj = UDPSocket.new
+          sock_obj.connect(target, port)
+        else
+          raise "Unsupported protocol: #{protocol}"
+        end
+
+        sock_obj
+      rescue OpenSSL::SSL::SSLError => e
+        case tls_min_version
+        when OpenSSL::SSL::TLS1_VERSION
+          puts 'Attempting OpenSSL::SSL::TLS1_1_VERSION...'
+          # cipher_tls = 'TLSv1.0'
+          tls_min_version = OpenSSL::SSL::TLS1_1_VERSION
+        when OpenSSL::SSL::TLS1_1_VERSION
+          puts 'Attempting OpenSSL::SSL::TLS1_2_VERSION...'
+          # cipher_tls = 'TLSv1.2'
+          tls_min_version = OpenSSL::SSL::TLS1_2_VERSION
+        when OpenSSL::SSL::TLS1_2_VERSION
+          puts 'Attempting OpenSSL::SSL::TLS1_3_VERSION...'
+          # cipher_tls = 'TLSv1.3'
+          tls_min_version = OpenSSL::SSL::TLS1_3_VERSION
+        else
+          tls_min_version = :abort
+        end
+
+        retry unless tls_min_version == :abort
+        raise "\n#{e.inspect}" if tls_min_version == :abort
+      rescue StandardError => e
+        sock_obj = disconnect(sock_obj: sock_obj) unless sock_obj.nil?
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::Sock.get_random_unused_port(
+      #   server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
+      #   protocol: 'optional - :tcp || :udp (defaults to tcp)'
+      # )
+
+      public_class_method def self.get_random_unused_port(opts = {})
+        server_ip = opts[:server_ip]
+        server_ip ||= '127.0.0.1'
+        port = -1
+        protocol = opts[:protocol]
+        protocol ||= :tcp
+
+        port_in_use = true
+        while port_in_use
+          port = Random.rand(1024..65_535)
+          port_in_use = check_port_in_use(
+            server_ip: server_ip,
+            port: port,
+            protocol: protocol
+          )
+        end
+
+        port
+      rescue Errno::ECONNREFUSED,
+             Errno::EHOSTUNREACH,
+             Errno::ETIMEDOUT
+        false
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::Sock.check_port_in_use(
+      #   server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
+      #   port: 'required - target port',
+      #   protocol: 'optional - :tcp || :udp (defaults to tcp)'
+      # )
+
+      public_class_method def self.check_port_in_use(opts = {})
+        server_ip = opts[:server_ip]
+        server_ip ||= '127.0.0.1'
+        port = opts[:port]
+        protocol = opts[:protocol]
+        protocol ||= :tcp
+
+        # TODO: Add proxy support
+
+        ct = 1
+        s = Socket.tcp(server_ip, port, connect_timeout: ct) if protocol == :tcp
+        s = Socket.udp(server_ip, port, connect_timeout: ct) if protocol == :udp
+        s.close
+
+        true
+      rescue Errno::ECONNREFUSED,
+             Errno::EHOSTUNREACH,
+             Errno::ETIMEDOUT
+        false
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::Sock.listen(
+      #   server_ip: 'required - target host or ip to listen',
+      #   port: 'required - target port',
+      #   protocol: 'optional - :tcp || :udp (defaults to tcp)',
+      #   tls: 'optional - boolean listen on TLS-enabled socket (defaults to false)'
+      # )
+
+      public_class_method def self.listen(opts = {})
+        server_ip = opts[:server_ip].to_s.scrub
+        port = opts[:port].to_i
+        opts[:protocol].nil? ? protocol = :tcp : protocol = opts[:protocol].to_s.downcase.to_sym
+        tls = true if opts[:tls]
+        tls ||= false
+
+        case protocol
+        when :tcp
+          if tls
+            # Multi-threaded - Not working
+            sock = TCPServer.open(server_ip, port)
+            tls_context = OpenSSL::SSL::SSLContext.new
+            tls_context.set_params(verify_mode: OpenSSL::SSL::VERIFY_NONE)
+            listen_obj = OpenSSL::SSL::SSLServer.new(sock, tls_context)
+            # loop do
+            #   Thread.start(listen_obj.accept) do |client_thread|
+            #     while (client_input = client_thread.gets)
+            #       puts client_input
+            #     end
+            #     client_thread.close
+            #   end
+            # end
+          else
+            # Multi-threaded
+            listen_obj = TCPServer.open(server_ip, port)
+            loop do
+              Thread.start(listen_obj.accept) do |client_thread|
+                while (client_input = client_thread.gets)
+                  puts client_input
+                end
+                client_thread.close
+              end
+            end
+          end
+        when :udp
+          # Single Threaded
+          listen_obj = UDPSocket.new
+          listen_obj.bind(server_ip, port)
+          while (client_input = listen_obj.recvmsg)
+            puts client_input[0]
+          end
+        else
+          raise "Unsupported protocol: #{protocol}"
+        end
+      rescue StandardError => e
+        raise e
+      ensure
+        listen_obj = disconnect(sock_obj: listen_obj) unless listen_obj.nil?
+      end
+
+      # Supported Method Parameters::
+      # cert_obj = PWN::Plugins::Sock.get_tls_cert(
+      #   target: 'required - target host or ip',
+      #   port: 'optional - target port (defaults to 443)'
+      # )
+
+      public_class_method def self.get_tls_cert(opts = {})
+        target = opts[:target].to_s.scrub
+        port = opts[:port]
+        port ||= 443
+
+        tls_sock_obj = connect(
+          target: target,
+          port: port,
+          protocol: :tcp,
+          tls: true
+        )
+        tls_sock_obj.peer_cert
+      rescue StandardError => e
+        raise e
+      ensure
+        tls_sock_obj = disconnect(sock_obj: tls_sock_obj) unless tls_sock_obj.nil?
+      end
+
+      # Supported Method Parameters::
+      # sock_obj = PWN::Plugins::Sock.disconnect(
+      #   sock_obj: 'required - sock_obj returned from #connect method'
+      # )
+
+      public_class_method def self.disconnect(opts = {})
+        sock_obj = opts[:sock_obj]
+        sock_obj.close
+        sock_obj = nil
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: 0day Inc. <support@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <support@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          sock_obj = #{self}.connect(
+            target: 'required - target host or ip',
+            port: 'required - target port',
+            protocol: 'optional - :tcp || :udp (defaults to tcp)',
+            tls: 'optional - boolean connect to target socket using TLS (defaults to false)'
+          )
+
+          port = #{self}.get_random_unused_port(
+            server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
+            protocol: 'optional - :tcp || :udp (defaults to tcp)'
+          )
+
+          #{self}.check_port_in_use(
+            server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
+            port: 'required - target port',
+            protocol: 'optional - :tcp || :udp (defaults to tcp)'
+          )
+
+          #{self}.listen(
+            server_ip: 'required - target host or ip to listen',
+            port: 'required - target port',
+            protocol: 'optional - :tcp || :udp (defaults to tcp)',
+            tls: 'optional - boolean listen on TLS-enabled socket (defaults to false)'
+          )
+
+          cert_obj = #{self}.get_tls_cert(
+            target: 'required - target host or ip',
+            port: 'optional - target port (defaults to 443)'
+          )
+
+          sock_obj = #{self}.disconnect(
+            sock_obj: 'required - sock_obj returned from #connect method'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/spider.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'anemone'
+
+module PWN
+  module Plugins
+    # This plugin supports Pastebin actions.
+    module Spider
+      # Supported Method Parameters::
+      # PWN::Plugins::Spider.crawl(
+      #   target_fqdn: 'required - target fqdn to spider',
+      #   results_path: 'required - path to save spider results',
+      #   proxy: 'optional - proxy to spider through e.g. http://127.0.0.1:8080'
+      # )
+
+      public_class_method def self.crawl(opts = {})
+        # TODO: Add AuthN Support
+        # FYI: Anemone very well may have a memory leak.
+        # Despite saving results to file, Anemone causes
+        # memory exhaustion on large sites
+        target_fqdn = opts[:target_fqdn].to_s.scrub.strip.chomp
+        results_path = opts[:results_path].to_s.scrub.strip.chomp
+
+        proxy = opts[:proxy].to_s.scrub.strip.chomp unless opts[:proxy].nil?
+
+        # Colors!
+        green = "\e[32m"
+        yellow = "\e[33m"
+        end_of_color = "\e[0m"
+
+        puts "#{green}Spidering Target FQDN: #{target_fqdn}#{end_of_color}"
+        File.open(results_path, 'w') do |f|
+          if proxy
+            proxy_uri = URI.parse(proxy)
+            proxy_hash = { proxy_host: proxy_uri.host, proxy_port: proxy_uri.port }
+            Anemone.crawl(target_fqdn, proxy_hash) do |anemone|
+              anemone.on_every_page do |page|
+                puts "#{yellow}Discovered: #{page.url}#{end_of_color}"
+                f.puts(page.url)
+              end
+            end
+          else
+            Anemone.crawl(target_fqdn) do |anemone|
+              anemone.on_every_page do |page|
+                puts "#{green}Discovered: #{page.url}#{end_of_color}"
+                f.puts(page.url)
+              end
+            end
+          end
+        end
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: 0day Inc. <support@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <support@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts %{USAGE:
+          #{self}.crawl(
+            target_fqdn: 'required - target fqdn to spider',
+            results_path: 'required - path to save spider results',
+            proxy: 'optional - proxy to spider through e.g. http://127.0.0.1:8080'
+          )
+
+          #{self}.authors
+        }
+      end
+    end
+  end
+end

data/lib/pwn/plugins/ssn.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PWN
+  module Plugins
+    # This plugin provides useful social security number capabilities
+    module SSN
+      # Supported Method Parameters::
+      # PWN::Plugins::SSN.generate(
+      #   count: 'required - number of SSN numbers to generate'
+      # )
+
+      public_class_method def self.generate(opts = {})
+        count = opts[:count].to_i
+
+        # Based upon new SSN Randomization:
+        # https://www.ssa.gov/employer/randomization.html
+        ssn_result_arr = []
+        (1..count).each do
+          this_area = format('%0.3d', Random.rand(1..999))
+          this_group = format('%0.2d', Random.rand(1..99))
+          this_serial = format('%0.4d', Random.rand(1..9999))
+          this_ssn = "#{this_area}-#{this_group}-#{this_serial}"
+          ssn_result_arr.push(this_ssn)
+        end
+
+        ssn_result_arr
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: 0day Inc. <support@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <support@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.generate(
+            count: 'required - number of SSN numbers to generate'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/thread_pool.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+module PWN
+  module Plugins
+    # This plugin makes the creation of a thread pool much simpler.
+    module ThreadPool
+      # Supported Method Parameters::
+      # PWN::Plugins::ThreadPool.fill(
+      #   enumerable_array: 'required array for proper thread pool assignment',
+      #   max_threads: 'optional number of threads in the thread pool (defaults to 9)',
+      #   detach: 'optional boolean to detach threads (defaults to false)'
+      # )
+      #
+      # Example:
+      # arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      # mutex = Mutex.new
+      # PWN::Plugins::ThreadPool.fill(enumerable_array: arr, max_threads: 9) do |integer|
+      #   mutex.synchronize do
+      #     puts integer
+      #   end
+      # end
+
+      public_class_method def self.fill(opts = {})
+        enumerable_array = opts[:enumerable_array]
+        max_threads = opts[:max_threads].to_i
+        max_threads = 9 if max_threads.zero?
+        detach = opts[:detach] ||= false
+
+        puts "Initiating Thread Pool of #{max_threads} Worker Threads...."
+        pool = Concurrent::FixedThreadPool.new(max_threads)
+
+        enumerable_array.each do |this_thread|
+          pool.post do
+            yield this_thread
+          end
+        end
+
+        pool.shutdown
+        pool.wait_for_termination unless detach
+      rescue Interrupt
+        puts "\n#{self}.#{__method__} => Goodbye."
+      rescue StandardError => e
+        puts e.backtrace
+        raise e
+      ensure
+        pool.kill if pool.running?
+      end
+
+      # Author(s):: 0day Inc. <support@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <support@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.fill(
+            enumerable_array. => 'required array for proper thread pool assignment',
+            max_threads: 'optional number of threads in the thread pool (defaults to 9)',
+            detach: 'optional boolean to detach threads (defaults to false)'
+          )
+
+          Example:
+          arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+          #{self}.fill(enumerable_array: arr, max_threads: 9) do |integer|
+            puts integer
+          end
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end