pwn 0.5.509 → 0.5.510

data/bin/pwn_bdba_groups

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-cCONFIG', '--config=CONFIG', '<Required - Black Duck Binary Analysis YAML config>') do |c|
+    opts[:config] = c
+  end
+
+  options.on('-CGROUP', '--create=GROUP', '<Optional - Group/Sub-Group to Create>') do |g|
+    opts[:group_name] = g
+  end
+
+  options.on('-lNAME', '--list-group=NAME', '<Optional - List Group Details>') do |l|
+    opts[:list_group_name] = l
+  end
+
+  options.on('-pID', '--parent-group-id=ID', '<Optional - Black Duck Binary Analysis Parent Group ID to Associate with Group>') do |p|
+    opts[:parent_group_id] = p
+  end
+
+  options.on('-bSEC', '--binary-cleanup-age=SEC', '<Optional - after how long the binary will be deleted in seconds (Default: 2_592_000 / 30 days)>') do |b|
+    opts[:binary_cleanup_age] = b
+  end
+
+  options.on('-PSEC', '--product-cleanup-age=SEC', '<Optional - after how long the product will be deleted in seconds (Default: 2_592_000 / 30 days)>') do |p|
+    opts[:product_cleanup_age] = p
+  end
+end.parse!
+
+begin
+  pwn_provider = 'ruby-gem'
+  pwn_provider = ENV.fetch('PWN_PROVIDER') if ENV.keys.any? { |s| s == 'PWN_PROVIDER' }
+
+  config = opts[:config]
+  raise "ERROR: BDBA YAML Config File Not Found: #{config}" unless File.exist?(config)
+
+  yaml_config = YAML.load_file(config, symbolize_names: true)
+
+  token = yaml_config[:token]
+  raise "ERROR: BDBA Token Not Found: #{token}" if token.nil?
+
+  list_group_name = opts[:list_group_name]
+  parent_group_id = opts[:parent_group_id]
+  binary_cleanup_age = opts[:binary_cleanup_age]
+  product_cleanup_age = opts[:product_cleanup_age]
+
+  if list_group_name
+    groups_resp = PWN::Plugins::BlackDuckBinaryAnalysis.get_groups(
+      token: token
+    )
+
+    group_arr = groups_resp[:groups].select { |g| g[:name] == list_group_name }
+
+    if list_group_name && group_arr.empty?
+      puts 'BDBA Group Not Found.'
+      exit 1
+    end
+
+    group_details_arr = []
+    # TODO: Add pagination support
+    # i.e. group_arr[:next]
+    group_arr.each do |group|
+      group_id = group[:id]
+
+      this_group_details = PWN::Plugins::BlackDuckBinaryAnalysis.get_group_details(
+        token: token,
+        group_id: group_id
+      )
+
+      group_details_arr.push(this_group_details)
+    end
+
+    if parent_group_id
+      filter_group_details_arr_by_parent = group_details_arr.select do |g|
+        g[:group][:parent] == parent_group_id.to_i
+      end
+      group_details_arr = filter_group_details_arr_by_parent
+      if group_details_arr.empty?
+        puts "BDBA Group Not Found for Parent Group ID: #{parent_group_id}"
+        exit 1
+      end
+    end
+
+    puts group_details_arr.to_json
+    exit 0
+  end
+
+  group_name = opts[:group_name]
+  raise "ERROR: BDBA Group Name Not Provided: #{group_name}" if group_name.nil?
+
+  create_group_resp = PWN::Plugins::BlackDuckBinaryAnalysis.create_group(
+    token: token,
+    name: group_name,
+    parent_id: parent_group_id,
+    binary_cleanup_age: binary_cleanup_age,
+    product_cleanup_age: product_cleanup_age
+  )
+
+  puts create_group_resp.to_json
+rescue SystemExit, Interrupt
+  puts "\nGoodbye."
+rescue StandardError => e
+  raise e
+end

