程序博客网 > 看港澳台网络机顶盒

c++实现aes加密算法，对字符串进行加密

来源：互联网 发布：看港澳台网络机顶盒 编辑：程序博客网 时间：2024/06/05 20:28
其主要功能进行实现unsigned char类型数据到char类型转化，将unsigned char结果与16进制字符串串之间的转化。代码如下：

 #ifndef AES_H

  1. #define AES_H

  3. #include <string.h>

  5. class AES
  6. {
  7. public:
  8.   AES(unsigned char* key);
  9.   virtual ~AES();
  10.   unsigned char* Cipher(unsigned char* input);
  11.   unsigned char* InvCipher(unsigned char* input);
  12.   void* Cipher(void* input,int length=0);
  13.   void* InvCipher(void* input,int length);

  15.   void Cipher(char *input, char *output);
  16.   void InvCipher(char *inut, char *output);

  18. private:
  19.   unsigned char Sbox[256];
  20.   unsigned char InvSbox[256];
  21.   unsigned char w[11][4][4];

  23.   void KeyExpansion(unsigned char* key, unsigned char w[][4][4]);
  24.   unsigned char FFmul(unsigned char a, unsigned char b);

  26.   void SubBytes(unsigned char state[][4]);
  27.   void ShiftRows(unsigned char state[][4]);
  28.   void MixColumns(unsigned char state[][4]);
  29.   void AddRoundKey(unsigned char state[][4], unsigned char k[][4]);

  31.   void InvSubBytes(unsigned char state[][4]);
  32.   void InvShiftRows(unsigned char state[][4]);
  33.   void InvMixColumns(unsigned char state[][4]);

  35.   int strToHex(const char*ch, char *hex);
  36.   int hexToStr(const char*hex, char*ch);
  37.   int ascillToValue(const char ch);
  38.   char valueToHexCh(constint value);
  39.   int getUCharLen(const unsigned char*uch);
  40.   int strToUChar(const char*ch, unsigned char*uch);
  41.   int ucharToStr(const unsigned char*uch, char *ch);
  42.   int ucharToHex(const unsigned char*uch, char *hex);
  43.   int hexToUChar(const char*hex, unsigned char*uch);
  44. };

  46. #endif // AES_H
