The new file format also produces more compact files—about 25% smaller.

Adds the optional ability to automatically delete the original item(s) after encryption/decryption.

A few minor improvements and bug fixes.

Important:

Scrambled files created with Scrambler 1.2 will not decrypt on older versions.

Descrambler users also have to upgrade to the newest version to decrypt the new file format. (Descrambler is a free “decrypt-only” version of Scrambler, available from the same developer.)

The new versions are, of course, able to decrypt the old file format.

Scrambler 1.1.8:

Sandbox support. This technology vastly improves app security and is now recommended by Apple for all Mac apps. For technical reasons, a consequence of this is that if you are currently using Scrambler’s “save in source folder” feature, you have to set it up again through Scrambler’s new Preferences window.

Various minor improvements.

Scrambler 1.1.6:

New icons and artwork that are compatible with the retina display.

Fixes a bug that in some cases caused an error during decryption.

Various underlying bug fixes.

Scrambler 1.1.4:

Fixes a bug that in some cases caused an error/crash during encryption.

Scrambler 1.1.2:

Fixes a bug that made it unable for some users to launch the app.

Some minor internal improvements.

Scrambler 1.1:

The file size limitation of 250 MB has been removed; users can now encrypt as large files as they want.

Adds a progress indicator that shows the percentage completion of the encryption/decryption.

Encryption and decryption can now be cancelled during progress.

Encryption and decryption are now dramatically more memory-efficient.

Fixes a bug that sometimes, in rare cases, made it impossible to decrypt scrambled files.

Fixes various other minor bugs.

The underlying codebase has been completely reworked to take full advantage of new technologies provided in OS X Lion. For the user, this results in a nice performance boost. For the developer, this provides a great foundation for further improvements.

ULTRA-TECHNICAL DETAILS

The first 16 bytes are the characters Scrambler0000001, obfuscated with each bit of each character inverted. (The obfuscation is done to discourage curious laypeople from modifying the file when they open it in a text editor.) The idea here is that if a new file format comes along, the count can be increased from 0000001 to 0000002.

The next 16 bytes consist of a random salt, which is generated fresh for each file.

Finally, all the remaining bytes consist of an encrypted tar.gz archive of the item(s) that the user wants to encrypt.

The archiving, key derivation, and encryption happen roughly as follows. (Since Scrambler shows a progress indicator, this actually happens in small chunks at a time, but you get the picture.)

The item/items that the user wants to encrypt is/are compressed into a tar.gz archive. This archive is designed to preserve OS X metadata of files, including extended attributes.

A random 16-byte salt is generated.

The user-provided password is converted to bytes using the UTF-8 encoding.

The salt and password are fed into the PBKDF2 key derivation function, which is set to use the HMAC-SHA512 pseudorandom function, and 50,000 iterations are performed to obtain 48 bytes of data. The first 32 bytes are used for the encryption key, and the other 16 bytes for the initialization vector.

The tar.gz archive data, encryption key, and initialization vector are fed into the AES-256-CBC encryption algorithm to produce the final encrypted data.

As mentioned above, the final scrambled file contains 16 bytes of obfuscated Scrambler0000001, followed by the 16-byte salt, followed by the final encrypted data.

Try using it to decrypt a scrambled file: Run ruby decrypt.rb file.scrambled file.tar.gz and type in the password. If this works, skip to step 8 below. You may, however, see an error about the missing function pbkdf2_hmac(). In this case, continue on to the next step.