David Zhu

Inspirations for this Blog

2026-05-24T00:00:00+00:00

Inspirations for this Blog

24 May 2026

Reasons why I wanted to create a very minimal blog.

Life with RSS

2026-01-17T00:00:00+00:00

Life with RSS

17 Jan 2026

Since I stopped infinite scrolling, I had to find another way of consuming information. RSS feeds have been a great solution for that. They allow me to subscribe to hand-picked sources of information and read them at my own pace. I can easily add new sources or remove those that no longer interest me.

Small Web

To begin with, while there is no single definition, "small web" typically refers to the non-commercial part of the web, crafted by individuals to express themselves or share knowledge without seeking any financial gain. ¹

I like reading articles from the small web, but discovering them can be hard. I use Kagi Small Web's RSS feed to find interesting blogs and add their RSS feeds to my reader. Kagi Small Web is a curated list of small websites and YouTube channels.

Or sometimes I come across an interesting post shared on Hacker News and add the blog's feed.

Reddit supports RSS, allowing me to subscribe to subreddits through their feeds. The feed contains the post title and description; however, I still have to open the link to see the comments.

YouTube

YouTube channels also have RSS feeds, but I prefer to just use my subscriptions page. I have a plugin to disable the Home page and sidebar recommendations, so I only see new videos from channels I subscribed to.

Software Updates

I also use RSS feeds to keep track of updates for my software and devices I use. This is actually an improvement, as previously I had to manually search for this information, but now I get notified through my RSS reader.

P.S. If you maintain a blog, please add a FULL RSS feed (not a truncated one) for your posts so I can read your posts without leaving my RSS reader.

What is Kagi Small Web?

Rendering LaTeX math without JavaScript

2026-01-11T00:00:00+00:00

Rendering LaTeX math without JavaScript

11 Jan 2026

Recently, I found out about MathML Core, which allows browsers to render mathematical notation in HTML without the need for a JavaScript library or converting to images. This got me very excited because I can add LaTeX math rendering to my SSG ¹ without having to use JavaScript!

So, obviously I spent the day adding this feature to my SSG. Unfortunately, for pages that use MathML, a math font has to be loaded, and they are quite large. I am using Libertinus, which is 396kB! In comparison to my other assets, it's huge! For comparison, the sum of all other assets on this page is less than 10kB.

Anyways, here's a POC:

Rendered

Prefixed Closeness: Let $ϕ$ be a set of feasible traces. If $τ_{1} τ_{2} \in ϕ$ then $τ_{1} \in ϕ$

HTML

Let 
<math>
    <mi>ϕ</mi>
</math>
be a set of feasible traces.
If 
<math>
    <msub>
        <mi>τ</mi>
        <mn>1</mn>
    </msub>
    <msub>
        <mi>τ</mi>
        <mn>2</mn>
    </msub>
    <mo>∈</mo>
    <mi>ϕ</mi>
</math>
then 
<math>
    <msub>
        <mi>τ</mi>
        <mn>1</mn>
    </msub>
    <mo>∈</mo>
    <mi>ϕ</mi>
</math>

Markdown

Let $\phi$ be a set of feasible traces.
If $\tau_1\tau_2\in\phi$ then $\tau_1\in\phi$

Static Site Generator

Life without infinite scroll

2026-01-07T00:00:00+00:00

Life without infinite scroll

07 Jan 2026

It's been a few months since I stopped using anything with infinite scrolling, and life has been great.

I feel like a brain-dead zombie while scrolling on these apps. My brain gets foggy afterward, and I don't even feel good about the time I just burned. Now I've got more time in my day for things that don't make me feel shitty afterward. The time spent doesn't even have to be a productive activity; even just watching shows is more enjoyable. So I wouldn't consider this a productivity improvement, but rather a health improvement.

I also cut social media out of my life, which is also very enjoyable. Now:

I make more effort to catch up with my friends.
I find out what's going on in their lives by talking to them directly.
I keep fake, curated highlight reels out of my sight.

Highly recommend y'all to try it out too!

Hello World Again

2026-01-04T00:00:00+00:00

Hello World Again

04 Jan 2026

A very happy new year to everyone reading this! (though slightly late) Anyways, welcome to my blog where I'll be spewing random thoughts (again). Most of it will probably be about tech, with a sprinkle of random stuff here and there, but we shall see.

Restarted this blog because I felt like writing stuff and sharing it online but didn't want to use any centralized social media sites. What's the fun in that right?

Comfort with a 34 key Keyboard

2021-11-24T11:29:48+00:00

Comfort with a 34 key Keyboard

24 Nov 2021

My current keyboard is the Ferris v0.2. I've been using it for about 6 months now and it feels very much like my endgame keyboard. Before I go onto to tell you about why this is my endgame keyboard, I'll tell you about my past keyboards.

Past Keyboards

Corsair K70

This was the first keyboard I bought, it's a full sized keyboard, back then having more keys at my disposal seemed like a good idea.

If I was typing for a long time on this keyboard my finger tips will start to hurt, most likely due to the switch being a linear switch and there's no dampening of the impact when I bottom out. On hindsight, it might help if I added O-rings.

The other problem was it's just not comfortable to type on for long periods of time. When typing my two hands will be close to each other causing my wrist to be bent in an uncomfortable angle. This is called ulnar deviation.

The combination of this two issues lead me on a search for a more ergonomic keyboard.

Ergodox EZ

This lead me to discover Ergodox EZ, a split ortholinear keyboard. This keyboard was not cheap but I bite the bullet and bought it in the name of ergonomics.

It was amazing how much more comfortable the typing experience was compared to my previous keyboard. The fact that it was split solved the issue of my wrist, it being ortholinear also made it easier for me to touch type. The thumb keys were comfortable to use, it makes sense that we use our thumbs more, since it is one of our strongest fingers. With the traditional keyboard design, we were under utilizing out thumbs. The tenting and wrist rest made it comfortable as well.

The only downside was some keys are far away and I have to shift my hand to reach them. Which made me interested in smaller form factor keyboards.

Planck

The planck is a 40% ortholinear keyboard which aims to minimize finger travel.

I got this keyboard with the intention of it being my portable keyboard and trying out a smaller form factor, but I found the keyboard uncomfortable to use, due to ulnar deviation and the high profile, I would need a wrist rest to type more comfortably. I also found it hard to use due to the limited number of keys, somehow I had the great idea that it would be fine if I get the slightly bigger version of the planck. (Including the comfort issue)

Preonic

