• Virtual registry editor in BoxedApp Packer
• API for intercepting functions
• Minor improvements

Virtual registry editor in BoxedApp Packer

Formerly, all virtual registry operations were carried out in users’ plugins. If it was required to create even a single virtual registry key, one needed to create a plugin, which would use the BoxedApp SDK functions.

Now BoxedApp Packer contains a full-fledged virtual registry editor. Literally with a couple of mouse clicks you can create the virtual keys you need and specify the parameter values.

[ back to top ]

API for intercepting functions

To create a virtual file system / registry, BoxedApp SDK (this, by the way, is exactly what applications created with BoxedApp Packer use) uses the interception of system functions technique. A number of original ideas have allowed us to create an interception system compatible with any environment, and now the part of SDK that is in charge of the interception has become accessible to developers – SDK users.

Now BoxedApp SDK can be considered as a full-value alternative to Microsoft’s Detours.

Be reminded that BoxedApp SDK supports 32-bit and 64-bit environments and also can be statically linked to applications that use VC++ / Delphi of any versions. And, of course, SDK can be used in any development environment that supports the use of DLL.

A couple of examples in C++ and Delphi that disable creating and opening the file named “1.txt”:

typedef HANDLE (WINAPI *P_CreateFileW)(
	LPCWSTR lpFileName,
	DWORD dwDesiredAccess,
	DWORD dwShareMode,
	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
	DWORD dwCreationDisposition,
	DWORD dwFlagsAndAttributes,
	HANDLE hTemplateFile);
P_CreateFileW g_pCreateFileW;

HANDLE WINAPI My_CreateFileW(
	LPCWSTR lpFileName,
	DWORD dwDesiredAccess,
	DWORD dwShareMode,
	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
	DWORD dwCreationDisposition,
	DWORD dwFlagsAndAttributes,
	HANDLE hTemplateFile)
{
	if (0 == lstrcmpiW(lpFileName, L"1.txt"))
	{
		SetLastError(ERROR_FILE_EXISTS);
		return INVALID_HANDLE_VALUE;
	}
	else
		return g_pCreateFileW(
				lpFileName,
				dwDesiredAccess,
				dwShareMode,
				lpSecurityAttributes,
				dwCreationDisposition,
				dwFlagsAndAttributes,
				hTemplateFile);
}
...
BoxedAppSDK_Init();

PVOID pCreateFileW = GetProcAddress(GetModuleHandle(_T("kernel32.dll")), "CreateFileW");

HANDLE hHook__CreateFileW = BoxedAppSDK_HookFunction(pCreateFileW, &My_CreateFileW, TRUE);

g_pCreateFileW = (P_CreateFileW)BoxedAppSDK_GetOriginalFunction(hHook__CreateFileW);

FILE* f = fopen("1.txt", "r");

// f is NULL
...

BoxedAppSDK_UnhookFunction(hHook__CreateFileW);

Delphi version of the same idea:

type
TCreateFileW = 
   function(lpFileName: PWideChar;
            dwDesiredAccess, dwShareMode: Integer;
            lpSecurityAttributes: PSecurityAttributes;
            dwCreationDisposition, dwFlagsAndAttributes: DWORD;
            hTemplateFile: THandle): THandle; stdcall;

var
   OriginalCreateFileW: TCreateFileW;

function My_CreateFileW(
         lpFileName: PWideChar;
         dwDesiredAccess, dwShareMode: Integer;
         lpSecurityAttributes: PSecurityAttributes;
         dwCreationDisposition, dwFlagsAndAttributes: DWORD;
         hTemplateFile: THandle): THandle; stdcall;
begin
   if 0 = lstrcmpiW(lpFileName, '1.txt') then
   begin
      Result := INVALID_HANDLE_VALUE;
      SetLastError(ERROR_ALREADY_EXISTS);
   end
   else
      Result := 
        OriginalCreateFileW(
           lpFileName, 
           dwDesiredAccess,
           dwShareMode, 
           lpSecurityAttributes, 
           dwCreationDisposition, 
           dwFlagsAndAttributes, 
           hTemplateFile);
end;

var
   pCreateFileW: Pointer;
   hHook__CreateFileW: THandle;

