ronin 2.0.5 → 2.1.0.rc1

data/lib/ronin/cli/commands/pack.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2023 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/cli/command'
+require 'ronin/cli/binary_template'
+
+module Ronin
+  class CLI
+    module Commands
+      #
+      # Packs values into binary data.
+      #
+      # ## Usage
+      #
+      #     ronin pack [options] TYPE:VALUE [...]
+      #
+      # ## Options
+      #
+      #     -E, --endian little|big|net      Sets the endianness
+      #     -A x86|x86_64|ppc|ppc64|mips|mips_le|mips_be|mips64|mips64_le|mips64_be|arm|arm_le|arm_be|arm64|arm64_le|arm64_be,
+      #         --arch                       Sets the architecture
+      #     -O linux|macos|windows|android|apple_ios|bsd|freebsd|openbsd|netbsd,
+      #         --os                         Sets the OS
+      #     -x, --hexdump                    Hexdumps the packed data, instead of writing it out
+      #         --output PATH                Optional output file to write to
+      #     -h, --help                       Print help information
+      #
+      # ## Arguments
+      #
+      #     TYPE:VALUE                      A value and it's type.
+      #
+      # ### Types
+      #
+      #     Native             Little-endian       Big-endian          Network-endian
+      #     ------             -------------       ----------          --------------
+      #
+      #     char
+      #     uchar
+      #     byte
+      #     string
+      #     int                int_le              int_be              int_net
+      #     int8
+      #     int16              int16_le            int16_be            int16_net
+      #     int32              int32_le            int32_be            int32_net
+      #     int64              int64_le            int64_be            int64_net
+      #     short              short_le            short_be            short_net
+      #     long               long_le             long_be             long_net
+      #     long_long          long_long_le        long_long_be        long_long_net
+      #     uint               uint_le             uint_be             uint_net
+      #     uint8
+      #     uint1616           uint16_le           uint16_be           uint16_net
+      #     uint3232           uint32_le           uint32_be           uint32_net
+      #     uint6464           uint64_le           uint64_be           uint64_net
+      #     ushort             ushort_le           ushort_be           ushort_net
+      #     ulong              ulong_le            ulong_be            ulong_net
+      #     ulong_long         ulong_long_le       ulong_long_be       ulong_long_net
+      #     float              float_le            float_be            float_net
+      #     float32            float32_le          float32_be          float32_net
+      #     float64            float64_le          float64_be          float64_net
+      #     double             double_le           double_be           double_net
+      #     pointer            pointer_le          pointer_be          pointer_net
+      #
+      # ## Examples
+      #
+      #     ronin pack int32:-1 uint32:0x12345678 char:A string:hello
+      #     ronin pack int32[4]:1,2,3,4 string[3]:hello,world
+      #     ronin pack uint32_le:0x12345678
+      #     ronin pack uint32_be:0x12345678
+      #     ronin pack --endian big int:4096 uint:0x12345678
+      #     ronin pack --arch arm_le int:4096 long:0x12345678
+      #     ronin pack --arch x86_64 --os windows uint:0x12345678
+      #
+      # @since 2.1.0
+      #
+      class Pack < Command
+
+        include BinaryTemplate
+
+        option :hexdump, short: '-x',
+                         desc:  'Hexdumps the packed data, instead of writing it out' do
+                           require 'hexdump'
+                         end
+
+        option :output, value: {
+                          type: String,
+                          usage: 'PATH'
+                        },
+                        desc: 'Optional output file to write to'
+
+        argument :element, required: true,
+                           repeats:  true,
+                           usage:    'TYPE:VALUE',
+                           desc:     "A value and it's C type"
+
+        examples [
+          'int32:-1 uint32:0x12345678 char:A string:hello',
+          'int32[4]:1,2,3,4 string[3]:hello,world',
+          'uint32_le:0x12345678',
+          'uint32_be:0x12345678',
+          '--endian big int:4096 uint:0x12345678',
+          '--arch arm_le int:4096 long:0x12345678',
+          '--arch x86_64 --os windows uint:0x12345678'
+        ]
+
+        description "Packs values into binary data"
+
+        man_page 'ronin-pack.1'
+
+        #
+        # Runs the `ronin pack` command.
+        #
+        # @param [Array<String>] args
+        #   The `TYPE:VALUE` strings to parse and pack.
+        #
+        def run(*args)
+          # perform an initial parsing of the arguments to extract types/values
+          types, values = parse_types_and_values(args)
+
+          # build the template using the parsed `TYPE`s
+          template = build_template(types)
+
+          # parse the values, but using the resolved C types.
+          values = parse_values(template.types,values)
+
+          # finally pack the parsed values using the binary template
+          data = template.pack(*values)
+
+          if options[:hexdump]
+            data.hexdump
+          else
+            write_output(data)
+          end
+        end
+
+        #
+        # Prints the help information for the arguments and lists `TYPE`s.
+        #
+        def help_arguments
+          super
+
+          puts
+          puts <<HELP
+Types:
+
+    Native             Little-endian       Big-endian          Network-endian
+    ------             -------------       ----------          --------------
+
+    char
+    uchar
+    byte
+    string
+    int                int_le              int_be              int_net
+    int8
+    int16              int16_le            int16_be            int16_net
+    int32              int32_le            int32_be            int32_net
+    int64              int64_le            int64_be            int64_net
+    short              short_le            short_be            short_net
+    long               long_le             long_be             long_net
+    long_long          long_long_le        long_long_be        long_long_net
+    uint               uint_le             uint_be             uint_net
+    uint8
+    uint1616           uint16_le           uint16_be           uint16_net
+    uint3232           uint32_le           uint32_be           uint32_net
+    uint6464           uint64_le           uint64_be           uint64_net
+    ushort             ushort_le           ushort_be           ushort_net
+    ulong              ulong_le            ulong_be            ulong_net
+    ulong_long         ulong_long_le       ulong_long_be       ulong_long_net
+    float              float_le            float_be            float_net
+    float32            float32_le          float32_be          float32_net
+    float64            float64_le          float64_be          float64_net
+    double             double_le           double_be           double_net
+    pointer            pointer_le          pointer_be          pointer_net
+HELP
+        end
+
+        #
+        # Performs an initial parsing of the `TYPE:VALUE` arguments into two
+        # separate lists of `TYPE`s and `VALUE`s.
+        #
+        # @param [Array<String>] args
+        #   The `TYPE:VALUE` argumens to parse.
+        #
+        # @return [(Array<Symbol, (Symbol, Integer)>, Array<String>)]
+        #   The parsed types and values.
+        #
+        def parse_types_and_values(args)
+          types  = []
+          values = []
+
+          args.each do |string|
+            type, value = string.split(':',2)
+
+            types  << parse_type(type)
+            values << value
+          end
+
+          return types, values
+        end
+
+        #
+        # Performs a second parsing of the values based on their desired
+        # C types.
+        #
+        # @param [Array<Ronin::Support::Binary::CTypes::Type>] types
+        #   The desired types of the values.
+        #
+        # @param [Array<String, Array<String>>] values
+        #   The values to further parse.
+        #
+        def parse_values(types,values)
+          # now parse the values based on their resolved CType types
+          values.map.with_index do |value,index|
+            parse_value(types[index],value)
+          end
+        end
+
+        #
+        # Parses the value based on it's C type.
+        #
+        # @param [Ronin::Support::Binary::CType::Type] ctype
+        #   The C type of the value.
+        #
+        # @param [String] string
+        #   The raw unparsed string.
+        #
+        # @return [Array<Integer>, Array<Float>, Array<String>, Integer, Float, String]
+        #   The parsed value.
+        #
+        def parse_value(ctype,string)
+          case ctype
+          when Support::Binary::CTypes::ArrayType,
+               Support::Binary::CTypes::ArrayObjectType,
+               Support::Binary::CTypes::UnboundedArrayType
+            parse_array_value(ctype,string)
+          when Support::Binary::CTypes::IntType,
+               Support::Binary::CTypes::UIntType
+            parse_int(string)
+          when Support::Binary::CTypes::FloatType
+            parse_float(string)
+          when Support::Binary::CTypes::CharType,
+               Support::Binary::CTypes::StringType
+            string
+          else
+            raise(NotImplementedError,"unable to parse value for CType #{ctype.class}")
+          end
+        end
+
+        #
+        # Parses an array.
+        #
+        # @param [Ronin::Support::Binary::CTypes::Type] ctype
+        #   The C type that represents the array type.
+        #
+        # @param [String] string
+        #   The raw string to parse.
+        #
+        # @return [Array<Integer>, Array<Float>, Array<String>]
+        #   The parsed array.
+        #
+        def parse_array_value(ctype,string)
+          # create array of the desired size
+          array = if ctype.length.finite?
+                    Array.new(ctype.length,ctype.type.uninitialized_value)
+                  else
+                    []
+                  end
+
+          string.split(/(?!\\),/).each_with_index do |element,index|
+            array[index] = parse_value(ctype.type,element)
+          end
+
+          return array
+        end
+
+        #
+        # Parses an integer value.
+        #
+        # @param [String] string
+        #   The raw string to parse.
+        #
+        # @return [Integer]
+        #   The parsed Integer.
+        #
+        def parse_int(string)
+          Integer(string)
+        rescue ArgumentError
+          print_error "cannot parse integer: #{string}"
+          exit(-1)
+        end
+
+        #
+        # Parses an float value.
+        #
+        # @param [String] string
+        #   The raw string to parse.
+        #
+        # @return [Float]
+        #   The parsed Float.
+        #
+        def parse_float(string)
+          Float(string)
+        rescue ArgumentError
+          print_error "cannot parse float: #{string}"
+          exit(-1)
+        end
+
+        #
+        # Writes the packed data to the `--output` file or stdout.
+        #
+        # @param [String] data
+        #   The packed data to output.
+        #
+        def write_output(data)
+          if options[:output]
+            File.binwrite(options[:output],data)
+          else
+            stdout.write(data)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/cli/commands/public_suffix_list.rb

