spice-html5-rails 0.0.1

data/vendor/assets/javascripts/spiceHTML5/ticket.js

@@ -0,0 +1,250 @@
+"use strict";
+/*
+   Copyright (C) 2012 by Jeremy P. White <jwhite@codeweavers.com>
+
+   This file is part of spice-html5.
+
+   spice-html5 is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   spice-html5 is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with spice-html5.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+var SHA_DIGEST_LENGTH = 20;
+
+/*----------------------------------------------------------------------------
+**  General ticket RSA encryption functions - just good enough to
+**      support what we need to send back an encrypted ticket.
+**--------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+**  OAEP padding functions.  Inspired by the OpenSSL implementation.
+**--------------------------------------------------------------------------*/
+function MGF1(mask, seed)
+{
+    var i, j, outlen;
+    for (i = 0, outlen = 0; outlen < mask.length; i++)
+    {
+        var combo_buf = new String;
+
+        for (j = 0; j < seed.length; j++)
+            combo_buf += String.fromCharCode(seed[j]);
+        combo_buf += String.fromCharCode((i >> 24) & 255);
+        combo_buf += String.fromCharCode((i >> 16) & 255);
+        combo_buf += String.fromCharCode((i >> 8)  & 255);
+        combo_buf += String.fromCharCode((i)       & 255);
+
+        var combo_hash = rstr_sha1(combo_buf);
+        for (j = 0; j < combo_hash.length && outlen < mask.length; j++, outlen++)
+        {
+            mask[outlen] = combo_hash.charCodeAt(j);
+        }
+    }
+}
+
+
+function RSA_padding_add_PKCS1_OAEP(tolen, from, param)
+{
+    var seed = new Array(SHA_DIGEST_LENGTH);
+    var rand = new SecureRandom();
+    rand.nextBytes(seed);
+
+    var dblen = tolen - 1 - seed.length;
+    var db = new Array(dblen);
+    var padlen = dblen - from.length - 1;
+    var i;
+
+    if (param === undefined)
+        param = "";
+
+    if (padlen < SHA_DIGEST_LENGTH)
+    {
+        console.log("Error - data too large for key size.");
+        return null;
+    }
+
+    for (i = 0; i < padlen; i++)
+        db[i] = 0;
+
+    var param_hash = rstr_sha1(param);
+    for (i = 0; i < param_hash.length; i++)
+        db[i] = param_hash.charCodeAt(i);
+
+    db[padlen] = 1;
+    for (i = 0; i < from.length; i++)
+        db[i + padlen + 1] = from.charCodeAt(i);
+
+    var dbmask = new Array(dblen);
+    if (MGF1(dbmask, seed) < 0)
+            return null;
+
+    for (i = 0; i < dbmask.length; i++)
+        db[i] ^= dbmask[i];
+
+
+    var seedmask = Array(SHA_DIGEST_LENGTH);
+    if (MGF1(seedmask, db) < 0)
+            return null;
+
+    for (i = 0; i < seedmask.length; i++)
+        seed[i] ^= seedmask[i];
+
+    var ret = new String;
+    ret += String.fromCharCode(0);
+    for (i = 0; i < seed.length; i++)
+        ret += String.fromCharCode(seed[i]);
+    for (i = 0; i < db.length; i++)
+        ret += String.fromCharCode(db[i]);
+    return ret;
+}
+
+
+function asn_get_length(u8, at)
+{
+    var len = u8[at++];
+    if (len > 0x80)
+    {
+        if (len != 0x81)
+        {
+            console.log("Error:  we lazily don't support keys bigger than 255 bytes.  It'd be easy to fix.");
+            return null;
+        }
+        len = u8[at++];
+    }
+
+    return [ at, len];
+}
+
+function find_sequence(u8, at)
+{
+    var lenblock;
+    at = at || 0;
+    if (u8[at++] != 0x30)
+    {
+        console.log("Error:  public key should start with a sequence flag.");
+        return null;
+    }
+
+    lenblock = asn_get_length(u8, at);
+    if (! lenblock)
+        return null;
+    return lenblock;
+}
+
+/*----------------------------------------------------------------------------
+**  Extract an RSA key from a memory buffer
+**--------------------------------------------------------------------------*/
+function create_rsa_from_mb(mb, at)
+{
+    var u8 = new Uint8Array(mb);
+    var lenblock;
+    var seq;
+    var ba;
+    var i;
+    var ret;
+
+    /* We have a sequence which contains a sequence followed by a bit string */
+    seq = find_sequence(u8, at);
+    if (! seq)
+        return null;
+
+    at = seq[0];
+    seq = find_sequence(u8, at);
+    if (! seq)
+        return null;
+
+    /* Skip over the contained sequence */
+    at = seq[0] + seq[1];
+    if (u8[at++] != 0x3)
+    {
+        console.log("Error: expecting bit string next.");
+        return null;
+    }
+
+    /* Get the bit string, which is *itself* a sequence.  Having fun yet? */
+    lenblock = asn_get_length(u8, at);
+    if (! lenblock)
+        return null;
+
+    at = lenblock[0];
+    if (u8[at] != 0 && u8[at + 1] != 0x30)
+    {
+        console.log("Error: unexpected values in bit string.");
+        return null;
+    }
+
+    /* Okay, now we have a sequence of two binary values, we hope. */
+    seq = find_sequence(u8, at + 1);
+    if (! seq)
+        return null;
+
+    at = seq[0];
+    if (u8[at++] != 0x02)
+    {
+        console.log("Error: expecting integer n next.");
+        return null;
+    }
+    lenblock = asn_get_length(u8, at);
+    if (! lenblock)
+        return null;
+    at = lenblock[0];
+
+    ba = new Array(lenblock[1]);
+    for (i = 0; i < lenblock[1]; i++)
+        ba[i] = u8[at + i];
+
+    ret = new RSAKey();
+    ret.n = new BigInteger(ba);
+
+    at += lenblock[1];
+
+    if (u8[at++] != 0x02)
+    {
+        console.log("Error: expecting integer e next.");
+        return null;
+    }
+    lenblock = asn_get_length(u8, at);
+    if (! lenblock)
+        return null;
+    at = lenblock[0];
+
+    ret.e = u8[at++];
+    for (i = 1; i < lenblock[1]; i++)
+    {
+        ret.e <<= 8;
+        ret.e |= u8[at++];
+    }
+
+    return ret;
+}
+
+function rsa_encrypt(rsa, str)
+{
+    var i;
+    var ret = [];
+    var oaep = RSA_padding_add_PKCS1_OAEP((rsa.n.bitLength()+7)>>3, str);
+    if (! oaep)
+        return null;
+
+    var ba = new Array(oaep.length);
+
+    for (i = 0; i < oaep.length; i++)
+        ba[i] = oaep.charCodeAt(i);
+    var bigint = new BigInteger(ba);
+    var enc = rsa.doPublic(bigint);
+    var h = enc.toString(16);
+    if ((h.length & 1) != 0)
+        h = "0" + h;
+    for (i = 0; i < h.length; i += 2)
+        ret[i / 2] = parseInt(h.substring(i, i + 2), 16);
+    return ret;
+}

