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 re
  18
  19 from datetime import datetime
  20 from email.utils import format_datetime
  21 from fastapi import Request, HTTPException, Query
  22 from fastapi.responses import JSONResponse
  23 from fastapi.responses import PlainTextResponse
  24 from fastapi.templating import Jinja2Templates
  25
  26 import fastapi
  27 import uvicorn
  28 import requests
  29 import validators
  30
  31 from fba import database
  32 from fba import utils
  33
  34 from fba.helpers import config
  35 from fba.helpers import tidyup
  36
  37 from fba.http import network
  38
  39 router = fastapi.FastAPI(docs_url=config.get("base_url") + "/docs", redoc_url=config.get("base_url") + "/redoc")
  40 templates = Jinja2Templates(directory="templates")
  41
  42 @router.get(config.get("base_url") + "/api/info.json", response_class=JSONResponse)
  43 def api_info():
  44     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)")
  45     row = database.cursor.fetchone()
  46
  47     return {
  48         "known_instances"   : row[0],
  49         "indexed_instances" : row[1],
  50         "blocks_recorded"   : row[2],
  51         "errorous_instances": row[3],
  52         "slogan"            : config.get("slogan")
  53     }
  54
  55 @router.get(config.get("base_url") + "/api/scoreboard.json", response_class=JSONResponse)
  56 def api_scoreboard(mode: str, amount: int):
  57     if amount > 500:
  58         raise HTTPException(status_code=400, detail="Too many results")
  59
  60     if mode == "blocked":
  61         database.cursor.execute("SELECT blocked, COUNT(blocked) AS score FROM blocks WHERE block_level = 'reject' GROUP BY blocked ORDER BY score DESC LIMIT ?", [amount])
  62     elif mode == "blocker":
  63         database.cursor.execute("SELECT blocker, COUNT(blocker) AS score FROM blocks WHERE block_level = 'reject' GROUP BY blocker ORDER BY score DESC LIMIT ?", [amount])
  64     elif mode == "reference":
  65         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])
  66     elif mode == "software":
  67         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])
  68     elif mode == "command":
  69         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])
  70     elif mode == "error_code":
  71         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])
  72     elif mode == "avg_peers":
  73         database.cursor.execute("SELECT software, AVG(total_peers) AS sum FROM instances WHERE software IS NOT NULL GROUP BY software HAVING sum>0 ORDER BY sum DESC LIMIT ?", [amount])
  74     else:
  75         raise HTTPException(status_code=400, detail="No filter specified")
  76
  77     scores = list()
  78
  79     for domain, score in database.cursor.fetchall():
  80         scores.append({
  81             "domain": domain,
  82             "score" : round(score)
  83         })
  84
  85     return scores
  86
  87 @router.get(config.get("base_url") + "/api/index.json", response_class=JSONResponse)
  88 def api_blocked(domain: str = None, reason: str = None, reverse: str = None):
  89     if domain is None and reason is None and reverse is None:
  90         raise HTTPException(status_code=400, detail="No filter specified")
  91
  92     if reason is not None:
  93         reason = re.sub("(%|_)", "", tidyup.reason(reason))
  94         if len(reason) < 3:
  95             raise HTTPException(status_code=400, detail="Keyword is shorter than three characters")
  96
  97     if domain is not None:
  98         domain = tidyup.domain(domain)
  99         if not validators.domain(domain.split("/")[0]):
 100             raise HTTPException(status_code=500, detail="Invalid domain")
 101
 102         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 103         punycode = domain.encode('idna').decode('utf-8')
 104
 105         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 ASC",
 106                   (domain, "*." + domain, wildchar, utils.get_hash(domain), punycode, "*." + punycode))
 107     elif reverse is not None:
 108         reverse = tidyup.domain(reverse)
 109         if not validators.domain(reverse):
 110             raise HTTPException(status_code=500, detail="Invalid domain")
 111
 112         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE blocker = ? ORDER BY first_seen ASC", [reverse])
 113     else:
 114         database.cursor.execute("SELECT blocker, blocked, block_level, reason, first_seen, last_seen FROM blocks WHERE reason like ? AND reason != '' ORDER BY first_seen ASC", ["%" + reason + "%"])
 115
 116     blocklist = database.cursor.fetchall()
 117
 118     result = {}
 119     for blocker, blocked, block_level, reason, first_seen, last_seen in blocklist:
 120         if reason is not None and reason != "":
 121             reason = reason.replace(",", " ").replace("  ", " ")
 122
 123         entry = {
 124             "blocker"   : blocker,
 125             "blocked"   : blocked,
 126             "reason"    : reason,
 127             "first_seen": first_seen,
 128             "last_seen" : last_seen
 129         }
 130
 131         if block_level in result:
 132             result[block_level].append(entry)
 133         else:
 134             result[block_level] = [entry]
 135
 136     return result
 137
 138 @router.get(config.get("base_url") + "/api/mutual.json", response_class=JSONResponse)
 139 def api_mutual(domains: list[str] = Query()):
 140     """Return 200 if federation is open between the two, 4xx otherwise"""
 141     database.cursor.execute(
 142         "SELECT block_level FROM blocks " \
 143         "WHERE ((blocker = :a OR blocker = :b) AND (blocked = :b OR blocked = :a OR blocked = :aw OR blocked = :bw)) " \
 144         "AND block_level = 'reject' " \
 145         "LIMIT 1",
 146         {
 147             "a" : domains[0],
 148             "b" : domains[1],
 149             "aw": "*." + domains[0],
 150             "bw": "*." + domains[1],
 151         },
 152     )
 153     response = database.cursor.fetchone()
 154
 155     if response is not None:
 156         # Blocks found
 157         return JSONResponse(status_code=418, content={})
 158
 159     # No known blocks
 160     return JSONResponse(status_code=200, content={})
 161
 162 @router.get(config.get("base_url") + "/scoreboard")
 163 def scoreboard(request: Request, mode: str, amount: int):
 164     response = None
 165
 166     if mode == "blocker" and amount > 0:
 167         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocker&amount={amount}")
 168     elif mode == "blocked" and amount > 0:
 169         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=blocked&amount={amount}")
 170     elif mode == "reference" and amount > 0:
 171         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=reference&amount={amount}")
 172     elif mode == "software" and amount > 0:
 173         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=software&amount={amount}")
 174     elif mode == "command" and amount > 0:
 175         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=command&amount={amount}")
 176     elif mode == "error_code" and amount > 0:
 177         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=error_code&amount={amount}")
 178     elif mode == "avg_peers" and amount > 0:
 179         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/scoreboard.json?mode=avg_peers&amount={amount}")
 180     else:
 181         raise HTTPException(status_code=400, detail="No filter specified")
 182
 183     if response is None:
 184         raise HTTPException(status_code=500, detail="Could not determine scores")
 185     elif not response.ok:
 186         raise HTTPException(status_code=response.status_code, detail=response.text)
 187
 188     return templates.TemplateResponse("views/scoreboard.html", {
 189         "base_url"  : config.get("base_url"),
 190         "slogan"    : config.get("slogan"),
 191         "request"   : request,
 192         "scoreboard": True,
 193         "mode"      : mode,
 194         "amount"    : amount,
 195         "scores"    : network.json_from_response(response)
 196     })
 197
 198 @router.get(config.get("base_url") + "/")
 199 def index(request: Request):
 200     # Get info
 201     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 202
 203     if not response.ok:
 204         raise HTTPException(status_code=response.status_code, detail=response.text)
 205
 206     return templates.TemplateResponse("views/index.html", {
 207         "request": request,
 208         "info"   : response.json()
 209     })
 210
 211 @router.get(config.get("base_url") + "/top")
 212 def top(request: Request, domain: str = None, reason: str = None, reverse: str = None):
 213     if domain == "" or reason == "" or reverse == "":
 214         raise HTTPException(status_code=500, detail="Insufficient parameter provided")
 215
 216     response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/info.json")
 217
 218     if not response.ok:
 219         raise HTTPException(status_code=response.status_code, detail=response.text)
 220
 221     info = response.json()
 222     response = None
 223
 224     if domain is not None:
 225         domain = tidyup.domain(domain)
 226         if not validators.domain(domain.split("/")[0]):
 227             raise HTTPException(status_code=500, detail="Invalid domain")
 228
 229         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/index.json?domain={domain}")
 230     elif reason is not None:
 231         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/index.json?reason={reason}")
 232     elif reverse is not None:
 233         reverse = tidyup.domain(reverse)
 234         if not validators.domain(reverse):
 235             raise HTTPException(status_code=500, detail="Invalid domain")
 236
 237         response = requests.get(f"http://{config.get('host')}:{config.get('port')}{config.get('base_url')}/api/index.json?reverse={reverse}")
 238
 239     if response is not None:
 240         if not response.ok:
 241             raise HTTPException(status_code=response.status_code, detail=response.text)
 242
 243         blocklist = response.json()
 244
 245         for block_level in blocklist:
 246             for block in blocklist[block_level]:
 247                 block["first_seen"] = datetime.utcfromtimestamp(block["first_seen"]).strftime(config.get("timestamp_format"))
 248                 block["last_seen"]  = datetime.utcfromtimestamp(block["last_seen"]).strftime(config.get("timestamp_format"))
 249
 250     return templates.TemplateResponse("views/top.html", {
 251         "request": request,
 252         "domain" : domain,
 253         "blocks" : blocklist,
 254         "reason" : reason,
 255         "reverse": reverse,
 256         "info"   : info
 257     })
 258
 259 @router.get(config.get("base_url") + "/rss")
 260 def rss(request: Request, domain: str = None):
 261     if domain is not None:
 262         domain = tidyup.domain(domain)
 263
 264         wildchar = "*." + ".".join(domain.split(".")[-domain.count("."):])
 265         punycode = domain.encode("idna").decode("utf-8")
 266
 267         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 ?", [
 268             domain,
 269             "*." + domain, wildchar,
 270             utils.get_hash(domain),
 271             punycode,
 272             "*." + punycode,
 273             config.get("rss_limit")
 274         ])
 275     else:
 276         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")])
 277
 278     result = database.cursor.fetchall()
 279     blocklist = []
 280
 281     for row in result:
 282         blocklist.append({
 283             "blocker"    : row[0],
 284             "blocked"    : row[1],
 285             "block_level": row[2],
 286             "reason"     : "Provided reason: '" + row[3] + "'" if row[3] is not None and row[3] != "" else "No reason provided.",
 287             "first_seen" : format_datetime(datetime.fromtimestamp(row[4])),
 288             "last_seen"  : format_datetime(datetime.fromtimestamp(row[5])),
 289         })
 290
 291     return templates.TemplateResponse("rss.xml", {
 292         "request"  : request,
 293         "timestamp": format_datetime(datetime.now()),
 294         "domain"   : domain,
 295         "hostname" : config.get("hostname"),
 296         "blocks"   : blocklist
 297     }, headers={
 298         "Content-Type": "routerlication/rss+xml"
 299     })
 300
 301 @router.get(config.get("base_url") + "/robots.txt", response_class=PlainTextResponse)
 302 def robots(request: Request):
 303     return templates.TemplateResponse("robots.txt", {
 304         "request" : request,
 305         "base_url": config.get("base_url")
 306     })
 307
 308 if __name__ == "__main__":
 309     uvicorn.run("api:router", host=config.get("host"), port=config.get("port"), log_level=config.get("log_level"))