Skip to content

A local-first personal finance app

Bank Sync Provider per budget file [1/3] - Sync server - Add file-scoped bank sync secrets (#8316)

lelemmb054e9a013d6
diff --git a/packages/sync-server/src/app-secrets.js b/packages/sync-server/src/app-secrets.js
index dc9b45551c..058197c91e 100644
--- a/packages/sync-server/src/app-secrets.js
+++ b/packages/sync-server/src/app-secrets.js
@@ -1,11 +1,13 @@
import express from 'express';
-import { getActiveLoginMethod, isAdmin } from './account-db';
+import { isAdmin } from './account-db';
import { SecretName, secretsService } from './services/secrets-service';
+import * as UserService from './services/user-service';
import {
requestLoggerMiddleware,
validateSessionMiddleware,
} from './util/middlewares';
+import { isValidFileId } from './util/paths';
const app = express();
@@ -14,24 +16,27 @@ app.use(express.json());
app.use(requestLoggerMiddleware);
app.use(validateSessionMiddleware);
-// In OpenID mode the secrets store is admin-managed; non-admins must be
-// blocked from both reads and writes, otherwise they can enumerate which
-// integrations are configured.
-function canManageSecrets(userId) {
- return getActiveLoginMethod() !== 'openid' || isAdmin(userId);
+// Global secrets are admin-managed.
+function canManageGlobalSecrets(userId) {
+ return isAdmin(userId);
}
-app.post('/', async (req, res) => {
- if (!canManageSecrets(res.locals.user_id)) {
- res.status(403).send({
- status: 'error',
- reason: 'not-admin',
- details: 'You have to be admin to set secrets',
- });
- return;
- }
+// Per-budget-file secrets are managed by file owners
+function isBudgetFileOwner(fileId, userId) {
+ const { granted } = UserService.checkFilePermission(fileId, userId) || {
+ granted: 0,
+ };
+ return granted > 0;
+}
+
+function canManagePerBudgetFileSecrets(fileId, userId) {
+ return isAdmin(userId) || isBudgetFileOwner(fileId, userId);
+}
+app.post('/', async (req, res) => {
const { name, value } = req.body || {};
+ const fileId = req.get('X-Actual-File-Id');
+ const perBudgetFile = fileId != null;
if (!(name in SecretName)) {
res.status(400).send({
@@ -42,28 +47,127 @@ app.post('/', async (req, res) => {
return;
}
- secretsService.set(name, value);
+ if (perBudgetFile) {
+ if (!isValidFileId(fileId)) {
+ res.status(400).send({
+ status: 'error',
+ reason: 'invalid-file-id',
+ details: 'invalid fileId',
+ });
+ return;
+ }
+
+ if (!canManagePerBudgetFileSecrets(fileId, res.locals.user_id)) {
+ res.status(403).send({
+ status: 'error',
+ reason: 'file-access-denied',
+ details: "You don't have permissions over this file",
+ });
+ return;
+ }
+ } else if (!canManageGlobalSecrets(res.locals.user_id)) {
+ res.status(403).send({
+ status: 'error',
+ reason: 'not-admin',
+ details: 'You have to be admin to manage global secrets',
+ });
+ return;
+ }
+
+ const secretFileId = perBudgetFile ? fileId : null;
+ secretsService.set(name, value, secretFileId);
res.status(200).send({ status: 'ok' });
});
-app.get('/:name', async (req, res) => {
- if (!canManageSecrets(res.locals.user_id)) {
+app.delete('/:name', async (req, res) => {
+ const name = req.params.name;
+ const fileId = req.get('X-Actual-File-Id');
+ const perBudgetFile = fileId != null;
+
+ if (!(name in SecretName)) {
+ res.status(404).send('key not found');
+ return;
+ }
+
+ if (!perBudgetFile) {
+ if (!canManageGlobalSecrets(res.locals.user_id)) {
+ res.status(403).send({
+ status: 'error',
+ reason: 'not-admin',
+ details: 'You have to be admin to manage global secrets',
+ });
+ return;
+ }
+
+ secretsService.reset(name);
+ res.status(200).send({ status: 'ok' });
+ return;
+ }
+
+ if (!isValidFileId(fileId)) {
+ res.status(400).send({
+ status: 'error',
+ reason: 'invalid-file-id',
+ details: 'invalid fileId',
+ });
+ return;
+ }
+
+ if (!canManagePerBudgetFileSecrets(fileId, res.locals.user_id)) {
res.status(403).send({
status: 'error',
- reason: 'not-admin',
- details: 'You have to be admin to read secrets',
+ reason: 'file-access-denied',
+ details: "You don't have permissions over this file",
});
return;
}
+ secretsService.reset(name, fileId);
+ res.status(200).send({ status: 'ok' });
+});
+
+app.get('/:name', async (req, res) => {
const name = req.params.name;
+ const fileId = req.get('X-Actual-File-Id');
+ const perBudgetFile = fileId != null;
+
if (!(name in SecretName)) {
res.status(404).send('key not found');
return;
}
- if (secretsService.exists(name)) {
+ if (!perBudgetFile) {
+ if (!canManageGlobalSecrets(res.locals.user_id)) {
+ res.status(403).send({
+ status: 'error',
+ reason: 'not-admin',
+ details: 'You have to be admin to manage global secrets',
+ });
+ return;
+ }
+ } else {
+ if (!isValidFileId(fileId)) {
+ res.status(400).send({
+ status: 'error',
+ reason: 'invalid-file-id',
+ details: 'invalid fileId',
+ });
+ return;
+ }
+
+ if (!canManagePerBudgetFileSecrets(fileId, res.locals.user_id)) {
+ res.status(403).send({
+ status: 'error',
+ reason: 'file-access-denied',
+ details: "You don't have permissions over this file",
+ });
+ return;
+ }
+ }
+
+ const keyExists = secretsService.exists(name, perBudgetFile ? fileId : null);
+ if (keyExists) {
res.sendStatus(204);
} else {
res.status(404).send('key not found');
diff --git a/packages/sync-server/src/secrets.test.js b/packages/sync-server/src/secrets.test.js
index 4197381f90..6e5f75d876 100644
--- a/packages/sync-server/src/secrets.test.js
+++ b/packages/sync-server/src/secrets.test.js
@@ -15,45 +15,134 @@ const enableOpenIdAuth = () => {
describe('secretsService', () => {
const testSecretName = SecretName.simplefin_token;
const testSecretValue = 'testValue';
+ const testFileId = 'test-file-id';
it('should set a secret', () => {
- const result = secretsService.set(testSecretName, testSecretValue);
+ const result = secretsService.set(
+ testSecretName,
+ testSecretValue,
+ testFileId,
+ );
expect(result).toBeDefined();
expect(result.changes).toBe(1);
+ expect(
+ getAccountDb().first('SELECT value FROM secrets WHERE name = ?', [
+ `${testSecretName}:${testFileId}`,
+ ])?.value,
+ ).toBe(testSecretValue);
});
it('should get a secret', () => {
- const result = secretsService.get(testSecretName);
+ const result = secretsService.get(testSecretName, testFileId);
expect(result).toBeDefined();
expect(result).toBe(testSecretValue);
});
it('should check if a secret exists', () => {
- const exists = secretsService.exists(testSecretName);
+ const exists = secretsService.exists(testSecretName, testFileId);
expect(exists).toBe(true);
- const nonExistent = secretsService.exists('nonExistentSecret');
+ const nonExistent = secretsService.exists('nonExistentSecret', testFileId);
expect(nonExistent).toBe(false);
});
it('should update a secret', () => {
const newValue = 'newValue';
- const setResult = secretsService.set(testSecretName, newValue);
+ const setResult = secretsService.set(testSecretName, newValue, testFileId);
expect(setResult).toBeDefined();
expect(setResult.changes).toBe(1);
- const getResult = secretsService.get(testSecretName);
+ const getResult = secretsService.get(testSecretName, testFileId);
expect(getResult).toBeDefined();
expect(getResult).toBe(newValue);
});
+ it('should keep global secrets compatible when fileId is missing', () => {
+ secretsService.set(testSecretName, 'global-value');
+
+ expect(secretsService.get(testSecretName)).toBe('global-value');
+ expect(secretsService.exists(testSecretName)).toBe(true);
+ expect(
+ getAccountDb().first('SELECT value FROM secrets WHERE name = ?', [
+ testSecretName,
+ ])?.value,
+ ).toBe('global-value');
+ });
+
+ it('should treat empty string secrets as existing', () => {
+ secretsService.set(testSecretName, '', testFileId);
+
+ expect(secretsService.get(testSecretName, testFileId)).toBe('');
+ expect(secretsService.exists(testSecretName, testFileId)).toBe(true);
+ });
+
+ describe('two-tier credentials', () => {
+ const fileAId = 'test-file-a';
+ const fileBId = 'test-file-b';
+
+ beforeEach(() => {
+ getAccountDb().mutate('DELETE FROM secrets WHERE name = ?', [
+ testSecretName,
+ ]);
+ secretsService.reset(testSecretName);
+ secretsService.reset(testSecretName, fileAId);
+ secretsService.reset(testSecretName, fileBId);
+ });
+
+ it('does not return global credentials when a budget file credential is missing', () => {
+ secretsService.set(testSecretName, 'global-value');
+
+ expect(secretsService.get(testSecretName, fileAId)).toBeNull();
+ });
+
+ it('returns budget file credentials for the requested scope', () => {
+ secretsService.set(testSecretName, 'global-value');
+ secretsService.set(testSecretName, 'file-value', fileAId);
+
+ expect(secretsService.get(testSecretName, fileAId)).toBe('file-value');
+ expect(
+ getAccountDb().first('SELECT value FROM secrets WHERE name = ?', [
+ `${testSecretName}:${fileAId}`,
+ ])?.value,
+ ).toBe('file-value');
+ });
+
+ it('keeps budget file credentials when global credentials are saved later', () => {
+ secretsService.set(testSecretName, 'file-value', fileAId);
+ secretsService.set(testSecretName, 'global-value');
+
+ expect(secretsService.get(testSecretName, fileAId)).toBe('file-value');
+ expect(secretsService.get(testSecretName, fileBId)).toBeNull();
+ expect(secretsService.get(testSecretName)).toBe('global-value');
+ });
+
+ it('resets only the scoped budget file credentials', () => {
+ secretsService.set(testSecretName, 'global-value');
+ secretsService.set(testSecretName, 'file-value', fileAId);
+
+ expect(secretsService.reset(testSecretName, fileAId).deletedFrom).toBe(
+ 'per-budget-file',
+ );
+ expect(secretsService.get(testSecretName, fileAId)).toBeNull();
+ expect(secretsService.get(testSecretName)).toBe('global-value');
+ });
+ });
+
describe('secrets api', () => {
+ beforeEach(() => {
+ getAccountDb().mutate('DELETE FROM secrets WHERE name = ?', [
+ testSecretName,
+ ]);
+ secretsService.reset(testSecretName);
+ secretsService.reset(testSecretName, testFileId);
+ });
+
afterEach(() => {
getAccountDb().mutate('DELETE FROM auth');
});
it('returns 401 if the user is not authenticated', async () => {
- secretsService.set(testSecretName, testSecretValue);
+ secretsService.set(testSecretName, testSecretValue, testFileId);
const res = await request(app).get(`/${testSecretName}`);
expect(res.statusCode).toEqual(401);
@@ -67,6 +156,7 @@ describe('secretsService', () => {
it('returns 404 if secret does not exist', async () => {
const res = await request(app)
.get(`/${SecretName.gocardless_secretKey}`)
+ .set('X-Actual-File-Id', 'test-file-id')
.set('x-actual-token', 'valid-token');
expect(res.statusCode).toEqual(404);
@@ -80,8 +170,9 @@ describe('secretsService', () => {
expect(res.statusCode).toEqual(404);
});
- it('returns 204 if secret exists', async () => {
+ it('returns 204 if global secret exists', async () => {
secretsService.set(testSecretName, testSecretValue);
+
const res = await request(app)
.get(`/${testSecretName}`)
.set('x-actual-token', 'valid-token');
@@ -89,16 +180,101 @@ describe('secretsService', () => {
expect(res.statusCode).toEqual(204);
});
+ it('returns 204 if budget file secret exists', async () => {
+ secretsService.set(testSecretName, testSecretValue, testFileId);
+ const res = await request(app)
+ .get(`/${testSecretName}`)
+ .set('X-Actual-File-Id', 'test-file-id')
+ .set('x-actual-token', 'valid-token');
+
+ expect(res.statusCode).toEqual(204);
+ });
+
+ it('returns 404 for global secrets when checking a budget file scope', async () => {
+ secretsService.set(testSecretName, testSecretValue);
+
+ const res = await request(app)
+ .get(`/${testSecretName}`)
+ .set('X-Actual-File-Id', testFileId)
+ .set('x-actual-token', 'valid-token');
+
+ expect(res.statusCode).toEqual(404);
+ });
+
it('returns 200 if secret was set', async () => {
const res = await request(app)
.post(`/`)
.set('x-actual-token', 'valid-token')
- .send({ name: testSecretName, value: testSecretValue });
+ .send({
+ name: testSecretName,
+ value: testSecretValue,
+ });
+
+ expect(res.statusCode).toEqual(200);
+ expect(res.body).toEqual({
+ status: 'ok',
+ });
+ });
+
+ it('DELETE resets budget file credentials', async () => {
+ secretsService.set(testSecretName, 'global-value');
+ secretsService.set(testSecretName, 'file-value', testFileId);
+
+ const res = await request(app)
+ .delete(`/${testSecretName}`)
+ .set('X-Actual-File-Id', testFileId)
+ .set('x-actual-token', 'valid-token');
+
+ expect(res.statusCode).toEqual(200);
+ expect(res.body).toEqual({
+ status: 'ok',
+ });
+ expect(secretsService.get(testSecretName, testFileId)).toBeNull();
+ expect(secretsService.get(testSecretName)).toBe('global-value');
+ });
+
+ it('DELETE resets global credentials', async () => {
+ secretsService.set(testSecretName, 'global-value');
+
+ const res = await request(app)
+ .delete(`/${testSecretName}`)
+ .set('x-actual-token', 'valid-token');
expect(res.statusCode).toEqual(200);
expect(res.body).toEqual({
status: 'ok',
});
+ expect(secretsService.get(testSecretName)).toBeNull();
+ });
+
+ it('POST returns 403 when a shared user tries to manage another user file credentials', async () => {
+ getAccountDb().mutate(
+ 'INSERT INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
+ ['shared-user-secret-file', 'genericAdmin'],
+ );
+ getAccountDb().mutate(
+ 'INSERT INTO user_access (file_id, user_id) VALUES (?, ?)',
+ ['shared-user-secret-file', 'genericUser'],
+ );
+
+ const res = await request(app)
+ .post('/')
+ .set('X-Actual-File-Id', 'shared-user-secret-file')
+ .set('x-actual-token', 'valid-token-user')
+ .send({
+ name: testSecretName,
+ value: testSecretValue,
+ });
+
+ expect(res.statusCode).toEqual(403);
+ expect(res.body).toEqual({
+ status: 'error',
+ reason: 'file-access-denied',
+ details: "You don't have permissions over this file",
+ });
+ expect(
+ secretsService.get(testSecretName, 'shared-user-secret-file'),
+ ).toBeNull();
});
it('POST returns 400 for unknown secret names', async () => {
@@ -118,49 +294,85 @@ describe('secretsService', () => {
describe('when OpenID is the active auth method', () => {
beforeEach(() => {
enableOpenIdAuth();
- secretsService.set(testSecretName, testSecretValue);
+ secretsService.set(testSecretName, testSecretValue, testFileId);
});
- it('GET returns 403 for non-admin users', async () => {
+ it('GET returns 403 when the user does not own the file', async () => {
const res = await request(app)
.get(`/${testSecretName}`)
+ .set('X-Actual-File-Id', 'test-file-id')
.set('x-actual-token', 'valid-token-user');
expect(res.statusCode).toEqual(403);
expect(res.body).toEqual({
status: 'error',
- reason: 'not-admin',
- details: 'You have to be admin to read secrets',
+ reason: 'file-access-denied',
+ details: "You don't have permissions over this file",
});
});
it('GET returns 204 for admin users when secret exists', async () => {
const res = await request(app)
.get(`/${testSecretName}`)
+ .set('X-Actual-File-Id', 'test-file-id')
.set('x-actual-token', 'valid-token-admin');
expect(res.statusCode).toEqual(204);
});
- it('POST returns 403 for non-admin users', async () => {
+ it('POST returns 200 for non-admin file owners setting per-budget credentials', async () => {
+ getAccountDb().mutate(
+ 'INSERT INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
+ ['owner-secret-file', 'genericUser'],
+ );
+
+ const res = await request(app)
+ .post('/')
+ .set('X-Actual-File-Id', 'owner-secret-file')
+ .set('x-actual-token', 'valid-token-user')
+ .send({
+ name: testSecretName,
+ value: testSecretValue,
+ });
+
+ expect(res.statusCode).toEqual(200);
+ expect(res.body).toEqual({ status: 'ok' });
+ expect(secretsService.get(testSecretName, 'owner-secret-file')).toBe(
+ testSecretValue,
+ );
+ });
+
+ it('POST returns 403 for non-admin file owners setting global credentials', async () => {
+ getAccountDb().mutate(
+ 'INSERT INTO files (id, deleted, owner) VALUES (?, FALSE, ?)',
+ ['owner-global-secret-file', 'genericUser'],
+ );
+
const res = await request(app)
.post('/')
.set('x-actual-token', 'valid-token-user')
- .send({ name: testSecretName, value: testSecretValue });
+ .send({
+ name: testSecretName,
+ value: testSecretValue,
+ });
expect(res.statusCode).toEqual(403);
expect(res.body).toEqual({
status: 'error',
reason: 'not-admin',
- details: 'You have to be admin to set secrets',
+ details: 'You have to be admin to manage global secrets',
});
+ expect(secretsService.get(testSecretName)).toBeNull();
});
it('POST returns 200 for admin users', async () => {
const res = await request(app)
.post('/')
.set('x-actual-token', 'valid-token-admin')
- .send({ name: testSecretName, value: 'newValue' });
+ .send({
+ name: testSecretName,
+ value: 'newValue',
+ });
expect(res.statusCode).toEqual(200);
expect(res.body).toEqual({ status: 'ok' });
diff --git a/packages/sync-server/src/services/secrets-service.js b/packages/sync-server/src/services/secrets-service.js
index 7ca7983fad..a7f0484b81 100644
--- a/packages/sync-server/src/services/secrets-service.js
+++ b/packages/sync-server/src/services/secrets-service.js
@@ -21,6 +21,10 @@ export const SecretName = {
enablebanking_secretKey: 'enablebanking_secretKey',
};
+function getSecretKey(name, fileId) {
+ return fileId == null ? name : `${name}:${fileId}`;
+}
+
class SecretsDb {
constructor() {
this.debug = createDebug('actual:secrets-db');
@@ -31,68 +35,85 @@ class SecretsDb {
return getAccountDb();
}
- set(name, value) {
+ set(name, value, fileId = null) {
if (!this.db) {
this.db = this.open();
}
+ const secretKey = getSecretKey(name, fileId);
this.debug(`setting secret '${name}' to '${value}'`);
- const result = this.db.mutate(
- `INSERT OR REPLACE INTO secrets (name, value) VALUES (?,?)`,
- [name, value],
+ return this.db.mutate(
+ `INSERT OR REPLACE INTO secrets (name, value) VALUES (?, ?)`,
+ [secretKey, value],
);
- return result;
}
- get(name) {
+ get(name, fileId = null) {
if (!this.db) {
this.db = this.open();
}
+ const secretKey = getSecretKey(name, fileId);
this.debug(`getting secret '${name}'`);
- const result = this.db.first(`SELECT value FROM secrets WHERE name =?`, [
- name,
+ return this.db.first(`SELECT value FROM secrets WHERE name = ?`, [
+ secretKey,
+ ]);
+ }
+
+ reset(name, fileId = null) {
+ if (!this.db) {
+ this.db = this.open();
+ }
+
+ const secretKey = getSecretKey(name, fileId);
+ const result = this.db.mutate(`DELETE FROM secrets WHERE name = ?`, [
+ secretKey,
]);
- return result;
+ return {
+ ...result,
+ deletedFrom: fileId == null ? 'global' : 'per-budget-file',
+ };
}
}
const secretsDb = new SecretsDb();
-const _cachedSecrets = new Map();
+
/**
* A service for managing secrets stored in `secretsDb`.
*/
export const secretsService = {
/**
- * Retrieves the value of a secret by name.
+ * Retrieves the active value of a secret by name.
* @param {SecretName} name - The name of the secret to retrieve.
+ * @param {string=} fileId - Budget file ID for this secret.
* @returns {string|null} The value of the secret, or null if the secret does not exist.
*/
- get: name => {
- return _cachedSecrets.get(name) ?? secretsDb.get(name)?.value ?? null;
+ get: (name, fileId = null) => {
+ return secretsDb.get(name, fileId)?.value ?? null;
},
/**
* Sets the value of a secret by name.
* @param {SecretName} name - The name of the secret to set.
* @param {string} value - The value to set for the secret.
+ * @param {string=} fileId - Budget file ID for this secret.
* @returns {Object}
*/
- set: (name, value) => {
- const result = secretsDb.set(name, value);
+ set: (name, value, fileId = null) => {
+ return secretsDb.set(name, value, fileId);
+ },
- if (result.changes === 1) {
- _cachedSecrets.set(name, value);
- }
- return result;
+ reset: (name, fileId = null) => {
+ return secretsDb.reset(name, fileId);
},
/**
* Determines whether a secret with the given name exists.
* @param {SecretName} name - The name of the secret to check for existence.
+ * @param {string=} fileId - Budget file ID for this secret.
* @returns {boolean} True if a secret with the given name exists, false otherwise.
*/
- exists: name => {
- return Boolean(secretsService.get(name));
+ exists: (name, fileId = null) => {
+ return secretsService.get(name, fileId) !== null;
},
};
diff --git a/upcoming-release-notes/8316.md b/upcoming-release-notes/8316.md
new file mode 100644
index 0000000000..7c58c6d6b3
--- /dev/null
+++ b/upcoming-release-notes/8316.md
@@ -0,0 +1,6 @@
+---
+category: Enhancements
+authors: [lelemm]
+---
+
+Allow bank sync credentials to be stored globally or for a specific budget file.