π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package cast
import (
"context"
"encoding/base64"
"github.com/ente/museum/ente"
"github.com/ente/museum/ente/cast"
"github.com/ente/museum/pkg/controller/access"
castRepo "github.com/ente/museum/pkg/repo/cast"
"github.com/ente/museum/pkg/utils/auth"
"github.com/ente/museum/pkg/utils/network"
"github.com/ente/museum/pkg/utils/ua"
"github.com/ente/stacktrace"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"github.com/sirupsen/logrus"
)
type Controller struct {
CastRepo *castRepo.Repository
AccessCtrl access.Controller
}
const (
maxRegisterDeviceUserAgentBytes = 1000
maxEncryptedPayloadBytes = 2 * 1024
pqPublicKeyBytes = 1216
)
func NewController(castRepo *castRepo.Repository,
accessCtrl access.Controller,
) *Controller {
return &Controller{
CastRepo: castRepo,
AccessCtrl: accessCtrl,
}
}
func (c *Controller) RegisterDevice(ctx *gin.Context, request *cast.RegisterDeviceRequest) (string, error) {
if err := validatePQPublicKey(request.PQPublicKey); err != nil {
return "", err
}
ipAddress := network.GetClientIP(ctx)
userAgent := ctx.GetHeader("User-Agent")
if len(userAgent) > maxRegisterDeviceUserAgentBytes {
return "", ente.NewInternalError("user agent too long")
}
deviceName, err := ua.GetDeviceType(userAgent)
if deviceName == "" || err != nil {
logrus.WithFields(logrus.Fields{
"userAgent": userAgent,
"ip": ipAddress,
"err": err,
}).Warn("RegisterDevice: failed to get device type")
deviceName = ipAddress
}
return c.CastRepo.AddCode(ctx, request.PublicKey, request.PQPublicKey, ipAddress, deviceName)
}
func validatePQPublicKey(publicKey *string) error {
if publicKey == nil {
return nil
}
if len(*publicKey) != base64.StdEncoding.EncodedLen(pqPublicKeyBytes) {
return stacktrace.Propagate(ente.ErrBadRequest, "invalid pqPublicKey length")
}
decoded, err := base64.StdEncoding.Strict().DecodeString(*publicKey)
if err != nil || len(decoded) != pqPublicKeyBytes {
return stacktrace.Propagate(ente.ErrBadRequest, "invalid pqPublicKey")
}
return nil
}
func (c *Controller) GetAllDevices(ctx *gin.Context, userID int64) ([]cast.CastInfo, error) {
return c.CastRepo.GetAllDevices(ctx, userID)
}
func (c *Controller) DeleteDevice(ctx *gin.Context, userID int64, deviceID uuid.UUID) error {
return c.CastRepo.RevokeForGivenUserAndDevice(ctx, userID, deviceID)
}
func (c *Controller) GetDeviceInfo(ctx *gin.Context, deviceCode string) (*cast.DeviceInfo, error) {
deviceInfo, ip, err := c.CastRepo.GetDeviceInfoAndIP(ctx, deviceCode)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
if ip != network.GetClientIP(ctx) {
logrus.WithFields(logrus.Fields{
"deviceCode": deviceCode,
"ip": ip,
"clientIP": network.GetClientIP(ctx),
}).Warn("GetDeviceInfo: IP mismatch")
}
return deviceInfo, nil
}
func (c *Controller) GetEncCastData(ctx context.Context, deviceCode string) (*string, error) {
return c.CastRepo.GetEncCastData(ctx, deviceCode)
}
func (c *Controller) InsertCastData(ctx *gin.Context, request *cast.CastRequest) (uuid.UUID, error) {
if len(request.EncPayload) > maxEncryptedPayloadBytes {
return uuid.Nil, stacktrace.Propagate(ente.ErrBadRequest, "encrypted payload too large")
}
userID := auth.GetUserID(ctx.Request.Header)
devices, err := c.CastRepo.GetAllDevices(ctx, userID)
if err != nil {
return uuid.Nil, stacktrace.Propagate(err, "failed to get existing devices")
}
if len(devices) >= 50 {
return uuid.Nil, stacktrace.NewError("device limit reached")
}
return c.CastRepo.InsertCastData(ctx, userID, request.DeviceCode, request.CollectionID, request.CastToken, request.EncPayload)
}
func (c *Controller) RevokeAllToken(ctx *gin.Context) error {
userID := auth.GetUserID(ctx.Request.Header)
return c.CastRepo.RevokeTokenForUser(ctx, userID)
}
func (c *Controller) GetCollectionAndCasterIDForToken(ctx *gin.Context, token string) (*cast.AuthContext, error) {
collectId, userId, err := c.CastRepo.GetCollectionAndCasterIDForToken(ctx, token)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
_, err = c.AccessCtrl.GetCollection(ctx, &access.GetCollectionParams{CollectionID: collectId, ActorUserID: userId})
if err != nil {
return nil, stacktrace.Propagate(err, "failed to verify cast access")
}
go c.CastRepo.UpdateLastUsedAtForToken(ctx, token)
return &cast.AuthContext{UserID: userId, CollectionID: collectId}, nil
}