pwn 0.5.708 → 0.5.709

data/lib/pwn/plugins/burp_suite.rb

@@ -1704,6 +1704,7 @@ module PWN
             uri: json_uri
           )
 
+          # Run help and return its result
           puts "Skipping #{json_uri} - not in scope. Check out #{self}.help >>  #add_to_scope method" unless uri_in_scope
           next unless uri_in_scope
 
@@ -2066,188 +2067,217 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          burp_obj1 = #{self}.start(
+          # Run start and return its result
+          #{self}.start(
             burp_jar_path: 'optional - path of burp suite pro jar file (defaults to /opt/burpsuite/burpsuite_pro.jar)',
-            headless: 'optional - run headless if set to true',
-            browser_type: 'optional - defaults to :firefox. See PWN::Plugins::TransparentBrowser.help for a list of types'
+            headless: 'optional - run burp headless if set to true (defaults to false)',
+            browser_type: 'optional - defaults to :firefox. See PWN::Plugins::TransparentBrowser.help for a list of types',
+            burp_ip: 'optional - IP address for the Burp proxy (defaults to 127.0.0.1)',
+            burp_port: 'optional - port for the Burp proxy (defaults to a random unused port)',
+            pwn_burp_ip: 'optional - IP address for the PWN Burp API (defaults to 127.0.0.1)',
+            pwn_burp_port: 'optional - port for the PWN Burp API (defaults to a random unused port)'
           )
 
-          uri_in_scope = #{self}.in_scope(
+          # Run in scope and return its result
+          #{self}.in_scope(
             burp_obj: 'required - burp_obj returned by #start method',
             uri: 'required - URI to determine if in scope'
           )
 
-          json_in_scope = #{self}.add_to_scope(
+          # Run add to scope and return its result
+          #{self}.add_to_scope(
             burp_obj: 'required - burp_obj returned by #start method',
             target_url: 'required - target url to add to scope'
           )
 
-          json_spider = #{self}.spider(
+          # Run spider and return its result
+          #{self}.spider(
             burp_obj: 'required - burp_obj returned by #start method',
-            target_url: 'required - target url to spider in scope'
+            target_url: 'required - target url to add to crawl / spider'
           )
 
+          # Run enable proxy and return its result
           #{self}.enable_proxy(
             burp_obj: 'required - burp_obj returned by #start method'
           )
 
+          # Run disable proxy and return its result
           #{self}.disable_proxy(
             burp_obj: 'required - burp_obj returned by #start method'
           )
 
+          # Run get proxy listeners and return its result
           #{self}.get_proxy_listeners(
             burp_obj: 'required - burp_obj returned by #start method'
           )
 
-          json_proxy_listener = #{self}.add_proxy_listener(
+          # Run add proxy listener and return its result
+          #{self}.add_proxy_listener(
             burp_obj: 'required - burp_obj returned by #start method',
-            bindAddress: 'required - bind address for the proxy listener (e.g., \"127.0.0.1\")',
             port: 'required - port for the proxy listener (e.g., 8081)',
-            enabled: 'optional - enable the listener (defaults to true)'
+            enabled: 'optional - enable the listener (defaults to true)',
+            bindAddress: 'required - bindAddress value consumed by #add_proxy_listener'
           )
 
-          json_proxy_listener = #{self}.update_proxy_listener(
+          # Run update proxy listener and return its result
+          #{self}.update_proxy_listener(
             burp_obj: 'required - burp_obj returned by #start method',
             id: 'optional - ID of the proxy listener (defaults to 0)',
-            bindAddress: 'optional - bind address for the proxy listener (defaults to value of existing listener)',
             port: 'optional - port for the proxy listener (defaults to value of existing listener)',
-            enabled: 'optional - enable the listener (defaults to value of existing listener)'
+            enabled: 'optional - enable or disable the listener (defaults to value of existing listener)',
+            bindAddress: 'optional - bindAddress value consumed by #update_proxy_listener'
           )
 
