feat: Add AER-256

Author: TheAlexLichter

README.md

@@ -56,6 +56,7 @@ console.log(rot('Hello world!'))
 - Wolfenbuetteler code
 - Multiplicative cipher
 - Affine
+- AER-256
 
 ## Contributing
 

docs/ciphers/aer256.md

@@ -0,0 +1,44 @@
+# AER-256
+
+> A widely unknown cipher, mostly seen on "underground" sites and forums.
+  Neither the origin nor the creator are known. It has large similarities
+  to [ARMON-64](./armon64.md).
+
+## Cipher behavior information
+
+* Case sensitive? ✓
+* Deterministic? ✓
+* Alphabet: ```!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ``` (All Unicode Characters using only 2 bytes (U+0000 - U+00FF)
+* Characters not in alphabet will: **throw an error**
+
+## Default options object
+
+```
+const options = {
+  key: '' // Must be at least 3 characters long!
+}
+```
+
+## Usage
+
+### Encoding
+
+#### Default
+
+```
+import aer256 from 'cipher-collection'
+
+
+console.log(aer256.encode('hey', { key: 'ABCDEF' })) // 1432.382960035134
+```
+
+### Decoding
+
+#### Default
+
+```
+import aer256 from 'cipher-collection'
+
+
+console.log(aer256.decode('1432.382960035134', { key: 'ABCDEF' })) // hey
+```

docs/index.md

@@ -18,4 +18,5 @@
 * [Wolfenbuetteler code](./ciphers/wolfenbuetteler.md)
 * [Multiplicative cipher](./ciphers/multiplicative.md)
 * [Affine](./ciphers/affine.md)
+* [AER-256](./ciphers/aer256.md)
 

src/aer256.js

@@ -0,0 +1,23 @@
+import aer256ArmonBase from './helpers/aerArmonBase'
+
+const encode = (input, options = {}) => {
+  options = { ...DEFAULT_OPTIONS, ...options }
+  options.isAer256 = true
+  return aer256ArmonBase.encode(input, options)
+}
+
+const decode = (input, options = {}) => {
+  options = { ...DEFAULT_OPTIONS, ...options }
+  options.isAer256 = true
+  return aer256ArmonBase.decode(input, options)
+}
+
+const DEFAULT_OPTIONS = {
+  key: '',
+  failOnUnknownCharacter: true
+}
+
+export default {
+  encode,
+  decode
+}

src/helpers/aerArmonBase.js

@@ -0,0 +1,83 @@
+const encode = (input, options) => {
+  if (options.key.length < 3) {
+    throw Error('Key is too short! It must be at least 3 characters')
+  }
+
+  const heyKey = [...options.key].map(reduceToHexCharCodeConcatenationNumber)
+
+  const chunkedString = input.match(new RegExp(`.{1,${Math.round(options.key.length / 2)}}`, 'g'))
+
+  const keyLengthRange = Array.from(new Array(options.key.length), (v, i) => i)
+
+  return chunkedString.map(s =>
+    keyLengthRange.reduce((acc, i) => {
+      switch (i % (options.isAer256 ? 3 : 4)) {
+        case 0:
+          acc += heyKey[i]
+          break
+        case 1:
+          acc /= heyKey[i]
+          break
+        case 2:
+          acc -= heyKey[i]
+          break
+        case 3:
+          acc *= 0.01 * heyKey[i]
+      }
+      return acc
+    }, reduceToHexCharCodeConcatenationNumber(s))
+  ).join(options.isAer256 ? ', ' : '+')
+}
+
+const decode = (input, options) => {
+  if (options.key.length < 3) {
+    throw Error('Key is too short! It must be at least 3 characters')
+  }
+
+  const hexKey = [...options.key].map(reduceToHexCharCodeConcatenationNumber)
+
+  const keyLengthRangeReversed = Array.from(new Array(options.key.length), (v, i) => i).reverse()
+
+  return input.split(options.isAer256 ? ', ' : '+').map(s => {
+    // Reverse arithmetic from encoding based on parsed float from string
+    const float = keyLengthRangeReversed.reduce((acc, i) => {
+      switch (i % (options.isAer256 ? 3 : 4)) {
+        case 0:
+          acc -= hexKey[i]
+          break
+        case 1:
+          acc *= hexKey[i]
+          break
+        case 2:
+          acc += hexKey[i]
+          break
+        case 3:
+          acc /= 0.01 * hexKey[i]
+      }
+      return acc
+    }, parseFloat(s))
+
+    // Round output and convert it to hex
+    return Math.round(float).toString(16)
+  })
+    .join('')
+    // Split up in hex groups of two again and unescape
+    .match(/.{1,2}/g).map(s => String.fromCharCode(parseInt(s, 16))).join('')
+}
+
+/**
+ * Map each character to hex representation of it's char code, join them together and then retrieve a decimal number
+ * out of the concatenated hex string.
+ */
+const reduceToHexCharCodeConcatenationNumber = c => parseInt([...c].map(x => {
+  const hexCharCode = x.charCodeAt(0).toString(16)
+  if (hexCharCode.length > 2) {
+    throw Error('Invalid character')
+  }
+  return hexCharCode
+}).join(''), 16)
+
+export default {
+  encode,
+  decode
+}

src/index.js

@@ -8,6 +8,7 @@ import base64 from './base64'
 import wolfenbuetteler from './wolfenbuetteler'
 import multiplicative from './multiplicative'
 import affine from './affine'
+import aer256 from './aer256'
 
 export default {
   rot,
@@ -19,5 +20,6 @@ export default {
   base64,
   wolfenbuetteler,
   multiplicative,
-  affine
+  affine,
+  aer256
 }

test/aer256.test.js

@@ -0,0 +1,31 @@
+import aer256 from 'aer256'
+
+describe('encoding', () => {
+  test('default', () => {
+    expect(() => { aer256.encode('1432.382960035134') }).toThrowError('Key is too short! It must be at least 3 characters')
+  })
+  test('with key', () => {
+    expect(aer256.encode('hey', { key: 'ABCDEF' })).toBe('1432.382960035134')
+    expect(aer256.encode('hey!*A', { key: 'ABCDEF*' })).toBe('384574.7097057532, -25.5959595959596')
+    expect(aer256.encode('hey!*A!Ü!Ü!Ü!', { key: 'ABCDEF*' })).toBe('384574.7097057532, 155639.92072902943,' +
+      ' 124713.95147123409, -27.963987703118136')
+    expect(aer256.encode('hey!*Aäää', { key: 'ABCDEF*' })).toBe('384574.7097057532, 155650.8842775582, -27.9211682037769')
+  })
+  test('invalid characters', () => {
+    expect(() => { aer256.encode('💯文', {key: 'ABCDEF*'}) }).toThrowError('Invalid character')
+  })
+})
+
+describe('decoding', () => {
+  test('default', () => {
+    expect(() => { aer256.decode('1432.382960035134') }).toThrowError('Key is too short! It must be at least 3 characters')
+  })
+  test('with key', () => {
+    expect(aer256.decode('1432.382960035134', { key: 'ABCDEF' })).toBe('hey')
+    expect(aer256.decode('384574.7097057532, -25.5959595959596', { key: 'ABCDEF*' })).toBe('hey!*A')
+    expect(aer256.decode('384574.7097057532, 155639.92072902943, 124713.95147123409, -27.963987703118136', { key: 'ABCDEF*' })).toBe('hey!*A!Ü!Ü!Ü!')
+    expect(aer256.decode('384574.7097057532, 155650.8842775582, -27.9211682037769', { key: 'ABCDEF*' })).toBe('hey!*Aäää')
+    // Fails because those characters have larger hex representations than "usual" characters
+    // expect(aer256.decode('796612.8594642073', { key: 'ABCDEF*' })).toBe('💯文')
+  })
+})