pwn 0.5.708 → 0.5.709

data/lib/pwn/plugins/packet.rb

@@ -1085,6 +1085,7 @@ module PWN
       # )
 
       public_class_method def self.send(opts = {})
+        PWN::Plugins::Doctor.require_cap_net_raw! if defined?(PWN::Plugins::Doctor)
         pkt = opts[:pkt]
 
         if opts[:iface]
@@ -1205,108 +1206,228 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          pcap = #{self}.open_pcap_file(
+          # Run open pcap file and return its result
+          #{self}.open_pcap_file(
             path: 'required - path to packet capture file'
           )
-          pcap[0].public_methods
-          pcap.each do |p|
-            print \"IP ID: \#{p.ip_id_readable} \"
-            print \"IP Sum: \#{p.ip_sum_readable} \"
-            print \"SRC IP: \#{p.ip_src_readable} \"
-            print \"SRC MAC: (\#{p.eth_src_readable}) \"
-            print \"TCP SRC PORT: \#{p.tcp_sport} => \"
-            print \"DST IP: \#{p.ip_dst_readable} \"
-            print \"DST MAC: (\#{p.eth_dst_readable}) \"
-            print \"TCP DST PORT: \#{p.tcp_dport} \"
-            print \"ETH PROTO: \#{p.eth_proto_readable} \"
-            print \"TCP FLAGS: \#{p.tcp_flags_readable} \"
-            print \"TCP ACK: \#{p.tcp_ack_readable} \"
-            print \"TCP SEQ: \#{p.tcp_seq_readable} \"
-            print \"TCP SUM: \#{p.tcp_sum_readable} \"
-            print \"TCP OPTS: \#{p.tcp_opts_readable} \"
-            puts \"BODY: \#{p.hexify(p.payload)}\"
-            puts \"\\n\\n\\n\"
-          end
 
-          pkt = #{self}.construct_arp(
+          # Run construct arp and return its result
+          #{self}.construct_arp(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_arp',
+            eth_dst: 'optional - eth dst value consumed by #construct_arp',
+            eth_proto: 'optional - eth proto value consumed by #construct_arp',
+            arp_hw: 'optional - arp hw value consumed by #construct_arp',
+            arp_proto: 'optional - arp proto value consumed by #construct_arp',
+            arp_hw_len: 'optional - arp hw len value consumed by #construct_arp',
+            arp_proto_len: 'optional - arp proto len value consumed by #construct_arp',
+            arp_opcode: 'optional - arp opcode value consumed by #construct_arp',
+            arp_src_mac: 'optional - arp src mac value consumed by #construct_arp',
+            arp_dst_mac: 'optional - arp dst mac value consumed by #construct_arp'
           )
 
-          pkt = #{self}.construct_eth(
+          # Run construct eth and return its result
+          #{self}.construct_eth(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_eth',
+            eth_dst: 'optional - eth dst value consumed by #construct_eth',
+            eth_proto: 'optional - eth proto value consumed by #construct_eth'
           )
 
-          pkt = #{self}.construct_hsrp(
+          # Run construct hsrp and return its result
+          #{self}.construct_hsrp(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_hsrp',
+            eth_dst: 'optional - eth dst value consumed by #construct_hsrp',
+            eth_proto: 'optional - eth proto value consumed by #construct_hsrp',
+            ip_v: 'optional - ip v value consumed by #construct_hsrp',
+            ip_hl: 'optional - ip hl value consumed by #construct_hsrp',
+            ip_tos: 'optional - ip tos value consumed by #construct_hsrp',
+            ip_len: 'optional - ip len value consumed by #construct_hsrp',
+            ip_frag: 'optional - ip frag value consumed by #construct_hsrp',
+            ip_ttl: 'optional - ip ttl value consumed by #construct_hsrp',
+            ip_proto: 'optional - ip proto value consumed by #construct_hsrp',
+            ip_sum: 'optional - ip sum value consumed by #construct_hsrp',
+            udp_src_port: 'optional - udp src port value consumed by #construct_hsrp',
+            udp_dst_port: 'optional - udp dst port value consumed by #construct_hsrp',
+            udp_len: 'optional - udp len value consumed by #construct_hsrp',
+            udp_sum: 'optional - udp sum value consumed by #construct_hsrp',
+            hsrp_version: 'optional - hsrp version value consumed by #construct_hsrp',
+            hsrp_opcode: 'optional - hsrp opcode value consumed by #construct_hsrp',
+            hsrp_state: 'optional - hsrp state value consumed by #construct_hsrp',
+            hsrp_hellotime: 'optional - hsrp hellotime value consumed by #construct_hsrp',
+            hsrp_holdtime: 'optional - hsrp holdtime value consumed by #construct_hsrp',
+            hsrp_priority: 'optional - hsrp priority value consumed by #construct_hsrp',
+            hsrp_group: 'optional - hsrp group value consumed by #construct_hsrp',
+            hsrp_reserved: 'optional - hsrp reserved value consumed by #construct_hsrp',
+            hsrp_password: 'optional - hsrp password value consumed by #construct_hsrp',
+            hsrp_addr: 'optional - hsrp addr value consumed by #construct_hsrp'
           )
 
