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 tidyup
  41
  42 from fba.http import network
  43
  44 from fba.models import blocks
  45
  46 router = fastapi.FastAPI(docs_url=config.get("base_url") + "/docs", redoc_url=config.get("base_url") + "/redoc")
  47 router.mount(
  48     "/static",
  49     StaticFiles(directory=Path(__file__).parent.absolute() / "static"),
  50     name="static",
  51 )
  52
  53 templates = Jinja2Templates(directory="templates")
  54
  55 @router.get(config.get("base_url") + "/api/info.json", response_class=JSONResponse)
  56 def api_info():
  57     database.cursor.execute("SELECT (SELECT COUNT(domain) FROM instances), (SELECT COUNT(domain) FROM instances WHERE software IN ('pleroma', 'mastodon', 'lemmy', 'friendica', 'misskey', 'peertube')), (SELECT COUNT(blocker) FROM blocks), (SELECT COUNT(domain) FROM instances WHERE last_error_details IS NOT NULL)")
  58     row = database.cursor.fetchone()
  59
  60     return {
  61         "known_instances"    : row[0],
  62         "supported_instances": row[1],
  63         "blocks_recorded"    : row[2],
  64         "erroneous_instances": row[3],
  65     }
  66
  67 @router.get(config.get("base_url") + "/api/scoreboard.json", response_class=JSONResponse)
  68 def api_scoreboard(mode: str, amount: int):
  69     if amount > config.get("api_limit"):
  70         raise HTTPException(status_code=400, detail="Too many results")
  71
  72     if mode == "blocked":
  73         database.cursor.execute("SELECT blocked, COUNT(blocked) AS score FROM blocks GROUP BY blocked ORDER BY score DESC LIMIT ?", [amount])
  74     elif mode == "blocker":
  75         database.cursor.execute("SELECT blocker, COUNT(blocker) AS score FROM blocks GROUP BY blocker ORDER BY score DESC LIMIT ?", [amount])
  76     elif mode == "reference":
  77         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])
  78     elif mode == "software":
  79         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])
  80     elif mode == "command":
  81         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])
  82     elif mode == "error_code":
  83         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])
  84     elif mode == "detection_mode":
  85         database.cursor.execute("SELECT detection_mode, COUNT(domain) AS cnt FROM instances GROUP BY detection_mode ORDER BY cnt DESC LIMIT ?", [amount])
  86     elif mode == "avg_peers":
  87         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])
  88     elif mode == "obfuscator":
  89         database.cursor.execute("SELECT software, COUNT(domain) AS cnt FROM instances WHERE has_obfuscation = 1 GROUP BY software ORDER BY cnt DESC LIMIT ?", [amount])
  90     elif mode == "obfuscation":
  91         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])
  92     elif mode == "block_level":
  93         database.cursor.execute("SELECT block_level, COUNT(rowid) AS cnt FROM blocks GROUP BY block_level ORDER BY cnt DESC LIMIT ?", [amount])
  94     else:
  95         raise HTTPException(status_code=400, detail="No filter specified")
  96
  97     scores = list()
  98
  99     for domain, score in database.cursor.fetchall():
 100         scores.append({
 101             "domain": domain,
 102             "score" : round(score)
 103         })
 104
 105     return scores
 106
 107 @router.get(config.get("base_url") + "/api/index.json", response_class=JSONResponse)
 108 def api_index(request: Request, mode: str, value: str, amount: int):
 109     if mode is None or value is None or amount is None:
 110         raise HTTPException(status_code=500, detail="No filter specified")
 111     elif amount > config.get("api_limit"):
 112         raise HTTPException(status_code=500, detail=f"amount={amount} is to big")
 113
 114     domain = wildchar = punycode = reason = None
 115
 116     if mode == "block_level":
 117         database.cursor.execute(
 118             "SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE block_level = ? LIMIT ?", [value, amount]
 119         )
 120     elif mode in ["domain", "reverse"]:
 121         domain = tidyup.domain(value)
 122         if not utils.is_domain_wanted(domain):
 123             raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 124
 125         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 126         punycode = domain.encode('idna').decode('utf-8')
 127     elif mode == "reason":
 128         reason = re.sub("(%|_)", "", tidyup.reason(value))
 129         if len(reason) < 3:
 130             raise HTTPException(status_code=400, detail="Keyword is shorter than three characters")
 131
 132     if mode == "domain":
 133         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 134 FROM blocks \
 135 WHERE blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? ORDER BY first_seen ASC LIMIT ?",
 136             [
 137                 domain,
 138                 "*." + domain,
 139                 wildchar,
 140                 utils.get_hash(domain),
 141                 punycode,
 142                 "*." + punycode,
 143                 amount
 144             ]
 145         )
 146     elif mode == "reverse":
 147         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 148 FROM blocks \
 149 WHERE blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? OR blocker = ? \
 150 ORDER BY first_seen ASC \
 151 LIMIT ?", [
 152             domain,
 153             "*." + domain,
 154             wildchar,
 155             utils.get_hash(domain),
 156             punycode,
 157             "*." + punycode,
 158             amount
 159         ])
 160     elif mode == "reason":
 161         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 162 FROM blocks \
 163 WHERE reason LIKE ? AND reason != '' \
 164 ORDER BY first_seen ASC \
 165 LIMIT ?", [
 166             "%" + reason + "%",
 167             amount
 168         ])
 169
 170     blocklist = database.cursor.fetchall()
 171
 172     result = {}
 173     for blocker, blocked, block_level, reason, first_seen, last_seen in blocklist:
 174         if reason is not None and reason != "":
 175             reason = reason.replace(",", " ").replace("  ", " ")
 176
 177         entry = {
 178             "blocker"   : blocker,
 179             "blocked"   : blocked,
 180             "reason"    : reason,
 181             "first_seen": first_seen,
 182             "last_seen" : last_seen
 183         }
 184
 185         if block_level in result:
 186             result[block_level].append(entry)
 187         else:
 188             result[block_level] = [entry]
 189
 190     return result
 191
 192 @router.get(config.get("base_url") + "/api/mutual.json", response_class=JSONResponse)
 193 def api_mutual(domains: list[str] = Query()):
 194     """Return 200 if federation is open between the two, 4xx otherwise"""
 195     database.cursor.execute(
 196         "SELECT block_level FROM blocks " \
 197         "WHERE ((blocker = :a OR blocker = :b) AND (blocked = :b OR blocked = :a OR blocked = :aw OR blocked = :bw)) " \
 198         "AND block_level = 'reject' " \
 199         "LIMIT 1",
 200         {
 201             "a" : domains[0],
 202             "b" : domains[1],
 203             "aw": "*." + domains[0],
 204             "bw": "*." + domains[1],
 205         },
 206     )
 207     response = database.cursor.fetchone()
 208
 209     if response is not None:
 210         # Blocks found
 211         return JSONResponse(status_code=418, content={})
 212
 213     # No known blocks
 214     return JSONResponse(status_code=200, content={})
 215
 216 @router.get(config.get("base_url") + "/scoreboard")
 217 def scoreboard(request: Request, mode: str, amount: int):
 218     response = None
 219
 220     if mode == "blocker" and amount > 0:
 221         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocker&amount={amount}")
 222     elif mode == "blocked" and amount > 0:
 223         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocked&amount={amount}")
 224     elif mode == "reference" and amount > 0:
 225         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=reference&amount={amount}")
 226     elif mode == "software" and amount > 0:
 227         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=software&amount={amount}")
 228     elif mode == "command" and amount > 0:
 229         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=command&amount={amount}")
 230     elif mode == "error_code" and amount > 0:
 231         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=error_code&amount={amount}")
 232     elif mode == "detection_mode" and amount > 0:
 233         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=detection_mode&amount={amount}")
 234     elif mode == "avg_peers" and amount > 0:
 235         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=avg_peers&amount={amount}")
 236     elif mode == "obfuscator" and amount > 0:
 237         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=obfuscator&amount={amount}")
 238     elif mode == "obfuscation" and amount > 0:
 239         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=obfuscation&amount={amount}")
 240     elif mode == "block_level" and amount > 0:
 241         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=block_level&amount={amount}")
 242     else:
 243         raise HTTPException(status_code=400, detail="No filter specified")
 244
 245     if response is None:
 246         raise HTTPException(status_code=500, detail="Could not determine scores")
 247     elif not response.ok:
 248         raise HTTPException(status_code=response.status_code, detail=response.text)
 249
 250     return templates.TemplateResponse("views/scoreboard.html", {
 251         "base_url"  : config.get("base_url"),
 252         "slogan"    : config.get("slogan"),
 253         "theme"     : config.get("theme"),
 254         "request"   : request,
 255         "scoreboard": True,
 256         "mode"      : mode,
 257         "amount"    : amount,
 258         "scores"    : network.json_from_response(response)
 259     })
 260
 261 @router.get(config.get("base_url") + "/")
 262 def index(request: Request):
 263     # Get info
 264     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 265
 266     if not response.ok:
 267         raise HTTPException(status_code=response.status_code, detail=response.text)
 268
 269     return templates.TemplateResponse("views/index.html", {
 270         "request": request,
 271         "theme"  : config.get("theme"),
 272         "info"   : response.json(),
 273         "slogan" : config.get("slogan"),
 274     })
 275
 276 @router.get(config.get("base_url") + "/top")
 277 def top(request: Request, mode: str, value: str, amount: int = config.get("api_limit")):
 278     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 279
 280     if not response.ok:
 281         raise HTTPException(status_code=response.status_code, detail=response.text)
 282     elif mode == "" or value == "" or amount == 0:
 283         raise HTTPException(status_code=500, detail="Parameter mode, value and amount must always be set")
 284     elif amount > config.get("api_limit"):
 285         raise HTTPException(status_code=500, detail=f"amount='{amount}' is to big")
 286
 287     info = response.json()
 288     response = None
 289     blocklist = list()
 290
 291     if mode == "block_level" and not blocks.is_valid_level(value):
 292         raise HTTPException(status_code=500, detail="Invalid block level provided")
 293     elif mode in ["domain", "reverse"] and not utils.is_domain_wanted(value):
 294         raise HTTPException(status_code=500, detail="Invalid or blocked domain specified")
 295
 296     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/index.json?mode={mode}&value={value}&amount={amount}")
 297
 298     if response is not None:
 299         blocklist = response.json()
 300
 301     found = 0
 302     for block_level in blocklist:
 303         for block in blocklist[block_level]:
 304             block["first_seen"] = datetime.utcfromtimestamp(block["first_seen"]).strftime(config.get("timestamp_format"))
 305             block["last_seen"]  = datetime.utcfromtimestamp(block["last_seen"]).strftime(config.get("timestamp_format"))
 306             found = found + 1
 307
 308     return templates.TemplateResponse("views/top.html", {
 309         "request"  : request,
 310         "mode"     : mode if response is not None else None,
 311         "value"    : value if response is not None else None,
 312         "amount"   : amount if response is not None else None,
 313         "found"    : found,
 314         "blocklist": blocklist,
 315         "info"     : info,
 316         "theme"    : config.get("theme"),
 317     })
 318
 319 @router.get(config.get("base_url") + "/rss")
 320 def rss(request: Request, domain: str = None):
 321     if domain is not None:
 322         domain = tidyup.domain(domain)
 323
 324         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 325         punycode = domain.encode("idna").decode("utf-8")
 326
 327         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 ?", [
 328             domain,
 329             "*." + domain, wildchar,
 330             utils.get_hash(domain),
 331             punycode,
 332             "*." + punycode,
 333             config.get("rss_limit")
 334         ])
 335     else:
 336         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")])
 337
 338     result = database.cursor.fetchall()
 339     blocklist = []
 340
 341     for row in result:
 342         blocklist.append({
 343             "blocker"    : row[0],
 344             "blocked"    : row[1],
 345             "block_level": row[2],
 346             "reason"     : "Provided reason: '" + row[3] + "'" if row[3] is not None and row[3] != "" else "No reason provided.",
 347             "first_seen" : format_datetime(datetime.fromtimestamp(row[4])),
 348             "last_seen"  : format_datetime(datetime.fromtimestamp(row[5])),
 349         })
 350
 351     return templates.TemplateResponse("views/rss.xml", {
 352         "request"  : request,
 353         "timestamp": format_datetime(datetime.now()),
 354         "domain"   : domain,
 355         "hostname" : config.get("hostname"),
 356         "blocks"   : blocklist
 357     }, headers={
 358         "Content-Type": "routerlication/rss+xml"
 359     })
 360
 361 @router.get(config.get("base_url") + "/robots.txt", response_class=PlainTextResponse)
 362 def robots(request: Request):
 363     return templates.TemplateResponse("views/robots.txt", {
 364         "request" : request,
 365         "base_url": config.get("base_url")
 366     })
 367
 368 if __name__ == "__main__":
 369     uvicorn.run("daemon:router", host=config.get("host"), port=config.get("port"), log_level=config.get("log_level"))