data/vendor/assets/javascripts/spiceHTML5/utils.js

@@ -0,0 +1,261 @@
+"use strict";
+/*
+   Copyright (C) 2012 by Jeremy P. White <jwhite@codeweavers.com>
+
+   This file is part of spice-html5.
+
+   spice-html5 is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   spice-html5 is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with spice-html5.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*----------------------------------------------------------------------------
+**  Utility settings and functions for Spice
+**--------------------------------------------------------------------------*/
+var DEBUG = 0;
+var DUMP_DRAWS = false;
+var DUMP_CANVASES = false;
+
+
+/*----------------------------------------------------------------------------
+**  combine_array_buffers
+**      Combine two array buffers.
+**      FIXME - this can't be optimal.  See wire.js about eliminating the need.
+**--------------------------------------------------------------------------*/
+function combine_array_buffers(a1, a2)
+{
+    var in1 = new Uint8Array(a1);
+    var in2 = new Uint8Array(a2);
+    var ret = new ArrayBuffer(a1.byteLength + a2.byteLength);
+    var out = new Uint8Array(ret);
+    var o = 0;
+    var i;
+    for (i = 0; i < in1.length; i++)
+        out[o++] = in1[i];
+    for (i = 0; i < in2.length; i++)
+        out[o++] = in2[i];
+
+    return ret;
+}
+
+/*----------------------------------------------------------------------------
+**  hexdump_buffer
+**--------------------------------------------------------------------------*/
+function hexdump_buffer(a)
+{
+    var mg = new Uint8Array(a);
+    var hex = "";
+    var str = "";
+    var last_zeros = 0;
+    for (var i = 0; i < mg.length; i++)
+    {
+        var h = Number(mg[i]).toString(16);
+        if (h.length == 1)
+            hex += "0";
+        hex += h + " ";
+
+        str += String.fromCharCode(mg[i]);
+
+        if ((i % 16 == 15) || (i == (mg.length - 1)))
+        {
+            while (i % 16 != 15)
+            {
+                hex += "   ";
+                i++;
+            }
+
+            if (last_zeros == 0)
+                console.log(hex + " | " + str);
+
+            if (hex == "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ")
+            {
+                if (last_zeros == 1)
+                {
+                    console.log(".");
+                    last_zeros++;
+                }
+                else if (last_zeros == 0)
+                    last_zeros++;
+            }
+            else
+                last_zeros = 0;
+
+            hex = str = "";
+        }
+    }
+}
+
+/*----------------------------------------------------------------------------
+** Converting keycodes to AT scancodes is very hard.
+** luckly there are some resources on the web and in the Xorg driver that help
+** us figure out what browser depenend keycodes match to what scancodes.
+**
+** This will most likely not work for non US keyboard and browsers other than
+** modern Chrome and FireFox.
+**--------------------------------------------------------------------------*/
+var common_scanmap = [];
+common_scanmap['Q'.charCodeAt(0)]  = KEY_Q;
+common_scanmap['W'.charCodeAt(0)]  = KEY_W;
+common_scanmap['E'.charCodeAt(0)]  = KEY_E;
+common_scanmap['R'.charCodeAt(0)]  = KEY_R;
+common_scanmap['T'.charCodeAt(0)]  = KEY_T;
+common_scanmap['Y'.charCodeAt(0)]  = KEY_Y;
+common_scanmap['U'.charCodeAt(0)]  = KEY_U;
+common_scanmap['I'.charCodeAt(0)]  = KEY_I;
+common_scanmap['O'.charCodeAt(0)]  = KEY_O;
+common_scanmap['P'.charCodeAt(0)]  = KEY_P;
+common_scanmap['A'.charCodeAt(0)]  = KEY_A;
+common_scanmap['S'.charCodeAt(0)]  = KEY_S;
+common_scanmap['D'.charCodeAt(0)]  = KEY_D;
+common_scanmap['F'.charCodeAt(0)]  = KEY_F;
+common_scanmap['G'.charCodeAt(0)]  = KEY_G;
+common_scanmap['H'.charCodeAt(0)]  = KEY_H;
+common_scanmap['J'.charCodeAt(0)]  = KEY_J;
+common_scanmap['K'.charCodeAt(0)]  = KEY_K;
+common_scanmap['L'.charCodeAt(0)]  = KEY_L;
+common_scanmap['Z'.charCodeAt(0)]  = KEY_Z;
+common_scanmap['X'.charCodeAt(0)]  = KEY_X;
+common_scanmap['C'.charCodeAt(0)]  = KEY_C;
+common_scanmap['V'.charCodeAt(0)]  = KEY_V;
+common_scanmap['B'.charCodeAt(0)]  = KEY_B;
+common_scanmap['N'.charCodeAt(0)]  = KEY_N;
+common_scanmap['M'.charCodeAt(0)]  = KEY_M;
+common_scanmap[' '.charCodeAt(0)]  = KEY_Space;
+common_scanmap[13]                 = KEY_Enter;
+common_scanmap[27]                 = KEY_Escape;
+common_scanmap[8]                  = KEY_BackSpace;
+common_scanmap[9]                  = KEY_Tab;
+common_scanmap[16]                 = KEY_ShiftL;
+common_scanmap[17]                 = KEY_LCtrl;
+common_scanmap[18]                 = KEY_Alt;
+common_scanmap[20]                 = KEY_CapsLock;
+common_scanmap[144]                = KEY_NumLock;
+common_scanmap[112]                = KEY_F1;
+common_scanmap[113]                = KEY_F2;
+common_scanmap[114]                = KEY_F3;
+common_scanmap[115]                = KEY_F4;
+common_scanmap[116]                = KEY_F5;
+common_scanmap[117]                = KEY_F6;
+common_scanmap[118]                = KEY_F7;
+common_scanmap[119]                = KEY_F8;
+common_scanmap[120]                = KEY_F9;
+common_scanmap[121]                = KEY_F10;
+common_scanmap[122]                = KEY_F11;
+common_scanmap[123]                = KEY_F12;
+
+/* These externded scancodes do not line up with values from atKeynames */
+common_scanmap[42]                 = 99;
+common_scanmap[19]                 = 101;    // Break
+common_scanmap[111]                = 0xE035; // KP_Divide
+common_scanmap[106]                = 0xE037; // KP_Multiply
+common_scanmap[36]                 = 0xE047; // Home
+common_scanmap[38]                 = 0xE048; // Up
+common_scanmap[33]                 = 0xE049; // PgUp
+common_scanmap[37]                 = 0xE04B; // Left
+common_scanmap[39]                 = 0xE04D; // Right
+common_scanmap[35]                 = 0xE04F; // End
+common_scanmap[40]                 = 0xE050; // Down
+common_scanmap[34]                 = 0xE051; // PgDown
+common_scanmap[45]                 = 0xE052; // Insert
+common_scanmap[46]                 = 0xE053; // Delete
+common_scanmap[44]                 = 0x2A37; // Print
+
+/* These are not common between ALL browsers but are between Firefox and DOM3 */
+common_scanmap['1'.charCodeAt(0)]  = KEY_1;
+common_scanmap['2'.charCodeAt(0)]  = KEY_2;
+common_scanmap['3'.charCodeAt(0)]  = KEY_3;
+common_scanmap['4'.charCodeAt(0)]  = KEY_4;
+common_scanmap['5'.charCodeAt(0)]  = KEY_5;
+common_scanmap['6'.charCodeAt(0)]  = KEY_6;
+common_scanmap['7'.charCodeAt(0)]  = KEY_7;
+common_scanmap['8'.charCodeAt(0)]  = KEY_8;
+common_scanmap['9'.charCodeAt(0)]  = KEY_9;
+common_scanmap['0'.charCodeAt(0)]  = KEY_0;
+common_scanmap[145]                = KEY_ScrollLock;
+common_scanmap[103]                = KEY_KP_7;
+common_scanmap[104]                = KEY_KP_8;
+common_scanmap[105]                = KEY_KP_9;
+common_scanmap[100]                = KEY_KP_4;
+common_scanmap[101]                = KEY_KP_5;
+common_scanmap[102]                = KEY_KP_6;
+common_scanmap[107]                = KEY_KP_Plus;
+common_scanmap[97]                 = KEY_KP_1;
+common_scanmap[98]                 = KEY_KP_2;
+common_scanmap[99]                 = KEY_KP_3;
+common_scanmap[96]                 = KEY_KP_0;
+common_scanmap[110]                = KEY_KP_Decimal;
+common_scanmap[191]                = KEY_Slash;
+common_scanmap[190]                = KEY_Period;
+common_scanmap[188]                = KEY_Comma;
+common_scanmap[220]                = KEY_BSlash;
+common_scanmap[192]                = KEY_Tilde;
+common_scanmap[222]                = KEY_Quote;
+common_scanmap[219]                = KEY_LBrace;
+common_scanmap[221]                = KEY_RBrace;
+
+common_scanmap[91]                 = 0xE05B; //KEY_LMeta
+common_scanmap[92]                 = 0xE05C; //KEY_RMeta
+common_scanmap[93]                 = 0xE05D; //KEY_Menu
+
+/* Firefox/Mozilla codes */
+var firefox_scanmap = [];
+firefox_scanmap[109]                = KEY_Minus;
+firefox_scanmap[61]                 = KEY_Equal;
+firefox_scanmap[59]                 = KEY_SemiColon;
+
+/* DOM3 codes */
+var DOM_scanmap = [];
+DOM_scanmap[189]                = KEY_Minus;
+DOM_scanmap[187]                = KEY_Equal;
+DOM_scanmap[186]                = KEY_SemiColon;
+
+function get_scancode(code)
+{
+    if (common_scanmap[code] === undefined)
+    {
+        if (navigator.userAgent.indexOf("Firefox") != -1)
+            return firefox_scanmap[code];
+        else
+            return DOM_scanmap[code];
+    }
+    else
+        return common_scanmap[code];
+}
+
+function keycode_to_start_scan(code)
+{
+    var scancode = get_scancode(code);
+    if (scancode === undefined)
+    {
+        alert('no map for ' + code);
+        return 0;
+    }
+
+    if (scancode < 0x100) {
+        return scancode;
+    } else {
+        return 0xe0 | ((scancode - 0x100) << 8);
+    }
+}
+
+function keycode_to_end_scan(code)
+{
+    var scancode = get_scancode(code);
+    if (scancode === undefined)
+        return 0;
+
+    if (scancode < 0x100) {
+        return scancode | 0x80;
+    } else {
+        return 0x80e0 | ((scancode - 0x100) << 8);
+    }
+}

