forked from longtao.wu/droboticflow
306 lines
12 KiB
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,
|
|
})
|
|
}
|