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