pwn 0.5.708 → 0.5.709

data/lib/pwn/plugins/dao_postgres.rb

@@ -190,34 +190,43 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          pg_conn = #{self}.connect(
-            host: 'required host or IP',
-            port: 'optional port (defaults to 5432)',
-            dbname: 'required database name',
-            user: 'required username',
-            password: 'optional (prompts if left blank)',
-            connect_timeout: 'optional (defaults to 60 seconds)',
-            options: 'optional postgres options',
-            tty: 'optional tty',
-            sslmode: :disable|:allow|:prefer|:require
+          # Run connect and return its result
+          #{self}.connect(
+            host: 'required - required host or IP',
+            port: 'optional - optional port (defaults to 5432)',
+            dbname: 'required - required database name',
+            user: 'required - required username',
+            password: 'optional - optional (prompts if left blank)',
+            connect_timeout: 'optional - optional (defaults to 60 seconds)',
+            options: 'optional - optional postgres options',
+            tty: 'optional - optional tty',
+            sslmode: 'required - :disable|:allow|:prefer|:require'
           )
 
-          res = #{self}.sql_statement(
-            pg_conn: pg_conn,
-            prepared_statement: 'SELECT * FROM tn_users WHERE state = $1',
-            statement_params: ['Active']
+          # Run sql statement and return its result
+          #{self}.sql_statement(
+            pg_conn: 'optional - pg conn value consumed by #sql_statement',
+            prepared_statement: 'optional - SELECT * FROM tn_users WHERE state = $1',
+            statement_params: 'required - statement params value consumed by #sql_statement'
           )
 
-          res = #{self}.list_all_columns_by_table(
-            pg_conn: pg_conn,
-            schema: 'required schema name',
-            table_name: 'required table name'
+          # Method Parameters Not Implemented
+          #{self}.list_all_columns_by_table(
+            pg_conn: 'optional - pg conn value consumed by #list_all_columns_by_table',
+            schema: 'required - required schema name',
+            table_name: 'required - required table name',
+            table_schema: 'optional - table schema value consumed by #list_all_columns_by_table'
           )
 
-          #{self}.disconnect(pg_conn: pg_conn)
+          # Run disconnect and return its result
+          #{self}.disconnect(
+            pg_conn: 'optional - pg conn value consumed by #disconnect'
+          )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/dao_sqlite3.rb

@@ -107,18 +107,27 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          sqlite3_conn = #{self}.connect(db_path: 'Required - Path of SQLite3 DB File')
+          # Run connect and return its result
+          #{self}.connect(
+            db_path: 'required - Path of SQLite3 DB File'
+          )
 
-          res = #{self}.sql_statement(
-            sqlite3_conn: sqlite3_conn,
-            prepared_statement: 'SELECT * FROM tn_users WHERE state = ?;',
-            statement_params: ['Active']
+          # Run sql statement and return its result
+          #{self}.sql_statement(
+            sqlite3_conn: 'optional - sqlite3 conn value consumed by #sql_statement',
+            prepared_statement: 'optional - SELECT * FROM tn_users WHERE state = ?;',
+            statement_params: 'required - statement params value consumed by #sql_statement'
           )
 
-          #{self}.disconnect(:sqlite3_conn => sqlite3_conn)
+          # Run disconnect and return its result
+          #{self}.disconnect(
+            sqlite3_conn: 'optional - sqlite3 conn value consumed by #disconnect'
+          )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/defect_dojo.rb

@@ -738,7 +738,8 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          dd_obj = #{self}.login(
+          # Run login and return its result
+          #{self}.login(
             url: 'required - url of DefectDojo Server',
             api_version: 'required - api version to use v1 || v2',
             username: 'required - username to AuthN w/ api v1)',
@@ -746,18 +747,21 @@ module PWN
             proxy: 'optional - proxy all traffic through MITM proxy (defaults to nil)'
           )
 
-          product_list = #{self}.product_list(
-            dd_obj: 'required dd_obj returned from #login_v1 method',
+          # Run product list and return its result
+          #{self}.product_list(
+            dd_obj: 'required - required dd_obj returned from #login method',
             id: 'optional - retrieve single product by id, otherwise return all'
           )
 
-          engagement_list = #{self}.engagement_list(
-            dd_obj: 'required dd_obj returned from #login_v1 method',
+          # Run engagement list and return its result
+          #{self}.engagement_list(
+            dd_obj: 'required - required dd_obj returned from #login method',
             id: 'optional - retrieve single engagement by id, otherwise return all'
           )
 
-          engagement_create_response = #{self}.engagement_create(
-            dd_obj: 'required - dd_obj returned from #login_v1 method',
+          # Run engagement create and return its result
+          #{self}.engagement_create(
+            dd_obj: 'required - dd_obj returned from #login method',
             name: 'required - name of the engagement',
             description: 'optional - description of engagement',
             engagement_type: 'optional - type of engagement Interactive||CI/CD (defaults to CI/CD)',
