Reflection

Dynamic API Calls in .NET

2 minute read Published: 15 May, 2015

Using Reflection to call APIs dinamically

Today I’m going to share a way to call APIs without DLLImport. I’ve first saw this years ago at OpenSC.ws as far as I remember and got into the idea. The code was lost since then but I found a copy.

Program.cs

using System;
using System.Reflection;

namespace APICaller
{
class Program
{

```
	public static void Main(string[] args)
	{
		Console.Title = "Dynamic API Caller";
		Console.WriteLine("Press any key to call your API!");
		Console.ReadKey(true);
		
		string className = MethodBase.GetCurrentMethod().DeclaringType.Name; //getting our current class name
		string asmName = Assembly.GetExecutingAssembly().FullName; //getting our current assembly name
		string methodName = MethodBase.GetCurrentMethod().Name; //getting our current method name
		
		//Sample with a simple MessageBox. You can adapt this call to whatever you need
		//(note that you should also adapt the class if needed)
		DynamicAPIs CreateDynamicAPI = new DynamicAPIs("user32.dll",
		                                               "MessageBoxA",
		                                               asmName,
		                                               methodName,
		                                               className,
		                                               typeof(int),
		                                               new object[] {
		                                               	IntPtr.Zero,
		                                               	"Test Message",
		                                               	"Test Title",
		                                               	0
		                                               });			
		
		Console.Write("Press any key to exit . . . ");
		Console.ReadKey(true);
	}
}

```

}

And our mighty class.

A Steganographic .NET Executable

3 minute read Published: 14 Apr, 2015

A simple introduction to steganography with .NET

A while ago, alcopaul suggested a .NET executable that could store a secret message inside. While I did not followed his strict theory, I did wrote a working proof of concept, very basic and dirty but, well, it’s only a POC. Here we go (dirty code, do not judge me):

Our includes for this application.

using System;
using System.Reflection;
using System.IO;
using System.Windows.Forms;
using System.Security.Cryptography;

I’ll now show you the methods I’m using here.

private static byte[] JoinTwoByteArrays(byte[] arrayA, byte[] arrayB)
		{
			byte[] outputBytes = new byte[arrayA.Length + arrayB.Length];
			Buffer.BlockCopy(arrayA, 0, outputBytes, 0, arrayA.Length);
			Buffer.BlockCopy(arrayB, 0, outputBytes, arrayA.Length, arrayB.Length);
			return outputBytes;
		}

private static byte[] encryptdata(byte[] bytearraytoencrypt, string key, string iv)
{
	AesCryptoServiceProvider dataencrypt = new AesCryptoServiceProvider();
	dataencrypt.BlockSize = 128;
	dataencrypt.KeySize = 128;
	dataencrypt.Key = System.Text.Encoding.UTF8.GetBytes(key);
	dataencrypt.IV = System.Text.Encoding.UTF8.GetBytes(iv);
	dataencrypt.Padding = PaddingMode.PKCS7;
	dataencrypt.Mode = CipherMode.CBC;
	ICryptoTransform crypto1 = dataencrypt.CreateEncryptor(dataencrypt.Key, dataencrypt.IV);
	byte[] encrypteddata = crypto1.TransformFinalBlock(bytearraytoencrypt, 0, bytearraytoencrypt.Length);
	crypto1.Dispose();
	return encrypteddata;
	}

private static byte[] decryptdata(byte[] bytearraytodecrypt, string key, string iv)
	{
	AesCryptoServiceProvider keydecrypt = new AesCryptoServiceProvider();
	keydecrypt.BlockSize = 128;
	keydecrypt.KeySize = 128;
	keydecrypt.Key = System.Text.Encoding.UTF8.GetBytes(key);
	keydecrypt.IV = System.Text.Encoding.UTF8.GetBytes(iv);
	keydecrypt.Padding = PaddingMode.PKCS7;
	keydecrypt.Mode = CipherMode.CBC;
	ICryptoTransform crypto1 = keydecrypt.CreateDecryptor(keydecrypt.Key, keydecrypt.IV);
	byte[] returnbytearray = crypto1.TransformFinalBlock(bytearraytodecrypt, 0, bytearraytodecrypt.Length);
	crypto1.Dispose();
	return returnbytearray;
	}

A basic method for joining two byte[] arrays and, of course, a standard AES encrypt/decrypt routine I’ve found somewhere. I could write my own but I was kind of in a hurry so I got this, credits to the creator, whoever you are. You can use your own, code your own, use other cypher, it does not matter, the concept should still work.