pwn 0.5.508 → 0.5.509

data/lib/pwn/plugins/slack_client.rb

@@ -1,104 +0,0 @@
-# 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

@@ -1,289 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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

@@ -1,52 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-# 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