first commit

packages/nodes-base/nodes/Slack/SlackTriggerHelpers.ts

@@ -0,0 +1,126 @@
+import { createHmac } from 'crypto';
+import type { IHttpRequestOptions, IWebhookFunctions } from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import { slackApiRequest } from './V2/GenericFunctions';
+import { verifySignature as verifySignatureGeneric } from '../../utils/webhook-signature-verification';
+
+export async function getUserInfo(this: IWebhookFunctions, userId: string): Promise<any> {
+	const user = await slackApiRequest.call(
+		this,
+		'GET',
+		'/users.info',
+		{},
+		{
+			user: userId,
+		},
+	);
+
+	return user.user.name;
+}
+
+export async function getChannelInfo(this: IWebhookFunctions, channelId: string): Promise<any> {
+	const channel = await slackApiRequest.call(
+		this,
+		'GET',
+		'/conversations.info',
+		{},
+		{
+			channel: channelId,
+		},
+	);
+
+	return channel.channel.name;
+}
+
+export async function downloadFile(this: IWebhookFunctions, url: string): Promise<any> {
+	let options: IHttpRequestOptions = {
+		method: 'GET',
+		url,
+	};
+
+	const requestOptions = {
+		encoding: 'arraybuffer',
+		returnFullResponse: true,
+		json: false,
+		useStream: true,
+	};
+
+	options = Object.assign({}, options, requestOptions);
+
+	const response = await this.helpers.requestWithAuthentication.call(this, 'slackApi', options);
+
+	if (response.ok === false) {
+		if (response.error === 'paid_teams_only') {
+			throw new NodeOperationError(
+				this.getNode(),
+				`Your current Slack plan does not include the resource '${
+					this.getNodeParameter('resource', 0) as string
+				}'`,
+				{
+					description:
+						'Hint: Upgrade to a Slack plan that includes the functionality you want to use.',
+					level: 'warning',
+				},
+			);
+		} else if (response.error === 'missing_scope') {
+			throw new NodeOperationError(
+				this.getNode(),
+				'Your Slack credential is missing required Oauth Scopes',
+				{
+					description: `Add the following scope(s) to your Slack App: ${response.needed}`,
+					level: 'warning',
+				},
+			);
+		}
+		throw new NodeOperationError(
+			this.getNode(),
+			'Slack error response: ' + JSON.stringify(response.error),
+		);
+	}
+	return response;
+}
+
+export async function verifySignature(this: IWebhookFunctions): Promise<boolean> {
+	const credential = await this.getCredentials('slackApi');
+	const req = this.getRequestObject();
+
+	const timestamp = req.header('x-slack-request-timestamp');
+	if (!timestamp) {
+		return false;
+	}
+
+	const signatureSecret = credential.signatureSecret;
+	try {
+		const isValid = verifySignatureGeneric({
+			getExpectedSignature: () => {
+				if (!signatureSecret || typeof signatureSecret !== 'string' || !req.rawBody) {
+					return null;
+				}
+
+				const hmac = createHmac('sha256', signatureSecret);
+
+				if (Buffer.isBuffer(req.rawBody)) {
+					hmac.update(`v0:${timestamp}:`);
+					hmac.update(req.rawBody);
+				} else {
+					const rawBodyString =
+						typeof req.rawBody === 'string' ? req.rawBody : JSON.stringify(req.rawBody);
+					hmac.update(`v0:${timestamp}:${rawBodyString}`);
+				}
+
+				const computedSignature = `v0=${hmac.digest('hex')}`;
+				return computedSignature;
+			},
+			skipIfNoExpectedSignature: !signatureSecret || typeof signatureSecret !== 'string',
+			getActualSignature: () => {
+				const actualSignature = req.header('x-slack-signature');
+				return typeof actualSignature === 'string' ? actualSignature : null;
+			},
+			getTimestamp: () => timestamp,
+		});
+		return isValid;
+	} catch (error) {
+		return false;
+	}
+}