@things-factory/shell 10.1.31 → 10.1.34

package/tests/encrypt-transform.test.ts

@@ -0,0 +1,130 @@
+import { encryptTransformer, DecryptionFailed } from '../server/typeorm/encrypt-transform'
+
+/**
+ * Reading an encrypted column has to tell two failures apart.
+ *
+ * The transformer used to answer `null` whenever decryption threw. That folded together a value
+ * written before the column was encrypted (plaintext, perfectly fine) and a value that is
+ * ciphertext the key will not open (something is wrong). Both read as "there is no value", so a
+ * deployment with the wrong `dataEncryptionKey` looked like a system holding no credentials —
+ * rows intact, one line on the console, no row named and no count.
+ *
+ * It also blocked turning encryption on at all: every row written before the change would have
+ * gone blank on the next read.
+ */
+
+/** The shape `to` writes: 32 hex characters of IV, a colon, then hex of even length. */
+const CIPHERTEXT = /^[0-9a-f]{32}:(?:[0-9a-f]{2})+$/
+
+describe('writing an encrypted column', () => {
+  it('produces the iv:body shape', () => {
+    const stored = encryptTransformer.to('client-secret-value')
+
+    expect(stored).toMatch(CIPHERTEXT)
+    expect(stored).not.toContain('client-secret-value')
+  })
+
+  it('keeps nothing for an empty value', () => {
+    expect(encryptTransformer.to('')).toBeNull()
+    expect(encryptTransformer.to(null as any)).toBeNull()
+  })
+
+  it('writes a different string each time, so equal values do not look equal at rest', () => {
+    /* The IV is random per write. Without that, two rows holding the same secret would match. */
+    expect(encryptTransformer.to('same')).not.toEqual(encryptTransformer.to('same'))
+  })
+})
+
+describe('reading an encrypted column', () => {
+  it('round-trips what it wrote', () => {
+    expect(encryptTransformer.from(encryptTransformer.to('client-secret-value'))).toEqual('client-secret-value')
+  })
+
+  it('hands back a value written before the column was encrypted', () => {
+    /*
+     * ⚠ The case that makes turning encryption on possible at all. Every row already in the
+     * table is plaintext; if reading them answered null they would go blank on deploy.
+     */
+    expect(encryptTransformer.from('plain-client-secret')).toEqual('plain-client-secret')
+  })
+
+  it('hands back a JWT, which is what these columns actually hold', () => {
+    /*
+     * `Appliance.accessToken` and the shadow user's password hold signed JWTs. A JWT is dot
+     * separated and carries no colon, so it can never be mistaken for the ciphertext shape.
+     */
+    const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjEyMyIsInVzZXJUeXBlIjoiYXBwbGlhbmNlIn0.c2lnbmF0dXJl'
+
+    expect(encryptTransformer.from(token)).toEqual(token)
+  })
+
+  it('throws when the value is ciphertext and the key does not open it', () => {
+    /*
+     * ⚠ The case this file exists for. Answering null here is what made a wrong key look like an
+     * empty system. The row is still there; what is broken is the key.
+     */
+    const iv = 'a'.repeat(32)
+    const body = 'b'.repeat(64)
+
+    expect(() => encryptTransformer.from(`${iv}:${body}`)).toThrow(DecryptionFailed)
+  })
+
+  it('says in the message that the value still exists', () => {
+    /* Whoever reads the log has to know not to go re-issue credentials. */
+    const iv = 'a'.repeat(32)
+
+    expect(() => encryptTransformer.from(`${iv}:${'b'.repeat(64)}`)).toThrow(/still in the database/)
+  })
+
+  it('keeps nothing for an empty value', () => {
+    expect(encryptTransformer.from('')).toBeNull()
+    expect(encryptTransformer.from(null as any)).toBeNull()
+  })
+})
+
+describe('telling the two shapes apart', () => {
+  /*
+   * The split has to be exact in both directions: a plaintext value read as ciphertext throws on
+   * a perfectly good row, and a ciphertext value read as plaintext hands out the stored bytes.
+   */
+
+  it('does not take a colon alone for ciphertext', () => {
+    expect(encryptTransformer.from('host:5432')).toEqual('host:5432')
+    expect(encryptTransformer.from('Basic dXNlcjpwYXNz')).toEqual('Basic dXNlcjpwYXNz')
+  })
+
+  it('does not take hex of the wrong length for ciphertext', () => {
+    /* The IV is 16 bytes, so 32 hex characters and no other length. */
+    expect(encryptTransformer.from(`${'a'.repeat(31)}:${'b'.repeat(64)}`)).toEqual(
+      `${'a'.repeat(31)}:${'b'.repeat(64)}`
+    )
+    expect(encryptTransformer.from(`${'a'.repeat(33)}:${'b'.repeat(64)}`)).toEqual(
+      `${'a'.repeat(33)}:${'b'.repeat(64)}`
+    )
+  })
+
+  it('does not take an odd-length body for ciphertext', () => {
+    const odd = `${'a'.repeat(32)}:${'b'.repeat(63)}`
+
+    expect(encryptTransformer.from(odd)).toEqual(odd)
+  })
+
+  it('does not take uppercase hex for ciphertext', () => {
+    /* `to` writes lowercase. Something else wrote this, so it is not ours to decrypt. */
+    const upper = `${'A'.repeat(32)}:${'B'.repeat(64)}`
+
+    expect(encryptTransformer.from(upper)).toEqual(upper)
+  })
+
+  it('recognises its own output as ciphertext', () => {
+    /*
+     * The other direction of the same split, and the one that would silently hand out stored
+     * bytes if the pattern ever stopped matching what `to` writes.
+     */
+    const stored = encryptTransformer.to('secret')
+
+    expect(stored).toMatch(CIPHERTEXT)
+    expect(encryptTransformer.from(stored)).toEqual('secret')
+    expect(encryptTransformer.from(stored)).not.toEqual(stored)
+  })
+})