pwn 0.5.508 → 0.5.509

data/lib/pwn/plugins/bus_pirate.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module PWN
-  module Plugins
-    # This plugin is used for interacting with Bus Pirate v3.6
-    # This plugin may be compatible with other versions, however,
-    # has not been tested with anything other than v3.6.
-    module BusPirate
-      # Supported Method Parameters::
-      # PWN::Plugins::BusPirate.connect_via_screen(
-      #   block_dev: 'optional - serial block device path (defaults to /dev/ttyUSB0)'
-      # )
-
-      public_class_method def self.connect_via_screen(opts = {})
-        block_dev = opts[:block_dev].to_s if File.exist?(
-          opts[:block_dev].to_s
-        )
-
-        block_dev ||= '/dev/ttyUSB0'
-
-        screen_bin = '/usr/bin/screen'
-        raise "ERROR: #{screen_bin} not found." unless File.exist?(screen_bin)
-
-        system(
-          screen_bin,
-          block_dev,
-          '115200',
-          '8',
-          'N',
-          '1'
-        )
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # bus_pirate_obj = PWN::Plugins::BusPirate.connect(
-      #   block_dev: 'optional serial block device path (defaults to /dev/ttyUSB0)',
-      #   baud: 'optional (defaults to 9600)',
-      #   data_bits: 'optional (defaults to 8)',
-      #   stop_bits: 'optional (defaults to 1)',
-      #   parity: 'optional (defaults to SerialPort::NONE)',
-      #   flow_control: 'optional (defaults to SerialPort::HARD) SerialPort::NONE|SerialPort::SOFT|SerialPort::HARD'
-      # )
-
-      public_class_method def self.connect(opts = {})
-        PWN::Plugins::Serial.connect(opts)
-      rescue StandardError => e
-        disconnect(bus_pirate_obj: bus_pirate_obj) unless bus_pirate_obj.nil?
-        raise e
-      end
-
-      # Supported Method Parameters::
-      #  PWN::Plugins::BusPirate.init_mode(
-      #   bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method'
-      #   mode: 'required - bus pirate mode to invoke'
-      # )
-      public_class_method def self.init_mode(opts = {})
-        bus_pirate_obj = opts[:bus_pirate_obj]
-        mode = opts[:mode].to_s.strip.chomp.scrub.upcase
-
-        case mode
-        when 'BBI01'
-          # Enter reset binary mode
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x00])
-        when 'SPI1'
-          # Enter binary SPI mode
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x01])
-        when 'I2C1'
-          # Enter I2C mode
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x02])
-        when 'ART1'
-          # Enter UART mode
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x03])
-        when '1W01'
-          # Enter 1-Wire mode
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x04])
-        when 'RAW1'
-          # Enter raw-wire mode
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x05])
-        when 'RESET'
-          # Reset Bus Pirate
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x0F])
-        when 'STEST'
-          # Bus Pirate self-tests
-          PWN::Plugins::Serial.request(serial_obj: bus_pirate_obj, payload: [0x10])
-        else
-          raise "Invalid mode: #{mode}"
-        end
-
-        PWN::Plugins::Serial.response(serial_obj: bus_pirate_obj)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::BusPirate.disconnect(
-      #   bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method'
-      # )
-
-      public_class_method def self.disconnect(opts = {})
-        PWN::Plugins::Serial.disconnect(
-          serial_obj: opts[:bus_pirate_obj]
-        )
-      rescue StandardError => e
-        raise e
-      end
-
-      # Author(s):: 0day Inc. <support@0dayinc.com>
-
-      public_class_method def self.authors
-        "AUTHOR(S):
-          0day Inc. <support@0dayinc.com>
-        "
-      end
-
-      # Display Usage for this Module
-
-      public_class_method def self.help
-        puts "USAGE:
-          #{self}.connect_via_screen(
-            block_dev: 'optional serial block device path (defaults to /dev/ttyUSB0)'
-          )
-
-          bus_pirate_obj = #{self}.connect(
-            block_dev: 'optional serial block device path (defaults to /dev/ttyUSB0)',
-            baud: 'optional (defaults to 9600)',
-            data_bits: 'optional (defaults to 8)',
-            stop_bits: 'optional (defaults to 1)',
-            parity: 'optional - :even||:odd|:none (defaults to :none)'
-          )
-
-          #{self}.init_mode(
-            bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method'
-            mode: 'required - bus pirate mode to invoke'
-          )
-
-          #{self}.disconnect(
-            bus_pirate_obj: 'required - bus_pirate_obj returned from #connect method'
-          )
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/char.rb

