pwn 0.5.509 → 0.5.510

data/bin/pwn_domain_reversewhois

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'csv'
+require 'nokogiri'
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-sRFILTER', '--registrant-filter=RFILTER', '<Required - Registrant Name or Email Address>') do |s|
+    opts[:registrant_filter] = s
+  end
+
+  options.on('-oPATH', '--output-results=PATH', '<Required - Path to Output Results>') do |o|
+    opts[:output_results] = o
+  end
+
+  options.on('-pPROXY', '--proxy=PROXY', '<Optional - HTTP or Socks Proxy || tor>') do |p|
+    opts[:proxy] = p
+  end
+end.parse!
+
+registrant_filter = opts[:registrant_filter].to_s.strip.chomp.scrub
+output_results = opts[:output_results].to_s.strip.chomp.scrub
+proxy = opts[:proxy].to_s.scrub.strip.chomp unless opts[:proxy].nil?
+
+begin
+  if proxy
+    browser_obj = PWN::Plugins::TransparentBrowser.open(
+      browser_type: :headless,
+      proxy: proxy
+    )
+  else
+    browser_obj = PWN::Plugins::TransparentBrowser.open(browser_type: :headless)
+  end
+
+  browser = browser_obj[:browser]
+  browser.goto("https://viewdns.info/reversewhois/?q=#{CGI.escape(registrant_filter)}")
+
+  # Consume Results Table and Convert to CSV :)
+  reversewhois_xp_resp = Nokogiri::HTML(browser.html).xpath('//*[@id="null"]/tbody/tr[3]/td/font/table/tbody/tr')
+  CSV.open(output_results, 'w', col_sep: ',', quote_char: "'", force_quotes: true) do |csv|
+    reversewhois_xp_resp.each do |row|
+      tarray = []
+      row.xpath('td').each do |cell|
+        tarray << cell.text
+      end
+      csv << tarray
+    end
+  end
+
+  # Ok, now let's append domain bigdata.com
+  browser.goto('https://domainbigdata.com')
+
+  # Type Registrant Filter in Char-by-Char to Ensure Everyone is Happy ;)
+  PWN::Plugins::TransparentBrowser.type_as_human(string: registrant_filter) do |char|
+    browser.text_field(id: 'txtSearchTopPage').wait_until(&:present?).send_keys(char)
+  end
+  browser.button(id: 'btnTopSearch').wait_until(&:present?).click
+
+  # Consume Results Table and Convert to CSV :)
+  reversewhois_xp_resp = Nokogiri::HTML(browser.html).xpath('//*[@id="domain-same-ip"]/div/div/table/tbody/tr')
+  CSV.open(output_results, 'a', col_sep: ',', quote_char: "'", force_quotes: true) do |csv|
+    reversewhois_xp_resp.each do |row|
+      tarray = []
+      row.xpath('td').each do |cell|
+        tarray << cell.text
+      end
+      csv << tarray
+    end
+  end
+rescue StandardError => e
+  raise e
+ensure
+  browser_obj = PWN::Plugins::TransparentBrowser.close(browser_obj: browser_obj) unless browser_obj.nil?
+end