begin
  Application.Initialize;

  BoxedAppSDK_Init;

  pCreateFileW := GetProcAddress(GetModuleHandle('kernel32.dll'), 'CreateFileW');
  hHook__CreateFileW := BoxedAppSDK_HookFunction(pCreateFileW, @My_CreateFileW, TRUE);
  OriginalCreateFileW := BoxedAppSDK_GetOriginalFunction(hHook__CreateFileW);

  // This line produces an exception because we prevent creating / opening '1.txt'
  TFileStream.Create('1.txt', fmCreate or fmOpenRead);

  BoxedAppSDK_UnhookFunction(hHook__CreateFileW);
end.

[ back to top ]

Minor improvements

• Added support for the FILE_FLAG_DELETE_ON_CLOSE flag for virtual files
• Fixed minor problems with launching virtual executable files created with Delphi
• Created a more flexible system for storing virtual files in the memory

[ back to top ]

[ Download demo versions ]

DWORD BoxedAppSDK_ExecuteDotNetApplication(LPCTSTR szPath, LPCTSTR szArgs);

[ Download demo version ]

You can launch .net applications from a virtual location (from a real file too, of course). One customer needed to launch FxCop from a memory. We’ve fixed a issue related with FxCop and… and we decided to provide a special function that runs a .net application within current process, BoxedAppSDK_ExecuteDotNetApplication.

