pwn 0.5.708 → 0.5.710

data/lib/pwn/plugins/exploit_dev.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module PWN
+  module Plugins
+    # p8/p16/p32/p64, cyclic, flat, fmt writes, gadget search.
+    module ExploitDev
+      CYCLIC_ALPHA = (('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a).freeze
+
+      public_class_method def self.required_bins
+        []
+      end
+
+      public_class_method def self.p8(opts = {})
+        pack_int(value: opts[:value] || opts[:n], bytes: 1, endian: opts[:endian])
+      end
+
+      public_class_method def self.p16(opts = {})
+        pack_int(value: opts[:value] || opts[:n], bytes: 2, endian: opts[:endian])
+      end
+
+      public_class_method def self.p32(opts = {})
+        pack_int(value: opts[:value] || opts[:n], bytes: 4, endian: opts[:endian])
+      end
+
+      public_class_method def self.p64(opts = {})
+        pack_int(value: opts[:value] || opts[:n], bytes: 8, endian: opts[:endian])
+      end
+
+      public_class_method def self.u8(opts = {})
+        unpack_int(buf: opts[:buf] || opts[:data], bytes: 1, endian: opts[:endian])
+      end
+
+      public_class_method def self.u16(opts = {})
+        unpack_int(buf: opts[:buf] || opts[:data], bytes: 2, endian: opts[:endian])
+      end
+
+      public_class_method def self.u32(opts = {})
+        unpack_int(buf: opts[:buf] || opts[:data], bytes: 4, endian: opts[:endian])
+      end
+
+      public_class_method def self.u64(opts = {})
+        unpack_int(buf: opts[:buf] || opts[:data], bytes: 8, endian: opts[:endian])
+      end
+
+      public_class_method def self.cyclic(opts = {})
+        n = (opts[:length] || 100).to_i
+        width = (opts[:width] || opts[:n] || 4).to_i
+        width = 4 if width < 2
+        out = +''
+        i = 0
+        while out.length < n
+          chunk = []
+          v = i
+          width.times do
+            chunk.unshift(CYCLIC_ALPHA[v % CYCLIC_ALPHA.length])
+            v /= CYCLIC_ALPHA.length
+          end
+          out << chunk.join
+          i += 1
+        end
+        out[0, n]
+      end
+
+      public_class_method def self.cyclic_find(opts = {})
+        needle = opts[:value] || opts[:subseq]
+        hay = cyclic(length: (opts[:length] || 8_192).to_i, n: (opts[:n] || 4).to_i)
+        blob = needle.is_a?(Integer) ? p32(value: needle, endian: opts[:endian]) : needle.to_s
+        hay.index(blob)
+      end
+
+      public_class_method def self.flat(opts = {})
+        parts = Array(opts[:parts] || opts[:values] || opts[:arr])
+        endian = opts[:endian]
+        parts.map do |p|
+          case p
+          when Integer then p32(value: p, endian: endian)
+          when Array then p32(value: p[0], endian: endian) * p[1].to_i
+          else p.to_s
+          end
+        end.join
+      end
+
+      public_class_method def self.shellcode(opts = {})
+        arch = (opts[:arch] || 'x86_64').to_s
+        kind = (opts[:kind] || opts[:payload] || 'nop').to_s
+        return execve_bin_sh_bytes(arch: arch) if kind == 'execve_bin_sh'
+
+        asm = case kind
+              when 'nop' then 'nop'
+              when 'ret' then 'ret'
+              else opts[:asm].to_s
+              end
+        raise 'ERROR: asm is required for custom shellcode' if asm.empty?
+
+        PWN::Plugins::Assembly.asm_to_opcodes(asm: asm, arch: arch, endian: opts[:endian])
+      end
+
+      public_class_method def self.one_gadget(opts = {})
+        path = (opts[:path] || opts[:libc]).to_s
+        raise 'ERROR: path is required' if path.empty?
+
+        return { error: 'one_gadget missing', hint: 'pwn setup --profile re', path: path } unless PWN::Plugins::PreflightChecker.bin?(name: 'one_gadget')
+
+        stdout, stderr, status = Open3.capture3('one_gadget', path)
+        {
+          path: path,
+          stdout: stdout,
+          stderr: stderr,
+          exit: status.exitstatus,
+          gadgets: stdout.scan(/0x[0-9a-fA-F]+/)
+        }
+      end
+
+      public_class_method def self.libc_offsets(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+
+        wanted = Array(opts[:names] || %w[system execve __libc_start_main])
+        syms = PWN::Plugins::BinaryParser.symbols(path: path, limit: 20_000)
+        map = {}
+        Array(syms).each do |s|
+          n = s[:name].to_s
+          next if n.empty?
+
+          wanted.each do |w|
+            map[w.to_s] = s[:value] if n == w.to_s || n.end_with?(w.to_s)
+          end
+        end
+        { path: path, symbols: map }
+      end
+
+      public_class_method def self.fmt_writes(opts = {})
+        addr = (opts[:addr] || 0).to_i
+        value = (opts[:value] || 0).to_i
+        offset = (opts[:offset] || 6).to_i
+        {
+          payload: "#{p32(value: addr)}%#{value}x%#{offset}$n",
+          addr: addr,
+          value: value,
+          offset: offset
+        }
+      end
+
+      public_class_method def self.gadgets(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+
+        if PWN::Plugins::PreflightChecker.bin?(name: 'r2')
+          sid = PWN::Plugins::Radare2.open(path: path)
+          begin
+            PWN::Plugins::Radare2.cmd(session: sid, cmd: '/R')
+          ensure
+            PWN::Plugins::Radare2.close(session: sid)
+          end
+        elsif PWN::Plugins::PreflightChecker.bin?(name: 'ROPgadget')
+          `ROPgadget --binary #{path}`.to_s
+        else
+          { error: 'r2 and ROPgadget missing', hint: 'pwn setup --profile re' }
+        end
+      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 p8 and return its result
+          #{self}.p8(
+            value: 'optional - integer or string to pack/encode',
+            n: 'optional - count, width, or size',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run p16 and return its result
+          #{self}.p16(
+            value: 'optional - integer or string to pack/encode',
+            n: 'optional - count, width, or size',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run p32 and return its result
+          #{self}.p32(
+            value: 'optional - integer or string to pack/encode',
+            n: 'optional - count, width, or size',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run p64 and return its result
+          #{self}.p64(
+            value: 'optional - integer or string to pack/encode',
+            n: 'optional - count, width, or size',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run u8 and return its result
+          #{self}.u8(
+            buf: 'optional - buf value consumed by #u8',
+            data: 'optional - data value consumed by #u8',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run u16 and return its result
+          #{self}.u16(
+            buf: 'optional - buf value consumed by #u16',
+            data: 'optional - data value consumed by #u16',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run u32 and return its result
+          #{self}.u32(
+            buf: 'optional - buf value consumed by #u32',
+            data: 'optional - data value consumed by #u32',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run u64 and return its result
+          #{self}.u64(
+            buf: 'optional - buf value consumed by #u64',
+            data: 'optional - data value consumed by #u64',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run cyclic and return its result
+          #{self}.cyclic(
+            length: 'optional - number of bytes or characters to generate',
+            width: 'optional - cyclic de Bruijn sequence width in bytes',
+            n: 'optional - count, width, or size'
+          )
+
+          # Run cyclic find and return its result
+          #{self}.cyclic_find(
+            value: 'optional - integer or string to pack/encode (defaults to opts[:subseq])',
+            subseq: 'optional - subseq value consumed by #cyclic_find',
+            length: 'optional - number of bytes or characters to generate',
+            n: 'optional - count, width, or size',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run flat and return its result
+          #{self}.flat(
+            parts: 'optional - parts value consumed by #flat',
+            values: 'optional - values value consumed by #flat',
+            arr: 'optional - arr value consumed by #flat',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run shellcode and return its result
+          #{self}.shellcode(
+            arch: 'optional - architecture string (as from objdump --info)',
+            kind: 'optional - kind value consumed by #shellcode',
+            payload: 'optional - payload value consumed by #shellcode',
+            asm: 'required - assembly source (one instruction per line)',
+            endian: 'optional - :little or :big byte order'
+          )
+
+          # Run fmt writes and return its result
+          #{self}.fmt_writes(
+            addr: 'optional - address or flag (e.g. main or 0x401000)',
+            value: 'optional - integer or string to pack/encode',
+            offset: 'optional - offset value consumed by #fmt_writes'
+          )
+
+          # Run gadgets and return its result
+          #{self}.gadgets(
+            path: 'required - filesystem path of the binary to search for gadgets'
+          )
+
+          # Resolve one_gadget offsets in a libc (needs the one_gadget gem/bin).
+          #{self}.one_gadget(
+            path: 'required - filesystem path to libc.so',
+            libc: 'optional - alias for path'
+          )
+
+          # Map named libc symbols to virtual addresses via BinaryParser.
+          #{self}.libc_offsets(
+            path: 'required - filesystem path to libc or any ELF',
+            names: 'optional - Array of symbol names (defaults to system, execve, __libc_start_main)'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+
+      private_class_method def self.pack_int(opts = {})
+        v = opts[:value].to_i
+        bytes = opts[:bytes].to_i
+        little = opts[:endian].to_s != 'big'
+        template = {
+          1 => 'C',
+          2 => little ? 'v' : 'n',
+          4 => little ? 'V' : 'N',
+          8 => little ? 'Q<' : 'Q>'
+        }[bytes]
+        [v].pack(template)
+      end
+
+      private_class_method def self.unpack_int(opts = {})
+        buf = opts[:buf].to_s
+        bytes = opts[:bytes].to_i
+        little = opts[:endian].to_s != 'big'
+        template = { 1 => 'C', 2 => little ? 'v' : 'n', 4 => little ? 'V' : 'N', 8 => little ? 'Q<' : 'Q>' }[bytes]
+        buf.unpack1(template)
+      end
+
+      private_class_method def self.execve_bin_sh_bytes(opts = {})
+        arch = opts[:arch].to_s
+        if arch.match?(/64|amd64/i)
+          return [
+            0x48, 0x31, 0xd2, 0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e,
+            0x2f, 0x73, 0x68, 0x00, 0x53, 0x48, 0x89, 0xe7, 0x50,
+            0x57, 0x48, 0x89, 0xe6, 0xb0, 0x3b, 0x0f, 0x05
+          ].pack('C*')
+        end
+
+        [
+          0x31, 0xc0, 0x50, 0x68, 0x2f, 0x2f, 0x73, 0x68, 0x68, 0x2f, 0x62, 0x69, 0x6e,
+          0x89, 0xe3, 0x50, 0x53, 0x89, 0xe1, 0xb0, 0x0b, 0xcd, 0x80
+        ].pack('C*')
+      end
+    end
+  end
+end