-          pkt = #{self}.construct_icmp(
+          # Run construct icmp and return its result
+          #{self}.construct_icmp(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
-            payload: 'optional - packet payload defaults to \"*ping*\"',
+            payload: 'optional - packet payload defaults to *ping*',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_icmp',
+            eth_dst: 'optional - eth dst value consumed by #construct_icmp',
+            eth_proto: 'optional - eth proto value consumed by #construct_icmp',
+            ip_v: 'optional - ip v value consumed by #construct_icmp',
+            ip_hl: 'optional - ip hl value consumed by #construct_icmp',
+            ip_tos: 'optional - ip tos value consumed by #construct_icmp',
+            ip_len: 'optional - ip len value consumed by #construct_icmp',
+            ip_frag: 'optional - ip frag value consumed by #construct_icmp',
+            ip_ttl: 'optional - ip ttl value consumed by #construct_icmp',
+            ip_proto: 'optional - ip proto value consumed by #construct_icmp',
+            ip_sum: 'optional - ip sum value consumed by #construct_icmp',
+            icmp_type: 'optional - icmp type value consumed by #construct_icmp',
+            icmp_code: 'optional - icmp code value consumed by #construct_icmp',
+            icmp_sum: 'optional - icmp sum value consumed by #construct_icmp'
           )
 
-          pkt = #{self}.construct_icmpv6(
+          # Run construct icmpv6 and return its result
+          #{self}.construct_icmpv6(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_icmpv6',
+            eth_dst: 'optional - eth dst value consumed by #construct_icmpv6',
+            eth_proto: 'optional - eth proto value consumed by #construct_icmpv6',
+            ipv6_v: 'optional - ipv6 v value consumed by #construct_icmpv6',
+            ipv6_class: 'optional - ipv6 class value consumed by #construct_icmpv6',
+            ipv6_label: 'optional - ipv6 label value consumed by #construct_icmpv6',
+            ipv6_len: 'optional - ipv6 len value consumed by #construct_icmpv6',
+            ipv6_next: 'optional - ipv6 next value consumed by #construct_icmpv6',
+            ipv6_hop: 'optional - ipv6 hop value consumed by #construct_icmpv6',
+            ipv6_saddr: 'optional - ipv6 saddr value consumed by #construct_icmpv6',
+            ipv6_daddr: 'optional - ipv6 daddr value consumed by #construct_icmpv6',
+            icmpv6_type: 'optional - icmpv6 type value consumed by #construct_icmpv6',
+            icmpv6_code: 'optional - icmpv6 code value consumed by #construct_icmpv6',
+            icmpv6_sum: 'optional - icmpv6 sum value consumed by #construct_icmpv6'
           )
 
-          pkt = #{self}.construct_ip(
+          # Run construct ip and return its result
+          #{self}.construct_ip(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_ip',
+            eth_dst: 'optional - eth dst value consumed by #construct_ip',
+            eth_proto: 'optional - eth proto value consumed by #construct_ip',
+            ip_v: 'optional - ip v value consumed by #construct_ip',
+            ip_hl: 'optional - ip hl value consumed by #construct_ip',
+            ip_tos: 'optional - ip tos value consumed by #construct_ip',
+            ip_len: 'optional - ip len value consumed by #construct_ip',
+            ip_frag: 'optional - ip frag value consumed by #construct_ip',
+            ip_ttl: 'optional - ip ttl value consumed by #construct_ip',
+            ip_proto: 'optional - ip proto value consumed by #construct_ip',
+            ip_sum: 'optional - ip sum value consumed by #construct_ip'
           )
 
