📄 mdencrypt.cpp

📁 使用VC编写的一个MD5算法的程序其中内嵌使用了asm
💻 CPP
字号:
// MDEncrypt.cpp: implementation of the CMDEncrypt class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MD5.h"
#include "MDEncrypt.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMDEncrypt::CMDEncrypt():m_nModCnt(448)
{
  m_pData = NULL;
  m_nOrigSize = m_nSize = 0;
}

CMDEncrypt::CMDEncrypt(BYTE argData[], int argSize):m_nModCnt(448)
{
  m_pData = new BYTE[argSize];
  if (NULL == m_pData)
    return;
  m_nOrigSize = m_nSize = argSize;
  memcpy(m_pData, argData, m_nSize * sizeof(BYTE));
}
CMDEncrypt::~CMDEncrypt()
{
  if (m_nSize > 0)
    delete []m_pData;
}

//////////////////////////////////////////////////////////////////////
//功能描述: 获得数据输入
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::GetInput(BYTE argData[], int argSize)
{
  if (m_nSize > 0)
    delete []m_pData;
  m_pData = new BYTE[argSize];
  if (NULL == m_pData)
    return;
  m_nOrigSize = m_nSize = argSize;
  memcpy(m_pData, argData, m_nSize * sizeof(BYTE));
}

//////////////////////////////////////////////////////////////////////
//功能描述: 完成报文填充
//////////////////////////////////////////////////////////////////////
int CMDEncrypt::Padding()
{
  int nOrigSize = m_nSize * sizeof(BYTE) * 8 ;
  int nModCnt = nOrigSize % 512;
  int nFillCnt = 0;
  int nNewSize = 0;
  //此处理系统448宜用常量代
  if (m_nModCnt == nModCnt)
  {
    nFillCnt = 512;
  }
  else
  {
    nFillCnt = m_nModCnt - nModCnt; 
  }
  nNewSize = nFillCnt / 8;
  //扩充至k*512 + 448位
  Expand(m_pData, nNewSize + m_nSize);
  //扩充64位的长度位
  ExpandLenSpace(m_pData);
  return 0;
}

//////////////////////////////////////////////////////////////////////
//功能描述: 扩充至k*512 + 448位
//@arg: LPBYTE argData
//@arg: int argNewSize
//@return : void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::Expand(LPBYTE argData, int argNewSize)
{
  int nRemainBytes = argNewSize - m_nSize;
  BYTE * pData = new BYTE[argNewSize];
  memcpy(pData, m_pData, sizeof(BYTE) * m_nSize);
  delete []m_pData;
  m_pData = pData;
  pData = m_pData + m_nSize;
  pData[0] = 0x80;
  for (int i = 1; i < nRemainBytes; i++)
  {
    pData[i] = 0x00;
  }
  m_nSize = argNewSize;
}

//////////////////////////////////////////////////////////////////////
//功能描述: 扩充64位的长度位(8个BYTE)
//          并在这64位中填入报文的原始长度
//@arg: LPBYTE argData
//return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::ExpandLenSpace(LPBYTE argData)
{
  int nNewSize = m_nSize + 8;
  
  BYTE * pData = new BYTE[nNewSize];
  if (NULL == pData)
    return;
  memcpy(pData, m_pData, sizeof(BYTE) * m_nSize);
  delete []m_pData;
  m_pData= pData;
  pData = m_pData + m_nSize;
  for (int i = 0; i < 8; i++)
    pData[i] = 0x00;
  //填入原始报文长度, 
  (*(int*)pData) = m_nOrigSize;
  m_nSize = nNewSize;
}

//////////////////////////////////////////////////////////////////////
//功能描述: 初始化MD5缓冲器
//@return: int 
//////////////////////////////////////////////////////////////////////
int CMDEncrypt::InitMDBuffer()
{
  LPBYTE * pByte = NULL;
  BYTE initData[4][4] = { {0x01, 0x23, 0x45, 0x67}, 
                          {0x89, 0xab, 0xcd, 0xef},
                          {0xfe, 0xdc, 0xba, 0x98},
                          {0x76, 0x54, 0x32, 0x10}
                        }  ;
  memcpy(&m_pBuffer[BUFFER_A], initData[0], sizeof(BYTE) * 4);
  memcpy(&m_pBuffer[BUFFER_B], initData[1], sizeof(BYTE) * 4);
  memcpy(&m_pBuffer[BUFFER_C], initData[2], sizeof(BYTE) * 4);
  memcpy(&m_pBuffer[BUFFER_D], initData[3], sizeof(BYTE) * 4);
  return 0;
}

