For every 32bit word of input (read sequentially), 4 (possibly) different PRNGs are selected from the set. Four sequential key words chosen from the extended 1040-bytes key are used as seed for the 4 PRNGs, generating 4 new numbers. These four numbers are used to replace the four words of the key and to encrypt the input word in this way: the first two are xored together and the result is rotated by a certain amount that depends on the chosen PRNGs. The same is done for the 3rd and 4th word. The two resulting values are xored with the input word, together with another value that depends (again) on the 4 chosen PRNGs. To achieve higher security, the algorithm periodically regenerates the key and changes the PRNG selection function. (I know that all this sounds vague and confusing - read carefully the pseudo code below for a throughtful explanation)

The following technique is used to make the cipher resistant to chosen and known plaintext attacks, and to verify payload integrity: upon encryption an MD5 value ("uniqueID") is output before the actual ciphertext. If the plaintext comes from a file, this value is equal to MD5(MD5(plaintext)+key); if it comes from stdin, this value is set to 16 bytes read from "/dev/urandom". The actual base key used during encryption is MD5(key+uniqueID). By doing this, each bit of the key (and thus of the ciphertext) depends on the entire plaintext. Upon decryption, a check is made to verify that the uniqueID of the decrypted data matches the one included in the ciphertext. If the ciphertext is modified by an attacker, this check will fail. If the uniqueID comes from "/dev/urandom" then this check is skipped (...only in this version...it could be made by calculating MD5(MD5(plaintext)+key) on input stream EOF and by appending it at the end of the output stream...but I'm lazy! :-).

To be more precise, here is the detailed pseudo code of the encryption process.
(k[0..259] is the extended 1040 bytes key (1040 bytes=260 32bit ints))

• Compute command_line_key=MD5(command line key string)
• Compute uniqueID=MD5(MD5(input file)+command_line_key)
• Compute key[0..3]=MD5(command_line_key+uniqueID)
• While any of the 32bit words k[0..3] equals 0 --> key[0..3]=MD5(key+uniqueID)
• selector=key[0]^key[1]^key[2]^key[3]
• orig_key=key[0..3]
• Extend key from 16 bytes to 1040 bytes: repeat key[i..i+3]=MD5(orig_key+key[i-4..i-1]) for "i" ranging from 4 to 256, step 4.
• Using the same method, generate 81 more md5 sums (1296 bytes). Associate these bytes to the xorshift PRNGs (2 for each prng - a[0..647] and b[0..647])
• Shuffle the complete set of xorshift PRNGs, depending on the extendend key.
• Choose one of the 648 PRNGs as the function used to alter "selector" during encryption ("selrng")
• Choose koff = offset in key[0..255]
• Set keyptr=&key[0]
• While more data to process:
  • Read one block (possibly) of input data (consisting of 16384 or 1024 bytes, depending on the command line)
  • Repeat "rounds" times the following:
    • For each input 32bit word of the block:
      • Use the first byte of "selector" as an index in the shuffled PRNG array. Use the indexex PRNG to transform the key word koff[0]. Use the generated number to replace the key word, and annotate it.
      • Use second byte of "selector" as an index in the shuffled PRNG array+131. Use the indexex PRNG to transform the key word koff[1]. Use the generated number to replace the key word, and annotate it.
      • Use third byte of "selector" as an index in the shuffled PRNG array+261. Use the indexex PRNG to transform the key word koff[2]. Use the generated number to replace the key word, and annotate it.
      • Use last byte of "selector" as an index in the shuffled PRNG array+392. Use the indexex PRNG to transform the key word koff[3]. Use the generated number to replace the key word, and annotate it.
      • XOR the first two number together, rotate the result right by b[selector[2]]&31 bits
      • XOR the third and the fourth number together, rotate the result right by b[selector[3]]&31 bits
      • XOR the input word with these two rotated values
      • XOR the input word with another 32bit int formed by concatenating a[selector[0]] + a[selector[1]] + a[selector[2]] + a[selector[3]]
      • Output the result as encrypted/decrypted word
      • Update selector by running it through "selrng"
      • Update koff by xoring it with b[selector[0]] ^ b[selector[1]] ^ b[selector[2]] ^ b[selector[3]]
  • Output processed block
  • Regenerate 4 words of the key: Compute keyptr[0..3]=MD5(keyptr[0..3]+orig_key) until keyptr[0..3] does not contain null 32bit words
  • Reset selector: selector=keyptr[0]^keyptr[1]^keyptr[2]^keyptr[3]
  • keyptr += 4
  • Reset selrng and koff