π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package controller
import (
"context"
"crypto/hpke"
"encoding/base64"
"encoding/json"
"errors"
"io"
"net/http"
"strings"
"sync/atomic"
"testing"
"github.com/ente/museum/ente"
"github.com/ente/museum/internal/testutil"
"github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/auth"
log "github.com/sirupsen/logrus"
logtest "github.com/sirupsen/logrus/hooks/test"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
type roundTripFunc func(*http.Request) (*http.Response, error)
func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func jsonResponse(status int, body string) *http.Response {
return &http.Response{
StatusCode: status,
Body: io.NopCloser(strings.NewReader(body)),
Header: make(http.Header),
}
}
type wireMsg struct {
Message struct {
Token string `json:"token"`
Data map[string]string `json:"data"`
Android struct {
Priority string `json:"priority"`
} `json:"android"`
APNS struct {
Headers map[string]string `json:"headers"`
Payload struct {
Aps struct {
ContentAvailable int `json:"content-available"`
} `json:"aps"`
} `json:"payload"`
} `json:"apns"`
} `json:"message"`
}
func TestFCMSendBuildsV1Request(t *testing.T) {
var captured *http.Request
var body []byte
c := &fcmClient{
projectID: "proj-123",
httpClient: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
captured = r
body, _ = io.ReadAll(r.Body)
return jsonResponse(http.StatusOK, "{}"), nil
})},
}
err := c.send(context.Background(), "device-token-abc", map[string]string{"action": "sync"})
require.NoError(t, err)
require.Equal(t, http.MethodPost, captured.Method)
require.Equal(t, "https://fcm.googleapis.com/v1/projects/proj-123/messages:send", captured.URL.String())
require.Equal(t, "application/json", captured.Header.Get("Content-Type"))
var msg wireMsg
require.NoError(t, json.Unmarshal(body, &msg))
require.Equal(t, "device-token-abc", msg.Message.Token)
require.Equal(t, map[string]string{"action": "sync"}, msg.Message.Data)
require.Equal(t, "high", msg.Message.Android.Priority)
require.Equal(t, map[string]string{
"apns-push-type": "background",
"apns-priority": "5",
"apns-topic": "io.ente.frame",
}, msg.Message.APNS.Headers)
require.Equal(t, 1, msg.Message.APNS.Payload.Aps.ContentAvailable)
}
func TestFCMSendNon200ReturnsError(t *testing.T) {
c := &fcmClient{
projectID: "p",
httpClient: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
return jsonResponse(http.StatusNotFound, `{"error":"not found"}`), nil
})},
}
err := c.send(context.Background(), "tok", map[string]string{"action": "sync"})
require.Error(t, err)
require.Contains(t, err.Error(), "404")
}
func TestSendFCMPushesCountsResults(t *testing.T) {
hook := captureLogs(t)
var requests int64
pc := &PushController{fcm: &fcmClient{
projectID: "p",
httpClient: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
atomic.AddInt64(&requests, 1)
b, _ := io.ReadAll(r.Body)
var m wireMsg
_ = json.Unmarshal(b, &m)
if strings.HasPrefix(m.Message.Token, "bad") {
return jsonResponse(http.StatusBadRequest, `{"error":"bad"}`), nil
}
return jsonResponse(http.StatusOK, "{}"), nil
})},
}}
tokens := []ente.PushToken{{FCMToken: "good-1"}, {FCMToken: "good-2"}, {FCMToken: "bad-3"}}
require.NoError(t, pc.sendFCMPushes(tokens, map[string]string{"action": "sync"}))
require.Equal(t, int64(3), atomic.LoadInt64(&requests))
require.True(t, hasLog(hook, log.InfoLevel, "success count: 2, failure count: 1"))
require.False(t, hasLog(hook, log.ErrorLevel, "Failed to send any pushes"))
}
func TestSendFCMPushesTotalFailureLogsError(t *testing.T) {
hook := captureLogs(t)
pc := &PushController{fcm: &fcmClient{
projectID: "p",
httpClient: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
return jsonResponse(http.StatusBadRequest, `{"error":"bad"}`), nil
})},
}}
tokens := []ente.PushToken{{FCMToken: "a"}, {FCMToken: "b"}}
require.NoError(t, pc.sendFCMPushes(tokens, map[string]string{"action": "sync"}))
require.True(t, hasLog(hook, log.ErrorLevel, "Failed to send any pushes to 2 devices"))
}
const fcmUnregisteredBody = `{"error":{"code":404,"status":"NOT_FOUND","message":"Requested entity was not found.","details":[{"@type":"type.googleapis.com/google.firebase.fcm.v1.FcmError","errorCode":"UNREGISTERED"}]}}`
const fcmInvalidArgumentBody = `{"error":{"code":400,"status":"INVALID_ARGUMENT","message":"The registration token is not a valid FCM registration token","details":[{"@type":"type.googleapis.com/google.firebase.fcm.v1.FcmError","errorCode":"INVALID_ARGUMENT"},{"@type":"type.googleapis.com/google.rpc.BadRequest","fieldViolations":[{"field":"message.token","description":"The registration token is not a valid FCM registration token"}]}]}}`
func TestFCMSendClassifiesUnregistered(t *testing.T) {
c := &fcmClient{
projectID: "p",
httpClient: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
return jsonResponse(http.StatusNotFound, fcmUnregisteredBody), nil
})},
}
err := c.send(context.Background(), "tok", map[string]string{"action": "sync"})
require.Error(t, err)
require.True(t, errors.Is(err, errUnregisteredToken))
}
func TestFCMSendDoesNotClassifyInvalidArgumentAsUnregistered(t *testing.T) {
c := &fcmClient{
projectID: "p",
httpClient: &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
return jsonResponse(http.StatusBadRequest, fcmInvalidArgumentBody), nil
})},
}
err := c.send(context.Background(), "tok", map[string]string{"action": "sync"})
require.Error(t, err)
require.False(t, errors.Is(err, errUnregisteredToken))
}
func TestAlbumShareSendsOnlyEnrolledAndroidDevices(t *testing.T) {
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
testutil.InsertUser(t, db, testutil.UserFixture{UserID: 1, Email: "[email protected]", CreationTime: 1})
_, err := db.Exec(`INSERT INTO remote_store(user_id,key_name,key_value) VALUES(1,'internalUser','true')`)
require.NoError(t, err)
require.NoError(t, (&repo.UserAuthRepository{DB: db}).AddToken(1, ente.Photos, "session", "", ""))
hash := auth.HashToken("session")
controller := &PushController{PushRepo: &repo.PushTokenRepository{DB: db}}
key, err := hpke.MLKEM768X25519().GenerateKey()
require.NoError(t, err)
for _, platform := range []string{"ios", "android"} {
require.NoError(t, controller.AddToken(1, hash[:], ente.PushTokenRequest{
FCMToken: platform + "-device", Platform: &platform, NotificationKey: key.PublicKey().Bytes(),
}))
}
var messages []map[string]any
controller.fcm = &fcmClient{projectID: "test-project", httpClient: &http.Client{Transport: roundTripFunc(func(request *http.Request) (*http.Response, error) {
require.NoError(t, request.Context().Err())
var envelope struct {
Message map[string]any `json:"message"`
}
require.NoError(t, json.NewDecoder(request.Body).Decode(&envelope))
messages = append(messages, envelope.Message)
return jsonResponse(http.StatusOK, "{}"), nil
})}}
ctx, cancel := context.WithCancel(context.Background())
cancel()
controller.NotifyAlbumShare(ctx, []int64{1})
require.Len(t, messages, 1)
require.Equal(t, "android-device", messages[0]["token"])
require.Equal(t, map[string]any{"priority": "high", "ttl": "86400s"}, messages[0]["android"])
}
func TestAlbumShareEncryptsForEachEnrolledDevice(t *testing.T) {
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
testutil.InsertUser(t, db, testutil.UserFixture{UserID: 8, Email: "[email protected]", CreationTime: 1})
require.NoError(t, (&repo.UserAuthRepository{DB: db}).AddToken(8, ente.Photos, "session", "", ""))
hash := auth.HashToken("session")
platform := "android"
c := &PushController{PushRepo: &repo.PushTokenRepository{DB: db}}
keys := make(map[string]hpke.PrivateKey)
for _, token := range []string{"first-device", "second-device"} {
key, err := hpke.MLKEM768X25519().GenerateKey()
require.NoError(t, err)
keys[token] = key
require.NoError(t, c.AddToken(8, hash[:], ente.PushTokenRequest{
FCMToken: token, Platform: &platform, NotificationKey: key.PublicKey().Bytes(),
}))
}
require.NoError(t, c.AddToken(8, hash[:], ente.PushTokenRequest{FCMToken: "legacy", Platform: &platform}))
var messages []wireMsg
c.fcm = &fcmClient{projectID: "test-project", httpClient: &http.Client{Transport: roundTripFunc(func(request *http.Request) (*http.Response, error) {
var message wireMsg
require.NoError(t, json.NewDecoder(request.Body).Decode(&message))
messages = append(messages, message)
return jsonResponse(http.StatusOK, "{}"), nil
})}}
c.NotifyAlbumShare(context.Background(), []int64{8})
require.Len(t, messages, 2, "devices without a key must receive no push")
for _, envelope := range messages {
message := envelope.Message
require.Contains(t, keys, message.Token)
require.Contains(t, message.Data, "notificationCiphertext")
ciphertext, err := base64.StdEncoding.DecodeString(message.Data["notificationCiphertext"])
require.NoError(t, err)
plaintext, err := hpke.Open(keys[message.Token], hpke.HKDFSHA256(), hpke.ChaCha20Poly1305(), []byte("ente-push"), ciphertext)
require.NoError(t, err)
require.JSONEq(t, `{"eventType":"album_shared"}`, string(plaintext))
}
// Removing a device key must stop album-share pushes to that device.
require.NoError(t, c.AddToken(8, hash[:], ente.PushTokenRequest{FCMToken: "first-device", Platform: &platform}))
messages = nil
c.NotifyAlbumShare(context.Background(), []int64{8})
require.Len(t, messages, 1)
require.Equal(t, "second-device", messages[0].Message.Token)
}
func TestAlbumSharePrunesOnlyUnregisteredTokens(t *testing.T) {
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
testutil.InsertUser(t, db, testutil.UserFixture{UserID: 1, Email: "[email protected]", CreationTime: 1})
_, err := db.Exec(`INSERT INTO remote_store(user_id,key_name,key_value) VALUES(1,'internalUser','true')`)
require.NoError(t, err)
require.NoError(t, (&repo.UserAuthRepository{DB: db}).AddToken(1, ente.Photos, "session", "", ""))
hash := auth.HashToken("session")
platform := "android"
controller := &PushController{PushRepo: &repo.PushTokenRepository{DB: db}}
responses := map[string]struct {
status int
body string
}{
"active": {http.StatusOK, "{}"},
"unregistered": {http.StatusNotFound, fcmUnregisteredBody},
"unavailable": {http.StatusServiceUnavailable, "unavailable"},
"unauthorized": {http.StatusUnauthorized, "unauthorized"},
"invalid-argument": {http.StatusBadRequest, fcmInvalidArgumentBody},
}
key, err := hpke.MLKEM768X25519().GenerateKey()
require.NoError(t, err)
for token := range responses {
require.NoError(t, controller.AddToken(1, hash[:], ente.PushTokenRequest{
FCMToken: token, Platform: &platform, NotificationKey: key.PublicKey().Bytes(),
}))
}
var attempted []string
controller.fcm = &fcmClient{projectID: "test-project", httpClient: &http.Client{Transport: roundTripFunc(func(request *http.Request) (*http.Response, error) {
var message wireMsg
require.NoError(t, json.NewDecoder(request.Body).Decode(&message))
attempted = append(attempted, message.Message.Token)
response := responses[message.Message.Token]
return jsonResponse(response.status, response.body), nil
})}}
controller.NotifyAlbumShare(context.Background(), []int64{1})
require.ElementsMatch(t, []string{"active", "unregistered", "unavailable", "unauthorized", "invalid-argument"}, attempted)
var unregisteredExists bool
require.NoError(t, db.QueryRow(`SELECT EXISTS(SELECT 1 FROM push_tokens WHERE fcm_token='unregistered')`).Scan(&unregisteredExists))
require.False(t, unregisteredExists)
attempted = nil
controller.NotifyAlbumShare(context.Background(), []int64{1})
require.ElementsMatch(t, []string{"active", "unavailable", "unauthorized", "invalid-argument"}, attempted)
}
func TestAlbumShareHonorsSilentMode(t *testing.T) {
previous := viper.GetBool("internal.silent")
viper.Set("internal.silent", true)
t.Cleanup(func() { viper.Set("internal.silent", previous) })
controller := &PushController{fcm: &fcmClient{}}
controller.NotifyAlbumShare(context.Background(), []int64{1})
}
func captureLogs(t *testing.T) *logtest.Hook {
t.Helper()
logger := log.StandardLogger()
origHooks := logger.ReplaceHooks(make(log.LevelHooks))
origOut := logger.Out
logger.SetOutput(io.Discard)
hook := logtest.NewGlobal()
t.Cleanup(func() {
logger.ReplaceHooks(origHooks)
logger.SetOutput(origOut)
hook.Reset()
})
return hook
}
func hasLog(hook *logtest.Hook, level log.Level, substr string) bool {
for _, e := range hook.AllEntries() {
if e.Level == level && strings.Contains(e.Message, substr) {
return true
}
}
return false
}