The preonic is basically the planck but with an additional row of keys. I would say it has all the downsides of the planck, and whether the additional row of keys is a pro or con is really dependent on the user. Currently, since I've already gotten used to using my 34 key keyboard, I would think that it is a con.

The End Game

Based on the experience above, I concluded for a keyboard to be comfortable it has to fit these criteria.

A split keyboard
Ortholinear
Low Profile/High Profile with wrist rest
Small size to minimize finger travel
Thumb keys

The ferris meets all of those criteria and with the additional plus of it being rust related :). Initially I was worried about whether 34 keys is too little, so I changed my Ergodox EZ layout to only use 34 keys and I got used to it quite comfortably after awhile, so I went ahead and got the ferris.

I got the ferris partially assembled so I just had to solder on the switches, it was my first time soldering and thankfully it all went smoothly. However, when I tested the keyboard, some keys were not working so I asked around in the Low Profile Keyboards discord group and Pierrec (the creator of the ferris) told me it was likely that some MCU pins were not soldered properly, he offered to fix it for me, but I decided to give it a shot and it turned out well, the keyboard works flawlessly now.

The one thing that is special about the ferris is that it has column stagger, meaning each column of keys are shifted to different offsets to better match natural finger alignment. It was weird at first, but now that I've gotten used to it it feels much more comfortable than linearly aligned keys.

After 6 months of using the ferris I don't have much to complain about, I've optimized my layout to my liking as well, which I plan on going into in a later post. The only thing I want now is a better TRRS cable, my current one is quite ugly.

Understanding rabin2 output

2020-02-28T00:00:00+00:00

Understanding rabin2 output

28 Feb 2020

Prelude

If you don't know what rabin2 is/what it does.

Rabin2 understands many file formats: Java CLASS, ELF, PE, Mach-O or any format supported by plugins, and it is able to obtain symbol import/exports, library dependencies, strings of data sections, xrefs, entrypoint address, sections, architecture type. [src]

The binary info option of rabin2 outputs quite a lot of information, however there's no explanation to what each of the values mean, they can be quite cryptic especially to those not familiar with reverse engineering. I tried searching around but couldn't find any information regarding it so I made this table to help with interpretting the values, not all values are included here, but I added all that I could figure out so far, this may be updated in the future.

Table

Header	Explanation	Remark
arch	Architecture of the binary (Eg. ARM, x86)
baddr	Base Address, used to calculate the absolute address when the program is loaded in memory.
laddr	Load Address	Reference
bits	Size of address pointer of program
bintype	The type of binary (Eg. PE, ELF), blank if not a known binary type
linenum	COFF Line Numbers for PE or DWARF in ELF, Debugging line numbers relating to the source code.
lsyms	Whether the binary contains debug symbols. Having symbols allows you to see function and variable names.
endian	Endianness of the binary (Little or Big)
binsz	Size of the binary in bytes
Canary	Stack canary. A random value is placed on the stack at the start of the function, this value is checked for modification before a function returns because it has to be overwritten in order to overwrite the return pointer.	Protection Mechanism
retguard	Similar function to stack canary. More info	Protection Mechanism
sanitiz	Address Sanitizer (ASAN) a memory error detector for C/C++	Should only be seen for debug builds because of the performance impact of ASAN
NX	No execute bit. W^X -> Memory regions cannot be both writable and executable	Protection Mechanism
PIC	Position Independent Code, allows ASLR	Protection Mechanism
reloc	Performs Load-time relocation
Relro	Makes some binary sections read-only.	Protection Mechanism
rpath	The run-time library search path hard-coded in an executable file or library.
Signed	Digitally signed	Only for PE binaries
Static	Whether the binary is statically linked
Stripped	Whether the binary contain debug information
va	Uses virtual addressing

Sample outputs

$ rabin2 -I /bin/bash
arch     x86
baddr    0x0
binsz    1111705
bintype  elf
bits     64
canary   true
sanitiz  false
class    ELF64
crypto   false
endian   little
havecode true
intrp    /lib64/ld-linux-x86-64.so.2
laddr    0x0
lang     c
linenum  false
lsyms    false
machine  AMD x86-64 architecture
maxopsz  16
minopsz  1
nx       true
os       linux
pcalign  0
pic      true
relocs   false
relro    full
rpath    NONE
static   false
stripped true
subsys   linux
va       true

$ rabin2 -I /mnt/c/Windows/System32/ipconfig.exe
arch     x86
baddr    0x140000000
binsz    34816
bintype  pe
bits     64
canary   false
retguard false
sanitiz  false
class    PE32+
cmp.csum 0x0000cef7
compiled Tue Jan 14 03:35:17 1986
crypto   false
dbg_file ipconfig.pdb
endian   little
havecode true
hdr.csum 0x0000cef7
guid     FF8C0F8EBC5D9AA01B9260167EE2FC3C1
laddr    0x0
linenum  false
lsyms    false
machine  AMD 64
maxopsz  16
minopsz  1
nx       true
os       windows
overlay  false
pcalign  0
pic      true
relocs   false
signed   false
static   false
stripped true
subsys   Windows CUI
va       true

SNI and ESNI

2019-07-20T00:00:00+00:00

SNI and ESNI

20 Jul 2019

Prelude

I have a DNS resolver setup at home which my home devices use and set it to use DNS over TLS (DoT) to resolve queries so ISPs and such can't see the domains I'm visiting, but SNI is leaking out the sites I'm visiting and there's nothing much I can do about it for now. 😣

What is the Purpose of SNI

Problem

Name-based virtual hosting allows multiple DNS hostnames to be hosted by a single server (usually a web server) on the same IP address. To achieve this, the server uses a hostname presented by the client as part of the protocol (for HTTP the name is presented in the host header). Source

However, when using HTTPS, the TLS connection happens before the sending of any HTTP data, so we need another way of letting the server know which host we are connecting to so it can establish the TLS connection with the correct certificate.

Solution

Server Name Indication (SNI) solves this by having the client send the hostname as part of the TLS handshake. This enables the server to establish the TLS connection with the correct certificate.

The hostname sent during TLS handshake is not encrypted, so eavesdroppers for example ISPs can see which sites you are visiting.

Here's a diagram to illustrate. 🔒 Means that it is encrypted.

sequenceDiagram
    Client->>Server: ClientHello + SNI
    Server->>Client: ServerHello
    Client->>Server: Finished🔒
    Client->>Server: HTTP Request🔒
    Server->>Client: HTTP Response🔒

