C++从内存安装加密字体的技术方案咨询

Great question—this is a common pain point when protecting font assets, and there are a couple of reliable ways to avoid writing decrypted fonts to disk entirely. Let’s break down the best approaches:

1. Use GDI+ PrivateFontCollection (Recommended) #

This is the most straightforward and secure method for C++ applications. GDI+'s PrivateFontCollection class lets you load font data directly from memory, with no need to save anything to disk. The font will only be accessible to your application process, keeping it hidden from other programs and users.

Example Code #

#include <gdiplus.h>
#pragma comment(lib, "gdiplus.lib")

int main() {
    // Initialize GDI+
    Gdiplus::GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, nullptr);

    // Step 1: Decrypt your font into a memory buffer (replace with your actual decryption logic)
    BYTE* decryptedFontBuffer = nullptr;
    size_t fontBufferSize = 0;
    // [Your decryption code here: read encrypted font file, decrypt into decryptedFontBuffer]

    // Step 2: Add the in-memory font to a private collection
    Gdiplus::PrivateFontCollection privateFonts;
    privateFonts.AddMemoryFont(decryptedFontBuffer, fontBufferSize);

    // Step 3: Retrieve the font family to use in your app
    Gdiplus::FontFamily* fontFamily = nullptr;
    int numFamilies = 0;
    privateFonts.GetFamilies(1, &fontFamily, &numFamilies);

    if (numFamilies > 0) {
        // Create a font object for drawing text
        Gdiplus::Font* customFont = new Gdiplus::Font(
            fontFamily, 
            16, 
            Gdiplus::FontStyleRegular, 
            Gdiplus::UnitPoint
        );

        // [Use customFont to render text in your application's windows/UI]

        // Clean up resources when done
        delete customFont;
        delete fontFamily;
    }

    // Critical: Keep the decrypted buffer in memory as long as the font is in use!
    // Only free decryptedFontBuffer after you've discarded all font objects

    // Shutdown GDI+
    Gdiplus::GdiplusShutdown(gdiplusToken);
    return 0;
}

Key Notes #

• Memory Persistence: The decrypted font buffer must remain allocated for the entire time you’re using the font. Freeing it early will invalidate the font.
• Process Isolation: The font is private to your app—no other processes can access it, which aligns perfectly with your privacy needs.
• No Admin Rights: You don’t need elevated privileges, and the font won’t persist after your application closes.

2. Memory-Mapped Files (For System-Wide Temporary Access) #

If you absolutely need the font to be available system-wide (e.g., for system components or other trusted apps to use), you can use memory-mapped files to avoid disk writes. Here’s the high-level workflow:

• Create an anonymous memory-mapped file with CreateFileMapping (using INVALID_HANDLE_VALUE).
• Map the file into memory with MapViewOfFile, then write your decrypted font data into the mapped view.
• Use GetMappedFileName to get the internal name of the mapped file, then pass it to AddFontResourceEx with the FR_PRIVATE flag to restrict access.

This method is more complex than PrivateFontCollection and carries a tiny risk of advanced users accessing the mapped memory, but it avoids disk exposure.

Why Avoid AddFontResource Alone? #

The standard AddFontResource function requires a disk file path—there’s no way to feed it in-memory data directly. Writing the font to disk (even temporarily) creates a window where the unencrypted file could be copied or accessed, which defeats your privacy goals.

内容的提问来源于stack exchange，提问作者Hafiz Mubashir Touqeer