pwn 0.5.708 → 0.5.710

data/lib/pwn/plugins/assembly.rb

@@ -252,23 +252,28 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run opcodes to asm and return its result
           #{self}.opcodes_to_asm(
-            opcodes: 'required - hex escaped opcode(s) (e.g. \"\\x90\\x90\\x90\")',
+            opcodes: 'required - hex escaped opcode(s) (e.g. \\x90\\x90\\x90)',
             opcodes_always_string_obj: 'optional - always interpret opcodes passed in as a string object (defaults to false)',
             arch: 'optional - architecture returned from objdump --info (defaults to PWN::Plugins::DetectOS.arch)',
-            endian: 'optional - endianess :big|:little (defaults to system endianess)'
+            endian: 'optional - endianess :big|:little (defaults to current system endianess)'
           )
 
+          # Run asm to opcodes and return its result
           #{self}.asm_to_opcodes(
-            asm: 'required - assembly instruction(s) (e.g. 'nop\nnop\nnop\njmp rsp\n)',
+            asm: 'required - assembly instruction(s) (e.g. nop\\nnop\\nnop\\njmp rsp\\n)',
             arch: 'optional - architecture returned from objdump --info (defaults to PWN::Plugins::DetectOS.arch)',
-            endian: 'optional - endianess :big|:little (defaults to system endianess)'
+            endian: 'optional - endianess :big|:little (defaults to current system endianess)'
           )
 
+          # Run list supported archs and return its result
           #{self}.list_supported_archs
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/authentication_helper.rb

@@ -66,20 +66,23 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          #{self}.username(
-            prompt: 'optional - string to display at prompt'
-          )
+          # Run username and return its result
+          #{self}.username
 
+          # Run mask password and return its result
           #{self}.mask_password(
-            prompt: 'optional - string to display at prompt'
+            prompt: 'optional - string to display at prompt (Default: Password)'
           )
 
+          # Run mfa and return its result
           #{self}.mfa(
-            prompt: 'optional - string to display at prompt'
+            prompt: 'optional - string to display at prompt (Default: MFA Token)'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/baresip.rb

@@ -682,26 +682,73 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          baresip_obj = #{self}.start(
-            src_num: 'Optional source phone number displayed',
-            baresip_bin: 'Optional path of baresip binary (Defaults to /usr/bin/baresip)',
-            config_root: 'Optional dir of baresip config (Defaults to ~/.baresip)',
-            session_root: 'Optional dir of baresip session (Defaults to Dir.pwd)',
-            screenlog_path: 'Optional path of screenlog file (Defaults to screenlog.txt)',
-            screen_session: 'Optional name of screen session (Defaults baresip)'
+          # Run start and return its result
+          #{self}.start(
+            src_num: 'optional - Optional source phone number displayed',
+            baresip_bin: 'optional - Optional path of baresip binary (Defaults to /usr/bin/baresip)',
+            config_root: 'optional - Optional dir of baresip config (Defaults to ~/.baresip)',
+            session_root: 'optional - Optional dir of baresip session (Defaults to Dir.pwd)',
+            screenlog_path: 'optional - Optional path of screenlog file (Defaults to screenlog.txt)',
+            screen_session: 'optional - Optional name of screen session (Defaults baresip)'
           )
 
-          cmd_resp = #{self}.baresip_exec(
-            baresip_obj: 'Required - baresip obj returned from #start method',
-            cmd: 'Required - command to send to baresip HTTP daemon'
+          # Run baresip exec and return its result
+          #{self}.baresip_exec(
+            baresip_obj: 'required - baresip obj returned from #start method',
+            cmd: 'required - command to send to baresip HTTP daemon'
           )
 
-          stopped_bool = #{self}.stop(
-            screen_session: 'Required - screen session to stop'
+          # Run stop and return its result
+          #{self}.stop(
+            screen_session: 'required - screen session to stop',
+            baresip_obj: 'optional - baresip obj value consumed by #stop'
           )
 
