Update symbol lists, properly support multiple "actual" DLLs at once

Unlinkable functions no longer result in an immediate crash. Instead,
a warning will be logged and then they will panic when called.

Author: mpfaff

src/root.zig

@@ -5,26 +5,72 @@ const paths = @import("paths.zig");
 
 pub const logger = std.log.scoped(.lib_proxy);
 
-const dll_name = "winhttp";
+const dll_names: []const [:0]const u8 = &.{ "version", "winhttp" };
 
-const iter_proxy_funcs = std.mem.splitScalar(u8, @embedFile("symbols/" ++ dll_name ++ ".txt"), '\n');
+const DllName = blk: {
+    var fields: []const std.builtin.Type.EnumField = &.{};
 
-const ProxyFuncAddrs = blk: {
-    @setEvalBranchQuota(8000);
+    for (dll_names, 0..) |dll_name, i| {
+        fields = fields ++ .{std.builtin.Type.EnumField{
+            .name = dll_name,
+            .value = i,
+        }};
+    }
 
-    var fields: []const std.builtin.Type.StructField = &.{};
+    break :blk @Type(.{ .@"enum" = .{
+        .fields = fields,
+        .decls = &.{},
+    } });
+};
 
-    var funcs = iter_proxy_funcs;
+fn proxyFunctions(comptime dll_name: []const u8) []const []const u8 {
+    var buf: []const []const u8 = &.{};
+
+    var funcs = std.mem.splitScalar(u8, @embedFile("symbols/" ++ dll_name ++ ".txt"), '\n');
     while (funcs.next()) |name| {
+        if (name.len == 0) {
+            continue;
+        }
         if (std.mem.indexOfScalar(u8, name, ' ') != null) {
             @compileError("proxy function name \"" ++ name ++ "\" contains whitespace");
         }
+        buf = buf ++ .{name};
+    }
+
+    return buf;
+}
+
+const DllIncludes = blk: {
+    var fields: []const std.builtin.Type.StructField = &.{};
+
+    for (std.meta.fieldNames(ProxyFuncAddrs)) |func_name| {
+        fields = fields ++ .{std.builtin.Type.StructField{
+            .name = func_name,
+            .type = bool,
+            .default_value_ptr = &false,
+            .is_comptime = false,
+            .alignment = 0,
+        }};
+    }
+
+    break :blk @Type(.{ .@"struct" = .{
+        .layout = .@"packed",
+        .fields = fields,
+        .decls = &.{},
+        .is_tuple = false,
+    } });
+};
+
+const EachDllIncludes = blk: {
+    var fields: []const std.builtin.Type.StructField = &.{};
+
+    for (dll_names) |dll_name| {
         fields = fields ++ .{std.builtin.Type.StructField{
-            .name = @ptrCast(name ++ .{0}),
-            .type = std.os.windows.FARPROC,
-            .default_value_ptr = null,
+            .name = dll_name,
+            .type = DllIncludes,
+            .default_value_ptr = &.{},
             .is_comptime = false,
-            .alignment = @alignOf(std.os.windows.FARPROC),
+            .alignment = 0,
         }};
     }
 
@@ -36,30 +82,91 @@ const ProxyFuncAddrs = blk: {
     } });
 };
 
