takahe/users/views/activitypub.py

362 lines
12 KiB
Python
Raw Normal View History

2022-11-13 04:14:21 +00:00
import json
import logging
from urllib.parse import urldefrag, urlparse
2022-11-13 04:14:21 +00:00
from django.conf import settings
from django.http import Http404, HttpResponse, HttpResponseBadRequest, JsonResponse
2022-11-13 04:14:21 +00:00
from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_control
2022-11-13 04:14:21 +00:00
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import View
from activities.models import Post
2023-05-13 16:01:27 +00:00
from activities.services import TimelineService
2022-12-05 17:55:30 +00:00
from core.decorators import cache_page
2022-11-13 04:14:21 +00:00
from core.ld import canonicalise
from core.models import Config
2022-11-13 04:14:21 +00:00
from core.signatures import (
HttpSignature,
LDSignature,
VerificationError,
VerificationFormatError,
)
from core.views import StaticContentView
from takahe import __version__
from users.models import Identity, InboxMessage, SystemActor
from users.models.domain import Domain
2022-11-13 04:14:21 +00:00
from users.shortcuts import by_handle_or_404
logger = logging.getLogger(__name__)
2022-11-13 04:14:21 +00:00
class HttpResponseUnauthorized(HttpResponse):
status_code = 401
class HostMeta(View):
"""
Returns a canned host-meta response
"""
def get(self, request):
return HttpResponse(
"""<?xml version="1.0" encoding="UTF-8"?>
<XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0">
<Link rel="lrdd" template="https://%s/.well-known/webfinger?resource={uri}"/>
</XRD>"""
% request.headers["host"],
content_type="application/xrd+xml",
2022-11-13 04:14:21 +00:00
)
class NodeInfo(View):
"""
Returns the well-known nodeinfo response, pointing to the 2.0 one
"""
def get(self, request):
host = request.META.get("HOST", settings.MAIN_DOMAIN)
return JsonResponse(
{
"links": [
{
"rel": "http://nodeinfo.diaspora.software/ns/schema/2.0",
"href": f"https://{host}/nodeinfo/2.0/",
}
]
}
)
2022-12-05 17:55:30 +00:00
@method_decorator(cache_page(), name="dispatch")
class NodeInfo2(View):
"""
Returns the nodeinfo 2.0 response
"""
def get(self, request):
# Fetch some user stats
if request.domain:
domain_config = Config.load_domain(request.domain)
local_identities = Identity.objects.filter(
local=True, domain=request.domain
).count()
local_posts = Post.objects.filter(
local=True, author__domain=request.domain
).count()
metadata = {"nodeName": domain_config.site_name}
else:
local_identities = Identity.objects.filter(local=True).count()
local_posts = Post.objects.filter(local=True).count()
metadata = {}
return JsonResponse(
{
"version": "2.0",
"software": {"name": "takahe", "version": __version__},
"protocols": ["activitypub"],
"services": {"outbound": [], "inbound": []},
"usage": {
"users": {"total": local_identities},
"localPosts": local_posts,
},
"openRegistrations": Config.system.signup_allowed,
"metadata": metadata,
}
)
2022-12-05 17:55:30 +00:00
@method_decorator(cache_page(), name="dispatch")
2022-11-13 04:14:21 +00:00
class Webfinger(View):
"""
Services webfinger requests
"""
def get(self, request):
resource = request.GET.get("resource")
if not resource:
return HttpResponseBadRequest("No resource specified")
2022-11-13 04:14:21 +00:00
if not resource.startswith("acct:"):
return HttpResponseBadRequest("Not an account resource")
handle = resource[5:]
if handle.startswith("__system__@"):
# They are trying to webfinger the system actor
actor = SystemActor()
else:
actor = by_handle_or_404(request, handle)
return JsonResponse(actor.to_webfinger(), content_type="application/jrd+json")
2022-11-13 04:14:21 +00:00
@method_decorator(csrf_exempt, name="dispatch")
class Inbox(View):
"""
AP Inbox endpoint
"""
2022-12-10 20:24:49 +00:00
def post(self, request, handle=None):
2022-12-28 03:01:00 +00:00
# Reject bodies that are unfeasibly big
if len(request.body) > settings.JSONLD_MAX_SIZE:
return HttpResponseBadRequest("Payload size too large")
2022-11-13 04:14:21 +00:00
# Load the LD
document = canonicalise(json.loads(request.body), include_security=True)
document_type = document["type"]
document_subtype = None
if isinstance(document.get("object"), dict):
document_subtype = document["object"].get("type")
2022-11-13 04:14:21 +00:00
# Find the Identity by the actor on the incoming item
# This ensures that the signature used for the headers matches the actor
# described in the payload.
if "actor" not in document:
logger.warning("Inbox error: unspecified actor")
return HttpResponseBadRequest("Unspecified actor")
identity = Identity.by_actor_uri(document["actor"], create=True, transient=True)
if (
document_type == "Delete"
and document["actor"] == document["object"]
2023-01-09 06:06:09 +00:00
and identity._state.adding
):
# We don't have an Identity record for the user. No-op
return HttpResponse(status=202)
# See if it's from a blocked user or domain - without calling
# fetch_actor, which would fetch data from potentially bad actor
domain = identity.domain
if not domain:
actor_url_parts = urlparse(document["actor"])
domain = Domain.get_remote_domain(actor_url_parts.hostname)
if identity.blocked or domain.recursively_blocked():
2022-11-26 01:11:31 +00:00
# I love to lie! Throw it away!
logger.info(
"Inbox: Discarded message from blocked %s %s",
"domain" if domain.recursively_blocked() else "user",
identity.actor_uri,
)
2022-11-26 01:11:31 +00:00
return HttpResponse(status=202)
# See if it's a type of message we know we want to ignore right now
# (e.g. Lemmy likes/dislikes, which we can't process anyway)
2023-11-12 19:35:11 +00:00
if document_type == "Announce" and document_subtype in [
"Like",
"Dislike",
"Create",
"Undo",
"Update",
]:
return HttpResponse(status=202)
# authenticate HTTP signature first, if one is present and the actor
# is already known to us. An invalid signature is an error and message
# should be discarded. NOTE: for previously unknown actors, we
# don't have their public key yet!
if "signature" in request:
2022-11-13 04:14:21 +00:00
try:
if identity.public_key:
HttpSignature.verify_request(
request,
identity.public_key,
)
logger.debug(
"Inbox: %s from %s has good HTTP signature",
document_type,
identity,
)
else:
logger.info(
"Inbox: New actor, no key available: %s",
document["actor"],
)
2022-11-13 04:14:21 +00:00
except VerificationFormatError as e:
logger.warning("Inbox error: Bad HTTP signature format: %s", e.args[0])
2022-11-13 04:14:21 +00:00
return HttpResponseBadRequest(e.args[0])
except VerificationError:
logger.warning("Inbox error: Bad HTTP signature from %s", identity)
2022-11-13 04:14:21 +00:00
return HttpResponseUnauthorized("Bad signature")
2022-12-17 02:42:48 +00:00
# Mastodon advices not implementing LD Signatures, but
# they're widely deployed today. Validate it if one exists.
# https://docs.joinmastodon.org/spec/security/#ld
if "signature" in document:
2022-11-13 04:14:21 +00:00
try:
# signatures are identified by the signature block
creator = urldefrag(document["signature"]["creator"]).url
creator_identity = Identity.by_actor_uri(
creator, create=True, transient=True
2022-11-13 04:14:21 +00:00
)
if not creator_identity.public_key:
logger.info("Inbox: New actor, no key available: %s", creator)
# if we can't verify it, we don't keep it
document.pop("signature")
else:
LDSignature.verify_signature(document, creator_identity.public_key)
logger.debug(
"Inbox: %s from %s has good LD signature",
document["type"],
creator_identity,
)
2022-11-13 04:14:21 +00:00
except VerificationFormatError as e:
logger.warning("Inbox error: Bad LD signature format: %s", e.args[0])
2022-11-13 04:14:21 +00:00
return HttpResponseBadRequest(e.args[0])
except VerificationError:
# An invalid LD Signature might also indicate nothing but
# a syntactical difference between implementations.
# Strip it out if we can't verify it.
if "signature" in document:
document.pop("signature")
logger.info(
"Inbox: Stripping invalid LD signature from %s %s",
creator_identity,
document["id"],
)
if not ("signature" in request or "signature" in document):
logger.debug(
"Inbox: %s from %s is unauthenticated. That's OK.",
document["type"],
identity,
)
2022-12-17 02:42:48 +00:00
# Don't allow injection of internal messages
if document["type"].startswith("__"):
return HttpResponseUnauthorized("Bad type")
2022-11-13 04:14:21 +00:00
# Hand off the item to be processed by the queue
InboxMessage.objects.create(message=document)
return HttpResponse(status=202)
class Outbox(View):
"""
The ActivityPub outbox for an identity
"""
def get(self, request, handle):
self.identity = by_handle_or_404(
self.request,
handle,
local=False,
fetch=True,
)
# If this not a local actor, 404
if not self.identity.local:
raise Http404("Not a local identity")
# Return an ordered collection with the most recent 10 public posts
posts = list(self.identity.posts.not_hidden().public()[:10])
return JsonResponse(
canonicalise(
{
"type": "OrderedCollection",
"totalItems": len(posts),
"orderedItems": [post.to_ap() for post in posts],
}
),
2023-05-13 16:01:27 +00:00
content_type="application/activity+json",
)
class FeaturedCollection(View):
"""
An ordered collection of all pinned posts of an identity
"""
def get(self, request, handle):
self.identity = by_handle_or_404(
request,
handle,
local=False,
fetch=True,
)
if not self.identity.local:
raise Http404("Not a local identity")
posts = list(TimelineService(self.identity).identity_pinned())
return JsonResponse(
canonicalise(
{
"type": "OrderedCollection",
"id": self.identity.actor_uri + "collections/featured/",
"totalItems": len(posts),
"orderedItems": [post.to_ap() for post in posts],
}
),
content_type="application/activity+json",
)
@method_decorator(cache_control(max_age=60 * 15), name="dispatch")
class EmptyOutbox(StaticContentView):
"""
A fixed-empty outbox for the system actor
"""
content_type: str = "application/activity+json"
def get_static_content(self) -> str | bytes:
return json.dumps(
canonicalise(
{
"type": "OrderedCollection",
"totalItems": 0,
"orderedItems": [],
}
)
)
@method_decorator(cache_control(max_age=60 * 15), name="dispatch")
class SystemActorView(StaticContentView):
"""
Special endpoint for the overall system actor
"""
content_type: str = "application/activity+json"
def get_static_content(self) -> str | bytes:
return json.dumps(
canonicalise(
SystemActor().to_ap(),
include_security=True,
)
)