daemon.py

   1 #!/usr/bin/python3
   2 # -*- coding: utf-8 -*-
   3
   4 # Fedi API Block - An aggregator for fetching blocking data from fediverse nodes
   5 # Copyright (C) 2023 Free Software Foundation
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU Affero General Public License as published
   9 # by the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU Affero General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Affero General Public License
  18 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19
  20 import re
  21
  22 from datetime import datetime
  23 from email.utils import format_datetime
  24 from pathlib import Path
  25
  26 import fastapi
  27 from fastapi import Request, HTTPException, Query
  28 from fastapi.responses import JSONResponse
  29 from fastapi.responses import PlainTextResponse
  30 from fastapi.staticfiles import StaticFiles
  31 from fastapi.templating import Jinja2Templates
  32
  33 import uvicorn
  34 import requests
  35
  36 from fba import database
  37 from fba import utils
  38
  39 from fba.helpers import config
  40 from fba.helpers import json as json_helper
  41 from fba.helpers import tidyup
  42
  43 from fba.models import blocks
  44
  45 router = fastapi.FastAPI(docs_url=config.get("base_url") + "/docs", redoc_url=config.get("base_url") + "/redoc")
  46 router.mount(
  47     "/static",
  48     StaticFiles(directory=Path(__file__).parent.absolute() / "static"),
  49     name="static",
  50 )
  51
  52 templates = Jinja2Templates(directory="templates")
  53
  54 @router.get(config.get("base_url") + "/api/info.json", response_class=JSONResponse)
  55 def api_info():
  56     database.cursor.execute("SELECT (SELECT COUNT(domain) FROM instances), (SELECT COUNT(domain) FROM instances WHERE software IN ('pleroma', 'mastodon', 'lemmy', 'friendica', 'misskey', 'peertube', 'takahe')), (SELECT COUNT(blocker) FROM blocks), (SELECT COUNT(domain) FROM instances WHERE last_error_details IS NOT NULL)")
  57     row = database.cursor.fetchone()
  58
  59     return {
  60         "known_instances"    : row[0],
  61         "supported_instances": row[1],
  62         "blocks_recorded"    : row[2],
  63         "erroneous_instances": row[3],
  64     }
  65
  66 @router.get(config.get("base_url") + "/api/scoreboard.json", response_class=JSONResponse)
  67 def api_scoreboard(mode: str, amount: int):
  68     if amount > config.get("api_limit"):
  69         raise HTTPException(status_code=400, detail="Too many results")
  70
  71     if mode == "blocked":
  72         database.cursor.execute("SELECT blocked, COUNT(blocked) AS score FROM blocks GROUP BY blocked ORDER BY score DESC LIMIT ?", [amount])
  73     elif mode == "blocker":
  74         database.cursor.execute("SELECT blocker, COUNT(blocker) AS score FROM blocks GROUP BY blocker ORDER BY score DESC LIMIT ?", [amount])
  75     elif mode == "reference":
  76         database.cursor.execute("SELECT origin, COUNT(domain) AS score FROM instances WHERE origin IS NOT NULL GROUP BY origin ORDER BY score DESC LIMIT ?", [amount])
  77     elif mode == "software":
  78         database.cursor.execute("SELECT software, COUNT(domain) AS score FROM instances WHERE software IS NOT NULL GROUP BY software ORDER BY score DESC, software ASC LIMIT ?", [amount])
  79     elif mode == "command":
  80         database.cursor.execute("SELECT command, COUNT(domain) AS score FROM instances WHERE command IS NOT NULL GROUP BY command ORDER BY score DESC, command ASC LIMIT ?", [amount])
  81     elif mode == "error_code":
  82         database.cursor.execute("SELECT last_status_code, COUNT(domain) AS score FROM instances WHERE last_status_code IS NOT NULL AND last_status_code != '200' GROUP BY last_status_code ORDER BY score DESC LIMIT ?", [amount])
  83     elif mode == "detection_mode":
  84         database.cursor.execute("SELECT detection_mode, COUNT(domain) AS cnt FROM instances GROUP BY detection_mode ORDER BY cnt DESC LIMIT ?", [amount])
  85     elif mode == "avg_peers":
  86         database.cursor.execute("SELECT software, AVG(total_peers) AS average FROM instances WHERE software IS NOT NULL GROUP BY software HAVING average>0 ORDER BY average DESC LIMIT ?", [amount])
  87     elif mode == "obfuscator":
  88         database.cursor.execute("SELECT software, COUNT(domain) AS cnt FROM instances WHERE has_obfuscation = 1 GROUP BY software ORDER BY cnt DESC LIMIT ?", [amount])
  89     elif mode == "obfuscation":
  90         database.cursor.execute("SELECT has_obfuscation, COUNT(domain) AS cnt FROM instances WHERE software IN ('pleroma', 'mastodon', 'friendica') GROUP BY has_obfuscation ORDER BY cnt DESC LIMIT ?", [amount])
  91     elif mode == "block_level":
  92         database.cursor.execute("SELECT block_level, COUNT(rowid) AS cnt FROM blocks GROUP BY block_level ORDER BY cnt DESC LIMIT ?", [amount])
  93     else:
  94         raise HTTPException(status_code=400, detail="No filter specified")
  95
  96     scores = list()
  97
  98     for domain, score in database.cursor.fetchall():
  99         scores.append({
 100             "domain": domain,
 101             "score" : round(score)
 102         })
 103
 104     return scores
 105
 106 @router.get(config.get("base_url") + "/api/index.json", response_class=JSONResponse)
 107 def api_index(request: Request, mode: str, value: str, amount: int):
 108     if mode is None or value is None or amount is None:
 109         raise HTTPException(status_code=500, detail="No filter specified")
 110     elif amount > config.get("api_limit"):
 111         raise HTTPException(status_code=500, detail=f"amount={amount} is to big")
 112
 113     domain = wildchar = punycode = reason = None
 114
 115     if mode == "block_level":
 116         database.cursor.execute(
 117             "SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE block_level = ? LIMIT ?", [value, amount]
 118         )
 119     elif mode in ["domain", "reverse"]:
 120         domain = tidyup.domain(value)
 121         if not utils.is_domain_wanted(domain):
 122             raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 123
 124         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 125         punycode = domain.encode("idna").decode("utf-8")
 126     elif mode == "reason":
 127         reason = re.sub("(%|_)", "", tidyup.reason(value))
 128         if len(reason) < 3:
 129             raise HTTPException(status_code=400, detail="Keyword is shorter than three characters")
 130
 131     if mode == "domain":
 132         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 133 FROM blocks \
 134 WHERE blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? ORDER BY first_seen ASC LIMIT ?",
 135             [
 136                 domain,
 137                 "*." + domain,
 138                 wildchar,
 139                 utils.get_hash(domain),
 140                 punycode,
 141                 "*." + punycode,
 142                 amount
 143             ]
 144         )
 145     elif mode == "reverse":
 146         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 147 FROM blocks \
 148 WHERE blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? \
 149 ORDER BY first_seen ASC \
 150 LIMIT ?", [
 151             domain,
 152             "*." + domain,
 153             wildchar,
 154             utils.get_hash(domain),
 155             punycode,
 156             "*." + punycode,
 157             amount
 158         ])
 159     elif mode == "reason":
 160         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 161 FROM blocks \
 162 WHERE reason LIKE ? AND reason != '' \
 163 ORDER BY first_seen ASC \
 164 LIMIT ?", [
 165             "%" + reason + "%",
 166             amount
 167         ])
 168
 169     blocklist = database.cursor.fetchall()
 170
 171     result = {}
 172     for blocker, blocked, block_level, reason, first_seen, last_seen in blocklist:
 173         if reason is not None and reason != "":
 174             reason = reason.replace(",", " ").replace("  ", " ")
 175
 176         entry = {
 177             "blocker"   : blocker,
 178             "blocked"   : blocked,
 179             "reason"    : reason,
 180             "first_seen": first_seen,
 181             "last_seen" : last_seen
 182         }
 183
 184         if block_level in result:
 185             result[block_level].append(entry)
 186         else:
 187             result[block_level] = [entry]
 188
 189     return result
 190
 191 @router.get(config.get("base_url") + "/api/mutual.json", response_class=JSONResponse)
 192 def api_mutual(domains: list[str] = Query()):
 193     """Return 200 if federation is open between the two, 4xx otherwise"""
 194     database.cursor.execute(
 195         "SELECT block_level FROM blocks " \
 196         "WHERE ((blocker = :a OR blocker = :b) AND (blocked = :b OR blocked = :a OR blocked = :aw OR blocked = :bw)) " \
 197         "AND block_level = 'reject' " \
 198         "LIMIT 1",
 199         {
 200             "a" : domains[0],
 201             "b" : domains[1],
 202             "aw": "*." + domains[0],
 203             "bw": "*." + domains[1],
 204         },
 205     )
 206     response = database.cursor.fetchone()
 207
 208     if response is not None:
 209         # Blocks found
 210         return JSONResponse(status_code=418, content={})
 211
 212     # No known blocks
 213     return JSONResponse(status_code=200, content={})
 214
 215 @router.get(config.get("base_url") + "/scoreboard")
 216 def scoreboard(request: Request, mode: str, amount: int):
 217     response = None
 218
 219     if mode == "blocker" and amount > 0:
 220         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocker&amount={amount}")
 221     elif mode == "blocked" and amount > 0:
 222         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocked&amount={amount}")
 223     elif mode == "reference" and amount > 0:
 224         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=reference&amount={amount}")
 225     elif mode == "software" and amount > 0:
 226         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=software&amount={amount}")
 227     elif mode == "command" and amount > 0:
 228         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=command&amount={amount}")
 229     elif mode == "error_code" and amount > 0:
 230         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=error_code&amount={amount}")
 231     elif mode == "detection_mode" and amount > 0:
 232         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=detection_mode&amount={amount}")
 233     elif mode == "avg_peers" and amount > 0:
 234         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=avg_peers&amount={amount}")
 235     elif mode == "obfuscator" and amount > 0:
 236         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=obfuscator&amount={amount}")
 237     elif mode == "obfuscation" and amount > 0:
 238         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=obfuscation&amount={amount}")
 239     elif mode == "block_level" and amount > 0:
 240         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=block_level&amount={amount}")
 241     else:
 242         raise HTTPException(status_code=400, detail="No filter specified")
 243
 244     if response is None:
 245         raise HTTPException(status_code=500, detail="Could not determine scores")
 246     elif not response.ok:
 247         raise HTTPException(status_code=response.status_code, detail=response.text)
 248
 249     return templates.TemplateResponse("views/scoreboard.html", {
 250         "base_url"  : config.get("base_url"),
 251         "slogan"    : config.get("slogan"),
 252         "theme"     : config.get("theme"),
 253         "request"   : request,
 254         "scoreboard": True,
 255         "mode"      : mode,
 256         "amount"    : amount,
 257         "scores"    : json_helper.from_response(response)
 258     })
 259
 260 @router.get(config.get("base_url") + "/")
 261 def index(request: Request):
 262     # Get info
 263     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 264
 265     if not response.ok:
 266         raise HTTPException(status_code=response.status_code, detail=response.text)
 267
 268     return templates.TemplateResponse("views/index.html", {
 269         "request": request,
 270         "theme"  : config.get("theme"),
 271         "info"   : response.json(),
 272         "slogan" : config.get("slogan"),
 273     })
 274
 275 @router.get(config.get("base_url") + "/top")
 276 def top(request: Request, mode: str, value: str, amount: int = config.get("api_limit")):
 277     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 278
 279     if not response.ok:
 280         raise HTTPException(status_code=response.status_code, detail=response.text)
 281     elif mode == "" or value == "" or amount == 0:
 282         raise HTTPException(status_code=500, detail="Parameter mode, value and amount must always be set")
 283     elif amount > config.get("api_limit"):
 284         raise HTTPException(status_code=500, detail=f"amount='{amount}' is to big")
 285
 286     info = response.json()
 287     response = None
 288     blocklist = list()
 289
 290     if mode == "block_level" and not blocks.is_valid_level(value):
 291         raise HTTPException(status_code=500, detail="Invalid block level provided")
 292     elif mode in ["domain", "reverse"] and not utils.is_domain_wanted(value):
 293         raise HTTPException(status_code=500, detail="Invalid or blocked domain specified")
 294
 295     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/index.json?mode={mode}&value={value}&amount={amount}")
 296
 297     if response is not None:
 298         blocklist = response.json()
 299
 300     found = 0
 301     for block_level in blocklist:
 302         for block in blocklist[block_level]:
 303             block["first_seen"] = datetime.utcfromtimestamp(block["first_seen"]).strftime(config.get("timestamp_format"))
 304             block["last_seen"]  = datetime.utcfromtimestamp(block["last_seen"]).strftime(config.get("timestamp_format"))
 305             found = found + 1
 306
 307     return templates.TemplateResponse("views/top.html", {
 308         "request"  : request,
 309         "mode"     : mode if response is not None else None,
 310         "value"    : value if response is not None else None,
 311         "amount"   : amount if response is not None else None,
 312         "found"    : found,
 313         "blocklist": blocklist,
 314         "info"     : info,
 315         "theme"    : config.get("theme"),
 316     })
 317
 318 @router.get(config.get("base_url") + "/infos")
 319 def rss(request: Request, domain: str):
 320     # Tidy up domain name
 321     domain = tidyup.domain(domain)
 322
 323     if not utils.is_domain_wanted(domain):
 324         raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 325
 326     # Fetch domain data
 327     database.cursor.execute("SELECT * FROM instances WHERE domain = ? LIMIT 1", [domain])
 328     domain_data = database.cursor.fetchone()
 329
 330     if domain_data is None:
 331         raise HTTPException(status_code=404, detail=f"domain='{domain}' not found")
 332
 333     # Format timestamps
 334     format = config.get("timestamp_format")
 335     instance = dict()
 336     for key in domain_data.keys():
 337         if key in ["last_nodeinfo", "last_blocked", "first_seen", "last_updated", "last_instance_fetch"]:
 338             # Timestamps
 339             instance[key] = datetime.utcfromtimestamp(domain_data[key]).strftime(format) if isinstance(domain_data[key], float) else "-"
 340         else:
 341             # Generic
 342             instance[key] = domain_data[key]
 343
 344     print(domain_data.keys())
 345     return templates.TemplateResponse("views/infos.html", {
 346         "request" : request,
 347         "domain"  : domain,
 348         "instance": instance,
 349         "theme"   : config.get("theme"),
 350         "slogan"  : config.get("slogan"),
 351     })
 352
 353 @router.get(config.get("base_url") + "/rss")
 354 def rss(request: Request, domain: str = None):
 355     if domain is not None:
 356         domain = tidyup.domain(domain)
 357
 358         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 359         punycode = domain.encode("idna").decode("utf-8")
 360
 361         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? ORDER BY first_seen DESC LIMIT ?", [
 362             domain,
 363             "*." + domain, wildchar,
 364             utils.get_hash(domain),
 365             punycode,
 366             "*." + punycode,
 367             config.get("rss_limit")
 368         ])
 369     else:
 370         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks ORDER BY first_seen DESC LIMIT ?", [config.get("rss_limit")])
 371
 372     result = database.cursor.fetchall()
 373     blocklist = []
 374
 375     for row in result:
 376         blocklist.append({
 377             "blocker"    : row[0],
 378             "blocked"    : row[1],
 379             "block_level": row[2],
 380             "reason"     : "Provided reason: '" + row[3] + "'" if row[3] is not None and row[3] != "" else "No reason provided.",
 381             "first_seen" : format_datetime(datetime.fromtimestamp(row[4])),
 382             "last_seen"  : format_datetime(datetime.fromtimestamp(row[5])),
 383         })
 384
 385     return templates.TemplateResponse("views/rss.xml", {
 386         "request"  : request,
 387         "timestamp": format_datetime(datetime.now()),
 388         "domain"   : domain,
 389         "hostname" : config.get("hostname"),
 390         "blocks"   : blocklist
 391     }, headers={
 392         "Content-Type": "routerlication/rss+xml"
 393     })
 394
 395 @router.get(config.get("base_url") + "/robots.txt", response_class=PlainTextResponse)
 396 def robots(request: Request):
 397     return templates.TemplateResponse("views/robots.txt", {
 398         "request" : request,
 399         "base_url": config.get("base_url")
 400     })
 401
 402 if __name__ == "__main__":
 403     uvicorn.run("daemon:router", host=config.get("host"), port=config.get("port"), log_level=config.get("log_level"))