MFC Base64和MD5的加密算法

其他 2020-02-24 10:48:42 阅读次数: 0

base64

Encode.h

pragma once
class CEncode
{
public:
    CEncode(void);
    ~CEncode(void);
    CString base64encode(CString src,int srclen) ;
};

Encode.cpp

include "StdAfx.h"
include "Encode.h"
CEncode::CEncode(void)
{
}


CEncode::~CEncode(void)
{
}
unsigned char * base64=(unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";  

CString CEncode::base64encode(CString src,int srclen)  
{  
     int n,buflen,i,j;  
     static unsigned char *dst;  
     CString buf=src;  
     buflen=n=srclen;  
     dst=(unsigned char*)malloc(buflen/3*4+3);  
     memset(dst,0,buflen/3*4+3);  
     for(i=0,j=0;i<=buflen-3;i+=3,j+=4) {  
         dst[j]=(buf[i]&0xFC)>>2;  
         dst[j+1]=((buf[i]&0x03)<<4) + ((buf[i+1]&0xF0)>>4);  
         dst[j+2]=((buf[i+1]&0x0F)<<2) + ((buf[i+2]&0xC0)>>6);  
         dst[j+3]=buf[i+2]&0x3F;  
     }  
     if(n%3==1) {  
          dst[j]=(buf[i]&0xFC)>>2;  
         dst[j+1]=((buf[i]&0x03)<<4);  
         dst[j+2]=64;  
         dst[j+3]=64;  
         j+=4;  
     }  
     else if(n%3==2) {  
         dst[j]=(buf[i]&0xFC)>>2;  
         dst[j+1]=((buf[i]&0x03)<<4)+((buf[i+1]&0xF0)>>4);  
         dst[j+2]=((buf[i+1]&0x0F)<<2);  
         dst[j+3]=64;  
         j+=4;  
     }  
     for(i=0;i<j;i++) /* map 6 bit value to base64 ASCII character */  
         dst[i]=base64[(int)dst[i]];  
     dst[j]=0;  
     return CString(dst);  
}

DM5

MD5Checksum.h

#if !defined(AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_)
#define AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_

#if _MSC_VER > 1000
#pragma once

#endif // _MSC_VER > 1000

class CMD5Checksum 
{
public:
 //interface functions for the RSA MD5 calculation
  CString GetMD5(BYTE* pBuf, UINT nLength);
  CString GetMD5(CFile& File);
 //static CString GetMD5(const CString& strFilePath);//对文件名加密
  CString GetMD5(const CString str);//对字符串加密


 //constructor/destructor
 CMD5Checksum();
 virtual ~CMD5Checksum() {};
protected:
 //RSA MD5 implementation
 void Transform(BYTE Block[64]);
 void Update(BYTE* Input, ULONG nInputLen);
 CString Final();
 inline DWORD RotateLeft(DWORD x, int n);
 inline void FF( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
 inline void GG( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
 inline void HH( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
 inline void II( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);

 //utility functions
 void DWordToByte(BYTE* Output, DWORD* Input, UINT nLength);
 void ByteToDWord(DWORD* Output, BYTE* Input, UINT nLength);

private:
 BYTE  m_lpszBuffer[64];  //input buffer
 ULONG m_nCount[2];   //number of bits, modulo 2^64 (lsb first)
 ULONG m_lMD5[4];   //MD5 checksum
};

#endif // !defined(AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_)

MD5ChecksumDefines.h

//MD5ChecksumDefines.h : MD5 Checksum constants

//Magic initialization constants
#define MD5_INIT_STATE_0 0x67452301
#define MD5_INIT_STATE_1 0xefcdab89
#define MD5_INIT_STATE_2 0x98badcfe
#define MD5_INIT_STATE_3 0x10325476

//Constants for Transform routine.
#define MD5_S11  7
#define MD5_S12 12
#define MD5_S13 17
#define MD5_S14 22
#define MD5_S21  5
#define MD5_S22  9
#define MD5_S23 14
#define MD5_S24 20
#define MD5_S31  4
#define MD5_S32 11
#define MD5_S33 16
#define MD5_S34 23
#define MD5_S41  6
#define MD5_S42 10
#define MD5_S43 15
#define MD5_S44 21

//Transformation Constants - Round 1
#define MD5_T01  0xd76aa478 //Transformation Constant 1
#define MD5_T02  0xe8c7b756 //Transformation Constant 2
#define MD5_T03  0x242070db //Transformation Constant 3
#define MD5_T04  0xc1bdceee //Transformation Constant 4
#define MD5_T05  0xf57c0faf //Transformation Constant 5
#define MD5_T06  0x4787c62a //Transformation Constant 6
#define MD5_T07  0xa8304613 //Transformation Constant 7
#define MD5_T08  0xfd469501 //Transformation Constant 8
#define MD5_T09  0x698098d8 //Transformation Constant 9
#define MD5_T10  0x8b44f7af //Transformation Constant 10
#define MD5_T11  0xffff5bb1 //Transformation Constant 11
#define MD5_T12  0x895cd7be //Transformation Constant 12
#define MD5_T13  0x6b901122 //Transformation Constant 13
#define MD5_T14  0xfd987193 //Transformation Constant 14
#define MD5_T15  0xa679438e //Transformation Constant 15
#define MD5_T16  0x49b40821 //Transformation Constant 16

//Transformation Constants - Round 2
#define MD5_T17  0xf61e2562 //Transformation Constant 17
#define MD5_T18  0xc040b340 //Transformation Constant 18
#define MD5_T19  0x265e5a51 //Transformation Constant 19
#define MD5_T20  0xe9b6c7aa //Transformation Constant 20
#define MD5_T21  0xd62f105d //Transformation Constant 21
#define MD5_T22  0x02441453 //Transformation Constant 22
#define MD5_T23  0xd8a1e681 //Transformation Constant 23
#define MD5_T24  0xe7d3fbc8 //Transformation Constant 24
#define MD5_T25  0x21e1cde6 //Transformation Constant 25
#define MD5_T26  0xc33707d6 //Transformation Constant 26
#define MD5_T27  0xf4d50d87 //Transformation Constant 27
#define MD5_T28  0x455a14ed //Transformation Constant 28
#define MD5_T29  0xa9e3e905 //Transformation Constant 29
#define MD5_T30  0xfcefa3f8 //Transformation Constant 30
#define MD5_T31  0x676f02d9 //Transformation Constant 31
#define MD5_T32  0x8d2a4c8a //Transformation Constant 32

//Transformation Constants - Round 3
#define MD5_T33  0xfffa3942 //Transformation Constant 33
#define MD5_T34  0x8771f681 //Transformation Constant 34
#define MD5_T35  0x6d9d6122 //Transformation Constant 35
#define MD5_T36  0xfde5380c //Transformation Constant 36
#define MD5_T37  0xa4beea44 //Transformation Constant 37
#define MD5_T38  0x4bdecfa9 //Transformation Constant 38
#define MD5_T39  0xf6bb4b60 //Transformation Constant 39
#define MD5_T40  0xbebfbc70 //Transformation Constant 40
#define MD5_T41  0x289b7ec6 //Transformation Constant 41
#define MD5_T42  0xeaa127fa //Transformation Constant 42
#define MD5_T43  0xd4ef3085 //Transformation Constant 43
#define MD5_T44  0x04881d05 //Transformation Constant 44
#define MD5_T45  0xd9d4d039 //Transformation Constant 45
#define MD5_T46  0xe6db99e5 //Transformation Constant 46
#define MD5_T47  0x1fa27cf8 //Transformation Constant 47
#define MD5_T48  0xc4ac5665 //Transformation Constant 48

//Transformation Constants - Round 4
#define MD5_T49  0xf4292244 //Transformation Constant 49
#define MD5_T50  0x432aff97 //Transformation Constant 50
#define MD5_T51  0xab9423a7 //Transformation Constant 51
#define MD5_T52  0xfc93a039 //Transformation Constant 52
#define MD5_T53  0x655b59c3 //Transformation Constant 53
#define MD5_T54  0x8f0ccc92 //Transformation Constant 54
#define MD5_T55  0xffeff47d //Transformation Constant 55
#define MD5_T56  0x85845dd1 //Transformation Constant 56
#define MD5_T57  0x6fa87e4f //Transformation Constant 57
#define MD5_T58  0xfe2ce6e0 //Transformation Constant 58
#define MD5_T59  0xa3014314 //Transformation Constant 59
#define MD5_T60  0x4e0811a1 //Transformation Constant 60
#define MD5_T61  0xf7537e82 //Transformation Constant 61
#define MD5_T62  0xbd3af235 //Transformation Constant 62
#define MD5_T63  0x2ad7d2bb //Transformation Constant 63
#define MD5_T64  0xeb86d391 //Transformation Constant 64


//Null data (except for first BYTE) used to finalise the checksum calculation
static unsigned char PADDING[64] = {
  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

MD5Checksum.CPP

#include "stdafx.h"
#include "MD5Checksum.h"
#include "MD5ChecksumDefines.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif




//CString CMD5Checksum::GetMD5(const CString& strFilePath)
//{
// //open the file as a binary file in readonly mode, denying write access
// CFile File(strFilePath, CFile::modeRead | CFile::shareDenyWrite | CFile::typeBinary);
//
// //the file has been successfully opened, so now get and return its checksum
// return GetMD5(File);
//}

CString CMD5Checksum::GetMD5(const CString str)
{
 try
 {
  CMD5Checksum MD5Checksum;  //checksum object 
  int nLength = 0;    //number of bytes read from the file
  const int nBufferSize = 1024; //checksum the file in blocks of 1024 bytes
  BYTE Buffer[nBufferSize];  //buffer for data read from the file

  //checksum the file in blocks of 1024 bytes
  if((nLength = str.GetLength()) > 0 )
  {
   MD5Checksum.Update( Buffer, nLength );
  }

  //finalise the checksum and return it
  return MD5Checksum.Final();
 }

 //report any file exceptions in debug mode only
 catch (CFileException* e )
 {
  TRACE0("CMD5Checksum::GetMD5: CFileException caught"); 
  throw e;
 }
}

CString CMD5Checksum::GetMD5(CFile& File)
{
 try
 {
  CMD5Checksum MD5Checksum;  //checksum object 
  int nLength = 0;    //number of bytes read from the file
  const int nBufferSize = 1024; //checksum the file in blocks of 1024 bytes
  BYTE Buffer[nBufferSize];  //buffer for data read from the file

  //checksum the file in blocks of 1024 bytes
  while ((nLength = File.Read( Buffer, nBufferSize )) > 0 )
  {
   MD5Checksum.Update( Buffer, nLength );
  }

  //finalise the checksum and return it
  return MD5Checksum.Final();
 }

 //report any file exceptions in debug mode only
 catch (CFileException* e )
 {
  TRACE0("CMD5Checksum::GetMD5: CFileException caught"); 
  throw e;
 }
}



CString CMD5Checksum::GetMD5(BYTE* pBuf, UINT nLength)
{
 //entry invariants
// IsValidAddress(pBuf,nLength,FALSE);

 //calculate and return the checksum
 CMD5Checksum MD5Checksum;
 MD5Checksum.Update( pBuf, nLength );
 return MD5Checksum.Final();
}



DWORD CMD5Checksum::RotateLeft(DWORD x, int n)
{
 //check that DWORD is 4 bytes long - true in Visual C++ 6 and 32 bit Windows
 // sizeof(x);

 //rotate and return x
 return (x << n) | (x >> (32-n));
}



void CMD5Checksum::FF( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
 DWORD F = (B & C) | (~B & D);
 A += F + X + T;
 A = RotateLeft(A, S);
 A += B;
}



void CMD5Checksum::GG( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
 DWORD G = (B & D) | (C & ~D);
 A += G + X + T;
 A = RotateLeft(A, S);
 A += B;
}



void CMD5Checksum::HH( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
 DWORD H = (B ^ C ^ D);
 A += H + X + T;
 A = RotateLeft(A, S);
 A += B;
}



void CMD5Checksum::II( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
 DWORD I = (C ^ (B | ~D));
 A += I + X + T;
 A = RotateLeft(A, S);
 A += B;
}



void CMD5Checksum::ByteToDWord(DWORD* Output, BYTE* Input, UINT nLength)
{
 //entry invariants
 ASSERT( nLength % 4 == 0 );
 ASSERT( AfxIsValidAddress(Output, nLength/4, TRUE) );
 ASSERT( AfxIsValidAddress(Input, nLength, FALSE) );

 //initialisations
 UINT i=0; //index to Output array
 UINT j=0; //index to Input array

 //transfer the data by shifting and copying
 for ( ; j < nLength; i++, j += 4)
 {
  Output[i] = (ULONG)Input[j]   |
     (ULONG)Input[j+1] << 8 |
     (ULONG)Input[j+2] << 16 |
     (ULONG)Input[j+3] << 24;
 }
}


void CMD5Checksum::Transform(BYTE Block[64])
{
 //initialise local data with current checksum
 ULONG a = m_lMD5[0];
 ULONG b = m_lMD5[1];
 ULONG c = m_lMD5[2];
 ULONG d = m_lMD5[3];

 //copy BYTES from input 'Block' to an array of ULONGS 'X'
 ULONG X[16];
 ByteToDWord( X, Block, 64 );

 //Perform Round 1 of the transformation
 FF (a, b, c, d, X[ 0], MD5_S11, MD5_T01);
 FF (d, a, b, c, X[ 1], MD5_S12, MD5_T02);
 FF (c, d, a, b, X[ 2], MD5_S13, MD5_T03);
 FF (b, c, d, a, X[ 3], MD5_S14, MD5_T04);
 FF (a, b, c, d, X[ 4], MD5_S11, MD5_T05);
 FF (d, a, b, c, X[ 5], MD5_S12, MD5_T06);
 FF (c, d, a, b, X[ 6], MD5_S13, MD5_T07);
 FF (b, c, d, a, X[ 7], MD5_S14, MD5_T08);
 FF (a, b, c, d, X[ 8], MD5_S11, MD5_T09);
 FF (d, a, b, c, X[ 9], MD5_S12, MD5_T10);
 FF (c, d, a, b, X[10], MD5_S13, MD5_T11);
 FF (b, c, d, a, X[11], MD5_S14, MD5_T12);
 FF (a, b, c, d, X[12], MD5_S11, MD5_T13);
 FF (d, a, b, c, X[13], MD5_S12, MD5_T14);
 FF (c, d, a, b, X[14], MD5_S13, MD5_T15);
 FF (b, c, d, a, X[15], MD5_S14, MD5_T16);

 //Perform Round 2 of the transformation
 GG (a, b, c, d, X[ 1], MD5_S21, MD5_T17);
 GG (d, a, b, c, X[ 6], MD5_S22, MD5_T18);
 GG (c, d, a, b, X[11], MD5_S23, MD5_T19);
 GG (b, c, d, a, X[ 0], MD5_S24, MD5_T20);
 GG (a, b, c, d, X[ 5], MD5_S21, MD5_T21);
 GG (d, a, b, c, X[10], MD5_S22, MD5_T22);
 GG (c, d, a, b, X[15], MD5_S23, MD5_T23);
 GG (b, c, d, a, X[ 4], MD5_S24, MD5_T24);
 GG (a, b, c, d, X[ 9], MD5_S21, MD5_T25);
 GG (d, a, b, c, X[14], MD5_S22, MD5_T26);
 GG (c, d, a, b, X[ 3], MD5_S23, MD5_T27);
 GG (b, c, d, a, X[ 8], MD5_S24, MD5_T28);
 GG (a, b, c, d, X[13], MD5_S21, MD5_T29);
 GG (d, a, b, c, X[ 2], MD5_S22, MD5_T30);
 GG (c, d, a, b, X[ 7], MD5_S23, MD5_T31);
 GG (b, c, d, a, X[12], MD5_S24, MD5_T32);

 //Perform Round 3 of the transformation
 HH (a, b, c, d, X[ 5], MD5_S31, MD5_T33);
 HH (d, a, b, c, X[ 8], MD5_S32, MD5_T34);
 HH (c, d, a, b, X[11], MD5_S33, MD5_T35);
 HH (b, c, d, a, X[14], MD5_S34, MD5_T36);
 HH (a, b, c, d, X[ 1], MD5_S31, MD5_T37);
 HH (d, a, b, c, X[ 4], MD5_S32, MD5_T38);
 HH (c, d, a, b, X[ 7], MD5_S33, MD5_T39);
 HH (b, c, d, a, X[10], MD5_S34, MD5_T40);
 HH (a, b, c, d, X[13], MD5_S31, MD5_T41);
 HH (d, a, b, c, X[ 0], MD5_S32, MD5_T42);
 HH (c, d, a, b, X[ 3], MD5_S33, MD5_T43);
 HH (b, c, d, a, X[ 6], MD5_S34, MD5_T44);
 HH (a, b, c, d, X[ 9], MD5_S31, MD5_T45);
 HH (d, a, b, c, X[12], MD5_S32, MD5_T46);
 HH (c, d, a, b, X[15], MD5_S33, MD5_T47);
 HH (b, c, d, a, X[ 2], MD5_S34, MD5_T48);

 //Perform Round 4 of the transformation
 II (a, b, c, d, X[ 0], MD5_S41, MD5_T49);
 II (d, a, b, c, X[ 7], MD5_S42, MD5_T50);
 II (c, d, a, b, X[14], MD5_S43, MD5_T51);
 II (b, c, d, a, X[ 5], MD5_S44, MD5_T52);
 II (a, b, c, d, X[12], MD5_S41, MD5_T53);
 II (d, a, b, c, X[ 3], MD5_S42, MD5_T54);
 II (c, d, a, b, X[10], MD5_S43, MD5_T55);
 II (b, c, d, a, X[ 1], MD5_S44, MD5_T56);
 II (a, b, c, d, X[ 8], MD5_S41, MD5_T57);
 II (d, a, b, c, X[15], MD5_S42, MD5_T58);
 II (c, d, a, b, X[ 6], MD5_S43, MD5_T59);
 II (b, c, d, a, X[13], MD5_S44, MD5_T60);
 II (a, b, c, d, X[ 4], MD5_S41, MD5_T61);
 II (d, a, b, c, X[11], MD5_S42, MD5_T62);
 II (c, d, a, b, X[ 2], MD5_S43, MD5_T63);
 II (b, c, d, a, X[ 9], MD5_S44, MD5_T64);

 //add the transformed values to the current checksum
 m_lMD5[0] += a;
 m_lMD5[1] += b;
 m_lMD5[2] += c;
 m_lMD5[3] += d;
}



CMD5Checksum::CMD5Checksum()
{
 // zero members
 memset( m_lpszBuffer, 0, 64 );
 m_nCount[0] = m_nCount[1] = 0;

 // Load magic state initialization constants
 m_lMD5[0] = MD5_INIT_STATE_0;
 m_lMD5[1] = MD5_INIT_STATE_1;
 m_lMD5[2] = MD5_INIT_STATE_2;
 m_lMD5[3] = MD5_INIT_STATE_3;
}


void CMD5Checksum::DWordToByte(BYTE* Output, DWORD* Input, UINT nLength )
{
 //entry invariants
 ASSERT( nLength % 4 == 0 );
 ASSERT( AfxIsValidAddress(Output, nLength, TRUE) );
 ASSERT( AfxIsValidAddress(Input, nLength/4, FALSE) );

 //transfer the data by shifting and copying
 UINT i = 0;
 UINT j = 0;
 for ( ; j < nLength; i++, j += 4)
 {
  Output[j] =   (UCHAR)(Input[i] & 0xff);
  Output[j+1] = (UCHAR)((Input[i] >> 8) & 0xff);
  Output[j+2] = (UCHAR)((Input[i] >> 16) & 0xff);
  Output[j+3] = (UCHAR)((Input[i] >> 24) & 0xff);
 }
}



CString CMD5Checksum::Final()
{
 //Save number of bits
 BYTE Bits[8];
 DWordToByte( Bits, m_nCount, 8 );

 //Pad out to 56 mod 64.
 UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3f);
 UINT nPadLen = (nIndex < 56) ? (56 - nIndex) : (120 - nIndex);
 Update( PADDING, nPadLen );

 //Append length (before padding)
 Update( Bits, 8 );

 //Store final state in 'lpszMD5'
 const int nMD5Size = 16;
 unsigned char lpszMD5[ nMD5Size ];
 DWordToByte( lpszMD5, m_lMD5, nMD5Size );

 //Convert the hexadecimal checksum to a CString
 CString strMD5;
 for ( int i=0; i < nMD5Size; i++)
 {
  CString Str;
  if (lpszMD5[i] == 0) {
   Str = CString("00");
  }
  else if (lpszMD5[i] <= 15)  {
   Str.Format(_T("0%x"),lpszMD5[i]);
  }
  else {
   Str.Format(_T("%x"),lpszMD5[i]);
  }

  ASSERT( Str.GetLength() == 2 );
  strMD5 += Str;
 }
 ASSERT( strMD5.GetLength() == 32 );
 return strMD5;
}



void CMD5Checksum::Update( BYTE* Input, ULONG nInputLen )
{
 //Compute number of bytes mod 64
 UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3F);

 //Update number of bits
 if ( ( m_nCount[0] += nInputLen << 3 )  <  ( nInputLen << 3) )
 {
  m_nCount[1]++;
 }
 m_nCount[1] += (nInputLen >> 29);

 //Transform as many times as possible.
 UINT i=0;  
 UINT nPartLen = 64 - nIndex;
 if (nInputLen >= nPartLen)  
 {
  memcpy( &m_lpszBuffer[nIndex], Input, nPartLen );
  Transform( m_lpszBuffer );
  for (i = nPartLen; i + 63 < nInputLen; i += 64)
  {
   Transform( &Input[i] );
  }
  nIndex = 0;
 }
 else
 {
  i = 0;
 }
 // Buffer remaining input
 memcpy( &m_lpszBuffer[nIndex], &Input[i], nInputLen-i);
}
Mr_ZHOUZHOU
发布了6 篇原创文章 · 获赞 2 · 访问量 1万+
私信 关注

猜你喜欢

转载自blog.csdn.net/Mr_ZHOUZHOU/article/details/78836284
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022