tm-sdk/lib/signhelper.js

tenmove copyright, node base module

var errors = require('./error');
var utility = require('./utility');

var commonlibError = errors.commonlibError;

function genHashSign(signType, input, encodeType) {
    if (utility.isErrorOrUndefined(signType) || 
        utility.isErrorOrUndefined(input) ||
        utility.isErrorOrUndefined(encodeType)) {
        throw commonlibError("func(genHashSign)'s input is invalid!");
    }

    try {
        var signer = crypto.createHash(signType);
        signer.update(input);
        var output = signer.digest(encodeType);
        return output;
    } catch(e) {
        throw commonlibError("func(genHashSign)'s input is invalid!");
    }
}

function genHmacSign(signType, key, input, encodeType) {
    if (utility.isErrorOrUndefined(signType) || 
        utility.isErrorOrUndefined(key) ||
        utility.isErrorOrUndefined(input) ||
        utility.isErrorOrUndefined(encodeType)) {
        throw commonlibError("func(genHmacSign)'s input is invalid!");
    }

    try {
        var output = crypto.createHmac(signType, key).update(input).digest(encodeType);
        return output;
    } catch(e) {
        throw commonlibError("func(genHmacSign)'s input is invalid!");
    }
}

function genRSASign(signtype, input, key, encodetype) {
    if (utility.isErrorOrUndefined(signType) || 
        utility.isErrorOrUndefined(key) ||
        utility.isErrorOrUndefined(input) ||
        utility.isErrorOrUndefined(encodeType)) {
        throw commonlibError("func(genRSASign)'s input is invalid!");
    }

    try {
        var signer = crypto.createSign(signtype);
        signer.update(input);
        var safeSign = signer.sign(key, encodetype);
        return safeSign;
    } catch(e) {
        throw commonlibError("func(genRSASign)'s input is invalid!");
    }
}

function genAESSign(signType, input, key, inputEncoding, outputEncoding) {
    if (utility.isErrorOrUndefined(signType) || 
        utility.isErrorOrUndefined(key) ||
        utility.isErrorOrUndefined(input) ||
        utility.isErrorOrUndefined(inputEncoding) ||
        utility.isErrorOrUndefined(outputEncoding)) {
        throw commonlibError("func(genAESSign)'s input is invalid!");
    }

    try {
        var cipher = crypto.createCipher(signType, key);
        var crypted = cipher.update(input, inputEncoding, outputEncoding);
        crypted += cipher.final(outputEncoding);
        return crypted;
    } catch(e) {
        throw commonlibError("func(genAESSign)'s input is invalid!");
    }
}

function genAESivSign(signtype, input, key, iv, inputEncoding, outputEncoding) {
    if (utility.isErrorOrUndefined(signType) || 
        utility.isErrorOrUndefined(key) ||
        utility.isErrorOrUndefined(input) ||
        utility.isErrorOrUndefined(iv) ||
        utility.isErrorOrUndefined(inputEncoding) ||
        utility.isErrorOrUndefined(outputEncoding)) {
        throw commonlibError("func(genAESivSign)'s input is invalid!");
    }

    try {
        var cipher = crypto.createCipheriv(signtype, key, iv);
        var crypted = cipher.update(input, inputEncoding, outputEncoding);
        crypted += cipher.final(outputEncoding);
        return crypted;
    } catch(e) {
        throw commonlibError("func(genAESivSign)'s input is invalid!");
    }
}

function checkVerifySign(verifyType, paramStr, key, sign, encodeType) {
    if (utility.isErrorOrUndefined(verifyType) || 
        utility.isErrorOrUndefined(key) ||
        utility.isErrorOrUndefined(paramStr) ||
        utility.isErrorOrUndefined(sign) ||
        utility.isErrorOrUndefined(encodeType)) {
        throw commonlibError("func(checkVerifySign)'s input is invalid!");
    }

    try {
        var verifier = crypto.createVerify(verifyType);
        verifier.update(paramStr);
        var result = verifier.verify(key, sign, encodeType);
        return result;
    } catch(e) {
        throw commonlibError("func(checkVerifySign)'s input is invalid!");
    }
}

function encodeBase64(input) {
    if (utility.isErrorOrUndefined(input)) {
        throw commonlibError("func(encodeBase64)'s input is invalid!");
    }

    try {
        return new Buffer(input).toString('base64');
    } catch(e) {
        throw commonlibError("func(encodeBase64)'s input is invalid!");
    }
}

function decodeBase64(input) {
    if (utility.isErrorOrUndefined(input)) {
        throw commonlibError("func(decodeBase64)'s input is invalid!");
    }
    
    try {
        return new Buffer(input, 'base64').toString();
    } catch(e) {
        throw commonlibError("func(encodeBase64)'s input is invalid!");
    }
}

module.exports = {
    genHashSign : genHashSign,
    genHmacSign : genHmacSign,
    genRSASign : genRSASign,
    genAESSign : genAESSign,
    genAESivSign : genAESivSign,
    checkVerifySign : checkVerifySign,
    encodeBase64 : encodeBase64,
    decodeBase64 : decodeBase64,
}