ronin 1.5.1 → 2.0.0.beta1

data/lib/ronin/cli/commands/http.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2023 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/cli/value_processor_command'
+require 'ronin/cli/printing/http'
+require 'ronin/cli/http_shell'
+require 'ronin/support/network/http'
+
+require 'command_kit/options/verbose'
+
+module Ronin
+  class CLI
+    module Commands
+      #
+      # Send HTTP requests or spawn an interactive HTTP shell.
+      #
+      # ## Usage
+      #
+      #     ronin http [options] [URL [...] | --shell URL]
+      #
+      # ## Options
+      #
+      #     -v, --verbose                    Enables verbose output
+      #     -f, --file FILE                  Optional file to read values from
+      #         --method HTTP_METHOD         Send the HTTP request method
+      #         --get                        Send a GET request
+      #         --head                       Send a HEAD request
+      #         --patch                      Send a PATCH request
+      #         --post                       Send a POST request
+      #         --put                        Send a PUT request
+      #         --copy                       Send a COPY request
+      #         --delete                     Send a DELETE request
+      #         --lock                       Send a LOCK request
+      #         --options                    Send a OPTIONS request
+      #         --mkcol                      Send a MKCOL request
+      #         --move                       Send a MOVE request
+      #         --propfind                   Send a PROPFIND request
+      #         --proppatch                  Send a PROPPATCH request
+      #         --trace                      Send a TRACE request
+      #         --unlock                     Send an UNLOCK request
+      #         --shell URL                  Open an interactive HTTP shell
+      #     -P, --proxy URL                  The proxy to use
+      #     -U, --user-agent-string STRING   The User-Agent string to use
+      #     -u chrome_linux|chrome_macos|chrome_windows|chrome_iphone|chrome_ipad|chrome_android|firefox_linux|firefox_macos|firefox_windows|firefox_iphone|firefox_ipad|firefox_android|safari_macos|safari_iphone|safari_ipad|edge,
+      #         --user-agent                 The User-Agent to use
+      #     -H, --header "NAME: VALUE"       Adds a header to the request
+      #     -B, --body STRING                The request body
+      #     -F, --body-file FILE             Sends the file as the request body
+      #     -f, --form-data NAME=VALUE       Adds a value to the form data
+      #     -q, --query-param NAME=VALUE     Adds a query param to the URL
+      #     -h, --help                       Print help information
+      #
+      # ## Arguments
+      #
+      #     [URL ...]                        The URL(s) to request
+      #
+      class Http < ValueProcessorCommand
+
+        include CommandKit::Options::Verbose
+        include Printing::HTTP
+
+        usage '[options] {URL [...] | --shell URL}'
+
+        option :method, value: {
+                          type: {
+                            'COPY'      => :copy,
+                            'DELETE'    => :delete,
+                            'GET'       => :get,
+                            'HEAD'      => :head,
+                            'LOCK'      => :lock,
+                            'MKCOL'     => :mkcol,
+                            'MOVE'      => :move,
+                            'OPTIONS'   => :options,
+                            'PATCH'     => :patch,
+                            'POST'      => :post,
+                            'PROPFIND'  => :propfind,
+                            'PROPPATCH' => :proppatch,
+                            'PUT'       => :put,
+                            'TRACE'     => :trace,
+                            'UNLOCK'    => :unlock
+                          },
+                          usage: 'HTTP_METHOD'
+                        },
+                        desc: 'Send the HTTP request method' do |name|
+                          @http_method = name
+                        end
+
+        option :get, desc: 'Send a GET request' do
+          @http_method = :get
+        end
+        option :head, desc: 'Send a HEAD request' do
+          @http_method = :head
+        end
+        option :patch, desc: 'Send a PATCH request' do
+          @http_method = :patch
+        end
+        option :post, desc: 'Send a POST request' do
+          @http_method = :post
+        end
+        option :put, desc: 'Send a PUT request' do
+          @http_method = :put
+        end
+        option :copy, desc: 'Send a COPY request' do
+          @http_method = :copy
+        end
+        option :delete, desc: 'Send a DELETE request' do
+          @http_method = :delete
+        end
+        option :lock, desc: 'Send a LOCK request' do
+          @http_method = :lock
+        end
+        option :options, desc: 'Send a OPTIONS request' do
+          @http_method = :options
+        end
+        option :mkcol, desc: 'Send a MKCOL request' do
+          @http_method = :mkcol
+        end
+        option :move, desc: 'Send a MOVE request' do
+          @http_method = :move
+        end
+        option :propfind, desc: 'Send a PROPFIND request' do
+          @http_method = :propfind
+        end
+        option :proppatch, desc: 'Send a PROPPATCH request' do
+          @http_method = :proppatch
+        end
+        option :trace, desc: 'Send a TRACE request' do
+          @http_method = :trace
+        end
+        option :unlock, desc: 'Send an UNLOCK request' do
+          @http_method = :unlock
+        end
+
+        option :shell, value: {
+                         type:  String,
+                         usage: 'URL'
+                       },
+                       desc: 'Open an interactive HTTP shell'
+
+        option :proxy, short: '-P',
+                       value: {
+                         type:   String,
+                         usage: 'URL'
+                       },
+                       desc: 'The proxy to use' do |proxy|
+                         @proxy = URI.parse(proxy)
+                       end
+
+        option :user_agent_string, short: '-U',
+                                   value: {
+                                     type: String,
+                                     usage: 'STRING'
+                                   },
+                                   desc: 'The User-Agent string to use' do |ua|
+                                     @user_agent = ua
+                                   end
+
+        option :user_agent, short: '-u',
+                            value: {
+                              type: Support::Network::HTTP::UserAgents::ALIASES.keys
+                            },
+                            desc: 'The User-Agent to use' do |name|
+                              @user_agent = name
+                            end
+
+        option :header, short: '-H',
+                        value: {
+                          type:  /[^\s:]+:.+/,
+                          usage: '\"NAME: VALUE\"'
+                        },
+                        desc: 'Adds a header to the request' do |str|
+                          name, value = str.split(/:\s*/,2)
+
+                          @headers[name] = value
+                        end
+
+        option :body, short: '-B',
+                      value: {
+                        type:  String,
+                        usage: 'STRING'
+                      },
+                      desc: 'The request body' do |str|
+                        @body = str
+                      end
+
+        option :body_file, short: '-F',
+                           value: {
+                             type:  String,
+                             usage: 'FILE'
+                           },
+                           desc: 'Sends the file as the request body' do |path|
+                             @body = File.new(path)
+                           end
+
+        option :form_data, short: '-f',
+                           value: {
+                             type:  /[^=]+=.*/,
+                             usage: 'NAME=VALUE'
+                           },
+                           desc: 'Adds a value to the form data' do |str|
+                             name, value = str.split('=',2)
+
+                             @form_data[name] = value
+                           end
+
+        option :query_param, short: '-q',
+                             value: {
+                               type:  /[^=]+=.*/,
+                               usage: 'NAME=VALUE'
+                             },
+                             desc: 'Adds a query param to the URL' do |str|
+                               name, value = str.split('=',2)
+
+                               @query_params[name] = value
+                             end
+
+        argument :url, required: false,
+                       repeats:  true,
+                       desc:     'The URL(s) to request'
+
+        description "Send HTTP requests or spawn an interactive HTTP shell"
+
+        man_page 'ronin-http.1'
+
+        # The optional proxy to use.
+        #
+        # @return [URI::HTTP, nil]
+        attr_reader :proxy
+
+        # The HTTP request method.
+        #
+        # @return [Symbol]
+        attr_reader :http_method
+
+        # Additional HTTP request headers to send.
+        #
+        # @return [Hash{String => String}]
+        attr_reader :headers
+
+        # Optional `User-agent` string to use.
+        #
+        # @return [String, nil]
+        attr_reader :user_agent
+
+        # Additional URL query params.
+        #
+        # @return [Hash{String => String}]
+        attr_reader :query_params
+
+        # Form data.
+        #
+        # @return [Hash{String => String}]
+        attr_reader :form_data
+
+        #
+        # Initializes the `ronin http` command.
+        #
+        # @param [Hash{Symbol => Object}] kwargs
+        #   Additional keyword arguments.
+        #
+        def initialize(**kwargs)
+          super(**kwargs)
+
+          @proxy        = nil
+          @http_method  = :get
+          @headers      = {}
+          @user_agent   = nil
+          @query_params = {}
+          @form_data    = {}
+        end
+
+        #
+        # Runs the `ronin http` command.
+        #
+        # @param [Array<String>] urls
+        #   The URL(s) to request.
+        #
+        def run(*urls)
+          if options[:shell]
+            start_shell(options[:shell])
+          else
+            super(*urls)
+          end
+        end
+
+        #
+        # Start the {HTTPShell}.
+        #
+        # @param [String] base_url
+        #   The base URL to connect to.
+        #
+        def start_shell(base_url)
+          HTTPShell.start(base_url, proxy:      @proxy,
+                                    headers:    @headers,
+                                    user_agent: @user_agent)
+        end
+
+        #
+        # Requests the given URL.
+        #
+        # @param [String] url
+        #   The URL to request.
+        #
+        def process_value(url)
+          url = URI(url)
+
+          Support::Network::HTTP.connect_uri(url, proxy:      @proxy,
+                                                  user_agent: @user_agent) do |http|
+            http.request(
+              @http_method, url.request_uri, user:         url.user,
+                                             password:     url.password,
+                                             query_params: @query_params,
+                                             headers:      @headers,
+                                             body:         @body,
+                                             form_data:    @form_data,
+                                             &method(:print_response))
+          end
+        end
+
+        #
+        # Prints the HTTP response.
+        #
+        # @param [Net::HTTPResponse] response
+        #   The HTTP response object.
+        #
+        # @note
+        #   If `--verbose` is specified then the response headers will also be
+        #   printed.
+        #
+        # @see HTTPMethods#print_response
+        #
+        def print_response(response)
+          super(response, show_headers: options[:verbose])
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/cli/commands/ip.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2023 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/cli/value_processor_command'
+require 'ronin/support/network/ip'
+require 'uri'
+
+module Ronin
+  class CLI
+    module Commands
+      #
+      # Queries or processes IP addresses.
+      #
+      # ## Usage
+      #
+      #     ronin ip [options] [IP ... | --public | --local]
+      #
+      # ## Options
+      #
+      #     -f, --file FILE                  Optional file to read values from
+      #     -P, --public                     Gets the machine's public IP address
+      #     -L, --local                      Gets the machine's local IP address
+      #     -r, --reverse                    Prints the IP address in reverse name format
+      #     -X, --hex                        Converts the IP address to hexadecimal format
+      #     -D, --decimal                    Converts the IP address to decimal format
+      #     -O, --octal                      Converts the IP address to octal format
+      #     -B, --binary                     Converts the IP address to binary format
+      #     -C, --cidr NETMASK               Converts the IP address into a CIDR range
+      #     -H, --host                       Converts the IP address to a host name
+      #     -p, --port PORT                  Appends the port number to each IP
+      #     -U, --uri                        Converts the IP address into a URI
+      #         --uri-scheme SCHEME          The scheme for the URI (Default: http)
+      #         --uri-port PORT              The port for the URI
+      #         --uri-path /PATH             The path for the URI (Default: /)
+      #         --uri-query STRING           The query string for the URI
+      #         --http                       Converts the IP address into a http:// URI
+      #         --https                      Converts the IP address into a https:// URI
+      #     -h, --help                       Print help information
+      #
+      # ## Arguments
+      #
+      #     [IP ...]                         The IP address(es) to process
+      #
+      # ## Examples
+      #
+      #     ronin ip --public
+      #     ronin ip --local
+      #     ronin ip --decimal 1.2.3.4
+      #     ronin ip --cidr 20 1.2.3.4
+      #     ronin ip --host 192.30.255.113
+      #
+      class Ip < ValueProcessorCommand
+
+        usage '[options] {IP ... | --public | --local}'
+
+        option :public, short: '-P',
+                        desc: "Gets the machine's public IP address"
+
+        option :local, short: '-L',
+                       desc:  "Gets the machine's local IP address"
+
+        option :reverse, short: '-r',
+                         desc:  'Prints the IP address in reverse name format'
+
+        option :hex, short: '-X',
+                     desc:  'Converts the IP address to hexadecimal format'
+
+        option :decimal, short: '-D',
+                         desc:  'Converts the IP address to decimal format'
+
+        option :octal, short: '-O',
+                       desc:  'Converts the IP address to octal format'
+
+        option :binary, short: '-B',
+                        desc:  'Converts the IP address to binary format'
+
+        option :cidr, short: '-C',
+                      value: {
+                        type:  String,
+                        usage: 'NETMASK'
+                      },
+                      desc: 'Converts the IP address into a CIDR range'
+
+        option :host, short: '-H',
+                      desc:  'Converts the IP address to a host name'
+
+        option :port, short: '-p',
+                      value: {
+                        type:  Integer,
+                        usage: 'PORT'
+                      },
+                      desc:  'Appends the port number to each IP'
+
+        option :uri, short: '-U', desc: 'Converts the IP address into a URI'
+
+        option :uri_scheme, value: {
+                              type:    String,
+                              default: 'http',
+                              usage:   'SCHEME'
+                            },
+                            desc: 'The scheme for the URI'
+
+        option :uri_port, value: {
+                            type:  Integer,
+                            usage: 'PORT'
+                          },
+                          desc: 'The port for the URI'
+
+        option :uri_path, value: {
+                            type:    %r{\A/.+},
+                            default: '/',
+                            usage:   '/PATH'
+                          },
+                          desc: 'The path for the URI'
+
+        option :uri_query, value: {
+                             type:  String,
+                             usage: 'STRING'
+                           },
+                           desc: 'The query string for the URI'
+
+        option :http, desc: 'Converts the IP address into a http:// URI' do
+          options[:uri] = true
+          options[:uri_scheme] = 'http'
+        end
+
+        option :https, desc: 'Converts the IP address into a https:// URI' do
+          options[:uri] = true
+          options[:uri_scheme] = 'https'
+        end
+
+        argument :ip, required: false,
+                      repeats:  true,
+                      desc:     'The IP address(es) to process'
+
+        description 'Queries or processes IP addresses'
+
+        examples [
+          '--public',
+          '--local',
+          '--decimal 1.2.3.4',
+          '--cidr 20 1.2.3.4',
+          '--host 192.30.255.113'
+        ]
+
+        man_page 'ronin-ip.1'
+
+        #
+        # Runs the `ronin ip` command.
+        #
+        # @param [Array<String>] ips
+        #   Additional IP arguments to process.
+        #
+        def run(*ips)
+          if options[:public]
+            if (address = Support::Network::IP.public_address)
+              puts address
+            else
+              print_error 'failed to lookup public IP address using https://ipinfo.io/ip'
+              exit(1)
+            end
+          elsif options[:local]
+            puts Support::Network::IP.local_address
+          else
+            super(*ips)
+          end
+        end
+
+        #
+        # Processes an individual IP address.
+        #
+        # @param [String] ip
+        #   The IP address string to process.
+        #
+        def process_value(ip)
+          ip = Support::Network::IP.new(ip)
+
+          if options[:reverse]
+            puts ip.reverse
+          elsif options[:cidr]
+            ip = Support::Network::IP.new("#{ip}/#{options[:cidr]}")
+
+            puts "#{ip}/#{ip.prefix}"
+          elsif options[:host]
+            puts ip.host
+          elsif options[:port]
+            puts "#{format_ip(ip)}:#{options[:port]}"
+          elsif options[:uri]
+            puts URI::Generic.build(
+              scheme: options[:uri_scheme],
+              host:   format_ip(ip),
+              port:   options[:uri_port],
+              path:   options[:uri_path],
+              query:  options[:uri_query]
+            )
+          else
+            puts format_ip(ip)
+          end
+        end
+
+        #
+        # Formats an IP address.
+        #
+        # @param [Ronin::Support::Network::IP] ip
+        #   The IP address to format.
+        #
+        # @return [String]
+        #   The formatted IP address.
+        #
+        def format_ip(ip)
+          if options[:hex]
+            "0x%x" % ip.to_i
+          elsif options[:decimal]
+            "%u" % ip.to_i
+          elsif options[:octal]
+            "0%o" % ip.to_i
+          elsif options[:binary]
+            "%b" % ip.to_i
+          else
+            ip.to_s
+          end
+        end
+
+      end
+    end
+  end
+end