-          pkt = #{self}.construct_ipv6(
+          # Run construct ipv6 and return its result
+          #{self}.construct_ipv6(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_ipv6',
+            eth_dst: 'optional - eth dst value consumed by #construct_ipv6',
+            eth_proto: 'optional - eth proto value consumed by #construct_ipv6',
+            ipv6_v: 'optional - ipv6 v value consumed by #construct_ipv6',
+            ipv6_class: 'optional - ipv6 class value consumed by #construct_ipv6',
+            ipv6_label: 'optional - ipv6 label value consumed by #construct_ipv6',
+            ipv6_len: 'optional - ipv6 len value consumed by #construct_ipv6',
+            ipv6_next: 'optional - ipv6 next value consumed by #construct_ipv6',
+            ipv6_hop: 'optional - ipv6 hop value consumed by #construct_ipv6',
+            ipv6_saddr: 'optional - ipv6 saddr value consumed by #construct_ipv6',
+            ipv6_daddr: 'optional - ipv6 daddr value consumed by #construct_ipv6'
           )
 
-          pkt = #{self}.construct_tcp(
+          # Run construct tcp and return its result
+          #{self}.construct_tcp(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_tcp',
+            eth_dst: 'optional - eth dst value consumed by #construct_tcp',
+            eth_proto: 'optional - eth proto value consumed by #construct_tcp',
+            ip_v: 'optional - ip v value consumed by #construct_tcp',
+            ip_hl: 'optional - ip hl value consumed by #construct_tcp',
+            ip_tos: 'optional - ip tos value consumed by #construct_tcp',
+            ip_len: 'optional - ip len value consumed by #construct_tcp',
+            ip_frag: 'optional - ip frag value consumed by #construct_tcp',
+            ip_ttl: 'optional - ip ttl value consumed by #construct_tcp',
+            ip_proto: 'optional - ip proto value consumed by #construct_tcp',
+            ip_sum: 'optional - ip sum value consumed by #construct_tcp',
+            tcp_src_port: 'optional - tcp src port value consumed by #construct_tcp',
+            tcp_dst_port: 'optional - tcp dst port value consumed by #construct_tcp',
+            tcp_seq: 'optional - tcp seq value consumed by #construct_tcp',
+            tcp_ack: 'optional - tcp ack value consumed by #construct_tcp',
+            tcp_hlen: 'optional - tcp hlen value consumed by #construct_tcp',
+            tcp_reserved: 'optional - tcp reserved value consumed by #construct_tcp',
+            tcp_ecn: 'optional - tcp ecn value consumed by #construct_tcp',
+            tcp_flags: 'optional - tcp flags value consumed by #construct_tcp',
+            tcp_win: 'optional - tcp win value consumed by #construct_tcp',
+            tcp_sum: 'optional - tcp sum value consumed by #construct_tcp',
+            tcp_urg: 'optional - tcp urg value consumed by #construct_tcp',
+            tcp_opts: 'optional - tcp opts value consumed by #construct_tcp'
           )
 
-          pkt = #{self}.construct_udp(
+          # Run construct udp and return its result
+          #{self}.construct_udp(
             ip_saddr: 'required - source ip of packet',
             ip_daddr: 'required - destination ip to send packet',
             payload: 'optional - packet payload defaults to empty string',
             ip_id: 'optional - defaults to 0xfeed',
             iface: 'optional - interface to send packet (defaults to eth0)',
+            eth_src: 'optional - eth src value consumed by #construct_udp',
+            eth_dst: 'optional - eth dst value consumed by #construct_udp',
+            eth_proto: 'optional - eth proto value consumed by #construct_udp',
+            ip_v: 'optional - ip v value consumed by #construct_udp',
+            ip_hl: 'optional - ip hl value consumed by #construct_udp',
+            ip_tos: 'optional - ip tos value consumed by #construct_udp',
+            ip_len: 'optional - ip len value consumed by #construct_udp',
+            ip_frag: 'optional - ip frag value consumed by #construct_udp',
+            ip_ttl: 'optional - ip ttl value consumed by #construct_udp',
+            ip_proto: 'optional - ip proto value consumed by #construct_udp',
+            ip_sum: 'optional - ip sum value consumed by #construct_udp',
+            udp_src_port: 'optional - udp src port value consumed by #construct_udp',
+            udp_dst_port: 'optional - udp dst port value consumed by #construct_udp',
+            udp_len: 'optional - udp len value consumed by #construct_udp',
+            udp_sum: 'optional - udp sum value consumed by #construct_udp'
           )
 
