# Module `src.onionrblocks.onionrblacklist`

Onionr - Private P2P Communication.

Handle maintenance of a blacklist database, for blocks and peers

Expand source code

    """Onionr - Private P2P Communication.

    Handle maintenance of a blacklist database, for blocks and peers
    """
    import sqlite3
    import os

    from onionrplugins.onionrevents import event
    import onionrcrypto
    from onionrutils import epoch, bytesconverter
    from coredb import dbfiles
    """
        This program 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.

        This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
    """

    class OnionrBlackList:
        def __init__(self):
            self.blacklistDB = dbfiles.blacklist_db

            if not os.path.exists(dbfiles.blacklist_db):
                self.generateDB()
            return

        def inBlacklist(self, data):
            hashed = bytesconverter.bytes_to_str(onionrcrypto.hashers.sha3_hash(data))
            retData = False

            if not hashed.isalnum():
                raise Exception("Hashed data is not alpha numeric")
            if len(hashed) > 64:
                raise Exception("Hashed data is too large")

            for i in self._dbExecute("SELECT * FROM blacklist WHERE hash = ?", (hashed,)):
                retData = True # this only executes if an entry is present by that hash
                break

            return retData

        def _dbExecute(self, toExec, params = ()):
            conn = sqlite3.connect(self.blacklistDB)
            c = conn.cursor()
            retData = c.execute(toExec, params)
            conn.commit()
            return retData

        def deleteBeforeDate(self, date):
            # TODO, delete blacklist entries before date
            return

        def deleteExpired(self, dataType=0):
            """Delete expired entries"""
            deleteList = []
            curTime = epoch.get_epoch()

            try:
                int(dataType)
            except AttributeError:
                raise TypeError("dataType must be int")

            for i in self._dbExecute('SELECT * FROM blacklist WHERE dataType = ?', (dataType,)):
                if i[1] == dataType:
                    if (curTime - i[2]) >= i[3]:
                        deleteList.append(i[0])

            for thing in deleteList:
                self._dbExecute("DELETE FROM blacklist WHERE hash = ?", (thing,))

        def generateDB(self):
            return

        def clearDB(self):
            self._dbExecute("""DELETE FROM blacklist;""")

        def getList(self):
            data = self._dbExecute('SELECT * FROM blacklist')
            myList = []
            for i in data:
                myList.append(i[0])
            return myList

        def addToDB(self, data, dataType=0, expire=0):
            """Add to the blacklist. Intended to be block hash, block data, peers, or transport addresses
            0=block
            1=peer
            2=pubkey
            """

            # we hash the data so we can remove data entirely from our node's disk
            hashed = bytesconverter.bytes_to_str(onionrcrypto.hashers.sha3_hash(data))

            event('blacklist_add', data={'data': data, 'hash': hashed})

            if len(hashed) > 64:
                raise Exception("Hashed data is too large")

            if not hashed.isalnum():
                raise Exception("Hashed data is not alpha numeric")
            try:
                int(dataType)
            except ValueError:
                raise Exception("dataType is not int")
            try:
                int(expire)
            except ValueError:
                raise Exception("expire is not int")
            if self.inBlacklist(hashed):
                return
            insert = (hashed,)
            blacklistDate = epoch.get_epoch()
            try:
                self._dbExecute("INSERT INTO blacklist (hash, dataType, blacklistDate, expire) VALUES(?, ?, ?, ?);", (str(hashed), dataType, blacklistDate, expire))
            except sqlite3.IntegrityError:
                pass

## Classes

