v1.5.0 Morse code

Author: sheepzh

src/locale/components/setting.js

@@ -13,7 +13,7 @@ module.exports = {
       remark: {
         1: 'Fixed and short',
         2: 'Random and short',
-        3: 'One natural language'
+        3: 'Morse code'
       }
     }
   },
@@ -31,7 +31,7 @@ module.exports = {
       remark: {
         1: '等长唯一',
         2: '等长随机',
-        3: '自然语言'
+        3: '摩斯码'
       }
     }
   },

src/locale/components/version.js

@@ -25,7 +25,7 @@ module.exports = {
     },
     "1_3_0": {
       "0": "Change the logo",
-      "1": "Support Ctrl+Q to quickly encrypt and decrypt the selected text"
+      "1": "Support Ctrl+, to quickly encrypt and decrypt the selected text"
     },
     "1_3_1": {
       "0": "Fix manual decription bug caused by FireFox's bug"
@@ -36,8 +36,9 @@ module.exports = {
     "1_4_1": {
       "0": "Optimize package size."
     },
-    "1_4_2": {
-      "0": "Fix bugs on www.tumblr.com"
+    "1_5_0": {
+      "0": "Support new ciphertext format: morse code",
+      "1": "Needn't refresh pages any more after settings changed"
     }
   },
   zh_CN: {
@@ -65,7 +66,7 @@ module.exports = {
       "1": "修复已知 bug"
     },
     "1_3_0": {
-      "0": "支持Ctrl+Q快捷加解密选中的明文/密文",
+      "0": "支持Ctrl+,快捷加解密选中的明文/密文",
       "1": "更改图标和 Logo"
     },
     "1_3_1": {
@@ -79,6 +80,10 @@ module.exports = {
     },
     "1_4_2": {
       "0": "修复 www.tumblr.com 上的一些 bug"
+    },
+    "1_5_0": {
+      "0": "支持新的密文风格：摩斯码",
+      "1": "修改设置信息后不用再刷新页面"
     }
   }
 }

src/zero/cryptor/algorithm/string-process.ts

@@ -0,0 +1,53 @@
+/**
+ * Translate string 2 unicode array 
+ */
+function toUnicodeArray(str: string): number[] {
+  const result: Array<number> = []
+  for (let i = 0; i < str.length; i++) {
+    result.push(str.charCodeAt(i))
+  }
+  return result
+}
+
+/**
+ * Translate the password 2 number
+ * 
+ * @param password 
+ * @returns number
+ */
+export function password2Number(password: string): number {
+  let pn: number = 0
+  toUnicodeArray(password).forEach((n: number) => pn ^= n)
+  return pn
+}
+
+function unicodes2Str(unicodes: number[]): string {
+  return unicodes.map(cn => String.fromCharCode(cn)).join("")
+}
+
+/**
+ * Ring with XOR
+ * 
+ * @param source source text
+ */
+export function ring(passwordNumber: number, source: string) {
+  return unicodes2Str(ringToUnicodes(passwordNumber, source))
+}
+
+/**
+ * Ring with XOR
+ * 
+ * @param source source text
+ */
+export function ringToUnicodes(passwordNumber: number, source: string): number[] {
+  return toUnicodeArray(source).map(mn => mn ^ passwordNumber)
+}
+
+/**
+ * Ring with XOR
+ * 
+ * @param source source text
+ */
+export function ringFromUnicodes(passwordNumber: number, source: number[]): string {
+  return unicodes2Str(source.map(mn => mn ^ passwordNumber))
+}

src/zero/cryptor/cryptor1.ts

@@ -1,5 +1,5 @@
 import { ICryptor } from '.'
-import { password2Number, toUnicodeArray } from './util'
+import { password2Number, ring } from './algorithm/string-process'
 
 /**
  * The first cryptor
@@ -23,13 +23,8 @@ export default class Cryptor1 implements ICryptor {
     return this.ring(cipher, password)
   }
 
-  /**
-   * Ring with XOR
-   * 
-   * @param msg msg
-   */
   private ring(msg: string, psw: string): string {
     const pn = password2Number(psw)
-    return toUnicodeArray(msg).map(mn => mn ^ pn).map(cn => String.fromCharCode(cn)).join("")
+    return ring(pn, msg)
   }
 }

src/zero/cryptor/cryptor2.ts

@@ -1,7 +1,6 @@
 import { ICryptor } from ".";
 import Cryptor1 from "./cryptor1";
-import Salt from "./salt";
-import { password2Number, toUnicodeArray } from "./util";
+import { password2Number, ring } from "./algorithm/string-process";
 
 /**
  * The second version of cryptor
@@ -23,26 +22,85 @@ export default class Cryptor2 extends Cryptor1 implements ICryptor {
   }
 
   encript(plain: string, password: string): string {
-    const charArr: Array<number> = toUnicodeArray(plain)
-
     let pn: number = password2Number(password)
     const salt: Salt = new Salt()
     salt.calcSalt(pn)
     pn = salt.getNewPn()
 
-    const cipher = charArr.map(value => value ^ pn).map(c => String.fromCharCode(c)).join("")
-    return salt.getPrefix() + cipher
+    const cipher = ring(pn, plain)
+    return String.fromCharCode(salt.getPrefixUnicode()) + cipher
   }
 
   decrypt(cipher: string, password: string): string {
     let pn: number = password2Number(password)
 
     const salt: Salt = new Salt()
-    salt.parseSalt(pn, cipher)
+    salt.parseSalt(pn, cipher.charCodeAt(0))
     pn = salt.getNewPn()
 
-    const charArr: Array<number> = toUnicodeArray(cipher.substring(1))
+    return ring(pn, cipher.substring(1))
+  }
+}
+
+
+/**
+ * Salt for ramdon cipher
+ * 
+ * @since 1.1.1
+ */
+class Salt {
+  private static ZERO_BASE = 0x4e00
+  private static MASK_SEGMENT = [7, 15, 31, 63, 127, 255]
+  private static ZH_LENGTH = 1 << 10 // = 1024
+
+  mask: number
+  salt: number
+  pn: number
+
+  /**
+   * Generate salt
+   * 
+   * @param pn 
+   */
+  calcSalt(pn: number): void {
+    this.pn = pn
+    this.calcMask()
+    while (!this.isValid()) {
+      this.circle()
+    }
+  }
+
+  parseSalt(pn: number, cipherSaltCode: number) {
+    this.pn = pn
+    this.calcMask()
+    this.salt = (cipherSaltCode - Salt.ZERO_BASE) * (this.mask + 1) / Salt.ZH_LENGTH
+  }
+
+  private isValid(): boolean {
+    return !!this.getNewPn()  // newPn != 0      
+  }
+
+  private circle() {
+    this.salt = new Date().getTime() & this.mask
+  }
+
+  private calcMask() {
+    let mask: number
+    for (let i = 0; i < Salt.MASK_SEGMENT.length; i++) {
+      mask = Salt.MASK_SEGMENT[i]
+      if (this.pn < mask) {
+        this.mask = mask
+        break
+      }
+    }
+    this.mask = mask
+  }
+
+  getNewPn(): number {
+    return this.pn + this.salt
+  }
 
-    return charArr.map(value => value ^ pn).map(c => String.fromCharCode(c)).join("")
+  getPrefixUnicode(): number {
+    return (this.salt * Salt.ZH_LENGTH / (this.mask + 1)) + Salt.ZERO_BASE
   }
 }

src/zero/cryptor/cryptor3.ts

@@ -1,22 +1,97 @@
 import { ICryptor } from "."
+import { password2Number, ringFromUnicodes, ringToUnicodes } from "./algorithm/string-process"
 
+const WORD_LEN_LEN = 4
 /**
  * 
  * The second version of cryptor with morse code
  * 
+ * Format:
+ * 4-digits-max-word-length + cipher
+ * 
  * @since 1.5.0
  */
 export default class Cryptor3 implements ICryptor {
+
   version(): number {
     return 3
   }
+
   prefix(): string {
-    return 'z03'
+    return '-'
   }
+
   encript(plain: string, password: string): string {
-    throw new Error("Method not implemented.")
+    let pn = password2Number(password)
+
+    const cipherUnicodes: number[] = ringToUnicodes(pn, plain)
+
+    const unicodeLength: number = this.maxUnicodeLength(cipherUnicodes)
+
+    return this.number2MorseCode(unicodeLength, WORD_LEN_LEN) + cipherUnicodes.map(unicode => this.number2MorseCode(unicode, unicodeLength)).join("")
   }
+
   decrypt(cipher: string, password: string): string {
-    throw new Error("Method not implemented.")
+    if (cipher.length < WORD_LEN_LEN) {
+      return cipher
+    }
+    const lenthMorse = cipher.substring(0, 4)
+    let length = this.morse2Number(lenthMorse)
+    if (length < 0) {
+      return cipher
+    }
+    if (length === 0) {
+      length = 16
+    }
+    const unicodes: number[] = []
+    for (let i = WORD_LEN_LEN; i + length <= cipher.length; i += length) {
+      const unicode = this.morse2Number(cipher.substr(i, length))
+      if (unicode === -1) {
+        return cipher
+      }
+      unicodes.push(unicode)
+    }
+    const pn = password2Number(password)
+    return ringFromUnicodes(pn, unicodes)
+  }
+
+  /**
+    * Translate unicode 2 morse code
+    * @param code unicode
+    * @returns the length of morse code
+    */
+  private number2MorseCode(code: number, length: number) {
+    let result = ''
+    for (let mask = 1 << (length - 1); mask > 0; mask >>= 1) {
+      result += (code & mask) ? '-' : '·'
+    }
+    return result
+  }
+
+  private morse2Number(morse: string) {
+    let result = 0
+    for (let i = 0; i < morse.length; i++) {
+      result <<= 1
+      const char = morse.charAt(i)
+      if (char === '-') {
+        result += 1
+      } else if (char !== '·') {
+        return -1
+      }
+    }
+    return result
+  }
+
+  private maxUnicodeLength(cipherUnicodes: number[]) {
+    let length = 1
+    let max = 1
+    cipherUnicodes.forEach(unicode => {
+      while (max < unicode) {
+        max <<= 1
+        max += 1
+        length++
+      }
+    })
+    return length
   }
 }

src/zero/cryptor/index.ts

@@ -1,6 +1,7 @@
 import cryptorConfig from "../cryptor-config"
 import Cryptor1 from './cryptor1'
 import Cryptor2 from './cryptor2'
+import Cryptor3 from "./cryptor3"
 
 /**
  * The set of cryptors with different version
@@ -15,7 +16,8 @@ class CryptorComposite {
 
   constructor() {
     this.register(new Cryptor1())
-    this.latest = this.register(new Cryptor2())
+    this.register(new Cryptor2())
+    this.latest = this.register(new Cryptor3())
   }
 
   private register(cryptor: ICryptor): ICryptor {