pwn 0.5.708 → 0.5.710

data/lib/pwn/plugins/packet.rb

@@ -1085,6 +1085,7 @@ module PWN
       # )
 
       public_class_method def self.send(opts = {})
+        PWN::Plugins::PreflightChecker.require_cap_net_raw! if defined?(PWN::Plugins::PreflightChecker)
         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/preflight_checker.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module PWN
+  module Plugins
+    # Plugin/binary/capability preflight. Plugins declare required_bins /
+    # required_caps; HOST summaries list degraded modules without autoloading
+    # the whole plugin tree.
+    module PreflightChecker
+      class MissingBinary < StandardError; end
+      class MissingCapability < StandardError; end
+      class MissingService < StandardError; end
+
+      PLUGIN_DEPS = {
+        'PWN::Plugins::Radare2' => { bins: %w[r2] },
+        'PWN::Plugins::GDB' => { bins: %w[gdb] },
+        'PWN::Plugins::Nuclei' => { bins: %w[nuclei] },
+        'PWN::Plugins::Sqlmap' => { bins: %w[sqlmap] },
+        'PWN::Plugins::Frida' => { bins: %w[frida] },
+        'PWN::Plugins::AFLplusplus' => { bins: %w[afl-fuzz] },
+        'PWN::Plugins::Volatility' => { bins: %w[vol] },
+        'PWN::Plugins::NmapIt' => { bins: %w[nmap] },
+        'PWN::Plugins::Metasploit' => { bins: %w[msfconsole] },
+        'PWN::Plugins::BurpSuite' => { bins: %w[burpsuite] },
+        'PWN::Plugins::Zaproxy' => { bins: %w[zaproxy] },
+        'PWN::Plugins::Packet' => { bins: [], caps: %w[CAP_NET_RAW] },
+        'PWN::Plugins::K8s' => { bins: %w[trivy], services: [{ name: 'docker', path: '/var/run/docker.sock' }] }
+      }.freeze
+
+      public_class_method def self.required_bins
+        []
+      end
+
+      public_class_method def self.bin?(opts = {})
+        name = opts[:name].to_s
+        return false if name.empty?
+
+        ENV['PATH'].to_s.split(File::PATH_SEPARATOR).any? do |dir|
+          File.executable?(File.join(dir, name))
+        end
+      end
+
+      public_class_method def self.require_bin!(opts = {})
+        name = opts[:name].to_s
+        return true if bin?(name: name)
+
+        raise MissingBinary, "ERROR: required binary missing: #{name}. Install via pwn setup --profile re (or the plugin profile)."
+      end
+
+      public_class_method def self.cap_net_raw?(opts = {})
+        return true unless File.readable?('/proc/self/status')
+
+        line = File.readlines('/proc/self/status').find { |l| l.start_with?('CapEff:') }
+        return false unless line
+
+        hex = line.split.last.to_s
+        hex.to_i(16).anybits?(1 << 13)
+      rescue StandardError
+        opts[:default] == true
+      end
+
+      public_class_method def self.require_cap_net_raw!(opts = {})
+        return true if cap_net_raw?(opts)
+
+        raise MissingCapability,
+              'ERROR: CAP_NET_RAW is missing. Packet.send cannot inject L2 frames. ' \
+              'Hint: sudo setcap cap_net_raw,cap_net_admin+ep "$(readlink -f "$(command -v ruby)")" ' \
+              'or run as root. Fallback: PWN::Plugins::Sock.connect (no raw).'
+      end
+
+      public_class_method def self.service?(opts = {})
+        path = opts[:path].to_s
+        return File.socket?(path) unless path.empty?
+
+        false
+      end
+
+      public_class_method def self.check(opts = {})
+        deps = PLUGIN_DEPS
+        if opts[:names]
+          want = Array(opts[:names]).map(&:to_s)
+          deps = deps.slice(*want)
+        end
+        deps.map do |plugin, dep|
+          bins = Array(dep[:bins])
+          caps = Array(dep[:caps])
+          services = Array(dep[:services])
+          missing_bins = bins.reject { |b| bin?(name: b) }
+          missing_caps = []
+          missing_caps << 'CAP_NET_RAW' if caps.include?('CAP_NET_RAW') && !cap_net_raw?
+          missing_services = services.reject { |s| service?(name: s[:name] || s['name'], path: s[:path] || s['path']) }.map { |s| s[:name] || s['name'] }
+          status = if missing_bins.empty? && missing_caps.empty? && missing_services.empty?
+                     :ok
+                   elsif bins.any? && missing_bins.length == bins.length
+                     :dead
+                   else
+                     :degraded
+                   end
+          { plugin: plugin, status: status, missing_bins: missing_bins, missing_caps: missing_caps, missing_services: missing_services }
+        end
+      end
+
+      public_class_method def self.host_summary(opts = {})
+        rows = check(names: opts[:names])
+        cap = (opts[:limit] || 12).to_i
+        dead = rows.select { |r| r[:status] == :dead }
+        degraded = rows.select { |r| r[:status] == :degraded }
+        lines = ["HOST plugins ok=#{rows.count { |r| r[:status] == :ok }} degraded=#{degraded.length} dead=#{dead.length}"]
+        (degraded + dead).first(cap).each do |r|
+          miss = (Array(r[:missing_bins]) + Array(r[:missing_caps]) + Array(r[:missing_services])).join(',')
+          lines << "  #{r[:status]} #{r[:plugin]} missing=#{miss}"
+        end
+        lines.join("\n")
+      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 bin and return its result
+          #{self}.bin?(
+            name: 'required - binary or identifier name'
+          )
+
+          # Run require bin and return its result
+          #{self}.require_bin!(
+            name: 'required - binary or identifier name'
+          )
+
+          # Run cap net raw and return its result
+          #{self}.cap_net_raw?(
+            default: 'optional - default value consumed by #cap_net_raw?'
+          )
+
+          # Run require cap net raw and return its result
+          #{self}.require_cap_net_raw!
+
+          # True when a unix socket/service path exists.
+          #{self}.service?(
+            name: 'optional - service name for the report row',
+            path: 'required - unix socket path (e.g. /var/run/docker.sock)'
+          )
+
+          # Run check and return its result
+          #{self}.check(
+            names: 'optional - Array names value consumed by #check'
+          )
+
+          # Run host summary and return its result
+          #{self}.host_summary(
+            names: 'optional - names value consumed by #host_summary',
+            limit: 'optional - limit value consumed by #host_summary'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end