data/bin/pwn_bdba_scan

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cgi'
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-cCONFIG', '--config=CONFG', '<Required - Black Duck Binary Analysis YAML config>') do |g|
+    opts[:config] = g
+  end
+
+  options.on('-pID', '--parent-group-id=ID', '<Required - Black Duck Binary Analysis Parent Group ID to Associate with Binary Scan>') do |p|
+    opts[:parent_group_id] = p
+  end
+
+  options.on('-sFILE', '--scan=FILE', '<Required - File to Scan in Black Duck Binary Analysis>') do |f|
+    opts[:target_file] = f
+  end
+
+  options.on('-rPATH', '--report=PATH', '<Required - Path to Save Black Duck Binary Analysis Scan Report>') do |r|
+    opts[:report_path] = r
+  end
+
+  options.on('-qSECONDS', '--queue-timeout=SECONDS', '<Optional - Duration in Seconds for a File to Remain in Queue Prior to Aborting (Default: 5_400)>') do |q|
+    opts[:queue_timeout] = q
+  end
+
+  options.on('-aATTEMPTS', '--scan-attempts=ATTEMPTS', '<Optional - Number of Attempts to Scan a File if the Scan was Aborted Due to Queue Timeouts or RestClient Exceptions (Default: 3)>') do |a|
+    opts[:scan_attempts] = a
+  end
+
+  options.on('-SSECONDS', '--sleep-between-scan-attempts=SECONDS', '<Optional - Seconds to Sleep Between Attempts to Scan a File if the Scan was Aborted Due to Queue Timeouts or RestClient Exceptions (Default: 60)>') do |s|
+    opts[:sleep_between_scan_attempts] = s
+  end
+
+  options.on('-R', '--report-only', '<Optional - Only Generate a Black Duck Binary Analysis Scan Report for an Existing Scan (Default: false)>') do |o|
+    opts[:report_only] = o
+  end
+
+  options.on('-tTYPE', '--report-type=TYPE', '<Optional - Black Duck Binary Analysis Scan Report Type csv_libs|csv_vulns|pdf|spdx (Default: csv_vulns)>') do |t|
+    opts[:report_type] = t
+  end
+
+  options.on('-vVERSION', '--version=VERSION', '<Optional - Version to Associate w/ Specific Scan (Default: nil)>') do |v|
+    opts[:version] = v
+  end
+end.parse!
+
+abort_total = 1
+begin
+  pwn_provider = 'ruby-gem'
+  pwn_provider = ENV.fetch('PWN_PROVIDER') if ENV.keys.any? { |s| s == 'PWN_PROVIDER' }
+
+  config = opts[:config]
+  raise "ERROR: BDBA YAML Config File Not Found: #{config}" unless File.exist?(config)
+
+  yaml_config = YAML.load_file(config, symbolize_names: true)
+
+  token = yaml_config[:token]
+  raise "ERROR: BDBA Token Not Found: #{token}" if token.nil?
+
+  parent_group_id = opts[:parent_group_id]
+  raise "ERROR: BDBA Parent Group ID Not Provided: #{parent_group_id}" if parent_group_id.nil?
+
+  target_file = opts[:target_file]
+  raise "ERROR: BDBA Target File Not Found: #{target_file}" unless File.exist?(target_file)
+
+  report_path = opts[:report_path]
+  raise "ERROR: BDBA Report Path Not Provided: #{report_path}" if report_path.nil?
+
+  queue_timeout = opts[:queue_timeout] ||= 5_400
+
+  scan_attempts = opts[:scan_attempts] ||= 3
+  sleep_between_scan_attempts = opts[:sleep_between_scan_attempts] ||= 60
+
+  report_only = opts[:report_only] ||= false
+
+  report_type_str = opts[:report_type] ||= 'csv_vulns'
+  report_type = report_type_str.to_s.to_sym
+
+  version = opts[:version]
+
+  unless report_only
+    puts "Uploading/Scanning: #{target_file}"
+    PWN::Plugins::BlackDuckBinaryAnalysis.upload_file(
+      token: token,
+      file: target_file,
+      group_id: parent_group_id,
+      version: version
+    )
+    puts "Scan Attempt #{abort_total} of #{scan_attempts}..."
+  end
+
+  scan_progress_resp = {}
+  scan_progress_busy_duration = 0
+  loop do
+    scan_progress_resp = PWN::Plugins::BlackDuckBinaryAnalysis.get_apps_by_group(
+      token: token,
+      group_id: parent_group_id
+    )
+
+    # Break out of infinite loop if status is anything other than 'B' (i.e. 'Busy')
+    # Possible status other than 'B' is:
+    # 'R' (i.e. 'Ready') or
+    # 'F' (i.e. 'Fail')
+    break if scan_progress_resp[:products].none? { |p| p[:status] == 'B' } || report_only
+
+    # Cancel queued scan if it's been queued for more than 90 minutes
+    if scan_progress_busy_duration > queue_timeout.to_i
+      puts "Scan Queued for More than #{queue_timeout} Seconds."
+      scan_progress_resp[:products].select { |p| p[:status] == 'B' }.each do |p|
+        puts "Abort Queued Scan: #{p[:name]}"
+        PWN::Plugins::BlackDuckBinaryAnalysis.abort_product_scan(
+          token: token,
+          product_id: p[:product_id]
+        )
+      end
+
+      raise IO::TimeoutError, "ERROR: BDBA Scan Aborted: #{target_file}"
+    end
+
+    10.times do
+      print '.'
+      sleep 1
+    end
+    scan_progress_busy_duration += 10
+  end
+
+  raise 'ERROR: BDBA Scan Failed - Check BDBA Logs for More Info...' if scan_progress_resp[:products].any? { |p| p[:status] == 'F' }
+
+  # Account for rare race condition scenario where get_apps_by_group may need to be called
+  # multiple times to find the product
+  find_product = nil
+  find_product_attempts = scan_attempts
+  print 'Looking for Product in Apps by Group...'
+  loop do
+    # target_basename = CGI.unescape_uri_component(File.basename(target_file))
+    # ^ Synopsis unescapes it for us.
+    target_basename = File.basename(target_file)
+
+    find_product = scan_progress_resp[:products].find { |p| p[:name] == target_basename }
+
+    break unless find_product.nil?
+
+    find_product_attempts += 1
+
+    raise "ERROR: Cannot Find Product in Apps by Group:\n#{scan_progress_resp}" if find_product_attempts >= scan_attempts
+
+    10.times do
+      print '.'
+      sleep 1
+    end
+
+    scan_progress_resp = PWN::Plugins::BlackDuckBinaryAnalysis.get_apps_by_group(
+      token: token,
+      group_id: parent_group_id
+    )
+  end
+  puts 'complete.'
+
+  product_id = find_product[:product_id]
+
+  scan_report_resp = PWN::Plugins::BlackDuckBinaryAnalysis.generate_product_report(
+    token: token,
+    product_id: product_id,
+    type: report_type,
+    output_path: report_path
+  )
+
+  puts "\nReport Saved to: #{report_path}"
+rescue IO::TimeoutError,
+       RestClient::BadGateway,
+       RestClient::BadRequest,
+       RestClient::Conflict,
+       RestClient::Exceptions::OpenTimeout,
+       RestClient::Forbidden,
+       RestClient::GatewayTimeout,
+       RestClient::InternalServerError,
+       RestClient::ResourceNotFound,
+       RestClient::ServiceUnavailable,
+       RestClient::Unauthorized
+
+  abort_total += 1
+
+  if abort_total <= scan_attempts.to_i
+    puts 'Sleeping for 60 Seconds and Retrying...'
+    sleep sleep_between_scan_attempts.to_i
+    retry
+  end
+
+  puts 'Scan Attempts Reached - Goodbye.'
+  exit 1
+rescue SystemExit, Interrupt
+  puts "\nGoodbye."
+rescue StandardError => e
+  raise e
+end