data/bin/pwn_fuzz_net_app_proto

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'htmlentities'
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-dDIR', '--dir-path=DIR', '<Required - Report Output Directory>') do |d|
+    opts[:dir_path] = d
+  end
+
+  options.on('-tHOST', '--target-host=HOST', '<Required - Target Host or IP>') do |t|
+    opts[:target] = t
+  end
+
+  options.on('-pPORT', '--port=PORT', '<Required - Target Port>') do |p|
+    opts[:port] = p
+  end
+
+  options.on('-PPROTOCOL', '--protocol=PROTOCOL', '<Optional - tcp || udp (defaults to tcp)>') do |p|
+    opts[:protocol] = p
+  end
+
+  options.on('-S', '--[no-]secure', '<Optional - boolean to connect to target socket using TLS (defaults to false)') do |s|
+    opts[:tls] = s
+  end
+
+  options.on('-FCHAR', '--fuzz-delimeter=CHAR', "<optional - fuzz delimeter used in request to specify where payloads should reside (defaults to \u2665)>") do |c|
+    opts[:fuzz_delimeter] = c
+  end
+
+  options.on('-rREQUEST', '--request-format=REQUEST', "<Required - String object of socket request w/ \u2665 as position delimeter (e.g. '\"GET /\u2665\u2665 HTTP/1.1\\r\\nHost: \u2665127.0.0.1\u2665\\r\\n\\r\\n\"'>") do |r|
+    opts[:request] = r
+  end
+
+  options.on('-fFILE', '--fuzz-file=FILE', '<Required - path of file containing fuzz requests>') do |f|
+    opts[:fuzz_file] = f
+  end
+
+  options.on('-eENC', '--payload-encoding=ENC', '<Optional - encode payload base64 || hex || html_entity || url (Defaults to nil)>') do |e|
+    opts[:encoding] = e
+  end
+
+  options.on('-DDEPTH', '--encoding-depth=DEPTH', '<Optional - payload encoding payload depth (Defaults to 1)>') do |d|
+    opts[:encoding_depth] = d
+  end
+
+  options.on('-cENC', '--char-encoding=ENC', '<Optional - character encoding returned by PWN::Plugins::Char.list_encoders (defaults to UTF-8)>') do |c|
+    opts[:char_encoding] = c
+  end
+
+  options.on('-TFLOAT', '--response-timeout=FLOAT', '<Optional - float (defaults to 0.3)>') do |f|
+    opts[:response_timeout] = f
+  end
+
+  options.on('-lFLOAT', '--request-rate-limit=FLOAT', '<Optional - limit between requests in a given thread (defaults to 0.0)>') do |l|
+    opts[:request_rate_limit] = l
+  end
+
+  options.on('-mINT', '--max-threads=INT', '<Optional - fuzz payloads to send in parallel (defaults to 1)>') do |i|
+    opts[:max_threads] = i
+  end
+
+  options.on('-nREPORTNAME', '--report-name=REPORTNAME', '<Optional Report Name (Defaults to, "File.basename(Dir.pwd)")>') do |n|
+    opts[:report_name] = n
+  end
+
+  options.on('-s', '--[no-]start-reporting-server', '<Optional - Start Simple HTTP Server for Reporting>') do |s|
+    opts[:start_reporting_server] = s
+  end
+end.parse!
+
+pwn_provider = 'ruby-gem'
+# pwn_provider = ENV.fetch('PWN_PROVIDER') if ENV.keys.select { |s| s == 'PWN_PROVIDER' }.any?
+pwn_provider = ENV.fetch('PWN_PROVIDER') if ENV.keys.any? { |s| s == 'PWN_PROVIDER' }
+
+if pwn_provider == 'ruby-gem'
+  require 'pwn'
+elsif pwn_provider == 'docker'
+  require '/opt/pwn/lib/pwn'
+else
+  raise "PWN_PROVIDER env variable is not set to 'ruby-gem' or 'docker'"
+end
+
+dir_path = opts[:dir_path] ||= '.'
+target = opts[:target]
+port = opts[:port]
+protocol = opts[:protocol]
+tls = opts[:tls]
+fuzz_delimeter = opts[:fuzz_delimeter]
+request = opts[:request]
+fuzz_file = opts[:fuzz_file].to_s.strip.scrub.chomp if File.exist?(opts[:fuzz_file].to_s.strip.scrub.chomp)
+encoding = opts[:encoding]
+encoding_depth = opts[:encoding_depth]
+opts[:char_encoding].nil? ? char_encoding = 'UTF-8' : char_encoding = opts[:char_encoding]
+response_timeout = opts[:response_timeout]
+request_rate_limit = opts[:request_rate_limit]
+opts[:max_threads].nil? ? max_threads = 1 : max_threads = opts[:max_threads].to_i
+report_name = opts[:report_name]
+report_name ||= File.basename(Dir.pwd)
+start_reporting_server = opts[:start_reporting_server]
+
+results_hash = {
+  report_name: HTMLEntities.new.encode(
+    report_name.to_s.strip.scrub.chomp
+  ),
+  data: []
+}
+results_arr = []
+mutex = Mutex.new
+
+slice = max_threads * 3
+File.open(fuzz_file, "rb:#{char_encoding}") do |file|
+  file.each_slice(slice) do |payload_batch_arr|
+    PWN::Plugins::ThreadPool.fill(
+      enumerable_array: payload_batch_arr,
+      max_threads: max_threads
+    ) do |payload|
+      socket_fuzz_results_arr = PWN::Plugins::Fuzz.socket(
+        target: target,
+        port: port,
+        protocol: protocol,
+        tls: tls,
+        fuzz_delimeter: fuzz_delimeter,
+        request: request.to_s.b,
+        payload: payload.to_s.b.chomp,
+        encoding: encoding,
+        encoding_depth: encoding_depth,
+        char_encoding: char_encoding,
+        response_timeout: response_timeout,
+        request_rate_limit: request_rate_limit
+      )
+      socket_fuzz_results_arr.each do |hash_line|
+        mutex.synchronize do
+          results_hash[:data].push(hash_line)
+        end
+      end
+    end
+  end
+end
+
+# Generate HTML Report
+print "#{File.basename($PROGRAM_NAME)} Generating Report..."
+PWN::Reports::Fuzz.generate(
+  dir_path: dir_path,
+  results_hash: results_hash,
+  char_encoding: char_encoding
+)
+puts 'complete.'
+
+# Start Simple HTTP Server (If Requested)
+if start_reporting_server
+  listen_port = PWN::Plugins::Sock.get_random_unused_port.to_s
+  if pwn_provider == 'docker'
+    listen_ip = '0.0.0.0'
+  else
+    listen_ip = '127.0.0.1'
+  end
+  puts "For Scan Results Navigate to: http://127.0.0.1:#{listen_port}/#{report_name}.html"
+  simple_http_server_params = "-i #{listen_ip} -p #{listen_port}"
+  Dir.chdir(dir_path)
+  system(
+    'pwn_simple_http_server',
+    '-i',
+    listen_ip,
+    '-p',
+    listen_port.to_s
+  )
+end

