code-scan starred Conari

🧬 Conari engine represents powerful platform for work with unmanaged memory, pe-modules, related PInvoke features, and more for: Libraries, Executable Modules, enjoying of the unmanaged native C/C++ in .NET world, and other raw binary data. Even accessing to complex types like structures without their declaration at all.

1:[ Quick start ] 2:[ Basic examples for C++ and C# ] 3:[ Complex types and Strings ] -> { Wiki }

Why Conari ?

It was designed to be loyal to your needs on the fly.

🔍 Easy to start:

using(var l = new ConariL("...")) {
    // ...
}

🚀 Awesome speed:

Optional caching of 0x29 opcodes (Calli) and more.

test of regXwild's algorithms [340x10000 Unicode]	+icase [x32]	+icase [x64]	`
regXwild native C++ `EXT` algorithm	~50ms	~26ms	`<<`
regexp-c++11(regex_search)	~59309ms	~53334ms
regexp-c++11(regex_match with endings .*)	~59503ms	~53817ms
.NET Regex engine [Compiled]	~38310ms	~37242ms
.NET Regex engine	~31565ms	~30975ms
regXwild via Conari v1.3 (Lambda) - `EXT`	~54ms	~35ms	`<<`
regXwild via Conari v1.3 (DLR) - `EXT`	~214ms	~226ms

🔨 Its amazing DLR features:

using(dynamic l = new ConariX("..."))
{
    // just everything is yours ~
    l.curl_easy_setopt(curl, 10002, "http://example.com");
}

🔧 Raw accessibility to any binary data in unmanaged memory:

ptr.Native().align<int>(2, "x", "y")
            .t<IntPtr>("data")
            .Raw;

🏄 Most powerful PInvoke and even most convenient use of WinAPI. Our recipe is simple: Just use it!

dynamic user32 = new User32();

    user32.ShowWindow(0x000A0A28, 3);
    user32.MessageBoxA(0, "Conari in action", "Hello!", 0);

dynamic kernel32 = new Kernel32();

    kernel32.GetModuleHandleA<IntPtr>("libcurl-x64");
    kernel32.GetModuleHandleW<IntPtr>((WCharPtr)ustr);

Important note: Conari does not provide anything from above. It will just generate and adapt everything at runtime. Specially for you!

🔖 Modern .NET Core

Conari is ready for .NET Core starting from 1.4.

But we have even more, again. Conari also provides support for .NET Standard 2.0 layer which does not cover unmanaged EmitCalli due to missed implementation for System.Private.CoreLib.

🍰 Open and Free:

Conari is available for everyone from 2016 🎉 Open Source project; MIT License, Yes! Enjoy!

🗸 License

The MIT License (MIT)

Copyright (c) 2016-2020  Denis Kuzmin < [email protected] > GitHub/3F

[ ☕ Donate ]

Conari contributors: https://github.com/3F/Conari/graphs/contributors

We're waiting for your awesome contributions!

Take a look closer

Dynamic features (DLR, fully automatic way) when using of unmanaged code:

var ptr     = d.test<IntPtr>(); //lambda ~ bind<Func<IntPtr>>("test")();
var codec   = d.avcodec_find_encoder<IntPtr>(AV_CODEC_ID_MP2); //lambda ~ bind<Func<ulong, IntPtr>>("avcodec_find_encoder")(AV_CODEC_ID_MP2);
              d.push(); //lambda ~ bind<Action>("push")();
              d.create<int>(ref cid, out data); //lambda ~ bind<MyFunc<Guid, object>>("create")(ref cid, out data);

It does not require the any configuration from you, because Conari will do it automatically. Works perfectly for most popular libraries like: Lua, 7-zip, FFmpeg, ...

Custom Lambda expressions (semi-automatic way) when using of unmanaged code:

using(var l = new ConariL("Library.dll"))
{
    l.bind<Action<int, int>>("call")(2, 1); 
    double num = l.bind<Func<IntPtr, int, double>>("tonumber")(L, 4);
}

This also does not require the creation of any additional delegates. Just use bind<> methods with additional types and have fun!

// you already may invoke it immediately as above:
l.bind<Action<int, string>>("set")(-1, "Hello from Conari !");

// or later:
var set = l.bind<Action<int, string>>("set");
...
set(-1, "Hello from Conari !");

Lazy loading:

using(var l = new ConariL(
                    new Config("Library.dll") {
                        LazyLoading = true
                    }))
{
    ...
}

Native C/C++ structures without declaration [?]:

// IMAGE_FILE_HEADER: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680313.aspx
dynamic ifh = NativeData
                ._(data)
                .t<WORD, WORD>(null, "NumberOfSections")
                .align<DWORD>(3)
                .t<WORD, WORD>("SizeOfOptionalHeader")
                .Raw.Type;
                
if(ifh.SizeOfOptionalHeader == 0xE0) { // IMAGE_OPTIONAL_HEADER32
    ... 
}

// IMAGE_DATA_DIRECTORY: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680305.aspx
dynamic idd = (new NativeData(data))
                    .t<DWORD>("VirtualAddress") // idd.VirtualAddress
                    .t<DWORD>("Size")           // idd.Size
                    .Raw.Type;

IntPtr ptr ...
Raw mt = ptr.Native()
                .align<int>(2, "a", "b")
                .t<IntPtr>("name")
                .Raw;
            
-     {byte[0x0000000c]} byte[]
        [0]    0x05    byte --
        [1]    0x00    byte   |
        [2]    0x00    byte   |
        [3]    0x00    byte --^ a = 5
        [4]    0x07    byte --
        [5]    0x00    byte   |
        [6]    0x00    byte   |
        [7]    0x00    byte --^ b = 7
        [8]    0x20    byte --
        [9]    0x78    byte   |_ pointer to allocated string: (CharPtr)name
        [10]   0xf0    byte   |
        [11]   0x56    byte --
...

Calling Convention & Name-Decoration [?]:

using(var l = new ConariL("Library.dll", CallingConvention.StdCall))
{
    //...
    l.Mangling = true; // _get_SevenStdCall@0 <-> get_SevenStdCall
    l.Convention = CallingConvention.Cdecl;
}

Exported Variables & Raw access [?]:

// v1.3+
l.ExVar.DLR.ADDR_SPEC // 0x00001CE8
l.ExVar.get<UInt32>("ADDR_SPEC"); // 0x00001CE8
l.ExVar.getField(typeof(UInt32).NativeSize(), "ADDR_SPEC"); // Native.Core.Field via raw size
l.Svc.native("lpProcName"); // Raw access via NativeData & Native.Core !
//v1.0+: Use Provider or ConariL frontend via your custom wrapper.

Aliases for exported-functions and variables [?]:

// v1.3+
l.Aliases["Flag"] = l.Aliases["getFlag"] = l.Aliases["xFunc"]; //Flag() -> getFlag() -> xFunc()->...
// ...
l.DLR.getFlag<bool>();

Additional types:

BSTR, CharPtr, WCharPtr, float_t, int_t, ptrdiff_t, size_t, uint_t
UnmanagedString - allocation of the new unmanaged strings.
...

size_t len;
CharPtr name = c.bind<FuncOut3<int, size_t, IntPtr>>("to")(1, out len);
string myName += name; // (IntPtr)name; .Raw; .Ansi; .Utf8; ...

Events:

l.ConventionChanged += (object sender, DataArgs<CallingConvention> e) =>
{
    DLR = newDLR(e.Data);
    LSender.Send(sender, $"DLR has been updated with new CallingConvention: {e.Data}", Message.Level.Info);
};

l.BeforeUnload += (object sender, DataArgs<Link> e) =>
{
    // Do not forget to do something before unloading a library
};

...

and more !

Examples

List of real usage via Conari engine

Sample for DLR

How about to use regXwild (Fast and powerful wildcards on native unmanaged C++) in your C# code ? It's easy:

using(var l = new ConariL("regXwild.dll")) {
...
    if(l.DLR.searchEssC<bool>((WCharPtr)data, (WCharPtr)filter, false)) {
        // ...
    }
}

yes, you don't need to do anything else! Conari will prepare all required operations and binding with native method instead of you:

REGXWILD_API bool searchEssC(const TCHAR* data, const TCHAR* filter, bool ignoreCase);

have fun!

How to get Conari

NuGet:
GetNuTool: msbuild gnt.core /p:ngpackages="Conari" or gnt /p:ngpackages="Conari"
GitHub Releases [ latest ]
CI builds: CI /artifacts ( old CI ) or find 🎲 CI build on GitHub Releases page.