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/top.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 = ? \
 135 ORDER BY block_level ASC, first_seen ASC \
 136 LIMIT ?",
 137             [
 138                 domain,
 139                 "*." + domain,
 140                 wildchar,
 141                 utils.get_hash(domain),
 142                 punycode,
 143                 "*." + punycode,
 144                 amount
 145             ]
 146         )
 147     elif mode == "reverse":
 148         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 149 FROM blocks \
 150 WHERE blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? \
 151 ORDER BY first_seen ASC \
 152 LIMIT ?", [
 153             domain,
 154             "*." + domain,
 155             wildchar,
 156             utils.get_hash(domain),
 157             punycode,
 158             "*." + punycode,
 159             amount
 160         ])
 161     elif mode == "reason":
 162         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 163 FROM blocks \
 164 WHERE reason LIKE ? AND reason != '' \
 165 ORDER BY first_seen ASC \
 166 LIMIT ?", [
 167             "%" + reason + "%",
 168             amount
 169         ])
 170
 171     blocklist = database.cursor.fetchall()
 172
 173     result = {}
 174     for blocker, blocked, block_level, reason, first_seen, last_seen in blocklist:
 175         if reason is not None and reason != "":
 176             reason = reason.replace(",", " ").replace("  ", " ")
 177
 178         entry = {
 179             "blocker"   : blocker,
 180             "blocked"   : blocked,
 181             "reason"    : reason,
 182             "first_seen": first_seen,
 183             "last_seen" : last_seen
 184         }
 185
 186         if block_level in result:
 187             result[block_level].append(entry)
 188         else:
 189             result[block_level] = [entry]
 190
 191     return result
 192
 193 @router.get(config.get("base_url") + "/api/mutual.json", response_class=JSONResponse)
 194 def api_mutual(domains: list[str] = Query()):
 195     """Return 200 if federation is open between the two, 4xx otherwise"""
 196     database.cursor.execute(
 197         "SELECT block_level FROM blocks " \
 198         "WHERE ((blocker = :a OR blocker = :b) AND (blocked = :b OR blocked = :a OR blocked = :aw OR blocked = :bw)) " \
 199         "AND block_level = 'reject' " \
 200         "LIMIT 1",
 201         {
 202             "a" : domains[0],
 203             "b" : domains[1],
 204             "aw": "*." + domains[0],
 205             "bw": "*." + domains[1],
 206         },
 207     )
 208     response = database.cursor.fetchone()
 209
 210     if response is not None:
 211         # Blocks found
 212         return JSONResponse(status_code=418, content={})
 213
 214     # No known blocks
 215     return JSONResponse(status_code=200, content={})
 216
 217 @router.get(config.get("base_url") + "/scoreboard")
 218 def scoreboard(request: Request, mode: str, amount: int):
 219     response = None
 220
 221     if mode == "blocker" and amount > 0:
 222         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocker&amount={amount}")
 223     elif mode == "blocked" and amount > 0:
 224         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocked&amount={amount}")
 225     elif mode == "reference" and amount > 0:
 226         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=reference&amount={amount}")
 227     elif mode == "software" and amount > 0:
 228         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=software&amount={amount}")
 229     elif mode == "command" and amount > 0:
 230         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=command&amount={amount}")
 231     elif mode == "error_code" and amount > 0:
 232         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=error_code&amount={amount}")
 233     elif mode == "detection_mode" and amount > 0:
 234         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=detection_mode&amount={amount}")
 235     elif mode == "avg_peers" and amount > 0:
 236         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=avg_peers&amount={amount}")
 237     elif mode == "obfuscator" and amount > 0:
 238         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=obfuscator&amount={amount}")
 239     elif mode == "obfuscation" and amount > 0:
 240         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=obfuscation&amount={amount}")
 241     elif mode == "block_level" and amount > 0:
 242         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=block_level&amount={amount}")
 243     else:
 244         raise HTTPException(status_code=400, detail="No filter specified")
 245
 246     if response is None:
 247         raise HTTPException(status_code=500, detail="Could not determine scores")
 248     elif not response.ok:
 249         raise HTTPException(status_code=response.status_code, detail=response.text)
 250
 251     return templates.TemplateResponse("views/scoreboard.html", {
 252         "base_url"  : config.get("base_url"),
 253         "slogan"    : config.get("slogan"),
 254         "theme"     : config.get("theme"),
 255         "request"   : request,
 256         "scoreboard": True,
 257         "mode"      : mode,
 258         "amount"    : amount,
 259         "scores"    : json_helper.from_response(response)
 260     })
 261
 262 @router.get(config.get("base_url") + "/")
 263 def index(request: Request):
 264     # Get info
 265     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 266
 267     if not response.ok:
 268         raise HTTPException(status_code=response.status_code, detail=response.text)
 269
 270     return templates.TemplateResponse("views/index.html", {
 271         "request": request,
 272         "theme"  : config.get("theme"),
 273         "info"   : response.json(),
 274         "slogan" : config.get("slogan"),
 275     })
 276
 277 @router.get(config.get("base_url") + "/top")
 278 def top(request: Request, mode: str, value: str, amount: int = config.get("api_limit")):
 279     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 280
 281     if not response.ok:
 282         raise HTTPException(status_code=response.status_code, detail=response.text)
 283     elif mode == "" or value == "" or amount == 0:
 284         raise HTTPException(status_code=500, detail="Parameter mode, value and amount must always be set")
 285     elif amount > config.get("api_limit"):
 286         raise HTTPException(status_code=500, detail=f"amount='{amount}' is to big")
 287
 288     info = response.json()
 289     response = None
 290     blocklist = list()
 291
 292     if mode == "block_level" and not blocks.is_valid_level(value):
 293         raise HTTPException(status_code=500, detail="Invalid block level provided")
 294     elif mode in ["domain", "reverse"] and not utils.is_domain_wanted(value):
 295         raise HTTPException(status_code=500, detail="Invalid or blocked domain specified")
 296
 297     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/top.json?mode={mode}&value={value}&amount={amount}")
 298
 299     if response is not None:
 300         blocklist = response.json()
 301
 302     found = 0
 303     for block_level in blocklist:
 304         for block in blocklist[block_level]:
 305             block["first_seen"] = datetime.utcfromtimestamp(block["first_seen"]).strftime(config.get("timestamp_format"))
 306             block["last_seen"]  = datetime.utcfromtimestamp(block["last_seen"]).strftime(config.get("timestamp_format"))
 307             found = found + 1
 308
 309     return templates.TemplateResponse("views/top.html", {
 310         "request"  : request,
 311         "mode"     : mode if response is not None else None,
 312         "value"    : value if response is not None else None,
 313         "amount"   : amount if response is not None else None,
 314         "found"    : found,
 315         "blocklist": blocklist,
 316         "info"     : info,
 317         "theme"    : config.get("theme"),
 318     })
 319
 320 @router.get(config.get("base_url") + "/infos")
 321 def rss(request: Request, domain: str):
 322     # Tidy up domain name
 323     domain = tidyup.domain(domain)
 324
 325     if not utils.is_domain_wanted(domain):
 326         raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 327
 328     # Fetch domain data
 329     database.cursor.execute("SELECT * FROM instances WHERE domain = ? LIMIT 1", [domain])
 330     domain_data = database.cursor.fetchone()
 331
 332     if domain_data is None:
 333         raise HTTPException(status_code=404, detail=f"domain='{domain}' not found")
 334
 335     # Format timestamps
 336     format = config.get("timestamp_format")
 337     instance = dict()
 338     for key in domain_data.keys():
 339         if key in ["last_nodeinfo", "last_blocked", "first_seen", "last_updated", "last_instance_fetch"]:
 340             # Timestamps
 341             instance[key] = datetime.utcfromtimestamp(domain_data[key]).strftime(format) if isinstance(domain_data[key], float) else "-"
 342         else:
 343             # Generic
 344             instance[key] = domain_data[key]
 345
 346     return templates.TemplateResponse("views/infos.html", {
 347         "request" : request,
 348         "domain"  : domain,
 349         "instance": instance,
 350         "theme"   : config.get("theme"),
 351         "slogan"  : config.get("slogan"),
 352     })
 353
 354 @router.get(config.get("base_url") + "/rss")
 355 def rss(request: Request, domain: str = None):
 356     if domain is not None:
 357         domain = tidyup.domain(domain)
 358
 359         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 360         punycode = domain.encode("idna").decode("utf-8")
 361
 362         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 ?", [
 363             domain,
 364             "*." + domain, wildchar,
 365             utils.get_hash(domain),
 366             punycode,
 367             "*." + punycode,
 368             config.get("rss_limit")
 369         ])
 370     else:
 371         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")])
 372
 373     result = database.cursor.fetchall()
 374     blocklist = []
 375
 376     for row in result:
 377         blocklist.append({
 378             "blocker"    : row[0],
 379             "blocked"    : row[1],
 380             "block_level": row[2],
 381             "reason"     : "Provided reason: '" + row[3] + "'" if row[3] is not None and row[3] != "" else "No reason provided.",
 382             "first_seen" : format_datetime(datetime.fromtimestamp(row[4])),
 383             "last_seen"  : format_datetime(datetime.fromtimestamp(row[5])),
 384         })
 385
 386     return templates.TemplateResponse("views/rss.xml", {
 387         "request"  : request,
 388         "timestamp": format_datetime(datetime.now()),
 389         "domain"   : domain,
 390         "hostname" : config.get("hostname"),
 391         "blocks"   : blocklist
 392     }, headers={
 393         "Content-Type": "routerlication/rss+xml"
 394     })
 395
 396 @router.get(config.get("base_url") + "/robots.txt", response_class=PlainTextResponse)
 397 def robots(request: Request):
 398     return templates.TemplateResponse("views/robots.txt", {
 399         "request" : request,
 400         "base_url": config.get("base_url")
 401     })
 402
 403 if __name__ == "__main__":
 404     uvicorn.run("daemon:router", host=config.get("host"), port=config.get("port"), log_level=config.get("log_level"))