data/bin/pwn_burp_suite_pro_active_rest_api_scan

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+require 'uri'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-tTARGET', '--target_url=TARGET', '<Required - Target URI to Scan>') do |t|
+    opts[:target_url] = t
+  end
+
+  options.on('-oDIR', '--report_output_dir=DIR', '<Required - Output Directory for Active Scan Report>') do |o|
+    opts[:output_dir] = o
+  end
+
+  options.on('-dSWAGGER', '--swagger_definitions=SWAGGER', '<Required - Comma-delimited list of Swagger JSON/YAML files to import>') do |s|
+    opts[:swagger_definitions] = s
+  end
+
+  options.on('-bBPATH', '--burp_path=BPATH', '<Optional - Path to Burp Suite Pro Jar File (Defaults to /opt/burpsuite/burpsuite-pro.jar)>') do |b|
+    opts[:burp_jar_path] = b
+  end
+
+  options.on('-h', '--[no-]headless', '<Optional - Run Burp and Browser Headless>') do |h|
+    opts[:headless] = h
+  end
+
+  options.on('-bTYPE', '--browser_type=TYPE', '<Optional - Browser Type <firefox|chrome|headless|rest> (Defaults to firefox)>') do |b|
+    opts[:browser_type] = b
+  end
+
+  options.on('-D', '--[no-]debug', '<Optional - Enable Debug Output and Do Not Delete Temporary OpenAPI Spec>') do |d|
+    opts[:debug] = d
+  end
+
+  options.on('-vVERSION', '--openapi_spec_version=VERSION', '<Optional - OpenAPI/Swagger Specification Version (Defaults to 3.0.3)>') do |o|
+    opts[:openapi_spec_version] = o
+  end
+
+  options.on('-HJSON', '--additional_http_headers=JSON', '<Optional - JSON string of additional HTTP headers to include in requests (e.g. \'{"Header1":"Value1","Header2":"Value2"}\')>') do |h|
+    opts[:additional_http_headers] = h
+  end
+
+  options.on('-cCOLOR', '--highlight-color=COLOR', '<Optional - Highlight Color to use when importing OpenAPI/Swagger definitions  NONE||RED||ORANGE||YELLOW||GREEN||CYAN||BLUE||PINK||MAGENTA||GRAY (Defaults to GREEN)>') do |h|
+    opts[:highlight_color] = h
+  end
+
+  options.on('-nCOMMENTS', '--notes=COMMENTS', '<Optional - Comments to add when importing OpenAPI/Swagger definitions (Defaults to "Imported via <openapi_spec> on <timestamp>")>') do |n|
+    opts[:notes] = n
+  end
+
+  options.on('-eLIST', '--exclude_paths=LIST', '<Optional - Comma-delimited list of paths to exlude from scanning (e.g. "/api/login, /api/logout, /api/etc")>') do |e|
+    opts[:exclude_paths] = e
+  end
+
+  options.on('-iURL', '--in_scope=URL', '<Optional - URL to include in scope (Defaults to value of --target_url)>') do |s|
+    opts[:in_scope] = s
+  end
+end.parse!
+
+begin
+  timestamp = Time.now.strftime('%Y-%m-%d_%H-%M-%S%Z')
+  logger = PWN::Plugins::PWNLogger.create
+
+  target_url = opts[:target_url]
+  raise 'ERROR: --target_url is required.' if target_url.nil?
+
+  output_dir = opts[:output_dir]
+  raise 'ERROR: --report_output_dir is required.' if output_dir.nil?
+
+  swagger_definitions = opts[:swagger_definitions]
+  raise 'ERROR: --swagger_definitions is required.' if swagger_definitions.nil?
+
+  burp_jar_path = opts[:burp_jar_path]
+  headless = opts[:headless] || false
+  browser_type = opts[:browser_type] ||= :firefox
+  debug = opts[:debug] || false
+
+  swagger_defs_arr = swagger_definitions.split(',').map(&:strip)
+  scheme = URI.parse(target_url).scheme
+  target_host = URI.parse(target_url).host
+  base_url = "#{scheme}://#{target_host}"
+
+  openapi_spec_version = opts[:openapi_spec_version]
+  openapi_spec_root = File.dirname(swagger_defs_arr.first)
+  openapi_spec = "#{openapi_spec_root}/openapi_spec-#{target_host}-#{timestamp}.json"
+
+  PWN::Plugins::OpenAPI.generate_spec(
+    spec_paths: swagger_defs_arr,
+    base_url: base_url,
+    output_json_path: openapi_spec,
+    target_version: openapi_spec_version,
+    debug: debug
+  )
+
+  additional_http_headers = opts[:additional_http_headers]
+  additional_http_headers = JSON.parse(additional_http_headers, symbolize_names: true) if additional_http_headers.is_a?(String)
+
+  highlight_color = opts[:highlight_color] ||= 'GREEN'
+  notes = opts[:notes] ||= "Imported via #{openapi_spec} on #{timestamp}"
+
+  exlude_paths = opts[:exclude_paths]
+  exlude_paths = exlude_paths.split(',').map(&:strip) if exlude_paths.is_a?(String)
+
+  in_scope = opts[:in_scope] ||= target_url
+
+  # ------
+  # Open Burp
+  if headless
+    burp_obj = PWN::Plugins::BurpSuite.start(
+      burp_jar_path: burp_jar_path,
+      headless: headless
+    )
+  else
+    burp_obj = PWN::Plugins::BurpSuite.start(
+      burp_jar_path: burp_jar_path,
+      browser_type: browser_type
+    )
+  end
+
+  logger.info(burp_obj)
+  # Disable Proxy Intercepting Capabilities for this Driver
+  PWN::Plugins::BurpSuite.disable_proxy(burp_obj: burp_obj)
+
+  # Add URL to Target >> Scope >> Inclue in scope
+  PWN::Plugins::BurpSuite.add_to_scope(
+    burp_obj: burp_obj,
+    target_url: in_scope
+  )
+
+  json_sitemap = PWN::Plugins::BurpSuite.import_openapi_to_sitemap(
+    burp_obj: burp_obj,
+    openapi_spec: openapi_spec,
+    additional_http_headers: additional_http_headers,
+    highlight: highlight_color,
+    comment: notes,
+    debug: debug
+  )
+
+  raise "ERROR: Failed to import OpenAPI/Swagger spec #{openapi_spec} into Burp Suite Pro's Sitemap." if json_sitemap.nil? || json_sitemap.empty?
+
+  PWN::Plugins::BurpSuite.active_scan(
+    burp_obj: burp_obj,
+    target_url: in_scope,
+    exclude_paths: exlude_paths
+  )
+
+  # Dump a list of scan issues from Active Scan result
+  # scan_issues = PWN::Plugins::BurpSuite.get_scan_issues(burp_obj: burp_obj)
+  # puts scan_issues
+
+  # Once DefectDojo begins to support XML report results
+  report_types = %i[html xml]
+  report_types.each do |report_type|
+    PWN::Plugins::BurpSuite.generate_scan_report(
+      burp_obj: burp_obj,
+      target_url: in_scope,
+      report_type: report_type,
+      output_dir: output_dir
+    )
+  end
+rescue StandardError => e
+  raise e
+ensure
+  PWN::Plugins::BurpSuite.stop(burp_obj: burp_obj) unless burp_obj.nil?
+end