//////////////////////////////////////////////////////////////////////
//功能描述: 处理报文分组
//@return: int 
//////////////////////////////////////////////////////////////////////
int CMDEncrypt::HandleData()
{
  //为了简便起见,规定每步处理中都是对B, C, D这三个寄存器进行逻辑操作
  //B,C, D逻辑操作后的结果与A相加,然后再加上第K个32位的分组
  //并加上一个常数(1..64),然后调用自定义函数,循环左移s个bits,
  //上面运算完后的结果再与A相加,相加的结果放入B中,将原来的B的值放入
  //C中, 原来的C的值放入D中, 原来的D的值放入A中,如果就算完成了一步操作,
  //每一次做16步这样的操作,一共做4次,就构成了对一组512位的数据的MD5算法的主流程
  int nGroupCnt = (m_nSize * 8)/ 512;
  int i = 0, j = 0, k = 0;
  int nPos = 0;
  LPBYTE pData = NULL;
  BYTE temp1[4], temp2[4], temp3[4];
  //temp4[4];
  TRACE("before encryption:\n");
  for (i = 0; i < 16; i++)
  {
    TRACE("0x%x ", m_pBuffer[i]);
  }
  TRACE("\n");
  //外循环是以报文分组数为计数器的单位的
  for (i = 0; i < nGroupCnt; i++)
  {
    pData = &m_pData[i * 512];
    //调用逻辑函数F完成16步运算操作,
    for (j = 0; j < 16; j++)
    {
      FunctionF(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), temp1);
      Add(temp1, &pData[j * 32], temp2, 4);
      //加Ti的操作暂时忽略
      Add(&(m_pBuffer[BUFFER_A]), temp2, temp3, 4);
      ROL(temp3, 2, 4);
      memcpy(&(m_pBuffer[BUFFER_D]), &(m_pBuffer[BUFFER_A]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), sizeof(BYTE) * 4);
      Add(temp3, &(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_B]), 4);
      //TRACE("Step %d, Loop %d:", i, j);
      //for (k = 0; k < 16; k++)
      //{
      //  TRACE("0x%x ", m_pBuffer[k]);
      //}
      //TRACE("\n");
    }
    //调用逻辑函数G完成16步运算操作
    for (j = 0; j < 16; j++)
    {
      FunctionG(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), temp1);
      //计算要使用的X[]的位置
      nPos = (j * 5 + 1) % 16;
      Add(temp1, &pData[nPos * 32], temp2, 4);
      //加Ti的操作暂时忽略
      Add(&(m_pBuffer[BUFFER_A]), temp2, temp3, 4);
      ROL(temp3, 2, 4);
      memcpy(&(m_pBuffer[BUFFER_D]), &(m_pBuffer[BUFFER_A]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), sizeof(BYTE) * 4);
      Add(temp3, &(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_B]), 4);
      //TRACE("Step %d, Loop %d:", i, j);
      //for (k = 0; k < 16; k++)
      //{
      //  TRACE("0x%x ", m_pBuffer[k]);
      //}
      //TRACE("\n");
    }
    //调用逻辑函数H完成16步运算操作
    for (j = 0; j < 16; j++)
    {
      FunctionH(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), temp1);
      nPos = (j * 3 + 5) % 16;
      Add(temp1, &pData[nPos * 32], temp2, 4);
      //加Ti的操作暂时忽略
      Add(&(m_pBuffer[BUFFER_A]), temp2, temp3, 4);
      ROL(temp3, 2, 4);
      memcpy(&(m_pBuffer[BUFFER_D]), &(m_pBuffer[BUFFER_A]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), sizeof(BYTE) * 4);
      Add(temp3, &(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_B]), 4);
      //TRACE("Step %d, Loop %d:", i, j);
      //for (k = 0; k < 16; k++)
      //{
      //  TRACE("0x%x ", m_pBuffer[k]);
      //}
      //TRACE("\n");
    }
    //调用逻辑函数I完成16步运算操作
    for (j = 0; j < 16; j++)
    {
      FunctionI(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), temp1);
      nPos = (7 * i) % 16;
      Add(temp1, &pData[nPos * 32], temp2, 4);
      //加Ti的操作暂时忽略
      Add(&(m_pBuffer[BUFFER_A]), temp2, temp3, 4);
      ROL(temp3, 2, 4);
      memcpy(&(m_pBuffer[BUFFER_D]), &(m_pBuffer[BUFFER_A]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_C]), &(m_pBuffer[BUFFER_D]), sizeof(BYTE) * 4);
      memcpy(&(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_C]), sizeof(BYTE) * 4);
      Add(temp3, &(m_pBuffer[BUFFER_B]), &(m_pBuffer[BUFFER_B]), 4);
      //TRACE("Step %d, Loop %d:", i, j);
      //for (k = 0; k < 16; k++)
      //{
      //  TRACE("0x%x ", m_pBuffer[k]);
      //}
      //TRACE("\n");
    }
  }
  TRACE("after encryption:\n");
  for (k = 0; k < 16; k++)
  {
    TRACE("0x%x ", m_pBuffer[k]);
  }
  TRACE("\n");
  return 0;
}

//////////////////////////////////////////////////////////////////////
//功能描述: 逻辑函数F
//逻辑功能描述: ( B^C )|( (~B)^d )
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argSrc3
//@arg: LPBYTE argDst
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::FunctionF(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argSrc3, LPBYTE argDst)
{
  BYTE temp[4];
  And(argSrc1, argSrc2, argDst, 4);
  Not(argSrc1, temp, 4);
  And(temp, argSrc3, temp, 4);
  Or(argDst, temp, argDst, 4);

}