+          # Run delete proxy listener and return its result
           #{self}.delete_proxy_listener(
             burp_obj: 'required - burp_obj returned by #start method',
             id: 'optional - ID of the proxy listener (defaults to 0)'
           )
 
-          json_proxy_history = #{self}.get_proxy_history(
+          # Run get proxy history and return its result
+          #{self}.get_proxy_history(
             burp_obj: 'required - burp_obj returned by #start method',
-            limit: 'optional - integer to limit number of proxy history entries returned (default: 200)',
-            offset: 'optional - integer to offset proxy history results (default: 0)',
-            uri: 'optional - URI to filter proxy history results (default: nil)',
-            highlight: 'optional - highlight color to filter proxy history results (default: \"NONE\")',
-            keyword: 'optional - keyword to filter proxy history results (default: nil)',
+            limit: 'optional - number of proxy history entries to return (default: 200)',
+            offset: 'optional - offset for pagination of proxy history entries (default: 0)',
+            uri: 'optional - filter proxy history entries by URI (default: nil)',
+            highlight: 'optional - highlight color to filter proxy history results (default: NONE)',
+            keyword: 'optional - keyword to filter proxy history entries (default: nil)',
             return_as: 'optional - :base64 or :har (defaults to :base64)'
           )
 
-          json_proxy_history = #{self}.update_proxy_history(
+          # Run update proxy history and return its result
+          #{self}.update_proxy_history(
             burp_obj: 'required - burp_obj returned by #start method',
-            entry: 'required - proxy history entry hash to update'
+            entry: 'required - hash of the proxy history entry to update'
           )
 
-          json_proxy_history = #{self}.get_websocket_history(
+          # Run get websocket history and return its result
+          #{self}.get_websocket_history(
             burp_obj: 'required - burp_obj returned by #start method',
-            limit: 'optional - integer to limit number of websocket history entries returned (default: 200)',
-            offset: 'optional - integer to offset websocket history results (default: 0)',
-            highlight: 'optional - highlight color to filter proxy history results (default: \"NONE\")',
-            keyword: 'optional - keyword to filter websocket history results (default: nil)'
+            limit: 'optional - number of websocket history entries to return (default: 200)',
+            offset: 'optional - offset for pagination of websocket history entries (default: 0)',
+            highlight: 'optional - highlight color to filter websocket history results (default: NONE)',
+            keyword: 'optional - keyword to filter websocket history entries (default: nil)'
           )
 
-          json_proxy_history = #{self}.update_websocket_history(
+          # Run update websocket history and return its result
+          #{self}.update_websocket_history(
             burp_obj: 'required - burp_obj returned by #start method',
-            entry: 'required - websocket history entry hash to update'
+            entry: 'required - hash of the websocket history entry to update'
           )
 
-          json_sitemap = #{self}.get_sitemap(
+          # Run get sitemap and return its result
+          #{self}.get_sitemap(
             burp_obj: 'required - burp_obj returned by #start method',
-            limit: 'optional - integer to limit number of sitemap entries returned (default: 200)',
-            offset: 'optional - integer to offset sitemap results (default: 0)',
-            uri: 'optional - URI to filter sitemap results (default: nil)',
-            highlight: 'optional - highlight color to filter proxy history results (default: \"NONE\")',
-            keyword: 'optional - keyword to filter sitemap results (default: nil)',
+            limit: 'optional - number of sitemap entries to return (default: 200)',
+            offset: 'optional - offset for pagination of sitemap entries (default: 0)',
+            uri: 'optional - URI to filter sitemap entries (default: nil)',
+            highlight: 'optional - highlight color to filter proxy history results (default: NONE)',
+            keyword: 'optional - keyword to filter sitemap entries (default: nil)',
             return_as: 'optional - :base64 or :har (defaults to :base64)'
           )
 
