pgsqlpot 2.0.1__tar.gz → 2.0.2__tar.gz

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.2]
+
+### Added in version 2.0.2
+
+* Nothing
+
+### Changed in version 2.0.2
+
+* Increased the version number
+* The `restart` command wasn't working correctly on Windows due to a race
+  condition. Fixed.
+* Fixed a problem in the MySQL plugin that made it unresponsive under high
+  traffic
+
 ## [2.0.1]
 
 ### Added in version 2.0.1

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/MANIFEST.in

@@ -1,9 +1,8 @@
-include honeypot.py
-include setup.cfg
+include CHANGELOG.md
 include LICENSE
 include README.md
-include CHANGELOG.md
-graft pgsqlpot
+include honeypot.py
 graft core
 graft output_plugins
+graft pgsqlpot
 prune pgsqlpot/data/test/develop

{pgsqlpot-2.0.1/pgsqlpot.egg-info → pgsqlpot-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgsqlpot
-Version: 2.0.1
+Version: 2.0.2
 Summary: A PostgeSQL Honeypot
 Home-page: https://gitlab.com/bontchev/pgsqlpot
 Author: Vesselin Bontchev

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/core/tools.py

@@ -20,7 +20,9 @@ except ImportError:
 
 if version_info[0] >= 3:
     def decode(x):
-        return x.decode('utf-8', errors='ignore')
+        if isinstance(x, bytes):
+            return x.decode('utf-8', errors='ignore')
+        return x
     def encode(x):
         return x.encode()
     def ord(x):

{pgsqlpot-2.0.1/pgsqlpot → pgsqlpot-2.0.2}/honeypot.py

@@ -23,7 +23,7 @@ from twisted.internet.reactor import listenTCP, run
 from twisted.python.log import msg
 
 
-__VERSION__ = '2.0.1'
+__VERSION__ = '2.0.2'
 __description__ = 'A PostgreSQL Honeypot'
 __license__ = 'GPLv3'
 __uri__ = 'https://gitlab.com/bontchev/pgsqlpot'

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/output_plugins/mysql.py

@@ -24,9 +24,16 @@ except ImportError:
         from _mysql_exceptions import (Error, OperationalError) # type: ignore
 
 from twisted.enterprise.adbapi import ConnectionPool
-from twisted.python.compat import reraise
 from twisted.python.log import msg
 
+if version_info[0] >= 3:
+    def _reraise(tp, value, tb):
+        raise value.with_traceback(tb)
+else:
+    exec("""def _reraise(tp, value, tb):
+    raise tp, value, tb
+""")
+
 
 class ReconnectingConnectionPool(ConnectionPool):
     """
@@ -42,14 +49,27 @@ class ReconnectingConnectionPool(ConnectionPool):
     def _runInteraction(self, interaction, *args, **kw):
 
         def rerise_exception(conn):
-            _, excValue, excTraceback = exc_info()
+            tp, value, tb = exc_info()
             try:
                 conn.rollback()
             except Exception:
                 msg('Rollback failed')
-            reraise(excValue, excTraceback)
+            _reraise(tp, value, tb)
+
+        conn = self.connect()
+
+        # Ping the connection before use.  This transparently handles stale
+        # connections closed by MySQL's wait_timeout (default 8 hours): if the
+        # server closed our idle connection, ping(True) reconnects immediately.
+        # If MySQL is genuinely unreachable, ping(True) raises OperationalError
+        # within connect_timeout seconds, which is caught below and re-raised
+        # so the Deferred errback fires and the worker thread is freed promptly.
+        try:
+            conn.ping(True)
+        except Exception:
+            self.disconnect(conn)
+            raise
 
-        conn = self.connectionFactory(self)
         trans = self.transactionFactory(self, conn)
         try:
             result = interaction(trans, *args, **kw)
@@ -57,12 +77,10 @@ class ReconnectingConnectionPool(ConnectionPool):
             conn.commit()
             return result
         except OperationalError as e:
-            if e.args[0] not in (2003, 2006, 2013):
-                rerise_exception(conn)
-            else:
+            if e.args[0] in (2003, 2006, 2013):
                 conn = self.connections.get(self.threadID())
                 self.disconnect(conn)
-                return ConnectionPool._runInteraction(self, interaction, *args, **kw)
+            rerise_exception(conn)
         except Exception:
             rerise_exception(conn)
 
@@ -73,6 +91,35 @@ class Output(output.Output):
         if self.debug:
             msg(message)
 
+    def _enqueue(self, label, d):
+        """
+        Wrap a runInteraction() deferred with two targeted diagnostics:
+
+        1. Pending counter + threshold warning: if the worker threads are stuck
+           the counter climbs without ever coming back down.  A warning fires
+           once per threshold crossing so the log stays quiet under normal load
+           but shouts when something is wrong.
+
+        2. Always-on errback: any DB error that would previously have been
+           silently swallowed now produces an explicit log line.
+        """
+        self._pending += 1
+
+        def on_success(result):
+            self._pending -= 1
+            return result
+
+        def on_failure(failure):
+            self._pending -= 1
+            msg('output_mysql: runInteraction {} failed: {}'.format(label, failure))
+            return None
+
+        d.addCallback(on_success)
+        d.addErrback(on_failure)
+
+        if self._pending > self._pending_warn_threshold:
+            msg('output_mysql: WARNING - {} interactions pending, worker thread may be stuck'.format(self._pending))
+
     def start(self):
         host = CONFIG.get('output_mysql', 'host', fallback='localhost')
         database = CONFIG.get('output_mysql', 'database', fallback='pgsqlpot')
@@ -82,6 +129,13 @@ class Output(output.Output):
 
         self.debug = CONFIG.getboolean('output_mysql', 'debug', fallback=False)
         self.geoip = CONFIG.getboolean('output_mysql', 'geoip', fallback=True)
+        self._pending = 0
+        self._pending_warn_threshold = CONFIG.getint('output_mysql', 'pending_warn_threshold', fallback=100)
+
+        connect_timeout = CONFIG.getint('output_mysql', 'connect_timeout', fallback=10)
+        read_timeout    = CONFIG.getint('output_mysql', 'read_timeout',    fallback=30)
+        write_timeout   = CONFIG.getint('output_mysql', 'write_timeout',   fallback=30)
+        cp_max = CONFIG.getint('output_mysql', 'cp_max', fallback=5)
 
         try:
             self.dbh = ReconnectingConnectionPool(
@@ -93,11 +147,14 @@ class Output(output.Output):
                 port=port,
                 charset='utf8',
                 use_unicode=True,
+                connect_timeout=connect_timeout,
+                read_timeout=read_timeout,
+                write_timeout=write_timeout,
                 cp_min=1,
-                cp_max=1
+                cp_max=cp_max,
             )
         except Error as e:
-            self.local_log('output_mysql: MySQL Error {}: "{}"'.format(e.args[0], e.args[1]))
+            msg('output_mysql: MySQL Error {}: "{}"'.format(e.args[0], e.args[1]))
 
         if self.geoip:
             geoipdb_city_path = CONFIG.get('output_mysql', 'geoip_citydb', fallback='data/GeoLite2-City.mmdb')
@@ -106,13 +163,14 @@ class Output(output.Output):
                 self.reader_city = Reader(geoipdb_city_path)
             except Exception:
                 self.reader_city = None
-                self.local_log('Failed to open City GeoIP database {}'.format(geoipdb_city_path))
+                msg('output_mysql: Failed to open City GeoIP database {}'.format(geoipdb_city_path))
 
             try:
                 self.reader_asn = Reader(geoipdb_asn_path)
             except Exception:
                 self.reader_asn = None
-                self.local_log('Failed to open ASN GeoIP database {}'.format(geoipdb_asn_path))
+                msg('output_mysql: Failed to open ASN GeoIP database {}'.format(geoipdb_asn_path))
+
 
     def stop(self):
         if self.geoip:
@@ -120,7 +178,6 @@ class Output(output.Output):
                 self.reader_city.close()
             if self.reader_asn is not None:
                 self.reader_asn.close()
-
     def write(self, event):
         """
         TODO: Check if the type (date, datetime or timestamp) of columns is appropriate for your needs and timezone
@@ -130,7 +187,8 @@ class Output(output.Output):
         and back from UTC to the current time zone for retrieval.
         (This does not occur for other types such as DATETIME.)"
         """
-        self.dbh.runInteraction(self.connect_event, event)
+        self._enqueue('connect_event', self.dbh.runInteraction(self.connect_event, event))
+
 
     def simple_query(self, txn, sql, args):
         if self.debug:
@@ -145,22 +203,19 @@ class Output(output.Output):
                 txn.execute(sql)
             result = txn.fetchall()
         except Exception as e:
-            self.local_log('output_mysql: MySQL Error: {}'.format(e))
+            msg('output_mysql: MySQL Error: {}'.format(e))
             result = None
         return result
 
     def get_id(self, txn, table, column, entry):
+        # INSERT IGNORE silently skips the insert when a UNIQUE constraint would
+        # be violated, so the subsequent SELECT always finds exactly one row
+        # regardless of whether a concurrent call already inserted it.
+        self.simple_query(txn, "INSERT IGNORE INTO `{}` (`{}`) VALUES (%s)".format(table, column), (entry, ))
         r = self.simple_query(txn, "SELECT `id` FROM `{}` WHERE `{}` = %s".format(table, column), (entry, ))
         if r:
-            id = r[0][0]
-        else:
-            self.simple_query(txn, "INSERT INTO `{}` (`{}`) VALUES (%s)".format(table, column), (entry, ))
-            r = self.simple_query(txn, 'SELECT LAST_INSERT_ID()', ())
-            if r:
-                id = int(r[0][0])
-            else:
-                id = 0
-        return id
+            return r[0][0]
+        return 0
 
     def connect_event(self, txn, event):
         remote_ip = event['src_ip']
@@ -197,14 +252,15 @@ class Output(output.Output):
 
         if self.geoip:
             country, country_code, city, org, asn_num = geolocate(remote_ip, self.reader_city, self.reader_asn)
+            # INSERT IGNORE rather than ON DUPLICATE KEY UPDATE: geolocation
+            # data for an IP rarely changes, so skipping the update on
+            # subsequent hits is acceptable.  More importantly, ON DUPLICATE
+            # KEY UPDATE takes an exclusive row lock on the existing row,
+            # causing InnoDB lock contention when multiple threads process
+            # connections from the same IP simultaneously.
+            # INSERT IGNORE avoids that lock entirely.
             self.simple_query(txn, """
-                INSERT INTO `geolocation` (`ip`, `country_name`, `country_iso_code`, `city_name`, `org`, `org_asn`)
+                INSERT IGNORE INTO `geolocation` (`ip`, `country_name`, `country_iso_code`, `city_name`, `org`, `org_asn`)
                 VALUES (%s, %s, %s, %s, %s, %s)
-                ON DUPLICATE KEY UPDATE
-                    `country_name` = %s,
-                    `country_iso_code` = %s,
-                    `city_name` = %s,
-                    `org` = %s,
-                    `org_asn` = %s
                 """,
-                (remote_ip, country, country_code, city, org, asn_num, country, country_code, city, org, asn_num, ))
+                (remote_ip, country, country_code, city, org, asn_num, ))

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/output_plugins/postgres.py

@@ -74,24 +74,18 @@ class Output(output.Output):
         return result
 
     def get_id(self, txn, table, column, entry):
+        # ON CONFLICT ... DO UPDATE is a deliberate no-op that makes RETURNING
+        # yield the existing row's id even when the INSERT is skipped due to a
+        # unique-constraint conflict.  DO NOTHING would leave RETURNING empty.
         r = self.simple_query(
             txn,
-            "SELECT id FROM {} WHERE {} = %s".format(table, column),
-            (entry, )
-        )
+            "INSERT INTO {} ({}) VALUES (%s) "
+            "ON CONFLICT ({}) DO UPDATE SET {} = EXCLUDED.{} "
+            "RETURNING id".format(table, column, column, column, column),
+            (entry, ))
         if r:
-            id = int(r[0])
-        else:
-            r = self.simple_query(
-                txn,
-                "INSERT INTO {} ({}) VALUES (%s) RETURNING id".format(table, column),
-                (entry, )
-            )
-            if r:
-                id = int(r[0])
-            else:
-                id = 0
-        return id
+            return int(r[0])
+        return 0
 
     def connect_event(self, txn, event):
         remote_ip = event['src_ip']

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/output_plugins/sqlite.py

@@ -15,7 +15,7 @@ from twisted.python.log import msg
 class Output(output.Output):
 
     def start(self):
-        db_name = CONFIG.get('output_sqlite', 'db_file', fallback='data/pgsqlpot.db')
+        db_name = CONFIG.get('output_sqlite', 'db_file', fallback='log/pgsqlpot.db')
         self.debug = CONFIG.getboolean('output_sqlite', 'debug', fallback=False)
         self.geoip = CONFIG.getboolean('output_sqlite', 'geoip', fallback=True)
 
@@ -75,17 +75,13 @@ class Output(output.Output):
         return result
 
     def get_id(self, txn, table, column, entry):
+        # INSERT OR IGNORE silently skips the insert when a UNIQUE constraint
+        # would be violated, so the subsequent SELECT always finds one row.
+        self.simple_query(txn, "INSERT OR IGNORE INTO `{}` (`{}`) VALUES (?)".format(table, column), (entry, ))
         r = self.simple_query(txn, "SELECT `id` FROM `{}` WHERE `{}` = ?".format(table, column), (entry, ))
         if r:
-            id = r[0][0]
-        else:
-            self.simple_query(txn, "INSERT INTO `{}` (`{}`) VALUES (?)".format(table, column), (entry, ))
-            r = self.simple_query(txn, 'SELECT LAST_INSERT_ROWID()', ())
-            if r:
-                id = int(r[0][0])
-            else:
-                id = 0
-        return id
+            return r[0][0]
+        return 0
 
     def connect_event(self, txn, event):
         remote_ip = event['src_ip']
@@ -100,7 +96,7 @@ class Output(output.Output):
             """,
             (event['session'], event['unixtime'], operation_id, remote_ip, event['src_port'],
              event['dst_ip'], event['dst_port'], sensor_id, ))
