bdcontract-web-client/js/createWS.js

var createWssocket = function (wsurl, onopen, handler) {
    console.log("[createWS.js] createWssocket : " + wsurl);
    var retsocket = {};
    retsocket.handlerList = [];
    if (handler)
        retsocket.handlerList.push(handler);
    var wssocket = new WebSocket(wsurl);
    wssocket.onerror = function (error) {
        console.log(error);
    };

    wssocket.onopen = onopen;
    var onmessage = function (event) {
        var obj = JSON.parse(event.data);
        switch (obj.action) {
            case 'sendNextSegment':
                retsocket.sendNextSegment();
                break;
            case 'sendSeg':
                retsocket.receiveSeg(obj);
                break;
            default:
                for (var i = 0; i < retsocket.handlerList.length; i++) {
                    var h = retsocket.handlerList[i];
                    h(event, wssocket);
                }
        }
    };

    var reconnect = function (error) {
        setTimeout(function () {
            console.log("[createWS.js] try to reconnect");
            wssocket = new WebSocket(wsurl);
            wssocket.onclose = reconnect;
            wssocket.onmessage = onmessage;
            wssocket.onopen = onopen;
        }, 1000);
    };
    wssocket.onclose = reconnect;

    retsocket.receiveSeg = function (obj) {
        if (obj.cid === 'start') {
            retsocket.toReceive = "";
        }
        retsocket.toReceive += obj.data;
        if (obj.cid === 'done') {
            console.log("[receiveSeg] Received AllData:" + retsocket.toReceive);
            var event = {};
            event.data = retsocket.toReceive;
            retsocket.toReceive = "";
            handler(event);
        }
    };
    wssocket.onmessage = onmessage;

    retsocket.isSending = false;
    retsocket.sendList = [];
    retsocket.monitor = function () {
        if (!retsocket.isSending) {
            if (retsocket.sendList.length > 0) {
                retsocket.send(retsocket.sendList.pop());
            }
        }
        setTimeout(retsocket.monitor, 1000);
    };
    // TODO: we don't need monitor at all?
    retsocket.monitor();
    retsocket.send = function (str) {
        if (retsocket.isSending) {
            retsocket.sendList.push(str);
            return;
        }
        if (str.length > 1024) {
            retsocket.isSending = true;
            retsocket.toSend = str.substr(1024);
            var obj = {};
            obj.isSegment = true;
            obj.data = str.substr(0, 1024);
            wssocket.send(JSON.stringify(obj));
        } else
            wssocket.send(str);
    };
    retsocket.sendNextSegment = function () {
        var str = retsocket.toSend;
        const obj = {};
        if (str.length > 1024) {
            retsocket.toSend = str.substr(1024);
            obj.isSegment = true;
            obj.data = str.substr(0, 1024);
            wssocket.send(JSON.stringify(obj));
        } else {
            retsocket.toSend = "";
            obj.isSegment = false;
            obj.data = str;
            wssocket.send(JSON.stringify(obj));
            retsocket.isSending = false;
            if (retsocket.sendList.length > 0) {
                retsocket.send(retsocket.sendList.pop());
            }
        }
    };
    retsocket.isOpen = function () {
        return wssocket.readyState;
    }
    retsocket.addHandler = function (handler) {
        retsocket.handlerList.push(handler);
    }
    return retsocket;
};

var aesDecrypt = function (data) {
    data = cryptico.b64to256(data);
    var encryptedBlocks = cryptico.string2bytes(data);
    var exkey = global.aesKey.slice(0);
    aes.ExpandKey(exkey);
    aes.Decrypt(encryptedBlocks, exkey);
    return cryptico.bytes2string(encryptedBlocks);

};
var aesEncrypt = function (data, aesKey) {
    var exkey = aesKey.slice(0);
    aes.ExpandKey(exkey);
    var blocks = my.string2bytes(data);
    blocks = my.pad16(blocks);
    aes.Encrypt(blocks, exkey);
    ciphertext = cryptico.bytes2string(blocks);
    ciphertext = cryptico.b256to64(ciphertext);
    return ciphertext;
};
var rsaEncrypt = function (data, rsaKey) {
    var rsa = new RSAKey();
    rsa.setPublic(rsaKey.n, rsaKey.e1);
    return rsa.encrypt(data);
};
var loadRSAKey = function (rsaKey) {
    var str = cryptico.b64to256(rsaKey);
    str = str.split(",");
    var ret = {};
    ret.n = str[0];
    ret.e1 = str[1];
    ret.e2 = str[2];
    return ret;
};
var testRSA = function () {
    pubKey = loadRSAKey(global.privKey);
    reqContent = {};
    reqContent.action = "main";
    reqContent.arg = "[{\"score\":20},{\"score\":20}]";
    reqContent.contractID = "abc";
    eReq = encryptReq(reqContent, pubKey);
    url = "http://localhost:8080/SCIDE/SCManager?action=executeContractEncrypted&contractRequest="
        + encodeURIComponent(JSON.stringify(eReq));
};