+          # Run send and return its result
           #{self}.send(
             pkt: 'required - pkt returned from other #construct_<type> methods',
-            iface: 'optional - interface to send packet (defaults to eth0)',
+            iface: 'optional - interface to send packet (defaults to eth0)'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/pdf_parse.rb

@@ -41,12 +41,15 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          pdf_pages_hash = #{self}.read_text(
-            pdf_path: 'required path to pdf file'
+          # Run read text and return its result
+          #{self}.read_text(
+            pdf_path: 'optional - optional path to dir defaults to .'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/pony.rb

@@ -276,9 +276,94 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          This module is deprecated.  Please Use PWN::Plugins::MailAgent instead.
+          # Default options can be set so that they dont have to be repeated
+          #{self}.options
+
+          # Method usage N/A
+          #{self}.options
+
+          # Method usage N/A
+          #{self}.override_options
+
+          # Method usage N/A
+          #{self}.override_options
+
+          # Method usage N/A
+          #{self}.subject_prefix(
+            value: 'optional - integer or string to pack/encode'
+          )
+
+          # Method usage N/A
+          #{self}.append_inputs
+
+          # Send an email
+          #{self}.mail(
+            body: 'optional - body value consumed by #mail',
+            subject: 'optional - subject value consumed by #mail',
+            to: 'required - to value consumed by #mail',
+            via: 'optional - via value consumed by #mail',
+            via_options: 'optional - via options value consumed by #mail'
+          )
+
+          # Method usage N/A
+          #{self}.permissable_options
+
+          # Method usage N/A
+          #{self}.default_delivery_method
+
+          # Method usage N/A
+          #{self}.standard_options
+
+          # Method usage N/A
+          #{self}.non_standard_options
+
+          # Method usage N/A
+          #{self}.build_mail(
+            date: 'optional - date value consumed by #build_mail',
+            from: 'optional - sender account or address to bind as operator',
+            via_options: 'optional - via options value consumed by #build_mail',
+            attachments: 'optional - attachments value consumed by #build_mail',
+            html_body: 'optional - html body value consumed by #build_mail (defaults to opts[:attachments])',
+            body: 'optional - body value consumed by #build_mail',
+            via: 'optional - via value consumed by #build_mail',
+            headers: 'optional - headers value consumed by #build_mail',
+            charset: 'optional - charset value consumed by #build_mail',
+            text_part_charset: 'optional - text part charset value consumed by #build_mail',
+            content_type: 'optional - content type value consumed by #build_mail'
+          )
+
+          # Method usage N/A
+          #{self}.build_html_part(
+            html_body: 'optional - html body value consumed by #build_html_part',
+            html_body_part_header: 'optional - html body part header value consumed by #build_html_part'
+          )
+
+          # Method usage N/A
+          #{self}.build_text_part(
+            charset: 'optional - charset value consumed by #build_text_part',
+            body: 'optional - body value consumed by #build_text_part',
+            body_part_header: 'optional - body part header value consumed by #build_text_part'
+          )
+
+          # Method usage N/A
+          #{self}.set_content_type(
+            mail: 'optional - mail value consumed by #set_content_type',
+            user_content_type: 'optional - user content type value consumed by #set_content_type'
+          )
+
+          # Method usage N/A
+          #{self}.add_attachments(
+            mail: 'optional - mail value consumed by #add_attachments',
+            attachments: 'optional - attachments value consumed by #add_attachments'
+          )
+
+          # Method usage N/A
+          #{self}.sendmail_binary
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/process_tube.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'timeout'
+
+module PWN
+  module Plugins
+    # PTY.spawn tube: sendline/recvuntil/recvline, persisted across pwn_eval.
+    module ProcessTube
+      @tubes = {}
+
+      public_class_method def self.required_bins
+        []
+      end
+
+      public_class_method def self.spawn(opts = {})
+        cmd = opts[:cmd] || opts[:command]
+        raise 'ERROR: cmd is required' if cmd.to_s.empty?
+
+        argv = cmd.is_a?(Array) ? cmd.map(&:to_s) : ['bash', '-lc', cmd.to_s]
+        r, w, pid = PTY.spawn(*argv)
+        id = "tube_#{pid}"
+        @tubes[id] = { r: r, w: w, pid: pid, buf: +'' }
+        { id: id, pid: pid }
+      end
+
+      public_class_method def self.write_line(opts = {})
+        t = tube!(opts)
+        line = opts[:line] || opts[:data] || ''
+        t[:w].write("#{line}\n")
+        t[:w].flush
+        line.to_s
+      end
+
+      public_class_method def self.recvuntil(opts = {})
+        t = tube!(opts)
+        needle = opts[:until].to_s
+        raise 'ERROR: until is required' if needle.empty?
+
+        timeout = (opts[:timeout] || 5).to_f
+        Timeout.timeout(timeout) do
+          loop do
+            return t[:buf] if t[:buf].include?(needle)
+
+            ch = t[:r].read_nonblock(4_096)
+            t[:buf] << ch
+          rescue IO::WaitReadable
+            t[:r].wait_readable(0.2)
+            retry
+          end
+        end
+      end
+
+      public_class_method def self.recvline(opts = {})
+        recvuntil(opts.merge(until: "\n"))
+      end
+
+      public_class_method def self.close(opts = {})
+        t = tube!(opts)
+        t[:w].close
+        t[:r].close
+        Process.kill('TERM', t[:pid])
+        @tubes.delete(opts[:id].to_s)
+        true
+      rescue StandardError
+        @tubes.delete(opts[:id].to_s)
+        false
+      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 spawn and return its result
+          #{self}.spawn(
+            cmd: 'required - command string to run (defaults to opts[:command])',
+            command: 'optional - command value consumed by #spawn'
+          )
+
+          # Run write line and return its result
+          #{self}.write_line(
+            line: 'optional - line value consumed by #write_line',
+            data: 'optional - data value consumed by #write_line'
+          )
+
+          # Run recvuntil and return its result
+          #{self}.recvuntil(
+            until: 'required - until value consumed by #recvuntil',
+            timeout: 'optional - seconds to wait before giving up'
+          )
+
+          # Run recvline and return its result
+          #{self}.recvline
+
+          # Close a session previously returned by #open.
+          #{self}.close(
+            id: 'optional - id value consumed by #close'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+
+      private_class_method def self.tube!(opts = {})
+        id = opts[:id].to_s
+        t = @tubes[id]
+        raise 'ERROR: id is required / unknown tube' unless t
+
+        t
+      end
+    end
+  end
+end