I have written a SNI Sniffer (only tested on linux) to see this in effect, the code quality is pretty bad I'll update it when I have time.

➜ sudo sni-sniffer -s eth0
Started capturing on ens33
TCP V4(192.168.14.128):50596 -> V4(172.217.27.46):443
SNI: [
    "google.com",
]
TCP V4(192.168.14.128):51262 -> V4(117.18.232.200):443
SNI: [
    "az764295.vo.msecnd.net",
]
TCP V4(192.168.14.128):45508 -> V4(111.221.29.254):443
SNI: [
    "vortex.data.microsoft.com",
]
TCP V4(192.168.14.128):40952 -> V4(172.217.160.10):443
SNI: [
    "safebrowsing.googleapis.com",
]
TCP V4(192.168.14.128):37934 -> V4(35.166.72.120):443
SNI: [
    "shavar.services.mozilla.com",
]

ESNI🔒

Encrypted SNI is an extension to TLS 1.3 and above which encrypts the SNI so eavesdroppers cannot see which sites you are visiting.

sequenceDiagram
    Client->>Server: ClientHello + ESNI🔒
    Server->>Client: ServerHello
    Client->>Server: Finished🔒
    Client->>Server: HTTP Request🔒
    Server->>Client: HTTP Response🔒

The general idea of how ESNI works is the server publishes a public key on as a DNS record, which can be fetched by the client before connecting. The client then encrypts the SNI extension using a symmetric encryption key derived using the server's public key. The server can then decrypt it by deriving the same symmetric encryption key using it's private key.

For now the only browser I know that supports ESNI is Firefox, but it is not enabled by default, you have to enable it yourself, by going to about:config and setting network.security.esni.enabled to true.

The problem now is the server you are connecting to has to support ESNI as well, and there isn't much support for it software wise as the specifications for ESNI is still in draft. Even when the software support is there, most people are probably lazy to setup ESNI for their servers, currently the best/easiest solution is to use cloudflare as a reverse proxy as they have ESNI enabled by default.

Hopefully specifications for ESNI will be firmed up soon and more sites and browsers will start using ESNI.

CDDC 2019 LSCVM Writeup

2019-06-14T00:00:00+00:00

CDDC 2019 LSCVM Writeup

14 Jun 2019

This is actually a challenge from the qualifiers, but because this challenge will be used in the Finals again so we weren't allowed to post about it until after the finals. More on that later, here's the writeup.

LSCVM: Immaculate Invasion

DESCRIPTION

During our recon on the notorious fools of LightSpeedCorp, we have discovered this service which runs on a really simple, tiny, trivial, virtual machine that they have created. We are not sure of its purpose, but it certainly looks fun to play with.

lscvm-ii.cddc19q.ctf.sg 9001

IMPORTANT: We highly recommend you to fully understand this challenge as we will use this VM again in the Final.

Solution

Looking at the strings in the binary, it looks like we are dealing with a Stack based vm, and those long strings are probably the instructions.

If we try running it we'll get an error.

cddc/re/LSCVM ➜ ./lscvm-ii
[-] Flag file open error: No such file or directory

We find the code that is throwing the error and we can see it is trying to read a file called flag.

Let's create a file called flag to fix this error.

echo 'CTF{flag}' > flag

Now when we run it we can see that it asks us for an ID which we have to figure out.

cddc/re/LSCVM ➜ ./lscvm-ii

=== Welcome to LSCVM(LightSpeed Corp Virtual Machine) ===

ID : 1
[-] Wrong id

After doing some analysis, I figured out that if argc is 2 the program will print out 'debug' information.

cddc/re/LSCVM ➜ ./lscvm-ii a
@0 c [ 02 ]
@1 f [ 02 05 ]
@2 M [ 0a ]
@3 c [ 0a 02 ]
@4 f [ 0a 02 05 ]
@5 M [ 0a 0a ]
@6 h [ 0a 0a 07 ]
@7 i [ 0a 0a 07 08 ]
@8 M [ 0a 0a 38 ]
@9 f [ 0a 0a 38 05 ]
@10 A [ 0a 0a 3d ]
.
.
.

The information can be interpreted this way.

Instruction pointer	instruction	Stack after running instruction
@0	c	[ 02 ]
@1	f	[ 02 05 ]
@2	M	[ 0a ]

Using the debug output and static analysis, I was able to recover the whole instruction set.

Opcode (Hex)	Opcode (Char)	Assmebly	Comment
Default	NIL	nop	no operation, waste cycle
0x0a	\n	nop	no operation, waste cycle
0x20	\s	nop	no operation, waste cycle
0x41	A	add	Pop 2 values from stack and push the addition
0x42	B	hlt	Stop executing code
0x43	C	jmp	Pop and jump to value
0x44	D	pop	Pop a value and do nothing
0x45	E	read	Pop addr and push val. `0` <= addr <= `0x3fff`
0x46	F	sclone	pop value n and (clone) push n+1 th previous stack value
0x47	G	ipadd	Pop value and add it to IP (Instruction Pointer)
0x48	H	sshift	pop value n and shift n+1 th previous stack value to the top of the stack
0x49	I	pint	Pop value and Print as int
0x4a	J	cmp	pop 2 values and push 0 if equal, 1 if first pop is smaller else -1. `0`
0x4b	K	write	first pop is addr, 2nd pop is value to write
0x4d	M	mul	Pop 2 values from stack and push the multiplication
0x50	P	pchar	Pops value from stack and print as char
0x52	R	rjmp	Jump to previous jump location, cant do twice in a row, because it consumes the previous jump location.
0x53	S	sub	subtract 1st pop from 2nd pop push result
0x56	V	div	Divide (floor) 2nd pop by 1st pop and push result
0x5a	Z	ipcadd	conditional add to IP, if 2nd pop is 0, add 1st pop to IP
0x61	a	p0	Push 0x00 to stack
0x62	b	p1	Push 0x01 to stack
0x63	c	p2	Push 0x02 to stack
0x64	d	p3	Push 0x03 to stack
0x65	e	p4	Push 0x04 to stack
0x66	f	p5	Push 0x05 to stack
0x67	g	p6	Push 0x06 to stack
0x68	h	p7	Push 0x07 to stack
0x69	i	p8	Push 0x08 to stack
0x6a	j	p9	Push 0x09 to stack

The input we are giving the program is actually being executed by the vm as code.

To get the flag, we have to provide the vm with code that will write lsc_user to the vm memory, and then provide another code that will write hi_darkspeed-corp! to the vm memory.