-var proxy_func_addrs: ProxyFuncAddrs = undefined;
+const each_dll_includes = blk: {
+    @setEvalBranchQuota(8000);
 
-comptime {
+    var includes: EachDllIncludes = &.{};
+
+    for (dll_names) |dll_name| {
+        for (proxyFunctions(dll_name)) |name| {
+            @field(@field(includes, name), dll_name) = true;
+        }
+    }
+
+    break :blk includes;
+};
+
+const ProxyFuncAddrs = blk: {
     @setEvalBranchQuota(8000);
-    var funcs = iter_proxy_funcs;
-    while (funcs.next()) |name| {
+
+    var fields: []const std.builtin.Type.StructField = &.{};
+
+    for (dll_names) |dll_name| {
+        for (proxyFunctions(dll_name)) |name| {
+            const FuncAddr = ?*fn () callconv(.c) void;
+            fields = fields ++ .{std.builtin.Type.StructField{
+                .name = @ptrCast(name ++ .{0}),
+                .type = FuncAddr,
+                .default_value_ptr = @ptrCast(&@as(FuncAddr, null)),
+                .is_comptime = false,
+                .alignment = 0,
+            }};
+        }
+    }
+
+    break :blk @Type(.{ .@"struct" = .{
+        .layout = .auto,
+        .fields = fields,
+        .decls = &.{},
+        .is_tuple = false,
+    } });
+};
+
+var proxy_func_addrs: ProxyFuncAddrs = .{};
+
+fn panicUnlinkedFunction(name: []const u8) noreturn {
+    @branchHint(.cold);
+    std.debug.panic("Attempted to call unlinked function {s}", .{name});
+}
+
+comptime {
+    for (std.meta.fieldNames(ProxyFuncAddrs)) |name| {
         @export(&struct {
             fn f() callconv(.c) void {
-                return @as(*fn () callconv(.c) void, @ptrCast(@field(proxy_func_addrs, name)))();
+                if (@field(proxy_func_addrs, name)) |func| {
+                    return func();
+                } else {
+                    panicUnlinkedFunction(name);
+                }
             }
         }.f, .{ .name = name });
     }
 }
 
-fn panicLocateFunction(path: []const u16, name: []const u8) noreturn {
+fn getDllIncludes(dll_name: DllName) *const DllIncludes {
+    inline for (dll_names) |other_dll_name| {
+        if (@field(DllName, other_dll_name) == dll_name) {
+            return &@field(each_dll_includes, other_dll_name);
+        }
+    }
+    unreachable;
+}
+
+fn logUnlinkableFunction(name: []const u8, path: []const u16) void {
     @branchHint(.cold);
-    std.debug.panic("Failed to locate function {s} in {s}", .{ name, std.unicode.fmtUtf16Le(path) });
+    logger.warn("Failed to locate function {s} in {s}", .{ name, std.unicode.fmtUtf16Le(path) });
 }
 
-fn loadFunctions(dll: std.os.windows.HMODULE, path: []const u16) void {
+fn loadFunctions(dll: std.os.windows.HMODULE, path: []const u16, dll_name: DllName) void {
+    const includes = getDllIncludes(dll_name);
     inline for (comptime std.meta.fieldNames(ProxyFuncAddrs)) |field| {
-        @field(proxy_func_addrs, field) = std.os.windows.kernel32.GetProcAddress(dll, field) orelse {
-            panicLocateFunction(path, field);
-        };
+        if (@field(includes, field)) {
+            if (std.os.windows.kernel32.GetProcAddress(dll, field)) |ptr| {
+                @field(proxy_func_addrs, field) = @ptrCast(ptr);
+            } else {
+                logUnlinkableFunction(field, path);
+            }
+        }
     }
 }
 
@@ -80,18 +187,29 @@ fn empty(comptime T: type) *[0:0]T {
     return @constCast(&[_:0]T{});
 }
 
+fn findDllMatch(module_name: []const u16) ?DllName {
+    if (module_name.len > 4 and eqlIgnoreCase(module_name[module_name.len - 4 ..], ".dll")) {
+        const module_name_stripped = module_name[0 .. module_name.len - 4];
+        inline for (dll_names) |dll_name| {
+            if (eqlIgnoreCase(module_name_stripped, dll_name)) {
+                return @field(DllName, dll_name);
+            }
+        }
+    }
+    return null;
+}
+
 pub fn loadProxy(module: std.os.windows.HMODULE) !void {
     var module_path_buf = paths.ModulePathBuf{};
     const module_path = (try module_path_buf.get(module)).?;
 
     const module_name = paths.getFileName(u16, module_path);
 
-    const proxy_name = dll_name ++ ".dll";
-    if (!eqlIgnoreCase(module_name, proxy_name)) {
-        logger.debug("{s} is not supported for proxying", .{std.unicode.fmtUtf16Le(module_name)});
+    const dll_name = findDllMatch(module_name) orelse {
+        logger.debug("{} is not supported for proxying", .{std.unicode.fmtUtf16Le(module_name)});
         return error.UnsupportedName;
-    }
-    logger.debug("Detected injection as supported proxy. Loading actual.", .{});
+    };
+    logger.debug("Detected injection as supported proxy {}. Loading actual.", .{std.unicode.fmtUtf16Le(module_name)});
 
     // sys_len includes null-terminator
     const sys_len = std.os.windows.kernel32.GetSystemDirectoryW(empty(u16), 0);
@@ -106,11 +224,11 @@ pub fn loadProxy(module: std.os.windows.HMODULE) !void {
     sys_full_path_buf[sys_len + module_name.len] = 0;
     const sys_full_path = sys_full_path_buf[0 .. sys_len + module_name.len :0];
 
-    logger.debug("Looking for actual DLL at {s}", .{std.unicode.fmtUtf16Le(sys_full_path)});
+    logger.debug("Looking for actual DLL at {}", .{std.unicode.fmtUtf16Le(sys_full_path)});
 
     const handle = try std.os.windows.LoadLibraryW(sys_full_path);
 
-    loadFunctions(handle, sys_full_path);
+    loadFunctions(handle, sys_full_path, dll_name);
 }
 
 test {

src/symbols/version.txt

@@ -0,0 +1,17 @@
+GetFileVersionInfoA
+GetFileVersionInfoByHandle
+GetFileVersionInfoExA
+GetFileVersionInfoExW
+GetFileVersionInfoSizeA
+GetFileVersionInfoSizeExA
+GetFileVersionInfoSizeExW
+GetFileVersionInfoSizeW
+GetFileVersionInfoW
+VerFindFileA
+VerFindFileW
+VerInstallFileA
+VerInstallFileW
+VerLanguageNameA
+VerLanguageNameW
+VerQueryValueA
+VerQueryValueW

src/symbols/winhttp.txt

@@ -1,23 +1,7 @@
-GetFileVersionInfoA
-GetFileVersionInfoByHandle
-GetFileVersionInfoExA
-GetFileVersionInfoExW
-GetFileVersionInfoSizeA
-GetFileVersionInfoSizeExA
-GetFileVersionInfoSizeExW
-GetFileVersionInfoSizeW
-GetFileVersionInfoW
-VerFindFileA
-VerFindFileW
-VerInstallFileA
-VerInstallFileW
-VerLanguageNameA
-VerLanguageNameW
-VerQueryValueA
-VerQueryValueW
 Private1
 SvchostPushServiceGlobals
 WinHttpAddRequestHeaders
+WinHttpAddRequestHeadersEx
 WinHttpAutoProxySvcMain
 WinHttpCheckPlatform
 WinHttpCloseHandle
@@ -30,16 +14,25 @@ WinHttpConnectionFreeProxyList
 WinHttpConnectionGetNameList
 WinHttpConnectionGetProxyInfo
 WinHttpConnectionGetProxyList
+WinHttpConnectionOnlyConvert
+WinHttpConnectionOnlyReceive
+WinHttpConnectionOnlySend
 WinHttpConnectionSetPolicyEntries
 WinHttpConnectionSetProxyInfo
 WinHttpConnectionUpdateIfIndexTable
 WinHttpCrackUrl
+WinHttpCreateProxyList
+WinHttpCreateProxyManager
 WinHttpCreateProxyResolver
+WinHttpCreateProxyResult
+WinHttpCreateUiCompatibleProxyString
 WinHttpCreateUrl
 WinHttpDetectAutoProxyConfigUrl
 WinHttpFreeProxyResult
 WinHttpFreeProxyResultEx
 WinHttpFreeProxySettings
+WinHttpFreeProxySettingsEx
+WinHttpFreeQueryConnectionGroupResult
 WinHttpGetDefaultProxyConfiguration
 WinHttpGetIEProxyConfigForCurrentUser
 WinHttpGetProxyForUrl
@@ -48,35 +41,49 @@ WinHttpGetProxyForUrlEx2
 WinHttpGetProxyForUrlHvsi
 WinHttpGetProxyResult
 WinHttpGetProxyResultEx
+WinHttpGetProxySettingsEx
+WinHttpGetProxySettingsResultEx
 WinHttpGetProxySettingsVersion
 WinHttpGetTunnelSocket
 WinHttpOpen
 WinHttpOpenRequest
 WinHttpPacJsWorkerMain
 WinHttpProbeConnectivity
+WinHttpProtocolCompleteUpgrade
+WinHttpProtocolReceive
+WinHttpProtocolSend
 WinHttpQueryAuthSchemes
+WinHttpQueryConnectionGroup
 WinHttpQueryDataAvailable
 WinHttpQueryHeaders
+WinHttpQueryHeadersEx
 WinHttpQueryOption
 WinHttpReadData
+WinHttpReadDataEx
 WinHttpReadProxySettings
 WinHttpReadProxySettingsHvsi
 WinHttpReceiveResponse
+WinHttpRefreshProxySettings
+WinHttpRegisterProxyChangeNotification
 WinHttpResetAutoProxy
+WinHttpResolverGetProxyForUrl
 WinHttpSaveProxyCredentials
 WinHttpSendRequest
 WinHttpSetCredentials
 WinHttpSetDefaultProxyConfiguration
 WinHttpSetOption
+WinHttpSetProxySettingsPerUser
+WinHttpSetSecureLegacyServersAppCompat
 WinHttpSetStatusCallback
 WinHttpSetTimeouts
 WinHttpTimeFromSystemTime
 WinHttpTimeToSystemTime
+WinHttpUnregisterProxyChangeNotification
 WinHttpWebSocketClose
 WinHttpWebSocketCompleteUpgrade
 WinHttpWebSocketQueryCloseStatus
 WinHttpWebSocketReceive
 WinHttpWebSocketSend
 WinHttpWebSocketShutdown
 WinHttpWriteData
-WinHttpWriteProxySettings
+WinHttpWriteProxySettings