Here a simple example of how to launch FxCop from a virtual location in C++:

   BoxedAppSDK_Init();

   HANDLE
   hFile = 
   BoxedAppSDK_CreateVirtualFile( 
      _T("Z:\\FxCop\\FxCop.exe"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_ALWAYS, 
      0, 
      NULL 
   );
#define DEF_COPY(name) CopyFileA("C:\\Program Files\\Microsoft FxCop 1.36\\" #name ,\
"Z:\\FxCop\\" #name , FALSE);
   DEF_COPY(CustomDictionary.xml);
   DEF_COPY(FxCop.exe);
   DEF_COPY(FxCop.exe.config);
   DEF_COPY(FxCopCmd.exe);
   DEF_COPY(FxCopCmd.exe.config);
   DEF_COPY(FxCopCommon.dll);
   DEF_COPY(FxCopSdk.dll);
   DEF_COPY(FxCopUI.dll);
   DEF_COPY(Microsoft.Cci.dll);
   DEF_COPY(MSSp3en.lex);
   DEF_COPY(MSSp3ena.lex);
   DEF_COPY(MSSpell3.dll);

   hFile = 
   BoxedAppSDK_CreateVirtualFile( 
      _T("Z:\\FxCop\\Engines\\IntrospectionAnalysisEngine.dll"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_ALWAYS, 
      0, 
      NULL 
   );
#define DEF_COPY(name) \ 
CopyFileA("C:\\Program Files\\Microsoft FxCop 1.36\\Engines\\" #name ,\
 "Z:\\FxCop\\Engines\\" #name , FALSE);
   DEF_COPY(IntrospectionAnalysisEngine.dll);
   DEF_COPY(IntrospectionForms.dll);

   hFile = 
   BoxedAppSDK_CreateVirtualFile( 
      _T("Z:\\FxCop\\Repository\\system32.bin"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_ALWAYS, 
      0, 
      NULL 
   );
#define DEF_COPY(name) \
CopyFileA("C:\\Program Files\\Microsoft FxCop 1.36\\Repository\\" #name ,\
 "Z:\\FxCop\\Repository\\" #name , FALSE);
   DEF_COPY(system32.bin);

   hFile = 
   BoxedAppSDK_CreateVirtualFile( 
      _T("Z:\\FxCop\\Repository\\Compatibility\\Desktop2.0.xml"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_ALWAYS, 
      0, 
      NULL 
   );
#define DEF_COPY(name) \
CopyFileA("C:\\Program Files\\Microsoft FxCop 1.36\\Repository\\Compatibility\\" #name ,\
 "Z:\\FxCop\\Repository\\Compatibility\\" #name , FALSE);
   DEF_COPY(Desktop2.0.xml);
   DEF_COPY(Desktop2.0SP1.xml);
   DEF_COPY(Desktop2.0SP2.xml);
   DEF_COPY(Desktop3.0.xml);
   DEF_COPY(Desktop3.0SP1.xml);
   DEF_COPY(Desktop3.0SP2.xml);
   DEF_COPY(Desktop3.5.xml);
   DEF_COPY(Desktop3.5SP1.xml);

   hFile = 
   BoxedAppSDK_CreateVirtualFile( 
      _T("Z:\\FxCop\\Rules\\DesignRules.dll"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_ALWAYS, 
      0, 
      NULL 
   );
#define DEF_COPY(name) \
CopyFileA("C:\\Program Files\\Microsoft FxCop 1.36\\Rules\\" #name , "Z:\\FxCop\\Rules\\" #name , FALSE);
   DEF_COPY(DesignRules.dll);
   DEF_COPY(GlobalizationRules.dll);
   DEF_COPY(InteroperabilityRules.dll);
   DEF_COPY(MobilityRules.dll);
   DEF_COPY(NamingRules.dll);
   DEF_COPY(PerformanceRules.dll);
   DEF_COPY(PortabilityRules.dll);
   DEF_COPY(SecurityRules.dll);
   DEF_COPY(UsageRules.dll);

   hFile = 
   BoxedAppSDK_CreateVirtualFile( 
      _T("Z:\\FxCop\\Xml\\CodeAnalysisReport.xsl"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_ALWAYS, 
      0, 
      NULL 
   );
#define DEF_COPY(name) \
CopyFileA("C:\\Program Files\\Microsoft FxCop 1.36\\Xml\\" #name , "Z:\\FxCop\\Xml\\" #name , FALSE);
   DEF_COPY(CodeAnalysisReport.xsl);
   DEF_COPY(FxCopReport.xsd);
   DEF_COPY(FxCopReport.xsl);
   DEF_COPY(FxCopReportExcludes.xsl);
   DEF_COPY(FxCopRichConsoleOutput.xsl);
   DEF_COPY(VSConsoleOutput.xsl);

BoxedAppSDK_ExecuteDotNetApplication(_T("Z:\\FxCop\\FxCopCmd.exe"), _T("/o:out.txt /p:FxCopProject.FxCop"));

[ Download demo version ]

[FIXED] ShellExecute doesn’t run virtual EXE under Windows 7
[FIXED] ActiveX registering in a virtual registry may not work properly under Windows 7

A small fix for all Windows:

[FIXED] Launching a lot of child processes cause memory and handles leak

New feature of the BoxedApp Packer:

[NEW] Environment variables are supported in a virtual path.

[ Download demo version ]

• launching a virtual file-based process
• shared virtual file system for several processes

Launching a virtual file-based process

Briefly, having created a virtual file with an embedded exe, you can launch a process upon that file:

BoxedAppSDK_Init();

HMODULE hModule = GetModuleHandle(NULL);
HRSRC hResInfo = FindResource(hModule, _T("BIN1"), _T("BIN"));
HGLOBAL hResData = LoadResource(hModule, hResInfo);
LPVOID lpData = LockResource(hResData);
DWORD dwSize = SizeofResource(hModule, hResInfo);

HANDLE hFile = 
   BoxedAppSDK_CreateVirtualFile(
      _T("app1.exe"), 
      GENERIC_WRITE, 
      FILE_SHARE_READ, 
      NULL, 
      CREATE_NEW, 
      0, 
      NULL);

DWORD temp;
WriteFile(hFile, lpData, dwSize, &temp, NULL);

CloseHandle(hFile);

ShellExecute(NULL, NULL, _T("app1.exe"), NULL, NULL, SW_SHOW);

Shared virtual file system for several processes

Prior to this, BoxedApp SDK was limited by a single process; however, we have received numerous requests, the summarized idea of which was to allow third-party applications to access the virtual files created in the original process.

We have improved BoxedApp, by having added the BoxedAppSDK_AttachToProcess function, which embeds BoxedApp in the process. Once has been embedded, the process can see all virtual files, which have been or are being created in the main process. It can modify them, etc. In other words, the both processes have the full access to the shared virtual file system. BoxedAppSDK_AttachToProcess can be called for several processes at once, and all of them would have the same file system.

Besides that, we have added the DEF_BOXEDAPPSDK_OPTION__EMBED_BOXEDAPP_IN_CHILD_PROCESSES option, which specifies whether or not BoxedApp is to be embedded in each child process (by default this option is disabled) created in the application:

// yes, embed in child processes
BoxedAppSDK_EnableOption(DEF_BOXEDAPPSDK_OPTION__EMBED_BOXEDAPP_IN_CHILD_PROCESSES, TRUE);
...
// no, do not embed in child processes
BoxedAppSDK_EnableOption(DEF_BOXEDAPPSDK_OPTION__EMBED_BOXEDAPP_IN_CHILD_PROCESSES, FALSE);

[ Download the DEMO versions ]