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