masyarakat Belajar Perpustakaan Alatan Masa lapang
cari
Melayu
Rumah > pembangunan bahagian belakang > tutorial php > teks badan

分割文件并进行Base64编解码

WBOY
Lepaskan： 2016-07-25 09:01:43
asal
1707 orang telah melayarinya
PHP分割文件并进行Base64编解码
  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
  18. $state = self::addRoundKey($state, $w, 0, $Nb);
  20. for ($round=1; $round $state = self::subBytes($state, $Nb);
  21. $state = self::shiftRows($state, $Nb);
  22. $state = self::mixColumns($state, $Nb);
  23. $state = self::addRoundKey($state, $w, $round, $Nb);
  24. }
  26. $state = self::subBytes($state, $Nb);
  27. $state = self::shiftRows($state, $Nb);
  28. $state = self::addRoundKey($state, $w, $Nr, $Nb);
  30. $output = array(4*$Nb); // convert state to 1-d array before returning [§3.4]
  31. for ($i=0; $i return $output;
  32. }
  35. private static function addRoundKey($state, $w, $rnd, $Nb) { // xor Round Key into state S [§5.1.4]
  36. for ($r=0; $r for ($c=0; $c }
  37. return $state;
  38. }
  40. private static function subBytes($s, $Nb) { // apply SBox to state S [§5.1.1]
  41. for ($r=0; $r for ($c=0; $c }
  42. return $s;
  43. }
  45. private static function shiftRows($s, $Nb) { // shift row r of state S left by r bytes [§5.1.2]
  46. $t = array(4);
  47. for ($r=1; $r for ($c=0; $c for ($c=0; $c } // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
  48. return $s; // see fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.311.pdf
  49. }
  51. private static function mixColumns($s, $Nb) { // combine bytes of each col of state S [§5.1.3]
  52. for ($c=0; $c $a = array(4); // 'a' is a copy of the current column from 's'
  53. $b = array(4); // 'b' is a?{02} in GF(2^8)
  54. for ($i=0; $i $a[$i] = $s[$i][$c];
  55. $b[$i] = $s[$i][$c]&0x80 ? $s[$i][$c] }
  56. // a[n] ^ b[n] is a?{03} in GF(2^8)
  57. $s[0][$c] = $b[0] ^ $a[1] ^ $b[1] ^ $a[2] ^ $a[3]; // 2*a0 + 3*a1 + a2 + a3
  58. $s[1][$c] = $a[0] ^ $b[1] ^ $a[2] ^ $b[2] ^ $a[3]; // a0 * 2*a1 + 3*a2 + a3
  59. $s[2][$c] = $a[0] ^ $a[1] ^ $b[2] ^ $a[3] ^ $b[3]; // a0 + a1 + 2*a2 + 3*a3
  60. $s[3][$c] = $a[0] ^ $b[0] ^ $a[1] ^ $a[2] ^ $b[3]; // 3*a0 + a1 + a2 + 2*a3
  61. }
  62. return $s;
  63. }
  65. /**
  66. * Key expansion for Rijndael cipher(): performs key expansion on cipher key
  67. * to generate a key schedule
  68. *
  69. * @param key cipher key byte-array (16 bytes)
  70. * @return key schedule as 2D byte-array (Nr+1 x Nb bytes)
  71. */
  72. public static function keyExpansion($key) { // generate Key Schedule from Cipher Key [§5.2]
  73. $Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
  74. $Nk = count($key)/4; // key length (in words): 4/6/8 for 128/192/256-bit keys
  75. $Nr = $Nk + 6; // no of rounds: 10/12/14 for 128/192/256-bit keys
  77. $w = array();
  78. $temp = array();
  80. for ($i=0; $i $r = array($key[4*$i], $key[4*$i+1], $key[4*$i+2], $key[4*$i+3]);
  81. $w[$i] = $r;
  82. }
  84. for ($i=$Nk; $i $w[$i] = array();
  85. for ($t=0; $t if ($i % $Nk == 0) {
  86. $temp = self::subWord(self::rotWord($temp));
  87. for ($t=0; $t } else if ($Nk > 6 && $i%$Nk == 4) {
  88. $temp = self::subWord($temp);
  89. }
  90. for ($t=0; $t }
  91. return $w;
  92. }
  94. private static function subWord($w) { // apply SBox to 4-byte word w
  95. for ($i=0; $i return $w;
  96. }
  98. private static function rotWord($w) { // rotate 4-byte word w left by one byte
  99. $tmp = $w[0];
  100. for ($i=0; $i $w[3] = $tmp;
  101. return $w;
  102. }
  104. // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1]
  105. private static $sBox = array(
  106. 0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
  107. 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
  108. 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
  109. 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
  110. 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
  111. 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
  112. 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
  113. 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
  114. 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
  115. 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
  116. 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
  117. 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
  118. 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
  119. 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
  120. 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
  121. 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16);
  123. // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
  124. private static $rCon = array(
  125. array(0x00, 0x00, 0x00, 0x00),
  126. array(0x01, 0x00, 0x00, 0x00),
  127. array(0x02, 0x00, 0x00, 0x00),
  128. array(0x04, 0x00, 0x00, 0x00),
  129. array(0x08, 0x00, 0x00, 0x00),
  130. array(0x10, 0x00, 0x00, 0x00),
  131. array(0x20, 0x00, 0x00, 0x00),
  132. array(0x40, 0x00, 0x00, 0x00),
  133. array(0x80, 0x00, 0x00, 0x00),
  134. array(0x1b, 0x00, 0x00, 0x00),
  135. array(0x36, 0x00, 0x00, 0x00) );
  137. }
  139. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  140. /* AES counter (CTR) mode implementation in PHP (c) Chris Veness 2005-2011. Right of free use is */
  141. /* granted for all commercial or non-commercial use under CC-BY licence. No warranty of any */
  142. /* form is offered. */
  143. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
  145. class AesCtr extends Aes {
  147. /**
  148. * Encrypt a text using AES encryption in Counter mode of operation
  149. * - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
  150. *
  151. * Unicode multi-byte character safe
  152. *
  153. * @param plaintext source text to be encrypted
  154. * @param password the password to use to generate a key
  155. * @param nBits number of bits to be used in the key (128, 192, or 256)
  156. * @return encrypted text
  157. */
  158. public static function encrypt($plaintext, $password, $nBits) {
  159. $blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  160. if (!($nBits==128 || $nBits==192 || $nBits==256)) return ''; // standard allows 128/192/256 bit keys
  161. // note PHP (5) gives us plaintext and password in UTF8 encoding!
  163. // use AES itself to encrypt password to get cipher key (using plain password as source for
  164. // key expansion) - gives us well encrypted key
  165. $nBytes = $nBits/8; // no bytes in key
  166. $pwBytes = array();
  167. for ($i=0; $i $key = Aes::cipher($pwBytes, Aes::keyExpansion($pwBytes));
  168. $key = array_merge($key, array_slice($key, 0, $nBytes-16)); // expand key to 16/24/32 bytes long
  170. // initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec,
  171. // [2-3] = random, [4-7] = seconds, giving guaranteed sub-ms uniqueness up to Feb 2106
  172. $counterBlock = array();
  173. $nonce = floor(microtime(true)*1000); // timestamp: milliseconds since 1-Jan-1970
  174. $nonceMs = $nonce%1000;
  175. $nonceSec = floor($nonce/1000);
  176. $nonceRnd = floor(rand(0, 0xffff));
  178. for ($i=0; $i for ($i=0; $i for ($i=0; $i
  179. // and convert it to a string to go on the front of the ciphertext
  180. $ctrTxt = '';
  181. for ($i=0; $i
  182. // generate key schedule - an expansion of the key into distinct Key Rounds for each round
  183. $keySchedule = Aes::keyExpansion($key);
  184. //print_r($keySchedule);
  186. $blockCount = ceil(strlen($plaintext)/$blockSize);
  187. $ciphertxt = array(); // ciphertext as array of strings
  189. for ($b=0; $b // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  190. // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
  191. for ($c=0; $c for ($c=0; $c
  192. $cipherCntr = Aes::cipher($counterBlock, $keySchedule); // -- encrypt counter block --
  194. // block size is reduced on final block
  195. $blockLength = $b $cipherByte = array();
  197. for ($i=0; $i $cipherByte[$i] = $cipherCntr[$i] ^ ord(substr($plaintext, $b*$blockSize+$i, 1));
  198. $cipherByte[$i] = chr($cipherByte[$i]);
  199. }
  200. $ciphertxt[$b] = implode('', $cipherByte); // escape troublesome characters in ciphertext
  201. }
  203. // implode is more efficient than repeated string concatenation
  204. $ciphertext = $ctrTxt . implode('', $ciphertxt);
  205. $ciphertext = base64_encode($ciphertext);
  206. return $ciphertext;
  207. }
  210. /**
  211. * Decrypt a text encrypted by AES in counter mode of operation
  212. *
  213. * @param ciphertext source text to be decrypted
  214. * @param password the password to use to generate a key
  215. * @param nBits number of bits to be used in the key (128, 192, or 256)
  216. * @return decrypted text
  217. */
  218. public static function decrypt($ciphertext, $password, $nBits) {
  219. $blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  220. if (!($nBits==128 || $nBits==192 || $nBits==256)) return ''; // standard allows 128/192/256 bit keys
  221. $ciphertext = base64_decode($ciphertext);
  223. // use AES to encrypt password (mirroring encrypt routine)
  224. $nBytes = $nBits/8; // no bytes in key
  225. $pwBytes = array();
  226. for ($i=0; $i $key = Aes::cipher($pwBytes, Aes::keyExpansion($pwBytes));
  227. $key = array_merge($key, array_slice($key, 0, $nBytes-16)); // expand key to 16/24/32 bytes long
  229. // recover nonce from 1st element of ciphertext
  230. $counterBlock = array();
  231. $ctrTxt = substr($ciphertext, 0, 8);
  232. for ($i=0; $i
  233. // generate key schedule
  234. $keySchedule = Aes::keyExpansion($key);
  236. // separate ciphertext into blocks (skipping past initial 8 bytes)
  237. $nBlocks = ceil((strlen($ciphertext)-8) / $blockSize);
  238. $ct = array();
  239. for ($b=0; $b $ciphertext = $ct; // ciphertext is now array of block-length strings
  241. // plaintext will get generated block-by-block into array of block-length strings
  242. $plaintxt = array();
  244. for ($b=0; $b // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  245. for ($c=0; $c for ($c=0; $c
  246. $cipherCntr = Aes::cipher($counterBlock, $keySchedule); // encrypt counter block
  248. $plaintxtByte = array();
  249. for ($i=0; $i // -- xor plaintext with ciphered counter byte-by-byte --
  250. $plaintxtByte[$i] = $cipherCntr[$i] ^ ord(substr($ciphertext[$b],$i,1));
  251. $plaintxtByte[$i] = chr($plaintxtByte[$i]);
  253. }
  254. $plaintxt[$b] = implode('', $plaintxtByte);
  255. }
  257. // join array of blocks into single plaintext string
  258. $plaintext = implode('',$plaintxt);
  260. return $plaintext;
  261. }
  264. /*
  265. * Unsigned right shift function, since PHP has neither >>> operator nor unsigned ints
  266. *
  267. * @param a number to be shifted (32-bit integer)
  268. * @param b number of bits to shift a to the right (0..31)
  269. * @return a right-shifted and zero-filled by b bits
  270. */
  271. private static function urs($a, $b) {
  272. $a &= 0xffffffff; $b &= 0x1f; // (bounds check)
  273. if ($a&0x80000000 && $b>0) { // if left-most bit set
  274. $a = ($a>>1) & 0x7fffffff; // right-shift one bit & clear left-most bit
  275. $a = $a >> ($b-1); // remaining right-shifts
  276. } else { // otherwise
  277. $a = ($a>>$b); // use normal right-shift
  278. }
  279. return $a;
  280. }
  281. }
  283. $cacheFileName = 'GdiPlus.dll';
  284. $pw='sdsafsa342sdfsafsa';
  286. function splitFile($fileName,$block) {
  287. global $cacheFileName;
  288. if (!file_exists($fileName)) return false;
  289. $num = 1;
  290. $file = fopen($fileName, 'rb');
  291. while ($content = fread($file,$block)) {
  292. $cacheFile = $cacheFileName . '.part' . $num++ ;
  293. $cfile = fopen($cacheFile, 'wb');
  294. fwrite($cfile, base64_encode(AesCtr::encrypt($content,$pw,256)));
  295. fflush($cfile);
  296. fclose($cfile);
  297. }
  298. fclose($file);
  299. }
  301. function mergeFile($targetFile) {
  302. global $cacheFileName;
  303. $num = 1;
  304. $file = fopen($targetFile, 'wb');
  305. while ($num > 0) {
  306. $cacheFile = $cacheFileName . '.part' . $num++;
  307. if (file_exists($cacheFile)) {
  308. $cfile = fopen($cacheFile, 'rb');
  309. $content = fread($cfile, filesize($cacheFile));
  310. fclose($cfile);
  311. fwrite($file, base64_decode(AesCtr::decrypt($content, $pw, 256)));
  312. fflush($file);
  313. } else {
  314. $num = -1;
  315. }
  316. }
  317. fclose($file);
  318. }
  320. splitFile('D:\GdiPlus.dll', pow(2,19));
  321. mergeFile('GdiPlus.dll');
  323. ?>
复制代码


Label berkaitan：
分割文件并进行Base64编解码
sumber：php.cn
Artikel sebelumnya：英雄联盟资料库 Artikel seterusnya：阿拉伯数字转化为中文汉字（大、小写）
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Artikel terbaru oleh pengarang
Isu terkini
Bandingkan Imagick, Adobe Photoshop dan Windows - Kesan resolusi (piksel per sentimeter atau piksel per inci) Ini bukan soalan tetapi percubaan untuk meningkatkan pemahaman saya tentang cara DPI disim...
daripada 2024-04-06 16:01:27
0
1
397
Adakah terdapat cara untuk memulihkan fail PHP saya? Saya menggunakan VisualStudioCode untuk pengekodan tetapi fail PHP saya kini rosak dan 70%...
daripada 2024-04-03 11:28:59
0
1
291
Topik-topik yang berkaitan
Lagi>
Cadangan popular
Tutorial Popular
Lagi>
Tutorial berkaitan
Cadangan popular
Kursus terkini
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan