first commit

packages/nodes-base/nodes/Crypto/v2/CryptoV2.node.ts

@@ -0,0 +1,586 @@
+import type { BinaryToTextEncoding } from 'crypto';
+import { createHash, createHmac, createSign, getHashes, randomBytes } from 'crypto';
+import set from 'lodash/set';
+import type {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeBaseDescription,
+	INodeTypeDescription,
+	JsonObject,
+} from 'n8n-workflow';
+import { deepCopy, BINARY_ENCODING, NodeConnectionTypes, NodeOperationError } from 'n8n-workflow';
+import { pipeline } from 'stream/promises';
+import { v4 as uuid } from 'uuid';
+
+import { formatPrivateKey } from '../../../utils/utilities';
+
+const unsupportedAlgorithms = [
+	'RSA-MD4',
+	'RSA-MDC2',
+	'md4',
+	'md4WithRSAEncryption',
+	'mdc2',
+	'mdc2WithRSA',
+];
+
+const supportedAlgorithms = getHashes()
+	.filter((algorithm) => !unsupportedAlgorithms.includes(algorithm))
+	.map((algorithm) => ({ name: algorithm, value: algorithm }));
+
+const versionDescription: INodeTypeDescription = {
+	displayName: 'Crypto',
+	name: 'crypto',
+	icon: 'fa:key',
+	iconColor: 'green',
+	group: ['transform'],
+	version: 2,
+	subtitle: '={{$parameter["action"]}}',
+	description: 'Provide cryptographic utilities',
+	defaults: {
+		name: 'Crypto',
+		color: '#408000',
+	},
+	usableAsTool: true,
+	inputs: [NodeConnectionTypes.Main],
+	outputs: [NodeConnectionTypes.Main],
+	credentials: [
+		{
+			// eslint-disable-next-line n8n-nodes-base/node-class-description-credentials-name-unsuffixed
+			name: 'crypto',
+			required: true,
+			displayOptions: {
+				show: {
+					action: ['hmac', 'sign'],
+				},
+			},
+		},
+	],
+	properties: [
+		{
+			displayName: 'Action',
+			name: 'action',
+			type: 'options',
+			options: [
+				{
+					name: 'Generate',
+					description: 'Generate random string',
+					value: 'generate',
+					action: 'Generate random string',
+				},
+				{
+					name: 'Hash',
+					description: 'Hash a text or file in a specified format',
+					value: 'hash',
+					action: 'Hash a text or file in a specified format',
+				},
+				{
+					name: 'Hmac',
+					description: 'Hmac a text or file in a specified format',
+					value: 'hmac',
+					action: 'HMAC a text or file in a specified format',
+				},
+				{
+					name: 'Sign',
+					description: 'Sign a string using a private key',
+					value: 'sign',
+					action: 'Sign a string using a private key',
+				},
+			],
+			default: 'hash',
+		},
+		{
+			displayName: 'Binary File',
+			name: 'binaryData',
+			type: 'boolean',
+			default: false,
+			required: true,
+			displayOptions: {
+				show: {
+					action: ['hash', 'hmac'],
+				},
+			},
+			description: 'Whether the data to hashed should be taken from binary field',
+		},
+		{
+			displayName: 'Binary Property Name',
+			name: 'binaryPropertyName',
+			displayOptions: {
+				show: {
+					action: ['hash', 'hmac'],
+					binaryData: [true],
+				},
+			},
+			type: 'string',
+			default: 'data',
+			description: 'Name of the binary property which contains the input data',
+			required: true,
+		},
+		{
+			displayName: 'Type',
+			name: 'type',
+			displayOptions: {
+				show: {
+					action: ['hash'],
+				},
+			},
+			type: 'options',
+			options: [
+				{
+					name: 'MD5',
+					value: 'MD5',
+				},
+				{
+					name: 'SHA256',
+					value: 'SHA256',
+				},
+				{
+					name: 'SHA3-256',
+					value: 'SHA3-256',
+				},
+				{
+					name: 'SHA3-384',
+					value: 'SHA3-384',
+				},
+				{
+					name: 'SHA3-512',
+					value: 'SHA3-512',
+				},
+				{
+					name: 'SHA384',
+					value: 'SHA384',
+				},
+				{
+					name: 'SHA512',
+					value: 'SHA512',
+				},
+			],
+			default: 'SHA256',
+			description: 'The hash type to use',
+			required: true,
+		},
+		{
+			displayName: 'Value',
+			name: 'value',
+			displayOptions: {
+				show: {
+					action: ['hash'],
+					binaryData: [false],
+				},
+			},
+			type: 'string',
+			default: '',
+			description: 'The value that should be hashed',
+			required: true,
+		},
+		{
+			displayName: 'Property Name',
+			name: 'dataPropertyName',
+			type: 'string',
+			default: 'data',
+			required: true,
+			displayOptions: {
+				show: {
+					action: ['hash'],
+				},
+			},
+			description: 'Name of the property to which to write the hash',
+		},
+		{
+			displayName: 'Encoding',
+			name: 'encoding',
+			displayOptions: {
+				show: {
+					action: ['hash'],
+				},
+			},
+			type: 'options',
+			options: [
+				{
+					name: 'BASE64',
+					value: 'base64',
+				},
+				{
+					name: 'HEX',
+					value: 'hex',
+				},
+			],
+			default: 'hex',
+			required: true,
+		},
+		{
+			displayName: 'Type',
+			name: 'type',
+			displayOptions: {
+				show: {
+					action: ['hmac'],
+				},
+			},
+			type: 'options',
+			options: [
+				{
+					name: 'MD5',
+					value: 'MD5',
+				},
+				{
+					name: 'SHA256',
+					value: 'SHA256',
+				},
+				{
+					name: 'SHA3-256',
+					value: 'SHA3-256',
+				},
+				{
+					name: 'SHA3-384',
+					value: 'SHA3-384',
+				},
+				{
+					name: 'SHA3-512',
+					value: 'SHA3-512',
+				},
+				{
+					name: 'SHA384',
+					value: 'SHA384',
+				},
+				{
+					name: 'SHA512',
+					value: 'SHA512',
+				},
+			],
+			default: 'SHA256',
+			description: 'The hash type to use',
+			required: true,
+		},
+		{
+			displayName: 'Value',
+			name: 'value',
+			displayOptions: {
+				show: {
+					action: ['hmac'],
+					binaryData: [false],
+				},
+			},
+			type: 'string',
+			default: '',
+			description: 'The value of which the hmac should be created',
+			required: true,
+		},
+		{
+			displayName: 'Property Name',
+			name: 'dataPropertyName',
+			type: 'string',
+			default: 'data',
+			required: true,
+			displayOptions: {
+				show: {
+					action: ['hmac'],
+				},
+			},
+			description: 'Name of the property to which to write the hmac',
+		},
+		{
+			displayName: 'Encoding',
+			name: 'encoding',
+			displayOptions: {
+				show: {
+					action: ['hmac'],
+				},
+			},
+			type: 'options',
+			options: [
+				{
+					name: 'BASE64',
+					value: 'base64',
+				},
+				{
+					name: 'HEX',
+					value: 'hex',
+				},
+			],
+			default: 'hex',
+			required: true,
+		},
+		{
+			displayName: 'Value',
+			name: 'value',
+			displayOptions: {
+				show: {
+					action: ['sign'],
+				},
+			},
+			type: 'string',
+			default: '',
+			description: 'The value that should be signed',
+			required: true,
+		},
+		{
+			displayName: 'Property Name',
+			name: 'dataPropertyName',
+			type: 'string',
+			default: 'data',
+			required: true,
+			displayOptions: {
+				show: {
+					action: ['sign'],
+				},
+			},
+			description: 'Name of the property to which to write the signed value',
+		},
+		{
+			displayName: 'Algorithm Name or ID',
+			name: 'algorithm',
+			displayOptions: {
+				show: {
+					action: ['sign'],
+				},
+			},
+			type: 'options',
+			description:
+				'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+			options: supportedAlgorithms,
+			default: '',
+			required: true,
+		},
+		{
+			displayName: 'Encoding',
+			name: 'encoding',
+			displayOptions: {
+				show: {
+					action: ['sign'],
+				},
+			},
+			type: 'options',
+			options: [
+				{
+					name: 'BASE64',
+					value: 'base64',
+				},
+				{
+					name: 'HEX',
+					value: 'hex',
+				},
+			],
+			default: 'hex',
+			required: true,
+		},
+		{
+			displayName: 'Property Name',
+			name: 'dataPropertyName',
+			type: 'string',
+			default: 'data',
+			required: true,
+			displayOptions: {
+				show: {
+					action: ['generate'],
+				},
+			},
+			description: 'Name of the property to which to write the random string',
+		},
+		{
+			displayName: 'Type',
+			name: 'encodingType',
+			displayOptions: {
+				show: {
+					action: ['generate'],
+				},
+			},
+			type: 'options',
+			options: [
+				{
+					name: 'ASCII',
+					value: 'ascii',
+				},
+				{
+					name: 'BASE64',
+					value: 'base64',
+				},
+				{
+					name: 'HEX',
+					value: 'hex',
+				},
+				{
+					name: 'UUID',
+					value: 'uuid',
+				},
+			],
+			default: 'uuid',
+			description: 'Encoding that will be used to generate string',
+			required: true,
+		},
+		{
+			displayName: 'Length',
+			name: 'stringLength',
+			type: 'number',
+			default: 32,
+			description: 'Length of the generated string',
+			displayOptions: {
+				show: {
+					action: ['generate'],
+					encodingType: ['ascii', 'base64', 'hex'],
+				},
+			},
+		},
+	],
+};
+
+export class CryptoV2 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			...versionDescription,
+		};
+	}
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+
+		const returnData: INodeExecutionData[] = [];
+		const length = items.length;
+		const action = this.getNodeParameter('action', 0) as string;
+
+		let hmacSecret = '';
+		let signPrivateKey = '';
+
+		if (action === 'hmac' || action === 'sign') {
+			const credentials = await this.getCredentials<{
+				hmacSecret?: string;
+				signPrivateKey?: string;
+			}>('crypto');
+
+			if (action === 'hmac') {
+				if (!credentials.hmacSecret) {
+					throw new NodeOperationError(
+						this.getNode(),
+						'No HMAC secret set in credentials. Please add an HMAC secret to your Crypto credentials.',
+					);
+				}
+				hmacSecret = credentials.hmacSecret;
+			}
+
+			if (action === 'sign') {
+				if (!credentials.signPrivateKey) {
+					throw new NodeOperationError(
+						this.getNode(),
+						'No private key set in credentials. Please add a private key to your Crypto credentials.',
+					);
+				}
+				signPrivateKey = formatPrivateKey(credentials.signPrivateKey);
+			}
+		}
+
+		let item: INodeExecutionData;
+		for (let i = 0; i < length; i++) {
+			try {
+				item = items[i];
+				const dataPropertyName = this.getNodeParameter('dataPropertyName', i);
+				const value = this.getNodeParameter('value', i, '') as string;
+				let newValue;
+				let binaryProcessed = false;
+
+				if (action === 'generate') {
+					const encodingType = this.getNodeParameter('encodingType', i);
+					if (encodingType === 'uuid') {
+						newValue = uuid();
+					} else {
+						const stringLength = this.getNodeParameter('stringLength', i) as number;
+						if (encodingType === 'base64') {
+							newValue = randomBytes(stringLength)
+								.toString(encodingType as BufferEncoding)
+								.replace(/\W/g, '')
+								.slice(0, stringLength);
+						} else {
+							newValue = randomBytes(stringLength)
+								.toString(encodingType as BufferEncoding)
+								.slice(0, stringLength);
+						}
+					}
+				}
+
+				if (action === 'hash' || action === 'hmac') {
+					const type = this.getNodeParameter('type', i) as string;
+					const encoding = this.getNodeParameter('encoding', i) as BinaryToTextEncoding;
+					const hashOrHmac = action === 'hash' ? createHash(type) : createHmac(type, hmacSecret);
+					if (this.getNodeParameter('binaryData', i)) {
+						const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+						const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
+						if (binaryData.id) {
+							const binaryStream = await this.helpers.getBinaryStream(binaryData.id);
+							hashOrHmac.setEncoding(encoding);
+							await pipeline(binaryStream, hashOrHmac);
+							newValue = hashOrHmac.read();
+						} else {
+							newValue = hashOrHmac
+								.update(Buffer.from(binaryData.data, BINARY_ENCODING))
+								.digest(encoding);
+						}
+						binaryProcessed = true;
+					} else {
+						newValue = hashOrHmac.update(value).digest(encoding);
+					}
+				}
+
+				if (action === 'sign') {
+					const algorithm = this.getNodeParameter('algorithm', i) as string;
+					const encoding = this.getNodeParameter('encoding', i) as BinaryToTextEncoding;
+					const sign = createSign(algorithm);
+					sign.write(value);
+					sign.end();
+					newValue = sign.sign(signPrivateKey, encoding);
+				}
+
+				let newItem: INodeExecutionData;
+				if (dataPropertyName.includes('.')) {
+					// Uses dot notation so copy all data
+					newItem = {
+						json: deepCopy(item.json),
+						pairedItem: {
+							item: i,
+						},
+					};
+				} else {
+					// Does not use dot notation so shallow copy is enough
+					newItem = {
+						json: { ...item.json },
+						pairedItem: {
+							item: i,
+						},
+					};
+				}
+
+				if (item.binary !== undefined && !binaryProcessed) {
+					newItem.binary = item.binary;
+				}
+
+				set(newItem, ['json', dataPropertyName], newValue);
+
+				returnData.push(newItem);
+			} catch (error) {
+				if (this.continueOnFail()) {
+					const errorDetails = error as Error & { code?: string };
+					const errorData: JsonObject = {
+						message: errorDetails.message,
+					};
+					if (errorDetails.name) {
+						errorData.name = errorDetails.name;
+					}
+					if (errorDetails.code) {
+						errorData.code = errorDetails.code;
+					}
+					returnData.push({
+						json: {
+							error: errorData,
+						},
+						pairedItem: {
+							item: i,
+						},
+					});
+					continue;
+				}
+				throw error;
+			}
+		}
+		return [returnData];
+	}
+}