@@ -1,474 +0,0 @@
-# frozen_string_literal: true
-
-require 'cgi'
-require 'htmlentities'
-
-module PWN
-  module Plugins
-    # This plugin was created to generate various characters for fuzzing
-    module Char
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.force_utf8(
-      #  obj: 'required - object to force to UTF-8'
-      #  )
-      public_class_method def self.force_utf8(obj)
-        case obj
-        when String
-          obj.force_encoding('ISO-8859-1').encode('UTF-8', invalid: :replace, undef: :replace)
-        when Array
-          obj.map { |item| force_utf8(item) }
-        when Hash
-          obj.transform_values { |value| force_utf8(value) }
-        else
-          obj
-        end
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.generate_by_range(
-      #   from: 'required - integer to start from',
-      #   to: 'required - integer to end UTF-8 generation'
-      # )
-
-      public_class_method def self.generate_by_range(opts = {})
-        from = opts[:from].to_i
-        to = opts[:to].to_i
-
-        char_arr = []
-
-        encoder_arr = list_encoders
-        encoder_arr.delete('UTF-8')
-
-        (from..to).each do |this_int|
-          char_hash = {}
-
-          this_bin = format('%08d', this_int.to_s(2))
-          this_dec = this_int
-          this_hex = format('%02x', this_int)
-          # this_long_int = [this_int].pack('L>').unpack1('H*').scan(/../).map { |h| '\x' + h }.join
-          this_long_int = [this_int].pack('L>').unpack1('H*').scan(/../).map { |h| "\\x#{h}" }.join
-          this_oct = format('\%03d', this_int.to_s(8))
-          # this_short_int = [this_int].pack('S>').unpack1('H*').scan(/../).map { |h| '\x' + h }.join
-          this_short_int = [this_int].pack('S>').unpack1('H*').scan(/../).map { |h| "\\x#{h}" }.join
-          this_utf8 = [this_int].pack('U*')
-
-          begin
-            # Begins breaking once this_int reaches 55296
-            this_html_entity = HTMLEntities.new.encode(this_utf8)
-            this_html_entity_dec = HTMLEntities.new.encode(this_utf8, :decimal)
-            this_html_entity_hex = HTMLEntities.new.encode(this_utf8, :hexadecimal)
-          rescue ArgumentError
-            this_html_entity = "***max_int<#{this_int}"
-            this_html_entity_dec = "***max_int<#{this_int}"
-            thishtml_entity_hex = "***max_int<#{this_int}"
-            next
-          end
-
-          this_url = CGI.escape(this_utf8)
-
-          # To date Base 2 - Base 36 is supported:
-          # (0..999).each {|base| begin; puts "#{base} => #{this_dec.to_s(base)}"; rescue; next; end }
-          char_hash[:bin] = { char: this_bin, encoder: nil }
-          char_hash[:dec] = { char: this_dec, encoder: nil }
-          char_hash[:hex] = { char: this_hex, encoder: nil }
-          char_hash[:html_entity] = { char: this_html_entity, encoder: nil }
-          char_hash[:html_entity_dec] = { char: this_html_entity_dec, encoder: nil }
-          char_hash[:html_entity_hex] = { char: this_html_entity_hex, encoder: nil }
-          char_hash[:long_int] = { char: this_long_int, encoder: nil }
-          char_hash[:oct] = { char: this_oct, encoder: nil }
-          char_hash[:short_int] = { char: this_short_int, encoder: nil }
-          char_hash[:url] = { char: this_url, encoder: nil }
-          char_hash[:utf8] = { char: this_utf8, encoder: 'UTF-8' }
-
-          encoder_arr.each do |encoder|
-            this_encoder_key = encoder.downcase.tr('-', '_').to_sym
-            begin
-              char_hash[this_encoder_key] = {
-                char: this_utf8.encode(encoder, 'UTF-8'),
-                encoder: encoder
-              }
-            rescue Encoding::InvalidByteSequenceError
-              char_hash[this_encoder_key] = {
-                char: "***invalid_byte_seq@#{this_int}",
-                encoder: encoder
-              }
-              next
-            rescue Encoding::UndefinedConversionError
-              char_hash[this_encoder_key] = {
-                char: "***max_int<#{this_int}",
-                encoder: encoder
-              }
-              next
-            rescue Encoding::ConverterNotFoundError
-              char_hash[this_encoder_key] = {
-                char: '***convertor_not_found',
-                encoder: encoder
-              }
-              next
-            end
-          end
-
-          sorted_char_hash = char_hash.sort.to_h
-          char_arr.push(sorted_char_hash)
-        end
-
-        char_arr
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.c0_controls_latin_basic
-
-      public_class_method def self.c0_controls_latin_basic
-        generate_by_range(from: 0, to: 127)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.c1_controls_latin_supplement
-
-      public_class_method def self.c1_controls_latin_supplement
-        generate_by_range(from: 128, to: 255)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.latin_extended_a
-
-      public_class_method def self.latin_extended_a
-        generate_by_range(from: 256, to: 383)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.latin_extended_b
-
-      public_class_method def self.latin_extended_b
-        generate_by_range(from: 384, to: 591)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.spacing_modifiers
-
-      public_class_method def self.spacing_modifiers
-        generate_by_range(from: 688, to: 767)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.diacritical_marks
-
-      public_class_method def self.diacritical_marks
-        generate_by_range(from: 768, to: 879)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.greek_coptic
-
-      public_class_method def self.greek_coptic
-        generate_by_range(from: 880, to: 1023)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.cyrillic_basic
-
-      public_class_method def self.cyrillic_basic
-        generate_by_range(from: 1024, to: 1279)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.cyrillic_supplement
-
-      public_class_method def self.cyrillic_supplement
-        generate_by_range(from: 1280, to: 1327)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.punctuation
-
-      public_class_method def self.punctuation
-        generate_by_range(from: 8192, to: 8303)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.currency_symbols
-
-      public_class_method def self.currency_symbols
-        generate_by_range(from: 8352, to: 8399)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.letterlike_symbols
-
-      public_class_method def self.letterlike_symbols
-        generate_by_range(from: 8448, to: 8527)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.arrows
-
-      public_class_method def self.arrows
-        generate_by_range(from: 8592, to: 8703)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.math_operators
-
-      public_class_method def self.math_operators
-        generate_by_range(from: 8704, to: 8959)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.box_drawings
-
-      public_class_method def self.box_drawings
-        generate_by_range(from: 9312, to: 9599)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.block_elements
-
-      public_class_method def self.block_elements
-        generate_by_range(from: 9600, to: 9631)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.geometric_shapes
-
-      public_class_method def self.geometric_shapes
-        generate_by_range(from: 9632, to: 9727)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.misc_symbols
-
-      public_class_method def self.misc_symbols
-        generate_by_range(from: 9728, to: 9983)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.dingbats
-
-      public_class_method def self.dingbats
-        generate_by_range(from: 9984, to: 10_175)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.bubble_ip(
-      #   ip: 'required - ip address to transform'
-      # )
-
-      public_class_method def self.bubble_ip(opts = {})
-        ip = opts[:ip].to_s
-
-        bubble_ip = ''
-        ip_arr = ip.split('.')
-        dot = "\u3002"
-        ip_arr.each.with_index do |octet_str, this_index|
-          octet_str.each_char do |digit_str|
-            case digit_str.to_i
-            when 0
-              bubble_ip = "#{bubble_ip}\u24ea"
-            when 1
-              bubble_ip = "#{bubble_ip}\u2460"
-            when 2
-              bubble_ip = "#{bubble_ip}\u2461"
-            when 3
-              bubble_ip = "#{bubble_ip}\u2462"
-            when 4
-              bubble_ip = "#{bubble_ip}\u2463"
-            when 5
-              bubble_ip = "#{bubble_ip}\u2464"
-            when 6
-              bubble_ip = "#{bubble_ip}\u2465"
-            when 7
-              bubble_ip = "#{bubble_ip}\u2466"
-            when 8
-              bubble_ip = "#{bubble_ip}\u2467"
-            when 9
-              bubble_ip = "#{bubble_ip}\u2468"
-            end
-          end
-          bubble_ip = "#{bubble_ip}#{dot}" if (this_index + 1) < ip_arr.length
-        end
-
-        bubble_ip
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # encoder_arr = PWN::Plugins::Char.list_encoders
-
-      public_class_method def self.list_encoders
-        encoder_arr = []
-
-        Encoding.list.each do |encoder|
-          encoder_arr.push(encoder.name)
-        end
-
-        encoder_arr.sort
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::Char.generate_encoded_files(
-      #   from: 'required - integer to start from',
-      #   to: 'required - integer to end UTF-8 generation',
-      #   output_dir: 'required - folder to create files'
-      # )
-
-      public_class_method def self.generate_encoded_files(opts = {})
-        from = opts[:from].to_i
-        to = opts[:to].to_i
-        output_dir = opts[:output_dir] if Dir.exist?(opts[:output_dir])
-
-        char_arr = generate_by_range(from: 0, to: 0).first
-        char_keys = char_arr.keys
-        char_keys.each do |char_key|
-          encoder = char_arr[char_key][:encoder]
-          this_file = "#{output_dir}/#{from}_#{to}_#{encoder}.txt"
-
-          case char_key
-          when :bin, :dec, :hex, :html_entity, :html_entity_dec, :html_entity_hex, :long_int, :oct, :short_int, :url
-            file_instr = 'wb'
-          else
-            file_instr = "wb:#{encoder}"
-          end
-
-          File.open(this_file, file_instr) do |f|
-            generate_by_range(from: from, to: to).each do |char_hash|
-              case char_key
-              when :bin, :dec, :hex, :html_entity, :html_entity_dec, :html_entity_hex, :long_int, :oct, :short_int, :url
-                f.puts char_hash[char_key][:char]
-              else
-                f.puts char_hash[char_key][:char] unless char_hash[char_key][:char].nil? || char_hash[char_key][:char].encode('utf-8').include?('***')
-              end
-            end
-          end
-
-          if File.empty?(this_file)
-            File.unlink(this_file)
-          else
-            print '.'
-          end
-        rescue StandardError => e
-          puts "FILE GENERATION ATTEMPT OF: #{this_file} RESULTED THE FOLLOWING ERROR:"
-          puts "#{e.class}: #{e.message}\n#{e.backtrace}\n\n\n"
-          File.unlink(this_file) if File.empty?(this_file)
-          next
-        end
-        print "\n"
-      rescue StandardError => e
-        raise e
-      end
-
-      # Author(s):: 0day Inc. <support@0dayinc.com>
-
-      public_class_method def self.authors
-        "AUTHOR(S):
-          0day Inc. <support@0dayinc.com>
-        "
-      end
-
-      # Display Usage for this Module
-
-      public_class_method def self.help
-        puts "USAGE:
-          char_arr = #{self}.generate_by_range(
-            from: 'required - integer to start from',
-            to: 'required - integer to end char generation'
-          )
-
-          #{self}.c0_controls_latin_basic
-
-          #{self}.c1_controls_latin_supplement
-
-          #{self}.latin_extended_a
-
-          #{self}.latin_extended_b
-
-          #{self}.spacing_modifiers
-
-          #{self}.diacritical_marks
-
-          #{self}.greek_coptic
-
-          #{self}.cyrillic_basic
-
-          #{self}.cyrillic_supplement
-
-          #{self}.punctuation
-
-          #{self}.currency_symbols
-
-          #{self}.letterlike_symbols
-
-          #{self}.arrows
-
-          #{self}.math_operators
-
-          #{self}.box_drawings
-
-          #{self}.block_elements
-
-          #{self}.geometric_shapes
-
-          #{self}.misc_symbols
-
-          #{self}.dingbats
-
-          #{self}.bubble_ip(
-            ip: 'required - ip address to transform'
-          )
-
-          encoder_arr = #{self}.list_encoders
-
-          #{self}.generate_encoded_files(
-            from: 'required - integer to start from',
-            to: 'required - integer to end UTF-8 generation',
-            output_dir: 'required - folder to create files'
-          )
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end