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 requests
  34 import uvicorn
  35
  36 from fba import database
  37 from fba import utils
  38
  39 from fba.helpers import blacklist
  40 from fba.helpers import config
  41 from fba.helpers import domain as domain_helper
  42 from fba.helpers import json as json_helper
  43 from fba.helpers import tidyup
  44
  45 from fba.models import blocks
  46 from fba.models import instances
  47
  48 router = fastapi.FastAPI(docs_url=config.get("base_url") + "/docs", redoc_url=config.get("base_url") + "/redoc")
  49 router.mount(
  50     "/static",
  51     StaticFiles(directory=Path(__file__).parent.absolute() / "static"),
  52     name="static",
  53 )
  54
  55 templates = Jinja2Templates(directory="templates")
  56
  57 @router.get(config.get("base_url") + "/api/info.json", response_class=JSONResponse)
  58 def api_info():
  59     database.cursor.execute("SELECT (SELECT COUNT(domain) FROM instances), (SELECT COUNT(domain) FROM instances WHERE software IN ('pleroma', 'mastodon', 'lemmy', 'friendica', 'misskey', 'peertube', 'takahe', 'gotosocial', 'brighteon', 'wildebeest', 'bookwyrm', 'mitra', 'areionskey', 'mammuthus', 'neodb')), (SELECT COUNT(blocker) FROM blocks), (SELECT COUNT(domain) FROM instances WHERE last_error_details IS NOT NULL)")
  60     row = database.cursor.fetchone()
  61
  62     return JSONResponse(status_code=200, content={
  63         "known_instances"    : row[0],
  64         "supported_instances": row[1],
  65         "blocks_recorded"    : row[2],
  66         "erroneous_instances": row[3],
  67     })
  68
  69 @router.get(config.get("base_url") + "/api/scoreboard.json", response_class=JSONResponse)
  70 def api_scoreboard(mode: str, amount: int):
  71     if amount > config.get("api_limit"):
  72         raise HTTPException(status_code=400, detail="Too many results")
  73
  74     if mode == "blocked":
  75         database.cursor.execute("SELECT blocked, COUNT(blocked) AS score FROM blocks GROUP BY blocked ORDER BY score DESC LIMIT ?", [amount])
  76     elif mode == "blocker":
  77         database.cursor.execute("SELECT blocker, COUNT(blocker) AS score FROM blocks GROUP BY blocker ORDER BY score DESC LIMIT ?", [amount])
  78     elif mode == "reference":
  79         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])
  80     elif mode == "original_software":
  81         database.cursor.execute("SELECT original_software, COUNT(domain) AS score FROM instances WHERE original_software IS NOT NULL GROUP BY original_software ORDER BY score DESC, original_software ASC LIMIT ?", [amount])
  82     elif mode == "software":
  83         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])
  84     elif mode == "command":
  85         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])
  86     elif mode == "error_code":
  87         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])
  88     elif mode == "detection_mode":
  89         database.cursor.execute("SELECT detection_mode, COUNT(domain) AS cnt FROM instances GROUP BY detection_mode ORDER BY cnt DESC LIMIT ?", [amount])
  90     elif mode == "avg_peers":
  91         database.cursor.execute("SELECT software, AVG(total_peers) AS average FROM instances WHERE software IS NOT NULL AND total_peers IS NOT NULL GROUP BY software HAVING average > 0 ORDER BY average DESC LIMIT ?", [amount])
  92     elif mode == "avg_blocks":
  93         database.cursor.execute("SELECT software, AVG(total_blocks) AS average FROM instances WHERE software IS NOT NULL AND total_blocks IS NOT NULL GROUP BY software HAVING average > 0 ORDER BY average DESC LIMIT ?", [amount])
  94     elif mode == "obfuscator":
  95         database.cursor.execute("SELECT software, COUNT(domain) AS cnt FROM instances WHERE has_obfuscation = 1 GROUP BY software ORDER BY cnt DESC LIMIT ?", [amount])
  96     elif mode == "obfuscation":
  97         database.cursor.execute("SELECT has_obfuscation, COUNT(domain) AS cnt FROM instances WHERE software IN ('pleroma', 'lemmy', 'mastodon', 'misskey', 'friendica') GROUP BY has_obfuscation ORDER BY cnt DESC LIMIT ?", [amount])
  98     elif mode == "block_level":
  99         database.cursor.execute("SELECT block_level, COUNT(rowid) AS cnt FROM blocks GROUP BY block_level ORDER BY cnt DESC LIMIT ?", [amount])
 100     else:
 101         raise HTTPException(status_code=400, detail="No filter specified")
 102
 103     scores = list()
 104
 105     for row in database.cursor.fetchall():
 106         scores.append({
 107             "domain": row[0],
 108             "score" : round(row[1]),
 109         })
 110
 111     return JSONResponse(status_code=200, content=scores)
 112
 113 @router.get(config.get("base_url") + "/api/list.json", response_class=JSONResponse)
 114 def api_list(request: Request, mode: str, value: str, amount: int):
 115     if mode is None or value is None or amount is None:
 116         raise HTTPException(status_code=500, detail="No filter specified")
 117     elif amount > config.get("api_limit"):
 118         raise HTTPException(status_code=500, detail=f"amount={amount} is to big")
 119
 120     if mode in ("detection_mode", "original_software", "software", "command", "origin"):
 121         database.cursor.execute(
 122             f"SELECT * \
 123 FROM instances \
 124 WHERE {mode} = ? \
 125 ORDER BY domain \
 126 LIMIT ?", [value, amount]
 127         )
 128     elif mode == "recently":
 129         database.cursor.execute(
 130             f"SELECT * \
 131 FROM instances \
 132 ORDER BY first_seen DESC \
 133 LIMIT ?", [amount]
 134         )
 135     else:
 136         raise HTTPException(status_code=500, detail=f"mode='{mode}' is unsupported")
 137
 138     domainlist = database.cursor.fetchall()
 139     return domainlist
 140
 141 @router.get(config.get("base_url") + "/api/top.json", response_class=JSONResponse)
 142 def api_index(request: Request, mode: str, value: str, amount: int):
 143     if mode is None or value is None or amount is None:
 144         raise HTTPException(status_code=500, detail="No filter specified")
 145     elif amount > config.get("api_limit"):
 146         raise HTTPException(status_code=500, detail=f"amount={amount} is to big")
 147
 148     domain = wildchar = punycode = reason = None
 149
 150     if mode == "block_level":
 151         database.cursor.execute(
 152             "SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE block_level = ? LIMIT ?", [value, amount]
 153         )
 154     elif mode in ["domain", "reverse"]:
 155         domain = tidyup.domain(value)
 156         if not domain_helper.is_wanted(domain):
 157             raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 158
 159         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 160         punycode = domain.encode("idna").decode("utf-8")
 161     elif mode == "reason":
 162         reason = re.sub("(%|_)", "", tidyup.reason(value))
 163         if len(reason) < 3:
 164             raise HTTPException(status_code=400, detail="Keyword is shorter than three characters")
 165
 166     if mode == "domain":
 167         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 168 FROM blocks \
 169 WHERE blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? \
 170 ORDER BY block_level ASC, first_seen ASC \
 171 LIMIT ?",
 172             [
 173                 domain,
 174                 "*." + domain,
 175                 wildchar,
 176                 utils.get_hash(domain),
 177                 punycode,
 178                 "*." + punycode,
 179                 amount
 180             ]
 181         )
 182     elif mode == "reverse":
 183         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 184 FROM blocks \
 185 WHERE blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? \
 186 ORDER BY first_seen ASC \
 187 LIMIT ?", [
 188             domain,
 189             "*." + domain,
 190             wildchar,
 191             utils.get_hash(domain),
 192             punycode,
 193             "*." + punycode,
 194             amount
 195         ])
 196     elif mode == "reason":
 197         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 198 FROM blocks \
 199 WHERE reason LIKE ? AND reason != '' \
 200 ORDER BY first_seen ASC \
 201 LIMIT ?", [
 202             "%" + reason + "%",
 203             amount
 204         ])
 205
 206     blocklist = database.cursor.fetchall()
 207
 208     result = {}
 209     for blocker, blocked, block_level, reason, first_seen, last_seen in blocklist:
 210         if reason is not None and reason != "":
 211             reason = reason.replace(",", " ").replace("  ", " ")
 212
 213         entry = {
 214             "blocker"   : blocker,
 215             "blocked"   : blocked,
 216             "reason"    : reason,
 217             "first_seen": first_seen,
 218             "last_seen" : last_seen
 219         }
 220
 221         if block_level in result:
 222             result[block_level].append(entry)
 223         else:
 224             result[block_level] = [entry]
 225
 226     return result
 227
 228 @router.get(config.get("base_url") + "/api/domain.json", response_class=JSONResponse)
 229 def api_domain(domain: str):
 230     if domain is None:
 231         raise HTTPException(status_code=400, detail="Invalid request, parameter 'domain' missing")
 232
 233     # Tidy up domain name
 234     domain = tidyup.domain(domain).encode("idna").decode("utf-8")
 235
 236     if not domain_helper.is_wanted(domain):
 237         raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 238
 239     # Fetch domain data
 240     database.cursor.execute("SELECT * FROM instances WHERE domain = ? LIMIT 1", [domain])
 241     domain_data = database.cursor.fetchone()
 242
 243     if domain_data is None:
 244         raise HTTPException(status_code=404, detail=f"domain='{domain}' not found")
 245
 246     return JSONResponse(status_code=200, content=dict(domain_data))
 247
 248 @router.get(config.get("base_url") + "/api/mutual.json", response_class=JSONResponse)
 249 def api_mutual(domains: list[str] = Query()):
 250     """Return 200 if federation is open between the two, 4xx otherwise"""
 251     database.cursor.execute(
 252         "SELECT block_level FROM blocks " \
 253         "WHERE ((blocker = :a OR blocker = :b) AND (blocked = :b OR blocked = :a OR blocked = :aw OR blocked = :bw)) " \
 254         "AND block_level = 'reject' " \
 255         "LIMIT 1",
 256         {
 257             "a" : domains[0],
 258             "b" : domains[1],
 259             "aw": "*." + domains[0],
 260             "bw": "*." + domains[1],
 261         },
 262     )
 263
 264     if database.cursor.fetchone() is not None:
 265         # Blocks found
 266         return JSONResponse(status_code=418, content={})
 267
 268     # No known blocks
 269     return JSONResponse(status_code=200, content={})
 270
 271 @router.get(config.get("base_url") + "/.well-known/nodeinfo", response_class=JSONResponse)
 272 def wellknown_nodeinfo(request: Request):
 273     return JSONResponse(status_code=200, content={
 274         "links": ({
 275             "rel" : "http://nodeinfo.diaspora.software/ns/schema/1.0",
 276             "href": f"{config.get('scheme')}://{config.get('hostname')}{config.get('base_url')}/nodeinfo/1.0"
 277         })
 278     })
 279
 280 @router.get(config.get("base_url") + "/nodeinfo/1.0", response_class=JSONResponse)
 281 def nodeinfo_1_0(request: Request):
 282     return JSONResponse(status_code=200, content={
 283         "version": "1.0",
 284         "software": {
 285             "name": "FBA",
 286             "version": "0.1",
 287         },
 288         "protocols": {
 289             "inbound": (),
 290             "outbound": (
 291                 "rss",
 292             ),
 293         },
 294         "services": {
 295             "inbound": (),
 296             "outbound": (
 297                 "rss",
 298             ),
 299         },
 300         "usage": {
 301             "users": {},
 302         },
 303         "openRegistrations": False,
 304         "metadata": {
 305             "nodeName": "Fedi Block API",
 306             "protocols": {
 307                 "inbound": (),
 308                 "outbound": (
 309                     "rss",
 310                 ),
 311             },
 312             "services": {
 313                 "inbound": (),
 314                 "outbound": (
 315                     "rss",
 316                 ),
 317             },
 318             "explicitContent": False,
 319         },
 320     })
 321
 322 @router.get(config.get("base_url") + "/api/v1/instance/domain_blocks", response_class=JSONResponse)
 323 def api_domain_blocks(request: Request):
 324     blocked = blacklist.get_all()
 325     blocking = list()
 326
 327     for block in blocked:
 328         blocking.append({
 329             "domain"  : block,
 330             "digest"  : utils.get_hash(block),
 331             "severity": "suspend",
 332             "comment" : blocked[block],
 333         })
 334
 335     return JSONResponse(status_code=200, content=blocking)
 336
 337 @router.get(config.get("base_url") + "/api/v1/instance/peers", response_class=JSONResponse)
 338 def api_peers(request: Request):
 339     database.cursor.execute("SELECT domain FROM instances WHERE nodeinfo_url IS NOT NULL")
 340
 341     peers = list()
 342     for row in database.cursor.fetchall():
 343         peers.append(row["domain"])
 344
 345     return JSONResponse(status_code=200, content=peers)
 346
 347 @router.get(config.get("base_url") + "/scoreboard")
 348 def scoreboard(request: Request, mode: str, amount: int):
 349     if mode == "":
 350         raise HTTPException(status_code=400, detail="No mode specified")
 351     elif amount <= 0:
 352         raise HTTPException(status_code=500, detail="Invalid amount specified")
 353
 354     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode={mode}&amount={amount}")
 355
 356     if response is None:
 357         raise HTTPException(status_code=500, detail="Could not determine scores")
 358     elif not response.ok:
 359         raise HTTPException(status_code=response.status_code, detail=response.text)
 360
 361     return templates.TemplateResponse("views/scoreboard.html", {
 362         "base_url"  : utils.base_url(),
 363         "slogan"    : config.get("slogan"),
 364         "theme"     : config.get("theme"),
 365         "request"   : request,
 366         "scoreboard": True,
 367         "mode"      : mode,
 368         "amount"    : amount,
 369         "scores"    : json_helper.from_response(response)
 370     })
 371
 372 @router.get(config.get("base_url") + "/list")
 373 def list_domains(request: Request, mode: str, value: str, amount: int = config.get("api_limit")):
 374     if mode == "detection_mode" and not instances.valid(value, "detection_mode"):
 375         raise HTTPException(status_code=500, detail="Invalid detection mode provided")
 376
 377     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/list.json?mode={mode}&value={value}&amount={amount}")
 378
 379     domainlist = list()
 380     if response is not None and response.ok:
 381         domainlist = response.json()
 382         tformat = config.get("timestamp_format")
 383         for row in domainlist:
 384             row["first_seen"]   = datetime.utcfromtimestamp(row["first_seen"]).strftime(tformat)
 385             row["last_updated"] = datetime.utcfromtimestamp(row["last_updated"]).strftime(tformat) if isinstance(row["last_updated"], float) else None
 386
 387     return templates.TemplateResponse("views/list.html", {
 388         "request"   : request,
 389         "mode"      : mode if response is not None else None,
 390         "value"     : value if response is not None else None,
 391         "amount"    : amount if response is not None else None,
 392         "found"     : len(domainlist),
 393         "domainlist": domainlist,
 394         "slogan"    : config.get("slogan"),
 395         "theme"     : config.get("theme"),
 396     })
 397
 398 @router.get(config.get("base_url") + "/top")
 399 def top(request: Request, mode: str, value: str, amount: int = config.get("api_limit")):
 400     if mode == "block_level" and not blocks.valid(value, "block_level"):
 401         raise HTTPException(status_code=500, detail="Invalid block level provided")
 402     elif mode in ["domain", "reverse"] and not domain_helper.is_wanted(value):
 403         raise HTTPException(status_code=500, detail="Invalid or blocked domain specified")
 404
 405     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/top.json?mode={mode}&value={value}&amount={amount}")
 406
 407     found = 0
 408     blocklist = list()
 409     if response.ok and response.status_code == 200 and len(response.text) > 0:
 410         blocklist = response.json()
 411
 412         tformat = config.get("timestamp_format")
 413         for block_level in blocklist:
 414             for row in blocklist[block_level]:
 415                 row["first_seen"] = datetime.utcfromtimestamp(row["first_seen"]).strftime(tformat)
 416                 row["last_seen"]  = datetime.utcfromtimestamp(row["last_seen"]).strftime(tformat) if isinstance(row["last_seen"], float) else None
 417                 found = found + 1
 418
 419     return templates.TemplateResponse("views/top.html", {
 420         "request"  : request,
 421         "mode"     : mode if response is not None else None,
 422         "value"    : value if response is not None else None,
 423         "amount"   : amount if response is not None else None,
 424         "found"    : found,
 425         "blocklist": blocklist,
 426         "slogan"   : config.get("slogan"),
 427         "theme"    : config.get("theme"),
 428     })
 429
 430 @router.get(config.get("base_url") + "/infos")
 431 def infos(request: Request, domain: str):
 432     if domain is None:
 433         raise HTTPException(status_code=400, detail="Invalid request, parameter 'domain' missing")
 434
 435     # Tidy up domain name
 436     domain = tidyup.domain(domain).encode("idna").decode("utf-8")
 437
 438     if not domain_helper.is_wanted(domain):
 439         raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 440
 441     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/domain.json?domain={domain}")
 442
 443     if not response.ok or response.status_code > 200 or response.text.strip() == "":
 444         raise HTTPException(status_code=response.status_code, detail=response.reason)
 445
 446     domain_data = response.json()
 447
 448     # Format timestamps
 449     tformat = config.get("timestamp_format")
 450     instance = dict()
 451     for key in domain_data.keys():
 452         if key in ["last_nodeinfo", "last_blocked", "first_seen", "last_updated", "last_instance_fetch"] and isinstance(domain_data[key], float):
 453             # Timestamps
 454             instance[key] = datetime.utcfromtimestamp(domain_data[key]).strftime(tformat)
 455         else:
 456             # Generic
 457             instance[key] = domain_data[key]
 458
 459     return templates.TemplateResponse("views/infos.html", {
 460         "request" : request,
 461         "domain"  : domain,
 462         "instance": instance,
 463         "theme"   : config.get("theme"),
 464         "slogan"  : config.get("slogan"),
 465     })
 466
 467 @router.get(config.get("base_url") + "/rss")
 468 def rss(request: Request, domain: str = None):
 469     if domain is not None:
 470         domain = tidyup.domain(domain).encode("idna").decode("utf-8")
 471
 472         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 473         punycode = domain.encode("idna").decode("utf-8")
 474
 475         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 ?", [
 476             domain,
 477             "*." + domain, wildchar,
 478             utils.get_hash(domain),
 479             punycode,
 480             "*." + punycode,
 481             config.get("rss_limit")
 482         ])
 483     else:
 484         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")])
 485
 486     result = database.cursor.fetchall()
 487     blocklist = []
 488
 489     for row in result:
 490         blocklist.append({
 491             "blocker"    : row[0],
 492             "blocked"    : row[1],
 493             "block_level": row[2],
 494             "reason"     : "Provided reason: '" + row[3] + "'" if row[3] is not None and row[3] != "" else "No reason provided.",
 495             "first_seen" : format_datetime(datetime.fromtimestamp(row[4])),
 496             "last_seen"  : format_datetime(datetime.fromtimestamp(row[5])),
 497         })
 498
 499     return templates.TemplateResponse("views/rss.xml", {
 500         "request"  : request,
 501         "timestamp": format_datetime(datetime.now()),
 502         "domain"   : domain,
 503         "scheme"   : config.get("scheme"),
 504         "hostname" : config.get("hostname"),
 505         "blocks"   : blocklist
 506     }, headers={
 507         "Content-Type": "routerlication/rss+xml"
 508     })
 509
 510 @router.get(config.get("base_url") + "/robots.txt", response_class=PlainTextResponse)
 511 def robots(request: Request):
 512     return templates.TemplateResponse("views/robots.txt", {
 513         "request" : request,
 514         "base_url": config.get("base_url")
 515     })
 516
 517 @router.get(config.get("base_url") + "/")
 518 def index(request: Request):
 519     # Get info
 520     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 521
 522     if not response.ok:
 523         raise HTTPException(status_code=response.status_code, detail=response.text)
 524
 525     return templates.TemplateResponse("views/index.html", {
 526         "request": request,
 527         "theme"  : config.get("theme"),
 528         "info"   : response.json(),
 529         "slogan" : config.get("slogan"),
 530     })
 531
 532 if __name__ == "__main__":
 533     uvicorn.run("daemon:router", host=config.get("host"), port=config.get("port"), log_level=config.get("log_level"), proxy_headers=True)