data/lib/pwn/plugins/file_fu.rb

@@ -116,27 +116,30 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run recurse in dir and return its result
           #{self}.recurse_in_dir(
-            dir_path: 'optional path to dir defaults to .',
-            include_extensions: 'optional - array of file extensions to search for in scan (e.g. ['.js', '.php'])',
-            exclude_extensions: 'optional - array of file extensions to exclude from scan (e.g. ['.log', '.txt', '.spec'])'
-          ) do |entry|
-            puts entry
-          end
+            dir_path: 'optional - optional path to dir defaults to .',
+            include_extensions: 'optional - array of file extensions to search for in scan (e.g. [.js, .php])',
+            exclude_extensions: 'optional - array of file extensions to exclude from scan (e.g. [.log, .txt, .spec])'
+          )
 
+          # Run untar gz file and return its result
           #{self}.untar_gz_file(
             tar_gz_file: 'required - path to .tar.gz file',
             destination: 'required - destination folder to save extracted contents'
           )
 
+          # Run shift file up and return its result
           #{self}.shift_file_up(
             path: 'required - path to file to shift up',
-            bytes: 'required - number of bytes to shift up',
-            buffer_size: 'optional - buffer size to use when shifting file up (default: 256 * 1024 / i.e 256KB)'
+            bytes: 'required - number of bytes to shift up (remove from beginning)',
+            buffer_size: 'optional - buffer size to use when shifting (default: 256KB)'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/frida.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module PWN
+  module Plugins
+    # Frida attach/spawn + script injection.
+    module Frida
+      SSL_PINNING = <<~JS
+        Java.perform(function () {
+          try {
+            var TrustManager = Java.use('javax.net.ssl.X509TrustManager');
+            var SSLContext = Java.use('javax.net.ssl.SSLContext');
+            var TrustManagers = [Java.registerClass({
+              name: 'pwn.TrustAll',
+              implements: [TrustManager],
+              methods: {
+                checkClientTrusted: function () {},
+                checkServerTrusted: function () {},
+                getAcceptedIssuers: function () { return []; }
+              }
+            }).$new()];
+            var ctx = SSLContext.getInstance('TLS');
+            ctx.init(null, TrustManagers, null);
+            SSLContext.getDefault.implementation = function () { return ctx; };
+          } catch (e) {}
+        });
+      JS
+
+      public_class_method def self.required_bins
+        %w[frida]
+      end
+
+      public_class_method def self.ps(opts = {})
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'frida')
+        stdout, stderr, status = Open3.capture3('frida-ps', *Array(opts[:extra]))
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.attach(opts = {})
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'frida')
+        target = opts[:target] || opts[:name]
+        script = opts[:script].to_s
+        raise 'ERROR: target is required' if target.to_s.empty?
+
+        cmd = ['frida', '-n', target.to_s]
+        cmd += ['-l', opts[:script_path].to_s] if opts[:script_path]
+        cmd += ['-e', script] unless script.empty?
+        stdout, stderr, status = Open3.capture3(*cmd)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.spawn(opts = {})
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'frida')
+        path = (opts[:path] || opts[:file]).to_s
+        raise 'ERROR: path is required' if path.empty?
+
+        cmd = ['frida', '-f', path]
+        cmd += ['-l', opts[:script_path].to_s] if opts[:script_path]
+        cmd += ['-e', opts[:script].to_s] unless opts[:script].to_s.empty?
+        stdout, stderr, status = Open3.capture3(*cmd)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.ssl_pinning_script(opts = {})
+        opts[:android]
+        SSL_PINNING
+      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
+
+          # List processes via frida-ps.
+          #{self}.ps(
+            extra: 'optional - extra frida-ps argv'
+          )
+
+          # Attach to a running process and optionally inject a script.
+          #{self}.attach(
+            target: 'required - process name (defaults to opts[:name])',
+            name: 'optional - alias for target',
+            script: 'optional - JavaScript source to pass with -e',
+            script_path: 'optional - path to a .js file for -l'
+          )
+
+          # Spawn a binary under Frida and inject a script.
+          #{self}.spawn(
+            path: 'required - filesystem path to the binary',
+            file: 'optional - alias for path',
+            script: 'optional - JavaScript source to pass with -e',
+            script_path: 'optional - path to a .js file for -l'
+          )
+
+          # Return an SSL-pinning bypass JavaScript template.
+          #{self}.ssl_pinning_script(
+            android: 'optional - currently always returns the Java TrustManager template'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end