Using the instruction set recovered I wrote this script to generate the vm code required to write the strings to memory and submit it to the service.

#!/usr/bin/env python3
import socket

nums = {
0x00:'a',
0x01:'b',
0x02:'c',
0x03:'d',
0x04:'e',
0x05:'f',
0x06:'g',
0x07:'h',
0x08:'i',
0x09:'j',
0x0a:'jbA',
0x0b:'jcA',
0x0c:'jdA',
0x0d:'jeA',
0x0e:'jfA',
0x0f:'jgA',
0x10:'jhA',
0x11:'jiA',
0x12:'jjA',
0x21:'eiMbA',
0x2d:'jfM',
0x5f:'jjMchMA',
0x61:'jjMcjMAcS',
0x63:'jjMcjMA',
0x64:'jjMcjMAbA',
0x65:'jjMcjMAcA',
0x68:'jjMdhMcAA',
0x69:'jjMdhMdAA',
0x6b:'jjMdjMAbS',
0x6c:'jjMdjMA',
0x6f:'jjMdjMAdA',
0x70:'jjMfhMeSA',
0x72:'jjMfhMcSA',
0x73:'jjMfhMbSA',
0x75:'jjMfhMbAA'}

def write_str(target):
    output = ''
    for i in range(len(target)):
        output += nums[ord(target[i])] + nums[i]

    return output + 'K' * len(target)

id_code = write_str('lsc_user')
pass_code = write_str('hi_darkspeed-corp!')
print('ID: {}\nPassword: {}\n'.format(id_code, pass_code))

print('Connecting to service...')
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('lscvm-ii.cddc19q.ctf.sg',9001))
client.sendall('{}\n'.format(id_code).encode())
client.sendall('{}\n'.format(pass_code).encode())
while True:
    msg = client.recv(1024).decode()
    if msg:
        print(msg)
        if '$CDDC19${' in msg:
            client.close()
            break

cddc/re/LSCVM ➜ ./solve.py
ID: jjMdjMAajjMfhMbSAbjjMcjMAcjjMchMAdjjMfhMbAAejjMfhMbSAfjjMcjMAcAgjjMfhMcSAhKKKKKKKK
Password: jjMdhMcAAajjMdhMdAAbjjMchMAcjjMcjMAbAdjjMcjMAcSejjMfhMcSAfjjMdjMAbSgjjMfhMbSAhjjMfhMeSA
ijjMcjMAcAjjjMcjMAcAjbAjjMcjMAbAjcAjfMjdAjjMcjMAjeAjjMdjMAdAjfAjjMfhMcSAjgAjjMfhMeSAjhAeiMbAjiAKK
KKKKKKKKKKKKKKKK

Connecting to service...


=== Welcome to LSCVM(LightSpeed Corp Virtual Machine) ===

ID : Password :
Login Successful! $CDDC19${IcY_GrE37ings_Fr0M_LigHT5pEeDC0Rp}

lsc_user, Good Bye!

Flag

$CDDC19${IcY_GrE37ings_Fr0M_LigHT5pEeDC0Rp}

Rant

The organizers stated in the qualifiers LSCVM challenges that it is important to fully understand the VM as it will be used again in the Finals.

IMPORTANT: We highly recommend you to fully understand this challenge as we will use this VM again in the Final.

The way they brought this accross made me think that it will play a big part in the finals, so I built a tool for the purpose of working on LSCVM challenge(s) during the Finals. However LSCVM was not a big part of the Finals and I didn't get to use my tool at all.

The finals also had Rings where you have to solve a certain number of challenges to unlock the next ring. Personally I don't think the rings concept is a good idea, because what if it just so happens the participant can't solve the starting challenges but they can solve the ones in the next or next next ring? I would've preferred it if the challenges were all available at the start.

I understand that it was implemented to limit the number of teams that can attempt the hardware challenges because they don't have enought equipment for everyone to attempt at the same time, but this can also be done by only unlocking the hardware challenges once a team reach a certain number of points/solves, instead of implementing Rings.

There's not gonna be any writeup for the finals challenges cause I did everything on the provided laptop and didn't transfer the files out.

CDDC 2019 Qualifiers Writeup

2019-06-04T00:00:00+00:00

CDDC 2019 Qualifiers Writeup

04 Jun 2019

This year's CDDC Qualifiers was very different from the previous year which was more of an 'red team' ctf, this year's qualifiers is a jeopardy style ctf and it's pretty focused on OSINT which I'm not really into, but anyways here are the writeups for some of the more interesting challenges I solved.

[B-1] Fight the Binary Monster

Category: OSINT_Blue

Drats, we found an unknown executable that someone uploaded to one of our web servers. How weird, it seems to be make heavy reference to trees. Is the author some kind of environmentalist, perhaps?

Solution

When we execute the binary it asks us for the domain it is accessing.

> .\tree_monster.exe
What domain is being accessed by this executable file?

If we grep for a common TLD .com in the binary, we find pastebin.com and 2 pastebin links.

cddc/osint_blue/Fight the Binary Monster ➜ strings tree_monster.exe| grep '\.com'
https://pastebin.com/raw/EcrLPtRP
https://pastebin.com/raw/v1cRRWEW
pastebin.com

Browsing to https://pastebin.com/raw/v1cRRWEW we get the word post repeated a lot times.

post post post post post post post post post post post post post post post post post post post post post post post post post post post post

Browsing to https://pastebin.com/raw/EcrLPtRP we get a tree. We see characters of the flag being the nodes of the tree, the previous pastebin link is a hint on using post order traversal to trasverse the tree to get the flag.

Flag

$CDDC19${havesometrees}

FunShop

Category: Crypto

Oops, I forgot what's the product code. Please help me to recover it!

http://funshop.cddc19q.ctf.sg/

Solution

When we click get on fun ant or fun guy we can see it is sending a get request to /page/transaction.php with the corresponding prod_code as the parameter.

When we send one ourself we can see that it's hinting that there's a debug mode we can enable by supplying the debug_mode=1 get parameter.

cddc/crypto/FunShop ➜ curl 'http://funshop.cddc19q.ctf.sg/page/transaction.php?prod_code=94-04-3Q
mM-ulP-c0z-k'
<!-- ?debug_mode=1 -->
Success: Actually, I'm not an ant. "I am Groot. :P"

When we supply the debug_mode=1 get parameter, we get the source code of the transcation.php.