data/bin/pwn_gqrx_scanner

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-aPROFILE', '--assume-profile=PROFILE', '<Required if "--target-freq" is Nil - Profile to assume for common radio protocols.  Use "--list-profiles" to display supported protocols (Defaults to nil)') do |p|
+    opts[:profile] = p
+  end
+
+  options.on('-l', '--list-scan-profiles', '<Optional - List supported scan profiles and exit>') do |l|
+    opts[:list_scan_profiles] = l
+  end
+
+  options.on('-tFREQ', '--target-freq=FREQ', '<Required if "--assume-profile" is Nil - Frequency to Conclude Scanning (e.g. 900.000.000 == 900 mHz>') do |e|
+    opts[:target_freq] = e
+  end
+
+  options.on('-sFREQ', '--start-freq=FREQ', '<Optional - Frequency to Set when Scanning Begins (Defaults to last known frequency)>') do |s|
+    opts[:start_freq] = s
+  end
+
+  options.on('-hHOST', '--host=HOST', '<Optional - GQRX Host (Defaults to 127.0.0.1)>') do |h|
+    opts[:host] = h
+  end
+
+  options.on('-pPORT', '--port=PORT', '<Optional - GQRX Port (Defaults to 7356)>') do |p|
+    opts[:port] = p
+  end
+
+  options.on('-AFLOAT', '--audio-gain=FLOAT', '<Optional - Set audio gain -80.0 to 50.0 (Defaults to 1.0)>') do |a|
+    opts[:audio_gain_db] = a
+  end
+
+  options.on('-bHZ', '--bandwidth=HZ', '<Optional - Set Bandwidth 0.0 - SDR Bandwidth Limit, e.g. 20.000.000 (Defaults to 270.000)>') do |b|
+    opts[:bandwidth] = b
+  end
+
+  options.on('-DMODE', '--demodulator-mode=MODE', '<Optional - Set Demodulator Mode OFF | RAW | AM | FM | WFM | WFM_ST | WFM_ST_OIRT | LSB | USB | CW | CWL | CWU (Defaults to WFM_ST)>') do |d|
+    opts[:demodulator_mode] = d
+  end
+
+  options.on('-PINT', '--precision=INT', '<Optional - Precision of Frequency 1-12 (Defaults to 5)>') do |p|
+    opts[:precision] = p
+  end
+
+  options.on('-SFLOAT', '--strength-lock=FLOAT', '<Optional - Strength to lock onto frequency (Defaults to -45.0)>') do |s|
+    opts[:strength_lock] = s
+  end
+
+  options.on('-LFLOAT', '--lock-freq-duration=FLOAT', '<Optional - Duration to lock onto Freqency when Strength < --strength-lock value (Defaults to 0.5)>') do |l|
+    opts[:lock_freq_duration] = l
+  end
+
+  options.on('-QFLOAT', '--squelch=FLOAT', '<Optional - Squelch Threshold -150.0 to 0 (Defaults to -50.0)>') do |q|
+    opts[:squelch] = q
+  end
+
+  options.on('-RFLOAT', '--rf-gain=FLOAT', '<Optional - RF Gain 0.0-16.0(Defaults to 16.0)>') do |r|
+    opts[:rf_gain] = r
+  end
+
+  options.on('-IFLOAT', '--intermediate-gain=FLOAT', '<Optional - Intermediate Gain 0.0-40.0 (Defaults to 40.0)>') do |i|
+    opts[:intermediate_gain] = i
+  end
+
+  options.on('-BFLOAT', '--basedband-gain=FLOAT', '<Optional - Baseband Gain 0.0-62.0 (Defaults to 10.0)>') do |b|
+    opts[:baseband_gain] = b
+  end
+end.parse!
+
+begin
+  pwn_provider = 'ruby-gem'
+  pwn_provider = ENV.fetch('PWN_PROVIDER') if ENV.keys.any? { |s| s == 'PWN_PROVIDER' }
+
+  list_scan_profiles = opts[:list_scan_profiles]
+  if list_scan_profiles
+    profiles_available = PWN::SDR::GQRX.list_scan_profiles
+    puts JSON.pretty_generate(profiles_available)
+    exit 0
+  end
+
+  profile = opts[:profile]
+  opts = PWN::SDR::GQRX.assume_profile(profile: profile) unless profile.nil?
+
+  target_freq = opts[:target_freq]
+  target_freq = target_freq.to_s.delete('.') unless target_freq.nil?
+  target_freq = target_freq.to_i
+  raise 'ERROR: --assume-profile || --target-freq is required.' if target_freq.zero? && profile.nil?
+
+  host = opts[:host]
+  port = opts[:port]
+
+  puts "Connecting to GQRX at #{host}:#{port}..."
+  gqrx_sock = PWN::SDR::GQRX.connect(target: host, port: port)
+
+  start_freq = opts[:start_freq]
+  start_freq = start_freq.to_s.delete('.') unless start_freq.nil?
+  start_freq = start_freq.to_i
+  if start_freq.zero?
+    start_freq = PWN::SDR::GQRX.gqrx_cmd(
+      gqrx_sock: gqrx_sock, cmd: 'f',
+      resp_ok: 'RPRT 0'
+    ).to_i
+  end
+
+  demodulator_mode = opts[:demodulator_mode] ||= 'WFM_ST'
+  puts "Demodulator Mode: #{demodulator_mode}"
+  # demodulator_mode.upcase! if opts[:demodulator_mode]
+  demodulator_modes = %i[OFF RAW AM FM WFM WFM_ST WFM_ST_OIRT LSB USB CW CWL CWU]
+  raise "ERROR: Invalid demodulator mode: #{demodulator_mode}" unless demodulator_modes.include?(demodulator_mode)
+
+  bandwidth = opts[:bandwidth] ||= '200.000'
+
+  puts "Setting demodulator mode to #{demodulator_mode} and bandwidth to #{bandwidth}..."
+  bandwidth = bandwidth.to_s.delete('.').to_i unless bandwidth.nil?
+  demod_resp = PWN::SDR::GQRX.gqrx_cmd(
+    gqrx_sock: gqrx_sock,
+    cmd: "M #{demodulator_mode} #{bandwidth}",
+    resp_ok: 'RPRT 0'
+  )
+
+  audio_gain_db = opts[:audio_gain_db] ||= 1.0
+  audio_gain_db = audio_gain_db.to_f
+  audio_gain_db_resp = PWN::SDR::GQRX.gqrx_cmd(
+    gqrx_sock: gqrx_sock,
+    cmd: "L AF #{audio_gain_db}",
+    resp_ok: 'RPRT 0'
+  )
+
+  squelch = opts[:squelch] ||= -63.0
+  squelch = squelch.to_f
+  squelch_resp = PWN::SDR::GQRX.gqrx_cmd(
+    gqrx_sock: gqrx_sock,
+    cmd: "L SQL #{squelch}",
+    resp_ok: 'RPRT 0'
+  )
+
+  precision = opts[:precision] ||= 5
+  precision = precision.to_i
+  raise "ERROR: Invalid precision: #{precision}" unless (1..12).include?(precision)
+
+  lock_freq_duration = opts[:lock_freq_duration] ||= 0.5
+  lock_freq_duration = lock_freq_duration.to_f
+
+  strength_lock = opts[:strength_lock] ||= -60.0
+  strength_lock = strength_lock.to_f
+
+  rf_gain = opts[:rf_gain] ||= 0.0
+  rf_gain = rf_gain.to_f
+  rf_gain_resp = PWN::SDR::GQRX.gqrx_cmd(
+    gqrx_sock: gqrx_sock,
+    cmd: "L RF_GAIN #{rf_gain}",
+    resp_ok: 'RPRT 0'
+  )
+
+  intermediate_gain = opts[:intermediate_gain] ||= 32.0
+  intermediate_gain = intermediate_gain.to_f
+  intermediate_resp = PWN::SDR::GQRX.gqrx_cmd(
+    gqrx_sock: gqrx_sock,
+    cmd: "L IF_GAIN #{intermediate_gain}",
+    resp_ok: 'RPRT 0'
+  )
+
+  baseband_gain = opts[:baseband_gain] ||= 10.0
+  baseband_gain = baseband_gain.to_f
+  baseband_resp = PWN::SDR::GQRX.gqrx_cmd(
+    gqrx_sock: gqrx_sock,
+    cmd: "L BB_GAIN #{baseband_gain}",
+    resp_ok: 'RPRT 0'
+  )
+
+  s_freq_pretty = start_freq.to_s.chars.insert(-4, '.').insert(-8, '.').join
+  t_freq_pretty = target_freq.to_s.chars.insert(-4, '.').insert(-8, '.').join
+  puts "*** Scanning from #{s_freq_pretty} to #{t_freq_pretty}\n\n\n"
+
+  PWN::SDR::GQRX.scan_range(
+    gqrx_sock: gqrx_sock,
+    demodulator_mode: demodulator_mode,
+    bandwidth: bandwidth,
+    start_freq: start_freq,
+    target_freq: target_freq,
+    precision: precision,
+    lock_freq_duration: lock_freq_duration,
+    strength_lock: strength_lock,
+    squelch: squelch
+  )
+  puts 'Scan Complete.'
+rescue StandardError => e
+  raise e
+rescue Interrupt, SystemExit
+  puts "\nGoodbye."
+ensure
+  gqrx_sock = PWN::SDR::GQRX.disconnect(gqrx_sock: gqrx_sock) unless gqrx_sock.nil?
+end

