--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/loader/security/t_ldrcheck.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1236 @@
+// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// f32test\loader\t_ldrcheck.cpp
+//
+//
+
+
+#include "dlltree.h"
+#include <e32uid.h>
+#include <hal.h>
+#include <e32wins.h>
+#include <e32svr.h>
+#include <e32test.h>
+#include <f32file.h>
+#include <f32dbg.h>
+#include <f32image.h>
+#include "t_hash.h"
+
+#if defined (WIN32) && !defined (__X86GCC__)
+#include <emulator.h>
+#include <stdlib.h>
+#endif
+
+
+RTest test(_L("T_LDRCheck"));
+RFs TheFs;
+GLDEF_D TChar gDriveToTest;
+
+
+/**
+ Copy modules from z:\\sys\\bin to c:\\sys\\bin
+*/
+void CopyModules()
+ {
+ test.Next(_L("Copy Modules from ROM to disk"));
+
+ TInt r;
+ TTime modtime;
+
+ r=TheFs.MkDirAll(KSystemLibs);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ CFileMan* fileMan=NULL;
+ TRAP(r,fileMan=CFileMan::NewL(TheFs));
+ test(r==KErrNone);
+
+ TBuf<40> dllfilenames;
+ TBuf<40> dlldestination;
+
+ for(TInt i=0;i<14;i++)
+ {
+ dllfilenames=KDllfilename;
+ dllfilenames.AppendNum(i);
+ dllfilenames +=KDllExt;
+ dlldestination=KNewDllName;
+ dlldestination.AppendNum(i);
+ dlldestination+=KDllExt;
+#ifndef WIN32
+ r=fileMan->Copy(dllfilenames,dlldestination, 0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=fileMan->Attribs(dlldestination,0, KEntryAttReadOnly,modtime,0);
+ test(r==KErrNone);
+#endif
+ }
+
+ TBuf<40> exefilenames;
+ TBuf<40> exedestination;
+
+ for(TInt j=14;j<16;j++)
+ {
+ exefilenames=KExefilename;
+ exefilenames.AppendNum(j);
+ exefilenames +=KExeExt;
+ exedestination=KNewExeName;
+ exedestination.AppendNum(j);
+ exedestination+=KExeExt;
+#ifndef WIN32
+ r=fileMan->Copy(exefilenames,exedestination,0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=fileMan->Attribs(exedestination, 0, KEntryAttReadOnly, modtime, 0);
+ test(r==KErrNone);
+#endif
+ }
+ delete fileMan;
+ }
+
+
+
+#ifndef WIN32
+/*
+void ModifyModuleCapabilties(TUint32 aNewCap, TInt aModuleNumber)
+//
+// Assign new capabilties to a module using raw disk write
+//
+ {
+// test.Next(_L("Modify Module Capabilities"));
+
+ test(aModuleNumber<=15 && aModuleNumber>=0);
+
+ TBuf<40> dlldestination;
+ RFile modFile;
+ TInt r=0;
+
+ SCapabilitySet caps;
+ memset(&caps,0,sizeof(caps));
+ caps[0] = aNewCap;
+ TPtrC8 theNewCaps((TUint8*)(&caps),sizeof(caps));
+
+ if(aModuleNumber < 14)
+ {
+ dlldestination=KNewDllName;
+ dlldestination.AppendNum(aModuleNumber);
+ dlldestination+=KDllExt;
+ }
+ else
+ {
+ dlldestination=KNewExeName;
+ dlldestination.AppendNum(aModuleNumber);
+ dlldestination+=KExeExt;
+ }
+
+ r=modFile.Open(TheFs, dlldestination, EFileWrite);
+ test(r==KErrNone);
+ r=modFile.Write(_FOFF(E32ImageHeaderV,iS.iCaps), theNewCaps,4);
+ test(r==KErrNone);
+ modFile.Close();
+
+ RLibrary lib;
+ TCapabilitySet theCaps;
+ RLibrary::TInfoBuf info;
+
+ lib.GetInfo(dlldestination, info);
+ theCaps=info().iSecurityInfo.iCaps;
+
+ lib.Close();
+ test(theCaps==aNewCap);
+
+ }
+*/
+#else
+/*
+void ModifyModuleCapabilties(TUint32 aNewCap, TInt aModuleNumber)
+//
+// Wins version (poking values is not quite so simple
+//
+ {
+// test.Next(_L("Modify Module Capabilities"));
+ test(aModuleNumber<=15 && aModuleNumber>=0);
+
+ TBuf<40> dlldestination;
+ TInt r=0;
+
+ TPtrC8 theNewCaps((TUint8*)(&aNewCap),sizeof(TUint32));
+
+
+ if(aModuleNumber < 14)
+ {
+ dlldestination=KNewDllName;
+ dlldestination.AppendNum(aModuleNumber);
+ dlldestination+=KDllExt;
+ }
+ else
+ {
+ dlldestination=KNewExeName;
+ dlldestination.AppendNum(aModuleNumber);
+ dlldestination+=KExeExt;
+ }
+
+ RLibrary lib2;
+ TCapabilitySet theCaps2;
+ RLibrary::TInfoBuf info;
+
+ lib2.GetInfo(dlldestination, info);
+ theCaps2=info().iSecurityInfo.iCaps;
+
+ lib2.Close();
+
+ TBuf<MAX_PATH> fileName;
+ r = MapEmulatedFileName(fileName, dlldestination);
+
+ HANDLE hFile=Emulator::CreateFile((LPCTSTR)fileName.PtrZ(),GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL);
+ if (hFile==INVALID_HANDLE_VALUE)
+ return;
+ DWORD ret;
+ TBuf8<sizeof(TCheckedUid)> checkedUidBuf;
+ checkedUidBuf.SetLength(sizeof(TCheckedUid));
+ ReadFile(hFile,&checkedUidBuf[0],sizeof(TCheckedUid),&ret,NULL);
+ if (ret!=sizeof(TCheckedUid))
+ goto close;
+
+ //Look at PE file for UID section
+ {
+ const TInt KPeHeaderAddrAddr=0x3c;
+ const TInt KPeHeaderAddrSize=0x01;
+ const TInt KNumberOfSectionsOffset=0x06;
+ const TInt KNumberOfSectionsSize=0x02;
+ const TInt KSectionTableOffset=0xf8;
+ const TInt KSectionHeaderSize=0x28;
+ const TInt KSectionNameLength=0x08;
+ const TInt KPtrToRawDataOffset=0x14;
+ const TInt KPtrToRawDataSize=0x04;
+ const TText8 peText[4]={'P','E',0,0};
+ const TText8 uidText[8]={'.','S','Y','M','B','I','A','N'};
+
+ //Read address of start of PE header
+ if (SetFilePointer(hFile,KPeHeaderAddrAddr,0,FILE_BEGIN)==0xFFFFFFFF)
+ goto close;
+ TInt peAddr=0;
+ ReadFile(hFile,&peAddr,KPeHeaderAddrSize,&ret,NULL);
+ if (ret!=KPeHeaderAddrSize)
+ goto close;
+
+ //Check it really is the start of PE header
+ if (SetFilePointer(hFile,peAddr,0,FILE_BEGIN)==0xFFFFFFFF)
+ goto close;
+ TText8 text[4];
+ ReadFile(hFile,text,4,&ret,NULL);
+ if (*(TInt32*)text!=*(TInt32*)peText)
+ goto close;
+
+ //Read number of sections
+ if (SetFilePointer(hFile,peAddr+KNumberOfSectionsOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+ goto close;
+ TInt sections=0;
+ ReadFile(hFile,§ions,KNumberOfSectionsSize,&ret,NULL);
+ if (ret!=KNumberOfSectionsSize)
+ goto close;
+
+ //Go through section headers looking for UID section
+ if (SetFilePointer(hFile,peAddr+KSectionTableOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+ goto close;
+ TInt i=0;
+ for(;i<sections;i++)
+ {
+ TText8 name[KSectionNameLength];
+ ReadFile(hFile,name,KSectionNameLength,&ret,NULL);
+ if (ret!=KSectionNameLength)
+ goto close;
+ if (*(TInt64*)name==*(TInt64*)uidText)
+ break;
+ if (SetFilePointer(hFile,KSectionHeaderSize-KSectionNameLength,0,FILE_CURRENT)==0xFFFFFFFF)
+ goto close;
+ }
+ if (i==sections)
+ goto close;
+
+ //Read RVA/Offset
+ if (SetFilePointer(hFile,KPtrToRawDataOffset-KSectionNameLength,0,FILE_CURRENT)==0xFFFFFFFF)
+ goto close;
+ TInt uidOffset;
+ ReadFile(hFile,&uidOffset,KPtrToRawDataSize,&ret,NULL);
+ if (ret!=KPtrToRawDataSize)
+ goto close;
+
+ //SYMBIAN Header
+ if (SetFilePointer(hFile,uidOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+ goto close;
+
+ TEmulatorImageHeader header;
+
+ ReadFile(hFile,&header,sizeof(header),&ret,NULL);
+ if (ret!=sizeof(header))
+ goto close;
+
+// DON'T modify, for now header.iS.iCaps[0] = aNewCap; //assign new caps to binary
+
+
+ if (SetFilePointer(hFile,uidOffset,0,FILE_BEGIN)==0xFFFFFFFF)
+ goto close;
+
+ BOOL b = WriteFile(hFile,&header,sizeof(header),&ret,NULL);
+ if (b==FALSE)
+ goto close;
+ CloseHandle(hFile);
+
+ RLibrary lib;
+ TCapabilitySet theCaps;
+ RLibrary::TInfoBuf info;
+ lib.GetInfo(dlldestination, info);
+ theCaps=info().iSecurityInfo.iCaps;
+
+ lib.Close();
+
+ SCapabilitySet& realCaps = (SCapabilitySet&) theCaps;
+// broke! test(realCaps[0] == aNewCap && realCaps[1] == 0);
+ return;
+ }
+
+//Close file
+close:
+ CloseHandle(hFile);
+ test(0);
+ }
+*/
+#endif
+
+/*
+void TestGetCapability()
+//
+// test RLibrary::GetCapabilites
+//
+ {
+ RLibrary library;
+ TInt r;
+ test.Next(_L("Test RLibrary::GetCapabilities()"));
+
+// These tests check the error code returned by the (deprecated) GetCapability method
+// and now serve no useful purpose
+// TCapability theCaps;
+// r=library.GetCapability(theCaps,_L("Z:\\Mongolia"));
+// test(r==KErrNotFound);
+// r=library.GetCapability(theCaps,_L("C:\\Malawi.Fip"));
+// test(r==KErrNotFound);
+
+ TCapabilitySet theCaps;
+ RLibrary::TInfoBuf info;
+#if defined __WINS__
+
+
+
+
+ test.Next(_L("Get caps of an existing library"));
+// r=lib1.GetCapability(theCaps,_L("ECONS"));
+// test(r==KErrNone);
+ RLibrary lib1;
+// r=lib1.GetInfo(_L("ECONS"), info);
+ r=lib1.GetInfo(_L("Z:\\SYS\\BIN\\ECONS"), info);
+ test(r==KErrNone);
+ theCaps=info().iSecurityInfo.iCaps;
+
+ test.Next(_L("And again"));
+// r=lib2.GetCapability(theCaps,_L("ECONS.DLL"));
+// test(r==KErrNone);
+ RLibrary lib2;
+ lib2.GetInfo(_L("ECONS.DLL"), info);
+ theCaps=info().iSecurityInfo.iCaps;
+
+#else
+// This test checks for the correct return value from the (deprecated)
+// method GetCapability, and now serves no useful purpose??
+// r=library.GetCapability(theCaps,_L("Malawi.Fip"));
+// test(r==KErrNotSupported);
+ library.GetInfo(_L("Malawi.Fip"), info);
+ theCaps=info().iSecurityInfo.iCaps;
+
+//TODO uncomment when in ssytem bin
+// RLibrary lib1;
+// test.Next(_L("Get caps of an existing library"));
+// r=lib1.GetCapability(theCaps,_L("ECONS"));
+// r=lib1.GetCapability(theCaps,_L("Z:\\Sys\\Bin\\ECONS"));
+// RDebug::Print(_L("r====%d"),r);
+// test(r==KErrNone);
+
+// RLibrary lib2;
+// test.Next(_L("And again"));
+// r=lib2.GetCapability(theCaps,_L("Z:\\Sys\\Bin\\ECONS.DLL"));
+// r=lib2.GetCapability(theCaps,_L("ECONS.DLL"));
+// test(r==KErrNone);
+
+ RLibrary lib3;
+ test.Next(_L("And again, but searching"));
+ r=lib3.GetCapability(theCaps,_L("ECONS.DLL"));
+ test(r==KErrNotSupported);
+ lib3.Close();
+
+#endif
+
+ test.Next(_L("Search through DLLs from t_ldrcheck"));
+
+ // Not sure of the benefit of this test ??
+
+ TBuf<40> dllfilenames;
+ RLibrary tlib;
+// TCapability deecaps;
+ TCapabilitySet deecaps;
+ for(TInt i=0;i<13;i++)
+ {
+ dllfilenames=KDllfilename;
+ dllfilenames.AppendNum(i);
+ dllfilenames +=KDllExt;
+// r=tlib.GetCapability(deecaps,dllfilenames);
+ tlib.GetInfo(dllfilenames, info);
+ theCaps=info().iSecurityInfo.iCaps;
+ }
+
+ test.Next(_L("Close()"));
+ tlib.Close();
+ library.Close();
+// lib1.Close();
+// lib2.Close();
+ }
+*/
+
+TInt LoadExe(TInt aModuleNum, RProcess& aProcess)
+//
+// Load executable
+//
+ {
+ TFileName fn;
+//#ifndef WIN32
+// fn =KSystemLibs();
+//#endif
+ TBuf<16> cmd;
+ fn += MODULE_FILENAME(aModuleNum);
+ TInt r=aProcess.Create(fn, cmd);
+ return r;
+ }
+
+
+void TestLoad(TInt aSequence)
+//
+// Test doing the loads using sequence number to get the results
+//
+ {
+ test.Next(_L("Test all single EXE/DLL combinations\n"));
+ TInt r=0;
+ test.Next(_L("New EXE"));
+ RProcess p;
+
+ r=LoadExe(14,p);
+ test.Printf(_L("LoadExe(14)->%d, Expected %d, seq %d \n"),r,ModuleResultsA[aSequence], aSequence);
+ test(r==ModuleResultsA[aSequence]);
+ if (r==KErrNone)
+ p.Terminate(0);
+ p.Close();
+
+ r=LoadExe(15,p);
+ test.Printf(_L("LoadExe(15)->%d, seq %d\n"),r,aSequence);
+ test(r==ModuleResultsA[aSequence]);
+ if (r==KErrNone)
+ p.Terminate(0);
+ p.Close();
+ }
+
+/*
+void TestLoadLibrary()
+//
+// test using load library to load dlls with out rom time dependancies
+//
+ {
+ test.Next(_L("Test loading libraries fromn this exe"));
+
+ RLibrary lib;
+ TInt r=0;
+ //I want to load 6 7 and 11 as these are of most interest
+
+ for(TInt i=0;i<KTestCases;i++)
+ {
+ for(TInt mod=0 ; mod < 16 ; mod++) //each module
+ {
+ ModifyModuleCapabilties(ModuleCaps[mod][i],mod);
+ }
+ r=lib.Load(KDll11);
+ test.Printf(_L("mod11, iter=%d, ret=%d, exp=%d"),i,r,ModuleResultsB[i]);
+ test(r==ModuleResultsB[i]);
+ lib.Close();
+ r=lib.Load(KDll6);
+ test.Printf(_L("mod6, iter=%d, ret=%d, exp=%d"),i,r,ModuleResultsB[i]);
+ test(r==ModuleResultsB[i]);
+ lib.Close();
+ r=lib.Load(KDll7);
+ test.Printf(_L("mod7, iter=%d, ret=%d, exp=%d"),i,r,ModuleResultsC[i]);
+ test(r==ModuleResultsC[i]);
+ lib.Close();
+ }
+
+ }
+*/
+/*
+void TestLoading()
+//
+// test loading various dependancies
+//
+ {
+ for(TInt tstcase=0; tstcase < KTestCases; tstcase++) //each test case
+ {
+ for(TInt mod=0 ; mod < 16 ; mod++) //each module
+ {
+ ModifyModuleCapabilties(ModuleCaps[mod][tstcase],mod);
+ }
+ TestLoad(tstcase);
+ }
+ }
+*/
+
+
+_LIT(KSysHash,"?:\\Sys\\Hash\\");
+const TInt KSlash='\\';
+
+/**
+ Creates a hash file in c:\\sys\\hash for a given file
+
+ @param aFileName full path to the file, which hash is to be created
+*/
+void CreateFileHash(const TDesC& aFileName)
+ {
+
+ test.Printf(_L("Create Hash for the file %S\n"), &aFileName);
+
+ TInt readsize = 1024*2;//to go into header
+ HBufC8* block0 = HBufC8::NewL(readsize);
+
+ TPtr8 fileblock0(block0->Des());
+ CSHA1* hasher=CSHA1::NewL();
+
+ RFile fTarget;
+ TInt r= fTarget.Open(TheFs, aFileName, EFileRead);
+ test(r==KErrNone);
+ TInt size;
+ r=fTarget.Size(size);
+ TInt offset=0;
+ do {
+ if((size - offset) < readsize)
+ readsize = (size - offset);
+ r=fTarget.Read(offset, fileblock0, readsize);
+ test(r==KErrNone);
+ hasher->Update(fileblock0);
+ offset+=readsize;
+ }
+ while(offset < size);
+
+ r=fTarget.Read(fileblock0, (size - offset));
+ test(r==KErrNone);
+ hasher->Update(fileblock0);
+
+ TBuf8<20> hash;//only outputs a 20 byte hash
+ hash = hasher->Final();
+ fTarget.Close();
+
+// const TUint8 * hptr=hash.Ptr();
+// for(TInt i=0;i<20;i++)
+// {
+// RDebug::Print(_L("install hash byte %d = 0x%x\n"),i,hptr[i]);
+// }
+
+ delete block0;
+ delete hasher;
+ TEntry entry;
+ r=TheFs.Entry(aFileName,entry);
+ test(r==KErrNone);
+ RFile fHash;
+ TBuf<50> hashfile;
+ hashfile = KSysHash;
+ hashfile[0] = (TUint8) RFs::GetSystemDriveChar();
+ TInt slashpos = aFileName.LocateReverse(KSlash);
+ hashfile += aFileName.Mid(slashpos+1);
+
+ //-- create directory for dll hashes
+ r=TheFs.MkDirAll(hashfile);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ //-- copy / replace given dll hash
+ r=fHash.Replace(TheFs, hashfile, EFileWrite);
+ test(r==KErrNone);
+ r=fHash.Write(hash);
+ test(r==KErrNone);
+ r=fHash.Size(size);
+ test(r==KErrNone);
+ test.Printf(_L("hash file size=%d\n"),size);
+ fHash.Close();
+
+ }
+
+
+/**
+ Corrups a file.
+
+ @param aFileName a full path to the file to corrupt
+ @return KErrNone on success
+*/
+static TInt CorruptFile(const TDesC& aFileName)
+{
+ test.Printf(_L("Corrupting file %S\n"), &aFileName);
+
+ RFile corrFile;
+ CleanupClosePushL(corrFile);
+
+ TInt r=corrFile.Open(TheFs, aFileName, EFileWrite);
+ if(r != KErrNone)
+ return r;
+
+ TInt size;
+ r=corrFile.Size(size);
+ if(r != KErrNone)
+ return r;
+
+ TBuf8<2> dat;
+ r=corrFile.Read(size - 5, dat);
+ if(r != KErrNone)
+ return r;
+
+ dat[0] = (TUint8) ~dat[0];
+
+ r=corrFile.Write(size - 5, dat);
+ if(r != KErrNone)
+ return r;
+
+ CleanupStack::PopAndDestroy(1); //-- corrFile
+
+ return KErrNone;
+}
+
+
+#ifndef WIN32
+void TestRemovableMediaWithHash()
+//
+// test loading from removable media and substed drives Both should fail
+//
+ {
+ test.Next(_L("Testing Removable Media with hashing\n"));
+ TInt r=0;
+ CFileMan* fileMan=NULL;
+ TRAP(r,fileMan=CFileMan::NewL(TheFs));
+ test(r==KErrNone);
+
+ TBuf<30> dllfilenames;
+ TBuf<30> dlldestination;
+ RLibrary lib;
+
+ for(TInt i=0;i<14;i++)
+ {
+ dllfilenames=KNewDllName;
+ dllfilenames.AppendNum(i);
+ dllfilenames +=KDllExt;
+
+ dlldestination=KNewDllName;
+ dlldestination[0]=gDriveToTest;
+ dlldestination.AppendNum(i);
+ dlldestination+=KDllExt;
+
+ r=TheFs.MkDirAll(dlldestination);
+ test.Printf(_L("MkDirAll(%S) returned %d\n"), &dlldestination, r);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ r=fileMan->Copy(dllfilenames,dlldestination, 0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+
+ //take hash of binary
+ CreateFileHash(dlldestination);
+
+ //load binary as is
+ r=lib.Load(dlldestination);
+ RDebug::Print(_L("t_ldrcheck: loading %S returned %d\n"),&dlldestination, r);
+
+ User::After(100000);
+ test(r==KErrNone);
+ lib.Close();
+ test.Printf(_L("Close lib on untouched load\n"));
+
+ //-- corrupt dll
+ r = CorruptFile(dlldestination);
+ test(r==KErrNone);
+ test.Printf(_L("Binary %S now corrupted\n"), &dlldestination);
+
+ //load should fail
+ test.Printf(_L("loading %S\n"),&dlldestination);
+ r=lib.Load(dlldestination);
+ test.Printf(_L("load of %S returned %d\n"),&dlldestination,r);
+ test(r==KErrPermissionDenied);//as this process has Root caps and the dlls should be loaded with non
+ lib.Close();
+ test.Printf(_L("Lib close 1\n"));
+
+ r=TheFs.Delete(dlldestination);
+ test.Printf(_L("Delete ret=%d\n"),r);
+ test(r==KErrNone);
+ }//for(TInt i=0;i<14;i++)
+
+
+ TBuf<30> exefilenames;
+ TBuf<30> exedestination;
+ RProcess p;
+ TBuf<16> cmd;
+
+ for(TInt j=14;j<16;j++)
+ {
+ exefilenames=KNewExeName;;
+ exefilenames.AppendNum(j);
+ exefilenames +=KExeExt;
+
+ exedestination=KNewExeName;
+ exedestination[0]=gDriveToTest;
+ exedestination.AppendNum(j);
+ exedestination+=KExeExt;
+
+ r=fileMan->Copy(exefilenames,exedestination,0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ CreateFileHash(exedestination);
+
+ r=p.Create(exedestination, cmd);
+ test(r==KErrNone);
+ p.Terminate(0);
+ p.Close();
+
+ r = CorruptFile(exedestination);
+ test(r==KErrNone);
+
+ test.Printf(_L("Binary %S now corrupted\n"), &exedestination);
+
+ r=p.Create(exedestination, cmd);
+ test(r==KErrPermissionDenied);
+// p.Terminate(0); DON'T DO THIS SINCE CREATION FAILED - HANDLE NOT OPENED
+ p.Close();
+
+ r=TheFs.Delete(exedestination);
+ test(r==KErrNone);
+
+ }
+ delete fileMan;
+ }
+
+/*
+void TestRemovableMedia()
+//
+// test loading from removable media and substed drives Both should fail
+//
+ {
+ test.Next(_L("Testing Removeable Media"));
+ TInt r=0;
+ CFileMan* fileMan=NULL;
+ TRAP(r,fileMan=CFileMan::NewL(TheFs));
+ test(r==KErrNone);
+
+ TBuf<30> dllfilenames;
+ TBuf<30> dlldestination;
+ RLibrary lib;
+ for(TInt i=0;i<14;i++)
+ {
+ dllfilenames=KNewDllName;
+ dllfilenames.AppendNum(i);
+ dllfilenames +=KDllExt;
+
+ dlldestination=KNewDllName;
+ dlldestination[0]='D';
+ dlldestination.AppendNum(i);
+ dlldestination+=KDllExt;
+
+ r=TheFs.MkDirAll(dlldestination);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=fileMan->Copy(dllfilenames,dlldestination, 0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=lib.Load(dlldestination);
+ test.Printf(_L("load %S ret=%d"),&dlldestination,r);
+ RDebug::Print(_L("r=%d"),r);
+ test(r==KErrPermissionDenied);//as this process has Root caps and the dlls should be loaded with non
+ lib.Close();
+ }
+
+ TBuf<30> exefilenames;
+ TBuf<30> exedestination;
+ RProcess p;
+ TBuf<16> cmd;
+
+ for(TInt j=14;j<16;j++)
+ {
+ exefilenames=KNewExeName;;
+ exefilenames.AppendNum(j);
+ exefilenames +=KExeExt;
+
+ exedestination=KNewExeName;
+ exedestination[0]='D';
+ exedestination.AppendNum(j);
+ exedestination+=KExeExt;
+
+ r=fileMan->Copy(exefilenames,exedestination,0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=p.Create(exedestination, cmd);
+ test(r==KErrPermissionDenied);
+ p.Close();
+ }
+ delete fileMan;
+ }
+*/
+
+void TestNonSystemSubsted()
+//
+// Test an internal drive on non system dir
+//
+ {
+ test.Next(_L("Testing Non System and Subst"));
+ TInt r=0;
+ CFileMan* fileMan=NULL;
+ TRAP(r,fileMan=CFileMan::NewL(TheFs));
+ test(r==KErrNone);
+
+ TBuf<50> dllfilenames;
+ TBuf<50> dlldestination;
+ TBuf<50> substed;
+ RLibrary lib;
+ for(TInt i=0;i<14;i++)
+ {
+ dllfilenames=KNewDllName;
+ dllfilenames.AppendNum(i);
+ dllfilenames +=KDllExt;
+
+ dlldestination=KAnyDirDll;
+ dlldestination+=_L("_X");
+ dlldestination.AppendNum(i);
+ dlldestination+=KDllExt;
+
+ if(i==0)
+ {
+ r=TheFs.MkDirAll(dlldestination);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ r=TheFs.SetSubst(KAnyDirShort(), EDriveN); //set up n as the substed drive
+ test(r==KErrNone);
+ }
+
+ RDebug::Print(_L("copying from %S to %S"),&dllfilenames,&dlldestination);
+ r=fileMan->Copy(dllfilenames,dlldestination, 0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ //
+ // Test that loading from fully qualified path fails
+ // (ie - C:\Anyoldname\sys\bin\DLLTS_X0.DLL)
+ //
+ r=lib.Load(dlldestination);
+ RDebug::Print(_L("RLibrary::Load(%S) : r=%d"), &dlldestination, r);
+ test(r==KErrNotFound);
+
+ //
+ // Test that loading from substituted drive fails
+ // (ie - N:\sys\bin\DLLTS_X0.DLL, where N:\ == C:\Anyoldname\)
+ //
+ substed=KJDllName;
+ substed+=_L("_X");
+ substed.AppendNum(i);
+ substed+=KDllExt;
+
+ r=lib.Load(substed);
+ RDebug::Print(_L("RLibrary::Load(%S) : r=%d"), &substed, r);
+ test(r==KErrNotFound);
+
+ //
+ // Test that loader search does not find substituted drives when
+ // loading library with no drive or path specified.
+ //
+ substed=KJDllNameOnly;
+ substed+=_L("_X");
+ substed.AppendNum(i);
+ substed+=KDllExt;
+
+ r=lib.Load(substed);
+ RDebug::Print(_L("RLibrary::Load(%S) : r=%d"), &substed, r);
+ test(r==KErrNotFound);
+ }
+
+ TBuf<50> exefilenames;
+ TBuf<50> exedestination;
+ RProcess p;
+ TBuf<16> cmd;
+
+ for(TInt j=14;j<16;j++)
+ {
+ exefilenames=KNewExeName;;
+ exefilenames.AppendNum(j);
+ exefilenames +=KExeExt;
+
+ exedestination=KAnyDirExe;
+ exedestination+=_L("_X");
+ exedestination.AppendNum(j);
+ exedestination+=KExeExt;
+
+ RDebug::Print(_L("copying from %S to %S"),&exefilenames,&exedestination);
+ r=fileMan->Copy(exefilenames,exedestination,0);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ //
+ // Test that loading from fully qualified path fails
+ // (ie - C:\Anyoldname\sys\bin\EXETS_X14.EXE)
+ //
+ r=p.Create(exedestination, cmd);
+ RDebug::Print(_L("RProcess::Create(%S) : r=%d"), &exedestination, r);
+ test(r==KErrNotFound);
+
+ //
+ // Test that loading from substituted drive fails
+ // (ie - N:\sys\bin\EXETS_X14.EXE, where N:\ == C:\Anyoldname\)
+ //
+ substed=KJExeName;
+ substed+=_L("_X");
+ substed.AppendNum(j);
+ substed+=KExeExt;
+
+ r=p.Create(substed, cmd);
+ RDebug::Print(_L("RProcess::Create(%S) : r=%d"), &substed, r);
+ test(r==KErrNotFound);
+
+ //
+ // Test that loader search does not find substituted drives when
+ // loading process with no drive or path specified.
+ //
+ substed=KJExeNameOnly;
+ substed+=_L("_X");
+ substed.AppendNum(j);
+ substed+=KExeExt;
+
+ r=p.Create(substed, cmd);
+ RDebug::Print(_L("RProcess::Create(%S) : r=%d"), &substed, r);
+ test(r==KErrNotFound);
+ }
+ delete fileMan;
+
+ // Clear the substituted drive
+ r=TheFs.SetSubst(KNullDesC, EDriveN);
+ test(r==KErrNone);
+ }
+
+/*
+void TestSystemBinSubsted()
+//
+// Test an internal drive on system dir
+//
+ {
+ test.Next(_L("Testing System bin -> Subst"));
+ TInt r=0;
+ CFileMan* fileMan=NULL;
+ TRAP(r,fileMan=CFileMan::NewL(TheFs));
+ test(r==KErrNone);
+
+ TBuf<50> dllfilenames;
+ TBuf<50> substed;
+ RLibrary lib;
+ r=TheFs.SetSubst(KSystemLibs, 14); //set up O as the substed drive
+ test(r==KErrNone);
+ for(TInt i=0;i<14;i++)
+ {
+ RDebug::Print(_L("doing modify caps = %d"),i);
+ ModifyModuleCapabilties(KCapabilityRoot,i);
+ dllfilenames=KNewDllName;
+ dllfilenames.AppendNum(i);
+ dllfilenames +=KDllExt;
+
+ RDebug::Print(_L("Module = %S"),&dllfilenames);
+ r=lib.Load(dllfilenames);
+ test(r==KErrNone);//as this process has Root caps and the dlls should be loaded with non
+ substed=_L("O:\\DLLTS");
+ substed.AppendNum(i);
+ substed+=KDllExt;
+
+ r=lib.Load(substed);
+ test(r==KErrNone);
+ lib.Close();
+ }
+ TBuf<50> exefilenames;
+ RProcess p;
+ TBuf<16> cmd;
+
+ for(TInt j=14;j<16;j++)
+ {
+ exefilenames=KNewExeName;
+ exefilenames.AppendNum(j);
+ exefilenames +=KExeExt;
+ ModifyModuleCapabilties(KCapabilityRoot,j);
+ r=p.Create(exefilenames, cmd);
+ test(r==KErrNone);
+ p.Terminate(0);
+ p.Close();
+
+
+ substed=_L("O:\\EXETS");
+ substed.AppendNum(j);
+ substed+=KExeExt;
+ RDebug::Print(_L("substed=%S"),&substed);
+ r=p.Create(substed, cmd);
+ test(r==KErrNone);
+ p.Terminate(0);
+ p.Close();
+ }
+ delete fileMan;
+ }
+*/
+#endif
+
+
+
+void HashBM()
+//
+// time how long to load a small dll 100 times and one large one
+//
+ {
+ test.Next(_L("Next Do Bench Mark\n"));
+ TBuf<30> dlldestination;
+ dlldestination=KNewDllName;
+ dlldestination[0]='D';
+ dlldestination.AppendNum(1);
+ dlldestination+=KDllExt;
+ RLibrary lib;
+ TInt r=0;
+ TUint32 startcount = User::NTickCount();
+ for (TInt i=0;i<100;i++)
+ {
+ r=lib.Load(dlldestination);
+ lib.Close();
+ }
+ TUint32 endcount = User::NTickCount();
+ test(r==KErrNone);
+ RDebug::Print(_L("100 * 4k dll \n"));
+ RDebug::Print(_L("start count=%d, end count=%d, dif=%d\n"),startcount,endcount,endcount-startcount);
+
+ startcount = User::NTickCount();
+ r=lib.Load(_L("D:\\sys\\bin\\euser.dll"));
+ lib.Close();
+ endcount = User::NTickCount();
+ RDebug::Print(_L("r=%d"));
+// test(r==KErrNone);
+ RDebug::Print(_L("1 * 233k dll \n"));
+ RDebug::Print(_L("start count=%d, end count=%d, dif=%d\n"),startcount,endcount,endcount-startcount);
+ }
+
+//-------------------------------------------------------
+
+/**
+ testing RLoader::CheckLibraryHash() API
+*/
+void TestCheckLibraryHash()
+{
+ test.Next(_L("Testing CheckLibraryHash API\n"));
+
+ TInt r=0;
+ CFileMan* pFileMan=NULL;
+ TRAP(r,pFileMan=CFileMan::NewL(TheFs));
+ test(r==KErrNone);
+
+ RLoader loader;
+ r=loader.Connect();
+ test(r==KErrNone);
+
+ //-- 1. copy test DLL to the specified drive and create hash file for it.
+ TBuf<40> dllFileName;
+ TBuf<40> dllDestination;
+
+ const TInt KDllNumber = 0;
+
+ dllFileName=KDllfilename;
+ dllFileName.AppendNum(KDllNumber);
+ dllFileName+=KDllExt;
+
+ dllDestination=KNewDllName;
+ dllDestination[0]=(TUint16)gDriveToTest;
+ dllDestination.AppendNum(KDllNumber);
+ dllDestination+=KDllExt;
+
+ test.Printf(_L("Copy %S to %S\n"), &dllFileName, &dllDestination);
+
+ r=TheFs.MkDirAll(dllDestination);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=pFileMan->Copy(dllFileName, dllDestination);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ r=pFileMan->Attribs(dllDestination, 0, KEntryAttReadOnly, TTime(0) ,0);
+ test(r==KErrNone);
+
+ test.Printf(_L("Creating Dll hash.\n"));
+ CreateFileHash(dllDestination);
+
+ //-- 2. check if the hash exists
+ r=loader.CheckLibraryHash(dllDestination);
+ test(r==KErrNone);
+ test.Printf(_L("Dll hash exists.\n"));
+
+ //-- 2.1 check if the hash exists and valid
+ r=loader.CheckLibraryHash(dllDestination, ETrue);
+ test(r==KErrNone);
+
+ test.Printf(_L("Dll hash exists and valid.\n"));
+
+ //-- 3. corrupt dll
+ r = CorruptFile(dllDestination);
+ test(r==KErrNone);
+
+ //-- 3.1 check that the hash exists, but is incorrect.
+ r=loader.CheckLibraryHash(dllDestination);
+ test(r==KErrNone);
+ test.Printf(_L("Dll hash exists.\n"));
+
+ r=loader.CheckLibraryHash(dllDestination, ETrue);
+ test(r==KErrCorrupt);
+
+ test.Printf(_L("Dll hash exists and INVALID.\n"));
+
+ //-- 4. try to locte hash fo the unexisting dll.
+ r=loader.CheckLibraryHash(_L("Z:\\sys\\bin\\NotExist.dll"));
+ test(r==KErrNotFound);
+
+ loader.Close();
+
+ delete pFileMan;
+}
+
+//-------------------------------------------------------
+
+void ParseCommandArguments()
+//
+//
+//
+ {
+ TBuf<0x100> cmd;
+ User::CommandLine(cmd);
+ TLex lex(cmd);
+ TPtrC token=lex.NextToken();
+ TFileName thisfile=RProcess().FileName();
+ if (token.MatchF(thisfile)==0)
+ {
+ token.Set(lex.NextToken());
+ }
+ test.Printf(_L("CLP=%S"),&token);
+
+ if(token.Length()!=0)
+ {
+ gDriveToTest=token[0];
+ gDriveToTest.UpperCase();
+ }
+ else
+ gDriveToTest='D'; //default to D:
+ }
+
+
+//-------------------------------------------------------
+
+void TestExes()
+{
+ test.Next(_L("Testing Exes presence.\n"));
+
+ TInt r;
+
+ RProcess ap;
+ r=LoadExe(14,ap);
+ test(r==KErrNone);
+ ap.Terminate(0);
+ ap.Close();
+
+ r=LoadExe(15,ap);
+ test(r==KErrNone);
+ ap.Terminate(0);
+ ap.Close();
+}
+
+
+//-------------------------------------------------------
+
+static void CallTestsL(void)
+{
+
+#ifdef __WINS__
+ test.Printf(_L("Not testing on WINS !\n"));
+ return;
+#else
+
+ TestExes();
+ // TestGetCapability();
+ CopyModules(); //copies modules from ROM to disk so they may be modified
+ // TestLoading();
+ // TestLoadLibrary();
+
+
+#ifndef WIN32
+ if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))
+ TestRemovableMediaWithHash();
+
+ // TestSystemBinSubsted();
+ // TestRemovableMedia();
+ TestNonSystemSubsted();
+#endif //WIN32
+ // HashBM();
+
+ TestCheckLibraryHash();
+
+#endif //#ifndef __WINS__
+
+}
+
+//-------------------------------------------------------
+//
+// main
+//
+GLDEF_C TInt E32Main()
+ {
+ ParseCommandArguments(); //need this for drive letter to test
+
+ test.Title();
+ test.Start(_L("Setup\n"));
+ CTrapCleanup* cleanup;
+ cleanup=CTrapCleanup::New();
+ __UHEAP_MARK;
+
+ TBuf<20> sessPath;
+ TInt r=0;
+ r=TheFs.Connect();
+ test(r==KErrNone);
+ r=TheFs.SessionPath(sessPath);
+ test(r==KErrNone);
+
+ TInt drive;
+ RFs::CharToDrive(gDriveToTest, drive);
+ TDriveInfo info;
+ r=TheFs.Drive(info, drive);
+ test(r==KErrNone);
+
+ if((info.iDriveAtt & KDriveAttRemovable) == 0)
+ {
+ test.Printf(_L("Not testing on non-removable media !\n"));
+ }
+ else
+ {//-- testing on removable media
+ TRAP(r,CallTestsL());
+ }
+
+ TheFs.Close();
+ test.End();
+ test.Close();
+
+ __UHEAP_MARKEND;
+ delete cleanup;
+
+ return KErrNone;
+ }
+
+