var encryptReq = function (reqContent, pubKey) {
    // global.pubKey = loadRSAKey(global.privKey);
    var aes = {};
    aes.key = cryptico.generateAESKey();
    var aesObj = JSON.stringify(aes);
    var rsa = new RSAKey();
    rsa.setPrivate(pubKey.n, pubKey.e1, pubKey.e2);
    var encrypedReq = {};
    encrypedReq.action = rsa.decrypt(aesObj);
    encrypedReq.contractID = reqContent.contractID;
    reqContent.contractID = undefined;
    encrypedReq.arg = JSON.stringify(reqContent);
    encrypedReq.arg = aesEncrypt(encrypedReq.arg, aes.key);
    encrypedReq.requester = pubKey.n + "," + pubKey.e1 + "," + "0";
    encrypedReq.requester = cryptico.b256to64(encrypedReq.requester);
    return encrypedReq;
};

var onExecuteResultInternal = function (data) {
    console.log(data);
    global.executeResult = data;
    var reqId = data.responseID;
    var callback = global.cbs[data.responseID];
    if (callback) {
        callback(global.executeResult, data);
    }
};
window.executeContract = function (contractID, method, strarg, cb, asDebug) {
    var sm2Key = global.sm2Key;
    var request = {};
    request.action = "executeContract";
    request.requestID = new Date().getTime() + "_"
        + Math.floor(Math.random() * 10000);
    if (asDebug)
       request.isDebug = true;
    global.cbs[request.requestID] = cb;
    request.contractID = contractID;
    request.operation = method;
    request.arg = strarg;

    if (sm2Key) {
        request.pubkey = sm2Key.publicKey;
        request.signature = sm2.doSignature(request.contractID + "|"
            + method + "|" + strarg + "|" + sm2Key.publicKey,
            sm2Key.privateKey, {hash: true, der: true});
    }

    global.wssocket.send(JSON.stringify(request));
};

window.executeCurrentContract = function (method, strarg, cb) {
    console.log("executeCurrentContract");
    var contract = global.currentContract;
    executeContract(contract.id, method, strarg, cb);
};


window.loadBDWareWebSDK = function (url, onopen, handler) {
    if (!window.global) {
        window.global = {};
    }
    if (!global.sm2Key) {
        if (sm2)
            global.sm2Key = sm2.generateKeyPairHex();
    }
    if (!global.cbs) {
        global.cbs = {};
    }
    if (!global.wssocket) {
        global.wssocket = createWssocket(url, onopen, function (event, wss) {
            var data = event.data;
            var obj = JSON.parse(data);
            switch (obj.action) {
                case 'onExecuteResult':
                    onExecuteResultInternal(obj);
                default:
                    break;
            }
            handler(event, global.wssocket);
        });
    } else {
        if (onopen)
            onopen();
        global.wssocket.addHandler(handler);
    }
};
// Usage:
// Approach 1:
// var url = "ws://" +
// document.location.host+(document.location.pathname.replace("scide.html",
// "SCExecutor"));
// global.wssocket = createWssocket(url, WSHandler);

// Approach 2:
// loadBDWareWebSDK(url,function(){},WSHandler);
// global.currentContract = {'id':'DataAnalysisSample'};
// executeContract("contractID","methodName","arg",function(data){
// });
// executeCurrentContract("methodName","arg",function(data){
// });
// the bdware client won't call this method