api.py

   1 # Fedi API Block - An aggregator for fetching blocking data from fediverse nodes
   2 # Copyright (C) 2023 Free Software Foundation
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU Affero General Public License as published
   6 # by the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU Affero General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
  16
  17 import os
  18 import os.path
  19 import re
  20
  21 from datetime import datetime
  22 from email.utils import format_datetime
  23 from pathlib import Path
  24
  25 import fastapi
  26 from fastapi import Request, HTTPException, Query
  27 from fastapi.responses import JSONResponse
  28 from fastapi.responses import PlainTextResponse
  29 from fastapi.staticfiles import StaticFiles
  30 from fastapi.templating import Jinja2Templates
  31
  32 import uvicorn
  33 import requests
  34 import validators
  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         "slogan"             : config.get("slogan"),
  66     }
  67
  68 @router.get(config.get("base_url") + "/api/scoreboard.json", response_class=JSONResponse)
  69 def api_scoreboard(mode: str, amount: int):
  70     if amount > config.get("api_limit"):
  71         raise HTTPException(status_code=400, detail="Too many results")
  72
  73     if mode == "blocked":
  74         database.cursor.execute("SELECT blocked, COUNT(blocked) AS score FROM blocks GROUP BY blocked ORDER BY score DESC LIMIT ?", [amount])
  75     elif mode == "blocker":
  76         database.cursor.execute("SELECT blocker, COUNT(blocker) AS score FROM blocks GROUP BY blocker ORDER BY score DESC LIMIT ?", [amount])
  77     elif mode == "reference":
  78         database.cursor.execute("SELECT origin, COUNT(domain) AS score FROM instances WHERE software IS NOT NULL GROUP BY origin ORDER BY score DESC LIMIT ?", [amount])
  79     elif mode == "software":
  80         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])
  81     elif mode == "command":
  82         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])
  83     elif mode == "error_code":
  84         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])
  85     elif mode == "detection_mode":
  86         database.cursor.execute("SELECT detection_mode, COUNT(domain) AS cnt FROM instances GROUP BY detection_mode ORDER BY cnt DESC LIMIT ?", [amount])
  87     elif mode == "avg_peers":
  88         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])
  89     elif mode == "obfuscator":
  90         database.cursor.execute("SELECT software, COUNT(domain) AS cnt FROM instances WHERE has_obfuscation = 1 GROUP BY software ORDER BY cnt DESC LIMIT ?", [amount])
  91     elif mode == "obfuscation":
  92         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])
  93     elif mode == "block_level":
  94         database.cursor.execute("SELECT block_level, COUNT(rowid) AS cnt FROM blocks GROUP BY block_level ORDER BY cnt DESC LIMIT ?", [amount])
  95     else:
  96         raise HTTPException(status_code=400, detail="No filter specified")
  97
  98     scores = list()
  99
 100     for domain, score in database.cursor.fetchall():
 101         scores.append({
 102             "domain": domain,
 103             "score" : round(score)
 104         })
 105
 106     return scores
 107
 108 @router.get(config.get("base_url") + "/api/index.json", response_class=JSONResponse)
 109 def api_index(request: Request, mode: str, value: str, amount: int):
 110     if mode is None or value is None or amount is None:
 111         raise HTTPException(status_code=500, detail="No filter specified")
 112     elif amount > config.get("api_limit"):
 113         raise HTTPException(status_code=500, detail=f"amount={amount} is to big")
 114
 115     domain = whildchar = punycode = reason = None
 116
 117     if mode == "block_level":
 118         database.cursor.execute(
 119             "SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE block_level = ? LIMIT ?", [value, amount]
 120         )
 121     elif mode in ["domain", "reverse"]:
 122         domain = tidyup.domain(value)
 123         if not utils.is_domain_wanted(domain):
 124             raise HTTPException(status_code=500, detail=f"domain='{domain}' is not wanted")
 125
 126         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 127         punycode = domain.encode('idna').decode('utf-8')
 128     elif mode == "reason":
 129         reason = re.sub("(%|_)", "", tidyup.reason(value))
 130         if len(reason) < 3:
 131             raise HTTPException(status_code=400, detail="Keyword is shorter than three characters")
 132
 133     if mode == "domain":
 134         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen \
 135 FROM blocks \
 136 WHERE blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? OR blocked = ? ORDER BY first_seen ASC 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"    : network.json_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     })
 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("api:router", host=config.get("host"), port=config.get("port"), log_level=config.get("log_level"))