data/lib/pwn/plugins/ps.rb

@@ -76,14 +76,20 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          proc_list_arr = #{self}.list
+          # Run list and return its result
+          #{self}.list(
+            pid: 'optional - pid value consumed by #list'
+          )
 
+          # Run cleanup pids and return its result
           #{self}.cleanup_pids(
             pids_arr: 'required - array of pids to kill'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/pwn_logger.rb

@@ -53,11 +53,15 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          logger = #{self}.create(
-            level: 'optional - logging verbosity :debug|:error|:fatal|:info|:unknown|:warn (Defaults to :info)'
+          # Run create and return its result
+          #{self}.create(
+            level: 'optional - level value consumed by #create'
           )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/rabbit_mq.rb

@@ -50,20 +50,25 @@ module PWN
       # Display Usage for this Module
 
       public_class_method def self.help
-        puts %{USAGE:
-          amqp_conn1 = #{self}.open(
-            hostname: 'required',
+        puts "USAGE:
+          # Open a session or connection and return a handle.
+          #{self}.open(
+            hostname: 'required - hostname value consumed by #open',
             port: 'optional - defaults to 5672',
-            username: 'optional',
-            password: 'optional'
+            username: 'optional - username value consumed by #open',
+            password: 'optional - password value consumed by #open'
           )
 
+          # Close a session previously returned by #open.
           #{self}.close(
-            amqp_oject: amqp_conn1
+            amqp_oject: 'optional - amqp oject value consumed by #close',
+            amqp_obj: 'optional - amqp obj value consumed by #close'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
-        }
+        "
+        constants.sort
       end
     end
   end