-          json_sitemap = #{self}.add_to_sitemap(
+          # Run add to sitemap and return its result
+          #{self}.add_to_sitemap(
             burp_obj: 'required - burp_obj returned by #start method',
             sitemap: 'required - sitemap hash to add',
-            debug: 'optional - boolean to enable sitemap debugging (default: false)'
+            debug: 'optional - boolean to enable sitemap debugging (default: false)',
+            request: 'optional - base64_encoded_request_string',
+            response: 'optional - base64_encoded_response_string',
+            highlight: 'optional - NONE||RED||ORANGE||YELLOW||GREEN||CYAN||BLUE||PINK||MAGENTA||GRAY',
+            comment: 'optional - optional comment for the sitemap entry',
+            http_service: 'optional - http service value consumed by #add_to_sitemap',
+            host: 'optional - hostname or IP address',
+            port: 'optional - TCP/UDP port number',
+            protocol: 'optional - protocol value consumed by #add_to_sitemap'
           )
 
-          Example:
-          json_sitemap = #{self}.add_to_sitemap(
+          # Run update sitemap and return its result
+          #{self}.update_sitemap(
             burp_obj: 'required - burp_obj returned by #start method',
-            sitemap: {
-              request: 'base64_encoded_request_string',
-              response: 'base64_encoded_response_string',
-              highlight: 'NONE'||'RED'||'ORANGE'||'YELLOW'||'GREEN'||'CYAN'||'BLUE'||'PINK'||'MAGENTA'||'GRAY',
-              comment: 'optional comment for the sitemap entry',
-              http_service: {
-                host: 'example.com',
-                port: 80,
-                protocol: 'http'
-              }
-            }
+            entry: 'required - hash of the sitemap entry to update'
           )
 
-          json_sitemap = #{self}.update_sitemap(
-            burp_obj: 'required - burp_obj returned by #start method',
-            entry: 'required - sitemap entry hash to update'
-          )
-
-          json_sitemap = #{self}.import_openapi_to_sitemap(
+          # Run import openapi to sitemap and return its result
+          #{self}.import_openapi_to_sitemap(
             burp_obj: 'required - burp_obj returned by #start method',
             openapi_spec: 'required - path to OpenAPI JSON or YAML specification file',
             additional_http_headers: 'optional - hash of additional HTTP headers to include in requests (default: {})',
-            debug: 'optional - boolean to enable debug logging (default: false)',
-            highlight: 'optional - highlight color for the sitemap entry (default: \"NONE\")',
-            comment: 'optional - comment for the sitemap entry (default: \"\")',
+            highlight: 'optional - highlight color for the sitemap entry (default: NONE)',
+            comment: 'optional - comment for the sitemap entry (default: )',
+            debug: 'optional - boolean to enable debug logging (default: false)'
           )
 
-          active_scan_url_arr = #{self}.active_scan(
+          # Run active scan and return its result
+          #{self}.active_scan(
             burp_obj: 'required - burp_obj returned by #start method',
             target_url: 'required - target url to scan in sitemap (should be loaded & authenticated w/ burp_obj[:mitm_browser])',
             exclude_paths: 'optional - array of paths to exclude from active scan (default: [])'
           )
 
-          json_scan_issues = #{self}.get_scan_issues(
+          # Run get scan issues and return its result
+          #{self}.get_scan_issues(
             burp_obj: 'required - burp_obj returned by #start method'
-          ).to_json
+          )
 
-          repeater_id = #{self}.add_repeater_tab(
+          # Run add repeater tab and return its result
+          #{self}.add_repeater_tab(
             burp_obj: 'required - burp_obj returned by #start method',
             name: 'required - name of the repeater tab (max 30 characters)',
             request: 'optional - base64 encoded HTTP request string'
           )
 
-          repeater_tabs = #{self}.get_all_repeater_tabs(
+          # Run get all repeater tabs and return its result
+          #{self}.get_all_repeater_tabs(
             burp_obj: 'required - burp_obj returned by #start method'
           )
 