To get the flag we have to send a prod_code that is not 94-04-3QmM-ulP-c0z-k or W8-31-5053-0kX-QiL-1, but to do this we need to know the private key, lucky for us this is an insecure implementation of a MAC which is vulnerable to hash length extension attack. We get a valid hash and we can append data to it and get the hash for the string with appended data, without having to know the private key. The only requirement for this attack is to know the length of the private key, which we can bruteforce.

Solve script

#!/usr/bin/env python3
import hashpumpy
import base64
import requests
import urllib

url = 'http://funshop.cddc19q.ctf.sg/page/transaction.php'
r = requests.get('{}?prod_code=94-04-3QmM-ulP-c0z-k'.format(url))
transaction_hash = r.cookies['transaction_hash']
prod_code = base64.b64decode(urllib.parse.unquote(r.cookies['prod_code'])).decode()

# brute force the private key length
for i in range(1, 200):
    x = hashpumpy.hashpump(transaction_hash,
        prod_code,
        'data_to_add',
        i)

    new_hash = x[0]
    crafted_data = base64.b64encode(x[1]).decode()

    cookies = {'prod_code': crafted_data, 'transaction_hash': new_hash}

    r = requests.get(url, cookies=cookies)

    if r.text != '<!-- ?debug_mode=1 -->\n':
        print('PRIVATE_KEY length = {}\n{}'.format(i, r.text))
        exit()

print('Failed')

cddc/crypto/FunShop ➜ ./length_extension.py
PRIVATE_KEY length = 14
<!-- ?debug_mode=1 -->
$CDDC19${Me0w_m30w_@wesome!_h0w_c@n_y0u_find_me?_FUNFUN}

Flag

$CDDC19${Me0w_m30w_@wesome!_h0w_c@n_y0u_find_me?_FUNFUN}

Lemonade

Category: Reverse

If we need lemons to make lemonade... Then what about Lemonade.EXE?

Solution

Looking at the strings in the binary I realized that it is a compiled AutoIT script.

Then I looked for a decompiler online and I found MyAut2EXE.

The tool found the version of AutoIT used to be AutoIT v3.3.14.5, and successfully decompiled it. Now we have the source code of the AutoIT script, and we can see the flag in plaintext in the code.

LOCAL $INT1 = GUICTRLREAD($INPUT1)
LOCAL $INT2 = GUICTRLREAD($INPUT2)
IF $INT1 = "" OR $INT2 = "" THEN

    MSGBOX(0, "NOPEEEE", "Please input numbers :)")
ELSEIF $INT1 = 941228 AND $INT2 = 940628 THEN
    MSGBOX(0, "Congratulations XD!!", "$CDDC19${easy_peasy_Autoit_squeezy}")
ELSEIF NOT STRINGISINT($INT1) OR NOT STRINGISINT($INT2) THEN
    MSGBOX(0, "NOPEEEE", "Only numbers allowed :(")
ELSE
    MSGBOX(0, "Result!!", $INT1 + $INT2)

Flag

$CDDC19${easy_peasy_Autoit_squeezy}

\'_'/

Category: Web

\'_'/

http://가나다라마바사아자차카타파하.cddc19q.ctf.sg/

Solution

When we browse to the site we are given the source code of the php file, I modified it for easier testing locally.

<?php
echo "1: ".strpos($_SERVER["QUERY_STRING"], '_')."<br>";    // strting must start with _
echo "2: ".stripos($_SERVER["QUERY_STRING"], '_')."<br>";   // string must start with _
echo "3: ".strrpos($_SERVER["QUERY_STRING"], '_')."<br>";   // last position of _ in string must be 0
echo "4: ".strripos($_SERVER["QUERY_STRING"], '_')."<br>";  // last position of _ in string must be 0
echo "5: ".strstr($_SERVER["QUERY_STRING"], '_')."<br>";
echo "6: ".strpbrk($_SERVER["QUERY_STRING"], '_')."<br>";
echo "7: ".preg_match("/[a-z][0-9._]/", $_SERVER["QUERY_STRING"])."<br>";
echo "8: ".preg_match("/ABCDEFGHIJKLMNOPQRSTUVWXYZ/", $_SERVER["QUERY_STRING"])."<br>";
print_r($_GET);
echo "=========================================================================<br>";

if( strpos($_SERVER["QUERY_STRING"], '_') == true ) {
    exit("\'1'/");
}

if( stripos($_SERVER["QUERY_STRING"], '_') == true ) {
    exit("\'2'/");
}

if( strrpos($_SERVER["QUERY_STRING"], '_') == true ) {
    exit("\'3'/");
}

if( strripos($_SERVER["QUERY_STRING"], '_') == true ) {
    exit("\'4'/");
}

if( strstr($_SERVER["QUERY_STRING"], '_') == true ) {
    exit("\'5'/");
}

if( strpbrk($_SERVER["QUERY_STRING"], '_') == true ) {
    exit("\'6'/");
}

if( preg_match("/[a-z][0-9._]/", $_SERVER["QUERY_STRING"]) ) {
    exit("\'7'/");
}

if( preg_match("/ABCDEFGHIJKLMNOPQRSTUVWXYZ/", $_SERVER["QUERY_STRING"]) ) {
    exit("\'8'/");
}

if( isset($_GET["_1234567890-ABCDEFGHIJKLMNOPQRSTUVWXYZ-qwertyuiopasdfghjklzxcvbnm_"]) ) {
    if( $_GET['_1234567890-ABCDEFGHIJKLMNOPQRSTUVWXYZ-qwertyuiopasdfghjklzxcvbnm_'] == "🚣‍♀️ 🚣🏻‍♀️ 🚣🏼‍♀️ 🚣🏽‍♀️ 🚣🏾‍♀️ 🚣🏿‍♀️ 🚣‍♂️ 🚣🏻‍♂️ 🚣🏼‍♂️ 🚣🏽‍♂️ 🚣🏾‍♂️ 🚣🏿‍♂️" ) {
        echo "CTF{Flag}";
    } else {
        echo "Param value not correct";
    }
}
else {
    echo "Required param not set";
}
?>

After some testing we found out these 2 conditions has to be true.

strting must start with _
last position of _ in string must be 0