对应的cpp文件如下：
  1. #include "aes.h"

  3. AES::AES(unsigned char* key)
  4. {
  5.   unsigned char sBox[]=
  6.   { /*  0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f*/
  7.     0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,/*0*/
  8.     0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,/*1*/
  9.     0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,/*2*/
  10.     0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,/*3*/
  11.     0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,/*4*/
  12.     0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,/*5*/
  13.     0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,/*6*/
  14.     0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,/*7*/
  15.     0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,/*8*/
  16.     0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,/*9*/
  17.     0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,/*a*/
  18.     0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,/*b*/
  19.     0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,/*c*/
  20.     0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,/*d*/
  21.     0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,/*e*/
  22.     0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16 /*f*/
  23.   };
  24.   unsigned char invsBox[256]=
  25.   { /* 0 1 2 3 4 5 6 7 8 9 a b c d e f*/
  26.     0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb,/*0*/
  27.     0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb,/*1*/
  28.     0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e,/*2*/
  29.     0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25,/*3*/
  30.     0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92,/*4*/
  31.     0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84,/*5*/
  32.     0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06,/*6*/
  33.     0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b,/*7*/
  34.     0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73,/*8*/
  35.     0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e,/*9*/
  36.     0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b,/*a*/
  37.     0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4,/*b*/
  38.     0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f,/*c*/
  39.     0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef,/*d*/
  40.     0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61,/*e*/
  41.     0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d /*f*/
  42.   };
  43.   memcpy(Sbox, sBox, 256);
  44.   memcpy(InvSbox, invsBox, 256);
  45.   KeyExpansion(key, w);
  46. }

  48. AES::~AES()
  49. {

  51. }

  53. void AES::Cipher(char*input, char *output)
  54. {
  55.   unsigned char uch_input[1024];
  56.   strToUChar(input, uch_input);
  57.   Cipher(uch_input);
  58.   ucharToHex(uch_input,output);
  59. }

  61. void AES::InvCipher(char*input, char *output)
  62. {
  63.   unsigned char uch_input[1024];
  64.   hexToUChar(input, uch_input);
  65.   InvCipher(uch_input);
  66.   ucharToStr(uch_input, output);
  67. }

  69. unsigned char* AES::Cipher(unsigned char* input)
  70. {
  71.   unsigned char state[4][4];
  72.   int i,r,c;

  74.   for(r=0; r<4; r++)
  75.   {
  76.     for(c=0; c<4;c++)
  77.     {
  78.       state[r][c]= input[c*4+r];
  79.     }
  80.   }

  82.   AddRoundKey(state,w[0]);

  84.   for(i=1; i<=10; i++)
  85.   {
  86.     SubBytes(state);
  87.     ShiftRows(state);
  88.     if(i!=10)MixColumns(state);
  89.     AddRoundKey(state,w[i]);
  90.   }

  92.   for(r=0; r<4; r++)
  93.   {
  94.     for(c=0; c<4;c++)
  95.     {
  96.       input[c*4+r]= state[r][c];
  97.     }
  98.   }

  100.   return input;
  101. }

  103. unsigned char* AES::InvCipher(unsigned char* input)
  104. {
  105.   unsigned char state[4][4];
  106.   int i,r,c;

  108.   for(r=0; r<4; r++)
  109.   {
  110.     for(c=0; c<4;c++)
  111.     {
  112.       state[r][c]= input[c*4+r];
  113.     }
  114.   }

  116.   AddRoundKey(state, w[10]);
  117.   for(i=9; i>=0; i--)
  118.   {
  119.     InvShiftRows(state);
  120.     InvSubBytes(state);
  121.     AddRoundKey(state, w[i]);
  122.     if(i)
  123.     {
  124.       InvMixColumns(state);
  125.     }
  126.   }

  128.   for(r=0; r<4; r++)
  129.   {
  130.     for(c=0; c<4;c++)
  131.     {
  132.       input[c*4+r]= state[r][c];
  133.     }
  134.   }

  136.   return input;
  137. }

  139. void* AES::Cipher(void* input,int length)
  140. {
  141.   unsigned char* in= (unsigned char*) input;
  142.   int i;
  143.   if(!length)
  144.   {
  145.     while(*(in+length++));
  146.     in = (unsigned char*) input;
  147.   }
  148.   for(i=0; i<length; i+=16)
  149.   {
  150.     Cipher(in+i);
  151.   }
  152.   return input;
  153. }

  155. void* AES::InvCipher(void* input,int length)
  156. {
  157.   unsigned char* in= (unsigned char*) input;
  158.   int i;
  159.   for(i=0; i<length; i+=16)
  160.   {
  161.     InvCipher(in+i);
  162.   }
  163.   return input;
  164. }

  166. void AES::KeyExpansion(unsigned char* key, unsigned char w[][4][4])
  167. {
  168.   int i,j,r,c;
  169.   unsigned char rc[]= {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36};
  170.   for(r=0; r<4; r++)
  171.   {
  172.     for(c=0; c<4; c++)
  173.     {
  174.       w[0][r][c]= key[r+c*4];
  175.     }
  176.   }
  177.   for(i=1; i<=10; i++)
  178.   {
  179.     for(j=0; j<4; j++)
  180.     {
  181.       unsigned char t[4];
  182.       for(r=0; r<4; r++)
  183.       {
  184.         t[r]= j ? w[i][r][j-1]: w[i-1][r][3];
  185.       }
  186.       if(j == 0)
  187.       {
  188.         unsigned char temp = t[0];
  189.         for(r=0; r<3; r++)
  190.         {
  191.           t[r]= Sbox[t[(r+1)%4]];
  192.         }
  193.         t[3]= Sbox[temp];
  194.         t[0] ^= rc[i-1];
  195.       }
  196.       for(r=0; r<4; r++)
  197.       {
  198.         w[i][r][j]= w[i-1][r][j] ^ t[r];
  199.       }
  200.     }
  201.   }
  202. }

  204. unsigned char AES::FFmul(unsigned char a, unsigned char b)
  205. {
  206.   unsigned char bw[4];
  207.   unsigned char res=0;
  208.   int i;
  209.   bw[0] = b;
  210.   for(i=1; i<4; i++)
  211.   {
  212.     bw[i] = bw[i-1]<<1;
  213.     if(bw[i-1]&0x80)
  214.     {
  215.       bw[i]^=0x1b;
  216.     }
  217.   }
  218.   for(i=0; i<4; i++)
  219.   {
  220.     if((a>>i)&0x01)
  221.     {
  222.       res ^= bw[i];
  223.     }
  224.   }
  225.   return res;
  226. }

  228. void AES::SubBytes(unsigned char state[][4])
  229. {
  230.   int r,c;
  231.   for(r=0; r<4; r++)
  232.   {
  233.     for(c=0; c<4; c++)
  234.     {
  235.       state[r][c]= Sbox[state[r][c]];
  236.     }
  237.   }
  238. }

  240. void AES::ShiftRows(unsigned char state[][4])
  241. {
  242.   unsigned char t[4];
  243.   int r,c;
  244.   for(r=1; r<4; r++)
  245.   {
  246.     for(c=0; c<4; c++)
  247.     {
  248.       t[c] = state[r][(c+r)%4];
  249.     }
  250.     for(c=0; c<4; c++)
  251.     {
  252.       state[r][c]= t[c];
  253.     }
  254.   }
  255. }

  257. void AES::MixColumns(unsigned char state[][4])
  258. {
  259.   unsigned char t[4];
  260.   int r,c;
  261.   for(c=0; c< 4; c++)
  262.   {
  263.     for(r=0; r<4; r++)
  264.     {
  265.       t[r] = state[r][c];
  266.     }
  267.     for(r=0; r<4; r++)
  268.     {
  269.       state[r][c]= FFmul(0x02, t[r])
  270.             ^ FFmul(0x03, t[(r+1)%4])
  271.             ^ FFmul(0x01, t[(r+2)%4])
  272.             ^ FFmul(0x01, t[(r+3)%4]);
  273.     }
  274.   }
  275. }

  277. void AES::AddRoundKey(unsigned char state[][4], unsigned char k[][4])
  278. {
  279.   int r,c;
  280.   for(c=0; c<4; c++)
  281.   {
  282.     for(r=0; r<4; r++)
  283.     {
  284.       state[r][c] ^= k[r][c];
  285.     }
  286.   }
  287. }

  289. void AES::InvSubBytes(unsigned char state[][4])
  290. {
  291.   int r,c;
  292.   for(r=0; r<4; r++)
  293.   {
  294.     for(c=0; c<4; c++)
  295.     {
  296.       state[r][c]= InvSbox[state[r][c]];
  297.     }
  298.   }
  299. }

  301. void AES::InvShiftRows(unsigned char state[][4])
  302. {
  303.   unsigned char t[4];
  304.   int r,c;
  305.   for(r=1; r<4; r++)
  306.   {
  307.     for(c=0; c<4; c++)
  308.     {
  309.       t[c] = state[r][(c-r+4)%4];
  310.     }
  311.     for(c=0; c<4; c++)
  312.     {
  313.       state[r][c]= t[c];
  314.     }
  315.   }
  316. }

  318. void AES::InvMixColumns(unsigned char state[][4])
  319. {
  320.   unsigned char t[4];
  321.   int r,c;
  322.   for(c=0; c< 4; c++)
  323.   {
  324.     for(r=0; r<4; r++)
  325.     {
  326.       t[r] = state[r][c];
  327.     }
  328.     for(r=0; r<4; r++)
  329.     {
  330.       state[r][c]= FFmul(0x0e, t[r])
  331.             ^ FFmul(0x0b, t[(r+1)%4])
  332.             ^ FFmul(0x0d, t[(r+2)%4])
  333.             ^ FFmul(0x09, t[(r+3)%4]);
  334.     }
  335.   }
  336. }

  338. int AES::getUCharLen(const unsigned char*uch)
  339. {
  340.   int len = 0;
  341.   while(*uch++)
  342.     ++len;

  344.   return len;
  345. }

  347. int AES::ucharToHex(const unsigned char*uch, char *hex)
  348. {
  349.   int high,low;
  350.   int tmp = 0;
  351.   if(uch == NULL || hex == NULL){
  352.     return -1;
  353.   }

  355.   if(getUCharLen(uch)== 0){
  356.     return -2;
  357.   }

  359.   while(*uch){
  360.     tmp = (int)*uch;
  361.     high = tmp >> 4;
  362.     low = tmp & 15;
  363.     *hex++= valueToHexCh(high);//先写高字节
  364.     *hex++= valueToHexCh(low);//其次写低字节
  365.     uch++;
  366.   }
  367.   *hex = '\0';
  368.   return 0;
  369. }

  371. int AES::hexToUChar(const char*hex, unsigned char*uch)
  372. {
  373.   int high,low;
  374.   int tmp = 0;
  375.   if(hex== NULL || uch== NULL){
  376.     return -1;
  377.   }

  379.   if(strlen(hex)%2 == 1){
  380.     return -2;
  381.   }

  383.   while(*hex){
  384.     high = ascillToValue(*hex);
  385.     if(high< 0){
  386.       *uch ='\0';
  387.       return -3;
  388.     }
  389.     hex++;//指针移动到下一个字符上
  390.     low = ascillToValue(*hex);
  391.     if(low < 0){
  392.       *uch ='\0';
  393.       return -3;
  394.     }
  395.     tmp = (high<< 4)+ low;
  396.     *uch++= tmp;
  397.     hex++;
  398.   }
  399.   *uch = (int)'\0';
  400.   return 0;
  401. }

  403. int AES::strToUChar(const char*ch, unsigned char*uch)
  404. {
  405.   int tmp = 0;
  406.   if(ch == NULL || uch ==NULL)
  407.     return -1;
  408.   if(strlen(ch)== 0)
  409.     return -2;

  411.   while(*ch){
  412.     tmp = (int)*ch;
  413.     *uch++= tmp;
  414.     ch++;
  415.   }
  416.   *uch = (int)'\0';
  417.   return 0;
  418. }

  420. int AES::ucharToStr(const unsigned char*uch, char *ch)
  421. {
  422.   int tmp = 0;
  423.   if(uch == NULL || ch ==NULL)
  424.     return -1;

  426.   while(*uch){
  427.     tmp = (int)*uch;
  428.     *ch++= (char)tmp;
  429.     uch++;
  430.   }
  431.   *ch = '\0';

  433.   return 0;
  434. }

  436. int AES::strToHex(const char*ch, char *hex)
  437. {
  438.   int high,low;
  439.   int tmp = 0;
  440.   if(ch == NULL || hex == NULL){
  441.     return -1;
  442.   }

  444.   if(strlen(ch)== 0){
  445.     return -2;
  446.   }

  448.   while(*ch){
  449.     tmp = (int)*ch;
  450.     high = tmp >> 4;
  451.     low = tmp & 15;
  452.     *hex++= valueToHexCh(high);//先写高字节
  453.     *hex++= valueToHexCh(low);//其次写低字节
  454.     ch++;
  455.   }
  456.   *hex = '\0';
  457.   return 0;
  458. }

  460. int AES::hexToStr(const char*hex, char*ch)
  461. {
  462.   int high,low;
  463.   int tmp = 0;
  464.   if(hex== NULL || ch== NULL){
  465.     return -1;
  466.   }

  468.   if(strlen(hex)%2 == 1){
  469.     return -2;
  470.   }

  472.   while(*hex){
  473.     high = ascillToValue(*hex);
  474.     if(high< 0){
  475.       *ch ='\0';
  476.       return -3;
  477.     }
  478.     hex++;//指针移动到下一个字符上
  479.     low = ascillToValue(*hex);
  480.     if(low < 0){
  481.       *ch ='\0';
  482.       return -3;
  483.     }
  484.     tmp = (high<< 4)+ low;
  485.     *ch++= (char)tmp;
  486.     hex++;
  487.   }
  488.   *ch = '\0';
  489.   return 0;
  490. }

  492. int AES::ascillToValue(const char ch){
  493.   int result = 0;
  494.   //获取16进制的高字节位数据
  495.   if(ch >= '0'&& ch <= '9'){
  496.     result = (int)(ch- '0');
  497.   }
  498.   else if(ch>= 'a' && ch<= 'z'){
  499.     result = (int)(ch- 'a')+ 10;
  500.   }
  501.   else if(ch>= 'A' && ch<= 'Z'){
  502.     result = (int)(ch- 'A')+ 10;
  503.   }
  504.   else{
  505.     result = -1;
  506.   }
  507.   return result;
  508. }

  510. char AES::valueToHexCh(constint value)
  511. {
  512.   char result = '\0';
  513.   if(value >= 0 && value<= 9){
  514.     result = (char)(value+ 48);//48为ascii编码的‘0’字符编码值
  515.   }
  516.   else if(value>= 10 && value <= 15){
  517.     result = (char)(value- 10 + 65);//减去10则找出其在16进制的偏移量，65为ascii的'A'的字符编码值
  518.   }
  519.   else{
  520.     ;
  521.   }

  523.   return result;
  524. }
     经过对代码的补充，这样我们在调用加密，解密时，就非常方便了，不用再考虑unsigned char类型字符串了。
