Thoughts and Musings

The One Thing Nobody Tells You About WiFi Hotspots on Arch Linux

mockingspectre — Thu, 16 Apr 2026 00:00:00 +0000

I spent longer than I'd like to admit trying to get a simple WiFi hotspot running on Arch. Not because it's hard — it genuinely isn't — but because of one missing piece that the NetworkManager documentation buries so deep you'd think it was classified.</p>

For context: I'm running a minimal Arch Linux install with KDE Plasma. No bloat, no extras, just what I explicitly put there. Which, as it turns out, is exactly why this bit me.</p>

Here's the whole story, and more importantly, the fix.</p>

It starts innocently enough</h2>

You fire up nmcli</code>, throw together what looks like a perfectly reasonable hotspot command, and get slapped with this:</p>

Error: Connection activation failed: IP configuration could not be reserved (no available address, timeout, etc.)</span></span></code></pre>
Vague. Unhelpful. The kind of error message that was clearly written by someone who never had to debug it.</p>
Your first instinct is probably to check if your WiFi card even supports AP mode — reasonable. Mine does. Maybe NetworkManager picked the wrong interface — also reasonable, so you specify ifname wlp61s0</code> explicitly. Still fails. You check for a conflicting dnsmasq</code> service. It doesn't even exist on the system.</p>
At this point the error message has told you nothing useful, and you're running out of obvious things to blame.</p>
The actual culprit</h2>
Dig into the NetworkManager journal and you'll find the real error hiding two lines below the surface:</p>
device (wlp61s0): ip:shared4: could not start dnsmasq: Could not find "dnsmasq" binary</span></span></code></pre>
There it is. NetworkManager's hotspot mode uses dnsmasq</code> internally to hand out IP addresses to devices that connect to your hotspot. It doesn't use the system dnsmasq</code> service — it manages its own instance entirely in the background. But it does need the binary to actually exist on your machine.</p>
On a minimal Arch install, it doesn't come pre-installed — and if you're not pulling in a full desktop environment with all its recommended packages, nothing drags it in for you either. So the whole thing silently falls apart at the IP configuration stage, and you get that useless generic error instead of "hey, install dnsmasq."</p>
The fix is one line:</p>
sudo</span> pacman -S dnsmasq</span></span></code></pre>
Don't enable it, don't start it. Just having it on the system is enough. NetworkManager will find it and handle the rest.</p>
Getting internet to actually work</h2>
Once the hotspot is up, you'll notice connected devices get an IP but no internet. The hotspot being active and internet being shared are two separate things — your machine needs to be explicitly told to forward traffic between its WiFi and ethernet interfaces.</p>
First, tell the kernel it's allowed to forward packets at all:</p>
sudo</span> sysctl -w net.ipv4.ip_forward=</span>1</span></span></code></pre>
Then set up NAT so traffic from WiFi clients gets routed out through your ethernet connection and back:</p>
sudo</span> iptables -t nat -A POSTROUTING -o enp0s31f6 -j MASQUERADE</span></span>
sudo</span> iptables -A FORWARD -i wlp61s0 -o enp0s31f6 -j ACCEPT</span></span>
sudo</span> iptables -A FORWARD -i enp0s31f6 -o wlp61s0 -m state --state RELATED,ESTABLISHED -j ACCEPT</span></span></code></pre>
Swap out enp0s31f6</code> and wlp61s0</code> for whatever your ethernet and WiFi interfaces are actually named. After that, clients connecting to your hotspot will have full internet access.</p>
These settings don't survive a reboot, so if you want them permanent, save them:</p>
echo</span> "net.ipv4.ip_forward=1"</span> |</span> sudo</span> tee /etc/sysctl.d/99-ipforward.conf</span></span>
sudo</span> iptables-save</span> |</span> sudo</span> tee /etc/iptables/iptables.rules</span></span>
sudo</span> systemctl enable iptables</span></span></code></pre>The short version</h2>
If your NetworkManager hotspot is failing on Arch, install dnsmasq</code>. That's almost certainly it. The error message won't tell you that, the hotspot command won't tell you that, but the journal will — and now so does this article.</p>
Everything else is just routing.</p>



From C to Machine Code: What Actually Runs
mockingspectre — Wed, 08 Apr 2026 00:00:00 +0000

    
    </iframe>
</div>
Before diving into how to break a program, we need to understand what the computer is actually executing. When you write a C program, the processor doesn't understand a single line of it. The C language exists for our</em> benefit, allowing us to write logic without having to manually shuffle bits around in the processor.</p>
To bridge this gap, we use a compiler (like GCC</code>), which translates our human-readable C code into machine code—raw binary instructions. Assembly language is simply the human-readable representation of that machine code.</p>
Because we usually don't have the original C source code when analyzing malware or playing a CTF, we are forced to read the assembly. (Though tools like Ghidra can try to decompile assembly back into C-like pseudocode to save us from staring at assembly instructions all day).</p>
Let's look at what a basic printf("Hello World!");</code> program actually turns into.</p>
#include</span> <stdio.h></span></span>
</span>
int</span> main</span>(){</span>  </span></span>
 printf</span>(</span>"hello world</span>\n</span>"</span>);</span>  </span></span>
 return</span> 0</span>;</span>  </span></span>
}</span>  </span></span></code></pre>
We will compile the  hello world C program, then  dump the assembly in Intel syntax(it defaults to AT&T syntax, a cancer).</p>
gcc</span> -o hello hello.c</span> &&</span> objdump</span> -d -M intel hello</span> |</span> grep</span> -A</span> 15</span> "**<main>:**"</span>  </span></span></code></pre>

0000000000001139</span> <main>:  </span></span>
    1139</span>:       </span>55</span>                      push</span>   rbp</span>  </span></span>
    113a</span>:</span>       48 89</span> e5                </span>mov</span>    rbp</span>,</span>rsp</span>  </span></span>
    113d</span>:       </span>48 8d 05</span> c0 0e </span>00 00</span>    lea</span>    rax</span>,[</span>rip</span>+</span>0xec0</span>]       </span> # 2004 <_IO_stdin_used+0x4>  </span></span>
    1144</span>:       </span>48 89</span> c7                </span>mov</span>    rdi</span>,</span>rax</span>  </span></span>
    1147</span>:       e8 e4 fe ff ff          </span>call</span>   1030</span> <puts@plt>  </span></span>
    114c</span>:</span>       b8 </span>00 00 00 00</span>          mov</span>    eax</span>,</span>0x0</span>  </span></span>
    1151</span>:       </span>5d</span>                      pop</span>    rbp</span>  </span></span>
    1152</span>:       c3                      </span>ret</span></span>
</span>
Disassembly of section </span>.</span>fini</span>:</span></span>
</span>
0000000000001154</span> <_fini>:  </span></span>
    1154</span>:       </span>48 83</span> ec </span>08</span>             sub</span>    rsp</span>,</span>0x8</span>  </span></span>
    1158</span>:       </span>48 83</span> c4 </span>08</span>             add</span>    rsp</span>,</span>0x8</span>  </span></span>
    115c</span>:</span>       c3                      </span>ret</span></span>
</span></code></pre>
Notice how different this looks from C. The processor executes different instruction sets depending on its architecture. The two most common architectures you will encounter  are 32-bit (x86) and 64-bit (x86_64 or just  x64/AMD64/Intel 64).</p>
The Processor's Workbench: Registers</strong></h2>
To process data rapidly, the CPU doesn't want to constantly reach all the way out to your system's RAM. Instead, it uses registers—extremely fast, temporary storage buckets located directly on the processor.</p>
Here are the critical x64 registers you need to know:</p>

rip</code> (Instruction Pointer):</strong> The most important register for exploitation. It points to the exact memory address of the next</em> instruction the CPU is supposed to execute.</li>
rsp</code> (Stack Pointer):</strong> Points to the very top of your current stack frame.</li>
rbp</code> (Base Pointer):</strong> Points to the bottom of your current stack frame.</li>
</ul>
General Purpose Registers & Calling Conventions</strong></h3>
There are also general-purpose registers (rax</code>, rbx</code>, rcx</code>, rdx</code>, rsi</code>, rdi</code>, and r8</code> through r15</code>). While they can be used for general math and data storage, they have strict roles when functions are called.</p>
In x64 Linux, when a function is called, the arguments are passed directly into registers in this specific order:</p>

rdi</code> (First argument)</li>
rsi</code> (Second argument)</li>
rdx</code> (Third argument)</li>
rcx</code> (Fourth argument)</li>
r8</code> (Fifth argument)</li>
r9</code> (Sixth argument)</li>
</ol>

  
    Note</span>
  </div>
  
    In older x86 32-bit binaries, arguments aren't passed in registers at all; they are pushed onto the stack. When a function finishes and returns a value, that return value is almost always placed in the rax</code></strong> register (or eax</code> in 32-bit).</p>

  </div>
</aside>
Register Sizes and "Words"</strong></h3>
Registers have different sizes depending on the architecture, and you can reference smaller chunks of a larger register. In binary exploitation, you'll frequently see data referred to by size:</p>
Word:</strong> 2 bytes</p>
Dword (Double Word):</strong> 4 bytes</p>
Qword (Quad Word):</strong> 8 bytes</p>
Here is how x64 registers break down into smaller accessible chunks:</p>
8-Byte (Qword)[64 bit]</th> Lower 4-Bytes (Dword)[lower 32 bits]</th> Lower 2-Bytes (Word)[lower 16 bits]</th> Lower 1-Byte[lower 8 bits]</th></tr></thead>

rax</td> eax</td> ax</td> al</td></tr>
rbx</td> ebx</td> bx</td> bl</td></tr>
rcx</td> ecx</td> cx</td> cl</td></tr>
rdx</td> edx</td> dx</td> dl</td></tr>
rdi</td> edi</td> di</td> dil</td></tr>
rsi</td> edi</td> si</td> sil</td></tr>
rsp</td> esp</td> sp</td> spl</td></tr>
rbp</td> ebp</td> bp</td> bpl</td></tr>
rip</td> eip</td> -</td> -</td></tr>
r8</td> r8d</td> r8w</td> r8b</td></tr>
r9</td> r9d</td> r9w</td> r9b</td></tr>
r10</td> r10d</td> r10w</td> r10b</td></tr>
r11</td> r11d</td> r11w</td> r11b</td></tr>
r12</td> r12d</td> r12w</td> r12b</td></tr>
r13</td> r13d</td> r13w</td> r13b</td></tr>
r14</td> r14d</td> r14w</td> r14b</td></tr>
r15</td> r15d</td> r15w</td> r15b</td></tr>
</tbody></table>


If you are dealing with a 32-bit (x86) binary, the 8-byte 'R' registers don't exist. The largest buckets you have are the 4-byte 'E' registers (`eax`, `ebp`, etc.).</p>
The Stack</strong></h2>
The stack is a segment of memory heavily used during execution. It's primarily used to store local variables, keep track of function calls, and manage control flow. It operates as a LIFO (Last-In, First-Out) structure—meaning you can only add (push) to the top of it, and remove (pop) from the top of it.</p>
The boundaries of the current stack space are tracked by rbp</code> (the base) and rsp</code> (the top). When you declare a local variable in C, like int x = 5;</code>, the program allocates space for it on the stack.</p>
Consider stack.c</p>
</span>
#include</span><stdio.h></span></span>
</span>
int</span> main</span>() {</span></span>
</span>
  int</span> x </span>=</span> 5</span>;</span></span>
</span>
  puts</span>(</span>"hi"</span>);</span></span>
</span>
}</span></span>
</span></code></pre>
Compile this with the command:</p>
gcc</span> -o stack stack.c</span> &&</span> objdump</span> -d -M intel stack</span> |</span> grep</span> -A</span> 15</span> "<main>:"</span></span></code></pre>0000000000001139</span> <main>:</span></span>
</span>
    1139</span>:       </span>55</span>                      push</span>   rbp</span></span>
</span>
    113a</span>:</span>       48 89</span> e5                </span>mov</span>    rbp</span>,</span>rsp</span></span>
</span>
    113d</span>:       </span>48 83</span> ec </span>10</span>             sub</span>    rsp</span>,</span>0x10</span></span>
</span>
    1141</span>:       c7 </span>45</span> fc </span>05 00 00 00</span>    mov    DWORD</span> PTR [</span>rbp</span>-</span>0x4</span>],</span>0x5</span></span>
</span>
    1148</span>:       </span>48 8d 05</span> b5 0e </span>00 00</span>    lea</span>    rax</span>,[</span>rip</span>+</span>0xeb5</span>]       </span> # 2004 <_IO_stdin_used+0x4></span></span>
</span>
    114f</span>:</span>       48 89</span> c7                </span>mov</span>    rdi</span>,</span>rax</span></span>
</span>
    1152</span>:       e8 d9 fe ff ff          </span>call</span>   1030</span> <puts@plt></span></span>
</span>
    1157</span>:       b8 </span>00 00 00 00</span>          mov</span>    eax</span>,</span>0x0</span></span>
</span>
    115c</span>:</span>       c9                      </span>leave</span></span>
</span>
    115d</span>:       c3                      </span>ret</span></span>
</span>
Disassembly of section </span>.</span>fini</span>:</span></span>
</span>
0000000000001160</span> <_fini>:</span></span>
</span>
    1160</span>:       </span>48 83</span> ec </span>08</span>             sub</span>    rsp</span>,</span>0x8</span></span>
</span></code></pre>

In your output, you'll see an instruction moving the value 0x5</code> into a memory location relative to the base pointer, usually something like [rbp-0x4]</code>. That is your local variable resting on the stack.</p>
The Heap</strong></h2>
We will just do an overview of this section. It can get quite complex very fast. We will eventually cover them in future articles.</p>
If the stack is the CPU’s fast, tightly organized workbench, the heap is the massive, slightly chaotic warehouse out back.</p>
The stack is great for small, temporary variables, but it has severe limitations: it is relatively small, and you must know exactly how much space you need at compile time. What if you want to load a 10MB image file? Or what if you are accepting user input and you don't know if the user will type 10 characters or 10,000?</p>
For dynamic, large, or unpredictable data, we use the Heap</strong>.</p>
Unlike the stack, which the CPU manages automatically by just moving the rsp</code> register up and down, the heap is entirely manual. The programmer must explicitly ask the operating system for a chunk of memory, and more importantly, they must explicitly give it back when they are done.</p>
In C, this is done using the malloc()</code> (memory allocate) and free()</code> functions.</p>
Consider heap.c</p>
#include</span> <stdlib.h></span>  </span></span>
#include</span> <string.h></span></span>
</span>
int</span> main</span>() {</span>  </span></span>
    // Ask the warehouse for 64 bytes of space  </span></span>
    char</span> *</span>buffer </span>=</span> (</span>char</span> *</span>)</span>malloc</span>(</span>64</span>);</span>  </span></span>
      </span></span>
    // Put some data into that space  </span></span>
    strcpy</span>(</span>buffer</span>,</span> "hello heap"</span>);</span>  </span></span>
      </span></span>
    // Give the space back to the warehouse  </span></span>
    free</span>(</span>buffer</span>);</span>  </span></span>
      </span></span>
    return</span> 0</span>;</span>  </span></span>
}</span></span>
</span></code></pre>
Now we do the necessary:</p>
gcc</span> -o heap heap.c</span> &&</span> objdump</span> -d -M intel heap</span> |</span> grep</span> -A</span> 20</span> "<main>:"</span></span>
</span></code></pre>

0000000000001149</span> **<main>:**  </span></span>
   1149</span>:       </span>55</span>                      push</span>   rbp</span>  </span></span>
   114a</span>:</span>       48 89</span> e5                </span>mov</span>    rbp</span>,</span>rsp</span>  </span></span>
   114d</span>:       </span>48 83</span> ec </span>10</span>             sub</span>    rsp</span>,</span>0x10</span>  </span></span>
   1151</span>:       bf </span>40 00 00 00</span>          mov</span>    edi</span>,</span>0x40</span>  </span></span>
   1156</span>:       e8 e5 fe ff ff          </span>call</span>   1040</span> <malloc@plt>  </span></span>
   115b</span>:</span>       48 89 45</span> f8             </span>mov    QWORD</span> PTR [</span>rbp</span>-</span>0x8</span>],</span>rax</span>  </span></span>
   115f</span>:</span>       48</span> 8b </span>45</span> f8             </span>mov</span>    rax</span>,</span>QWORD</span> PTR [</span>rbp</span>-</span>0x8</span>]  </span></span>
   1163</span>:       </span>48</span> ba </span>68 65</span> 6c 6c 6f    movabs </span>rdx</span>,</span>0x6568206f6c6c6568</span>  </span></span>
   116a</span>:</span>       20 68 65</span>    </span></span>
   116d</span>:       </span>48 89 10</span>                mov    QWORD</span> PTR [</span>rax</span>],</span>rdx</span>  </span></span>
   1170</span>:       c7 </span>40 07 65 61 70 00</span>    mov    DWORD</span> PTR [</span>rax</span>+</span>0x7</span>],</span>0x706165</span>  </span></span>
   1177</span>:       </span>48</span> 8b </span>45</span> f8             </span>mov</span>    rax</span>,</span>QWORD</span> PTR [</span>rbp</span>-</span>0x8</span>]  </span></span>
   117b</span>:</span>       48 89</span> c7                </span>mov</span>    rdi</span>,</span>rax</span>  </span></span>
   117e</span>:</span>       e8 ad fe ff ff          </span>call</span>   1030</span> <free@plt>  </span></span>
   1183</span>:       b8 </span>00 00 00 00</span>          mov</span>    eax</span>,</span>0x0</span>  </span></span>
   1188</span>:       c9                      </span>leave</span>  </span></span>
   1189</span>:       c3                      </span>ret</span></span>