+          # Run parse target file and return its result
+          #{self}.parse_target_file(
+            target_file: 'required - txt file containing phone numbers to dial',
+            randomize: 'optional - randomize list of phone numbers to dial (Defaults to false)'
+          )
+
+          # Run apply src num rules and return its result
+          #{self}.apply_src_num_rules(
+            target_num: 'required - destination number to derive source number',
+            src_num_rules: 'optional - Comma-delimited list of rules for src_num format (i.e. XXXXXXXXXX, self, same_country, same_area, and/or same_prefix [Defaults to random src_num w/ same length as target_num])',
+            config_root: 'optional - config root value consumed by #apply_src_num_rules'
+          )
+
+          # Run dial target in list and return its result
+          #{self}.dial_target_in_list(
+            baresip_bin: 'optional - baresip bin value consumed by #dial_target_in_list',
+            target_num: 'optional - target num value consumed by #dial_target_in_list',
+            config_root: 'optional - config root value consumed by #dial_target_in_list',
+            session_root: 'optional - session root value consumed by #dial_target_in_list',
+            randomize: 'optional - randomize value consumed by #dial_target_in_list',
+            src_num_rules: 'optional - src num rules value consumed by #dial_target_in_list',
+            seconds_to_record: 'optional - seconds to record value consumed by #dial_target_in_list',
+            sox_bin: 'optional - sox bin value consumed by #dial_target_in_list',
+            speech_to_text: 'optional - speech to text value consumed by #dial_target_in_list'
+          )
+
+          # Run recon and return its result
+          #{self}.recon(
+            baresip_bin: 'optional - baresip bin value consumed by #recon',
+            config_root: 'optional - config root value consumed by #recon',
+            session_root: 'optional - session root value consumed by #recon',
+            target_file: 'optional - target file value consumed by #recon',
+            randomize: 'optional - randomize value consumed by #recon',
+            src_num_rules: 'optional - src num rules value consumed by #recon',
+            max_threads: 'optional - max threads value consumed by #recon',
+            seconds_to_record: 'optional - seconds to record value consumed by #recon',
+            sox_bin: 'optional - sox bin value consumed by #recon',
+            speech_to_text: 'optional - speech to text value consumed by #recon',
+            report_name: 'optional - report name value consumed by #recon'
+          )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/basic_auth.rb

@@ -48,15 +48,21 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run encode and return its result
           #{self}.encode(
-            username: 'optional username',
-            password: 'optional password'
+            username: 'optional - optional username',
+            password: 'optional - optional password'
           )
 
-          #{self}.decode(base64_str: 'base64 encoded string')
+          # Run decode and return its result
+          #{self}.decode(
+            base64_str: 'required - required base64 encoded string'
+          )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/beef.rb

@@ -266,46 +266,56 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          beef_obj = #{self}.login(
-            beef_ip: 'required host/ip of Nexpose Console (server)',
+          # Run login and return its result
+          #{self}.login(
+            beef_ip: 'required - host/ip of BeEF Server',
             beef_port: 'optional - port of BeEF server (defaults to 3000)',
-            username: 'required username',
-            password: 'optional password (will prompt if nil)'
+            username: 'required - username value consumed by #login',
+            password: 'optional - password (will prompt if nil)'
           )
 
-          hooks = #{self}.hooks(
-            beef_obj: 'required beef_obj returned from #login method'
+          # Run hooks and return its result
+          #{self}.hooks(
+            beef_obj: 'required - required beef_obj returned from #login method'
           )
 
-          hooked_browser_info = #{self}.hooked_browser_info(
-            beef_obj: 'required beef_obj returned from #login method',
+          # Run hooked browser info and return its result
+          #{self}.hooked_browser_info(
+            beef_obj: 'required - required beef_obj returned from #login method',
             browser_session: 'required - browser session id returned from #hooks method'
           )
 
-          logs = #{self}.logs(
-            beef_obj: 'required beef_obj returned from #login method'
+          # Run logs and return its result
+          #{self}.logs(
+            beef_obj: 'required - required beef_obj returned from #login method'
           )
 
-          hooked_browser_logs = #{self}.hooked_browser_logs(
-            beef_obj: 'required beef_obj returned from #login method',
+          # Run hooked browser logs and return its result
+          #{self}.hooked_browser_logs(
+            beef_obj: 'required - required beef_obj returned from #login method',
             browser_session: 'required - browser session id returned from #hooks method'
           )
 
-          modules = #{self}.modules(
-            beef_obj: 'required beef_obj returned from #login method'
+          # Run modules and return its result
+          #{self}.modules(
+            beef_obj: 'required - required beef_obj returned from #login method'
           )
 
-          module_info = #{self}.module_info(
-            beef_obj: 'required beef_obj returned from #login method',
+          # Run module info and return its result
+          #{self}.module_info(
+            beef_obj: 'required - required beef_obj returned from #login method',
             module_id: 'required - module id returned from #modules method'
           )
 