`class OnionrBlackList`
  Expand source code

      class OnionrBlackList:
          def __init__(self):
              self.blacklistDB = dbfiles.blacklist_db

              if not os.path.exists(dbfiles.blacklist_db):
                  self.generateDB()
              return

          def inBlacklist(self, data):
              hashed = bytesconverter.bytes_to_str(onionrcrypto.hashers.sha3_hash(data))
              retData = False

              if not hashed.isalnum():
                  raise Exception("Hashed data is not alpha numeric")
              if len(hashed) > 64:
                  raise Exception("Hashed data is too large")

              for i in self._dbExecute("SELECT * FROM blacklist WHERE hash = ?", (hashed,)):
                  retData = True # this only executes if an entry is present by that hash
                  break

              return retData

          def _dbExecute(self, toExec, params = ()):
              conn = sqlite3.connect(self.blacklistDB)
              c = conn.cursor()
              retData = c.execute(toExec, params)
              conn.commit()
              return retData

          def deleteBeforeDate(self, date):
              # TODO, delete blacklist entries before date
              return

          def deleteExpired(self, dataType=0):
              """Delete expired entries"""
              deleteList = []
              curTime = epoch.get_epoch()

              try:
                  int(dataType)
              except AttributeError:
                  raise TypeError("dataType must be int")

              for i in self._dbExecute('SELECT * FROM blacklist WHERE dataType = ?', (dataType,)):
                  if i[1] == dataType:
                      if (curTime - i[2]) >= i[3]:
                          deleteList.append(i[0])

              for thing in deleteList:
                  self._dbExecute("DELETE FROM blacklist WHERE hash = ?", (thing,))

          def generateDB(self):
              return

          def clearDB(self):
              self._dbExecute("""DELETE FROM blacklist;""")

          def getList(self):
              data = self._dbExecute('SELECT * FROM blacklist')
              myList = []
              for i in data:
                  myList.append(i[0])
              return myList

          def addToDB(self, data, dataType=0, expire=0):
              """Add to the blacklist. Intended to be block hash, block data, peers, or transport addresses
              0=block
              1=peer
              2=pubkey
              """

              # we hash the data so we can remove data entirely from our node's disk
              hashed = bytesconverter.bytes_to_str(onionrcrypto.hashers.sha3_hash(data))

              event('blacklist_add', data={'data': data, 'hash': hashed})

              if len(hashed) > 64:
                  raise Exception("Hashed data is too large")

              if not hashed.isalnum():
                  raise Exception("Hashed data is not alpha numeric")
              try:
                  int(dataType)
              except ValueError:
                  raise Exception("dataType is not int")
              try:
                  int(expire)
              except ValueError:
                  raise Exception("expire is not int")
              if self.inBlacklist(hashed):
                  return
              insert = (hashed,)
              blacklistDate = epoch.get_epoch()
              try:
                  self._dbExecute("INSERT INTO blacklist (hash, dataType, blacklistDate, expire) VALUES(?, ?, ?, ?);", (str(hashed), dataType, blacklistDate, expire))
              except sqlite3.IntegrityError:
                  pass

  ### Methods

  `def addToDB(self, data, dataType=0, expire=0)`

    Add to the blacklist. Intended to be block hash, block data, peers, or transport addresses 0=block 1=peer 2=pubkey

    Expand source code

        def addToDB(self, data, dataType=0, expire=0):
            """Add to the blacklist. Intended to be block hash, block data, peers, or transport addresses
            0=block
            1=peer
            2=pubkey
            """

            # we hash the data so we can remove data entirely from our node's disk
            hashed = bytesconverter.bytes_to_str(onionrcrypto.hashers.sha3_hash(data))

            event('blacklist_add', data={'data': data, 'hash': hashed})

            if len(hashed) > 64:
                raise Exception("Hashed data is too large")

            if not hashed.isalnum():
                raise Exception("Hashed data is not alpha numeric")
            try:
                int(dataType)
            except ValueError:
                raise Exception("dataType is not int")
            try:
                int(expire)
            except ValueError:
                raise Exception("expire is not int")
            if self.inBlacklist(hashed):
                return
            insert = (hashed,)
            blacklistDate = epoch.get_epoch()
            try:
                self._dbExecute("INSERT INTO blacklist (hash, dataType, blacklistDate, expire) VALUES(?, ?, ?, ?);", (str(hashed), dataType, blacklistDate, expire))
            except sqlite3.IntegrityError:
                pass

  `def clearDB(self)`
    Expand source code

        def clearDB(self):
            self._dbExecute("""DELETE FROM blacklist;""")

  `def deleteBeforeDate(self, date)`
    Expand source code

        def deleteBeforeDate(self, date):
            # TODO, delete blacklist entries before date
            return

  `def deleteExpired(self, dataType=0)`

    Delete expired entries

    Expand source code

        def deleteExpired(self, dataType=0):
            """Delete expired entries"""
            deleteList = []
            curTime = epoch.get_epoch()

            try:
                int(dataType)
            except AttributeError:
                raise TypeError("dataType must be int")

            for i in self._dbExecute('SELECT * FROM blacklist WHERE dataType = ?', (dataType,)):
                if i[1] == dataType:
                    if (curTime - i[2]) >= i[3]:
                        deleteList.append(i[0])

            for thing in deleteList:
                self._dbExecute("DELETE FROM blacklist WHERE hash = ?", (thing,))

  `def generateDB(self)`
    Expand source code

        def generateDB(self):
            return

  `def getList(self)`
    Expand source code

        def getList(self):
            data = self._dbExecute('SELECT * FROM blacklist')
            myList = []
            for i in data:
                myList.append(i[0])
            return myList

  `def inBlacklist(self, data)`
    Expand source code

        def inBlacklist(self, data):
            hashed = bytesconverter.bytes_to_str(onionrcrypto.hashers.sha3_hash(data))
            retData = False

            if not hashed.isalnum():
                raise Exception("Hashed data is not alpha numeric")
            if len(hashed) > 64:
                raise Exception("Hashed data is too large")

            for i in self._dbExecute("SELECT * FROM blacklist WHERE hash = ?", (hashed,)):
                retData = True # this only executes if an entry is present by that hash
                break

            return retData