-          repeater_tab = #{self}.get_repeater_tab(
+          # Run get repeater tab and return its result
+          #{self}.get_repeater_tab(
             burp_obj: 'required - burp_obj returned by #start method',
             id: 'required - id of the repeater tab to get'
           )
 
-          repeater_resp = #{self}.send_repeater_request(
+          # Run send repeater request and return its result
+          #{self}.send_repeater_request(
             burp_obj: 'required - burp_obj returned by #start method',
             id: 'required - id of the repeater tab to send'
           )
 
-          repeater_obj = #{self}.update_repeater_tab(
+          # Run update repeater tab and return its result
+          #{self}.update_repeater_tab(
             burp_obj: 'required - burp_obj returned by #start method',
             id: 'required - id of the repeater tab to update',
             name: 'required - name of the repeater tab (max 30 characters)',
             request: 'required - base64 encoded HTTP request string'
           )
 
-          repeater_obj = #{self}.delete_repeater_tab(
+          # Run delete repeater tab and return its result
+          #{self}.delete_repeater_tab(
             burp_obj: 'required - burp_obj returned by #start method',
             id: 'required - id of the repeater tab to delete'
           )
 
+          # Run generate scan report and return its result
           #{self}.generate_scan_report(
             burp_obj: 'required - burp_obj returned by #start method',
             target_url: 'required - target_url passed to #active_scan method',
             output_dir: 'required - directory to save the report',
-            report_type: 'required - <:html|:xml>'
+            report_type: 'required - report type value consumed by #generate_scan_report'
           )
 
+          # Run update burp jar and return its result
+          #{self}.update_burp_jar
+
+          # Run stop and return its result
           #{self}.stop(
             burp_obj: 'required - burp_obj returned by #start method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/bus_pirate.rb

@@ -118,29 +118,36 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run connect via screen and return its result
           #{self}.connect_via_screen(
-            block_dev: 'optional serial block device path (defaults to /dev/ttyUSB0)'
+            block_dev: 'optional - serial block device path (defaults to /dev/ttyUSB0)'
           )
 
-          bus_pirate_obj = #{self}.connect(
-            block_dev: 'optional serial block device path (defaults to /dev/ttyUSB0)',
-            baud: 'optional (defaults to 9600)',
-            data_bits: 'optional (defaults to 8)',
-            stop_bits: 'optional (defaults to 1)',
-            parity: 'optional - :even||:odd|:none (defaults to :none)'
+          # Run connect and return its result
+          #{self}.connect(
+            block_dev: 'optional - optional serial block device path (defaults to /dev/ttyUSB0)',
+            baud: 'optional - optional (defaults to 9600)',
+            data_bits: 'optional - optional (defaults to 8)',
+            stop_bits: 'optional - optional (defaults to 1)',
+            parity: 'optional - optional (defaults to SerialPort::NONE)',
+            flow_control: 'optional - optional (defaults to SerialPort::HARD) SerialPort::NONE|SerialPort::SOFT|SerialPort::HARD'
           )
 
+          # Run init mode and return its result
           #{self}.init_mode(
-            bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method'
+            bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method',
             mode: 'required - bus pirate mode to invoke'
           )
 
+          # Run disconnect and return its result
           #{self}.disconnect(
             bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/char.rb

@@ -412,63 +412,93 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          char_arr = #{self}.generate_by_range(
+          # Run force utf8 and return its result
+          #{self}.force_utf8(
+            obj: 'required - object to force to UTF-8'
+          )
+
+          # Run generate by range and return its result
+          #{self}.generate_by_range(
             from: 'required - integer to start from',
-            to: 'required - integer to end char generation'
+            to: 'required - integer to end UTF-8 generation'
           )
 
+          # Run c0 controls latin basic and return its result
           #{self}.c0_controls_latin_basic
 
+          # Run c1 controls latin supplement and return its result
           #{self}.c1_controls_latin_supplement
 
