Add 2022 leet challenges

Author: KevinL10

Diff for: _posts/2022-11-08-diffie-hellman-guide.md

@@ -0,0 +1,140 @@
+---
+layout: post
+title: "1337 Crypto Guide - Diffie Hellman"
+author: vEvergarden
+hide: "true"
+---
+
+Let's begin by introducing our two favourite people - Alice and Bob.
+
+![](https://i.imgur.com/46b0dOe.png)
+
+
+Alice and Bob have a mutual enemy - Eve. 
+![](https://i.imgur.com/HPTmmsh.png)
+
+
+Eve is notorious for *eaves*dropping on other people's conversations and listening to all of their gossip. One day, Alice and Bob decide that they've had enough of Eve's eavesdropping. They want to communicate in public, but in a way such that only they themselves can understand each other.
+
+One way they can accomplish this is by speaking a different language that Eve doesn't understand. Now, they can freely talk to each other in the open without worrying about Eve listening in on their conversations.
+
+Similarly, **cryptographic ciphers** are another way Alice and Bob can securely communicate with each other. If they decide on a secret key on a slip of paper beforehand (similar to a password), they can **encrypt** all of their messages with that secret key. To Eve who doesn't know the secret key, all of Alice's and Bob's messages are just random garbage that she can't understand.
+
+![](https://i.imgur.com/t5DAg1l.png)
+
+
+Now, all is well - Alice and Bob have found a way to talk without Eve understanding what they're saying. 
+
+
+### Details
+[AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) is the most widely used block cipher - it's used to encrypt/decrypt messages with a given secret key. The length of the key and message must be multiples of 16 bytes; for the message, we can simply add a few extra bytes at the end; for the key, we can apply the [SHA-256](https://www.n-able.com/blog/sha-256-encryption) hash function to produce a 32-byte hash.
+
+The Python `pycryptodome` library offers a wide range of cryptography tools - try playing around with the code below!
+```python
+from Crypto.Util.Padding import pad
+from Crypto.Cipher import AES
+from hashlib import sha256
+
+# we use SHA256 to ensure that the key is the right length
+key = sha256(b'my secret key').digest()
+cipher = AES.new(key, AES.MODE_ECB)
+
+# the length of your message has to be a multiple of 16, so we pad it with some extra bytes
+message = pad(b'This is a secret message!', 16)
+ciphertext = cipher.encrypt(message)
+print("Encrypted message:", ciphertext)
+
+# Decryption is very similar!
+plaintext = cipher.decrypt(ciphertext)
+print("Decrypted message:", plaintext)
+```
+
+## Part 2
+
+Five years later, Alice and Bob have moved to different parts of the world. They can't talk to each other in-person anymore, but they would like to communicate digitally. Unfortunately, Bob has forgotten the original secret key that they decided on, and (even after 5 years) they're still worried about Eve spying on their conversations.
+
+What's different is that this time there's **no easy way to decide on a secret key**. For example:
+- If they mail a slip of paper with the key written on it, someone could intercept it midway
+- If they send it through e-mail, someone hosting the mail server may see the secret key
+- If they say what the key is over a call, someone could tap in on their conversation
+
+![](https://i.imgur.com/pffi11V.png)
+
+Think about this problem for a bit and see if you can come up with your own ideas. Is it possible to decide on something secret over a network where anyone can see what you send?
+
+Yes! In fact, the **Diffie-Hellman Key Exchange** is one method for securely exchanging a secret key. Alice and Bob will each generate a "public" and "private" key - using those, they can then generate a shared secret that only they know. Even if Eve sees all of the communication between Alice and Bob, she can't figure out what their shared secret is.
+
+### Details
+
+The Diffie-Hellman Key Exchange revolves around some mathematical concepts - but don't be intimidated! 
+
+The process begins with:
+- Alice randomly picks an integer $a$
+- Bob randomly picks an integer $b$
+
+$a$ and $b$ are Alice's and Bob's personal "private keys". If anyone is able to guess or brute-force either of these private keys, they can recover the shared secret. Usually, $a$ and $b$ are on the order of $2^{1024}$, making it computationally infeasible to try out all possibilities.
+
+Beforehand, Alice and Bob have publicly decided on the integers $g$ and $p$ - Eve will know these values.
+
+Now:
+- Alice calculates $g^a \mod p$ and sends it publicly to Bob 
+- Bob calculates $g^b \mod p$ and sends it publicly to Alice 
+- (Here, $g^x \mod p$ is the remainder when $g^x$ is divided by p)
+
+![](https://i.imgur.com/jGHumNZ.png)
+
+
+
+**The key idea is that: even if Eve knows $g$, $p$, and $g^a \mod p$, she won't be able to find the value of $a$**. Not even Bob will know the value of $a$ - only Alice knows $a$ because she was the one who chose it.
+
+Similarly, neither Alice nor Eve know the value of $b$, even though they know $g$, $p$, and $g^b \mod p$
+
+The problem of finding either $a$ or $b$ in these cases is known as the [**Discrete Logarithm Problem**](https://en.wikipedia.org/wiki/Discrete_logarithm). There are faster solutions than simply trying out all values of $a$, but they are still far too slow to find $a$ or $b$ in reasonable time.
+
+Alice, now knowing the value of $g^b$, can compute $(g^b) ^a \equiv g^{ba} \mod p$
+
+Bob, now knowing the value of $g^a$, can compute $(g^a) ^ b \equiv g ^ {ab} \mod p$.
+
+![](https://i.imgur.com/OnAbfVE.png)
+
+
+Since $g^{ab} \equiv g^{ba} \mod p$, **Alice and Bob have successfully decided on a secret value: $g^{ab} \mod p$!** Even though Eve knows the values:
+- $g$
+- $p$
+- $g^a \mod p$
+- $g^b \mod p$
+
+there is no way for her to find $g^{ab} \mod p$ because the **Discrete Logarithm Problem** is computationally hard and will take a *very, very* long time to solve.
+
+```python
+from Crypto.Util.number import getPrime
+from random import randint
+
+p = getPrime(1024)        # generate a large modulus 
+g = 2
+
+alice_secret = randint(0, p)
+alice_public = pow(g, alice_secret, p)        # g^a mod p
+
+bob_secret = randint(0, p)
+bob_public = pow(g, bob_secret, p)            # g^b mod p
+
+# Alice calculates the shared secret: (g^b)^a == g^(ba) mod p
+shared_secret_A = pow(bob_public, alice_secret, p)   
+
+# Bob calculates the shared secret: (g^a)^b == g^(ab) mod p
+shared_secret_B = pow(alice_public, bob_secret, p)
+
+# They've successfully shared a secret that only they know!
+assert shared_secret_A == shared_secret_B
+```
+
+Now, Alice and Bob can continue along their merry ways and use AES, with the shared secret as the AES key, to securely encrypt their messages (see Part 1 for details).
+
+# Summary
+
+We started off with Alice and Bob - they wanted to communicate securely because Eve was eavesdropping on their conversations. We accomplished this by making Alice and Bob decide on a secret, then using a cryptographic cipher like [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) to encrypt/decrypt their messages.
+
+Then, we pondered how we could decide a shared secret if Eve could also eavesdrop on that process. Ultimately, the **Diffie-Hellman Key Exchange** came to the rescue - it relies on the Discrete Logarithm Problem being hard to solve. Even if Eve can see everything that Alice sends to Bob and everything that Bob sends to Alice, she still won't be able to calculate Alice and Bob's shared secret. From there, Alice and Bob can use a cipher like AES, as in the first part.
+
+![](https://i.imgur.com/ZY1jz82.png)

Diff for: _posts/2022-11-08-jail-challenges-guide.md

@@ -0,0 +1,19 @@
+---
+layout: post
+title: "1337 Misc Guide - Jail Challenges in CTFs"
+author: rctcwyvrn
+---
+
+### Jail challenges in CTFs
+
+Jail challenges are a kind of `misc` category challenge in CTFs where the server lets you run arbitrary code, but subject to certain restrictions. For example python jails might not let you import anything or limit you to a very limited character set.
+
+Typically in jail challenges the goal is to spawn a shell, ie to convince the jail to let you execute something like `bash` or `sh`.
+
+For example a python jail might call `exec` on your input, but doing `exec("import os; os.system('bash')")` would let you escape into the shell.
+- https://docs.python.org/3/library/functions.html#exec 
+- https://docs.python.org/3/library/os.html#os.system 
+
+Now these examples are for python jails, in this challenge you'll be in a racket jail. Convincing the jail to allow you execute the racket equivalent like `os.system("bash")` will usually require some manipulation of your input in order to work around the blocklist or restrictions put in place by the jail, and it'll be a similar story in this challenge.
+
+

Diff for: _posts/2022-11-08-reversing-guide.md

@@ -0,0 +1,41 @@
+---
+layout: post
+title: "1337 Reversing Guide - "
+author: Kevin
+hide: "true"
+---
+
+
+## What is reverse engineering?
+In the context of software engineering, reverse engineering is the process of taking a program and finding out what it does. This is a difficult process because source code is not usually provided which means that the only thing you can work with is the machine code that the program is comprised of. Luckily, there are tools out there that can make your life a lot easier.
+
+## How do I reverse engineer a program?
+A program is comprised of machine code that in not legible by a human. This is why when you open an `.exe` file in a text editor it just looks like garbage. So the first step in reverse engineering is to turn this machine code into something a person can read. Usually, a disassembler is used to convert machine code into human readable assembly.
+
+![disassembly.PNG](/assets/images/rev-guide/disassembly.PNG)
+<center> <em>The result of disassembling a program using a disassembler.</em> </center></br>
+
+However, it is still difficult to understand what is going on. Fortunately, we can do better than the disassembly. There are programs called decompilers that will try to decompile the program into C like source code.
+
+![decompile.PNG](/assets/images/rev-guide/decompile.PNG)
+<center> <em>The result of decompiling a program using a decompiler.</em> </center></br>
+
+## Disassemblers vs. Decompilers
+
+One may be asking why would they ever use a disassembler over a decompiler. The answer is that while decompilers generate output that is easier to understand the way it does this is through a heuristic. This means that sometimes that decompilers will output something that does not make any sense at all. On the other hand, disassemblers generate their output by directly translating machine code to assembly using documentation from the instruction set that the CPU must follow.  This is why its still important to be able to understand assembly.
+
+## Static Analysis vs. Dynamic Analysis
+There are two approaches to reverse engineering; static analysis and dynamic analysis.</br>
+Static analysis is the practice of reverse engineering the program without ever running it. This involves figuring out what the machine code is trying to do using some of the tools that we have mentioned before.
+
+Dynamic analysis is all about running the program to figure out what its doing. It involves attaching a debugger to the program when it is running and then examining the state of the during the execution of the program. The state of the program includes things such as register values and what is in memory at the time of execution.
+
+There is no single best approach and one may be better than the other depending on the program that you are trying to analyze.
+
+## Tools
+Okay, now for the important part. What are these tools that I have been talking about all this time?
+
+For static analysis, `Ghidra` is an open source disassembler/decompiler that is developed by the NSA. It is both a disassembler and decompiler. The best part is its open source and free!
+
+For dynamic analysis, personally I use `gdb` plus an extension like `gef` that provides a couple more features.
+

Diff for: assets/1337-2022/crypto/main.py

@@ -0,0 +1,60 @@
+from Crypto.Util.Padding import pad
+from Crypto.Util.number import getPrime
+from Crypto.Cipher import AES
+from hashlib import sha256
+from random import randint
+from secrets import flag  # imports the challenge flag
+import sys
+
+sys.setrecursionlimit(10**8)
+
+p = getPrime(1024)
+G = [[1, 1337], [0, 1]]
+
+# multiply two 2x2 matrices A and B:
+def mult(A, B):
+    result = [[0, 0], [0, 0]]
+    for i in range(2):
+        for j in range(2):
+            result[i][j] = (A[i][0] * B[0][j] + A[i][1] * B[1][j]) % p
+    return result
+
+
+# compute A^n with exponentiation by squaring
+def exp(A, n):
+    if n == 0:
+        return [[1, 0], [0, 1]]
+    half = exp(A, n // 2)
+    if n % 2 == 0:
+        return mult(half, half)
+    return mult(A, mult(half, half))
+
+
+# generate Alice's private and public keys
+alice_secret = randint(0, p)
+alice_public = exp(G, alice_secret)
+
+# generate Bob's private and public keys
+bob_secret = randint(0, p)
+bob_public = exp(G, bob_secret)
+
+# generate their shared secrets & check that they're the same
+shared_secret_A = exp(bob_public, alice_secret)
+shared_secret_B = exp(alice_public, bob_secret)
+assert shared_secret_A == shared_secret_B
+
+# encrypt the flag with the shared secret
+key = str(
+    shared_secret_A[0][0]
+    + shared_secret_A[0][1]
+    + shared_secret_A[1][0]
+    + shared_secret_A[1][1]
+).encode()
+key = sha256(key).digest()
+cipher = AES.new(key, AES.MODE_ECB)
+ciphertext = cipher.encrypt(pad(flag, 16))
+
+print("p:", p)
+print("Alice's public key:", alice_public)
+print("Bob's public key:", bob_public)
+print("Ciphertext:", ciphertext.hex())

Diff for: assets/1337-2022/crypto/output.txt

@@ -0,0 +1,4 @@
+p: 146635760303605976983894071500931857745973394259316464700291483611526724218460127444254168689045959985005212817040847174467141482547356061539722956992438198039196888496774232353702637340110963371323293180453107143830592752177650175267498096676840496849442055749071547763221826370121367266367265736640016224849
+Alice's public key: [[1, 122593569202713047256910856823064610802102165848412863419714367343535068432181229651183057378109240921706373026419955238421640119452077037295962596003436443748125952314067117706872613751900101093292596858137281488155807864319911989756603206024363635538681795330100292400684134799357570963098198243796012905071], [0, 1]]
+Bob's public key: [[1, 142857700274726494408753852766748133062989262570137331655228102720787303055171574691107864588269598429108651878879476731967757999196356469620766415382477392868604610906632622085379260676352636736367989787236537655987365802465995407192642985159206280944380481606853288780557358104659172496832399866770779719373], [0, 1]]
+Ciphertext: 214ede254e789f9cd153b54ca115d5c2dce406dc9552bfd00241ed2054706f91

Diff for: assets/1337-2022/misc/jail1.rkt

@@ -0,0 +1,19 @@
+#lang racket
+
+(define (jail)
+  ; Prepare the jail namespace
+  (parameterize ([current-namespace (make-base-namespace)])
+    ; Inside your jail you have racket/system and racket/base
+    ; https://docs.racket-lang.org/reference/subprocess.html#%28mod-path._racket%2Fsystem%29
+    (namespace-require 'racket/system)
+    (printf "> ")
+    (let ([stx (syntax->datum (read-syntax))])
+      (printf "Your input: ~a\n" stx)
+      (printf "Result: ~a \n" (eval stx)))))
+
+(module+ main
+  (displayln "Welcome to Racket jail, where people who complain about the usage of Racket in 110 are sentenced to, forced to live in a Racket REPL for all eternity")
+  (displayln "'Racket has no practical uses' you say? Well you better learn about some practical uses if you wanna escape!\n")
+  (displayln "Hint: Successfully run the `get-flag` command in a shell to obtain the flag. You'll need to escape from Racket into the system shell in order to do it")
+  (jail)
+  (displayln "Exiting"))

Diff for: assets/1337-2022/misc/jail2.rkt

@@ -0,0 +1,70 @@
+#lang racket
+
+; Just a conversion function
+(define (datum->string d)
+  (cond
+    [(string? d) d]
+    [(number? d) (number->string d)]
+    [(symbol? d) (symbol->string d)]
+    [else (error "datum->string: not a terminal")]))
+
+; None of these functions are allowed this time! No easy escape tools!
+(define (strictly-forbidden? x)
+  (ormap (curry string-contains? x) 
+         (list "system" "process" "read-eval-print-loop" "shell-execute")))
+
+; Have you used your one exception?
+(define has-seen-allowed-exception #f)
+
+; A string is allowed if it it is one of:
+; - A single character in length 
+; - A string containing "string" (https://docs.racket-lang.org/reference/strings.html)
+; - A string containing "quote" (https://docs.racket-lang.org/guide/quote.html https://docs.racket-lang.org/guide/qq.html)
+(define (allowed? term)
+  (or (string-contains? term "string") 
+      (string-contains? term "quote")
+      (eq? (string-length term) 1)))
+
+; Check that each term follows the requirements
+(define (check term)
+  (printf "check: ~a (has-seen-allowed-exception ~a) \n" term has-seen-allowed-exception)
+    (cond
+    ; Never allow any strictly forbidden terms
+    [(strictly-forbidden? term) #f]
+    ; Check if the term is allowed
+    [(allowed? term) #t]
+    ; You're allowed to have ONE term that is not normally allowed! Use it wisely
+    [has-seen-allowed-exception #f]
+    [else
+     (begin
+       (set! has-seen-allowed-exception #t)
+       #t)]))
+
+; Walk down the syntax tree to check that everything follows the requirements
+(define (valid stx)
+  (match stx
+    [`(,xs ...) (andmap valid xs)]
+    [x (check (datum->string x))]))
+
+(define (jail)
+  ; Prepare the jail namespace
+  (parameterize ([current-namespace (make-base-namespace)])
+    ; Inside your jail you have racket/system and racket/base
+    ; https://docs.racket-lang.org/reference/subprocess.html#%28mod-path._racket%2Fsystem%29
+    (namespace-require 'racket/system)
+    (printf "> ")
+    (let ([stx (syntax->datum (read-syntax))])
+      (printf "Your input: ~a\n" stx)
+      ; Check the given racket expression
+      (if (valid stx) 
+          ; if it's valid, eval it https://docs.racket-lang.org/guide/eval.html
+          (printf "Result: ~a \n" (eval stx)) 
+          (printf "Invalid input: ~a \n" stx)))))
+
+(module+ main
+  (displayln "Well done escaping out of that last jail, but there's no way you'll get out of this one!")
+  (displayln "We've taken away all of your escape tools so there should be no way of escaping")
+  (displayln "PS: Warden Gregor felt bad for you so he said to give you one exception to our rules, it's not like you can escape with just one exception anyway")
+  (displayln "Hint: Successfully run the `get-flag` command to obtain the flag")
+  (jail)
+  (displayln "Exiting"))