Class: Ronin::Support::Network::HTTP

Inherits:

Object

Object
Ronin::Support::Network::HTTP

show all

Defined in:: lib/ronin/support/network/http.rb,
lib/ronin/support/network/http/mixin.rb,
lib/ronin/support/network/http/cookie.rb,
lib/ronin/support/network/http/request.rb,
lib/ronin/support/network/http/set_cookie.rb,
lib/ronin/support/network/http/user_agents.rb

Overview

Provides helper methods for communicating with HTTP Servers.

Core-Ext Methods

Defined Under Namespace

Modules: Mixin, Request, UserAgents Classes: Cookie, SetCookie

Instance Attribute Summary collapse

#cookie ⇒ Cookie^?
The default cookie params to add to every request.
#headers ⇒ Hash{String => String,Array} readonly
Additional headers to add to every request.
#host ⇒ String readonly
The host to connect to.
#password ⇒ String^? readonly
The HTTP Baic-Auth password to add to every request.
#port ⇒ Integer readonly
The port to connect to.
#proxy ⇒ URI::HTTP, ... readonly
The proxy to send requests through.
#user ⇒ String^? readonly
The HTTP Baic-Auth user to add to every request.
#user_agent ⇒ String^?
The User-Agent header value.

Class Method Summary collapse