data/bin/pwn_jenkins_create_job

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-sIP', '--ip=IP', '<Required - Jenkins Server IP>') { |s| opts[:ip] = s }
+
+  options.on('-dPORT', '--dest-port=PORT', '<Optional - Jenkins Server Port (Defaults to 8080)>') do |port|
+    opts[:port] = port
+  end
+
+  options.on('-UUSER', '--username=USER', '<Required - Jenkins Username>') do |user|
+    opts[:username] = user
+  end
+
+  options.on('-PKEY', '--api-key=KEY', '<Optional - Jenkins API Key (Will Prompt if Flag Undetected)>') do |api_key|
+    opts[:api_key] = api_key
+  end
+
+  options.on('-jNAME', '--job-name=NAME', '<Required - Name of Job to Create>') do |job|
+    opts[:job_name] = job
+  end
+
+  options.on('-cPATH', '--config-xml=PATH', '<Required - Path to config.xml>') do |xml|
+    opts[:config_xml] = xml
+  end
+end.parse!
+
+ip = opts[:ip].to_s.scrub
+port = opts[:port].to_i
+username = opts[:username]
+api_key = opts[:api_key]
+job_name = opts[:job_name].to_s.scrub
+config_xml = File.read(opts[:config_xml]) if File.exist?(opts[:config_xml])
+
+if port.positive?
+  jenkins_obj = PWN::Plugins::Jenkins.connect(
+    ip: ip,
+    port: port,
+    username: username,
+    api_key: api_key
+  )
+else
+  jenkins_obj = PWN::Plugins::Jenkins.connect(
+    ip: ip,
+    username: username,
+    api_key: api_key
+  )
+end
+
+jenkins_obj.job.create(
+  job_name,
+  config_xml
+)
+
+PWN::Plugins::Jenkins.disconnect(jenkins_obj: jenkins_obj)