+          # Run latin extended a and return its result
           #{self}.latin_extended_a
 
+          # Run latin extended b and return its result
           #{self}.latin_extended_b
 
+          # Run spacing modifiers and return its result
           #{self}.spacing_modifiers
 
+          # Run diacritical marks and return its result
           #{self}.diacritical_marks
 
+          # Run greek coptic and return its result
           #{self}.greek_coptic
 
+          # Run cyrillic basic and return its result
           #{self}.cyrillic_basic
 
+          # Run cyrillic supplement and return its result
           #{self}.cyrillic_supplement
 
+          # Run punctuation and return its result
           #{self}.punctuation
 
+          # Run currency symbols and return its result
           #{self}.currency_symbols
 
+          # Run letterlike symbols and return its result
           #{self}.letterlike_symbols
 
+          # Run arrows and return its result
           #{self}.arrows
 
+          # Run math operators and return its result
           #{self}.math_operators
 
+          # Run box drawings and return its result
           #{self}.box_drawings
 
+          # Run block elements and return its result
           #{self}.block_elements
 
+          # Run geometric shapes and return its result
           #{self}.geometric_shapes
 
+          # Run misc symbols and return its result
           #{self}.misc_symbols
 
+          # Run dingbats and return its result
           #{self}.dingbats
 
+          # Run bubble ip and return its result
           #{self}.bubble_ip(
             ip: 'required - ip address to transform'
           )
 
-          encoder_arr = #{self}.list_encoders
+          # Run list encoders and return its result
+          #{self}.list_encoders
 
+          # Run generate encoded files and return its result
           #{self}.generate_encoded_files(
             from: 'required - integer to start from',
             to: 'required - integer to end UTF-8 generation',
             output_dir: 'required - folder to create files'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/credential_attack.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+
+module PWN
+  module Plugins
+    # hydra/john/hashcat wrappers and ~/.pwn/wordlists convention.
+    module CredentialAttack
+      WORDLISTS = File.join(Dir.home, '.pwn', 'wordlists')
+
+      public_class_method def self.required_bins
+        []
+      end
+
+      public_class_method def self.wordlist_dir(opts = {})
+        FileUtils.mkdir_p(WORDLISTS) if opts[:ensure] != false
+        WORDLISTS
+      end
+
+      public_class_method def self.hydra(opts = {})
+        PWN::Plugins::Doctor.require_bin!(name: 'hydra')
+        target = opts[:target].to_s
+        service = (opts[:service] || 'ssh').to_s
+        user = opts[:user] || opts[:login]
+        wordlist = opts[:wordlist] || File.join(WORDLISTS, 'rockyou.txt')
+        extra = Array(opts[:extra])
+        cmd = ['hydra', '-l', user.to_s, '-P', wordlist, '-t', (opts[:tasks] || 4).to_s]
+        cmd += extra
+        cmd += [target, service]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.john(opts = {})
+        PWN::Plugins::Doctor.require_bin!(name: 'john')
+        hashfile = opts[:hashfile] || opts[:file]
+        raise 'ERROR: hashfile is required' if hashfile.to_s.empty?
+
+        stdout, stderr, status = Open3.capture3('john', hashfile.to_s)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.hashcat(opts = {})
+        PWN::Plugins::Doctor.require_bin!(name: 'hashcat')
+        hashfile = opts[:hashfile] || opts[:file]
+        mode = (opts[:mode] || 0).to_i
+        wordlist = opts[:wordlist] || File.join(WORDLISTS, 'rockyou.txt')
+        stdout, stderr, status = Open3.capture3('hashcat', '-m', mode.to_s, hashfile.to_s, wordlist)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      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 wordlist dir and return its result
+          #{self}.wordlist_dir(
+            ensure: 'optional - ensure value consumed by #wordlist_dir'
+          )
+
+          # Run hydra and return its result
+          #{self}.hydra(
+            target: 'optional - hostname, IP, or CIDR to scan',
+            service: 'optional - service value consumed by #hydra',
+            user: 'optional - user value consumed by #hydra (defaults to opts[:login])',
+            login: 'optional - login value consumed by #hydra',
+            wordlist: 'optional - wordlist value consumed by #hydra',
+            extra: 'optional - Array extra value consumed by #hydra',
+            tasks: 'optional - tasks value consumed by #hydra'
+          )
+
+          # Run john and return its result
+          #{self}.john(
+            hashfile: 'required - hashfile value consumed by #john (defaults to opts[:file])',
+            file: 'required - filesystem path'
+          )
+
+          # Run hashcat and return its result
+          #{self}.hashcat(
+            hashfile: 'optional - hashfile value consumed by #hashcat (defaults to opts[:file])',
+            file: 'optional - filesystem path',
+            mode: 'optional - mode value consumed by #hashcat',
+            wordlist: 'optional - wordlist value consumed by #hashcat'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end

