From ed927d34b25b4ddd7048b622c141e32a8a57b6b7 Mon Sep 17 00:00:00 2001 From: Alex Grozav Date: Fri, 25 Aug 2023 11:33:46 +0300 Subject: [PATCH] feat: External Secrets storage for credentials (#6477) Github issue / Community forum post (link here to close automatically): --------- Co-authored-by: Romain Minaud Co-authored-by: Valya Bullions Co-authored-by: Csaba Tuncsik Co-authored-by: Giulio Andreini Co-authored-by: Omar Ajoue --- packages/cli/package.json | 1 + packages/cli/src/CredentialsHelper.ts | 70 ++- .../ExternalSecrets.controller.ee.ts | 102 ++++ .../ExternalSecrets.service.ee.ts | 154 +++++ .../ExternalSecretsManager.ee.ts | 381 ++++++++++++ .../ExternalSecretsProviders.ee.ts | 24 + packages/cli/src/ExternalSecrets/constants.ts | 6 + .../externalSecretsHelper.ee.ts | 7 + .../ExternalSecrets/providers/infisical.ts | 153 +++++ .../src/ExternalSecrets/providers/vault.ts | 559 ++++++++++++++++++ packages/cli/src/Interfaces.ts | 39 ++ packages/cli/src/InternalHooks.ts | 10 + packages/cli/src/License.ts | 4 + packages/cli/src/SecretsHelpers.ts | 41 ++ packages/cli/src/Server.ts | 13 + .../cli/src/WorkflowExecuteAdditionalData.ts | 2 + packages/cli/src/commands/BaseCommand.ts | 6 + packages/cli/src/commands/start.ts | 1 + packages/cli/src/commands/webhook.ts | 1 + packages/cli/src/commands/worker.ts | 1 + packages/cli/src/constants.ts | 1 + .../cli/src/controllers/e2e.controller.ts | 1 + .../src/credentials/credentials.service.ts | 5 +- .../src/credentials/oauth2Credential.api.ts | 9 + .../repositories/settings.repository.ts | 16 + .../MessageEventBusDestinationWebhook.ee.ts | 3 + packages/cli/src/requests.ts | 31 +- .../externalSecrets.api.test.ts | 370 ++++++++++++ packages/cli/test/integration/shared/types.ts | 1 + .../integration/shared/utils/testServer.ts | 4 + .../cli/test/shared/ExternalSecrets/utils.ts | 215 +++++++ .../test/unit/ActiveWorkflowRunner.test.ts | 2 + .../ExternalSecretsManager.test.ts | 194 ++++++ packages/core/src/NodeExecuteFunctions.ts | 4 + packages/core/src/Secrets.ts | 76 +++ .../src/components/N8nCallout/Callout.vue | 2 +- .../__snapshots__/Callout.spec.ts.snap | 2 +- packages/design-system/src/css/loading.scss | 4 +- .../src/css/utilities/_link.scss | 10 + .../src/css/utilities/index.scss | 1 + packages/editor-ui/src/Interface.ts | 21 + .../editor-ui/src/api/externalSecrets.ee.ts | 58 ++ .../editor-ui/src/assets/images/doppler.webp | Bin 0 -> 315064 bytes .../src/assets/images/hashicorp.webp | Bin 0 -> 1602 bytes .../src/assets/images/infisical.webp | Bin 0 -> 1560 bytes .../components/CodeNodeEditor/completer.ts | 1 + .../completions/secrets.completions.ts | 54 ++ .../completions/variables.completions.ts | 2 +- .../CredentialEdit/CredentialConfig.vue | 13 + .../CredentialEdit/CredentialEdit.vue | 24 +- .../components/ExpressionParameterInput.vue | 8 +- .../ExternalSecretsProviderCard.ee.vue | 185 ++++++ ...rnalSecretsProviderConnectionSwitch.ee.vue | 116 ++++ .../ExternalSecretsProviderImage.ee.vue | 28 + .../ExternalSecretsProviderModal.ee.vue | 331 +++++++++++ .../InlineExpressionEditorInput.vue | 8 +- packages/editor-ui/src/components/Modals.vue | 10 + .../src/components/ParameterInput.vue | 6 + .../src/components/ParameterInputExpanded.vue | 6 +- .../src/components/ParameterInputWrapper.vue | 20 +- .../src/components/SettingsSidebar.vue | 54 +- packages/editor-ui/src/composables/index.ts | 1 + .../composables/useExternalSecretsProvider.ts | 101 ++++ packages/editor-ui/src/constants.ts | 4 + .../editor-ui/src/mixins/expressionManager.ts | 8 +- .../editor-ui/src/mixins/workflowHelpers.ts | 4 + .../completions/__tests__/completions.test.ts | 88 ++- .../completions/datatype.completions.ts | 58 +- .../completions/dollar.completions.ts | 21 +- .../plugins/codemirror/completions/utils.ts | 5 +- .../src/plugins/i18n/locales/en.json | 42 ++ .../editor-ui/src/plugins/icons/custom.ts | 12 + packages/editor-ui/src/plugins/icons/index.ts | 3 +- packages/editor-ui/src/router.ts | 23 + .../src/stores/externalSecrets.ee.store.ts | 164 +++++ packages/editor-ui/src/stores/index.ts | 1 + packages/editor-ui/src/stores/ui.store.ts | 4 + packages/editor-ui/src/utils/expressions.ts | 12 + packages/editor-ui/src/utils/index.ts | 1 + .../editor-ui/src/views/CredentialsView.vue | 3 + packages/editor-ui/src/views/NodeView.vue | 6 + .../src/views/SettingsExternalSecrets.vue | 75 +++ .../__tests__/SettingsExternalSecrets.test.ts | 60 ++ packages/nodes-base/test/nodes/Helpers.ts | 1 + packages/workflow/src/Expression.ts | 5 +- packages/workflow/src/Interfaces.ts | 14 + packages/workflow/src/index.ts | 1 + packages/workflow/test/Helpers.ts | 1 + pnpm-lock.yaml | 32 + 89 files changed, 4164 insertions(+), 57 deletions(-) create mode 100644 packages/cli/src/ExternalSecrets/ExternalSecrets.controller.ee.ts create mode 100644 packages/cli/src/ExternalSecrets/ExternalSecrets.service.ee.ts create mode 100644 packages/cli/src/ExternalSecrets/ExternalSecretsManager.ee.ts create mode 100644 packages/cli/src/ExternalSecrets/ExternalSecretsProviders.ee.ts create mode 100644 packages/cli/src/ExternalSecrets/constants.ts create mode 100644 packages/cli/src/ExternalSecrets/externalSecretsHelper.ee.ts create mode 100644 packages/cli/src/ExternalSecrets/providers/infisical.ts create mode 100644 packages/cli/src/ExternalSecrets/providers/vault.ts create mode 100644 packages/cli/src/SecretsHelpers.ts create mode 100644 packages/cli/test/integration/ExternalSecrets/externalSecrets.api.test.ts create mode 100644 packages/cli/test/shared/ExternalSecrets/utils.ts create mode 100644 packages/cli/test/unit/ExternalSecrets/ExternalSecretsManager.test.ts create mode 100644 packages/core/src/Secrets.ts create mode 100644 packages/design-system/src/css/utilities/_link.scss create mode 100644 packages/editor-ui/src/api/externalSecrets.ee.ts create mode 100644 packages/editor-ui/src/assets/images/doppler.webp create mode 100644 packages/editor-ui/src/assets/images/hashicorp.webp create mode 100644 packages/editor-ui/src/assets/images/infisical.webp create mode 100644 packages/editor-ui/src/components/CodeNodeEditor/completions/secrets.completions.ts create mode 100644 packages/editor-ui/src/components/ExternalSecretsProviderCard.ee.vue create mode 100644 packages/editor-ui/src/components/ExternalSecretsProviderConnectionSwitch.ee.vue create mode 100644 packages/editor-ui/src/components/ExternalSecretsProviderImage.ee.vue create mode 100644 packages/editor-ui/src/components/ExternalSecretsProviderModal.ee.vue create mode 100644 packages/editor-ui/src/composables/useExternalSecretsProvider.ts create mode 100644 packages/editor-ui/src/stores/externalSecrets.ee.store.ts create mode 100644 packages/editor-ui/src/utils/expressions.ts create mode 100644 packages/editor-ui/src/views/SettingsExternalSecrets.vue create mode 100644 packages/editor-ui/src/views/__tests__/SettingsExternalSecrets.test.ts diff --git a/packages/cli/package.json b/packages/cli/package.json index 2cc9396c4b..9c9b788222 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -139,6 +139,7 @@ "formidable": "^3.5.0", "google-timezones-json": "^1.1.0", "handlebars": "4.7.7", + "infisical-node": "^1.3.0", "inquirer": "^7.0.1", "ioredis": "^5.2.4", "json-diff": "^1.0.6", diff --git a/packages/cli/src/CredentialsHelper.ts b/packages/cli/src/CredentialsHelper.ts index 303b7a0fcb..f8bfc0cc8a 100644 --- a/packages/cli/src/CredentialsHelper.ts +++ b/packages/cli/src/CredentialsHelper.ts @@ -31,6 +31,7 @@ import type { IHttpRequestHelper, INodeTypeData, INodeTypes, + IWorkflowExecuteAdditionalData, ICredentialTestFunctions, } from 'n8n-workflow'; import { @@ -342,6 +343,7 @@ export class CredentialsHelper extends ICredentialsHelper { * @param {boolean} [raw] Return the data as supplied without defaults or overwrites */ async getDecrypted( + additionalData: IWorkflowExecuteAdditionalData, nodeCredentials: INodeCredentialsDetails, type: string, mode: WorkflowExecuteMode, @@ -356,12 +358,18 @@ export class CredentialsHelper extends ICredentialsHelper { return decryptedDataOriginal; } + await additionalData?.secretsHelpers?.waitForInit(); + + const canUseSecrets = await this.credentialOwnedByOwner(nodeCredentials); + return this.applyDefaultsAndOverwrites( + additionalData, decryptedDataOriginal, type, mode, defaultTimezone, expressionResolveValues, + canUseSecrets, ); } @@ -369,11 +377,13 @@ export class CredentialsHelper extends ICredentialsHelper { * Applies credential default data and overwrites */ applyDefaultsAndOverwrites( + additionalData: IWorkflowExecuteAdditionalData, decryptedDataOriginal: ICredentialDataDecryptedObject, type: string, mode: WorkflowExecuteMode, defaultTimezone: string, expressionResolveValues?: ICredentialsExpressionResolveValues, + canUseSecrets?: boolean, ): ICredentialDataDecryptedObject { const credentialsProperties = this.getCredentialsProperties(type); @@ -395,6 +405,10 @@ export class CredentialsHelper extends ICredentialsHelper { decryptedData.oauthTokenData = decryptedDataOriginal.oauthTokenData; } + const additionalKeys = NodeExecuteFunctions.getAdditionalKeys(additionalData, mode, null, { + secretsEnabled: canUseSecrets, + }); + if (expressionResolveValues) { const timezone = expressionResolveValues.workflow.settings.timezone ?? defaultTimezone; @@ -408,7 +422,7 @@ export class CredentialsHelper extends ICredentialsHelper { expressionResolveValues.connectionInputData, mode, timezone, - {}, + additionalKeys, undefined, false, decryptedData, @@ -431,7 +445,7 @@ export class CredentialsHelper extends ICredentialsHelper { decryptedData as INodeParameters, mode, defaultTimezone, - {}, + additionalKeys, undefined, undefined, decryptedData, @@ -573,10 +587,24 @@ export class CredentialsHelper extends ICredentialsHelper { } if (credentialsDecrypted.data) { - credentialsDecrypted.data = CredentialsOverwrites().applyOverwrite( - credentialType, - credentialsDecrypted.data, - ); + try { + const additionalData = await WorkflowExecuteAdditionalData.getBase(user.id); + credentialsDecrypted.data = this.applyDefaultsAndOverwrites( + additionalData, + credentialsDecrypted.data, + credentialType, + 'internal' as WorkflowExecuteMode, + additionalData.timezone, + undefined, + user.isOwner, + ); + } catch (error) { + Logger.debug('Credential test failed', error); + return { + status: 'Error', + message: error.message.toString(), + }; + } } if (typeof credentialTestFunction === 'function') { @@ -759,6 +787,36 @@ export class CredentialsHelper extends ICredentialsHelper { message: 'Connection successful!', }; } + + async credentialOwnedByOwner(nodeCredential: INodeCredentialsDetails): Promise { + if (!nodeCredential.id) { + return false; + } + + const credential = await Db.collections.SharedCredentials.findOne({ + where: { + role: { + scope: 'credential', + name: 'owner', + }, + user: { + globalRole: { + scope: 'global', + name: 'owner', + }, + }, + credentials: { + id: nodeCredential.id, + }, + }, + }); + + if (!credential) { + return false; + } + + return true; + } } /** diff --git a/packages/cli/src/ExternalSecrets/ExternalSecrets.controller.ee.ts b/packages/cli/src/ExternalSecrets/ExternalSecrets.controller.ee.ts new file mode 100644 index 0000000000..10eed808a6 --- /dev/null +++ b/packages/cli/src/ExternalSecrets/ExternalSecrets.controller.ee.ts @@ -0,0 +1,102 @@ +import { Authorized, Get, Post, RestController } from '@/decorators'; +import { ExternalSecretsRequest } from '@/requests'; +import { NotFoundError } from '@/ResponseHelper'; +import { Response } from 'express'; +import { Service } from 'typedi'; +import { ProviderNotFoundError, ExternalSecretsService } from './ExternalSecrets.service.ee'; + +@Service() +@Authorized(['global', 'owner']) +@RestController('/external-secrets') +export class ExternalSecretsController { + constructor(private readonly secretsService: ExternalSecretsService) {} + + @Get('/providers') + async getProviders() { + return this.secretsService.getProviders(); + } + + @Get('/providers/:provider') + async getProvider(req: ExternalSecretsRequest.GetProvider) { + const providerName = req.params.provider; + try { + return this.secretsService.getProvider(providerName); + } catch (e) { + if (e instanceof ProviderNotFoundError) { + throw new NotFoundError(`Could not find provider "${e.providerName}"`); + } + throw e; + } + } + + @Post('/providers/:provider/test') + async testProviderSettings(req: ExternalSecretsRequest.TestProviderSettings, res: Response) { + const providerName = req.params.provider; + try { + const result = await this.secretsService.testProviderSettings(providerName, req.body); + if (result.success) { + res.statusCode = 200; + } else { + res.statusCode = 400; + } + return result; + } catch (e) { + if (e instanceof ProviderNotFoundError) { + throw new NotFoundError(`Could not find provider "${e.providerName}"`); + } + throw e; + } + } + + @Post('/providers/:provider') + async setProviderSettings(req: ExternalSecretsRequest.SetProviderSettings) { + const providerName = req.params.provider; + try { + await this.secretsService.saveProviderSettings(providerName, req.body, req.user.id); + } catch (e) { + if (e instanceof ProviderNotFoundError) { + throw new NotFoundError(`Could not find provider "${e.providerName}"`); + } + throw e; + } + return {}; + } + + @Post('/providers/:provider/connect') + async setProviderConnected(req: ExternalSecretsRequest.SetProviderConnected) { + const providerName = req.params.provider; + try { + await this.secretsService.saveProviderConnected(providerName, req.body.connected); + } catch (e) { + if (e instanceof ProviderNotFoundError) { + throw new NotFoundError(`Could not find provider "${e.providerName}"`); + } + throw e; + } + return {}; + } + + @Post('/providers/:provider/update') + async updateProvider(req: ExternalSecretsRequest.UpdateProvider, res: Response) { + const providerName = req.params.provider; + try { + const resp = await this.secretsService.updateProvider(providerName); + if (resp) { + res.statusCode = 200; + } else { + res.statusCode = 400; + } + return { updated: resp }; + } catch (e) { + if (e instanceof ProviderNotFoundError) { + throw new NotFoundError(`Could not find provider "${e.providerName}"`); + } + throw e; + } + } + + @Get('/secrets') + getSecretNames() { + return this.secretsService.getAllSecrets(); + } +} diff --git a/packages/cli/src/ExternalSecrets/ExternalSecrets.service.ee.ts b/packages/cli/src/ExternalSecrets/ExternalSecrets.service.ee.ts new file mode 100644 index 0000000000..9952c8a9b8 --- /dev/null +++ b/packages/cli/src/ExternalSecrets/ExternalSecrets.service.ee.ts @@ -0,0 +1,154 @@ +import { CREDENTIAL_BLANKING_VALUE } from '@/constants'; +import type { SecretsProvider } from '@/Interfaces'; +import type { ExternalSecretsRequest } from '@/requests'; +import type { IDataObject } from 'n8n-workflow'; +import { deepCopy } from 'n8n-workflow'; +import Container, { Service } from 'typedi'; +import { ExternalSecretsManager } from './ExternalSecretsManager.ee'; + +export class ProviderNotFoundError extends Error { + constructor(public providerName: string) { + super(undefined); + } +} + +@Service() +export class ExternalSecretsService { + getProvider(providerName: string): ExternalSecretsRequest.GetProviderResponse | null { + const providerAndSettings = + Container.get(ExternalSecretsManager).getProviderWithSettings(providerName); + if (!providerAndSettings) { + throw new ProviderNotFoundError(providerName); + } + const { provider, settings } = providerAndSettings; + return { + displayName: provider.displayName, + name: provider.name, + icon: provider.name, + state: provider.state, + connected: settings.connected, + connectedAt: settings.connectedAt, + properties: provider.properties, + data: this.redact(settings.settings, provider), + }; + } + + async getProviders() { + return Container.get(ExternalSecretsManager) + .getProvidersWithSettings() + .map(({ provider, settings }) => ({ + displayName: provider.displayName, + name: provider.name, + icon: provider.name, + state: provider.state, + connected: !!settings.connected, + connectedAt: settings.connectedAt, + data: this.redact(settings.settings, provider), + })); + } + + // Take data and replace all sensitive values with a sentinel value. + // This will replace password fields and oauth data. + redact(data: IDataObject, provider: SecretsProvider): IDataObject { + const copiedData = deepCopy(data || {}); + + const properties = provider.properties; + + for (const dataKey of Object.keys(copiedData)) { + // The frontend only cares that this value isn't falsy. + if (dataKey === 'oauthTokenData') { + copiedData[dataKey] = CREDENTIAL_BLANKING_VALUE; + continue; + } + const prop = properties.find((v) => v.name === dataKey); + if (!prop) { + continue; + } + + if ( + prop.typeOptions?.password && + (!(copiedData[dataKey] as string).startsWith('=') || prop.noDataExpression) + ) { + copiedData[dataKey] = CREDENTIAL_BLANKING_VALUE; + } + } + + return copiedData; + } + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + private unredactRestoreValues(unmerged: any, replacement: any) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + for (const [key, value] of Object.entries(unmerged)) { + if (value === CREDENTIAL_BLANKING_VALUE) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access + unmerged[key] = replacement[key]; + } else if ( + typeof value === 'object' && + value !== null && + key in replacement && + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + typeof replacement[key] === 'object' && + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + replacement[key] !== null + ) { + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + this.unredactRestoreValues(value, replacement[key]); + } + } + } + + // Take unredacted data (probably from the DB) and merge it with + // redacted data to create an unredacted version. + unredact(redactedData: IDataObject, savedData: IDataObject): IDataObject { + // Replace any blank sentinel values with their saved version + const mergedData = deepCopy(redactedData ?? {}); + this.unredactRestoreValues(mergedData, savedData); + return mergedData; + } + + async saveProviderSettings(providerName: string, data: IDataObject, userId: string) { + const providerAndSettings = + Container.get(ExternalSecretsManager).getProviderWithSettings(providerName); + if (!providerAndSettings) { + throw new ProviderNotFoundError(providerName); + } + const { settings } = providerAndSettings; + const newData = this.unredact(data, settings.settings); + await Container.get(ExternalSecretsManager).setProviderSettings(providerName, newData, userId); + } + + async saveProviderConnected(providerName: string, connected: boolean) { + const providerAndSettings = + Container.get(ExternalSecretsManager).getProviderWithSettings(providerName); + if (!providerAndSettings) { + throw new ProviderNotFoundError(providerName); + } + await Container.get(ExternalSecretsManager).setProviderConnected(providerName, connected); + return this.getProvider(providerName); + } + + getAllSecrets(): Record { + return Container.get(ExternalSecretsManager).getAllSecretNames(); + } + + async testProviderSettings(providerName: string, data: IDataObject) { + const providerAndSettings = + Container.get(ExternalSecretsManager).getProviderWithSettings(providerName); + if (!providerAndSettings) { + throw new ProviderNotFoundError(providerName); + } + const { settings } = providerAndSettings; + const newData = this.unredact(data, settings.settings); + return Container.get(ExternalSecretsManager).testProviderSettings(providerName, newData); + } + + async updateProvider(providerName: string) { + const providerAndSettings = + Container.get(ExternalSecretsManager).getProviderWithSettings(providerName); + if (!providerAndSettings) { + throw new ProviderNotFoundError(providerName); + } + return Container.get(ExternalSecretsManager).updateProvider(providerName); + } +} diff --git a/packages/cli/src/ExternalSecrets/ExternalSecretsManager.ee.ts b/packages/cli/src/ExternalSecrets/ExternalSecretsManager.ee.ts new file mode 100644 index 0000000000..6a0b422377 --- /dev/null +++ b/packages/cli/src/ExternalSecrets/ExternalSecretsManager.ee.ts @@ -0,0 +1,381 @@ +import { SettingsRepository } from '@/databases/repositories'; +import type { + ExternalSecretsSettings, + SecretsProvider, + SecretsProviderSettings, +} from '@/Interfaces'; + +import { UserSettings } from 'n8n-core'; +import Container, { Service } from 'typedi'; + +import { AES, enc } from 'crypto-js'; +import { getLogger } from '@/Logger'; + +import type { IDataObject } from 'n8n-workflow'; +import { + EXTERNAL_SECRETS_INITIAL_BACKOFF, + EXTERNAL_SECRETS_MAX_BACKOFF, + EXTERNAL_SECRETS_UPDATE_INTERVAL, +} from './constants'; +import { License } from '@/License'; +import { InternalHooks } from '@/InternalHooks'; +import { ExternalSecretsProviders } from './ExternalSecretsProviders.ee'; + +const logger = getLogger(); + +@Service() +export class ExternalSecretsManager { + private providers: Record = {}; + + private initializingPromise?: Promise; + + private cachedSettings: ExternalSecretsSettings = {}; + + initialized = false; + + updateInterval: NodeJS.Timer; + + initRetryTimeouts: Record = {}; + + constructor( + private settingsRepo: SettingsRepository, + private license: License, + private secretsProviders: ExternalSecretsProviders, + ) {} + + async init(): Promise { + if (!this.initialized) { + if (!this.initializingPromise) { + this.initializingPromise = new Promise(async (resolve) => { + await this.internalInit(); + this.initialized = true; + resolve(); + this.initializingPromise = undefined; + this.updateInterval = setInterval( + async () => this.updateSecrets(), + EXTERNAL_SECRETS_UPDATE_INTERVAL, + ); + }); + } + return this.initializingPromise; + } + } + + shutdown() { + clearInterval(this.updateInterval); + Object.values(this.providers).forEach((p) => { + // Disregard any errors as we're shutting down anyway + void p.disconnect().catch(() => {}); + }); + Object.values(this.initRetryTimeouts).forEach((v) => clearTimeout(v)); + } + + private async getEncryptionKey(): Promise { + return UserSettings.getEncryptionKey(); + } + + private decryptSecretsSettings(value: string, encryptionKey: string): ExternalSecretsSettings { + const decryptedData = AES.decrypt(value, encryptionKey); + + try { + return JSON.parse(decryptedData.toString(enc.Utf8)) as ExternalSecretsSettings; + } catch (e) { + throw new Error( + 'External Secrets Settings could not be decrypted. The likely reason is that a different "encryptionKey" was used to encrypt the data.', + ); + } + } + + private async getDecryptedSettings( + settingsRepo: SettingsRepository, + ): Promise { + const encryptedSettings = await settingsRepo.getEncryptedSecretsProviderSettings(); + if (encryptedSettings === null) { + return null; + } + const encryptionKey = await this.getEncryptionKey(); + return this.decryptSecretsSettings(encryptedSettings, encryptionKey); + } + + private async internalInit() { + const settings = await this.getDecryptedSettings(this.settingsRepo); + if (!settings) { + return; + } + const providers: Array = ( + await Promise.allSettled( + Object.entries(settings).map(async ([name, providerSettings]) => + this.initProvider(name, providerSettings), + ), + ) + ).map((i) => (i.status === 'rejected' ? null : i.value)); + this.providers = Object.fromEntries( + (providers.filter((p) => p !== null) as SecretsProvider[]).map((s) => [s.name, s]), + ); + this.cachedSettings = settings; + await this.updateSecrets(); + } + + private async initProvider( + name: string, + providerSettings: SecretsProviderSettings, + currentBackoff = EXTERNAL_SECRETS_INITIAL_BACKOFF, + ) { + const providerClass = this.secretsProviders.getProvider(name); + if (!providerClass) { + return null; + } + const provider: SecretsProvider = new providerClass(); + + try { + await provider.init(providerSettings); + } catch (e) { + logger.error( + `Error initializing secrets provider ${provider.displayName} (${provider.name}).`, + ); + this.retryInitWithBackoff(name, currentBackoff); + return provider; + } + + try { + if (providerSettings.connected) { + await provider.connect(); + } + } catch (e) { + try { + await provider.disconnect(); + } catch {} + logger.error( + `Error initializing secrets provider ${provider.displayName} (${provider.name}).`, + ); + this.retryInitWithBackoff(name, currentBackoff); + return provider; + } + + return provider; + } + + private retryInitWithBackoff(name: string, currentBackoff: number) { + if (name in this.initRetryTimeouts) { + clearTimeout(this.initRetryTimeouts[name]); + delete this.initRetryTimeouts[name]; + } + this.initRetryTimeouts[name] = setTimeout(() => { + delete this.initRetryTimeouts[name]; + if (this.providers[name] && this.providers[name].state !== 'error') { + return; + } + void this.reloadProvider(name, Math.min(currentBackoff * 2, EXTERNAL_SECRETS_MAX_BACKOFF)); + }, currentBackoff); + } + + async updateSecrets() { + if (!this.license.isExternalSecretsEnabled()) { + return; + } + await Promise.allSettled( + Object.entries(this.providers).map(async ([k, p]) => { + try { + if (this.cachedSettings[k].connected && p.state === 'connected') { + await p.update(); + } + } catch { + logger.error(`Error updating secrets provider ${p.displayName} (${p.name}).`); + } + }), + ); + } + + getProvider(provider: string): SecretsProvider | undefined { + return this.providers[provider]; + } + + hasProvider(provider: string): boolean { + return provider in this.providers; + } + + getProviderNames(): string[] | undefined { + return Object.keys(this.providers); + } + + getSecret(provider: string, name: string): IDataObject | undefined { + return this.getProvider(provider)?.getSecret(name); + } + + hasSecret(provider: string, name: string): boolean { + return this.getProvider(provider)?.hasSecret(name) ?? false; + } + + getSecretNames(provider: string): string[] | undefined { + return this.getProvider(provider)?.getSecretNames(); + } + + getAllSecretNames(): Record { + return Object.fromEntries( + Object.keys(this.providers).map((provider) => [ + provider, + this.getSecretNames(provider) ?? [], + ]), + ); + } + + getProvidersWithSettings(): Array<{ + provider: SecretsProvider; + settings: SecretsProviderSettings; + }> { + return Object.entries(this.secretsProviders.getAllProviders()).map(([k, c]) => ({ + provider: this.getProvider(k) ?? new c(), + settings: this.cachedSettings[k] ?? {}, + })); + } + + getProviderWithSettings(provider: string): + | { + provider: SecretsProvider; + settings: SecretsProviderSettings; + } + | undefined { + const providerConstructor = this.secretsProviders.getProvider(provider); + if (!providerConstructor) { + return undefined; + } + return { + provider: this.getProvider(provider) ?? new providerConstructor(), + settings: this.cachedSettings[provider] ?? {}, + }; + } + + async reloadProvider(provider: string, backoff = EXTERNAL_SECRETS_INITIAL_BACKOFF) { + if (provider in this.providers) { + await this.providers[provider].disconnect(); + delete this.providers[provider]; + } + const newProvider = await this.initProvider(provider, this.cachedSettings[provider], backoff); + if (newProvider) { + this.providers[provider] = newProvider; + } + } + + async setProviderSettings(provider: string, data: IDataObject, userId?: string) { + let isNewProvider = false; + let settings = await this.getDecryptedSettings(this.settingsRepo); + if (!settings) { + settings = {}; + } + if (!(provider in settings)) { + isNewProvider = true; + } + settings[provider] = { + connected: settings[provider]?.connected ?? false, + connectedAt: settings[provider]?.connectedAt ?? new Date(), + settings: data, + }; + + await this.saveAndSetSettings(settings, this.settingsRepo); + this.cachedSettings = settings; + await this.reloadProvider(provider); + + void this.trackProviderSave(provider, isNewProvider, userId); + } + + async setProviderConnected(provider: string, connected: boolean) { + let settings = await this.getDecryptedSettings(this.settingsRepo); + if (!settings) { + settings = {}; + } + settings[provider] = { + connected, + connectedAt: connected ? new Date() : settings[provider]?.connectedAt ?? null, + settings: settings[provider]?.settings ?? {}, + }; + + await this.saveAndSetSettings(settings, this.settingsRepo); + this.cachedSettings = settings; + await this.reloadProvider(provider); + await this.updateSecrets(); + } + + private async trackProviderSave(vaultType: string, isNew: boolean, userId?: string) { + let testResult: [boolean] | [boolean, string] | undefined; + try { + testResult = await this.getProvider(vaultType)?.test(); + } catch {} + void Container.get(InternalHooks).onExternalSecretsProviderSettingsSaved({ + user_id: userId, + vault_type: vaultType, + is_new: isNew, + is_valid: testResult?.[0] ?? false, + error_message: testResult?.[1], + }); + } + + encryptSecretsSettings(settings: ExternalSecretsSettings, encryptionKey: string): string { + return AES.encrypt(JSON.stringify(settings), encryptionKey).toString(); + } + + async saveAndSetSettings(settings: ExternalSecretsSettings, settingsRepo: SettingsRepository) { + const encryptionKey = await this.getEncryptionKey(); + const encryptedSettings = this.encryptSecretsSettings(settings, encryptionKey); + await settingsRepo.saveEncryptedSecretsProviderSettings(encryptedSettings); + } + + async testProviderSettings( + provider: string, + data: IDataObject, + ): Promise<{ + success: boolean; + testState: 'connected' | 'tested' | 'error'; + error?: string; + }> { + let testProvider: SecretsProvider | null = null; + try { + testProvider = await this.initProvider(provider, { + connected: true, + connectedAt: new Date(), + settings: data, + }); + if (!testProvider) { + return { + success: false, + testState: 'error', + }; + } + const [success, error] = await testProvider.test(); + let testState: 'connected' | 'tested' | 'error' = 'error'; + if (success && this.cachedSettings[provider]?.connected) { + testState = 'connected'; + } else if (success) { + testState = 'tested'; + } + return { + success, + testState, + error, + }; + } catch { + return { + success: false, + testState: 'error', + }; + } finally { + if (testProvider) { + await testProvider.disconnect(); + } + } + } + + async updateProvider(provider: string): Promise { + if (!this.license.isExternalSecretsEnabled()) { + return false; + } + if (!this.providers[provider] || this.providers[provider].state !== 'connected') { + return false; + } + try { + await this.providers[provider].update(); + return true; + } catch { + return false; + } + } +} diff --git a/packages/cli/src/ExternalSecrets/ExternalSecretsProviders.ee.ts b/packages/cli/src/ExternalSecrets/ExternalSecretsProviders.ee.ts new file mode 100644 index 0000000000..a0e9353699 --- /dev/null +++ b/packages/cli/src/ExternalSecrets/ExternalSecretsProviders.ee.ts @@ -0,0 +1,24 @@ +import type { SecretsProvider } from '@/Interfaces'; +import { Service } from 'typedi'; +import { InfisicalProvider } from './providers/infisical'; +import { VaultProvider } from './providers/vault'; + +@Service() +export class ExternalSecretsProviders { + providers: Record = { + infisical: InfisicalProvider, + vault: VaultProvider, + }; + + getProvider(name: string): { new (): SecretsProvider } | null { + return this.providers[name] ?? null; + } + + hasProvider(name: string) { + return name in this.providers; + } + + getAllProviders() { + return this.providers; + } +} diff --git a/packages/cli/src/ExternalSecrets/constants.ts b/packages/cli/src/ExternalSecrets/constants.ts new file mode 100644 index 0000000000..534b4ceb72 --- /dev/null +++ b/packages/cli/src/ExternalSecrets/constants.ts @@ -0,0 +1,6 @@ +export const EXTERNAL_SECRETS_DB_KEY = 'feature.externalSecrets'; +export const EXTERNAL_SECRETS_UPDATE_INTERVAL = 5 * 60 * 1000; +export const EXTERNAL_SECRETS_INITIAL_BACKOFF = 10 * 1000; +export const EXTERNAL_SECRETS_MAX_BACKOFF = 5 * 60 * 1000; + +export const EXTERNAL_SECRETS_NAME_REGEX = /^[a-zA-Z0-9_]+$/; diff --git a/packages/cli/src/ExternalSecrets/externalSecretsHelper.ee.ts b/packages/cli/src/ExternalSecrets/externalSecretsHelper.ee.ts new file mode 100644 index 0000000000..54885664ff --- /dev/null +++ b/packages/cli/src/ExternalSecrets/externalSecretsHelper.ee.ts @@ -0,0 +1,7 @@ +import { License } from '@/License'; +import Container from 'typedi'; + +export function isExternalSecretsEnabled() { + const license = Container.get(License); + return license.isExternalSecretsEnabled(); +} diff --git a/packages/cli/src/ExternalSecrets/providers/infisical.ts b/packages/cli/src/ExternalSecrets/providers/infisical.ts new file mode 100644 index 0000000000..39a0eb92d4 --- /dev/null +++ b/packages/cli/src/ExternalSecrets/providers/infisical.ts @@ -0,0 +1,153 @@ +import type { SecretsProvider, SecretsProviderSettings, SecretsProviderState } from '@/Interfaces'; +import InfisicalClient from 'infisical-node'; +import { populateClientWorkspaceConfigsHelper } from 'infisical-node/lib/helpers/key'; +import { getServiceTokenData } from 'infisical-node/lib/api/serviceTokenData'; +import type { IDataObject, INodeProperties } from 'n8n-workflow'; +import { EXTERNAL_SECRETS_NAME_REGEX } from '../constants'; + +export interface InfisicalSettings { + token: string; + siteURL: string; + cacheTTL: number; + debug: boolean; +} + +interface InfisicalSecret { + secretName: string; + secretValue?: string; +} + +interface InfisicalServiceToken { + environment?: string; + scopes?: Array<{ environment: string; path: string }>; +} + +export class InfisicalProvider implements SecretsProvider { + properties: INodeProperties[] = [ + { + displayName: + 'Need help filling out these fields? Open docs', + name: 'notice', + type: 'notice', + default: '', + }, + { + displayName: 'Service Token', + name: 'token', + type: 'string', + hint: 'The Infisical Service Token with read access', + default: '', + required: true, + placeholder: 'e.g. st.64ae963e1874ea.374226a166439dce.39557e4a1b7bdd82', + noDataExpression: true, + typeOptions: { password: true }, + }, + { + displayName: 'Site URL', + name: 'siteURL', + type: 'string', + hint: "The absolute URL of the Infisical instance. Change it only if you're self-hosting Infisical.", + required: true, + noDataExpression: true, + placeholder: 'https://app.infisical.com', + default: 'https://app.infisical.com', + }, + ]; + + displayName = 'Infisical'; + + name = 'infisical'; + + state: SecretsProviderState = 'initializing'; + + private cachedSecrets: Record = {}; + + private client: InfisicalClient; + + private settings: InfisicalSettings; + + private environment: string; + + async init(settings: SecretsProviderSettings): Promise { + this.settings = settings.settings as unknown as InfisicalSettings; + } + + async update(): Promise { + if (!this.client) { + throw new Error('Updated attempted on Infisical when initialization failed'); + } + if (!(await this.test())[0]) { + throw new Error('Infisical provider test failed during update'); + } + const secrets = (await this.client.getAllSecrets({ + environment: this.environment, + path: '/', + attachToProcessEnv: false, + includeImports: true, + })) as InfisicalSecret[]; + const newCache = Object.fromEntries( + secrets.map((s) => [s.secretName, s.secretValue]), + ) as Record; + if (Object.keys(newCache).length === 1 && '' in newCache) { + this.cachedSecrets = {}; + } else { + this.cachedSecrets = newCache; + } + } + + async connect(): Promise { + this.client = new InfisicalClient(this.settings); + if ((await this.test())[0]) { + try { + this.environment = await this.getEnvironment(); + this.state = 'connected'; + } catch { + this.state = 'error'; + } + } else { + this.state = 'error'; + } + } + + async getEnvironment(): Promise { + const serviceTokenData = (await getServiceTokenData( + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + this.client.clientConfig, + )) as InfisicalServiceToken; + if (serviceTokenData.environment) { + return serviceTokenData.environment; + } + if (serviceTokenData.scopes) { + return serviceTokenData.scopes[0].environment; + } + throw new Error("Couldn't find environment for Infisical"); + } + + async test(): Promise<[boolean] | [boolean, string]> { + if (!this.client) { + return [false, 'Client not initialized']; + } + try { + await populateClientWorkspaceConfigsHelper(this.client.clientConfig); + return [true]; + } catch (e) { + return [false]; + } + } + + async disconnect(): Promise { + // + } + + getSecret(name: string): IDataObject { + return this.cachedSecrets[name] as unknown as IDataObject; + } + + getSecretNames(): string[] { + return Object.keys(this.cachedSecrets).filter((k) => EXTERNAL_SECRETS_NAME_REGEX.test(k)); + } + + hasSecret(name: string): boolean { + return name in this.cachedSecrets; + } +} diff --git a/packages/cli/src/ExternalSecrets/providers/vault.ts b/packages/cli/src/ExternalSecrets/providers/vault.ts new file mode 100644 index 0000000000..65ef4a9acf --- /dev/null +++ b/packages/cli/src/ExternalSecrets/providers/vault.ts @@ -0,0 +1,559 @@ +import type { SecretsProviderSettings, SecretsProviderState } from '@/Interfaces'; +import { SecretsProvider } from '@/Interfaces'; +import type { IDataObject, INodeProperties } from 'n8n-workflow'; +import type { AxiosInstance, AxiosResponse } from 'axios'; +import axios from 'axios'; +import { getLogger } from '@/Logger'; +import { EXTERNAL_SECRETS_NAME_REGEX } from '../constants'; + +const logger = getLogger(); + +type VaultAuthMethod = 'token' | 'usernameAndPassword' | 'appRole'; + +interface VaultSettings { + url: string; + namespace?: string; + authMethod: VaultAuthMethod; + + // Token + token: string; + renewToken: boolean; + + // Username and Password + username: string; + password: string; + + // AppRole + roleId: string; + secretId: string; +} + +interface VaultResponse { + data: T; +} + +interface VaultTokenInfo { + accessor: string; + creation_time: number; + creation_ttl: number; + display_name: string; + entity_id: string; + expire_time: string | null; + explicit_max_ttl: number; + id: string; + issue_time: string; + meta: Record; + num_uses: number; + orphan: boolean; + path: string; + policies: string[]; + ttl: number; + renewable: boolean; + type: 'kv' | string; +} + +interface VaultMount { + accessor: string; + config: Record; + description: string; + external_entropy_access: boolean; + local: boolean; + options: Record; + plugin_version: string; + running_plugin_version: string; + running_sha256: string; + seal_wrap: number; + type: string; + uuid: string; +} + +interface VaultMountsResp { + [path: string]: VaultMount; +} + +interface VaultUserPassLoginResp { + auth: { + client_token: string; + }; +} + +type VaultAppRoleResp = VaultUserPassLoginResp; + +interface VaultSecretList { + keys: string[]; +} + +export class VaultProvider extends SecretsProvider { + properties: INodeProperties[] = [ + { + displayName: + 'Need help filling out these fields? Open docs', + name: 'notice', + type: 'notice', + default: '', + }, + { + displayName: 'Vault URL', + name: 'url', + type: 'string', + required: true, + noDataExpression: true, + placeholder: 'e.g. https://example.com/v1/', + default: '', + }, + { + displayName: 'Vault Namespace (optional)', + name: 'namespace', + type: 'string', + hint: 'Leave blank if not using namespaces', + required: false, + noDataExpression: true, + placeholder: 'e.g. admin', + default: '', + }, + { + displayName: 'Authentication Method', + name: 'authMethod', + type: 'options', + required: true, + noDataExpression: true, + options: [ + { name: 'Token', value: 'token' }, + { name: 'Username and Password', value: 'usernameAndPassword' }, + { name: 'AppRole', value: 'appRole' }, + ], + default: 'token', + }, + + // Token Auth + { + displayName: 'Token', + name: 'token', + type: 'string', + default: '', + required: true, + noDataExpression: true, + placeholder: 'e.g. hvs.2OCsZxZA6Z9lChbt0janOOZI', + typeOptions: { password: true }, + displayOptions: { + show: { + authMethod: ['token'], + }, + }, + }, + // { + // displayName: 'Renew Token', + // name: 'renewToken', + // description: + // 'Try to renew Vault token. This will update the settings on this provider when doing so.', + // type: 'boolean', + // noDataExpression: true, + // default: true, + // displayOptions: { + // show: { + // authMethod: ['token'], + // }, + // }, + // }, + + // Username and Password + { + displayName: 'Username', + name: 'username', + type: 'string', + default: '', + required: true, + noDataExpression: true, + placeholder: 'Username', + displayOptions: { + show: { + authMethod: ['usernameAndPassword'], + }, + }, + }, + { + displayName: 'Password', + name: 'password', + type: 'string', + default: '', + required: true, + noDataExpression: true, + placeholder: '***************', + typeOptions: { password: true }, + displayOptions: { + show: { + authMethod: ['usernameAndPassword'], + }, + }, + }, + + // Username and Password + { + displayName: 'Role ID', + name: 'roleId', + type: 'string', + default: '', + required: true, + noDataExpression: true, + placeholder: '59d6d1ca-47bb-4e7e-a40b-8be3bc5a0ba8', + displayOptions: { + show: { + authMethod: ['appRole'], + }, + }, + }, + { + displayName: 'Secret ID', + name: 'secretId', + type: 'string', + default: '', + required: true, + noDataExpression: true, + placeholder: '84896a0c-1347-aa90-a4f6-aca8b7558780', + typeOptions: { password: true }, + displayOptions: { + show: { + authMethod: ['appRole'], + }, + }, + }, + ]; + + displayName = 'HashiCorp Vault'; + + name = 'vault'; + + state: SecretsProviderState = 'initializing'; + + private cachedSecrets: Record = {}; + + private settings: VaultSettings; + + #currentToken: string | null = null; + + #tokenInfo: VaultTokenInfo | null = null; + + #http: AxiosInstance; + + private refreshTimeout: NodeJS.Timer | null; + + private refreshAbort = new AbortController(); + + async init(settings: SecretsProviderSettings): Promise { + this.settings = settings.settings as unknown as VaultSettings; + + const baseURL = new URL(this.settings.url); + + this.#http = axios.create({ baseURL: baseURL.toString() }); + if (this.settings.namespace) { + this.#http.interceptors.request.use((config) => { + return { + ...config, + // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unsafe-assignment + headers: { ...config.headers, 'X-Vault-Namespace': this.settings.namespace }, + }; + }); + } + this.#http.interceptors.request.use((config) => { + if (!this.#currentToken) { + return config; + } + // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unsafe-assignment + return { ...config, headers: { ...config.headers, 'X-Vault-Token': this.#currentToken } }; + }); + } + + async connect(): Promise { + if (this.settings.authMethod === 'token') { + this.#currentToken = this.settings.token; + } else if (this.settings.authMethod === 'usernameAndPassword') { + try { + this.#currentToken = await this.authUsernameAndPassword( + this.settings.username, + this.settings.password, + ); + } catch { + this.state = 'error'; + logger.error('Failed to connect to Vault using Username and Password credentials.'); + return; + } + } else if (this.settings.authMethod === 'appRole') { + try { + this.#currentToken = await this.authAppRole(this.settings.roleId, this.settings.secretId); + } catch { + this.state = 'error'; + logger.error('Failed to connect to Vault using AppRole credentials.'); + return; + } + } + try { + if (!(await this.test())[0]) { + this.state = 'error'; + } else { + this.state = 'connected'; + + [this.#tokenInfo] = await this.getTokenInfo(); + this.setupTokenRefresh(); + } + } catch (e) { + this.state = 'error'; + logger.error('Failed credentials test on Vault connect.'); + } + + try { + await this.update(); + } catch { + logger.warn('Failed to update Vault secrets'); + } + } + + async disconnect(): Promise { + if (this.refreshTimeout !== null) { + clearTimeout(this.refreshTimeout); + } + this.refreshAbort.abort(); + } + + private setupTokenRefresh() { + if (!this.#tokenInfo) { + return; + } + // Token never expires + if (this.#tokenInfo.expire_time === null) { + return; + } + // Token can't be renewed + if (!this.#tokenInfo.renewable) { + return; + } + + const expireDate = new Date(this.#tokenInfo.expire_time); + setTimeout(this.tokenRefresh, (expireDate.valueOf() - Date.now()) / 2); + } + + private tokenRefresh = async () => { + if (this.refreshAbort.signal.aborted) { + return; + } + try { + // We don't actually care about the result of this since it doesn't + // return an expire_time + await this.#http.post('auth/token/renew-self'); + + [this.#tokenInfo] = await this.getTokenInfo(); + + if (!this.#tokenInfo) { + logger.error('Failed to fetch token info during renewal. Cancelling all future renewals.'); + return; + } + + if (this.refreshAbort.signal.aborted) { + return; + } + + this.setupTokenRefresh(); + } catch { + logger.error('Failed to renew Vault token. Attempting to reconnect.'); + void this.connect(); + } + }; + + private async authUsernameAndPassword( + username: string, + password: string, + ): Promise { + try { + const resp = await this.#http.request({ + method: 'POST', + url: `auth/userpass/login/${username}`, + responseType: 'json', + data: { password }, + }); + + return resp.data.auth.client_token; + } catch { + return null; + } + } + + private async authAppRole(roleId: string, secretId: string): Promise { + try { + const resp = await this.#http.request({ + method: 'POST', + url: 'auth/approle/login', + responseType: 'json', + data: { role_id: roleId, secret_id: secretId }, + }); + + return resp.data.auth.client_token; + } catch (e) { + return null; + } + } + + private async getTokenInfo(): Promise<[VaultTokenInfo | null, AxiosResponse]> { + const resp = await this.#http.request>({ + method: 'GET', + url: 'auth/token/lookup-self', + responseType: 'json', + validateStatus: () => true, + }); + + if (resp.status !== 200 || !resp.data.data) { + return [null, resp]; + } + return [resp.data.data, resp]; + } + + private async getKVSecrets( + mountPath: string, + kvVersion: string, + path: string, + ): Promise<[string, IDataObject] | null> { + let listPath = mountPath; + if (kvVersion === '2') { + listPath += 'metadata/'; + } + listPath += path; + let listResp: AxiosResponse>; + try { + listResp = await this.#http.request>({ + url: listPath, + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any + method: 'LIST' as any, + }); + } catch { + return null; + } + const data = Object.fromEntries( + ( + await Promise.allSettled( + listResp.data.data.keys.map(async (key): Promise<[string, IDataObject] | null> => { + if (key.endsWith('/')) { + return this.getKVSecrets(mountPath, kvVersion, path + key); + } + let secretPath = mountPath; + if (kvVersion === '2') { + secretPath += 'data/'; + } + secretPath += path + key; + try { + const secretResp = await this.#http.get>(secretPath); + return [ + key, + kvVersion === '2' + ? (secretResp.data.data.data as IDataObject) + : secretResp.data.data, + ]; + } catch { + return null; + } + }), + ) + ) + .map((i) => (i.status === 'rejected' ? null : i.value)) + .filter((v) => v !== null) as Array<[string, IDataObject]>, + ); + const name = path.substring(0, path.length - 1); + return [name, data]; + } + + async update(): Promise { + const mounts = await this.#http.get>('sys/mounts'); + + const kvs = Object.entries(mounts.data.data).filter(([, v]) => v.type === 'kv'); + + const secrets = Object.fromEntries( + ( + await Promise.all( + kvs.map(async ([basePath, data]): Promise<[string, IDataObject] | null> => { + const value = await this.getKVSecrets(basePath, data.options.version as string, ''); + if (value === null) { + return null; + } + return [basePath.substring(0, basePath.length - 1), value[1]]; + }), + ) + ).filter((v) => v !== null) as Array<[string, IDataObject]>, + ); + this.cachedSecrets = secrets; + } + + async test(): Promise<[boolean] | [boolean, string]> { + try { + const [token, tokenResp] = await this.getTokenInfo(); + + if (token === null) { + if (tokenResp.status === 404) { + return [false, 'Could not find auth path. Try adding /v1/ to the end of your base URL.']; + } + return [false, 'Invalid credentials']; + } + + const resp = await this.#http.request>({ + method: 'GET', + url: 'sys/mounts', + responseType: 'json', + validateStatus: () => true, + }); + + if (resp.status === 403) { + return [ + false, + "Couldn't list mounts. Please give these credentials 'read' access to sys/mounts.", + ]; + } else if (resp.status !== 200) { + return [ + false, + "Couldn't list mounts but wasn't a permissions issue. Please consult your Vault admin.", + ]; + } + + return [true]; + } catch (e) { + if (axios.isAxiosError(e)) { + if (e.code === 'ECONNREFUSED') { + return [ + false, + 'Connection refused. Please check the host and port of the server are correct.', + ]; + } + } + + return [false]; + } + } + + getSecret(name: string): IDataObject { + return this.cachedSecrets[name]; + } + + hasSecret(name: string): boolean { + return name in this.cachedSecrets; + } + + getSecretNames(): string[] { + const getKeys = ([k, v]: [string, IDataObject]): string[] => { + if (!EXTERNAL_SECRETS_NAME_REGEX.test(k)) { + return []; + } + if (typeof v === 'object') { + const keys: string[] = []; + for (const key of Object.keys(v)) { + if (!EXTERNAL_SECRETS_NAME_REGEX.test(key)) { + continue; + } + const value = v[key]; + if (typeof value === 'object' && value !== null) { + keys.push(...getKeys([key, value as IDataObject]).map((ok) => `${k}.${ok}`)); + } else { + keys.push(`${k}.${key}`); + } + } + return keys; + } + return [k]; + }; + return Object.entries(this.cachedSecrets).flatMap(getKeys); + } +} diff --git a/packages/cli/src/Interfaces.ts b/packages/cli/src/Interfaces.ts index 4de5209a0f..83c2664332 100644 --- a/packages/cli/src/Interfaces.ts +++ b/packages/cli/src/Interfaces.ts @@ -21,6 +21,7 @@ import type { ExecutionStatus, IExecutionsSummary, FeatureFlags, + INodeProperties, IUserSettings, IHttpRequestMethods, } from 'n8n-workflow'; @@ -460,6 +461,13 @@ export interface IInternalHooksClass { onApiKeyCreated(apiKeyDeletedData: { user: User; public_api: boolean }): Promise; onApiKeyDeleted(apiKeyDeletedData: { user: User; public_api: boolean }): Promise; onVariableCreated(createData: { variable_type: string }): Promise; + onExternalSecretsProviderSettingsSaved(saveData: { + user_id?: string; + vault_type: string; + is_valid: boolean; + is_new: boolean; + error_message?: string; + }): Promise; } export interface IVersionNotificationSettings { @@ -779,4 +787,35 @@ export interface N8nApp { export type UserSettings = Pick; +export interface SecretsProviderSettings { + connected: boolean; + connectedAt: Date | null; + settings: T; +} + +export interface ExternalSecretsSettings { + [key: string]: SecretsProviderSettings; +} + +export type SecretsProviderState = 'initializing' | 'connected' | 'error'; + +export abstract class SecretsProvider { + displayName: string; + + name: string; + + properties: INodeProperties[]; + + state: SecretsProviderState; + + abstract init(settings: SecretsProviderSettings): Promise; + abstract connect(): Promise; + abstract disconnect(): Promise; + abstract update(): Promise; + abstract test(): Promise<[boolean] | [boolean, string]>; + abstract getSecret(name: string): IDataObject | undefined; + abstract hasSecret(name: string): boolean; + abstract getSecretNames(): string[]; +} + export type N8nInstanceType = 'main' | 'webhook' | 'worker'; diff --git a/packages/cli/src/InternalHooks.ts b/packages/cli/src/InternalHooks.ts index ebd3bc2570..a099d6fd76 100644 --- a/packages/cli/src/InternalHooks.ts +++ b/packages/cli/src/InternalHooks.ts @@ -1086,4 +1086,14 @@ export class InternalHooks implements IInternalHooksClass { }): Promise { return this.telemetry.track('User finished push via UI', data); } + + async onExternalSecretsProviderSettingsSaved(saveData: { + user_id?: string | undefined; + vault_type: string; + is_valid: boolean; + is_new: boolean; + error_message?: string | undefined; + }): Promise { + return this.telemetry.track('User updated external secrets settings', saveData); + } } diff --git a/packages/cli/src/License.ts b/packages/cli/src/License.ts index 267419da9f..b296c3a333 100644 --- a/packages/cli/src/License.ts +++ b/packages/cli/src/License.ts @@ -140,6 +140,10 @@ export class License { return this.isFeatureEnabled(LICENSE_FEATURES.SOURCE_CONTROL); } + isExternalSecretsEnabled() { + return this.isFeatureEnabled(LICENSE_FEATURES.EXTERNAL_SECRETS); + } + isWorkflowHistoryLicensed() { return this.isFeatureEnabled(LICENSE_FEATURES.WORKFLOW_HISTORY); } diff --git a/packages/cli/src/SecretsHelpers.ts b/packages/cli/src/SecretsHelpers.ts new file mode 100644 index 0000000000..d90a0e84c8 --- /dev/null +++ b/packages/cli/src/SecretsHelpers.ts @@ -0,0 +1,41 @@ +import type { IDataObject, SecretsHelpersBase } from 'n8n-workflow'; +import { Service } from 'typedi'; +import { ExternalSecretsManager } from './ExternalSecrets/ExternalSecretsManager.ee'; + +@Service() +export class SecretsHelper implements SecretsHelpersBase { + constructor(private service: ExternalSecretsManager) {} + + async update() { + if (!this.service.initialized) { + await this.service.init(); + } + await this.service.updateSecrets(); + } + + async waitForInit() { + if (!this.service.initialized) { + await this.service.init(); + } + } + + getSecret(provider: string, name: string): IDataObject | undefined { + return this.service.getSecret(provider, name); + } + + hasSecret(provider: string, name: string): boolean { + return this.service.hasSecret(provider, name); + } + + hasProvider(provider: string): boolean { + return this.service.hasProvider(provider); + } + + listProviders(): string[] { + return this.service.getProviderNames() ?? []; + } + + listSecrets(provider: string): string[] { + return this.service.getSecretNames(provider) ?? []; + } +} diff --git a/packages/cli/src/Server.ts b/packages/cli/src/Server.ts index 372071ac19..ebc16f9a61 100644 --- a/packages/cli/src/Server.ts +++ b/packages/cli/src/Server.ts @@ -99,6 +99,7 @@ import { WorkflowStatisticsController, } from '@/controllers'; +import { ExternalSecretsController } from '@/ExternalSecrets/ExternalSecrets.controller.ee'; import { executionsController } from '@/executions/executions.controller'; import { isApiEnabled, loadPublicApiVersions } from '@/PublicApi'; import { @@ -163,6 +164,7 @@ import { isLdapCurrentAuthenticationMethod, isSamlCurrentAuthenticationMethod, } from './sso/ssoHelpers'; +import { isExternalSecretsEnabled } from './ExternalSecrets/externalSecretsHelper.ee'; import { isSourceControlLicensed } from '@/environments/sourceControl/sourceControlHelper.ee'; import { SourceControlService } from '@/environments/sourceControl/sourceControl.service.ee'; import { SourceControlController } from '@/environments/sourceControl/sourceControl.controller.ee'; @@ -314,6 +316,7 @@ export class Server extends AbstractServer { variables: false, sourceControl: false, auditLogs: false, + externalSecrets: false, showNonProdBanner: false, debugInEditor: false, }, @@ -451,6 +454,7 @@ export class Server extends AbstractServer { advancedExecutionFilters: isAdvancedExecutionFiltersEnabled(), variables: isVariablesEnabled(), sourceControl: isSourceControlLicensed(), + externalSecrets: isExternalSecretsEnabled(), showNonProdBanner: Container.get(License).isFeatureEnabled( LICENSE_FEATURES.SHOW_NON_PROD_BANNER, ), @@ -526,6 +530,7 @@ export class Server extends AbstractServer { Container.get(SamlController), Container.get(SourceControlController), Container.get(WorkflowStatisticsController), + Container.get(ExternalSecretsController), ]; if (isLdapEnabled()) { @@ -929,10 +934,13 @@ export class Server extends AbstractServer { throw new ResponseHelper.InternalServerError(error.message); } + const additionalData = await WorkflowExecuteAdditionalData.getBase(req.user.id); + const mode: WorkflowExecuteMode = 'internal'; const timezone = config.getEnv('generic.timezone'); const credentialsHelper = new CredentialsHelper(encryptionKey); const decryptedDataOriginal = await credentialsHelper.getDecrypted( + additionalData, credential as INodeCredentialsDetails, credential.type, mode, @@ -941,6 +949,7 @@ export class Server extends AbstractServer { ); const oauthCredentials = credentialsHelper.applyDefaultsAndOverwrites( + additionalData, decryptedDataOriginal, credential.type, mode, @@ -1075,10 +1084,13 @@ export class Server extends AbstractServer { throw new ResponseHelper.InternalServerError(error.message); } + const additionalData = await WorkflowExecuteAdditionalData.getBase(req.user.id); + const mode: WorkflowExecuteMode = 'internal'; const timezone = config.getEnv('generic.timezone'); const credentialsHelper = new CredentialsHelper(encryptionKey); const decryptedDataOriginal = await credentialsHelper.getDecrypted( + additionalData, credential as INodeCredentialsDetails, credential.type, mode, @@ -1086,6 +1098,7 @@ export class Server extends AbstractServer { true, ); const oauthCredentials = credentialsHelper.applyDefaultsAndOverwrites( + additionalData, decryptedDataOriginal, credential.type, mode, diff --git a/packages/cli/src/WorkflowExecuteAdditionalData.ts b/packages/cli/src/WorkflowExecuteAdditionalData.ts index 4c8dacf76b..5760cce3d1 100644 --- a/packages/cli/src/WorkflowExecuteAdditionalData.ts +++ b/packages/cli/src/WorkflowExecuteAdditionalData.ts @@ -65,6 +65,7 @@ import { InternalHooks } from '@/InternalHooks'; import type { ExecutionMetadata } from '@db/entities/ExecutionMetadata'; import { ExecutionRepository } from '@db/repositories'; import { EventsService } from '@/services/events.service'; +import { SecretsHelper } from './SecretsHelpers'; import { OwnershipService } from './services/ownership.service'; const ERROR_TRIGGER_TYPE = config.getEnv('nodes.errorTriggerType'); @@ -1167,6 +1168,7 @@ export async function getBase( userId, setExecutionStatus, variables, + secretsHelpers: Container.get(SecretsHelper), }; } diff --git a/packages/cli/src/commands/BaseCommand.ts b/packages/cli/src/commands/BaseCommand.ts index abf7257eda..78be7cc23f 100644 --- a/packages/cli/src/commands/BaseCommand.ts +++ b/packages/cli/src/commands/BaseCommand.ts @@ -20,6 +20,7 @@ import type { IExternalHooksClass } from '@/Interfaces'; import { InternalHooks } from '@/InternalHooks'; import { PostHogClient } from '@/posthog'; import { License } from '@/License'; +import { ExternalSecretsManager } from '@/ExternalSecrets/ExternalSecretsManager.ee'; export abstract class BaseCommand extends Command { protected logger = LoggerProxy.init(getLogger()); @@ -134,6 +135,11 @@ export abstract class BaseCommand extends Command { } } + async initExternalSecrets() { + const secretsManager = Container.get(ExternalSecretsManager); + await secretsManager.init(); + } + async finally(error: Error | undefined) { if (inTest || this.id === 'start') return; if (Db.connectionState.connected) { diff --git a/packages/cli/src/commands/start.ts b/packages/cli/src/commands/start.ts index 84afe4770c..a21a93e21f 100644 --- a/packages/cli/src/commands/start.ts +++ b/packages/cli/src/commands/start.ts @@ -195,6 +195,7 @@ export class Start extends BaseCommand { await this.initLicense(); await this.initBinaryManager(); await this.initExternalHooks(); + await this.initExternalSecrets(); if (!config.getEnv('endpoints.disableUi')) { await this.generateStaticAssets(); diff --git a/packages/cli/src/commands/webhook.ts b/packages/cli/src/commands/webhook.ts index c627d0d328..7d5bf46302 100644 --- a/packages/cli/src/commands/webhook.ts +++ b/packages/cli/src/commands/webhook.ts @@ -80,6 +80,7 @@ export class Webhook extends BaseCommand { await this.initLicense(); await this.initBinaryManager(); await this.initExternalHooks(); + await this.initExternalSecrets(); } async run() { diff --git a/packages/cli/src/commands/worker.ts b/packages/cli/src/commands/worker.ts index 5702dc2d35..dfaf0e34c0 100644 --- a/packages/cli/src/commands/worker.ts +++ b/packages/cli/src/commands/worker.ts @@ -239,6 +239,7 @@ export class Worker extends BaseCommand { await this.initLicense(); await this.initBinaryManager(); await this.initExternalHooks(); + await this.initExternalSecrets(); } async run() { diff --git a/packages/cli/src/constants.ts b/packages/cli/src/constants.ts index 88808c0491..8d9bbb9e14 100644 --- a/packages/cli/src/constants.ts +++ b/packages/cli/src/constants.ts @@ -77,6 +77,7 @@ export const LICENSE_FEATURES = { VARIABLES: 'feat:variables', SOURCE_CONTROL: 'feat:sourceControl', API_DISABLED: 'feat:apiDisabled', + EXTERNAL_SECRETS: 'feat:externalSecrets', SHOW_NON_PROD_BANNER: 'feat:showNonProdBanner', WORKFLOW_HISTORY: 'feat:workflowHistory', DEBUG_IN_EDITOR: 'feat:debugInEditor', diff --git a/packages/cli/src/controllers/e2e.controller.ts b/packages/cli/src/controllers/e2e.controller.ts index d58e21f4f4..57ec0316d4 100644 --- a/packages/cli/src/controllers/e2e.controller.ts +++ b/packages/cli/src/controllers/e2e.controller.ts @@ -64,6 +64,7 @@ export class E2EController { [LICENSE_FEATURES.SOURCE_CONTROL]: false, [LICENSE_FEATURES.VARIABLES]: false, [LICENSE_FEATURES.API_DISABLED]: false, + [LICENSE_FEATURES.EXTERNAL_SECRETS]: false, [LICENSE_FEATURES.SHOW_NON_PROD_BANNER]: false, [LICENSE_FEATURES.WORKFLOW_HISTORY]: false, [LICENSE_FEATURES.DEBUG_IN_EDITOR]: false, diff --git a/packages/cli/src/credentials/credentials.service.ts b/packages/cli/src/credentials/credentials.service.ts index 94be5b9fb6..0d6c67c554 100644 --- a/packages/cli/src/credentials/credentials.service.ts +++ b/packages/cli/src/credentials/credentials.service.ts @@ -309,7 +309,10 @@ export class CredentialsService { if (!prop) { continue; } - if (prop.typeOptions?.password) { + if ( + prop.typeOptions?.password && + (!(copiedData[dataKey] as string).startsWith('={{') || prop.noDataExpression) + ) { if (copiedData[dataKey].toString().length > 0) { copiedData[dataKey] = CREDENTIAL_BLANKING_VALUE; } else { diff --git a/packages/cli/src/credentials/oauth2Credential.api.ts b/packages/cli/src/credentials/oauth2Credential.api.ts index bcb3892ddf..dda9b486e9 100644 --- a/packages/cli/src/credentials/oauth2Credential.api.ts +++ b/packages/cli/src/credentials/oauth2Credential.api.ts @@ -34,6 +34,8 @@ import config from '@/config'; import { getInstanceBaseUrl } from '@/UserManagement/UserManagementHelper'; import { Container } from 'typedi'; +import * as WorkflowExecuteAdditionalData from '@/WorkflowExecuteAdditionalData'; + export const oauth2CredentialController = express.Router(); /** @@ -81,12 +83,15 @@ oauth2CredentialController.get( throw new ResponseHelper.InternalServerError((error as Error).message); } + const additionalData = await WorkflowExecuteAdditionalData.getBase(req.user.id); + const credentialType = (credential as unknown as ICredentialsEncrypted).type; const mode: WorkflowExecuteMode = 'internal'; const timezone = config.getEnv('generic.timezone'); const credentialsHelper = new CredentialsHelper(encryptionKey); const decryptedDataOriginal = await credentialsHelper.getDecrypted( + additionalData, credential as INodeCredentialsDetails, credentialType, mode, @@ -107,6 +112,7 @@ oauth2CredentialController.get( } const oauthCredentials = credentialsHelper.applyDefaultsAndOverwrites( + additionalData, decryptedDataOriginal, credentialType, mode, @@ -223,11 +229,13 @@ oauth2CredentialController.get( } const encryptionKey = await UserSettings.getEncryptionKey(); + const additionalData = await WorkflowExecuteAdditionalData.getBase(state.cid); const mode: WorkflowExecuteMode = 'internal'; const timezone = config.getEnv('generic.timezone'); const credentialsHelper = new CredentialsHelper(encryptionKey); const decryptedDataOriginal = await credentialsHelper.getDecrypted( + additionalData, credential as INodeCredentialsDetails, (credential as unknown as ICredentialsEncrypted).type, mode, @@ -235,6 +243,7 @@ oauth2CredentialController.get( true, ); const oauthCredentials = credentialsHelper.applyDefaultsAndOverwrites( + additionalData, decryptedDataOriginal, (credential as unknown as ICredentialsEncrypted).type, mode, diff --git a/packages/cli/src/databases/repositories/settings.repository.ts b/packages/cli/src/databases/repositories/settings.repository.ts index 82630bffdb..a213ee78a3 100644 --- a/packages/cli/src/databases/repositories/settings.repository.ts +++ b/packages/cli/src/databases/repositories/settings.repository.ts @@ -1,3 +1,4 @@ +import { EXTERNAL_SECRETS_DB_KEY } from '@/ExternalSecrets/constants'; import { Service } from 'typedi'; import { DataSource, Repository } from 'typeorm'; import { ErrorReporterProxy as ErrorReporter } from 'n8n-workflow'; @@ -10,6 +11,21 @@ export class SettingsRepository extends Repository { super(Settings, dataSource.manager); } + async getEncryptedSecretsProviderSettings(): Promise { + return (await this.findOne({ where: { key: EXTERNAL_SECRETS_DB_KEY } }))?.value ?? null; + } + + async saveEncryptedSecretsProviderSettings(data: string): Promise { + await this.upsert( + { + key: EXTERNAL_SECRETS_DB_KEY, + value: data, + loadOnStartup: false, + }, + ['key'], + ); + } + async dismissBanner({ bannerName }: { bannerName: string }): Promise<{ success: boolean }> { const key = 'ui.banners.dismissed'; const dismissedBannersSetting = await this.findOneBy({ key }); diff --git a/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts b/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts index 2a97f4471d..6af27c1b76 100644 --- a/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts +++ b/packages/cli/src/eventbus/MessageEventBusDestination/MessageEventBusDestinationWebhook.ee.ts @@ -15,6 +15,7 @@ import type { MessageEventBusDestinationOptions, MessageEventBusDestinationWebhookParameterItem, MessageEventBusDestinationWebhookParameterOptions, + IWorkflowExecuteAdditionalData, } from 'n8n-workflow'; import { CredentialsHelper } from '@/CredentialsHelper'; import { UserSettings } from 'n8n-core'; @@ -24,6 +25,7 @@ import { isLogStreamingEnabled } from '../MessageEventBus/MessageEventBusHelper' import { eventMessageGenericDestinationTestEvent } from '../EventMessageClasses/EventMessageGeneric'; import { MessageEventBus } from '../MessageEventBus/MessageEventBus'; import type { MessageWithCallback } from '../MessageEventBus/MessageEventBus'; +import * as SecretsHelpers from '@/ExternalSecrets/externalSecretsHelper.ee'; export const isMessageEventBusDestinationWebhookOptions = ( candidate: unknown, @@ -108,6 +110,7 @@ export class MessageEventBusDestinationWebhook if (foundCredential) { const timezone = config.getEnv('generic.timezone'); const credentialsDecrypted = await this.credentialsHelper?.getDecrypted( + { secretsHelpers: SecretsHelpers } as unknown as IWorkflowExecuteAdditionalData, foundCredential[1], foundCredential[0], 'internal', diff --git a/packages/cli/src/requests.ts b/packages/cli/src/requests.ts index ecee712f22..fea69cd652 100644 --- a/packages/cli/src/requests.ts +++ b/packages/cli/src/requests.ts @@ -4,6 +4,7 @@ import type { IConnections, ICredentialDataDecryptedObject, ICredentialNodeAccess, + IDataObject, INode, INodeCredentialTestRequest, IPinData, @@ -14,7 +15,13 @@ import type { import { IsBoolean, IsEmail, IsOptional, IsString, Length } from 'class-validator'; import { NoXss } from '@db/utils/customValidators'; -import type { PublicUser, IExecutionDeleteFilter, IWorkflowDb } from '@/Interfaces'; +import type { + PublicUser, + IExecutionDeleteFilter, + IWorkflowDb, + SecretsProvider, + SecretsProviderState, +} from '@/Interfaces'; import type { Role } from '@db/entities/Role'; import type { User } from '@db/entities/User'; import type { UserManagementMailer } from '@/UserManagement/email'; @@ -497,3 +504,25 @@ export declare namespace VariablesRequest { type Update = AuthenticatedRequest<{ id: string }, {}, CreateUpdatePayload, {}>; type Delete = Get; } + +export declare namespace ExternalSecretsRequest { + type GetProviderResponse = Pick & { + icon: string; + connected: boolean; + connectedAt: Date | null; + state: SecretsProviderState; + data: IDataObject; + }; + + type GetProviders = AuthenticatedRequest; + type GetProvider = AuthenticatedRequest<{ provider: string }, GetProviderResponse>; + type SetProviderSettings = AuthenticatedRequest<{ provider: string }, {}, IDataObject>; + type TestProviderSettings = SetProviderSettings; + type SetProviderConnected = AuthenticatedRequest< + { provider: string }, + {}, + { connected: boolean } + >; + + type UpdateProvider = AuthenticatedRequest<{ provider: string }>; +} diff --git a/packages/cli/test/integration/ExternalSecrets/externalSecrets.api.test.ts b/packages/cli/test/integration/ExternalSecrets/externalSecrets.api.test.ts new file mode 100644 index 0000000000..8ea55e7e73 --- /dev/null +++ b/packages/cli/test/integration/ExternalSecrets/externalSecrets.api.test.ts @@ -0,0 +1,370 @@ +import type { SuperAgentTest } from 'supertest'; +import { License } from '@/License'; +import * as testDb from '../shared/testDb'; +import * as utils from '../shared/utils/'; +import type { ExternalSecretsSettings, SecretsProviderState } from '@/Interfaces'; +import { UserSettings } from 'n8n-core'; +import { SettingsRepository } from '@/databases/repositories/settings.repository'; +import Container from 'typedi'; +import { AES, enc } from 'crypto-js'; +import { ExternalSecretsProviders } from '@/ExternalSecrets/ExternalSecretsProviders.ee'; +import { + DummyProvider, + FailedProvider, + MockProviders, + TestFailProvider, +} from '../../shared/ExternalSecrets/utils'; +import config from '@/config'; +import { ExternalSecretsManager } from '@/ExternalSecrets/ExternalSecretsManager.ee'; +import { CREDENTIAL_BLANKING_VALUE } from '@/constants'; +import type { IDataObject } from 'n8n-workflow'; + +let authOwnerAgent: SuperAgentTest; +let authMemberAgent: SuperAgentTest; + +const licenseLike = utils.mockInstance(License, { + isExternalSecretsEnabled: jest.fn().mockReturnValue(true), + isWithinUsersLimit: jest.fn().mockReturnValue(true), +}); + +const mockProvidersInstance = new MockProviders(); +let providersMock: ExternalSecretsProviders = utils.mockInstance( + ExternalSecretsProviders, + mockProvidersInstance, +); + +const testServer = utils.setupTestServer({ endpointGroups: ['externalSecrets'] }); + +const connectedDate = '2023-08-01T12:32:29.000Z'; + +async function setExternalSecretsSettings(settings: ExternalSecretsSettings) { + const encryptionKey = await UserSettings.getEncryptionKey(); + return Container.get(SettingsRepository).saveEncryptedSecretsProviderSettings( + AES.encrypt(JSON.stringify(settings), encryptionKey).toString(), + ); +} + +async function getExternalSecretsSettings(): Promise { + const encryptionKey = await UserSettings.getEncryptionKey(); + const encSettings = await Container.get(SettingsRepository).getEncryptedSecretsProviderSettings(); + if (encSettings === null) { + return null; + } + return JSON.parse(AES.decrypt(encSettings, encryptionKey).toString(enc.Utf8)); +} + +const resetManager = async () => { + Container.get(ExternalSecretsManager).shutdown(); + Container.set( + ExternalSecretsManager, + new ExternalSecretsManager( + Container.get(SettingsRepository), + licenseLike, + mockProvidersInstance, + ), + ); + + await Container.get(ExternalSecretsManager).init(); +}; + +const getDummyProviderData = ({ + data, + includeProperties, + connected, + state, + connectedAt, + displayName, +}: { + data?: IDataObject; + includeProperties?: boolean; + connected?: boolean; + state?: SecretsProviderState; + connectedAt?: string | null; + displayName?: string; +} = {}) => { + const dummy: IDataObject = { + connected: connected ?? true, + connectedAt: connectedAt === undefined ? connectedDate : connectedAt, + data: data ?? {}, + name: 'dummy', + displayName: displayName ?? 'Dummy Provider', + icon: 'dummy', + state: state ?? 'connected', + }; + + if (includeProperties) { + dummy.properties = new DummyProvider().properties; + } + + return dummy; +}; + +beforeAll(async () => { + await utils.initEncryptionKey(); + + const owner = await testDb.createOwner(); + authOwnerAgent = testServer.authAgentFor(owner); + const member = await testDb.createUser(); + authMemberAgent = testServer.authAgentFor(member); + config.set('userManagement.isInstanceOwnerSetUp', true); +}); + +beforeEach(async () => { + licenseLike.isExternalSecretsEnabled.mockReturnValue(true); + + mockProvidersInstance.setProviders({ + dummy: DummyProvider, + }); + + await setExternalSecretsSettings({ + dummy: { + connected: true, + connectedAt: new Date(connectedDate), + settings: {}, + }, + }); + + await resetManager(); +}); + +afterEach(async () => { + Container.get(ExternalSecretsManager).shutdown(); +}); + +describe('GET /external-secrets/providers', () => { + test('can retrieve providers as owner', async () => { + const resp = await authOwnerAgent.get('/external-secrets/providers'); + expect(resp.body).toEqual({ + data: [getDummyProviderData()], + }); + }); + + test('can not retrieve providers as non-owner', async () => { + const resp = await authMemberAgent.get('/external-secrets/providers'); + expect(resp.status).toBe(403); + }); + + test('does obscure passwords', async () => { + await setExternalSecretsSettings({ + dummy: { + connected: true, + connectedAt: new Date(connectedDate), + settings: { + username: 'testuser', + password: 'testpass', + }, + }, + }); + + await resetManager(); + + const resp = await authOwnerAgent.get('/external-secrets/providers'); + expect(resp.body).toEqual({ + data: [ + getDummyProviderData({ + data: { + username: 'testuser', + password: CREDENTIAL_BLANKING_VALUE, + }, + }), + ], + }); + }); +}); + +describe('GET /external-secrets/providers/:provider', () => { + test('can retrieve provider as owner', async () => { + const resp = await authOwnerAgent.get('/external-secrets/providers/dummy'); + expect(resp.body.data).toEqual(getDummyProviderData({ includeProperties: true })); + }); + + test('can not retrieve provider as non-owner', async () => { + const resp = await authMemberAgent.get('/external-secrets/providers/dummy'); + expect(resp.status).toBe(403); + }); + + test('does obscure passwords', async () => { + await setExternalSecretsSettings({ + dummy: { + connected: true, + connectedAt: new Date(connectedDate), + settings: { + username: 'testuser', + password: 'testpass', + }, + }, + }); + + await resetManager(); + + const resp = await authOwnerAgent.get('/external-secrets/providers/dummy'); + expect(resp.body.data).toEqual( + getDummyProviderData({ + data: { + username: 'testuser', + password: CREDENTIAL_BLANKING_VALUE, + }, + includeProperties: true, + }), + ); + }); +}); + +describe('POST /external-secrets/providers/:provider', () => { + test('can update provider settings', async () => { + const testData = { + username: 'testuser', + other: 'testother', + }; + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy').send(testData); + expect(resp.status).toBe(200); + + const confirmResp = await authOwnerAgent.get('/external-secrets/providers/dummy'); + expect(confirmResp.body.data).toEqual( + getDummyProviderData({ data: testData, includeProperties: true }), + ); + }); + + test('can update provider settings with blanking value', async () => { + await setExternalSecretsSettings({ + dummy: { + connected: true, + connectedAt: new Date(connectedDate), + settings: { + username: 'testuser', + password: 'testpass', + }, + }, + }); + + await resetManager(); + + const testData = { + username: 'newuser', + password: CREDENTIAL_BLANKING_VALUE, + }; + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy').send(testData); + expect(resp.status).toBe(200); + + const confirmResp = await authOwnerAgent.get('/external-secrets/providers/dummy'); + expect((await getExternalSecretsSettings())?.dummy.settings).toEqual({ + username: 'newuser', + password: 'testpass', + }); + }); +}); + +describe('POST /external-secrets/providers/:provider/connect', () => { + test('can change provider connected state', async () => { + const testData = { + connected: false, + }; + const resp = await authOwnerAgent + .post('/external-secrets/providers/dummy/connect') + .send(testData); + expect(resp.status).toBe(200); + + const confirmResp = await authOwnerAgent.get('/external-secrets/providers/dummy'); + expect(confirmResp.body.data).toEqual( + getDummyProviderData({ + includeProperties: true, + connected: false, + state: 'initializing', + }), + ); + }); +}); + +describe('POST /external-secrets/providers/:provider/test', () => { + test('can test provider', async () => { + const testData = { + username: 'testuser', + other: 'testother', + }; + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy/test').send(testData); + expect(resp.status).toBe(200); + expect(resp.body.data.success).toBe(true); + expect(resp.body.data.testState).toBe('connected'); + }); + + test('can test provider fail', async () => { + mockProvidersInstance.setProviders({ + dummy: TestFailProvider, + }); + + await resetManager(); + + const testData = { + username: 'testuser', + other: 'testother', + }; + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy/test').send(testData); + expect(resp.status).toBe(400); + expect(resp.body.data.success).toBe(false); + expect(resp.body.data.testState).toBe('error'); + }); +}); + +describe('POST /external-secrets/providers/:provider/update', () => { + test('can update provider', async () => { + const updateSpy = jest.spyOn( + Container.get(ExternalSecretsManager).getProvider('dummy')!, + 'update', + ); + + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy/update'); + expect(resp.status).toBe(200); + expect(resp.body.data).toEqual({ updated: true }); + expect(updateSpy).toBeCalled(); + }); + + test('can not update errored provider', async () => { + mockProvidersInstance.setProviders({ + dummy: FailedProvider, + }); + + await resetManager(); + + const updateSpy = jest.spyOn( + Container.get(ExternalSecretsManager).getProvider('dummy')!, + 'update', + ); + + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy/update'); + expect(resp.status).toBe(400); + expect(resp.body.data).toEqual({ updated: false }); + expect(updateSpy).not.toBeCalled(); + }); + + test('can not update provider without a valid license', async () => { + const updateSpy = jest.spyOn( + Container.get(ExternalSecretsManager).getProvider('dummy')!, + 'update', + ); + + licenseLike.isExternalSecretsEnabled.mockReturnValue(false); + + const resp = await authOwnerAgent.post('/external-secrets/providers/dummy/update'); + expect(resp.status).toBe(400); + expect(resp.body.data).toEqual({ updated: false }); + expect(updateSpy).not.toBeCalled(); + }); +}); + +describe('GET /external-secrets/secrets', () => { + test('can get secret names as owner', async () => { + const resp = await authOwnerAgent.get('/external-secrets/secrets'); + expect(resp.status).toBe(200); + expect(resp.body.data).toEqual({ + dummy: ['test1', 'test2'], + }); + }); + + test('can not get secret names as non-owner', async () => { + const resp = await authMemberAgent.get('/external-secrets/secrets'); + expect(resp.status).toBe(403); + expect(resp.body.data).not.toEqual({ + dummy: ['test1', 'test2'], + }); + }); +}); diff --git a/packages/cli/test/integration/shared/types.ts b/packages/cli/test/integration/shared/types.ts index b1fa62a11e..1e4e20c6f0 100644 --- a/packages/cli/test/integration/shared/types.ts +++ b/packages/cli/test/integration/shared/types.ts @@ -26,6 +26,7 @@ export type EndpointGroup = | 'license' | 'variables' | 'tags' + | 'externalSecrets' | 'mfa' | 'metrics'; diff --git a/packages/cli/test/integration/shared/utils/testServer.ts b/packages/cli/test/integration/shared/utils/testServer.ts index c6ed5426c9..26fa2b81a0 100644 --- a/packages/cli/test/integration/shared/utils/testServer.ts +++ b/packages/cli/test/integration/shared/utils/testServer.ts @@ -50,6 +50,7 @@ import * as testDb from '../../shared/testDb'; import { AUTHLESS_ENDPOINTS, PUBLIC_API_REST_PATH_SEGMENT, REST_PATH_SEGMENT } from '../constants'; import type { EndpointGroup, SetupProps, TestServer } from '../types'; import { mockInstance } from './mocking'; +import { ExternalSecretsController } from '@/ExternalSecrets/ExternalSecrets.controller.ee'; import { MfaService } from '@/Mfa/mfa.service'; import { TOTPService } from '@/Mfa/totp.service'; import { UserSettings } from 'n8n-core'; @@ -285,6 +286,9 @@ export const setupTestServer = ({ case 'tags': registerController(app, config, Container.get(TagsController)); break; + case 'externalSecrets': + registerController(app, config, Container.get(ExternalSecretsController)); + break; } } } diff --git a/packages/cli/test/shared/ExternalSecrets/utils.ts b/packages/cli/test/shared/ExternalSecrets/utils.ts new file mode 100644 index 0000000000..068e22576e --- /dev/null +++ b/packages/cli/test/shared/ExternalSecrets/utils.ts @@ -0,0 +1,215 @@ +import { SecretsProvider } from '@/Interfaces'; +import type { SecretsProviderSettings, SecretsProviderState } from '@/Interfaces'; +import type { IDataObject, INodeProperties } from 'n8n-workflow'; + +export class MockProviders { + providers: Record = { + dummy: DummyProvider, + }; + + setProviders(providers: Record) { + this.providers = providers; + } + + getProvider(name: string): { new (): SecretsProvider } | null { + return this.providers[name] ?? null; + } + + hasProvider(name: string) { + return name in this.providers; + } + + getAllProviders() { + return this.providers; + } +} + +export class DummyProvider extends SecretsProvider { + properties: INodeProperties[] = [ + { + name: 'username', + displayName: 'Username', + type: 'string', + default: '', + required: true, + }, + { + name: 'other', + displayName: 'Other', + type: 'string', + default: '', + }, + { + name: 'password', + displayName: 'Password', + type: 'string', + default: '', + typeOptions: { + password: true, + }, + }, + ]; + + secrets: Record = {}; + + displayName = 'Dummy Provider'; + + name = 'dummy'; + + state: SecretsProviderState = 'initializing'; + + _updateSecrets: Record = { + test1: 'value1', + test2: 'value2', + }; + + async init(settings: SecretsProviderSettings): Promise {} + + async connect(): Promise { + this.state = 'connected'; + } + + async disconnect(): Promise {} + + async update(): Promise { + this.secrets = this._updateSecrets; + } + + async test(): Promise<[boolean] | [boolean, string]> { + return [true]; + } + + getSecret(name: string): IDataObject | undefined { + return this.secrets[name] as unknown as IDataObject | undefined; + } + + hasSecret(name: string): boolean { + return name in this.secrets; + } + + getSecretNames(): string[] { + return Object.keys(this.secrets); + } +} + +export class ErrorProvider extends SecretsProvider { + secrets: Record = {}; + + displayName = 'Error Provider'; + + name = 'dummy'; + + state: SecretsProviderState = 'initializing'; + + async init(settings: SecretsProviderSettings): Promise { + throw new Error(); + } + + async connect(): Promise { + this.state = 'error'; + throw new Error(); + } + + async disconnect(): Promise { + throw new Error(); + } + + async update(): Promise { + throw new Error(); + } + + async test(): Promise<[boolean] | [boolean, string]> { + throw new Error(); + } + + getSecret(name: string): IDataObject | undefined { + throw new Error(); + } + + hasSecret(name: string): boolean { + throw new Error(); + } + + getSecretNames(): string[] { + throw new Error(); + } +} + +export class FailedProvider extends SecretsProvider { + secrets: Record = {}; + + displayName = 'Failed Provider'; + + name = 'dummy'; + + state: SecretsProviderState = 'initializing'; + + async init(settings: SecretsProviderSettings): Promise {} + + async connect(): Promise { + this.state = 'error'; + } + + async disconnect(): Promise {} + + async update(): Promise {} + + async test(): Promise<[boolean] | [boolean, string]> { + return [true]; + } + + getSecret(name: string): IDataObject | undefined { + return this.secrets[name] as unknown as IDataObject | undefined; + } + + hasSecret(name: string): boolean { + return name in this.secrets; + } + + getSecretNames(): string[] { + return Object.keys(this.secrets); + } +} + +export class TestFailProvider extends SecretsProvider { + secrets: Record = {}; + + displayName = 'Test Failed Provider'; + + name = 'dummy'; + + state: SecretsProviderState = 'initializing'; + + _updateSecrets: Record = { + test1: 'value1', + test2: 'value2', + }; + + async init(settings: SecretsProviderSettings): Promise {} + + async connect(): Promise { + this.state = 'connected'; + } + + async disconnect(): Promise {} + + async update(): Promise { + this.secrets = this._updateSecrets; + } + + async test(): Promise<[boolean] | [boolean, string]> { + return [false]; + } + + getSecret(name: string): IDataObject | undefined { + return this.secrets[name] as unknown as IDataObject | undefined; + } + + hasSecret(name: string): boolean { + return name in this.secrets; + } + + getSecretNames(): string[] { + return Object.keys(this.secrets); + } +} diff --git a/packages/cli/test/unit/ActiveWorkflowRunner.test.ts b/packages/cli/test/unit/ActiveWorkflowRunner.test.ts index c9b3e6ad09..0622dac9a2 100644 --- a/packages/cli/test/unit/ActiveWorkflowRunner.test.ts +++ b/packages/cli/test/unit/ActiveWorkflowRunner.test.ts @@ -24,6 +24,7 @@ import { mockInstance } from '../integration/shared/utils/'; import { Push } from '@/push'; import { ActiveExecutions } from '@/ActiveExecutions'; import { NodeTypes } from '@/NodeTypes'; +import { SecretsHelper } from '@/SecretsHelpers'; import { WebhookService } from '@/services/webhook.service'; import { VariablesService } from '../../src/environments/variables/variables.service'; @@ -159,6 +160,7 @@ describe('ActiveWorkflowRunner', () => { Container.set(LoadNodesAndCredentials, nodesAndCredentials); Container.set(VariablesService, mockVariablesService); mockInstance(Push); + mockInstance(SecretsHelper); }); beforeEach(() => { diff --git a/packages/cli/test/unit/ExternalSecrets/ExternalSecretsManager.test.ts b/packages/cli/test/unit/ExternalSecrets/ExternalSecretsManager.test.ts new file mode 100644 index 0000000000..0789b87d67 --- /dev/null +++ b/packages/cli/test/unit/ExternalSecrets/ExternalSecretsManager.test.ts @@ -0,0 +1,194 @@ +import type { SettingsRepository } from '@/databases/repositories'; +import type { ExternalSecretsSettings } from '@/Interfaces'; +import { License } from '@/License'; +import { ExternalSecretsManager } from '@/ExternalSecrets/ExternalSecretsManager.ee'; +import { ExternalSecretsProviders } from '@/ExternalSecrets/ExternalSecretsProviders.ee'; +import { mock } from 'jest-mock-extended'; +import { UserSettings } from 'n8n-core'; +import Container from 'typedi'; +import { mockInstance } from '../../integration/shared/utils'; +import { + DummyProvider, + ErrorProvider, + FailedProvider, + MockProviders, +} from '../../shared/ExternalSecrets/utils'; +import { AES, enc } from 'crypto-js'; +import { InternalHooks } from '@/InternalHooks'; + +const connectedDate = '2023-08-01T12:32:29.000Z'; +const encryptionKey = 'testkey'; +let settings: string | null = null; +const mockProvidersInstance = new MockProviders(); +const settingsRepo = mock({ + async getEncryptedSecretsProviderSettings() { + return settings; + }, + async saveEncryptedSecretsProviderSettings(data) { + settings = data; + }, +}); +let licenseMock: License; +let providersMock: ExternalSecretsProviders; +let manager: ExternalSecretsManager | undefined; + +const createMockSettings = (settings: ExternalSecretsSettings): string => { + return AES.encrypt(JSON.stringify(settings), encryptionKey).toString(); +}; + +const decryptSettings = (settings: string) => { + return JSON.parse(AES.decrypt(settings ?? '', encryptionKey).toString(enc.Utf8)); +}; + +describe('External Secrets Manager', () => { + beforeAll(() => { + jest + .spyOn(UserSettings, 'getEncryptionKey') + .mockReturnValue(new Promise((resolve) => resolve(encryptionKey))); + providersMock = mockInstance(ExternalSecretsProviders, mockProvidersInstance); + licenseMock = mockInstance(License, { + isExternalSecretsEnabled() { + return true; + }, + }); + mockInstance(InternalHooks); + }); + + beforeEach(() => { + mockProvidersInstance.setProviders({ + dummy: DummyProvider, + }); + settings = createMockSettings({ + dummy: { connected: true, connectedAt: new Date(connectedDate), settings: {} }, + }); + + Container.remove(ExternalSecretsManager); + }); + + afterEach(() => { + manager?.shutdown(); + jest.useRealTimers(); + }); + + test('should get secret', async () => { + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + await manager.init(); + + expect(manager.getSecret('dummy', 'test1')).toBe('value1'); + }); + + test('should not throw errors during init', async () => { + mockProvidersInstance.setProviders({ + dummy: ErrorProvider, + }); + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + expect(async () => manager!.init()).not.toThrow(); + }); + + test('should not throw errors during shutdown', async () => { + mockProvidersInstance.setProviders({ + dummy: ErrorProvider, + }); + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + await manager.init(); + expect(() => manager!.shutdown()).not.toThrow(); + manager = undefined; + }); + + test('should save provider settings', async () => { + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + const settingsSpy = jest.spyOn(settingsRepo, 'saveEncryptedSecretsProviderSettings'); + + await manager.init(); + + await manager.setProviderSettings('dummy', { + test: 'value', + }); + + expect(decryptSettings(settingsSpy.mock.calls[0][0])).toEqual({ + dummy: { + connected: true, + connectedAt: connectedDate, + settings: { + test: 'value', + }, + }, + }); + }); + + test('should call provider update functions on a timer', async () => { + jest.useFakeTimers(); + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + await manager.init(); + + const updateSpy = jest.spyOn(manager.getProvider('dummy')!, 'update'); + + expect(updateSpy).toBeCalledTimes(0); + + jest.runOnlyPendingTimers(); + + expect(updateSpy).toBeCalledTimes(1); + }); + + test('should not call provider update functions if the not licensed', async () => { + jest.useFakeTimers(); + + manager = new ExternalSecretsManager( + settingsRepo, + mock({ + isExternalSecretsEnabled() { + return false; + }, + }), + providersMock, + ); + + await manager.init(); + + const updateSpy = jest.spyOn(manager.getProvider('dummy')!, 'update'); + + expect(updateSpy).toBeCalledTimes(0); + + jest.runOnlyPendingTimers(); + + expect(updateSpy).toBeCalledTimes(0); + }); + + test('should not call provider update functions if the provider has an error', async () => { + jest.useFakeTimers(); + + mockProvidersInstance.setProviders({ + dummy: FailedProvider, + }); + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + await manager.init(); + + const updateSpy = jest.spyOn(manager.getProvider('dummy')!, 'update'); + + expect(updateSpy).toBeCalledTimes(0); + + jest.runOnlyPendingTimers(); + + expect(updateSpy).toBeCalledTimes(0); + }); + + test('should reinitialize a provider when save provider settings', async () => { + manager = new ExternalSecretsManager(settingsRepo, licenseMock, providersMock); + + await manager.init(); + + const dummyInitSpy = jest.spyOn(DummyProvider.prototype, 'init'); + + await manager.setProviderSettings('dummy', { + test: 'value', + }); + + expect(dummyInitSpy).toBeCalledTimes(1); + }); +}); diff --git a/packages/core/src/NodeExecuteFunctions.ts b/packages/core/src/NodeExecuteFunctions.ts index 11c1844a71..af000e91cc 100644 --- a/packages/core/src/NodeExecuteFunctions.ts +++ b/packages/core/src/NodeExecuteFunctions.ts @@ -136,6 +136,7 @@ import { setAllWorkflowExecutionMetadata, setWorkflowExecutionMetadata, } from './WorkflowExecutionMetadata'; +import { getSecretsProxy } from './Secrets'; import { getUserN8nFolderPath } from './UserSettings'; axios.defaults.timeout = 300000; @@ -1683,6 +1684,7 @@ export function getAdditionalKeys( additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, runExecutionData: IRunExecutionData | null, + options?: { secretsEnabled?: boolean }, ): IWorkflowDataProxyAdditionalKeys { const executionId = additionalData.executionId || PLACEHOLDER_EMPTY_EXECUTION_ID; const resumeUrl = `${additionalData.webhookWaitingBaseUrl}/${executionId}`; @@ -1723,6 +1725,7 @@ export function getAdditionalKeys( : undefined, }, $vars: additionalData.variables, + $secrets: options?.secretsEnabled ? getSecretsProxy(additionalData) : undefined, // deprecated $executionId: executionId, @@ -1858,6 +1861,7 @@ export async function getCredentials( // } const decryptedDataObject = await additionalData.credentialsHelper.getDecrypted( + additionalData, nodeCredentials, type, mode, diff --git a/packages/core/src/Secrets.ts b/packages/core/src/Secrets.ts new file mode 100644 index 0000000000..508af6ada3 --- /dev/null +++ b/packages/core/src/Secrets.ts @@ -0,0 +1,76 @@ +import type { IDataObject, IWorkflowExecuteAdditionalData } from 'n8n-workflow'; +import { ExpressionError } from 'n8n-workflow'; + +function buildSecretsValueProxy(value: IDataObject): unknown { + return new Proxy(value, { + get(target, valueName) { + if (typeof valueName !== 'string') { + return; + } + if (!(valueName in value)) { + throw new ExpressionError('Could not load secrets', { + description: + 'The credential in use tries to use secret from an external store that could not be found', + }); + } + const retValue = value[valueName]; + if (typeof retValue === 'object' && retValue !== null) { + return buildSecretsValueProxy(retValue as IDataObject); + } + return retValue; + }, + }); +} + +export function getSecretsProxy(additionalData: IWorkflowExecuteAdditionalData): IDataObject { + const secretsHelpers = additionalData.secretsHelpers; + return new Proxy( + {}, + { + get(target, providerName) { + if (typeof providerName !== 'string') { + return {}; + } + if (secretsHelpers.hasProvider(providerName)) { + return new Proxy( + {}, + { + get(target2, secretName): IDataObject | undefined { + if (typeof secretName !== 'string') { + return; + } + if (!secretsHelpers.hasSecret(providerName, secretName)) { + throw new ExpressionError('Could not load secrets', { + description: + 'The credential in use tries to use secret from an external store that could not be found', + }); + } + const retValue = secretsHelpers.getSecret(providerName, secretName); + if (typeof retValue === 'object' && retValue !== null) { + return buildSecretsValueProxy(retValue) as IDataObject; + } + return retValue; + }, + set() { + return false; + }, + ownKeys() { + return secretsHelpers.listSecrets(providerName); + }, + }, + ); + } + throw new ExpressionError('Could not load secrets', { + description: + 'The credential in use pulls secrets from an external store that is not reachable', + }); + }, + set() { + return false; + }, + ownKeys() { + return secretsHelpers.listProviders(); + }, + }, + ); +} diff --git a/packages/design-system/src/components/N8nCallout/Callout.vue b/packages/design-system/src/components/N8nCallout/Callout.vue index 53545563ab..639380773f 100644 --- a/packages/design-system/src/components/N8nCallout/Callout.vue +++ b/packages/design-system/src/components/N8nCallout/Callout.vue @@ -24,7 +24,7 @@ const CALLOUT_DEFAULT_ICONS: { [key: string]: string } = { info: 'info-circle', success: 'check-circle', warning: 'exclamation-triangle', - danger: 'times-circle', + danger: 'exclamation-triangle', }; export default defineComponent({ diff --git a/packages/design-system/src/components/N8nCallout/__tests__/__snapshots__/Callout.spec.ts.snap b/packages/design-system/src/components/N8nCallout/__tests__/__snapshots__/Callout.spec.ts.snap index 3e04a43141..a2f82a3ef9 100644 --- a/packages/design-system/src/components/N8nCallout/__tests__/__snapshots__/Callout.spec.ts.snap +++ b/packages/design-system/src/components/N8nCallout/__tests__/__snapshots__/Callout.spec.ts.snap @@ -27,7 +27,7 @@ exports[`components > N8nCallout > should render danger theme correctly 1`] = ` "
- +
 
diff --git a/packages/design-system/src/css/loading.scss b/packages/design-system/src/css/loading.scss index 9244291640..d13db8be39 100644 --- a/packages/design-system/src/css/loading.scss +++ b/packages/design-system/src/css/loading.scss @@ -26,7 +26,7 @@ position: fixed; .el-loading-spinner { - margin-top: #{- var.$loading-fullscreen-spinner-size * 0.5}; + transform: translateY(-50%); .circular { height: var.$loading-fullscreen-spinner-size; @@ -38,7 +38,7 @@ @include mixins.b(loading-spinner) { top: 50%; - margin-top: #{- var.$loading-spinner-size * 0.5}; + transform: translateY(-50%); width: 100%; text-align: center; position: absolute; diff --git a/packages/design-system/src/css/utilities/_link.scss b/packages/design-system/src/css/utilities/_link.scss new file mode 100644 index 0000000000..4a65d43ae8 --- /dev/null +++ b/packages/design-system/src/css/utilities/_link.scss @@ -0,0 +1,10 @@ +.overlay-link::after { + content: ''; + position: absolute; + top: 0; + right: 0; + bottom: 0; + left: 0; + z-index: 1; + pointer-events: auto; +} diff --git a/packages/design-system/src/css/utilities/index.scss b/packages/design-system/src/css/utilities/index.scss index 73ac65908a..e79fb2651a 100644 --- a/packages/design-system/src/css/utilities/index.scss +++ b/packages/design-system/src/css/utilities/index.scss @@ -1,4 +1,5 @@ @import 'float'; +@import 'link'; @import 'list'; @import 'spacing'; @import 'typography'; diff --git a/packages/editor-ui/src/Interface.ts b/packages/editor-ui/src/Interface.ts index c2dece42d7..8b0a607d60 100644 --- a/packages/editor-ui/src/Interface.ts +++ b/packages/editor-ui/src/Interface.ts @@ -44,6 +44,7 @@ import type { } from './constants'; import type { BulkCommand, Undoable } from '@/models/history'; import type { PartialBy } from '@/utils/typeHelpers'; +import type { INodeProperties } from 'n8n-workflow'; export * from 'n8n-design-system/types'; @@ -1542,6 +1543,26 @@ export interface InstanceUsage { export type CloudPlanAndUsageData = Cloud.PlanData & { usage: InstanceUsage }; +export interface ExternalSecretsProviderSecret { + key: string; +} + +export type ExternalSecretsProviderData = Record; + +export interface ExternalSecretsProvider { + icon: string; + name: string; + displayName: string; + connected: boolean; + connectedAt: string | false; + state: 'connected' | 'tested' | 'initializing' | 'error'; + data?: ExternalSecretsProviderData; +} + +export interface ExternalSecretsProviderWithProperties extends ExternalSecretsProvider { + properties: INodeProperties[]; +} + export type CloudUpdateLinkSourceType = | 'canvas-nav' | 'custom-data-filter' diff --git a/packages/editor-ui/src/api/externalSecrets.ee.ts b/packages/editor-ui/src/api/externalSecrets.ee.ts new file mode 100644 index 0000000000..76a1e189f9 --- /dev/null +++ b/packages/editor-ui/src/api/externalSecrets.ee.ts @@ -0,0 +1,58 @@ +import type { + IRestApiContext, + ExternalSecretsProvider, + ExternalSecretsProviderWithProperties, +} from '@/Interface'; +import { makeRestApiRequest } from '@/utils'; + +export const getExternalSecrets = async ( + context: IRestApiContext, +): Promise> => { + return makeRestApiRequest(context, 'GET', '/external-secrets/secrets'); +}; + +export const getExternalSecretsProviders = async ( + context: IRestApiContext, +): Promise => { + return makeRestApiRequest(context, 'GET', '/external-secrets/providers'); +}; + +export const getExternalSecretsProvider = async ( + context: IRestApiContext, + id: string, +): Promise => { + return makeRestApiRequest(context, 'GET', `/external-secrets/providers/${id}`); +}; + +export const testExternalSecretsProviderConnection = async ( + context: IRestApiContext, + id: string, + data: ExternalSecretsProvider['data'], +): Promise<{ testState: ExternalSecretsProvider['state'] }> => { + return makeRestApiRequest(context, 'POST', `/external-secrets/providers/${id}/test`, data); +}; + +export const updateProvider = async ( + context: IRestApiContext, + id: string, + data: ExternalSecretsProvider['data'], +): Promise => { + return makeRestApiRequest(context, 'POST', `/external-secrets/providers/${id}`, data); +}; + +export const reloadProvider = async ( + context: IRestApiContext, + id: string, +): Promise<{ updated: boolean }> => { + return makeRestApiRequest(context, 'POST', `/external-secrets/providers/${id}/update`); +}; + +export const connectProvider = async ( + context: IRestApiContext, + id: string, + connected: boolean, +): Promise => { + return makeRestApiRequest(context, 'POST', `/external-secrets/providers/${id}/connect`, { + connected, + }); +}; diff --git a/packages/editor-ui/src/assets/images/doppler.webp b/packages/editor-ui/src/assets/images/doppler.webp new file mode 100644 index 0000000000000000000000000000000000000000..7bd34406375ca8402b4830a3749cf85fc7eaeda8 GIT binary patch literal 315064 zcmXteV{j#0wCssbY}?7iwrx*rOp=K)v2EKnCbn(s#Ky$-`|7@X|Lvb$-MhP2ty-!w zl9Kf^kN`~yQRSb?-10^Ly_tvyM^RA2Y$;?CQcLozTwYZ-P%2TwJ-2g^vT+c3D#NYIXvSsPc)Et=7m+5K zn|E}^0qWgcyZT9z0c2N!gzZPav)j1HhIUh}!U}J!}L_?|SvMwSf zZ5n;T0vSIFY|v;FtfItXu`r>M&(H{Bp=~}5+*)5L%~k9EmF&JmIbjdxr!6sWUHo?C5L*(_$QX3~ zsU6(k=?v|#n*n%H5#x86bHS;#WvQDt@azEJc1JwS4zmywh=F>3a`Se$giRAuuM3)o zHEMVxW*kVF=u5GGwy}YSMW153lFk-oY%0^&P+tWdHu4&0YD|8r+(Py4OV$j-DSa*h#w53vKgC# zj|hY=oCX?wc;0o_iQ=dUi*N@FCH|P>yx$Q&PytPTmep9u zU|L_Oo>HVhr<&Eh*#^-edX@T^F-XkRIc5>FJ$$lCfU7GqAVX(Y!|MskZ~;hCzT>|Q z@@({;1K1H*QpxD+F?Ua7@N%p>J-_(%6Rs!q8{ti!?|>oHH4d+6rOQVdoWKCQ%u=aa!aWMCk{vwFC&@~dEARsaxyyOLN3Xo0NPN>LjUz{7w1>HMzV zC;t^3ZnP_HjW5k}z*caCE~ITJ2cL51sZtSAo{UFaUXpxYU9yrC=$7mFbOI%-?yng> zqY9VOn5<((3hp;XC$tU@EG$Zzkws;tP@7K_Ek98@R zgUa^_&Whi;J`4*#zi6h%{8$P(4;5*H3ddIohz3V7rc(`m=<V6+T=cm^6eUp$)&z z4^W2St?q=zm#^GuGy5E~1x%16Li_Xh<#myPAG`(R2_BW-F~ghBiqKDPfu@Yn_LFTt z(p3(!0ePN{`)Y4DFc(ep=SObZ7OQ*o@yC#j&|)_s>n&2tqGqPx&z@=I-uKJVoKQ|h z2-f2ZWEb*0xz6^=j`uEn1cYeVxYH0(+p_d^q?ZEEcgF`P?4uYpJ__Z`4dW|bPPDOi zQ91lQrLsPM*WAj>i>KkR0qwXF|7Zpq1c-g+zUo$6tol^} zWqYmqg7K{Pwo9YS^PZxIq0?^XAojjq#^TkxF2|;n1AmZ2rWMJod6c!l#WFvO)>LLN zW&CWj-39flB#H!Pse>s6PxULGjCAUZmM{dm%p;xlduv7?VHdRi&`v)hk>TbHnb?rA zT-G4nv>X4`C`dwU!ONQdhFIgU87Ijb$5$r9dBjULi?vi5!p!${YpZ*QE4tu>RS9~W zj})GVSih4vxAX%5pFAxt+(3xs+h*MxM~=fcMBggUkPynp4I%*d-R#KI;v+nxoua*(Fa840wLKjEp4S0Int7x3*xeHE4xWYK4>b z)mggS&q5XfLeYQxoDnY$amImO{IIfW-ZIR=$6~aObNR4(IZsu*vj7CMc=r?W_RN&ws zGn#Zyxn0;jEor!g)cV_M#bJ8zBJGGpu>Y}RPzYj)ij|p@It~;S&;k)ljOW3!LW`pq z5%oo^Uv@_(MPF#JVW5%VWd;`>l(EptLd3G5A*?{f&vmbC@hu91-EF0XeP%egoD6Mdz>Pct(tvS? z!Tvfps=>L1!u&mdu^7gX<1$xw4TpbD=?IXCoL8TGdBO|FjeaNaz{n3`TktNkK3m-u zTRBtYZ)^LWUC4{@m+r%=#XZw`q|P|evTTms!d7jd&du^)3`n4p3uKLgR9PA{uHe

b)r2Sss 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 S8dQ4AxA=iV?j#V!h5iA}b~%aw literal 0 HcmV?d00001 diff --git a/packages/editor-ui/src/assets/images/hashicorp.webp b/packages/editor-ui/src/assets/images/hashicorp.webp new file mode 100644 index 0000000000000000000000000000000000000000..ca52275380f5473672b6aa305c98d50fa420753c GIT binary patch literal 1602 zcmV-I2EF-GNk&FG1^@t8MM6+kP&iC31^@srzrZg51s!bLl-v;oMdX|lig?!DC@3i6 z?(Xio?(V)DcMnC}g@PhN5m(kXt`rm$6jMww#atK6aG3dLzAjfH`VYZv8%dJWUA;#y zkv*%XF#7=m{Cebn9*Rv9y-SJnDOclio>Sm3t+8vj>RU^vwp1Z+N0@3`7e8-nC~$OL znQEJCW5+rb-qCXGMO`oW;_H^F#0S2#G1fH6+OCRFEoX*$hD1}_sxtA|D^sFl;;oKp zC{lGZPa++!Ctq)AC{rDmCK{gETBnIRX{#fGFV3}0bz<5YBFV~*22)TYB$~)6svu5| z=&GoLoJE={N+Fsm3Lz7F=Xypq@AK1vNF|9 zQ4k^8C}JpB3G!|Br+q6$3m-F!sjKfj80XyLh`2PxXvwP@j`sSy!XW^#(g2uXsKOINO3y7ep~cXzH_ znvXlLQWAMZ3u_N1Vj<~Dn^V+AA|iN6?-mtjgyMv0AwiU)m}w@#qCfL9>kKAZBLt%i zWf{Vh5`?mRM1)ezwt$JCvXoPlM^4IFx7@6@ZaJF?Dq|aYzuK!W@pa44l6A|#M%OKJ z6!npdxR&##6h#X}-n>&~-jt$ffJ}`@4F?&D4v4cgmNH<;>y~7xYv@yLUq7kdx)+xy zdLXUo`uw*Q4sg-HM8i4**H*|B}}a8&4u~(bR~uHOwk0Bf0l$h-|EakmRJ7*T#bpCULOU%g5j@rFR2wqvv`4 zU0g|d$<#Ea^?FnZA($yrw7?YG0ox3zq)fF8UCZpcR(KnnIZHbeRJ259itRz+*x%}T z-d6vn*j`gOl~XiDb|zxmU{hVkbvjP-W zSp|}tTfY6bOoRly0t(`#vK4UZsT`?+0u7SNSKvV;Di%no>*^ud3OvaBk`NM1v<#q* zzFsO>0UAL^Cvpl3c!e8T<(6&DKI1D3dBg? zotR!-$SE)*pWnnmt^j@v-FtOmt^i*4>nn2w@>q7?=M2zeHmPf3fM1XN&%@3!00Fwy A=l}o! literal 0 HcmV?d00001 diff --git a/packages/editor-ui/src/assets/images/infisical.webp b/packages/editor-ui/src/assets/images/infisical.webp new file mode 100644 index 0000000000000000000000000000000000000000..abe9a20de36b6ffe7a2fa80ea192eee5f1b2e12b GIT binary patch literal 1560 zcmV+z2Iu)wNk&Ex1^@t8MM6+kP&il$0000G00027006N706|PpNE847009rs|A+_( zNC^2q+yfE)p8#SvA68H}Al3x{01zSoodGJc0I~o+Z8n)mBqJiBCb)=5fDMUdZsBr@ z%k-!39Jd^M;huYn$7loeKlN952keiouc7Zi5A8ib9)KQOpSJ%6zqp^Y{?eJHf8aZF z{`X!c_&ZN-@@0M?G=WU7_Ak$0)n38=PF}=47X^kVsEaCQrYkCDlpBRb{xq%g-u_ze z(y#t(t0ol4%>>oeBnw^|B4Rmt2JIM-C#(PaAv&Hd$nw+98OTeTr{sD1PGXGX4!!E6 zu)h4&^q4oh|5EMsWcHPHsOk7+U35|A%%fLy5ePcrKLBV7{pWG|L{rxhm471u? zBW@-0jA*m6YJ%)*ZYL&f{SL;Jz*djOmAwPTl=x9)Ow#ngsK3URkN^Pw{-#&||6Y&$ z%Kzq9YCmM1;~5@R1n*^RZ~@$Kntf{E$v8b>SDaOa|2#j@Ieo@={*ilaeRrC8p5kdc zP`L>?W&B!&eXEsw(aI*CWY96M@AOXt<6@(|>w+O9<46b^2v3GR62z7$UIa~dUfKC>lZtvMg=qAGNNdB`T*O6jR)l~4Zm#*7h!|rM3 zx~p0IGE!T-V~x>tc;f~03eV;cZ1VlC}*)hQG#jgL*TbjC6t|vm?C`FPy zw%V8Obnw%t{U92x3$5$cH7qikw-@~R9>9Du8me4%E&SL^%Um^&;rGl{tI=M5Ag3^% zolO%A*E1E6$A9<|_~uy@H->a@>YOv2nm)h}IgSh%xxGJ0o|;I}x%H?V;%B+>OBD@; zEwrs8JW%)`EP^V7M zC^Fcf20E6}Tw1a2{08X8pR`S*(9@W)s|&-=e*Ke398#Fv-(Js#?VC?dVZx}SQz7`m zHfY*WPTaP2)&>WqXl$1#El5$EVHS71^Zy2}ovrGITkrfWu-P&no!l6IOL;nRCxf1Q z14-$7+#nuQJNvwpQDU|__Bu9>*MnS-f+D6yFGSw@j8`_o+GTf$!iY{^nBbVms@%{0wS?=%QMQk>IlQ z9vbV!E9O;?e;Z#_DV#N57a%coW{??SJPDlG<(opPW#=`0w~a(!vDRdRg(0grHz*~v zQ1h7W0Ao3TkXEhOm>3w^pVPp&t6fWM|6!3H@#q~g+qmzx#IL5PoA-|@KRi6PC^MZh zrp&_|SAoi2yw;e%PPgleZK&|yid^MxDttS~D|_NSoOb{6pU zEU`XZ1Qzkk!1i21k9N@!XKadS0Pp_~EKuevUh&NH1!g>nOW>y(oU5>35r6sy-XPB{ zoxG-m&0(#ZZ`FkYr<~Xs*)o&B&-CE0Cw=Q(Gxb(Q*R|ntRJzH(IWN1}$vA846)^7H KzyJUM0000ePY%xj literal 0 HcmV?d00001 diff --git a/packages/editor-ui/src/components/CodeNodeEditor/completer.ts b/packages/editor-ui/src/components/CodeNodeEditor/completer.ts index dfcb2b6f14..9d64f92a49 100644 --- a/packages/editor-ui/src/components/CodeNodeEditor/completer.ts +++ b/packages/editor-ui/src/components/CodeNodeEditor/completer.ts @@ -172,6 +172,7 @@ export const completerExtension = defineComponent({ if (value === '$execution') return this.executionCompletions(context, variable); if (value === '$vars') return this.variablesCompletions(context, variable); + if (value === '$workflow') return this.workflowCompletions(context, variable); if (value === '$prevNode') return this.prevNodeCompletions(context, variable); diff --git a/packages/editor-ui/src/components/CodeNodeEditor/completions/secrets.completions.ts b/packages/editor-ui/src/components/CodeNodeEditor/completions/secrets.completions.ts new file mode 100644 index 0000000000..d3eec85bc0 --- /dev/null +++ b/packages/editor-ui/src/components/CodeNodeEditor/completions/secrets.completions.ts @@ -0,0 +1,54 @@ +import Vue from 'vue'; +import { addVarType } from '../utils'; +import type { Completion, CompletionContext, CompletionResult } from '@codemirror/autocomplete'; +import type { CodeNodeEditorMixin } from '../types'; +import { useExternalSecretsStore } from '@/stores'; + +const escape = (str: string) => str.replace('$', '\\$'); + +export const secretsCompletions = (Vue as CodeNodeEditorMixin).extend({ + methods: { + /** + * Complete `$secrets.` to `$secrets.providerName` and `$secrets.providerName.secretName`. + */ + secretsCompletions(context: CompletionContext, matcher = '$secrets'): CompletionResult | null { + const pattern = new RegExp(`${escape(matcher)}\..*`); + const preCursor = context.matchBefore(pattern); + + if (!preCursor || (preCursor.from === preCursor.to && !context.explicit)) return null; + + const provider = preCursor.text.split('.')[1]; + const externalSecretsStore = useExternalSecretsStore(); + let options: Completion[]; + + const optionsForObject = (leftSide: string, object: object): Completion[] => { + return Object.entries(object).flatMap(([key, value]) => { + if (typeof value === 'object' && value !== null) { + return optionsForObject(`${leftSide}.${key}`, value); + } + return { + label: `${leftSide}.${key}`, + info: '*******', + }; + }); + }; + + if (provider) { + options = optionsForObject( + `${matcher}.${provider}`, + externalSecretsStore.secretsAsObject[provider], + ); + } else { + options = Object.keys(externalSecretsStore.secretsAsObject).map((provider) => ({ + label: `${matcher}.${provider}`, + info: JSON.stringify(externalSecretsStore.secretsAsObject[provider]), + })); + } + + return { + from: preCursor.from, + options: options.map(addVarType), + }; + }, + }, +}); diff --git a/packages/editor-ui/src/components/CodeNodeEditor/completions/variables.completions.ts b/packages/editor-ui/src/components/CodeNodeEditor/completions/variables.completions.ts index c7a6983b6e..278d401545 100644 --- a/packages/editor-ui/src/components/CodeNodeEditor/completions/variables.completions.ts +++ b/packages/editor-ui/src/components/CodeNodeEditor/completions/variables.completions.ts @@ -8,7 +8,7 @@ const escape = (str: string) => str.replace('$', '\\$'); export const variablesCompletions = defineComponent({ methods: { /** - * Complete `$workflow.` to `.id .name .active`. + * Complete `$vars.` to `$vars.VAR_NAME`. */ variablesCompletions(context: CompletionContext, matcher = '$vars'): CompletionResult | null { const pattern = new RegExp(`${escape(matcher)}\..*`); diff --git a/packages/editor-ui/src/components/CredentialEdit/CredentialConfig.vue b/packages/editor-ui/src/components/CredentialEdit/CredentialConfig.vue index 8a75cfeb2b..37b8e7f4c7 100644 --- a/packages/editor-ui/src/components/CredentialEdit/CredentialConfig.vue +++ b/packages/editor-ui/src/components/CredentialEdit/CredentialConfig.vue @@ -126,6 +126,17 @@ {{ $locale.baseText('credentialEdit.credentialConfig.missingCredentialType') }} + + + +

@@ -152,10 +163,12 @@ import { useNodeTypesStore } from '@/stores/nodeTypes.store'; import type { ICredentialsResponse } from '@/Interface'; import AuthTypeSelector from '@/components/CredentialEdit/AuthTypeSelector.vue'; import GoogleAuthButton from './GoogleAuthButton.vue'; +import EnterpriseEdition from '@/components/EnterpriseEdition.ee.vue'; export default defineComponent({ name: 'CredentialConfig', components: { + EnterpriseEdition, AuthTypeSelector, Banner, CopyInput, diff --git a/packages/editor-ui/src/components/CredentialEdit/CredentialEdit.vue b/packages/editor-ui/src/components/CredentialEdit/CredentialEdit.vue index 05a06cbf4d..22a5e8f3ef 100644 --- a/packages/editor-ui/src/components/CredentialEdit/CredentialEdit.vue +++ b/packages/editor-ui/src/components/CredentialEdit/CredentialEdit.vue @@ -157,6 +157,8 @@ import { getNodeCredentialForSelectedAuthType, updateNodeAuthType, isCredentialModalState, + isExpression, + isTestableExpression, } from '@/utils'; import { externalHooks } from '@/mixins/externalHooks'; @@ -370,12 +372,13 @@ export default defineComponent({ } const { ownedBy, sharedWith, ...credentialData } = this.credentialData; - const hasExpressions = Object.values(credentialData).reduce( + const hasUntestableExpressions = Object.values(credentialData).reduce( (accu: boolean, value: CredentialInformation) => - accu || (typeof value === 'string' && value.startsWith('=')), + accu || + (typeof value === 'string' && isExpression(value) && !isTestableExpression(value)), false, ); - if (hasExpressions) { + if (hasUntestableExpressions) { return false; } @@ -445,8 +448,14 @@ export default defineComponent({ return false; } - if (property.type === 'number' && typeof this.credentialData[property.name] !== 'number') { - return false; + if (property.type === 'number') { + const isExpression = + typeof this.credentialData[property.name] === 'string' && + this.credentialData[property.name].startsWith('='); + + if (typeof this.credentialData[property.name] !== 'number' && !isExpression) { + return false; + } } } return true; @@ -835,12 +844,17 @@ export default defineComponent({ this.testedSuccessfully = false; } + const usesExternalSecrets = Object.entries(credentialDetails.data || {}).some(([, value]) => + /=.*\{\{[^}]*\$secrets\.[^}]+}}.*/.test(`${value}`), + ); + const trackProperties: ITelemetryTrackProperties = { credential_type: credentialDetails.type, workflow_id: this.workflowsStore.workflowId, credential_id: credential.id, is_complete: !!this.requiredPropertiesFilled, is_new: isNewCredential, + uses_external_secrets: usesExternalSecrets, }; if (this.isOAuthType) { diff --git a/packages/editor-ui/src/components/ExpressionParameterInput.vue b/packages/editor-ui/src/components/ExpressionParameterInput.vue index 8567f95123..ad9093f180 100644 --- a/packages/editor-ui/src/components/ExpressionParameterInput.vue +++ b/packages/editor-ui/src/components/ExpressionParameterInput.vue @@ -19,6 +19,7 @@ :isReadOnly="isReadOnly" :targetItem="hoveringItem" :isSingleLine="isForRecordLocator" + :additionalData="additionalExpressionData" :path="path" @focus="onFocus" @blur="onBlur" @@ -34,7 +35,6 @@ data-test-id="expander" /> - import { mapStores } from 'pinia'; +import type { PropType } from 'vue'; import { defineComponent } from 'vue'; import { useNDVStore } from '@/stores/ndv.store'; @@ -57,6 +58,7 @@ import { createExpressionTelemetryPayload } from '@/utils/telemetryUtils'; import type { Segment } from '@/types/expressions'; import type { TargetItem } from '@/Interface'; +import type { IDataObject } from 'n8n-workflow'; type InlineExpressionEditorInputRef = InstanceType; @@ -88,6 +90,10 @@ export default defineComponent({ type: Boolean, default: false, }, + additionalExpressionData: { + type: Object as PropType, + default: () => ({}), + }, }, computed: { ...mapStores(useNDVStore, useWorkflowsStore), diff --git a/packages/editor-ui/src/components/ExternalSecretsProviderCard.ee.vue b/packages/editor-ui/src/components/ExternalSecretsProviderCard.ee.vue new file mode 100644 index 0000000000..ed4934733c --- /dev/null +++ b/packages/editor-ui/src/components/ExternalSecretsProviderCard.ee.vue @@ -0,0 +1,185 @@ + + + + + diff --git a/packages/editor-ui/src/components/ExternalSecretsProviderConnectionSwitch.ee.vue b/packages/editor-ui/src/components/ExternalSecretsProviderConnectionSwitch.ee.vue new file mode 100644 index 0000000000..d56ead9a86 --- /dev/null +++ b/packages/editor-ui/src/components/ExternalSecretsProviderConnectionSwitch.ee.vue @@ -0,0 +1,116 @@ + + + + + diff --git a/packages/editor-ui/src/components/ExternalSecretsProviderImage.ee.vue b/packages/editor-ui/src/components/ExternalSecretsProviderImage.ee.vue new file mode 100644 index 0000000000..e70742a4a7 --- /dev/null +++ b/packages/editor-ui/src/components/ExternalSecretsProviderImage.ee.vue @@ -0,0 +1,28 @@ + + + diff --git a/packages/editor-ui/src/components/ExternalSecretsProviderModal.ee.vue b/packages/editor-ui/src/components/ExternalSecretsProviderModal.ee.vue new file mode 100644 index 0000000000..64c2d54d7b --- /dev/null +++ b/packages/editor-ui/src/components/ExternalSecretsProviderModal.ee.vue @@ -0,0 +1,331 @@ + + + + + + + diff --git a/packages/editor-ui/src/components/InlineExpressionEditor/InlineExpressionEditorInput.vue b/packages/editor-ui/src/components/InlineExpressionEditor/InlineExpressionEditorInput.vue index 902729dbe1..fc6434aa63 100644 --- a/packages/editor-ui/src/components/InlineExpressionEditor/InlineExpressionEditorInput.vue +++ b/packages/editor-ui/src/components/InlineExpressionEditor/InlineExpressionEditorInput.vue @@ -4,6 +4,7 @@ + + diff --git a/packages/editor-ui/src/views/__tests__/SettingsExternalSecrets.test.ts b/packages/editor-ui/src/views/__tests__/SettingsExternalSecrets.test.ts new file mode 100644 index 0000000000..d6969d5261 --- /dev/null +++ b/packages/editor-ui/src/views/__tests__/SettingsExternalSecrets.test.ts @@ -0,0 +1,60 @@ +import { createTestingPinia } from '@pinia/testing'; +import { merge } from 'lodash-es'; +import { EnterpriseEditionFeature, STORES } from '@/constants'; +import { SETTINGS_STORE_DEFAULT_STATE } from '@/__tests__/utils'; +import SettingsExternalSecrets from '@/views/SettingsExternalSecrets.vue'; +import { useExternalSecretsStore } from '@/stores/externalSecrets.ee.store'; +import { createComponentRenderer } from '@/__tests__/render'; +import { useSettingsStore } from '@/stores'; +import { setupServer } from '@/__tests__/server'; + +let pinia: ReturnType; +let externalSecretsStore: ReturnType; +let settingsStore: ReturnType; +let server: ReturnType; + +const renderComponent = createComponentRenderer(SettingsExternalSecrets); + +describe('SettingsExternalSecrets', () => { + beforeAll(() => { + server = setupServer(); + }); + + beforeEach(async () => { + pinia = createTestingPinia({ + initialState: { + [STORES.SETTINGS]: { + settings: merge({}, SETTINGS_STORE_DEFAULT_STATE.settings), + }, + }, + }); + externalSecretsStore = useExternalSecretsStore(pinia); + settingsStore = useSettingsStore(); + + await settingsStore.getSettings(); + }); + + afterEach(() => { + vi.clearAllMocks(); + }); + + afterAll(() => { + server.shutdown(); + }); + + it('should render paywall state when there is no license', () => { + const { getByTestId, queryByTestId } = renderComponent({ pinia }); + + expect(queryByTestId('external-secrets-content-licensed')).not.toBeInTheDocument(); + expect(getByTestId('external-secrets-content-unlicensed')).toBeInTheDocument(); + }); + + it('should render licensed content', () => { + settingsStore.settings.enterprise[EnterpriseEditionFeature.ExternalSecrets] = true; + + const { getByTestId, queryByTestId } = renderComponent({ pinia }); + + expect(getByTestId('external-secrets-content-licensed')).toBeInTheDocument(); + expect(queryByTestId('external-secrets-content-unlicensed')).not.toBeInTheDocument(); + }); +}); diff --git a/packages/nodes-base/test/nodes/Helpers.ts b/packages/nodes-base/test/nodes/Helpers.ts index c038f7621d..5e3e4a0c7b 100644 --- a/packages/nodes-base/test/nodes/Helpers.ts +++ b/packages/nodes-base/test/nodes/Helpers.ts @@ -123,6 +123,7 @@ export class CredentialsHelper extends ICredentialsHelper { } async getDecrypted( + additionalData: IWorkflowExecuteAdditionalData, nodeCredentials: INodeCredentialsDetails, type: string, ): Promise { diff --git a/packages/workflow/src/Expression.ts b/packages/workflow/src/Expression.ts index a99040b000..6d1ab313c9 100644 --- a/packages/workflow/src/Expression.ts +++ b/packages/workflow/src/Expression.ts @@ -2,6 +2,7 @@ import * as tmpl from '@n8n_io/riot-tmpl'; import { DateTime, Duration, Interval } from 'luxon'; import type { + IDataObject, IExecuteData, INode, INodeExecutionData, @@ -66,8 +67,8 @@ export class Expression { this.workflow = workflow; } - static resolveWithoutWorkflow(expression: string) { - return tmpl.tmpl(expression, {}); + static resolveWithoutWorkflow(expression: string, data: IDataObject = {}) { + return tmpl.tmpl(expression, data); } /** diff --git a/packages/workflow/src/Interfaces.ts b/packages/workflow/src/Interfaces.ts index cba00dbd34..84f142fa05 100644 --- a/packages/workflow/src/Interfaces.ts +++ b/packages/workflow/src/Interfaces.ts @@ -225,6 +225,7 @@ export abstract class ICredentialsHelper { ): Promise; abstract getDecrypted( + additionalData: IWorkflowExecuteAdditionalData, nodeCredentials: INodeCredentialsDetails, type: string, mode: WorkflowExecuteMode, @@ -1775,6 +1776,7 @@ export interface IWorkflowExecuteAdditionalData { executionTimeoutTimestamp?: number; userId: string; variables: IDataObject; + secretsHelpers: SecretsHelpersBase; } export type WorkflowExecuteMode = @@ -2185,6 +2187,7 @@ export interface IN8nUISettings { variables: boolean; sourceControl: boolean; auditLogs: boolean; + externalSecrets: boolean; showNonProdBanner: boolean; debugInEditor: boolean; }; @@ -2206,4 +2209,15 @@ export interface IN8nUISettings { }; } +export interface SecretsHelpersBase { + update(): Promise; + waitForInit(): Promise; + + getSecret(provider: string, name: string): IDataObject | undefined; + hasSecret(provider: string, name: string): boolean; + hasProvider(provider: string): boolean; + listProviders(): string[]; + listSecrets(provider: string): string[]; +} + export type BannerName = 'V1' | 'TRIAL_OVER' | 'TRIAL' | 'NON_PRODUCTION_LICENSE'; diff --git a/packages/workflow/src/index.ts b/packages/workflow/src/index.ts index f2a6ac66e6..7fe6de45dd 100644 --- a/packages/workflow/src/index.ts +++ b/packages/workflow/src/index.ts @@ -44,6 +44,7 @@ export { } from './type-guards'; export { ExpressionExtensions } from './Extensions'; +export * as ExpressionParser from './Extensions/ExpressionParser'; export { NativeMethods } from './NativeMethods'; export type { DocMetadata, NativeDoc } from './Extensions'; diff --git a/packages/workflow/test/Helpers.ts b/packages/workflow/test/Helpers.ts index ad2b8c64b7..fededf3777 100644 --- a/packages/workflow/test/Helpers.ts +++ b/packages/workflow/test/Helpers.ts @@ -125,6 +125,7 @@ export class CredentialsHelper extends ICredentialsHelper { } async getDecrypted( + additionalData: IWorkflowExecuteAdditionalData, nodeCredentials: INodeCredentialsDetails, type: string, ): Promise { diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 2277df9914..24d3216059 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -305,6 +305,9 @@ importers: handlebars: specifier: 4.7.7 version: 4.7.7 + infisical-node: + specifier: ^1.3.0 + version: 1.3.0 inquirer: specifier: ^7.0.1 version: 7.3.3 @@ -8218,6 +8221,16 @@ packages: transitivePeerDependencies: - debug + /axios@1.4.0: + resolution: {integrity: sha512-S4XCWMEmzvo64T9GfvQDOXgYRDJ/wsSZc7Jvdgx5u1sd0JwsuPLqb3SYmusag+edF6ziyMensPVqLTSc1PiSEA==} + dependencies: + follow-redirects: 1.15.2(debug@4.3.4) + form-data: 4.0.0 + proxy-from-env: 1.1.0 + transitivePeerDependencies: + - debug + dev: false + /babel-core@7.0.0-bridge.0(@babel/core@7.22.9): resolution: {integrity: sha512-poPX9mZH/5CSanm50Q+1toVci6pv5KSRv/5TWCwtzQS5XEwn40BcCrgIeMFWP9CKKIniKXNxoIOnOq4VVlGXhg==} peerDependencies: @@ -12918,6 +12931,17 @@ packages: dev: false optional: true + /infisical-node@1.3.0: + resolution: {integrity: sha512-tTnnExRAO/ZyqiRdnSlBisErNToYWgtunMWh+8opClEt5qjX7l6HC/b4oGo2AuR2Pf41IR+oqo+dzkM1TCvlUA==} + dependencies: + axios: 1.4.0 + dotenv: 16.0.3 + tweetnacl: 1.0.3 + tweetnacl-util: 0.15.1 + transitivePeerDependencies: + - debug + dev: false + /inflected@2.1.0: resolution: {integrity: sha512-hAEKNxvHf2Iq3H60oMBHkB4wl5jn3TPF3+fXek/sRwAB5gP9xWs4r7aweSF95f99HFoz69pnZTcu8f0SIHV18w==} dev: true @@ -20081,9 +20105,17 @@ packages: turbo-windows-arm64: 1.10.12 dev: true + /tweetnacl-util@0.15.1: + resolution: {integrity: sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==} + dev: false + /tweetnacl@0.14.5: resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} + /tweetnacl@1.0.3: + resolution: {integrity: sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==} + dev: false + /type-check@0.3.2: resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} engines: {node: '>= 0.8.0'}