crypt.io.js

/**
 * crypt.io - Encryption enabled browser storage
 *
 * https://www.github.com/jas-/crypt.io
 *
 * Author: Jason Gerfen <jason.gerfen@gmail.com>
 * License: MIT (see LICENSE)
 */
(function(window, undefined) {

  'use strict';

  /**
   * @function cryptio
   * @abstract Namespace for saving/retrieving encrypted HTML5 storage engine
   * data
   */
  var cryptio = cryptio || function() {

    /**
     * @var {Object} defaults
     * @abstract Default set of options for plug-in
     *
     * @param {Boolean} encrypt Optionally encrypt stored data
     * @param {String} passphrase Passphrase to use (optional)
     * @param {String} storage Storage mechanism (local, session or cookies)
     */
    var defaults = {
      passphrase: '',
      storage: 'local'
    };

    /**
     * @method setup
     * @abstract Initial setup routines
     */
    var setup = setup || {

      /**
       * @function set
       * @abstract Initialization
       *
       * @param {Object} opts Plug-in option object
       */
      init: function(opts) {
        opts.passphrase = opts.passphrase || (crypto.key(opts.passphrase) || crypto.key());
      }
    };

    /**
     * @method storage
     * @abstract Interface to handle storage options
     */
    var storage = storage || {

      /**
       * @function quota
       * @abstract Tests specified storage option for current amount of space available.
       *  - Cookies: 4K
       *  - localStorage: 5MB
       *  - sessionStorage: 5MB
       *  - default: 5MB
       *
       * @param {String} t Type of storage specified
       *
       * @returns {Boolean}
       */
      quota: function(storage) {
        var max = /local|session/.test(storage) ? 1024 * 1025 * 5 :
          1024 * 4,
          cur = libs.total(storage),
          total = max - cur;

        return total > 0;
      },

      /**
       * @function set
       * @abstract Interface for saving to available storage mechanisms
       *
       * @param {Object} opts Default options
       * @param {String} key Index of storage object
       * @param {Object} data Data to be stored
       * @param {Function} cb Callback function
       *
       * @returns {Boolean}
       */
      set: function(opts, key, data, cb) {
        var ret = false;

        if (!storage.quota(opts.storage))
          cb('Browser storage quota has been exceeded.');

        if (opts.passphrase) {
          try {
            data = sjcl.encrypt(opts.passphrase, storage.fromJSON(data));
          } catch(err) {
            return cb(err);
          }
        }

        ret = this[opts.storage] ?
          this[opts.storage].set(key, data) :
          this.local.set(key, data);

        if (!ret) {
          cb('Error occured saving data');
        } else {
          cb(null, 'Successfully set data');
        }
      },

      /**
       * @function get
       * @abstract Interface for retrieving from available storage mechanisms
       *
       * @param {Object} opts Default options
       * @param {String} key Index of storage object
       * @param {Function} cb Callback function
       *
       * @returns {Object}
       */
      get: function(opts, key, cb) {
        var ret = false;

        ret = this[opts.storage] ?
          this[opts.storage].get(key) :
          this.local.get(key);

        try {
          ret = sjcl.decrypt(opts.passphrase, ret);
        } catch(err) {
          cb(err);
        }
        
        ret = storage.toJSON(ret);

        if (ret) {
          cb(null, ret);
        } else {
          cb('Error occured retrieving storage data');
        }
      },

      /**
       * @function fromJSON
       * @abstract Convert to JSON object to string
       *
       * @param {Object|Array|String} obj Object, Array or String to convert to JSON object
       *
       * @returns {String}
       */
      fromJSON: function(obj) {
        var ret;
        try {
          ret = JSON.stringify(obj);
        } catch (e) {
          ret = obj;
        }
        return ret;
      },

      /**
       * @function toJSON
       * @abstract Creates JSON object from formatted string
       *
       * @param {String} obj Object to convert to JSON object
       *
       * @returns {Object}
       */
      toJSON: function(obj) {
        var ret;
        try {
          ret = JSON.parse(obj);
        } catch (e) {
          ret = obj;
        }
        return ret;
      },

      /**
       * @method cookie
       * @abstract Method for handling setting & retrieving of cookie objects
       */
      cookie: {

        /**
         * @function set
         * @abstract Handle setting of cookie objects
         *
         * @param {String} key Key to use for cookies
         * @param {String|Object} value String or object to place in cookie
         *
         * @returns {Boolean}
         */
        set: function(key, value) {
          var date = new Date();
          date.setTime(date.getTime() + (30 * 24 * 60 * 60 * 1000));
          document.cookie = key + '=' + value + ';expires=' + date.toGMTString() +
            ';path=/;domain=' + this.domain();
          return true;
        },

        /**
         * @function get
         * @abstract Handle retrieval of cookie objects
         *
         * @param {String} key cookie key
         *
         * @returns {String|False}
         */
        get: function(key) {
          var i, index, value, content = document.cookie.split(";");
          for (i = 0; i < content.length; i++) {
            index = content[i].substr(0, content[i].indexOf('='));
            value = content[i].substr(content[i].indexOf('=') + 1);
            index = index.replace(/^\s+|\s+$/g, '');
            if (index == key) {
              return unescape(value);
            }
          }
          return false;
        },

        /**
         * @function domain
         * @abstract Provides current domain of client for cookie realm
         *
         * @returns {String}
         */
        domain: function() {
          return location.hostname;
        }
      },

      /**
       * @method local
       * @abstract Method for handling setting & retrieving of localStorage objects
       */
      local: {

        /**
         * @function set
         * @abstract Handle setting & retrieving of localStorage objects
         *
         * @param {String} key Index of storage object
         * @param {Object} data Data to be stored
         *
         * @returns {Boolean}
         */
        set: function(key, data) {
          try {
            window.localStorage.setItem(key, data);
            return true;
          } catch (e) {
            return false;
          }
        },

        /**
         * @function get
         * @abstract Handle retrieval of localStorage objects
         *
         * @param {String} key Index of storage object
         *
         * @returns {Object|String|Boolean}
         */
        get: function(key) {
          return window.localStorage.getItem(key);
        }
      },

      /**
       * @method session
       * @abstract Method for handling setting & retrieving of sessionStorage objects
       */
      session: {

        /**
         * @function set
         * @abstract Set session storage objects
         *
         * @param {String} key Index of storage object
         * @param {Object} data Data to be stoed
         *
         * @returns {Boolean}
         */
        set: function(key, data) {
          try {
            window.sessionStorage.setItem(key, data);
            return true;
          } catch (e) {
            return false;
          }
        },

        /**
         * @function get
         * @abstract Retrieves sessionStorage objects
         *
         * @param {String} key Index of storage object
         *
         * @returns {Object|String|Boolean}
         */
        get: function(key) {
          return window.sessionStorage.getItem(key);
        }
      }
    };

    /**
     * @method crypto
     * @abstract Interface to handle encryption option
     */
    var crypto = crypto || {

      /**
       * @function key
       * @abstract Prepares key for encryption/decryption routines
       *
       * @param {String} pass Optional passphrase
       * 
       * @returns {String}
       */
      key: function(pass) {
        pass = pass || this.muid();

        var salt = crypto.salt(pass);

        return sjcl.codec.hex.fromBits(sjcl.misc.pbkdf2(pass, salt));
      },

      /**
       * @function muid
       * @abstract Generates a machine identifier
       *
       * @returns {String}
       */
      muid: function() {
        var ret = window.navigator.appName +
          window.navigator.language +
          window.navigator.platform;

        return ret;
      },

      /**
       * @function salt
       * @abstract Creates salt from string & iv
       *
       * @param {String} str Machine identification used as salt
       *
       * @returns {String}
       */
      salt: function(str) {
        return sjcl.codec.base64.fromBits(
                sjcl.hash.sha256.hash(window.navigator.appName));
      }
    };

    /**
     * @method libs
     * @abstract Miscellaneous helper libraries
     */
    var libs = libs || {

      /**
       * @function total
       * @abstract Returns size of specified storage
       *
       * @param {String} engine Storage mechanism
       *
       * @returns {Insteger}
       */
      total: function(storage) {
        var current = '',
          engine = window.storage + 'Storage';

        for (var key in engine) {
          if (engine.hasOwnProperty(key)) {
            current += engine[key];
          }
        }

        return current ? 3 + ((current.length * 16) / (8 * 1024)) : 0;
      },

      /**
       * @function size
       * @abstract Perform calculation on objects
       *
       * @param {Object|Array} obj The object/array to calculate
       *
       * @returns {Integer}
       */
      size: function(obj) {
        var n = 0;

        if (/object/.test(typeof(obj))) {
          for (var i in obj) {
            if (obj.hasOwnProperty(obj[i])) n++;
          }
        } else if (/array/.test(typeof(obj))) {
          n = obj.length;
        }
        return n;
      },

      /**
       * @function merge
       * @abstract Perform preliminary option/default object merge
       *
       * @param {Object} defaults Application defaults
       * @param {Object} obj User supplied object
       *
       * @returns {Object}
       */
      merge: function(defaults, obj) {
        defaults = defaults || {};

        for (var item in defaults) {
          if (defaults.hasOwnProperty(item)) {
            obj[item] = (/object/.test(typeof(defaults[item]))) ?
              this.merge(obj[item], defaults[item]) : defaults[item];
          }
          obj[item] = defaults[item];
        }

        return obj;
      }
    };

    /**
     * @function get
     * @abstract Retrieves storage engine data
     *
     * @param {Object} obj User supplied options
     * @param {String} key Key of storage object to retrieve
     * @param {Function} cb User supplied callback function
     */
    cryptio.prototype.get = function(obj, key, cb) {
      if (cb == undefined)
        cb = key, key = obj, obj = {};

      var opts = libs.merge(obj, defaults);

      setup.init(opts);

      storage.get(opts, key, cb);
    };

    /**
     * @function set
     * @abstract Saves data to specified storage engine
     *
     * @param {Object} obj User supplied options
     * @param {String} key Key of storage object to retrieve
     * @param {Object} data User provided data to store
     * @param {Function} cb User supplied callback function
     */
    cryptio.prototype.set = function(obj, key, data, cb) {
      if (cb == undefined)
        cb = data,data = key, key = obj, obj = {};

      var opts = libs.merge(obj, defaults);

      setup.init(opts);

      storage.set(opts, key, data, cb);
    };

  };

  /* crypt.io, do work */
  window.cryptio = new cryptio;

})(window);