Which is not possible if we want to set the get parameter _1234567890-ABCDEFGHIJKLMNOPQRSTUVWXYZ-qwertyuiopasdfghjklzxcvbnm_. Then it just hit me that the korean subdomain is a hint to the solution, url encoding. Since $_SERVER["QUERY_STRING" gets the query string without parsing it, this should work.

I used this Cyber Chef recipe to url encode _1234567890-ABCDEFGHIJKLMNOPQRSTUVWXYZ-qwertyuiopasdfghjklzxcvbnm_.

To_Hex('Space')
Find_/_Replace({'option':'Regex','string':'\\s'},'%',true,false,true,false)
Find_/_Replace({'option':'Regex','string':'^'},'%',true,false,true,false)

This is our payload url.

http://가나다라마바사아자차카타파하.cddc19q.ctf.sg/?%5f%31%32%33%34%35%36%37%38%39%30%2d%41%42%43%44%45%46%47%48%49%4a%4b%4c%4d%4e%4f%50%51%52%53%54%55%56%57%58%59%5a%2d%71%77%65%72%74%79%75%69%6f%70%61%73%64%66%67%68%6a%6b%6c%7a%78%63%76%62%6e%6d%5f=🚣‍♀️ 🚣🏻‍♀️ 🚣🏼‍♀️ 🚣🏽‍♀️ 🚣🏾‍♀️ 🚣🏿‍♀️ 🚣‍♂️ 🚣🏻‍♂️ 🚣🏼‍♂️ 🚣🏽‍♂️ 🚣🏾‍♂️ 🚣🏿‍♂️

Sure enought it worked.

Flag

$CDDC19${PHP_tricks_are_very_fun!}

System32 Magic

2019-05-21T00:00:00+00:00

System32 Magic

21 May 2019

So I was using 32-bit python on windows and trying to read a binary in System32.

with open(r'C:\Windows\System32\FileHistory.exe', 'rb') as f:
    content = f.read()

Then I was thrown the following error.

This makes no sense, I know the file exists in System32.

After some hair tearing and swearing, I figured it out. This error occurs because 32-bit applications are redirected to SysWOW64 when they try to access System32 and there is no FileHistory.exe in SysWOW64.

To access the real System32 with 32-bit applications, replace System32 with Sysnative. Sysnative is a special alias that is only visible and accessible from 32-bit programs. So in this case I have to use the following path to actually read the file.

with open(r'C:\Windows\Sysnative\FileHistory.exe', 'rb') as f:
    content = f.read()

Why?

Microsoft wants to split the DLLs and other stuff used by 64-bit and 32-bit applications. 64-bit DLLs will be located in System32 because it is a hardcoded path by a lot of apps.

Intuitively SysWOW64 seems like it should contain 64-bit stuff, but WOW64 stands for Windows 32-bit on Windows 64-bit so it actually contains 32-bit stuff.

In computing on Microsoft platforms, WoW64 (Windows 32-bit on Windows 64-bit) is a subsystem of the Windows operating system capable of running 32-bit applications on 64-bit Windows.

Why not keep 32-bit stuff in System32 and apply the redirection to 64-bit apps instead, and name the 64-bit folder something more intuitive like System64 so it won't be so confusing? Maybe Microsoft is in the forefront of implementing security by confusion.

Resources

Where are the Strings in Windows Binaries

2019-05-04T00:00:00+00:00

Where are the Strings in Windows Binaries

04 May 2019

Prelude

The Windows Binaries I'm talking about here are the ones that comes default with Windows provided by Microsoft.

Searching for Strings in the binary

I was analyzing a Windows binary C:\Windows\System32\where.exe when I realized the help text of the binary cannot be found anywhere in the binary.

After some futher investigation using Process Monitor from Windows Sysinternals I found out that it is reading from C:\Windows\System32\en-US\where.exe.mui during it's execution.

Searching for Strings in the MUI

I did some googling to find out more about the MUI file type and realized that it's how Windows enable support for different user interface languages.

Multilingual User Interface (MUI) enables the localization of user interfaces for globalized applications. MUI also supports the creation of resources for any number of user interface languages.

Further googling on how to open it says that it can be opened using 7zip, so I did and found the strings in .rsrc\string.txt in the archieve.

52	Type "WHERE /?" for usage help.\n
58	ERROR: Invalid directory specified.\n
60	ERROR: "$env:pattern" cannot be used with /R.\n
63	ERROR: Missing pattern in "$env:pattern".\n
64	INFO: Could not find "%s".\n
--------------------------snip--------------------------

What's weird is when I ran linux's strings on the MUI file which did not manage to find the strings in the MUI file, so I initially thought that the MUI file is compressed.

I then ran file on where.exe.mui and it returned PE32 executable (DLL) (GUI) Intel 80386, for MS Windows, I thought that's weird, so I tried opening the file in CFF Explorer and it worked! So a MUI file is actually a PE file.

If we check the resource directories of where.exe.mui using CFF Explorer we can see a resource directory called String Tables. If we check the data within the Directory, we can find all the strings we previously seen using 7zip.

The only thing that's weird was each character was followed by a null byte, which turns out to be because the strings are stored as unicode. Now it makes sense why linux's strings did not find anything, it does not search for unicode strings. I tried again with the strings tool from Windows Sysinternals and it managed to find the strings because it also searches for unicode strings.

I also looked at bash.exe.mui and realized that the strings can also be in the MESSAGETABLE section of the resource directory, which have the ID of 0xb.

All the resource type can be found from the Microsoft Documentation.

Ending Notes

Most of the Windows binaries does this, but not all, if you want to extract all the strings used by a Windows binary you should combine finding strings in the binary and the MUI.

The strings can be in STRING (ID of 0x6) and MESSAGETABLE (ID of 0xb) section of the resource directory of the MUI file.

I have made a tool in rust to retrieve the strings from a MUI file.

Preventing Email Spoofing with SPF, DKIM and DMARC

2019-04-11T00:00:00+00:00

Preventing Email Spoofing with SPF, DKIM and DMARC

11 Apr 2019

Preventing email spoofing is important to all domain owners, even if you are not using your domain for email services as it affects the reputation of your domain. In this post I will talk about how to prevent email spoofing with SPF, DKIM and DMARC.

Sender Policy Framework (SPF)

SPF allows the receiver to check that an email claiming to come from a specific domain comes from an IP address authorized by that domain's administrators. The list of authorized sending hosts and IP addresses for a domain is in the SPF record for the domain which is published in the DNS TXT records for that domain.

How it works

The receiver checks if the sender is valid by querying the domain in the message header field Return-Path aka MAIL FROM for SPF record and checking the sender's IP against that record.

Setup

Place the SPF record at the root of your domain.

Directive	Effect
-all	non-matching emails will be rejected
~all	non-matching emails will be accepted but marked
+all	allows any ip to send email from your domain.

This SPF record below will allow emails from 10.0.0.1, 2001:0db8:85a3:0000:0000:8a2e:0370:7334 and all the allowed IPs from the spf record from example.com and reject emails sent from all other IPs.

v=spf1 ip4:10.0.0.1 ip6:2001:0db8:85a3:0000:0000:8a2e:0370:7334 include:example.com -all

For more options check out the rfc.

Things to Note

SPF records cannot include more than ten dns queries.

A single TXT record cannot be more than 255 characters, but we can concate TXT records to form a SPF record of a longer length.

The DNS overhead for a reply that contains a single TXT record with two strings is about 34 bytes, plus the length of the hostname that’s being queries (e.g. "spf.example.com" is 15 bytes). So to keep within the 512 byte limit you need to break your SPF into chunks of no more than 478 minus the length of the hostname.

Another option is SPF record chaining.

You can check your spf record using this SPF Checker.

Macros

It is possible to create more complex SPF records using marcros.

Problem

SPF does not validate the From header which is shown in most clients as the actual sender of the message, but uses the Return-Path to determine the sending domain.

For example, a email was sent with the Return-Path of example.com and a From field of david@dzhy.dev assuming dzhy.dev have SPF setup to not allow any IPs, if example.com has a SPF record that allows my IP, the SPF check will still pass, because it does not check the From field, instead it checks the Return-Path.

Domain Keys Identified Mail (DKIM)

DKIM checks that an email was indeed send and authorized by the owner of that domain using digital signatures. This DKIM signature is a header that is added to the message and is secured with encryption.

How it works

The DKIM signature is generated by the MTA (Mail Transfer Agent). It creates a hash of the email. This hash value is encrypted using the private key and attached to the email as the DKIM signature in the header.

After receiving the email, the receiver verifies the DKIM signature using the public key in the TXT record of the domain specified in the signature, by decrypting the DKIM signature and comparing the decrypted hash value with the hash value of the email it received. If these two hashes are the same the MTA knows that the email has not been altered. This gives the user confirmation that the email was actually sent from the listed domain.

Setup

Refer to your email service provider's documentation. Typically all you have to do is to add a DNS TXT record to your domain.

Finding DKIM selector

The DKIM record is at selector._domainkey.dzhy.dev, the selector can be any string, we can only find out the selector of a domain if we have the DKIM-Signature, of a email sent by that domain.

In the signature, the s field is the selector, so in this case s=zoho means the selector is zoho and the DKIM public key will be at zoho._domainkey.dzhy.dev.

DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1554622568; 
s=zoho; d=dzhy.dev; i=david@dzhy.dev; h=Date:From:To:Message-Id:Subject:MIME-
Version:Content-Type; l=721; bh=YLjE/ckf0hWWS6SSYjvfMS06DZjBcD0C0ignKAs7TUs=;
b=HT4wf4u2t5PiApv9zgAWiyTbC8dwoE5qV7vZbGO+/1t+XUPOOlwGV3tfM/0/GqYl
oVtsVDqykG1B2iKGlXIDJGSU6qzsuzxCmHlv3YaddIR7WWLteCvMM4lOg3ZzwSHtiNx 
dVwG2fJ/iSgzB1AFrSQJa/C21ZewOKL0J8piwKYg=

Problem

The dkim signature can be valid and have no relation to the From header.

For example, I can have the following DKIM signature

DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; t=1554622568; 
s=zoho; d=dzhy.dev; i=david@dzhy.dev; h=Date:From:To:Message-Id:Subject:MIME-
Version:Content-Type; l=721; bh=YLjE/ckf0hWWS6SSYjvfMS06DZjBcD0C0ignKAs7TUs=;
b=HT4wf4u2t5PiApv9zgAWiyTbC8dwoE5qV7vZbGO+/1t+XUPOOlwGV3tfM/0/GqYl
oVtsVDqykG1B2iKGlXIDJGSU6qzsuzxCmHlv3YaddIR7WWLteCvMM4lOg3ZzwSHtiNx 
dVwG2fJ/iSgzB1AFrSQJa/C21ZewOKL0J8piwKYg=

which is for the domain dzhy.dev but my From field is david@example.com, this will be valid because the signature is valid for the given domain dzhy.dev, it does not check the signature using the domain in the From field.

Domain-based Message Authentication, Reporting & Conformance (DMARC)

DMARC builds on the widely deployed SPF and DKIM protocols, to improve and monitor protection of the domain from fraudulent email. It is meant to fix the issues of SPF and DKIM. Implementing SPF and DKIM by themselves does not prevent spoofing, but combined with DMARC they will work great.

DMARC requires authentication alignment with the domain used in the header From, for both SPF and DKIM. Meaning the domain in DKIM must share the same organizational domain as the From header or be the exact same depending on the configuration, the domain for SPF the Return-Path and the header From should share an organizational domain or be the exact same depending on the configuration.

How it works

The receiver extracts the domain in the From header, and queries for a DMARC policy record of that domain. If it exists, perform DKIM and SPF checks, then perform Identifier Alignment checks. Emails that fail the DMARC mechanism check are disposed of in accordance with the discovered DMARC policy of the Domain Owner.

Setup

Domain Owner DMARC preferences are stored as DNS TXT records in subdomains named _dmarc. For example, the Domain Owner of example.com would post DMARC preferences in a TXT record at _dmarc.example.com.

The table below explains each tag of the sample DMARC policy.

Tag	Effect
v=DMARC1	Specify DMARC version
p=reject	Reject any mail that fails the DMARC check
rua=mailto:dmarc@dzhy.dev	Send aggregate reports to `dmarc@dzhy.dev`
adkim=s	DKIM Identifier Alignment strict mode
adkim=s	SPF Identifier Alignment strict mode
ruf=mailto:dmarc@dzhy.dev	Send failure reports to `dmarc@dzhy.dev`
fo=1	Generate a DMARC failure report if any checks failed

By default daily aggregate reports will be sent if you set a rua address.

Sample DMARC policy.

v=DMARC1; p=reject; rua=mailto:dmarc@dzhy.dev; adkim=s ; aspf=s ; ruf=mailto:dmarc@dzhy.dev ; fo=1

For other options refer to rfc7489 Section 6.3

Resources

Firefly III Setup with Docker and HTTPS

2019-04-06T00:00:00+00:00

Firefly III Setup with Docker and HTTPS

06 Apr 2019

In this tutorial we will setup Firefly III using docker and setup a reverse proxy to enable https, as Firefly III itself does not support https. For the purpose of this tutorial we will be using firefly.example.com as the domain.

Note: This tutorial assumes you have already setup a mysql/postgres database.

Docker

If you have not yet installed docker refere to docker install documentation to install it first.

First we create persistent volumes to store uploaded files and exported data.

docker volume create firefly_iii_export
docker volume create firefly_iii_upload

To ensure the site works behind our reverse proxy and all the links on the site is using https we have to set the following environment variables.

APP_URL=https://firefly.example.com
TRUSTED_PROXIES=**

The app key is any 32 character alphanumeric string. The database by default is assumed to be MySQL, if you are using a Postgres database you have to set an extra environment vairable DB_CONNECTION=pgsql.

The following command will run the firefly-iii container and map it to port 4040 on the host.

docker run -d \
-v firefly_iii_export:/var/www/firefly-iii/storage/export \
-v firefly_iii_upload:/var/www/firefly-iii/storage/upload \
-p 127.0.0.1:4040:80 \
-e FF_APP_ENV=local \
-e FF_APP_KEY=12345678901234567890123456789012 \
-e FF_DB_HOST=CHANGEME \
-e FF_DB_PORT=CHANGEME \
-e FF_DB_NAME=CHANGEME \
-e FF_DB_USER=CHANGEME \
-e FF_DB_PASSWORD=CHANGEME \
-e APP_URL=https://firefly.example.com \
-e TRUSTED_PROXIES=** \
--name firefly-iii-c1 \
jc5x/firefly-iii:latest

Enable Recurring Transactions

You can ignore this if you are not planning on using recurring transactions.

Drop into shell on the container

docker exec -it firefly-iii-c1 /bin/bash

Install cron in docker container

apt update
apt install cron

Run crontab -e to edit cronjobs, then add the following cron job to enable recurring transactions.

0 0 * * * /usr/local/bin/php /var/www/firefly-iii/artisan firefly:cron

These changes will persist even if you restart the container, however if you start another container from the image jc5x/firefly-iii:latest you have to do these steps again.

Setup Nginx

If you are using cloudflare as your dns provider, you can refer to [this post]({% post_url 2019-04-03-Certbot-Cloudflare-DNS-Plugin %}) on getting TLS certificates from Let's Encrypt using the cloudflare dns plugin.

This is a sample site configuration for nginx. Change firefly.example.com to your domain. You should also change the proxy_pass parameter on line 17 if you mapped the host port of Firefly III to a port other than 4040, or if the docker container is running on another host.

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name firefly.example.com;

    # SSL
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;

    # logging
    access_log /var/log/nginx/firefly.example.com.access.log;
    error_log /var/log/nginx/firefly.example.com.error.log warn;

    # reverse proxy
    location / {
        proxy_pass http://127.0.0.1:4040;
        proxy_http_version      1.1;
        proxy_cache_bypass      $http_upgrade;
        proxy_set_header Upgrade                $http_upgrade;
        proxy_set_header Connection             "upgrade";
        proxy_set_header Host                   $host;
        proxy_set_header X-Real-IP              $remote_addr;
        proxy_set_header X-Forwarded-For        $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto      $scheme;
        proxy_set_header X-Forwarded-Host       $host;
        proxy_set_header X-Forwarded-Port       $server_port;
    }
    
    # security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;
    add_header Content-Security-Policy "default-src * data: 'unsafe-eval' 'unsafe-inline'" always;
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;

    # . files
    location ~ /\.(?!well-known) {
        deny all;
    }

    # gzip
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css text/xml application/json application/javascript application/xml+rss applica
    tion/atom+xml image/svg+xml;
}

