bool FileVEILOperationsImpl::ValidateFileContents_PublicOnly(const tscrypto::tsCryptoString& sFile) { TSDECLARE_FUNCTIONExt(true); std::shared_ptr<ICryptoHelper> helper; std::shared_ptr<IDataReader> reader; std::shared_ptr<IDataIOBase> ioBase; std::shared_ptr<IKeyVEILSession> empty; if (!(helper = CreateCryptoHelper(empty))) { LogError("Unable to create the decryption processor."); return TSRETURN_ERROR(("Unable to create the decryption processor"), false); } helper->SetOperationStatusCallback(m_status); helper->SetTaskInformation(m_currentTask, m_taskCount); if (!!m_keyGenCallback) helper->SetKeyGenCallback(m_keyGenCallback); if (!(reader = std::dynamic_pointer_cast<IDataReader>(CreateFileReader(sFile)))) { LogError("Error occurred trying to open input file '%s'.", sFile.c_str()); return TSRETURN_ERROR(("Bad File"), false); } if (!helper->ValidateFileContents_PublicOnly(reader)) { LogError("ERROR: The file has been modified."); return TSRETURN_ERROR(("The file has been modified."), false); } return TSRETURN(("OK"), true); }
bool FileVEILOperationsImpl::RegenerateStreamKey(const tscrypto::tsCryptoString &sFilename, tscrypto::tsCryptoData& headerSignature, tscrypto::tsCryptoData& workingKey) { TSDECLARE_FUNCTIONExt(true); std::shared_ptr<IDataReader> reader; std::shared_ptr<ICmsHeaderBase> headerBase; std::shared_ptr<ICmsHeader> header7; std::shared_ptr<IDataIOBase> ioBase; if (!(reader = std::dynamic_pointer_cast<IDataReader>(CreateFileReader(sFilename)))) { LogError("Error occured trying to open input file '%s'.", sFilename.c_str()); return TSRETURN_ERROR(("Bad File"), false); } headerSignature.clear(); workingKey.clear(); if (!StreamStartsWithCmsHeader(reader, headerBase)) { return true; } if (!(header7 = std::dynamic_pointer_cast<ICmsHeader>(headerBase))) { return TSRETURN_ERROR(("Not a CKM7 header"), false); } if (!m_session && header7->NeedsSession()) { if (!!m_sessionCallback) { if (!(m_sessionCallback->GetSessionForHeader(false, headerBase, 0, m_session))) { LogError("No session."); reader->Close(); return TSRETURN_ERROR(("Returns ~~"), false); } } } if (!m_session) { LOG(DebugError, "Unable to regenerate the working key and encrypted data."); return TSRETURN_ERROR(("Unable to regenerate the working key and encrypted data."), false); } else { std::shared_ptr<ICkmOperations> ops = std::dynamic_pointer_cast<ICkmOperations>(header7); if (!ops || !ops->RegenerateWorkingKey(m_session, workingKey)) { LOG(DebugError, "Unable to regenerate the working key and encrypted data."); return TSRETURN_ERROR(("Unable to regenerate the working key and encrypted data."), false); } } headerSignature = header7->GetSignature(); return TSRETURN(("OK"), true); }
//------------------------------------------------------------------------ bool CFileReadSLK::LoadFromFile( const char* pFileName ) //------------------------------------------------------------------------ { assert( NULL == m_data ); assert( NULL == m_column ); //OutputDebugString(pFileName); //OutputDebugString("\n==================================\n"); IFileReader* fileReader = NULL; if( !CreateFileReader( &fileReader ) ) return false; bool isLoadOk = true; for( unsigned int i = 0; i < _TSLKValueArray.size(); i++ ) { _TSLKValue* p = _TSLKValueArray[i]; SAFE_DELETE( p ); } _TSLKValueArray.clear(); char* buffer = NULL; uInt32 bufferSize = 0; if(fileReader) { if( !(fileReader->OpenFile( pFileName )) ) { isLoadOk = false; goto OPEN_FILE_FAIL; } bufferSize = fileReader->GetSize(); assert( bufferSize > 0 ); buffer = new char[bufferSize+1]; memset( buffer, 0, (bufferSize + 1) * sizeof(char) ); char tmpBuffer[1024]; memset( tmpBuffer, 0, 1024 * sizeof(char) ); char* ptrBuffer = buffer; size_t size = fileReader->Read( (void*)tmpBuffer, 1024 ); assert( "出现异常错误!" && size <= 1024 ); size_t count = 0; while( size > 0 ) { memcpy( ptrBuffer, tmpBuffer, size ); ptrBuffer += size; count += size; memset( tmpBuffer, 0, 1024 * sizeof(char) ); size = fileReader->Read( tmpBuffer, 1024 ); assert( "出现异常错误!" && size <= 1024 ); } assert( "文件大小错误!" && bufferSize == count ); if( bufferSize != count ) isLoadOk = false; else if( !GetInfoFromMemory( buffer, bufferSize ) ) isLoadOk = false; SAFE_DELETE_ARRAY( buffer ); } OPEN_FILE_FAIL: if(fileReader) fileReader->Close(); SAFE_DELETE( fileReader ); for( unsigned int i = 0; i < _TSLKValueArray.size(); i++ ) { _TSLKValue* p = _TSLKValueArray[i]; SAFE_DELETE( p ); } _TSLKValueArray.clear(); return isLoadOk; }
bool FileVEILOperationsImpl::EncryptSignFile(const tscrypto::tsCryptoString &sFilename, const tscrypto::tsCryptoString &sEncryptedFilename, const tscrypto::tsCryptoString &lpszTempFile, std::shared_ptr<ICmsHeader> Header, CompressionType comp, TS_ALG_ID algorithm, TS_ALG_ID hashAlgorithm, bool SignHeader, bool bindData, CMSFileFormatIds DataFormat, bool randomIvec, SymmetricPaddingType paddingType, int blockSize) { TSDECLARE_FUNCTIONExt(true); std::shared_ptr<IDataReader> inputFile; std::shared_ptr<IDataWriter> outputFile; std::shared_ptr<IDataIOBase> ioBase; tscrypto::tsCryptoData buff; tscrypto::tsCryptoString sTempFile; if (lpszTempFile.size() > 0) { sTempFile = lpszTempFile; } else { sTempFile = sEncryptedFilename; sTempFile += ".tmp"; } LOG(DebugInfo3, "Encrypting file '" << sFilename << "'"); // // Now create the output file. // if (!(outputFile = std::dynamic_pointer_cast<IDataWriter>(CreateDataWriter(sTempFile.c_str())))) { LogError("Error occurred while creating temporary file '%s'.", sTempFile.c_str()); return TSRETURN_ERROR(("FAILED"), false); } if (!(inputFile = std::dynamic_pointer_cast<IDataReader>(CreateFileReader(sFilename.c_str())))) { outputFile->Close(); xp_DeleteFile(sTempFile); LogError("Error occurred trying to open input file '%s'.", sFilename.c_str()); return TSRETURN_ERROR(("Bad File"), false); } if (!EncryptSignStream(inputFile, outputFile, Header, comp, algorithm, hashAlgorithm, SignHeader, bindData, DataFormat, randomIvec, paddingType, blockSize)) { inputFile->Close(); outputFile->Close(); xp_DeleteFile(sTempFile); return TSRETURN_ERROR(("Returns ~~"), false); } inputFile->Close(); outputFile->Close(); if (lpszTempFile.size() == 0) { xp_DeleteFile(sEncryptedFilename); // Copy the temp file to the destination file // According to Jeffrey Richter, "...MoveFile() does not support // the moving/renaming of streams." // (http://www.microsoft.com/msj/1198/ntfs/ntfs.aspx) //if(!MoveFile(sTempFile, sEncryptedFilename)) if (!xp_RenameFile(sTempFile, sEncryptedFilename)) { tscrypto::tsCryptoString msg; switch (errno) { case EACCES: msg = "The destination file already exists"; break; case ENOENT: msg = "The source file does not exist"; break; case EINVAL: if ((xp_GetFileAttributes(sEncryptedFilename.c_str()) & XP_FILE_ATTRIBUTE_DIRECTORY) != 0) msg = "There is a directory called " + sEncryptedFilename + " already."; else msg = "The file name contains invalid characters"; break; default: msg = "An unknown error has occurred while creating the encrypted file."; break; } // Process any inserts in lpMsgBuf. // ... // Check to see if this was a file permissions error DWORD dwAttributes = ::xp_GetFileAttributes(sEncryptedFilename.c_str()); if (dwAttributes & XP_FILE_ATTRIBUTE_READONLY) LogError("The specified output file cannot be accessed because it has Read Only permissions."); //else if(dwAttributes & FILE_ATTRIBUTE_SYSTEM) // SetErrorMessage("The specified output file cannot be accessed because it is used exclusively by the Operating System."); //else if(dwAttributes & FILE_ATTRIBUTE_HIDDEN) // SetErrorMessage("The specified output file cannot be accessed because it has the Hidden file attribute set."); else LogError(msg.c_str()); secureDeleteEntireFile(sTempFile.c_str(), 3); return TSRETURN_ERROR(("FAILED"), false); } xp_DeleteFile(sTempFile); //CKMUtility::secureDelete((CKMString)sTempFile); } return TSRETURN(("OK"), true); }
bool FileVEILOperationsImpl::DecryptVerify(std::shared_ptr<ICmsHeader> header, const tscrypto::tsCryptoString &sFilename, const tscrypto::tsCryptoString &sDecryptedFilename, const tscrypto::tsCryptoString &lpszTempFile, const tscrypto::tsCryptoString &sTempFile, bool headerIncluded) { TSDECLARE_FUNCTIONExt(true); std::shared_ptr<IDataReader> reader; std::shared_ptr<IDataWriter> writer; tscrypto::tsCryptoString outputFilename; // Get output filename if (sDecryptedFilename.size() > 0) { outputFilename = sDecryptedFilename; } else { outputFilename = header->GetDataName(); if (outputFilename.size() == 0) { LogError("Unable to retrieve the original file name from the encrypted file."); return TSRETURN_ERROR(("false"), false); } } std::shared_ptr<IDataIOBase> ioBase; if (!(reader = std::dynamic_pointer_cast<IDataReader>(CreateFileReader(sFilename)))) { xp_DeleteFile(sTempFile); LogError("Error occured trying to open input file '%s'.", sFilename.c_str()); return TSRETURN_ERROR(("Bad File"), false); } ioBase.reset(); if (!(writer = std::dynamic_pointer_cast<IDataWriter>(CreateDataWriter(sTempFile)))) { reader->Close(); xp_DeleteFile(sTempFile); LogError("Error occured trying to open input file '%s'.", sFilename.c_str()); return TSRETURN_ERROR(("Bad File"), false); } ioBase.reset(); std::shared_ptr<ICryptoHelper> helper; if (!m_session && header->NeedsSession()) { if (!!m_sessionCallback) { if (!m_sessionCallback->GetSessionForHeader(false, std::dynamic_pointer_cast<ICmsHeaderBase>(header), 0, m_session)) { LogError("No session."); reader->Close(); xp_DeleteFile(sTempFile); return TSRETURN_ERROR(("Returns ~~"), false); } } } if (!m_session) { LogError("Unable to retrieve the cryptographic helper object from the CKM Runtime."); reader->Close(); xp_DeleteFile(sTempFile); return TSRETURN_ERROR(("Returns ~~"), false); } else { if (!(helper = CreateCryptoHelper(m_session))) { LogError("Unable to retrieve the cryptographic helper object from the CKM Runtime."); reader->Close(); xp_DeleteFile(sTempFile); return TSRETURN_ERROR(("Returns ~~"), false); } } helper->SetOperationStatusCallback(m_status); helper->SetTaskInformation(m_currentTask, m_taskCount); if (!!m_keyGenCallback) helper->SetKeyGenCallback(m_keyGenCallback); std::shared_ptr<ICmsHeaderBase> headerBase; // TODO: Issue with new code for disconnected streams. = header; if (!(helper->DecryptStream(headerBase, reader, writer, headerIncluded))) { LogError("Unable to decrypt the data."); return TSRETURN_ERROR(("Unable to decrypt the data."), false); } reader->Close(); writer->Close(); reader.reset(); writer.reset(); if (lpszTempFile.size() == 0) { xp_DeleteFile(sDecryptedFilename); // Copy the temp file to the destination file // According to Jeffrey Richter, "...MoveFile() does not support // the moving/renaming of streams." // (http://www.microsoft.com/msj/1198/ntfs/ntfs.aspx) //if(!MoveFile(sTempFile, sEncryptedFilename)) if (!xp_RenameFile(sTempFile, sDecryptedFilename)) { tscrypto::tsCryptoString msg; switch (errno) { case EACCES: msg = "The destination file already exists"; break; case ENOENT: msg = "The source file does not exist"; break; case EINVAL: if ((xp_GetFileAttributes(sDecryptedFilename.c_str()) & XP_FILE_ATTRIBUTE_DIRECTORY) != 0) msg = "There is a directory called " + sDecryptedFilename + " already."; else msg = "The file name contains invalid characters"; break; default: msg = "An unknown error has occurred while creating the decrypted file."; break; } // Process any inserts in lpMsgBuf. // ... // Check to see if this was a file permissions error DWORD dwAttributes = ::xp_GetFileAttributes(sDecryptedFilename.c_str()); if (dwAttributes & XP_FILE_ATTRIBUTE_READONLY) LogError("The specified output file cannot be accessed because it has Read Only permissions."); //else if(dwAttributes & FILE_ATTRIBUTE_SYSTEM) // SetErrorMessage("The specified output file cannot be accessed because it is used exclusively by the Operating System."); //else if(dwAttributes & FILE_ATTRIBUTE_HIDDEN) // SetErrorMessage("The specified output file cannot be accessed because it has the Hidden file attribute set."); else LogError(msg.c_str()); secureDeleteEntireFile(sTempFile.c_str(), 3); return TSRETURN_ERROR(("FAILED"), false); } xp_DeleteFile(sTempFile); //CKMUtility::secureDelete((CKMString)sTempFile); } return TSRETURN(("OK"), true); }
HGRPOBJ DGraphicStore::AcquireSMD( SString strFilename, int Preset ) { strFilename = strFilename.LowerCase(); HGRPOBJ Handle; HGRPOBJ Null; bool bCloneWhenItFound; DPOOLMODE Mode; bool bEasyToUpdate; switch( Preset ) { case SkinningMesh: Mode = DPOOL_DEFAULT; bEasyToUpdate = true; bCloneWhenItFound = true; break; case StaticMesh: default: Mode = DPOOL_DEFAULT; bEasyToUpdate = false; bCloneWhenItFound = false; break; } // Finding MeshIterator iMeshAdd = m_Case.find( SFullName("offline", DCutPath(strFilename)) ); if( !iMeshAdd.valid() ) {// not found, create new one iMeshAdd = m_Case.addEmpty(); Handle.pObject = iMeshAdd.ptr(); Handle.ID = iMeshAdd.index(); m_Case.setName( iMeshAdd.index(), SFullName("offline", DCutPath(strFilename)) ); if( !Handle.IsValid() ) { DLogWriteSystem( "DGraphicStore(%s) has fatal error on creation.", (lpctstr)strFilename ); return Handle; } } else {// already exist Handle.pObject = iMeshAdd.ptr(); Handle.ID = iMeshAdd.index(); if( bCloneWhenItFound ) { return CloneSMD( Handle ); } else {// increase reference count m_Case.addEmpty( iMeshAdd.index() ); // this func. just add ref if object already exists in the index. return Handle; } } if( Handle.pObject==NULL ) { return Null; } #ifdef _DEBUG Handle.pObject->m_strDebugRscName = strFilename;// 디버그를 위한 객체이름 #endif Handle.pObject->Name = SName((const char*)strFilename); // Load from file DFile File; if( !File.Open( (const char*)strFilename ) ) {// cannot open a file! DLogWriteSystem( "DGraphicStore::AcquireSMD(%s) couldn't open file!", (const char*)strFilename ); m_Case.remove( Handle.ID ); return Null; } DProgressiveMesh *pMesh = Handle.pObject; //////////////////////////////////////////// // Convert // Old SMD -> Latest SMD // // : Test File Type to convert //////////////////////////////////////////// char aTestBuffer[4]; File.Read( aTestBuffer, 4*sizeof(char) ); if( appStrncmp( aTestBuffer, "SSKF", 4 )!=0 ) { File.SeekToBegin(); // Read mesh GMeshGrp meshOther; if( !meshOther.Load( &File, false ) ) { File.Close(); return Null; } // Cut Texture Name's Path string GMaterial *pMaterial = meshOther.GetMaterial(); DWORD nNumMaterials = meshOther.GetNumMaterials(); for( DWORD i=0; i<nNumMaterials; i++ ) { SString strTemp = pMaterial[i].GetTexture(); pMaterial[i].SetTexture( DCutPath(strTemp) ); } // Convert it! pMesh->ImportOtherMesh( meshOther ); } // End of Converting else { File.SeekToBegin(); DArchive *Ar = CreateFileReader( File.GetFile() ); pMesh->Serialize( *Ar ); // release buffer SAFE_DELETE( Ar ); } // End of Loading pMesh->BuildVertexBuffer(); pMesh->Textures.Empty(); For( int i = 0; i < pMesh->Materials.Num(); ++i ) { SString strTexName; strTexName = DGetParentDir(strFilename,2); strTexName += "png\\"; strTexName += (const char*)*pMesh->Materials[i].DiffuseTex; DTexture *pTex = DGlobalMng()->TextureAcquire( strTexName, true, true ); if( pTex==NULL ) { strTexName = DGetPathOnly(strFilename); strTexName += (const char*)*pMesh->Materials[i].DiffuseTex; pTex = DGlobalMng()->TextureAcquire( strTexName, true, true ); } pMesh->Textures.AddItem( pTex ); } File.Close(); return Handle; }
uint32 FFileManagerGeneric::CopyWithProgress( const TCHAR* InDestFile, const TCHAR* InSrcFile, bool ReplaceExisting, bool EvenIfReadOnly, bool Attributes, FCopyProgress* Progress ) { uint32 Result = COPY_OK; // Direct file copier. if( Progress->Poll( 0.0 ) ) { FString SrcFile = InSrcFile; FString DestFile = InDestFile; FArchive* Src = CreateFileReader( *SrcFile ); if( !Src ) { Result = COPY_Fail; } else { FArchive* Dest = CreateFileWriter( *DestFile,( ReplaceExisting ? 0 : FILEWRITE_NoReplaceExisting ) | ( EvenIfReadOnly ? FILEWRITE_EvenIfReadOnly : 0 ) ); if( !Dest ) { Result = COPY_Fail; } else { int64 Size = Src->TotalSize(); int64 Percent = 0, NewPercent = 0; uint8* Buffer = new uint8[COPYBLOCKSIZE]; for( int64 Total = 0; Total < Size; Total += sizeof(Buffer) ) { int64 Count = FMath::Min( Size - Total, (int64)sizeof(Buffer) ); Src->Serialize( Buffer, Count ); if( Src->IsError() ) { Result = COPY_Fail; break; } Dest->Serialize( Buffer, Count ); if( Dest->IsError() ) { Result = COPY_Fail; break; } NewPercent = Total * 100 / Size; if( Progress && Percent != NewPercent && !Progress->Poll( ( float )NewPercent / 100.f ) ) { Result = COPY_Canceled; break; } Percent = NewPercent; } delete [] Buffer; if( Result == COPY_OK && !Dest->Close() ) { Result = COPY_Fail; } delete Dest; if( Result != COPY_OK ) { Delete( *DestFile ); } } if( Result == COPY_OK && !Src->Close() ) { Result = COPY_Fail; } delete Src; } if( Progress && Result==COPY_OK && !Progress->Poll( 1.0 ) ) { Result = COPY_Canceled; } } else { Result = COPY_Canceled; } return Result; }