data/bin/pwn_jenkins_create_view

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-sIP', '--ip=IP', '<Required - Jenkins Server IP>') { |s| opts[:ip] = s }
+
+  options.on('-dPORT', '--dest-port=PORT', '<Optional - Jenkins Server Port (Defaults to 8080)>') do |port|
+    opts[:port] = port
+  end
+
+  options.on('-UUSER', '--username=USER', '<Required - Jenkins Username>') do |user|
+    opts[:username] = user
+  end
+
+  options.on('-PKEY', '--api-key=KEY', '<Required - Jenkins API Key>') do |api_key|
+    opts[:api_key] = api_key
+  end
+
+  options.on('-vVIEW', '--view-name=VIEW', '<Required - View Name to Create>') do |view_name|
+    opts[:view_name] = view_name
+  end
+
+  options.on('-rREGX', '--regx-filter=REGEX', '<Required - RegEx >') do |regex_filter|
+    opts[:regex_filter] = regex_filter
+  end
+end.parse!
+
+ip = opts[:ip].to_s.scrub
+port = opts[:port].to_i
+username = opts[:username]
+api_key = opts[:api_key]
+view_name = opts[:view_name].to_s.chomp.strip.scrub
+regex_filter = opts[:regex_filter].to_s.chomp.strip.scrub
+
+if port.positive?
+  jenkins_obj = PWN::Plugins::Jenkins.connect(
+    ip: ip,
+    port: port,
+    username: username,
+    api_key: api_key
+  )
+else
+  jenkins_obj = PWN::Plugins::Jenkins.connect(
+    ip: ip,
+    username: username,
+    api_key: api_key
+  )
+end
+
+jenkins_obj.view.create_list_view(
+  name: view_name,
+  regex: regex_filter
+)
+
+PWN::Plugins::Jenkins.disconnect(jenkins_obj: jenkins_obj)

