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