139 lines
3.1 KiB
C++
139 lines
3.1 KiB
C++
|
|
#include "Structure.h"
|
|
#include "Crypt.RndKey.h"
|
|
#include "CryptFileWriter.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
CryptFileWriter::~CryptFileWriter()
|
|
{
|
|
if( m_pChunk )
|
|
{
|
|
delete [] m_pChunk;
|
|
m_pChunk = NULL;
|
|
}
|
|
}
|
|
|
|
//BYTE __buffer[5000];
|
|
|
|
BOOL CryptFileWriter::Create( const CHAR* pFileName, const DWORD dwKey, const DWORD dwMaxCount )
|
|
{
|
|
if( !pFileName )
|
|
return FALSE;
|
|
|
|
OFSTRUCT pOF;
|
|
HANDLE hFILE = (HANDLE)(__int64)OpenFile( pFileName, &pOF, OF_WRITE|OF_CREATE );
|
|
|
|
return Create( hFILE, dwKey, dwMaxCount );
|
|
}
|
|
|
|
BOOL CryptFileWriter::Create( const HANDLE hFD, const DWORD dwKey, const DWORD dwMaxCount )
|
|
{
|
|
if( hFD == INVALID_HANDLE_VALUE )
|
|
return FALSE;
|
|
|
|
SetFD( hFD );
|
|
|
|
SetFilePointer( hFD, 0, NULL, FILE_BEGIN );
|
|
DWORD dwFixCount = 0;
|
|
if( !dwMaxCount )
|
|
{
|
|
DWORD dwFileSize = GetFileSize( GetFD(), NULL );
|
|
dwFixCount = (DWORD)(dwFileSize/TOKEN_SIZE);
|
|
DWORD dwRemain = (DWORD)(dwFileSize%TOKEN_SIZE);
|
|
if( dwRemain )
|
|
++dwFixCount;
|
|
}
|
|
else
|
|
dwFixCount = dwMaxCount;
|
|
|
|
m_dwKey = m_dwLKey = dwKey;
|
|
|
|
DWORD file_size = ( (DWORD)sizeof(CRYPT_FILE_TOKEN) ) * dwFixCount; //32B*count
|
|
file_size = BUF_ALIGN( file_size, MIN_FILE_DATA_SIZE );
|
|
file_size += sizeof(CRYPT_FILE_HEADER);
|
|
//DWORD size = (DWORD)(sizeof(CRYPT_FILE_CHUNK)/sizeof(DWORD));
|
|
|
|
//m_pChunk = (CRYPT_FILE_CHUNK_RENEW*)malloc(file_size);
|
|
m_pChunk = (CRYPT_FILE_CHUNK_RENEW*)new BYTE[file_size];
|
|
|
|
DWORD* pPtr = (DWORD*)m_pChunk;
|
|
|
|
DWORD divide_size = (DWORD) (file_size/sizeof(DWORD)) ;
|
|
for( DWORD i=1 ; i<=divide_size ; ++i )
|
|
{
|
|
m_dwLKey = RANDOMKEY::GetDBProxyKey(m_dwLKey);
|
|
*pPtr = m_dwLKey;
|
|
pPtr++;
|
|
}
|
|
|
|
m_pChunk->Header.byW = 'W';
|
|
m_pChunk->Header.byZ = 'z';
|
|
m_pChunk->Header.byC = 'C';
|
|
m_pChunk->Header.byF = 'F';
|
|
m_pChunk->Header.INFO.dwRndKey = m_dwKey^m_dwLKey;
|
|
//m_pChunk->Header.INFO.wJumpIndex = 0;
|
|
m_dwCount = 0;
|
|
m_dwMaxCount = dwFixCount;
|
|
m_dwSize = 0;
|
|
m_pLastINFO = &(m_pChunk->Header.INFO);
|
|
|
|
//..wSize;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//+Decrypt
|
|
INT CryptFileWriter::Read( BYTE* OUT pBuffer, const DWORD rLen )
|
|
{
|
|
// DWORD dwKey = m_pChunk->Header.dwRndKey^m_dwKey;
|
|
return 0;
|
|
}
|
|
|
|
//+Encrypt
|
|
INT CryptFileWriter::Write( BYTE* IN pBuffer, const DWORD wLen )
|
|
{
|
|
if( wLen > TOKEN_SIZE || !pBuffer )
|
|
return -1;
|
|
|
|
DWORD count = m_dwCount++;
|
|
|
|
//32B
|
|
CRYPT_FILE_TOKEN* pInfo = (CRYPT_FILE_TOKEN*)m_pChunk->KeyData;
|
|
pInfo = pInfo+count;
|
|
|
|
//pInfo->INFO.wJumpIndex = (WORD)m_dwCount;
|
|
DWORD dwRndKey = pInfo->INFO.dwRndKey = RANDOMKEY::GetDBProxyKey(m_dwLKey);
|
|
memcpy( pInfo->TOKEN, pBuffer, wLen );
|
|
|
|
DWORD size = (DWORD)(sizeof(CRYPT_FILE_TOKEN)/sizeof(DWORD));
|
|
DWORD* pdwInfo = (DWORD*)pInfo;
|
|
for( DWORD i=0 ; i<size ; ++i )
|
|
{
|
|
*pdwInfo ^= m_dwLKey;
|
|
pdwInfo++;
|
|
}
|
|
|
|
m_dwSize += (DWORD)wLen;
|
|
m_dwLKey = dwRndKey;
|
|
|
|
return 0;
|
|
}
|
|
|
|
BOOL CryptFileWriter::Save( BYTE* IN pBuffer, DWORD IN dwLen )
|
|
{
|
|
if( pBuffer )
|
|
{
|
|
CRYPT_FILE_HEADER* pHeader = (CRYPT_FILE_HEADER*)pBuffer;
|
|
pHeader->INFO.dwSize = m_dwSize;
|
|
|
|
DWORD file_size = ( (DWORD)sizeof(CRYPT_FILE_TOKEN) ) * m_dwMaxCount; //32B*count
|
|
file_size = BUF_ALIGN( file_size, MIN_FILE_DATA_SIZE );
|
|
file_size += sizeof(CRYPT_FILE_HEADER);
|
|
|
|
return CryptFile::Save( pBuffer, file_size );
|
|
}
|
|
return FALSE;
|
|
}
|
|
|