直接使用char类型字符串，就好了。调用如下：

点击(此处)折叠或打开

  1. #include <QString>

  3. #include <stdio.h>
  4. #include "aes.h"

  6. int main(int argc, char*argv[])
  7. {
  8.     char mingwen[]= "http://www.baidu.com";
  9.     char miwen_hex[1024];
  10.     //char miwen_hex[]= "8FEEEFE524F8B68DC1FCA2899AC1A6B82E636F6D";
  11.     char result[1024];
  12.     unsigned char key[]= "xcysoft123";
  13.     AES aes(key);
  14.     aes.Cipher(mingwen, miwen_hex);
  15.     printf("%s\n",miwen_hex);
  16.     aes.InvCipher(miwen_hex, result);
  17.     printf("%s\n",result);
  18.     getchar();
  19.     return 0;
  20. }
0 0
看港澳台网络机顶盒 看港澳台网络机顶盒
原创粉丝点击
热门IT博客
mysql 四舍五入精确mysql 四舍五入精确
淘宝安热沙旗舰店淘宝安热沙旗舰店
it技能培训
php导出excel汉字乱码
货车运输价格算法
人人贷网络平台
托福 新东方 网络课程
剑桥商务英语 知乎
装修精美淘宝店
表层套管数据
嘉兴菜鸟网络
python 2.7.11.msi
欧文17总决赛数据
如何添加数据有效性
淘宝手机助手官网首页
mac怎么解压zip文件
网络借贷平台如何坑人
delay函数单片机
.name域名有毒么
知乎日报 mac
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 qq平板在线 怎么退订qq会员 qq乐园首页 qq美化大师 企业qq qq名字大全 qq名字男生 qq实名 qq群头衔 qq解绑手机 qq号注册申请 qqqlb 手机qq群发 qq网站首页 qq美化包 为什么qq安装不上 qq辅助器 qq群名字大全霸气 qq积分 q宠企鹅 qq个性名片 qq运动 qq密码怎么找回 如何绑定qq 网页qq登陆 qq怎样添加分组 qq举报 qq资料修改中心 怎样申请qq号 qq 申请 qq个人中心 qq发红包 qq动态表情 qq怎么群发消息 qq朋友圈 qq国际 手机申请qq qq被冻结 qq清理缓存 qq怎么下载不了 qq宠物企鹅手机版

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里