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