data/bin/pwn_burp_suite_pro_active_scan

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-tTARGET', '--target_url=TARGET', '<Required - Target URI to Scan>') do |t|
+    opts[:target_url] = t
+  end
+
+  options.on('-oDIR', '--report_output_dir=DIR', '<Required - Output Directory for Active Scan Report>') do |o|
+    opts[:output_dir] = o
+  end
+
+  options.on('-eLIST', '--exclude_paths=LIST', '<Optional - Comma-delimited list of paths to exlude from scanning (e.g. "/api/login, /api/logout, /api/etc")>') do |e|
+    opts[:exclude_paths] = e
+  end
+
+  options.on('-bBPATH', '--burp_path=BPATH', '<Optional - Path to Burp Suite Pro Jar File (Defaults to /opt/burpsuite/burpsuite-pro.jar)>') do |b|
+    opts[:burp_jar_path] = b
+  end
+
+  options.on('-h', '--[no-]headless', '<Optional - Run Burp and Browser Headless>') do |h|
+    opts[:headless] = h
+  end
+
+  options.on('-bTYPE', '--browser_type=TYPE', '<Optional - Browser Type <firefox|chrome|headless|rest> (Defaults to firefox)>') do |b|
+    opts[:browser_type] = b
+  end
+
+  options.on('-s', '--[no-]spider', '<Optional - Crawl / Spider Target Prior to Scanning (Defaults to false)>') do |s|
+    opts[:spider] = s
+  end
+
+  options.on('-IINST', '--navigation_instruct=INST', '<Optional - Path to Navigation Instructions (e.g. Auth w/ Target - see /pwn/etc/burpsuite/navigation.instruct.EXAMPLE)>') do |i|
+    opts[:navigation_instruct] = i
+  end
+
+  options.on('-iURL', '--in_scope=URL', '<Optional - URL to include in scope (Defaults to value of --target_url)>') do |s|
+    opts[:in_scope] = s
+  end
+end.parse!
+
+begin
+  logger = PWN::Plugins::PWNLogger.create
+
+  target_url = opts[:target_url]
+  raise 'ERROR: --target_url is required.' if target_url.nil?
+
+  output_dir = opts[:output_dir]
+  raise 'ERROR: --report_output_dir is required.' if output_dir.nil?
+
+  exlude_paths = opts[:exclude_paths]
+  exlude_paths = exlude_paths.split(',').map(&:strip) if exlude_paths.is_a?(String)
+  burp_jar_path = opts[:burp_jar_path]
+  headless = opts[:headless] || false
+  browser_type = opts[:browser_type] ||= :firefox
+  spider = opts[:spider] || false
+  navigation_instruct = opts[:navigation_instruct]
+  in_scope = opts[:in_scope] ||= target_url
+
+  # ------
+  # Open Burp
+  if headless
+    burp_obj = PWN::Plugins::BurpSuite.start(
+      burp_jar_path: burp_jar_path,
+      headless: headless
+    )
+  else
+    burp_obj = PWN::Plugins::BurpSuite.start(
+      burp_jar_path: burp_jar_path,
+      browser_type: browser_type
+    )
+  end
+
+  logger.info(burp_obj)
+  # Disable Proxy Intercepting Capabilities for this Driver
+  PWN::Plugins::BurpSuite.disable_proxy(burp_obj: burp_obj)
+
+  # Add URL to Target >> Scope >> Inclue in scope
+  PWN::Plugins::BurpSuite.add_to_scope(
+    burp_obj: burp_obj,
+    target_url: in_scope
+  )
+
+  # Use a headless browser w/ JavaScript Support to Load Our Target
+  # and Optionally Authenticate to Provide the Capability to Conduct
+  # a Burp Active Scan in a Post-AuthN state.  Since our browsers
+  # support JavaScript, DOM-based XSS vuln attempts are
+  # possible as well since we have a DOM to interact w/
+  # (Burp's DOM-XSS checks are based on static code analysis)
+  browser_obj = burp_obj[:mitm_browser]
+  browser = browser_obj[:browser]
+  browser.goto(target_url)
+
+  if navigation_instruct
+    File.read(navigation_instruct).each_line do |instruction|
+      # Look for any set method in this instruction and replace its value w/ asterisks
+      redact_regex = /\.set\(['"]([^'"]*)['"]\)/
+      redacted_instruction = instruction.gsub(redact_regex, ".set('********')")
+      print "\nExecuting Instruction: #{redacted_instruction}"
+      browser.instance_eval(instruction.to_s.scrub.strip.chomp)
+    end
+  end
+
+  PWN::Plugins::BurpSuite.spider(burp_obj: burp_obj, target_url: in_scope) if spider
+  PWN::Plugins::BurpSuite.active_scan(
+    burp_obj: burp_obj,
+    target_url: in_scope,
+    exclude_paths: exlude_paths
+  )
+
+  # Dump a list of scan issues from Active Scan result
+  # scan_issues = PWN::Plugins::BurpSuite.get_scan_issues(burp_obj: burp_obj)
+  # puts scan_issues
+
+  # Once DefectDojo begins to support XML report results
+  report_types = %i[html xml]
+  report_types.each do |report_type|
+    PWN::Plugins::BurpSuite.generate_scan_report(
+      burp_obj: burp_obj,
+      target_url: in_scope,
+      report_type: report_type,
+      output_dir: output_dir
+    )
+  end
+rescue StandardError => e
+  raise e
+ensure
+  PWN::Plugins::BurpSuite.stop(burp_obj: burp_obj) unless burp_obj.nil?
+end

