mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
e52a507924
A configuration file may now declare which identity-provider subject signs
in as a declared user, as a fourth resource kind:
"linkedIdentities": [
{ "name": "users/admin/linkedIdentities/sso", "externalUid": "subject" }
]
An administrator on an SSO-only instance otherwise has no way in before the
first sign-in, which provisions a new account because the sign-in path
matches a provider and subject and nothing else. Matching an email or
username claim was rejected: neither proves ownership on this instance. A
declared subject trusts no claim, and the sign-in path is unchanged.
Rules: the user must be declared in the same configuration, a subject is
declared once, the provider must exist after apply, and a subject already
linked to a different user fails the plan rather than being taken over. A
link made by signing in with the declared subject is adopted; a different
stored subject is replaced. Links are written after users in the apply
transaction. A declared user with a declared link may be created without a
password; it gets an unusable random one, as SSO provisioning does.
The API refuses to create or delete a managed link, and to delete a
provider a declared link names. The account page hides Unlink for a
declared link. LinkedIdentity.external_uid is no longer output only.
158 lines
5.1 KiB
Go
158 lines
5.1 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/emptypb"
|
|
|
|
apipb "github.com/usememos/memos/proto/gen/api"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
func (s *APIService) ListLinkedIdentities(ctx context.Context, request *apipb.ListLinkedIdentitiesRequest) (*apipb.ListLinkedIdentitiesResponse, error) {
|
|
user, err := s.resolveUserFromName(ctx, request.Parent)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid parent: %v", err)
|
|
}
|
|
userID := user.ID
|
|
|
|
if _, err := s.authorizeUserResourceAccess(ctx, userID, true); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
identities, err := s.Store.ListUserIdentities(ctx, &store.FindUserIdentity{UserID: &userID})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to list linked identities: %v", err)
|
|
}
|
|
|
|
response := &apipb.ListLinkedIdentitiesResponse{
|
|
LinkedIdentities: []*apipb.LinkedIdentity{},
|
|
}
|
|
for _, identity := range identities {
|
|
response.LinkedIdentities = append(response.LinkedIdentities, convertLinkedIdentityFromStore(user, identity))
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
func (s *APIService) CreateLinkedIdentity(ctx context.Context, request *apipb.CreateLinkedIdentityRequest) (*apipb.LinkedIdentity, error) {
|
|
user, err := s.resolveUserFromName(ctx, request.Parent)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid parent: %v", err)
|
|
}
|
|
|
|
currentUser, err := s.fetchCurrentUser(ctx)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get current user: %v", err)
|
|
}
|
|
if currentUser == nil {
|
|
return nil, status.Errorf(codes.Unauthenticated, "user not authenticated")
|
|
}
|
|
if currentUser.ID != user.ID {
|
|
return nil, status.Errorf(codes.PermissionDenied, "permission denied")
|
|
}
|
|
|
|
identityProvider, userInfo, err := s.resolveSSOIdentity(ctx, request.IdentityProvider, request.Code, request.RedirectUri, request.CodeVerifier)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
provider := identityProvider.Uid
|
|
externUID := userInfo.Identifier
|
|
|
|
if err := s.checkManagedExistence(ctx, linkedIdentityName(user, provider)); err != nil {
|
|
return nil, err
|
|
}
|
|
if _, err := s.bindSSOIdentityToUser(ctx, currentUser, provider, externUID); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
identity, err := s.Store.GetUserIdentity(ctx, &store.FindUserIdentity{
|
|
UserID: ¤tUser.ID,
|
|
Provider: &provider,
|
|
})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get linked identity: %v", err)
|
|
}
|
|
if identity == nil {
|
|
return nil, status.Errorf(codes.Internal, "linked identity not found after creation")
|
|
}
|
|
|
|
return convertLinkedIdentityFromStore(user, identity), nil
|
|
}
|
|
|
|
func (s *APIService) GetLinkedIdentity(ctx context.Context, request *apipb.GetLinkedIdentityRequest) (*apipb.LinkedIdentity, error) {
|
|
user, provider, err := s.resolveUserAndLinkedIdentityProviderFromName(ctx, request.Name)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid linked identity name: %v", err)
|
|
}
|
|
userID := user.ID
|
|
|
|
if _, err := s.authorizeUserResourceAccess(ctx, userID, true); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
identity, err := s.Store.GetUserIdentity(ctx, &store.FindUserIdentity{
|
|
UserID: &userID,
|
|
Provider: &provider,
|
|
})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get linked identity: %v", err)
|
|
}
|
|
if identity == nil {
|
|
return nil, status.Errorf(codes.NotFound, "linked identity not found")
|
|
}
|
|
|
|
return convertLinkedIdentityFromStore(user, identity), nil
|
|
}
|
|
|
|
func (s *APIService) DeleteLinkedIdentity(ctx context.Context, request *apipb.DeleteLinkedIdentityRequest) (*emptypb.Empty, error) {
|
|
user, provider, err := s.resolveUserAndLinkedIdentityProviderFromName(ctx, request.Name)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid linked identity name: %v", err)
|
|
}
|
|
userID := user.ID
|
|
|
|
if _, err := s.authorizeUserResourceAccess(ctx, userID, true); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
existing, err := s.Store.GetUserIdentity(ctx, &store.FindUserIdentity{
|
|
UserID: &userID,
|
|
Provider: &provider,
|
|
})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get linked identity: %v", err)
|
|
}
|
|
if existing == nil {
|
|
return nil, status.Errorf(codes.NotFound, "linked identity not found")
|
|
}
|
|
if err := s.checkManagedExistence(ctx, linkedIdentityName(user, provider)); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := s.Store.DeleteUserIdentities(ctx, &store.DeleteUserIdentity{
|
|
UserID: &userID,
|
|
Provider: &provider,
|
|
}); err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to delete linked identity: %v", err)
|
|
}
|
|
return &emptypb.Empty{}, nil
|
|
}
|
|
|
|
// ListPersonalAccessTokens retrieves all Personal Access Tokens (PATs) for a user.
|
|
//
|
|
// Personal Access Tokens are used for:
|
|
// - Mobile app authentication
|
|
// - CLI tool authentication
|
|
// - API client authentication
|
|
// - Any programmatic access requiring Bearer token auth
|
|
//
|
|
// Security:
|
|
// - Only the token owner can list their tokens
|
|
// - Returns token metadata only (not the actual token value)
|
|
// - Invalid or expired tokens are filtered out
|
|
//
|
|
// Authentication: Required (session cookie or access token)
|
|
// Authorization: User can only list their own tokens.
|