Page MenuHomePhabricator
Differential D12610

[Tunnelbroker] implement APNs Token generation and lifetime
ClosedPublic
Actions

Authored by kamil on Jun 28 2024, 4:46 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 17, 5:30 AM
Unknown Object (File)
Thu, Apr 17, 4:36 AM
Unknown Object (File)
Wed, Apr 16, 11:19 PM
Unknown Object (File)
Wed, Apr 16, 9:31 PM
Unknown Object (File)
Wed, Apr 16, 8:16 AM
Unknown Object (File)
Sat, Apr 5, 5:06 AM
Unknown Object (File)
Wed, Apr 2, 4:43 AM
Unknown Object (File)
Mar 7 2025, 8:22 AM
View All 89 Files
Subscribers
ashoat
tomek

Details

Reviewers
bartek
marcin
Commits
rCOMM228893b1fd5a: [Tunnelbroker] implement APNs Token generation and lifetime
Summary

Implementing what is described in Apple's Establishing a token-based connection to APNs.

Config in tests is randomly generated.

Depends on D12609

Test Plan

Tests, later in the task tested actual communication with APNs.

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

kamil created this revision.Jun 28 2024, 4:46 AM
kamil held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptJun 28 2024, 4:46 AM
Harbormaster failed remote builds in B29988: Diff 41787!Jun 28 2024, 4:53 AM
kamil updated this revision to Diff 41788.Jun 28 2024, 5:00 AM

fix typo

kamil added a child revision: D12611: [Tunnelbroker] implement creating APNs client.Jun 28 2024, 5:00 AM
Harbormaster completed remote builds in B29989: Diff 41788.Jun 28 2024, 5:16 AM
kamil mentioned this in D12607: [Tunnelbroker] add `jsonwebtoken` dependency.Jun 28 2024, 6:22 AM
kamil published this revision for review.Jun 28 2024, 6:26 AM
kamil added inline comments.
services/tunnelbroker/src/notifs/apns/token.rs
83 ↗(On Diff #41788)

Apple key is in PKCS#8 form.

bartek accepted this revision.Jul 1 2024, 2:08 AM

Nice job with the Arc<RwLock>!

services/tunnelbroker/src/notifs/apns/token.rs
6 ↗(On Diff #41788)

Up to you, but we have the chrono crate which might be more handy.
Not worth changing though, std::time works well too, I just find it a bit less convenient

This revision is now accepted and ready to land.Jul 1 2024, 2:08 AM
kamil added a child revision: D12635: [Tunnelbroker] implement creating APNs client.Jul 2 2024, 4:07 AM
Closed by commit rCOMM228893b1fd5a: [Tunnelbroker] implement APNs Token generation and lifetime (authored by kamil). · Explain WhyJul 2 2024, 8:35 AM
This revision was automatically updated to reflect the committed changes.
kamil mentioned this in rCOMMc36192b438fe: [Tunnelbroker] add `jsonwebtoken` dependency.
kamil added a commit: rCOMM228893b1fd5a: [Tunnelbroker] implement APNs Token generation and lifetime.

Revision Contents
Changeset List

PathSize
services/
tunnelbroker/
src/
notifs/
apns/
12 lines
5 lines
147 lines

Diff 41891

View Options

services/tunnelbroker/src/notifs/apns/error.rs

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};
View Options

services/tunnelbroker/src/notifs/apns/mod.rs

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};
View Options

services/tunnelbroker/src/notifs/apns/token.rs

  • This file was added.