packages/nodes-base/nodes/Crypto/v2/test/Crypto.node.test.ts

@@ -0,0 +1,239 @@
+import { mockDeep } from 'jest-mock-extended';
+import type { IExecuteFunctions, INodeTypeBaseDescription } from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+
+import { CryptoV2 } from '../CryptoV2.node';
+
+describe('CryptoV2 Node', () => {
+	let cryptoNode: CryptoV2;
+	let mockExecuteFunctions: jest.Mocked<IExecuteFunctions>;
+
+	const baseDescription: INodeTypeBaseDescription = {
+		displayName: 'Crypto',
+		name: 'crypto',
+		icon: 'fa:key',
+		iconColor: 'green',
+		group: ['transform'],
+		defaultVersion: 2,
+		subtitle: '={{$parameter["action"]}}',
+		description: 'Provide cryptographic utilities',
+	};
+
+	beforeEach(() => {
+		cryptoNode = new CryptoV2(baseDescription);
+		mockExecuteFunctions = mockDeep<IExecuteFunctions>();
+		jest.clearAllMocks();
+
+		mockExecuteFunctions.getNode.mockReturnValue({
+			id: 'crypto-node',
+			name: 'Crypto',
+			type: 'n8n-nodes-base.crypto',
+			typeVersion: 2,
+			position: [0, 0],
+			parameters: {},
+		});
+	});
+
+	describe('Credential Validation', () => {
+		describe('HMAC action', () => {
+			it('should throw error when hmacSecret is not set in credentials', async () => {
+				mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					const params: Record<string, string | boolean> = {
+						action: 'hmac',
+						type: 'SHA256',
+						encoding: 'hex',
+						dataPropertyName: 'data',
+						binaryData: false,
+						value: 'test value',
+					};
+					return params[paramName];
+				});
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					hmacSecret: '',
+					signPrivateKey: 'some-key',
+				});
+
+				await expect(cryptoNode.execute.call(mockExecuteFunctions)).rejects.toThrow(
+					NodeOperationError,
+				);
+				await expect(cryptoNode.execute.call(mockExecuteFunctions)).rejects.toThrow(
+					'No HMAC secret set in credentials',
+				);
+			});
+
+			it('should execute successfully when hmacSecret is provided', async () => {
+				mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					const params: Record<string, string | boolean> = {
+						action: 'hmac',
+						type: 'SHA256',
+						encoding: 'base64',
+						dataPropertyName: 'data',
+						binaryData: false,
+						value: 'test',
+					};
+					return params[paramName];
+				});
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					hmacSecret:
+						'-----BEGIN RSA PRIVATE KEY-----|MIIBOgIBAAJBAKj34GkxFhD90vcNLYLInFEX6Ppy1tPf9Cnzj4p4WGeKLs1Pt8QuKUpRKfFLfRYC9AIKjbJTWit+CqvjWYzvQwECAwEAAQJAIJLixBy2qpFoS4DSmoEmo3qGy0t6z09AIJtH+5OeRV1be+N4cDYJKffGzDa88vQENZiRm0GRq6a+HPGQMd2kTQIhAKMSvzIBnni7ot/OSie2TmJLY4SwTQAevXysE2RbFDYdAiEBCUEaRQnMnbp79mxDXDf6AU0cN/RPBjb9qSHDcWZHGzUCIG2Es59z8ugGrDY+pxLQnwfotadxd+Uyv/Ow5T0q5gIJAiEAyS4RaI9YG8EWx/2w0T67ZUVAw8eOMB6BIUg0Xcu+3okCIBOs/5OiPgoTdSy7bcF9IGpSE8ZgGKzgYQVZeN97YE00-----END RSA PRIVATE KEY-----',
+					signPrivateKey: '',
+				});
+
+				const result = await cryptoNode.execute.call(mockExecuteFunctions);
+
+				expect(result[0][0].json.data).toBe('hoB1e7VM7nbOTl8floCPteEqN4ZODWlVc9IWQjsEhUk=');
+			});
+		});
+
+		describe('Sign action', () => {
+			it('should throw error when signPrivateKey is not set in credentials', async () => {
+				mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					const params: Record<string, string> = {
+						action: 'sign',
+						algorithm: 'RSA-SHA256',
+						encoding: 'hex',
+						dataPropertyName: 'data',
+						value: 'test value',
+					};
+					return params[paramName];
+				});
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					hmacSecret: 'some-secret',
+					signPrivateKey: '',
+				});
+
+				await expect(cryptoNode.execute.call(mockExecuteFunctions)).rejects.toThrow(
+					NodeOperationError,
+				);
+				await expect(cryptoNode.execute.call(mockExecuteFunctions)).rejects.toThrow(
+					'No private key set in credentials',
+				);
+			});
+
+			it('should sign data with valid private key', async () => {
+				// Key format matches V1 workflow JSON - uses \n escape sequences
+				const privateKey =
+					'-----BEGIN RSA PRIVATE KEY-----\nMIIBOgIBAAJBAKj34GkxFhD90vcNLYLInFEX6Ppy1tPf9Cnzj4p4WGeKLs1Pt8Qu\nKUpRKfFLfRYC9AIKjbJTWit+CqvjWYzvQwECAwEAAQJAIJLixBy2qpFoS4DSmoEm\no3qGy0t6z09AIJtH+5OeRV1be+N4cDYJKffGzDa88vQENZiRm0GRq6a+HPGQMd2k\nTQIhAKMSvzIBnni7ot/OSie2TmJLY4SwTQAevXysE2RbFDYdAiEBCUEaRQnMnbp7\n9mxDXDf6AU0cN/RPBjb9qSHDcWZHGzUCIG2Es59z8ugGrDY+pxLQnwfotadxd+Uy\nv/Ow5T0q5gIJAiEAyS4RaI9YG8EWx/2w0T67ZUVAw8eOMB6BIUg0Xcu+3okCIBOs\n/5OiPgoTdSy7bcF9IGpSE8ZgGKzgYQVZeN97YE00\n-----END RSA PRIVATE KEY-----';
+
+				mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+				mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					const params: Record<string, string> = {
+						action: 'sign',
+						algorithm: 'RSA-SHA256',
+						encoding: 'base64',
+						dataPropertyName: 'data',
+						value: 'test',
+					};
+					return params[paramName];
+				});
+				mockExecuteFunctions.getCredentials.mockResolvedValue({
+					hmacSecret: '',
+					signPrivateKey: privateKey,
+				});
+
+				const result = await cryptoNode.execute.call(mockExecuteFunctions);
+
+				expect(result[0][0].json.data).toBe(
+					'ZlDI7xX0XElJHwEpTw08Ykz/D+IJ+hQkcb4Cr929bUjiiLRXy8Etagc0Miuld2WnksIaznNmlqn7bom5oOpDnw==',
+				);
+			});
+		});
+	});
+
+	describe('Hash action', () => {
+		it('should hash with MD5 (hex encoding)', async () => {
+			mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+			mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				const params: Record<string, string | boolean> = {
+					action: 'hash',
+					type: 'MD5',
+					encoding: 'hex',
+					dataPropertyName: 'data',
+					binaryData: false,
+					value: 'test',
+				};
+				return params[paramName];
+			});
+
+			const result = await cryptoNode.execute.call(mockExecuteFunctions);
+
+			expect(result[0][0].json.data).toBe('098f6bcd4621d373cade4e832627b4f6');
+		});
+
+		it('should hash with MD5 (base64 encoding)', async () => {
+			mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+			mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				const params: Record<string, string | boolean> = {
+					action: 'hash',
+					type: 'MD5',
+					encoding: 'base64',
+					dataPropertyName: 'data',
+					binaryData: false,
+					value: 'test',
+				};
+				return params[paramName];
+			});
+
+			const result = await cryptoNode.execute.call(mockExecuteFunctions);
+
+			expect(result[0][0].json.data).toBe('CY9rzUYh03PK3k6DJie09g==');
+		});
+
+		it('should not require credentials for hash action', async () => {
+			mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+			mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				const params: Record<string, string | boolean> = {
+					action: 'hash',
+					type: 'SHA256',
+					encoding: 'hex',
+					dataPropertyName: 'data',
+					binaryData: false,
+					value: 'test',
+				};
+				return params[paramName];
+			});
+
+			await cryptoNode.execute.call(mockExecuteFunctions);
+
+			expect(mockExecuteFunctions.getCredentials).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('Generate action', () => {
+		it('should generate valid UUID', async () => {
+			mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+			mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				const params: Record<string, string> = {
+					action: 'generate',
+					encodingType: 'uuid',
+					dataPropertyName: 'data',
+				};
+				return params[paramName];
+			});
+
+			const result = await cryptoNode.execute.call(mockExecuteFunctions);
+
+			const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+			expect(result[0][0].json.data).toMatch(uuidRegex);
+		});
+
+		it('should not require credentials for generate action', async () => {
+			mockExecuteFunctions.getInputData.mockReturnValue([{ json: {} }]);
+			mockExecuteFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				const params: Record<string, string> = {
+					action: 'generate',
+					encodingType: 'uuid',
+					dataPropertyName: 'data',
+				};
+				return params[paramName];
+			});
+
+			await cryptoNode.execute.call(mockExecuteFunctions);
+
+			expect(mockExecuteFunctions.getCredentials).not.toHaveBeenCalled();
+		});
+	});
+});