pwn 0.4.333

data/lib/pwn/plugins/dao_mongo.rb

@@ -0,0 +1,96 @@
+# 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):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.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

@@ -0,0 +1,224 @@
+# 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):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.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

@@ -0,0 +1,125 @@
+# 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):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.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