home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / lightsprites.swf / scripts / __Packages / ScoreEncrypter.as < prev    next >
Encoding:
Text File  |  2007-09-27  |  12.7 KB  |  376 lines
  1. class ScoreEncrypter
  2. {
  3.    var roundsArray;
  4.    var shiftOffsets;
  5.    var Nb;
  6.    var Nk;
  7.    var Nr;
  8.    var Rcon = [1,2,4,8,16,32,64,128,27,54,108,216,171,77,154,47,94,188,99,198,151,53,106,212,179,125,250,239,197,145];
  9.    var SBox = [99,124,119,123,242,107,111,197,48,1,103,43,254,215,171,118,202,130,201,125,250,89,71,240,173,212,162,175,156,164,114,192,183,253,147,38,54,63,247,204,52,165,229,241,113,216,49,21,4,199,35,195,24,150,5,154,7,18,128,226,235,39,178,117,9,131,44,26,27,110,90,160,82,59,214,179,41,227,47,132,83,209,0,237,32,252,177,91,106,203,190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,56,245,188,182,218,33,16,255,243,210,205,12,19,236,95,151,68,23,196,167,126,61,100,93,25,115,96,129,79,220,34,42,144,136,70,238,184,20,222,94,11,219,224,50,58,10,73,6,36,92,194,211,172,98,145,149,228,121,231,200,55,109,141,213,78,169,108,86,244,234,101,122,174,8,186,120,37,46,28,166,180,198,232,221,116,31,75,189,139,138,112,62,181,102,72,3,246,14,97,53,87,185,134,193,29,158,225,248,152,17,105,217,142,148,155,30,135,233,206,85,40,223,140,161,137,13,191,230,66,104,65,153,45,15,176,84,187,22];
  10.    var SBoxInverse = [82,9,106,213,48,54,165,56,191,64,163,158,129,243,215,251,124,227,57,130,155,47,255,135,52,142,67,68,196,222,233,203,84,123,148,50,166,194,35,61,238,76,149,11,66,250,195,78,8,46,161,102,40,217,36,178,118,91,162,73,109,139,209,37,114,248,246,100,134,104,152,22,212,164,92,204,93,101,182,146,108,112,72,80,253,237,185,218,94,21,70,87,167,141,157,132,144,216,171,0,140,188,211,10,247,228,88,5,184,179,69,6,208,44,30,143,202,63,15,2,193,175,189,3,1,19,138,107,58,145,17,65,79,103,220,234,151,242,207,206,240,180,230,115,150,172,116,34,231,173,53,133,226,249,55,232,28,117,223,110,71,241,26,113,29,41,197,137,111,183,98,14,170,24,190,27,252,86,62,75,198,210,121,32,154,219,192,254,120,205,90,244,31,221,168,51,136,7,199,49,177,18,16,89,39,128,236,95,96,81,127,169,25,181,74,13,45,229,122,159,147,201,156,239,160,224,59,77,174,42,245,176,200,235,187,60,131,83,153,97,23,43,4,126,186,119,214,38,225,105,20,99,85,33,12,125];
  11.    var blockSize = 128;
  12.    var keySize = 128;
  13.    function ScoreEncrypter(keySize, blockSize)
  14.    {
  15.       if(keySize != null)
  16.       {
  17.          this.keySize = keySize;
  18.       }
  19.       if(blockSize != null)
  20.       {
  21.          this.blockSize = blockSize;
  22.       }
  23.       this.roundsArray = [0,0,0,0,[0,0,0,0,10,0,12,0,14],0,[0,0,0,0,12,0,12,0,14],0,[0,0,0,0,14,0,14,0,14]];
  24.       this.shiftOffsets = [0,0,0,0,[0,1,2,3],0,[0,1,2,3],0,[0,1,3,4]];
  25.       this.Nb = blockSize / 32;
  26.       this.Nk = keySize / 32;
  27.       this.Nr = this.roundsArray[this.Nk][this.Nb];
  28.    }
  29.    function encrypt(src, key, mode)
  30.    {
  31.       var _loc5_ = new Array();
  32.       var _loc6_ = new Array();
  33.       var _loc4_ = this.blockSize / 8;
  34.       if(mode == "CBC")
  35.       {
  36.          _loc5_ = this.getRandomBytes(_loc4_);
  37.       }
  38.       var _loc7_ = this.formatPlaintext(this.strToChars(src));
  39.       var _loc8_ = this.keyExpansion(this.strToChars(key));
  40.       var _loc3_ = 0;
  41.       while(_loc3_ < _loc7_.length / _loc4_)
  42.       {
  43.          _loc6_ = _loc7_.slice(_loc3_ * _loc4_,(_loc3_ + 1) * _loc4_);
  44.          if(mode == "CBC")
  45.          {
  46.             var _loc2_ = 0;
  47.             while(_loc2_ < _loc4_)
  48.             {
  49.                _loc6_[_loc2_] ^= _loc5_[_loc3_ * _loc4_ + _loc2_];
  50.                _loc2_ = _loc2_ + 1;
  51.             }
  52.          }
  53.          _loc5_ = _loc5_.concat(this.encryption(_loc6_,_loc8_));
  54.          _loc3_ = _loc3_ + 1;
  55.       }
  56.       return this.charsToHex(_loc5_);
  57.    }
  58.    function decrypt(src, key, mode)
  59.    {
  60.       var _loc5_ = new Array();
  61.       var _loc7_ = new Array();
  62.       var _loc6_ = this.hexToChars(src);
  63.       var _loc4_ = this.blockSize / 8;
  64.       var _loc8_ = this.keyExpansion(this.strToChars(key));
  65.       var _loc3_ = _loc6_.length / _loc4_ - 1;
  66.       while(_loc3_ > 0)
  67.       {
  68.          _loc7_ = this.decryption(_loc6_.slice(_loc3_ * _loc4_,(_loc3_ + 1) * _loc4_),_loc8_);
  69.          if(mode == "CBC")
  70.          {
  71.             var _loc2_ = 0;
  72.             while(_loc2_ < _loc4_)
  73.             {
  74.                _loc5_[(_loc3_ - 1) * _loc4_ + _loc2_] = _loc7_[_loc2_] ^ _loc6_[(_loc3_ - 1) * _loc4_ + _loc2_];
  75.                _loc2_ = _loc2_ + 1;
  76.             }
  77.          }
  78.          else
  79.          {
  80.             _loc5_ = _loc7_.concat(_loc5_);
  81.          }
  82.          _loc3_ = _loc3_ - 1;
  83.       }
  84.       if(mode == "ECB")
  85.       {
  86.          _loc5_ = this.decryption(_loc6_.slice(0,_loc4_),_loc8_).concat(_loc5_);
  87.       }
  88.       return this.charsToStr(_loc5_);
  89.    }
  90.    function cyclicShiftLeft(src, pos)
  91.    {
  92.       var _loc2_ = src.slice(0,pos);
  93.       src = src.slice(pos).concat(_loc2_);
  94.       return src;
  95.    }
  96.    function xtime(poly)
  97.    {
  98.       poly <<= 1;
  99.       return !(poly & 256) ? poly : poly ^ 283;
  100.    }
  101.    function mult_GF256(x, y)
  102.    {
  103.       var _loc4_ = 0;
  104.       var _loc2_ = 1;
  105.       while(_loc2_ < 256)
  106.       {
  107.          if(x & _loc2_)
  108.          {
  109.             _loc4_ ^= y;
  110.          }
  111.          _loc2_ *= 2;
  112.          y = this.xtime(y);
  113.       }
  114.       return _loc4_;
  115.    }
  116.    function byteSub(state, dir)
  117.    {
  118.       if(dir == "encrypt")
  119.       {
  120.          var _loc5_ = this.SBox;
  121.       }
  122.       else
  123.       {
  124.          _loc5_ = this.SBoxInverse;
  125.       }
  126.       var _loc3_ = 0;
  127.       while(_loc3_ < 4)
  128.       {
  129.          var _loc2_ = 0;
  130.          while(_loc2_ < this.Nb)
  131.          {
  132.             state[_loc3_][_loc2_] = _loc5_[state[_loc3_][_loc2_]];
  133.             _loc2_ = _loc2_ + 1;
  134.          }
  135.          _loc3_ = _loc3_ + 1;
  136.       }
  137.    }
  138.    function shiftRow(state, dir)
  139.    {
  140.       var _loc2_ = 1;
  141.       while(_loc2_ < 4)
  142.       {
  143.          if(dir == "encrypt")
  144.          {
  145.             state[_loc2_] = this.cyclicShiftLeft(state[_loc2_],this.shiftOffsets[this.Nb][_loc2_]);
  146.          }
  147.          else
  148.          {
  149.             state[_loc2_] = this.cyclicShiftLeft(state[_loc2_],this.Nb - this.shiftOffsets[this.Nb][_loc2_]);
  150.          }
  151.          _loc2_ = _loc2_ + 1;
  152.       }
  153.    }
  154.    function mixColumn(state, dir)
  155.    {
  156.       var _loc5_ = new Array();
  157.       var _loc2_ = 0;
  158.       while(_loc2_ < this.Nb)
  159.       {
  160.          var _loc4_ = 0;
  161.          while(_loc4_ < 4)
  162.          {
  163.             if(dir == "encrypt")
  164.             {
  165.                _loc5_[_loc4_] = this.mult_GF256(state[_loc4_][_loc2_],2) ^ this.mult_GF256(state[(_loc4_ + 1) % 4][_loc2_],3) ^ state[(_loc4_ + 2) % 4][_loc2_] ^ state[(_loc4_ + 3) % 4][_loc2_];
  166.             }
  167.             else
  168.             {
  169.                _loc5_[_loc4_] = this.mult_GF256(state[_loc4_][_loc2_],14) ^ this.mult_GF256(state[(_loc4_ + 1) % 4][_loc2_],11) ^ this.mult_GF256(state[(_loc4_ + 2) % 4][_loc2_],13) ^ this.mult_GF256(state[(_loc4_ + 3) % 4][_loc2_],9);
  170.             }
  171.             _loc4_ = _loc4_ + 1;
  172.          }
  173.          _loc4_ = 0;
  174.          while(_loc4_ < 4)
  175.          {
  176.             state[_loc4_][_loc2_] = _loc5_[_loc4_];
  177.             _loc4_ = _loc4_ + 1;
  178.          }
  179.          _loc2_ = _loc2_ + 1;
  180.       }
  181.    }
  182.    function addRoundKey(state, roundKey)
  183.    {
  184.       var _loc2_ = 0;
  185.       while(_loc2_ < this.Nb)
  186.       {
  187.          state[0][_loc2_] ^= roundKey[_loc2_] & 255;
  188.          state[1][_loc2_] ^= roundKey[_loc2_] >> 8 & 255;
  189.          state[2][_loc2_] ^= roundKey[_loc2_] >> 16 & 255;
  190.          state[3][_loc2_] ^= roundKey[_loc2_] >> 24 & 255;
  191.          _loc2_ = _loc2_ + 1;
  192.       }
  193.    }
  194.    function keyExpansion(key)
  195.    {
  196.       var _loc2_ = 0;
  197.       this.Nk = this.keySize / 32;
  198.       this.Nb = this.blockSize / 32;
  199.       var _loc4_ = new Array();
  200.       this.Nr = this.roundsArray[this.Nk][this.Nb];
  201.       var _loc3_ = 0;
  202.       while(_loc3_ < this.Nk)
  203.       {
  204.          _loc4_[_loc3_] = key[4 * _loc3_] | key[4 * _loc3_ + 1] << 8 | key[4 * _loc3_ + 2] << 16 | key[4 * _loc3_ + 3] << 24;
  205.          _loc3_ = _loc3_ + 1;
  206.       }
  207.       _loc3_ = this.Nk;
  208.       while(_loc3_ < this.Nb * (this.Nr + 1))
  209.       {
  210.          _loc2_ = _loc4_[_loc3_ - 1];
  211.          if(_loc3_ % this.Nk == 0)
  212.          {
  213.             _loc2_ = (this.SBox[_loc2_ >> 8 & 255] | this.SBox[_loc2_ >> 16 & 255] << 8 | this.SBox[_loc2_ >> 24 & 255] << 16 | this.SBox[_loc2_ & 255] << 24) ^ this.Rcon[Math.floor(_loc3_ / this.Nk) - 1];
  214.          }
  215.          else if(this.Nk > 6 && _loc3_ % this.Nk == 4)
  216.          {
  217.             _loc2_ = this.SBox[_loc2_ >> 24 & 255] << 24 | this.SBox[_loc2_ >> 16 & 255] << 16 | this.SBox[_loc2_ >> 8 & 255] << 8 | this.SBox[_loc2_ & 255];
  218.          }
  219.          _loc4_[_loc3_] = _loc4_[_loc3_ - this.Nk] ^ _loc2_;
  220.          _loc3_ = _loc3_ + 1;
  221.       }
  222.       return _loc4_;
  223.    }
  224.    function Round(state, roundKey)
  225.    {
  226.       this.byteSub(state,"encrypt");
  227.       this.shiftRow(state,"encrypt");
  228.       this.mixColumn(state,"encrypt");
  229.       this.addRoundKey(state,roundKey);
  230.    }
  231.    function InverseRound(state, roundKey)
  232.    {
  233.       this.addRoundKey(state,roundKey);
  234.       this.mixColumn(state,"decrypt");
  235.       this.shiftRow(state,"decrypt");
  236.       this.byteSub(state,"decrypt");
  237.    }
  238.    function FinalRound(state, roundKey)
  239.    {
  240.       this.byteSub(state,"encrypt");
  241.       this.shiftRow(state,"encrypt");
  242.       this.addRoundKey(state,roundKey);
  243.    }
  244.    function InverseFinalRound(state, roundKey)
  245.    {
  246.       this.addRoundKey(state,roundKey);
  247.       this.shiftRow(state,"decrypt");
  248.       this.byteSub(state,"decrypt");
  249.    }
  250.    function encryption(block, expandedKey)
  251.    {
  252.       block = this.packBytes(block);
  253.       this.addRoundKey(block,expandedKey);
  254.       var _loc2_ = 1;
  255.       while(_loc2_ < this.Nr)
  256.       {
  257.          this.Round(block,expandedKey.slice(this.Nb * _loc2_,this.Nb * (_loc2_ + 1)));
  258.          _loc2_ = _loc2_ + 1;
  259.       }
  260.       this.FinalRound(block,expandedKey.slice(this.Nb * this.Nr));
  261.       return this.unpackBytes(block);
  262.    }
  263.    function decryption(block, expandedKey)
  264.    {
  265.       block = this.packBytes(block);
  266.       this.InverseFinalRound(block,expandedKey.slice(this.Nb * this.Nr));
  267.       var _loc2_ = this.Nr - 1;
  268.       while(_loc2_ > 0)
  269.       {
  270.          this.InverseRound(block,expandedKey.slice(this.Nb * _loc2_,this.Nb * (_loc2_ + 1)));
  271.          _loc2_ = _loc2_ - 1;
  272.       }
  273.       this.addRoundKey(block,expandedKey);
  274.       return this.unpackBytes(block);
  275.    }
  276.    function packBytes(octets)
  277.    {
  278.       var _loc2_ = new Array();
  279.       _loc2_[0] = new Array();
  280.       _loc2_[1] = new Array();
  281.       _loc2_[2] = new Array();
  282.       _loc2_[3] = new Array();
  283.       var _loc1_ = 0;
  284.       while(_loc1_ < octets.length)
  285.       {
  286.          _loc2_[0][_loc1_ / 4] = octets[_loc1_];
  287.          _loc2_[1][_loc1_ / 4] = octets[_loc1_ + 1];
  288.          _loc2_[2][_loc1_ / 4] = octets[_loc1_ + 2];
  289.          _loc2_[3][_loc1_ / 4] = octets[_loc1_ + 3];
  290.          _loc1_ += 4;
  291.       }
  292.       return _loc2_;
  293.    }
  294.    function unpackBytes(packed)
  295.    {
  296.       var _loc1_ = new Array();
  297.       var _loc2_ = 0;
  298.       while(_loc2_ < packed[0].length)
  299.       {
  300.          _loc1_[_loc1_.length] = packed[0][_loc2_];
  301.          _loc1_[_loc1_.length] = packed[1][_loc2_];
  302.          _loc1_[_loc1_.length] = packed[2][_loc2_];
  303.          _loc1_[_loc1_.length] = packed[3][_loc2_];
  304.          _loc2_ = _loc2_ + 1;
  305.       }
  306.       return _loc1_;
  307.    }
  308.    function formatPlaintext(plaintext)
  309.    {
  310.       var _loc3_ = this.blockSize / 8;
  311.       var _loc2_ = _loc3_ - plaintext.length % _loc3_;
  312.       while(_loc2_ > 0 && _loc2_ < _loc3_)
  313.       {
  314.          plaintext[plaintext.length] = 0;
  315.          _loc2_ = _loc2_ - 1;
  316.       }
  317.       return plaintext;
  318.    }
  319.    function getRandomBytes(howMany)
  320.    {
  321.       var _loc2_ = new Array();
  322.       var _loc1_ = 0;
  323.       while(_loc1_ < howMany)
  324.       {
  325.          _loc2_[_loc1_] = Math.round(Math.random() * 255);
  326.          _loc1_ = _loc1_ + 1;
  327.       }
  328.       return _loc2_;
  329.    }
  330.    function hexToChars(hex)
  331.    {
  332.       var _loc3_ = new Array();
  333.       var _loc1_ = hex.substr(0,2) != "0x" ? 0 : 2;
  334.       while(_loc1_ < hex.length)
  335.       {
  336.          _loc3_.push(parseInt(hex.substr(_loc1_,2),16));
  337.          _loc1_ += 2;
  338.       }
  339.       return _loc3_;
  340.    }
  341.    function charsToHex(chars)
  342.    {
  343.       var _loc4_ = new String("");
  344.       var _loc3_ = new Array("0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f");
  345.       var _loc1_ = 0;
  346.       while(_loc1_ < chars.length)
  347.       {
  348.          _loc4_ += _loc3_[chars[_loc1_] >> 4] + _loc3_[chars[_loc1_] & 15];
  349.          _loc1_ = _loc1_ + 1;
  350.       }
  351.       return _loc4_;
  352.    }
  353.    function charsToStr(chars)
  354.    {
  355.       var _loc3_ = new String("");
  356.       var _loc1_ = 0;
  357.       while(_loc1_ < chars.length)
  358.       {
  359.          _loc3_ += String.fromCharCode(chars[_loc1_]);
  360.          _loc1_ = _loc1_ + 1;
  361.       }
  362.       return _loc3_;
  363.    }
  364.    function strToChars(str)
  365.    {
  366.       var _loc3_ = new Array();
  367.       var _loc1_ = 0;
  368.       while(_loc1_ < str.length)
  369.       {
  370.          _loc3_.push(str.charCodeAt(_loc1_));
  371.          _loc1_ = _loc1_ + 1;
  372.       }
  373.       return _loc3_;
  374.    }
  375. }
  376.