A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
import type {ApiContext} from '@app/api/ApiContext';
import type {UserID} from '@app/api/BrandedTypes';
import {executeConditional, fetchMany} from '@app/api/database/CassandraQueryExecution';
import {
type AppAttestAgeAccepted,
type AppAttestOutcome,
type AppAttestRejectionCode,
createUsersServiceClient,
type PlayIntegrityOutcome,
type PlayIntegrityRejectionCode,
} from '@app/api/infrastructure/UsersServiceClient';
import type {User} from '@app/api/models/User';
import {AppAttestKeyLookup, AppAttestKeys} from '@app/api/Tables';
import {settingsForAge} from '@app/api/user/DateOfBirth';
import {mapUserSettingsToResponse, mapUserToPrivateResponse} from '@app/api/user/UserMappers';
import {canUserAccessNsfwContent} from '@app/api/utils/AgeUtils';
import type {AppAttestChallengePurpose} from '@fluxer/constants/src/AgeAssuranceConstants';
import {AppAttestAssertionInvalidError} from '@fluxer/errors/src/domains/user/AppAttestAssertionInvalidError';
import {AppAttestAttestationInvalidError} from '@fluxer/errors/src/domains/user/AppAttestAttestationInvalidError';
import {AppAttestChallengeInvalidError} from '@fluxer/errors/src/domains/user/AppAttestChallengeInvalidError';
import {AppAttestKeyInUseError} from '@fluxer/errors/src/domains/user/AppAttestKeyInUseError';
import {AppAttestKeyNotRegisteredError} from '@fluxer/errors/src/domains/user/AppAttestKeyNotRegisteredError';
import {AppAttestNotAvailableError} from '@fluxer/errors/src/domains/user/AppAttestNotAvailableError';
import {AppAttestRequestInvalidError} from '@fluxer/errors/src/domains/user/AppAttestRequestInvalidError';
import {PlayIntegrityAppNotRecognizedError} from '@fluxer/errors/src/domains/user/PlayIntegrityAppNotRecognizedError';
import {PlayIntegrityChallengeInvalidError} from '@fluxer/errors/src/domains/user/PlayIntegrityChallengeInvalidError';
import {PlayIntegrityDeviceNotTrustedError} from '@fluxer/errors/src/domains/user/PlayIntegrityDeviceNotTrustedError';
import {PlayIntegrityNotAvailableError} from '@fluxer/errors/src/domains/user/PlayIntegrityNotAvailableError';
import {PlayIntegrityRequestInvalidError} from '@fluxer/errors/src/domains/user/PlayIntegrityRequestInvalidError';
import {PlayIntegrityTokenInvalidError} from '@fluxer/errors/src/domains/user/PlayIntegrityTokenInvalidError';
import {PlayIntegrityUnavailableError} from '@fluxer/errors/src/domains/user/PlayIntegrityUnavailableError';
import type {
AgeAssuranceSubmitRequest,
AgeAssuranceSubmitResponse,
AppAttestChallengeResponse,
AppAttestKeyRegisterRequest,
PlayIntegrityAgeSubmitRequest,
} from '@fluxer/schema/src/domains/user/AgeAssuranceSchemas';
const FETCH_APP_ATTEST_KEYS_FOR_USER_CQL = AppAttestKeys.selectCql({
columns: ['key_id', 'app_id'],
where: AppAttestKeys.where.eq('user_id'),
});
function rejectionError(code: AppAttestRejectionCode): Error {
switch (code) {
case 'not_configured':
return new AppAttestNotAvailableError();
case 'invalid_request':
return new AppAttestRequestInvalidError();
case 'invalid_challenge':
return new AppAttestChallengeInvalidError();
case 'invalid_attestation':
return new AppAttestAttestationInvalidError();
case 'key_in_use':
return new AppAttestKeyInUseError();
case 'unknown_key':
return new AppAttestKeyNotRegisteredError();
case 'invalid_assertion':
return new AppAttestAssertionInvalidError();
}
}
function unwrap<T>(outcome: AppAttestOutcome<T>): T {
if (!outcome.ok) throw rejectionError(outcome.code);
return outcome.value;
}
function playIntegrityRejectionError(code: PlayIntegrityRejectionCode): Error {
switch (code) {
case 'not_configured':
return new PlayIntegrityNotAvailableError();
case 'invalid_request':
return new PlayIntegrityRequestInvalidError();
case 'invalid_challenge':
return new PlayIntegrityChallengeInvalidError();
case 'invalid_token':
return new PlayIntegrityTokenInvalidError();
case 'app_not_recognized':
return new PlayIntegrityAppNotRecognizedError();
case 'device_not_trusted':
return new PlayIntegrityDeviceNotTrustedError();
case 'unavailable':
return new PlayIntegrityUnavailableError();
}
}
function unwrapPlayIntegrity<T>(outcome: PlayIntegrityOutcome<T>): T {
if (!outcome.ok) throw playIntegrityRejectionError(outcome.code);
return outcome.value;
}
export async function createAppAttestChallenge(
userId: UserID,
purpose: AppAttestChallengePurpose,
): Promise<AppAttestChallengeResponse> {
return unwrap(await createUsersServiceClient().appAttestCreateChallenge(userId, purpose));
}
export async function registerAppAttestKey(userId: UserID, request: AppAttestKeyRegisterRequest): Promise<void> {
unwrap(
await createUsersServiceClient().appAttestRegisterKey({
userId,
keyId: request.key_id,
attestationBase64: request.attestation,
challenge: request.challenge,
}),
);
}
export async function submitAttestedAge(
ctx: ApiContext,
user: User,
request: AgeAssuranceSubmitRequest,
): Promise<AgeAssuranceSubmitResponse> {
const accepted = unwrap(
await createUsersServiceClient().appAttestSubmitAge({
userId: user.id,
keyId: request.key_id,
assertionBase64: request.assertion,
clientDataBase64: request.client_data,
}),
);
return applyAttestedAge(ctx, user, accepted);
}
export async function createPlayIntegrityChallenge(userId: UserID): Promise<AppAttestChallengeResponse> {
return unwrapPlayIntegrity(await createUsersServiceClient().playIntegrityCreateChallenge(userId));
}
export async function submitPlayIntegrityAge(
ctx: ApiContext,
user: User,
request: PlayIntegrityAgeSubmitRequest,
): Promise<AgeAssuranceSubmitResponse> {
const accepted = unwrapPlayIntegrity(
await createUsersServiceClient().playIntegritySubmitAge({
userId: user.id,
packageName: request.package_name,
integrityToken: request.integrity_token,
clientDataBase64: request.client_data,
}),
);
return applyAttestedAge(ctx, user, accepted);
}
async function applyAttestedAge(
ctx: ApiContext,
user: User,
accepted: AppAttestAgeAccepted,
): Promise<AgeAssuranceSubmitResponse> {
const attestedAt = new Date(accepted.attested_at);
if (user.ageAttestedAt !== null && user.ageAttestedAt.getTime() > attestedAt.getTime()) {
return {age_floor: accepted.age_floor};
}
const updated = await ctx.services.users.patchUpsert(
user.id,
{attested_age_floor: accepted.age_floor, age_attested_at: attestedAt},
user.toRow(),
);
if (canUserAccessNsfwContent(user) !== canUserAccessNsfwContent(updated)) {
const settings = await ctx.services.users.findSettings(user.id);
const adjusted = settings ? settingsForAge(settings, canUserAccessNsfwContent(updated)) : null;
if (adjusted) {
const saved = await ctx.services.users.upsertSettings(adjusted.toRow());
await ctx.services.gateway.dispatchPresence({
userId: user.id,
event: 'USER_SETTINGS_UPDATE',
data: mapUserSettingsToResponse({settings: saved}),
});
}
}
if (user.attestedAgeFloor !== updated.attestedAgeFloor) {
await ctx.services.gateway.dispatchPresence({
userId: user.id,
event: 'USER_UPDATE',
data: mapUserToPrivateResponse(updated),
});
}
return {age_floor: accepted.age_floor};
}
export async function deleteAllAppAttestKeys(userId: UserID): Promise<void> {
const keys = await fetchMany<{key_id: string; app_id: string}>(FETCH_APP_ATTEST_KEYS_FOR_USER_CQL, {
user_id: userId,
});
for (const key of keys) {
await executeConditional(
AppAttestKeys.conditionalDeleteByPk({user_id: userId, key_id: key.key_id}, {app_id: key.app_id}),
);
await executeConditional(AppAttestKeyLookup.conditionalDeleteByPk({key_id: key.key_id}, {user_id: userId}));
}
}