data/vendor/assets/javascripts/spiceHTML5/wire.js

@@ -0,0 +1,123 @@
+"use strict";
+/*
+   Copyright (C) 2012 by Jeremy P. White <jwhite@codeweavers.com>
+
+   This file is part of spice-html5.
+
+   spice-html5 is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   spice-html5 is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with spice-html5.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*--------------------------------------------------------------------------------------
+**  SpiceWireReader
+**      This class will receive messages from a WebSocket and relay it to a given
+**  callback.  It will optionally save and pass along a header, useful in processing
+**  the mini message format.
+**--------------------------------------------------------------------------------------*/
+function SpiceWireReader(sc, callback)
+{
+    this.sc = sc;
+    this.callback = callback;
+    this.needed = 0;
+
+    this.buffers = [];
+
+    this.sc.ws.wire_reader = this;
+    this.sc.ws.binaryType = "arraybuffer";
+    this.sc.ws.addEventListener('message', wire_blob_catcher);
+}
+
+SpiceWireReader.prototype =
+{
+
+    /*------------------------------------------------------------------------
+    **  Process messages coming in from our WebSocket
+    **----------------------------------------------------------------------*/
+    inbound: function (mb)
+    {
+        var at;
+
+        /* Just buffer if we don't need anything yet */
+        if (this.needed == 0)
+        {
+            this.buffers.push(mb);
+            return;
+        }
+
+        /* Optimization - if we have just one inbound block, and it's
+            suitable for our needs, just use it.  */
+        if (this.buffers.length == 0 && mb.byteLength >= this.needed)
+        {
+            if (mb.byteLength > this.needed)
+            {
+                this.buffers.push(mb.slice(this.needed));
+                mb = mb.slice(0, this.needed);
+            }
+            this.callback.call(this.sc, mb,
+                        this.saved_msg_header || undefined);
+        }
+        else
+        {
+            this.buffers.push(mb);
+        }
+
+
+        /* If we have fragments that add up to what we need, combine them */
+        /*  FIXME - it would be faster to revise the processing code to handle
+        **          multiple fragments directly.  Essentially, we should be
+        **          able to do this without any slice() or combine_array_buffers() calls */
+        while (this.buffers.length > 1 && this.buffers[0].byteLength < this.needed)
+        {
+            var mb1 = this.buffers.shift();
+            var mb2 = this.buffers.shift();
+
+            this.buffers.unshift(combine_array_buffers(mb1, mb2));
+        }
+
+
+        while (this.buffers.length > 0 && this.buffers[0].byteLength >= this.needed)
+        {
+            mb = this.buffers.shift();
+            if (mb.byteLength > this.needed)
+            {
+                this.buffers.unshift(mb.slice(this.needed));
+                mb = mb.slice(0, this.needed);
+            }
+            this.callback.call(this.sc, mb,
+                        this.saved_msg_header || undefined);
+        }
+        
+    },
+
+    request: function(n)
+    {
+        this.needed = n;
+    },
+
+    save_header: function(h)
+    {
+        this.saved_msg_header = h;
+    },
+
+    clear_header: function()
+    {
+        this.saved_msg_header = undefined;
+    },
+}
+
+function wire_blob_catcher(e)
+{
+    DEBUG > 1 && console.log(">> WebSockets.onmessage");
+    DEBUG > 1 && console.log("id " + this.wire_reader.sc.connection_id +"; type " + this.wire_reader.sc.type);
+    SpiceWireReader.prototype.inbound.call(this.wire_reader, e.data);
+}