-        
+
         if event['operation'].lower() == 'login':
             usr_id = self.get_id(txn, 'usernames', 'username', event['username'])
             pwd_id = self.get_id(txn, 'passwords', 'password', event['password'])

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/pgsqlpot/cli.py

@@ -48,6 +48,7 @@ from os.path import (
 from re import search, IGNORECASE
 from shutil import copy2
 import sys
+from time import sleep
 
 from core.paths import bundled, get_workdir, workdir_path
 
@@ -62,8 +63,27 @@ def _ensure_dir(p):
 
 
 def _file_differs(a, b):
-    with open(a, 'r') as fa, open(b, 'r') as fb:
-        return fa.read() != fb.read()
+    """Return True if files differ. Ignores line-ending differences for text files."""
+    # Try text mode first (normalizes \r\n, \r, \n)
+    try:
+        with open(a, 'r') as fa, open(b, 'r') as fb:
+            while True:
+                line_a = fa.readline()
+                line_b = fb.readline()
+                if line_a != line_b:
+                    return True
+                if not line_a:  # EOF on both
+                    return False
+    except UnicodeDecodeError:
+        # Binary fallback: compare in chunks without loading whole file
+        with open(a, 'rb') as fa, open(b, 'rb') as fb:
+            while True:
+                chunk_a = fa.read(8192)
+                chunk_b = fb.read(8192)
+                if chunk_a != chunk_b:
+                    return True
+                if not chunk_a:
+                    return False
 
 
 def _copy_if_missing(src, dst, label=None):
@@ -157,7 +177,7 @@ def cmd_init(args):
     print('Initialising pgsqlpot working directory: {}'.format(target))
 
     # Runtime directories
-    for d in ('etc', 'log', 'data'):
+    for d in ('data', 'etc', 'log'):
         _ensure_dir(join(target, d))
         print('  mkdir  {}'.format(d))
 
@@ -356,6 +376,7 @@ def cmd_stop(args):
         return
 
     print('Stopping the honeypot (PID {})... '.format(pid), end='')
+    sys.stdout.flush()
 
     if name == 'nt':
         _stop_windows(pid, pidfile)
@@ -365,7 +386,6 @@ def cmd_stop(args):
 
 def _stop_posix(pid, pidfile):
     from signal import SIGKILL, SIGTERM
-    from time import sleep
     kill(pid, SIGTERM)
     for _ in range(60):
         sleep(1)
@@ -399,11 +419,28 @@ def _stop_windows(pid, pidfile):
     finally:
         _devnull.close()
 
-    if ret == 0 or not _pid_running(pid):
-        print('Stopped.')
+    if ret != 0 and _pid_running(pid):
+        print()
+        print(
+            'Warning: taskkill returned {}, process may still be running.'.format(ret)
+        )
+        remove(pidfile)
+        return
+
+    # taskkill /F calls TerminateProcess() which is asynchronous: the call
+    # returns before the kernel has finished tearing down the process and
+    # releasing its resources (sockets, handles, etc.).  Poll until the
+    # process is truly gone so that a subsequent 'start' does not race with
+    # the old process still holding port 3389.
+    for _ in range(30):
+        if not _pid_running(pid):
+            break
+        sleep(0.5)
     else:
         print()
-        print('Warning: taskkill returned {}, process may still be running.'.format(ret))
+        print('Warning: process {} did not exit within 15 s.'.format(pid))
+
+    print('Stopped.')
     remove(pidfile)
 
 

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/pgsqlpot/data/docs/mysql/mysql.sql

@@ -11,7 +11,8 @@ CREATE TABLE IF NOT EXISTS `connections` (
   PRIMARY KEY (`id`),
   KEY `time_idx` (`timestamp`),
   KEY `ip_idx` (`ip`),
-  KEY `ip2_idx` (`timestamp`, `ip`)
+  KEY `ip2_idx` (`timestamp`, `ip`),
+  KEY `session_idx` (`session`)
 );
 
 CREATE TABLE IF NOT EXISTS `operations` (
@@ -26,7 +27,8 @@ CREATE TABLE IF NOT EXISTS `credentials` (
   `session` CHAR(32) NOT NULL,
   `username` INT DEFAULT NULL,
   `password` INT DEFAULT NULL,
-  PRIMARY KEY (`id`)
+  PRIMARY KEY (`id`),
+  KEY `session_idx` (`session`)
 );
 
 CREATE TABLE IF NOT EXISTS `usernames` (
@@ -48,7 +50,8 @@ CREATE TABLE IF NOT EXISTS `variables` (
   `session` VARCHAR(32) NOT NULL,
   `var` INT DEFAULT NULL,
   `val` INT DEFAULT NULL,
-  PRIMARY KEY (`id`)
+  PRIMARY KEY (`id`),
+  KEY `session_idx` (`session`)
 );
 
 CREATE TABLE IF NOT EXISTS `vars` (

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/pgsqlpot/data/docs/postgres/postgres.sql

@@ -13,12 +13,16 @@ CREATE TABLE IF NOT EXISTS connections (
 CREATE INDEX IF NOT EXISTS time_idx ON connections (time_stamp);
 CREATE INDEX IF NOT EXISTS ip_idx ON connections (ip);
 CREATE INDEX IF NOT EXISTS ip2_idx ON connections (time_stamp, ip);
+CREATE INDEX IF NOT EXISTS session_idx ON connections(sess_no);
+
 
 CREATE TABLE IF NOT EXISTS operations (
   id SERIAL PRIMARY KEY,
   op_name VARCHAR(63) NOT NULL
 );
 
+CREATE UNIQUE INDEX op_name_idx ON operations (op_name);
+
 CREATE TABLE IF NOT EXISTS credentials (
   id SERIAL PRIMARY KEY,
   sess_no VARCHAR(32) NOT NULL,
@@ -26,16 +30,22 @@ CREATE TABLE IF NOT EXISTS credentials (
   passwd SMALLINT DEFAULT NULL
 );
 
+CREATE INDEX IF NOT EXISTS sess_no_idx ON credentials(sess_no);
+
 CREATE TABLE IF NOT EXISTS usernames (
   id SERIAL PRIMARY KEY,
   username VARCHAR(255) DEFAULT NULL
 );
 
+CREATE UNIQUE INDEX username_idx ON usernames (username);
+
 CREATE TABLE IF NOT EXISTS passwords (
   id SERIAL PRIMARY KEY,
   passwd VARCHAR(255) DEFAULT NULL
 );
 
+CREATE UNIQUE INDEX passwd_idx ON passwords (passwd);
+
 CREATE TABLE IF NOT EXISTS variables (
   id SERIAL PRIMARY KEY,
   sess_no VARCHAR(32) NOT NULL,
@@ -43,16 +53,22 @@ CREATE TABLE IF NOT EXISTS variables (
   val SMALLINT DEFAULT NULL
 );
 
+CREATE INDEX IF NOT EXISTS var_sess_no_idx ON variables(sess_no);
+
 CREATE TABLE IF NOT EXISTS vars (
   id SERIAL PRIMARY KEY,
   var_name VARCHAR(255) DEFAULT NULL
 );
 
+CREATE UNIQUE INDEX var_name_idx ON vars (var_name);
+
 CREATE TABLE IF NOT EXISTS var_values (
   id SERIAL PRIMARY KEY,
   var_value VARCHAR(255) DEFAULT NULL
 );
 
+CREATE UNIQUE INDEX var_value_idx ON var_values (var_value);
+
 CREATE TABLE IF NOT EXISTS sensors (
   id SERIAL PRIMARY KEY,
   sname VARCHAR(255) DEFAULT NULL

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/pgsqlpot/data/docs/sqlite3/sqlite3.sql

@@ -13,6 +13,7 @@ CREATE TABLE IF NOT EXISTS `connections` (
 CREATE INDEX IF NOT EXISTS `time_idx` ON `connections` (`timestamp`);
 CREATE INDEX IF NOT EXISTS `ip_idx` ON `connections` (`ip`);
 CREATE INDEX IF NOT EXISTS `ip2_idx` ON `connections` (`timestamp`, `ip`);
+CREATE INDEX IF NOT EXISTS `session_idx` ON `connections` (`session`);
 
 CREATE TABLE IF NOT EXISTS `operations` (
   `id` INTEGER PRIMARY KEY,
@@ -26,6 +27,8 @@ CREATE TABLE IF NOT EXISTS `credentials` (
   `password` INT(4) DEFAULT NULL
 );
 
+CREATE INDEX IF NOT EXISTS `session_idx` ON `credentials` (`session`);
+
 CREATE TABLE IF NOT EXISTS `usernames` (
   `id` INTEGER PRIMARY KEY,
   `username` VARCHAR(255) DEFAULT NULL UNIQUE
@@ -43,6 +46,8 @@ CREATE TABLE IF NOT EXISTS `variables` (
   `val` INT(4) DEFAULT NULL
 );
 
+CREATE INDEX IF NOT EXISTS `session_idx` ON `variables` (`session`);
+
 CREATE TABLE IF NOT EXISTS `vars` (
   `id` INTEGER PRIMARY KEY,
   `var_name` VARCHAR(20) NOT NULL UNIQUE

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2}/pgsqlpot/data/etc/honeypot.cfg.base

@@ -26,7 +26,7 @@
 # Log files are named <log_filename>.YYYY-MM-DD in that directory
 #
 # (default: log)
-log_path = log
+#log_path = log
 
 # Log file name
 #
@@ -55,8 +55,8 @@ log_path = log
 
 # A comma-separated list of networks, connection from whose IPs won't be logged
 #
-# (default: none)
-#blacklist=127.0.0.1,192.168.0.0/16
+# (default: 127.0.0.1,192.168.0.0/16)
+#blacklist = 127.0.0.1,192.168.0.0/16
 
 
 # ============================================================================
@@ -84,7 +84,7 @@ log_path = log
 #geoip_citydb = data/GeoLite2-City.mmdb
 #geoip_asndb = data/GeoLite2-ASN.mmdb
 
-# Datadog output module
+# Datadog logging module
 # sends JSON directly to Datadog
 # mandatory field: api_key
 # optional fields (fallback configured in module): ddsource, ddtags, service
@@ -104,7 +104,7 @@ log_path = log
 # Host from which the logs are connected, default - current hostname
 #hostname = pandora.nlcv.bas.bg
 
-# Send output to a Discord webhook
+# Discord logging module
 #
 #[output_discord]
 #enabled = false
@@ -140,9 +140,9 @@ log_path = log
 #username = pgsqlpot
 #password = secret
 #
-# TLS encryption. Communications between the client (pgsqlpot) 
+# TLS encryption. Communications between the client (pgsqlpot)
 # and the ES server should naturally be protected by encryption
-# if requests are authenticated (to prevent from man-in-the-middle 
+# if requests are authenticated (to prevent from man-in-the-middle
 # attacks). The following options are then paramount
 # if username and password are provided.
 #
@@ -210,7 +210,7 @@ log_path = log
 #geoip_asndb = data/GeoLite2-ASN.mmdb
 
 # MySQL logging module
-# Database structure for this module is supplied in docs/sql/mysql.sql
+# Database structure for this module is supplied in docs/mysql/mysql.sql
 #
 # MySQL logging requires extra software: sudo apt-get install libmysqlclient-dev
 # MySQL logging requires an extra Python module: pip install mysql-python
@@ -223,6 +223,16 @@ log_path = log
 #password = secret
 #port = 3306
 #debug = false
+# Connection timeout (default: 10)
+#connect_timeout = 10
+# Read timeout (default: 30)
+#read_timeout = 30
+# Write timeout (default: 30)
+#write_timeout = 30
+# Max threads (default: 5)
+#cp_max = 5
+# Log a warning if the queue length exceeds this value (default: 100)
+#pending_warn_threshold = 100
 # Whether to store geolocation data in the database
 #geoip = true
 # Location of the databases used for geolocation
@@ -277,7 +287,7 @@ log_path = log
 # Can be one of [lpush, rpush, publish]. Defaults to lpush
 #send_method = lpush
 
-# Rethinkdb output module
+# Rethinkdb logging module
 #
 #[output_rethinkdblog]
 #enabled = false
@@ -308,20 +318,20 @@ log_path = log
 # SQLite3 logging module
 #
 # Logging to SQLite3 database. To init the database, use the script
-# docs/sql/sqlite3.sql:
-#     sqlite3 <db_file> < docs/sql/sqlite3.sql
+# docs/sqlite3/sqlite3.sql:
+#     sqlite3 log/pgsqlpot.db < docs/sqlite3/sqlite3.sql
 #
 #[output_sqlite]
 #enabled = false
 #debug = false
-#db_file = data/pgsqlpot.db
+#db_file = log/pgsqlpot.db
 # Whether to store geolocation data in the database
 #geoip = true
 # Location of the databases used for geolocation
 #geoip_citydb = data/GeoLite2-City.mmdb
 #geoip_asndb = data/GeoLite2-ASN.mmdb
 
-# Local Syslog output module
+# Local Syslog logging module
 #
 # This sends log messages to the local syslog daemon.
 #
@@ -333,7 +343,7 @@ log_path = log
 # default: USER
 #facility = USER
 
-# Send message using Telegram bot
+# Telegram logging module
 # 1. Create a bot following https://core.telegram.org/bots#6-botfather to get token.
 # 2. Send message to your bot, then use https://api.telegram.org/bot{bot_token}/getUpdates to find chat_id.
 #
@@ -348,7 +358,7 @@ log_path = log
 # Delay between messages (for rate limiting)
 #delay = 2.0
 
-# Text output
+# Text logging module
 # This writes audit log entries to a text file
 #
 #[output_textlog]
@@ -393,7 +403,7 @@ log_path = log
 #database_name = pgsqlpot
 #retention_policy_duration = 30d
 
-# Oracle Cloud custom logs output module
+# Oracle Cloud custom logs logging module
 # sends JSON directly to Oracle Cloud custom logs
 # mandatory field: authtype, log_ocid
 # optional fields (to be set if user_principals is selected as authtype): user_ocid, fingerprint, tenancy_ocid, region, keyfile
@@ -413,7 +423,7 @@ log_path = log
 #region = eu-stockholm-1
 #keyfile = /home/xx/key.pem
 
-# Splunk HTTP Event Collector (HEC) output module
+# Splunk HTTP Event Collector (HEC) logging module
 # sends JSON directly to Splunk over HTTP or HTTPS
 # Use 'https' if your HEC is encrypted, else 'http'
 # mandatory fields: url, token

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2/pgsqlpot}/honeypot.py

@@ -23,7 +23,7 @@ from twisted.internet.reactor import listenTCP, run
 from twisted.python.log import msg
 
 
-__VERSION__ = '2.0.1'
+__VERSION__ = '2.0.2'
 __description__ = 'A PostgreSQL Honeypot'
 __license__ = 'GPLv3'
 __uri__ = 'https://gitlab.com/bontchev/pgsqlpot'

{pgsqlpot-2.0.1 → pgsqlpot-2.0.2/pgsqlpot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgsqlpot
-Version: 2.0.1
+Version: 2.0.2
 Summary: A PostgeSQL Honeypot
 Home-page: https://gitlab.com/bontchev/pgsqlpot
 Author: Vesselin Bontchev