data/lib/pwn/plugins/fuzz.rb

@@ -171,6 +171,25 @@ module PWN
         sock_obj = PWN::Plugins::Sock.disconnect(sock_obj: sock_obj) unless sock_obj.nil?
       end
 
+      public_class_method def self.http(opts = {})
+        template = opts[:request].to_s
+        raise 'ERROR: request is required' if template.empty?
+
+        token = (opts[:token] || 'FUZZ').to_s
+        Array(opts[:dictionary] || opts[:payloads] || ['A']).map do |p|
+          template.gsub(token, p.to_s)
+        end
+      end
+
+      public_class_method def self.file_format(opts = {})
+        path = opts[:path].to_s
+        raise 'ERROR: path is required' if path.empty?
+
+        seed = File.binread(path)
+        dict = Array(opts[:dictionary] || ["\xff"])
+        dict.map { |blob| seed + blob.to_s }
+      end
+
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -183,13 +202,14 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          socket_fuzz_results_arr = #{self}.socket(
-            target: 'required = target host or ip',
-            port: 'required => target port',
-            protocol: 'optional => :tcp || :udp (defaults to tcp)',
+          # Run socket and return its result
+          #{self}.socket(
+            target: 'required - target host or ip',
+            port: 'required - target port',
+            protocol: 'optional - :tcp || :udp (defaults to tcp)',
             tls: 'optional - boolean connect to target socket using TLS (defaults to false)',
