pwn 0.5.508 → 0.5.509

data/lib/pwn/plugins/credit_card.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'credit_card_validations'
-require 'credit_card_validations/string'
-
-module PWN
-  module Plugins
-    # This plugin provides useful credit card capabilities
-    module CreditCard
-      # Supported Method Parameters::
-      # PWN::Plugins::CreditCard.list_types
-
-      public_class_method def self.list_types
-        %i[
-          amex
-          unionpay
-          dankort
-          diners
-          elo
-          discover
-          hipercard
-          jcb
-          maestro
-          mastercard
-          mir
-          rupay
-          solo
-          switch
-          visa
-        ]
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::CreditCard.generate(
-      #   type: 'optional - card type from #list_types method to generate (defaults to :random)',
-      #   count: 'optional - number of numbers to generate (defaults to 1)'
-      # )
-
-      public_class_method def self.generate(opts = {})
-        type = opts[:type] ||= :random
-        type = type.to_s.strip.scrub.chomp.downcase.to_sym
-
-        count = opts[:count].to_i
-        count = 1 if count.zero?
-
-        cc_result_arr = []
-        (1..count).each do
-          gen_type = list_types.sample if type == :random
-          gen_type = type unless type == :random
-          cc_hash = type(cc: CreditCardValidations::Factory.random(gen_type))
-          cc_result_arr.push(cc_hash)
-        end
-
-        cc_result_arr
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::CreditCard.type(
-      #   cc: 'required - e.g. XXXX XXXX XXXX XXXX'
-      # )
-
-      public_class_method def self.type(opts = {})
-        cc = opts[:cc].to_s.scrub.strip.chomp
-        cc_hash = {}
-        cc_hash[:number] = cc
-        cc_hash[:type] = cc.credit_card_brand
-
-        cc_hash
-      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}.list_types
-
-          #{self}.generate(
-            type: 'required - card to generate from #list_types method to generate',
-            count: 'optional - number of numbers to generate (defaults to 1)'
-          )
-
-          #{self}.type(
-            cc: 'required - e.g. XXXX XXXX XXXX XXXX'
-          )
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/dao_ldap.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/ldap'
-
-module PWN
-  module Plugins
-    # This plugin is a data access object used for interacting w/ Active Directory/LDAP Servers
-    module DAOLDAP
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOLDAP.connect(
-      #   host: 'required host or IP',
-      #   port: 'optional port (defaults to 636)',
-      #   base: 'required ldap base to search from (e.g. dc=domain,dc=com)'
-      #   encryption: 'optional parameter to protect communication in transit, :simple_tls OR :start_tls'
-      #   auth_method: 'required ldap auth bind method, :simple, :sasl, OR :gss_spnego'
-      #   username: 'required username (e.g. support@0dayinc.com)',
-      #   password: 'optional (prompts if left blank)',
-      # )
-
-      public_class_method def self.connect(opts = {})
-        host = opts[:host].to_s
-        port = opts[:port].to_i
-        base = opts[:base]
-        encryption = opts[:encryption]
-        auth_method = opts[:auth_method]
-
-        username = opts[:username].to_s
-
-        password = if opts[:password].nil?
-                     PWN::Plugins::AuthenticationHelper.mask_password
-                   else
-                     opts[:password].to_s
-                   end
-
-        if encryption
-          ldap_obj = Net::LDAP.new(
-            host: host,
-            port: port,
-            base: base,
-            encryption: encryption,
-            auth: {
-              method: auth_method,
-              username: username,
-              password: password
-            }
-          )
-        else
-          ldap_obj = Net::LDAP.new(
-            host: host,
-            port: port,
-            base: base,
-            auth: {
-              method: auth_method,
-              username: username,
-              password: password
-            }
-          )
-        end
-
-        ldap_obj.bind
-
-        ldap_obj
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOLDAP.get_employee_by_username(
-      #   ldap_obj: 'required ldap_obj returned from #connect method',
-      #   username: 'required username of employee to retrieve from LDAP server'
-      # )
-
-      public_class_method def self.get_employee_by_username(opts = {})
-        ldap_obj = opts[:ldap_obj]
-        username = opts[:username].to_s.scrub
-        treebase = ldap_obj.base
-
-        filter = Net::LDAP::Filter.eq('samaccountname', username)
-        ldap_obj.search(base: treebase, filter: filter)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOLDAP.disconnect(
-      #   ldap_obj: ldap_obj
-      # )
-
-      public_class_method def self.disconnect(opts = {})
-        ldap_obj = opts[:ldap_obj]
-        ldap_obj = nil
-      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:
-          ldap_obj = #{self}.connect(
-            host: 'required host or IP',
-            port: 'required port',
-            base: 'required ldap base to search from (e.g. dc=domain,dc=com)',
-            encryption: 'optional parameter to protect communication in transit, :simple_tls OR :start_tls',
-            auth_method: 'required ldap auth bind method, :simple, :sasl, OR :gss_spnego'
-            username: 'required username',
-            password: 'optional (prompts if left blank)',
-          )
-
-          employee = #{self}.get_employee_by_username(
-            ldap_obj: 'required ldap_obj returned from #connect method',
-            username: 'required username of employee to retrieve from LDAP server'
-          )
-          puts employee[0][:dn]
-
-          #{self}.disconnect(:ldap_obj => ldap_obj)
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/dao_mongo.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# require 'mongo'
-
-module PWN
-  module Plugins
-    # This plugin needs additional development, however, its intent is to be
-    # used as a data access object for interacting w/ MongoDB
-    module DAOMongo
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOMongo.connect(
-      #   host: 'optional host or IP defaults to 127.0.0.1',
-      #   port: 'optional port defaults to 27017',
-      #   database: 'optional database name'
-      # )
-
-      public_class_method def self.connect(opts = {})
-        # Set host
-        host = if opts[:host].nil?
-                 '127.0.0.1' # Defaults to localhost
-               else
-                 opts[:host].to_s
-               end
-
-        # Set port
-        port = if opts[:port].nil?
-                 27_017 # Defaults to TCP port 27017
-               else
-                 opts[:port].to_i
-               end
-
-        database = opts[:database].to_s.scrub
-
-        if opts[:database].nil?
-          mongo_conn = Mongo::Client.new(["#{host}:#{port}"])
-        else
-          mongo_conn = Mongo::Client.new(["#{host}:#{port}"], database: database)
-        end
-
-        validate_mongo_conn(mongo_conn: mongo_conn)
-        mongo_conn
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOMongo.disconnect(
-      #   mongo_conn: mongo_conn
-      # )
-
-      public_class_method def self.disconnect(opts = {})
-        mongo_conn = opts[:mongo_conn]
-        validate_mongo_conn(mongo_conn: mongo_conn)
-        mongo_conn.close
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # validate_mongo_conn(
-      #   :mongo_conn => mongo_conn
-      # )
-
-      private_class_method def self.validate_mongo_conn(opts = {})
-        mongo_conn = opts[:mongo_conn]
-        raise "Error: Invalid mongo_conn Object #{mongo_conn}" unless mongo_conn.instance_of?(Mongo::Client)
-      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:
-          mongo_conn = #{self}.connect(
-            host: 'optional host or IP defaults to 127.0.0.1',
-            port: 'optional port defaults to 27017',
-            database: 'optional database name'
-          )
-
-          #{self}.disconnect(mongo_conn: mongo_conn)
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/dao_postgres.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require 'pg'
-
-module PWN
-  module Plugins
-    # This plugin is a data access object used for interacting w/ PostgreSQL databases.
-    module DAOPostgres
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOPostgres.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
-      # )
-
-      public_class_method def self.connect(opts = {})
-        host = opts[:host].to_s
-
-        port = if opts[:port].nil? || opts[:port].zero?
-                 5432
-               else
-                 opts[:port].to_i
-               end
-
-        dbname = opts[:dbname].to_s
-        user = opts[:user].to_s
-
-        password = if opts[:password].nil?
-                     PWN::Plugins::AuthenticationHelper.mask_password
-                   else
-                     opts[:password].to_s
-                   end
-
-        connect_timeout = if opts[:connect_timeout].nil?
-                            60
-                          else
-                            opts[:connect_timeout].to_i
-                          end
-
-        options = opts[:options]
-        tty = opts[:tty]
-
-        case opts[:sslmode]
-        when :disable
-          sslmode = 'disable'
-        when :allow
-          sslmode = 'allow'
-        when :prefer
-          sslmode = 'prefer'
-        when :require
-          sslmode = 'require'
-        else
-          raise "Error: Invalid :sslmode => #{opts[:sslmode]}. Valid params are :disable, :allow, :prefer, or :require"
-        end
-
-        pg_conn = PG::Connection.new(
-          host: host,
-          port: port,
-          dbname: dbname,
-          user: user,
-          password: password,
-          connect_timeout: connect_timeout,
-          options: options,
-          tty: tty,
-          sslmode: sslmode
-        )
-
-        validate_pg_conn(pg_conn: pg_conn)
-        pg_conn
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOPostgres.sql_statement(
-      #   pg_conn: pg_conn,
-      #   prepared_statement: 'SELECT * FROM tn_users WHERE state = $1',
-      #   statement_params: ['Active']
-      # )
-
-      public_class_method def self.sql_statement(opts = {})
-        pg_conn = opts[:pg_conn]
-        validate_pg_conn(pg_conn: pg_conn)
-        prepared_statement = opts[:prepared_statement] # Can also be leveraged for 'select * from user;'
-        statement_params = opts[:statement_params] # << Array of Params
-        raise "Error: :statement_params => #{statement_params.class}. Pass as an Array object" unless statement_params.instance_of?(Array) || statement_params.nil?
-
-        if statement_params.nil?
-          pg_conn.exec(prepared_statement)
-        else
-          pg_conn.exec(prepared_statement, statement_params)
-        end
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # Method Parameters Not Implemented
-
-      # public
-
-      # def self.list_all_schemas_by_host(opts = {})
-      # end
-
-      # Supported Method Parameters::
-      # Method Parameters Not Implemented
-
-      # public
-
-      # def self.list_all_databases_by_schema(opts = {})
-      # end
-
-      # Supported Method Parameters::
-      # Method Parameters Not Implemented
-
-      # public
-
-      # def self.list_all_tables_by_database(opts = {})
-      # end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOPostgres.list_all_columns_by_table(
-      #   pg_conn: pg_conn,
-      #   schema: 'required schema name',
-      #   table_name: 'required table name'
-      # )
-
-      public_class_method def self.list_all_columns_by_table(opts = {})
-        pg_conn = opts[:pg_conn]
-        validate_pg_conn(pg_conn: pg_conn)
-
-        table_schema = opts[:table_schema].to_s
-        table_name = opts[:table_name].to_s
-
-        prep_sql = "
-          SELECT * FROM information_schema.columns
-          WHERE table_schema = $1
-          AND table_name = $2
-        "
-
-        sql_statement(
-          pg_conn: pg_conn,
-          prepared_statement: prep_sql,
-          statement_params: [table_schema, table_name]
-        )
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOPostgres.disconnect(
-      #   pg_conn: pg_conn
-      # )
-
-      public_class_method def self.disconnect(opts = {})
-        pg_conn = opts[:pg_conn]
-        validate_pg_conn(pg_conn: pg_conn)
-        pg_conn.close
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # validate_pg_conn(
-      #   pg_conn: pg_conn
-      # )
-
-      private_class_method def self.validate_pg_conn(opts = {})
-        pg_conn = opts[:pg_conn]
-        raise "Error: Invalid pg_conn Object #{pg_conn}" unless pg_conn.instance_of?(PG::Connection)
-      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:
-          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
-          )
-
-          res = #{self}.sql_statement(
-            pg_conn: pg_conn,
-            prepared_statement: 'SELECT * FROM tn_users WHERE state = $1',
-            statement_params: ['Active']
-          )
-
-          res = #{self}.list_all_columns_by_table(
-            pg_conn: pg_conn,
-            schema: 'required schema name',
-            table_name: 'required table name'
-          )
-
-          #{self}.disconnect(pg_conn: pg_conn)
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/dao_sqlite3.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'sqlite3'
-
-module PWN
-  module Plugins
-    # This plugin is a data access object used for interacting w/ SQLite3
-    # databases.
-    module DAOSQLite3
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOSQLite3.connect(
-      #   db_path: 'Required - Path of SQLite3 DB File'
-      # )
-
-      public_class_method def self.connect(opts = {})
-        db_path = opts[:db_path]
-
-        sqlite3_conn = SQLite3::Database.new(db_path)
-        sqlite3_conn.results_as_hash = true
-        # Be sure to enable foreign key support for each connection
-        sql_enable_fk = 'PRAGMA foreign_keys = ON;'
-        res = sql_statement(
-          sqlite3_conn: sqlite3_conn,
-          prepared_statement: sql_enable_fk
-        )
-        # TODO: better handling since sqlite3 gem always returns SQLite3::Database
-        # whether DB exists or not
-        unless sqlite3_conn.instance_of?(SQLite3::Database)
-          raise "
-            Connection Error - class should be SQLite3::Database...received:
-            sqlite3_conn = #{sqlite3_conn.inspect}
-            sqlite3_conn.class = #{sqlite3_conn.class}
-          "
-        end
-
-        sqlite3_conn
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # validate_sqlite3_conn(
-      #   sqlite3_conn: sqlite3_conn
-      # )
-
-      private_class_method def self.validate_sqlite3_conn(opts = {})
-        sqlite3_conn = opts[:sqlite3_conn]
-        raise "Error: Invalid sqlite3_conn Object #{sqlite3_conn}" unless sqlite3_conn.instance_of?(SQLite3::Database)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOSQLite3.sql_statement(
-      #   sqlite3_conn: sqlite3_conn,
-      #   prepared_statement: 'SELECT * FROM tn_users WHERE state = ?;',
-      #   statement_params: ['Active']
-      # )
-
-      public_class_method def self.sql_statement(opts = {})
-        sqlite3_conn = opts[:sqlite3_conn]
-        validate_sqlite3_conn(sqlite3_conn: sqlite3_conn)
-        prepared_statement = opts[:prepared_statement] # Can also be leveraged for 'select * from user;'
-        statement_params = opts[:statement_params] # << Array of Params
-        raise "Error: :statement_params => #{statement_params.class}. Pass as an Array object" unless statement_params.instance_of?(Array) || statement_params.nil?
-
-        begin
-          if statement_params.nil?
-            res = sqlite3_conn.execute(prepared_statement)
-          else
-            res = sqlite3_conn.execute(prepared_statement, statement_params)
-          end
-        rescue SQLite3::BusyException
-          puts 'Database In Use - Retrying...'
-          sleep 0.3
-          retry
-        end
-
-        res
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::DAOSQLite3.disconnect(
-      #   sqlite3_conn: sqlite3_conn
-      # )
-
-      public_class_method def self.disconnect(opts = {})
-        sqlite3_conn = opts[:sqlite3_conn]
-        validate_sqlite3_conn(sqlite3_conn: sqlite3_conn)
-
-        sqlite3_conn.close
-      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:
-          sqlite3_conn = #{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']
-          )
-
-          #{self}.disconnect(:sqlite3_conn => sqlite3_conn)
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end