mirror of
https://github.com/reactos/wine.git
synced 2024-11-29 22:50:43 +00:00
733 lines
19 KiB
C
733 lines
19 KiB
C
/*
|
|
* IMAGEHLP library
|
|
*
|
|
* Copyright 1998 Patrik Stridvall
|
|
* Copyright 2003 Mike McCormack
|
|
* Copyright 2009 Owen Rudge for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winerror.h"
|
|
#include "winternl.h"
|
|
#include "winnt.h"
|
|
#include "imagehlp.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(imagehlp);
|
|
|
|
/*
|
|
* These functions are partially documented at:
|
|
* http://www.cs.auckland.ac.nz/~pgut001/pubs/authenticode.txt
|
|
*/
|
|
|
|
#define HDR_FAIL -1
|
|
#define HDR_NT32 0
|
|
#define HDR_NT64 1
|
|
|
|
/***********************************************************************
|
|
* IMAGEHLP_GetNTHeaders (INTERNAL)
|
|
*
|
|
* Return the IMAGE_NT_HEADERS for a PE file, after validating magic
|
|
* numbers and distinguishing between 32-bit and 64-bit files.
|
|
*/
|
|
static int IMAGEHLP_GetNTHeaders(HANDLE handle, DWORD *pe_offset, IMAGE_NT_HEADERS32 *nt32, IMAGE_NT_HEADERS64 *nt64)
|
|
{
|
|
IMAGE_DOS_HEADER dos_hdr;
|
|
DWORD count;
|
|
BOOL r;
|
|
|
|
TRACE("handle %p\n", handle);
|
|
|
|
if ((!nt32) || (!nt64))
|
|
return HDR_FAIL;
|
|
|
|
/* read the DOS header */
|
|
count = SetFilePointer(handle, 0, NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return HDR_FAIL;
|
|
|
|
count = 0;
|
|
|
|
r = ReadFile(handle, &dos_hdr, sizeof dos_hdr, &count, NULL);
|
|
|
|
if (!r)
|
|
return HDR_FAIL;
|
|
|
|
if (count != sizeof dos_hdr)
|
|
return HDR_FAIL;
|
|
|
|
/* verify magic number of 'MZ' */
|
|
if (dos_hdr.e_magic != 0x5A4D)
|
|
return HDR_FAIL;
|
|
|
|
if (pe_offset != NULL)
|
|
*pe_offset = dos_hdr.e_lfanew;
|
|
|
|
/* read the PE header */
|
|
count = SetFilePointer(handle, dos_hdr.e_lfanew, NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return HDR_FAIL;
|
|
|
|
count = 0;
|
|
|
|
r = ReadFile(handle, nt32, sizeof(IMAGE_NT_HEADERS32), &count, NULL);
|
|
|
|
if (!r)
|
|
return HDR_FAIL;
|
|
|
|
if (count != sizeof(IMAGE_NT_HEADERS32))
|
|
return HDR_FAIL;
|
|
|
|
/* verify NT signature */
|
|
if (nt32->Signature != IMAGE_NT_SIGNATURE)
|
|
return HDR_FAIL;
|
|
|
|
/* check if we have a 32-bit or 64-bit executable */
|
|
switch (nt32->OptionalHeader.Magic)
|
|
{
|
|
case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
|
|
return HDR_NT32;
|
|
|
|
case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
|
|
/* Re-read as 64-bit */
|
|
|
|
count = SetFilePointer(handle, dos_hdr.e_lfanew, NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return HDR_FAIL;
|
|
|
|
count = 0;
|
|
|
|
r = ReadFile(handle, nt64, sizeof(IMAGE_NT_HEADERS64), &count, NULL);
|
|
|
|
if (!r)
|
|
return HDR_FAIL;
|
|
|
|
if (count != sizeof(IMAGE_NT_HEADERS64))
|
|
return HDR_FAIL;
|
|
|
|
/* verify NT signature */
|
|
if (nt64->Signature != IMAGE_NT_SIGNATURE)
|
|
return HDR_FAIL;
|
|
|
|
return HDR_NT64;
|
|
}
|
|
|
|
return HDR_FAIL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IMAGEHLP_GetSecurityDirOffset (INTERNAL)
|
|
*
|
|
* Read a file's PE header, and return the offset and size of the
|
|
* security directory.
|
|
*/
|
|
static BOOL IMAGEHLP_GetSecurityDirOffset( HANDLE handle,
|
|
DWORD *pdwOfs, DWORD *pdwSize )
|
|
{
|
|
IMAGE_NT_HEADERS32 nt_hdr32;
|
|
IMAGE_NT_HEADERS64 nt_hdr64;
|
|
IMAGE_DATA_DIRECTORY *sd;
|
|
int ret;
|
|
|
|
ret = IMAGEHLP_GetNTHeaders(handle, NULL, &nt_hdr32, &nt_hdr64);
|
|
|
|
if (ret == HDR_NT32)
|
|
sd = &nt_hdr32.OptionalHeader.DataDirectory[IMAGE_FILE_SECURITY_DIRECTORY];
|
|
else if (ret == HDR_NT64)
|
|
sd = &nt_hdr64.OptionalHeader.DataDirectory[IMAGE_FILE_SECURITY_DIRECTORY];
|
|
else
|
|
return FALSE;
|
|
|
|
TRACE("ret = %d size = %x addr = %x\n", ret, sd->Size, sd->VirtualAddress);
|
|
|
|
*pdwSize = sd->Size;
|
|
*pdwOfs = sd->VirtualAddress;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IMAGEHLP_SetSecurityDirOffset (INTERNAL)
|
|
*
|
|
* Read a file's PE header, and update the offset and size of the
|
|
* security directory.
|
|
*/
|
|
static BOOL IMAGEHLP_SetSecurityDirOffset(HANDLE handle,
|
|
DWORD dwOfs, DWORD dwSize)
|
|
{
|
|
IMAGE_NT_HEADERS32 nt_hdr32;
|
|
IMAGE_NT_HEADERS64 nt_hdr64;
|
|
IMAGE_DATA_DIRECTORY *sd;
|
|
int ret, nt_hdr_size = 0;
|
|
DWORD pe_offset;
|
|
void *nt_hdr;
|
|
DWORD count;
|
|
BOOL r;
|
|
|
|
ret = IMAGEHLP_GetNTHeaders(handle, &pe_offset, &nt_hdr32, &nt_hdr64);
|
|
|
|
if (ret == HDR_NT32)
|
|
{
|
|
sd = &nt_hdr32.OptionalHeader.DataDirectory[IMAGE_FILE_SECURITY_DIRECTORY];
|
|
|
|
nt_hdr = &nt_hdr32;
|
|
nt_hdr_size = sizeof(IMAGE_NT_HEADERS32);
|
|
}
|
|
else if (ret == HDR_NT64)
|
|
{
|
|
sd = &nt_hdr64.OptionalHeader.DataDirectory[IMAGE_FILE_SECURITY_DIRECTORY];
|
|
|
|
nt_hdr = &nt_hdr64;
|
|
nt_hdr_size = sizeof(IMAGE_NT_HEADERS64);
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
sd->Size = dwSize;
|
|
sd->VirtualAddress = dwOfs;
|
|
|
|
TRACE("size = %x addr = %x\n", sd->Size, sd->VirtualAddress);
|
|
|
|
/* write the header back again */
|
|
count = SetFilePointer(handle, pe_offset, NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return FALSE;
|
|
|
|
count = 0;
|
|
|
|
r = WriteFile(handle, nt_hdr, nt_hdr_size, &count, NULL);
|
|
|
|
if (!r)
|
|
return FALSE;
|
|
|
|
if (count != nt_hdr_size)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IMAGEHLP_GetCertificateOffset (INTERNAL)
|
|
*
|
|
* Read a file's PE header, and return the offset and size of the
|
|
* security directory.
|
|
*/
|
|
static BOOL IMAGEHLP_GetCertificateOffset( HANDLE handle, DWORD num,
|
|
DWORD *pdwOfs, DWORD *pdwSize )
|
|
{
|
|
DWORD size, count, offset, len, sd_VirtualAddr;
|
|
BOOL r;
|
|
|
|
r = IMAGEHLP_GetSecurityDirOffset( handle, &sd_VirtualAddr, &size );
|
|
if( !r )
|
|
return FALSE;
|
|
|
|
offset = 0;
|
|
/* take the n'th certificate */
|
|
while( 1 )
|
|
{
|
|
/* read the length of the current certificate */
|
|
count = SetFilePointer( handle, sd_VirtualAddr + offset,
|
|
NULL, FILE_BEGIN );
|
|
if( count == INVALID_SET_FILE_POINTER )
|
|
return FALSE;
|
|
r = ReadFile( handle, &len, sizeof len, &count, NULL );
|
|
if( !r )
|
|
return FALSE;
|
|
if( count != sizeof len )
|
|
return FALSE;
|
|
|
|
/* check the certificate is not too big or too small */
|
|
if( len < sizeof len )
|
|
return FALSE;
|
|
if( len > (size-offset) )
|
|
return FALSE;
|
|
if( !num-- )
|
|
break;
|
|
|
|
/* calculate the offset of the next certificate */
|
|
offset += len;
|
|
|
|
/* padded out to the nearest 8-byte boundary */
|
|
if( len % 8 )
|
|
offset += 8 - (len % 8);
|
|
|
|
if( offset >= size )
|
|
return FALSE;
|
|
}
|
|
|
|
*pdwOfs = sd_VirtualAddr + offset;
|
|
*pdwSize = len;
|
|
|
|
TRACE("len = %x addr = %x\n", len, sd_VirtualAddr + offset);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IMAGEHLP_RecalculateChecksum (INTERNAL)
|
|
*
|
|
* Update the NT header checksum for the specified file.
|
|
*/
|
|
static BOOL IMAGEHLP_RecalculateChecksum(HANDLE handle)
|
|
{
|
|
DWORD FileLength, count, HeaderSum, pe_offset, nt_hdr_size;
|
|
IMAGE_NT_HEADERS32 nt_hdr32;
|
|
IMAGE_NT_HEADERS64 nt_hdr64;
|
|
LPVOID BaseAddress;
|
|
HANDLE hMapping;
|
|
DWORD *CheckSum;
|
|
void *nt_hdr;
|
|
int ret;
|
|
BOOL r;
|
|
|
|
TRACE("handle %p\n", handle);
|
|
|
|
ret = IMAGEHLP_GetNTHeaders(handle, &pe_offset, &nt_hdr32, &nt_hdr64);
|
|
|
|
if (ret == HDR_NT32)
|
|
{
|
|
CheckSum = &nt_hdr32.OptionalHeader.CheckSum;
|
|
|
|
nt_hdr = &nt_hdr32;
|
|
nt_hdr_size = sizeof(IMAGE_NT_HEADERS32);
|
|
}
|
|
else if (ret == HDR_NT64)
|
|
{
|
|
CheckSum = &nt_hdr64.OptionalHeader.CheckSum;
|
|
|
|
nt_hdr = &nt_hdr64;
|
|
nt_hdr_size = sizeof(IMAGE_NT_HEADERS64);
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
hMapping = CreateFileMappingW(handle, NULL, PAGE_READONLY, 0, 0, NULL);
|
|
|
|
if (!hMapping)
|
|
return FALSE;
|
|
|
|
BaseAddress = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
|
|
|
|
if (!BaseAddress)
|
|
{
|
|
CloseHandle(hMapping);
|
|
return FALSE;
|
|
}
|
|
|
|
FileLength = GetFileSize(handle, NULL);
|
|
|
|
*CheckSum = 0;
|
|
CheckSumMappedFile(BaseAddress, FileLength, &HeaderSum, CheckSum);
|
|
|
|
UnmapViewOfFile(BaseAddress);
|
|
CloseHandle(hMapping);
|
|
|
|
if (*CheckSum)
|
|
{
|
|
/* write the header back again */
|
|
count = SetFilePointer(handle, pe_offset, NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return FALSE;
|
|
|
|
count = 0;
|
|
|
|
r = WriteFile(handle, nt_hdr, nt_hdr_size, &count, NULL);
|
|
|
|
if (!r)
|
|
return FALSE;
|
|
|
|
if (count != nt_hdr_size)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImageAddCertificate (IMAGEHLP.@)
|
|
*
|
|
* Adds the specified certificate to the security directory of
|
|
* open PE file.
|
|
*/
|
|
|
|
BOOL WINAPI ImageAddCertificate(
|
|
HANDLE FileHandle, LPWIN_CERTIFICATE Certificate, PDWORD Index)
|
|
{
|
|
DWORD size = 0, count = 0, offset = 0, sd_VirtualAddr = 0, index = 0;
|
|
WIN_CERTIFICATE hdr;
|
|
const size_t cert_hdr_size = sizeof hdr - sizeof hdr.bCertificate;
|
|
BOOL r;
|
|
|
|
TRACE("(%p, %p, %p)\n", FileHandle, Certificate, Index);
|
|
|
|
r = IMAGEHLP_GetSecurityDirOffset(FileHandle, &sd_VirtualAddr, &size);
|
|
|
|
/* If we've already got a security directory, find the end of it */
|
|
if ((r) && (sd_VirtualAddr != 0))
|
|
{
|
|
offset = 0;
|
|
index = 0;
|
|
count = 0;
|
|
|
|
/* Check if the security directory is at the end of the file.
|
|
If not, we should probably relocate it. */
|
|
if (GetFileSize(FileHandle, NULL) != sd_VirtualAddr + size)
|
|
{
|
|
FIXME("Security directory already present but not located at EOF, not adding certificate\n");
|
|
|
|
SetLastError(ERROR_NOT_SUPPORTED);
|
|
return FALSE;
|
|
}
|
|
|
|
while (offset < size)
|
|
{
|
|
/* read the length of the current certificate */
|
|
count = SetFilePointer (FileHandle, sd_VirtualAddr + offset,
|
|
NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return FALSE;
|
|
|
|
r = ReadFile(FileHandle, &hdr, cert_hdr_size, &count, NULL);
|
|
|
|
if (!r)
|
|
return FALSE;
|
|
|
|
if (count != cert_hdr_size)
|
|
return FALSE;
|
|
|
|
/* check the certificate is not too big or too small */
|
|
if (hdr.dwLength < cert_hdr_size)
|
|
return FALSE;
|
|
|
|
if (hdr.dwLength > (size-offset))
|
|
return FALSE;
|
|
|
|
/* next certificate */
|
|
offset += hdr.dwLength;
|
|
|
|
/* padded out to the nearest 8-byte boundary */
|
|
if (hdr.dwLength % 8)
|
|
offset += 8 - (hdr.dwLength % 8);
|
|
|
|
index++;
|
|
}
|
|
|
|
count = SetFilePointer (FileHandle, sd_VirtualAddr + offset, NULL, FILE_BEGIN);
|
|
|
|
if (count == INVALID_SET_FILE_POINTER)
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
sd_VirtualAddr = SetFilePointer(FileHandle, 0, NULL, FILE_END);
|
|
|
|
if (sd_VirtualAddr == INVALID_SET_FILE_POINTER)
|
|
return FALSE;
|
|
}
|
|
|
|
/* Write the certificate to the file */
|
|
r = WriteFile(FileHandle, Certificate, Certificate->dwLength, &count, NULL);
|
|
|
|
if (!r)
|
|
return FALSE;
|
|
|
|
/* Pad out if necessary */
|
|
if (Certificate->dwLength % 8)
|
|
{
|
|
char null[8];
|
|
|
|
ZeroMemory(null, 8);
|
|
WriteFile(FileHandle, null, 8 - (Certificate->dwLength % 8), NULL, NULL);
|
|
|
|
size += 8 - (Certificate->dwLength % 8);
|
|
}
|
|
|
|
size += Certificate->dwLength;
|
|
|
|
/* Update the security directory offset and size */
|
|
if (!IMAGEHLP_SetSecurityDirOffset(FileHandle, sd_VirtualAddr, size))
|
|
return FALSE;
|
|
|
|
if (!IMAGEHLP_RecalculateChecksum(FileHandle))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImageEnumerateCertificates (IMAGEHLP.@)
|
|
*/
|
|
BOOL WINAPI ImageEnumerateCertificates(
|
|
HANDLE handle, WORD TypeFilter, PDWORD CertificateCount,
|
|
PDWORD Indices, DWORD IndexCount)
|
|
{
|
|
DWORD size, count, offset, sd_VirtualAddr, index;
|
|
WIN_CERTIFICATE hdr;
|
|
const size_t cert_hdr_size = sizeof hdr - sizeof hdr.bCertificate;
|
|
BOOL r;
|
|
|
|
TRACE("%p %hd %p %p %d\n",
|
|
handle, TypeFilter, CertificateCount, Indices, IndexCount);
|
|
|
|
r = IMAGEHLP_GetSecurityDirOffset( handle, &sd_VirtualAddr, &size );
|
|
if( !r )
|
|
return FALSE;
|
|
|
|
offset = 0;
|
|
index = 0;
|
|
*CertificateCount = 0;
|
|
while( offset < size )
|
|
{
|
|
/* read the length of the current certificate */
|
|
count = SetFilePointer( handle, sd_VirtualAddr + offset,
|
|
NULL, FILE_BEGIN );
|
|
if( count == INVALID_SET_FILE_POINTER )
|
|
return FALSE;
|
|
r = ReadFile( handle, &hdr, cert_hdr_size, &count, NULL );
|
|
if( !r )
|
|
return FALSE;
|
|
if( count != cert_hdr_size )
|
|
return FALSE;
|
|
|
|
TRACE("Size = %08x id = %08hx\n",
|
|
hdr.dwLength, hdr.wCertificateType );
|
|
|
|
/* check the certificate is not too big or too small */
|
|
if( hdr.dwLength < cert_hdr_size )
|
|
return FALSE;
|
|
if( hdr.dwLength > (size-offset) )
|
|
return FALSE;
|
|
|
|
if( (TypeFilter == CERT_SECTION_TYPE_ANY) ||
|
|
(TypeFilter == hdr.wCertificateType) )
|
|
{
|
|
(*CertificateCount)++;
|
|
if(Indices && *CertificateCount <= IndexCount)
|
|
*Indices++ = index;
|
|
}
|
|
|
|
/* next certificate */
|
|
offset += hdr.dwLength;
|
|
|
|
/* padded out to the nearest 8-byte boundary */
|
|
if (hdr.dwLength % 8)
|
|
offset += 8 - (hdr.dwLength % 8);
|
|
|
|
index++;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImageGetCertificateData (IMAGEHLP.@)
|
|
*
|
|
* FIXME: not sure that I'm dealing with the Index the right way
|
|
*/
|
|
BOOL WINAPI ImageGetCertificateData(
|
|
HANDLE handle, DWORD Index,
|
|
LPWIN_CERTIFICATE Certificate, PDWORD RequiredLength)
|
|
{
|
|
DWORD r, offset, ofs, size, count;
|
|
|
|
TRACE("%p %d %p %p\n", handle, Index, Certificate, RequiredLength);
|
|
|
|
if( !RequiredLength)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
if( !IMAGEHLP_GetCertificateOffset( handle, Index, &ofs, &size ) )
|
|
return FALSE;
|
|
|
|
if( *RequiredLength < size )
|
|
{
|
|
*RequiredLength = size;
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
if( !Certificate )
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return FALSE;
|
|
}
|
|
|
|
*RequiredLength = size;
|
|
|
|
offset = SetFilePointer( handle, ofs, NULL, FILE_BEGIN );
|
|
if( offset == INVALID_SET_FILE_POINTER )
|
|
return FALSE;
|
|
|
|
r = ReadFile( handle, Certificate, size, &count, NULL );
|
|
if( !r )
|
|
return FALSE;
|
|
if( count != size )
|
|
return FALSE;
|
|
|
|
TRACE("OK\n");
|
|
SetLastError( NO_ERROR );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImageGetCertificateHeader (IMAGEHLP.@)
|
|
*/
|
|
BOOL WINAPI ImageGetCertificateHeader(
|
|
HANDLE handle, DWORD index, LPWIN_CERTIFICATE pCert)
|
|
{
|
|
DWORD r, offset, ofs, size, count;
|
|
const size_t cert_hdr_size = sizeof *pCert - sizeof pCert->bCertificate;
|
|
|
|
TRACE("%p %d %p\n", handle, index, pCert);
|
|
|
|
if( !IMAGEHLP_GetCertificateOffset( handle, index, &ofs, &size ) )
|
|
return FALSE;
|
|
|
|
if( size < cert_hdr_size )
|
|
return FALSE;
|
|
|
|
offset = SetFilePointer( handle, ofs, NULL, FILE_BEGIN );
|
|
if( offset == INVALID_SET_FILE_POINTER )
|
|
return FALSE;
|
|
|
|
r = ReadFile( handle, pCert, cert_hdr_size, &count, NULL );
|
|
if( !r )
|
|
return FALSE;
|
|
if( count != cert_hdr_size )
|
|
return FALSE;
|
|
|
|
TRACE("OK\n");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImageGetDigestStream (IMAGEHLP.@)
|
|
*/
|
|
BOOL WINAPI ImageGetDigestStream(
|
|
HANDLE FileHandle, DWORD DigestLevel,
|
|
DIGEST_FUNCTION DigestFunction, DIGEST_HANDLE DigestHandle)
|
|
{
|
|
FIXME("(%p, %d, %p, %p): stub\n",
|
|
FileHandle, DigestLevel, DigestFunction, DigestHandle
|
|
);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImageRemoveCertificate (IMAGEHLP.@)
|
|
*/
|
|
BOOL WINAPI ImageRemoveCertificate(HANDLE FileHandle, DWORD Index)
|
|
{
|
|
DWORD size = 0, count = 0, sd_VirtualAddr = 0, offset = 0;
|
|
DWORD data_size = 0, cert_size = 0, cert_size_padded = 0, ret = 0;
|
|
LPVOID cert_data;
|
|
BOOL r;
|
|
|
|
TRACE("(%p, %d)\n", FileHandle, Index);
|
|
|
|
r = ImageEnumerateCertificates(FileHandle, CERT_SECTION_TYPE_ANY, &count, NULL, 0);
|
|
|
|
if ((!r) || (count == 0))
|
|
return FALSE;
|
|
|
|
if ((!IMAGEHLP_GetSecurityDirOffset(FileHandle, &sd_VirtualAddr, &size)) ||
|
|
(!IMAGEHLP_GetCertificateOffset(FileHandle, Index, &offset, &cert_size)))
|
|
return FALSE;
|
|
|
|
/* Ignore any padding we have, too */
|
|
if (cert_size % 8)
|
|
cert_size_padded = cert_size + (8 - (cert_size % 8));
|
|
else
|
|
cert_size_padded = cert_size;
|
|
|
|
data_size = size - (offset - sd_VirtualAddr) - cert_size_padded;
|
|
|
|
if (data_size == 0)
|
|
{
|
|
ret = SetFilePointer(FileHandle, sd_VirtualAddr, NULL, FILE_BEGIN);
|
|
|
|
if (ret == INVALID_SET_FILE_POINTER)
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
cert_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, data_size);
|
|
|
|
if (!cert_data)
|
|
return FALSE;
|
|
|
|
ret = SetFilePointer(FileHandle, offset + cert_size_padded, NULL, FILE_BEGIN);
|
|
|
|
if (ret == INVALID_SET_FILE_POINTER)
|
|
goto error;
|
|
|
|
/* Read any subsequent certificates */
|
|
r = ReadFile(FileHandle, cert_data, data_size, &count, NULL);
|
|
|
|
if ((!r) || (count != data_size))
|
|
goto error;
|
|
|
|
SetFilePointer(FileHandle, offset, NULL, FILE_BEGIN);
|
|
|
|
/* Write them one index back */
|
|
r = WriteFile(FileHandle, cert_data, data_size, &count, NULL);
|
|
|
|
if ((!r) || (count != data_size))
|
|
goto error;
|
|
|
|
HeapFree(GetProcessHeap(), 0, cert_data);
|
|
}
|
|
|
|
/* If security directory is at end of file, trim the file */
|
|
if (GetFileSize(FileHandle, NULL) == sd_VirtualAddr + size)
|
|
SetEndOfFile(FileHandle);
|
|
|
|
if (count == 1)
|
|
r = IMAGEHLP_SetSecurityDirOffset(FileHandle, 0, 0);
|
|
else
|
|
r = IMAGEHLP_SetSecurityDirOffset(FileHandle, sd_VirtualAddr, size - cert_size_padded);
|
|
|
|
if (!r)
|
|
return FALSE;
|
|
|
|
if (!IMAGEHLP_RecalculateChecksum(FileHandle))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
|
|
error:
|
|
HeapFree(GetProcessHeap(), 0, cert_data);
|
|
return FALSE;
|
|
}
|