# subdomains redirect
server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name *.firefly.example.com;

    # SSL
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;

    return 301 https://firefly.example.com$request_uri;
}

# HTTP redirect
server {
    listen 80;
    listen [::]:80;
    server_name .firefly.example.com;

    location / {
        return 301 https://firefly.example.com$request_uri;
    }
}

Resources

Certbot - Cloudflare DNS Plugin

2019-04-02T00:00:00+00:00

Certbot - Cloudflare DNS Plugin

02 Apr 2019

In this tutorial we will get a wildcard certificate from letsencrypt using the cloudflare dns plugin. For the purpose of this tutorial we will be using example.com as the domain.

Install Cloudflare DNS Plugin

This tutorial assumes you have already installed certbot. If you have not, you can follow the instructions from certbot-eff.

sudo apt update
sudo apt install python3-certbot-dns-cloudflare -y

API Credentials

mkdir -p /root/secrets/certbot

Retrieve your api key from cloudflare.

Login to the Cloudflare account.

Go to My Profile.

Scroll down to API Keys and locate Global API Key.

Click API Key to see your API identifier.

Create the file below with your cloudflare information. We will save the file at /root/secrets/certbot/cloudflare.ini.

# Cloudflare API credentials used by Certbot
dns_cloudflare_email = cloudflare@example.com
dns_cloudflare_api_key = 0123456789abcdef0123456789abcdef01234567