.allowed_methods(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Array<Symbol>
Performs a OPTIONS HTTP request for the given URI and parses the Allow response header.
.connect(host, port, ssl: port == 443, **kwargs) {|http| ... } ⇒ HTTP^?
Creates a HTTP connection to the host nad port.
.connect_uri(url, ssl: nil, user: nil, password: nil, **kwargs) {|http| ... } ⇒ HTTP^?
Creates a HTTP connection using the URI.
.copy(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a COPY request for the given URI.
.delete(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a DELETE request for the given URI.
.get(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a GET request for the given URI.
.get_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String
Performs a GET request for the given URI and returns the response body.
.get_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Array<SetCookie>^?
Sends an HTTP request and returns the parsed Set-Cookie header(s).
.get_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Hash{String => String}
Performs a GET request for the given URI and returns the response headers.
.head(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a HEAD request for the given URI.
.lock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a LOCK request for the given URI.
.mkcol(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a MKCOL request for the given URI.
.move(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a MOVE request for the given URI.
.ok?(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Boolean
Sends a HTTP request and determines if the response status was 200.
.options(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a OPTIONS request for the given URI.
.patch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a PATCH request for the given URI.
.post(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a POST request for the given URI.
.post_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String
Performs a POST request for the given URI and returns the response body.
.post_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs, &block) ⇒ Array<SetCookie>^?
Sends an HTTP request and returns the parsed Set-Cookie header(s).
.post_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Hash{String => String}
Performs a POST request on the given URI and returns the response headers.
.powered_by_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String^?
Sends an HTTP request and returns the X-Powered-By header.
.propfind(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a PROPFIND request for the given URI.
.proppatch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a PROPPATCH request for the given URI.
.proxy ⇒ URI::HTTP, ...
The Ronin HTTP proxy to use.
.proxy=(new_proxy) ⇒ URI::HTTP, ...
Sets the Ronin HTTP proxy to use.
.put(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a PUT request for the given URI.
.request(method, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs and arbitrary HTTP request.
.response_body(method = :get, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String
Sends an arbitrary HTTP request and returns the response body.
.response_headers(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Hash{String => String}
Sends an arbitrary HTTP request and returns the response headers.
.response_status(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Integer
Sends an arbitrary HTTP request and returns the response status.
.server_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String^?
Sends an HTTP request and returns the Server header.
.trace(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a TRACE request for the given URI.
.unlock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Performs a UNLOCK request for the given URI.
.user_agent ⇒ String^?
The default Ronin HTTP User-Agent string.
.user_agent=(new_user_agent) ⇒ String^?
Sets the default Ronin HTTP User-Agent string.

Instance Method Summary collapse

#allowed_methods(path = '*', **kwargs) ⇒ Array<Symbol>
Sends a OPTIONS HTTP request and parses the Allow response header.
#close ⇒ Object
Closes the HTTP connection.
#copy(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a COPY HTTP request.
#delete(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a DELETE HTTP request.
#get(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a GET HTTP request.
#get_body(path, **kwargs) ⇒ String
Sends a GET HTTP request and returns the response body.
#get_cookies(path, **kwargs) ⇒ Array<SetCookie>
Sends an HTTP request and returns the parsed Set-Cookie header(s).
#get_headers(path, **kwargs) ⇒ Hash{String => String}
Sends a GET HTTP request and returns the response headers.
#head(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a HEAD HTTP request.
#initialize(host, port, proxy: nil, ssl: port == 443, headers: {}, user_agent: self.class.user_agent, cookie: nil, user: nil, password: nil) {|_self| ... } ⇒ HTTP constructor
Initializes an HTTP connection.
#lock(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a LOCK HTTP request.
#mkcol(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a MKCOL HTTP request.
#move(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a MOVE HTTP request.
#ok?(method = :head, path, **kwargs) ⇒ Boolean
Sends a HTTP request and determines if the response status was 200.
#options(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a OPTIONS HTTP request.
#patch(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a PATCH HTTP request.
#post(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a POST HTTP request.
#post_body(path, **kwargs) ⇒ String
Sends a POST HTTP request and returns the response body.
#post_cookies(path, **kwargs) ⇒ Array<SetCookie>^?
Sends an HTTP request and returns the parsed Set-Cookie header(s).
#post_headers(path, **kwargs) ⇒ Hash{String => String}
Sends a POST HTTP request and returns the response headers.
#powered_by_header(method: :head, path: '/', **kwargs) ⇒ String^?
Sends an HTTP request and returns the X-Powered-By header.
#prop_find {|response| ... } ⇒ Net::HTTPResponse
Sends a PROPFIND HTTP request.
#prop_patch {|response| ... } ⇒ Net::HTTPResponse
Sends a PROPPATCH HTTP request.
#propfind(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a PROPFIND HTTP request.
#proppatch(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a PROPPATCH HTTP request.
#put(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a PUT HTTP request.
#request(method, path, query: nil, query_params: nil, headers: nil, content_type: nil, accept: nil, user_agent: @user_agent, cookie: @cookie, user: @user, password: @password, body: nil, form_data: nil, json: nil, **additional_headers) {|response| ... } ⇒ Net::HTTPResponse
Sends an arbitrary HTTP request.
#response_body(method = :get, path, **kwargs) ⇒ String
Sends an arbitrary HTTP request and returns the response body.
#response_headers(method = :head, path, **kwargs) ⇒ Hash{String => String}
Sends an arbitrary HTTP request and returns the response headers.
#response_status(method = :head, path, **kwargs) ⇒ Integer
Sends an arbitrary HTTP request and returns the response status.
#server_header(method: :head, path: '/', **kwargs) ⇒ String^?
Sends an HTTP request and returns the Server header.
#ssl? ⇒ Boolean
Determines if the HTTP connect is using SSL/TLS.
#trace(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a TRACE HTTP request.
#unlock(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse
Sends a UNLOCK HTTP request.

Constructor Details

#initialize(host, port, proxy: nil, ssl: port == 443, headers: {}, user_agent: self.class.user_agent, cookie: nil, user: nil, password: nil) {|_self| ... } ⇒ `HTTP`

Initializes an HTTP connection.

Parameters:

host (String) —
The host to connect to.
port (Integer) —
The port to connect tto.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: nil) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: self.class.user_agent) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: port == 443) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Yields:

(_self)

Yield Parameters:

_self (Ronin::Support::Network::HTTP) —
the object that the method was called on

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 249

def initialize(host,port, proxy:      nil,
                          ssl:        port == 443,
                          # header options
                          headers:    {},
                          user_agent: self.class.user_agent,
                          cookie:     nil,
                          # Basic-Auth options
                          user:       nil,
                          password:   nil)
  @host  = DNS::IDN.to_ascii(host)
  @port  = port.to_i

  @headers        = headers
  self.user_agent = user_agent if user_agent
  self.cookie     = cookie     if cookie

  @user     = user
  @password = password

  if proxy
    @proxy = URI(proxy)
    @http  = Net::HTTP.new(
      @host, @port,
      @proxy.host, @proxy.port, @proxy.user, @proxy.password
    )
  else
    @http = Net::HTTP.new(@host,@port)
  end

  case ssl
  when true then initialize_ssl
  when Hash then initialize_ssl(**ssl)
  end

  yield self if block_given?
end

Instance Attribute Details

The default cookie params to add to every request.

Returns:

(Cookie, nil)



167
168
169

# File 'lib/ronin/support/network/http.rb', line 167

def cookie
  @cookie
end

#headers ⇒ `Hash{String => String,Array}` (readonly)

Additional headers to add to every request.

Returns:

(Hash{String => String,Array})



152
153
154

# File 'lib/ronin/support/network/http.rb', line 152

def headers
  @headers
end

#host ⇒ `String` (readonly)

The host to connect to.

Returns:

(String)



142
143
144

# File 'lib/ronin/support/network/http.rb', line 142

def host
  @host
end

#password ⇒ `String`^? (readonly)

The HTTP Baic-Auth password to add to every request.

Returns:

(String, nil)



162
163
164

# File 'lib/ronin/support/network/http.rb', line 162

def password
  @password
end

#port ⇒ `Integer` (readonly)

The port to connect to.

Returns:

(Integer)



147
148
149

# File 'lib/ronin/support/network/http.rb', line 147

def port
  @port
end

#proxy ⇒ `URI::HTTP`, ... (readonly)

The proxy to send requests through.

Returns:

(URI::HTTP, Addressable::URI, nil)



137
138
139

# File 'lib/ronin/support/network/http.rb', line 137

def proxy
  @proxy
end

#user ⇒ `String`^? (readonly)

The HTTP Baic-Auth user to add to every request.

Returns:

(String, nil)



157
158
159

# File 'lib/ronin/support/network/http.rb', line 157

def user
  @user
end

#user_agent ⇒ `String`^?

The User-Agent header value.

Returns:

(String, nil)

Since:

1.0.0



578
579
580

# File 'lib/ronin/support/network/http.rb', line 578

def user_agent
  @user_agent
end

Class Method Details

.allowed_methods(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Array<Symbol>`

Performs a OPTIONS HTTP request for the given URI and parses the Allow response header.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Array<Symbol>) —
The allowed HTTP request methods for the given URL.

See Also:

connect_uri
#allowed_methods

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2416

def self.allowed_methods(url, proxy:      self.proxy,
                              ssl:        nil,
                              headers:    {},
                              user_agent: nil,
                              cookie:     nil,
                              user:       nil,
                              password:   nil,
                              **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.allowed_methods(path,**kwargs)
end

.connect(host, port, ssl: port == 443, **kwargs) {|http| ... } ⇒ `HTTP`^?

Creates a HTTP connection to the host nad port.

Parameters:

host (String) —
The host to connect to.
port (Integer) —
The port to connect to.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: port == 443) —
Specifies whether to enable SSL and/or the SSL context configuration.
kwargs (Hash{Symbol => Object}) —
Additional keyword arguments for #initialize.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:proxy (String, URI::HTTP, Addressable::URI, nil) —
The optional proxy to send requests through.
:headers (Hash{Symbol,String => String,Array}, nil) —
Additional headers to add to each request.
:user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) — default: HTTP.user_agent —
The default User-Agent string to add to each request.
:user (String, nil) —
The HTTP Basic-Auth user to add to each request.
:password (String, nil) —
The HTTP Basic-Auth password to add to each request.

Yields:

(http) —
If a block is given, it will be passed the newly created HTTP session object. Once the block returns, the HTTP session will be closed.

Yield Parameters:

http (HTTP) —
The HTTP session object.

Returns:

(HTTP, nil) —
The HTTP session object. If a block is given, then nil will be returned.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 486

def self.connect(host,port, ssl: port == 443, **kwargs)
  http = new(host,port, ssl: ssl, **kwargs)

  if block_given?
    begin
      yield http
    ensure
      http.close
    end
  else
    return http
  end
end

.connect_uri(url, ssl: nil, user: nil, password: nil, **kwargs) {|http| ... } ⇒ `HTTP`^?

Creates a HTTP connection using the URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
The URI to connect to.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.
kwargs (Hash{Symbol => Object}) —
Additional keyword arguments for #initialize.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:proxy (String, URI::HTTP, Addressable::URI, nil) —
The optional proxy to send requests through.
:headers (Hash{Symbol,String => String,Array}, nil) —
Additional headers to add to each request.
:user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) — default: HTTP.user_agent —
The default User-Agent string to add to each request.
:user (String, nil) —
The HTTP Basic-Auth user to add to each request.
:password (String, nil) —
The HTTP Basic-Auth password to add to each request.

Yields:

(http) —
If a block is given, it will be passed the newly created HTTP session object. Once the block returns, the HTTP session will be closed.

Yield Parameters:

http (HTTP) —
The HTTP session object.

Returns:

(HTTP, nil) —
The HTTP session object. If a block is given, then nil will be returned.

Raises:

(ArgumentError) —
The URL was not a URI::HTTP, Addressable::URI, or a String object.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 525

def self.connect_uri(url, ssl:      nil,
                          user:     nil,
                          password: nil,
                          **kwargs, &block)
  case url
  when URI::HTTP
    host       = url.host
    port       = url.port
    user     ||= url.user
    password ||= url.password
    ssl      ||= (url.scheme == 'https')
  when String
    uri = Addressable::URI.parse(url)

    host       = uri.host
    port       = uri.inferred_port
    user     ||= uri.user
    password ||= uri.password
    ssl      ||= (uri.scheme == 'https')
  when Addressable::URI
    host       = url.host
    port       = url.inferred_port
    user     ||= url.user
    password ||= url.password
    ssl      ||= (url.scheme == 'https')
  else
    raise(ArgumentError,"url must be a URI::HTTP, Addressable::URI, or a String: #{url.inspect}")
  end

  return connect(host,port, ssl:      ssl,
                            user:     user,
                            password: password,
                            **kwargs, &block)
end

.copy(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a COPY request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#copy

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1857

def self.copy(url, proxy:      self.proxy,
                   ssl:        nil,
                   headers:    {},
                   user_agent: nil,
                   cookie:     nil,
                   user:       nil,
                   password:   nil,
                   **kwargs,
                   &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.copy(path,**kwargs,&block)
end

.delete(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a DELETE request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#delete

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1910

def self.delete(url, proxy:      self.proxy,
                     ssl:        nil,
                     headers:    {},
                     user_agent: nil,
                     cookie:     nil,
                     user:       nil,
                     password:   nil,
                     **kwargs,
                     &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.delete(path,**kwargs,&block)
end

.get(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a GET request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#get

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1963

def self.get(url, proxy:      self.proxy,
                  ssl:        nil,
                  headers:    {},
                  user_agent: nil,
                  cookie:     nil,
                  user:       nil,
                  password:   nil,
                  **kwargs,
                  &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.get(path,**kwargs,&block)
end

.get_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`

Performs a GET request for the given URI and returns the response body.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String) —
The response body.

See Also:

connect_uri
#get_body

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2104

def self.get_body(url, proxy:      self.proxy,
                       ssl:        nil,
                       headers:    {},
                       user_agent: nil,
                       cookie:     nil,
                       user:       nil,
                       password:   nil,
                       **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.get_body(path,**kwargs)
end

.get_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Array<SetCookie>`^?

Sends an HTTP request and returns the parsed Set-Cookie header(s).

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Array<SetCookie>, nil) —
The parsed SetCookie header(s).

See Also:

connect_uri
#get_cookies

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2057

def self.get_cookies(url, proxy:      self.proxy,
                          ssl:        nil,
                          headers:    {},
                          user_agent: nil,
                          cookie:     nil,
                          user:       nil,
                          password:   nil,
                          **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.get_cookies(path, **kwargs)
end

.get_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Hash{String => String}`

Performs a GET request for the given URI and returns the response headers.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Hash{String => String}) —
The response headers.

See Also:

connect_uri
#get_headers

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2011

def self.get_headers(url, proxy:      self.proxy,
                          ssl:        nil,
                          headers:    {},
                          user_agent: nil,
                          cookie:     nil,
                          user:       nil,
                          password:   nil,
                          **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.get_headers(path,**kwargs)
end

.head(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a HEAD request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#head

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2156

def self.head(url, proxy:      self.proxy,
                   ssl:        nil,
                   headers:    {},
                   user_agent: nil,
                   cookie:     nil,
                   user:       nil,
                   password:   nil,
                   **kwargs,
                   &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.head(path,**kwargs,&block)
end

.lock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a LOCK request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#lock

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2209

def self.lock(url, proxy:      self.proxy,
                   ssl:        nil,
                   headers:    {},
                   user_agent: nil,
                   cookie:     nil,
                   user:       nil,
                   password:   nil,
                   **kwargs,
                   &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.lock(path,**kwargs,&block)
end

.mkcol(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a MKCOL request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#mkcol

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2262

def self.mkcol(url, proxy:      self.proxy,
                    ssl:        nil,
                    headers:    {},
                    user_agent: nil,
                    cookie:     nil,
                    user:       nil,
                    password:   nil,
                    **kwargs,
                    &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.mkcol(path,**kwargs,&block)
end

.move(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a MOVE request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#move

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2315

def self.move(url, proxy:      self.proxy,
                   ssl:        nil,
                   headers:    {},
                   user_agent: nil,
                   cookie:     nil,
                   user:       nil,
                   password:   nil,
                   **kwargs,
                   &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.move(path,**kwargs,&block)
end

.ok?(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Boolean`

Sends a HTTP request and determines if the response status was 200.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Boolean) —
Indicates that the response status was 200.

See Also:

connect_uri
#ok?

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1611

def self.ok?(method=:head,url, proxy:      self.proxy,
                               ssl:        nil,
                               headers:    {},
                               user_agent: nil,
                               cookie:     nil,
                               user:       nil,
                               password:   nil,
                               **kwargs)
  uri  = case url
         when Addressable::URI, URI::HTTP
           url
         when String
           Addressable::URI.parse(url)
         else
           raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
         end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.ok?(method,path,**kwargs)
end

.options(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a OPTIONS request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#options

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2368

def self.options(url, proxy:      self.proxy,
                      ssl:        nil,
                      headers:    {},
                      user_agent: nil,
                      cookie:     nil,
                      user:       nil,
                      password:   nil,
                      **kwargs,
                      &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.options(path,**kwargs,&block)
end

.patch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a PATCH request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#patch

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2468

def self.patch(url, proxy:      self.proxy,
                    ssl:        nil,
                    headers:    {},
                    user_agent: nil,
                    cookie:     nil,
                    user:       nil,
                    password:   nil,
                    **kwargs,
                    &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.patch(path,**kwargs,&block)
end

.post(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a POST request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#post

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2521

def self.post(url, proxy:      self.proxy,
                   ssl:        nil,
                   headers:    {},
                   user_agent: nil,
                   cookie:     nil,
                   user:       nil,
                   password:   nil,
                   **kwargs,
                   &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.post(path,**kwargs,&block)
end

.post_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`

Performs a POST request for the given URI and returns the response body.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String) —
The response body.

See Also:

connect_uri
#post_body

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2616

def self.post_body(url, proxy:      self.proxy,
                        ssl:        nil,
                        headers:    {},
                        user_agent: nil,
                        cookie:     nil,
                        user:       nil,
                        password:   nil,
                        **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.post_body(path,**kwargs)
end

.post_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs, &block) ⇒ `Array<SetCookie>`^?

Sends an HTTP request and returns the parsed Set-Cookie header(s).

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Array<SetCookie>, nil) —
The parsed Cookie header(s).

See Also:

connect_uri
#post_cookies

Since:

1.1.0

# File 'lib/ronin/support/network/http.rb', line 2927

def self.post_cookies(url, proxy:      self.proxy,
                           ssl:        nil,
                           headers:    {},
                           user_agent: nil,
                           cookie:     nil,
                           user:       nil,
                           password:   nil,
                           **kwargs,
                           &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.post_cookies(path,**kwargs)
end

.post_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Hash{String => String}`

Performs a POST request on the given URI and returns the response headers.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Hash{String => String}) —
The response headers.

See Also:

connect_uri
#post_headers

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2569

def self.post_headers(url, proxy:      self.proxy,
                           ssl:        nil,
                           headers:    {},
                           user_agent: nil,
                           cookie:     nil,
                           user:       nil,
                           password:   nil,
                           **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.post_headers(path,**kwargs)
end

.powered_by_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`^?

Sends an HTTP request and returns the X-Powered-By header.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String, nil) —
The X-Powered-By header.

See Also:

connect_uri
#powered_by_header

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1754

def self.powered_by_header(url, proxy:      self.proxy,
                                ssl:        nil,
                                headers:    {},
                                user_agent: nil,
                                cookie:     nil,
                                user:       nil,
                                password:   nil,
                                **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.powered_by_header(path: path, **kwargs)
end

.propfind(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a PROPFIND request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#propfind

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2668

def self.propfind(url, proxy:      self.proxy,
                       ssl:        nil,
                       headers:    {},
                       user_agent: nil,
                       cookie:     nil,
                       user:       nil,
                       password:   nil,
                       **kwargs,
                       &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.propfind(path,**kwargs,&block)
end

.proppatch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a PROPPATCH request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#proppatch

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2721

def self.proppatch(url, proxy:      self.proxy,
                        ssl:        nil,
                        headers:    {},
                        user_agent: nil,
                        cookie:     nil,
                        user:       nil,
                        password:   nil,
                        **kwargs,
                        &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.proppatch(path,**kwargs,&block)
end

.proxy ⇒ `URI::HTTP`, ...

Note:

If the RONIN_HTTP_PROXY environment variable is specified, it will be used as the default value. If the HTTP_PROXY environment variable is specified, it will be used as the default value.

The Ronin HTTP proxy to use.

Returns:

(URI::HTTP, Addressable::URI, nil) —
The Ronin HTTP proxy.

# File 'lib/ronin/support/network/http.rb', line 59

def self.proxy
  @proxy ||= if ENV['RONIN_HTTP_PROXY']
               Addressable::URI.parse(ENV['RONIN_HTTP_PROXY'])
             elsif ENV['HTTP_PROXY']
               Addressable::URI.parse(ENV['HTTP_PROXY'])
             end
end

.proxy=(new_proxy) ⇒ `URI::HTTP`, ...

Sets the Ronin HTTP proxy to use.

Parameters:

new_proxy (URI::HTTP, Addressable::URI, String, nil) —
The new proxy information to use.

Returns:

(URI::HTTP, Addressable::URI, nil) —
The new proxy.

Raises:

(ArgumentError) —
The given proxy information was not a URI::HTTP, Addressable::URI, String, or nil.

# File 'lib/ronin/support/network/http.rb', line 82

def self.proxy=(new_proxy)
  @proxy = case new_proxy
           when URI::HTTP, Addressable::URI
             new_proxy
           when String
             Addressable::URI.parse(new_proxy)
           when nil
             nil
           else
             raise(ArgumentError,"invalid proxy value (#{new_proxy.inspect}), must be either a URI::HTTP, Addressable::URI, String, or nil")
           end
end

.put(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a PUT request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#put

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2774

def self.put(url, proxy:      self.proxy,
                  ssl:        nil,
                  headers:    {},
                  user_agent: nil,
                  cookie:     nil,
                  user:       nil,
                  password:   nil,
                  **kwargs,
                  &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.put(path,**kwargs,&block)
end

.request(method, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs and arbitrary HTTP request.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock)
url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Raises:

(ArgumentError) —
The :method option did not match a known Net::HTTP request class.

See Also:

connect_uri
#request

# File 'lib/ronin/support/network/http.rb', line 1508

def self.request(method,url, proxy:      self.proxy,
                             ssl:        nil,
                             headers:    {},
                             user_agent: nil,
                             cookie:     nil,
                             user:       nil,
                             password:   nil,
                             **kwargs,
                             &block)
  uri  = case url
         when Addressable::URI, URI::HTTP
           url
         when String
           Addressable::URI.parse(url)
         else
           raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
         end

  path = uri.request_uri
  http = connect_uri(uri, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.request(method,path,**kwargs,&block)
end

.response_body(method = :get, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`

Sends an arbitrary HTTP request and returns the response body.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :get)
url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String) —
The response body.

See Also:

connect_uri
#response_body

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1805

def self.response_body(method=:get,url, proxy:      self.proxy,
                                        ssl:        nil,
                                        headers:    {},
                                        user_agent: nil,
                                        cookie:     nil,
                                        user:       nil,
                                        password:   nil,
                                        **kwargs)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.response_body(method,path,**kwargs)
end

.response_headers(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Hash{String => String}`

Sends an arbitrary HTTP request and returns the response headers.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Hash{String => String}) —
The response headers.

See Also:

connect_uri
#response_headers

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1662

def self.response_headers(method=:head,url, proxy:      self.proxy,
                                            ssl:        nil,
                                            headers:    {},
                                            user_agent: nil,
                                            cookie:     nil,
                                            user:       nil,
                                            password:   nil,
                                            **kwargs)
  uri  = case url
         when Addressable::URI, URI::HTTP
           url
         when String
           Addressable::URI.parse(url)
         else
           raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
         end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.response_headers(method,path,**kwargs)
end

.response_status(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Integer`

Sends an arbitrary HTTP request and returns the response status.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Integer) —
The status code of the response.

See Also:

connect_uri
#response_status

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1560

def self.response_status(method=:head,url, proxy:      self.proxy,
                                           ssl:        nil,
                                           headers:    {},
                                           user_agent: nil,
                                           cookie:     nil,
                                           user:       nil,
                                           password:   nil,
                                           **kwargs)
  uri  = case url
         when Addressable::URI, URI::HTTP
           url
         when String
           Addressable::URI.parse(url)
         else
           raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
         end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.response_status(method,path,**kwargs)
end

.server_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`^?

Sends an HTTP request and returns the Server header.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String, nil) —
The Server header.

See Also:

connect_uri
#server_header

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1708

def self.server_header(url, proxy:      self.proxy,
                            ssl:        nil,
                            headers:    {},
                            user_agent: nil,
                            cookie:     nil,
                            user:       nil,
                            password:   nil,
                            **kwargs)
  uri  = case url
         when Addressable::URI, URI::HTTP
           url
         when String
           Addressable::URI.parse(url)
         else
           raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
         end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.server_header(path: path, **kwargs)
end

.trace(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a TRACE request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#trace

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2827

def self.trace(url, proxy:      self.proxy,
                    ssl:        nil,
                    headers:    {},
                    user_agent: nil,
                    cookie:     nil,
                    user:       nil,
                    password:   nil,
                    **kwargs,
                    &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.trace(path,**kwargs,&block)
end

.unlock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Performs a UNLOCK request for the given URI.

Parameters:

url (URI::HTTP, Addressable::URI, String) —
Optional URL to create the HTTP request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.
proxy (String, URI::HTTP, Addressable::URI, nil) (defaults to: self.proxy) —
Optional proxy to use for the request.
headers (Hash{Symbol,String => String,Array}, nil) (defaults to: {}) —
Additional headers to add to each request.
user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil) (defaults to: nil) —
The default User-Agent value to add to each request.
cookie (Cookie, Hash, String, nil) (defaults to: nil) —
The default cookie params to add to each request.
user (String, nil) (defaults to: nil) —
The HTTP Basic-Auth user to add to each request.
password (String, nil) (defaults to: nil) —
The HTTP Basic-Auth password to add to each request.
ssl (Boolean, Hash{Symbol => Object}, nil) (defaults to: nil) —
Specifies whether to enable SSL and/or the SSL context configuration.

Options Hash (ssl:):

:ca_bundle (String, nil) —
The path to the CA bundle directory or file.
:cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The certificate to use for the SSL/TLS connection.
:cert_store (OpenSSL::X509::Store, nil) —
The certificate store to use for the SSL/TLS connection.
:ciphers (Array<(name, version, bits, alg_bits)>, nil) —
The accepted ciphers to use for the SSL/TLS connection.
:extra_chain_cert (Crypto::Cert, OpenSSL::X509::Certificate, nil) —
The extra certificate to add to the SSL/TLS certificate chain.
:key (Crypto::Key::RSA, Crypto::Key::DSA, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA, nil) —
The RSA or DSA key to use for the SSL/TLS connection.
:timeout (Integer, nil) —
The connection timeout limit.
:version (1, 1.1, 1.2, Symbol, nil) —
The desired SSL/TLS version.
:min_version (1, 1.1, 1.2, Symbol, nil) —
The minimum SSL/TLS version.
:max_version (1, 1.1, 1.2, Symbol, nil) —
The maximum SSL/TLS version.
:verify_callback (Proc, nil) —
The callback to use when verifying the server's certificate.
:verify_depth (Integer, nil) —
The verification depth limit.
:verify (:none, :peer, :fail_if_no_peer_cert, true, false, Integer, nil) —
The verification mode.
:verify_hostname (Boolean, nil) —
Indicates whether to verify the server's hostname.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPRresponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

See Also:

connect_uri
#unlock

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 2880

def self.unlock(url, proxy:      self.proxy,
                     ssl:        nil,
                     headers:    {},
                     user_agent: nil,
                     cookie:     nil,
                     user:       nil,
                     password:   nil,
                     **kwargs,
                     &block)
  uri = case url
        when Addressable::URI, URI::HTTP
          url
        when String
          Addressable::URI.parse(url)
        else
          raise(ArgumentError,"URL argument must be either a Addressable::URI, URI::HTTP, or a String: #{url.inspect}")
        end

  path = uri.request_uri
  http = connect_uri(url, proxy:      proxy,
                          ssl:        ssl,
                          headers:    headers,
                          user_agent: user_agent,
                          cookie:     cookie,
                          user:       user,
                          password:   password)

  http.unlock(path,**kwargs,&block)
end

.user_agent ⇒ `String`^?

The default Ronin HTTP User-Agent string.

Returns:

(String, nil) —
The default Ronin HTTP User-Agent.



103
104
105

# File 'lib/ronin/support/network/http.rb', line 103

def self.user_agent
  @user_agent
end

.user_agent=(new_user_agent) ⇒ `String`^?

Sets the default Ronin HTTP User-Agent string.

The new User-Agent default value.

If a Symbol or a String is given, then the user_agent value will be set.
If nil is given, then the user_agent value will be cleared.

Parameters:

new_user_agent (String, :random, :chrome, :chrome_linux, :chrome_macos, :chrome_windows, :chrome_iphone, :chrome_ipad, :chrome_android, :firefox, :firefox_linux, :firefox_macos, :firefox_windows, :firefox_iphone, :firefox_ipad, :firefox_android, :safari, :safari_macos, :safari_iphone, :safari_ipad, :edge, :linux, :macos, :windows, :iphone, :ipad, :android, nil)

Returns:

(String, nil) —
The new User-Agent string.

# File 'lib/ronin/support/network/http.rb', line 127

def self.user_agent=(new_user_agent)
  @user_agent = case new_user_agent
                when Symbol then UserAgents[new_user_agent]
                else             new_user_agent
                end
end

Instance Method Details

#allowed_methods(path = '*', **kwargs) ⇒ `Array<Symbol>`

Sends a OPTIONS HTTP request and parses the Allow response header.

Parameters:

path (String) (defaults to: '*') —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Array<Symbol>) —
The allowed HTTP request methods for the given path.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1257

def allowed_methods(path='*',**kwargs)
  response = options(path,**kwargs)
  allow    = response['Allow']
  methods  = allow.split(', ')

  methods.map! do |method|
    method.downcase!
    method.to_sym
  end

  return methods
end

#close ⇒ `Object`

Closes the HTTP connection.

Since:

1.0.0



1474
1475
1476

# File 'lib/ronin/support/network/http.rb', line 1474

def close
  @http.finish if @http.started?
end

#copy(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a COPY HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



996
997
998

# File 'lib/ronin/support/network/http.rb', line 996

def copy(path,**kwargs,&block)
  request(:copy,path,**kwargs,&block)
end

#delete(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a DELETE HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1019
1020
1021

# File 'lib/ronin/support/network/http.rb', line 1019

def delete(path,**kwargs,&block)
  request(:delete,path,**kwargs,&block)
end

#get(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a GET HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1042
1043
1044

# File 'lib/ronin/support/network/http.rb', line 1042

def get(path,**kwargs,&block)
  request(:get,path,**kwargs,&block)
end

#get_body(path, **kwargs) ⇒ `String`

Sends a GET HTTP request and returns the response body.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String) —
The response body.

Since:

1.0.0



1124
1125
1126

# File 'lib/ronin/support/network/http.rb', line 1124

def get_body(path,**kwargs)
  response_body(:get,path,**kwargs)
end

#get_cookies(path, **kwargs) ⇒ `Array<SetCookie>`

Sends an HTTP request and returns the parsed Set-Cookie header(s).

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Array<SetCookie>) —
The parsed Set-Cookie headers.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 1076

def get_cookies(path, **kwargs)
  response = request(:get,path,**kwargs)

  if (set_cookies = response.get_fields('Set-Cookie'))
    set_cookies.map do |cookie|
      SetCookie.parse(cookie)
    end
  else
    []
  end
end

#get_headers(path, **kwargs) ⇒ `Hash{String => String}`

Sends a GET HTTP request and returns the response headers.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Hash{String => String}) —
The response headers.

Since:

1.0.0



1059
1060
1061

# File 'lib/ronin/support/network/http.rb', line 1059

def get_headers(path,**kwargs)
  response_headers(:get,path,**kwargs)
end

#head(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a HEAD HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1147
1148
1149

# File 'lib/ronin/support/network/http.rb', line 1147

def head(path,**kwargs,&block)
  request(:head,path,**kwargs,&block)
end

#lock(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a LOCK HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1170
1171
1172

# File 'lib/ronin/support/network/http.rb', line 1170

def lock(path,**kwargs,&block)
  request(:lock,path,**kwargs,&block)
end

#mkcol(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a MKCOL HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1193
1194
1195

# File 'lib/ronin/support/network/http.rb', line 1193

def mkcol(path,**kwargs,&block)
  request(:mkcol,path,**kwargs,&block)
end

#move(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a MOVE HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1216
1217
1218

# File 'lib/ronin/support/network/http.rb', line 1216

def move(path,**kwargs,&block)
  request(:move,path,**kwargs,&block)
end

#ok?(method = :head, path, **kwargs) ⇒ `Boolean`

Sends a HTTP request and determines if the response status was 200.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Boolean) —
Indicates that the response status was 200.

Since:

1.0.0



877
878
879

# File 'lib/ronin/support/network/http.rb', line 877

def ok?(method=:head,path,**kwargs)
  response_status(method,path,**kwargs) == 200
end

#options(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a OPTIONS HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1239
1240
1241

# File 'lib/ronin/support/network/http.rb', line 1239

def options(path,**kwargs,&block)
  request(:options,path,**kwargs,&block)
end

#patch(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a PATCH HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1289
1290
1291

# File 'lib/ronin/support/network/http.rb', line 1289

def patch(path,**kwargs,&block)
  request(:patch,path,**kwargs,&block)
end

#post(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a POST HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1312
1313
1314

# File 'lib/ronin/support/network/http.rb', line 1312

def post(path,**kwargs,&block)
  request(:post,path,**kwargs,&block)
end

#post_body(path, **kwargs) ⇒ `String`

Sends a POST HTTP request and returns the response body.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String) —
The response body.

Since:

1.0.0



1346
1347
1348

# File 'lib/ronin/support/network/http.rb', line 1346

def post_body(path,**kwargs)
  response_body(:post,path,**kwargs)
end

#post_cookies(path, **kwargs) ⇒ `Array<SetCookie>`^?

Sends an HTTP request and returns the parsed Set-Cookie header(s).

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Array<SetCookie>, nil) —
The parsed Cookie headers.

Since:

1.1.0

# File 'lib/ronin/support/network/http.rb', line 1101

def post_cookies(path, **kwargs)
  response = request(:post,path,**kwargs)

  if (set_cookies = response.get_fields('Set-Cookie'))
    set_cookies.map do |cookie|
      SetCookie.parse(cookie)
    end
  end
end

#post_headers(path, **kwargs) ⇒ `Hash{String => String}`

Sends a POST HTTP request and returns the response headers.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Hash{String => String}) —
The response headers.

Since:

1.0.0



1329
1330
1331

# File 'lib/ronin/support/network/http.rb', line 1329

def post_headers(path,**kwargs)
  response_headers(:post,path,**kwargs)
end

#powered_by_header(method: :head, path: '/', **kwargs) ⇒ `String`^?

Sends an HTTP request and returns the X-Powered-By header.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
path (String) (defaults to: '/') —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String, nil) —
The X-Powered-By header.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 950

def powered_by_header(method: :head, path: '/',**kwargs)
  response = request(method,path,**kwargs)
  response['X-Powered-By']
end

#prop_find {|response| ... } ⇒ `Net::HTTPResponse`

Sends a PROPFIND HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1373
1374
1375

# File 'lib/ronin/support/network/http.rb', line 1373

def propfind(path,**kwargs,&block)
  request(:propfind,path,**kwargs,&block)
end

#prop_patch {|response| ... } ⇒ `Net::HTTPResponse`

Sends a PROPPATCH HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1398
1399
1400

# File 'lib/ronin/support/network/http.rb', line 1398

def proppatch(path,**kwargs,&block)
  request(:proppatch,path,**kwargs,&block)
end

#propfind(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a PROPFIND HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1369
1370
1371

# File 'lib/ronin/support/network/http.rb', line 1369

def propfind(path,**kwargs,&block)
  request(:propfind,path,**kwargs,&block)
end

#proppatch(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a PROPPATCH HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1394
1395
1396

# File 'lib/ronin/support/network/http.rb', line 1394

def proppatch(path,**kwargs,&block)
  request(:proppatch,path,**kwargs,&block)
end

#put(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a PUT HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1419
1420
1421

# File 'lib/ronin/support/network/http.rb', line 1419

def put(path,**kwargs,&block)
  request(:put,path,**kwargs,&block)
end

#request(method, path, query: nil, query_params: nil, headers: nil, content_type: nil, accept: nil, user_agent: @user_agent, cookie: @cookie, user: @user, password: @password, body: nil, form_data: nil, json: nil, **additional_headers) {|response| ... } ⇒ `Net::HTTPResponse`

Sends an arbitrary HTTP request.

The HTTP method to use for the request.

Examples:

http.request(:get, '/')

Streaming response body:

http.request(:get, '/big_file.txt') do |response|
  respnse.read_body do |chunk|
    # ...
  end
end

Basic-Auth

http.request(:get, '/', user: 'admin', password: 'secret')

Query string:

http.request(:get, '/search', query: 'foo%20bar')

Query params:

http.request(:get, '/search', query_params: {q: 'foo bar'})

Request body:

http.request(:post, '/form', body: 'foo=1&bar=2')

Form data:

http.request(:post, '/form', form_data: {'foo' => 1, 'bar' => 2})

Streaming request body:

http.request(:put, '/file', body: File.new('/path/to/file'))

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock)
path (String) —
The path to to make the request for.
query (String, nil) (defaults to: nil) —
The query-string to append to the request path.
query_params (Hash, nil) (defaults to: nil) —
The query-params to append to the request path.
user (String, nil) (defaults to: @user) —
The user to authenticate as.
password (String, nil) (defaults to: @password) —
The password to authenticate with.
headers (Hash{Symbol,String => String}, nil) (defaults to: nil) —
Additional HTTP header names and values to add to the request.
content_type (String, :text, :xml, :html, :json, nil) (defaults to: nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
accept (String, :text, :xml, :html, :json, nil) (defaults to: nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
cookie (String, Hash{String => String}, nil) (defaults to: @cookie) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie.
body (String, nil) (defaults to: nil) —
The body of the request.
form_data (Hash, String, nil) (defaults to: nil) —
The form data that may be sent in the body of the request.
json (#to_json, nil) (defaults to: nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.
additional_headers (Hash{Symbol => String}) —
Additional headers to add to the request.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Raises:

(ArgumentError) —
The :method option did not match a known Net::HTTP request class.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 735

def request(method,path, # query string keyword arguments
                         query:        nil,
                         query_params: nil,
                         # header keyword arguments
                         headers:      nil,
                         content_type: nil,
                         accept:       nil,
                         user_agent:   @user_agent,
                         cookie:       @cookie,
                         # Basic-Auth keyword arguments
                         user:     @user,
                         password: @password,
                         # request body keyword arguments
                         body:      nil,
                         form_data: nil,
                         json:      nil,
                         **additional_headers,
                         &block)
  request = Request.build(method,path, headers:      @headers,
                                       content_type: content_type,
                                       accept:       accept,
                                       user_agent:   user_agent,
                                       cookie:       cookie,
                                       user:         user,
                                       password:     password,
                                       query:        query,
                                       query_params: query_params,
                                       body:         body,
                                       form_data:    form_data,
                                       json:         json)

  if headers
    # populate any arbitrary headers
    headers.each do |name,value|
      request[name] = value
    end
  end

  unless additional_headers.empty?
    # set additional keyword argument headers (ex: `referer: '...'`
    additional_headers.each do |name,value|
      request[name] = value
    end
  end

  return @http.request(request,&block)
end

#response_body(method = :get, path, **kwargs) ⇒ `String`

Sends an arbitrary HTTP request and returns the response body.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :get)
path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String) —
The response body.

Since:

1.0.0



973
974
975

# File 'lib/ronin/support/network/http.rb', line 973

def response_body(method=:get,path,**kwargs)
  request(method,path,**kwargs).body
end

#response_headers(method = :head, path, **kwargs) ⇒ `Hash{String => String}`

Sends an arbitrary HTTP request and returns the response headers.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Hash{String => String}) —
The response headers.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 899

def response_headers(method=:head,path,**kwargs)
  headers = {}

  request(method,path,**kwargs).each_capitalized do |name,value|
    headers[name] = value
  end

  return headers
end

#response_status(method = :head, path, **kwargs) ⇒ `Integer`

Sends an arbitrary HTTP request and returns the response status.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(Integer) —
The response status code.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 854

def response_status(method=:head,path,**kwargs)
  response = request(method,path,**kwargs)
  response.code.to_i
end

#server_header(method: :head, path: '/', **kwargs) ⇒ `String`^?

Sends an HTTP request and returns the Server header.

The HTTP method to use for the request.

Parameters:

method (:copy, :delete, :get, :head, :lock, :mkcol, :move, :options, :patch, :post, :propfind, :proppatch, :put, :trace, :unlock) (defaults to: :head)
path (String) (defaults to: '/') —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Returns:

(String, nil) —
The Server header.

Since:

1.0.0

# File 'lib/ronin/support/network/http.rb', line 927

def server_header(method: :head, path: '/',**kwargs)
  response = request(method,path,**kwargs)
  response['Server']
end

#ssl? ⇒ `Boolean`

Determines if the HTTP connect is using SSL/TLS.

Returns:

(Boolean)

Since:

1.0.0



567
568
569

# File 'lib/ronin/support/network/http.rb', line 567

def ssl?
  @http.use_ssl?
end

#trace(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a TRACE HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1442
1443
1444

# File 'lib/ronin/support/network/http.rb', line 1442

def trace(path,**kwargs,&block)
  request(:trace,path,**kwargs,&block)
end

#unlock(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

Sends a UNLOCK HTTP request.

Parameters:

path (String) —
The path to to make the request for.
kwargs (Hash{Symbol => Object}) —
Aditional keyword arguments and headers for #request.

Options Hash (**kwargs):

:query (String, nil) —
The query-string to append to the request path.
:query_params (Hash, nil) —
The query-params to append to the request path.
:user (String, nil) —
The user to authenticate as.
:password (String, nil) —
The password to authenticate with.
:headers (Hash{Symbol,String => String}, nil) —
Additional HTTP header names and values to add to the request.
:content_type (String, :text, :xml, :html, :json, nil) —
The Content-Type header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:accept (String, :text, :xml, :html, :json, nil) —
The Accept header value for the request. If a Symbol is given it will be resolved to a common MIME type:
- :text - text/plain
- :xml - text/xml
- :html - text/html
- :json - application/json
:cookie (String, Hash{String => String}, Cookie, nil) —
Additional Cookie header. If a Hash is given, it will be converted to a String using Cookie. If the cookie value is empty, the Cookie header will not be set.
:body (String, nil) —
The body of the request.
:form_data (Hash, String, nil) —
The form data that may be sent in the body of the request.
:json (#to_json, nil) —
The JSON data that will be sent in the body of the request. Will also default the Content-Type header to application/json, unless already set.

Yields:

(response) —
If a block is given it will be passed the received HTTP response.

Yield Parameters:

response (Net::HTTPResponse) —
The received HTTP response object.

Returns:

(Net::HTTPResponse) —
The new HTTP Request object.

Since:

1.0.0



1465
1466
1467

# File 'lib/ronin/support/network/http.rb', line 1465

def unlock(path,**kwargs,&block)
  request(:unlock,path,**kwargs,&block)
end

Class: Ronin::Support::Network::HTTP

Overview

Core-Ext Methods

Defined Under Namespace

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(host, port, proxy: nil, ssl: port == 443, headers: {}, user_agent: self.class.user_agent, cookie: nil, user: nil, password: nil) {|_self| ... } ⇒ HTTP

Instance Attribute Details

#cookie ⇒ Cookie?

#headers ⇒ Hash{String => String,Array} (readonly)

#host ⇒ String (readonly)

#password ⇒ String? (readonly)

#port ⇒ Integer (readonly)

#proxy ⇒ URI::HTTP, ... (readonly)

#user ⇒ String? (readonly)

#user_agent ⇒ String?

Class Method Details

.allowed_methods(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Array<Symbol>

.connect(host, port, ssl: port == 443, **kwargs) {|http| ... } ⇒ HTTP?

.connect_uri(url, ssl: nil, user: nil, password: nil, **kwargs) {|http| ... } ⇒ HTTP?

.copy(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.delete(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.get(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.get_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String

.get_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Array<SetCookie>?

.get_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Hash{String => String}

.head(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.lock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.mkcol(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.move(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.ok?(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Boolean

.options(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.patch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.post(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.post_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String

.post_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs, &block) ⇒ Array<SetCookie>?

.post_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Hash{String => String}

.powered_by_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String?

.propfind(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.proppatch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.proxy ⇒ URI::HTTP, ...

.proxy=(new_proxy) ⇒ URI::HTTP, ...

.put(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.request(method, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.response_body(method = :get, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String

.response_headers(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Hash{String => String}

.response_status(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ Integer

.server_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ String?

.trace(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.unlock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

.user_agent ⇒ String?

.user_agent=(new_user_agent) ⇒ String?

Instance Method Details

#allowed_methods(path = '*', **kwargs) ⇒ Array<Symbol>

#close ⇒ Object

#copy(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#delete(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#get(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#get_body(path, **kwargs) ⇒ String

#get_cookies(path, **kwargs) ⇒ Array<SetCookie>

#get_headers(path, **kwargs) ⇒ Hash{String => String}

#head(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#lock(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#mkcol(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#move(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#ok?(method = :head, path, **kwargs) ⇒ Boolean

#options(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#patch(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#post(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#post_body(path, **kwargs) ⇒ String

#post_cookies(path, **kwargs) ⇒ Array<SetCookie>?

#post_headers(path, **kwargs) ⇒ Hash{String => String}

#powered_by_header(method: :head, path: '/', **kwargs) ⇒ String?

#prop_find {|response| ... } ⇒ Net::HTTPResponse

#prop_patch {|response| ... } ⇒ Net::HTTPResponse

#propfind(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#proppatch(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#put(path, **kwargs) {|response| ... } ⇒ Net::HTTPResponse

#initialize(host, port, proxy: nil, ssl: port == 443, headers: {}, user_agent: self.class.user_agent, cookie: nil, user: nil, password: nil) {|_self| ... } ⇒ `HTTP`

#cookie ⇒ `Cookie`^?

#headers ⇒ `Hash{String => String,Array}` (readonly)

#host ⇒ `String` (readonly)

#password ⇒ `String`^? (readonly)

#port ⇒ `Integer` (readonly)

#proxy ⇒ `URI::HTTP`, ... (readonly)

#user ⇒ `String`^? (readonly)

#user_agent ⇒ `String`^?

.allowed_methods(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Array<Symbol>`

.connect(host, port, ssl: port == 443, **kwargs) {|http| ... } ⇒ `HTTP`^?

.connect_uri(url, ssl: nil, user: nil, password: nil, **kwargs) {|http| ... } ⇒ `HTTP`^?

.copy(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.delete(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.get(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.get_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`

.get_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Array<SetCookie>`^?

.get_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Hash{String => String}`

.head(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.lock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.mkcol(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.move(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.ok?(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Boolean`

.options(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.patch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.post(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.post_body(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`

.post_cookies(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs, &block) ⇒ `Array<SetCookie>`^?

.post_headers(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Hash{String => String}`

.powered_by_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`^?

.propfind(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.proppatch(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.proxy ⇒ `URI::HTTP`, ...

.proxy=(new_proxy) ⇒ `URI::HTTP`, ...

.put(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.request(method, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.response_body(method = :get, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`

.response_headers(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Hash{String => String}`

.response_status(method = :head, url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `Integer`

.server_header(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) ⇒ `String`^?

.trace(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.unlock(url, proxy: self.proxy, ssl: nil, headers: {}, user_agent: nil, cookie: nil, user: nil, password: nil, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

.user_agent ⇒ `String`^?

.user_agent=(new_user_agent) ⇒ `String`^?

#allowed_methods(path = '*', **kwargs) ⇒ `Array<Symbol>`

#close ⇒ `Object`

#copy(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#delete(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#get(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#get_body(path, **kwargs) ⇒ `String`

#get_cookies(path, **kwargs) ⇒ `Array<SetCookie>`

#get_headers(path, **kwargs) ⇒ `Hash{String => String}`

#head(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#lock(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#mkcol(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#move(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#ok?(method = :head, path, **kwargs) ⇒ `Boolean`

#options(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#patch(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#post(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#post_body(path, **kwargs) ⇒ `String`

#post_cookies(path, **kwargs) ⇒ `Array<SetCookie>`^?

#post_headers(path, **kwargs) ⇒ `Hash{String => String}`

#powered_by_header(method: :head, path: '/', **kwargs) ⇒ `String`^?

#prop_find {|response| ... } ⇒ `Net::HTTPResponse`

#prop_patch {|response| ... } ⇒ `Net::HTTPResponse`

#propfind(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#proppatch(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#put(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#request(method, path, query: nil, query_params: nil, headers: nil, content_type: nil, accept: nil, user_agent: @user_agent, cookie: @cookie, user: @user, password: @password, body: nil, form_data: nil, json: nil, **additional_headers) {|response| ... } ⇒ `Net::HTTPResponse`

#response_body(method = :get, path, **kwargs) ⇒ `String`

#response_headers(method = :head, path, **kwargs) ⇒ `Hash{String => String}`

#response_status(method = :head, path, **kwargs) ⇒ `Integer`

#server_header(method: :head, path: '/', **kwargs) ⇒ `String`^?

#ssl? ⇒ `Boolean`

#trace(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`

#unlock(path, **kwargs) {|response| ... } ⇒ `Net::HTTPResponse`