data/bin/pwn_char_base64_encoding

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'base64'
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-pSTRING', '--payload=STRING', '<Required - String to Encode>') do |p|
+    opts[:payload] = p
+  end
+end.parse!
+
+payload = opts[:payload].to_s.scrub
+puts Base64.strict_encode64(payload)

data/bin/pwn_char_dec_encoding

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-pSTRING', '--payload=STRING', '<Required - String to Encode>') do |p|
+    opts[:payload] = p
+  end
+end.parse!
+
+payload = opts[:payload].to_s.scrub
+puts payload.unpack('C*')

data/bin/pwn_char_hex_escaped_encoding

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-pSTRING', '--payload=STRING', '<Required - String to Encode>') do |p|
+    opts[:payload] = p
+  end
+end.parse!
+
+payload = opts[:payload].to_s.scrub
+payload.each_char do |char|
+  print "\\x#{char.to_s.unpack1('H*')}"
+end
+print "\n"

data/bin/pwn_char_html_entity_encoding

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cgi'
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-pSTRING', '--payload=STRING', '<Required - String to Encode>') do |p|
+    opts[:payload] = p
+  end
+end.parse!
+
+payload = opts[:payload].to_s.scrub
+puts CGI.escapeHTML(payload)

data/bin/pwn_char_unicode_escaped_encoding

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pwn'
+
+opts = PWN::Env[:driver_opts]
+PWN::Driver::Parser.new do |options|
+  options.on('-pSTRING', '--payload=STRING', '<Required - String to Encode>') do |p|
+    opts[:payload] = p
+  end
+end.parse!
+
+payload = opts[:payload].to_s.scrub
+puts payload.unpack('U*').map { |i| "\\u#{i.to_s(16).rjust(4, '0')}" }.join