281 lines
8.9 KiB
JavaScript
281 lines
8.9 KiB
JavaScript
import { click, fillIn, find, currentURL, settled, visit } from '@ember/test-helpers';
|
|
import { module, test } from 'qunit';
|
|
import { setupApplicationTest } from 'ember-qunit';
|
|
import { encodeString } from 'vault/utils/b64';
|
|
import authPage from 'vault/tests/pages/auth';
|
|
import enablePage from 'vault/tests/pages/settings/mount-secret-backend';
|
|
|
|
let generateTransitKeys = async () => {
|
|
const ts = new Date().getTime();
|
|
const keys = [
|
|
{
|
|
name: `aes-${ts}`,
|
|
type: 'aes256-gcm96',
|
|
exportable: true,
|
|
supportsEncryption: true,
|
|
},
|
|
{
|
|
name: `aes-convergent-${ts}`,
|
|
type: 'aes256-gcm96',
|
|
convergent: true,
|
|
supportsEncryption: true,
|
|
},
|
|
{
|
|
name: `chacha-${ts}`,
|
|
type: 'chacha20-poly1305',
|
|
exportable: true,
|
|
supportsEncryption: true,
|
|
},
|
|
{
|
|
name: `chacha-convergent-${ts}`,
|
|
type: 'chacha20-poly1305',
|
|
convergent: true,
|
|
supportsEncryption: true,
|
|
},
|
|
{
|
|
name: `ecdsa-${ts}`,
|
|
type: 'ecdsa-p256',
|
|
exportable: true,
|
|
supportsSigning: true,
|
|
},
|
|
{
|
|
name: `ed25519-${ts}`,
|
|
type: 'ed25519',
|
|
derived: true,
|
|
supportsSigning: true,
|
|
},
|
|
{
|
|
name: `rsa-2048-${ts}`,
|
|
type: `rsa-2048`,
|
|
supportsSigning: true,
|
|
supportsEncryption: true,
|
|
},
|
|
{
|
|
name: `rsa-4096-${ts}`,
|
|
type: `rsa-4096`,
|
|
supportsSigning: true,
|
|
supportsEncryption: true,
|
|
},
|
|
];
|
|
|
|
for (let key of keys) {
|
|
await click('[data-test-secret-create]');
|
|
await fillIn('[data-test-transit-key-name]', key.name);
|
|
await fillIn('[data-test-transit-key-type]', key.type);
|
|
if (key.exportable) {
|
|
await click('[data-test-transit-key-exportable]');
|
|
}
|
|
if (key.derived) {
|
|
await click('[data-test-transit-key-derived]');
|
|
}
|
|
if (key.convergent) {
|
|
await click('[data-test-transit-key-convergent-encryption]');
|
|
}
|
|
await click('[data-test-transit-key-create]');
|
|
|
|
// link back to the list
|
|
await click('[data-test-secret-root-link]');
|
|
}
|
|
await settled();
|
|
return keys;
|
|
};
|
|
|
|
const testEncryption = async (assert, keyName) => {
|
|
const tests = [
|
|
// raw bytes for plaintext and context
|
|
{
|
|
plaintext: 'NaXud2QW7KjyK6Me9ggh+zmnCeBGdG93LQED49PtoOI=',
|
|
context: 'nqR8LiVgNh/lwO2rArJJE9F9DMhh0lKo4JX9DAAkCDw=',
|
|
encodePlaintext: false,
|
|
encodeContext: false,
|
|
decodeAfterDecrypt: false,
|
|
assertAfterEncrypt: key => {
|
|
assert.ok(
|
|
/vault:/.test(find('[data-test-transit-input="ciphertext"]').value),
|
|
`${key}: ciphertext shows a vault-prefixed ciphertext`
|
|
);
|
|
},
|
|
assertBeforeDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="context"]')
|
|
.hasValue(
|
|
'nqR8LiVgNh/lwO2rArJJE9F9DMhh0lKo4JX9DAAkCDw=',
|
|
`${key}: the ui shows the base64-encoded context`
|
|
);
|
|
},
|
|
|
|
assertAfterDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="plaintext"]')
|
|
.hasValue(
|
|
'NaXud2QW7KjyK6Me9ggh+zmnCeBGdG93LQED49PtoOI=',
|
|
`${key}: the ui shows the base64-encoded plaintext`
|
|
);
|
|
},
|
|
},
|
|
// raw bytes for plaintext, string for context
|
|
{
|
|
plaintext: 'NaXud2QW7KjyK6Me9ggh+zmnCeBGdG93LQED49PtoOI=',
|
|
context: encodeString('context'),
|
|
encodePlaintext: false,
|
|
encodeContext: false,
|
|
decodeAfterDecrypt: false,
|
|
assertAfterEncrypt: key => {
|
|
assert.ok(
|
|
/vault:/.test(find('[data-test-transit-input="ciphertext"]').value),
|
|
`${key}: ciphertext shows a vault-prefixed ciphertext`
|
|
);
|
|
},
|
|
assertBeforeDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="context"]')
|
|
.hasValue(encodeString('context'), `${key}: the ui shows the input context`);
|
|
},
|
|
assertAfterDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="plaintext"]')
|
|
.hasValue(
|
|
'NaXud2QW7KjyK6Me9ggh+zmnCeBGdG93LQED49PtoOI=',
|
|
`${key}: the ui shows the base64-encoded plaintext`
|
|
);
|
|
},
|
|
},
|
|
// base64 input
|
|
{
|
|
plaintext: encodeString('This is the secret'),
|
|
context: encodeString('context'),
|
|
encodePlaintext: false,
|
|
encodeContext: false,
|
|
decodeAfterDecrypt: true,
|
|
assertAfterEncrypt: key => {
|
|
assert.ok(
|
|
/vault:/.test(find('[data-test-transit-input="ciphertext"]').value),
|
|
`${key}: ciphertext shows a vault-prefixed ciphertext`
|
|
);
|
|
},
|
|
assertBeforeDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="context"]')
|
|
.hasValue(encodeString('context'), `${key}: the ui shows the input context`);
|
|
},
|
|
assertAfterDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="plaintext"]')
|
|
.hasValue('This is the secret', `${key}: the ui decodes plaintext`);
|
|
},
|
|
},
|
|
|
|
// string input
|
|
{
|
|
plaintext: 'There are many secrets 🤐',
|
|
context: 'secret 2',
|
|
encodePlaintext: true,
|
|
encodeContext: true,
|
|
decodeAfterDecrypt: true,
|
|
assertAfterEncrypt: key => {
|
|
assert.ok(find('[data-test-transit-input="ciphertext"]'), `${key}: ciphertext box shows`);
|
|
assert.ok(
|
|
/vault:/.test(find('[data-test-transit-input="ciphertext"]').value),
|
|
`${key}: ciphertext shows a vault-prefixed ciphertext`
|
|
);
|
|
},
|
|
assertBeforeDecrypt: key => {
|
|
assert
|
|
.dom('[data-test-transit-input="context"]')
|
|
.hasValue(encodeString('secret 2'), `${key}: the ui shows the encoded context`);
|
|
},
|
|
assertAfterDecrypt: key => {
|
|
assert.ok(find('[data-test-transit-input="plaintext"]'), `${key}: plaintext box shows`);
|
|
assert
|
|
.dom('[data-test-transit-input="plaintext"]')
|
|
.hasValue('There are many secrets 🤐', `${key}: the ui decodes plaintext`);
|
|
},
|
|
},
|
|
];
|
|
|
|
for (let testCase of tests) {
|
|
await click('[data-test-transit-action-link="encrypt"]');
|
|
await fillIn('[data-test-transit-input="plaintext"]', testCase.plaintext);
|
|
await fillIn('[data-test-transit-input="context"]', testCase.context);
|
|
if (testCase.encodePlaintext) {
|
|
await click('[data-test-transit-b64-toggle="plaintext"]');
|
|
}
|
|
if (testCase.encodeContext) {
|
|
await click('[data-test-transit-b64-toggle="context"]');
|
|
}
|
|
await click('[data-test-button-encrypt]');
|
|
if (testCase.assertAfterEncrypt) {
|
|
testCase.assertAfterEncrypt(keyName);
|
|
}
|
|
await click('[data-test-transit-action-link="decrypt"]');
|
|
if (testCase.assertBeforeDecrypt) {
|
|
testCase.assertBeforeDecrypt(keyName);
|
|
}
|
|
await click('[data-test-button-decrypt]');
|
|
|
|
if (testCase.assertAfterDecrypt) {
|
|
if (testCase.decodeAfterDecrypt) {
|
|
await click('[data-test-transit-b64-toggle="plaintext"]');
|
|
testCase.assertAfterDecrypt(keyName);
|
|
} else {
|
|
testCase.assertAfterDecrypt(keyName);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
module('Acceptance | transit', function(hooks) {
|
|
setupApplicationTest(hooks);
|
|
|
|
hooks.beforeEach(async function() {
|
|
await authPage.login();
|
|
const now = new Date().getTime();
|
|
hooks.transitPath = `transit-${now}`;
|
|
|
|
await enablePage.enable('transit', hooks.transitPath);
|
|
// create a bunch of different kinds of keys
|
|
hooks.transitKeys = await generateTransitKeys();
|
|
});
|
|
|
|
test('transit backend', async function(assert) {
|
|
assert.expect(47);
|
|
for (let [index, key] of hooks.transitKeys.entries()) {
|
|
await visit(`vault/secrets/${hooks.transitPath}/show/${key.name}`);
|
|
if (index === 0) {
|
|
await click('[data-test-transit-link="versions"]');
|
|
assert
|
|
.dom('[data-test-transit-key-version-row]')
|
|
.exists({ count: 1 }, `${key.name}: only one key version`);
|
|
await click('[data-test-transit-key-rotate] button');
|
|
await click('[data-test-confirm-button]');
|
|
assert
|
|
.dom('[data-test-transit-key-version-row]')
|
|
.exists({ count: 2 }, `${key.name}: two key versions after rotate`);
|
|
}
|
|
await click('[data-test-transit-key-actions-link]');
|
|
assert.ok(
|
|
currentURL().startsWith(`/vault/secrets/${hooks.transitPath}/actions/${key.name}`),
|
|
`${key.name}: navigates to tranist actions`
|
|
);
|
|
if (index === 0) {
|
|
assert.ok(
|
|
find('[data-test-transit-key-version-select]'),
|
|
`${key.name}: the rotated key allows you to select versions`
|
|
);
|
|
}
|
|
if (key.exportable) {
|
|
assert.ok(
|
|
find('[data-test-transit-action-link="export"]'),
|
|
`${key.name}: exportable key has a link to export action`
|
|
);
|
|
} else {
|
|
assert
|
|
.dom('[data-test-transit-action-link="export"]')
|
|
.doesNotExist(`${key.name}: non-exportable key does not link to export action`);
|
|
}
|
|
if (key.convergent && key.supportsEncryption) {
|
|
await testEncryption(assert, key.name);
|
|
}
|
|
}
|
|
});
|
|
});
|