data/lib/pwn/plugins/credit_card.rb

@@ -86,19 +86,24 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run list types and return its result
           #{self}.list_types
 
+          # Run generate and return its result
           #{self}.generate(
-            type: 'required - card to generate from #list_types method to generate',
+            type: 'optional - card type from #list_types method to generate (defaults to :random)',
             count: 'optional - number of numbers to generate (defaults to 1)'
           )
 
+          # Run type and return its result
           #{self}.type(
             cc: 'required - e.g. XXXX XXXX XXXX XXXX'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/dao_ldap.rb

@@ -105,26 +105,32 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          ldap_obj = #{self}.connect(
-            host: 'required host or IP',
-            port: 'required port',
-            base: 'required ldap base to search from (e.g. dc=domain,dc=com)',
-            encryption: 'optional parameter to protect communication in transit, :simple_tls OR :start_tls',
-            auth_method: 'required ldap auth bind method, :simple, :sasl, OR :gss_spnego'
-            username: 'required username',
-            password: 'optional (prompts if left blank)',
+          # Run connect and return its result
+          #{self}.connect(
+            host: 'required - required host or IP',
+            port: 'optional - optional port (defaults to 636)',
+            base: 'required - required ldap base to search from (e.g. dc=domain,dc=com)',
+            encryption: 'optional - optional parameter to protect communication in transit, :simple_tls OR :start_tls',
+            auth_method: 'required - required ldap auth bind method, :simple, :sasl, OR :gss_spnego',
+            username: 'required - required username (e.g. support@0dayinc.com)',
+            password: 'optional - optional (prompts if left blank)'
           )
 
-          employee = #{self}.get_employee_by_username(
-            ldap_obj: 'required ldap_obj returned from #connect method',
-            username: 'required username of employee to retrieve from LDAP server'
+          # Run get employee by username and return its result
+          #{self}.get_employee_by_username(
+            ldap_obj: 'required - required ldap_obj returned from #connect method',
+            username: 'required - required username of employee to retrieve from LDAP server'
           )
-          puts employee[0][:dn]
 
-          #{self}.disconnect(:ldap_obj => ldap_obj)
+          # Run disconnect and return its result
+          #{self}.disconnect(
+            ldap_obj: 'optional - ldap obj value consumed by #disconnect'
+          )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/dao_mongo.rb

@@ -80,16 +80,22 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          mongo_conn = #{self}.connect(
-            host: 'optional host or IP defaults to 127.0.0.1',
-            port: 'optional port defaults to 27017',
-            database: 'optional database name'
+          # Run connect and return its result
+          #{self}.connect(
+            host: 'optional - optional host or IP defaults to 127.0.0.1',
+            port: 'optional - optional port defaults to 27017',
+            database: 'optional - optional database name'
           )
 
-          #{self}.disconnect(mongo_conn: mongo_conn)
+          # Run disconnect and return its result
+          #{self}.disconnect(
+            mongo_conn: 'optional - mongo conn value consumed by #disconnect'
+          )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end