</span>
Disassembly of section </span>.</span>fini</span>:</span></span></code></pre>
When you look at this assembly, you won't see data simply being pushed onto the stack. Instead, you will see instructions setting up arguments (like putting 0x40</code>—which is 64 in hex—into the edi</code> register) followed by a call</code> to malloc@plt</code>.</p>
malloc</code> acts as the warehouse manager. It goes out, finds 64 bytes of free space in the heap memory region, and returns a pointer (a memory address) to that space in the tax</code> register.</p>
This manual management is exactly why the heap is such a prime target for exploitation. If a programmer calls malloc</code> but forgets to call free</code>, the program leaks memory. If they call free</code> but keep using the pointer anyway, you get a "Use-After-Free" vulnerability. If they ask for 64 bytes but copy 100 bytes into it, you get a Heap Overflow. Breaking the heap means tricking the warehouse manager (glibc</code>'s allocator) into giving you access to things you shouldn't have.</p>
The CPU's Instruction Set</strong></h2>
Assembly might look like gibberish at first, but it essentially boils down to moving data, doing basic math, and jumping around memory. Here are the most common instructions you will encounter:</p>
Moving Data</strong></h3>

mov dest, src</code></strong>: Copies data from the source to the destination. (mov rax, rdx</code> copies the value in rdx</code> into rax</code>).</li>
Dereferencing []</code></strong>: Brackets act like pointers in C. mov rax, [rdx]</code> doesn't move rdx</code> itself; it goes to the memory address stored in rdx</code> and grabs the value sitting there. Conversely, mov [rax], rdx</code> takes the value in rdx</code> and writes it into the memory address pointed to by rax</code>.</li>
lea dest, src</code></strong>: Load Effective Address. It calculates a memory address and stores the address itself</em> in the destination, rather than the data at that address. (lea rdi, [rbx+0x10]</code>).</li>
</ul>
Math and Logic</strong></h3>

add dest, src</code> / sub dest, src</code></strong>: Adds or subtracts the source from the destination, storing the result in the destination.</li>
xor dest, src</code></strong>: Performs a bitwise exclusive OR. (You will frequently see xor rax, rax</code>—this is simply an optimized way to set rax</code> to 0).</li>
</ul>
Stack Operations</strong></h3>

push reg</code></strong>: Subtracts from rsp</code> to grow the stack, then places the register's value onto the new top of the stack.</li>
pop reg</code></strong>: Takes the value from the top of the stack, puts it into the register, and adds to rsp</code> to shrink the stack.</li>
</ul>
Control Flow</strong></h3>

jmp address</code></strong>: Unconditionally redirects code execution to a new memory address.</li>
call address</code></strong>: Used to invoke functions. It pushes the current rip</code> onto the stack (so the program remembers where it was) and then jumps to the new address.</li>
ret</code></strong>: Pops the saved address off the stack and places it back into rip</code>, seamlessly resuming execution where it left off before the call</code>.</li>
</ul>
Conditionals and Flags</strong></h3>
The CPU has a special register dedicated to Flags</strong>—individual bits that indicate the state of the processor (e.g., the Zero Flag, Carry Flag, Sign Flag).</p>

cmp arg1, arg2</code></strong>: Compares two values by silently subtracting them. It doesn't save the mathematical result; instead, it updates the CPU Flags (like setting the Zero Flag if the two values were equal).</li>
jz</code> / jnz</code></strong>: Jump if Zero / Jump if Not Zero. These look at the CPU flags set by a previous cmp</code> instruction. If the Zero Flag is set, jz</code> will take the jump. If not, the program just continues to the next instruction.</li>
</ul>
There is one register that contains flags. A flag is a particular bit of this register. If it is set or not, will typically mean something. Here is the list of flags.</p>
00:     Carry Flag  </span></span>
01:     always 1  </span></span>
02:     Parity Flag  </span></span>
03:     always 0  </span></span>
04:     Adjust Flag  </span></span>
05:     always 0  </span></span>
06:     Zero Flag  </span></span>
07:     Sign Flag  </span></span>
08:     Trap Flag  </span></span>
09:     Interruption Flag       </span></span>
10:     Direction Flag  </span></span>
11:     Overflow Flag  </span></span>
12:     I/O Privilege Field lower bit  </span></span>
13:     I/O Privilege Field higher bit  </span></span>
14:     Nested Task Flag  </span></span>
15:     Resume Flag  </span></span></code></pre>

There are other flags then the one listed, however we really don't deal with them too much (and out of these, there are only a few we actively deal with).</p>
This has been a lot to unpack but it will get simpler with time. Now that we understand how C code becomes assembly, how the CPU juggles data in registers, and how the stack manages memory, we need to look at how all of this is packaged together by the operating system. Next, we will dive deeper into the structure of the ELF binary itself.</p>
You can support my work at https://buymeacoffee.com/mockingspectre</a></p>
Further Reading</h2>
https://en.wikibooks.org/wiki/X86_Assembly/X86_Architecture</a>

https://en.wikipedia.org/wiki/Assembly_language</a></p>


The Single Byte That Kills Your Exploit: Understanding Endianness
mockingspectre — Sun, 09 Nov 2025 00:00:00 +0000
If you’ve ever crafted a perfect shellcode and ROP chain only to have your exploit immediately crash with a SIGSEGV(a signal sent by the operating system to a program when it attempts to access a protected or invalid memory location) or EIP(a 32-bit CPU register in the x86 architecture that holds the memory address of the next machine instruction to be executed) pointing to garbage, you’ve likely met the silent killer of beginners: Endianness.</p>
Endianness is fundamental; it defines the order in which a multi-byte value (like a 4-byte integer or an 8-byte memory address) is stored in a machine’s memory. For us in the pwn game, this translates directly to whether the addresses we pack into our exploit payloads are interpreted correctly by the target program. A single misplaced byte means the difference between a shell and a stack smash(stack buffer overflow**)**.</p>
Little vs. Big: The Two Orders</h2>
There are two primary byte orders</p>
Little-Endian (LE): The Least Significant Byte (LSB) is stored first, at the lowest memory address. This is the byte order used by the vast majority of personal computers, including all modern Intel/AMD (x86/x64) architectures.</p>
Big-Endian (BE): The Most Significant Byte (MSB) is stored first, at the lowest memory address. This is often called Network Byte Order (NBO) and is common in network protocols, as well as some older or embedded architectures like PowerPC, MIPS, and SPARC.</p>
Cross-architecture exploitation (LE <-> BE)</h2>
If you’re attacking an embedded device, router, or IoT target, it might be Big-Endian. Always confirm the target architecture and ABI. Common mistakes when cross-compiling or reusing gadgets:</p>
Using x86/x86_64 gadgets and packers on a MIPS/PowerPC target (different endianness and instruction set) will not work.</p>
pwntools and other frameworks allow you to set context.arch</code> and context.endian</code> So packers and disassemblers behave correctly.</p>
How to detect the target’s endianness quickly</h2>
Run the small C program above on the target if you have code execution. Use readelf</code>, file</code>, or objdump</code> On binaries from the target filesystem, some formats indicate endianness.</p>
In GDB, examine the memory representation of a known constant or pointer. Put a known value in a register or memory, and inspect the byte order with x/4xb address</code>.</p>
(gdb) p/x 0x41424344</span></span>
$1 = 0x41424344</span></span>
(gdb) set {int}0x601000 = 0x41424344</span></span>
(gdb) x/4xb 0x601000</span></span>
0x601000: 0x44 0x43 0x42 0x41  # little-endian: ‘DCBA’</span></span></code></pre>Debugging tips when an exploit “looks right” but crashes</h2>
Print the raw payload bytes you are sending, compare with what the target receives (packet capture or logging), and what the target’s memory shows in a debugger.</p>
Verify pointer size. Are you packing 32-bit or 64-bit addresses?</p>
Check alignment and padding. Are there extra bytes inserted by the protocol or scanf</code>/fgets</code> behavior?</p>
Confirm endianness on the target; don’t assume x86 for embedded devices.</p>
Use tool packing (struct.pack</code>, pwntools</code>) instead of hand-reversing where possible.</p>
If attacking over the network, confirm whether fields are consumed in network byte order.</p>
Short checklist for exploit authors</h2>

Confirm target architecture (x86, x86_64, MIPS, ARM, PowerPC).</li>
Confirm endianness (LE or BE).</li>
Use correct pointer width (p32</code> vs p64</code>) and pack accordingly.</li>
Use library packing (struct</code>, pwntools</code>) to avoid manual reversal mistakes.</li>
For network services, encode multi-byte protocol fields in network (big-endian) byte order unless the protocol documentation says otherwise.</li>
Check struct padding and alignment on the target.</li>
Inspect the target’s memory with a debugger to verify the actual byte layout.</li>
</ul>
Final thoughts</h2>
Endianness is simple in concept but vital in practice. For most modern exploit work, you’ll be on x8664 (Little-Endian), so make it a habit to pack addresses in reverse byte order relative to how you read them in a disassembler. Use pwntools</code>, struct</code>, or equivalent to do the packing for you, but keep in mind _why</em> bytes are reversed; that understanding is what will let you debug the next crash quickly and confidently.</p>
Recommended reading:</p>

https://betterexplained.com/articles/understanding-big-and-little-endian-byte-order/</a></li>
https://medium.com/coderscorner/byte-ordering-e4737416d906</a></li>
https://devopedia.org/byte-ordering</a></li>
https://www.geeksforgeeks.org/dsa/little-and-big-endian-mystery/</a></li>
</ul>
Disclaimer: This article was written with AI assistance, for a bit of brainstorming and proofreading.</p>


What is pwn?
mockingspectre — Wed, 03 Sep 2025 00:00:00 +0000

Binary Exploitation is a broad topic within Cyber Security which really comes down to finding a vulnerability in the program and exploiting it to gain control of a shell or modifying the program's functions ~ctf101</p>
</blockquote>
In most challenges, you’ll be given a Linux binary to exploit, and occasionally a Windows executable. The goal is to find a way to get the program to run in a way that was not intended.</p>
Over the course of this series, we will look at the basics of a binary from simple to advanced concepts. This will be a multipart post covering the concepts over a couple of months. I’ll also use it as a reference to track my own progress.</p>

This assumes that the reader has some significant experience with programming, i will not be explaining how to write software. The tutorials will be in C, simple enough while being low level for some of the things well do. I recommend reading :</p>
The C Programming Language</a></em>, 2nd Edition, by Brian W. Kernighan and Dennis M. Ritchie (Prentice Hall, 1988).</a></p>
</blockquote>

Concepts to Cover</h2>
This roadmap will take you from “I don’t know how the stack works”</em> to “I can write exploits for CTFs and understand real-world CVEs.”</em></p>
Episode 1: Getting Started</strong></h3>

Why binary exploitation matters (CTFs, real-world, research).</li>
Computer architecture basics (x86/x64 registers, stack vs heap, memory layout).</li>
Compiling and running simple C programs.</li>
Intro to ELF binaries.</li>
</ul>

Episode 2: Assembly & Tools Crash Course</strong></h3>

Function calls in assembly (prologue/epilogue, stack frames).</li>
Common instructions (mov</code>, call</code>, jmp</code>, ret</code>).</li>
Debugging with gdb</code>, gef</code>/pwndbg</code>.</li>
Disassembly with objdump</code>, radare2</code>, and Ghidra</code>.</li>
</ul>

Episode 3: Memory Corruption 101</strong></h3>

What is a segmentation fault?</li>
Stack buffer overflows (first crashes).</li>
Off-by-one errors.</li>
Writing your first shellcode and executing it locally.</li>
</ul>

Episode 4: Exploiting Control Flow</strong></h3>

Overwriting return addresses.</li>
NOP sleds and shellcode execution.</li>
Return-to-libc attacks (ret2libc).</li>
Environment variables and argument tricks.</li>
</ul>

Episode 5: Format String Vulnerabilities</strong></h3>

How printf</code> becomes an exploit primitive.</li>
Memory leaks via format strings.</li>
Overwriting memory using %n</code>.</li>
</ul>

Episode 6: Modern Protections & Bypasses (Part 1)</strong></h3>

NX (non-executable stack) and its bypass with ROP.</li>
Intro to ROP gadgets and building small chains.</li>
Automating with Pwntools and ROPgadget.</li>
</ul>

Episode 7: Modern Protections & Bypasses (Part 2)</strong></h3>

ASLR: how randomization works.</li>
Leaking addresses to defeat ASLR.</li>
Stack canaries and partial overwrites.</li>
</ul>

Episode 8: Heap Exploitation (Basics)</strong></h3>

Understanding malloc/free and heap metadata.</li>
Classic heap overflows.</li>
Use-after-free and double free.</li>
Simple heap exploitation demos.</li>
</ul>

Episode 9: Heap Exploitation (Advanced)</strong></h3>


Unlink attacks and unsafe unlink.</p>
</li>

Fastbin dup tricks.</p>
</li>

The “House of” techniques:</p>

House of Force</li>
House of Spirit</li>
House of Lore</li>
House of Einherjar</li>
</ul>
</li>

Tcache poisoning in modern glibc.</p>
</li>
</ul>

Episode 10: Advanced Exploitation Techniques</strong></h3>

GOT/PLT overwrites.</li>
Ret2dlresolve.</li>
Sigreturn-oriented programming (SROP).</li>
JOP (Jump-Oriented Programming).</li>
</ul>

Episode 11: Kernel & Windows Exploitation (Intro)</strong></h3>

Userland vs kernel space.</li>
Exploiting syscalls for privilege escalation.</li>
Windows basics: SEH overwrites, DEP/ASLR bypass.</li>
Kernel driver exploitation.</li>
</ul>

Episode 12: Modern Defenses & Mitigations</strong></h3>

Control-Flow Integrity (CFI).</li>
Shadow stacks & CET.</li>
Hardened malloc and allocator security.</li>
Sandboxing & seccomp-bpf.</li>
</ul>

Episode 13: Exploit Workflow in Practice</strong></h3>

Solving a CTF challenge step-by-step.</li>
Remote exploitation (exploiting over sockets).</li>
Exploit reliability (stability, bruteforcing).</li>
Post-exploitation steps (getting a shell, escalating privileges).</li>
</ul>

Episode 14: Beyond the Basics</strong></h3>

Automating exploit discovery with fuzzing (AFL, honggfuzz).</li>
Symbolic execution with angr.</li>
Real-world case studies (Heartbleed, Dirty COW, Shellshock).</li>
Writing weaponized exploits responsibly.</li>
</ul>


ScriptCTF 2025 Writeup
mockingspectre — Mon, 18 Aug 2025 00:00:00 +0000


Over the weekend, I participated in ScriptCTF, a capture-the-flag competition packed with diverse challenges spanning cryptography, forensics, reverse engineering, and web exploitation.</p>
In this write-up, I’ll walk through some of the problems I solved, breaking down my approach, the tools I used, and the reasoning behind each step. Rather than just dropping final answers, my goal is to document the problem-solving process in a way that’s reproducible and useful for others looking to sharpen their cybersecurity skills.</p>
Challenge: Renderer</h1>
</p>
This is the first web challenge; it launches an instance, and the source code is provided for manual code review. There are three important files: two Jinja templates and a Python file.</p>
upload.html</p>
<!DOCTYPE</span> html</span>></span></span>
<</span>html</span>></span></span>
  <</span>head</span>></span></span>
    <</span>title</span>></span>Upload Image</span></</span>title</span>></span></span>
  </</span>head</span>></span></span>
  <</span>body</span>></span></span>
    <</span>h1</span>></span>Upload Images</span></</span>h1</span>></span></span>
    <</span>p</span>></span>This free to use website allows you to render your images!</span></</span>p</span>></span></span>
    <</span>p</span>></</span>p</span>></span></span>
    <</span>form</span> method</span>=</span>"post"</span> enctype</span>=</span>"multipart/form-data"</span>></span></span>
      <</span>input</span> type</span>=</span>"file"</span> name</span>=</span>"file"</span> accept</span>=</span>".png,.jpg,.jpeg,.svg"</span> required</span> /></span></span>
      <</span>input</span> type</span>=</span>"submit"</span> value</span>=</span>"Upload"</span> /></span></span>
    </</span>form</span>></span></span>
  </</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
display.html</p>
<!DOCTYPE</span> html</span>></span></span>
<</span>html</span>></span></span>
  <</span>head</span>></span></span>
    <</span>title</span>></span>View Image</span></</span>title</span>></span></span>
    <</span>style</span>></span></span>
      iframe</span> {</span></span>
        max-width</span>:</span> 600</span>px</span>;</span></span>
        max-height</span>:</span> 600</span>px</span>;</span></span>
        border</span>:</span> hidden</span>;</span></span>
        overflow</span>:</span> none</span>;</span></span>
      }</span></span>
    <</span>/</span>style</span>></span></span>
  </</span>head</span>></span></span>
  <</span>body</span>></span></span>
    <</span>h1</span>></span>Uploaded Image</span></</span>h1</span>></span></span>
    <</span>iframe</span> src</span>=</span>"{{'/static/uploads/' + filename }}"</span> alt</span>=</span>"Uploaded Image"</span>></</span>iframe</span>></span></span>
    <</span>p</span>><</span>a</span> href</span>=</span>"/"</span>></span>Upload another image</span></</span>a</span>></</span>p</span>></span></span>
  </</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
[app.py](http://app.py)</code></p>
from</span> flask</span> import</span> Flask</span>,</span> request</span>,</span> redirect</span>,</span> render_template</span>,</span> make_response</span>,</span> url_for</span></span>
app</span> =</span> Flask</span>(</span>__name__</span>)</span></span>
from</span> hashlib</span> import</span> sha256</span></span>
import</span> os</span></span>
def</span> allowed</span>(</span>name</span>):</span></span>
    if</span> name</span>.</span>split</span>(</span>'.'</span>)[</span>1</span>]</span> in</span> [</span>'jpg'</span>,</span>'jpeg'</span>,</span>'png'</span>,</span>'svg'</span>]:</span></span>
        return</span> True</span></span>
    return</span> False</span></span>
</span>
@app</span>.</span>route</span>(</span>'/'</span>,</span>methods</span>=</span>[</span>'GET'</span>,</span>'POST'</span>])</span></span>
def</span> upload</span>():</span></span>
    if</span> request</span>.</span>method</span> ==</span> 'POST'</span>:</span></span>
        if</span> 'file'</span> not in</span> request</span>.</span>files</span>:</span></span>
            return</span> redirect</span>(</span>request</span>.</span>url</span>)</span></span>
        file</span> =</span> request</span>.</span>files</span>[</span>'</span>file</span>'</span>]</span></span>
        if</span> file</span>.</span>filename</span> ==</span> ''</span>:</span></span>
            return</span> redirect</span>(</span>request</span>.</span>url</span>)</span></span>
        if</span> file</span> and</span> allowed</span>(</span>file</span>.</span>filename</span>):</span></span>
            filename</span> =</span> file</span>.</span>filename</span></span>
            hash</span> =</span> sha256</span>(</span>os</span>.</span>urandom</span>(</span>32</span>)).</span>hexdigest</span>()</span></span>
            filepath</span> =</span> f</span>'./static/uploads/</span>{</span>hash</span>}</span>.</span>{</span>filename</span>.</span>split</span>(</span>"."</span>)[</span>1</span>]</span>}</span>'</span></span>
            file</span>.</span>save</span>(</span>filepath</span>)</span></span>
            return</span> redirect</span>(</span>f</span>'/render/</span>{</span>hash</span>}</span>.</span>{</span>filename</span>.</span>split</span>(</span>"."</span>)[</span>1</span>]</span>}</span>'</span>)</span></span>
    return</span> render_template</span>(</span>'upload.html'</span>)</span></span>
</span>
@app</span>.</span>route</span>(</span>'/render/<path:filename>'</span>)</span></span>
def</span> render</span>(</span>filename</span>):</span></span>
    return</span> render_template</span>(</span>'display.html'</span>,</span> filename</span>=</span>filename</span>)</span></span>
</span>
@app</span>.</span>route</span>(</span>'/developer'</span>)</span></span>
def</span> developer</span>():</span></span>
    cookie</span> =</span> request</span>.</span>cookies</span>.</span>get</span>(</span>"developer_secret_cookie"</span>)</span></span>
    correct</span> =</span> open</span>(</span>'./static/uploads/secrets/secret_cookie.txt'</span>).</span>read</span>()</span></span>
    if</span> correct</span> ==</span> ''</span>:</span></span>
        c</span> =</span> open</span>(</span>'./static/uploads/secrets/secret_cookie.txt'</span>,</span>'w'</span>)</span></span>
        c</span>.</span>write</span>(</span>sha256</span>(</span>os</span>.</span>urandom</span>(</span>16</span>)).</span>hexdigest</span>())</span></span>
        c</span>.</span>close</span>()</span></span>
    correct</span> =</span> open</span>(</span>'./static/uploads/secrets/secret_cookie.txt'</span>).</span>read</span>()</span></span>
    if</span> cookie</span> ==</span> correct</span>:</span></span>
        c</span> =</span> open</span>(</span>'./static/uploads/secrets/secret_cookie.txt'</span>,</span>'w'</span>)</span></span>
        c</span>.</span>write</span>(</span>sha256</span>(</span>os</span>.</span>urandom</span>(</span>16</span>)).</span>hexdigest</span>())</span></span>
        c</span>.</span>close</span>()</span></span>
        return</span> f</span>"Welcome! There is currently 1 unread message: </span>{</span>open</span>(</span>'flag.txt'</span>).</span>read</span>()</span>}</span>"</span></span>
    else</span>:</span></span>
        return</span> "You are not a developer!"</span></span>
</span>
if</span> __name__</span> ==</span> '__main__'</span>:</span></span>
    app</span>.</span>run</span>(</span>host</span>=</span>'0.0.0.0'</span>,</span> port</span>=</span>1337</span>)</span></span></code></pre>
From the files, we can see that this is an app built using Flask. What the app does:</p>
/</code> — Upload endpoint:</p>


Accepts jpg</code>, jpeg</code>, png</code>, svg</code> files.</p>
</li>

Saves them under ./static/uploads/<randomhash>.<ext></code>.</p>
</li>

Redirects to /render/<file></code>.</p>
</li>
</ul>
/render/<filename></code> — Renders the uploaded image using display.html</code>.</p>
/developer</code> — Protected route:</p>


Checks a cookie developer_secret_cookie</code> against secret_cookie.txt</code>.</p>
</li>

If it matches, it reveals flag.txt</code>.</p>
</li>
</ul>
secret_cookie.txt</code> is generated if empty and is overwritten after a successful visit.</p>
Key Observations</p>


File upload: Only the extension is checked; there is no content verification. So you can upload anything with .jpg, .png, etc.</p>
</li>

Render template: The render() route calls render_template('display.html', filename=filename).</p>
</li>

Secrets: The /developer route requires knowing secret_cookie.txt. We need a way to leak it.</p>
</li>
</ol>
Navigating to the developer endpoint without the cookie returns this request.</p>
HTTP/1.1 200 OK</span></span>
Server: Werkzeug/3.1.3 Python/3.10.16</span></span>
Date: Sun, 17 Aug 2025 11:51:49 GMT</span></span>
Content-Type: text/html; charset=utf-8</span></span>
Content-Length: 24</span></span>
Connection: close</span></span>
</span>
You are not a developer!</span></span></code></pre>
Now I tried some path traversal techniques, but I couldn't reach the cookie. I turned my focus on how the uploaded images were being rendered and saw that it was an inline iframe. Hmm… interesting, what if I could get code execution on this? I thought of uploading a malicious SVG.

Here is an innocent-looking SVG</p>
<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"></span></span>
  <script type="text/javascript"></span></span>
    fetch('/developer', {credentials:'include'})</span></span>
      .then(res => res.text())</span></span>
      .then(data => alert(data));</span></span>
  </script></span></span>
</svg></span></span></code></pre>
And…



I didn't think that through. I can't make that request without the cookie. Another approach I tried was Local File Inclusion(LFI) using the SVG. Here is another not-so-evil one:</p>
<svg xmlns="http://www.w3.org/2000/svg"></span></span>
  <image href="/static/uploads/secrets/secret_cookie.txt" /></span></span>
</svg></span></span></code></pre>
The browser shows it as a broken image, but on opening it on another tab, I was able to leak the cookie 5eb7b76fbb08895de572fbe6028a4ee4abe3663641416deb5b889e0127920c6e</code>. I copied and pasted the direct URL on another browser tab, and I got straight to it. I might have over-engineered something so simple, but anyway, Do Hard Things!!

Retrieving the flag</p>
$</span> curl -b "developer_secret_cookie=5eb7b76fbb08895de572fbe6028a4ee4abe3663641416deb5b889e0127920c6e" http://play.scriptsorcerers.xyz:10257/developer</span></span>
</span>
Welcome!</span> There is currently</span> 1</span> unread message: scriptCTF{my_c00k135_4r3_n0t_s4f3!_601871f7aad5}</span></span></code></pre>
Flag: scriptCTF{my_c00k135_4r3_n0t_s4f3!_601871f7aad5}</code></p>
Challenge: Div</h1>


Here are the contents of the chall.py</a></p>
import</span> os</span></span>
import</span> decimal</span></span>
decimal</span>.</span>getcontext</span>().</span>prec</span> =</span> 50</span></span>
</span>
secret</span> =</span> int</span>(</span>os</span>.</span>urandom</span>(</span>16</span>).</span>hex</span>(),</span>16</span>)</span></span>
num</span> =</span> input</span>(</span>'Enter a number: '</span>)</span></span>
</span>
if</span> 'e'</span> in</span> num</span>.</span>lower</span>():</span></span>
   print</span>(</span>"Nice try..."</span>)</span></span>
   exit</span>(</span>0</span>)</span></span>
</span>
if</span> len</span>(</span>num</span>)</span> >=</span> 10</span>:</span></span>
   print</span>(</span>'Number too long...'</span>)</span></span>
   exit</span>(</span>0</span>)</span></span>
</span>
fl_num</span> =</span> decimal</span>.</span>Decimal</span>(</span>num</span>)</span></span>
div</span> =</span> secret</span> /</span> fl_num</span></span>
</span>
if</span> div</span> ==</span> 0</span>:</span></span>
   print</span>(</span>open</span>(</span>'flag.txt'</span>).</span>read</span>().</span>strip</span>())</span></span>
else</span>:</span></span>
   print</span>(</span>'Try again...'</span>)</span></span></code></pre>
Let’s break it down:</p>


The server picks a secret — a random 128-bit integer (os.urandom(16)</code> → 32 hex chars → huge number).</p>
</li>

You input a number num</code>.</p>
</li>

If your input contains 'e'</code> or 'E'</code> (scientific notation), you get blocked.</p>
</li>

If your input is ≥ 10 characters, you get blocked.</p>
</li>

It converts num</code> to a decimal.Decimal</code> with precision 50.</p>
</li>

It computes div = secret / fl_num</code>.</p>
</li>

If div == 0</code>, you get the flag.</p>
</li>
</ol>
Key observation</p>


secret</code> is positive and huge (on the order of 2128</code>).</p>
</li>

Normally, secret / something</code> won’t be 0.</p>
</li>

In Python decimal.Decimal</code>, div == 0</code> only if the result is exactly</em> 0. Decimal doesn’t overflow or underflow like float — it has arbitrary precision (set to 50).</p>
</li>
</ul>
So how do we get exactly zero?</p>


Decimal division only returns 0</code> if the numerator is 0</code> OR if the denominator is so huge that the quotient rounds down to 0 at the given precision.</p>
</li>

Precision is 50 significant digits. That means if the result is smaller than 10^(-50)</code>, it will round to 0.</p>
</li>
</ul>
We want</p>
secret / fl_num < 10^-50</code>.</p>
fl_num > secret × 10^50</code></p>
Since</p>
secret</code> ≈ 2^128</code> ≈ 3.4 × 10^38</code>,</p>
we need</p>
fl_num > (3.4 × 10^38) × 10^50 = 3.4 × 10^88</code></p>
But there’s a catch

We can’t use exponent notation (e), and the input length must be < 10 characters.</p>
That means we can’t type a literal 100000... with 89 zeros, it’s too long.

But in Decimal, you can input a decimal point and make something big by making it a very small number and dividing 1 by it.</p>
This is about NaN / Infinity in decimal.Decimal</code>. If fl_num</code> is 'Infinity'</code> (allowed, length 8), secret / Infinity</code></p>
nc</span> play.scriptsorcerers.xyz</span> 10456</span></span>
</span>
Enter</span> a number: Infinity</span></span>
scriptCTF</span>{70_1nf1n17y_4nd_b3y0nd_20e422d293fc}</span></span></code></pre>
Flag: scriptCTF{70_1nf1n17y_4nd_b3y0nd_20e422d293fc}</code></p>
Some context

Python’s decimal.Decimal module implements IEEE 754 decimal floating-point arithmetic.

It accepts strings like:</p>
"Infinity" or "inf" → positive infinity</p>
"-Infinity" → negative infinity</p>
"NaN" → not-a-number</p>
These are special constants, not parsed as normal numbers.</p>
Under IEEE 754 rules:</p>


finite_number / Infinity = 0 exactly</p>
</li>

finite_number / -Infinity = -0 (also treated as zero)</p>
</li>
</ul>
Infinity represents a number so large that any finite numerator divided by it tends towards 0 exactly, with no rounding error.</p>
Challenge: Emoji</h1>


Out.txt has some symbols.</p>
🁳🁣🁲🁩🁰🁴🁃🁔🁆🁻🀳🁭🀰🁪🀱🁟🀳🁮🁣🀰🁤🀱🁮🁧🁟🀱🁳🁟🁷🀳🀱🁲🁤🁟🀴🁮🁤🁟🁦🁵🁮🀡🀱🁥🀴🀶🁤🁽</span></span></code></pre>
The symbols are Unicode Domino Tiles (in the U+1F030–U+1F093 range). If you subtract 0x1F000 (the start of the Mahjong/Domino emoji area) from each character’s code point, you get plain ASCII bytes. You can learn more about Unicode here.</p>

https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/</a></li>
https://en.wikipedia.org/wiki/Dominoes#Dominoes_in_Unicode:~:text=%5B38%5D-,Dominoes%20in%20Unicode,-%5Bedit%5D</a></li>
https://www.reedbeta.com/blog/programmers-intro-to-unicode/</li>
</ul>
Here is a Python script for that(old habits die hard)</p>
s</span> =</span> "🁳🁣🁲🁩🁰🁴🁃🁔🁆🁻🀳🁭🀰🁪🀱🁟🀳🁮🁣🀰🁤🀱🁮🁧🁟🀱🁳🁟🁷🀳🀱🁲🁤🁟🀴🁮🁤🁟🁦🁵🁮🀡🀱🁥🀴🀶🁤🁽"</span></span>
print</span>(</span>''</span>.</span>join</span>(</span>chr</span>(</span>ord</span>(</span>ch</span>)</span> -</span> 0x</span>1F000</span>)</span> for</span> ch</span> in</span> s</span>))</span></span></code></pre>$</span> python3 solve.py</span></span>
scriptCTF</span>{3m0j1_3nc0d1ng_1s_w31rd_4nd_fun!1e46d}</span></span></code></pre>
Flag : scriptCTF{3m0j1_3nc0d1ng_1s_w31rd_4nd_fun!1e46d}</code></p>
Challenge: Enchant</h1>


After some Google search, I found out that’s the Standard Galactic Alphabet, the glyphs used by Minecraft’s enchantment table. The enchantment-table glyphs map one-to-one to letters in the Standard Galactic Alphabet (SGA). I used the SGA ↔ Latin mapping to translate each symbol into its English letter at https://www.dcode.fr/standard-galactic-alphabet</a>. The result is MINECRAFTISFUN.</p>
Flag: scriptCTF{MINECRAFTISFUN}</code></p>
Challenge: diskchal



This was a forensics challenge; we were given a disk image, probably to recover some files, as the challenge description suggests.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$</span> file stick.img</span></span>
stick.img:</span> DOS/MBR boot sector, code offset 0x58+2, OEM-ID "mkfs.fat", sectors</span> 49152</span> (volumes</span> <</span>=</span>32</span> MB</span>), Media descriptor 0xf8, sectors/track 32, heads 4, FAT (</span>32</span> bit</span>), sectors/FAT 378, reserved 0x1, serial num</span></span>
ber</span> 0x8caae860, unlabeled</span></span></code></pre>
The file is a FAT32 filesystem image created with mkfs.fat</code>.I try to mount the image and see what's inside.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$</span> sudo mount stick.img mnt/</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$</span> ls mnt</span></span>
notes.txt</span>  random_thoughts.txt</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$</span> cat</span> *</span> mnt/</span></span>
cat:</span> mnt: Is a directory</span></span>
�X�mkfs.fat</span> �� z�</span>)</span>`</span>誌NO</span> NAME    FAT32   �w</span>|</span>�"�t</span></span>
                                              V^2�����This is not a bootable disk.  Please insert a bootable floppy and</span></span>
press any key to try again ...</span></span>
U�RRaArrAa��U��X�mkfs.fat �� z�)</span>`</span>誌NO</span> NAME    FAT32   �w</span>|</span>�"�t</span></span>
                                                            V���^��2�����This is not a bootable disk.  Please insert a bootable floppy and</span></span>
press any key to try again ...</span></span>
U�RRaArrAa��U�������������������������������Anotes�.txt������NOTES   TXT Rk��Z[k��ZLBts.tx<t������������rando<m_thoughRANDOM~1TXT Rk��Z[k��Z8�collection.gz�secret_magic_�ECRET~1GZ  Sk��Z�Zk��Z<Notes:</span></span>
- practice my zarrow shuffle</span></span>
- learn some false cuts</span></span>
- play some sts</span></span>
i wonder where i put the flag. did i palm it somewhere?</span></span>
�xyhflag.txt+N.�,(qq�6��1(3��513L�7/2L�6��</span></span>
                                         ���cat: mnt/: Is a directory</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$ cat *.txt  mnt/</span></span>
cat: '*.txt': No such file or directory</span></span>
cat: mnt/: Is a directory</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$ cd mnt</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal/mnt$ ls -lah</span></span>
total 5.5K</span></span>
drwxr-xr-x 2 root           root            512 Jan  1  1970 .</span></span>
drwxrwxr-x 3 mockingspectre mockingspectre 4.0K Aug 17 16:06 ..</span></span>
-rwxr-xr-x 1 root           root             76 Jul 18 01:27 notes.txt</span></span>
-rwxr-xr-x 1 root           root             56 Jul 18 01:27 random_thoughts.txt</span></span></code></pre>
Nothing particularly juicy or interesting. Running binwalk brings up some info.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$</span> binwalk stick.img</span></span>
</span>
DECIMAL</span>       HEXADECIMAL     DESCRIPTION</span></span>
--------------------------------------------------------------------------------</span></span>
404992</span>        0x62E00</span>         gzip compressed data, has original file name: "flag.txt", from Unix, last modified: 2025-07-17 22:27:22</span></span></code></pre>
Let me extract everything with dd.</code></p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal$</span> binwalk --dd='.*' stick.img</span></span>
</span>
DECIMAL</span>       HEXADECIMAL     DESCRIPTION</span></span>
--------------------------------------------------------------------------------</span></span>
404992</span>        0x62E00</span>         gzip compressed data, has original file name: "flag.txt", from Unix, last modified: 2025-07-17 22:27:22</span></span></code></pre>
After some bashfu, the flag is revealed.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal/_stick.img.extracted$</span> ls</span></span>
flag.txt</span>  flag.txt.gz</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/diskchal/_stick.img.extracted$</span> cat flag.txt</span></span>
scriptCTF</span>{1_l0v3_m461c_7r1ck5}</span></span></code></pre>
Flag: scriptCTF{1_l0v3_m461c_7r1ck5}</p>
Challenge: pdf</h1>


Opening the PDF was just a trol



Running strings on it made me think I had a quick win.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/pdf$</span> strings  challenge.pdf</span> |</span> grep</span> -i ctf</span></span>
scriptCTF</span>{this_is_def_the_flag_trust}</span></span></code></pre>
Hmm.. quite easy. Or is it? Turns out this was the site-wide fake flag. Let's continue.</p>
Running binwalk gives us.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/pdf$</span> binwalk challenge.pdf</span></span>
</span>
DECIMAL</span>       HEXADECIMAL     DESCRIPTION</span></span>
--------------------------------------------------------------------------------</span></span>
0</span>             0x0</span>             PDF document, version: "1.4"</span></span>
283</span>           0x11B</span>           Zlib compressed data, default compression</span></span>
1521</span>          0x5F1</span>           Copyright string: "copyright/ordfeminine 172/logicalnot/.notdef/registered/macron/degree/plusminus/twosuperior/threesuperior/acute/mu 183/periodcen"</span></span></code></pre>
binwalk found a zlib chunk at offset 0x11B (decimal 283). Extracting</p>
binwalk</span> -eM challenge.pdf</span></span>
ls</span> -la _challenge.pdf.extracted</span></span></code></pre>
We get the flag</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/pdf/_challenge.pdf.extracted$</span> file</span> *</span></span>
11B:</span>      ASCII text, with no line terminators</span></span>
11B.zlib:</span> zlib compressed data</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/pdf/_challenge.pdf.extracted$</span> cat 11B</span></span>
scriptCTF</span>{pdf_s7r34m5_0v3r_7w17ch_5tr34ms}</span></span>
</span></code></pre>
Flag: scriptCTF{pdf_s7r34m5_0v3r_7w17ch_5tr34ms}</code></p>
Challenge: Just Some Avocado</h1>
</p>
This is another forensics challenge; we are given a JPEG file with an image of an avocado. Preliminary investigations reveal some interesting objects.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> file avocado.jpg</span></span>
avocado.jpg:</span> JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 1280x1280, components</span> 3</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> strings -4 avocado.jpg</span> |</span> grep</span> -i script</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> exiftool avocado.jpg</span></span>
ExifTool</span> Version Number         :</span> 13.25</span></span>
File</span> Name                       : avocado.jpg</span></span>
Directory</span>                       : .</span></span>
File</span> Size                       :</span> 509</span> kB</span></span>
File</span> Modification Date/Time     : 2025:08:14 03:40:32+03:00</span></span>
File</span> Access Date/Time           : 2025:08:16 17:15:16+03:00</span></span>
File</span> Inode Change Date/Time     : 2025:08:16 17:15:11+03:00</span></span>
File</span> Permissions                : -rw-rw-r--</span></span>
File</span> Type                       : JPEG</span></span>
File</span> Type Extension             : jpg</span></span>
MIME</span> Type                       : image/jpeg</span></span>
JFIF</span> Version                    :</span> 1.01</span></span>
Resolution</span> Unit                 : None</span></span>
X</span> Resolution                    :</span> 1</span></span>
Y</span> Resolution                    :</span> 1</span></span>
Image</span> Width                     :</span> 1280</span></span>
Image</span> Height                    :</span> 1280</span></span>
Encoding</span> Process                : Baseline DCT, Huffman coding</span></span>
Bits</span> Per Sample                 :</span> 8</span></span>
Color</span> Components                :</span> 3</span></span>
Y</span> Cb Cr Sub Sampling            : YCbCr4:2:0</span> (2</span> 2</span>)</span></span>
Image</span> Size                      : 1280x1280</span></span>
Megapixels</span>                      :</span> 1.6</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> binwalk avocado.jpg</span></span>
</span>
DECIMAL</span>       HEXADECIMAL     DESCRIPTION</span></span>
--------------------------------------------------------------------------------</span></span>
0</span>             0x0</span>             JPEG image data, JFIF standard</span> 1.01</span></span>
100599</span>        0x188F7</span>         Zip archive data, encrypted at least v1.0 to extract, compressed size: 234, uncompressed size: 222, name: justsomezip.zip</span></span>
100922</span>        0x18A3A</span>         Zip archive data, encrypted at least v2.0 to extract, compressed size: 408140, uncompressed size: 437908, name: staticnoise.wav</span></span>
509321</span>        0x7C589</span>         End of Zip archive, footer length:</span> 22</span></span></code></pre>
Embedded within the image are two files, a zip file justsomezip.zip</code> and a wav audio file staticnoise.wav . Extracting the files</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> dd if=avocado.jpg of=justsomezip.zip bs=</span>1</span> skip=</span>100599</span></span>
</span>
408744+0</span> records in</span></span>
408744+0</span> records out</span></span>
408744</span> bytes</span> (409</span> kB,</span> 399</span> KiB</span>) copied, 0.713391 s, 573 kB/s</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> dd if=avocado.jpg of=staticnoise.wav  bs=</span>1</span> skip=</span>100922</span></span>
</span>
408421+0</span> records in</span></span>
408421+0</span> records out</span></span>
408421</span> bytes</span> (408</span> kB,</span> 399</span> KiB</span>) copied, 0.725639 s, 563 kB/s</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> ls</span></span>
avocado.jpg</span>  justsomezip.zip  staticnoise.wav</span></span></code></pre>
The zip file is password-protected. I'll try using John to crack it.</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> zip2john justsomezip.zip</span> ></span> hash.txt</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado$</span> john --format=PKZIP hash.txt --wordlist=/usr/share/wordlists/rockyou.txt</span></span>
</span>
Using</span> default input encoding: UTF-8</span></span>
Loaded</span> 1</span> password hash</span> (PKZIP [32/64])</span></span>
Will</span> run</span> 4</span> OpenMP threads</span></span>
Press</span> 'q' or Ctrl-C to abort, almost any other key for status</span></span>
impassive3428</span>    (justsomezip.zip)</span></span>
1g</span> 0:00:00:01 DONE</span> (2025-08-17</span> 17:16</span>) 0.7633g/s 5609Kp/s 5609Kc/s 5609KC/s in4nd0keren..imissdesi</span></span>
Use</span> the "--show" option to display all of the cracked passwords reliably</span></span>
Session</span> completed.</span></span></code></pre>
After a few seconds, the password is revealed to be impassive3428</code>. Inside the zip were two files with the same name as before</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado/justsomezip$</span> tree</span></span>
.</span></span>
├──</span> justsomezip.zip</span></span>
└──</span> staticnoise.wav</span></span>
</span>
1</span> directory,</span> 2</span> files</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado/justsomezip$</span> file</span> *</span></span>
justsomezip.zip:</span> Zip archive data, made by v3.0 UNIX, extract using at least v1.0, last modified Jun</span> 24 2025</span> 19:12:42, uncompressed size 28, method=store</span></span>
staticnoise.wav:</span> RIFF</span> (little-endian) data, WAVE audio, Microsoft PCM, 16 bit, stereo 22050 Hz</span></span></code></pre>
I tried brute-forcing the password again, but there were no positive results, so I shifted my focus onto the WAV file. Running exiftool on it showed a telling comment. The password couldn't be brute-forced</p>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado/justsomezip$</span> exiftool staticnoise.wav</span></span>
ExifTool</span> Version Number         :</span> 13.25</span></span>
File</span> Name                       : staticnoise.wav</span></span>
Directory</span>                       : .</span></span>
File</span> Size                       :</span> 438</span> kB</span></span>
File</span> Modification Date/Time     : 2025:06:25 13:38:40+03:00</span></span>
File</span> Access Date/Time           : 2025:08:17 17:18:23+03:00</span></span>
File</span> Inode Change Date/Time     : 2025:08:17 17:18:17+03:00</span></span>
File</span> Permissions                : -rw-r--r--</span></span>
File</span> Type                       : WAV</span></span>
File</span> Type Extension             : wav</span></span>
MIME</span> Type                       : audio/x-wav</span></span>
Encoding</span>                        : Microsoft PCM</span></span>
Num</span> Channels                    :</span> 2</span></span>
Sample</span> Rate                     :</span> 22050</span></span>
Avg</span> Bytes Per Sec               :</span> 88200</span></span>
Bits</span> Per Sample                 :</span> 16</span></span>
Comment</span>                         : What if my password isn't on rockyou.txt</span></span>
Software                        : Lavf61.7.100</span></span>
Duration                        : 4.96 s</span></span>
</span></code></pre>
I opened the file in Sonic Visualizer and applied a spectrogram view. Here is what shows

</p>
It looks like some embedded text, but it's clipped. I redid the same process in Audacity, and this is what it shows.</p>
</p>
I can make out the first three characters, d41, and the fifth 3</code>. We can use John's mask mode to generate the possible combinations.</p>
john</span> --mask='d41?1?1?1?1?1' --1='?l?d' --format=PKZIP hash.txt</span></span></code></pre>

d41 = known prefix</li>
?1?1?1?1?1 = 5 unknown characters</li>
--1='?l?d' = defines ?1 as “lowercase letters or digits”</li>
--format=PKZIP = tells John it’s a ZIP hash</li>
</ul>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado/justsomezip$</span> john --mask='d41?1?1?1?1?1' --1='?l?d' --format=PKZIP hash.txt</span></span>
</span>
Using</span> default input encoding: UTF-8</span></span>
Loaded</span> 1</span> password hash</span> (PKZIP [32/64])</span></span>
Will</span> run</span> 4</span> OpenMP threads</span></span>
Press</span> 'q' or Ctrl-C to abort, almost any other key for status</span></span>
d41v3ron</span>         (justsomezip.zip/flag.txt)</span></span>
1g</span> 0:00:00:00 DONE</span> (2025-08-17</span> 21:23</span>) 1.388g/s 9545Kp/s 9545Kc/s 9545KC/s d41v7non..d41oddon</span></span>
Use</span> the "--show" option to display all of the cracked passwords reliably</span></span>
Session</span> completed.</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado/justsomezip$</span> unzip justsomezip.zip</span></span>
Archive:</span>  justsomezip.zip</span></span>
[</span>justsomezip.zip</span>]</span> flag.txt password:</span></span>
extracting:</span> flag.txt</span></span>
</span>
mockingspectre@kali:~/ctf/scriptctf2025/forensics/justsome-avocado/justsomezip$</span> cat flag.txt</span></span>
scriptCTF</span>{1_l0ve_d41_v3r0n}</span></span></code></pre>
Flag: scriptCTF{1_l0ve_d41_v3r0n}</code></p>
Challenge: RSA-1</h1>
</p>
The attachment out.txt has</p>
out.txt has: n1 = 156503881374173899106040027210320626006530930815116631795516553916547375688556673985142242828597628615920973708595994675661662789752600109906259326160805121029243681236938272723595463141696217880136400102526509149966767717309801293569923237158596968679754520209177602882862180528522927242280121868961697240587 c1 = 77845730447898247683281609913423107803974192483879771538601656664815266655476695261695401337124553851404038028413156487834500306455909128563474382527072827288203275942719998719612346322196694263967769165807133288612193509523277795556658877046100866328789163922952483990512216199556692553605487824176112568965 n2 = 81176790394812943895417667822424503891538103661290067749746811244149927293880771403600643202454602366489650358459283710738177024118857784526124643798095463427793912529729517724613501628957072457149015941596656959113353794192041220905793823162933257702459236541137457227898063370534472564804125139395000655909 c2 = 40787486105407063933087059717827107329565540104154871338902977389136976706405321232356479461501507502072366720712449240185342528262578445532244098369654742284814175079411915848114327880144883620517336793165329893295685773515696260299308407612535992098605156822281687718904414533480149775329948085800726089284 n3 = 140612513823906625290578950857303904693579488575072876654320011261621692347864140784716666929156719735696270348892475443744858844360080415632704363751274666498790051438616664967359811895773995052063222050631573888071188619609300034534118393135291537302821893141204544943440866238800133993600817014789308510399 c3 = 100744134973371882529524399965586539315832009564780881084353677824875367744381226140488591354751113977457961062275480984708865578896869353244823264759044617432862876208706282555040444253921290103354489356742706959370396360754029015494871561563778937571686573716714202098622688982817598258563381656498389039630 e = 3</span></span></code></pre>
this is the classic low-exponent (e = 3) broadcast attack. To crack it:</p>


Use the three ciphertexts c1,c2,c3c_1,c_2,c_3c1,c2,c3 and moduli n1,n2,n3n_1,n_2,n_3n1,n2,n3.</p>
</li>

Combine them with the Chinese Remainder Theorem to reconstruct M=m3 mod NM = m^3 bmod NM=m3modN where N=n1n2n3N = n_1 n_2 n_3N=n1n2n3. Because the original message mmm is smaller than each modulus and m3<Nm^3 < Nm3<N, CRT yields the actual integer m3m^3m3.</p>
</li>

Take the integer cube root of MMM to get mmm.</p>
</li>

Decode mmm to bytes — the result contained PKCS#7-style padding (0x12 repeated), so stripping that reveals the flag.</p>
</li>
</ol>
This calls for the good old Python script:</p>
def</span> egcd</span>(</span>a</span>,</span>b</span>):</span></span>
    if</span> b</span> ==</span> 0</span>:</span></span>
        return</span> (</span>1</span>,</span> 0</span>,</span> a</span>)</span></span>
    x</span>,</span>y</span>,</span>g</span> =</span> egcd</span>(</span>b</span>,</span> a</span> %</span> b</span>)</span></span>
    return</span> (</span>y</span>,</span> x</span> -</span> (</span>a</span> //</span> b</span>)</span> *</span> y</span>,</span> g</span>)</span></span>
</span>
def</span> invmod</span>(</span>a</span>,</span>m</span>):</span></span>
    x</span>,</span>y</span>,</span>g</span> =</span> egcd</span>(</span>a</span>,</span>m</span>)</span></span>
    if</span> g</span> !=</span> 1</span>:</span></span>
        raise</span> Exception</span>(</span>"no inverse"</span>)</span></span>
    return</span> x</span> %</span> m</span></span>
</span>
def</span> iroot</span>(</span>k</span>,</span> n</span>):</span></span>
    low</span>,</span> high</span> =</span> 0</span>,</span> 1</span> <<</span> ((</span>n</span>.</span>bit_length</span>()</span>+</span>k</span>-</span>1</span>)</span>//</span>k</span> +</span> 1</span>)</span></span>
    while</span> low</span> <</span> high</span>:</span></span>
        mid</span> =</span> (</span>low</span>+</span>high</span>)</span>//</span>2</span></span>
        if</span> midk</span> <</span> n</span>:</span></span>
            low</span> =</span> mid</span>+</span>1</span></span>
        else</span>:</span></span>
            high</span> =</span> mid</span></span>
    return</span> low</span>-</span>1</span></span>
</span>
n1</span>=</span>156503881374173899106040027210320626006530930815116631795516553916547375688556673985142242828597628615920973708595994675661662789752600109906259326160805121029243681236938272723595463141696217880136400102526509149966767717309801293569923237158596968679754520209177602882862180528522927242280121868961697240587</span></span>
</span>
c1</span>=</span>77845730447898247683281609913423107803974192483879771538601656664815266655476695261695401337124553851404038028413156487834500306455909128563474382527072827288203275942719998719612346322196694263967769165807133288612193509523277795556658877046100866328789163922952483990512216199556692553605487824176112568965</span></span>
</span>
n2</span>=</span>81176790394812943895417667822424503891538103661290067749746811244149927293880771403600643202454602366489650358459283710738177024118857784526124643798095463427793912529729517724613501628957072457149015941596656959113353794192041220905793823162933257702459236541137457227898063370534472564804125139395000655909</span></span>
</span>
c2</span>=</span>40787486105407063933087059717827107329565540104154871338902977389136976706405321232356479461501507502072366720712449240185342528262578445532244098369654742284814175079411915848114327880144883620517336793165329893295685773515696260299308407612535992098605156822281687718904414533480149775329948085800726089284</span></span>
</span>
n3</span>=</span>140612513823906625290578950857303904693579488575072876654320011261621692347864140784716666929156719735696270348892475443744858844360080415632704363751274666498790051438616664967359811895773995052063222050631573888071188619609300034534118393135291537302821893141204544943440866238800133993600817014789308510399</span></span>
</span>
c3</span>=</span>100744134973371882529524399965586539315832009564780881084353677824875367744381226140488591354751113977457961062275480984708865578896869353244823264759044617432862876208706282555040444253921290103354489356742706959370396360754029015494871561563778937571686573716714202098622688982817598258563381656498389039630</span></span>
</span>
e</span> =</span> 3</span></span>
</span>
# CRT combine</span></span>
N</span> =</span> n1</span> *</span> n2</span> *</span> n3</span></span>
m1</span> =</span> N</span> //</span> n1</span></span>
m2</span> =</span> N</span> //</span> n2</span></span>
m3</span> =</span> N</span> //</span> n3</span></span>
C</span> =</span> (</span>m1</span>*</span>invmod</span>(</span>m1</span>,</span>n1</span>)</span>*</span>c1</span> +</span> m2</span>*</span>invmod</span>(</span>m2</span>,</span>n2</span>)</span>*</span>c2</span> +</span> m3</span>*</span>invmod</span>(</span>m3</span>,</span>n3</span>)</span>*</span>c3</span>)</span> %</span> N</span></span>
</span>
# integer cube root</span></span>
m</span> =</span> iroot</span>(</span>e</span>,</span> C</span>)</span></span>
mb</span> =</span> m</span>.</span>to_bytes</span>((</span>m</span>.</span>bit_length</span>()</span>+</span>7</span>)</span>//</span>8</span>,</span> 'big'</span>)</span></span>
</span>
# strip PKCS#7 padding</span></span>
pad</span> =</span> mb</span>[</span>-</span>1</span>]</span></span>
flag</span> =</span> mb</span>[:</span>-</span>pad</span>].</span>decode</span>()</span></span>
print</span>(</span>flag</span>)</span></span></code></pre>
Running this, we get the flag:</p>
mockingspectre@kali:~/ctf/scriptctf2025/crypto/RSA-1$</span> python3 solve.py</span></span>
scriptCTF</span>{y0u_f0und_mr_yu</span>'s_s3cr3t_m3g_12a4e4}</span></span></code></pre>
Flag: scriptCTF{y0u_f0und_mr_yu's_s3cr3t_m3g_12a4e4}</code></p>
Challenge: Secure-Server</h1>
</p>
The provided files are a network capture(pcap) and a Python file. The contents of the Python file are</p>
import</span> os</span></span>
from</span> pwn</span> import</span> xor</span></span>
print</span>(</span>"With the Secure Server, sharing secrets is safer than ever!"</span>)</span></span>
enc</span> =</span> bytes</span>.</span>fromhex</span>(</span>input</span>(</span>"Enter the secret, XORed by your key (in hex): "</span>).</span>strip</span>())</span></span>
key</span> =</span> os</span>.</span>urandom</span>(</span>32</span>)</span></span>
enc2</span> =</span> xor</span>(</span>enc</span>,</span>key</span>).</span>hex</span>()</span></span>
print</span>(</span>f</span>"Double encrypted secret (in hex): </span>{</span>enc2</span>}</span>"</span>)</span></span>
dec</span> =</span> bytes</span>.</span>fromhex</span>(</span>input</span>(</span>"XOR the above with your key again (in hex): "</span>).</span>strip</span>())</span></span>
secret</span> =</span> xor</span>(</span>dec</span>,</span>key</span>)</span></span>
print</span>(</span>"Secret received!"</span>)</span></span></code></pre>
Opening the pcap file in Wireshark, we get some TCP streams that we follow and see.</p>
</p>
To decrypt it</p>
from</span> binascii</span> import</span> unhexlify</span></span>
</span>
def</span> xor_bytes</span>(</span>a</span>,</span> b</span>):</span></span>
    return</span> bytes</span>(</span>x</span> ^</span> y</span> for</span> x</span>,</span> y</span> in</span> zip</span>(</span>a</span>,</span> b</span>))</span></span>
</span>
# Variables from the captured session</span></span>
enc</span> =</span> bytes</span>.</span>fromhex</span>(</span>"151e71ce4addf692d5bac83bb87911a20c39b71da3fa5e7ff05a2b2b0a83ba03"</span>)</span></span>
enc2</span> =</span> bytes</span>.</span>fromhex</span>(</span>"e1930164280e44386b389f7e3bc02b707188ea70d9617e3ced989f15d8a10d70"</span>)</span></span>
dec</span> =</span> bytes</span>.</span>fromhex</span>(</span>"87ee02c312a7f1fef8f92f75f1e60ba122df321925e8132068b0871ff303960e"</span>)</span></span>
</span>
# Recover the key</span></span>
key</span> =</span> xor_bytes</span>(</span>enc</span>,</span> enc2</span>)</span></span>
</span>
# Recover the secret</span></span>
secret</span> =</span> xor_bytes</span>(</span>dec</span>,</span> key</span>)</span></span>
</span>
print</span>(</span>"Recovered key:"</span>,</span> key</span>.</span>hex</span>())</span></span>
print</span>(</span>"Recovered secret:"</span>,</span> secret</span>.</span>decode</span>())</span></span></code></pre>
Running this, we get the flag in plaintext.</p>
mockingspectre@kali:~/ctf/scriptctf2025/crypto/Secure-Server$</span> python3 solve.py</span></span>
Recovered</span> key: f48d70aa62d3b2aabe82574583b93ad27db15d6d7a9b20431dc2b43ed222b773</span></span>
Recovered</span> secret: scriptCTF{x0r_1s_not_s3cur3!!!!}</span></span></code></pre>
The server prints enc2</code> (which leaks enc XOR key</code>) while also sending/receiving the original enc</code> and the follow-up dec</code>. With both enc</code> and enc2,</code> an eavesdropper can derive the session key (enc XOR enc2</code>) and then decrypt whatever the client sends later (dec XOR key</code>) — so the server ends up leaking secrets it was supposed to protect.

Flag: scriptCTF{x0r_1s_not_s3cur3!!!!}</code></p>


mmuctf 2025 writeup
mockingspectre — Sun, 03 Aug 2025 00:00:00 +0000
Over the weekend, I had the opportunity to participate in the mmuctf 2025. It was an individual jeopardy style CTF targeted towards beginners and intermediate people in cybersecurity. This is a write-up to explore some challenges I did, or at least almost did.</p>
Welcome</h2>

Through the shadows of the cave, at the door I had a zeal to get a welcome flag, but I couldn't see it though
I could hear it calling for me to get it. Happy hacking
{: .prompt-info }</p>
</blockquote>
This was a sanity check flag. I believe competitions pose such challenges that you can't get zero points. It's the same as flags in Discord servers, a flag after completing the feedback form, or just other free points.</p>
The challenge description talked about the door</code>, my first instinct was to view the source of the front page. I got this html comment with what looked liked a base64 encoded string <!--bW11Y3Rme3dlbGNvbWVfZmxhZ19hZGlvc19NdWNoQGNob30= --></code></p>
┌──(mockingspectre㉿blackout</span>)-</span>[</span>~/ctf/mmuctf2025</span>]</span></span>
└─$</span> echo -n "bW11Y3Rme3dlbGNvbWVfZmxhZ19hZGlvc19NdWNoQGNob30="</span> |</span> base64</span> -d</span></span>
mmuctf</span>{welcome_flag_adios_Much@cho}</span></span></code></pre>My First App</h2>

Our intern dev swears this app’s secure...</p>
</blockquote>
This was a web challenge with an account creation form. Let's fire up Burp. The account creation request didn't seem suspicious for now, so I sent it to the repeater to abuse it some more. The response seemed interesting, the user id was in the query parameter: GET /profile.php?id=5 HTTP/1.1</code>. This was a nice candidate for an Insecure Direct Object Reference(IDOR). I tried repeating the request with values from 0-4. The flag was at 1, the admin user's account.</p>
mmuctf{1d0r_4dm1n_4cc3ss_1s_c0mpr0m1s3d}</span></span></code></pre>Ledilect</h2>

Sometimes the path you take is just a jump away.</p>
</blockquote>
This was a simple one, I knew what the challenge wanted, but I couldn't get myself to exploit it, definitely a skill issue. The webapp had a landing page that had a button that made this request:</p>
GET /portal/jump.php?url=https://example.com HTTP/1.1</span></span>
Host: redacted</span></span>
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0</span></span>
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8</span></span>
Accept-Language: en-US, en;q=0.5</span></span>
Accept-Encoding: gzip, deflate, br</span></span>
Connection: keep-alive</span></span>
Referer: redacted</span></span>
Cookie: PHPSESSID=ce7743f6cd447d7a1ee94e230c3d9cdb</span></span>
Upgrade-Insecure-Requests: 1</span></span>
Priority: u=0, i</span></span></code></pre>
Looking at that, I suspected an open redirect vulnerability, but I don't know anything about this bug class. I let it rest.</p>
Meet my X</h2>

Iｎ tｈｅ�days оｆ cοｍfoｒt ｉ ｍeｔ tｈis ｇｉrl ａｔ thｅ Ｊobleｓs соrｎｅr. Аt ｔｈe�doоrs ａnd windows of iddleness i approached, oops she smiled and thats how i knew she was the one. I guess thatsss whyyy i learned on getting Flags because be warned she later left me at first it feels like a green flag i guess no life was there on blood(heart_break)</p>
</blockquote>
This challenge involved homoglyphs, a character or a sequence of characters that looks very similar or identical to another character or sequence of characters, but has a different meaning, encoding, or origin.</p>
A sentence might look normal, but if you copy it into a text editor that shows Unicode details or a specialized homoglyph detector, you'll see different underlying character codes.</p>
I used these online decoders, https://wulfsige.com/crypto/</a> and https://holloway.nz/steg/</a> to get the flag:</p>
mmuctf{oops_twitter_steg_1s_fun}</span></span></code></pre>Shadow</h2>

Look beyond the appearance, perhaps their numerical essence will guide you to the flag.
Can you reveal what lurks in the shadow?</p>
</blockquote>
This was another stego challenge; there is an image with what looks like a color palette. The description hints at 'numerical essence', so it might be something to deal with the hex values of the colors. I used this site https://imagecolorpicker.com/</a> to extract the hex values.</p>
#6d6d75</span></span>
#637466</span></span>
#7b346c</span></span>
#773479</span></span>
#355f68</span></span>
#316464</span></span>
#336e5f</span></span>
#316e35</span></span>
#64335f</span></span>
#6d337d</span></span></code></pre>
Decoded becomes</p>
mmuctf{4lw4y5_h1dd3n_1n5d3_m3}</span></span></code></pre>Revealme</h2>

We found this mysterious executable on an old USB stick... Can you figure out how to get it to reveal the flag?</p>
</blockquote>
The provided file is an ELF executable binary.</p>
┌──(mockingspectre㉿blackout</span>)-</span>[</span>~/ctf/mmuctf2025</span>]</span></span>
└─$</span> file revealme</span></span>
revealme:</span> ELF 64-bit LSB pie executable, x86-64, version</span> 1</span> (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID</span>[</span>sha1</span>]</span>=</span>d8546bb2c10c0226384fb2771684af9bc150b55e,</span> for</span> GNU/Linux 3.2.0, stripped</span></span></code></pre>┌──(mockingspectre㉿blackout</span>)-</span>[</span>~/ctf/mmuctf2025</span>]</span></span>
└─$</span> checksec --file=revealme</span></span>
RELRO</span>           STACK CANARY      NX            PIE             RPATH      RUNPATH      Symbols         FORTIFY Fortified       Fortifiable     FILE</span></span>
Partial</span> RELRO   No canary found   NX enabled    PIE enabled     No RPATH   No RUNPATH   No Symbols        No</span>    0               2</span>               revealme</span></span></code></pre>
Opening it with Binary Ninja gives us a quick win:</p>
00401179</span>    int32_t main(int32_t argc, char** argv, char** envp)</span></span>
</span>
</span>
00401179  55</span>                 push</span>    rbp</span> {__saved_rbp}</span></span>
0040117a  </span>4889e5</span>             mov</span>     rbp</span>, </span>rsp</span> {__saved_rbp}</span></span>
0040117d</span>  4883ec70           </span>sub</span>     rsp</span>, </span>0x70</span></span>
00401181</span>  488d05800e0000     </span>lea</span>     rax</span>, [</span>rel</span> data_402008]</span></span>
00401188</span>  4889c7             </span>mov</span>     rdi</span>, </span>rax</span>  {data_402008, "</span>Enter</span> the secret </span>passphrase</span>:</span> "}</span></span>
0040118b  b800000000         </span>mov</span>     eax</span>, </span>0x0</span></span>
00401190</span>  e8abfeffff         </span>call</span>    printf</span></span>
00401195</span>  488b15a42e0000     </span>mov</span>     rdx</span>, </span>qword</span> [</span>rel</span> stdin]</span></span>
0040119c  488d4590           </span>lea</span>     rax</span>, [</span>rbp</span>-</span>0x70</span> {buf}]</span></span>
004011a0  be64000000         </span>mov</span>     esi</span>, </span>0x64</span></span>
004011a5  4889c7             </span>mov</span>     rdi</span>, </span>rax</span> {buf}</span></span>
004011a8  e8b3feffff         </span>call</span>    fgets</span></span>
004011ad  488d4590           </span>lea</span>     rax</span>, [</span>rbp</span>-</span>0x70</span> {buf}]</span></span>
004011b1  488d156e0e0000     </span>lea</span>     rdx</span>, [</span>rel</span> data_402026]</span></span>
004011b8  4889d6             </span>mov</span>     rsi</span>, </span>rdx</span>  {data_402026}</span></span>
004011bb  4889c7             </span>mov</span>     rdi</span>, </span>rax</span> {buf}</span></span>
004011be  e88dfeffff         </span>call</span>    strcspn</span></span>
004011c3  c644059000         </span>mov     byte</span> [</span>rbp</span>+</span>rax</span>-</span>0x70</span> {buf}], </span>0x0</span></span>
004011c8  488d4590           </span>lea</span>     rax</span>, [</span>rbp</span>-</span>0x70</span> {buf}]</span></span>
004011cc  488d15550e0000     </span>lea</span>     rdx</span>, [</span>rel</span> data_402028]</span></span>
004011d3  4889d6             </span>mov</span>     rsi</span>, </span>rdx</span>  {data_402028, "OpenSesame123!"}</span></span>
004011d6  4889c7             </span>mov</span>     rdi</span>, </span>rax</span> {buf}</span></span>
004011d9  e892feffff         </span>call</span>    strcmp</span></span>
004011de  85c0               </span>test</span>    eax</span>, </span>eax</span></span>
004011e0  7511</span>               jne</span>     0x4011f3</span></span>
</span>
</span>
004011e2</span>  488d054f0e0000     </span>lea</span>     rax</span>, [</span>rel</span> data_402038]</span></span>
004011e9</span>  4889c7             </span>mov</span>     rdi</span>, </span>rax</span>  {data_402038, "Correct! The flag </span>is</span>:</span> mmuctf{r3v3rs1ng_st4rt3r}"}</span></span>
004011ec  e83ffeffff         </span>call</span>    puts</span></span>
004011f1  eb0f               </span>jmp</span>     0x401202</span></span>
</span>
</span>
004011f3  488d056e0e0000     </span>lea</span>     rax</span>, [</span>rel</span> data_402068]</span></span>
004011fa  4889c7             </span>mov</span>     rdi</span>, </span>rax</span>  {data_402068, "Nope, try again."}</span></span>
004011fd  e82efeffff         </span>call</span>    puts</span></span>
</span>
</span>
00401202</span>  b800000000         </span>mov</span>     eax</span>, </span>0x0</span></span>
00401207</span>  c9                 </span>leave</span>    {__saved_rbp}</span></span>
00401208</span>  c3                 </span>retn</span>     {__return_addr}</span></span></code></pre>
Flag:</p>
mmuctf{r3v3rs1ng_st4rt3r}</span></span></code></pre>Flicker</h2>

An ordinary looking Android app... or is it?</p>
</blockquote>
The provided app is an Android APK. Let's fire up jadx-gui. The package name is com.example.blink</code>. There is an interesting class r2d2</code>. In the onCreate method, there is an image string variable that seems to contain base64 image data.</p>
┌──(mockingspectre㉿blackout</span>)-</span>[</span>~/ctf/mmuctf2025</span>]</span></span>
└─$</span> cat output.txt</span> |</span> base64</span> -d</span> ></span> decoded_image.png</span></span></code></pre>
flag:</p>
CTF{PUCKMAN}</span></span></code></pre>Open_Secrets</h2>

Someone trusted the wrong site and network didn’t forget. Can you piece together what was left behind?
Some people still think locks are optional on digital doors.*</p>
</blockquote>
The provided file was a network capture pcap file. For people who don't know, pcap (a packet capture) consists of an application programming interface (API) for capturing network traffic.The challenge title and filename hint at unencrypted traffic. Open up Wireshark and apply an HTTP filter. There is an HTTP stream that leaks the flag:</p>
mmuctf{plaintext_login_leak}</span></span></code></pre>C-x C-s</h2>

Ugh, I keep typing ^x ^s in my shell instead of saving, should’ve stuck with Emacs</p>
</blockquote>
This one made me mad. I thought I had the flag, but I couldn't get it. The provided file is a PCAP file. Another network forensics challenge, or so I thought.</p>
opened the file with Wireshark packet and noticed a new kind of communication, to be honest, I didn't know this was possible until I understood what was happening...</p>
I found some articles dealing with this</p>

https://abawazeeer.medium.com/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4</a></li>
https://res260.medium.com/usb-pcap-forensics-barcode-scanner-nsec-ctf-2021-writeup-part-1-3-b0a5392c9313</a></li>
https://steemit.com/reverseengineering/@nileshevrywhr/auth0-ctf-reverse-engineering-usb-keystrokes-from-pcaps</a></li>
</ul>
The source and destination use object IDs for communication, something I gathered when reading about the SNMP
protocol, USB(Universal Serial Bus)
it's apparent I'm not dealing with any 802.x traffic</p>
Interrupts happen whenever you press a key or click a button, anything that "interrupts" the CPU, after which it has to process your input. Each URB_INTERRUPT in the file corresponds to a key pressed, and the Leftover Capture Data field shows the hex value of the key in 8-byte format.</p>
Creating a filter to list all interrupt communication with non-empty 8 bytes</p>
usb.transfer_type == 0x01</span></span></code></pre>usb.transfer_type == 0x01 && usb.dst == "host" && !(usb.capdata == 00:00:00:00:00:00:00:00)</span></span></code></pre>
Crafting a tshark command to get the leftover capture data for the above filters and redirect it into a file</p>
tshark</span> -r log.pcap -Tfields -Eseparator=, -e thekey.pcapng -Y 'usb.transfer_type == 0x01 && usb.dst == "host" && !(usb.capdata == 00:00:00:00:00:00:00:00)'</span> |</span> sed</span> 's/://g'</span> ></span> usb.capdata</span></span></code></pre>┌──(mockingspectre㉿blackout</span>)-</span>[</span>~/ctf/mmuctf2025</span>]</span></span>
└─$</span> tshark -r thekey.pcapng -Tfields -Eseparator=, -e usb.capdata -Y 'usb.transfer_type == 0x01 && usb.dst == "host" && !(usb.capdata == 00:00:00:00:00:00:00:00)'</span> |</span> sed</span> 's/://g'</span> ></span> usb.capdata</span></span>
</span>
┌──(mockingspectre㉿blackout</span>)-</span>[</span>~/ctf/mmuctf2025</span>]</span></span>
└─$</span> cat usb.capdata</span></span>
0000190000000000</span></span>
00000c0000000000</span></span>
00000c1000000000</span></span>
0000102c00000000</span></span>
00002c0000000000</span></span>
0000090000000000</span></span>
00000f0000000000</span></span>
0000040000000000</span></span>
0000040a00000000</span></span>
................</span></span></code></pre>
Python script to decode the hex values to strings:</p>
keyboard</span> =</span> {</span></span>
   2</span>:</span> "PostFail"</span>,</span>    4</span>:</span> "a"</span>,</span>    5</span>:</span> "b"</span>,</span>    6</span>:</span> "c"</span>,</span>    7</span>:</span> "d"</span>,</span>    8</span>:</span> "e"</span>,</span>    9</span>:</span> "f"</span>,</span>    10</span>:</span> "g"</span>,</span>    11</span>:</span> "h"</span>,</span>    12</span>:</span> "i"</span>,</span>    13</span>:</span> "j"</span>,</span>    14</span>:</span> "k"</span>,</span>    15</span>:</span> "l"</span>,</span>    16</span>:</span> "m"</span>,</span>    17</span>:</span> "n"</span>,</span>    18</span>:</span> "o"</span>,</span>    19</span>:</span> "p"</span>,</span>    20</span>:</span> "q"</span>,</span>    21</span>:</span> "r"</span>,</span>    22</span>:</span> "s"</span>,</span>    23</span>:</span> "t"</span>,</span>    24</span>:</span> "u"</span>,</span>    25</span>:</span> "v"</span>,</span>    26</span>:</span> "w"</span>,</span>    27</span>:</span> "x"</span>,</span>    28</span>:</span> "y"</span>,</span>    29</span>:</span> "z"</span>,</span>    30</span>:</span> "1"</span>,</span>    31</span>:</span> "2"</span>,</span>    32</span>:</span> "3"</span>,</span>    33</span>:</span> "4"</span>,</span>    34</span>:</span> "5"</span>,</span>    35</span>:</span> "6"</span>,</span>    36</span>:</span> "7"</span>,</span>    37</span>:</span> "8"</span>,</span>    38</span>:</span> "9"</span>,</span>    39</span>:</span> "0"</span>,</span>    40</span>:</span> "Enter"</span>,</span>    41</span>:</span> "esc"</span>,</span>    2</span>:</span> "del"</span>,</span>    43</span>:</span> "tab"</span>,</span>    44</span>:</span> "space"</span>,</span>    45</span>:</span> "-"</span>,</span>    47</span>:</span> "["</span>,</span>    48</span>:</span> "]"</span>,</span>    51</span>:</span> "DownArrow"</span>,</span>    54</span>:</span> "1"</span>,</span>    55</span>:</span> "*"</span>,</span>    56</span>:</span> "/"</span>,</span>    57</span>:</span> "CapsLock"</span>,</span>    79</span>:</span> "RightArrow"</span>,</span>    80</span>:</span> "LeftArrow"</span></span>
}</span></span>
</span>
</span>
with</span> open</span>(</span>"usb.capdata"</span>)</span> as</span> file</span>:</span></span>
   i</span> =</span> 1</span></span>
   for</span> line</span> in</span> file</span>:</span></span>
       bytesArray</span> =</span> bytearray</span>.</span>fromhex</span>(</span>line</span>.</span>strip</span>())</span></span>
       for</span> byte</span> in</span> bytesArray</span>:</span></span>
           if</span> byte</span> !=</span> 0</span>:</span></span>
               keyVal</span> =</span> int</span>(</span>byte</span>)</span></span>
</span>
</span>
       if</span> keyVal</span> in</span> keyboard</span>:</span></span>
           print</span>(</span>keyboard</span>[</span>keyVal</span>])</span></span>
       else</span>:</span></span>
           print</span>(</span>"no map found for this value: "</span> +</span> str</span>(</span>keyVal</span>))</span></span>
</span>
</span>
   i</span> +=</span> 1</span></span></code></pre>
Running the code outputs what seems to be Vim motions. I wasn't able to decipher this to a correct flag:</p>
v</span></span>
i</span></span>
m</span></span>
space</span></span>
space</span></span>
f</span></span>
l</span></span>
a</span></span>
g</span></span>
g</span></span>
*</span></span>
t</span></span>
t</span></span>
x</span></span>
t</span></span>
Enter</span></span>
i</span></span>
3</span></span>
t</span></span>
t</span></span>
h</span></span>
e</span></span>
space</span></span>
f</span></span>
l</span></span>
a</span></span>
g</span></span>
g</span></span>
space</span></span>
i</span></span>
s</span></span>
space</span></span>
c</span></span>
t</span></span>
f</span></span>
esc</span></span>
v</span></span>
b</span></span>
3</span></span>
u</span></span>
u</span></span>
3</span></span>
a</span></span>
3</span></span>
[</span></span>
[</span></span>
m</span></span>
y</span></span>
3</span></span>
-</span></span>
3</span></span>
f</span></span>
a</span></span>
v</span></span>
o</span></span>
r</span></span>
i</span></span>
t</span></span>
e</span></span>
e</span></span>
3</span></span>
-</span></span>
e</span></span>
d</span></span>
i</span></span>
t</span></span>
o</span></span>
r</span></span>
3</span></span>
-</span></span>
3</span></span>
i</span></span>
s</span></span>
3</span></span>
-</span></span>
v</span></span>
i</span></span>
m</span></span>
3</span></span>
]</span></span>
esc</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
h</span></span>
a</span></span>
u</span></span>
esc</span></span>
v</span></span>
i</span></span>
3</span></span>
[</span></span>
3</span></span>
3</span></span>
u</span></span>
3</span></span>
esc</span></span>
3</span></span>
DownArrow</span></span>
DownArrow</span></span>
w</span></span>
q</span></span>
Enter</span></span>
a</span></span>
tab</span></span>
a</span></span>
e</span></span></code></pre>
These are the challenges I had the time to tackle. if you have any insights or suggestions. Share them in the comments</p>


cognitive inertia
mockingspectre — Wed, 26 Feb 2025 00:00:00 +0000
Staring at the void</p>
Cognitive inertia is the reason changing our habits can be difficult. If you want to overcome inertia you have to apply a force. I consider myself an eternal student, who is ready to learn anything, or so I thought. It happened but I had not noticed, I had stopped moving forward.</p>
Metawork</h2>
I will define this as the things we do before getting the "real" work doe. Its things like choosing the best IDE or text editor, setting up your coding environment, choosing the best note taking app, or even the 'best' operating system. They are the prerequisites of the actual work.</p>
I had been stuck on this loop, always trying to craft the perfect workflow. Setting up the best personalized linux distro, switching note taking apps, trying out multiple layouts, stylings and technologies for my blog, the list is endless.</p>
All of these metawork took more time thn the actual work; building, active learning and writing. Im going to stop all of these and start doing the important stuff.</p>


Export default and module.exports in Javascript
mockingspectre — Wed, 17 Jan 2024 00:00:00 +0000
Modules are the building blocks of modern JavaScript applications, allowing for the encapsulation of code into reusable components. Two primary systems govern the exportation of these modules: export default in ES6 and module.exports in CommonJS.</p>
Javascript is a popular programming language that can run both in the browser and on the server. However, different environments may have different ways of organizing and importing Javascript modules. In this article, we will compare two common methods of exporting and importing modules: export default</strong> and module.exports</strong>.</p>
What are modules?</h2>
Modules are reusable pieces of code that can be separated into different files. Modules can export values, functions, classes, or objects that can be imported by other modules. This way, modules can avoid polluting the global scope and enable code reuse and modularity.</p>
How to export modules in Node.js?</h2>
Node.js is a runtime environment that allows Javascript to run on the server. Node.js uses a module system called CommonJS, which is based on the require and module.exports syntax.</p>
To export a module in Node.js, you can assign the value that you want to export to the module.exports object. For example:</p>
// my-module.js</span></span>
// export a function</span></span>
module</span>.</span>exports</span> =</span> function</span> add</span>(</span>a</span>,</span> b</span>) {</span></span>
  return</span> a</span> +</span> b</span>;</span></span>
};</span></span>
</span>
// export an object</span></span>
module</span>.</span>exports</span> =</span> {</span></span>
  name</span>:</span> 'Alice'</span>,</span></span>
  age</span>:</span> 25</span>,</span></span>
};</span></span></code></pre>
To import a module in Node.js, you can use the require function and pass the path of the module file as an argument. The require function will return the value of module.exports from the module file. For example:</p>
// main.js</span></span>
// import a function</span></span>
const</span> add</span> =</span> require</span>(</span>'./my-module.js'</span>)</span>;</span></span>
console</span>.</span>log</span>(</span>add</span>(</span>2</span>,</span> 3</span>))</span>;</span> // 5</span></span>
</span>
// import an object</span></span>
const</span> person</span> =</span> require</span>(</span>'./my-module.js'</span>)</span>;</span></span>
console</span>.</span>log</span>(person</span>.</span>name)</span>;</span> // Alice</span></span>
console</span>.</span>log</span>(person</span>.</span>age)</span>;</span> // 25</span></span></code></pre>
Note that Node.js will cache the modules that are imported with require, so if you import the same module multiple times, you will get the same instance of the module.</p>
How to export modules in ES6?</h2>
ES6 is the version of Javascript that introduced many new features, including a native module system. ES6 modules use the import</code> and export</code> syntax.</p>
To export a module in ES6, you can use the export</code> keyword followed by the declaration of the value that you want to export. You can also use the export keyword with curly braces to export a list of named values. For example:</p>
// my-module.js</span></span>
// export a function</span></span>
export function</span> add</span>(</span>a</span>,</span> b</span>) {</span></span>
  return</span> a</span> +</span> b</span>;</span></span>
}</span></span>
</span>
// export a class</span></span>
export class</span> Person</span> {</span></span>
  constructor</span>(</span>name</span>,</span> age</span>) {</span></span>
    this</span>.</span>name</span> =</span> name</span>;</span></span>
    this</span>.</span>age</span> =</span> age</span>;</span></span>
  }</span></span>
}</span></span>
</span>
// export an object</span></span>
export const</span> person</span> =</span> {</span></span>
  name</span>:</span> 'Alice'</span>,</span></span>
  age</span>:</span> 25</span>,</span></span>
};</span></span></code></pre>
To import a module in ES6, you can use the import</code> keyword followed by the name of the value that you want to import and the path of the module file. You can also use the import keyword with curly braces to import a list of named values. For example:</p>
// main.js</span></span>
// import a function</span></span>
import</span> {</span> add</span> }</span> from</span> './my-module.js'</span>;</span></span>
console</span>.</span>log</span>(</span>add</span>(</span>2</span>,</span> 3</span>))</span>;</span> // 5</span></span>
</span>
// import a class</span></span>
import</span> {</span> Person</span> }</span> from</span> './my-module.js'</span>;</span></span>
const</span> person</span> =</span> new</span> Person</span>(</span>'Bob'</span>,</span> 30</span>)</span>;</span></span>
console</span>.</span>log</span>(person</span>.</span>name)</span>;</span> // Bob</span></span>
console</span>.</span>log</span>(person</span>.</span>age)</span>;</span> // 30</span></span>
</span>
// import an object</span></span>
import</span> {</span> person</span> as</span> Alice</span> }</span> from</span> './my-module.js'</span>;</span></span>
console</span>.</span>log</span>(Alice</span>.</span>name)</span>;</span> // Alice</span></span>
console</span>.</span>log</span>(Alice</span>.</span>age)</span>;</span> // 25</span></span></code></pre>
Note that ES6 modules are imported and executed only once, so if you import the same module multiple times, you will get the same instance of the module.</p>
What is the difference between export default and module.exports?</h2>
One of the main differences between export default and module.exports is that export default is an ES6 feature, while module.exports is a CommonJS feature. Therefore, they are not compatible with each other by default. However, some tools like Babel or Webpack can transpile ES6 modules to CommonJS modules, or vice versa, to make them work together.</p>
Another difference is that export default can only export one value per module, while module.exports can export any value, including multiple values. For example:</p>
// my-module.js</span></span>
// export default a function</span></span>
export default function</span> add</span>(</span>a</span>,</span> b</span>) {</span></span>
  return</span> a</span> +</span> b</span>;</span></span>
}</span></span>
</span>
// export default an object</span></span>
export default</span> {</span></span>
  name</span>:</span> "Alice"</span>,</span></span>
  age</span>:</span> 25</span>,</span></span>
};</span></span>
</span>
// export default a class</span></span>
export default class</span> Person</span> {</span></span>
  constructor</span>(</span>name</span>,</span> age</span>) {</span></span>
    this</span>.</span>name</span> =</span> name</span>;</span></span>
    this</span>.</span>age</span> =</span> age</span>;</span></span>
  }</span></span>
}</span></span></code></pre>// my-module.js</span></span>
// export a function</span></span>
module</span>.</span>exports</span> =</span> function</span> add</span>(</span>a</span>,</span> b</span>) {</span></span>
  return</span> a</span> +</span> b</span>;</span></span>
};</span></span>
</span>
// export an object</span></span>
module</span>.</span>exports</span> =</span> {</span></span>
  name</span>:</span> 'Alice'</span>,</span></span>
  age</span>:</span> 25</span>,</span></span>
};</span></span>
</span>
// export a class</span></span>
module</span>.</span>exports</span> =</span> class</span> Person</span> {</span></span>
  constructor</span>(</span>name</span>,</span> age</span>) {</span></span>
    this</span>.</span>name</span> =</span> name</span>;</span></span>
    this</span>.</span>age</span> =</span> age</span>;</span></span>
  }</span></span>
};</span></span></code></pre>
Note that you can only have one export default statement per module, but you can have multiple module.exports statements. However, each module.exports statement will overwrite the previous one, so only the last one will be exported.</p>
To import a default export, you can use the import keyword without curly braces and assign any name to the imported value. For example:</p>
// main.js</span></span>
// import a default export</span></span>
import</span> add</span> from</span> './my-module.js'</span>;</span></span>
console</span>.</span>log</span>(</span>add</span>(</span>2</span>,</span> 3</span>))</span>;</span> // 5</span></span>
</span>
// import another default export</span></span>
import</span> person</span> from</span> './my-module.js'</span>;</span></span>
console</span>.</span>log</span>(person</span>.</span>name)</span>;</span> // Alice</span></span>
console</span>.</span>log</span>(person</span>.</span>age)</span>;</span> // 25</span></span>
</span>
// import another default export</span></span>
import</span> Person</span> from</span> './my-module.js'</span>;</span></span>
const</span> person</span> =</span> new</span> Person</span>(</span>'Bob'</span>,</span> 30</span>)</span>;</span></span>
console</span>.</span>log</span>(person</span>.</span>name)</span>;</span> // Bob</span></span>
console</span>.</span>log</span>(person</span>.</span>age)</span>;</span> // 30</span></span></code></pre>
To import a module.exports value, you can use the require function and assign any name to the imported value. For example:</p>
// main.js</span></span>
// import a module.exports value</span></span>
const</span> add</span> =</span> require</span>(</span>'./my-module.js'</span>)</span>;</span></span>
console</span>.</span>log</span>(</span>add</span>(</span>2</span>,</span> 3</span>))</span>;</span> // 5</span></span>
</span>
// import another module.exports value</span></span>
const</span> person</span> =</span> require</span>(</span>'./my-module.js'</span>)</span>;</span></span>
console</span>.</span>log</span>(person</span>.</span>name)</span>;</span> // Alice</span></span>
console</span>.</span>log</span>(person</span>.</span>age)</span>;</span> // 25</span></span>
</span>
// import another module.exports value</span></span>
const</span> Person</span> =</span> require</span>(</span>'./my-module.js'</span>)</span>;</span></span>
const</span> person</span> =</span> new</span> Person</span>(</span>'Bob'</span>,</span> 30</span>)</span>;</span></span>
console</span>.</span>log</span>(person</span>.</span>name)</span>;</span> // Bob</span></span>
console</span>.</span>log</span>(person</span>.</span>age)</span>;</span> // 30</span></span></code></pre>
Node’s JavaScript has diverged from that of the browser. Understanding both CommonJS modules and ES6 modules is your first step in becoming a 10X developer. Happy coding!</p>


Setting up Obsidian sync in Windows
mockingspectre — Sun, 01 Oct 2023 00:00:00 +0000
Syncing Obsidian in Windows with Windows Task Scheduler and git</p>
Obsidian</a> is a powerful note-taking and knowledge management tool that has gained a dedicated following among researchers, writers, and knowledge workers. To make the most of Obsidian, it's essential to keep your notes synchronized across devices and ensure your data is regularly backed up.Obsidian is the private and flexible writing app that adapts to the way you think.</p>
Obsidian is free for personal use.It does not charge based on features or usage.You only pay if you use Obsidian commercially.</p>
In this article, we'll guide you through the process of setting up automated synchronization for your Obsidian vault on Windows using Windows Task Scheduler and a PowerShell script.1</a></sup></p>
Prerequisites</h2>
Before we dive into setting up the synchronization task, ensure you have the following prerequisites in place:</p>


Obsidian Installed:</strong> Make sure Obsidian is installed</a> on your Windows computer, and you have an existing Obsidian vault that you want to sync.</p>
</li>

Git Installed:</strong> You'll need Git installed and configured with your Obsidian vault's repository. If you haven't already done this, you can download Git from the official website</a> and follow the installation instructions.</p>
</li>

PowerShell Script:</strong> The provided PowerShell script, sync.ps1, should be located in your Obsidian vault folder.</p>
</li>
</ol>
Understanding the PowerShell Script</h2>
The provided PowerShell script, sync.ps1, is the heart of our synchronization task. It automates the process of committing changes in your Obsidian vault's Git repository and pushing them to your remote repository (e.g., GitHub or GitLab). Here's a brief overview of the script:</p>
# Define the folder path</span></span>
$FolderPath</span> =</span> "C:\path\to\obsidian-vault"</span></span>
</span>
# Change directory to the repository folder</span></span>
Set-Location</span> -</span>Path $FolderPath</span></span>
</span>
# Check if the working tree is clean</span></span>
$IsClean</span> =</span> (</span>git diff</span>-</span>index </span>--</span>quiet HEAD </span>--</span>)</span> -or</span> (</span>git diff</span>-</span>files </span>--</span>quiet</span>)</span></span>
</span>
if</span> (</span>$IsClean</span>) {</span></span>
    Write-Host</span> "Working tree is clean. Skipping commit and pushing changes."</span></span>
    git push</span></span>
}</span> else</span> {</span></span>
    # Get the current date in the desired format (Day - Date)</span></span>
    $CommitMessage</span> =</span> "</span>$(</span>Get-Date</span> -</span>Format 'dddd - yyyy-MM-dd HH:mm:ss'</span>)</span>"</span></span>
</span>
    # Commit the changes</span></span>
    git add .</span></span>
    git commit </span>-</span>m $CommitMessage</span></span>
</span>
    # Push the changes</span></span>
    git push</span></span>
}</span></span></code></pre>
This script does the following:</p>

Sets the folder path to your Obsidian vault.</li>
Checks if there are any changes to commit. If the vault is clean (no changes), it skips the commit and only pushes changes.</li>
If there are changes, it commits them with a timestamped message and then pushes them to the remote repository.</li>
</ul>
Setting up Windows Task Scheduler</h2>
Now that we have our PowerShell script ready, let's set up a scheduled task using Windows Task Scheduler to automate the synchronization process. Follow these steps:</p>


Open an Elevated PowerShell Prompt:</strong> To run the necessary commands, open PowerShell as an administrator.</p>
</li>

Define Task Variables:</strong> Execute the following commands to define variables for your task:</p>
$ScriptPath</span> =</span> "C:\path\to\obsidian-vault\sync.ps1"</span></span>
$TaskName</span> =</span> "obsidian-sync"</span></span>
$UserAccount</span> =</span> "</span>$env:USERDOMAIN</span>\</span>$env:USERNAME</span>"</span></span></code></pre>
Replace $ScriptPath with the actual path to your sync.ps1 script, $TaskName with a name for your task.</p>
</li>

Configure Task Trigger:</strong> Set up a trigger for your task. In this example, we'll schedule the task to run daily at 9:00 PM:</p>
$Trigger</span> =</span> New-ScheduledTaskTrigger</span> -</span>Daily </span>-</span>At </span>'9:00 PM'</span></span></code></pre>
You can adjust the schedule according to your preference.</p>
</li>

Define Task Principal and Settings: Configure the task's principal (the user account under which the task will run) and settings:</p>
$Principal</span> =</span> New-ScheduledTaskPrincipal</span> -</span>UserId $UserAccount</span> -</span>RunLevel Highest</span></span>
$Settings</span> =</span> New-ScheduledTaskSettingsSet</span> -</span>AllowStartIfOnBatteries </span>-</span>RunOnlyIfNetworkAvailable </span>-</span>WakeToRun</span></span></code></pre>
These settings ensure that the task runs with the necessary privileges and conditions.</p>
</li>

Define Task Action:</strong> Specify the action that the task will perform, which is running the PowerShell script:</p>
$Action</span> =</span> New-ScheduledTaskAction</span> -</span>Execute </span>'PowerShell.exe'</span> -</span>Argument </span>"-ExecutionPolicy Bypass -WindowStyle Hidden -File </span>`"</span>$ScriptPath</span>`"</span>"</span></span></code></pre>
This action runs PowerShell with the provided script.</p>
</li>

Create the Scheduled Task:</strong> Finally, create the scheduled task and register it with Windows Task Scheduler:</p>
$Task</span> =</span> New-ScheduledTask</span> -</span>Action $Action</span> -</span>Trigger $Trigger</span> -</span>Principal $Principal</span> -</span>Settings $Settings</span></span>
Register-ScheduledTask</span> -</span>TaskName $TaskName</span> -</span>InputObject $Task</span></span></code></pre></li>
</ol>
The Obsidian synchronization task is now set up and ready to run automatically based on the schedule you defined.</p>
Inspiration</h1>
When looking up on how to implement this I found some breakthrough from this stack overflow</a> post. There are suggestions on how to do this using cron jobs in wsl. They are worth a look at. This article on powershell</a> with windows server was also helpful.</p>
^1</sup>This method is only optimal for desktop sync. To sync across devices obsidian has a paid plan that has some extra features Such as Sync notes across devices, End-to-end encryption, Version history, Priority email support. Consider checking it out at https://obsidian.md/pricing</a></p>
</div>


What say you?
mockingspectre — Thu, 24 Aug 2023 15:34:14 +0000
Free speech enhanced</p>
There is no point in writing online if your readers cannot provide feedback for your writings. You might as well be shouting at a void. My ideal commenting system has to be free, open source and should not be a hassle to setup. Luckily, utterances 🔮</a> checks all of these conditions</p>
It is a lightweight comments widget built on GitHub issues. Use GitHub issues for blog comments, wiki pages and more! The notable features are:</p>

Open source. 🙌</li>
No tracking, no ads, always free. 📡🚫</li>
No lock-in. All data stored in GitHub issues. 🔓</li>
Styled with Primer, the css toolkit that powers GitHub. 💅</li>
Dark theme. 🌘</li>
Lightweight. Vanilla TypeScript. No font downloads, JavaScript frameworks or polyfills for evergreen browsers. 🐦🌲</li>
</ul>
How it works</h2>
When Utterances loads, the GitHub issue search API</a> is used to find the issue associated with the page based on url, pathname or title. If it cannot find an issue that matches the page, utterances-bot</a> will automatically create an issue the first time someone comments.</p>
To comment, users must authorize the utterances app to post on their behalf using the GitHub OAuth flow</a>. Alternatively, users can comment on the GitHub issue directly.</p>
Setting up Utterances</h1>
Repository</h3>
Choose the repository utterances will connect to.</p>
Make sure the repo is public, otherwise your readers will not be able to view the issues/comments.
Make sure the utterances app is installed on the repo, otherwise users will not be able to post comments.
If your repo is a fork, navigate to its settings tab and confirm the issues feature is turned on.</p>
repo:</span></span>
    username/repo</span></span></code></pre>
A public GitHub repository. This is where the blog post issues and issue-comments will be posted.</p>
Theme</h3>
Choose an Utterances theme that matches your blog.</p>
Enable Utterances</h3>
Add the following script tag to your blog's template. Position it where you want the comments to appear. Customize the layout using the .utterances and .utterances-frame selectors.</p>
<</span>script</span></span>
  src</span>=</span>"https://utteranc.es/client.js"</span></span>
  repo</span>=</span>"[ENTER REPO HERE]"</span></span>
  issue-term</span>=</span>"title"</span></span>
  theme</span>=</span>"gruvbox-dark"</span></span>
  crossorigin</span>=</span>"anonymous"</span></span>
  async</span></span>
></</span>script</span>></span></span></code></pre>
The complete documentation can be found at https://utteranc.es</a></p>


A Fresh Coat Of Paint
mockingspectre — Thu, 24 Aug 2023 00:00:00 +0000
Using Zola as my preferred static site generator</p>
After using Hugo for over eight months I got tired of it and looked for other alternatives. That's when I stumbled upon Zola. Zola is a static site generator (SSG), similar to Hugo</a>, Pelican</a>, and Jekyll</a>.</p>
It is written in Rust and uses the Tera template engine, similar to Jinja2, Django templates, Liquid, and Twig. SSGs use dynamic templates to transform content into static HTML pages. Static sites are thus very fast and require no databases, making them easy to host.</p>
My previous Hugo site used a theme because I wasn't really ready to learn Go's template engine. I'm already familiar with Python Django and its template system so using Tera wasn't hard because it's similar to jinja2 and the Django template syntax.</p>
Content is written in CommonMark</a>, a strongly defined, highly compatible specification of Markdown</a>. Zola uses pulldown-cmark</a> to parse markdown files. The goal of this library is 100% compliance with the CommonMark spec. It adds a few additional features such as parsing footnotes, Github-flavored tables, Github-flavored task lists, and strikethrough.</p>
Zola comes with built-in syntax highlighting, but you must first enable it in the configuration file.</p>
Zola is very minimalistic, it is installed only as a single binary, with no extra dependencies needed. It is configured in toml</code> and you only use what is needed. For example here is the configuration for this site config.toml</code>:</p>
title</span> =</span> "Ian Andwati"</span></span>
description</span> =</span> "Ian Andwati's personal website"</span></span>
base_url</span> =</span> "https://andwati.github.io"</span></span>
</span>
generate_categories_pages</span> =</span> false</span></span>
generate_tags_pages</span> =</span> false</span></span>
generate_feed</span> =</span> true</span></span>
feed_filename</span> =</span> "rss.xml"</span></span>
minify_html</span> =</span> false</span></span>
taxonomies</span> =</span> [{</span> name</span> =</span> 'tags'</span>,</span> feed</span> =</span> false</span> }]</span></span>
compile_sass</span> =</span> true</span></span>
</span>
[</span>markdown</span>]</span></span>
highlight_code</span> =</span> true</span></span>
highlight_theme</span> =</span> "gruvbox-dark"</span></span>
</span>
[</span>link_checker</span>]</span></span>
</span>
[</span>extra</span>]</span></span>
author</span> =</span> "Ian Andwati"</span></span></code></pre>Inspiration</h2>
The motivation to use Zola also came from my decision to move from independently developed themes. I decided to write the HTML and CSS myself and endeavor to maintain the site individually. The base CSS is borrowed from Reilly Tucker Siemens</a> who had created a nice gruvbox palette for his site.</p>
I improved on it by adding an archive page, pagination, a comment system, and Google Analytics (more of these in later posts). I also implemented article read time and word count.</p>
What next</h2>
The site is a work in progress and is far from polished. I plan on implementing a newsletter to notify readers of new posts. The site is primarily a dark theme, in the future I'll also add theme toggling and maybe different palettes.</p>
You can subscribe to the site's RSS feed at https://andwati.xyz/rss.xml</a>.</p>


Subresource Integrity
mockingspectre — Sat, 29 Apr 2023 00:00:00 +0000
Understanding Subresource Integrity</p>
In my junior year while I was learning HTML and CSS I got to use the Bootstrap css library.The easiest way to obtain the files was from a Content Delivery Network(CDN). I could see links such as:</p>
<</span>link</span></span>
  href</span>=</span>"https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha3/dist/css/bootstrap.min.css"</span></span>
  rel</span>=</span>"stylesheet"</span></span>
  integrity</span>=</span>"sha384-KK94CHFLLe+nY2dmCWGMq91rCGa5gtU4mk92HdvYe+M/SXH301p5ILy+dN9+nJOZ"</span></span>
  crossorigin</span>=</span>"anonymous"</span></span>
/></span></span></code></pre>
I didn't bother with the integrity</code> attribute of the link(guess I wasn't curios enough). The integrity attribute has a cryptographic hash value that is important in CDNs and its called the Subresource Integrity.</p>
Subresource Integrity (SRI) is a security feature in web browsers that helps prevent malicious or compromised scripts from being loaded and executed on a website.a security feature that enables browsers to verify that resources they fetch (for example, from a CDN) are delivered without unexpected manipulation. It works by allowing you to provide a cryptographic hash that a fetched resource must match.</p>
When a resource, such as a script or stylesheet, fails the SRI check, the browser will block the resource from being loaded and displayed on the website.</p>
How Subresource Integrity Helps</h1>
Subresource Integrity (SRI) is a security feature that helps protect against certain types of attacks, such as those that involve malicious modifications to third-party resources that a website loads.</p>
SRI works by allowing a website to specify a cryptographic hash for a particular external resource (such as a JavaScript file or a CSS stylesheet) that it expects to load. When a user's browser fetches that resource, it checks the hash against the actual contents of the resource. If the hash doesn't match, the browser will refuse to load the resource, indicating that it may have been tampered with.</p>
This can help prevent a variety of attacks, such as those involving a compromised content delivery network (CDN) or a man-in-the-middle attacker who intercepts and modifies network traffic. By using SRI, a website can help ensure that it is loading only the resources it expects, and that those resources have not been tampered with in transit.</p>
Using it</h1>
Using Subresource Integrity (SRI) involves a few steps, but it is relatively straightforward.An integrity value begins with at least one string, with each string including a prefix indicating a particular hash algorithm (currently the allowed prefixes are sha256, sha384, and sha512), followed by a dash, and ending with the actual base64-encoded hash.</p>


Generate a cryptographic hash(a base64-encoded cryptographic hash) of the external resource you want to load on your website. This can be done using a hash function such as SHA-256.</p>
</li>

Add the hash as an attribute to the tag that loads the external resource. For example, for a JavaScript file, you would add the integrity attribute to the <script></code> tag like this:</p>
</li>
</ul>
<</span>script</span> src</span>=</span>"https://example.com/example.js"</span> integrity</span>=</span>"sha256-ABC123XYZ456"</span>></span><</span>/</span>script</span>></span></span></code></pre>

An integrity value may contain multiple hashes separated by whitespace. A resource will be loaded if it matches one of those hashes.</p>
</blockquote>
Make sure the hash you've generated matches the actual contents of the external resource.</p>
Test your website to ensure that the external resource is loading correctly and that the SRI feature is working as intended.</p>
Tools for generating SRI hashes</h1>
You can use a tool such as the SRI Hash Generator</a> to generate the hash and check it against the file's contents.</p>
You can generate SRI hashes from the command-line with openssl using a command invocation such as:</p>
cat</span> FILENAME.py</span> |</span> openssl</span> dgst -sha384 -binary</span> |</span> openssl</span> base64 -A</span></span></code></pre>
or with shasum using a command invocation such as:</p>
shasum</span> -b -a</span> 384</span> FILENAME.js</span> |</span> awk</span> '{ print $1 }'</span> |</span> xxd</span> -r -p</span> |</span> base64</span></span></code></pre>

The pipe-through xxd step takes the hexadecimal output from shasum and converts it to binary.
The pipe-through awk step is necessary because shasum will pass the hashed filename in its output to xxd. That can have disastrous consequences if the filename happens to have valid hex characters in it — because xxd will also decode that and pass it to base64.</p>
</blockquote>
In a Windows environment, you can create a tool for generating SRI hashes with the following code:</p>
@</span>echo off</span></span>
set</span> bits</span>=</span>384</span></span>
openssl dgst -sha%bits% -binary %</span>1</span>% </span>|</span> openssl base64 -A </span>></span> tmp</span></span>
set</span> /p a</span>= <</span> tmp</span></span>
del</span> tmp</span></span>
echo</span> sha%bits%-%a%</span></span>
pause</span></span></code></pre>
To use that code:</p>

Save that code in a file named sri-hash.bat in the Windows SendTo folder in your environment (for example, C:\Users\USER\AppData\Roaming\Microsoft\Windows\SendTo).</li>
Right-click a file in the File Explorer, select Send to…, and then select sri-hash. You will see the integrity value in a command box.</li>
Select the integrity value and right-click to copy it to the Clipboard.</li>
Press any key to dismiss the command box</li>
</ol>
Cross-Origin Resource Sharing and Subresource Integrity</h1>
When verifying the subresource integrity of a resource that originates from a different domain than the document it's embedded in, web browsers will check the resource using Cross-Origin Resource Sharing (CORS) to ensure that the domain serving the resource allows it to be shared with the requesting domain.
As a result, the resource must be served with an Access-Control-Allow-Origin header that permits the resource to be shared with the requesting domain. For example, the header could include a wildcard (*) to allow any domain to access the resource.</p>
Access-Control-Allow-Origin: *</span></span></code></pre>How browsers handle Subresource Integrity</h1>
Web browsers employ several mechanisms to handle Subresource Integrity (SRI). When a script</strong> or link</strong> element with an integrity attribute is encountered by the browser, it compares the script or stylesheet to the expected hash given in the integrity value before executing the script or applying the stylesheet.</p>
For resources served from a different domain than the document in which it's embedded, the browser also checks the resource using Cross-Origin Resource Sharing (CORS) to ensure that the origin serving the resource allows it to be shared with the requesting domain. This additional check is important for preventing unauthorized access to sensitive resources.</p>
If the script or stylesheet fails to match its associated integrity value, the browser will refuse to execute the script or apply the stylesheet and return a network error, indicating that the fetching of that script or stylesheet failed. This behavior ensures that the resource being loaded is trustworthy and helps to protect users from potential security threats.</p>
References</h1>

https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP</a></li>
https://www.srihash.org/</a></li>
https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity</a></li>
https://html.spec.whatwg.org/multipage/semantics.html#attr-script-integrity</a></li>
https://html.spec.whatwg.org/multipage/semantics.html#attr-link-integrity</a></li>
https://w3c.github.io/webappsec-subresource-integrity/#the-integrity-attribute</a></li>
</ul>


Install PostgreSQL  on Arch | Manjaro | Garuda Linux
mockingspectre — Thu, 16 Feb 2023 15:34:14 +0000
Overview</h1>
PostgreSQL</strong> is a powerful open-source relational database management system (RDBMS) that allows you to store and manage large amounts of data. It was first released in 1996 and has become one of the most popular RDBMSs in the world.</p>
PostgreSQL is designed to handle high levels of concurrency</strong>, providing features such as MVCC (multi-version concurrency control)</strong> that allow multiple users to access the same data simultaneously without conflicts. It is also highly extensible</strong>, with a large number of third-party extensions and libraries available that can be used to add functionality to the core database.</p>
Some of the key features of PostgreSQL include support for complex SQL queries</strong>, advanced indexing</strong> and query optimization</strong>, transactional integrity</strong>, and support for a wide range of programming languages</strong> and development frameworks.PostgreSQL is used by a wide range of organizations, from small businesses to large enterprises, and is particularly popular in industries such as finance, healthcare, and e-commerce, where high levels of data security and reliability are critical.</p>
In this tutorial, we’ll look at how to install PostgreSQL on Arch Linux, Manjaro, Garuda Linux, or any other Arch-based distro out there.</p>
PostgreSQL use cases</h1>

E-commerce websites:</strong> PostgreSQL is a popular choice for e-commerce websites because it can handle large amounts of data and supports complex queries. It is used for product catalogs, order management, customer data, and more.</li>
Financial institutions:</strong> PostgreSQL is used in financial institutions to store and manage transactional data, such as stock trades, bank transfers, and credit card transactions. It is highly secure and provides features such as transactional integrity and data encryption.</li>
Healthcare industry:</strong> PostgreSQL is used in the healthcare industry to store patient data, such as medical records and diagnostic test results. It is also used for research purposes, where large amounts of data need to be stored and analyzed.</li>
Government agencies:</strong> PostgreSQL is used by government agencies for a variety of purposes, including managing large datasets, storing and analyzing census data, and managing public health information.</li>
Mobile and web applications:</strong> PostgreSQL is often used as a back-end database for mobile and web applications. It provides reliable data storage and retrieval and supports a wide range of programming languages and development frameworks.</li>
Geospatial applications:</strong> PostgreSQL has built-in support for geospatial data and is often used for applications that require location-based data, such as mapping and GPS tracking.</li>
</ul>
Why PostgreSQL?</h1>
Postgres offers a lot of advantages that make it an excellent choice for highly transactional environments regardless of application size and data volume. Its rich feature set and flexibility make it a popular choice for a wide range of applications and industries. Some of the top features are:</p>

ACID Compliance:</strong> PostgreSQL is ACID (Atomicity, Consistency, Isolation, Durability) compliant, which means it provides high reliability, consistency, and data integrity, even in the presence of hardware failures, power outages, and other system errors.</li>
Extensibility:</strong> PostgreSQL is highly extensible, allowing developers to add new data types, operators, and functions using its extension framework. This makes it easy to customize PostgreSQL to meet the specific needs of your application.</li>
Concurrency:</strong> PostgreSQL provides a high level of concurrency, allowing multiple users to access the same data at the same time without conflicts. It uses a Multi-Version Concurrency Control (MVCC) model that enables fast and reliable access to data, even under heavy load.</li>
Full-text search:</strong> PostgreSQL provides a powerful full-text search engine that supports advanced search capabilities, such as stemming, ranking, and relevance matching.</li>
Advanced indexing:</strong> PostgreSQL provides a wide range of indexing options, including B-tree, Hash, GiST, SP-GiST, GIN, and BRIN. These indexing options allow developers to optimize database performance for their specific use cases.</li>
JSON support:</strong> PostgreSQL provides native support for storing and querying JSON data, making it easy to work with modern web and mobile applications that rely on JSON for data exchange.</li>
Security:</strong> PostgreSQL provides a high level of security, with features such as SSL support, client authentication, and role-based access control. It also provides encryption for both data at rest and data in transit.</li>
Scalability:</strong> PostgreSQL is designed to scale horizontally and vertically, allowing you to add more nodes to a cluster or increase the resources of a single node to handle more load.</li>
</ul>
Install PostgreSQL on Arch | Manjaro | Garuda Linux</h1>
Now with all that fluff out of the way, let's get to business. The steps have been tested on Arch Linux with the KDE desktop.</p>

Note:</strong> Commands that should be run as the postgres</em> user are prefixed by [postgres]$</code> in this article.</p>
</blockquote>
Step 1: Installing the PostgreSQL Package</h2>
sudo</span> pacman -Syu postgresql</span></span></code></pre>
This command will update the package database and update all packages on the system then install the PostgreSQL package from your distribution mirrors. Never install a package without updating the system first. On a rolling release, this can lead to an unbootable system. Installing the package will also create a system user called postgres</em>. You can now switch to the postgres</em> user using a privilege elevation program.</p>
You can switch to the PostgreSQL user by executing the following command:</p>


If you have sudo and are in sudoers</p>
sudo</span> -iu postgres</span></span></code></pre></li>

Otherwise using su:</p>
su</span></span>
su</span> -l postgres</span></span></code></pre></li>
</ul>
Step 2: Initial Configuration</h2>
Before PostgreSQL can function correctly, the database cluster must be initialized.</p>
2.1 We can confirm the installed PostgreSQL version by running</h3>
postgres</span> --version                                                                           ─╯</span></span>
postgres</span> (PostgreSQL) 15.1</span></span></code></pre>2.2 Set applicable entries in /etc/locale.gen</strong></h3>
echo</span> "en_US.UTF-8 UTF-8"</span> |</span> sudo</span> tee /etc/locale.gen</span></span></code></pre>2.3 Then run **locale-gen**</strong> to generate locale settings</h3>
sudo</span> locale-gen</span></span>
Generating</span> locales...</span></span>
  en_US.UTF-8...</span> done</span></span>
Generation</span> complete.</span></span></code></pre>2.4 Initialize Postgres Data Directory</h3>
You must first log in as the postgres</strong> user using the following command before you can initialize PostgreSQL’s data directory:</p>
sudo</span> su - postgres</span></span></code></pre>2.5 With the following command, you can now initialize PostgreSQL’s data directory</h3>
[</span>postgres</span>]</span>$ initdb -D /var/lib/postgres/data</span></span></code></pre>Step 3: PostgreSQL Service Management</h3>
3.1 Check PostgreSQL status with the following command</h3>
systemctl</span> status postgresql                                                                  ─╯</span></span>
 postgresql.service</span> - PostgreSQL database server</span></span>
     Loaded:</span> loaded</span> (/usr/lib/systemd/system/postgresql.service</span>;</span> disabled</span>;</span> preset:</span> disabled</span>)</span></span>
     Active:</span> inactive</span> (dead)</span></span></code></pre>3.2 Start the PostgreSQL service by running the following command</h3>
sudo</span> systemctl start postgresql</span></span></code></pre>3.3 Enable the PostgreSQL service to start automatically at boot by running the following command</h3>
sudo</span> systemctl enable postgresql</span></span></code></pre>3.4 Verify that PostgreSQL is running by running the following command</h3>
sudo</span> systemctl status postgresql                                                             ─╯</span></span>
●</span> postgresql.service - PostgreSQL database server</span></span>
     Loaded:</span> loaded</span> (/usr/lib/systemd/system/postgresql.service</span>;</span> enabled</span>;</span> preset:</span> disabled</span>)</span></span>
     Active:</span> active</span> (running) since Thu 2023-02-16 22:52:43 EAT</span>;</span> 20s</span> ago</span></span>
   Main</span> PID:</span> 26106</span> (postgres)</span></span>
      Tasks:</span> 6</span> (limit:</span> 8790</span>)</span></span>
     Memory:</span> 16.9M</span></span>
        CPU:</span> 113ms</span></span>
     CGroup:</span> /system.slice/postgresql.service</span></span>
             ├─26106</span> /usr/bin/postgres -D /var/lib/postgres/data</span></span>
             ├─26107</span> "postgres: checkpointer "</span></span>
             ├─26108</span> "postgres: background writer "</span></span>
             ├─26110</span> "postgres: walwriter "</span></span>
             ├─26111</span> "postgres: autovacuum launcher "</span></span>
             └─26112</span> "postgres: logical replication launcher "</span></span></code></pre>Change postgres user password</h3>
To change the postgres user password execute the following command:</p>
sudo</span> -u postgres psql -c "ALTER USER postgres PASSWORD '</span>$PGPASSWORD</span>';"</span></span></code></pre>Resources</h1>

Arch Linux Wiki</a></li>
Wikipedia</a></li>
PostgreSQL Documentation</a></li>
</ul>
Conclusion</h1>
Installing PostgreSQL on Arch Linux-based distribution is a straightforward process that can be completed in just a few steps. By following the steps outlined above, you can install, configure, and start the PostgreSQL database server on your Arch Linux system. Once installed, you can use PostgreSQL to store, manage, and query data for a wide range of applications and use cases. With its advanced features and high level of extensibility, PostgreSQL is a popular choice for developers and businesses seeking a robust and reliable database management system.</p>
You can connect to the PostgreSQL server using the psql command-line client or a graphical tool such as pgAdmin.</p>


Semantic Versioning(SemVer) and Conventional  Commits
mockingspectre — Tue, 24 Jan 2023 15:34:14 +0000
Adopting best practices in your git and build workflows.</p>
What is Semver?</h1>
Semantic versioning or just SemVer is a dependency naming guidline that aims to bring some sanity into naming libraries and packages in software development. It is a standard versioning system created by Tom Preston Werner</strong> (co-founder of Github) that’s used to communicate what changes are in a release.</p>
An efficient and smooth versioning becomes crucial for efficient software delivery expecially for projects that expose a public API. This saves the developers the chaos that is dependency hell</strong>.Dependency hell is a colloquial term for the frustration of some software users who have installed software packages which have dependencies on specific versions of other software packages.</p>
The dependency issue arises when several packages have dependencies on the same shared packages or libraries, but they depend on different and incompatible versions of the shared packages. If the shared package or library can only be installed in a single version, the user may need to address the problem by obtaining newer or older versions of the dependent packages. This, in turn, may break other dependencies and push the problem to another set of packages.</p>
Semantic Versioning Specifications</h2>
Summary</h3>
Semantic versioning is based on three numbers that indicate the versions of the software and the compatibilities.They are X.Y.Z</code> corresponding to Major.Minor.Patch</code></p>

**Major Version (X):**Introduces major changes to the code and breaking changes toward backward compatibility</li>
Minor Version (Y):</strong> These code changes don’t introduce breaking changes. This could be adding a new feature that doesn't break changes but are not exactly bug fixes.</li>
Patches (Z):</strong> Mainly correspond to bug fixes</li>
</ul>
Examples in common packages</h3>
React(v18.2.0)</h4>
</p>

Major -> 18</strong></li>
Minor -> 2</strong></li>
Patch -> 0</strong></li>
</ul>

Pipx(v1.1.0)</h4>
</p>

Major -> 1</strong></li>
Minor -> 1</strong></li>
Patch -> 0</strong></li>
</ul>

Start at v0.1.0 or v1.0.0?</h2>
Convention recommends that in the initial development phase the starting version should be 0.1.0 which makes sense since it’s not in production yet.</p>
The version should only be bumped to 1.0.0 only if it is being used in production and stable.</p>
If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0.</p>
Conventional Commits</h1>
Conventional Commits is a convention on top of commit messages that are used to automate version changes. It provides an easy set of rules for creating commit messages and works well with SemVer by describing features, fixes and breaking changes that correspond to SemVer standards.</p>
Summary</h2>
The commit message should be structured as follows:</p>
<type>[optional scope]: <description></span></span>
</span>
[optional body]</span></span>
</span>
[optional footer(s)]</span></span></code></pre>
The commit contains the following structural elements, to communicate intent to the consumers of your library:</p>

fix: a commit of the type fix patches a bug in your codebase (this correlates with PATCH in Semantic Versioning).</li>
feat: a commit of the type feat introduces a new feature to the codebase (this correlates with MINOR in Semantic Versioning).</li>
BREAKING CHANGE: a commit that has a footer BREAKING CHANGE:, or appends a ! after the type/scope, introduces a breaking API change (correlating with MAJOR in Semantic Versioning). A BREAKING CHANGE can be part of commits of any type.</li>
types other than fix: and feat: are allowed, for example @commitlint/config-conventional (based on the Angular convention) recommends build:, chore:, ci:, docs:, style:, refactor:, perf:, test:, and others.</li>
footers other than BREAKING CHANGE:  may be provided and follow a convention similar to git trailer format.</li>
</ol>
Resources</h1>
https://semver.org/</a>
https://www.conventionalcommits.org/en/v1.0.0/</a></p>


Integrating Netlify CMS
mockingspectre — Thu, 24 Nov 2022 15:34:14 +0000
Migrating to a better content management system through Netlify CMS</p>
Heavy Lifting</h1>
I use Visual Studio Code</a> to manually edit the blog post content on this website. This is quite a hassle because I have to deal with
markdown files. There are many problems with this approach and several gotchas. I have to work on a local site repository to be able to edit the content. My GitHub credentials are also required to push my local changes to my remote repository on GitHub so that it can trigger the build process and publish the site.</p>
This process has helped me a lot to master markdown syntax and some practice on my git skills. It’s fun to update the website content following these steps but sometimes it can be frustrating. At those times, I really miss the user interface of content management systems. After careful consideration, I moved on with Netlify CMS. At its core, Netlify CMS is an open-source React app that acts as a wrapper for the Git workflow, using the GitHub, GitLab, or Bitbucket API. This provides many advantages, including:</p>

Fast, web-based UI:</strong> With rich-text editing, real-time preview, and drag-and-drop media uploads.</li>
Platform agnostic:</strong> Works with most static site generators.</li>
Easy installation:</strong> Add two files to your site and hook up the backend by including those files in your build process or linking to our Content Delivery Network (CDN).</li>
Modern authentication:</strong> Using GitHub, GitLab, or Bitbucket and JSON web tokens.</li>
Flexible content types:</strong> Specify an unlimited number of content types with custom fields.</li>
Fully extensible:</strong> Create custom-styled previews, UI widgets, and editor plugins.</li>
</ul>
Redeploying to Netlify</h1>
I decided to move the site from GitHub pages to Netlify hosting to take full control of the platform. Hugo sites on Netlify can benefit from automatic framework detection and control over Hugo version selection. When you link a repository for a project, Netlify tries to detect the framework your site is using. If your site is built with Hugo, Netlify provides a suggested build command and publish directory: Hugo and public. The build process is straight forward but you can add custom options to your netlify.toml</code> file, here are my options:</p>
[</span>build</span>]</span></span>
command</span> =</span> "hugo"</span></span>
publish</span> =</span> "public"</span></span>
</span>
[</span>build.environment</span>]</span></span>
HUGO_VERSION</span> =</span> "0.105.0"</span></span></code></pre>Setting up Netlify CMS</h1>
You can adapt Netlify CMS to a wide variety of projects. It works with any content written in markdown, JSON, YAML, or TOML files, stored in a repo on GitHub, GitLab, or Bitbucket. You can Netlify CMS to a site that's built with a common static site generator, like Jekyll, Hugo, Hexo, or Gatsby. The official documentation for installing on your website can be found at the official site</a></p>
Steps</h2>
Step 1</strong></p>
Create a static admin folder containing all Netlify CMS files, stored at the root of your published site. Where you store this folder in the source files depends on your static site generator. For Hugo, it is the static</code> folder.</p>
/static/admin</code></p>
Step 2</strong></p>
Inside the admin folder, create two files: index.html</code> and config.yml</code>. The first file admin/index.html</code> is an entry point to Netlify CMS. You will access the CMS interface from yourwebsite.com/admin</code> when everything is ready.</p>
Step 3</strong></p>
The first file, admin/index.html</code>, is the entry point for the Netlify CMS admin interface. Paste this code in index.html and save. This HTML starter page will load the Netlify CMS Javascript file:</p>
<!DOCTYPE</span> html</span>></span></span>
<</span>html</span>></span></span>
  <</span>head</span>></span></span>
    <</span>meta</span> charset</span>=</span>"utf-8"</span> /></span></span>
    <</span>meta</span> name</span>=</span>"viewport"</span> content</span>=</span>"width=device-width, initial-scale=1.0"</span> /></span></span>
    <</span>title</span>></span>Content Manager</span></</span>title</span>></span></span>
  </</span>head</span>></span></span>
  <</span>body</span>></span></span>
    <!-- Include the script that builds the page and powers Netlify CMS --></span></span>
    <</span>script</span> src</span>=</span>"https://unpkg.com/netlify-cms@^2.0.0/dist/netlify-cms.js"</span>></span><</span>/</span>script</span>></span></span>
  </</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
Step 4</strong></p>
Now let’s move to the configuration section. These are the configurations that go into the config.yml</code> file. This process is different for every site. I followed the guidelines on the website and made minor adjustments. It worked on my website. The configuration options are available at the docs</a>. This is how I configured my config.yml file:</p>
backend</span>:</span></span>
  name</span>:</span> git-gateway</span></span>
  branch</span>:</span> netlify-cms</span> # Branch to update (optional; defaults to master)</span></span>
</span>
# This line should *not* be indented</span></span>
publish_mode</span>:</span> editorial_workflow</span></span>
</span>
media_folder</span>:</span> 'static/images/uploads'</span> # Media files will be stored in the repo under static/images/uploads</span></span>
public_folder</span>:</span> '/images/uploads'</span> # The src attribute for uploaded media will begin with /images/uploads</span></span>
</span>
collections</span>:</span></span>
  -</span> name</span>:</span> 'post'</span> # Used in routes, e.g., /admin/collections/blog</span></span>
    label</span>:</span> 'posts'</span> # Used in the UI</span></span>
    folder</span>:</span> 'content/post'</span> # The path to the folder where the documents are stored</span></span>
    create</span>:</span> true</span> # Allow users to create new documents in this collection</span></span>
    slug</span>:</span> '{{year}}-{{month}}-{{day}}-{{slug}}'</span> # Filename template, e.g., YYYY-MM-DD-title.md</span></span>
    fields</span>:</span> # The fields for each document, usually in front matter</span></span>
      - {</span> label</span>:</span> 'Layout'</span>,</span> name</span>:</span> 'layout'</span>,</span> widget</span>:</span> 'hidden'</span>,</span> default</span>:</span> 'blog'</span> }</span></span>
      - {</span> label</span>:</span> 'Title'</span>,</span> name</span>:</span> 'title'</span>,</span> widget</span>:</span> 'string'</span> }</span></span>
      - {</span> label</span>:</span> 'Draft'</span>,</span> name</span>:</span> 'draft'</span>,</span> widget</span>:</span> 'boolean'</span>,</span> default</span>:</span> true</span> }</span></span>
      - {</span> label</span>:</span> 'Publish Date'</span>,</span> name</span>:</span> 'date'</span>,</span> widget</span>:</span> 'datetime'</span> }</span></span>
      - {</span> label</span>:</span> 'Last Modified'</span>,</span> name</span>:</span> 'lastmod'</span>,</span> widget</span>:</span> 'datetime'</span> }</span></span>
      - {</span> label</span>:</span> 'Body'</span>,</span> name</span>:</span> 'body'</span>,</span> widget</span>:</span> 'markdown'</span> }</span></span>
      - {</span> label</span>:</span> 'Keywords'</span>,</span> name</span>:</span> 'keywords'</span>,</span> widget</span>:</span> 'list'</span> }</span></span>
      - {</span> label</span>:</span> 'Tags'</span>,</span> name</span>:</span> 'tags'</span>,</span> widget</span>:</span> 'list'</span> }</span></span>
      - {</span> label</span>:</span> 'Categories'</span>,</span> name</span>:</span> 'categories'</span>,</span> widget</span>:</span> 'list'</span> }</span></span>
      - {</span> label</span>:</span> 'Comments'</span>,</span> name</span>:</span> 'comment'</span>,</span> widget</span>:</span> 'boolean'</span>,</span> default</span>:</span> true</span> }</span></span>
      - {</span> label</span>:</span> 'Table of Contents'</span>,</span> name</span>:</span> 'toc'</span>,</span> widget</span>:</span> 'boolean'</span>,</span> default</span>:</span> true</span> }</span></span></code></pre>
Step 5</strong></p>
Authentication</strong></p>
Now that the Netlify CMS files are in place and configured, all that's left is to enable authentication.
Netlify offers a built-in authentication service called Identity. In order to use it, connect your site repo with Netlify. Netlify has published a general Step-by-Step Guide</a> for this, along with detailed guides for many popular static site generators</p>
Let’s first enable Netlify Identity and Git Gateway:</p>

On your Netlify account, go to Settings > Identity</strong> and select Enable Identity Service</strong></li>
Under Registration preferences</strong>, select Invite Only</strong>.</li>
If you want to enable login from external providers such as Google and GitHub, check the boxes you want to use, under External Providers</strong> section. I find it practical to log in with GitHub, so I added it.</li>
Go to Services > Git Gateway</strong>, and click Enable Git Gateway</strong>. This authenticates with your Git Host and generates and API token.</li>
Everything is almost set up. What we need now is a front-end interface to connect. We will add the following script in two places, to include the Netlify Identity Widget</strong> on our website:</li>
</ul>
<</span>script</span> src</span>=</span>"https://identity.netlify.com/v1/netlify-identity-widget.js"</span>></span><</span>/</span>script</span>></span></span></code></pre>
We will use Netlify's script injection</a> feature to add the script to our site. To use snippet injection, go to Site Settings > Build & Deploy > Post processing</strong>. Find the Snippet Injection section and select Add Snippet</strong>. Write a name for the script in the first box (e.g. Netlify Identity Widget). Paste the script inside the second box. Choose Insert before the </body></code> option and save.</p>
Lastly, we will add the following script before the closing <body></code> tag of our website’s main index page. This script allows the user to redirect back to the /admin/</code> path after completing the login with the Netlify Identity Widget:</p>
<</span>script</span>></span></span>
  if</span> (window</span>.</span>netlifyIdentity)</span> {</span></span>
    window</span>.</span>netlifyIdentity</span>.</span>on</span>(</span>'init'</span>, (</span>user</span>)</span> =></span> {</span></span>
      if</span> (</span>!</span>user)</span> {</span></span>
        window</span>.</span>netlifyIdentity</span>.</span>on</span>(</span>'login'</span>, ()</span> =></span> {</span></span>
          document</span>.</span>location</span>.</span>href</span> =</span> '/admin/'</span>;</span></span>
        }</span>)</span>;</span></span>
      }</span></span>
    }</span>)</span>;</span></span>
  }</span></span>
<</span>/</span>script</span>></span></span></code></pre>
Step 5</strong></p>
Now we’re all set. Since we set our registration preferences to “Invite Only”</strong>, we need to invite ourselves as site users. To do this, select the Identity tab from the Netlify site dashboard and select the Invite Users button. Add your email address and send an invitation. You will receive an email. In your email, click “accept the invitation”</strong>. You will be directed to your website admin sign-up panel. Choose a password. Now you are ready to log in to Netlify CMS.</p>
Setting up a custom domain</h1>
I bought a custom domain from Namecheap</a>, they provide some pretty good deals. After pointing the nameservers for the domain to the Netlify nameservers, voila! everything worked smoothly. For HTTPS support, Netlify enables automatic TLS certificates with Let’s Encrypt.</p>


Django Secret Key Tutorial
mockingspectre — Fri, 11 Nov 2022 15:34:14 +0000
Managing the Django SECRET_KEY variable.</p>
The Django SECRET_KEY</code> variable is very crucial to your Django application. The secret key must be a large random value and it must be kept secret. Leaking this value to unauthorized people could lead to a security breach. The SECRET_KEY is used in Django for cryptographic signing. It is used to generate tokens and hashes, they can be recreated using this variable. If it is not configured Django throws a django.core.exceptions.ImproperlyConfigured: The SECRET_KEY setting must not be empty</code> error</p>
Using Environment Variables</h1>
The secret key should not be committed to version control. It is best practice to store the value in a .env file which is added to the .gitignore file to un-track its changes. The values can be loaded programmatically into your settings.py file.</p>
Generating A New Secret Key</h1>
This solution is using python's secrets lib on the back</p>
from</span> django</span>.</span>core</span>.</span>management</span>.</span>utils</span> import</span> get_random_secret_key</span></span>
# print new random secret key</span></span>
print</span>(</span>get_random_secret_key</span>())</span></span></code></pre>
This code can be run in the terminal as a command:</p>
python</span> -</span>c</span> 'from django.core.management.utils import get_random_secret_key; </span>\</span></span>
            print(get_random_secret_key())'</span></span></code></pre>
Alternatively, If you are using python 3.6+ then you can use the secrets.token_hex(\[nbytes=None])</code> function:</p>
python3</span> -</span>c</span> 'import secrets; print(secrets.token_hex(100))'</span></span></code></pre>


Hello World
mockingspectre — Fri, 04 Nov 2022 00:00:00 +0000
How it begins</p>
In this post-web2.0 age, people seem to blog less and less, and blogs seem to be dying slowly. People are separated in different Apps where the content is not searchable by search engines.</p>
However, I still prefer to write using a blog.</p>
Why this?</h1>
The best way to learn something is to teach others the knowledge that you have gained. Regurgitating that information will solidify it more firmly in your mind.</p>
What I write?</h1>
Mostly random stuff and a few tutorials. I'll see where this goes.Although some of the blog posts may only be helpful to myself, but who knows, I hope they will be helpful to someone else in some day.</p>
Static blog generator</h1>
I use hugo as a static site generator.After trying a couple of blogging platforms and trying to build a few from scratch I decided to
throw in the towel and opt in for a ready made solution, no need reinventing the wheel.</p>
Hugo is one of the most popular open-source static site generators. With its amazing speed and flexibility, Hugo makes building websites fun again.Hugo provides a robust theming system that is easy to implement but capable of producing even the most complicated websites.Hugo's Go-based templates provide just the right amount of logic to build anything from the simple to complex. For this site I decided to go with the even theme</a>. The commenting system is implemented using Utterances</a></p>
Blog site hosting</h1>
The site is hosted on github pages as evident by the *.github.io domain name.I prefer this mainly because it is free and I don't have
to switch to a different hosting provider.</p>


Configure Vue.js app With Tailwind CSS
mockingspectre — Sat, 12 Jun 2021 00:00:00 +0000
A guide on how to use Tailwind CSS</a> in your Vue project.</p>

Note</strong>

This article was originaly published on my old medium blog. I moved it here for archival purposes.</p>
</blockquote>
Tailwind is a utility-first CSS framework for rapidly building custom user interfaces. It is an un-opinionated framework which means that it doesn't come with custom configurations like Bootstrap or Bulma(Yeah, I know, no one should tell you how to live your life).</p>
Now let's get to the juicy part that brought us all here. I'll assume that we are using Vue 3 and the Vue CLI is already installed.</p>
Create a new Vue project</h2>
Open a terminal window and type the following commands to create a new Vue project in the current directory.</p>
vue</span> create vue-app</span></span></code></pre>
wait for the dependencies installation to finish then</p>
cd</span> vue-app</span></span></code></pre>
to change into the project directory.</p>
Install the Tailwind CSS and its peer dependencies as a dev dependency using npm</h2>
npm</span> install -D tailwindcss@latest postcss@latest autoprefixer@latest</span></span></code></pre>Create your configuration files</h2>
Next, generate your tailwind.config.js</code> and postcss.config.js</code> files:</p>
npx</span> tailwindcss init -p</span></span></code></pre>
This command will create a minimal tailwind.config.js</code> file at the root of your project:</p>
// tailwind.config.js</span></span>
module</span>.</span>exports</span> =</span> {</span></span>
  purge</span>:</span> []</span>,</span></span>
  darkMode</span>:</span> false</span>,</span> // or 'media' or 'class'</span></span>
  theme</span>:</span> {</span></span>
    extend</span>:</span> {},</span></span>
  },</span></span>
  variants</span>:</span> {</span></span>
    extend</span>:</span> {},</span></span>
  },</span></span>
  plugins</span>:</span> []</span>,</span></span>
};</span></span></code></pre>
It will also create a postcss.config.js</code> file that includes tailwindcss and autoprefixer already configured.Postcss is needed to process tailwind:</p>
// postcss.config.js</span></span>
module</span>.</span>exports</span> =</span> {</span></span>
  plugins</span>:</span> {</span></span>
    tailwindcss</span>:</span> {},</span></span>
    autoprefixer</span>:</span> {},</span></span>
  },</span></span>
};</span></span></code></pre>Configure Tailwind to remove unused styles in production</h2>
In your tailwind.config.js file, configure the purge option with the paths to all of your pages and components so Tailwind can tree-shake unused styles in production builds:</p>
// tailwind.config.js</span></span>
module</span>.</span>exports</span> =</span> {</span></span>
  purge</span>:</span> [</span>'./index.html'</span>,</span> './src/**/*.{vue,js,ts,jsx,tsx}'</span>]</span>,</span></span>
  darkMode</span>:</span> false</span>,</span> // or 'media' or 'class'</span></span>
  theme</span>:</span> {</span></span>
    extend</span>:</span> {},</span></span>
  },</span></span>
  variants</span>:</span> {</span></span>
    extend</span>:</span> {},</span></span>
  },</span></span>
  plugins</span>:</span> []</span>,</span></span>
};</span></span></code></pre>Include Tailwind in your CSS</h2>
Navigate to src/assets/css</code> and create a new tailwind.css</code> file in the folder, and use the @tailwind directive to include Tailwind’s base, components, and utilities styles in the file.</p>
/* ./src/assets/css/tailwind.css */</span></span>
@tailwind</span> base</span>;</span></span>
@tailwind</span> components</span>;</span></span>
@tailwind</span> utilities</span>;</span></span></code></pre>
Tailwind will swap these directives out at build-time with all of the styles it generates based on your configured design system.</p>
Import Tailwind into your Vue app</h2>
Finally, ensure your CSS file is being imported in your ./src/main.js</code> file:</p>
// src/main.js</span></span>
import</span> {</span> createApp</span> }</span> from</span> 'vue'</span>;</span></span>
import</span> App</span> from</span> './App.vue'</span>;</span></span>
import</span> './index.css'</span>;</span></span>
</span>
createApp</span>(App)</span>.</span>mount</span>(</span>'#app'</span>)</span>;</span></span></code></pre>
You're finished! Now when you run npm run dev, Tailwind CSS will be ready to use in your Vue app! You can now proceed to create awesome stuff</p>

Thoughts and Musings

The One Thing Nobody Tells You About WiFi Hotspots on Arch Linux

From C to Machine Code: What Actually Runs

The Single Byte That Kills Your Exploit: Understanding Endianness

What is pwn?

Concepts to Cover</h2> This roadmap will take you from “I don’t know how the stack works”</em> to “I can write exploits for CTFs and understand real-world CVEs.”</em></p>

Episode 14: Beyond the Basics</strong></h3> Automating exploit discovery with fuzzing (AFL, honggfuzz).</li> Symbolic execution with angr.</li> Real-world case studies (Heartbleed, Dirty COW, Shellshock).</li> Writing weaponized exploits responsibly.</li> </ul>

ScriptCTF 2025 Writeup

Challenge: Renderer</h1> </p> This is the first web challenge; it launches an instance, and the source code is provided for manual code review. There are three important files: two Jinja templates and a Python file.</p> upload.html</p>

mmuctf 2025 writeup

Shadow</h2> Look beyond the appearance, perhaps their numerical essence will guide you to the flag. Can you reveal what lurks in the shadow?</p> </blockquote>

Revealme</h2> We found this mysterious executable on an old USB stick... Can you figure out how to get it to reveal the flag?</p> </blockquote> The provided file is an ELF executable binary.</p>

cognitive inertia

Export default and module.exports in Javascript

Setting up Obsidian sync in Windows

Setting up Windows Task Scheduler</h2> Now that we have our PowerShell script ready, let's set up a scheduled task using Windows Task Scheduler to automate the synchronization process. Follow these steps:</p>

What say you?

Theme</h3> Choose an Utterances theme that matches your blog.</p>

Enable Utterances</h3> Add the following script tag to your blog's template. Position it where you want the comments to appear. Customize the layout using the .utterances and .utterances-frame selectors.</p>

A Fresh Coat Of Paint

Subresource Integrity

Install PostgreSQL on Arch | Manjaro | Garuda Linux

Step 2: Initial Configuration</h2> Before PostgreSQL can function correctly, the database cluster must be initialized.</p>

Step 3: PostgreSQL Service Management</h3>

Semantic Versioning(SemVer) and Conventional Commits

Semantic Versioning Specifications</h2> Summary</h3> Semantic versioning is based on three numbers that indicate the versions of the software and the compatibilities.They are X.Y.Z</code> corresponding to Major.Minor.Patch</code></p>

Summary</h3> Semantic versioning is based on three numbers that indicate the versions of the software and the compatibilities.They are X.Y.Z</code> corresponding to Major.Minor.Patch</code></p>

Examples in common packages</h3>

React(v18.2.0)</h4> </p>

Resources</h1> https://semver.org/</a> https://www.conventionalcommits.org/en/v1.0.0/</a></p>

Integrating Netlify CMS

Django Secret Key Tutorial

Hello World

Why this?</h1> The best way to learn something is to teach others the knowledge that you have gained. Regurgitating that information will solidify it more firmly in your mind.</p>

What I write?</h1> Mostly random stuff and a few tutorials. I'll see where this goes.Although some of the blog posts may only be helpful to myself, but who knows, I hope they will be helpful to someone else in some day.</p>

Static blog generator</h1> I use hugo as a static site generator.After trying a couple of blogging platforms and trying to build a few from scratch I decided to throw in the towel and opt in for a ready made solution, no need reinventing the wheel.</p>

Configure Vue.js app With Tailwind CSS

Concepts to Cover</h2>
This roadmap will take you from “I don’t know how the stack works”</em> to “I can write exploits for CTFs and understand real-world CVEs.”</em></p>

Episode 14: Beyond the Basics</strong></h3>

Automating exploit discovery with fuzzing (AFL, honggfuzz).</li>
Symbolic execution with angr.</li>
Real-world case studies (Heartbleed, Dirty COW, Shellshock).</li>
Writing weaponized exploits responsibly.</li> </ul>

Theme</h3>
Choose an Utterances theme that matches your blog.</p>

Step 2: Initial Configuration</h2>
Before PostgreSQL can function correctly, the database cluster must be initialized.</p>

Resources</h1>
https://semver.org/</a> https://www.conventionalcommits.org/en/v1.0.0/</a></p>

Why this?</h1>
The best way to learn something is to teach others the knowledge that you have gained. Regurgitating that information will solidify it more firmly in your mind.</p>

What I write?</h1>
Mostly random stuff and a few tutorials. I'll see where this goes.Although some of the blog posts may only be helpful to myself, but who knows, I hope they will be helpful to someone else in some day.</p>