Initial commit

2016-11-28 10:42:58 +00:00 · 2016-11-28 10:42:58 +00:00 · b1d73a725d
commit b1d73a725d
238 changed files with 105357 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,6 @@
+node_modules
+npm-debug.log
+build/dev
+docs/*
+!docs/*.conf.json
+!docs/*.ico
--- a/Gruntfile.js
+++ b/Gruntfile.js
@ -0,0 +1,444 @@
+module.exports = function(grunt) {
+    grunt.file.defaultEncoding = "utf8";
+    grunt.file.preserveBOM = false;
+    
+    // Tasks
+    grunt.registerTask("dev",
+        "A persistent task which creates a development build whenever source files are modified.",
+        ["clean:dev", "concat:css", "concat:js", "copy:html_dev", "copy:static_dev", "chmod:build", "watch"]);
+        
+    grunt.registerTask("prod",
+        "Creates a production-ready build. Use the --msg flag to add a compile message.",
+        ["jshint", "exec:stats", "clean", "jsdoc", "concat", "copy", "cssmin", "uglify:prod", "inline", "htmlmin", "chmod"]);
+        
+    grunt.registerTask("docs",
+        "Compiles documentation in the /docs directory.",
+        ["clean:docs", "jsdoc", "chmod:docs"]);
+    
+    grunt.registerTask("stats",
+        "Provides statistics about the code base such as how many lines there are as well as details of file sizes before and after compression.",
+        ["concat:js", "uglify:prod", "exec:stats", "exec:repo_size", "exec:display_stats"]);
+    
+    grunt.registerTask("default",
+        "Lints the code base and shows stats",
+        ["jshint", "exec:stats", "exec:display_stats"]);
+    
+    grunt.registerTask("doc", "docs");
+    grunt.registerTask("lint", "jshint");
+    
+    
+    // Load tasks provided by each plugin
+    grunt.loadNpmTasks("grunt-contrib-jshint");
+    grunt.loadNpmTasks("grunt-jsdoc");
+    grunt.loadNpmTasks("grunt-contrib-clean");
+    grunt.loadNpmTasks("grunt-contrib-concat");
+    grunt.loadNpmTasks("grunt-contrib-copy");
+    grunt.loadNpmTasks("grunt-contrib-uglify");
+    grunt.loadNpmTasks("grunt-contrib-cssmin");
+    grunt.loadNpmTasks("grunt-contrib-htmlmin");
+    grunt.loadNpmTasks("grunt-inline-alt");
+    grunt.loadNpmTasks("grunt-chmod");
+    grunt.loadNpmTasks("grunt-exec");
+    grunt.loadNpmTasks("grunt-contrib-watch");
+    
+    
+    // JS includes
+    var js_files = [
+        // Third party framework libraries
+        "src/js/lib/jquery-2.1.1.js",
+        "src/js/lib/bootstrap-3.3.6.js",
+        "src/js/lib/split.js",
+        "src/js/lib/bootstrap-switch.js",
+        "src/js/lib/yahoo.js",
+        "src/js/lib/snowfall.jquery.js",
+        
+        // Third party operation libraries
+        "src/js/lib/cryptojs/core.js",
+        "src/js/lib/cryptojs/x64-core.js",
+        "src/js/lib/cryptojs/enc-base64.js",
+        "src/js/lib/cryptojs/enc-utf16.js",
+        "src/js/lib/cryptojs/md5.js",
+        "src/js/lib/cryptojs/evpkdf.js",
+        "src/js/lib/cryptojs/cipher-core.js",
+        "src/js/lib/cryptojs/mode-cfb.js",
+        "src/js/lib/cryptojs/mode-ctr-gladman.js",
+        "src/js/lib/cryptojs/mode-ctr.js",
+        "src/js/lib/cryptojs/mode-ecb.js",
+        "src/js/lib/cryptojs/mode-ofb.js",
+        "src/js/lib/cryptojs/format-hex.js",
+        "src/js/lib/cryptojs/lib-typedarrays.js",
+        "src/js/lib/cryptojs/pad-ansix923.js",
+        "src/js/lib/cryptojs/pad-iso10126.js",
+        "src/js/lib/cryptojs/pad-iso97971.js",
+        "src/js/lib/cryptojs/pad-nopadding.js",
+        "src/js/lib/cryptojs/pad-zeropadding.js",
+        "src/js/lib/cryptojs/aes.js",
+        "src/js/lib/cryptojs/hmac.js",
+        "src/js/lib/cryptojs/rabbit-legacy.js",
+        "src/js/lib/cryptojs/rabbit.js",
+        "src/js/lib/cryptojs/ripemd160.js",
+        "src/js/lib/cryptojs/sha1.js",
+        "src/js/lib/cryptojs/sha256.js",
+        "src/js/lib/cryptojs/sha224.js",
+        "src/js/lib/cryptojs/sha512.js",
+        "src/js/lib/cryptojs/sha384.js",
+        "src/js/lib/cryptojs/sha3.js",
+        "src/js/lib/cryptojs/tripledes.js",
+        "src/js/lib/cryptojs/rc4.js",
+        "src/js/lib/cryptojs/pbkdf2.js",
+        "src/js/lib/jsbn/jsbn.js",
+        "src/js/lib/jsbn/jsbn2.js",
+        "src/js/lib/jsbn/base64.js",
+        "src/js/lib/jsbn/ec.js",
+        "src/js/lib/jsbn/prng4.js",
+        "src/js/lib/jsbn/rng.js",
+        "src/js/lib/jsbn/rsa.js",
+        "src/js/lib/jsbn/sec.js",
+        "src/js/lib/jsrasign/asn1-1.0.js",
+        "src/js/lib/jsrasign/asn1hex-1.1.js",
+        "src/js/lib/jsrasign/asn1x509-1.0.js",
+        "src/js/lib/jsrasign/base64x-1.1.js",
+        "src/js/lib/jsrasign/crypto-1.1.js",
+        "src/js/lib/jsrasign/dsa-modified-1.0.js",
+        "src/js/lib/jsrasign/ecdsa-modified-1.0.js",
+        "src/js/lib/jsrasign/ecparam-1.0.js",
+        "src/js/lib/jsrasign/keyutil-1.0.js",
+        "src/js/lib/jsrasign/x509-1.1.js",
+        "src/js/lib/blowfish.dojo.js",
+        "src/js/lib/rawdeflate.js",
+        "src/js/lib/rawinflate.js",
+        "src/js/lib/zip.js",
+        "src/js/lib/unzip.js",
+        "src/js/lib/zlib_and_gzip.js",
+        "src/js/lib/bzip2.js",
+        "src/js/lib/punycode.js",
+        "src/js/lib/uas_parser.js",
+        "src/js/lib/esprima.js",
+        "src/js/lib/escodegen.browser.js",
+        "src/js/lib/esmangle.min.js",
+        "src/js/lib/diff.js",
+        "src/js/lib/moment.js",
+        "src/js/lib/moment-timezone.js",
+        "src/js/lib/prettify.js",
+        "src/js/lib/vkbeautify.js",
+        "src/js/lib/Sortable.js",
+        "src/js/lib/bootstrap-colorpicker.js",
+        
+        // Custom libraries
+        "src/js/lib/canvas_components.js",
+        
+        // Utility functions
+        "src/js/core/Utils.js",
+        
+        // Operation objects
+        "src/js/operations/*.js",
+        
+        // Core framework objects
+        "src/js/core/*.js",
+        "src/js/config/Categories.js",
+        "src/js/config/OperationConfig.js",
+        
+        // HTML view objects
+        "src/js/views/html/*.js",
+        "!src/js/views/html/main.js",
+        
+        // Start the app!
+        "src/js/views/html/main.js",
+    ];
+
+    var banner = '/**\n\
+ * CyberChef - The Cyber Swiss Army Knife\n\
+ *\n\
+ * @copyright Crown Copyright 2016\n\
+ * @license Apache-2.0\n\
+ *\n\
+ *   Copyright 2016 Crown Copyright\n\
+ *\n\
+ * Licensed under the Apache License, Version 2.0 (the "License");\n\
+ * you may not use this file except in compliance with the License.\n\
+ * You may obtain a copy of the License at\n\
+ *\n\
+ *     http://www.apache.org/licenses/LICENSE-2.0\n\
+ *\n\
+ * Unless required by applicable law or agreed to in writing, software\n\
+ * distributed under the License is distributed on an "AS IS" BASIS,\n\
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
+ * See the License for the specific language governing permissions and\n\
+ * limitations under the License.\n\
+ */\n';
+
+    var template_options = {
+        data: {
+            compile_msg: grunt.option("compile-msg") || grunt.option("msg") || "",
+            codebase_stats: grunt.file.read("src/static/stats.txt").split("\n").join("<br>")
+        }
+    };
+    
+    // Project configuration
+    grunt.initConfig({
+        jshint: {
+            options: {
+                jshintrc: "src/js/.jshintrc"
+            },
+            gruntfile: ["Gruntfile.js"],
+            core: ["src/js/core/**/*.js"],
+            config: ["src/js/config/**/*.js"],
+            views: ["src/js/views/**/*.js"],
+            operations: ["src/js/operations/**/*.js"],
+        },
+        jsdoc: {
+            options: {
+                destination: "docs",
+                template: "node_modules/ink-docstrap/template",
+                recurse: true,
+                readme: "./README.md",
+                configure: "docs/jsdoc.conf.json"
+            },
+            all: {
+                src: [
+                    "src/js/**/*.js",
+                    "!src/js/lib/**/*",
+                ],
+            }
+        },
+        clean: {
+            dev: ["build/dev/*"],
+            prod: ["build/prod/*"],
+            docs: ["docs/*", "!docs/*.conf.json", "!docs/*.ico"],
+        },
+        concat: {
+            options: {
+                process: template_options
+            },
+            css: {
+                options: {
+                    banner: banner.replace(/\/\*\*/g, "/*!"),
+                    process: function(content, srcpath) {
+                        // Change special comments from /** to /*! to comply with cssmin
+                        content = content.replace(/^\/\*\* /g, "/*! ");
+                        return grunt.template.process(content);
+                    }
+                },
+                src: [
+                    "src/css/lib/**/*.css",
+                    "src/css/structure/**/*.css",
+                    "src/css/themes/classic.css"
+                ],
+                dest: "build/dev/styles.css"
+            },
+            js: {
+                options: {
+                    banner: '"use strict";\n'
+                },
+                src: js_files,
+                dest: "build/dev/scripts.js"
+            }
+        },
+        copy: {
+            html_dev: {
+                options: {
+                    process: function(content, srcpath) {
+                        return grunt.template.process(content, template_options);
+                    }
+                },
+                src: "src/html/index.html",
+                dest: "build/dev/index.html"
+            },
+            html_prod: {
+                options: {
+                    process: function(content, srcpath) {
+                        return grunt.template.process(content, template_options);
+                    }
+                },
+                src: "src/html/index.html",
+                dest: "build/prod/index.html"
+            },
+            html_inline: {
+                options: {
+                    process: function(content, srcpath) {
+                        // TODO: Do all this in Jade
+                        content = content.replace(
+                            '<a href="cyberchef.htm" style="float: left; margin-left: 10px; margin-right: 80px;">Download CyberChef<img src="images/cloud_computing_download-plain-24x24.png" /></a>',
+                            '<span style="float: left; margin-left: 10px;">Compile time: ' + grunt.template.today("dd/mm/yyyy HH:MM:ss") + ' UTC</span>');
+                        return grunt.template.process(content, template_options);
+                    }
+                },
+                src: "src/html/index.html",
+                dest: "build/prod/cyberchef.htm"
+            },
+            static_dev: {
+                files: [
+                    {
+                        expand: true,
+                        cwd: "src/static/",
+                        src: [
+                            "**/*",
+                            "**/.*",
+                            "!stats.txt"
+                        ],
+                        dest: "build/dev/"
+                    }
+                ]
+            },
+            static_prod: {
+                files: [
+                    {
+                        expand: true,
+                        cwd: "src/static/",
+                        src: [
+                            "**/*",
+                            "**/.*",
+                            "!stats.txt"
+                        ],
+                        dest: "build/prod/"
+                    }
+                ]
+            }
+        },
+        uglify: {
+            options: {
+                preserveComments: function(node, comment) {
+                    if (comment.value.indexOf("* @license") === 0) return true;
+                    return false;
+                },
+                screwIE8: true,
+                ASCIIOnly: true,
+                beautify: {
+                    beautify: false,
+                    inline_script: true,
+                    ascii_only: true,
+                    screw_ie8: true
+                },
+                compress: {
+                    screw_ie8: true
+                },
+                banner: banner
+            },
+            prod: {
+                src: "build/dev/scripts.js",
+                dest: "build/prod/scripts.js"
+            }
+        },
+        cssmin: {
+            prod: {
+                src: "build/dev/styles.css",
+                dest: "build/prod/styles.css"
+            }
+        },
+        htmlmin: {
+            prod: {
+                options: {
+                    removeComments: true,
+                    collapseWhitespace: true,
+                    minifyJS: true,
+                    minifyCSS: true
+                },
+                src: "build/prod/index.html",
+                dest: "build/prod/index.html"
+            },
+            inline: {
+                options: {
+                    removeComments: true,
+                    collapseWhitespace: true,
+                    minifyJS: false,
+                    minifyCSS: false
+                },
+                src: "build/prod/cyberchef.htm",
+                dest: "build/prod/cyberchef.htm"
+            }
+        },
+        inline: {
+            options: {
+                tag: "",
+                inlineTagAttributes: {
+                    js: "type='application/javascript'",
+                    css: "type='text/css'"
+                }
+            },
+            prod: {
+                src: "build/prod/cyberchef.htm",
+                dest: "build/prod/cyberchef.htm"
+            }
+        },
+        chmod: {
+            build: {
+                options: {
+                    mode: "755",
+                },
+                src: ["build/**/*", "build/**/.htaccess", "build/"]
+            },
+            docs: {
+                options: {
+                    mode: "755",
+                },
+                src: ["docs/**/*", "docs/"]
+            }
+        },
+        exec: {
+            repo_size: {
+                command: [
+                        "git ls-files | wc -l | xargs printf '\n%b\ttracked files\n'",
+                        "du -hs | egrep -o '^[^\t]*' | xargs printf '%b\trepository size\n'"
+                    ].join(";"),
+                stderr: false
+            },
+            stats: {
+                command: "rm src/static/stats.txt;" + 
+                    [
+                        "ls src/ -R1 | grep '^$' -v | grep ':$' -v | wc -l | xargs printf '%b\tsource files\n'",
+                        "find src/ -regex '.*\..*' -print | xargs cat | wc -l | xargs printf '%b\tlines\n'",
+                        "du -hs src/ | pcregrep -o '^[^\t]*' | xargs printf '%b\tsize\n'",
+
+                        "ls src/js/ -R1 | grep '\.js$' | wc -l | xargs printf '\n%b\tJavaScript source files\n'",
+                        "find src/js/ -regex '.*\.js' -print | xargs cat | wc -l | xargs printf '%b\tlines\n'",
+                        "find src/js/ -regex '.*\.js' -exec du -hcs {} \+ | tail -n1 | egrep -o '^[^\t]*' | xargs printf '%b\tsize\n'",
+
+                        "find src/js/ -regex '.*/lib/.*\.js' -print | wc -l | xargs printf '\n%b\tthird party JavaScript source files\n'",
+                        "find src/js/ -regex '.*/lib/.*\.js' -print | xargs cat | wc -l | xargs printf '%b\tlines\n'",
+                        "find src/js/ -regex '.*/lib/.*\.js' -exec du -hcs {} \+ | tail -n1 | egrep -o '^[^\t]*' | xargs printf '%b\tsize\n'",
+
+                        "find src/js/ -regex '.*\.js' -not -regex '.*/lib/.*' -print | wc -l | xargs printf '\n%b\tfirst party JavaScript source files\n'",
+                        "find src/js/ -regex '.*\.js' -not -regex '.*/lib/.*' -print | xargs cat | wc -l | xargs printf '%b\tlines\n'",
+                        "find src/js/ -regex '.*\.js' -not -regex '.*/lib/.*' -exec du -hcs {} \+ | tail -n1 | egrep -o '^[^\t]*' | xargs printf '%b\tsize\n'",
+
+                        "du build/dev/scripts.js -h | egrep -o '^[^\t]*' | xargs printf '\n%b\tuncompressed JavaScript size\n'",
+                        "du build/prod/scripts.js -h | egrep -o '^[^\t]*' | xargs printf '%b\tcompressed JavaScript size\n'",
+                        
+                        "grep -E '^\\s+name: ' src/js/config/Categories.js | wc -l | xargs printf '\n%b\tcategories\n'",
+                        "grep -E '^\\s+\"[A-Za-z0-9 \\-]+\": {' src/js/config/OperationConfig.js | wc -l | xargs printf '%b\toperations\n'",
+                        
+                    ].join(" >> src/static/stats.txt;") + " >> src/static/stats.txt;",
+                stderr: false
+            },
+            display_stats: {
+                command: "cat src/static/stats.txt"
+            },
+            clean_git: {
+                command: "git gc --prune=now --aggressive"
+            },
+        },
+        watch: {
+            css: {
+                files: "src/css/**/*.css",
+                tasks: ["concat:css", "chmod:build"]
+            },
+            js: {
+                files: "src/js/**/*.js",
+                tasks: ["concat:js_all", "chmod:build"]
+            },
+            html: {
+                files: "src/html/**/*.html",
+                tasks: ["copy:html_dev", "chmod:build"]
+            },
+            static: {
+                files: ["src/static/**/*", "src/static/**/.*"],
+                tasks: ["copy:static_dev", "chmod:build"]
+            },
+            grunt: {
+                files: "Gruntfile.js",
+                tasks: ["clean:dev", "concat:css", "concat:js_all", "copy:html_dev", "copy:static_dev", "chmod:build"]
+            }
+        },
+    });
+
+};
--- a/202
+++ b/202
@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/README.md
+++ b/README.md
@ -0,0 +1,89 @@
+# CyberChef
+
+####*The Cyber Swiss Army Knife*
+
+CyberChef is a simple, intuitive web app for carrying out all manner of "cyber" operations within a web browser. These operations include creating hexdumps, simple encoding like XOR or Base64, more complex encryption like AES, DES and Blowfish, data compression and decompression, calculating hashes and checksums, IPv6 and X.509 parsing, and much more.
+
+The tool is designed to enable both technical and non-technical analysts to manipulate data in complex ways without having to deal with complex tools or algorithms. It was conceived, designed, built and incrementally improved by an analyst in their 10% innovation time over several years. Every effort has been made to structure the code in a readable and extendable format, however it should be noted that the analyst is not a professional developer and the code has not been peer-reviewed for compliance with a formal specification.
+
+## Live demo
+
+CyberChef is still under active development. As a result, it shouldn't be considered a finished product. There is still testing and bug fixing to do, new features to be added and additional documentation to write. Please contribute!
+
+Cryptographic operations in CyberChef should not be relied upon to provide security in any situation. No guarantee is offered for their correctness.
+
+[A live demo can be found here][1] - have fun!
+Note: Use Chrome or Firefox, see the Browser Support section below for details.
+
+
+## How it works
+
+There are four main areas in CyberChef:
+
+ 1. The **input** box in the top right, where you can paste, type or drag the data you want to operate on.
+ 2. The **output** box in the bottom right, where the outcome of the specified processing will be displayed.
+ 3. The **operations** list on the far left, where you can find all the operations that CyberChef is capable of in categorised lists, or by searching.
+ 4. The **recipe** area in the middle, where you drag the operations that you want to use and specify arguments and options.
+
+You can use as many operations as you like in simple or complex ways. Some examples are as follows:
+
+ - [Decode a Base64-encoded string][2]
+ - [Convert a date and time to a different time zone][3]
+ - [Parse a Teredo IPv6 address][4]
+ - [Convert data from a hexdump, then decompress][5]
+ - [Display multiple timestamps as full dates][6]
+ - [Carry out different operations on data of different types][7]
+
+
+## Features
+
+ - Drag and drop
+     - Operations can be dragged in and out of the recipe list, or reorganised.
+     - Files can be dragged over the input box to load them directly.
+ - Auto Bake
+     - Whenever you modify the input or the recipe, CyberChef will automatically “bake” for you and produce the output immediately.
+     - This can be turned off and operated manually if it is affecting performance (if the input is very large, for instance).
+     - If any bake takes longer than 200 milliseconds, auto bake will be switched off automatically to prevent further performance issues.
+ - Breakpoints
+     - You can set breakpoints on any operation in your recipe to pause execution before running it.
+     - You can also step through the recipe one operation at a time to see what the data looks like at each stage.
+ - Save and load recipes
+     - If you come up with an awesome recipe that you know you’ll want to use again, just click save and add it to your local storage. It'll be waiting for you next time you visit CyberChef.
+     - You can also copy a URL which includes your recipe and input which can be shared with others.
+ - Search
+     - If you know the name of the operation you want or a word associated with it, start typing it into the search field and any matching operations will immediately be shown.
+ - Highlighting
+     - When you highlight text in the input or output, the offset and length values will be displayed and, if possible, the corresponding data will be highlighted in the output or input respectively (example: [highlight the word 'question' in the input to see where it appears in the output][8]).
+ - Save to file and load from file
+     - You can save the output to a file at any time or load a file by dragging and dropping it into the input field (note that files larger than about 500kb may cause your browser to hang or even crash due to the way that browsers handle large amounts of textual data).
+ - CyberChef is entirely client-side
+     - It should be noted that none of your input or recipe configuration is ever sent to the CyberChef web server - all processing is carried out within your browser, on your own computer.
+     - Due to this feature, CyberChef can be compiled into a single HTML file. You can download this file and drop it into a virtual machine, share it with other people, or use it independently on your desktop.
+
+
+## Browser support
+
+CyberChef works well in modern versions of Google Chrome and Mozilla Firefox.
+
+To aid in the efficient development of new features and operations, there has been no attempt to maintain support for any version of Microsoft Internet Explorer.
+
+Microsoft Edge is currently unsupported, but if anyone would like to contribute compatibility fixes, they would be appreciated.
+
+
+## Contributing
+
+An installation walkthrough, how-to guides for adding new operations, descriptions of the repository structure, available data types and coding conventions can all be found in the project [wiki pages](#### TO BE REPLACED ####).
+
+ - Sign the [GCHQ Contributor Licence Agreement](https://github.com/gchq/Gaffer/wiki/GCHQ-OSS-Contributor-License-Agreement-V1.0)
+ - Push your changes to your fork.
+ - Submit a pull request.
+
+
+  [1]: https://gchq.github.io/cyberchef
+  [2]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22From%20Base64%22%2C%22args%22%3A%5B%22A-Za-z0-9%2B%2F%3D%22%2Ctrue%5D%7D%5D&input=VTI4Z2JHOXVaeUJoYm1RZ2RHaGhibXR6SUdadmNpQmhiR3dnZEdobElHWnBjMmd1
+  [3]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22Translate%20DateTime%20Format%22%2C%22args%22%3A%5B%22Standard%20date%20and%20time%22%2C%22DD%2FMM%2FYYYY%20HH%3Amm%3Ass%22%2C%22UTC%22%2C%22dddd%20Do%20MMMM%20YYYY%20HH%3Amm%3Ass%20Z%20z%22%2C%22Australia%2FQueensland%22%5D%7D%5D&input=MTUvMDYvMjAxNSAyMDo0NTowMA
+  [4]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22Parse%20IPv6%20address%22%2C%22args%22%3A%5B%5D%7D%5D&input=MjAwMTowMDAwOjQxMzY6ZTM3ODo4MDAwOjYzYmY6M2ZmZjpmZGQy
+  [5]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22From%20Hexdump%22%2C%22args%22%3A%5B%5D%7D%2C%7B%22op%22%3A%22Gunzip%22%2C%22args%22%3A%5B%5D%7D%5D&input=MDAwMDAwMDAgIDFmIDhiIDA4IDAwIDEyIGJjIGYzIDU3IDAwIGZmIDBkIGM3IGMxIDA5IDAwIDIwICB8Li4uLi6881cu%2Fy7HwS4uIHwKMDAwMDAwMTAgIDA4IDA1IGQwIDU1IGZlIDA0IDJkIGQzIDA0IDFmIGNhIDhjIDQ0IDIxIDViIGZmICB8Li7QVf4uLdMuLsouRCFb%2F3wKMDAwMDAwMjAgIDYwIGM3IGQ3IDAzIDE2IGJlIDQwIDFmIDc4IDRhIDNmIDA5IDg5IDBiIDlhIDdkICB8YMfXLi6%2BQC54Sj8uLi4ufXwKMDAwMDAwMzAgIDRlIGM4IDRlIDZkIDA1IDFlIDAxIDhiIDRjIDI0IDAwIDAwIDAwICAgICAgICAgICB8TshObS4uLi5MJC4uLnw
+  [6]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22Fork%22%2C%22args%22%3A%5B%22%5C%5Cn%22%2C%22%5C%5Cn%22%5D%7D%2C%7B%22op%22%3A%22From%20UNIX%20Timestamp%22%2C%22args%22%3A%5B%22Seconds%20(s)%22%5D%7D%5D&input=OTc4MzQ2ODAwCjEwMTI2NTEyMDAKMTA0NjY5NjQwMAoxMDgxMDg3MjAwCjExMTUzMDUyMDAKMTE0OTYwOTYwMA
+  [7]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22Fork%22%2C%22args%22%3A%5B%22%5C%5Cn%22%2C%22%5C%5Cn%22%5D%7D%2C%7B%22op%22%3A%22Conditional%20Jump%22%2C%22args%22%3A%5B%221%22%2C%222%22%2C%2210%22%5D%7D%2C%7B%22op%22%3A%22To%20Hex%22%2C%22args%22%3A%5B%22Space%22%5D%7D%2C%7B%22op%22%3A%22Return%22%2C%22args%22%3A%5B%5D%7D%2C%7B%22op%22%3A%22To%20Base64%22%2C%22args%22%3A%5B%22A-Za-z0-9%2B%2F%3D%22%5D%7D%5D&input=U29tZSBkYXRhIHdpdGggYSAxIGluIGl0ClNvbWUgZGF0YSB3aXRoIGEgMiBpbiBpdA
+  [8]: https://gchq.github.io/cyberchef/?recipe=%5B%7B%22op%22%3A%22XOR%22%2C%22args%22%3A%5B%22de%20ad%20be%20ef%22%2C%22Hex%22%2Cfalse%2Cfalse%5D%7D%2C%7B%22op%22%3A%22To%20Hexdump%22%2C%22args%22%3A%5B%2216%22%2Cfalse%2Cfalse%5D%7D%5D&input=VGhlIGFuc3dlciB0byB0aGUgdWx0aW1hdGUgcXVlc3Rpb24gb2YgbGlmZSwgdGhlIFVuaXZlcnNlLCBhbmQgZXZlcnl0aGluZyBpcyA0Mi4
--- a/build/prod/.htaccess
+++ b/build/prod/.htaccess
@ -0,0 +1,50 @@
+# Serve up .htm files as binary files rather than text/html.
+# This allows cyberchef.htm to be downloaded rather than opened in the browser.
+AddType application/octet-stream .htm
+
+# Fix Apache bug #45023 where "-gzip" is appended to all ETags, preventing 304 responses
+<IfModule mod_headers.c>
+    RequestHeader edit "If-None-Match" "^\"(.*)-gzip\"$" "\"$1\""
+    Header edit "ETag" "^\"(.*[^g][^z][^i][^p])\"$" "\"$1-gzip\""
+</IfModule>
+
+# Set gzip compression on all resources that support it
+<IfModule mod_deflate.c>
+    SetOutputFilter DEFLATE
+</IfModule>
+
+# Set Expires headers on various resources
+<IfModule mod_expires.c>
+    ExpiresActive On
+    
+    # 10 minutes
+    ExpiresDefault "access plus 600 seconds"
+    
+    # 30 days
+    ExpiresByType image/x-icon "access plus 2592000 seconds"
+    ExpiresByType image/jpeg "access plus 2592000 seconds"
+    ExpiresByType image/png "access plus 2592000 seconds"
+    ExpiresByType image/gif "access plus 2592000 seconds"
+    
+    # 7 days
+    ExpiresByType text/css "access plus 604800 seconds"
+    ExpiresByType text/javascript "access plus 604800 seconds"
+    ExpiresByType application/javascript "access plus 604800 seconds"
+    ExpiresByType text/html "access plus 604800 seconds"
+</IfModule>
+
+# Set Cache-Control headers on various resources
+<IfModule mod_headers.c>
+    <FilesMatch "\\.(ico|jpe?g|png|gif)$">
+        Header set Cache-Control "max-age=2592000, public"
+    </FilesMatch>
+    <FilesMatch "\\.(css)$">
+        Header set Cache-Control "max-age=600, public"
+    </FilesMatch>
+    <FilesMatch "\\.(js)$">
+        Header set Cache-Control "max-age=600, private, must-revalidate"
+    </FilesMatch>
+    <FilesMatch "\\.(x?html?)$">
+        Header set Cache-Control "max-age=600, private, must-revalidate"
+    </FilesMatch>
+</IfModule>
--- a/build/prod/cyberchef.htm
+++ b/build/prod/cyberchef.htm
--- a/build/prod/images/breakpoint-16x16.png
+++ b/build/prod/images/breakpoint-16x16.png
--- a/build/prod/images/bug-16x16.png
+++ b/build/prod/images/bug-16x16.png
--- a/build/prod/images/clean-16x16.png
+++ b/build/prod/images/clean-16x16.png
--- a/build/prod/images/code-16x16.png
+++ b/build/prod/images/code-16x16.png
--- a/build/prod/images/cook_female-32x32.png
+++ b/build/prod/images/cook_female-32x32.png
--- a/build/prod/images/cook_male-32x32.png
+++ b/build/prod/images/cook_male-32x32.png
--- a/build/prod/images/cyberchef-128x128.png
+++ b/build/prod/images/cyberchef-128x128.png
--- a/build/prod/images/cyberchef-16x16.png
+++ b/build/prod/images/cyberchef-16x16.png
--- a/build/prod/images/cyberchef-256x256.png
+++ b/build/prod/images/cyberchef-256x256.png
--- a/build/prod/images/cyberchef-32x32.png
+++ b/build/prod/images/cyberchef-32x32.png
--- a/build/prod/images/cyberchef-512x512.png
+++ b/build/prod/images/cyberchef-512x512.png
--- a/build/prod/images/cyberchef-64x64.png
+++ b/build/prod/images/cyberchef-64x64.png
--- a/build/prod/images/disable_deselected-16x16.png
+++ b/build/prod/images/disable_deselected-16x16.png
--- a/build/prod/images/disable_selected-16x16.png
+++ b/build/prod/images/disable_selected-16x16.png
--- a/build/prod/images/download-24x24.png
+++ b/build/prod/images/download-24x24.png
--- a/build/prod/images/erase-16x16.png
+++ b/build/prod/images/erase-16x16.png
--- a/build/prod/images/favicon.ico
+++ b/build/prod/images/favicon.ico
--- a/build/prod/images/favourite-16x16.png
+++ b/build/prod/images/favourite-16x16.png
--- a/build/prod/images/favourite-24x24.png
+++ b/build/prod/images/favourite-24x24.png
--- a/build/prod/images/help-16x16.png
+++ b/build/prod/images/help-16x16.png
--- a/build/prod/images/help-22x22.png
+++ b/build/prod/images/help-22x22.png
--- a/build/prod/images/info-16x16.png
+++ b/build/prod/images/info-16x16.png
--- a/build/prod/images/layout-16x16.png
+++ b/build/prod/images/layout-16x16.png
--- a/build/prod/images/mail-16x16.png
+++ b/build/prod/images/mail-16x16.png
--- a/build/prod/images/open_yellow-16x16.png
+++ b/build/prod/images/open_yellow-16x16.png
--- a/build/prod/images/open_yellow-24x24.png
+++ b/build/prod/images/open_yellow-24x24.png
--- a/build/prod/images/recycle-16x16.png
+++ b/build/prod/images/recycle-16x16.png
--- a/build/prod/images/remove-16x16.png
+++ b/build/prod/images/remove-16x16.png
--- a/build/prod/images/save-16x16.png
+++ b/build/prod/images/save-16x16.png
--- a/build/prod/images/save-22x22.png
+++ b/build/prod/images/save-22x22.png
--- a/build/prod/images/save_as-16x16.png
+++ b/build/prod/images/save_as-16x16.png
--- a/build/prod/images/settings-22x22.png
+++ b/build/prod/images/settings-22x22.png
--- a/build/prod/images/speech-16x16.png
+++ b/build/prod/images/speech-16x16.png
--- a/build/prod/images/stats-16x16.png
+++ b/build/prod/images/stats-16x16.png
--- a/build/prod/images/step-16x16.png
+++ b/build/prod/images/step-16x16.png
--- a/build/prod/images/switch-16x16.png
+++ b/build/prod/images/switch-16x16.png
--- a/build/prod/images/thumb_down-16x16.png
+++ b/build/prod/images/thumb_down-16x16.png
--- a/build/prod/images/thumb_up-16x16.png
+++ b/build/prod/images/thumb_up-16x16.png
--- a/build/prod/images/undo-16x16.png
+++ b/build/prod/images/undo-16x16.png
--- a/build/prod/index.html
+++ b/build/prod/index.html
--- a/build/prod/scripts.js
+++ b/build/prod/scripts.js
--- a/build/prod/styles.css
+++ b/build/prod/styles.css
--- a/docs/favicon.ico
+++ b/docs/favicon.ico
--- a/docs/jsdoc.conf.json
+++ b/docs/jsdoc.conf.json
@ -0,0 +1,29 @@
+{
+    "tags": {
+        "allowUnknownTags": true
+    },
+    "plugins": ["plugins/markdown"],
+    "templates": {
+        "systemName": "CyberChef",
+        "footer": "",
+        "copyright": "&copy; Crown Copyright 2016",
+        "navType": "inline",
+        "theme": "cerulean",
+        "linenums": true,
+        "collapseSymbols": false,
+        "inverseNav": true,
+        "outputSourceFiles": true,
+        "outputSourcePath": true,
+        "dateFormat": "ddd MMM Do YYYY",
+        "sort": false,
+        "logoFile": "../build/prod/images/cyberchef-32x32.png",
+        "cleverLinks": false,
+        "monospaceLinks": false,
+        "protocol": "html://",
+        "methodHeadingReturns": false
+    },
+    "markdown": {
+        "parser": "gfm",
+        "hardwrap": true
+    }
+}
--- a/package.json
+++ b/package.json
@ -0,0 +1,47 @@
+{
+  "name": "cyberchef",
+  "version": "4.0.0",
+  "description": "CyberChef is a simple, intuitive web app for analysing and decoding data within a web browser.",
+  "author": "n1474335 <n1474335@gmail.com>",
+  "homepage": "https://gchq.github.io/cyberchef",
+  "copyright": "Crown copyright 2016",
+  "license": "Apache-2.0",
+  "keywords": [
+    "cipher",
+    "cypher",
+    "encode",
+    "decode",
+    "encrypt",
+    "decrypt",
+    "base64",
+    "xor",
+    "charset",
+    "hex",
+    "encoding",
+    "format",
+    "cybersecurity"
+  ],
+  "bugs": {
+    "email": ""
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "devDependencies": {
+    "grunt": "~0.4.5",
+    "grunt-chmod": "~1.1.1",
+    "grunt-contrib-clean": "~1.0.0",
+    "grunt-contrib-concat": "~1.0.0",
+    "grunt-contrib-copy": "~0.8.2",
+    "grunt-contrib-cssmin": "~0.14.0",
+    "grunt-contrib-htmlmin": "~0.6.0",
+    "grunt-contrib-jshint": "~1.0.0",
+    "grunt-contrib-uglify": "~0.11.1",
+    "grunt-contrib-watch": "~0.6.1",
+    "grunt-exec": "~0.4.6",
+    "grunt-inline-alt": "~0.3.10",
+    "grunt-jsdoc": "^1.1.0",
+    "ink-docstrap": "^1.1.4"
+  }
+}
--- a/src/css/lib/bootstrap-colorpicker.css
+++ b/src/css/lib/bootstrap-colorpicker.css
--- a/src/css/lib/bootstrap-switch.css
+++ b/src/css/lib/bootstrap-switch.css
@ -0,0 +1,221 @@
+/** @license
+========================================================================
+  bootstrap-switch - v3.1.0
+  http://www.bootstrap-switch.org
+  Copyright 2012-2013 Mattia Larentis
+ 
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+  http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+.bootstrap-switch {
+  display: inline-block;
+  cursor: pointer;
+  border-radius: 4px;
+  border: 1px solid;
+  border-color: #cccccc;
+  position: relative;
+  text-align: left;
+  overflow: hidden;
+  line-height: 8px;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  vertical-align: middle;
+  min-width: 100px;
+  -webkit-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
+  transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
+}
+.bootstrap-switch.bootstrap-switch-mini {
+  min-width: 71px;
+}
+.bootstrap-switch.bootstrap-switch-mini .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-mini .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-mini .bootstrap-switch-label {
+  padding-bottom: 4px;
+  padding-top: 4px;
+  font-size: 10px;
+  line-height: 9px;
+}
+.bootstrap-switch.bootstrap-switch-small {
+  min-width: 79px;
+}
+.bootstrap-switch.bootstrap-switch-small .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-small .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-small .bootstrap-switch-label {
+  padding-bottom: 3px;
+  padding-top: 3px;
+  font-size: 12px;
+  line-height: 18px;
+}
+.bootstrap-switch.bootstrap-switch-large {
+  min-width: 120px;
+}
+.bootstrap-switch.bootstrap-switch-large .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-large .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-large .bootstrap-switch-label {
+  padding-bottom: 9px;
+  padding-top: 9px;
+  font-size: 16px;
+  line-height: normal;
+}
+.bootstrap-switch.bootstrap-switch-disabled,
+.bootstrap-switch.bootstrap-switch-readonly,
+.bootstrap-switch.bootstrap-switch-indeterminate {
+  opacity: 0.5;
+  filter: alpha(opacity=50);
+  cursor: default !important;
+}
+.bootstrap-switch.bootstrap-switch-disabled .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-readonly .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-handle-on,
+.bootstrap-switch.bootstrap-switch-disabled .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-readonly .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-handle-off,
+.bootstrap-switch.bootstrap-switch-disabled .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-readonly .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-label {
+  cursor: default !important;
+}
+.bootstrap-switch.bootstrap-switch-animate .bootstrap-switch-container {
+  -webkit-transition: margin-left 0.5s;
+  transition: margin-left 0.5s;
+}
+.bootstrap-switch.bootstrap-switch-inverse .bootstrap-switch-handle-on {
+  border-bottom-left-radius: 0;
+  border-top-left-radius: 0;
+  border-bottom-right-radius: 3px;
+  border-top-right-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-inverse .bootstrap-switch-handle-off {
+  border-bottom-right-radius: 0;
+  border-top-right-radius: 0;
+  border-bottom-left-radius: 3px;
+  border-top-left-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-focused {
+  border-color: #66afe9;
+  outline: 0;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6);
+}
+.bootstrap-switch.bootstrap-switch-on .bootstrap-switch-container,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-off .bootstrap-switch-container {
+  margin-left: 0%;
+}
+.bootstrap-switch.bootstrap-switch-on .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-off .bootstrap-switch-label {
+  border-bottom-right-radius: 3px;
+  border-top-right-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-off .bootstrap-switch-container,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-on .bootstrap-switch-container {
+  margin-left: -50%;
+}
+.bootstrap-switch.bootstrap-switch-off .bootstrap-switch-label,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-on .bootstrap-switch-label {
+  border-bottom-left-radius: 3px;
+  border-top-left-radius: 3px;
+}
+.bootstrap-switch.bootstrap-switch-indeterminate .bootstrap-switch-container,
+.bootstrap-switch.bootstrap-switch-inverse.bootstrap-switch-indeterminate .bootstrap-switch-container {
+  margin-left: -25%;
+}
+.bootstrap-switch .bootstrap-switch-container {
+  display: inline-block;
+  width: 150%;
+  top: 0;
+  border-radius: 4px;
+  -webkit-transform: translate3d(0, 0, 0);
+  transform: translate3d(0, 0, 0);
+}
+.bootstrap-switch .bootstrap-switch-handle-on,
+.bootstrap-switch .bootstrap-switch-handle-off,
+.bootstrap-switch .bootstrap-switch-label {
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  cursor: pointer;
+  display: inline-block !important;
+  height: 100%;
+  padding-bottom: 4px;
+  padding-top: 4px;
+  font-size: 14px;
+  line-height: 20px;
+}
+.bootstrap-switch .bootstrap-switch-handle-on,
+.bootstrap-switch .bootstrap-switch-handle-off {
+  text-align: center;
+  z-index: 1;
+  width: 33.333333333%;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-primary,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-primary {
+  color: #fff;
+  background: #428bca;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-info,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-info {
+  color: #fff;
+  background: #5bc0de;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-success,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-success {
+  color: #fff;
+  background: #5cb85c;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-warning,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-warning {
+  background: #f0ad4e;
+  color: #fff;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-danger,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-danger {
+  color: #fff;
+  background: #d9534f;
+}
+.bootstrap-switch .bootstrap-switch-handle-on.bootstrap-switch-default,
+.bootstrap-switch .bootstrap-switch-handle-off.bootstrap-switch-default {
+  color: #000;
+  background: #eeeeee;
+}
+.bootstrap-switch .bootstrap-switch-label {
+  text-align: center;
+  margin-top: -1px;
+  margin-bottom: -1px;
+  z-index: 100;
+  width: 33.333333333%;
+  color: #333333;
+  background: #ffffff;
+}
+.bootstrap-switch .bootstrap-switch-handle-on {
+  border-bottom-left-radius: 3px;
+  border-top-left-radius: 3px;
+}
+.bootstrap-switch .bootstrap-switch-handle-off {
+  border-bottom-right-radius: 3px;
+  border-top-right-radius: 3px;
+}
+.bootstrap-switch input[type='radio'],
+.bootstrap-switch input[type='checkbox'] {
+  position: absolute !important;
+  top: 0;
+  left: 0;
+  opacity: 0;
+  filter: alpha(opacity=0);
+  z-index: -1;
+}
+.bootstrap-switch input[type='radio'].form-control,
+.bootstrap-switch input[type='checkbox'].form-control {
+  height: auto;
+}
--- a/src/css/lib/bootstrap3.min.css
+++ b/src/css/lib/bootstrap3.min.css
--- a/src/css/lib/jquery.splitter.css
+++ b/src/css/lib/jquery.splitter.css
@ -0,0 +1,58 @@
+/** @license
+========================================================================
+  StyleSheet for JQuery splitter Plugin
+  Copyright (C) 2010 Jakub Jankiewicz <http://jcubic.pl>
+ 
+  Same license as plugin
+*/
+.splitter_panel {
+  position: relative;
+}
+.splitter_panel .vsplitter {
+    background-color: grey;
+    cursor: col-resize;
+    z-index:900;
+    width: 4px;
+}
+
+.splitter_panel .hsplitter {
+    background-color: #5F5F5F;
+    cursor: row-resize;
+    z-index: 800;
+    height: 4px;
+}
+.splitter_panel .vsplitter.splitter-invisible,
+.splitter_panel .hsplitter.splitter-invisible {
+    background: none;
+}
+.splitter_panel .vsplitter, .splitter_panel .left_panel, .splitter_panel .right_panel,
+.splitter_panel .hsplitter, .splitter_panel .top_panel, .splitter_panel .bottom_panel {
+    position: absolute;
+    overflow: auto;
+}
+.splitter_panel .vsplitter, .splitter_panel .left_panel, .splitter_panel .right_panel {
+  height: 100%;
+}
+.splitter_panel .hsplitter, .splitter_panel .top_panel, .splitter_panel .bottom_panel {
+  width: 100%;
+}
+.splitter_panel .top_panel, .splitter_panel .left_panel, .splitter_panel .vsplitter {
+   top: 0;
+}
+.splitter_panel .top_panel, .splitter_panel .bottom_panel, .splitter_panel .left_panel, .splitter_panel .hsplitter {
+   left: 0;
+}
+.splitter_panel .bottom_panel {
+   bottom: 0;
+}
+.splitter_panel .right_panel {
+   right: 0;
+}
+.splitterMask {
+  position: absolute;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 1000;
+}
--- a/src/css/lib/prettify.css
+++ b/src/css/lib/prettify.css
@ -0,0 +1,68 @@
+/** @license
+========================================================================
+  StyleSheet for Google Code Prettify
+  Copyright (C) 2006 Google Inc.
+ 
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+       http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+/* SPAN elements with the classes below are added by prettyprint. */
+.pln { color: #000 }  /* plain text */
+
+@media screen {
+  .str { color: #080 }  /* string content */
+  .kwd { color: #008 }  /* a keyword */
+  .com { color: #800 }  /* a comment */
+  .typ { color: #606 }  /* a type name */
+  .lit { color: #066 }  /* a literal value */
+  /* punctuation, lisp open bracket, lisp close bracket */
+  .pun, .opn, .clo { color: #660 }
+  .tag { color: #008 }  /* a markup tag name */
+  .atn { color: #606 }  /* a markup attribute name */
+  .atv { color: #080 }  /* a markup attribute value */
+  .dec, .var { color: #606 }  /* a declaration; a variable name */
+  .fun { color: red }  /* a function name */
+}
+
+/* Use higher contrast and text-weight for printable form. */
+@media print, projection {
+  .str { color: #060 }
+  .kwd { color: #006; font-weight: bold }
+  .com { color: #600; font-style: italic }
+  .typ { color: #404; font-weight: bold }
+  .lit { color: #044 }
+  .pun, .opn, .clo { color: #440 }
+  .tag { color: #006; font-weight: bold }
+  .atn { color: #404 }
+  .atv { color: #060 }
+}
+
+/* Put a border around prettyprinted code snippets. */
+pre.prettyprint { padding: 2px; border: 1px solid #888 }
+
+/* Specify class=linenums on a pre to get line numbering */
+ol.linenums { margin-top: 0; margin-bottom: 0 } /* IE indents via margin-left */
+li.L0,
+li.L1,
+li.L2,
+li.L3,
+li.L5,
+li.L6,
+li.L7,
+li.L8 { list-style-type: none }
+/* Alternate shading for lines */
+li.L1,
+li.L3,
+li.L5,
+li.L7,
+li.L9 { background: #eee }
--- a/src/css/structure/layout.css
+++ b/src/css/structure/layout.css
--- a/src/css/structure/overrides.css
+++ b/src/css/structure/overrides.css
@ -0,0 +1,105 @@
+/* Bootstrap */
+
+button,
+a:focus {
+    outline: none;
+    -moz-outline-style: none;
+}
+
+.btn-default {
+    border-color: #ddd;
+}
+
+.btn-default:focus {
+    background-color: #fff;
+    border-color: #adadad;
+}
+
+.btn-default:hover,
+.btn-default:active {
+    background-color: #ebebeb;
+    border-color: #adadad;
+}
+
+.btn,
+.btn-lg,
+.nav-tabs>li>a,
+.form-control,
+.popover,
+.alert,
+.modal-content,
+.tooltip-inner,
+.dropdown-menu {
+    border-radius: 0 !important;
+}
+
+input[type="search"] {
+    -webkit-appearance: searchfield;
+    box-shadow: none;
+}
+
+input[type="search"]::-webkit-search-cancel-button {
+    -webkit-appearance: searchfield-cancel-button;
+}
+
+.modal {
+    overflow-y: auto;
+}
+
+.form-control {
+    background-color: transparent;
+}
+
+code {
+    border: 0;
+    white-space: pre-wrap;
+    font-family: Consolas, monospace;
+}
+
+pre {
+    border-radius: 0 !important;
+}
+
+blockquote {
+    font-size: inherit;
+}
+
+optgroup {
+    font-weight: bold;
+}
+
+.panel-body:before,
+.panel-body:after {
+    content: "";
+}
+
+
+/* Bootstrap-switch */
+
+.bootstrap-switch,
+.bootstrap-switch-container,
+.bootstrap-switch-handle-on,
+.bootstrap-switch-handle-off,
+.bootstrap-switch-label {
+    border-radius: 0 !important;
+}
+
+
+/* Sortable */
+
+.sortable-ghost {
+    opacity: 0.6;
+}
+
+
+/* Bootstrap Colorpicker */
+
+.colorpicker-element {
+    float: left;
+    margin-right: 15px;
+}
+
+.colorpicker-color,
+.colorpicker-color div {
+    height: 100px;
+}
--- a/src/css/structure/utils.css
+++ b/src/css/structure/utils.css
@ -0,0 +1,37 @@
+.word-wrap {
+    white-space: pre !important;
+    word-wrap: normal !important;
+    overflow-x: scroll !important;
+}
+
+.clearfix {
+    clear: both;
+    height: 0;
+}
+
+.blur {
+    color: transparent !important;
+    text-shadow: rgba(0, 0, 0, 0.95) 0 0 10px !important;
+}
+
+.no-select { 
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+.konami {
+    -ms-transform: rotate(180deg);
+    -webkit-transform: rotate(180deg);
+    transform: rotate(180deg);
+    -moz-transform: rotate(180deg);
+}
+
+.hl1, .hlyellow { background-color: #fff000; }
+.hl2, .hlblue   { background-color: #95dfff; }
+.hl3, .hlred    { background-color: #ffb6b6; } /* Half-Life 3 confirmed :O */
+.hl4, .hlorange { background-color: #fcf8e3; }
+.hl5, .hlgreen  { background-color: #8de768; }
--- a/src/css/themes/classic.css
+++ b/src/css/themes/classic.css
@ -0,0 +1,252 @@
+#banner {
+    border-bottom: 1px solid #ddd;
+}
+
+.title {
+    border-bottom: 1px solid #ddd;
+    font-weight: bold;
+    color: #424242;
+    background-color: #fafafa;
+}
+
+.gutter {
+    background-color: #eee;
+    background-repeat: no-repeat;
+    background-position: 50%;
+}
+
+.gutter.gutter-horizontal {
+    background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAAeCAYAAAAGos/EAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAlSURBVChTYzxz5sx/BiBgAhEgwPju3TtUEZZ79+6BGcNcDQMDACWJMFs4hNOSAAAAAElFTkSuQmCC');
+    cursor: ew-resize;
+}
+
+.gutter.gutter-vertical {
+    background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAACCAYAAABPJGxCAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACHDwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKL2lDQ1BJQ0MgUHJvZmlsZQAASMedlndUVNcWh8+9d3qhzTDSGXqTLjCA9C4gHQRRGGYGGMoAwwxNbIioQEQREQFFkKCAAaOhSKyIYiEoqGAPSBBQYjCKqKhkRtZKfHl57+Xl98e939pn73P32XuftS4AJE8fLi8FlgIgmSfgB3o401eFR9Cx/QAGeIABpgAwWempvkHuwUAkLzcXerrICfyL3gwBSPy+ZejpT6eD/0/SrFS+AADIX8TmbE46S8T5Ik7KFKSK7TMipsYkihlGiZkvSlDEcmKOW+Sln30W2VHM7GQeW8TinFPZyWwx94h4e4aQI2LER8QFGVxOpohvi1gzSZjMFfFbcWwyh5kOAIoktgs4rHgRm4iYxA8OdBHxcgBwpLgvOOYLFnCyBOJDuaSkZvO5cfECui5Lj25qbc2ge3IykzgCgaE/k5XI5LPpLinJqUxeNgCLZ/4sGXFt6aIiW5paW1oamhmZflGo/7r4NyXu7SK9CvjcM4jW94ftr/xS6gBgzIpqs+sPW8x+ADq2AiB3/w+b5iEAJEV9a7/xxXlo4nmJFwhSbYyNMzMzjbgclpG4oL/rfzr8DX3xPSPxdr+Xh+7KiWUKkwR0cd1YKUkpQj49PZXJ4tAN/zzE/zjwr/NYGsiJ5fA5PFFEqGjKuLw4Ubt5bK6Am8Kjc3n/qYn/MOxPWpxrkSj1nwA1yghI3aAC5Oc+gKIQARJ5UNz13/vmgw8F4psXpjqxOPefBf37rnCJ+JHOjfsc5xIYTGcJ+RmLa+JrCdCAACQBFcgDFaABdIEhMANWwBY4AjewAviBYBAO1gIWiAfJgA8yQS7YDApAEdgF9oJKUAPqQSNoASdABzgNLoDL4Dq4Ce6AB2AEjIPnYAa8AfMQBGEhMkSB5CFVSAsygMwgBmQPuUE+UCAUDkVDcRAPEkK50BaoCCqFKqFaqBH6FjoFXYCuQgPQPWgUmoJ+hd7DCEyCqbAyrA0bwwzYCfaGg+E1cBycBufA+fBOuAKug4/B7fAF+Dp8Bx6Bn8OzCECICA1RQwwRBuKC+CERSCzCRzYghUg5Uoe0IF1IL3ILGUGmkXcoDIqCoqMMUbYoT1QIioVKQ21AFaMqUUdR7age1C3UKGoG9QlNRiuhDdA2aC/0KnQcOhNdgC5HN6Db0JfQd9Dj6DcYDIaG0cFYYTwx4ZgEzDpMMeYAphVzHjOAGcPMYrFYeawB1g7rh2ViBdgC7H7sMew57CB2HPsWR8Sp4sxw7rgIHA+XhyvHNeHO4gZxE7h5vBReC2+D98Oz8dn4Enw9vgt/Az+OnydIE3QIdoRgQgJhM6GC0EK4RHhIeEUkEtWJ1sQAIpe4iVhBPE68QhwlviPJkPRJLqRIkpC0k3SEdJ50j/SKTCZrkx3JEWQBeSe5kXyR/Jj8VoIiYSThJcGW2ChRJdEuMSjxQhIvqSXpJLlWMkeyXPKk5A3JaSm8lLaUixRTaoNUldQpqWGpWWmKtKm0n3SydLF0k/RV6UkZrIy2jJsMWyZf5rDMRZkxCkLRoLhQWJQtlHrKJco4FUPVoXpRE6hF1G+o/dQZWRnZZbKhslmyVbJnZEdoCE2b5kVLopXQTtCGaO+XKC9xWsJZsmNJy5LBJXNyinKOchy5QrlWuTty7+Xp8m7yifK75TvkHymgFPQVAhQyFQ4qXFKYVqQq2iqyFAsVTyjeV4KV9JUCldYpHVbqU5pVVlH2UE5V3q98UXlahabiqJKgUqZyVmVKlaJqr8pVLVM9p/qMLkt3oifRK+g99Bk1JTVPNaFarVq/2ry6jnqIep56q/ojDYIGQyNWo0yjW2NGU1XTVzNXs1nzvhZei6EVr7VPq1drTltHO0x7m3aH9qSOnI6XTo5Os85DXbKug26abp3ubT2MHkMvUe+A3k19WN9CP16/Sv+GAWxgacA1OGAwsBS91Hopb2nd0mFDkqGTYYZhs+GoEc3IxyjPqMPohbGmcYTxbuNe408mFiZJJvUmD0xlTFeY5pl2mf5qpm/GMqsyu21ONnc332jeaf5ymcEyzrKDy+5aUCx8LbZZdFt8tLSy5Fu2WE5ZaVpFW1VbDTOoDH9GMeOKNdra2Xqj9WnrdzaWNgKbEza/2BraJto22U4u11nOWV6/fMxO3Y5pV2s3Yk+3j7Y/ZD/ioObAdKhzeOKo4ch2bHCccNJzSnA65vTC2cSZ79zmPOdi47Le5bwr4urhWuja7ybjFuJW6fbYXd09zr3ZfcbDwmOdx3lPtKe3527PYS9lL5ZXo9fMCqsV61f0eJO8g7wrvZ/46Pvwfbp8Yd8Vvnt8H67UWslb2eEH/Lz89vg98tfxT/P/PgAT4B9QFfA00DQwN7A3iBIUFdQU9CbYObgk+EGIbogwpDtUMjQytDF0Lsw1rDRsZJXxqvWrrocrhHPDOyOwEaERDRGzq91W7109HmkRWRA5tEZnTdaaq2sV1iatPRMlGcWMOhmNjg6Lbor+wPRj1jFnY7xiqmNmWC6sfaznbEd2GXuKY8cp5UzE2sWWxk7G2cXtiZuKd4gvj5/munAruS8TPBNqEuYS/RKPJC4khSW1JuOSo5NP8WR4ibyeFJWUrJSBVIPUgtSRNJu0vWkzfG9+QzqUvia9U0AV/Uz1CXWFW4WjGfYZVRlvM0MzT2ZJZ/Gy+rL1s3dkT+S453y9DrWOta47Vy13c+7oeqf1tRugDTEbujdqbMzfOL7JY9PRzYTNiZt/yDPJK817vSVsS1e+cv6m/LGtHlubCyQK+AXD22y31WxHbedu799hvmP/jk+F7MJrRSZF5UUfilnF174y/ariq4WdsTv7SyxLDu7C7OLtGtrtsPtoqXRpTunYHt897WX0ssKy13uj9l4tX1Zes4+wT7hvpMKnonO/5v5d+z9UxlfeqXKuaq1Wqt5RPXeAfWDwoOPBlhrlmqKa94e4h+7WetS212nXlR/GHM44/LQ+tL73a8bXjQ0KDUUNH4/wjowcDTza02jV2Nik1FTSDDcLm6eORR67+Y3rN50thi21rbTWouPguPD4s2+jvx064X2i+yTjZMt3Wt9Vt1HaCtuh9uz2mY74jpHO8M6BUytOdXfZdrV9b/T9kdNqp6vOyJ4pOUs4m3924VzOudnzqeenL8RdGOuO6n5wcdXF2z0BPf2XvC9duex++WKvU++5K3ZXTl+1uXrqGuNax3XL6+19Fn1tP1j80NZv2d9+w+pG503rm10DywfODjoMXrjleuvyba/b1++svDMwFDJ0dzhyeOQu++7kvaR7L+9n3J9/sOkh+mHhI6lH5Y+VHtf9qPdj64jlyJlR19G+J0FPHoyxxp7/lP7Th/H8p+Sn5ROqE42TZpOnp9ynbj5b/Wz8eerz+emCn6V/rn6h++K7Xxx/6ZtZNTP+kv9y4dfiV/Kvjrxe9rp71n/28ZvkN/NzhW/l3x59x3jX+z7s/cR85gfsh4qPeh+7Pnl/eriQvLDwG/eE8/s3BCkeAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAI0lEQVQYV2M8c+bMfwYgUFJSAlEM9+7dA9O05jOBSboDBgYAtPcYZ1oUA30AAAAASUVORK5CYII=');
+    cursor: ns-resize;
+}
+
+.operation {
+    border: 1px solid #999;
+    border-top-width: 0;
+}
+
+.op_list .operation { /*blue*/
+    color: #3a87ad;
+    background-color: #d9edf7;
+    border-color: #bce8f1;
+}
+
+#rec_list .operation { /*green*/
+    color: #468847;
+    background-color: #dff0d8;
+    border-color: #d6e9c6;
+}
+
+#controls {
+    border-top: 1px solid #ddd;
+    background-color: #fafafa;
+}
+
+.textarea-wrapper textarea,
+.textarea-wrapper div {
+    font-family: Consolas, monospace;
+    font-size: inherit;
+}
+
+.io-info {
+    font-family: Consolas, monospace;
+    font-weight: normal;
+    font-size: 8pt;
+}
+
+.arg-title {
+    font-weight: bold;
+}
+
+.arg-input {
+    height: 34px;
+    font-size: 15px;
+    line-height: 1.428571429;
+    color: #424242;
+    background-color: #fff;
+    border: 1px solid #ddd;
+    font-family: Consolas, monospace;
+}
+
+select {
+    padding: 6px 8px;
+    height: 34px;
+    border: 1px solid #ddd;
+    background-color: #fff;
+    color: #424242;
+}
+
+.arg[disabled] {
+    background-color: #eee;
+}
+
+textarea.arg {
+    color: #424242;
+    font-family: Consolas, monospace;
+}
+
+.break {
+    color: #b94a48 !important;
+    background-color: #f2dede !important;
+    border-color: #eed3d7 !important;
+}
+
+.category-title {
+    background-color: #fafafa;
+    border-bottom: 1px solid #eee;
+    font-weight: bold;
+}
+
+.category-title[href='#catFavourites'] {
+    border-bottom-color: #ddd;
+}
+
+.category-title[aria-expanded=true] {
+    border-bottom-color: #ddd;
+}
+
+.category-title.collapsed {
+    border-bottom-color: #eee;
+}
+
+.category-title:hover {
+    color: #3a87ad;
+}
+
+#search {
+    border-bottom: 1px solid #e3e3e3;
+}
+
+.dropping-file {
+    border: 5px dashed #3a87ad !important;
+}
+
+.selected-op {
+    color: #c09853 !important;
+    background-color: #fcf8e3 !important;
+    border-color: #fbeed5 !important;
+}
+
+.option-item input[type=number] {
+    font-size: 14px;
+    line-height: 1.428571429;
+    color: #555;
+    background-color: #fff;
+    border: 1px solid #ccc;
+}
+
+.favourites-hover {
+    color: #468847;
+    background-color: #dff0d8;
+    border: 2px dashed #468847 !important;
+    padding: 8px 8px 9px 8px;
+}
+
+#edit-favourites-list {
+    border: 1px solid #bce8f1;
+}
+
+#edit-favourites-list .operation {
+    border-left: none;
+    border-right: none;
+}
+
+#edit-favourites-list .operation:last-child {
+    border-bottom: none;
+}
+
+.subtext {
+    font-style: italic;
+    font-size: 13px;
+    color: #999;
+}
+
+#save-footer {
+    border-bottom: 1px solid #e5e5e5;
+}
+
+.flow-control-op {
+    color: #396f3a !important;
+    background-color: #c7e4ba !important;
+    border-color: #b3dba2 !important;
+}
+
+#support-modal textarea {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
+
+#save-text,
+#load-text {
+    font-family: Consolas, monospace;
+}
+
+button.dropdown-toggle {
+    background-color: #f4f4f4;
+}
+
+
+
+
+::-webkit-scrollbar {
+    width: 10px;
+    height: 10px;
+}
+::-webkit-scrollbar-track {
+    background-color: #fafafa;
+}
+::-webkit-scrollbar-thumb {
+    background-color: #ccc;
+}
+::-webkit-scrollbar-thumb:hover {
+    background-color: #bbb;
+}
+::-webkit-scrollbar-corner {
+    background-color: #fafafa;
+}
+
+.disabled {
+    color: #999 !important;
+    background-color: #dfdfdf !important;
+    border-color: #cdcdcd !important;
+}
+
+.grey {
+    color: #333;
+    background-color: #f5f5f5;
+    border-color: #ddd;
+}
+
+.dark-blue {
+    color: #fff;
+    background-color: #428bca;
+    border-color: #428bca;
+}
+
+.red {
+    color: #b94a48;
+    background-color: #f2dede;
+    border-color: #eed3d7;
+}
+
+.amber {
+    color: #c09853;
+    background-color: #fcf8e3;
+    border-color: #fbeed5;
+}
+
+.green {
+    color: #468847;
+    background-color: #dff0d8;
+    border-color: #d6e9c6;
+}
+
+.blue {
+    color: #3a87ad;
+    background-color: #d9edf7;
+    border-color: #bce8f1;
+}
--- a/src/html/index.html
+++ b/src/html/index.html
@ -0,0 +1,394 @@
+<!-- htmlmin:ignore --><!--
+    CyberChef - The Cyber Swiss Army Knife
+    
+    @copyright Crown Copyright 2016
+    @license Apache-2.0
+    
+      Copyright 2016 Crown Copyright
+    
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    
+        http://www.apache.org/licenses/LICENSE-2.0
+    
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<!-- htmlmin:ignore -->
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+        <title>CyberChef</title>
+        
+        <meta name="copyright" content="Crown Copyright 2016" />
+        <meta name="description" content="The Cyber Swiss Army Knife" />
+        <meta name="keywords" content="base64, hex, decode, encode, encrypt, decrypt, compress, decompress, regex, regular expressions, hash, crypt, hexadecimal, user agent, url, certificate, x.509, parser, JSON, gzip,  md5, sha1, aes, des, blowfish, xor" />
+
+        <link rel="icon" type="image/png" href="images/favicon.ico" />
+        <link href="styles.css" rel="stylesheet" />
+    </head>
+    <body>
+        <span id="edit-favourites" class="btn btn-default btn-sm"><img src="images/favourite-16x16.png" /> Edit</span>
+        <div id="alert" class="alert alert-danger">
+            <button type="button" class="close" id="alert-close">&times;</button>
+            <span id="alert-content"></span>
+        </div>
+        <div id="content-wrapper">
+            <div id="banner" class="green">
+                <a href="cyberchef.htm" style="float: left; margin-left: 10px; margin-right: 80px;">Download CyberChef<img src="images/download-24x24.png" /></a>
+                <span id="notice">
+                    <script type="text/javascript">
+                        // Must be text/javascript rather than application/javascript otherwise IE won't recognise it...
+                        if (navigator.userAgent && navigator.userAgent.match(/MSIE \d\d?\./)) {
+                            document.write("Internet Explorer is not supported, please use Firefox or Chrome instead");
+                            alert("Internet Explorer is not supported, please use Firefox or Chrome instead");
+                        }
+                    </script>
+                    <noscript>JavaScript is not enabled. Good luck.</noscript>
+                </span>
+                <a href="#" id="support" class="banner-right" data-toggle="modal" data-target="#support-modal">About / Support<img src="images/help-22x22.png" /></a>
+                <a href="#" id="options" class="banner-right">Options<img src="images/settings-22x22.png" /></a>
+            </div>
+            <div id="wrapper">
+                <div id="operations" class="split split-horizontal no-select">
+                    <div class="title no-select">Operations</div>
+                    <input type="search" class="form-control" id="search" placeholder="Search..." autocomplete="off">
+                    <ul class="op_list" id="search-results"></ul>
+                    <div class="panel-group no-select" id="categories"></div>
+                </div>
+                
+                <div id="recipe" class="split split-horizontal no-select">
+                    <div class="title no-select">Recipe</div>
+                    <ul id="rec_list" class="no-select"></ul>
+                    
+                    <div id="controls" class="no-select">
+                        <div id="operational-controls">
+                            <div id="bake-group">
+                                <button type="button" class="btn btn-success btn-lg" id="bake">
+                                    <img src="images/cook_male-32x32.png" />
+                                    Bake!
+                                </button>
+                                <label class="btn btn-success btn-lg" id="auto-bake-label">
+                                    <input type="checkbox" checked="checked" id="auto-bake">
+                                    <div>Auto Bake</div>
+                                </label>
+                            </div>
+                            
+                            <div class="btn-group" style="padding-top: 10px;">
+                                <button type="button" class="btn btn-default" id="step"><img src="images/step-16x16.png" /> Step through</button>
+                                <button type="button" class="btn btn-default" id="clr-breaks"><img src="images/erase-16x16.png" /> Clear breakpoints</button>
+                            </div>
+                        </div>
+                        
+                        <div class="btn-group-vertical" id="extra-controls">
+                            <button type="button" class="btn btn-default" id="save"><img src="images/save-16x16.png" /> Save recipe</button>
+                            <button type="button" class="btn btn-default" id="load"><img src="images/open_yellow-16x16.png" /> Load recipe</button>
+                            <button type="button" class="btn btn-default" id="clr-recipe"><img src="images/clean-16x16.png" /> Clear recipe</button>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="split split-horizontal" id="IO">
+                    <div id="input" class="split no-select">
+                        <div class="title no-select">
+                            Input
+                            <div class="btn-group io-btn-group">
+                                <button type="button" class="btn btn-default btn-sm" id="clr-io"><img src="images/recycle-16x16.png" /> Clear I/O</button>
+                                <button type="button" class="btn btn-default btn-sm" id="reset-layout"><img src="images/layout-16x16.png" /> Reset layout</button>
+                            </div>
+                            <div class="io-info" id="input-info"></div>
+                            <div class="io-info" id="input-selection-info"></div>
+                        </div>
+                        <div class="textarea-wrapper no-select">
+                            <div id="input-highlighter" class="no-select"></div>
+                            <textarea id="input-text"></textarea>
+                        </div>
+                    </div>
+                    
+                    <div id="output" class="split">
+                        <div class="title no-select">
+                            Output
+                            <div class="btn-group io-btn-group">
+                                <button type="button" class="btn btn-default btn-sm" id="save-to-file"><img src="images/save_as-16x16.png" /> Save to file</button>
+                                <button type="button" class="btn btn-default btn-sm" id="switch"><img src="images/switch-16x16.png" /> Move output to input</button>
+                                <button type="button" class="btn btn-default btn-sm" id="undo-switch" disabled="disabled"><img src="images/undo-16x16.png" /> Undo</button>
+                            </div>
+                            <div class="io-info" id="output-info"></div>
+                            <div class="io-info" id="output-selection-info"></div>
+                        </div>
+                        <div class="textarea-wrapper">
+                            <div id="output-highlighter" class="no-select"></div>
+                            <div id="output-html"></div>
+                            <textarea id="output-text" readonly="readonly"></textarea>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="modal" id="save-modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog modal-lg">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <img class="pull-right" src="images/save-22x22.png" />
+                        <h4 class="modal-title">Save recipe</h4>
+                    </div>
+                    <div class="modal-body">
+                        <div class="form-group">
+                            <label for="save-text">Save your recipe to local storage or copy the following string to load later</label>
+                            <textarea class="form-control" id="save-text" rows="5"></textarea>
+                        </div>
+                        <div class="form-group">
+                            <label for="save-name">Recipe name</label>
+                            <input type="text" class="form-control" id="save-name" placeholder="Recipe name">
+                        </div>
+                    </div>
+                    <div class="modal-footer" id="save-footer">
+                        <button type="button" class="btn btn-primary" id="save-button" data-dismiss="modal">Save</button>
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Done</button>
+                    </div>
+                    <div class="modal-body">
+                        <div class="form-group" id="save-link-group">
+                            <label>Data link</label>
+                            <div class="save-link-options">
+                                <input type="checkbox" id="save-link-recipe-checkbox" checked> Include recipe
+                                <input type="checkbox" id="save-link-input-checkbox" checked> Include input
+                            </div>
+                            <a id="save-link" style="word-wrap: break-word;"></a>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="modal" id="load-modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog modal-lg">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <img class="pull-right" src="images/open_yellow-24x24.png" />
+                        <h4 class="modal-title">Load recipe</h4>
+                    </div>
+                    <div class="modal-body">
+                        <div class="form-group">
+                            <label for="load-name">Load your recipe from local storage or paste it into the box below</label>
+                            <select class="form-control" id="load-name"></select>
+                        </div>
+                        <div class="form-group">
+                            <textarea class="form-control" id="load-text" rows="5"></textarea>
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-primary" id="load-button" data-dismiss="modal">Load</button>
+                        <button type="button" class="btn btn-danger" id="load-delete-button">Delete</button>
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Cancel</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="modal" id="options-modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog modal-lg">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <img class="pull-right" src="images/settings-22x22.png" />
+                        <h4 class="modal-title">Options</h4>
+                    </div>
+                    <div class="modal-body" id="options-body">
+                        <p style="font-weight: bold">Please note that these options will persist between sessions.</p>
+                        <div class="option-item">
+                            <input type="checkbox" option="update_url" checked />
+                            Update the URL when the input or recipe changes
+                        </div>
+                        <div class="option-item">
+                            <input type="checkbox" option="show_highlighter" checked />
+                            Highlight selected bytes in output and input (when possible)
+                        </div>
+                        <div class="option-item">
+                            <input type="checkbox" option="treat_as_utf8" checked />
+                            Treat output as UTF-8 if possible
+                        </div>
+                        <div class="option-item">
+                            <input type="checkbox" option="word_wrap" checked />
+                            Word wrap the input and output
+                        </div>
+                        <div class="option-item">
+                            <input type="checkbox" option="show_errors" checked />
+                            Operation error reporting (recommended)
+                        </div>
+                        <div class="option-item">
+                            <input type="number" option="error_timeout" />
+                            Operation error timeout in ms (0 for never)
+                        </div>
+                        <div class="option-item">
+                            <input type="number" option="auto_bake_threshold" />
+                            Auto Bake threshold in ms
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-default" id="reset-options">Reset options to default</button>
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="modal" id="favourites-modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog modal-lg">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <img class="pull-right" src="images/favourite-24x24.png" />
+                        <h4 class="modal-title">Edit Favourites</h4>
+                    </div>
+                    <div class="modal-body" id="options-body">
+                        <ul>
+                            <li><span style="font-weight: bold">To add:</span> drag the operation over the favourites category</li>
+                            <li><span style="font-weight: bold">To reorder:</span> drag up and down in the list below</li>
+                            <li><span style="font-weight: bold">To remove:</span> hit the red cross or drag out of the list below</li>
+                        </ul>
+                        <br>
+                        <ul id="edit-favourites-list" class="op_list"></ul>
+                        <div class="option-item">
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-default" data-dismiss="modal" id="reset-favourites">Reset favourites to default</button>
+                        <button type="button" class="btn btn-success" data-dismiss="modal" id="save-favourites">Save</button>
+                        <button type="button" class="btn btn-danger" data-dismiss="modal">Cancel</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="modal" id="support-modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog modal-lg">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <img class="pull-right" src="images/help-22x22.png" />
+                        <h4 class="modal-title">CyberChef - The Cyber Swiss Army Knife</h4>
+                    </div>
+                    <div class="modal-body">
+                        <img class="about-img-left" src="images/cyberchef-128x128.png" />
+                        <p class="subtext">Compile time: <%= grunt.template.today("dd/mm/yyyy HH:MM:ss") %> UTC</p>
+                        <p>&copy Crown Copyright 2016.</p>
+                        <p>Licenced under the Apache Licence, Version 2.0.</p>
+                        <br>
+                        <br>
+                        <div>
+                            <ul class='nav nav-tabs' role='tablist'>
+                                <li role='presentation' class='active'><a href='#faqs' aria-controls='profile' role='tab' data-toggle='tab'>
+                                    <img src='images/help-16x16.png' />
+                                    FAQs
+                                </a></li>
+                                <li role='presentation'><a href='#stats' aria-controls='messages' role='tab' data-toggle='tab'>
+                                    <img src='images/stats-16x16.png' />
+                                    Stats
+                                </a></li>
+                                <li role='presentation'><a href='#about' aria-controls='messages' role='tab' data-toggle='tab'>
+                                    <img src='images/speech-16x16.png' />
+                                    About
+                                </a></li>
+                            </ul>
+                            <div class='tab-content'>
+                                <div role='tabpanel' class='tab-pane active' id='faqs'>
+                                    <br>
+                                    <blockquote>
+                                        <a data-toggle='collapse' data-target='#faq-examples'>
+                                            What sort of things can I do with CyberChef?
+                                        </a>
+                                    </blockquote>
+                                    <div class='collapse' id='faq-examples'>
+                                        <p>There are well over 100 operations in CyberChef allowing you to carry simple and complex tasks easily. Here are some examples:</p>
+                                        <ul>
+                                            <li><a href="?recipe=%5B%7B%22op%22%3A%22From%20Base64%22%2C%22args%22%3A%5B%22A-Za-z0-9%2B%2F%3D%22%2Ctrue%5D%7D%5D&input=VTI4Z2JHOXVaeUJoYm1RZ2RHaGhibXR6SUdadmNpQmhiR3dnZEdobElHWnBjMmd1">Decode a Base64-encoded string</a></li>
+                                            <li><a href="?recipe=%5B%7B%22op%22%3A%22Translate%20DateTime%20Format%22%2C%22args%22%3A%5B%22Standard%20date%20and%20time%22%2C%22DD%2FMM%2FYYYY%20HH%3Amm%3Ass%22%2C%22UTC%22%2C%22dddd%20Do%20MMMM%20YYYY%20HH%3Amm%3Ass%20Z%20z%22%2C%22Australia%2FQueensland%22%5D%7D%5D&input=MTUvMDYvMjAxNSAyMDo0NTowMA">Convert a date and time to a different time zone</a></li>
+                                            <li><a href="?recipe=%5B%7B%22op%22%3A%22Parse%20IPv6%20address%22%2C%22args%22%3A%5B%5D%7D%5D&input=MjAwMTowMDAwOjQxMzY6ZTM3ODo4MDAwOjYzYmY6M2ZmZjpmZGQy">Parse a Teredo IPv6 address</a></li>
+                                            <li><a href="?recipe=%5B%7B%22op%22%3A%22From%20Hexdump%22%2C%22args%22%3A%5B%5D%7D%2C%7B%22op%22%3A%22Gunzip%22%2C%22args%22%3A%5B%5D%7D%5D&input=MDAwMDAwMDAgIDFmIDhiIDA4IDAwIDEyIGJjIGYzIDU3IDAwIGZmIDBkIGM3IGMxIDA5IDAwIDIwICB8Li4uLi6881cu%2Fy7HwS4uIHwKMDAwMDAwMTAgIDA4IDA1IGQwIDU1IGZlIDA0IDJkIGQzIDA0IDFmIGNhIDhjIDQ0IDIxIDViIGZmICB8Li7QVf4uLdMuLsouRCFb%2F3wKMDAwMDAwMjAgIDYwIGM3IGQ3IDAzIDE2IGJlIDQwIDFmIDc4IDRhIDNmIDA5IDg5IDBiIDlhIDdkICB8YMfXLi6%2BQC54Sj8uLi4ufXwKMDAwMDAwMzAgIDRlIGM4IDRlIDZkIDA1IDFlIDAxIDhiIDRjIDI0IDAwIDAwIDAwICAgICAgICAgICB8TshObS4uLi5MJC4uLnw">Convert data from a hexdump, then decompress</a></li>
+                                            <li><a href="?recipe=%5B%7B%22op%22%3A%22Fork%22%2C%22args%22%3A%5B%22%5C%5Cn%22%2C%22%5C%5Cn%22%5D%7D%2C%7B%22op%22%3A%22From%20UNIX%20Timestamp%22%2C%22args%22%3A%5B%22Seconds%20(s)%22%5D%7D%5D&input=OTc4MzQ2ODAwCjEwMTI2NTEyMDAKMTA0NjY5NjQwMAoxMDgxMDg3MjAwCjExMTUzMDUyMDAKMTE0OTYwOTYwMA">Display multiple timestamps as full dates</a></li>
+                                            <li><a href="?recipe=%5B%7B%22op%22%3A%22Fork%22%2C%22args%22%3A%5B%22%5C%5Cn%22%2C%22%5C%5Cn%22%5D%7D%2C%7B%22op%22%3A%22Conditional%20Jump%22%2C%22args%22%3A%5B%221%22%2C%222%22%2C%2210%22%5D%7D%2C%7B%22op%22%3A%22To%20Hex%22%2C%22args%22%3A%5B%22Space%22%5D%7D%2C%7B%22op%22%3A%22Return%22%2C%22args%22%3A%5B%5D%7D%2C%7B%22op%22%3A%22To%20Base64%22%2C%22args%22%3A%5B%22A-Za-z0-9%2B%2F%3D%22%5D%7D%5D&input=U29tZSBkYXRhIHdpdGggYSAxIGluIGl0ClNvbWUgZGF0YSB3aXRoIGEgMiBpbiBpdA">Carry out different operations on data of different types</a></li>
+                                        </ul>
+                                    </div>
+                                    <blockquote>
+                                        <a data-toggle='collapse' data-target='#faq-load-files'>
+                                            Can I load input directly from files?
+                                        </a>
+                                    </blockquote>
+                                    <div class='collapse' id='faq-load-files'>
+                                        <p>Yes! Just drag your file over the input box and drop it. The contents of the file will be converted into hexadecimal and the 'From Hex' operation will be added to the beginning of the recipe (if it's not already there). This is so that special characters like carriage returns aren't removed by your browser.</p>
+                                        <p>Please note that loading large files is likely to cause a crash. There's not a lot that can be done about this - browsers just aren't very good at handling and displaying large amounts of data.</p>
+                                    </div>
+                                    <blockquote>
+                                        <a data-toggle='collapse' data-target='#faq-fork'>
+                                            How do I run operation X over multiple inputs at once?
+                                        </a>
+                                    </blockquote>
+                                    <div class='collapse' id='faq-fork'>
+                                        <p>Maybe you have 10 timestamps that you want to parse or 16 encoded strings that all have the same key.</p>
+                                        <p>The 'Fork' operation (found in the 'Flow control' category) splits up the input line by line and runs all subsequent operations on each line separately. Each output is then displayed on a separate line. These delimiters can be changed, so if your inputs are separated by commas, you can change the split delimiter to a comma instead.</p>
+                                        <p><a href='?recipe=%5B%7B"op"%3A"Fork"%2C"args"%3A%5B"%5C%5Cn"%2C"%5C%5Cn"%5D%7D%2C%7B"op"%3A"From%20UNIX%20Timestamp"%2C"args"%3A%5B"Seconds%20(s)"%5D%7D%5D&input=OTc4MzQ2ODAwCjEwMTI2NTEyMDAKMTA0NjY5NjQwMAoxMDgxMDg3MjAwCjExMTUzMDUyMDAKMTE0OTYwOTYwMA%3D%3D'>Click here</a> for an example.</p>
+                                    </div>
+                                </div>
+                                <div role='tabpanel' class='tab-pane' id='stats'>
+                                    <br>
+                                    <p>If you're a nerd like me, you might find statistics really fun! Here's some about the CyberChef code base:</p>
+                                    <br><pre><%= codebase_stats %></pre>
+                                </div>
+                                <div role='tabpanel' class='tab-pane' id='about' style="padding: 20px;">
+                                    <h4>What</h4>
+                                    <p>A simple, intuitive web app for analysing and decoding data without having to deal with complex tools or programming languages. CyberChef encourages both technical and non-technical people to explore data formats, encryption and compression.</p>
+                                    
+                                    <h4>Why</h4>
+                                    <p>Digital data comes in all shapes, sizes and formats in the modern world – CyberChef helps to make sense of this data all on one easy-to-use platform.</p>
+                                    
+                                    <h4>How</h4>
+                                    <p>The interface is designed with simplicity at its heart. Complex techniques are now as trivial as drag-and-drop. Simple functions can be combined to build up a "recipe", potentially resulting in complex analysis, which can be shared with other users and used with their input.</p>
+                                    <p>For those comfortable writing code, CyberChef is a quick and efficient way to prototype solutions to a problem which can then be scripted once proven to work.</p>
+                                    
+                                    <h4>Who</h4>
+                                    <p>It is expected that CyberChef will be useful for cybersecurity and antivirus companies. It should also appeal to the academic world and any individuals or companies involved in the analysis of digital data, be that software developers, analysts, mathematicians or casual puzzle solvers.</p>
+                                    
+                                    <h4>Aim</h4>
+                                    <p>It is hoped that by releasing CyberChef through <a href="https://github.com/gchq/cyberchef">GitHub</a>, contributions can be added which can be rolled out into future versions of the tool.</p>
+
+                                    <br>
+                                    <p>There are around 150 useful operations in CyberChef for anyone working on anything vaguely Internet-related, whether you just want to convert a timestamp to a different format, decompress gzipped data, create a SHA3 hash, or parse an X.509 certificate to find out who issued it.</p>
+                                    <p>It’s the Cyber Swiss Army Knife.</p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="modal" id="confirm-modal" tabindex="-1" role="dialog">
+            <div class="modal-dialog modal-lg">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <h4 class="modal-title" id="confirm-title"></h4>
+                    </div>
+                    <div class="modal-body" id="confirm-body"></div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-success" id="confirm-yes">
+                            <img src="images/thumb_up-16x16.png" />
+                            Yes
+                        </button>
+                        <button type="button" class="btn btn-danger" id="confirm-no" data-dismiss="modal">
+                            <img src="images/thumb_down-16x16.png" />
+                            No
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <script type="application/javascript" src="scripts.js"></script>
+    </body>
+</html>
--- a/src/js/.jshintrc
+++ b/src/js/.jshintrc
@ -0,0 +1,38 @@
+{
+    "strict": "implied",
+    "multistr": true,
+    "browser": true,
+    "typed": true,
+    "jquery": true,
+    "node": true,
+    "undef": true,
+    "globals": {
+        /* core/* */
+        "Chef": true,
+        "Dish": true,
+        "Recipe": true,
+        "Ingredient": true,
+        "Operation": true,
+        "Utils": true,
+        
+        /* config/* */
+        "Categories": true,
+        "OperationConfig": true,
+        
+        /* views/html/* */
+        "HTMLApp": true,
+        "HTMLCategory": true,
+        "HTMLOperation": true,
+        "HTMLIngredient": true,
+        "Manager": true,
+        "ControlsWaiter": true,
+        "HighlighterWaiter": true,
+        "InputWaiter": true,
+        "OperationsWaiter": true,
+        "OptionsWaiter": true,
+        "OutputWaiter": true,
+        "RecipeWaiter": true,
+        "SeasonalWaiter": true,
+        "WindowWaiter": true
+    }
+}
--- a/src/js/config/Categories.js
+++ b/src/js/config/Categories.js
@ -0,0 +1,266 @@
+/**
+ * Type definition for a CatConf.
+ *
+ * @typedef {Object} CatConf
+ * @property {string} name - The display name for the category
+ * @property {string[]} ops - A list of the operations to be included in this category
+ */
+
+
+/**
+ * Categories of operations.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @constant
+ * @type {CatConf[]}
+ */
+var Categories = [
+    {
+        name: "Favourites",
+        ops: []
+    },
+    {
+        name: "Data format",
+        ops: [
+            "To Hexdump",
+            "From Hexdump",
+            "To Hex",
+            "From Hex",
+            "To Charcode",
+            "From Charcode",
+            "To Decimal",
+            "From Decimal",
+            "To Binary",
+            "From Binary",
+            "To Base64",
+            "From Base64",
+            "Show Base64 offsets",
+            "To Base32",
+            "From Base32",
+            "To Base",
+            "From Base",
+            "To HTML Entity",
+            "From HTML Entity",
+            "URL Encode",
+            "URL Decode",
+            "Unescape Unicode Characters",
+            "To Quoted Printable",
+            "From Quoted Printable",
+            "To Punycode",
+            "From Punycode",
+            "To Hex Content",
+            "From Hex Content",
+            "PEM to Hex",
+            "Hex to PEM",
+            "Parse ASN.1 hex string",
+            "Change IP format",
+            "Text encoding",
+            "Swap endianness",
+        ]
+    },
+    {
+        name: "Encryption / Encoding",
+        ops: [
+            "AES Encrypt",
+            "AES Decrypt",
+            "Blowfish Encrypt",
+            "Blowfish Decrypt",
+            "DES Encrypt",
+            "DES Decrypt",
+            "Triple DES Encrypt",
+            "Triple DES Decrypt",
+            "Rabbit Encrypt",
+            "Rabbit Decrypt",
+            "RC4",
+            "RC4 Drop",
+            "ROT13",
+            "XOR",
+            "XOR Brute Force",
+            "Derive PBKDF2 key",
+            "Derive EVP key",
+        ]
+    },
+    {
+        name: "Public Key",
+        ops: [
+            "Parse X.509 certificate",
+            "Parse ASN.1 hex string",
+            "PEM to Hex",
+            "Hex to PEM",
+            "Hex to Object Identifier",
+            "Object Identifier to Hex",
+        ]
+    },
+    {
+        name: "Logical operations",
+        ops: [
+            "XOR",
+            "XOR Brute Force",
+            "OR",
+            "NOT",
+            "AND",
+            "ADD",
+            "SUB",
+            "Rotate left",
+            "Rotate right",
+            "ROT13",
+        ]
+    },
+    {
+        name: "Networking",
+        ops: [
+            "Strip HTTP headers",
+            "Parse User Agent",
+            "Parse IP range",
+            "Parse IPv6 address",
+            "Parse URI",
+            "URL Encode",
+            "URL Decode",
+            "Format MAC addresses",
+            "Change IP format",
+            "Group IP addresses",
+        ]
+    },
+    {
+        name: "Language",
+        ops: [
+            "Text encoding",
+            "Unescape Unicode Characters",
+        ]
+    },
+    {
+        name: "Utils",
+        ops: [
+            "Diff",
+            "Remove whitespace",
+            "Remove null bytes",
+            "To Upper case",
+            "To Lower case",
+            "Add line numbers",
+            "Remove line numbers",
+            "Reverse",
+            "Sort",
+            "Unique",
+            "Split",
+            "Count occurrences",
+            "Expand alphabet range",
+            "Parse escaped string",
+            "Drop bytes",
+            "Take bytes",
+            "Pad lines",
+            "Find / Replace",
+            "Regular expression",
+            "Offset checker",
+            "Convert distance",
+            "Convert area",
+            "Convert mass",
+            "Convert speed",
+            "Convert data units",
+            "Parse UNIX file permissions",
+            "Swap endianness",
+            "Parse colour code",
+        ]
+    },
+    {
+        name: "Date / Time",
+        ops: [
+            "Parse DateTime",
+            "Translate DateTime Format",
+            "From UNIX Timestamp",
+            "To UNIX Timestamp",
+            "Extract dates",
+        ]
+    },
+    {
+        name: "Extractors",
+        ops: [
+            "Strings",
+            "Extract IP addresses",
+            "Extract email addresses",
+            "Extract MAC addresses",
+            "Extract URLs",
+            "Extract domains",
+            "Extract file paths",
+            "Extract dates",
+            "Regular expression",
+        ]
+    },
+    {
+        name: "Compression",
+        ops: [
+            "Raw Deflate",
+            "Raw Inflate",
+            "Zlib Deflate",
+            "Zlib Inflate",
+            "Gzip",
+            "Gunzip",
+            "Zip",
+            "Unzip",
+            "Bzip2 Decompress",
+        ]
+    },
+    {
+        name: "Hashing",
+        ops: [
+            "Analyse hash",
+            "Generate all hashes",
+            "MD5",
+            "SHA1",
+            "SHA224",
+            "SHA256",
+            "SHA384",
+            "SHA512",
+            "SHA3",
+            "RIPEMD-160",
+            "HMAC",
+            "Fletcher-16 Checksum",
+            "Adler-32 Checksum",
+            "CRC-32 Checksum",
+            "TCP/IP Checksum",
+        ]
+    },
+    {
+        name: "Code tidy",
+        ops: [
+            "Syntax highlighter",
+            "Generic Code Beautify",
+            "JavaScript Parser",
+            "JavaScript Beautify",
+            "JavaScript Minify",
+            "JSON Beautify",
+            "JSON Minify",
+            "XML Beautify",
+            "XML Minify",
+            "SQL Beautify",
+            "SQL Minify",
+            "CSS Beautify",
+            "CSS Minify",
+            "Strip HTML tags",
+            "Diff",
+        ]
+    },
+    {
+        name: "Other",
+        ops: [
+            "Entropy",
+            "Frequency distribution",
+            "Detect File Type",
+            "Scan for Embedded Files",
+            "Generate UUID",
+            "Numberwang",
+        ]
+    },
+    {
+        name: "Flow control",
+        ops: [
+            "Fork",
+            "Merge",
+            "Jump",
+            "Conditional Jump",
+            "Return",
+        ]
+    },
+];
--- a/src/js/config/OperationConfig.js
+++ b/src/js/config/OperationConfig.js
--- a/src/js/core/Chef.js
+++ b/src/js/core/Chef.js
@ -0,0 +1,120 @@
+/**
+ * The main controller for CyberChef.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @class
+ */
+var Chef = function() {
+    this.dish = new Dish();
+};
+
+
+/**
+ * Runs the recipe over the input.
+ *
+ * @param {string} input_text - The input data as a string
+ * @param {Object[]} recipe_config - The recipe configuration object
+ * @param {Object} options - The options object storing various user choices
+ * @param {boolean} options.attemp_highlight - Whether or not to attempt highlighting
+ * @param {number} progress - The position in the recipe to start from
+ * @param {number} [step] - The number of operations to execute
+ *
+ * @returns {Object} response
+ * @returns {string} response.result - The output of the recipe
+ * @returns {string} response.type - The data type of the result
+ * @returns {number} response.progress - The position that we have got to in the recipe
+ * @returns {number} response.options - The app options object (which may have been changed)
+ * @returns {number} response.duration - The number of ms it took to execute the recipe
+ * @returns {number} response.error - The error object thrown by a failed operation (false if no error)
+*/
+Chef.prototype.bake = function(input_text, recipe_config, options, progress, step) {
+    var start_time  = new Date().getTime(),
+        recipe      = new Recipe(recipe_config),
+        contains_fc = recipe.contains_flow_control(),
+        error       = false;
+    
+    // Reset attempt_highlight flag
+    if (options.hasOwnProperty("attempt_highlight")) {
+        options.attempt_highlight = true;
+    }
+    
+    if (contains_fc) options.attempt_highlight = false;
+    
+    // Clean up progress
+    if (progress >= recipe_config.length) {
+        progress = 0;
+    }
+    
+    if (step) {
+        // Unset breakpoint on this step
+        recipe.set_breakpoint(progress, false);
+        // Set breakpoint on next step
+        recipe.set_breakpoint(progress + 1, true);
+    }
+    
+    // If stepping with flow control, we have to start from the beginning
+    // but still want to skip all previous breakpoints
+    if (progress > 0 && contains_fc) {
+        recipe.remove_breaks_up_to(progress);
+        progress = 0;
+    }
+    
+    // If starting from scratch, load data
+    if (progress === 0) {
+        this.dish.set(input_text, Dish.STRING);
+    }
+
+    try {
+        progress = recipe.execute(this.dish, progress);
+    } catch (err) {
+        // We can't throw the error from here as we will return in the finally block and ignore it
+        // so we return the error in the result instead.
+        error = err;
+        progress = err.progress;
+    } finally {
+        return {
+            result: this.dish.type == Dish.HTML ?
+                this.dish.get(Dish.HTML) :
+                this.dish.get(Dish.STRING),
+            type: Dish.enum_lookup(this.dish.type),
+            progress: progress,
+            options: options,
+            duration: new Date().getTime() - start_time,
+            error: error
+        };
+    }
+};
+
+
+/**
+ * When a browser tab is unfocused and the browser has to run lots of dynamic content in other tabs,
+ * it swaps out the memory for that tab. If the CyberChef tab has been unfocused for more than a
+ * minute, we run a silent bake which will force the browser to load and cache all the relevant
+ * JavaScript code needed to do a real bake.
+ * 
+ * This will stop baking taking a long time when the CyberChef browser tab has been unfocused for a
+ * long time and the browser has swapped out all its memory.
+ * 
+ * The output will not be modified (hence "silent" bake).
+ * 
+ * This will only actually execute the recipe if auto-bake is enabled, otherwise it will just load
+ * the recipe, ingredients and dish.
+ *
+ * @param {Object[]} recipe_config - The recipe configuration object
+ * @returns {number} The time it took to run the silent bake in milliseconds.
+*/
+Chef.prototype.silent_bake = function(recipe_config) {
+    var start_time = new Date().getTime(),
+        recipe     = new Recipe(recipe_config),
+        dish       = new Dish("", Dish.STRING);
+        
+    try {
+        recipe.execute(dish);
+    } catch(err) {
+        // Suppress all errors
+    }
+    return new Date().getTime() - start_time;
+};
--- a/src/js/core/Dish.js
+++ b/src/js/core/Dish.js
@ -0,0 +1,202 @@
+/**
+ * The data being operated on by each operation.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @class
+ * @param {byte_array|string|number} value - The value of the input data.
+ * @param {number} type - The data type of value, see Dish enums.
+ */
+var Dish = function(value, type) {
+    this.value = value || typeof value == "string" ? value : null;
+    this.type  = type || Dish.BYTE_ARRAY;
+};
+
+
+/**
+ * Dish data type enum for byte arrays.
+ * @readonly
+ * @enum
+ */
+Dish.BYTE_ARRAY = 0;
+/**
+ * Dish data type enum for strings.
+ * @readonly
+ * @enum
+ */
+Dish.STRING = 1;
+/**
+ * Dish data type enum for numbers.
+ * @readonly
+ * @enum
+ */
+Dish.NUMBER = 2;
+/**
+ * Dish data type enum for HTML.
+ * @readonly
+ * @enum
+ */
+Dish.HTML = 3;
+
+
+/**
+ * Returns the data type enum for the given type string.
+ *
+ * @static
+ * @param {string} type_str - The name of the data type.
+ * @returns {number} The data type enum value.
+ */
+Dish.type_enum = function(type_str) {
+    switch (type_str) {
+        case "byte_array":
+        case "Byte array":
+            return Dish.BYTE_ARRAY;
+        case "string":
+        case "String":
+            return Dish.STRING;
+        case "number":
+        case "Number":
+            return Dish.NUMBER;
+        case "html":
+        case "HTML":
+            return Dish.HTML;
+        default:
+            throw "Invalid data type string. No matching enum.";
+    }
+};
+
+
+/**
+ * Returns the data type string for the given type enum.
+ *
+ * @static
+ * @param {string} type_enum - The enum value of the data type.
+ * @returns {number} The data type as a string.
+ */
+Dish.enum_lookup = function(type_enum) {
+    switch (type_enum) {
+        case Dish.BYTE_ARRAY:
+            return "byte_array";
+        case Dish.STRING:
+            return "string";
+        case Dish.NUMBER:
+            return "number";
+        case Dish.HTML:
+            return "html";
+        default:
+            throw "Invalid data type enum. No matching type.";
+    }
+};
+
+
+/**
+ * Sets the data value and type and then validates them.
+ *
+ * @param {byte_array|string|number} value - The value of the input data.
+ * @param {number} type - The data type of value, see Dish enums.
+ */
+Dish.prototype.set = function(value, type) {
+    this.value = value;
+    this.type  = type;
+    
+    if (!this.valid()) {
+        var sample = Utils.truncate(JSON.stringify(this.value), 13);
+        throw "Data is not a valid " + Dish.enum_lookup(type) + ": " + sample;
+    }
+};
+
+
+/**
+ * Returns the value of the data in the type format specified.
+ *
+ * @param {number} type - The data type of value, see Dish enums.
+ * @returns {byte_array|string|number} The value of the output data.
+ */
+Dish.prototype.get = function(type) {
+    if (this.type != type) {
+        this.translate(type);
+    }
+    return this.value;
+};
+
+
+/**
+ * Translates the data to the given type format.
+ *
+ * @param {number} to_type - The data type of value, see Dish enums.
+ */
+Dish.prototype.translate = function(to_type) {
+    // Convert data to intermediate byte_array type
+    switch (this.type) {
+        case Dish.STRING:
+            this.value = this.value ? Utils.str_to_byte_array(this.value) : [];
+            this.type = Dish.BYTE_ARRAY;
+            break;
+        case Dish.NUMBER:
+            this.value = typeof this.value == "number" ? Utils.str_to_byte_array(this.value.toString()) : [];
+            this.type = Dish.BYTE_ARRAY;
+            break;
+        case Dish.HTML:
+            this.value = this.value ? Utils.str_to_byte_array(Utils.strip_html_tags(this.value, true)) : [];
+            this.type = Dish.BYTE_ARRAY;
+            break;
+        default:
+            break;
+    }
+    
+    // Convert from byte_array to to_type
+    switch (to_type) {
+        case Dish.STRING:
+        case Dish.HTML:
+            this.value = this.value ? Utils.byte_array_to_utf8(this.value) : "";
+            this.type = Dish.STRING;
+            break;
+        case Dish.NUMBER:
+            this.value = this.value ? parseFloat(Utils.byte_array_to_utf8(this.value)) : 0;
+            this.type = Dish.NUMBER;
+            break;
+        default:
+            break;
+    }
+};
+
+
+/**
+ * Validates that the value is the type that has been specified.
+ * May have to disable parts of BYTE_ARRAY validation if it effects performance.
+ *
+ * @returns {boolean} Whether the data is valid or not.
+*/
+Dish.prototype.valid = function() {
+    switch (this.type) {
+        case Dish.BYTE_ARRAY:
+            if (!(this.value instanceof Array)) {
+                return false;
+            }
+            
+            // Check that every value is a number between 0 - 255
+            for (var i = 0; i < this.value.length; i++) {
+                if (typeof this.value[i] != "number" ||
+                    this.value[i] < 0 ||
+                    this.value[i] > 255) {
+                    return false;
+                }
+            }
+            return true;
+        case Dish.STRING:
+        case Dish.HTML:
+            if (typeof this.value == "string") {
+                return true;
+            }
+            return false;
+        case Dish.NUMBER:
+            if (typeof this.value == "number") {
+                return true;
+            }
+            return false;
+        default:
+            return false;
+    }
+};
--- a/src/js/core/FlowControl.js
+++ b/src/js/core/FlowControl.js
@ -0,0 +1,171 @@
+/**
+ * Flow Control operations.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @namespace
+ */
+var FlowControl = {
+
+    /**
+     * @constant
+     * @default
+     */
+    FORK_DELIM: "\\n",
+    /**
+     * @constant
+     * @default
+     */
+    MERGE_DELIM: "\\n",
+    
+    /**
+     * Fork operation.
+     *
+     * @param {Object} state - The current state of the recipe.
+     * @param {number} state.progress - The current position in the recipe.
+     * @param {Dish} state.dish - The Dish being operated on.
+     * @param {Operation[]} state.op_list - The list of operations in the recipe.
+     * @returns {Object} The updated state of the recipe.
+     */
+    run_fork: function(state) {
+        var op_list     = state.op_list,
+            input_type  = op_list[state.progress].input_type,
+            output_type = op_list[state.progress].output_type,
+            input       = state.dish.get(input_type),
+            ings        = op_list[state.progress].get_ing_values(),
+            split_delim = ings[0],
+            merge_delim = ings[1],
+            sub_op_list = [],
+            inputs      = [];
+        
+        if (input)
+            inputs = input.split(split_delim);
+        
+        // Create sub_op_list for each tranche to operate on
+        // (all remaining operations unless we encounter a Merge)
+        for (var i = state.progress + 1; i < op_list.length; i++) {
+            if (op_list[i].name == "Merge" && !op_list[i].is_disabled()) {
+                break;
+            } else {
+                sub_op_list.push(op_list[i]);
+            }
+        }
+        
+        var recipe = new Recipe(),
+            output = "",
+            progress;
+            
+        recipe.add_operations(sub_op_list);
+        
+        // Run recipe over each tranche
+        for (i = 0; i < inputs.length; i++) {
+            var dish = new Dish(inputs[i], input_type);
+            progress = recipe.execute(dish, 0);
+            output += dish.get(output_type) + merge_delim;
+        }
+        
+        state.dish.set(output, output_type);
+        state.progress += progress;
+        return state;
+    },
+    
+    
+    /**
+     * Merge operation.
+     *
+     * @param {Object} state - The current state of the recipe.
+     * @param {number} state.progress - The current position in the recipe.
+     * @param {Dish} state.dish - The Dish being operated on.
+     * @param {Operation[]} state.op_list - The list of operations in the recipe.
+     * @returns {Object} The updated state of the recipe.
+     */
+    run_merge: function(state) {
+        // No need to actually do anything here. The fork operation will
+        // merge when it sees this operation.
+        return state;
+    },
+    
+    
+    /**
+     * @constant
+     * @default
+     */
+    JUMP_NUM: 0,
+    /**
+     * @constant
+     * @default
+     */
+    MAX_JUMPS: 10,
+    
+    /**
+     * Jump operation.
+     *
+     * @param {Object} state - The current state of the recipe.
+     * @param {number} state.progress - The current position in the recipe.
+     * @param {Dish} state.dish - The Dish being operated on.
+     * @param {Operation[]} state.op_list - The list of operations in the recipe.
+     * @param {number} state.num_jumps - The number of jumps taken so far.
+     * @returns {Object} The updated state of the recipe.
+     */
+    run_jump: function(state) {
+        var ings      = state.op_list[state.progress].get_ing_values(),
+            jump_num  = ings[0],
+            max_jumps = ings[1];
+        
+        if (state.num_jumps >= max_jumps) {
+            throw "Reached maximum jumps, sorry!";
+        }
+        
+        state.progress += jump_num;
+        state.num_jumps++;
+        return state;
+    },
+    
+    
+    /**
+     * Conditional Jump operation.
+     *
+     * @param {Object} state - The current state of the recipe.
+     * @param {number} state.progress - The current position in the recipe.
+     * @param {Dish} state.dish - The Dish being operated on.
+     * @param {Operation[]} state.op_list - The list of operations in the recipe.
+     * @param {number} state.num_jumps - The number of jumps taken so far.
+     * @returns {Object} The updated state of the recipe.
+     */
+    run_cond_jump: function(state) {
+        var ings      = state.op_list[state.progress].get_ing_values(),
+            dish      = state.dish,
+            regex_str = ings[0],
+            jump_num  = ings[1],
+            max_jumps = ings[2];
+        
+        if (state.num_jumps >= max_jumps) {
+            throw "Reached maximum jumps, sorry!";
+        }
+        
+        if (regex_str !== "" && dish.get(Dish.STRING).search(regex_str) > -1) {
+            state.progress += jump_num;
+            state.num_jumps++;
+        }
+        
+        return state;
+    },
+    
+    
+    /**
+     * Return operation.
+     *
+     * @param {Object} state - The current state of the recipe.
+     * @param {number} state.progress - The current position in the recipe.
+     * @param {Dish} state.dish - The Dish being operated on.
+     * @param {Operation[]} state.op_list - The list of operations in the recipe.
+     * @returns {Object} The updated state of the recipe.
+     */
+    run_return: function(state) {
+        state.progress = state.op_list.length;
+        return state;
+    },
+    
+};
--- a/src/js/core/Ingredient.js
+++ b/src/js/core/Ingredient.js
@ -0,0 +1,86 @@
+/**
+ * The arguments to operations.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @class
+ * @param {Object} ingredient_config
+ */
+var Ingredient = function(ingredient_config) {
+    this.name  = "";
+    this.type  = "";
+    this.value = null;
+    
+    if (ingredient_config) {
+        this._parse_config(ingredient_config);
+    }
+};
+
+
+/**
+ * Reads and parses the given config.
+ *
+ * @private
+ * @param {Object} ingredient_config
+ */
+Ingredient.prototype._parse_config = function(ingredient_config) {
+    this.name = ingredient_config.name;
+    this.type = ingredient_config.type;
+};
+
+
+/**
+ * Returns the value of the Ingredient as it should be displayed in a recipe config.
+ *
+ * @returns {*}
+ */
+Ingredient.prototype.get_config = function() {
+    return this.value;
+};
+
+
+/**
+ * Sets the value of the Ingredient.
+ *
+ * @param {*} value
+ */
+Ingredient.prototype.set_value = function(value) {
+    this.value = Ingredient.prepare(value, this.type);
+};
+
+
+/**
+ * Most values will be strings when they are entered. This function converts them to the correct
+ * type.
+ *
+ * @static
+ * @param {*} data
+ * @param {string} type - The name of the data type.
+*/
+Ingredient.prepare = function(data, type) {
+    switch (type) {
+        case "binary_string":
+        case "binary_short_string":
+        case "editable_option":
+            return Utils.parse_escaped_chars(data);
+        case "byte_array":
+            if (typeof data == "string") {
+                data = data.replace(/\s+/g, '');
+                return Utils.hex_to_byte_array(data);
+            } else {
+                return data;
+            }
+            break;
+        case "number":
+            var number = parseFloat(data);
+            if (isNaN(number)) {
+                var sample = Utils.truncate(data.toString(), 10);
+                throw "Invalid ingredient value. Not a number: " + sample;
+            }
+            return number;
+        default:
+            return data;
+    }
+};
--- a/src/js/core/Operation.js
+++ b/src/js/core/Operation.js
@ -0,0 +1,157 @@
+/**
+ * The Operation specified by the user to be run.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @class
+ * @param {string} operation_name
+ * @param {Object} operation_config
+ */
+var Operation = function(operation_name, operation_config) {
+    this.name              = operation_name;
+    this.description       = "";
+    this.input_type        = -1;
+    this.output_type       = -1;
+    this.run               = null;
+    this.highlight         = null;
+    this.highlight_reverse = null;
+    this.breakpoint        = false;
+    this.disabled          = false;
+    this.ing_list          = [];
+    
+    if (operation_config) {
+        this._parse_config(operation_config);
+    }
+};
+
+
+/**
+ * Reads and parses the given config.
+ *
+ * @private
+ * @param {Object} operation_config
+ */
+Operation.prototype._parse_config = function(operation_config) {
+    this.description       = operation_config.description;
+    this.input_type        = Dish.type_enum(operation_config.input_type);
+    this.output_type       = Dish.type_enum(operation_config.output_type);
+    this.run               = operation_config.run;
+    this.highlight         = operation_config.highlight;
+    this.highlight_reverse = operation_config.highlight_reverse;
+    this.flow_control      = operation_config.flow_control;
+
+    for (var a = 0; a < operation_config.args.length; a++) {
+        var ingredient_config = operation_config.args[a];
+        var ingredient = new Ingredient(ingredient_config);
+        this.add_ingredient(ingredient);
+    }
+};
+
+
+/**
+ * Returns the value of the Operation as it should be displayed in a recipe config.
+ *
+ * @returns {Object}
+ */
+Operation.prototype.get_config = function() {
+    var ingredient_config = [];
+    
+    for (var o = 0; o < this.ing_list.length; o++) {
+        ingredient_config.push(this.ing_list[o].get_config());
+    }
+    
+    var operation_config = {
+        "op": this.name,
+        "args": ingredient_config
+    };
+    
+    return operation_config;
+};
+
+
+/**
+ * Adds a new Ingredient to this Operation.
+ *
+ * @param {Ingredient} ingredient
+ */
+Operation.prototype.add_ingredient = function(ingredient) {
+    this.ing_list.push(ingredient);
+};
+
+
+/**
+ * Set the Ingredient values for this Operation.
+ *
+ * @param {Object[]} ing_values
+ */
+Operation.prototype.set_ing_values = function(ing_values) {
+    for (var i = 0; i < ing_values.length; i++) {
+        this.ing_list[i].set_value(ing_values[i]);
+    }
+};
+
+
+/**
+ * Get the Ingredient values for this Operation.
+ *
+ * @returns {Object[]}
+ */
+Operation.prototype.get_ing_values = function() {
+    var ing_values = [];
+    for (var i = 0; i < this.ing_list.length; i++) {
+        ing_values.push(this.ing_list[i].value);
+    }
+    return ing_values;
+};
+
+
+/**
+ * Set whether this Operation has a breakpoint.
+ *
+ * @param {boolean} value
+ */
+Operation.prototype.set_breakpoint = function(value) {
+    this.breakpoint = !!value;
+};
+
+
+/**
+ * Returns true if this Operation has a breakpoint set.
+ *
+ * @returns {boolean}
+ */
+Operation.prototype.is_breakpoint = function() {
+    return this.breakpoint;
+};
+
+
+/**
+ * Set whether this Operation is disabled.
+ *
+ * @param {boolean} value
+ */
+Operation.prototype.set_disabled = function(value) {
+    this.disabled = !!value;
+};
+
+
+/**
+ * Returns true if this Operation is disabled.
+ *
+ * @returns {boolean}
+ */
+Operation.prototype.is_disabled = function() {
+    return this.disabled;
+};
+
+
+/**
+ * Returns true if this Operation is a flow control.
+ *
+ * @returns {boolean}
+ */
+Operation.prototype.is_flow_control = function() {
+    return this.flow_control;
+};
--- a/src/js/core/Recipe.js
+++ b/src/js/core/Recipe.js
@ -0,0 +1,215 @@
+/**
+ * The Recipe controls a list of Operations and the Dish they operate on.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @class
+ * @param {Object} recipe_config
+ */
+var Recipe = function(recipe_config) {
+    this.op_list = [];
+    
+    if (recipe_config) {
+        this._parse_config(recipe_config);
+    }
+};
+
+
+/**
+ * Reads and parses the given config.
+ *
+ * @private
+ * @param {Object} recipe_config
+ */
+Recipe.prototype._parse_config = function(recipe_config) {
+    for (var c = 0; c < recipe_config.length; c++) {
+        var operation_name = recipe_config[c].op;
+        var operation_config = OperationConfig[operation_name];
+        var operation = new Operation(operation_name, operation_config);
+        operation.set_ing_values(recipe_config[c].args);
+        operation.set_breakpoint(recipe_config[c].breakpoint);
+        operation.set_disabled(recipe_config[c].disabled);
+        this.add_operation(operation);
+    }
+};
+
+
+/**
+ * Returns the value of the Recipe as it should be displayed in a recipe config.
+ *
+ * @returns {*}
+ */
+Recipe.prototype.get_config = function() {
+    var recipe_config = [];
+    
+    for (var o = 0; o < this.op_list.length; o++) {
+        recipe_config.push(this.op_list[o].get_config());
+    }
+    
+    return recipe_config;
+};
+
+
+/**
+ * Adds a new Operation to this Recipe.
+ *
+ * @param {Operation} operation
+ */
+Recipe.prototype.add_operation = function(operation) {
+    this.op_list.push(operation);
+};
+
+
+/**
+ * Adds a list of Operations to this Recipe.
+ *
+ * @param {Operation[]} operations
+ */
+Recipe.prototype.add_operations = function(operations) {
+    this.op_list = this.op_list.concat(operations);
+};
+
+
+/**
+ * Set a breakpoint on a specified Operation.
+ *
+ * @param {number} position - The index of the Operation
+ * @param {boolean} value
+ */
+Recipe.prototype.set_breakpoint = function(position, value) {
+    try {
+        this.op_list[position].set_breakpoint(value);
+    } catch (err) {
+        // Ignore index error
+    }
+};
+
+
+/**
+ * Remove breakpoints on all Operations in the Recipe up to the specified position. Used by Flow
+ * Control Fork operation.
+ *
+ * @param {number} pos
+ */
+Recipe.prototype.remove_breaks_up_to = function(pos) {
+    for (var i = 0; i < pos; i++) {
+        this.op_list[i].set_breakpoint(false);
+    }
+};
+
+
+/**
+ * Returns true if there is an Flow Control Operation in this Recipe.
+ *
+ * @returns {boolean}
+ */
+Recipe.prototype.contains_flow_control = function() {
+    for (var i = 0; i < this.op_list.length; i++) {
+        if (this.op_list[i].is_flow_control()) return true;
+    }
+    return false;
+};
+
+
+/**
+ * Returns the index of the last Operation index that will be executed, taking into account disabled
+ * Operations and breakpoints.
+ *
+ * @param {number} [start_index=0] - The index to start searching from
+ * @returns (number}
+ */
+Recipe.prototype.last_op_index = function(start_index) {
+    var i = start_index + 1 || 0,
+        op;
+        
+    for (; i < this.op_list.length; i++) {
+        op = this.op_list[i];
+        if (op.is_disabled()) return i-1;
+        if (op.is_breakpoint()) return i-1;
+    }
+    
+    return i-1;
+};
+
+
+/**
+ * Executes each operation in the recipe over the given Dish.
+ *
+ * @param {Dish} dish
+ * @param {number} [start_from=0] - The index of the Operation to start executing from
+ * @returns {number} - The final progress through the recipe
+ */
+Recipe.prototype.execute = function(dish, start_from) {
+    start_from = start_from || 0;
+    var op, input, output, num_jumps = 0;
+    
+    for (var i = start_from; i < this.op_list.length; i++) {
+        op = this.op_list[i];
+        if (op.is_disabled()) {
+            continue;
+        }
+        if (op.is_breakpoint()) {
+            return i;
+        }
+        
+        try {
+            input = dish.get(op.input_type);
+            
+            if (op.is_flow_control()) {
+                // Package up the current state
+                var state = {
+                    "progress" : i,
+                    "dish"     : dish,
+                    "op_list"  : this.op_list,
+                    "num_jumps" : num_jumps
+                };
+                
+                state = op.run(state);
+                i = state.progress;
+                num_jumps = state.num_jumps;
+            } else {
+                output = op.run(input, op.get_ing_values());
+                dish.set(output, op.output_type);
+            }
+        } catch (err) {
+            var e = typeof err == "string" ? { message: err } : err;
+
+            e.progress = i;
+            e.display_str = op.name + " - ";
+            if (e.fileName) {
+                e.display_str += e.name + " in " + e.fileName +
+                    " on line " + e.lineNumber +
+                    ".<br><br>Message: " + e.message;
+            } else {
+                e.display_str += e.message;
+            }
+            
+            throw e;
+        }
+    }
+    
+    return this.op_list.length;
+};
+
+
+/**
+ * Returns the recipe configuration in string format.
+ *
+ * @returns {string}
+ */
+Recipe.prototype.to_string = function() {
+    return JSON.stringify(this.get_config());
+};
+
+
+/**
+ * Creates a Recipe from a given configuration string.
+ *
+ * @param {string} recipe_str
+ */
+Recipe.prototype.from_string = function(recipe_str) {
+    var recipe_config = JSON.parse(recipe_str);
+    this._parse_config(recipe_config);
+};
--- a/src/js/core/Utils.js
+++ b/src/js/core/Utils.js
--- a/src/js/lib/Sortable.js
+++ b/src/js/lib/Sortable.js
--- a/src/js/lib/blowfish.dojo.js
+++ b/src/js/lib/blowfish.dojo.js
@ -0,0 +1,649 @@
+/** @license
+========================================================================
+  Blowfish.js from Dojo Toolkit 1.8.1
+  Cut of by Sladex (xslade@gmail.com)
+  
+  Created based on the C# implementation by Marcus Hahn (http://www.hotpixel.net/)
+  Unsigned math based on Paul Johnstone and Peter Wood patches.
+  2005-12-08
+  
+  The Dojo Toolkit (including this package) is dual licensed under BSD 3-Clause and AFL.
+  The Dojo Toolkit is Copyright (c) 2005-2016, The Dojo Foundation.  All rights reserved.
+*/
+
+
+/* 
+ * Blowfish.js from Dojo Toolkit 1.8.1
+ * Cut of by Sladex (xslade@gmail.com)
+ * 
+ * Usage:
+ * blowfish.encrypt(String 'subj to encrypt', String 'key', Object {outputType: 1, cipherMode: 0});
+ * 
+ */
+
+
+(function(global){
+
+var crypto = {};
+
+
+
+/* dojo-release-1.8.1/dojox/encoding/crypto/_base.js.uncompressed.js */
+
+crypto.cipherModes = {
+	// summary:
+	//		Enumeration for various cipher modes.
+	ECB:0, CBC:1, PCBC:2, CFB:3, OFB:4, CTR:5
+};
+crypto.outputTypes = {
+	// summary:
+	//		Enumeration for input and output encodings.
+	Base64:0, Hex:1, String:2, Raw:3
+};
+
+
+
+/* dojo-release-1.8.1/dojox/encoding/base64.js.uncompressed.js */
+
+var base64 = {};
+var p="=";
+var tab="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+base64.encode=function(/* byte[] */ba){
+	// summary:
+	//		Encode an array of bytes as a base64-encoded string
+	var s=[], l=ba.length;
+	var rm=l%3;
+	var x=l-rm;
+	for (var i=0; i<x;){
+		var t=ba[i++]<<16|ba[i++]<<8|ba[i++];
+		s.push(tab.charAt((t>>>18)&0x3f));
+		s.push(tab.charAt((t>>>12)&0x3f));
+		s.push(tab.charAt((t>>>6)&0x3f));
+		s.push(tab.charAt(t&0x3f));
+	}
+	//	deal with trailers, based on patch from Peter Wood.
+	switch(rm){
+		case 2:{
+			var t=ba[i++]<<16|ba[i++]<<8;
+			s.push(tab.charAt((t>>>18)&0x3f));
+			s.push(tab.charAt((t>>>12)&0x3f));
+			s.push(tab.charAt((t>>>6)&0x3f));
+			s.push(p);
+			break;
+		}
+		case 1:{
+			var t=ba[i++]<<16;
+			s.push(tab.charAt((t>>>18)&0x3f));
+			s.push(tab.charAt((t>>>12)&0x3f));
+			s.push(p);
+			s.push(p);
+			break;
+		}
+	}
+	return s.join("");	//	string
+};
+
+base64.decode=function(/* string */str){
+	// summary:
+	//		Convert a base64-encoded string to an array of bytes
+	var s=str.split(""), out=[];
+	var l=s.length;
+	while(s[--l]==p){ }	//	strip off trailing padding
+	for (var i=0; i<l;){
+		var t=tab.indexOf(s[i++])<<18;
+		if(i<=l){ t|=tab.indexOf(s[i++])<<12 };
+		if(i<=l){ t|=tab.indexOf(s[i++])<<6 };
+		if(i<=l){ t|=tab.indexOf(s[i++]) };
+		out.push((t>>>16)&0xff);
+		out.push((t>>>8)&0xff);
+		out.push(t&0xff);
+	}
+	//	strip off any null bytes
+	while(out[out.length-1]==0){ out.pop(); }
+	return out;	//	byte[]
+};
+
+
+
+/* dojo-release-1.8.1/dojo/_base/lang.js.uncompressed.js */
+
+var lang = {};
+lang.isString = function(it){
+	// summary:
+	//		Return true if it is a String
+	// it: anything
+	//		Item to test.
+	return (typeof it == "string" || it instanceof String); // Boolean
+};
+
+
+
+/* dojo-release-1.8.1/dojo/_base/array.js.uncompressed.js */
+
+var arrayUtil = {};
+arrayUtil.map = function(arr, callback, thisObject, Ctr){
+	// summary:
+	//		applies callback to each element of arr and returns
+	//		an Array with the results
+	// arr: Array|String
+	//		the array to iterate on. If a string, operates on
+	//		individual characters.
+	// callback: Function|String
+	//		a function is invoked with three arguments, (item, index,
+	//		array),	 and returns a value
+	// thisObject: Object?
+	//		may be used to scope the call to callback
+	// returns: Array
+	// description:
+	//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+	//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+	//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+	//		For more details, see:
+	//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+	// example:
+	//	| // returns [2, 3, 4, 5]
+	//	| array.map([1, 2, 3, 4], function(item){ return item+1 });
+
+	// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+	var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l);
+	if(l && typeof arr == "string") arr = arr.split("");
+	if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
+	if(thisObject){
+		for(; i < l; ++i){
+			out[i] = callback.call(thisObject, arr[i], i, arr);
+		}
+	}else{
+		for(; i < l; ++i){
+			out[i] = callback(arr[i], i, arr);
+		}
+	}
+	return out; // Array
+};
+
+
+
+/* dojo-release-1.8.1/dojox/encoding/crypto/Blowfish.js.uncompressed.js */
+
+/*	Blowfish
+ *	Created based on the C# implementation by Marcus Hahn (http://www.hotpixel.net/)
+ *	Unsigned math based on Paul Johnstone and Peter Wood patches.
+ *	2005-12-08
+ */
+crypto.Blowfish = new function(){
+	// summary:
+	//		Object for doing Blowfish encryption/decryption.
+	var POW2=Math.pow(2,2);
+	var POW3=Math.pow(2,3);
+	var POW4=Math.pow(2,4);
+	var POW8=Math.pow(2,8);
+	var POW16=Math.pow(2,16);
+	var POW24=Math.pow(2,24);
+	var iv=null;	//	CBC mode initialization vector
+	var boxes={
+		p:[
+			0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+			0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+			0x9216d5d9, 0x8979fb1b
+		],
+		s0:[
+			0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+			0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+			0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+			0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+			0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+			0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+			0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+			0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+			0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+			0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+			0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+			0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+			0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+			0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+			0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+			0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+			0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+			0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+			0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+			0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+			0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+			0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+			0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+			0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+			0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+			0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+			0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+			0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+			0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+			0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+			0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+			0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
+		],
+		s1:[
+			0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+			0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+			0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+			0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+			0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+			0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+			0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+			0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+			0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+			0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+			0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+			0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+			0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+			0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+			0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+			0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+			0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+			0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+			0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+			0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+			0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+			0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+			0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+			0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+			0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+			0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+			0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+			0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+			0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+			0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+			0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+			0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
+		],
+		s2:[
+			0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+			0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+			0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+			0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+			0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+			0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+			0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+			0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+			0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+			0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+			0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+			0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+			0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+			0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+			0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+			0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+			0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+			0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+			0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+			0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+			0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+			0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+			0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+			0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+			0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+			0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+			0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+			0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+			0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+			0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+			0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+			0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
+		],
+		s3:[
+			0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+			0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+			0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+			0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+			0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+			0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+			0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+			0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+			0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+			0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+			0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+			0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+			0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+			0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+			0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+			0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+			0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+			0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+			0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+			0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+			0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+			0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+			0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+			0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+			0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+			0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+			0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+			0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+			0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+			0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+			0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+			0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+		]
+	}
+////////////////////////////////////////////////////////////////////////////
+//	fixes based on patch submitted by Peter Wood (#5791)
+	function add(x,y){
+		return (((x>>0x10)+(y>>0x10)+(((x&0xffff)+(y&0xffff))>>0x10))<<0x10)|(((x&0xffff)+(y&0xffff))&0xffff);
+	}
+	function xor(x,y){
+		return (((x>>0x10)^(y>>0x10))<<0x10)|(((x&0xffff)^(y&0xffff))&0xffff);
+	}
+
+	function $(v, box){
+		var d=box.s3[v&0xff]; v>>=8;
+		var c=box.s2[v&0xff]; v>>=8;
+		var b=box.s1[v&0xff]; v>>=8;
+		var a=box.s0[v&0xff];
+
+		var r = (((a>>0x10)+(b>>0x10)+(((a&0xffff)+(b&0xffff))>>0x10))<<0x10)|(((a&0xffff)+(b&0xffff))&0xffff);
+		r = (((r>>0x10)^(c>>0x10))<<0x10)|(((r&0xffff)^(c&0xffff))&0xffff);
+		return (((r>>0x10)+(d>>0x10)+(((r&0xffff)+(d&0xffff))>>0x10))<<0x10)|(((r&0xffff)+(d&0xffff))&0xffff);
+	}
+////////////////////////////////////////////////////////////////////////////
+	function eb(o, box){
+		//	TODO: see if this can't be made more efficient
+		var l=o.left;
+		var r=o.right;
+		l=xor(l,box.p[0]);
+		r=xor(r,xor($(l,box),box.p[1]));
+		l=xor(l,xor($(r,box),box.p[2]));
+		r=xor(r,xor($(l,box),box.p[3]));
+		l=xor(l,xor($(r,box),box.p[4]));
+		r=xor(r,xor($(l,box),box.p[5]));
+		l=xor(l,xor($(r,box),box.p[6]));
+		r=xor(r,xor($(l,box),box.p[7]));
+		l=xor(l,xor($(r,box),box.p[8]));
+		r=xor(r,xor($(l,box),box.p[9]));
+		l=xor(l,xor($(r,box),box.p[10]));
+		r=xor(r,xor($(l,box),box.p[11]));
+		l=xor(l,xor($(r,box),box.p[12]));
+		r=xor(r,xor($(l,box),box.p[13]));
+		l=xor(l,xor($(r,box),box.p[14]));
+		r=xor(r,xor($(l,box),box.p[15]));
+		l=xor(l,xor($(r,box),box.p[16]));
+		o.right=l;
+		o.left=xor(r,box.p[17]);
+	}
+
+	function db(o, box){
+		var l=o.left;
+		var r=o.right;
+		l=xor(l,box.p[17]);
+		r=xor(r,xor($(l,box),box.p[16]));
+		l=xor(l,xor($(r,box),box.p[15]));
+		r=xor(r,xor($(l,box),box.p[14]));
+		l=xor(l,xor($(r,box),box.p[13]));
+		r=xor(r,xor($(l,box),box.p[12]));
+		l=xor(l,xor($(r,box),box.p[11]));
+		r=xor(r,xor($(l,box),box.p[10]));
+		l=xor(l,xor($(r,box),box.p[9]));
+		r=xor(r,xor($(l,box),box.p[8]));
+		l=xor(l,xor($(r,box),box.p[7]));
+		r=xor(r,xor($(l,box),box.p[6]));
+		l=xor(l,xor($(r,box),box.p[5]));
+		r=xor(r,xor($(l,box),box.p[4]));
+		l=xor(l,xor($(r,box),box.p[3]));
+		r=xor(r,xor($(l,box),box.p[2]));
+		l=xor(l,xor($(r,box),box.p[1]));
+		o.right=l;
+		o.left=xor(r,box.p[0]);
+	}
+
+	//	Note that we aren't caching contexts here; it might take a little longer
+	//	but we should be more secure this way.
+	function init(key){
+		var k=key;
+		if(lang.isString(k)){
+			k = arrayUtil.map(k.split(""), function(item){
+				return item.charCodeAt(0) & 0xff;
+			});
+		}
+
+		//	init the boxes
+		var pos=0, data=0, res={ left:0, right:0 }, i, j, l;
+		var box = {
+			p: arrayUtil.map(boxes.p.slice(0), function(item){
+				var l=k.length, j;
+				for(j=0; j<4; j++){ data=(data*POW8)|k[pos++ % l]; }
+				return (((item>>0x10)^(data>>0x10))<<0x10)|(((item&0xffff)^(data&0xffff))&0xffff);
+			}),
+			s0:boxes.s0.slice(0),
+			s1:boxes.s1.slice(0),
+			s2:boxes.s2.slice(0),
+			s3:boxes.s3.slice(0)
+		};
+
+		//	encrypt p and the s boxes
+		for(i=0, l=box.p.length; i<l;){
+			eb(res, box);
+			box.p[i++]=res.left, box.p[i++]=res.right;
+		}
+		for(i=0; i<4; i++){
+			for(j=0, l=box["s"+i].length; j<l;){
+				eb(res, box);
+				box["s"+i][j++]=res.left, box["s"+i][j++]=res.right;
+			}
+		}
+		return box;
+	}
+
+////////////////////////////////////////////////////////////////////////////
+//	PUBLIC FUNCTIONS
+////////////////////////////////////////////////////////////////////////////
+	this.getIV=function(/* dojox.encoding.crypto.outputTypes? */ outputType){
+		// summary:
+		//		returns the initialization vector in the output format specified by outputType
+		var out=outputType||crypto.outputTypes.Base64;
+		switch(out){
+			case crypto.outputTypes.Hex:{
+				return arrayUtil.map(iv, function(item){
+					return (item<=0xf?'0':'')+item.toString(16);
+				}).join("");			//	string
+			}
+			case crypto.outputTypes.String:{
+				return iv.join("");		//	string
+			}
+			case crypto.outputTypes.Raw:{
+				return iv;				//	array
+			}
+			default:{
+				return base64.encode(iv); 	//	 string
+			}
+		}
+	};
+
+	this.setIV=function(/* string */data, /* dojox.encoding.crypto.outputTypes? */inputType){
+		// summary:
+		//		sets the initialization vector to data (as interpreted as inputType)
+		var ip=inputType||crypto.outputTypes.Base64;
+		var ba=null;
+		switch(ip){
+			case crypto.outputTypes.String:{
+				ba = arrayUtil.map(data.split(""), function(item){
+					return item.charCodeAt(0);
+				});
+				break;
+			}
+			case crypto.outputTypes.Hex:{
+				ba=[];
+				for(var i=0, l=data.length-1; i<l; i+=2){
+					ba.push(parseInt(data.substr(i,2), 16));
+				}
+				break;
+			}
+			case crypto.outputTypes.Raw:{
+				ba=data;
+				break;
+			}
+			default:{
+				ba=base64.decode(data);
+				break;
+			}
+		}
+		//	make it a pair of words now
+		iv={};
+		iv.left=ba[0]*POW24|ba[1]*POW16|ba[2]*POW8|ba[3];
+		iv.right=ba[4]*POW24|ba[5]*POW16|ba[6]*POW8|ba[7];
+	};
+
+	this.encrypt = function(/* string */plaintext, /* string */key, /* object? */ao){
+		// summary:
+		//		encrypts plaintext using key; allows user to specify output type and cipher mode via keyword object "ao"
+		var out=crypto.outputTypes.Base64;
+		var mode=crypto.cipherModes.ECB;
+		if (ao){
+			if (ao.outputType) out=ao.outputType;
+			if (ao.cipherMode) mode=ao.cipherMode;
+		}
+
+		var bx = init(key), padding = 8-(plaintext.length&7);
+		for (var i=0; i<padding; i++){ plaintext+=String.fromCharCode(padding); }
+
+		var cipher=[], count=plaintext.length >> 3, pos=0, o={}, isCBC=(mode==crypto.cipherModes.CBC);
+		var vector={left:iv.left||null, right:iv.right||null};
+		for(var i=0; i<count; i++){
+			o.left=plaintext.charCodeAt(pos)*POW24
+				|plaintext.charCodeAt(pos+1)*POW16
+				|plaintext.charCodeAt(pos+2)*POW8
+				|plaintext.charCodeAt(pos+3);
+			o.right=plaintext.charCodeAt(pos+4)*POW24
+				|plaintext.charCodeAt(pos+5)*POW16
+				|plaintext.charCodeAt(pos+6)*POW8
+				|plaintext.charCodeAt(pos+7);
+
+			if(isCBC){
+				o.left=(((o.left>>0x10)^(vector.left>>0x10))<<0x10)|(((o.left&0xffff)^(vector.left&0xffff))&0xffff);
+				o.right=(((o.right>>0x10)^(vector.right>>0x10))<<0x10)|(((o.right&0xffff)^(vector.right&0xffff))&0xffff);
+			}
+
+			eb(o, bx);	//	encrypt the block
+
+			if(isCBC){
+				vector.left=o.left;
+				vector.right=o.right;
+			}
+
+			cipher.push((o.left>>24)&0xff);
+			cipher.push((o.left>>16)&0xff);
+			cipher.push((o.left>>8)&0xff);
+			cipher.push(o.left&0xff);
+			cipher.push((o.right>>24)&0xff);
+			cipher.push((o.right>>16)&0xff);
+			cipher.push((o.right>>8)&0xff);
+			cipher.push(o.right&0xff);
+			pos+=8;
+		}
+
+		switch(out){
+			case crypto.outputTypes.Hex:{
+				return arrayUtil.map(cipher, function(item){
+					return (item<=0xf?'0':'')+item.toString(16);
+				}).join("");	//	string
+			}
+			case crypto.outputTypes.String:{
+				return cipher.join("");	//	string
+			}
+			case crypto.outputTypes.Raw:{
+				return cipher;	//	array
+			}
+			default:{
+				return base64.encode(cipher);	//	string
+			}
+		}
+	};
+
+	this.decrypt = function(/* string */ciphertext, /* string */key, /* object? */ao){
+		// summary:
+		//		decrypts ciphertext using key; allows specification of how ciphertext is encoded via ao.
+		var ip=crypto.outputTypes.Base64;
+		var mode=crypto.cipherModes.ECB;
+		if (ao){
+			if (ao.outputType) ip=ao.outputType;
+			if (ao.cipherMode) mode=ao.cipherMode;
+		}
+		var bx = init(key);
+		var pt=[];
+
+		var c=null;
+		switch(ip){
+			case crypto.outputTypes.Hex:{
+				c = [];
+				for(var i=0, l=ciphertext.length-1; i<l; i+=2){
+					c.push(parseInt(ciphertext.substr(i,2), 16));
+				}
+				break;
+			}
+			case crypto.outputTypes.String:{
+				c = arrayUtil.map(ciphertext.split(""), function(item){
+					return item.charCodeAt(0);
+				});
+				break;
+			}
+			case crypto.outputTypes.Raw:{
+				c=ciphertext;	//	should be a byte array
+				break;
+			}
+			default:{
+				c=base64.decode(ciphertext);
+				break;
+			}
+		}
+
+		var count=c.length >> 3, pos=0, o={}, isCBC=(mode==crypto.cipherModes.CBC);
+		var vector={left:iv.left||null, right:iv.right||null};
+		for(var i=0; i<count; i++){
+			o.left=c[pos]*POW24|c[pos+1]*POW16|c[pos+2]*POW8|c[pos+3];
+			o.right=c[pos+4]*POW24|c[pos+5]*POW16|c[pos+6]*POW8|c[pos+7];
+
+			if(isCBC){
+				var left=o.left;
+				var right=o.right;
+			}
+
+			db(o, bx);	//	decrypt the block
+
+			if(isCBC){
+				o.left=(((o.left>>0x10)^(vector.left>>0x10))<<0x10)|(((o.left&0xffff)^(vector.left&0xffff))&0xffff);
+				o.right=(((o.right>>0x10)^(vector.right>>0x10))<<0x10)|(((o.right&0xffff)^(vector.right&0xffff))&0xffff);
+				vector.left=left;
+				vector.right=right;
+			}
+
+			pt.push((o.left>>24)&0xff);
+			pt.push((o.left>>16)&0xff);
+			pt.push((o.left>>8)&0xff);
+			pt.push(o.left&0xff);
+			pt.push((o.right>>24)&0xff);
+			pt.push((o.right>>16)&0xff);
+			pt.push((o.right>>8)&0xff);
+			pt.push(o.right&0xff);
+			pos+=8;
+		}
+
+		//	check for padding, and remove.
+		if(pt[pt.length-1]==pt[pt.length-2]||pt[pt.length-1]==0x01){
+			var n=pt[pt.length-1];
+			pt.splice(pt.length-n, n);
+		}
+
+		//	convert to string
+		return arrayUtil.map(pt, function(item){
+			return String.fromCharCode(item);
+		}).join("");	//	string
+	};
+
+	this.setIV("0000000000000000", crypto.outputTypes.Hex);
+}();
+
+
+
+if (typeof exports != 'undefined') {
+    exports.blowfish = crypto.Blowfish;
+} else {
+    global.blowfish = crypto.Blowfish;
+}
+
+}(this));
--- a/src/js/lib/bootstrap-3.3.6.js
+++ b/src/js/lib/bootstrap-3.3.6.js
--- a/src/js/lib/bootstrap-colorpicker.js
+++ b/src/js/lib/bootstrap-colorpicker.js
--- a/src/js/lib/bootstrap-switch.js
+++ b/src/js/lib/bootstrap-switch.js
@ -0,0 +1,583 @@
+/** @license
+========================================================================
+  bootstrap-switch - v3.1.0
+  http://www.bootstrap-switch.org
+  Copyright 2012-2013 Mattia Larentis
+ 
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+      http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+(function() {
+  var __slice = [].slice;
+
+  (function($, window) {
+    "use strict";
+    var BootstrapSwitch;
+    BootstrapSwitch = (function() {
+      function BootstrapSwitch(element, options) {
+        if (options == null) {
+          options = {};
+        }
+        this.$element = $(element);
+        this.options = $.extend({}, $.fn.bootstrapSwitch.defaults, {
+          state: this.$element.is(":checked"),
+          size: this.$element.data("size"),
+          animate: this.$element.data("animate"),
+          disabled: this.$element.is(":disabled"),
+          readonly: this.$element.is("[readonly]"),
+          indeterminate: this.$element.data("indeterminate"),
+          inverse: this.$element.data("inverse"),
+          radioAllOff: this.$element.data("radio-all-off"),
+          onColor: this.$element.data("on-color"),
+          offColor: this.$element.data("off-color"),
+          onText: this.$element.data("on-text"),
+          offText: this.$element.data("off-text"),
+          labelText: this.$element.data("label-text"),
+          baseClass: this.$element.data("base-class"),
+          wrapperClass: this.$element.data("wrapper-class")
+        }, options);
+        this.$wrapper = $("<div>", {
+          "class": (function(_this) {
+            return function() {
+              var classes;
+              classes = ["" + _this.options.baseClass].concat(_this._getClasses(_this.options.wrapperClass));
+              classes.push(_this.options.state ? "" + _this.options.baseClass + "-on" : "" + _this.options.baseClass + "-off");
+              if (_this.options.size != null) {
+                classes.push("" + _this.options.baseClass + "-" + _this.options.size);
+              }
+              if (_this.options.animate) {
+                classes.push("" + _this.options.baseClass + "-animate");
+              }
+              if (_this.options.disabled) {
+                classes.push("" + _this.options.baseClass + "-disabled");
+              }
+              if (_this.options.readonly) {
+                classes.push("" + _this.options.baseClass + "-readonly");
+              }
+              if (_this.options.indeterminate) {
+                classes.push("" + _this.options.baseClass + "-indeterminate");
+              }
+              if (_this.options.inverse) {
+                classes.push("" + _this.options.baseClass + "-inverse");
+              }
+              if (_this.$element.attr("id")) {
+                classes.push("" + _this.options.baseClass + "-id-" + (_this.$element.attr("id")));
+              }
+              return classes.join(" ");
+            };
+          })(this)()
+        });
+        this.$container = $("<div>", {
+          "class": "" + this.options.baseClass + "-container"
+        });
+        this.$on = $("<span>", {
+          html: this.options.onText,
+          "class": "" + this.options.baseClass + "-handle-on " + this.options.baseClass + "-" + this.options.onColor
+        });
+        this.$off = $("<span>", {
+          html: this.options.offText,
+          "class": "" + this.options.baseClass + "-handle-off " + this.options.baseClass + "-" + this.options.offColor
+        });
+        this.$label = $("<label>", {
+          html: this.options.labelText,
+          "class": "" + this.options.baseClass + "-label"
+        });
+        if (this.options.indeterminate) {
+          this.$element.prop("indeterminate", true);
+        }
+        this.$element.on("init.bootstrapSwitch", (function(_this) {
+          return function() {
+            return _this.options.onInit.apply(element, arguments);
+          };
+        })(this));
+        this.$element.on("switchChange.bootstrapSwitch", (function(_this) {
+          return function() {
+            return _this.options.onSwitchChange.apply(element, arguments);
+          };
+        })(this));
+        this.$container = this.$element.wrap(this.$container).parent();
+        this.$wrapper = this.$container.wrap(this.$wrapper).parent();
+        this.$element.before(this.options.inverse ? this.$off : this.$on).before(this.$label).before(this.options.inverse ? this.$on : this.$off).trigger("init.bootstrapSwitch");
+        this._elementHandlers();
+        this._handleHandlers();
+        this._labelHandlers();
+        this._formHandler();
+      }
+
+      BootstrapSwitch.prototype._constructor = BootstrapSwitch;
+
+      BootstrapSwitch.prototype.state = function(value, skip) {
+        if (typeof value === "undefined") {
+          return this.options.state;
+        }
+        if (this.options.disabled || this.options.readonly) {
+          return this.$element;
+        }
+        if (this.options.state && !this.options.radioAllOff && this.$element.is(':radio')) {
+          return this.$element;
+        }
+        if (this.options.indeterminate) {
+          this.indeterminate(false);
+          value = true;
+        } else {
+          value = !!value;
+        }
+        this.$element.prop("checked", value).trigger("change.bootstrapSwitch", skip);
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleState = function(skip) {
+        if (this.options.disabled || this.options.readonly) {
+          return this.$element;
+        }
+        if (this.options.indeterminate) {
+          this.indeterminate(false);
+          return this.state(true);
+        } else {
+          return this.$element.prop("checked", !this.options.state).trigger("change.bootstrapSwitch", skip);
+        }
+      };
+
+      BootstrapSwitch.prototype.size = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.size;
+        }
+        if (this.options.size != null) {
+          this.$wrapper.removeClass("" + this.options.baseClass + "-" + this.options.size);
+        }
+        if (value) {
+          this.$wrapper.addClass("" + this.options.baseClass + "-" + value);
+        }
+        this.options.size = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.animate = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.animate;
+        }
+        value = !!value;
+        this.$wrapper[value ? "addClass" : "removeClass"]("" + this.options.baseClass + "-animate");
+        this.options.animate = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleAnimate = function() {
+        this.$wrapper.toggleClass("" + this.options.baseClass + "-animate");
+        this.options.animate = !this.options.animate;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.disabled = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.disabled;
+        }
+        value = !!value;
+        this.$wrapper[value ? "addClass" : "removeClass"]("" + this.options.baseClass + "-disabled");
+        this.$element.prop("disabled", value);
+        this.options.disabled = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleDisabled = function() {
+        this.$element.prop("disabled", !this.options.disabled);
+        this.$wrapper.toggleClass("" + this.options.baseClass + "-disabled");
+        this.options.disabled = !this.options.disabled;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.readonly = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.readonly;
+        }
+        value = !!value;
+        this.$wrapper[value ? "addClass" : "removeClass"]("" + this.options.baseClass + "-readonly");
+        this.$element.prop("readonly", value);
+        this.options.readonly = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleReadonly = function() {
+        this.$element.prop("readonly", !this.options.readonly);
+        this.$wrapper.toggleClass("" + this.options.baseClass + "-readonly");
+        this.options.readonly = !this.options.readonly;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.indeterminate = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.indeterminate;
+        }
+        value = !!value;
+        this.$wrapper[value ? "addClass" : "removeClass"]("" + this.options.baseClass + "-indeterminate");
+        this.$element.prop("indeterminate", value);
+        this.options.indeterminate = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleIndeterminate = function() {
+        this.$element.prop("indeterminate", !this.options.indeterminate);
+        this.$wrapper.toggleClass("" + this.options.baseClass + "-indeterminate");
+        this.options.indeterminate = !this.options.indeterminate;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.inverse = function(value) {
+        var $off, $on;
+        if (typeof value === "undefined") {
+          return this.options.inverse;
+        }
+        value = !!value;
+        this.$wrapper[value ? "addClass" : "removeClass"]("" + this.options.baseClass + "-inverse");
+        $on = this.$on.clone(true);
+        $off = this.$off.clone(true);
+        this.$on.replaceWith($off);
+        this.$off.replaceWith($on);
+        this.$on = $off;
+        this.$off = $on;
+        this.options.inverse = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.toggleInverse = function() {
+        var $off, $on;
+        this.$wrapper.toggleClass("" + this.options.baseClass + "-inverse");
+        $on = this.$on.clone(true);
+        $off = this.$off.clone(true);
+        this.$on.replaceWith($off);
+        this.$off.replaceWith($on);
+        this.$on = $off;
+        this.$off = $on;
+        this.options.inverse = !this.options.inverse;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onColor = function(value) {
+        var color;
+        color = this.options.onColor;
+        if (typeof value === "undefined") {
+          return color;
+        }
+        if (color != null) {
+          this.$on.removeClass("" + this.options.baseClass + "-" + color);
+        }
+        this.$on.addClass("" + this.options.baseClass + "-" + value);
+        this.options.onColor = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.offColor = function(value) {
+        var color;
+        color = this.options.offColor;
+        if (typeof value === "undefined") {
+          return color;
+        }
+        if (color != null) {
+          this.$off.removeClass("" + this.options.baseClass + "-" + color);
+        }
+        this.$off.addClass("" + this.options.baseClass + "-" + value);
+        this.options.offColor = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onText = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.onText;
+        }
+        this.$on.html(value);
+        this.options.onText = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.offText = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.offText;
+        }
+        this.$off.html(value);
+        this.options.offText = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.labelText = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.labelText;
+        }
+        this.$label.html(value);
+        this.options.labelText = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.baseClass = function(value) {
+        return this.options.baseClass;
+      };
+
+      BootstrapSwitch.prototype.wrapperClass = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.wrapperClass;
+        }
+        if (!value) {
+          value = $.fn.bootstrapSwitch.defaults.wrapperClass;
+        }
+        this.$wrapper.removeClass(this._getClasses(this.options.wrapperClass).join(" "));
+        this.$wrapper.addClass(this._getClasses(value).join(" "));
+        this.options.wrapperClass = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.radioAllOff = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.radioAllOff;
+        }
+        this.options.radioAllOff = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onInit = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.onInit;
+        }
+        if (!value) {
+          value = $.fn.bootstrapSwitch.defaults.onInit;
+        }
+        this.options.onInit = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.onSwitchChange = function(value) {
+        if (typeof value === "undefined") {
+          return this.options.onSwitchChange;
+        }
+        if (!value) {
+          value = $.fn.bootstrapSwitch.defaults.onSwitchChange;
+        }
+        this.options.onSwitchChange = value;
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype.destroy = function() {
+        var $form;
+        $form = this.$element.closest("form");
+        if ($form.length) {
+          $form.off("reset.bootstrapSwitch").removeData("bootstrap-switch");
+        }
+        this.$container.children().not(this.$element).remove();
+        this.$element.unwrap().unwrap().off(".bootstrapSwitch").removeData("bootstrap-switch");
+        return this.$element;
+      };
+
+      BootstrapSwitch.prototype._elementHandlers = function() {
+        return this.$element.on({
+          "change.bootstrapSwitch": (function(_this) {
+            return function(e, skip) {
+              var checked;
+              e.preventDefault();
+              e.stopImmediatePropagation();
+              checked = _this.$element.is(":checked");
+              if (checked === _this.options.state) {
+                return;
+              }
+              _this.options.state = checked;
+              _this.$wrapper.removeClass(checked ? "" + _this.options.baseClass + "-off" : "" + _this.options.baseClass + "-on").addClass(checked ? "" + _this.options.baseClass + "-on" : "" + _this.options.baseClass + "-off");
+              if (!skip) {
+                if (_this.$element.is(":radio")) {
+                  $("[name='" + (_this.$element.attr('name')) + "']").not(_this.$element).prop("checked", false).trigger("change.bootstrapSwitch", true);
+                }
+                return _this.$element.trigger("switchChange.bootstrapSwitch", [checked]);
+              }
+            };
+          })(this),
+          "focus.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              e.preventDefault();
+              return _this.$wrapper.addClass("" + _this.options.baseClass + "-focused");
+            };
+          })(this),
+          "blur.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              e.preventDefault();
+              return _this.$wrapper.removeClass("" + _this.options.baseClass + "-focused");
+            };
+          })(this),
+          "keydown.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              if (!e.which || _this.options.disabled || _this.options.readonly) {
+                return;
+              }
+              switch (e.which) {
+                case 37:
+                  e.preventDefault();
+                  e.stopImmediatePropagation();
+                  return _this.state(false);
+                case 39:
+                  e.preventDefault();
+                  e.stopImmediatePropagation();
+                  return _this.state(true);
+              }
+            };
+          })(this)
+        });
+      };
+
+      BootstrapSwitch.prototype._handleHandlers = function() {
+        this.$on.on("click.bootstrapSwitch", (function(_this) {
+          return function(e) {
+            _this.state(false);
+            return _this.$element.trigger("focus.bootstrapSwitch");
+          };
+        })(this));
+        return this.$off.on("click.bootstrapSwitch", (function(_this) {
+          return function(e) {
+            _this.state(true);
+            return _this.$element.trigger("focus.bootstrapSwitch");
+          };
+        })(this));
+      };
+
+      BootstrapSwitch.prototype._labelHandlers = function() {
+        return this.$label.on({
+          "mousemove.bootstrapSwitch touchmove.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              var left, pageX, percent, right;
+              if (!_this.isLabelDragging) {
+                return;
+              }
+              e.preventDefault();
+              _this.isLabelDragged = true;
+              pageX = e.pageX || e.originalEvent.touches[0].pageX;
+              percent = ((pageX - _this.$wrapper.offset().left) / _this.$wrapper.width()) * 100;
+              left = 25;
+              right = 75;
+              if (_this.options.animate) {
+                _this.$wrapper.removeClass("" + _this.options.baseClass + "-animate");
+              }
+              if (percent < left) {
+                percent = left;
+              } else if (percent > right) {
+                percent = right;
+              }
+              _this.$container.css("margin-left", "" + (percent - right) + "%");
+              return _this.$element.trigger("focus.bootstrapSwitch");
+            };
+          })(this),
+          "mousedown.bootstrapSwitch touchstart.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              if (_this.isLabelDragging || _this.options.disabled || _this.options.readonly) {
+                return;
+              }
+              e.preventDefault();
+              _this.isLabelDragging = true;
+              return _this.$element.trigger("focus.bootstrapSwitch");
+            };
+          })(this),
+          "mouseup.bootstrapSwitch touchend.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              var state;
+              if (!_this.isLabelDragging) {
+                return;
+              }
+              e.preventDefault();
+              if (_this.isLabelDragged) {
+                state = parseInt(_this.$container.css("margin-left"), 10) > -(_this.$container.width() / 6);
+                _this.isLabelDragged = false;
+                _this.state(_this.options.inverse ? !state : state);
+                if (_this.options.animate) {
+                  _this.$wrapper.addClass("" + _this.options.baseClass + "-animate");
+                }
+                _this.$container.css("margin-left", "");
+              } else {
+                _this.state(!_this.options.state);
+              }
+              return _this.isLabelDragging = false;
+            };
+          })(this),
+          "mouseleave.bootstrapSwitch": (function(_this) {
+            return function(e) {
+              return _this.$label.trigger("mouseup.bootstrapSwitch");
+            };
+          })(this)
+        });
+      };
+
+      BootstrapSwitch.prototype._formHandler = function() {
+        var $form;
+        $form = this.$element.closest("form");
+        if ($form.data("bootstrap-switch")) {
+          return;
+        }
+        return $form.on("reset.bootstrapSwitch", function() {
+          return window.setTimeout(function() {
+            return $form.find("input").filter(function() {
+              return $(this).data("bootstrap-switch");
+            }).each(function() {
+              return $(this).bootstrapSwitch("state", this.checked);
+            });
+          }, 1);
+        }).data("bootstrap-switch", true);
+      };
+
+      BootstrapSwitch.prototype._getClasses = function(classes) {
+        var c, cls, _i, _len;
+        if (!$.isArray(classes)) {
+          return ["" + this.options.baseClass + "-" + classes];
+        }
+        cls = [];
+        for (_i = 0, _len = classes.length; _i < _len; _i++) {
+          c = classes[_i];
+          cls.push("" + this.options.baseClass + "-" + c);
+        }
+        return cls;
+      };
+
+      return BootstrapSwitch;
+
+    })();
+    $.fn.bootstrapSwitch = function() {
+      var args, option, ret;
+      option = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      ret = this;
+      this.each(function() {
+        var $this, data;
+        $this = $(this);
+        data = $this.data("bootstrap-switch");
+        if (!data) {
+          $this.data("bootstrap-switch", data = new BootstrapSwitch(this, option));
+        }
+        if (typeof option === "string") {
+          return ret = data[option].apply(data, args);
+        }
+      });
+      return ret;
+    };
+    $.fn.bootstrapSwitch.Constructor = BootstrapSwitch;
+    return $.fn.bootstrapSwitch.defaults = {
+      state: true,
+      size: null,
+      animate: true,
+      disabled: false,
+      readonly: false,
+      indeterminate: false,
+      inverse: false,
+      radioAllOff: false,
+      onColor: "primary",
+      offColor: "default",
+      onText: "ON",
+      offText: "OFF",
+      labelText: "&nbsp;",
+      baseClass: "bootstrap-switch",
+      wrapperClass: "wrapper",
+      onInit: function() {},
+      onSwitchChange: function() {}
+    };
+  })(window.jQuery, window);
+
+}).call(this);
--- a/src/js/lib/bzip2.js
+++ b/src/js/lib/bzip2.js
@ -0,0 +1,263 @@
+/** @license
+========================================================================
+  bzip2.js - a small bzip2 decompression implementation
+  
+  Copyright 2011 by antimatter15 (antimatter15@gmail.com)
+  
+  Based on micro-bunzip by Rob Landley (rob@landley.net).
+
+  Copyright (c) 2011 by antimatter15 (antimatter15@gmail.com).
+
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
+  THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+"use strict";
+
+var bzip2 = {};
+
+bzip2.array = function(bytes){
+  var bit = 0, byte = 0;
+  var BITMASK = [0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF ];
+  return function(n){
+    var result = 0;
+    while(n > 0){
+      var left = 8 - bit;
+      if(n >= left){
+        result <<= left;
+        result |= (BITMASK[left] & bytes[byte++]);
+        bit = 0;
+        n -= left;
+      }else{
+        result <<= n;
+        result |= ((bytes[byte] & (BITMASK[n] << (8 - n - bit))) >> (8 - n - bit));
+        bit += n;
+        n = 0;
+      }
+    }
+    return result
+  }
+}
+
+bzip2.simple = function(bits){
+  var size = bzip2.header(bits);
+  var all = '', chunk = '';
+  do{
+    all += chunk;
+    chunk = bzip2.decompress(bits, size);
+  }while(chunk != -1);
+  return all;
+}
+
+bzip2.header = function(bits){
+  if(bits(8*3) != 4348520) throw "No magic number found";
+  var i = bits(8) - 48;
+  if(i < 1 || i > 9) throw "Not a BZIP archive";
+  return i;
+};
+
+
+//takes a function for reading the block data (starting with 0x314159265359)
+//a block size (0-9) (optional, defaults to 9)
+//a length at which to stop decompressing and return the output
+bzip2.decompress = function(bits, size, len){
+  var MAX_HUFCODE_BITS = 20;
+  var MAX_SYMBOLS = 258;
+  var SYMBOL_RUNA = 0;
+  var SYMBOL_RUNB = 1;
+  var GROUP_SIZE = 50;
+  
+  var bufsize = 100000 * size;
+  for(var h = '', i = 0; i < 6; i++) h += bits(8).toString(16);
+  if(h == "177245385090") return -1; //last block
+  if(h != "314159265359") throw "Not valid bzip data";
+  bits(32); //ignore CRC codes
+  if(bits(1)) throw "Unsupported obsolete version";
+  var origPtr = bits(24);
+  if(origPtr > bufsize) throw "Initial position larger than buffer size";
+  var t = bits(16);
+  var symToByte = new Uint8Array(256), 
+      symTotal = 0;
+  for (i = 0; i < 16; i++) {
+    if(t & (1 << (15 - i))) {
+      var k = bits(16);
+      for(j = 0; j < 16; j++){
+        if(k & (1 << (15 - j))){
+          symToByte[symTotal++] = (16 * i) + j;
+        }
+      }
+    }
+  }
+
+  var groupCount = bits(3);
+  if(groupCount < 2 || groupCount > 6) throw "Error 1";
+  var nSelectors = bits(15);
+  if(nSelectors == 0) throw "Error";
+  var mtfSymbol = []; //TODO: possibly replace JS array with typed arrays
+  for(var i = 0; i < groupCount; i++) mtfSymbol[i] = i;
+  var selectors = new Uint8Array(32768);
+  
+  for(var i = 0; i < nSelectors; i++){
+    for(var j = 0; bits(1); j++) if(j >= groupCount) throw "Error 2"; 
+    var uc = mtfSymbol[j];
+    mtfSymbol.splice(j, 1); //this is a probably inefficient MTF transform
+    mtfSymbol.splice(0, 0, uc);
+    selectors[i] = uc;
+  }
+  
+  var symCount = symTotal + 2;
+  var groups = [];
+  for(var j = 0; j < groupCount; j++){
+    var length = new Uint8Array(MAX_SYMBOLS), 
+        temp = new Uint8Array(MAX_HUFCODE_BITS+1);
+    t = bits(5); //lengths
+    for(var i = 0; i < symCount; i++){
+      while(true){
+        if (t < 1 || t > MAX_HUFCODE_BITS) throw "Error 3";
+        if(!bits(1)) break;
+        if(!bits(1)) t++;
+        else t--;
+      }
+      length[i] = t;
+    }
+    var  minLen,  maxLen;
+    minLen = maxLen = length[0];
+    for(var i = 1; i < symCount; i++){
+      if(length[i] > maxLen) maxLen = length[i];
+      else if(length[i] < minLen) minLen = length[i];
+    }
+    var hufGroup;
+    hufGroup = groups[j] = {};
+    hufGroup.permute = new Uint32Array(MAX_SYMBOLS);
+    hufGroup.limit = new Uint32Array(MAX_HUFCODE_BITS + 1);
+    hufGroup.base = new Uint32Array(MAX_HUFCODE_BITS + 1);
+    hufGroup.minLen = minLen;
+    hufGroup.maxLen = maxLen;
+    var base = hufGroup.base.subarray(1);
+    var limit = hufGroup.limit.subarray(1);
+    var pp = 0;
+    for(var i = minLen; i <= maxLen; i++)
+      for(var t = 0; t < symCount; t++) 
+      if(length[t] == i) hufGroup.permute[pp++] = t;
+      for(i = minLen; i <= maxLen; i++) temp[i] = limit[i] = 0;
+      for(i = 0; i < symCount; i++) temp[length[i]]++;
+      pp = t = 0;
+      for(i = minLen; i < maxLen; i++) {
+        pp += temp[i];
+        limit[i] = pp - 1;
+        pp <<= 1;
+        base[i+1] = pp - (t += temp[i]);
+      }
+      limit[maxLen]=pp+temp[maxLen]-1;
+      base[minLen]=0;
+  }
+  var byteCount = new Uint32Array(256);
+  for(var i = 0; i < 256; i++) mtfSymbol[i] = i;
+  var runPos, count, symCount, selector;
+  runPos = count = symCount = selector = 0;
+  var buf = new Uint32Array(bufsize);
+  while(true){
+    if(!(symCount--)){
+      symCount = GROUP_SIZE - 1;
+      if(selector >= nSelectors) throw "Error 4";
+      hufGroup = groups[selectors[selector++]];
+      base = hufGroup.base.subarray(1);
+      limit = hufGroup.limit.subarray(1);
+    }
+    i = hufGroup.minLen;
+    j = bits(i);
+    while(true){
+      if(i > hufGroup.maxLen) throw "Error 5";
+      if(j <= limit[i]) break;
+      i++;
+      j = (j << 1) | bits(1);
+    }
+    j -= base[i];
+    if(j < 0 || j >= MAX_SYMBOLS) throw "Error 6";
+    var nextSym = hufGroup.permute[j];
+    if (nextSym == SYMBOL_RUNA || nextSym == SYMBOL_RUNB) {
+      if(!runPos){
+        runPos = 1;
+        t = 0;
+      }
+      if(nextSym == SYMBOL_RUNA) t += runPos;
+      else t += 2 * runPos;
+      runPos <<= 1;
+      continue;
+    }
+    if(runPos){
+      runPos = 0;
+      if(count + t >= bufsize) throw "Error 7";
+      uc = symToByte[mtfSymbol[0]];
+      byteCount[uc] += t;
+      while(t--) buf[count++] = uc;
+    }
+    if(nextSym > symTotal) break;
+    if(count >= bufsize) throw "Error 8";
+    i = nextSym -1;
+    uc = mtfSymbol[i];
+    mtfSymbol.splice(i, 1);
+    mtfSymbol.splice(0, 0, uc);
+    uc = symToByte[uc];
+    byteCount[uc]++;
+    buf[count++] = uc;
+  }
+  if(origPtr < 0 || origPtr >= count) throw "Error 9";
+  var j = 0;
+  for(var i = 0; i < 256; i++){
+    k = j + byteCount[i];
+    byteCount[i] = j;
+    j = k;
+  }
+  for(var i = 0; i < count; i++){
+    uc = buf[i] & 0xff;
+    buf[byteCount[uc]] |= (i << 8);
+    byteCount[uc]++;
+  }
+  var pos = 0, current = 0, run = 0;
+  if(count) {
+    pos = buf[origPtr];
+    current = (pos & 0xff);
+    pos >>= 8;
+    run = -1;
+  }
+  count = count;
+  var output = '';
+  var copies, previous, outbyte;
+  if(!len) len = Infinity;
+  while(count){
+    count--;
+    previous = current;
+    pos = buf[pos];
+    current = pos & 0xff;
+    pos >>= 8;
+    if(run++ == 3){
+      copies = current;
+      outbyte = previous;
+      current = -1;
+    }else{
+      copies = 1;
+      outbyte = current;
+    }
+    while(copies--){
+      output += (String.fromCharCode(outbyte));
+      if(!--len) return output;
+    }
+    if(current != previous) run = 0;
+  }
+  return output;
+}
--- a/src/js/lib/canvas_components.js
+++ b/src/js/lib/canvas_components.js
@ -0,0 +1,184 @@
+"use strict";
+
+/**
+ * Various components for drawing diagrams on an HTML5 canvas.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ *
+ * @constant
+ * @namespace
+ */
+var CanvasComponents = {
+
+	draw_line: function(ctx, start_x, start_y, end_x, end_y) {
+		ctx.beginPath();
+		ctx.moveTo(start_x, start_y);
+		ctx.lineTo(end_x, end_y);
+		ctx.closePath();
+		ctx.stroke();
+	},
+
+	draw_bar_chart: function(canvas, scores, x_axis_label, y_axis_label, num_x_labels, num_y_labels, font_size) {
+		font_size = font_size || 15;
+		if (!num_x_labels || num_x_labels > Math.round(canvas.width / 50)) {
+			num_x_labels = Math.round(canvas.width / 50);
+		}
+		if (!num_y_labels || num_y_labels > Math.round(canvas.width / 50)) {
+			num_y_labels = Math.round(canvas.height / 50);
+		}
+		
+		// Graph properties
+		var ctx = canvas.getContext("2d"),
+			left_padding = canvas.width * 0.08,
+			right_padding = canvas.width * 0.03,
+			top_padding = canvas.height * 0.08,
+			bottom_padding = canvas.height * 0.15,
+			graph_height = canvas.height - top_padding - bottom_padding,
+			graph_width = canvas.width - left_padding - right_padding,
+			base = top_padding + graph_height,
+			ceil = top_padding;
+			
+		ctx.font = font_size + "px Arial";
+		
+		// Draw axis
+		ctx.lineWidth = "1.0";
+		ctx.strokeStyle = "#444";
+		CanvasComponents.draw_line(ctx, left_padding, base, graph_width + left_padding, base); // x
+		CanvasComponents.draw_line(ctx, left_padding, base, left_padding, ceil); // y
+		
+		// Bar properties
+		var bar_padding = graph_width * 0.003,
+			bar_width = (graph_width - (bar_padding * scores.length)) / scores.length,
+			curr_x = left_padding + bar_padding,
+			max = Math.max.apply(Math, scores);
+			
+		// Draw bars
+		ctx.fillStyle = "green";
+		for (var i = 0; i < scores.length; i++) {
+			var h = scores[i] / max * graph_height;
+			ctx.fillRect(curr_x, base - h, bar_width, h);
+			curr_x += bar_width + bar_padding;
+		}
+		
+		// Mark x axis
+		ctx.fillStyle = "black";
+		ctx.textAlign = "center";
+		curr_x = left_padding + bar_padding;
+		if (num_x_labels >= scores.length) {
+			// Mark every score
+			for (var i = 0; i <= scores.length; i++) {
+				ctx.fillText(i, curr_x, base + (bottom_padding * 0.3));
+				curr_x += bar_width + bar_padding;
+			}
+		} else {
+			// Mark some scores
+			for (var i = 0; i <= num_x_labels; i++) {
+				var val = Math.ceil((scores.length / num_x_labels) * i);
+				curr_x = (graph_width / num_x_labels) * i + left_padding;
+				ctx.fillText(val, curr_x, base + (bottom_padding * 0.3));
+			}
+		}
+		
+		// Mark y axis
+		ctx.textAlign = "right";
+		var curr_y;
+		if (num_y_labels >= max) {
+			// Mark every increment
+			for (var i = 0; i <= max; i++) {
+				curr_y = base - (i / max * graph_height) + font_size / 3;
+				ctx.fillText(i, left_padding * 0.8, curr_y);
+			}
+		} else {
+			// Mark some increments
+			for (var i = 0; i <= num_y_labels; i++) {
+				var val = Math.ceil((max / num_y_labels) * i);
+				curr_y = base - (val / max * graph_height) + font_size / 3;
+				ctx.fillText(val, left_padding * 0.8, curr_y);
+			}
+		}
+		
+		// Label x axis
+		if (x_axis_label) {
+			ctx.textAlign = "center";
+			ctx.fillText(x_axis_label, graph_width / 2 + left_padding, base + bottom_padding * 0.8);
+		}
+		
+		// Label y axis
+		if (y_axis_label) {
+			ctx.save();
+			var x = left_padding * 0.3,
+				y = graph_height / 2 + top_padding;
+			ctx.translate(x, y);
+			ctx.rotate(-Math.PI / 2);
+			ctx.textAlign = "center";
+			ctx.fillText(y_axis_label, 0, 0);
+			ctx.restore();
+		}
+	},
+	
+	draw_scale_bar: function(canvas, score, max, markings) {
+		// Bar properties
+		var ctx = canvas.getContext("2d"),
+			left_padding = canvas.width * 0.01,
+			right_padding = canvas.width * 0.01,
+			top_padding = canvas.height * 0.1,
+			bottom_padding = canvas.height * 0.3,
+			bar_height = canvas.height - top_padding - bottom_padding,
+			bar_width = canvas.width - left_padding - right_padding;
+		
+		// Scale properties
+		var proportion = score / max;
+		
+		// Draw bar outline
+		ctx.strokeRect(left_padding, top_padding, bar_width, bar_height);
+		
+		// Shade in up to proportion
+		var grad = ctx.createLinearGradient(left_padding, 0, bar_width + left_padding, 0);
+		grad.addColorStop(0, "green");
+		grad.addColorStop(0.5, "gold");
+		grad.addColorStop(1, "red");
+		ctx.fillStyle = grad;
+		ctx.fillRect(left_padding, top_padding, bar_width * proportion, bar_height);
+		
+		// Add markings
+		var x0, y0, x1, y1;
+		ctx.fillStyle = "black";
+		ctx.textAlign = "center";
+		ctx.font = "13px Arial";
+		for (var i = 0; i < markings.length; i++) {
+			// Draw min line down
+			x0 = bar_width / max * markings[i].min + left_padding;
+			y0 = top_padding + bar_height + (bottom_padding * 0.1);
+			x1 = x0;
+			y1 = top_padding + bar_height + (bottom_padding * 0.3);
+			CanvasComponents.draw_line(ctx, x0, y0, x1, y1);
+			
+			// Draw max line down
+			x0 = bar_width / max * markings[i].max + left_padding;
+			x1 = x0;
+			CanvasComponents.draw_line(ctx, x0, y0, x1, y1);
+			
+			// Join min and max lines
+			x0 = bar_width / max * markings[i].min + left_padding;
+			y0 = top_padding + bar_height + (bottom_padding * 0.3);
+			x1 = bar_width / max * markings[i].max + left_padding;
+			y1 = y0;
+			CanvasComponents.draw_line(ctx, x0, y0, x1, y1);
+			
+			// Add label
+			if (markings[i].max >= max * 0.9) {
+				ctx.textAlign = "right";
+				x0 = x1;
+			} else if (markings[i].max <= max * 0.1) {
+				ctx.textAlign = "left";
+			} else {
+				x0 = x0 + (x1 - x0) / 2;
+			}
+			y0 = top_padding + bar_height + (bottom_padding * 0.8);
+			ctx.fillText(markings[i].label, x0, y0);
+		}
+	},
+	
+};
--- a/src/js/lib/cryptojs/aes.js
+++ b/src/js/lib/cryptojs/aes.js
@ -0,0 +1,213 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var BlockCipher = C_lib.BlockCipher;
+    var C_algo = C.algo;
+
+    // Lookup tables
+    var SBOX = [];
+    var INV_SBOX = [];
+    var SUB_MIX_0 = [];
+    var SUB_MIX_1 = [];
+    var SUB_MIX_2 = [];
+    var SUB_MIX_3 = [];
+    var INV_SUB_MIX_0 = [];
+    var INV_SUB_MIX_1 = [];
+    var INV_SUB_MIX_2 = [];
+    var INV_SUB_MIX_3 = [];
+
+    // Compute lookup tables
+    (function () {
+        // Compute double table
+        var d = [];
+        for (var i = 0; i < 256; i++) {
+            if (i < 128) {
+                d[i] = i << 1;
+            } else {
+                d[i] = (i << 1) ^ 0x11b;
+            }
+        }
+
+        // Walk GF(2^8)
+        var x = 0;
+        var xi = 0;
+        for (var i = 0; i < 256; i++) {
+            // Compute sbox
+            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
+            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
+            SBOX[x] = sx;
+            INV_SBOX[sx] = x;
+
+            // Compute multiplication
+            var x2 = d[x];
+            var x4 = d[x2];
+            var x8 = d[x4];
+
+            // Compute sub bytes, mix columns tables
+            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
+            SUB_MIX_0[x] = (t << 24) | (t >>> 8);
+            SUB_MIX_1[x] = (t << 16) | (t >>> 16);
+            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
+            SUB_MIX_3[x] = t;
+
+            // Compute inv sub bytes, inv mix columns tables
+            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
+            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
+            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
+            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
+            INV_SUB_MIX_3[sx] = t;
+
+            // Compute next counter
+            if (!x) {
+                x = xi = 1;
+            } else {
+                x = x2 ^ d[d[d[x8 ^ x2]]];
+                xi ^= d[d[xi]];
+            }
+        }
+    }());
+
+    // Precomputed Rcon lookup
+    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
+
+    /**
+     * AES block cipher algorithm.
+     */
+    var AES = C_algo.AES = BlockCipher.extend({
+        _doReset: function () {
+            // Shortcuts
+            var key = this._key;
+            var keyWords = key.words;
+            var keySize = key.sigBytes / 4;
+
+            // Compute number of rounds
+            var nRounds = this._nRounds = keySize + 6
+
+            // Compute number of key schedule rows
+            var ksRows = (nRounds + 1) * 4;
+
+            // Compute key schedule
+            var keySchedule = this._keySchedule = [];
+            for (var ksRow = 0; ksRow < ksRows; ksRow++) {
+                if (ksRow < keySize) {
+                    keySchedule[ksRow] = keyWords[ksRow];
+                } else {
+                    var t = keySchedule[ksRow - 1];
+
+                    if (!(ksRow % keySize)) {
+                        // Rot word
+                        t = (t << 8) | (t >>> 24);
+
+                        // Sub word
+                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
+
+                        // Mix Rcon
+                        t ^= RCON[(ksRow / keySize) | 0] << 24;
+                    } else if (keySize > 6 && ksRow % keySize == 4) {
+                        // Sub word
+                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
+                    }
+
+                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
+                }
+            }
+
+            // Compute inv key schedule
+            var invKeySchedule = this._invKeySchedule = [];
+            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
+                var ksRow = ksRows - invKsRow;
+
+                if (invKsRow % 4) {
+                    var t = keySchedule[ksRow];
+                } else {
+                    var t = keySchedule[ksRow - 4];
+                }
+
+                if (invKsRow < 4 || ksRow <= 4) {
+                    invKeySchedule[invKsRow] = t;
+                } else {
+                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
+                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
+                }
+            }
+        },
+
+        encryptBlock: function (M, offset) {
+            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
+        },
+
+        decryptBlock: function (M, offset) {
+            // Swap 2nd and 4th rows
+            var t = M[offset + 1];
+            M[offset + 1] = M[offset + 3];
+            M[offset + 3] = t;
+
+            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
+
+            // Inv swap 2nd and 4th rows
+            var t = M[offset + 1];
+            M[offset + 1] = M[offset + 3];
+            M[offset + 3] = t;
+        },
+
+        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
+            // Shortcut
+            var nRounds = this._nRounds;
+
+            // Get input, add round key
+            var s0 = M[offset]     ^ keySchedule[0];
+            var s1 = M[offset + 1] ^ keySchedule[1];
+            var s2 = M[offset + 2] ^ keySchedule[2];
+            var s3 = M[offset + 3] ^ keySchedule[3];
+
+            // Key schedule row counter
+            var ksRow = 4;
+
+            // Rounds
+            for (var round = 1; round < nRounds; round++) {
+                // Shift rows, sub bytes, mix columns, add round key
+                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
+                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
+                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
+                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
+
+                // Update state
+                s0 = t0;
+                s1 = t1;
+                s2 = t2;
+                s3 = t3;
+            }
+
+            // Shift rows, sub bytes, add round key
+            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
+            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
+            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
+            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
+
+            // Set output
+            M[offset]     = t0;
+            M[offset + 1] = t1;
+            M[offset + 2] = t2;
+            M[offset + 3] = t3;
+        },
+
+        keySize: 256/32
+    });
+
+    /**
+     * Shortcut functions to the cipher's object interface.
+     *
+     * @example
+     *
+     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
+     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
+     */
+    C.AES = BlockCipher._createHelper(AES);
+}());
--- a/src/js/lib/cryptojs/cipher-core.js
+++ b/src/js/lib/cryptojs/cipher-core.js
@ -0,0 +1,864 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * Cipher core components.
+ */
+CryptoJS.lib.Cipher || (function (undefined) {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var Base = C_lib.Base;
+    var WordArray = C_lib.WordArray;
+    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
+    var C_enc = C.enc;
+    var Utf8 = C_enc.Utf8;
+    var Base64 = C_enc.Base64;
+    var C_algo = C.algo;
+    var EvpKDF = C_algo.EvpKDF;
+
+    /**
+     * Abstract base cipher template.
+     *
+     * @property {number} keySize This cipher's key size. Default: 4 (128 bits)
+     * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
+     * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
+     * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
+     */
+    var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
+        /**
+         * Configuration options.
+         *
+         * @property {WordArray} iv The IV to use for this operation.
+         */
+        cfg: Base.extend(),
+
+        /**
+         * Creates this cipher in encryption mode.
+         *
+         * @param {WordArray} key The key.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @return {Cipher} A cipher instance.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
+         */
+        createEncryptor: function (key, cfg) {
+            return this.create(this._ENC_XFORM_MODE, key, cfg);
+        },
+
+        /**
+         * Creates this cipher in decryption mode.
+         *
+         * @param {WordArray} key The key.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @return {Cipher} A cipher instance.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
+         */
+        createDecryptor: function (key, cfg) {
+            return this.create(this._DEC_XFORM_MODE, key, cfg);
+        },
+
+        /**
+         * Initializes a newly created cipher.
+         *
+         * @param {number} xformMode Either the encryption or decryption transormation mode constant.
+         * @param {WordArray} key The key.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @example
+         *
+         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
+         */
+        init: function (xformMode, key, cfg) {
+            // Apply config defaults
+            this.cfg = this.cfg.extend(cfg);
+
+            // Store transform mode and key
+            this._xformMode = xformMode;
+            this._key = key;
+
+            // Set initial values
+            this.reset();
+        },
+
+        /**
+         * Resets this cipher to its initial state.
+         *
+         * @example
+         *
+         *     cipher.reset();
+         */
+        reset: function () {
+            // Reset data buffer
+            BufferedBlockAlgorithm.reset.call(this);
+
+            // Perform concrete-cipher logic
+            this._doReset();
+        },
+
+        /**
+         * Adds data to be encrypted or decrypted.
+         *
+         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
+         *
+         * @return {WordArray} The data after processing.
+         *
+         * @example
+         *
+         *     var encrypted = cipher.process('data');
+         *     var encrypted = cipher.process(wordArray);
+         */
+        process: function (dataUpdate) {
+            // Append
+            this._append(dataUpdate);
+
+            // Process available blocks
+            return this._process();
+        },
+
+        /**
+         * Finalizes the encryption or decryption process.
+         * Note that the finalize operation is effectively a destructive, read-once operation.
+         *
+         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
+         *
+         * @return {WordArray} The data after final processing.
+         *
+         * @example
+         *
+         *     var encrypted = cipher.finalize();
+         *     var encrypted = cipher.finalize('data');
+         *     var encrypted = cipher.finalize(wordArray);
+         */
+        finalize: function (dataUpdate) {
+            // Final data update
+            if (dataUpdate) {
+                this._append(dataUpdate);
+            }
+
+            // Perform concrete-cipher logic
+            var finalProcessedData = this._doFinalize();
+
+            return finalProcessedData;
+        },
+
+        keySize: 128/32,
+
+        ivSize: 128/32,
+
+        _ENC_XFORM_MODE: 1,
+
+        _DEC_XFORM_MODE: 2,
+
+        /**
+         * Creates shortcut functions to a cipher's object interface.
+         *
+         * @param {Cipher} cipher The cipher to create a helper for.
+         *
+         * @return {Object} An object with encrypt and decrypt shortcut functions.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
+         */
+        _createHelper: (function () {
+            function selectCipherStrategy(key) {
+                if (typeof key == 'string') {
+                    return PasswordBasedCipher;
+                } else {
+                    return SerializableCipher;
+                }
+            }
+
+            return function (cipher) {
+                return {
+                    encrypt: function (message, key, cfg) {
+                        return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
+                    },
+
+                    decrypt: function (ciphertext, key, cfg) {
+                        return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
+                    }
+                };
+            };
+        }())
+    });
+
+    /**
+     * Abstract base stream cipher template.
+     *
+     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
+     */
+    var StreamCipher = C_lib.StreamCipher = Cipher.extend({
+        _doFinalize: function () {
+            // Process partial blocks
+            var finalProcessedBlocks = this._process(!!'flush');
+
+            return finalProcessedBlocks;
+        },
+
+        blockSize: 1
+    });
+
+    /**
+     * Mode namespace.
+     */
+    var C_mode = C.mode = {};
+
+    /**
+     * Abstract base block cipher mode template.
+     */
+    var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
+        /**
+         * Creates this mode for encryption.
+         *
+         * @param {Cipher} cipher A block cipher instance.
+         * @param {Array} iv The IV words.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
+         */
+        createEncryptor: function (cipher, iv) {
+            return this.Encryptor.create(cipher, iv);
+        },
+
+        /**
+         * Creates this mode for decryption.
+         *
+         * @param {Cipher} cipher A block cipher instance.
+         * @param {Array} iv The IV words.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
+         */
+        createDecryptor: function (cipher, iv) {
+            return this.Decryptor.create(cipher, iv);
+        },
+
+        /**
+         * Initializes a newly created mode.
+         *
+         * @param {Cipher} cipher A block cipher instance.
+         * @param {Array} iv The IV words.
+         *
+         * @example
+         *
+         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
+         */
+        init: function (cipher, iv) {
+            this._cipher = cipher;
+            this._iv = iv;
+        }
+    });
+
+    /**
+     * Cipher Block Chaining mode.
+     */
+    var CBC = C_mode.CBC = (function () {
+        /**
+         * Abstract base CBC mode.
+         */
+        var CBC = BlockCipherMode.extend();
+
+        /**
+         * CBC encryptor.
+         */
+        CBC.Encryptor = CBC.extend({
+            /**
+             * Processes the data block at offset.
+             *
+             * @param {Array} words The data words to operate on.
+             * @param {number} offset The offset where the block starts.
+             *
+             * @example
+             *
+             *     mode.processBlock(data.words, offset);
+             */
+            processBlock: function (words, offset) {
+                // Shortcuts
+                var cipher = this._cipher;
+                var blockSize = cipher.blockSize;
+
+                // XOR and encrypt
+                xorBlock.call(this, words, offset, blockSize);
+                cipher.encryptBlock(words, offset);
+
+                // Remember this block to use with next block
+                this._prevBlock = words.slice(offset, offset + blockSize);
+            }
+        });
+
+        /**
+         * CBC decryptor.
+         */
+        CBC.Decryptor = CBC.extend({
+            /**
+             * Processes the data block at offset.
+             *
+             * @param {Array} words The data words to operate on.
+             * @param {number} offset The offset where the block starts.
+             *
+             * @example
+             *
+             *     mode.processBlock(data.words, offset);
+             */
+            processBlock: function (words, offset) {
+                // Shortcuts
+                var cipher = this._cipher;
+                var blockSize = cipher.blockSize;
+
+                // Remember this block to use with next block
+                var thisBlock = words.slice(offset, offset + blockSize);
+
+                // Decrypt and XOR
+                cipher.decryptBlock(words, offset);
+                xorBlock.call(this, words, offset, blockSize);
+
+                // This block becomes the previous block
+                this._prevBlock = thisBlock;
+            }
+        });
+
+        function xorBlock(words, offset, blockSize) {
+            // Shortcut
+            var iv = this._iv;
+
+            // Choose mixing block
+            if (iv) {
+                var block = iv;
+
+                // Remove IV for subsequent blocks
+                this._iv = undefined;
+            } else {
+                var block = this._prevBlock;
+            }
+
+            // XOR blocks
+            for (var i = 0; i < blockSize; i++) {
+                words[offset + i] ^= block[i];
+            }
+        }
+
+        return CBC;
+    }());
+
+    /**
+     * Padding namespace.
+     */
+    var C_pad = C.pad = {};
+
+    /**
+     * PKCS #5/7 padding strategy.
+     */
+    var Pkcs7 = C_pad.Pkcs7 = {
+        /**
+         * Pads data using the algorithm defined in PKCS #5/7.
+         *
+         * @param {WordArray} data The data to pad.
+         * @param {number} blockSize The multiple that the data should be padded to.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
+         */
+        pad: function (data, blockSize) {
+            // Shortcut
+            var blockSizeBytes = blockSize * 4;
+
+            // Count padding bytes
+            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+
+            // Create padding word
+            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
+
+            // Create padding
+            var paddingWords = [];
+            for (var i = 0; i < nPaddingBytes; i += 4) {
+                paddingWords.push(paddingWord);
+            }
+            var padding = WordArray.create(paddingWords, nPaddingBytes);
+
+            // Add padding
+            data.concat(padding);
+        },
+
+        /**
+         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
+         *
+         * @param {WordArray} data The data to unpad.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     CryptoJS.pad.Pkcs7.unpad(wordArray);
+         */
+        unpad: function (data) {
+            // Get number of padding bytes from last byte
+            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+            // Remove padding
+            data.sigBytes -= nPaddingBytes;
+        }
+    };
+
+    /**
+     * Abstract base block cipher template.
+     *
+     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
+     */
+    var BlockCipher = C_lib.BlockCipher = Cipher.extend({
+        /**
+         * Configuration options.
+         *
+         * @property {Mode} mode The block mode to use. Default: CBC
+         * @property {Padding} padding The padding strategy to use. Default: Pkcs7
+         */
+        cfg: Cipher.cfg.extend({
+            mode: CBC,
+            padding: Pkcs7
+        }),
+
+        reset: function () {
+            // Reset cipher
+            Cipher.reset.call(this);
+
+            // Shortcuts
+            var cfg = this.cfg;
+            var iv = cfg.iv;
+            var mode = cfg.mode;
+
+            // Reset block mode
+            if (this._xformMode == this._ENC_XFORM_MODE) {
+                var modeCreator = mode.createEncryptor;
+            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
+                var modeCreator = mode.createDecryptor;
+
+                // Keep at least one block in the buffer for unpadding
+                this._minBufferSize = 1;
+            }
+            this._mode = modeCreator.call(mode, this, iv && iv.words);
+        },
+
+        _doProcessBlock: function (words, offset) {
+            this._mode.processBlock(words, offset);
+        },
+
+        _doFinalize: function () {
+            // Shortcut
+            var padding = this.cfg.padding;
+
+            // Finalize
+            if (this._xformMode == this._ENC_XFORM_MODE) {
+                // Pad data
+                padding.pad(this._data, this.blockSize);
+
+                // Process final blocks
+                var finalProcessedBlocks = this._process(!!'flush');
+            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
+                // Process final blocks
+                var finalProcessedBlocks = this._process(!!'flush');
+
+                // Unpad data
+                padding.unpad(finalProcessedBlocks);
+            }
+
+            return finalProcessedBlocks;
+        },
+
+        blockSize: 128/32
+    });
+
+    /**
+     * A collection of cipher parameters.
+     *
+     * @property {WordArray} ciphertext The raw ciphertext.
+     * @property {WordArray} key The key to this ciphertext.
+     * @property {WordArray} iv The IV used in the ciphering operation.
+     * @property {WordArray} salt The salt used with a key derivation function.
+     * @property {Cipher} algorithm The cipher algorithm.
+     * @property {Mode} mode The block mode used in the ciphering operation.
+     * @property {Padding} padding The padding scheme used in the ciphering operation.
+     * @property {number} blockSize The block size of the cipher.
+     * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
+     */
+    var CipherParams = C_lib.CipherParams = Base.extend({
+        /**
+         * Initializes a newly created cipher params object.
+         *
+         * @param {Object} cipherParams An object with any of the possible cipher parameters.
+         *
+         * @example
+         *
+         *     var cipherParams = CryptoJS.lib.CipherParams.create({
+         *         ciphertext: ciphertextWordArray,
+         *         key: keyWordArray,
+         *         iv: ivWordArray,
+         *         salt: saltWordArray,
+         *         algorithm: CryptoJS.algo.AES,
+         *         mode: CryptoJS.mode.CBC,
+         *         padding: CryptoJS.pad.PKCS7,
+         *         blockSize: 4,
+         *         formatter: CryptoJS.format.OpenSSL
+         *     });
+         */
+        init: function (cipherParams) {
+            this.mixIn(cipherParams);
+        },
+
+        /**
+         * Converts this cipher params object to a string.
+         *
+         * @param {Format} formatter (Optional) The formatting strategy to use.
+         *
+         * @return {string} The stringified cipher params.
+         *
+         * @throws Error If neither the formatter nor the default formatter is set.
+         *
+         * @example
+         *
+         *     var string = cipherParams + '';
+         *     var string = cipherParams.toString();
+         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);
+         */
+        toString: function (formatter) {
+            return (formatter || this.formatter).stringify(this);
+        }
+    });
+
+    /**
+     * Format namespace.
+     */
+    var C_format = C.format = {};
+
+    /**
+     * OpenSSL formatting strategy.
+     */
+    var OpenSSLFormatter = C_format.OpenSSL = {
+        /**
+         * Converts a cipher params object to an OpenSSL-compatible string.
+         *
+         * @param {CipherParams} cipherParams The cipher params object.
+         *
+         * @return {string} The OpenSSL-compatible string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
+         */
+        stringify: function (cipherParams) {
+            // Shortcuts
+            var ciphertext = cipherParams.ciphertext;
+            var salt = cipherParams.salt;
+
+            // Format
+            if (salt) {
+                var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
+            } else {
+                var wordArray = ciphertext;
+            }
+
+            return wordArray.toString(Base64);
+        },
+
+        /**
+         * Converts an OpenSSL-compatible string to a cipher params object.
+         *
+         * @param {string} openSSLStr The OpenSSL-compatible string.
+         *
+         * @return {CipherParams} The cipher params object.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
+         */
+        parse: function (openSSLStr) {
+            // Parse base64
+            var ciphertext = Base64.parse(openSSLStr);
+
+            // Shortcut
+            var ciphertextWords = ciphertext.words;
+
+            // Test for salt
+            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
+                // Extract salt
+                var salt = WordArray.create(ciphertextWords.slice(2, 4));
+
+                // Remove salt from ciphertext
+                ciphertextWords.splice(0, 4);
+                ciphertext.sigBytes -= 16;
+            }
+
+            return CipherParams.create({ ciphertext: ciphertext, salt: salt });
+        }
+    };
+
+    /**
+     * A cipher wrapper that returns ciphertext as a serializable cipher params object.
+     */
+    var SerializableCipher = C_lib.SerializableCipher = Base.extend({
+        /**
+         * Configuration options.
+         *
+         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
+         */
+        cfg: Base.extend({
+            format: OpenSSLFormatter
+        }),
+
+        /**
+         * Encrypts a message.
+         *
+         * @param {Cipher} cipher The cipher algorithm to use.
+         * @param {WordArray|string} message The message to encrypt.
+         * @param {WordArray} key The key.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @return {CipherParams} A cipher params object.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
+         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
+         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
+         */
+        encrypt: function (cipher, message, key, cfg) {
+            // Apply config defaults
+            cfg = this.cfg.extend(cfg);
+
+            // Encrypt
+            var encryptor = cipher.createEncryptor(key, cfg);
+            var ciphertext = encryptor.finalize(message);
+
+            // Shortcut
+            var cipherCfg = encryptor.cfg;
+
+            // Create and return serializable cipher params
+            return CipherParams.create({
+                ciphertext: ciphertext,
+                key: key,
+                iv: cipherCfg.iv,
+                algorithm: cipher,
+                mode: cipherCfg.mode,
+                padding: cipherCfg.padding,
+                blockSize: cipher.blockSize,
+                formatter: cfg.format
+            });
+        },
+
+        /**
+         * Decrypts serialized ciphertext.
+         *
+         * @param {Cipher} cipher The cipher algorithm to use.
+         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
+         * @param {WordArray} key The key.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @return {WordArray} The plaintext.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
+         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
+         */
+        decrypt: function (cipher, ciphertext, key, cfg) {
+            // Apply config defaults
+            cfg = this.cfg.extend(cfg);
+
+            // Convert string to CipherParams
+            ciphertext = this._parse(ciphertext, cfg.format);
+
+            // Decrypt
+            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
+
+            return plaintext;
+        },
+
+        /**
+         * Converts serialized ciphertext to CipherParams,
+         * else assumed CipherParams already and returns ciphertext unchanged.
+         *
+         * @param {CipherParams|string} ciphertext The ciphertext.
+         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
+         *
+         * @return {CipherParams} The unserialized ciphertext.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+         */
+        _parse: function (ciphertext, format) {
+            if (typeof ciphertext == 'string') {
+                return format.parse(ciphertext, this);
+            } else {
+                return ciphertext;
+            }
+        }
+    });
+
+    /**
+     * Key derivation function namespace.
+     */
+    var C_kdf = C.kdf = {};
+
+    /**
+     * OpenSSL key derivation function.
+     */
+    var OpenSSLKdf = C_kdf.OpenSSL = {
+        /**
+         * Derives a key and IV from a password.
+         *
+         * @param {string} password The password to derive from.
+         * @param {number} keySize The size in words of the key to generate.
+         * @param {number} ivSize The size in words of the IV to generate.
+         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
+         *
+         * @return {CipherParams} A cipher params object with the key, IV, and salt.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
+         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
+         */
+        execute: function (password, keySize, ivSize, salt) {
+            // Generate random salt
+            if (!salt) {
+                salt = WordArray.random(64/8);
+            }
+
+            // Derive key and IV
+            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
+
+            // Separate key and IV
+            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
+            key.sigBytes = keySize * 4;
+
+            // Return params
+            return CipherParams.create({ key: key, iv: iv, salt: salt });
+        }
+    };
+
+    /**
+     * A serializable cipher wrapper that derives the key from a password,
+     * and returns ciphertext as a serializable cipher params object.
+     */
+    var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
+        /**
+         * Configuration options.
+         *
+         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
+         */
+        cfg: SerializableCipher.cfg.extend({
+            kdf: OpenSSLKdf
+        }),
+
+        /**
+         * Encrypts a message using a password.
+         *
+         * @param {Cipher} cipher The cipher algorithm to use.
+         * @param {WordArray|string} message The message to encrypt.
+         * @param {string} password The password.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @return {CipherParams} A cipher params object.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
+         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
+         */
+        encrypt: function (cipher, message, password, cfg) {
+            // Apply config defaults
+            cfg = this.cfg.extend(cfg);
+
+            // Derive key and other params
+			// MODIFIED: added cfg.salt param
+            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt);
+
+            // Add IV to config
+            cfg.iv = derivedParams.iv;
+
+            // Encrypt
+            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
+
+            // Mix in derived params
+            ciphertext.mixIn(derivedParams);
+
+            return ciphertext;
+        },
+
+        /**
+         * Decrypts serialized ciphertext using a password.
+         *
+         * @param {Cipher} cipher The cipher algorithm to use.
+         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
+         * @param {string} password The password.
+         * @param {Object} cfg (Optional) The configuration options to use for this operation.
+         *
+         * @return {WordArray} The plaintext.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
+         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
+         */
+        decrypt: function (cipher, ciphertext, password, cfg) {
+            // Apply config defaults
+            cfg = this.cfg.extend(cfg);
+
+            // Convert string to CipherParams
+            ciphertext = this._parse(ciphertext, cfg.format);
+
+            // Derive key and other params
+            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
+
+            // Add IV to config
+            cfg.iv = derivedParams.iv;
+
+            // Decrypt
+            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
+
+            return plaintext;
+        }
+    });
+}());
--- a/src/js/lib/cryptojs/core.js
+++ b/src/js/lib/cryptojs/core.js
@ -0,0 +1,713 @@
+/** @license
+========================================================================
+  CryptoJS v3.1.2
+  code.google.com/p/crypto-js
+  (c) 2009-2013 by Jeff Mott. All rights reserved.
+  code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * CryptoJS core components.
+ */
+var CryptoJS = CryptoJS || (function (Math, undefined) {
+    /**
+     * CryptoJS namespace.
+     */
+    var C = {};
+
+    /**
+     * Library namespace.
+     */
+    var C_lib = C.lib = {};
+
+    /**
+     * Base object for prototypal inheritance.
+     */
+    var Base = C_lib.Base = (function () {
+        function F() {}
+
+        return {
+            /**
+             * Creates a new object that inherits from this object.
+             *
+             * @param {Object} overrides Properties to copy into the new object.
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         field: 'value',
+             *
+             *         method: function () {
+             *         }
+             *     });
+             */
+            extend: function (overrides) {
+                // Spawn
+                F.prototype = this;
+                var subtype = new F();
+
+                // Augment
+                if (overrides) {
+                    subtype.mixIn(overrides);
+                }
+
+                // Create default initializer
+                if (!subtype.hasOwnProperty('init')) {
+                    subtype.init = function () {
+                        subtype.$super.init.apply(this, arguments);
+                    };
+                }
+
+                // Initializer's prototype is the subtype object
+                subtype.init.prototype = subtype;
+
+                // Reference supertype
+                subtype.$super = this;
+
+                return subtype;
+            },
+
+            /**
+             * Extends this object and runs the init method.
+             * Arguments to create() will be passed to init().
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var instance = MyType.create();
+             */
+            create: function () {
+                var instance = this.extend();
+                instance.init.apply(instance, arguments);
+
+                return instance;
+            },
+
+            /**
+             * Initializes a newly created object.
+             * Override this method to add some logic when your objects are created.
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         init: function () {
+             *             // ...
+             *         }
+             *     });
+             */
+            init: function () {
+            },
+
+            /**
+             * Copies properties into this object.
+             *
+             * @param {Object} properties The properties to mix in.
+             *
+             * @example
+             *
+             *     MyType.mixIn({
+             *         field: 'value'
+             *     });
+             */
+            mixIn: function (properties) {
+                for (var propertyName in properties) {
+                    if (properties.hasOwnProperty(propertyName)) {
+                        this[propertyName] = properties[propertyName];
+                    }
+                }
+
+                // IE won't copy toString using the loop above
+                if (properties.hasOwnProperty('toString')) {
+                    this.toString = properties.toString;
+                }
+            },
+
+            /**
+             * Creates a copy of this object.
+             *
+             * @return {Object} The clone.
+             *
+             * @example
+             *
+             *     var clone = instance.clone();
+             */
+            clone: function () {
+                return this.init.prototype.extend(this);
+            }
+        };
+    }());
+
+    /**
+     * An array of 32-bit words.
+     *
+     * @property {Array} words The array of 32-bit words.
+     * @property {number} sigBytes The number of significant bytes in this word array.
+     */
+    var WordArray = C_lib.WordArray = Base.extend({
+        /**
+         * Initializes a newly created word array.
+         *
+         * @param {Array} words (Optional) An array of 32-bit words.
+         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.lib.WordArray.create();
+         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+         */
+        init: function (words, sigBytes) {
+            words = this.words = words || [];
+
+            if (sigBytes != undefined) {
+                this.sigBytes = sigBytes;
+            } else {
+                this.sigBytes = words.length * 4;
+            }
+        },
+
+        /**
+         * Converts this word array to a string.
+         *
+         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+         *
+         * @return {string} The stringified word array.
+         *
+         * @example
+         *
+         *     var string = wordArray + '';
+         *     var string = wordArray.toString();
+         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+         */
+        toString: function (encoder) {
+            return (encoder || Hex).stringify(this);
+        },
+
+        /**
+         * Concatenates a word array to this word array.
+         *
+         * @param {WordArray} wordArray The word array to append.
+         *
+         * @return {WordArray} This word array.
+         *
+         * @example
+         *
+         *     wordArray1.concat(wordArray2);
+         */
+        concat: function (wordArray) {
+            // Shortcuts
+            var thisWords = this.words;
+            var thatWords = wordArray.words;
+            var thisSigBytes = this.sigBytes;
+            var thatSigBytes = wordArray.sigBytes;
+
+            // Clamp excess bits
+            this.clamp();
+
+            // Concat
+            if (thisSigBytes % 4) {
+                // Copy one byte at a time
+                for (var i = 0; i < thatSigBytes; i++) {
+                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+                }
+            } else if (thatWords.length > 0xffff) {
+                // Copy one word at a time
+                for (var i = 0; i < thatSigBytes; i += 4) {
+                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
+                }
+            } else {
+                // Copy all words at once
+                thisWords.push.apply(thisWords, thatWords);
+            }
+            this.sigBytes += thatSigBytes;
+
+            // Chainable
+            return this;
+        },
+
+        /**
+         * Removes insignificant bits.
+         *
+         * @example
+         *
+         *     wordArray.clamp();
+         */
+        clamp: function () {
+            // Shortcuts
+            var words = this.words;
+            var sigBytes = this.sigBytes;
+
+            // Clamp
+            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
+            words.length = Math.ceil(sigBytes / 4);
+        },
+
+        /**
+         * Creates a copy of this word array.
+         *
+         * @return {WordArray} The clone.
+         *
+         * @example
+         *
+         *     var clone = wordArray.clone();
+         */
+        clone: function () {
+            var clone = Base.clone.call(this);
+            clone.words = this.words.slice(0);
+
+            return clone;
+        },
+
+        /**
+         * Creates a word array filled with random bytes.
+         *
+         * @param {number} nBytes The number of random bytes to generate.
+         *
+         * @return {WordArray} The random word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.lib.WordArray.random(16);
+         */
+        random: function (nBytes) {
+            var words = [];
+            for (var i = 0; i < nBytes; i += 4) {
+                words.push((Math.random() * 0x100000000) | 0);
+            }
+
+            return new WordArray.init(words, nBytes);
+        }
+    });
+
+    /**
+     * Encoder namespace.
+     */
+    var C_enc = C.enc = {};
+
+    /**
+     * Hex encoding strategy.
+     */
+    var Hex = C_enc.Hex = {
+        /**
+         * Converts a word array to a hex string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The hex string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+
+            // Convert
+            var hexChars = [];
+            for (var i = 0; i < sigBytes; i++) {
+                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+                hexChars.push((bite >>> 4).toString(16));
+                hexChars.push((bite & 0x0f).toString(16));
+            }
+
+            return hexChars.join('');
+        },
+
+        /**
+         * Converts a hex string to a word array.
+         *
+         * @param {string} hexStr The hex string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+         */
+        parse: function (hexStr) {
+            // Shortcut
+            var hexStrLength = hexStr.length;
+
+            // Convert
+            var words = [];
+            for (var i = 0; i < hexStrLength; i += 2) {
+                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
+            }
+
+            return new WordArray.init(words, hexStrLength / 2);
+        }
+    };
+
+    /**
+     * Latin1 encoding strategy.
+     */
+    var Latin1 = C_enc.Latin1 = {
+        /**
+         * Converts a word array to a Latin1 string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The Latin1 string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+
+            // Convert
+            var latin1Chars = [];
+            for (var i = 0; i < sigBytes; i++) {
+                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+                latin1Chars.push(String.fromCharCode(bite));
+            }
+
+            return latin1Chars.join('');
+        },
+
+        /**
+         * Converts a Latin1 string to a word array.
+         *
+         * @param {string} latin1Str The Latin1 string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+         */
+        parse: function (latin1Str) {
+            // Shortcut
+            var latin1StrLength = latin1Str.length;
+
+            // Convert
+            var words = [];
+            for (var i = 0; i < latin1StrLength; i++) {
+                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+            }
+
+            return new WordArray.init(words, latin1StrLength);
+        }
+    };
+
+    /**
+     * UTF-8 encoding strategy.
+     */
+    var Utf8 = C_enc.Utf8 = {
+        /**
+         * Converts a word array to a UTF-8 string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The UTF-8 string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            try {
+                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+            } catch (e) {
+                throw new Error('Malformed UTF-8 data');
+            }
+        },
+
+        /**
+         * Converts a UTF-8 string to a word array.
+         *
+         * @param {string} utf8Str The UTF-8 string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+         */
+        parse: function (utf8Str) {
+            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+        }
+    };
+
+    /**
+     * Abstract buffered block algorithm template.
+     *
+     * The property blockSize must be implemented in a concrete subtype.
+     *
+     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
+     */
+    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+        /**
+         * Resets this block algorithm's data buffer to its initial state.
+         *
+         * @example
+         *
+         *     bufferedBlockAlgorithm.reset();
+         */
+        reset: function () {
+            // Initial values
+            this._data = new WordArray.init();
+            this._nDataBytes = 0;
+        },
+
+        /**
+         * Adds new data to this block algorithm's buffer.
+         *
+         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+         *
+         * @example
+         *
+         *     bufferedBlockAlgorithm._append('data');
+         *     bufferedBlockAlgorithm._append(wordArray);
+         */
+        _append: function (data) {
+            // Convert string to WordArray, else assume WordArray already
+            if (typeof data == 'string') {
+                data = Utf8.parse(data);
+            }
+
+            // Append
+            this._data.concat(data);
+            this._nDataBytes += data.sigBytes;
+        },
+
+        /**
+         * Processes available data blocks.
+         *
+         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+         *
+         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+         *
+         * @return {WordArray} The processed data.
+         *
+         * @example
+         *
+         *     var processedData = bufferedBlockAlgorithm._process();
+         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+         */
+        _process: function (doFlush) {
+            // Shortcuts
+            var data = this._data;
+            var dataWords = data.words;
+            var dataSigBytes = data.sigBytes;
+            var blockSize = this.blockSize;
+            var blockSizeBytes = blockSize * 4;
+
+            // Count blocks ready
+            var nBlocksReady = dataSigBytes / blockSizeBytes;
+            if (doFlush) {
+                // Round up to include partial blocks
+                nBlocksReady = Math.ceil(nBlocksReady);
+            } else {
+                // Round down to include only full blocks,
+                // less the number of blocks that must remain in the buffer
+                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+            }
+
+            // Count words ready
+            var nWordsReady = nBlocksReady * blockSize;
+
+            // Count bytes ready
+            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+
+            // Process blocks
+            if (nWordsReady) {
+                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+                    // Perform concrete-algorithm logic
+                    this._doProcessBlock(dataWords, offset);
+                }
+
+                // Remove processed words
+                var processedWords = dataWords.splice(0, nWordsReady);
+                data.sigBytes -= nBytesReady;
+            }
+
+            // Return processed words
+            return new WordArray.init(processedWords, nBytesReady);
+        },
+
+        /**
+         * Creates a copy of this object.
+         *
+         * @return {Object} The clone.
+         *
+         * @example
+         *
+         *     var clone = bufferedBlockAlgorithm.clone();
+         */
+        clone: function () {
+            var clone = Base.clone.call(this);
+            clone._data = this._data.clone();
+
+            return clone;
+        },
+
+        _minBufferSize: 0
+    });
+
+    /**
+     * Abstract hasher template.
+     *
+     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
+     */
+    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+        /**
+         * Configuration options.
+         */
+        cfg: Base.extend(),
+
+        /**
+         * Initializes a newly created hasher.
+         *
+         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+         *
+         * @example
+         *
+         *     var hasher = CryptoJS.algo.SHA256.create();
+         */
+        init: function (cfg) {
+            // Apply config defaults
+            this.cfg = this.cfg.extend(cfg);
+
+            // Set initial values
+            this.reset();
+        },
+
+        /**
+         * Resets this hasher to its initial state.
+         *
+         * @example
+         *
+         *     hasher.reset();
+         */
+        reset: function () {
+            // Reset data buffer
+            BufferedBlockAlgorithm.reset.call(this);
+
+            // Perform concrete-hasher logic
+            this._doReset();
+        },
+
+        /**
+         * Updates this hasher with a message.
+         *
+         * @param {WordArray|string} messageUpdate The message to append.
+         *
+         * @return {Hasher} This hasher.
+         *
+         * @example
+         *
+         *     hasher.update('message');
+         *     hasher.update(wordArray);
+         */
+        update: function (messageUpdate) {
+            // Append
+            this._append(messageUpdate);
+
+            // Update the hash
+            this._process();
+
+            // Chainable
+            return this;
+        },
+
+        /**
+         * Finalizes the hash computation.
+         * Note that the finalize operation is effectively a destructive, read-once operation.
+         *
+         * @param {WordArray|string} messageUpdate (Optional) A final message update.
+         *
+         * @return {WordArray} The hash.
+         *
+         * @example
+         *
+         *     var hash = hasher.finalize();
+         *     var hash = hasher.finalize('message');
+         *     var hash = hasher.finalize(wordArray);
+         */
+        finalize: function (messageUpdate) {
+            // Final message update
+            if (messageUpdate) {
+                this._append(messageUpdate);
+            }
+
+            // Perform concrete-hasher logic
+            var hash = this._doFinalize();
+
+            return hash;
+        },
+
+        blockSize: 512/32,
+
+        /**
+         * Creates a shortcut function to a hasher's object interface.
+         *
+         * @param {Hasher} hasher The hasher to create a helper for.
+         *
+         * @return {Function} The shortcut function.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+         */
+        _createHelper: function (hasher) {
+            return function (message, cfg) {
+                return new hasher.init(cfg).finalize(message);
+            };
+        },
+
+        /**
+         * Creates a shortcut function to the HMAC's object interface.
+         *
+         * @param {Hasher} hasher The hasher to use in this HMAC helper.
+         *
+         * @return {Function} The shortcut function.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+         */
+        _createHmacHelper: function (hasher) {
+            return function (message, key) {
+                return new C_algo.HMAC.init(hasher, key).finalize(message);
+            };
+        }
+    });
+
+    /**
+     * Algorithm namespace.
+     */
+    var C_algo = C.algo = {};
+
+    return C;
+}(Math));
--- a/src/js/lib/cryptojs/enc-base64.js
+++ b/src/js/lib/cryptojs/enc-base64.js
@ -0,0 +1,109 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var WordArray = C_lib.WordArray;
+    var C_enc = C.enc;
+
+    /**
+     * Base64 encoding strategy.
+     */
+    var Base64 = C_enc.Base64 = {
+        /**
+         * Converts a word array to a Base64 string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The Base64 string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var map = this._map;
+
+            // Clamp excess bits
+            wordArray.clamp();
+
+            // Convert
+            var base64Chars = [];
+            for (var i = 0; i < sigBytes; i += 3) {
+                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
+                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
+                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
+
+                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+
+                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
+                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
+                }
+            }
+
+            // Add padding
+            var paddingChar = map.charAt(64);
+            if (paddingChar) {
+                while (base64Chars.length % 4) {
+                    base64Chars.push(paddingChar);
+                }
+            }
+
+            return base64Chars.join('');
+        },
+
+        /**
+         * Converts a Base64 string to a word array.
+         *
+         * @param {string} base64Str The Base64 string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+         */
+        parse: function (base64Str) {
+            // Shortcuts
+            var base64StrLength = base64Str.length;
+            var map = this._map;
+
+            // Ignore padding
+            var paddingChar = map.charAt(64);
+            if (paddingChar) {
+                var paddingIndex = base64Str.indexOf(paddingChar);
+                if (paddingIndex != -1) {
+                    base64StrLength = paddingIndex;
+                }
+            }
+
+            // Convert
+            var words = [];
+            var nBytes = 0;
+            for (var i = 0; i < base64StrLength; i++) {
+                if (i % 4) {
+                    var bits1 = map.indexOf(base64Str.charAt(i - 1)) << ((i % 4) * 2);
+                    var bits2 = map.indexOf(base64Str.charAt(i)) >>> (6 - (i % 4) * 2);
+                    words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
+                    nBytes++;
+                }
+            }
+
+            return WordArray.create(words, nBytes);
+        },
+
+        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+    };
+}());
--- a/src/js/lib/cryptojs/enc-utf16.js
+++ b/src/js/lib/cryptojs/enc-utf16.js
@ -0,0 +1,135 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var WordArray = C_lib.WordArray;
+    var C_enc = C.enc;
+
+    /**
+     * UTF-16 BE encoding strategy.
+     */
+    var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = {
+        /**
+         * Converts a word array to a UTF-16 BE string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The UTF-16 BE string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+
+            // Convert
+            var utf16Chars = [];
+            for (var i = 0; i < sigBytes; i += 2) {
+                var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
+                utf16Chars.push(String.fromCharCode(codePoint));
+            }
+
+            return utf16Chars.join('');
+        },
+
+        /**
+         * Converts a UTF-16 BE string to a word array.
+         *
+         * @param {string} utf16Str The UTF-16 BE string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
+         */
+        parse: function (utf16Str) {
+            // Shortcut
+            var utf16StrLength = utf16Str.length;
+
+            // Convert
+            var words = [];
+            for (var i = 0; i < utf16StrLength; i++) {
+                words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
+            }
+
+            return WordArray.create(words, utf16StrLength * 2);
+        }
+    };
+
+    /**
+     * UTF-16 LE encoding strategy.
+     */
+    C_enc.Utf16LE = {
+        /**
+         * Converts a word array to a UTF-16 LE string.
+         *
+         * @param {WordArray} wordArray The word array.
+         *
+         * @return {string} The UTF-16 LE string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
+         */
+        stringify: function (wordArray) {
+            // Shortcuts
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+
+            // Convert
+            var utf16Chars = [];
+            for (var i = 0; i < sigBytes; i += 2) {
+                var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
+                utf16Chars.push(String.fromCharCode(codePoint));
+            }
+
+            return utf16Chars.join('');
+        },
+
+        /**
+         * Converts a UTF-16 LE string to a word array.
+         *
+         * @param {string} utf16Str The UTF-16 LE string.
+         *
+         * @return {WordArray} The word array.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
+         */
+        parse: function (utf16Str) {
+            // Shortcut
+            var utf16StrLength = utf16Str.length;
+
+            // Convert
+            var words = [];
+            for (var i = 0; i < utf16StrLength; i++) {
+                words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
+            }
+
+            return WordArray.create(words, utf16StrLength * 2);
+        }
+    };
+
+    function swapEndian(word) {
+        return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
+    }
+}());
--- a/src/js/lib/cryptojs/evpkdf.js
+++ b/src/js/lib/cryptojs/evpkdf.js
@ -0,0 +1,118 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var Base = C_lib.Base;
+    var WordArray = C_lib.WordArray;
+    var C_algo = C.algo;
+    var MD5 = C_algo.MD5;
+
+    /**
+     * This key derivation function is meant to conform with EVP_BytesToKey.
+     * www.openssl.org/docs/crypto/EVP_BytesToKey.html
+     */
+    var EvpKDF = C_algo.EvpKDF = Base.extend({
+        /**
+         * Configuration options.
+         *
+         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+         * @property {Hasher} hasher The hash algorithm to use. Default: MD5
+         * @property {number} iterations The number of iterations to perform. Default: 1
+         */
+        cfg: Base.extend({
+            keySize: 128/32,
+            hasher: MD5,
+            iterations: 1
+        }),
+
+        /**
+         * Initializes a newly created key derivation function.
+         *
+         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+         *
+         * @example
+         *
+         *     var kdf = CryptoJS.algo.EvpKDF.create();
+         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
+         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
+         */
+        init: function (cfg) {
+            this.cfg = this.cfg.extend(cfg);
+        },
+
+        /**
+         * Derives a key from a password.
+         *
+         * @param {WordArray|string} password The password.
+         * @param {WordArray|string} salt A salt.
+         *
+         * @return {WordArray} The derived key.
+         *
+         * @example
+         *
+         *     var key = kdf.compute(password, salt);
+         */
+        compute: function (password, salt) {
+            // Shortcut
+            var cfg = this.cfg;
+
+            // Init hasher
+            var hasher = cfg.hasher.create();
+
+            // Initial values
+            var derivedKey = WordArray.create();
+
+            // Shortcuts
+            var derivedKeyWords = derivedKey.words;
+            var keySize = cfg.keySize;
+            var iterations = cfg.iterations;
+
+            // Generate key
+            while (derivedKeyWords.length < keySize) {
+                if (block) {
+                    hasher.update(block);
+                }
+                var block = hasher.update(password).finalize(salt);
+                hasher.reset();
+
+                // Iterations
+                for (var i = 1; i < iterations; i++) {
+                    block = hasher.finalize(block);
+                    hasher.reset();
+                }
+
+                derivedKey.concat(block);
+            }
+            derivedKey.sigBytes = keySize * 4;
+
+            return derivedKey;
+        }
+    });
+
+    /**
+     * Derives a key from a password.
+     *
+     * @param {WordArray|string} password The password.
+     * @param {WordArray|string} salt A salt.
+     * @param {Object} cfg (Optional) The configuration options to use for this computation.
+     *
+     * @return {WordArray} The derived key.
+     *
+     * @static
+     *
+     * @example
+     *
+     *     var key = CryptoJS.EvpKDF(password, salt);
+     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
+     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
+     */
+    C.EvpKDF = function (password, salt, cfg) {
+        return EvpKDF.create(cfg).compute(password, salt);
+    };
+}());
--- a/src/js/lib/cryptojs/format-hex.js
+++ b/src/js/lib/cryptojs/format-hex.js
@ -0,0 +1,52 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function (undefined) {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var CipherParams = C_lib.CipherParams;
+    var C_enc = C.enc;
+    var Hex = C_enc.Hex;
+    var C_format = C.format;
+
+    var HexFormatter = C_format.Hex = {
+        /**
+         * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
+         *
+         * @param {CipherParams} cipherParams The cipher params object.
+         *
+         * @return {string} The hexadecimally encoded string.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var hexString = CryptoJS.format.Hex.stringify(cipherParams);
+         */
+        stringify: function (cipherParams) {
+            return cipherParams.ciphertext.toString(Hex);
+        },
+
+        /**
+         * Converts a hexadecimally encoded ciphertext string to a cipher params object.
+         *
+         * @param {string} input The hexadecimally encoded string.
+         *
+         * @return {CipherParams} The cipher params object.
+         *
+         * @static
+         *
+         * @example
+         *
+         *     var cipherParams = CryptoJS.format.Hex.parse(hexString);
+         */
+        parse: function (input) {
+            var ciphertext = Hex.parse(input);
+            return CipherParams.create({ ciphertext: ciphertext });
+        }
+    };
+}());
--- a/src/js/lib/cryptojs/hmac.js
+++ b/src/js/lib/cryptojs/hmac.js
@ -0,0 +1,131 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var Base = C_lib.Base;
+    var C_enc = C.enc;
+    var Utf8 = C_enc.Utf8;
+    var C_algo = C.algo;
+
+    /**
+     * HMAC algorithm.
+     */
+    var HMAC = C_algo.HMAC = Base.extend({
+        /**
+         * Initializes a newly created HMAC.
+         *
+         * @param {Hasher} hasher The hash algorithm to use.
+         * @param {WordArray|string} key The secret key.
+         *
+         * @example
+         *
+         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+         */
+        init: function (hasher, key) {
+            // Init hasher
+            hasher = this._hasher = new hasher.init();
+
+            // Convert string to WordArray, else assume WordArray already
+            if (typeof key == 'string') {
+                key = Utf8.parse(key);
+            }
+
+            // Shortcuts
+            var hasherBlockSize = hasher.blockSize;
+            var hasherBlockSizeBytes = hasherBlockSize * 4;
+
+            // Allow arbitrary length keys
+            if (key.sigBytes > hasherBlockSizeBytes) {
+                key = hasher.finalize(key);
+            }
+
+            // Clamp excess bits
+            key.clamp();
+
+            // Clone key for inner and outer pads
+            var oKey = this._oKey = key.clone();
+            var iKey = this._iKey = key.clone();
+
+            // Shortcuts
+            var oKeyWords = oKey.words;
+            var iKeyWords = iKey.words;
+
+            // XOR keys with pad constants
+            for (var i = 0; i < hasherBlockSize; i++) {
+                oKeyWords[i] ^= 0x5c5c5c5c;
+                iKeyWords[i] ^= 0x36363636;
+            }
+            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+
+            // Set initial values
+            this.reset();
+        },
+
+        /**
+         * Resets this HMAC to its initial state.
+         *
+         * @example
+         *
+         *     hmacHasher.reset();
+         */
+        reset: function () {
+            // Shortcut
+            var hasher = this._hasher;
+
+            // Reset
+            hasher.reset();
+            hasher.update(this._iKey);
+        },
+
+        /**
+         * Updates this HMAC with a message.
+         *
+         * @param {WordArray|string} messageUpdate The message to append.
+         *
+         * @return {HMAC} This HMAC instance.
+         *
+         * @example
+         *
+         *     hmacHasher.update('message');
+         *     hmacHasher.update(wordArray);
+         */
+        update: function (messageUpdate) {
+            this._hasher.update(messageUpdate);
+
+            // Chainable
+            return this;
+        },
+
+        /**
+         * Finalizes the HMAC computation.
+         * Note that the finalize operation is effectively a destructive, read-once operation.
+         *
+         * @param {WordArray|string} messageUpdate (Optional) A final message update.
+         *
+         * @return {WordArray} The HMAC.
+         *
+         * @example
+         *
+         *     var hmac = hmacHasher.finalize();
+         *     var hmac = hmacHasher.finalize('message');
+         *     var hmac = hmacHasher.finalize(wordArray);
+         */
+        finalize: function (messageUpdate) {
+            // Shortcut
+            var hasher = this._hasher;
+
+            // Compute HMAC
+            var innerHash = hasher.finalize(messageUpdate);
+            hasher.reset();
+            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
+
+            return hmac;
+        }
+    });
+}());
--- a/src/js/lib/cryptojs/lib-typedarrays.js
+++ b/src/js/lib/cryptojs/lib-typedarrays.js
@ -0,0 +1,62 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Check if typed arrays are supported
+    if (typeof ArrayBuffer != 'function') {
+        return;
+    }
+
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var WordArray = C_lib.WordArray;
+
+    // Reference original init
+    var superInit = WordArray.init;
+
+    // Augment WordArray.init to handle typed arrays
+    var subInit = WordArray.init = function (typedArray) {
+        // Convert buffers to uint8
+        if (typedArray instanceof ArrayBuffer) {
+            typedArray = new Uint8Array(typedArray);
+        }
+
+        // Convert other array views to uint8
+        if (
+            typedArray instanceof Int8Array ||
+            typedArray instanceof Uint8ClampedArray ||
+            typedArray instanceof Int16Array ||
+            typedArray instanceof Uint16Array ||
+            typedArray instanceof Int32Array ||
+            typedArray instanceof Uint32Array ||
+            typedArray instanceof Float32Array ||
+            typedArray instanceof Float64Array
+        ) {
+            typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+        }
+
+        // Handle Uint8Array
+        if (typedArray instanceof Uint8Array) {
+            // Shortcut
+            var typedArrayByteLength = typedArray.byteLength;
+
+            // Extract bytes
+            var words = [];
+            for (var i = 0; i < typedArrayByteLength; i++) {
+                words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);
+            }
+
+            // Initialize this word array
+            superInit.call(this, words, typedArrayByteLength);
+        } else {
+            // Else call normal init
+            superInit.apply(this, arguments);
+        }
+    };
+
+    subInit.prototype = WordArray;
+}());
--- a/src/js/lib/cryptojs/md5.js
+++ b/src/js/lib/cryptojs/md5.js
@ -0,0 +1,254 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function (Math) {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var WordArray = C_lib.WordArray;
+    var Hasher = C_lib.Hasher;
+    var C_algo = C.algo;
+
+    // Constants table
+    var T = [];
+
+    // Compute constants
+    (function () {
+        for (var i = 0; i < 64; i++) {
+            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
+        }
+    }());
+
+    /**
+     * MD5 hash algorithm.
+     */
+    var MD5 = C_algo.MD5 = Hasher.extend({
+        _doReset: function () {
+            this._hash = new WordArray.init([
+                0x67452301, 0xefcdab89,
+                0x98badcfe, 0x10325476
+            ]);
+        },
+
+        _doProcessBlock: function (M, offset) {
+            // Swap endian
+            for (var i = 0; i < 16; i++) {
+                // Shortcuts
+                var offset_i = offset + i;
+                var M_offset_i = M[offset_i];
+
+                M[offset_i] = (
+                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
+                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
+                );
+            }
+
+            // Shortcuts
+            var H = this._hash.words;
+
+            var M_offset_0  = M[offset + 0];
+            var M_offset_1  = M[offset + 1];
+            var M_offset_2  = M[offset + 2];
+            var M_offset_3  = M[offset + 3];
+            var M_offset_4  = M[offset + 4];
+            var M_offset_5  = M[offset + 5];
+            var M_offset_6  = M[offset + 6];
+            var M_offset_7  = M[offset + 7];
+            var M_offset_8  = M[offset + 8];
+            var M_offset_9  = M[offset + 9];
+            var M_offset_10 = M[offset + 10];
+            var M_offset_11 = M[offset + 11];
+            var M_offset_12 = M[offset + 12];
+            var M_offset_13 = M[offset + 13];
+            var M_offset_14 = M[offset + 14];
+            var M_offset_15 = M[offset + 15];
+
+            // Working variables
+            var a = H[0];
+            var b = H[1];
+            var c = H[2];
+            var d = H[3];
+
+            // Computation
+            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);
+            d = FF(d, a, b, c, M_offset_1,  12, T[1]);
+            c = FF(c, d, a, b, M_offset_2,  17, T[2]);
+            b = FF(b, c, d, a, M_offset_3,  22, T[3]);
+            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);
+            d = FF(d, a, b, c, M_offset_5,  12, T[5]);
+            c = FF(c, d, a, b, M_offset_6,  17, T[6]);
+            b = FF(b, c, d, a, M_offset_7,  22, T[7]);
+            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);
+            d = FF(d, a, b, c, M_offset_9,  12, T[9]);
+            c = FF(c, d, a, b, M_offset_10, 17, T[10]);
+            b = FF(b, c, d, a, M_offset_11, 22, T[11]);
+            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);
+            d = FF(d, a, b, c, M_offset_13, 12, T[13]);
+            c = FF(c, d, a, b, M_offset_14, 17, T[14]);
+            b = FF(b, c, d, a, M_offset_15, 22, T[15]);
+
+            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);
+            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);
+            c = GG(c, d, a, b, M_offset_11, 14, T[18]);
+            b = GG(b, c, d, a, M_offset_0,  20, T[19]);
+            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);
+            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);
+            c = GG(c, d, a, b, M_offset_15, 14, T[22]);
+            b = GG(b, c, d, a, M_offset_4,  20, T[23]);
+            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);
+            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);
+            c = GG(c, d, a, b, M_offset_3,  14, T[26]);
+            b = GG(b, c, d, a, M_offset_8,  20, T[27]);
+            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);
+            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);
+            c = GG(c, d, a, b, M_offset_7,  14, T[30]);
+            b = GG(b, c, d, a, M_offset_12, 20, T[31]);
+
+            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);
+            d = HH(d, a, b, c, M_offset_8,  11, T[33]);
+            c = HH(c, d, a, b, M_offset_11, 16, T[34]);
+            b = HH(b, c, d, a, M_offset_14, 23, T[35]);
+            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);
+            d = HH(d, a, b, c, M_offset_4,  11, T[37]);
+            c = HH(c, d, a, b, M_offset_7,  16, T[38]);
+            b = HH(b, c, d, a, M_offset_10, 23, T[39]);
+            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);
+            d = HH(d, a, b, c, M_offset_0,  11, T[41]);
+            c = HH(c, d, a, b, M_offset_3,  16, T[42]);
+            b = HH(b, c, d, a, M_offset_6,  23, T[43]);
+            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);
+            d = HH(d, a, b, c, M_offset_12, 11, T[45]);
+            c = HH(c, d, a, b, M_offset_15, 16, T[46]);
+            b = HH(b, c, d, a, M_offset_2,  23, T[47]);
+
+            a = II(a, b, c, d, M_offset_0,  6,  T[48]);
+            d = II(d, a, b, c, M_offset_7,  10, T[49]);
+            c = II(c, d, a, b, M_offset_14, 15, T[50]);
+            b = II(b, c, d, a, M_offset_5,  21, T[51]);
+            a = II(a, b, c, d, M_offset_12, 6,  T[52]);
+            d = II(d, a, b, c, M_offset_3,  10, T[53]);
+            c = II(c, d, a, b, M_offset_10, 15, T[54]);
+            b = II(b, c, d, a, M_offset_1,  21, T[55]);
+            a = II(a, b, c, d, M_offset_8,  6,  T[56]);
+            d = II(d, a, b, c, M_offset_15, 10, T[57]);
+            c = II(c, d, a, b, M_offset_6,  15, T[58]);
+            b = II(b, c, d, a, M_offset_13, 21, T[59]);
+            a = II(a, b, c, d, M_offset_4,  6,  T[60]);
+            d = II(d, a, b, c, M_offset_11, 10, T[61]);
+            c = II(c, d, a, b, M_offset_2,  15, T[62]);
+            b = II(b, c, d, a, M_offset_9,  21, T[63]);
+
+            // Intermediate hash value
+            H[0] = (H[0] + a) | 0;
+            H[1] = (H[1] + b) | 0;
+            H[2] = (H[2] + c) | 0;
+            H[3] = (H[3] + d) | 0;
+        },
+
+        _doFinalize: function () {
+            // Shortcuts
+            var data = this._data;
+            var dataWords = data.words;
+
+            var nBitsTotal = this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+
+            // Add padding
+            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+
+            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
+            var nBitsTotalL = nBitsTotal;
+            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
+                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
+                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
+            );
+            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
+                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
+                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
+            );
+
+            data.sigBytes = (dataWords.length + 1) * 4;
+
+            // Hash final blocks
+            this._process();
+
+            // Shortcuts
+            var hash = this._hash;
+            var H = hash.words;
+
+            // Swap endian
+            for (var i = 0; i < 4; i++) {
+                // Shortcut
+                var H_i = H[i];
+
+                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
+                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
+            }
+
+            // Return final computed hash
+            return hash;
+        },
+
+        clone: function () {
+            var clone = Hasher.clone.call(this);
+            clone._hash = this._hash.clone();
+
+            return clone;
+        }
+    });
+
+    function FF(a, b, c, d, x, s, t) {
+        var n = a + ((b & c) | (~b & d)) + x + t;
+        return ((n << s) | (n >>> (32 - s))) + b;
+    }
+
+    function GG(a, b, c, d, x, s, t) {
+        var n = a + ((b & d) | (c & ~d)) + x + t;
+        return ((n << s) | (n >>> (32 - s))) + b;
+    }
+
+    function HH(a, b, c, d, x, s, t) {
+        var n = a + (b ^ c ^ d) + x + t;
+        return ((n << s) | (n >>> (32 - s))) + b;
+    }
+
+    function II(a, b, c, d, x, s, t) {
+        var n = a + (c ^ (b | ~d)) + x + t;
+        return ((n << s) | (n >>> (32 - s))) + b;
+    }
+
+    /**
+     * Shortcut function to the hasher's object interface.
+     *
+     * @param {WordArray|string} message The message to hash.
+     *
+     * @return {WordArray} The hash.
+     *
+     * @static
+     *
+     * @example
+     *
+     *     var hash = CryptoJS.MD5('message');
+     *     var hash = CryptoJS.MD5(wordArray);
+     */
+    C.MD5 = Hasher._createHelper(MD5);
+
+    /**
+     * Shortcut function to the HMAC's object interface.
+     *
+     * @param {WordArray|string} message The message to hash.
+     * @param {WordArray|string} key The secret key.
+     *
+     * @return {WordArray} The HMAC.
+     *
+     * @static
+     *
+     * @example
+     *
+     *     var hmac = CryptoJS.HmacMD5(message, key);
+     */
+    C.HmacMD5 = Hasher._createHmacHelper(MD5);
+}(Math));
--- a/src/js/lib/cryptojs/mode-cfb.js
+++ b/src/js/lib/cryptojs/mode-cfb.js
@ -0,0 +1,64 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * Cipher Feedback block mode.
+ */
+CryptoJS.mode.CFB = (function () {
+    var CFB = CryptoJS.lib.BlockCipherMode.extend();
+
+    CFB.Encryptor = CFB.extend({
+        processBlock: function (words, offset) {
+            // Shortcuts
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+
+            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
+
+            // Remember this block to use with next block
+            this._prevBlock = words.slice(offset, offset + blockSize);
+        }
+    });
+
+    CFB.Decryptor = CFB.extend({
+        processBlock: function (words, offset) {
+            // Shortcuts
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+
+            // Remember this block to use with next block
+            var thisBlock = words.slice(offset, offset + blockSize);
+
+            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
+
+            // This block becomes the previous block
+            this._prevBlock = thisBlock;
+        }
+    });
+
+    function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
+        // Shortcut
+        var iv = this._iv;
+
+        // Generate keystream
+        if (iv) {
+            var keystream = iv.slice(0);
+
+            // Remove IV for subsequent blocks
+            this._iv = undefined;
+        } else {
+            var keystream = this._prevBlock;
+        }
+        cipher.encryptBlock(keystream, 0);
+
+        // Encrypt
+        for (var i = 0; i < blockSize; i++) {
+            words[offset + i] ^= keystream[i];
+        }
+    }
+
+    return CFB;
+}());
--- a/src/js/lib/cryptojs/mode-ctr-gladman.js
+++ b/src/js/lib/cryptojs/mode-ctr-gladman.js
@ -0,0 +1,104 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/** @license
+========================================================================
+  CryptoJS.mode.CTRGladman
+  Counter block mode compatible with  Dr Brian Gladman fileenc.c
+  derived from CryptoJS.mode.CTR 
+  Jan Hruby jhruby.web@gmail.com
+*/
+CryptoJS.mode.CTRGladman = (function () {
+    var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
+
+	function incWord(word)
+	{	
+		if (((word >> 24) & 0xff) === 0xff) { //overflow
+		var b1 = (word >> 16)&0xff;
+		var b2 = (word >> 8)&0xff;
+		var b3 = word & 0xff;
+
+		if (b1 === 0xff) // overflow b1
+		{		 
+		b1 = 0;
+		if (b2 === 0xff)
+		{
+			b2 = 0;
+			if (b3 === 0xff)
+			{
+				b3 = 0;
+			}
+			else
+			{
+				++b3;
+			}
+		}
+		else
+		{
+			++b2;
+		}
+		}
+		else
+		{
+		++b1;
+		}
+
+		word = 0;	  	  
+		word += (b1 << 16);
+		word += (b2 << 8);
+		word += b3;	  
+		}
+		else
+		{
+		word += (0x01 << 24);
+		}
+		return word;
+	}
+
+	function incCounter(counter)
+	{
+		if ((counter[0] = incWord(counter[0])) === 0)
+		{
+			// encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8
+			counter[1] = incWord(counter[1]);
+		}
+		return counter;
+	}
+	
+    var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
+        processBlock: function (words, offset) {
+            // Shortcuts
+            var cipher = this._cipher
+            var blockSize = cipher.blockSize;
+            var iv = this._iv;
+            var counter = this._counter;
+
+            // Generate keystream
+            if (iv) {
+                counter = this._counter = iv.slice(0);
+
+                // Remove IV for subsequent blocks
+                this._iv = undefined;
+            }
+            
+			incCounter(counter);
+			
+			var keystream = counter.slice(0);
+            cipher.encryptBlock(keystream, 0);
+
+            // Encrypt
+            for (var i = 0; i < blockSize; i++) {
+                words[offset + i] ^= keystream[i];
+            }
+        }
+    });
+
+    CTRGladman.Decryptor = Encryptor;
+
+    return CTRGladman;
+}());
+
+
--- a/src/js/lib/cryptojs/mode-ctr.js
+++ b/src/js/lib/cryptojs/mode-ctr.js
@ -0,0 +1,44 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * Counter block mode.
+ */
+CryptoJS.mode.CTR = (function () {
+    var CTR = CryptoJS.lib.BlockCipherMode.extend();
+
+    var Encryptor = CTR.Encryptor = CTR.extend({
+        processBlock: function (words, offset) {
+            // Shortcuts
+            var cipher = this._cipher
+            var blockSize = cipher.blockSize;
+            var iv = this._iv;
+            var counter = this._counter;
+
+            // Generate keystream
+            if (iv) {
+                counter = this._counter = iv.slice(0);
+
+                // Remove IV for subsequent blocks
+                this._iv = undefined;
+            }
+            var keystream = counter.slice(0);
+            cipher.encryptBlock(keystream, 0);
+
+            // Increment counter
+            counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0
+
+            // Encrypt
+            for (var i = 0; i < blockSize; i++) {
+                words[offset + i] ^= keystream[i];
+            }
+        }
+    });
+
+    CTR.Decryptor = Encryptor;
+
+    return CTR;
+}());
--- a/src/js/lib/cryptojs/mode-ecb.js
+++ b/src/js/lib/cryptojs/mode-ecb.js
@ -0,0 +1,26 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * Electronic Codebook block mode.
+ */
+CryptoJS.mode.ECB = (function () {
+    var ECB = CryptoJS.lib.BlockCipherMode.extend();
+
+    ECB.Encryptor = ECB.extend({
+        processBlock: function (words, offset) {
+            this._cipher.encryptBlock(words, offset);
+        }
+    });
+
+    ECB.Decryptor = ECB.extend({
+        processBlock: function (words, offset) {
+            this._cipher.decryptBlock(words, offset);
+        }
+    });
+
+    return ECB;
+}());
--- a/src/js/lib/cryptojs/mode-ofb.js
+++ b/src/js/lib/cryptojs/mode-ofb.js
@ -0,0 +1,40 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * Output Feedback block mode.
+ */
+CryptoJS.mode.OFB = (function () {
+    var OFB = CryptoJS.lib.BlockCipherMode.extend();
+
+    var Encryptor = OFB.Encryptor = OFB.extend({
+        processBlock: function (words, offset) {
+            // Shortcuts
+            var cipher = this._cipher
+            var blockSize = cipher.blockSize;
+            var iv = this._iv;
+            var keystream = this._keystream;
+
+            // Generate keystream
+            if (iv) {
+                keystream = this._keystream = iv.slice(0);
+
+                // Remove IV for subsequent blocks
+                this._iv = undefined;
+            }
+            cipher.encryptBlock(keystream, 0);
+
+            // Encrypt
+            for (var i = 0; i < blockSize; i++) {
+                words[offset + i] ^= keystream[i];
+            }
+        }
+    });
+
+    OFB.Decryptor = Encryptor;
+
+    return OFB;
+}());
--- a/src/js/lib/cryptojs/pad-ansix923.js
+++ b/src/js/lib/cryptojs/pad-ansix923.js
@ -0,0 +1,35 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * ANSI X.923 padding strategy.
+ */
+CryptoJS.pad.AnsiX923 = {
+    pad: function (data, blockSize) {
+        // Shortcuts
+        var dataSigBytes = data.sigBytes;
+        var blockSizeBytes = blockSize * 4;
+
+        // Count padding bytes
+        var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+
+        // Compute last byte position
+        var lastBytePos = dataSigBytes + nPaddingBytes - 1;
+
+        // Pad
+        data.clamp();
+        data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
+        data.sigBytes += nPaddingBytes;
+    },
+
+    unpad: function (data) {
+        // Get number of padding bytes from last byte
+        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+        // Remove padding
+        data.sigBytes -= nPaddingBytes;
+    }
+};
--- a/src/js/lib/cryptojs/pad-iso10126.js
+++ b/src/js/lib/cryptojs/pad-iso10126.js
@ -0,0 +1,30 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * ISO 10126 padding strategy.
+ */
+CryptoJS.pad.Iso10126 = {
+    pad: function (data, blockSize) {
+        // Shortcut
+        var blockSizeBytes = blockSize * 4;
+
+        // Count padding bytes
+        var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+
+        // Pad
+        data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
+             concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
+    },
+
+    unpad: function (data) {
+        // Get number of padding bytes from last byte
+        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+        // Remove padding
+        data.sigBytes -= nPaddingBytes;
+    }
+};
--- a/src/js/lib/cryptojs/pad-iso97971.js
+++ b/src/js/lib/cryptojs/pad-iso97971.js
@ -0,0 +1,26 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * ISO/IEC 9797-1 Padding Method 2.
+ */
+CryptoJS.pad.Iso97971 = {
+    pad: function (data, blockSize) {
+        // Add 0x80 byte
+        data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
+
+        // Zero pad the rest
+        CryptoJS.pad.ZeroPadding.pad(data, blockSize);
+    },
+
+    unpad: function (data) {
+        // Remove zero padding
+        CryptoJS.pad.ZeroPadding.unpad(data);
+
+        // Remove one more byte -- the 0x80 byte
+        data.sigBytes--;
+    }
+};
--- a/src/js/lib/cryptojs/pad-nopadding.js
+++ b/src/js/lib/cryptojs/pad-nopadding.js
@ -0,0 +1,16 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * A noop padding strategy.
+ */
+CryptoJS.pad.NoPadding = {
+    pad: function () {
+    },
+
+    unpad: function () {
+    }
+};
--- a/src/js/lib/cryptojs/pad-zeropadding.js
+++ b/src/js/lib/cryptojs/pad-zeropadding.js
@ -0,0 +1,31 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+/**
+ * Zero padding strategy.
+ */
+CryptoJS.pad.ZeroPadding = {
+    pad: function (data, blockSize) {
+        // Shortcut
+        var blockSizeBytes = blockSize * 4;
+
+        // Pad
+        data.clamp();
+        data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
+    },
+
+    unpad: function (data) {
+        // Shortcut
+        var dataWords = data.words;
+
+        // Unpad
+        var i = data.sigBytes - 1;
+        while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
+            i--;
+        }
+        data.sigBytes = i + 1;
+    }
+};
--- a/src/js/lib/cryptojs/pbkdf2.js
+++ b/src/js/lib/cryptojs/pbkdf2.js
@ -0,0 +1,131 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var Base = C_lib.Base;
+    var WordArray = C_lib.WordArray;
+    var C_algo = C.algo;
+    var SHA1 = C_algo.SHA1;
+    var HMAC = C_algo.HMAC;
+
+    /**
+     * Password-Based Key Derivation Function 2 algorithm.
+     */
+    var PBKDF2 = C_algo.PBKDF2 = Base.extend({
+        /**
+         * Configuration options.
+         *
+         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+         * @property {Hasher} hasher The hasher to use. Default: SHA1
+         * @property {number} iterations The number of iterations to perform. Default: 1
+         */
+        cfg: Base.extend({
+            keySize: 128/32,
+            hasher: SHA1,
+            iterations: 1
+        }),
+
+        /**
+         * Initializes a newly created key derivation function.
+         *
+         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+         *
+         * @example
+         *
+         *     var kdf = CryptoJS.algo.PBKDF2.create();
+         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
+         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
+         */
+        init: function (cfg) {
+            this.cfg = this.cfg.extend(cfg);
+        },
+
+        /**
+         * Computes the Password-Based Key Derivation Function 2.
+         *
+         * @param {WordArray|string} password The password.
+         * @param {WordArray|string} salt A salt.
+         *
+         * @return {WordArray} The derived key.
+         *
+         * @example
+         *
+         *     var key = kdf.compute(password, salt);
+         */
+        compute: function (password, salt) {
+            // Shortcut
+            var cfg = this.cfg;
+
+            // Init HMAC
+            var hmac = HMAC.create(cfg.hasher, password);
+
+            // Initial values
+            var derivedKey = WordArray.create();
+            var blockIndex = WordArray.create([0x00000001]);
+
+            // Shortcuts
+            var derivedKeyWords = derivedKey.words;
+            var blockIndexWords = blockIndex.words;
+            var keySize = cfg.keySize;
+            var iterations = cfg.iterations;
+
+            // Generate key
+            while (derivedKeyWords.length < keySize) {
+                var block = hmac.update(salt).finalize(blockIndex);
+                hmac.reset();
+
+                // Shortcuts
+                var blockWords = block.words;
+                var blockWordsLength = blockWords.length;
+
+                // Iterations
+                var intermediate = block;
+                for (var i = 1; i < iterations; i++) {
+                    intermediate = hmac.finalize(intermediate);
+                    hmac.reset();
+
+                    // Shortcut
+                    var intermediateWords = intermediate.words;
+
+                    // XOR intermediate with block
+                    for (var j = 0; j < blockWordsLength; j++) {
+                        blockWords[j] ^= intermediateWords[j];
+                    }
+                }
+
+                derivedKey.concat(block);
+                blockIndexWords[0]++;
+            }
+            derivedKey.sigBytes = keySize * 4;
+
+            return derivedKey;
+        }
+    });
+
+    /**
+     * Computes the Password-Based Key Derivation Function 2.
+     *
+     * @param {WordArray|string} password The password.
+     * @param {WordArray|string} salt A salt.
+     * @param {Object} cfg (Optional) The configuration options to use for this computation.
+     *
+     * @return {WordArray} The derived key.
+     *
+     * @static
+     *
+     * @example
+     *
+     *     var key = CryptoJS.PBKDF2(password, salt);
+     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });
+     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });
+     */
+    C.PBKDF2 = function (password, salt, cfg) {
+        return PBKDF2.create(cfg).compute(password, salt);
+    };
+}());
--- a/src/js/lib/cryptojs/rabbit-legacy.js
+++ b/src/js/lib/cryptojs/rabbit-legacy.js
@ -0,0 +1,176 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function () {
+    // Shortcuts
+    var C = CryptoJS;
+    var C_lib = C.lib;
+    var StreamCipher = C_lib.StreamCipher;
+    var C_algo = C.algo;
+
+    // Reusable objects
+    var S  = [];
+    var C_ = [];
+    var G  = [];
+
+    /**
+     * Rabbit stream cipher algorithm.
+     *
+     * This is a legacy version that neglected to convert the key to little-endian.
+     * This error doesn't affect the cipher's security,
+     * but it does affect its compatibility with other implementations.
+     */
+    var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({
+        _doReset: function () {
+            // Shortcuts
+            var K = this._key.words;
+            var iv = this.cfg.iv;
+
+            // Generate initial state values
+            var X = this._X = [
+                K[0], (K[3] << 16) | (K[2] >>> 16),
+                K[1], (K[0] << 16) | (K[3] >>> 16),
+                K[2], (K[1] << 16) | (K[0] >>> 16),
+                K[3], (K[2] << 16) | (K[1] >>> 16)
+            ];
+
+            // Generate initial counter values
+            var C = this._C = [
+                (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
+                (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
+                (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
+                (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
+            ];
+
+            // Carry bit
+            this._b = 0;
+
+            // Iterate the system four times
+            for (var i = 0; i < 4; i++) {
+                nextState.call(this);
+            }
+
+            // Modify the counters
+            for (var i = 0; i < 8; i++) {
+                C[i] ^= X[(i + 4) & 7];
+            }
+
+            // IV setup
+            if (iv) {
+                // Shortcuts
+                var IV = iv.words;
+                var IV_0 = IV[0];
+                var IV_1 = IV[1];
+
+                // Generate four subvectors
+                var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
+                var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
+                var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
+                var i3 = (i2 << 16)  | (i0 & 0x0000ffff);
+
+                // Modify counter values
+                C[0] ^= i0;
+                C[1] ^= i1;
+                C[2] ^= i2;
+                C[3] ^= i3;
+                C[4] ^= i0;
+                C[5] ^= i1;
+                C[6] ^= i2;
+                C[7] ^= i3;
+
+                // Iterate the system four times
+                for (var i = 0; i < 4; i++) {
+                    nextState.call(this);
+                }
+            }
+        },
+
+        _doProcessBlock: function (M, offset) {
+            // Shortcut
+            var X = this._X;
+
+            // Iterate the system
+            nextState.call(this);
+
+            // Generate four keystream words
+            S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
+            S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
+            S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
+            S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
+
+            for (var i = 0; i < 4; i++) {
+                // Swap endian
+                S[i] = (((S[i] << 8)  | (S[i] >>> 24)) & 0x00ff00ff) |
+                       (((S[i] << 24) | (S[i] >>> 8))  & 0xff00ff00);
+
+                // Encrypt
+                M[offset + i] ^= S[i];
+            }
+        },
+
+        blockSize: 128/32,
+
+        ivSize: 64/32
+    });
+
+    function nextState() {
+        // Shortcuts
+        var X = this._X;
+        var C = this._C;
+
+        // Save old counter values
+        for (var i = 0; i < 8; i++) {
+            C_[i] = C[i];
+        }
+
+        // Calculate new counter values
+        C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
+        C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
+        C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
+        C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
+        C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
+        C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
+        C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
+        C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
+        this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
+
+        // Calculate the g-values
+        for (var i = 0; i < 8; i++) {
+            var gx = X[i] + C[i];
+
+            // Construct high and low argument for squaring
+            var ga = gx & 0xffff;
+            var gb = gx >>> 16;
+
+            // Calculate high and low result of squaring
+            var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
+            var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
+
+            // High XOR low
+            G[i] = gh ^ gl;
+        }
+
+        // Calculate new state values
+        X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
+        X[1] = (G[1] + ((G[0] << 8)  | (G[0] >>> 24)) + G[7]) | 0;
+        X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
+        X[3] = (G[3] + ((G[2] << 8)  | (G[2] >>> 24)) + G[1]) | 0;
+        X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
+        X[5] = (G[5] + ((G[4] << 8)  | (G[4] >>> 24)) + G[3]) | 0;
+        X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
+        X[7] = (G[7] + ((G[6] << 8)  | (G[6] >>> 24)) + G[5]) | 0;
+    }
+
+    /**
+     * Shortcut functions to the cipher's object interface.
+     *
+     * @example
+     *
+     *     var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);
+     *     var plaintext  = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);
+     */
+    C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);
+}());
--- a/Show More
+++ b/Show More