@@ -46,6 +46,8 @@ module Ronin
         include CommandKit::Options::Verbose
         include Core::CLI::Logging
 
+        command_name 'public-suffix-list'
+
         option :update, short: '-u',
                         desc: 'Updates the public suffix list file'
 

data/lib/ronin/cli/commands/tld_list.rb

@@ -46,6 +46,8 @@ module Ronin
         include CommandKit::Options::Verbose
         include Core::CLI::Logging
 
+        command_name 'tld-list'
+
         option :update, short: '-u',
                         desc: 'Updates the TLD list file'
 

data/lib/ronin/cli/commands/unarchive.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2024 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/cli/file_processor_command'
+require 'ronin/support/archive'
+
+module Ronin
+  class CLI
+    module Commands
+      #
+      # Unarchive the file(s).
+      #
+      # ## Usage
+      #
+      #     ronin unarchive [options] FILE ...
+      #
+      ## Options
+      #
+      #     -f, --format tar|zip             Explicit archive format
+      #
+      # ## Arguments
+      #
+      #     FILE ...                         File(s) to unarchive
+      #
+      # @since 2.1.0
+      #
+      class Unarchive < FileProcessorCommand
+
+        usage '[options] FILE ...'
+
+        argument :file, required: true,
+                        repeats:  true,
+                        desc:     'Archive files to unarchive'
+
+        option :format, short: '-f',
+                        value: {
+                          type: [:tar, :zip]
+                        },
+                        desc: 'Archive type'
+
+        description 'Unarchive the archive file(s)'
+
+        man_page 'ronin-unarchive.1'
+
+        #
+        # Runs the `unarchive` sub-command.
+        #
+        # @param [Array<String>] files
+        #   File arguments.
+        #
+        def run(*files)
+          files.each do |file|
+            open_archive(file) do |archived_files|
+              archived_files.each do |archived_file|
+                File.binwrite(archived_file.name, archived_file.read)
+              end
+            end
+          end
+        end
+
+        # Archive file formats and archive types.
+        ARCHIVE_FORMATS = {
+          '.tar' => :tar,
+          '.zip' => :zip
+        }
+
+        #
+        # Returns the format for the given archive path.
+        #
+        # @param [String] path
+        #   The path to the archive file.
+        #
+        # @return [:tar, :zip, nil]
+        #   The archive format. `nil` is returned if the format cannot be
+        #   guessed and the `--format` option was not given.
+        #
+        def format_for(path)
+          options.fetch(:format) do
+            ARCHIVE_FORMATS[File.extname(path)]
+          end
+        end
+
+        #
+        # Opens archive for read.
+        #
+        # @param [String] file
+        #   File to open.
+        #
+        # @yield [archive_reader]
+        #   Yielded archived file.
+        #
+        # @yieldparam [Ronin::Support::Archive::Zip::Reader,
+        #              Ronin::Support::Archive::Tar::Reader] archive_reader
+        #   Zip or tar reader object.
+        #
+        def open_archive(file,&block)
+          format = format_for(file)
+
+          case format
+          when :tar
+            Support::Archive.untar(file,&block)
+          when :zip
+            Support::Archive.unzip(file,&block)
+          when nil
+            print_error("unknown archive format: #{file}")
+          else
+            raise(NotImplementedError,"archive format not supported: #{format.inspect}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ronin/cli/commands/unhexdump.rb

@@ -23,7 +23,7 @@ module Ronin
   class CLI
     module Commands
       #
-      # Hexdumps data in a variety of encodings and formats.
+      # Decodes a hexdump back into raw data.
       #
       # ## Usage
       #
@@ -149,6 +149,8 @@ module Ronin
         argument :file, required: false,
                         desc: 'Optional file to unhexdump'
 
+        description 'Decodes a hexdump back into raw data'
+
         man_page 'ronin-unhexdump.1'
 
         #

data/lib/ronin/cli/commands/unpack.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2023 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/cli/command'
+require 'ronin/cli/binary_template'
+
+module Ronin
+  class CLI
+    module Commands
+      #
+      # Unpacks binary data.
+      #
+      # ## Usage
+      #
+      #     ronin unpack [options] TYPE [...]
+      #
+      # ## Options
+      #
+      #     -E, --endian little|big|net      Sets the endianness
+      #     -A x86|x86_64|ppc|ppc64|mips|mips_le|mips_be|mips64|mips64_le|mips64_be|arm|arm_le|arm_be|arm64|arm64_le|arm64_be,
+      #         --arch                       Sets the architecture
+      #     -O linux|macos|windows|android|apple_ios|bsd|freebsd|openbsd|netbsd,
+      #         --os                         Sets the OS
+      #     -S, --string $'\xXX\x..'         The raw binary string to unpack
+      #     -f, --file FILE                  The binary file to unpack
+      #     -h, --help                       Print help information
+      #
+      # ## Arguments
+      #
+      #     TYPE:VALUE                      A value and it's type.
+      #
+      # ### Types
+      #
+      #     Native             Little-endian       Big-endian          Network-endian
+      #     ------             -------------       ----------          --------------
+      #
+      #     char
+      #     uchar
+      #     byte
+      #     string
+      #     int                int_le              int_be              int_net
+      #     int8
+      #     int16              int16_le            int16_be            int16_net
+      #     int32              int32_le            int32_be            int32_net
+      #     int64              int64_le            int64_be            int64_net
+      #     short              short_le            short_be            short_net
+      #     long               long_le             long_be             long_net
+      #     long_long          long_long_le        long_long_be        long_long_net
+      #     uint               uint_le             uint_be             uint_net
+      #     uint8
+      #     uint1616           uint16_le           uint16_be           uint16_net
+      #     uint3232           uint32_le           uint32_be           uint32_net
+      #     uint6464           uint64_le           uint64_be           uint64_net
+      #     ushort             ushort_le           ushort_be           ushort_net
+      #     ulong              ulong_le            ulong_be            ulong_net
+      #     ulong_long         ulong_long_le       ulong_long_be       ulong_long_net
+      #     float              float_le            float_be            float_net
+      #     float32            float32_le          float32_be          float32_net
+      #     float64            float64_le          float64_be          float64_net
+      #     double             double_le           double_be           double_net
+      #     pointer            pointer_le          pointer_be          pointer_net
+      #
+      # ## Examples
+      #
+      #     ronin unpack int32 uint32 char string
+      #     ronin unpack int32[4] string[3]
+      #     ronin unpack uint32_le
+      #     ronin unpack uint32_be
+      #     ronin unpack --endian big int uint
+      #     ronin unpack --arch arm_le int long
+      #     ronin unpack --arch x86_64 --os windows uint
+      #     ronin unpack --string $'\x44\x33\x22\x11' int32
+      #     ronin unpack --file int32.dat int32
+      #     ronin pack int32:0x11223344 | ronin unpack int32
+      #
+      # @since 2.1.0
+      #
+      class Unpack < Command
+
+        include BinaryTemplate
+
+        option :string, short: '-S',
+                        value: {
+                          type:  String,
+                          usage: "$'\\xXX\\x..'"
+                        },
+                        desc: 'The raw binary string to unpack'
+
+        option :file, short: '-f',
+                      value: {
+                        type:  String,
+                        usage: 'FILE'
+                      },
+                      desc: 'The binary file to unpack'
+
+        argument :type, required: true,
+                        repeats:  true,
+                        desc:     'A C type to unpack'
+
+        examples [
+          'int32 uint32 char string',
+          'int32[4] string[3]',
+          'uint32_le',
+          'uint32_be',
+          '--endian big int uint',
+          '--arch arm_le int long',
+          '--arch x86_64 --os windows uint',
+          '--string $\'\x44\x33\x22\x11\' int32',
+          '--file int32.dat int32',
+          'int32'
+        ]
+
+        description 'Unpacks binary data'
+
+        man_page 'ronin-unpack.1'
+
+        #
+        # Runs the `ronin unpack` command.
+        #
+        # @param [Array<String>] args
+        #   The `TYPE` arguments to parse.
+        #
+        def run(*args)
+          types    = args.map(&method(:parse_type))
+          template = build_template(types)
+
+          data = if options[:string]
+                   options[:string]
+                 elsif options[:file]
+                   File.binread(options[:file])
+                 else
+                   stdin.read
+                 end
+
+          values = template.unpack(data)
+
+          # remove the outer-most square brackets
+          print_array_value(values)
+          puts
+        end
+
+        #
+        # Prints an Array of values.
+        #
+        # @param [Array<Integer, Float, String, Ronin::Support::Binary::Array>] value
+        #   The array value to print.
+        #
+        def print_array_value(value)
+          # convert Ronin::Support::Binary::Array objects to plain Arrays
+          value = value.to_a
+
+          print '['
+
+          value.each_with_index do |element,index|
+            print_value(element)
+            print(', ') unless (index == (value.length - 1))
+          end
+
+          print ']'
+        end
+
+        #
+        # Prints an individual value.
+        #
+        # @param [Integer, Float, String, Ronin::Support::Binary::Array] value
+        #   The value to print.
+        #
+        def print_value(value)
+          case value
+          when Array, Support::Binary::Array
+            print_array_value(value)
+          else
+            print(value.inspect)
+          end
+        end
+
+      end
+    end
+  end
+end