// проверка проекта с чтением из flash
static BOOL validProjectALL(const BOOL flFlash)
{
BYTE CountFlash = 0;
// check error load flash
memset(&PROJ,0,sizeof(PROJ)); // чистим структуру проекта
memset(&crc_idp,0,sizeof(crc_idp));
if(flFlash)CountFlash = 1;
// read project
flash_rd(FLASH_PROGRAM,sizeof(TPROJECT)*CountFlash,(unsigned char*)&PROJ[CUR_DK], sizeof(PROJ[CUR_DK]));
// calcul crc32
const unsigned long crc=crc32_calc((unsigned char*)&PROJ[CUR_DK],sizeof(PROJ[CUR_DK])-sizeof(PROJ[CUR_DK].CRC32));
// read CRC32 programms
unsigned long crc_progs;
flash_rd(FLASH_PROGS,sizeof(TPROGRAMS)*(CUR_DK+1)-sizeof(crc_progs),(unsigned char*)&crc_progs,sizeof(crc_progs));
// check project
if(PROJ[CUR_DK].ProjectSize == sizeof(PROJ[CUR_DK])){
if(crc==PROJ[CUR_DK].CRC32){
if(crc_progs==PROJ[CUR_DK].CRC32_programs){
// сохранить параметры IDP
crc_idp.crc = PROJ[CUR_DK].IDP_CRC32;
return true;
}
}
}
return false;
}
//------------------------------------------------------------------------------
// fin_try==0 - последняя поппытка, можно и записать в журнал ерроры
BOOL ligh_load_init(int fin_try)
{
//
memset(&DK[CUR_DK],0,sizeof(DK[CUR_DK]));
// clear crc
memset(&crc_idp,0,sizeof(crc_idp));
// FLASH_PROGS
flash_rd(FLASH_PROGRAM, sizeof(TPROJECT)*CUR_DK,
(unsigned char*)&PROJ[CUR_DK], sizeof(PROJ[CUR_DK]));
unsigned long crc=crc32_calc((unsigned char*)&PROJ[CUR_DK] ,
sizeof(PROJ[CUR_DK]) - sizeof(PROJ[CUR_DK].CRC32));
//
unsigned long crc_progs;
flash_rd(FLASH_PROGS, sizeof(TPROGRAMS)*(CUR_DK+1)-sizeof(crc_progs) ,
(unsigned char*)&crc_progs, sizeof(crc_progs));
//
crc_idp.crc = crc_progs;// сохраним для передачи по UDP
//i_size = sizeof(PROJ[CUR_DK]);
if (PROJ[CUR_DK].ProjectSize ==sizeof(PROJ[CUR_DK]))
{
if ( crc == PROJ[CUR_DK].CRC32)
{
//
if (crc_progs==PROJ[CUR_DK].CRC32_programs)
{
Init_DK();
DK[CUR_DK].proj_valid=true;
DK[CUR_DK].work = true;
DK[CUR_DK].progs_valid = true;
return true;
}
else
{
dbg_printf("FAULT. CRC32 of progs invalid");
if (CUR_DK==0)
if (!fin_try)
Event_Push_Str("Некорр. программы (CRC)");
}
}
else
{
dbg_printf("FAULT. PROJ.CRC32");
if (CUR_DK==0)
if (!fin_try)
Event_Push_Str("Некорр. проект (CRC).");
}
}
else
{
if (CUR_DK==0)
if (!fin_try)
Event_Push_Str("Некорр. проект (размер).");
//
dbg_printf("FAULT. PROJ.ProjectSize ==sizeof(PROJ)");
}
return false;
}
BOOL
CNdasUnitDeviceCreator::ReadBACL(BLOCK_ACCESS_CONTROL_LIST** ppBACL, UINT32 BACLSize)
{
//
// ppBACL will be set only if this function succeed.
//
UINT32 ElementCount =
(BACLSize - (sizeof(BLOCK_ACCESS_CONTROL_LIST) - sizeof(BLOCK_ACCESS_CONTROL_LIST_ELEMENT))) /
sizeof(BLOCK_ACCESS_CONTROL_LIST_ELEMENT);
// allocate pBACL to fit sector align
PBLOCK_ACCESS_CONTROL_LIST pBACL = reinterpret_cast<PBLOCK_ACCESS_CONTROL_LIST>(
::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, 512 * BACL_SECTOR_SIZE(ElementCount)));
if (NULL == pBACL)
{
// Out of memory!
return FALSE;
}
BOOL fSuccess = m_devComm.ReadDiskBlock(
reinterpret_cast<PBYTE>(pBACL),
NDAS_BLOCK_LOCATION_BACL,
BACL_SECTOR_SIZE(ElementCount));
//
// Regardless of the existence,
// Disk Block should be read.
// Failure means communication error or disk error
//
if (!fSuccess)
{
::HeapFree(::GetProcessHeap(), 0, pBACL);
DBGPRT_ERR(_FT("ReadDiskBlock failed.\n"));
return FALSE;
}
//
// check structure
//
if (BACL_SIGNATURE != pBACL->Signature ||
BACL_VERSION < pBACL->Version ||
crc32_calc((unsigned char *)&pBACL->Elements[0],
sizeof(BLOCK_ACCESS_CONTROL_LIST_ELEMENT) * (pBACL->ElementCount)) !=
pBACL->crc)
{
::HeapFree(::GetProcessHeap(), 0, pBACL);
DBGPRT_ERR(_FT("Invalid BACL information on disk.\n"));
return FALSE;
}
*ppBACL = pBACL;
return TRUE;
}
// проверка проекта
// проверка CRC, размера
static BOOL validProjectRAM(void)
{
const unsigned long crc =crc32_calc((unsigned char*)&PROJ[CUR_DK],sizeof(PROJ[CUR_DK])-sizeof(PROJ[CUR_DK].CRC32));
if(PROJ[CUR_DK].ProjectSize == sizeof(PROJ[CUR_DK])){
if(crc==PROJ[CUR_DK].CRC32){
crc_idp.crc = PROJ[CUR_DK].IDP_CRC32; // IDP для передачи по сети.
return true;
}
}
return false;
}
uint32_t generic_crc32(target *t, uint32_t base, int len)
{
uint32_t crc = -1;
uint8_t byte;
while (len--) {
byte = target_mem_read8(t, base);
crc = crc32_calc(crc, byte);
base++;
}
return crc;
}
/* Create and add a node without copying name string.
* We don't check if the table is full, either.
*/
HashNode *hash_addnocopy(struct HashTable *h, char *name, void *data)
{
HashNode *n;
ulong key;
n = calloc(1, sizeof(HashNode));
if(!n) return NULL;
n->name = name;
n->data = data;
n->crc = crc32_calc(name, strlen(name));
h->count++;
key = n->crc % h->size;
if(h->buckets[key]) {
n->next = h->buckets[key];
}
h->buckets[key] = n;
return n;
}
NTSTATUS
LsuGetBlockACL(
IN PLANSCSI_SESSION LSS,
OUT PBLOCK_ACCESS_CONTROL_LIST BlockACL,
IN ULONG BlockACLLen,
IN UINT64 LogicalBlockAddress,
IN ULONG BlockBytes,
IN ULONG PduFlags
) {
NTSTATUS status;
ULONG readBlock;
PBYTE buffer;
ASSERT(BlockBytes);
ASSERT(BlockACLLen);
//
// allocate block buffer
//
readBlock = (BlockACLLen + BlockBytes) / BlockBytes;
buffer = (PBYTE)ExAllocatePoolWithTag(NonPagedPool, readBlock * BlockBytes, LSU_POOLTAG_BLOCKBUFFER);
if(buffer == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
status = LsuReadBlocks(LSS, buffer, LogicalBlockAddress, readBlock, BlockBytes, PduFlags);
if(!NT_SUCCESS(status)) {
ExFreePoolWithTag(buffer, LSU_POOLTAG_BLOCKBUFFER);
return status;
}
//
// Copy to the caller's buffer
//
RtlCopyMemory(BlockACL, buffer, BlockACLLen);
//
// Free the buffer
//
ExFreePoolWithTag(buffer, LSU_POOLTAG_BLOCKBUFFER);
//
// Revision check
//
if( BlockACL->Signature != BACL_SIGNATURE ||
BlockACL->Version != BACL_VERSION) {
status = STATUS_REVISION_MISMATCH;
KDPrintM(DBG_OTHER_ERROR,
("Error: Revision mismatch. Signature:0x%08lx, Version:%u\n",
BlockACL->Signature,
BlockACL->Version));
}
//
// CRC check.
//
if(NT_SUCCESS(status)) {
UINT32 crc;
crc = crc32_calc((PUCHAR)BlockACL->Elements,
BlockACL->ElementCount * sizeof(BLOCK_ACCESS_CONTROL_LIST_ELEMENT));
if(crc != BlockACL->crc) {
KDPrintM(DBG_OTHER_ERROR, ("BACL's crc is invalid.\n"));
return STATUS_REVISION_MISMATCH;
}
}
return status;
}
BOOL
CNdasUnitDeviceCreator::ConvertDIBv1toDIBv2(
CONST NDAS_DIB* pDIBv1,
NDAS_DIB_V2* pDIBv2,
UINT64 nDiskSectorCount)
{
XTLASSERT(!IsBadReadPtr(pDIBv1, sizeof(NDAS_DIB)));
XTLASSERT(!IsBadWritePtr(pDIBv2, sizeof(NDAS_DIB_V2)));
InitializeDIBv2(pDIBv2, nDiskSectorCount);
// fit to old system
pDIBv2->sizeUserSpace = nDiskSectorCount - pDIBv2->sizeXArea;
pDIBv2->iSectorsPerBit = 0; // no backup information
// single disk
if(IS_NDAS_DIBV1_WRONG_VERSION(*pDIBv1) || // no DIB information
NDAS_DIB_DISK_TYPE_SINGLE == pDIBv1->DiskType)
{
InitializeDIBv2AsSingle(pDIBv2);
}
else
{
// pair(2) disks (mirror, aggregation)
UNIT_DISK_LOCATION *pUnitDiskLocation0, *pUnitDiskLocation1;
if(NDAS_DIB_DISK_TYPE_MIRROR_MASTER == pDIBv1->DiskType ||
NDAS_DIB_DISK_TYPE_AGGREGATION_FIRST == pDIBv1->DiskType)
{
pUnitDiskLocation0 = &pDIBv2->UnitDisks[0];
pUnitDiskLocation1 = &pDIBv2->UnitDisks[1];
}
else
{
pUnitDiskLocation0 = &pDIBv2->UnitDisks[1];
pUnitDiskLocation1 = &pDIBv2->UnitDisks[0];
}
//
// EtherAddress Conversion
//
if(
0x00 == pDIBv1->EtherAddress[0] &&
0x00 == pDIBv1->EtherAddress[1] &&
0x00 == pDIBv1->EtherAddress[2] &&
0x00 == pDIBv1->EtherAddress[3] &&
0x00 == pDIBv1->EtherAddress[4] &&
0x00 == pDIBv1->EtherAddress[5])
{
// usually, there is no ether address information
C_ASSERT(
sizeof(pUnitDiskLocation0->MACAddr) ==
sizeof(m_pDevice->GetDeviceId().Node));
CopyMemory(
pUnitDiskLocation0->MACAddr,
m_pDevice->GetDeviceId().Node,
sizeof(pUnitDiskLocation0->MACAddr));
pUnitDiskLocation0->UnitNumber = static_cast<UCHAR>(m_dwUnitNo);
}
else
{
C_ASSERT(
sizeof(pUnitDiskLocation0->MACAddr) ==
sizeof(pDIBv1->EtherAddress));
CopyMemory(
pUnitDiskLocation0->MACAddr,
pDIBv1->EtherAddress,
sizeof(pUnitDiskLocation0->MACAddr));
pUnitDiskLocation0->UnitNumber = pDIBv1->UnitNumber;
}
//
// Peer Address Conversion
//
{
C_ASSERT(
sizeof(pUnitDiskLocation1->MACAddr) ==
sizeof(pDIBv1->PeerAddress));
CopyMemory(
pUnitDiskLocation1->MACAddr,
pDIBv1->PeerAddress,
sizeof(pUnitDiskLocation1->MACAddr));
pUnitDiskLocation1->UnitNumber = pDIBv1->UnitNumber;
}
pDIBv2->nDiskCount = 2;
pDIBv2->nSpareCount = 0;
switch(pDIBv1->DiskType)
{
case NDAS_DIB_DISK_TYPE_MIRROR_MASTER:
pDIBv2->iMediaType = NMT_MIRROR;
pDIBv2->iSequence = 0;
break;
case NDAS_DIB_DISK_TYPE_MIRROR_SLAVE:
pDIBv2->iMediaType = NMT_MIRROR;
pDIBv2->iSequence = 1;
break;
case NDAS_DIB_DISK_TYPE_AGGREGATION_FIRST:
pDIBv2->iMediaType = NMT_AGGREGATE;
pDIBv2->iSequence = 0;
break;
case NDAS_DIB_DISK_TYPE_AGGREGATION_SECOND:
pDIBv2->iMediaType = NMT_AGGREGATE;
pDIBv2->iSequence = 1;
break;
default:
return FALSE;
}
}
// write crc
pDIBv2->crc32 = crc32_calc(
(unsigned char *)pDIBv2,
sizeof(pDIBv2->bytes_248));
pDIBv2->crc32_unitdisks = crc32_calc(
(unsigned char *)pDIBv2->UnitDisks,
sizeof(pDIBv2->UnitDisks));
return TRUE;
}
BOOL
CNdasUnitDeviceCreator::ReadDIB(NDAS_DIB_V2** ppDIBv2)
{
//
// ppDIBv2 will be set only if this function succeed.
//
PNDAS_DIB_V2 pDIBv2 = reinterpret_cast<PNDAS_DIB_V2>(
HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 512));
if (NULL == pDIBv2)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"ReadDiskBlock failed, error=0x%X\n",
GetLastError());
return FALSE;
}
BOOL fSuccess = m_devComm.ReadDiskBlock(
reinterpret_cast<PBYTE>(pDIBv2),
NDAS_BLOCK_LOCATION_DIB_V2);
//
// Regardless of the existence,
// Disk Block should be read.
// Failure means communication error or disk error
//
if (!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"ReadDiskBlock failed, error=0x%X\n",
GetLastError());
XTLVERIFY( HeapFree(GetProcessHeap(), 0, pDIBv2) );
return FALSE;
}
//
// check signature
//
if(NDAS_DIB_V2_SIGNATURE != pDIBv2->Signature ||
pDIBv2->crc32 != crc32_calc((unsigned char *)pDIBv2,
sizeof(pDIBv2->bytes_248)) ||
pDIBv2->crc32_unitdisks != crc32_calc((unsigned char *)pDIBv2->UnitDisks,
sizeof(pDIBv2->UnitDisks)))
{
//
// Read DIBv1
//
fSuccess = ReadDIBv1AndConvert(pDIBv2);
if (!fSuccess)
{
XTLVERIFY( HeapFree(GetProcessHeap(), 0, pDIBv2) );
return FALSE;
}
if ( ! IsConsistentDIB(pDIBv2) )
{
// Inconsistent DIB will be reported as single
InitializeDIBv2AsSingle(pDIBv2);
}
*ppDIBv2 = pDIBv2;
return TRUE;
}
//
// check version
//
if(IS_HIGHER_VERSION_V2(*pDIBv2))
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"Unsupported version V2.\n");
XTLVERIFY( HeapFree(GetProcessHeap(), 0, pDIBv2) );
return FALSE;
}
//
// TODO: Lower version process (future code) ???
//
if(0)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"lower version V2 detected\n");
}
//
// read additional locations if needed
//
if (pDIBv2->nDiskCount + pDIBv2->nSpareCount > NDAS_MAX_UNITS_IN_V2)
{
UINT32 nTrailSectorCount =
GET_TRAIL_SECTOR_COUNT_V2(pDIBv2->nDiskCount + pDIBv2->nSpareCount);
SIZE_T dwBytes = sizeof(NDAS_DIB_V2) + 512 * nTrailSectorCount;
LPVOID ptr = HeapReAlloc(
GetProcessHeap(),
HEAP_ZERO_MEMORY,
pDIBv2,
dwBytes);
if (NULL == ptr)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"HeapReAlloc failed, bytes=%d\n", dwBytes);
// When HeapReAlloc fails, pDIBv2 should be freed
XTLVERIFY( HeapFree(GetProcessHeap(), 0, pDIBv2) );
return FALSE;
}
pDIBv2 = reinterpret_cast<PNDAS_DIB_V2>(ptr);
for(DWORD i = 0; i < nTrailSectorCount; i++) {
fSuccess = m_devComm.ReadDiskBlock(
reinterpret_cast<PBYTE>(pDIBv2) + sizeof(NDAS_DIB_V2) + 512 * i,
NDAS_BLOCK_LOCATION_ADD_BIND + i);
if(!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"Reading additional block failed, block=%d, error=0x%X\n",
NDAS_BLOCK_LOCATION_ADD_BIND + i, GetLastError());
XTLVERIFY( HeapFree(GetProcessHeap(), 0, pDIBv2) );
return FALSE;
}
}
}
// Virtual DVD check. Not supported ATM.
//
// DIB Consistency Check
//
if ( ! IsConsistentDIB(pDIBv2) )
{
// Inconsistent DIB will be reported as single
InitializeDIBv2AsSingle(pDIBv2);
}
*ppDIBv2 = pDIBv2;
return TRUE;
}
UINT
WINAPI
NdasEncImportSysKeyFromFile(LPCTSTR szFileName)
{
BYTE lpBuffer[1024] = {0}; // large enough to hold the entire data;
PNDAS_ENC_SYSKEY_FILE_HEADER lpFileHeader =
reinterpret_cast<PNDAS_ENC_SYSKEY_FILE_HEADER>(lpBuffer);
AutoFileHandle hFile = ::CreateFile(
szFileName,
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == (HANDLE) hFile) {
return ::GetLastError();
}
GUID FileGuid = {0};
DWORD cbRead = 0;
BOOL fSuccess = ::ReadFile(
hFile,
lpBuffer,
sizeof(lpBuffer),
&cbRead,
NULL);
if (!fSuccess) {
return ::GetLastError();
}
if (cbRead < sizeof(NDAS_ENC_SYSKEY_FILE_HEADER)) {
return NDASENC_ERROR_INVALID_SYSKEY_FILE;
}
if (0 != ::memcmp(
&lpFileHeader->FileGuid,
&NDAS_SYSKEY_FILE_GUID,
sizeof(NDAS_SYSKEY_FILE_GUID)))
{
return NDASENC_ERROR_INVALID_SYSKEY_FILE;
}
if (cbRead !=
lpFileHeader->KeyDataLength + sizeof(NDAS_ENC_SYSKEY_FILE_HEADER))
{
return NDASENC_ERROR_INVALID_SYSKEY_FILE;
}
lpFileHeader->KeyDecryptedDataCRC32;
lpFileHeader->KeyData;
//
// Encrypt the key (DES)
//
xcrypt::IEncryption* pDesEnc = xcrypt::CreateCryptAPIDESEncryption();
if (NULL == pDesEnc) {
return ERROR_OUTOFMEMORY;
}
fSuccess = pDesEnc->Initialize();
if (!fSuccess) {
return ::GetLastError();
}
fSuccess = pDesEnc->SetKey(
(CONST BYTE*) &NDAS_ENC_GUIDS[0],
sizeof(NDAS_ENC_GUIDS[0]));
if (!fSuccess) {
return ::GetLastError();
}
fSuccess = pDesEnc->Decrypt(
lpFileHeader->KeyData,
&lpFileHeader->KeyDataLength);
if (!fSuccess) {
return ::GetLastError();
}
//
// Check CRC
//
DWORD dataCRC32 = crc32_calc(
lpFileHeader->KeyData,
lpFileHeader->KeyDataLength);
if (dataCRC32 != lpFileHeader->KeyDecryptedDataCRC32) {
return NDASENC_ERROR_INVALID_SYSKEY_FILE;
}
#ifdef _DEBUG
_tprintf(_T("Importing System Key: %s\n"),
xs::CXSByteString(
lpFileHeader->KeyDataLength,
lpFileHeader->KeyData,
_T(' ')).ToString());
#endif
UINT uiResult = ::NdasEncSetSysKey(
lpFileHeader->KeyDataLength,
lpFileHeader->KeyData);
if (ERROR_SUCCESS != uiResult) {
return uiResult;
}
return ERROR_SUCCESS;
}