-          beef_obj = #{self}.logout(
-            beef_obj: 'required beef_obj returned from #login method'
+          # Run logout and return its result
+          #{self}.logout(
+            beef_obj: 'required - required beef_obj returned from #login method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/binary_parser.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'metasm'
+
+module PWN
+  module Plugins
+    # ELF/PE/Mach-O headers, sections, symbols, imports/exports, relocations
+    # via Metasm loaders.
+    module BinaryParser
+      public_class_method def self.required_bins
+        []
+      end
+
+      public_class_method def self.load_exe(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+        raise "ERROR: file not found: #{path}" unless File.file?(path)
+
+        Metasm::AutoExe.decode_file(path)
+      end
+
+      public_class_method def self.info(opts = {})
+        exe = load_exe(opts)
+        {
+          class: exe.class.name,
+          cpu: exe.cpu.class.name,
+          entrypoint: (exe.optheader.entrypoint if exe.respond_to?(:optheader) && exe.optheader.respond_to?(:entrypoint)),
+          format: format_name(exe: exe)
+        }
+      end
+
+      public_class_method def self.sections(opts = {})
+        exe = load_exe(opts)
+        Array(exe.sections).map do |sec|
+          {
+            name: (sec.name if sec.respond_to?(:name)),
+            size: (sec.size if sec.respond_to?(:size)),
+            virtaddr: (sec.virtaddr if sec.respond_to?(:virtaddr))
+          }
+        end
+      end
+
+      public_class_method def self.symbols(opts = {})
+        exe = load_exe(opts)
+        return [] unless exe.respond_to?(:symbols)
+
+        Array(exe.symbols).first((opts[:limit] || 200).to_i).map do |sym|
+          { name: (sym.name if sym.respond_to?(:name)), value: (sym.value if sym.respond_to?(:value)) }
+        end
+      end
+
+      public_class_method def self.imports(opts = {})
+        exe = load_exe(opts)
+        if exe.respond_to?(:imports)
+          Array(exe.imports).map(&:to_s)
+        else
+          symbols(opts).map { |s| s[:name].to_s }.grep(/plt|imp/i).first(100)
+        end
+      end
+
+      public_class_method def self.exports(opts = {})
+        exe = load_exe(opts)
+        if exe.respond_to?(:export)
+          Array(exe.export&.exports).map { |e| e.respond_to?(:name) ? e.name : e.to_s }
+        else
+          []
+        end
+      rescue StandardError
+        []
+      end
+
+      public_class_method def self.relocations(opts = {})
+        exe = load_exe(opts)
+        return [] unless exe.respond_to?(:relocations)
+
+        Array(exe.relocations).first((opts[:limit] || 100).to_i).map(&:to_s)
+      rescue StandardError
+        []
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:
+          # List host binaries this module expects to be installed.
+          #{self}.required_bins
+
+          # Run load exe and return its result
+          #{self}.load_exe(
+            path: 'required - filesystem path to read or write'
+          )
+
+          # Run info and return its result
+          #{self}.info
+
+          # Run sections and return its result
+          #{self}.sections
+
+          # Run symbols and return its result
+          #{self}.symbols(
+            limit: 'optional - limit value consumed by #symbols'
+          )
+
+          # Run imports and return its result
+          #{self}.imports
+
+          # Run exports and return its result
+          #{self}.exports
+
+          # Run relocations and return its result
+          #{self}.relocations(
+            limit: 'optional - limit value consumed by #relocations'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+
+      private_class_method def self.format_name(opts = {})
+        exe = opts[:exe]
+        return 'elf' if exe.class.name.to_s.include?('ELF')
+        return 'pe' if exe.class.name.to_s.include?('PE')
+        return 'macho' if exe.class.name.to_s.include?('MachO') || exe.class.name.to_s.include?('Mach')
+
+        exe.class.name
+      end
+    end
+  end
+end

data/lib/pwn/plugins/black_duck_binary_analysis.rb

@@ -658,63 +658,72 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          response = #{self}.get_apps(
+          # Run get apps and return its result
+          #{self}.get_apps(
             token: 'required - Bearer token'
           )
 
-          response = PWN::Plugins::BlackDuckBinaryAnalysis.upload_file(
+          # Run get apps by group and return its result
+          #{self}.get_apps_by_group(
+            token: 'required - Bearer token',
+            group_id: 'required - group id value consumed by #get_apps_by_group'
+          )
+
+          # Run upload file and return its result
+          #{self}.upload_file(
             token: 'required - Bearer token',
             file: 'required - path of file to upload',
-            group_id: 'optional - group id',
+            group_id: 'optional - group id value consumed by #upload_file',
             delete_binary: 'optional - delete binary after upload (defaults to false)',
             force_scan: 'optional - force scan (defaults to false)',
-            callback_url: 'optional - callback url',
+            callback_url: 'optional - callback url value consumed by #upload_file',
             scan_infoleak: 'optional - scan infoleak (defaults to true)',
             code_analysis: 'optional - code analysis (defaults to true)',