// @flow
import invariant from 'invariant';
import t, { type TInterface } from 'tcomb';
import {
type CommonNativeNotifInputData,
commonNativeNotifInputDataValidator,
} from './android-notif-creators.js';
import {
prepareEncryptedAPNsVisualNotifications,
prepareEncryptedAPNsSilentNotifications,
} from './crypto.js';
import { getAPNsNotificationTopic } from '../shared/notif-utils.js';
import {
hasMinCodeVersion,
FUTURE_CODE_VERSION,
} from '../shared/version-utils.js';
import type { PlatformDetails } from '../types/device-types.js';
import { messageTypes } from '../types/message-types-enum.js';
import {
type NotificationTargetDevice,
type EncryptedNotifUtilsAPI,
type TargetedAPNsNotification,
type APNsVisualNotification,
type APNsNotificationHeaders,
type SenderDeviceDescriptor,
} from '../types/notif-types.js';
import { tShape } from '../utils/validation-utils.js';
export const apnMaxNotificationPayloadByteSize = 4096;
export type APNsNotifInputData = {
...CommonNativeNotifInputData,
+badgeOnly: boolean,
+uniqueID: string,
};
export const apnsNotifInputDataValidator: TInterface<APNsNotifInputData> =
tShape<APNsNotifInputData>({
...commonNativeNotifInputDataValidator.meta.props,
badgeOnly: t.Boolean,
uniqueID: t.String,
});
async function createAPNsVisualNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotifInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
senderDeviceDescriptor,
notifTexts,
newRawMessageInfos,
threadID,
collapseKey,
badgeOnly,
unreadCount,
platformDetails,
uniqueID,
} = inputData;
const canDecryptNonCollapsibleTextIOSNotifs = hasMinCodeVersion(
platformDetails,
{ native: 222 },
);
const isNonCollapsibleTextNotification =
newRawMessageInfos.every(
newRawMessageInfo => newRawMessageInfo.type === messageTypes.TEXT,
) && !collapseKey;
const canDecryptAllIOSNotifs = hasMinCodeVersion(platformDetails, {
native: 267,
});
const canDecryptIOSNotif =
platformDetails.platform === 'ios' &&
(canDecryptAllIOSNotifs ||
(isNonCollapsibleTextNotification &&
canDecryptNonCollapsibleTextIOSNotifs));
const canDecryptMacOSNotifs =
platformDetails.platform === 'macos' &&
hasMinCodeVersion(platformDetails, {
web: 47,
majorDesktop: 9,
});
let apsDictionary = {
'thread-id': threadID,
};
if (unreadCount !== undefined && unreadCount !== null) {
apsDictionary = {
...apsDictionary,
badge: unreadCount,
};
}
const { merged, ...rest } = notifTexts;
// We don't include alert's body on macos because we
// handle displaying the notification ourselves and
// we don't want macOS to display it automatically.
if (!badgeOnly && platformDetails.platform !== 'macos') {
apsDictionary = {
...apsDictionary,
alert: merged,
sound: 'default',
};
}
if (hasMinCodeVersion(platformDetails, { native: 198 })) {
apsDictionary = {
...apsDictionary,
'mutable-content': 1,
};
}
let notificationPayload = {
...rest,
id: uniqueID,
threadID,
};
let notificationHeaders: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-id': uniqueID,
'apns-push-type': 'alert',
};
if (collapseKey && (canDecryptAllIOSNotifs || canDecryptMacOSNotifs)) {
notificationPayload = {
...notificationPayload,
collapseID: collapseKey,
};
} else if (collapseKey) {
notificationHeaders = {
...notificationHeaders,
'apns-collapse-id': collapseKey,
};
}
const notification = {
...notificationPayload,
headers: notificationHeaders,
aps: apsDictionary,
};
const messageInfos = JSON.stringify(newRawMessageInfos);
const copyWithMessageInfos = {
...notification,
messageInfos,
};
const notificationSizeValidator = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return (
encryptedNotifUtilsAPI.getNotifByteSize(
JSON.stringify(notifSansHeaders),
) <= apnMaxNotificationPayloadByteSize
);
};
const serializeAPNsNotif = (notif: APNsVisualNotification) => {
const { headers, ...notifSansHeaders } = notif;
return JSON.stringify(notifSansHeaders);
};
const shouldBeEncrypted = canDecryptIOSNotif || canDecryptMacOSNotifs;
if (!shouldBeEncrypted) {
const notificationToSend = notificationSizeValidator(copyWithMessageInfos)
? copyWithMessageInfos
: notification;
return devices.map(({ deliveryID }) => ({
notification: notificationToSend,
deliveryID,
}));
}
// The `messageInfos` field in notification payload is
// not used on MacOS so we can return early.
if (platformDetails.platform === 'macos') {
const macOSNotifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return macOSNotifsWithoutMessageInfos.map(
({ notification: notif, deliveryID }) => ({
notification: notif,
deliveryID,
}),
);
}
const notifsWithMessageInfos = await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
copyWithMessageInfos,
platformDetails.codeVersion,
notificationSizeValidator,
);
const devicesWithExcessiveSizeNoHolders = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => payloadSizeExceeded)
.map(({ cryptoID, deliveryID }) => ({
cryptoID,
deliveryID,
}));
if (devicesWithExcessiveSizeNoHolders.length === 0) {
return notifsWithMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
}
const canQueryBlobService = hasMinCodeVersion(platformDetails, {
native: 331,
});
let blobHash, blobHolders, encryptionKey, blobUploadError;
if (canQueryBlobService) {
({ blobHash, blobHolders, encryptionKey, blobUploadError } =
await encryptedNotifUtilsAPI.uploadLargeNotifPayload(
serializeAPNsNotif(copyWithMessageInfos),
devicesWithExcessiveSizeNoHolders.length,
));
}
if (blobUploadError) {
console.warn(
`Failed to upload payload of notification: ${uniqueID} ` +
`due to error: ${blobUploadError}`,
);
}
let devicesWithExcessiveSize = devicesWithExcessiveSizeNoHolders;
let notificationWithBlobMetadata = notification;
if (
blobHash &&
encryptionKey &&
blobHolders &&
blobHolders.length === devicesWithExcessiveSize.length
) {
notificationWithBlobMetadata = {
...notification,
blobHash,
encryptionKey,
};
devicesWithExcessiveSize = blobHolders.map((holder, idx) => ({
...devicesWithExcessiveSize[idx],
blobHolder: holder,
}));
}
const notifsWithoutMessageInfos =
await prepareEncryptedAPNsVisualNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devicesWithExcessiveSize,
notificationWithBlobMetadata,
platformDetails.codeVersion,
);
const targetedNotifsWithMessageInfos = notifsWithMessageInfos
.filter(({ payloadSizeExceeded }) => !payloadSizeExceeded)
.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
const targetedNotifsWithoutMessageInfos = notifsWithoutMessageInfos.map(
({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}) => ({
notification: notif,
deliveryID,
encryptedPayloadHash,
encryptionOrder,
}),
);
return [
...targetedNotifsWithMessageInfos,
...targetedNotifsWithoutMessageInfos,
];
}
type APNsNotificationRescindInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+rescindID?: string,
+badge?: number,
+threadID: string,
+platformDetails: PlatformDetails,
};
async function createAPNsNotificationRescind(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsNotificationRescindInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const {
badge,
rescindID,
threadID,
platformDetails,
senderDeviceDescriptor,
} = inputData;
invariant(
(rescindID && badge !== null && badge !== undefined) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread rescind not support for this client version',
);
const apnsTopic = getAPNsNotificationTopic(platformDetails);
let notification;
if (
rescindID &&
badge !== null &&
badge !== undefined &&
hasMinCodeVersion(platformDetails, { native: 198 })
) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else if (rescindID && badge !== null && badge !== undefined) {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'background',
'apns-priority': 5,
},
aps: {
'mutable-content': 1,
'badge': badge,
},
threadID,
notificationId: rescindID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
} else {
notification = {
headers: {
'apns-topic': apnsTopic,
'apns-push-type': 'alert',
},
aps: {
'mutable-content': 1,
},
threadID,
backgroundNotifType: 'CLEAR',
setUnreadStatus: true,
};
}
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, { native: 233 });
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
notification,
deliveryID,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
type APNsBadgeOnlyNotificationInputData = {
+senderDeviceDescriptor: SenderDeviceDescriptor,
+badge?: number,
+threadID?: string,
+platformDetails: PlatformDetails,
};
async function createAPNsBadgeOnlyNotification(
encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
inputData: APNsBadgeOnlyNotificationInputData,
devices: $ReadOnlyArray<NotificationTargetDevice>,
): Promise<$ReadOnlyArray<TargetedAPNsNotification>> {
const { senderDeviceDescriptor, platformDetails, threadID, badge } =
inputData;
invariant(
(!threadID && badge !== undefined && badge !== null) ||
hasMinCodeVersion(platformDetails, { native: FUTURE_CODE_VERSION }),
'thick thread badge updates not support for this client version',
);
const shouldBeEncrypted = hasMinCodeVersion(platformDetails, {
native: 222,
web: 47,
majorDesktop: 9,
});
const headers: APNsNotificationHeaders = {
'apns-topic': getAPNsNotificationTopic(platformDetails),
'apns-push-type': 'alert',
};
let notification;
if (shouldBeEncrypted && threadID) {
notification = {
headers,
threadID,
aps: {
'mutable-content': 1,
},
};
} else if (shouldBeEncrypted && badge !== undefined && badge !== null) {
notification = {
headers,
aps: {
'badge': badge,
'mutable-content': 1,
},
};
} else {
invariant(
badge !== null && badge !== undefined,
'badge update must contain either badge count or threadID',
);
notification = {
headers,
aps: {
badge,
},
};
}
if (!shouldBeEncrypted) {
return devices.map(({ deliveryID }) => ({
deliveryID,
notification,
}));
}
const notifications = await prepareEncryptedAPNsSilentNotifications(
encryptedNotifUtilsAPI,
senderDeviceDescriptor,
devices,
notification,
platformDetails.codeVersion,
);
return notifications.map(({ deliveryID, notification: notif }) => ({
deliveryID,
notification: notif,
}));
}
export {
createAPNsBadgeOnlyNotification,
createAPNsNotificationRescind,
createAPNsVisualNotification,
};