Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
4.9 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {createHash} from 'node:crypto';
import {SsoIdentityRepository} from '@app/api/auth/services/SsoIdentityRepository';
import type {UserSsoIdentityRow} from '@app/api/database/types/AuthTypes';
import type {InstanceSsoConfig} from '@app/api/instance/InstanceConfigRepository';
import type {User} from '@app/api/models/User';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {UserTraits} from '@app/api/user/UserTraits';
import {UserFlags} from '@fluxer/constants/src/UserConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';

const SSO_IDENTITY_TRAIT_PREFIXES = ['sso:', 'sso_provider:', 'sso_identity:'];

export function ssoProviderIdOf(config: Pick<InstanceSsoConfig, 'issuer' | 'authorizationUrl'>): string {
	return config.issuer || config.authorizationUrl || 'sso';
}

export function ssoIdentityTrait(providerId: string, sub: string): string {
	const digest = createHash('sha256').update(providerId).update('\0').update(sub).digest('hex');
	return `sso_identity:${digest}`;
}

function ssoProviderTrait(providerId: string): string {
	return `sso_provider:${createHash('sha256').update(providerId).digest('hex').slice(0, 32)}`;
}

export function isLinkedToSsoProvider(user: User, providerId: string): boolean {
	return user.traits.has(`sso:${providerId}`) || user.traits.has(ssoProviderTrait(providerId));
}

export function ssoIdentityTraits(providerId: string, sub: string): Array<string> {
	return [UserTraits.SSO, `sso:${providerId}`, ssoProviderTrait(providerId), ssoIdentityTrait(providerId, sub)];
}

function withoutSsoIdentityTraits(traits: Iterable<string>): Set<string> {
	return new Set(
		Array.from(traits).filter(
			(trait) => trait !== UserTraits.SSO && !SSO_IDENTITY_TRAIT_PREFIXES.some((prefix) => trait.startsWith(prefix)),
		),
	);
}

function isLiveAccount(user: User | null): user is User {
	return user !== null && (user.flags & UserFlags.DELETED) === 0n;
}

export class SsoIdentityLinkService {
	private readonly identities = new SsoIdentityRepository();

	constructor(private readonly users: UserRepository) {}

	async unlink(user: User, providerId: string): Promise<Array<UserSsoIdentityRow>> {
		await this.releaseAll(user, providerId);
		await this.users.patchUpsert(user.id, {traits: withoutSsoIdentityTraits(user.traits)}, user.toRow());
		return this.identities.listForUser(user.id);
	}

	async link(user: User, providerId: string, subject: string): Promise<Array<UserSsoIdentityRow>> {
		const holder = await this.identities.findIdentity(providerId, subject);
		if (holder && holder.user_id !== user.id) {
			if (isLiveAccount(await this.users.findUnique(holder.user_id))) {
				throw InputValidationError.fromCode('subject', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);
			}
			await this.identities.releaseIdentity(providerId, subject);
		}
		await this.releaseAll(user, providerId);
		await this.identities.tryClaimIdentity({providerId, subject, userId: user.id, claimedAt: new Date()});
		const traits = withoutSsoIdentityTraits(user.traits);
		for (const trait of ssoIdentityTraits(providerId, subject)) {
			traits.add(trait);
		}
		await this.users.patchUpsert(user.id, {traits}, user.toRow());
		return this.identities.listForUser(user.id);
	}

	async migrate(fromProviderId: string, toProviderId: string): Promise<{moved: number; skipped: number}> {
		let moved = 0;
		let skipped = 0;
		for (const identity of await this.identities.listForProvider(fromProviderId)) {
			const user = await this.users.findUnique(identity.user_id);
			if (!user || !(await this.claimFor(toProviderId, identity))) {
				skipped += 1;
				continue;
			}
			await this.identities.releaseIdentity(fromProviderId, identity.subject);
			const traits = new Set(user.traits);
			for (const trait of ssoIdentityTraits(fromProviderId, identity.subject)) {
				traits.delete(trait);
			}
			for (const trait of ssoIdentityTraits(toProviderId, identity.subject)) {
				traits.add(trait);
			}
			await this.users.patchUpsert(user.id, {traits}, user.toRow());
			moved += 1;
		}
		return {moved, skipped};
	}

	private async releaseAll(user: User, providerId: string): Promise<void> {
		if ((await this.identities.releaseIdentitiesForUser(user.id)) > 0) return;
		for (const identity of await this.identities.listForProvider(providerId)) {
			if (identity.user_id === user.id) {
				await this.identities.releaseIdentity(identity.provider_id, identity.subject);
			}
		}
	}

	private async claimFor(providerId: string, identity: UserSsoIdentityRow): Promise<boolean> {
		const claimed = await this.identities.tryClaimIdentity({
			providerId,
			subject: identity.subject,
			userId: identity.user_id,
			claimedAt: identity.claimed_at,
		});
		return claimed || (await this.identities.findUserId(providerId, identity.subject)) === identity.user_id;
	}
}