droboticflow/internal/api/object_sync_access_keys.go

306 lines
12 KiB
Go

package api
import (
"context"
"net/http"
"strings"
"time"
"droboticflow/internal/domain"
"droboticflow/internal/store"
)
func (server *server) normalizeObjectSyncCredentialScopes(
ctx context.Context,
target store.ObjectSyncStore,
organizationID string,
scopes []domain.ObjectSyncCredentialScope,
) ([]domain.ObjectSyncCredentialScope, error) {
if len(scopes) == 0 || len(scopes) > 100 {
return nil, objectSyncInputError("between 1 and 100 credential scopes are required")
}
allowedActions := map[string]struct{}{
"plan": {},
"list_metadata": {},
"create": {},
"update": {},
"keep_both": {},
}
seenSpaces := make(map[string]struct{}, len(scopes))
normalized := make([]domain.ObjectSyncCredentialScope, 0, len(scopes))
for _, scope := range scopes {
scope.SyncSpaceID = strings.TrimSpace(scope.SyncSpaceID)
if scope.SyncSpaceID == "" {
return nil, objectSyncInputError("syncSpaceId is required for every credential scope")
}
if _, exists := seenSpaces[scope.SyncSpaceID]; exists {
return nil, objectSyncInputError("credential scopes must not repeat a sync space")
}
space, err := target.GetObjectSyncSpace(ctx, scope.SyncSpaceID)
if err != nil {
return nil, err
}
if space == nil || normalizedOrganizationID(space.OrganizationID) != normalizedOrganizationID(organizationID) {
return nil, objectSyncInputError("a credential scope refers to an unavailable sync space")
}
actionSeen := make(map[string]struct{}, len(scope.Actions))
actions := make([]string, 0, len(scope.Actions))
for _, value := range scope.Actions {
action := strings.ToLower(strings.TrimSpace(value))
if _, allowed := allowedActions[action]; !allowed {
return nil, objectSyncInputError("credential scope contains an unsupported action")
}
if _, duplicate := actionSeen[action]; duplicate {
continue
}
actionSeen[action] = struct{}{}
actions = append(actions, action)
}
if len(actions) == 0 {
return nil, objectSyncInputError("at least one action is required for every credential scope")
}
prefixSeen := make(map[string]struct{}, len(scope.AllowedRelativePrefixes))
prefixes := make([]string, 0, len(scope.AllowedRelativePrefixes))
for _, value := range scope.AllowedRelativePrefixes {
prefix := strings.Trim(strings.ReplaceAll(strings.TrimSpace(value), "\\", "/"), "/")
if prefix != "" {
validated, validateErr := normalizeObjectSyncRelativePath(prefix)
if validateErr != nil {
return nil, objectSyncInputError("credential scope contains an invalid relative prefix")
}
prefix = validated
}
if _, duplicate := prefixSeen[prefix]; duplicate {
continue
}
prefixSeen[prefix] = struct{}{}
prefixes = append(prefixes, prefix)
}
seenSpaces[scope.SyncSpaceID] = struct{}{}
normalized = append(normalized, domain.ObjectSyncCredentialScope{
SyncSpaceID: scope.SyncSpaceID,
AllowedRelativePrefixes: prefixes,
Actions: actions,
})
}
return normalized, nil
}
type objectSyncInputError string
func (err objectSyncInputError) Error() string {
return string(err)
}
func (server *server) handleObjectSyncCredentialCreate(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
principal := objectSyncManagementPrincipal(request)
var input struct {
Name string `json:"name"`
Scopes []domain.ObjectSyncCredentialScope `json:"scopes"`
}
if !decodeJSON(writer, request, &input) {
return
}
input.Name = strings.TrimSpace(input.Name)
if input.Name == "" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_credential", "name is required", false, nil)
return
}
scopes, err := server.normalizeObjectSyncCredentialScopes(request.Context(), target, principal.User.OrganizationID, input.Scopes)
if err != nil {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_credential_scope", err.Error(), false, nil)
return
}
secretToken, err := randomURLToken(32)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
secret := "dss_" + secretToken
secretHash, err := hashObjectSyncSecret(secret)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
now := nowISO()
item := domain.ObjectSyncCredentialRecord{
ID: objectSyncNewID("odc"),
OrganizationID: principal.User.OrganizationID,
Name: input.Name,
Enabled: true,
AccessKeyID: objectSyncNewID("dsk"),
SecretHash: secretHash,
SecretPreview: objectSyncSecretPreview(secret),
Scopes: scopes,
CreatedAt: now,
UpdatedAt: now,
}
if err := target.UpsertObjectSyncCredential(request.Context(), item); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: item.OrganizationID,
ActorType: "user",
ActorID: principal.User.ID,
RequestID: objectSyncRequestID(request),
Action: "credential.create",
Target: map[string]any{"credentialId": item.ID, "accessKeyId": item.AccessKeyID},
Result: "success",
}) {
return
}
renderJSON(writer, http.StatusCreated, map[string]any{
"credential": sanitizeObjectSyncCredential(item),
"secret": secret,
})
}
func (server *server) handleExternalObjectSyncAccessKeyAuth(writer http.ResponseWriter, request *http.Request) {
target, ok := server.objectSyncStore(writer, request)
if !ok {
return
}
var input struct {
AuthenticationProtocol string `json:"authenticationProtocol"`
RecoverDevice bool `json:"recoverDevice"`
AccessKeyID string `json:"accessKeyId"`
Secret string `json:"secret"`
DeviceID string `json:"deviceId"`
DeviceName string `json:"deviceName"`
Platform string `json:"platform"`
Architecture string `json:"architecture"`
ClientVersion string `json:"clientVersion"`
}
if !decodeJSON(writer, request, &input) {
return
}
if input.AuthenticationProtocol != objectSyncAuthenticationProtocol {
renderObjectSyncError(writer, request, http.StatusBadRequest, "authentication_protocol_required", "Upgrade the client: activation-v1 authentication is required", false, nil)
return
}
input.AccessKeyID = strings.TrimSpace(input.AccessKeyID)
input.Secret = strings.TrimSpace(input.Secret)
input.DeviceID = strings.TrimSpace(input.DeviceID)
input.DeviceName = strings.TrimSpace(input.DeviceName)
if input.AccessKeyID == "" || input.Secret == "" || input.DeviceID == "" {
renderObjectSyncError(writer, request, http.StatusBadRequest, "invalid_access_key_auth", "accessKeyId, secret and deviceId are required", false, nil)
return
}
credential, err := target.GetObjectSyncCredentialByAccessKeyID(request.Context(), input.AccessKeyID)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_lookup_failed", err.Error(), true, nil)
return
}
if credential == nil || !credential.Enabled || credential.SecretHash == "" || !verifyObjectSyncSecret(input.Secret, credential.SecretHash) {
renderObjectSyncError(writer, request, http.StatusUnauthorized, "credential_invalid", "The drosync access key or secret is invalid or revoked", false, nil)
return
}
device, err := target.GetObjectSyncDevice(request.Context(), input.DeviceID)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_lookup_failed", err.Error(), true, nil)
return
}
if input.RecoverDevice && device == nil {
renderObjectSyncError(writer, request, 404, "recovery_device_not_found", "The recovery device ID does not exist; no new identity was created", false, nil)
return
}
if device == nil {
devices, listErr := target.ListObjectSyncDevices(request.Context(), credential.OrganizationID)
if listErr != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_quota_check_failed", listErr.Error(), true, nil)
return
}
if len(devices) >= objectSyncMaxOrgDevices {
renderObjectSyncError(writer, request, http.StatusConflict, "device_quota_exceeded", "The organization has reached its 500-device limit", false, map[string]any{"limit": objectSyncMaxOrgDevices})
return
}
device = &domain.ObjectSyncDeviceRecord{
ID: input.DeviceID,
OrganizationID: credential.OrganizationID,
CreatedAt: nowISO(),
}
}
if normalizedOrganizationID(device.OrganizationID) != normalizedOrganizationID(credential.OrganizationID) {
renderObjectSyncError(writer, request, http.StatusForbidden, "device_organization_mismatch", "The device belongs to a different organization", false, nil)
return
}
// Re-authentication may restore the same device, but may not strand its
// active sessions under a different credential authority.
cursor := ""
for {
page, listErr := target.ListObjectSyncSessions(request.Context(), domain.ObjectSyncListQuery{OrganizationID: credential.OrganizationID, DeviceID: input.DeviceID, ActiveOnly: true, Cursor: cursor, Limit: 1000})
if listErr != nil {
renderObjectSyncError(writer, request, http.StatusServiceUnavailable, "active_sessions_lookup_failed", "Could not verify device session ownership", true, nil)
return
}
for _, session := range page.Items {
if session.DeviceID != device.ID || session.CredentialID == credential.ID {
continue
}
switch session.Status {
case domain.ObjectSyncSessionCompleted, domain.ObjectSyncSessionPartial, domain.ObjectSyncSessionConflicted, domain.ObjectSyncSessionAborted, domain.ObjectSyncSessionExpired, domain.ObjectSyncSessionFailed:
continue
}
renderObjectSyncError(writer, request, http.StatusConflict, "active_sessions_different_credential", "Finish or cancel the device's sessions using the original credential before changing keys", false, nil)
return
}
if page.NextCursor == "" {
break
}
cursor = page.NextCursor
}
token, err := randomURLToken(32)
if err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
now := nowISO()
device.Name = input.DeviceName
if device.Name == "" {
device.Name = input.DeviceID
}
device.Platform = strings.TrimSpace(input.Platform)
device.Architecture = strings.TrimSpace(input.Architecture)
device.ClientVersion = strings.TrimSpace(input.ClientVersion)
device.Status = "active"
device.LastSeenAt = now
device.UpdatedAt = now
activationID := objectSyncNewID("activation")
expiresAt := time.Now().UTC().Add(10 * time.Minute).Format(time.RFC3339Nano)
binding := domain.ObjectSyncCredentialTokenBinding{TokenHash: sessionTokenHash(token), DeviceID: device.ID, CreatedAt: now, Pending: true, ActivationID: activationID, ExpiresAt: expiresAt}
credential.LastUsedAt = now
credential.UpdatedAt = now
if err := target.RegisterObjectSyncDevice(request.Context(), *device); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_save_failed", err.Error(), true, nil)
return
}
if err := target.AddObjectSyncPendingToken(request.Context(), credential.ID, credential.SecretHash, binding); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "credential_issue_failed", err.Error(), true, nil)
return
}
if !server.requireObjectSyncAudit(writer, request, target, domain.ObjectSyncAuditEvent{
OrganizationID: credential.OrganizationID,
ActorType: "device",
ActorID: device.ID,
CredentialID: credential.ID,
DeviceID: device.ID,
RequestID: objectSyncRequestID(request),
Action: "credential.authenticate",
Target: map[string]any{"credentialId": credential.ID, "accessKeyId": credential.AccessKeyID},
Result: "success",
}) {
return
}
renderJSON(writer, http.StatusOK, map[string]any{
"accessToken": token,
"activationRequired": true, "activationId": activationID, "expiresAt": expiresAt,
"device": device,
"scopes": credential.Scopes,
})
}