droboticflow-new/internal/api/object_sync_access_keys.go

304 lines
11 KiB
Go

package api
import (
"context"
"net/http"
"strings"
"droboticflow/internal/domain"
"droboticflow/internal/store"
)
const objectSyncCredentialMaxActiveTokens = 500
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
}
placeholder, err := randomURLToken(32)
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),
TokenHash: sessionTokenHash(placeholder),
TokenPreview: 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 {
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
}
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 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
}
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
activeBindings := credential.TokenBindings[:0]
for _, binding := range credential.TokenBindings {
if binding.DeviceID != device.ID {
activeBindings = append(activeBindings, binding)
}
}
credential.TokenBindings = append(activeBindings, domain.ObjectSyncCredentialTokenBinding{
TokenHash: sessionTokenHash(token),
DeviceID: device.ID,
CreatedAt: now,
})
if len(credential.TokenBindings) > objectSyncCredentialMaxActiveTokens {
credential.TokenBindings = append(
[]domain.ObjectSyncCredentialTokenBinding(nil),
credential.TokenBindings[len(credential.TokenBindings)-objectSyncCredentialMaxActiveTokens:]...,
)
}
credential.LastUsedAt = now
credential.UpdatedAt = now
if err := target.UpsertObjectSyncDevice(request.Context(), *device); err != nil {
renderObjectSyncError(writer, request, http.StatusInternalServerError, "device_save_failed", err.Error(), true, nil)
return
}
if err := target.UpsertObjectSyncCredential(request.Context(), *credential); 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,
"device": device,
"scopes": credential.Scopes,
})
}
func (server *server) handleObjectSyncDeviceApprovalRemoved(writer http.ResponseWriter, request *http.Request) {
renderObjectSyncError(
writer,
request,
http.StatusGone,
"device_approval_removed",
"Device approval codes are not supported; create a scoped drosync access key and secret in Object Storage",
false,
nil,
)
}