//自定义实现的逻辑操作

//////////////////////////////////////////////////////////////////////
//功能描述: 与操作
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argDst
//@arg: int argSize
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::And(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argDst, int argSize)
{
  for(int i = 0; i < argSize; i++)
  {
    argDst[i] = argSrc1[i] & argSrc2[i];
  }
}

//////////////////////////////////////////////////////////////////////
//功能描述: 非操作
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argDst
//@arg: int argSize
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::Not(LPBYTE argSrc1, LPBYTE argDst, int argSize)
{
  for (int i = 0; i < argSize; i++)
  {
    argDst[i] = ~argSrc1[i];
  }
}

//////////////////////////////////////////////////////////////////////
//功能描述: 异或操作
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argDst
//@arg: int argSize
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::XOR(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argDst, int argSize)
{
  //因为用c直接实现xor操作还需要自己编写一个函数,索性直接嵌入asm了
  for (int i = 0; i < argSize; i++)
  {
    _asm
    {
      pushad
      mov edi, DWORD ptr argSrc1
      mov eax, DWORD ptr [edi]
      mov esi, DWORD ptr argSrc2
      mov ebx, DWORD ptr [esi]
      xor eax, ebx
      mov edi, DWORD ptr  argDst
      mov DWORD ptr [edi], eax
      popad
    }
  }
}

//////////////////////////////////////////////////////////////////////
//功能描述: 或操作
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argDst
//@arg: int argSize
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::Or(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argDst, int argSize)
{
  for (int i = 0; i < argSize; i++)
  {
    argDst[i] = argSrc1[i] | argSrc2[2];
  }
}

//自定义的算术操作

//////////////////////////////////////////////////////////////////////
//功能描述: 二进制加操作
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argDst
//@arg: int argSize (字节数)
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::Add(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argDst, int argSize)
{
  _asm
  {
    pushad
    mov edi, DWORD ptr argSrc1
    mov eax, DWORD ptr [edi]
    mov edi, DWORD ptr argSrc2
    add eax, DWORD ptr [edi]
    mov edi, DWORD ptr argDst
    mov DWORD ptr [edi], eax
    popad
  }
  
}

//////////////////////////////////////////////////////////////////////
//功能描述: 循环左移操作
//@arg:LPBYTE argSrc
//@arg:int argTimes
//@arg:int argSize (字节数)
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::ROL(LPBYTE argSrc, int argTimes, int argSize)
{
  __asm
  {
    pushad
    mov edi, DWORD ptr argSrc
    mov eax, DWORD ptr [edi]
    mov ecx, argSize
    rol eax, cl
    mov DWORD ptr [edi], eax
    popad
  }
}

//////////////////////////////////////////////////////////////////////
//功能描述: 逻辑函数G
//逻辑功能描述: ( B^D )|( C^(~D) )
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argSrc3
//@arg: LPBYTE argDst
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::FunctionG(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argSrc3, LPBYTE argDst)
{
  BYTE temp1[4], temp2[4], temp3[4];
  And(argSrc1, argSrc3, temp1, 4);
  Not(argSrc3, temp2, 4);
  And(argSrc2, temp2, temp3, 4);
  Or(temp1, temp3, argDst, 4);
}

//////////////////////////////////////////////////////////////////////
//功能描述: 逻辑函数H
//逻辑功能描述: B xor C xor D
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argSrc3
//@arg: LPBYTE argDst
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::FunctionH(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argSrc3, LPBYTE argDst)
{
  BYTE temp1[4];
  XOR(argSrc1, argSrc2, temp1, 4);
  XOR(temp1, argSrc3, argDst, 4);
}

//////////////////////////////////////////////////////////////////////
//功能描述: 逻辑函数I
//逻辑功能描述: C xor (B | (~D))
//@arg: LPBYTE argSrc1
//@arg: LPBYTE argSrc2
//@arg: LPBYTE argSrc3
//@arg: LPBYTE argDst
//@return: void
//////////////////////////////////////////////////////////////////////
void CMDEncrypt::FunctionI(LPBYTE argSrc1, LPBYTE argSrc2, LPBYTE argSrc3, LPBYTE argDst)
{
  BYTE temp1[4], temp2[4];
  Not(argSrc3, temp1, 4);
  Or(argSrc1, temp1, temp2, 4);
  XOR(argSrc2, temp2, argDst, 4);
}

//////////////////////////////////////////////////////////////////////
//功能描述: 获得加密后的结果数据的指针
//@return: LPBYTE
//////////////////////////////////////////////////////////////////////
LPBYTE CMDEncrypt::GetResult()
{
  return m_pBuffer;
}
💿 文件大小 127 K
👤 上传用户 cando99
📂 所属分类加密解密
🏷️ 相关标签

#MD5 #asm #编写 #算法
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -