pwn 0.5.508 → 0.5.509

data/bin/pwn_domain_reversewhois

@@ -1,76 +0,0 @@
-#!/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

@@ -1,170 +0,0 @@
-#!/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

@@ -1,196 +0,0 @@
-#!/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

@@ -1,58 +0,0 @@
-#!/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

@@ -1,58 +0,0 @@
-#!/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

@@ -1,83 +0,0 @@
-#!/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