-            fuzz_delimeter: \"optional - fuzz delimeter used in request to specify where payloads should reside (defaults to \u2665)\",
-            request: \"required - String object of socket request w/ \u2665 as fuzz delimeter (e.g. '\"GET /\u2665\u2665 HTTP/1.1\\r\\nHost: \u2665127.0.0.1\u2665\\r\\n\\r\\n\"')\",
+            fuzz_delimeter: 'optional - fuzz delimeter used in request to specify where payloads should reside (defaults to \\u2665)',
+            request: 'required - String object of socket request w/ \\u001A as fuzz delimeter (e.g. GET /\\u001A\\u001A HTTP/1.1\\r\\nHost: \\u001A127..0.0.1\\u001A\\r\\n\\r\\n)',
             payload: 'required - payload string',
             response_timeout: 'optional - float (defaults to 0.9)',
             request_rate_limit: 'optional - float (defaults to 0.3)',
@@ -198,8 +218,24 @@ module PWN
             char_encoding: 'optional - character encoding returned by PWN::Plugins::Char.list_encoders (defaults to UTF-8)'
           )
 
+          # Expand an HTTP request template by substituting FUZZ with dictionary payloads.
+          #{self}.http(
+            request: 'required - HTTP request template containing FUZZ (or token:)',
+            dictionary: 'optional - Array of payload strings',
+            payloads: 'optional - alias for dictionary',
+            token: 'optional - placeholder to replace (defaults to FUZZ)'
+          )
+
+          # Append dictionary blobs to a seed file for coverage-guided or dumb file fuzzing.
+          #{self}.file_format(
+            path: 'required - filesystem path to the seed file',
+            dictionary: 'optional - Array of binary/string mutations'
+          )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/gdb.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module PWN
+  module Plugins
+    # gdb/MI batch driver: run-to-crash, registers, mitigations, core dumps.
+    module GDB
+      public_class_method def self.required_bins
+        %w[gdb]
+      end
+
+      public_class_method def self.batch(opts = {})
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'gdb')
+        binary = opts[:binary].to_s
+        cmds = Array(opts[:commands] || opts[:cmds])
+        args = Array(opts[:args])
+        mi = ['gdb', '--batch', '--quiet']
+        mi += ['-ex', 'set pagination off']
+        cmds.each { |c| mi += ['-ex', c.to_s] }
+        mi << '--args' if !binary.empty? || args.any?
+        mi << binary unless binary.empty?
+        mi.concat(args.map(&:to_s))
+        stdout, stderr, status = Open3.capture3(*mi)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.run_to_crash(opts = {})
+        cmds = ['run', 'bt', 'info registers']
+        batch(opts.merge(commands: cmds))
+      end
+
+      public_class_method def self.registers(opts = {})
+        batch(opts.merge(commands: ['info registers']))
+      end
+
+      public_class_method def self.mitigations(opts = {})
+        batch(opts.merge(commands: ['checksec']))
+      rescue StandardError
+        path = opts[:binary].to_s
+        return { error: 'gdb missing' } unless PWN::Plugins::PreflightChecker.bin?(name: 'gdb')
+
+        { hint: 'pwndbg/gef checksec not loaded', binary: path }
+      end
+
+      public_class_method def self.core(opts = {})
+        core = opts[:core].to_s
+        binary = opts[:binary].to_s
+        raise 'ERROR: core is required' if core.empty?
+
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'gdb')
+        binary = opts[:binary].to_s
+        argv = ['gdb', '--batch', '--quiet', '-c', core, '-ex', 'set pagination off', '-ex', 'bt', '-ex', 'info registers']
+        argv << binary unless binary.empty?
+        stdout, stderr, status = Open3.capture3(*argv)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.breakpoints(opts = {})
+        bps = Array(opts[:breakpoints] || opts[:bp])
+        cmds = bps.map { |b| "break #{b}" } + Array(opts[:commands]) + %w[run bt]
+        batch(opts.merge(commands: cmds))
+      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 batch and return its result
+          #{self}.batch(
+            binary: 'required - binary value consumed by #batch',
+            commands: 'optional - commands value consumed by #batch',
+            cmds: 'optional - cmds value consumed by #batch',
+            args: 'required - Array args value consumed by #batch'
+          )
+
+          # Run run to crash and return its result
+          #{self}.run_to_crash
+
+          # Run registers and return its result
+          #{self}.registers
+
+          # Run mitigations and return its result
+          #{self}.mitigations(
+            binary: 'optional - binary value consumed by #mitigations'
+          )
+
+          # Run core and return its result
+          #{self}.core(
+            core: 'required - filesystem path to the core dump',
+            binary: 'optional - matching binary for symbols'
+          )
+
+          # Plant breakpoints then run and dump a backtrace.
+          #{self}.breakpoints(
+            binary: 'optional - binary to debug',
+            breakpoints: 'optional - Array of break specs (e.g. main or *0x401000)',
+            bp: 'optional - alias for breakpoints',
+            commands: 'optional - extra gdb commands after the breaks',
+            args: 'optional - Array of inferior argv'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end