Skip to content

The open alternative to Salesforce, designed for AI.

feat(teams): require a Teams endorsement on the activity signing key (#26444)

Abdul Rahman0e602ea2e14b
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-kv-key.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-kv-key.ts
new file mode 100644
index 00000000000..a6fcc0616e5
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-kv-key.ts
@@ -0,0 +1 @@
+export const TEAMS_BOT_CONNECTOR_KEYS_KV_KEY = 'teams-bot-connector-keys';
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-max-age-ms.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-max-age-ms.ts
new file mode 100644
index 00000000000..125777b71f1
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-max-age-ms.ts
@@ -0,0 +1 @@
+export const TEAMS_BOT_CONNECTOR_KEYS_MAX_AGE_MS = 24 * 60 * 60 * 1000;
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-min-refresh-interval-ms.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-min-refresh-interval-ms.ts
new file mode 100644
index 00000000000..eea7a07f336
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-bot-connector-keys-min-refresh-interval-ms.ts
@@ -0,0 +1 @@
+export const TEAMS_BOT_CONNECTOR_KEYS_MIN_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-channel-id.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-channel-id.ts
new file mode 100644
index 00000000000..e83e5d09999
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/constants/teams-channel-id.ts
@@ -0,0 +1 @@
+export const TEAMS_CHANNEL_ID = 'msteams';
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/load-teams-bot-connector-keys.type.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/load-teams-bot-connector-keys.type.ts
new file mode 100644
index 00000000000..f72a1bcfb0f
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/load-teams-bot-connector-keys.type.ts
@@ -0,0 +1,3 @@
+import { type getTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/utils/get-teams-bot-connector-keys';
+
+export type LoadTeamsBotConnectorKeys = typeof getTeamsBotConnectorKeys;
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-bot-connector-key.type.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-bot-connector-key.type.ts
new file mode 100644
index 00000000000..cd53c15801c
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-bot-connector-key.type.ts
@@ -0,0 +1,6 @@
+import { type JWK } from 'jose';
+
+export type TeamsBotConnectorKey = JWK & {
+ kid: string;
+ endorsements?: string[];
+};
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-bot-connector-keys-cache-entry.type.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-bot-connector-keys-cache-entry.type.ts
new file mode 100644
index 00000000000..9f16f525f81
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-bot-connector-keys-cache-entry.type.ts
@@ -0,0 +1,7 @@
+import { type TeamsBotConnectorKey } from 'src/features/chat/logic-functions/types/teams-bot-connector-key.type';
+
+export type TeamsBotConnectorKeysCacheEntry = {
+ keys: TeamsBotConnectorKey[];
+ fetchedAtMs: number;
+ refreshAttemptedAtMs: number;
+};
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-conversation-member.type.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-conversation-member.type.ts
index 630a8fae4e2..68f32b87ca8 100644
--- a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-conversation-member.type.ts
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/types/teams-conversation-member.type.ts
@@ -1,3 +1,5 @@
+// TODO(@abdulrahmancodes): settle against a live tenant whether a bot can read
+// email and userPrincipalName from this payload or has to go through Graph.
export type TeamsConversationMember = {
id: string;
objectId?: string;
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/fetch-teams-bot-connector-keys.test.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/fetch-teams-bot-connector-keys.test.ts
new file mode 100644
index 00000000000..5e1e79423ac
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/fetch-teams-bot-connector-keys.test.ts
@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { TEAMS_BOT_OPENID_KEYS_URL } from 'src/features/chat/logic-functions/constants/teams-bot-openid-keys-url';
+import { fetchTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/utils/fetch-teams-bot-connector-keys';
+
+const fetchMock = vi.fn();
+
+const TEAMS_KEY = {
+ kty: 'RSA',
+ use: 'sig',
+ kid: 'teams-key',
+ n: 'modulus',
+ e: 'AQAB',
+ x5c: ['certificate'],
+ x5t: 'thumbprint',
+ endorsements: ['skype', 'msteams'],
+};
+
+const respondWith = (body: unknown) =>
+ fetchMock.mockResolvedValue(
+ new Response(JSON.stringify(body), {
+ headers: { 'content-type': 'application/json' },
+ }),
+ );
+
+beforeEach(() => {
+ fetchMock.mockReset();
+ vi.stubGlobal('fetch', fetchMock);
+});
+
+afterEach(() => {
+ vi.unstubAllGlobals();
+});
+
+describe('fetchTeamsBotConnectorKeys', () => {
+ it('should keep only the verification fields of keys endorsed for Teams', async () => {
+ respondWith({
+ keys: [
+ TEAMS_KEY,
+ { ...TEAMS_KEY, kid: 'telephony-key', endorsements: ['telephony'] },
+ { ...TEAMS_KEY, kid: 'unendorsed-key', endorsements: undefined },
+ { ...TEAMS_KEY, kid: '' },
+ 'not-a-key',
+ ],
+ });
+
+ expect(await fetchTeamsBotConnectorKeys()).toEqual([
+ {
+ kty: 'RSA',
+ use: 'sig',
+ kid: 'teams-key',
+ n: 'modulus',
+ e: 'AQAB',
+ endorsements: ['skype', 'msteams'],
+ },
+ ]);
+ expect(fetchMock).toHaveBeenCalledWith(TEAMS_BOT_OPENID_KEYS_URL);
+ });
+
+ it('should drop keys that cannot verify an RS256 signature', async () => {
+ respondWith({
+ keys: [
+ TEAMS_KEY,
+ { ...TEAMS_KEY, kid: 'elliptic-curve-key', kty: 'EC', n: undefined },
+ { ...TEAMS_KEY, kid: 'encryption-key', use: 'enc' },
+ { ...TEAMS_KEY, kid: 'exponent-less-key', e: undefined },
+ ],
+ });
+
+ expect(await fetchTeamsBotConnectorKeys()).toEqual([
+ {
+ kty: 'RSA',
+ use: 'sig',
+ kid: 'teams-key',
+ n: 'modulus',
+ e: 'AQAB',
+ endorsements: ['skype', 'msteams'],
+ },
+ ]);
+ });
+
+ it('should reject a response with no key endorsed for Teams rather than cache an empty set', async () => {
+ respondWith({
+ keys: [
+ { ...TEAMS_KEY, kid: 'telephony-key', endorsements: ['telephony'] },
+ ],
+ });
+
+ await expect(fetchTeamsBotConnectorKeys()).rejects.toThrow(
+ 'no key endorsed for Teams',
+ );
+ });
+});
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/get-teams-bot-connector-keys.test.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/get-teams-bot-connector-keys.test.ts
new file mode 100644
index 00000000000..6ee79b4c5fd
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/get-teams-bot-connector-keys.test.ts
@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { TEAMS_BOT_CONNECTOR_KEYS_KV_KEY } from 'src/features/chat/logic-functions/constants/teams-bot-connector-keys-kv-key';
+import { getTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/utils/get-teams-bot-connector-keys';
+
+const { kvGetMock, kvSetMock, fetchKeysMock } = vi.hoisted(() => ({
+ kvGetMock: vi.fn(),
+ kvSetMock: vi.fn(),
+ fetchKeysMock: vi.fn(),
+}));
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ kv: { get: kvGetMock, set: kvSetMock },
+}));
+
+vi.mock(
+ 'src/features/chat/logic-functions/utils/fetch-teams-bot-connector-keys',
+ () => ({
+ fetchTeamsBotConnectorKeys: fetchKeysMock,
+ }),
+);
+
+const CACHED_KEYS = [{ kid: 'cached', kty: 'RSA' }];
+const FETCHED_KEYS = [{ kid: 'fetched', kty: 'RSA' }];
+
+const cacheEntry = ({
+ fetchedAgoMs,
+ refreshAttemptedAgoMs = fetchedAgoMs,
+}: {
+ fetchedAgoMs: number;
+ refreshAttemptedAgoMs?: number;
+}) => ({
+ keys: CACHED_KEYS,
+ fetchedAtMs: Date.now() - fetchedAgoMs,
+ refreshAttemptedAtMs: Date.now() - refreshAttemptedAgoMs,
+});
+
+describe('getTeamsBotConnectorKeys', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+ fetchKeysMock.mockResolvedValue(FETCHED_KEYS);
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it('should reuse a key set fetched within the last day', async () => {
+ kvGetMock.mockResolvedValue(
+ cacheEntry({ fetchedAgoMs: 23 * 60 * 60 * 1000 }),
+ );
+
+ expect(await getTeamsBotConnectorKeys()).toEqual(CACHED_KEYS);
+ expect(fetchKeysMock).not.toHaveBeenCalled();
+ expect(kvSetMock).not.toHaveBeenCalled();
+ });
+
+ it('should fetch and cache when nothing is stored', async () => {
+ kvGetMock.mockResolvedValue(null);
+
+ expect(await getTeamsBotConnectorKeys()).toEqual(FETCHED_KEYS);
+ expect(kvSetMock).toHaveBeenCalledTimes(1);
+ expect(kvSetMock).toHaveBeenCalledWith(TEAMS_BOT_CONNECTOR_KEYS_KV_KEY, {
+ keys: FETCHED_KEYS,
+ fetchedAtMs: Date.now(),
+ refreshAttemptedAtMs: Date.now(),
+ });
+ });
+
+ it('should stamp the refresh attempt before fetching once the cached key set is a day old', async () => {
+ const staleEntry = cacheEntry({ fetchedAgoMs: 25 * 60 * 60 * 1000 });
+
+ kvGetMock.mockResolvedValue(staleEntry);
+
+ expect(await getTeamsBotConnectorKeys()).toEqual(FETCHED_KEYS);
+ expect(kvSetMock).toHaveBeenNthCalledWith(
+ 1,
+ TEAMS_BOT_CONNECTOR_KEYS_KV_KEY,
+ { ...staleEntry, refreshAttemptedAtMs: Date.now() },
+ );
+ expect(kvSetMock).toHaveBeenNthCalledWith(
+ 2,
+ TEAMS_BOT_CONNECTOR_KEYS_KV_KEY,
+ {
+ keys: FETCHED_KEYS,
+ fetchedAtMs: Date.now(),
+ refreshAttemptedAtMs: Date.now(),
+ },
+ );
+ });
+
+ it('should rate limit forced refreshes on the last attempt, not on the last successful fetch', async () => {
+ kvGetMock.mockResolvedValue(
+ cacheEntry({
+ fetchedAgoMs: 10 * 60 * 1000,
+ refreshAttemptedAgoMs: 60 * 1000,
+ }),
+ );
+
+ expect(await getTeamsBotConnectorKeys({ forceRefresh: true })).toEqual(
+ CACHED_KEYS,
+ );
+ expect(fetchKeysMock).not.toHaveBeenCalled();
+ expect(kvSetMock).not.toHaveBeenCalled();
+ });
+
+ it('should keep serving the last good key set when the fetch fails', async () => {
+ kvGetMock.mockResolvedValue(
+ cacheEntry({ fetchedAgoMs: 25 * 60 * 60 * 1000 }),
+ );
+ fetchKeysMock.mockRejectedValue(new Error('upstream down'));
+
+ expect(await getTeamsBotConnectorKeys()).toEqual(CACHED_KEYS);
+ expect(kvSetMock).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/verify-teams-activity-token.test.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/verify-teams-activity-token.test.ts
index a82b94454ee..598edac94f8 100644
--- a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/verify-teams-activity-token.test.ts
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/__tests__/verify-teams-activity-token.test.ts
@@ -1,35 +1,50 @@
-import { SignJWT, generateKeyPair } from 'jose';
-import { beforeAll, describe, expect, it } from 'vitest';
+import { SignJWT, exportJWK, generateKeyPair } from 'jose';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
import { TEAMS_BOT_CONNECTOR_ISSUER } from 'src/features/chat/logic-functions/constants/teams-bot-connector-issuer';
+import { TEAMS_CHANNEL_ID } from 'src/features/chat/logic-functions/constants/teams-channel-id';
+import { type TeamsBotConnectorKey } from 'src/features/chat/logic-functions/types/teams-bot-connector-key.type';
import { verifyTeamsActivityTokenOrThrow } from 'src/features/chat/logic-functions/utils/verify-teams-activity-token';
const BOT_APP_ID = 'bbbbbbbb-1111-2222-3333-444444444444';
const SERVICE_URL = 'https://smba.trafficmanager.net/amer/';
const NORMALIZED_SERVICE_URL = 'https://smba.trafficmanager.net/amer';
+const KEY_ID = 'teams-signing-key';
+const OTHER_CHANNEL_KEY_ID = 'skype-signing-key';
+const ROTATED_KEY_ID = 'rotated-signing-key';
let privateKey: CryptoKey;
-let publicKey: CryptoKey;
+let teamsKey: TeamsBotConnectorKey;
+let otherChannelKey: TeamsBotConnectorKey;
let symmetricSecret: Uint8Array;
+const loadKeysMock =
+ vi.fn<
+ (options?: { forceRefresh?: boolean }) => Promise<TeamsBotConnectorKey[]>
+ >();
+
const signActivityToken = async ({
issuer = TEAMS_BOT_CONNECTOR_ISSUER,
audience = BOT_APP_ID,
serviceUrlClaim = SERVICE_URL,
claimName = 'serviceurl',
expiresIn = '5m',
+ keyId = KEY_ID,
}: {
issuer?: string;
audience?: string;
serviceUrlClaim?: string | null;
claimName?: 'serviceurl' | 'serviceUrl';
expiresIn?: string | number;
+ keyId?: string | null;
} = {}) => {
const payload =
serviceUrlClaim === null ? {} : { [claimName]: serviceUrlClaim };
return new SignJWT(payload)
- .setProtectedHeader({ alg: 'RS256' })
+ .setProtectedHeader(
+ keyId === null ? { alg: 'RS256' } : { alg: 'RS256', kid: keyId },
+ )
.setIssuer(issuer)
.setAudience(audience)
.setIssuedAt()
@@ -37,38 +52,59 @@ const signActivityToken = async ({
.sign(privateKey);
};
-const verify = (token: string, activityServiceUrl = SERVICE_URL) =>
+const verify = (
+ authorizationHeader: string | undefined,
+ activityServiceUrl = SERVICE_URL,
+) =>
verifyTeamsActivityTokenOrThrow({
- authorizationHeader: `Bearer ${token}`,
+ authorizationHeader,
activityServiceUrl,
botAppId: BOT_APP_ID,
- keySet: publicKey,
+ loadKeys: loadKeysMock,
});
+const verifyToken = (token: string, activityServiceUrl = SERVICE_URL) =>
+ verify(`Bearer ${token}`, activityServiceUrl);
+
beforeAll(async () => {
const pair = await generateKeyPair('RS256', { extractable: true });
+ const publicJwk = await exportJWK(pair.publicKey);
privateKey = pair.privateKey;
- publicKey = pair.publicKey;
+ teamsKey = {
+ ...publicJwk,
+ kid: KEY_ID,
+ endorsements: ['skype', TEAMS_CHANNEL_ID],
+ };
+ otherChannelKey = {
+ ...publicJwk,
+ kid: OTHER_CHANNEL_KEY_ID,
+ endorsements: ['directlinespeech', 'telephony'],
+ };
symmetricSecret = new Uint8Array(32).fill(7);
});
+beforeEach(() => {
+ loadKeysMock.mockReset();
+ loadKeysMock.mockResolvedValue([teamsKey, otherChannelKey]);
+});
+
describe('verifyTeamsActivityTokenOrThrow', () => {
it('should return the verified service url for a well-formed Bot Connector token', async () => {
- expect(await verify(await signActivityToken())).toBe(
+ expect(await verifyToken(await signActivityToken())).toBe(
NORMALIZED_SERVICE_URL,
);
});
it('should accept the documented serviceUrl spelling as well as the wire one', async () => {
expect(
- await verify(await signActivityToken({ claimName: 'serviceUrl' })),
+ await verifyToken(await signActivityToken({ claimName: 'serviceUrl' })),
).toBe(NORMALIZED_SERVICE_URL);
});
it('should ignore a trailing slash difference between claim and activity', async () => {
expect(
- await verify(
+ await verifyToken(
await signActivityToken({ serviceUrlClaim: SERVICE_URL }),
NORMALIZED_SERVICE_URL,
),
@@ -77,7 +113,7 @@ describe('verifyTeamsActivityTokenOrThrow', () => {
it('should ignore host casing between claim and activity', async () => {
expect(
- await verify(
+ await verifyToken(
await signActivityToken({
serviceUrlClaim: 'https://SMBA.TrafficManager.net/amer/',
}),
@@ -85,60 +121,81 @@ describe('verifyTeamsActivityTokenOrThrow', () => {
).toBe(NORMALIZED_SERVICE_URL);
});
- it('should reject a missing Authorization header', async () => {
+ it('should refetch the key set once when the token names a rotated key', async () => {
+ const rotatedTeamsKey = { ...teamsKey, kid: ROTATED_KEY_ID };
+
+ loadKeysMock
+ .mockResolvedValueOnce([teamsKey])
+ .mockResolvedValueOnce([rotatedTeamsKey]);
+
+ expect(
+ await verifyToken(await signActivityToken({ keyId: ROTATED_KEY_ID })),
+ ).toBe(NORMALIZED_SERVICE_URL);
+ expect(loadKeysMock).toHaveBeenNthCalledWith(1);
+ expect(loadKeysMock).toHaveBeenNthCalledWith(2, { forceRefresh: true });
+ });
+
+ it('should reject a token naming no signing key without reaching for the key set', async () => {
await expect(
- verifyTeamsActivityTokenOrThrow({
- authorizationHeader: undefined,
- activityServiceUrl: SERVICE_URL,
- botAppId: BOT_APP_ID,
- keySet: publicKey,
- }),
- ).rejects.toThrow('Missing or malformed Authorization header');
+ verifyToken(await signActivityToken({ keyId: null })),
+ ).rejects.toThrow('names no signing key');
+ expect(loadKeysMock).not.toHaveBeenCalled();
+ });
+
+ it('should reject a missing Authorization header', async () => {
+ await expect(verify(undefined)).rejects.toThrow(
+ 'Missing or malformed Authorization header',
+ );
});
it('should reject a non-Bearer scheme', async () => {
- await expect(
- verifyTeamsActivityTokenOrThrow({
- authorizationHeader: `Basic ${await signActivityToken()}`,
- activityServiceUrl: SERVICE_URL,
- botAppId: BOT_APP_ID,
- keySet: publicKey,
- }),
- ).rejects.toThrow('Missing or malformed Authorization header');
+ await expect(verify(`Basic ${await signActivityToken()}`)).rejects.toThrow(
+ 'Missing or malformed Authorization header',
+ );
});
it('should reject an Authorization header carrying more than a scheme and a token', async () => {
await expect(
- verifyTeamsActivityTokenOrThrow({
- authorizationHeader: `Bearer ${await signActivityToken()} extra`,
- activityServiceUrl: SERVICE_URL,
- botAppId: BOT_APP_ID,
- keySet: publicKey,
- }),
+ verify(`Bearer ${await signActivityToken()} extra`),
).rejects.toThrow('Missing or malformed Authorization header');
});
+ it('should reject a token signed with a key the Bot Connector does not publish', async () => {
+ await expect(
+ verifyToken(await signActivityToken({ keyId: 'unknown-key' })),
+ ).rejects.toThrow('does not publish');
+ expect(loadKeysMock).toHaveBeenCalledTimes(2);
+ });
+
+ it('should reject a validly signed token whose key is endorsed for another channel', async () => {
+ await expect(
+ verifyToken(await signActivityToken({ keyId: OTHER_CHANNEL_KEY_ID })),
+ ).rejects.toThrow('not endorsed for Teams');
+ });
+
it('should reject a token from another issuer', async () => {
await expect(
- verify(await signActivityToken({ issuer: 'https://evil.example' })),
+ verifyToken(await signActivityToken({ issuer: 'https://evil.example' })),
).rejects.toThrow();
});
it('should reject a token minted for another bot', async () => {
await expect(
- verify(await signActivityToken({ audience: 'someone-elses-app-id' })),
+ verifyToken(
+ await signActivityToken({ audience: 'someone-elses-app-id' }),
+ ),
).rejects.toThrow();
});
it('should reject an expired token beyond the clock tolerance', async () => {
await expect(
- verify(await signActivityToken({ expiresIn: '-10m' })),
+ verifyToken(await signActivityToken({ expiresIn: '-10m' })),
).rejects.toThrow();
});
it('should reject a token whose serviceUrl claim points elsewhere', async () => {
await expect(
- verify(
+ verifyToken(
await signActivityToken({
serviceUrlClaim: 'https://attacker.example',
}),
@@ -148,26 +205,19 @@ describe('verifyTeamsActivityTokenOrThrow', () => {
it('should reject a token carrying no serviceUrl claim', async () => {
await expect(
- verify(await signActivityToken({ serviceUrlClaim: null })),
+ verifyToken(await signActivityToken({ serviceUrlClaim: null })),
).rejects.toThrow('has no serviceUrl claim');
});
- it('should reject a symmetrically signed token, so alg cannot be downgraded', async () => {
+ it('should reject a symmetrically signed token naming a published key, so alg cannot be downgraded', async () => {
const forgedToken = await new SignJWT({ serviceurl: SERVICE_URL })
- .setProtectedHeader({ alg: 'HS256' })
+ .setProtectedHeader({ alg: 'HS256', kid: KEY_ID })
.setIssuer(TEAMS_BOT_CONNECTOR_ISSUER)
.setAudience(BOT_APP_ID)
.setIssuedAt()
.setExpirationTime('5m')
.sign(symmetricSecret);
- await expect(
- verifyTeamsActivityTokenOrThrow({
- authorizationHeader: `Bearer ${forgedToken}`,
- activityServiceUrl: SERVICE_URL,
- botAppId: BOT_APP_ID,
- keySet: symmetricSecret,
- }),
- ).rejects.toThrow();
+ await expect(verifyToken(forgedToken)).rejects.toThrow();
});
});
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/fetch-teams-bot-connector-keys.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/fetch-teams-bot-connector-keys.ts
new file mode 100644
index 00000000000..ee78d2b94e8
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/fetch-teams-bot-connector-keys.ts
@@ -0,0 +1,71 @@
+import { isArray, isNonEmptyArray, isNonEmptyString } from '@sniptt/guards';
+import { type JWK } from 'jose';
+import { isDefined } from 'twenty-sdk/utils';
+
+import { TEAMS_BOT_OPENID_KEYS_URL } from 'src/features/chat/logic-functions/constants/teams-bot-openid-keys-url';
+import { type TeamsBotConnectorKey } from 'src/features/chat/logic-functions/types/teams-bot-connector-key.type';
+import { isTeamsEndorsedKey } from 'src/features/chat/logic-functions/utils/is-teams-endorsed-key';
+
+type PublishedBotConnectorKey = JWK & { endorsements?: string[] };
+
+type TeamsBotConnectorKeysResponse = {
+ keys?: PublishedBotConnectorKey[];
+};
+
+const isRsaSignatureKey = (
+ key: PublishedBotConnectorKey,
+): key is TeamsBotConnectorKey =>
+ key.kty === 'RSA' &&
+ isNonEmptyString(key.kid) &&
+ isNonEmptyString(key.n) &&
+ isNonEmptyString(key.e) &&
+ (!isDefined(key.use) || key.use === 'sig');
+
+const toSigningKey = ({
+ kty,
+ kid,
+ use,
+ alg,
+ n,
+ e,
+ endorsements,
+}: TeamsBotConnectorKey): TeamsBotConnectorKey => ({
+ kty,
+ kid,
+ use,
+ alg,
+ n,
+ e,
+ endorsements,
+});
+
+export const fetchTeamsBotConnectorKeys = async (): Promise<
+ TeamsBotConnectorKey[]
+> => {
+ const response = await fetch(TEAMS_BOT_OPENID_KEYS_URL);
+
+ if (!response.ok) {
+ throw new Error(
+ `Failed to fetch the Bot Connector signing keys: ${response.status} ${response.statusText}`,
+ );
+ }
+
+ const body: TeamsBotConnectorKeysResponse = await response.json();
+
+ if (!isArray(body.keys)) {
+ throw new Error('Bot Connector signing keys response carried no keys');
+ }
+
+ const teamsKeys = body.keys
+ .filter(isRsaSignatureKey)
+ .filter(isTeamsEndorsedKey)
+ .map(toSigningKey);
+
+ if (!isNonEmptyArray(teamsKeys)) {
+ throw new Error(
+ 'Bot Connector signing keys response carried no key endorsed for Teams',
+ );
+ }
+
+ return teamsKeys;
+};
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/get-teams-bot-connector-keys.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/get-teams-bot-connector-keys.ts
new file mode 100644
index 00000000000..02215c982ad
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/get-teams-bot-connector-keys.ts
@@ -0,0 +1,85 @@
+import { isNonEmptyArray } from '@sniptt/guards';
+import { kv } from 'twenty-sdk/logic-function';
+import { isDefined } from 'twenty-sdk/utils';
+
+import { TEAMS_BOT_CONNECTOR_KEYS_KV_KEY } from 'src/features/chat/logic-functions/constants/teams-bot-connector-keys-kv-key';
+import { TEAMS_BOT_CONNECTOR_KEYS_MAX_AGE_MS } from 'src/features/chat/logic-functions/constants/teams-bot-connector-keys-max-age-ms';
+import { TEAMS_BOT_CONNECTOR_KEYS_MIN_REFRESH_INTERVAL_MS } from 'src/features/chat/logic-functions/constants/teams-bot-connector-keys-min-refresh-interval-ms';
+import { type TeamsBotConnectorKey } from 'src/features/chat/logic-functions/types/teams-bot-connector-key.type';
+import { type TeamsBotConnectorKeysCacheEntry } from 'src/features/chat/logic-functions/types/teams-bot-connector-keys-cache-entry.type';
+import { fetchTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/utils/fetch-teams-bot-connector-keys';
+
+const isWithin = ({
+ timestampMs,
+ maxAgeMs,
+}: {
+ timestampMs: number;
+ maxAgeMs: number;
+}): boolean => timestampMs + maxAgeMs > Date.now();
+
+const canReuse = ({
+ entry,
+ forceRefresh,
+}: {
+ entry: TeamsBotConnectorKeysCacheEntry;
+ forceRefresh: boolean;
+}): boolean =>
+ forceRefresh
+ ? isWithin({
+ timestampMs: entry.refreshAttemptedAtMs,
+ maxAgeMs: TEAMS_BOT_CONNECTOR_KEYS_MIN_REFRESH_INTERVAL_MS,
+ })
+ : isWithin({
+ timestampMs: entry.fetchedAtMs,
+ maxAgeMs: TEAMS_BOT_CONNECTOR_KEYS_MAX_AGE_MS,
+ });
+
+const readCachedEntry =
+ async (): Promise<TeamsBotConnectorKeysCacheEntry | null> => {
+ const cachedEntry = await kv.get<TeamsBotConnectorKeysCacheEntry>(
+ TEAMS_BOT_CONNECTOR_KEYS_KV_KEY,
+ );
+
+ return isDefined(cachedEntry) && isNonEmptyArray(cachedEntry.keys)
+ ? cachedEntry
+ : null;
+ };
+
+export const getTeamsBotConnectorKeys = async ({
+ forceRefresh = false,
+}: {
+ forceRefresh?: boolean;
+} = {}): Promise<TeamsBotConnectorKey[]> => {
+ const cachedEntry = await readCachedEntry();
+
+ if (
+ isDefined(cachedEntry) &&
+ canReuse({ entry: cachedEntry, forceRefresh })
+ ) {
+ return cachedEntry.keys;
+ }
+
+ if (isDefined(cachedEntry)) {
+ await kv.set<TeamsBotConnectorKeysCacheEntry>(
+ TEAMS_BOT_CONNECTOR_KEYS_KV_KEY,
+ { ...cachedEntry, refreshAttemptedAtMs: Date.now() },
+ );
+ }
+
+ try {
+ const keys = await fetchTeamsBotConnectorKeys();
+
+ await kv.set<TeamsBotConnectorKeysCacheEntry>(
+ TEAMS_BOT_CONNECTOR_KEYS_KV_KEY,
+ { keys, fetchedAtMs: Date.now(), refreshAttemptedAtMs: Date.now() },
+ );
+
+ return keys;
+ } catch (error) {
+ if (isDefined(cachedEntry)) {
+ return cachedEntry.keys;
+ }
+
+ throw error;
+ }
+};
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/is-teams-endorsed-key.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/is-teams-endorsed-key.ts
new file mode 100644
index 00000000000..6d33f5d4a30
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/is-teams-endorsed-key.ts
@@ -0,0 +1,7 @@
+import { isArray } from '@sniptt/guards';
+
+import { TEAMS_CHANNEL_ID } from 'src/features/chat/logic-functions/constants/teams-channel-id';
+import { type TeamsBotConnectorKey } from 'src/features/chat/logic-functions/types/teams-bot-connector-key.type';
+
+export const isTeamsEndorsedKey = (key: TeamsBotConnectorKey): boolean =>
+ isArray(key.endorsements) && key.endorsements.includes(TEAMS_CHANNEL_ID);
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/resolve-teams-bot-connector-key-or-throw.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/resolve-teams-bot-connector-key-or-throw.ts
new file mode 100644
index 00000000000..0d8858e256b
--- /dev/null
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/resolve-teams-bot-connector-key-or-throw.ts
@@ -0,0 +1,40 @@
+import { isDefined } from 'twenty-sdk/utils';
+
+import { type LoadTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/types/load-teams-bot-connector-keys.type';
+import { type TeamsBotConnectorKey } from 'src/features/chat/logic-functions/types/teams-bot-connector-key.type';
+import { getTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/utils/get-teams-bot-connector-keys';
+
+const findKey = ({
+ keys,
+ keyId,
+}: {
+ keys: TeamsBotConnectorKey[];
+ keyId: string;
+}) => keys.find((key) => key.kid === keyId);
+
+export const resolveTeamsBotConnectorKeyOrThrow = async ({
+ keyId,
+ loadKeys = getTeamsBotConnectorKeys,
+}: {
+ keyId: string;
+ loadKeys?: LoadTeamsBotConnectorKeys;
+}): Promise<TeamsBotConnectorKey> => {
+ const cachedKey = findKey({ keys: await loadKeys(), keyId });
+
+ if (isDefined(cachedKey)) {
+ return cachedKey;
+ }
+
+ const refreshedKey = findKey({
+ keys: await loadKeys({ forceRefresh: true }),
+ keyId,
+ });
+
+ if (isDefined(refreshedKey)) {
+ return refreshedKey;
+ }
+
+ throw new Error(
+ 'Teams activity token is signed with a key the Bot Connector does not publish',
+ );
+};
diff --git a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/verify-teams-activity-token.ts b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/verify-teams-activity-token.ts
index 7facf7b912e..48157ebceab 100644
--- a/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/verify-teams-activity-token.ts
+++ b/packages/twenty-apps/public/teams/src/features/chat/logic-functions/utils/verify-teams-activity-token.ts
@@ -1,15 +1,13 @@
import { isNonEmptyString } from '@sniptt/guards';
-import { createRemoteJWKSet, jwtVerify } from 'jose';
+import { decodeProtectedHeader, importJWK, jwtVerify } from 'jose';
import { isDefined } from 'twenty-sdk/utils';
import { TEAMS_BOT_CONNECTOR_ISSUER } from 'src/features/chat/logic-functions/constants/teams-bot-connector-issuer';
-import { TEAMS_BOT_OPENID_KEYS_URL } from 'src/features/chat/logic-functions/constants/teams-bot-openid-keys-url';
import { TEAMS_JWT_CLOCK_TOLERANCE_SECONDS } from 'src/features/chat/logic-functions/constants/teams-jwt-clock-tolerance-seconds';
+import { type LoadTeamsBotConnectorKeys } from 'src/features/chat/logic-functions/types/load-teams-bot-connector-keys.type';
+import { isTeamsEndorsedKey } from 'src/features/chat/logic-functions/utils/is-teams-endorsed-key';
import { normalizeTeamsServiceUrl } from 'src/features/chat/logic-functions/utils/normalize-teams-service-url';
-
-const botConnectorKeySet = createRemoteJWKSet(
- new URL(TEAMS_BOT_OPENID_KEYS_URL),
-);
+import { resolveTeamsBotConnectorKeyOrThrow } from 'src/features/chat/logic-functions/utils/resolve-teams-bot-connector-key-or-throw';
const extractBearerToken = (
authorizationHeader: string | undefined,
@@ -33,6 +31,16 @@ const extractBearerToken = (
return token;
};
+const readKeyId = (token: string): string | null => {
+ try {
+ const { kid } = decodeProtectedHeader(token);
+
+ return isNonEmptyString(kid) ? kid : null;
+ } catch {
+ return null;
+ }
+};
+
const readServiceUrlClaim = (payload: Record<string, unknown>): string | null =>
[payload.serviceurl, payload.serviceUrl].find(isNonEmptyString) ?? null;
@@ -40,12 +48,12 @@ export const verifyTeamsActivityTokenOrThrow = async ({
authorizationHeader,
activityServiceUrl,
botAppId,
- keySet = botConnectorKeySet,
+ loadKeys,
}: {
authorizationHeader: string | undefined;
activityServiceUrl: string;
botAppId: string;
- keySet?: Parameters<typeof jwtVerify>[1];
+ loadKeys?: LoadTeamsBotConnectorKeys;
}): Promise<string> => {
const token = extractBearerToken(authorizationHeader);
@@ -55,13 +63,34 @@ export const verifyTeamsActivityTokenOrThrow = async ({
);
}
- const { payload } = await jwtVerify(token, keySet, {
- issuer: TEAMS_BOT_CONNECTOR_ISSUER,
- audience: botAppId,
- algorithms: ['RS256'],
- clockTolerance: TEAMS_JWT_CLOCK_TOLERANCE_SECONDS,
+ const keyId = readKeyId(token);
+
+ if (!isDefined(keyId)) {
+ throw new Error('Teams activity token names no signing key');
+ }
+
+ const signingKey = await resolveTeamsBotConnectorKeyOrThrow({
+ keyId,
+ loadKeys,
});
+ if (!isTeamsEndorsedKey(signingKey)) {
+ throw new Error(
+ 'Teams activity token is signed with a key not endorsed for Teams',
+ );
+ }
+
+ const { payload } = await jwtVerify(
+ token,
+ await importJWK(signingKey, 'RS256'),
+ {
+ issuer: TEAMS_BOT_CONNECTOR_ISSUER,
+ audience: botAppId,
+ algorithms: ['RS256'],
+ clockTolerance: TEAMS_JWT_CLOCK_TOLERANCE_SECONDS,
+ },
+ );
+
const serviceUrlClaim = readServiceUrlClaim(payload);
if (!isDefined(serviceUrlClaim)) {