Home > Developer > PHP

Split the file and perform Base64 encoding/decoding

Source: Internet
Author: User
Tags bit set rounds
Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞
Split the file and perform Base64 encoding/decoding
Split the PHP file and perform Base64 encoding/decoding

  2. $ OrgFile = 'd: \ GdiPlus. dll ';
  3. $ CacheFileName = 'gdiplus. dll ';
  5. Function splitFile ($ fileName, $ block ){
  6. Global $ cacheFileName;
  7. If (! File_exists ($ fileName) return false;
  8. $ Num = 1;
  9. $ File = fopen ($ fileName, 'RB ');
  10. While ($ content = fread ($ file, $ block )){
  11. $ CacheFile = $ cacheFileName. '. part'. $ num ++;
  12. $ Cfile = fopen ($ cacheFile, 'wb ');
  13. Fwrite ($ cfile, base64_encode ($ content ));
  14. Fflush ($ cfile );
  15. Fclose ($ cfile );
  16. }
  17. Fclose ($ file );
  18. }
  20. Function mergeFile ($ targetFile ){
  21. Global $ cacheFileName;
  22. $ Num = 1;
  23. $ File = fopen ($ targetFile, 'WB ');
  24. While ($ num> 0 ){
  25. $ CacheFile = $ cacheFileName. '. part'. $ num ++;
  26. If (file_exists ($ cacheFile )){
  27. $ Cfile = fopen ($ cacheFile, 'RB ');
  28. $ Content = fread ($ cfile, filesize ($ cacheFile ));
  29. Fclose ($ cfile );
  30. Fwrite ($ file, base64_decode ($ content ));
  31. Fflush ($ file );
  32. } Else {
  33. $ Num =-1;
  34. }
  35. }
  36. Fclose ($ file );
  37. }
  39. SplitFile ($ orgFile, pow (2, 19 ));
  40. MergeFile ('gdiplus. dll ');
  42. ?>

  1. Class Aes {
  3. /**
  4. * AES Cipher function: encrypt 'input' with Rijndael algorithm
  5. *
  6. * @ Param input message as byte-array (16 bytes)
  7. * @ Param w key schedule as 2D byte-array (Nr + 1 x Nb bytes )-
  8. * Generated from the cipher key by keyExpansion ()
  9. * @ Return ciphertext as byte-array (16 bytes)
  10. */
  11. Public static function cipher ($ input, $ w ){
  12. // Main cipher function [§ 5. 1]
  13. $ Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
  14. $ Nr = count ($ w)/$ Nb-1; // no of rounds: 10/12/14 for 128/192/256-bit keys
  16. $ State = array (); // initialise 4xNb byte-array 'state' with input [§ 3. 4]
  17. For ($ I = 0; $ I <4 * $ Nb; $ I ++) $ state [$ I % 4] [floor ($ I/4)] = $ input [$ I];
  19. $ State = self: addRoundKey ($ state, $ w, 0, $ Nb );
  21. For ($ round = 1; $ round <$ Nr; $ round ++) {// apply Nr rounds
  22. $ State = self: subBytes ($ state, $ Nb );
  23. $ State = self: shiftRows ($ state, $ Nb );
  24. $ State = self: mixColumns ($ state, $ Nb );
  25. $ State = self: addRoundKey ($ state, $ w, $ round, $ Nb );
  26. }
  28. $ State = self: subBytes ($ state, $ Nb );
  29. $ State = self: shiftRows ($ state, $ Nb );
  30. $ State = self: addRoundKey ($ state, $ w, $ Nr, $ Nb );
  32. $ Output = array (4 * $ Nb); // convert state to 1-d array before returning [§ 3. 4]
  33. For ($ I = 0; $ I <4 * $ Nb; $ I ++) $ output [$ I] = $ state [$ I % 4] [floor ($ I/4)];
  34. Return $ output;
  35. }
  38. Private static function addRoundKey ($ state, $ w, $ rnd, $ Nb) {// xor Round Key into state S [§ 5. 1.4]
  39. For ($ r = 0; $ r <4; $ r ++ ){
  40. For ($ c = 0; $ c <$ Nb; $ c ++) $ state [$ r] [$ c] ^ = $ w [$ rnd * 4 + $ c] [$ r];
  41. }
  42. Return $ state;
  43. }
  45. Private static function subBytes ($ s, $ Nb) {// apply SBox to state S [§ 5. 1.1]
  46. For ($ r = 0; $ r <4; $ r ++ ){
  47. For ($ c = 0; $ c <$ Nb; $ c ++) $ s [$ r] [$ c] = self :: $ sBox [$ s [$ r] [$ c];
  48. }
  49. Return $ s;
  50. }
  52. Private static function shiftRows ($ s, $ Nb) {// shift row r of state S left by r bytes [§ 5. 1.2]
  53. $ T = array (4 );
  54. For ($ r = 1; $ r <4; $ r ++ ){
  55. For ($ c = 0; $ c <4; $ c ++) $ t [$ c] = $ s [$ r] [($ c + $ r) % $ Nb]; // shift into temp copy
  56. For ($ c = 0; $ c <4; $ c ++) $ s [$ r] [$ c] = $ t [$ c]; // and copy back
  57. } // Note that this will work for Nb = 4,5, 6, but not 7,8 (always 4 for AES ):
  58. Return $ s; // see fp.gladman.plus.com/cryptography_policy/rijndael/aes.spec.311.pdf
  59. }
  61. Private static function mixColumns ($ s, $ Nb) {// combine bytes of each col of state S [§ 5. 1.3]
  62. For ($ c = 0; $ c <4; $ c ++ ){
  63. $ A = array (4); // 'a' is a copy of the current column from S'
  64. $ B = array (4); // 'B' is? {02} in GF (2 ^ 8)
  65. For ($ I = 0; $ I <4; $ I ++ ){
  66. $ A [$ I] = $ s [$ I] [$ c];
  67. $ B [$ I] = $ s [$ I] [$ c] & 0x80? $ S [$ I] [$ c] <1 ^ 0x011b: $ s [$ I] [$ c] <1;
  68. }
  69. // A [n] ^ B [n] is? {03} in GF (2 ^ 8)
  70. $ S [0] [$ c] = $ B [0] ^ $ a [1] ^ $ B [1] ^ $ a [2] ^ $ a [3]; // 2 * a0 + 3 * a1 + a2 + a3
  71. $ S [1] [$ c] = $ a [0] ^ $ B [1] ^ $ a [2] ^ $ B [2] ^ $ a [3]; // a0 * 2 * a1 + 3 * a2 + a3
  72. $ S [2] [$ c] = $ a [0] ^ $ a [1] ^ $ B [2] ^ $ a [3] ^ $ B [3]; // a0 + a1 + 2 * a2 + 3 * a3
  73. $ S [3] [$ c] = $ a [0] ^ $ B [0] ^ $ a [1] ^ $ a [2] ^ $ B [3]; // 3 * a0 + a1 + a2 + 2 * a3
  74. }
  75. Return $ s;
  76. }
  78. /**
  79. * Key expansion for Rijndael cipher (): performs key expansion on cipher key
  80. * To generate a key schedule
  81. *
  82. * @ Param key cipher key byte-array (16 bytes)
  83. * @ Return key schedule as 2D byte-array (Nr + 1 x Nb bytes)
  84. */
  85. Public static function keyExpansion ($ key) {// generate Key Schedule from Cipher Key [§ 5. 2]
  86. $ Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
  87. $ Nk = count ($ key)/4; // key length (in words): 4/6/8 for 128/192/256-bit keys
  88. $ Nr = $ Nk + 6; // no of rounds: 10/12/14 for 128/192/256-bit keys
  90. $ W = array ();
  91. $ Temp = array ();
  93. For ($ I = 0; $ I <$ Nk; $ I ++ ){
  94. $ R = array ($ key [4 * $ I], $ key [4 * $ I + 1], $ key [4 * $ I + 2], $ key [4 * $ I + 3]);
  95. $ W [$ I] = $ r;
  96. }
  98. For ($ I = $ Nk; $ I <($ Nb * ($ Nr + 1); $ I ++ ){
  99. $ W [$ I] = array ();
  100. For ($ t = 0; $ t <4; $ t ++) $ temp [$ t] = $ w [$ i-1] [$ t];
  101. If ($ I % $ Nk = 0 ){
  102. $ Temp = self: subWord (self: rotWord ($ temp ));
  103. For ($ t = 0; $ t <4; $ t ++) $ temp [$ t] ^ = self :: $ rCon [$ I/$ Nk] [$ t];
  104. } Else if ($ Nk> 6 & $ I % $ Nk = 4 ){
  105. $ Temp = self: subWord ($ temp );
  106. }
  107. For ($ t = 0; $ t <4; $ t ++) $ w [$ I] [$ t] = $ w [$ I-$ Nk] [$ t] ^ $ temp [$ t];
  108. }
  109. Return $ w;
  110. }
  112. Private static function subWord ($ w) {// apply SBox to 4-byte word w
  113. For ($ I = 0; $ I <4; $ I ++) $ w [$ I] = self: $ sBox [$ w [$ I];
  114. Return $ w;
  115. }
  117. Private static function rotWord ($ w) {// rotate 4-byte word w left by one byte
  118. $ Tmp = $ w [0];
  119. For ($ I = 0; $ I <3; $ I ++) $ w [$ I] = $ w [$ I + 1];
  120. $ W [3] = $ tmp;
  121. Return $ w;
  122. }
  124. // SBox is pre-computed multiplicative inverse in GF (2 ^ 8) used in subBytes and keyExpansion [§ 5. 1.1]
  125. Private static $ sBox = array (
  126. 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30,0x01,0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  127. 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59,0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
  128. 0xb7, 0xfd, 0x93,0x26,0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31,0x15,
  129. 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96,0x05, 0x9a, 0x07,0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
  130. 0x09,0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
  131. 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
  132. 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33,0x85,0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
  133. 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21,0x10, 0xff, 0xf3, 0xd2,
  134. 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97,0x44,0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19,0x73,
  135. 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90,0x88,0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
  136. 0xe0, 0x32, 0x3a, 0x0a, 0x49,0x06,0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62,0x91,0x95, 0xe4, 0x79,
  137. 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
  138. 0xba, 0x78,0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
  139. 0x70, 0x3e, 0xb5, 0x66,0x48,0x03, 0xf6, 0x0e, 0x61,0x35,0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
  140. 0xe1, 0xf8, 0x98,0x11,0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55,0x28, 0xdf,
  141. 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42,0x68,0x41,0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 );
  143. // RCon is Round Constant used for the Key Expansion [1st col is 2 ^ (R-1) in GF (2 ^ 8)] [§ 5. 2]
  144. Private static $ rCon = array (
  145. Array (0x00, 0x00, 0x00, 0x00 ),
  146. Array (0x01, 0x00, 0x00, 0x00 ),
  147. Array (0x02, 0x00, 0x00, 0x00 ),
  148. Array (0x04, 0x00, 0x00, 0x00 ),
  149. Array (0x08, 0x00, 0x00, 0x00 ),
  150. Array (0x10, 0x00, 0x00, 0x00 ),
  151. Array (0x20, 0x00, 0x00, 0x00 ),
  152. Array (0x40, 0x00, 0x00, 0x00 ),
  153. Array (0x80, 0x00, 0x00, 0x00 ),
  154. Array (0x1b, 0x00, 0x00, 0x00 ),
  155. Array (0x36, 0x00, 0x00, 0x00 ));
  157. }
  159. /*-------------------------------------- ---------*/
  160. /* AES counter (CTR) mode implementation in PHP (c) Chris Veness 2005-2011. Right of free use is */
  161. /* Granted for all specified cial or non-specified cial use under CC-BY licence. No warranty of any */
  162. /* Form is offered .*/
  163. /*-------------------------------------- ---------*/
  165. Class AesCtr extends Aes {
  167. /**
  168. * Encrypt a text using AES encryption in Counter mode of operation
  169. *-See http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
  170. *
  171. * Unicode multi-byte character safe
  172. *
  173. * @ Param plaintext source text to be encrypted
  174. * @ Param password the password to use to generate a key
  175. * @ Param nBits number of bits to be used in the key (128,192, or 256)
  176. * @ Return encrypted text
  177. */
  178. Public static function encrypt ($ plaintext, $ password, $ nBits ){
  179. $ BlockSize = 16; // block size fixed at 16 bytes/128 bits (Nb = 4) for AES
  180. If (! ($ NBits = 128 | $ nBits = 192 | $ nBits = 256) return ''; // standard allows 128/192/256 bit keys
  181. // Note PHP (5) gives us plaintext and password in UTF8 encoding!
  183. // Use AES itself to encrypt password to get cipher key (using plain password as source
  184. // Key expansion)-gives us well encrypted key
  185. $ NBytes = $ nBits/8; // no bytes in key
  186. $ PwBytes = array ();
  187. For ($ I = 0; $ I <$ nBytes; $ I ++) $ pwBytes [$ I] = ord (substr ($ password, $ I, 1 )) & 0xff;
  188. $ Key = Aes: cipher ($ pwBytes, Aes: keyExpansion ($ pwBytes ));
  189. $ Key = array_merge ($ key, array_slice ($ key, 0, $ nBytes-16); // expand key to 16/24/32 bytes long
  191. // Initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A § B. 2): [0-1] = millisec,
  192. // [2-3] = random, [4-7] = seconds, giving guaranteed sub-ms uniqueness up to Feb 2106
  193. $ CounterBlock = array ();
  194. $ Nonce = floor (microtime (true) * 1000); // timestamp: milliseconds since 1-Jan-1970
  195. $ NonceMs = $ nonce % 1000;
  196. $ NonceSec = floor ($ nonce/1000 );
  197. $ NonceRnd = floor (rand (0, 0 xffff ));
  199. For ($ I = 0; $ I <2; $ I ++) $ counterBlock [$ I] = self: urs ($ nonceMs, $ I * 8) & 0xff;
  200. For ($ I = 0; $ I <2; $ I ++) $ counterBlock [$ I + 2] = self: urs ($ nonceRnd, $ I * 8) & 0xff;
  201. For ($ I = 0; $ I <4; $ I ++) $ counterBlock [$ I + 4] = self: urs ($ nonceSec, $ I * 8) & 0xff;
  203. // And convert it to a string to go on the front of the ciphertext
  204. $ CtrTxt = '';
  205. For ($ I = 0; $ I <8; $ I ++) $ ctrTxt. = chr ($ counterBlock [$ I]);
  207. // Generate key schedule-an expansion of the key into distinct Key Rounds for each round
  208. $ KeySchedule = Aes: keyExpansion ($ key );
  209. // Print_r ($ keySchedule );
  211. $ BlockCount = ceil (strlen ($ plaintext)/$ blockSize );
  212. $ Ciphertxt = array (); // ciphertext as array of strings
  214. For ($ B = 0; $ B <$ blockCount; $ B ++ ){
  215. // Set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  216. // Done in two stages for 32-bit ops: using two words allows us to go past 2 ^ 32 blocks (68 GB)
  217. For ($ c = 0; $ c <4; $ c ++) $ counterBlock [15-$ c] = self: urs ($ B, $ c * 8) & 0xff;
  218. For ($ c = 0; $ c <4; $ c ++) $ counterBlock [15-$ C-4] = self: urs ($ B/0x100000000, $ c * 8 );
  220. $ CipherCntr = Aes: cipher ($ counterBlock, $ keySchedule); // -- encrypt counter block --
  222. // Block size is already CED on final block
  223. $ BlockLength = $ B <$ blockCount-1? $ BlockSize: (strlen ($ plaintext)-1) % $ blockSize + 1;
  224. $ CipherByte = array ();
  226. For ($ I = 0; $ I <$ blockLength; $ I ++) {// -- xor plaintext with ciphered counter byte-by-byte --
  227. $ CipherByte [$ I] = $ cipherCntr [$ I] ^ ord (substr ($ plaintext, $ B * $ blockSize + $ I, 1 ));
  228. $ CipherByte [$ I] = chr ($ cipherByte [$ I]);
  229. }
  230. $ Ciphertxt [$ B] = implode ('', $ cipherByte); // escape troublesome characters in ciphertext
  231. }
  233. // Implode is more efficient than repeated string concatenation
  234. $ Ciphertext = $ ctrTxt. implode ('', $ ciphertxt );
  235. $ Ciphertext = base64_encode ($ ciphertext );
  236. Return $ ciphertext;
  237. }
  240. /**
  241. * Decrypt a text encrypted by AES in counter mode of operation
  242. *
  243. * @ Param ciphertext source text to be decrypted
  244. * @ Param password the password to use to generate a key
  245. * @ Param nBits number of bits to be used in the key (128,192, or 256)
  246. * @ Return decrypted text
  247. */
  248. Public static function decrypt ($ ciphertext, $ password, $ nBits ){
  249. $ BlockSize = 16; // block size fixed at 16 bytes/128 bits (Nb = 4) for AES
  250. If (! ($ NBits = 128 | $ nBits = 192 | $ nBits = 256) return ''; // standard allows 128/192/256 bit keys
  251. $ Ciphertext = base64_decode ($ ciphertext );
  253. // Use AES to encrypt password (encryption ing encrypt routine)
  254. $ NBytes = $ nBits/8; // no bytes in key
  255. $ PwBytes = array ();
  256. For ($ I = 0; $ I <$ nBytes; $ I ++) $ pwBytes [$ I] = ord (substr ($ password, $ I, 1 )) & 0xff;
  257. $ Key = Aes: cipher ($ pwBytes, Aes: keyExpansion ($ pwBytes ));
  258. $ Key = array_merge ($ key, array_slice ($ key, 0, $ nBytes-16); // expand key to 16/24/32 bytes long
  260. // Recover nonce from 1st element of ciphertext
  261. $ CounterBlock = array ();
  262. $ CtrTxt = substr ($ ciphertext, 0, 8 );
  263. For ($ I = 0; $ I <8; $ I ++) $ counterBlock [$ I] = ord (substr ($ ctrTxt, $ I, 1 ));
  265. // Generate key schedule
  266. $ KeySchedule = Aes: keyExpansion ($ key );
  268. // Separate ciphertext into blocks (skipping past initial 8 bytes)
  269. $ NBlocks = ceil (strlen ($ ciphertext)-8)/$ blockSize );
  270. $ Ct = array ();
  271. For ($ B = 0; $ B <$ nBlocks; $ B ++) $ ct [$ B] = substr ($ ciphertext, 8 + $ B * $ blockSize, 16 );
  272. $ Ciphertext = $ ct; // ciphertext is now array of block-length strings
  274. // Plaintext will get generated block-by-block into array of block-length strings
  275. $ Plaintxt = array ();
  277. For ($ B = 0; $ B <$ nBlocks; $ B ++ ){
  278. // Set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  279. For ($ c = 0; $ c <4; $ c ++) $ counterBlock [15-$ c] = self: urs ($ B, $ c * 8) & 0xff;
  280. For ($ c = 0; $ c <4; $ c ++) $ counterBlock [15-$ C-4] = self: urs ($ B + 1)/0x00000000-1, $ c * 8) & 0xff;
  282. $ CipherCntr = Aes: cipher ($ counterBlock, $ keySchedule); // encrypt counter block
  284. $ PlaintxtByte = array ();
  285. For ($ I = 0; $ I // -- Xor plaintext with ciphered counter byte-by-byte --
  286. $ PlaintxtByte [$ I] = $ cipherCntr [$ I] ^ ord (substr ($ ciphertext [$ B], $ I, 1 ));
  287. $ PlaintxtByte [$ I] = chr ($ plaintxtByte [$ I]);
  289. }
  290. $ Plaintxt [$ B] = implode ('', $ plaintxtByte );
  291. }
  293. // Join array of blocks into single plaintext string
  294. $ Plaintext = implode ('', $ plaintxt );
  296. Return $ plaintext;
  297. }
  300. /*
  301. * Unsigned right shift function, since PHP has neither >>> operator nor unsigned ints
  302. *
  303. * @ Param a number to be shifted (32-bit integer)
  304. * @ Param B number of bits to shift a to the right (0 .. 31)
  305. * @ Return a right-shifted and zero-filled by B bits
  306. */
  307. Private static function urs ($ a, $ B ){
  308. $ A & = 0 xffffffff; $ B & = 0x1f; // (bounds check)
  309. If ($ a & 0x80000000 & $ B> 0) {// if left-most bit set
  310. $ A = ($ a> 1) & 0x7fffffff; // right-shift one bit & clear left-most bit
  311. $ A = $ a >>( $ B-1); // remaining right-shifts
  312. } Else {// otherwise
  313. $ A = ($ a >>$ B); // use normal right-shift
  314. }
  315. Return $;
  316. }
  317. }
  319. $ CacheFileName = 'gdiplus. dll ';
  320. $ Pw = 'sdsafsa342sdfsafsa ';
  322. Function splitFile ($ fileName, $ block ){
  323. Global $ cacheFileName;
  324. If (! File_exists ($ fileName) return false;
  325. $ Num = 1;
  326. $ File = fopen ($ fileName, 'RB ');
  327. While ($ content = fread ($ file, $ block )){
  328. $ CacheFile = $ cacheFileName. '. part'. $ num ++;
  329. $ Cfile = fopen ($ cacheFile, 'wb ');
  330. Fwrite ($ cfile, base64_encode (AesCtr: encrypt ($ content, $ pw, 256 )));
  331. Fflush ($ cfile );
  332. Fclose ($ cfile );
  333. }
  334. Fclose ($ file );
  335. }
  337. Function mergeFile ($ targetFile ){
  338. Global $ cacheFileName;
  339. $ Num = 1;
  340. $ File = fopen ($ targetFile, 'WB ');
  341. While ($ num> 0 ){
  342. $ CacheFile = $ cacheFileName. '. part'. $ num ++;
  343. If (file_exists ($ cacheFile )){
  344. $ Cfile = fopen ($ cacheFile, 'RB ');
  345. $ Content = fread ($ cfile, filesize ($ cacheFile ));
  346. Fclose ($ cfile );
  347. Fwrite ($ file, base64_decode (AesCtr: decrypt ($ content, $ pw, 256 )));
  348. Fflush ($ file );
  349. } Else {
  350. $ Num =-1;
  351. }
  352. }
  353. Fclose ($ file );
  354. }
  356. SplitFile ('d: \ GdiPlus. dll ', pow (2,19 ));
  357. MergeFile ('gdiplus. dll ');
  359. ?>

This article is an English version of an article which is originally in the Chinese language on aliyun.com and is provided for information purposes only. This website makes no representation or warranty of any kind, either expressed or implied, as to the accuracy, completeness ownership or reliability of the article or any translations thereof. If you have any concerns or complaints relating to the article, please send an email, providing a detailed description of the concern or complaint, to info-contact@alibabacloud.com. A staff member will contact you within 5 working days. Once verified, infringing content will be removed immediately.

Related Keywords:
lz77 encoding and decoding example base64 encoding of username and password base64 encoding algorithm how base64 encoding works content encoding base64 what base64 encoding mime base64 encoding

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

What's Trending
Top 10 Tags
datastax versions naming convention zookeeper client class definition md5 microsoft sql server 2005 data structures exception handling error handling
Top 10 Keywords
microsoft download center down wordpress address url site address url wordpress address url windows installer 4 0 download 302 not found web address url definition site address url wordpress db2 integer mac os installation step by step pdf abbreviation for return

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

Get Started for Free

  • Sales Support

    1 on 1 presale consultation

    Chat Contact Sales

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

    Open a Ticket

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.

    Learn More