OK...I'm posting the algorithm, but not because mister high-strung above demands it. My apologies if my terminology isn't exactly "industry standard." I'm a newb to the field.

1. User Inputs (ASCII only):

a. Plaintext message ($M)

b. Password 1 ($P1)

i. Passwords greater than 64 bytes are rejected

c. Password 2 ($P2)

i. Passwords greater than 64 bytes are rejected

2. Key 1 Derivation ($K1)

a. Obtain base-10 salt ($P1S) from $P1 through a looped calculation: ($P1S + ($P1_{n}^{(v *2)}) where n = an integer representing the position in $P1 and v = an integer

i. initial values: n = 1 ; v = 2

ii. with each cycle, n and v are increased by 1; loop ends when n = length of $P1

b. Extract base-10 constant-lookup value ($P1L) from $P1S

i. $P1L = last two digits of $P1S

c. Salt $P1 with $P1S using addition modulo 10 per char of $P1; result: $P1T

d. Convert $P1T to Binary ; result: $P1B

e. Expand $P1B to 512 bits through a looped calculation: ($P1B & ($P1B shifted 1 bit to the left) ; XOR the result—bit by bit—with a 512-bit constant looked up from $P1L) ; result: $P1EK

f. Shift $P1EK in three cycles of two parts (result: $K1):

i. Part 1: XOR $P1EK bit by bit with the constant used looked up through $P1L

ii. Part 2: shift the result n bits to the left, where n = $P1L

3. Key 2 Derivation ($K2)

a. $K2 is derived in an identical manner as is $K1, with the exception that the various 512-bit constants used to derive $K2 are different than those used to derive $K1

4. Final Key Derivation ($K)

a. $K1 and $K2 are interleaved, bit by bit, to form a 1024-bit string ($S)—$K1 interleaves from back to front, $K2 interleaves from front to back

b. Extract base-10 constant-lookup value ($SL) from $S using the result ($C) of a looped calculation: ($C + ($S_{n[u]}^{(v *2)}) where n = an integer representing the position in $P1, u = number of digits modified and v = an integer

i. initial values: n = 1 ; u = 2 (fixed) ; v =1.01

ii. with each cycle, n is increased by 2 and v is increased by .01 ; loop ends when n + 2 > length of $S

iii. $SL = the last two digits of $C

c. Shift $S in three cycles of two parts (result: $K):

i. Part 1: XOR $S bit by bit with a looked-up 512-bit constant from $SL

ii. Part 2: shift the result n bits to the left, where n = $SL

5. Encryption ($Y) of Plaintext Message ($M)

a. Extract base-10 constant-lookup value ($TL) from $M using the result ($C) of a looped calculation: ($C + ($M_{n}^{(v *2)}) where n = an integer representing the position in $M and v = an integer

i. initial values: n = 1 ; v = 1.01

ii. with each cycle, n is increased by 1 and v is increased by .01 ; loop ends when n = length of $M

iii. $TL = the last two digits of $C

b. Convert $M to Binary ; result: $MB

c. Add padding to $MB until modulo 64 of $MB = 0 ; result: $MB

d. Convert $TL to binary and append to $MB ; result: $MB

e. XOR $MB bit by bit with a looked-up 512-bit constant from $TL ; result: $MX

f. XOR $MX bit by bit with $K ; result: $ME

i. if $MX is longer than $K, shift $K one bit to the left for each new cycle

g. Encode $ME in base-64 ; result: $M64

h. Add padding to $M64 until modulo 8 of $M64 = 0 ; result: $Y

Tweet This+ 1 thisPost To Linkedin