Return to Answer

From a technical perspective. Yes, you can do this. It can be accomplished by something called DLL search order hijacking. However this is a pretty rudimentary security vulnerability and is likely patched by most AVs. Alternatively you can simply just monkeypatch a particular (or a set of particular) function live and unload DLL once done (by performing an IAT hook and redirect it to your monkeypatched function). Both would require you to reverse engineer the implementation of said function, however.

From a pragmatic perspective, why would you ever do something like this? If your aim is to reduce the size of your binary, then I'm sorry to be the bearer of bad news but this does exactly nothing because the DLL in question (winAPI DLLs) are in every windows OS. When you ship an executable that depends on a WinAPI DLL, you aren't shipping a copy of the DLL itself. The customer will be using their own version (which should be the same as yours, anyhow) of the WinAPI DLL. This kind of the reason why DLLs exist in the first place, anyways.

Addendum: Reading some of your comments, if your goal is to make your program portable across different OSes, then you are tackling a much bigger issue than simply polyfilling DLLs. For starters, not every OS (and I'm pretty sure most OSes do not) uses the DOS executable format. Your .exe doesn't run on Linux not because of the missing DLLs, but because Linux doesn't even recognise your .exe as a valid executable and have no idea how to run it.

From a technical perspective. Yes, you can do this. It can be accomplished by something called DLL search order hijacking. However this is a pretty rudimentary security vulnerability and is likely patched by most AVs. Alternatively you can simply just monkeypatch a particular (or a set of particular) function live and unload DLL once done (by performing an IAT hook and redirect it to your monkeypatched function). Both would require you to reverse engineer the implementation of said function, however.

From a pragmatic perspective, why would you ever do something like this? If your aim is to reduce the size of your binary, then I'm sorry to be the bearer of bad news but this does exactly nothing because the DLL in question (winAPI DLLs) are in every windows OS. When you ship an executable that depends on a WinAPI DLL, you aren't shipping a copy of the DLL itself. The customer will be using their own version (which should be the same as yours, anyhow) of the WinAPI DLL. This kind of the reason why DLLs exist in the first place, anyways.

Addendum: Reading some of your comments, if your goal is to make your program portable across different OSes, then you are tackling a much bigger issue than simply polyfilling DLLs. For starters, not every OS (and I'm pretty sure most OSes do not) uses the DOS executable format. Your .exe doesn't run on Linux not because of the missing DLLs, but because Linux doesn't even recognise your .exe as a valid executable and have no idea how to run it. Consider using a managed language like Java or Python, they are kind of created for this exact purpose

From a technical perspective. Yes, you can do this. It can be accomplished by something called DLL search order hijacking. However this is a pretty rudimentary security vulnerability and is likely patched by most AVs. Alternatively you can simply just monkeypatch a particular (or a set of particular) function live and unload DLL once done (by performing an IAT hook and redirect it to your monkeypatched function). Both would require you to reverse engineer the implementation of said function, however.

From a pragmatic perspective, why would you ever do something like this? If your aim is to reduce the size of your binary, then I'm sorry to be the bearer of bad news but this does exactly nothing because the DLL in question (winAPI DLLs) are in every windows OS. When you ship an executable that depends on a WinAPI DLL, you aren't shipping a copy of the DLL itself. The customer will be using their own version (which should be the same as yours, anyhow) of the WinAPI DLL. This kind of the reason why DLLs exist in the first place, anyways.

Addendum: Reading some of your comments, if your goal is to make your program portable, then you are tackling a much bigger issue than simply polyfilling DLLs. For starters, not every OS (and I'm pretty sure most OSes) uses the DOS executable format. Your .exe doesn't run on Linux not because of the missing DLLs, but because Linux doesn't even recognise your .exe as a valid executable and have no idea how to run it.

From a technical perspective. Yes, you can do this. It can be accomplished by something called DLL search order hijacking. However this is a pretty rudimentary security vulnerability and is likely patched by most AVs. Alternatively you can simply just monkeypatch a particular (or a set of particular) function live and unload DLL once done (by performing an IAT hook and redirect it to your monkeypatched function). Both would require you to reverse engineer the implementation of said function, however.

From a pragmatic perspective, why would you ever do something like this? If your aim is to reduce the size of your binary, then I'm sorry to be the bearer of bad news but this does exactly nothing because the DLL in question (winAPI DLLs) are in every windows OS. When you ship an executable that depends on a WinAPI DLL, you aren't shipping a copy of the DLL itself. The customer will be using their own version (which should be the same as yours, anyhow) of the WinAPI DLL. This kind of the reason why DLLs exist in the first place, anyways.

Addendum: Reading some of your comments, if your goal is to make your program portable across different OSes, then you are tackling a much bigger issue than simply polyfilling DLLs. For starters, not every OS (and I'm pretty sure most OSes do not) uses the DOS executable format. Your .exe doesn't run on Linux not because of the missing DLLs, but because Linux doesn't even recognise your .exe as a valid executable and have no idea how to run it.

From a technical perspective. Yes, you can do this. It can be accomplished by something called DLL search order hijacking. However this is a pretty rudimentary security vulnerability and is likely patched by most AVs. Alternatively you can simply just monkeypatch a particular (or a set of particular) function live and unload DLL once done (by performing an IAT hook and redirect it to your monkeypatched function). Both would require you to reverse engineer the implementation of said function, however.

From a pragmatic perspective, why would you ever do something like this? If your aim is to reduce the size of your binary, then I'm sorry to be the bearer of bad news but this does exactly nothing because the DLL in question (winAPI DLLs) are in every windows OS. When you ship an executable that depends on a WinAPI DLL, you aren't shipping a copy of the DLL itself. The customer will be using their own version (which should be the same as yours, anyhow) of the WinAPI DLL. This kind of the reason why DLLs exist in the first place, anyways.

From a technical perspective. Yes, you can do this. It can be accomplished by something called DLL search order hijacking. However this is a pretty rudimentary security vulnerability and is likely patched by most AVs. Alternatively you can simply just monkeypatch a particular (or a set of particular) function live and unload DLL once done (by performing an IAT hook and redirect it to your monkeypatched function). Both would require you to reverse engineer the implementation of said function, however.

From a pragmatic perspective, why would you ever do something like this? If your aim is to reduce the size of your binary, then I'm sorry to be the bearer of bad news but this does exactly nothing because the DLL in question (winAPI DLLs) are in every windows OS. When you ship an executable that depends on a WinAPI DLL, you aren't shipping a copy of the DLL itself. The customer will be using their own version (which should be the same as yours, anyhow) of the WinAPI DLL. This kind of the reason why DLLs exist in the first place, anyways.

Addendum: Reading some of your comments, if your goal is to make your program portable, then you are tackling a much bigger issue than simply polyfilling DLLs. For starters, not every OS (and I'm pretty sure most OSes) uses the DOS executable format. Your .exe doesn't run on Linux not because of the missing DLLs, but because Linux doesn't even recognise your .exe as a valid executable and have no idea how to run it.