Secure the folder and file.

find /root/secrets -type d -exec chmod 700 {} \;
find /root/secrets -type f -exec chmod 600 {} \;

Requesting for Certificate

The --dns-cloudflare-propagation-seconds option defines the number of seconds to wait before doing the validation checks, you can change it accordingly.

It is important that we specify the server to be the ACME v2 server as the v1 server does not support wildcard certificates.

certbot certonly \
  --preferred-challenges dns \
  --email admin@example.com
  --dns-cloudflare-credentials /root/secrets/certbot/cloudflare.ini \
  --dns-cloudflare-propagation-seconds 60 \
  -d "*.example.com" -d example.com \
  --server https://acme-v02.api.letsencrypt.org/directory \
  --agree-tos

We should now have our cert at /etc/letsencrypt/live/example.com/.

root@server:~# ls -la /etc/letsencrypt/live/example.com
total 12
drwxr-xr-x 2 root root 4096 Apr  3 10:44 .
drwx------ 3 root root 4096 Apr  3 10:44 ..
lrwxrwxrwx 1 root root   34 Apr  3 10:44 cert.pem -> ../../archive/example.com/cert1.pem
lrwxrwxrwx 1 root root   35 Apr  3 10:44 chain.pem -> ../../archive/example.com/chain1.pem
lrwxrwxrwx 1 root root   39 Apr  3 10:44 fullchain.pem -> ../../archive/example.com/fullchain1.pem
lrwxrwxrwx 1 root root   37 Apr  3 10:44 privkey.pem -> ../../archive/example.com/privkey1.pem
-rw-r--r-- 1 root root  692 Apr  3 10:44 README