-            scan_code_familiarity: 'optional - scan code familiarity (defaults to true)',
-            version: 'optional - version',
-            product_id: 'optional - product id'
+            scan_code_familiarity: 'optional - scan code familiarity (defaults to false)',
+            version: 'optional - version value consumed by #upload_file',
+            product_id: 'optional - product id value consumed by #upload_file'
           )
 
-          response = #{self}.get_product(
+          # Run get product and return its result
+          #{self}.get_product(
             token: 'required - Bearer token',
-            product_id: 'required - product id'
+            product_id: 'required - product id value consumed by #get_product'
           )
 
-          response = #{self}.abort_product_scan(
+          # Run abort product scan and return its result
+          #{self}.abort_product_scan(
             token: 'required - Bearer token',
-            product_id: 'required - product id'
+            product_id: 'required - product id value consumed by #abort_product_scan'
           )
 
-          response = #{self}.generate_product_report(
+          # Run generate product report and return its result
+          #{self}.generate_product_report(
             token: 'required - Bearer token',
-            product_id: 'required - product id',
+            product_id: 'required - product id value consumed by #generate_product_report',
             output_path: 'required - path to output file',
             type: 'optional - report type csv_libs||csv_vulns|pdf|spdx (Defaults to csv_vulns)'
           )
 
-          response = #{self}.get_tasks(
+          # Run get tasks and return its result
+          #{self}.get_tasks(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_apps_by_group(
-            token: 'required - Bearer token',
-            group_id: 'required - group id'
-          )
-
-          response = #{self}.get_groups(
+          # Run get groups and return its result
+          #{self}.get_groups(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.create_group(
+          # Run create group and return its result
+          #{self}.create_group(
             token: 'required - Bearer token',
             name: 'required - group name',
             desc: 'optional - group description',
-            parent_id: 'optional - parent_id group id',
+            parent_id: 'optional - parent group id',
             delete_binary: 'optional - delete binary after analysis C|Y|N (Default: C== company default)',
             binary_cleanup_age: 'optional - after how long the binary will be deleted in seconds (Default: 2_592_000 / 30 days)',
             product_cleanup_age: 'optional - after how long the product will be deleted in seconds (Default: 2_592_000 / 30 days)',
-            file_download_enabled: 'optional - allow download of uploaded binaries from group (Default: false),
+            file_download_enabled: 'optional - allow download of uploaded binaries from group (Default: false',
             low_risk_tolerance: 'optional - low risk tolerance nil|true|false (Default: nil == company default)',
             include_historical_vulns: 'optional - include historical vulns nil|true|false (Default: nil == company default)',
             cvss3_fallback: 'optional - cvss3 fallback nil|true|false (Default: nil == company default)',
@@ -725,63 +734,78 @@ module PWN
             scan_code_similarity: 'optional - scan code similarity nil|true|false (Default: nil == company default)'
           )
 
-          response = #{self}.get_group_details(
+          # Run get group details and return its result
+          #{self}.get_group_details(
             token: 'required - Bearer token',
-            group_id: 'required - group id'
+            group_id: 'required - group id value consumed by #get_group_details'
           )
 
-          response = #{self}.get_group_statistics(
+          # Run get group statistics and return its result
+          #{self}.get_group_statistics(
             token: 'required - Bearer token',
-            group_id: 'required - group id'
+            group_id: 'required - group id value consumed by #get_group_statistics'
           )
 
-          response = #{self}.delete_group(
+          # Run delete group and return its result
+          #{self}.delete_group(
             token: 'required - Bearer token',
-            group_id: 'required - group id'
+            group_id: 'required - group id value consumed by #delete_group'
           )
 
-          response = #{self}.get_licenses(
+          # Run get licenses and return its result
+          #{self}.get_licenses(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_component_licenses(
+          # Run get component licenses and return its result
+          #{self}.get_component_licenses(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_tags(
+          # Run get tags and return its result
+          #{self}.get_tags(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_vulnerabilities(
+          # Run get vulnerabilities and return its result
+          #{self}.get_vulnerabilities(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_components(
+          # Run get components and return its result
+          #{self}.get_components(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_vendor_vulns(
+          # Run get vendor vulns and return its result
+          #{self}.get_vendor_vulns(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_audit_trail(
+          # Run get audit trail and return its result
+          #{self}.get_audit_trail(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_status(
+          # Run get status and return its result
+          #{self}.get_status(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_service_info(
+          # Run get service info and return its result
+          #{self}.get_service_info(
             token: 'required - Bearer token'
           )
 
-          response = #{self}.get_service_version(
+          # Run get service version and return its result
+          #{self}.get_service_version(
             token: 'required - Bearer token'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end