data/bin/pwn_jenkins_install_plugin

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-sIP', '--ip=IP', '<Required - Jenkins Server IP>') { |s| opts[:ip] = s }
+
+  options.on('-dPORT', '--dest-port=PORT', '<Optional - Jenkins Server Port (Defaults to 8080)>') do |port|
+    opts[:port] = port
+  end
+
+  options.on('-UUSER', '--username=USER', '<Required - Jenkins Username>') do |user|
+    opts[:username] = user
+  end
+
+  options.on('-PKEY', '--api-key=KEY', '<Required - Jenkins API Key>') do |api_key|
+    opts[:api_key] = api_key
+  end
+
+  options.on('-pPLUGIN', '--plugin=PLUGIN', '<Required - Comma-Delimited List of Jenkins Plugins to Install>') do |plugins|
+    opts[:plugins] = plugins
+  end
+
+  options.on('-L', '--list-available', '<Optional - List Available Jenkins Plugins for Installation>') do |list_available_bool|
+    opts[:list_available_bool] = list_available_bool
+  end
+
+  options.on('-R', '--restart-jenkins', '<Do not Install Plugins - Just Restart Jenkins - Defaults to false>') do |restart_bool|
+    opts[:restart_jenkins] = restart_bool
+  end
+end.parse!
+
+begin
+  ip = opts[:ip].to_s.scrub
+  port = opts[:port].to_i
+  username = opts[:username]
+  api_key = opts[:api_key]
+  plugins = opts[:plugins].to_s.scrub
+  list_available_bool = true if opts[:list_available_bool] ||= false
+  restart_jenkins = true if opts[:restart_jenkins] ||= false
+
+  if port.positive?
+    jenkins_obj = PWN::Plugins::Jenkins.connect(
+      ip: ip,
+      port: port,
+      username: username,
+      api_key: api_key
+    )
+  else
+    jenkins_obj = PWN::Plugins::Jenkins.connect(
+      ip: ip,
+      username: username,
+      api_key: api_key
+    )
+  end
+
+  if restart_jenkins
+    puts 'Restarting Jenkins...'
+    jenkins_obj.system.restart
+    exit 0
+  end
+
+  if list_available_bool
+    puts jenkins_obj.plugin.list_available
+  else
+    plugin_arr = []
+    plugins.split(',').each do |p|
+      plugin_arr.push(p.strip.chomp)
+    end
+
+    jenkins_obj.plugin.install(plugin_arr)
+  end
+rescue Interrupt
+  puts "\nGoodbye."
+rescue JenkinsApi::Exceptions::ServiceUnavailable
+  puts 'Jenkins Server Unavailable.' unless restart_jenkins
+rescue StandardError => e
+  raise e
+ensure
+  PWN::Plugins::Jenkins.disconnect(jenkins_obj: jenkins_obj) unless restart_jenkins
+end