sstapi/lib/util.js

a 3rd-party ifeng fm api

(function() {
  var crypto, fs, util;

  crypto = require('crypto');

  util = require('util');

  fs = require('fs');

  this.changeChar = function(charCode) {
    if ((65 <= charCode && charCode <= 90)) {
      return charCode - 65;
    }
    if ((97 <= charCode && charCode <= 122)) {
      return 26 + charCode - 97;
    }
    if ((48 <= charCode && charCode <= 57)) {
      return 52 + charCode - 48;
    }
    switch (charCode) {
      case 43:
        return 62;
      case 47:
        return 63;
      case 64:
        return 61;
      default:
        return -1;
    }
  };

  this.segmentDecode = function(array) {
    var abyte1, byte0, byte1, byte10, byte2, byte3, byte4, byte5, byte6, byte7, byte8, byte9, len;
    len = array.length;
    if ((2 > len && len > 4)) {
      null;
    }
    abyte1 = [];
    if (len > 1) {
      byte0 = 0x3F & array[0];
      byte6 = byte0 << 2;
      byte1 = 0x30 & array[1];
      byte7 = this.byteDecode(byte1, 4);
      byte2 = 0x0F & array[1];
      byte8 = byte2 << 4;
      abyte1[0] = byte6 | byte7 & 0xFF;
    }
    if (len > 2) {
      byte3 = 0x3C & array[2];
      byte9 = this.byteDecode(byte3, 2);
      abyte1[1] = byte8 | byte9 & 0xFF;
    }
    if (len > 3) {
      byte4 = 0x03 & array[2];
      byte10 = byte4 << 6;
      byte5 = 0x3F & array[3];
      abyte1[2] = byte10 | byte5 & 0xFF;
    }
    return abyte1;
  };

  this.byteDecode = function(charCode, pos) {
    var baseCode, bitset, i, _i;
    baseCode = [-128, 64, 32, 16, 8, 4, 2, 1];
    bitset = '00000000'.split('');
    for (i = _i = 0; _i < 8; i = ++_i) {
      if (i < pos) {
        bitset[i] = '0';
      } else {
        if ((charCode & baseCode[i - pos]) === baseCode[i - pos]) {
          bitset[i] = '1';
        } else {
          bitset[i] = '0';
        }
      }
    }
    return parseInt(bitset.join(''), 2);
  };

  this.convertUrl = function(encryptedUrl) {
    var changedArray, convertedArray, i, len, piece, seg, _i, _j;
    len = encryptedUrl.length;
    seg = encryptedUrl.length / 4;
    convertedArray = [];
    changedArray = [];
    for (i = _i = 0; 0 <= len ? _i < len : _i > len; i = 0 <= len ? ++_i : --_i) {
      changedArray.push(this.changeChar(encryptedUrl[i].charCodeAt(0)));
    }
    piece = [];
    for (i = _j = 0; 0 <= len ? _j < len : _j > len; i = 0 <= len ? ++_j : --_j) {
      if (changedArray[i] === -1) {

      } else {
        piece.push(changedArray[i]);
      }
      if (piece.length >= 4) {
        convertedArray = convertedArray.concat(this.segmentDecode(piece));
        piece = [];
      }
    }
    if (piece.length > 0) {
      convertedArray = convertedArray.concat(this.segmentDecode(piece));
    }
    return convertedArray;
  };

  this.crateKeyString = function(audioId) {
    var fullkey, keyTemplate;
    keyTemplate = "sst_android_" + audioId + "_sstifengcom";
    fullkey = crypto.createHash('md5').update(keyTemplate).digest('hex');
    return fullkey.substring(0, 24);
  };

  module.exports.decryptAudioUrl = function(encryptedUrl, audioId) {
    var convertedUrl, decipher, e, hexedUrl, i, key, plainText, _i, _len;
    convertedUrl = this.convertUrl(encryptedUrl);
    hexedUrl = '';
    for (_i = 0, _len = convertedUrl.length; _i < _len; _i++) {
      i = convertedUrl[_i];
      if (i <= 16) {
        hexedUrl += "0";
      }
      hexedUrl += i.toString(16);
    }
    key = this.crateKeyString(audioId);
    decipher = crypto.createDecipheriv('des-ede3-cbc', key, '20110512');
    plainText = '';
    try {
      plainText = decipher.update(hexedUrl, 'hex', 'utf8');
      plainText += decipher.final('utf8');
    } catch (_error) {
      e = _error;
    }
    return plainText;
  };

  module.exports.objectLoop = function(v, k) {
    var kp, logTemplate, logText, plainText, q;
    if (typeof v === "object") {
      for (kp in v) {
        if (Object.hasOwnProperty.call(v, kp)) {
          q = kp;
          if (k != null) {
            q = "" + k + "." + kp;
          }
          this.objectLoop(v[kp], q);
        } else {

        }
      }
      if ((v != null) && (v.filepath != null)) {
        plainText = this.decryptAudioUrl(v.filepath, v.audio[0].audioid);
        if (plainText === '') {
          logTemplate = 'encryptedUrl: %s\nkey: %s\nlength: %s\n\n';
          logText = util.format(logTemplate, v.filepath, v.audio[0].audioid, v.filepath.length);
          this.writeLog('./_decryptfailed', logText);
        } else {

        }
        v.filepath = plainText;
      }
    }
  };

  this.writeLog = function(filePath, text) {
    return fs.appendFileSync(filePath, text);
  };

}).call(this);