@@ -774,16 +778,19 @@ module PWN
             check_list: 'optional - boolean to set an engagement as a checkbox assessment (defaults to false)',
             first_contacted: 'optional - date of engagement request e.g. 2018-06-18 (Defaults to current day)',
             target_start: 'optional - date to start enagement e.g. 2018-06-19 (Defaults to current day)',
-            target_end: 'optional - date of engagement completion e.g. 2018-06-20 (Defaults to current day)'
+            target_end: 'optional - date of engagement completion e.g. 2018-06-20 (Defaults to current day)',
+            engagment_type: 'optional - engagment type value consumed by #engagement_create'
           )
 
-          test_list = #{self}.test_list(
-            dd_obj: 'required dd_obj returned from #login_v1 method',
+          # Run test list and return its result
+          #{self}.test_list(
+            dd_obj: 'required - required dd_obj returned from #login method',
             id: 'optional - retrieve single test by id, otherwise return all'
           )
 
-          importscan_response = #{self}.importscan(
-            dd_obj: 'required - dd_obj returned from #login_v1 method',
+          # Run importscan and return its result
+          #{self}.importscan(
+            dd_obj: 'required - dd_obj returned from #login method',
             engagement_name: 'required - name of engagement to associate w/ scan',
             scan_type: 'required - type of scan importing (see <DEFECTDOJO_URL>/admin/dojo/test_type/ for listing)',
             file: 'required - path of scan results file',
@@ -795,11 +802,14 @@ module PWN
             create_finding_groups: 'optional - flag to create finding groups (defaults to false)',
             close_old_findings_product_scope: 'optional - flag to close old findings from engagement (defaults to false)',
             close_old_findings: 'optional - flag to close old findings, regardless of engagement (defaults to false)',
-            push_to_jira: 'optional - flag to push findings to JIRA (defaults to false)'
+            push_to_jira: 'optional - flag to push findings to JIRA (defaults to false)',
+            test_title: 'optional - test title value consumed by #importscan',
+            group_by: 'required - group by value consumed by #importscan'
           )
 
-          reimportscan_response = #{self}.reimportscan(
-            dd_obj: 'required - dd_obj returned from #login_v1 method',
+          # Run reimportscan and return its result
+          #{self}.reimportscan(
+            dd_obj: 'required - dd_obj returned from #login method',
             engagement_name: 'required - name of engagement to associate w/ scan',
             scan_type: 'required - type of scan importing (see <DEFECTDOJO_URL>/admin/dojo/test_type/ for listing)',
             file: 'required - path of scan results file',
@@ -814,27 +824,33 @@ module PWN
             push_to_jira: 'optional - flag to push findings to JIRA (defaults to false)'
           )
 
-          finding_list = #{self}.finding_list(
-            dd_obj: 'required dd_obj returned from #login_v1 method',
+          # Run finding list and return its result
+          #{self}.finding_list(
+            dd_obj: 'required - required dd_obj returned from #login method',
             id: 'optional - retrieve single finding by id, otherwise return all'
           )
 
-          user_list = #{self}.user_list(
-            dd_obj: 'required dd_obj returned from #login_v1 method',
+          # Run user list and return its result
+          #{self}.user_list(
+            dd_obj: 'required - required dd_obj returned from #login method',
             id: 'optional - retrieve single user by id, otherwise return all'
           )
 
-          tool_configuration_list = #{self}.tool_configuration_list(
-            dd_obj: 'required dd_obj returned from #login_v1 method',
+          # Run tool configuration list and return its result
+          #{self}.tool_configuration_list(
+            dd_obj: 'required - required dd_obj returned from #login method',
             id: 'optional - retrieve single test by id, otherwise return all'
           )
 
+          # Run logout and return its result
           #{self}.logout(
-            dd_obj: 'required dd_obj returned from #login_v1 or #login_v2 method'
+            dd_obj: 'required - required dd_obj returned from #login method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/detect_os.rb

@@ -57,14 +57,19 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run type and return its result
           #{self}.type
 
+          # Run arch and return its result
           #{self}.arch
 
+          # Run endian and return its result
           #{self}.endian
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/doctor.rb

@@ -0,0 +1,149 @@
+# 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 Doctor
+      class MissingBinary < StandardError; end
+      class MissingCapability < 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] }
+      }.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.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])
+          missing_bins = bins.reject { |b| bin?(name: b) }
+          missing_caps = []
+          missing_caps << 'CAP_NET_RAW' if caps.include?('CAP_NET_RAW') && !cap_net_raw?
+          status = if missing_bins.empty? && missing_caps.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 }
+        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 = (r[:missing_bins] + r[:missing_caps]).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!
+
+          # 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

data/lib/pwn/plugins/ein.rb

@@ -129,12 +129,15 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run generate and return its result
           #{self}.generate(
             count: 'required - number of EIN numbers to generate'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/exploit_dev.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+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
+        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.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::Doctor.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::Doctor.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 to read or write'
+          )
+
+          # 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
+    end
+  end
+end