mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-10-17 15:52:16 +02:00
* move finger to dereferencer * totally break GetRemoteAccount * start reworking finger func a bit * start reworking getRemoteAccount a bit * move mention parts to namestring * rework webfingerget * use util function to extract webfinger parts * use accountDomain * rework finger again, final form * just a real nasty commit, the worst * remove refresh from account * use new ASRepToAccount signature * fix incorrect debug call * fix for new getRemoteAccount * rework GetRemoteAccount * start updating tests to remove repetition * break a lot of tests Move shared test logic into the testrig, rather than having it scattered all over the place. This allows us to just mock the transport controller once, and have all tests use it (unless they need not to for some other reason). * fix up tests to use main mock httpclient * webfinger only if necessary * cheeky linting with the lads * update mentionName regex recognize instance accounts * don't finger instance accounts * test webfinger part extraction * increase default worker count to 4 per cpu * don't repeat regex parsing * final search for discovered accountDomain * be more permissive in namestring lookup * add more extraction tests * simplify GetParseMentionFunc * skip long search if local account * fix broken test
426 lines
16 KiB
Go
426 lines
16 KiB
Go
/*
|
|
GoToSocial
|
|
Copyright (C) 2021-2022 GoToSocial Authors admin@gotosocial.org
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package federation
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/superseriousbusiness/activity/pub"
|
|
"github.com/superseriousbusiness/activity/streams"
|
|
"github.com/superseriousbusiness/activity/streams/vocab"
|
|
"github.com/superseriousbusiness/gotosocial/internal/ap"
|
|
"github.com/superseriousbusiness/gotosocial/internal/db"
|
|
"github.com/superseriousbusiness/gotosocial/internal/federation/dereferencing"
|
|
"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
|
|
"github.com/superseriousbusiness/gotosocial/internal/uris"
|
|
"github.com/superseriousbusiness/gotosocial/internal/util"
|
|
)
|
|
|
|
/*
|
|
GO FED FEDERATING PROTOCOL INTERFACE
|
|
FederatingProtocol contains behaviors an application needs to satisfy for the
|
|
full ActivityPub S2S implementation to be supported by this library.
|
|
It is only required if the client application wants to support the server-to-
|
|
server, or federating, protocol.
|
|
It is passed to the library as a dependency injection from the client
|
|
application.
|
|
*/
|
|
|
|
// PostInboxRequestBodyHook callback after parsing the request body for a federated request
|
|
// to the Actor's inbox.
|
|
//
|
|
// Can be used to set contextual information based on the Activity
|
|
// received.
|
|
//
|
|
// Only called if the Federated Protocol is enabled.
|
|
//
|
|
// Warning: Neither authentication nor authorization has taken place at
|
|
// this time. Doing anything beyond setting contextual information is
|
|
// strongly discouraged.
|
|
//
|
|
// If an error is returned, it is passed back to the caller of
|
|
// PostInbox. In this case, the DelegateActor implementation must not
|
|
// write a response to the ResponseWriter as is expected that the caller
|
|
// to PostInbox will do so when handling the error.
|
|
func (f *federator) PostInboxRequestBodyHook(ctx context.Context, r *http.Request, activity pub.Activity) (context.Context, error) {
|
|
// extract any other IRIs involved in this activity
|
|
otherInvolvedIRIs := []*url.URL{}
|
|
|
|
// check if the Activity itself has an 'inReplyTo'
|
|
if replyToable, ok := activity.(ap.ReplyToable); ok {
|
|
if inReplyToURI := ap.ExtractInReplyToURI(replyToable); inReplyToURI != nil {
|
|
otherInvolvedIRIs = append(otherInvolvedIRIs, inReplyToURI)
|
|
}
|
|
}
|
|
|
|
// now check if the Object of the Activity (usually a Note or something) has an 'inReplyTo'
|
|
if object := activity.GetActivityStreamsObject(); object != nil {
|
|
if replyToable, ok := object.(ap.ReplyToable); ok {
|
|
if inReplyToURI := ap.ExtractInReplyToURI(replyToable); inReplyToURI != nil {
|
|
otherInvolvedIRIs = append(otherInvolvedIRIs, inReplyToURI)
|
|
}
|
|
}
|
|
}
|
|
|
|
// check for Tos and CCs on Activity itself
|
|
if addressable, ok := activity.(ap.Addressable); ok {
|
|
if ccURIs, err := ap.ExtractCCs(addressable); err == nil {
|
|
otherInvolvedIRIs = append(otherInvolvedIRIs, ccURIs...)
|
|
}
|
|
if toURIs, err := ap.ExtractTos(addressable); err == nil {
|
|
otherInvolvedIRIs = append(otherInvolvedIRIs, toURIs...)
|
|
}
|
|
}
|
|
|
|
// and on the Object itself
|
|
if object := activity.GetActivityStreamsObject(); object != nil {
|
|
if addressable, ok := object.(ap.Addressable); ok {
|
|
if ccURIs, err := ap.ExtractCCs(addressable); err == nil {
|
|
otherInvolvedIRIs = append(otherInvolvedIRIs, ccURIs...)
|
|
}
|
|
if toURIs, err := ap.ExtractTos(addressable); err == nil {
|
|
otherInvolvedIRIs = append(otherInvolvedIRIs, toURIs...)
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove any duplicate entries in the slice we put together
|
|
deduped := util.UniqueURIs(otherInvolvedIRIs)
|
|
|
|
// clean any instances of the public URI since we don't care about that in this context
|
|
cleaned := []*url.URL{}
|
|
for _, u := range deduped {
|
|
if !pub.IsPublic(u.String()) {
|
|
cleaned = append(cleaned, u)
|
|
}
|
|
}
|
|
|
|
withOtherInvolvedIRIs := context.WithValue(ctx, ap.ContextOtherInvolvedIRIs, cleaned)
|
|
return withOtherInvolvedIRIs, nil
|
|
}
|
|
|
|
// AuthenticatePostInbox delegates the authentication of a POST to an
|
|
// inbox.
|
|
//
|
|
// If an error is returned, it is passed back to the caller of
|
|
// PostInbox. In this case, the implementation must not write a
|
|
// response to the ResponseWriter as is expected that the client will
|
|
// do so when handling the error. The 'authenticated' is ignored.
|
|
//
|
|
// If no error is returned, but authentication or authorization fails,
|
|
// then authenticated must be false and error nil. It is expected that
|
|
// the implementation handles writing to the ResponseWriter in this
|
|
// case.
|
|
//
|
|
// Finally, if the authentication and authorization succeeds, then
|
|
// authenticated must be true and error nil. The request will continue
|
|
// to be processed.
|
|
func (f *federator) AuthenticatePostInbox(ctx context.Context, w http.ResponseWriter, r *http.Request) (context.Context, bool, error) {
|
|
l := logrus.WithFields(logrus.Fields{
|
|
"func": "AuthenticatePostInbox",
|
|
"useragent": r.UserAgent(),
|
|
"url": r.URL.String(),
|
|
})
|
|
l.Trace("received request to authenticate")
|
|
|
|
if !uris.IsInboxPath(r.URL) {
|
|
return nil, false, fmt.Errorf("path %s was not an inbox path", r.URL.String())
|
|
}
|
|
|
|
username, err := uris.ParseInboxPath(r.URL)
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("could not parse path %s: %s", r.URL.String(), err)
|
|
}
|
|
|
|
if username == "" {
|
|
return nil, false, errors.New("username was empty")
|
|
}
|
|
|
|
receivingAccount, err := f.db.GetLocalAccountByUsername(ctx, username)
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("could not fetch receiving account with username %s: %s", username, err)
|
|
}
|
|
|
|
publicKeyOwnerURI, errWithCode := f.AuthenticateFederatedRequest(ctx, receivingAccount.Username)
|
|
if errWithCode != nil {
|
|
switch errWithCode.Code() {
|
|
case http.StatusUnauthorized, http.StatusForbidden, http.StatusBadRequest:
|
|
// if 400, 401, or 403, obey the interface by writing the header and bailing
|
|
w.WriteHeader(errWithCode.Code())
|
|
return ctx, false, nil
|
|
default:
|
|
// if not, there's been a proper error
|
|
return ctx, false, err
|
|
}
|
|
}
|
|
|
|
// authentication has passed, so add an instance entry for this instance if it hasn't been done already
|
|
i := >smodel.Instance{}
|
|
if err := f.db.GetWhere(ctx, []db.Where{{Key: "domain", Value: publicKeyOwnerURI.Host}}, i); err != nil {
|
|
if err != db.ErrNoEntries {
|
|
// there's been an actual error
|
|
return ctx, false, fmt.Errorf("error getting requesting account with public key id %s: %s", publicKeyOwnerURI.String(), err)
|
|
}
|
|
|
|
// we don't have an entry for this instance yet so dereference it
|
|
i, err = f.GetRemoteInstance(ctx, username, &url.URL{
|
|
Scheme: publicKeyOwnerURI.Scheme,
|
|
Host: publicKeyOwnerURI.Host,
|
|
})
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("could not dereference new remote instance %s during AuthenticatePostInbox: %s", publicKeyOwnerURI.Host, err)
|
|
}
|
|
|
|
// and put it in the db
|
|
if err := f.db.Put(ctx, i); err != nil {
|
|
return nil, false, fmt.Errorf("error inserting newly dereferenced instance %s: %s", publicKeyOwnerURI.Host, err)
|
|
}
|
|
}
|
|
|
|
requestingAccount, err := f.GetRemoteAccount(ctx, dereferencing.GetRemoteAccountParams{
|
|
RequestingUsername: username,
|
|
RemoteAccountID: publicKeyOwnerURI,
|
|
})
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("couldn't get requesting account %s: %s", publicKeyOwnerURI, err)
|
|
}
|
|
|
|
withRequesting := context.WithValue(ctx, ap.ContextRequestingAccount, requestingAccount)
|
|
withReceiving := context.WithValue(withRequesting, ap.ContextReceivingAccount, receivingAccount)
|
|
return withReceiving, true, nil
|
|
}
|
|
|
|
// Blocked should determine whether to permit a set of actors given by
|
|
// their ids are able to interact with this particular end user due to
|
|
// being blocked or other application-specific logic.
|
|
//
|
|
// If an error is returned, it is passed back to the caller of
|
|
// PostInbox.
|
|
//
|
|
// If no error is returned, but authentication or authorization fails,
|
|
// then blocked must be true and error nil. An http.StatusForbidden
|
|
// will be written in the wresponse.
|
|
//
|
|
// Finally, if the authentication and authorization succeeds, then
|
|
// blocked must be false and error nil. The request will continue
|
|
// to be processed.
|
|
func (f *federator) Blocked(ctx context.Context, actorIRIs []*url.URL) (bool, error) {
|
|
l := logrus.WithFields(logrus.Fields{
|
|
"func": "Blocked",
|
|
})
|
|
l.Debugf("entering BLOCKED function with IRI list: %+v", actorIRIs)
|
|
|
|
// check domain blocks first for the given actor IRIs
|
|
blocked, err := f.db.AreURIsBlocked(ctx, actorIRIs)
|
|
if err != nil {
|
|
return false, fmt.Errorf("error checking domain blocks of actorIRIs: %s", err)
|
|
}
|
|
if blocked {
|
|
return blocked, nil
|
|
}
|
|
|
|
// check domain blocks for any other involved IRIs
|
|
otherInvolvedIRIsI := ctx.Value(ap.ContextOtherInvolvedIRIs)
|
|
otherInvolvedIRIs, ok := otherInvolvedIRIsI.([]*url.URL)
|
|
if !ok {
|
|
l.Errorf("other involved IRIs not set on request context")
|
|
return false, errors.New("other involved IRIs not set on request context, so couldn't determine blocks")
|
|
}
|
|
blocked, err = f.db.AreURIsBlocked(ctx, otherInvolvedIRIs)
|
|
if err != nil {
|
|
return false, fmt.Errorf("error checking domain blocks of otherInvolvedIRIs: %s", err)
|
|
}
|
|
if blocked {
|
|
return blocked, nil
|
|
}
|
|
|
|
// now check for user-level block from receiving against requesting account
|
|
receivingAccountI := ctx.Value(ap.ContextReceivingAccount)
|
|
receivingAccount, ok := receivingAccountI.(*gtsmodel.Account)
|
|
if !ok {
|
|
l.Errorf("receiving account not set on request context")
|
|
return false, errors.New("receiving account not set on request context, so couldn't determine blocks")
|
|
}
|
|
requestingAccountI := ctx.Value(ap.ContextRequestingAccount)
|
|
requestingAccount, ok := requestingAccountI.(*gtsmodel.Account)
|
|
if !ok {
|
|
l.Errorf("requesting account not set on request context")
|
|
return false, errors.New("requesting account not set on request context, so couldn't determine blocks")
|
|
}
|
|
// the receiver shouldn't block the sender
|
|
blocked, err = f.db.IsBlocked(ctx, receivingAccount.ID, requestingAccount.ID, false)
|
|
if err != nil {
|
|
return false, fmt.Errorf("error checking user-level blocks: %s", err)
|
|
}
|
|
if blocked {
|
|
return blocked, nil
|
|
}
|
|
|
|
// get account IDs for other involved accounts
|
|
var involvedAccountIDs []string
|
|
for _, iri := range otherInvolvedIRIs {
|
|
var involvedAccountID string
|
|
if involvedStatus, err := f.db.GetStatusByURI(ctx, iri.String()); err == nil {
|
|
involvedAccountID = involvedStatus.AccountID
|
|
} else if involvedAccount, err := f.db.GetAccountByURI(ctx, iri.String()); err == nil {
|
|
involvedAccountID = involvedAccount.ID
|
|
}
|
|
|
|
if involvedAccountID != "" {
|
|
involvedAccountIDs = append(involvedAccountIDs, involvedAccountID)
|
|
}
|
|
}
|
|
deduped := util.UniqueStrings(involvedAccountIDs)
|
|
|
|
for _, involvedAccountID := range deduped {
|
|
// the involved account shouldn't block whoever is making this request
|
|
blocked, err = f.db.IsBlocked(ctx, involvedAccountID, requestingAccount.ID, false)
|
|
if err != nil {
|
|
return false, fmt.Errorf("error checking user-level otherInvolvedIRI blocks: %s", err)
|
|
}
|
|
if blocked {
|
|
return blocked, nil
|
|
}
|
|
|
|
// whoever is receiving this request shouldn't block the involved account
|
|
blocked, err = f.db.IsBlocked(ctx, receivingAccount.ID, involvedAccountID, false)
|
|
if err != nil {
|
|
return false, fmt.Errorf("error checking user-level otherInvolvedIRI blocks: %s", err)
|
|
}
|
|
if blocked {
|
|
return blocked, nil
|
|
}
|
|
}
|
|
|
|
return false, nil
|
|
}
|
|
|
|
// FederatingCallbacks returns the application logic that handles
|
|
// ActivityStreams received from federating peers.
|
|
//
|
|
// Note that certain types of callbacks will be 'wrapped' with default
|
|
// behaviors supported natively by the library. Other callbacks
|
|
// compatible with streams.TypeResolver can be specified by 'other'.
|
|
//
|
|
// For example, setting the 'Create' field in the
|
|
// FederatingWrappedCallbacks lets an application dependency inject
|
|
// additional behaviors they want to take place, including the default
|
|
// behavior supplied by this library. This is guaranteed to be compliant
|
|
// with the ActivityPub Social protocol.
|
|
//
|
|
// To override the default behavior, instead supply the function in
|
|
// 'other', which does not guarantee the application will be compliant
|
|
// with the ActivityPub Social Protocol.
|
|
//
|
|
// Applications are not expected to handle every single ActivityStreams
|
|
// type and extension. The unhandled ones are passed to DefaultCallback.
|
|
func (f *federator) FederatingCallbacks(ctx context.Context) (wrapped pub.FederatingWrappedCallbacks, other []interface{}, err error) {
|
|
wrapped = pub.FederatingWrappedCallbacks{
|
|
// OnFollow determines what action to take for this particular callback
|
|
// if a Follow Activity is handled.
|
|
//
|
|
// For our implementation, we always want to do nothing because we have internal logic for handling follows.
|
|
OnFollow: pub.OnFollowDoNothing,
|
|
}
|
|
|
|
// override some default behaviors and trigger our own side effects
|
|
other = []interface{}{
|
|
func(ctx context.Context, undo vocab.ActivityStreamsUndo) error {
|
|
return f.FederatingDB().Undo(ctx, undo)
|
|
},
|
|
func(ctx context.Context, accept vocab.ActivityStreamsAccept) error {
|
|
return f.FederatingDB().Accept(ctx, accept)
|
|
},
|
|
func(ctx context.Context, reject vocab.ActivityStreamsReject) error {
|
|
return f.FederatingDB().Reject(ctx, reject)
|
|
},
|
|
func(ctx context.Context, announce vocab.ActivityStreamsAnnounce) error {
|
|
return f.FederatingDB().Announce(ctx, announce)
|
|
},
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// DefaultCallback is called for types that go-fed can deserialize but
|
|
// are not handled by the application's callbacks returned in the
|
|
// Callbacks method.
|
|
//
|
|
// Applications are not expected to handle every single ActivityStreams
|
|
// type and extension, so the unhandled ones are passed to
|
|
// DefaultCallback.
|
|
func (f *federator) DefaultCallback(ctx context.Context, activity pub.Activity) error {
|
|
l := logrus.WithFields(logrus.Fields{
|
|
"func": "DefaultCallback",
|
|
"aptype": activity.GetTypeName(),
|
|
})
|
|
l.Debugf("received unhandle-able activity type so ignoring it")
|
|
return nil
|
|
}
|
|
|
|
// MaxInboxForwardingRecursionDepth determines how deep to search within
|
|
// an activity to determine if inbox forwarding needs to occur.
|
|
//
|
|
// Zero or negative numbers indicate infinite recursion.
|
|
func (f *federator) MaxInboxForwardingRecursionDepth(ctx context.Context) int {
|
|
// TODO
|
|
return 4
|
|
}
|
|
|
|
// MaxDeliveryRecursionDepth determines how deep to search within
|
|
// collections owned by peers when they are targeted to receive a
|
|
// delivery.
|
|
//
|
|
// Zero or negative numbers indicate infinite recursion.
|
|
func (f *federator) MaxDeliveryRecursionDepth(ctx context.Context) int {
|
|
// TODO
|
|
return 4
|
|
}
|
|
|
|
// FilterForwarding allows the implementation to apply business logic
|
|
// such as blocks, spam filtering, and so on to a list of potential
|
|
// Collections and OrderedCollections of recipients when inbox
|
|
// forwarding has been triggered.
|
|
//
|
|
// The activity is provided as a reference for more intelligent
|
|
// logic to be used, but the implementation must not modify it.
|
|
func (f *federator) FilterForwarding(ctx context.Context, potentialRecipients []*url.URL, a pub.Activity) ([]*url.URL, error) {
|
|
// TODO
|
|
return []*url.URL{}, nil
|
|
}
|
|
|
|
// GetInbox returns the OrderedCollection inbox of the actor for this
|
|
// context. It is up to the implementation to provide the correct
|
|
// collection for the kind of authorization given in the request.
|
|
//
|
|
// AuthenticateGetInbox will be called prior to this.
|
|
//
|
|
// Always called, regardless whether the Federated Protocol or Social
|
|
// API is enabled.
|
|
func (f *federator) GetInbox(ctx context.Context, r *http.Request) (vocab.ActivityStreamsOrderedCollectionPage, error) {
|
|
// IMPLEMENTATION NOTE: For GoToSocial, we serve GETS to outboxes and inboxes through
|
|
// the CLIENT API, not through the federation API, so we just do nothing here.
|
|
return streams.NewActivityStreamsOrderedCollectionPage(), nil
|
|
}
|