#somethingawesome

This one was a bit harder to do as its clearly taken alot longer (mostly because the logic of my code was not correct 😢). However now it works relatively well it should be able to decrypt most substitution ciphers. From what I see the longer your ciphertext the less variation in the scores outputted at the end. With shorter texts it might not work as well. So below is the code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

import re, random from ngram_class import nGramInfo #substitution cipher def main(): # grabs input and makes it lower case ciphertext = input("Enter the message: ") ciphertext = ciphertext.lower() # removes everything except for letters this is used for calculating the healthiness ciphertext_only_letters = re.sub("[^a-z]+", "", ciphertext) alphabet = list("abcdefghijklmnopqrstuvwxyz") #randomly shuffles the alphabet random.shuffle(alphabet) starter_key = "".join(alphabet) #starter key is random arrangement of alphabet # calculates the best keys and prints them out in a decending order of healthiness # highest healthiness (most correct) will be at the bottom best_keys = calculate_best_key(ciphertext_only_letters, starter_key, ciphertext) best_keys = sorted(best_keys) for i in range(len(best_keys)): print("================\n"+"Score:", best_keys[i][0], "\nKey:", best_keys[i][1], "\nDecryption:", substitution(ciphertext, best_keys[i][1])) # print(best_keys) #prints out the best guess #its just the last thing anyway print("\n======== BEST GUESS ========") print("Score:", best_keys[-1][0]) print("Key:", best_keys[-1][1]) print("Decryption:", substitution(ciphertext, best_keys[-1][1])) def calculate_best_key(ciphertext_only_letters, starter_key, ciphertext): #creates object to calculate fitness calculator = create_nGramInfo_class() print("\n\n\nCiphertext:", ciphertext) print("Ciphertext Healthiness Score:", calculator.calculate_fitness_score(ciphertext)) highest = [] #highest holds the highest scores and the keys associated with the scores # this is the key that is shuffled into a new key every iteration key = list('abcdefghijklmnopqrstuvwxyz') # if the thing cant be solved iterations should be increased first iteration = 0 while iteration < 15: print("Iteration:", iteration) #generates new key and calculates the fitness of the keys associated possible plaintext random.shuffle(key) new_key = "".join(key) print("new key:", new_key) high_score = calculator.calculate_fitness_score(substitution(ciphertext_only_letters, new_key)) best_key = new_key highest.append([high_score, best_key]) iteration += 1 i = 0 # this can be increased if solver not solving however changing iteration number should be first while i < 10000: prev_key = new_key #generates 2 random numbers (musnt be the same) num1 = num2 = 0 while num1 == num2: num1 = random.randint(0, 25) num2 = random.randint(0, 25) #swaps the letters new = list(new_key) new[num1], new[num2] = new[num2], new[num1] new_key = "".join(new) #creates the possible plaintext and calculates fitness plaintext = substitution(ciphertext_only_letters, new_key) new_score = calculator.calculate_fitness_score(plaintext) #if new score is higher than high score new score becomes high score and is added to highest list if new_score > high_score: high_score = new_score best_key = new_key highest.append([high_score, best_key]) if len(highest) > 20: highest = sorted(highest) highest = highest[5:] else: #if score doesnt increase it goes back to previous key new_key = prev_key i += 1 # summarises information in every iteration print("Current highest score is", high_score, "on iteration", iteration) print(best_key) print("This decodes to", substitution(ciphertext_only_letters, best_key)) print("\n\n") return highest def create_nGramInfo_class(): print("Enter '1' for monograms") print("Enter '2' for bigrams") print("Enter '3' for trigrams") print("Enter '4' for quadgrams") print("Note: quadgrams can only do analysis on messages >= 4 characters\ntrigrams for >= 3 and so on \n(if you need a program to help decipher a < 4 letter caesar cipher RIP)") mode = input("Enter Mode: ") mode = mode.strip().lower() if mode == '1': file_name = "ngrams/english_monograms.txt" elif mode == '2': file_name = "ngrams/english_bigrams.txt" elif mode == '3': file_name = "ngrams/english_trigrams.txt" elif mode == '4': file_name = "ngrams/english_quadgrams.txt" else: print("Make sure input is correct") exit() return nGramInfo(file_name) def substitution(ciphertext_only_letters, key): plaintext = "" for letter in ciphertext_only_letters: if letter.isalpha() == True: plaintext += key[ord(letter) - ord("a")] else: plaintext += letter return plaintext if __name__ == "__main__": main()

Here are some tests using it.

Test 1

Message we are encrypting: “short message test”

Key used to encrypt: “qwertyuiopasdfghjklzxcvbnm”

basically just left to right on the keyboard

Ciphertext: “ligkz dtllqut ztlz”

Program ouputs:

Running the program 2 times gives us nothing significant it is mostly just gibberish however imagine someone with more computing power than me they could run multiple versions of this program while increasing the number of iterations the program goes through. It could easily decipher these messages with little issue.

Test 2

Message we are encrypting: “longer messages should work much better with these substitution cipher solvers however i mean who is even trying to solve the shorter ones using a computer”

Key used to encrypt: “qwertyuiopasdfghjklzxcvbnm”

same one as before

Ciphertext: “sgfutk dtllqutl ligxsr vgka dxei wtzztk vozi zitlt lxwlzozxzogf eohitk lgsctkl igvtctk o dtqf vig ol tctf zknofu zg lgsct zit ligkztk gftl xlofu q egdhxztk”

Program ouputs:

Guess what it was solved on the first go despite having such a large keyspace it is still relatively easy to crack a substitution cipher

From this I was legitimately surprised at how fast the substitution cipher could be cracked even with the resources I had. As we had to do many cryptograms, which are essentially substitution ciphers, I thought that this would be harder for a computer to do because even for us it would take a decent amount of time to decrypt them. Its shocking how fast a computer can do this just be randomly generating keys and choosing the better ones.

Note: once again i don’t know if the code is visible so will leave it below (all the code is on the github anyway)

This one here is quite interesting in the sense that we have to determine if an image has been digitally modified. The image we’ve been given is below; looking at it from a distance nothing seems too obvious and stands out. If you zoom in on the edges of the woman they look a bit dodgy but we need to prove this more definitively.

I looked into some of the techniques you can use for determining modification of an image - one of them is known as “error level analysis”. The idea behind it is that if another object has been “photoshopped” into an image, there will be different compression artifacts in different sections of the image. For example, if the image of the woman was extracted from a higher resolution image, you would be able to distinguish this when it is compressed to be added to the selfie above. There is actually a pretty cool forensics tool online at www.fotoforensics.com to do this:

My personal notes:

His keystrokes were fairly straight forward. I asked my cousin, Matthew, to accelerate what he would normally do on his computer to compensate for the minimal time on the computer allowed. For this reason, there are far less variety in keystrokes than expected.

I noticed in general that due to the prevalence of Youtube and websites in general that his keyboard was not being used for much in his general like. Although I could take note of specific tastes like “Monster vs Robot” and “Riddles”, these keystrokes did not nearly capture the scope the content he was watching - mainly through clicking on new videos that were recommended and click navigating on roblox/fortnite. 

Analysis of the keys logged from a 7 year old from an attacker:

Again I asked my sister to give some points of analysis and she had guessed it was one of my cousins. Below are her points:

blastedemasta is a username probably???

w keys are probably from a game. Minecraft/fortnite/roblox?

everything else is youtube 

Analysis of the analysis:

All the guesses were accurate. Blastedemasta my younger cousins username on Fortnite and he logged on and played a game. It was when he died that I asked him to use his keyboard in different ways (probably skewing the data). Surprisingly it ended up with my cousin on youtube, not exactly giving much anyway. The w keys were indeed from Fortnite which he died not as quickly as I thought he would. Finally, last of the entries were indeed off of Youtube. Again unfortunately, it was all Fortnite and riddles. 

Letter Frequency

This is likely not useful whatsoever, but here is the data. All the fortnite key entries were taken out. 

Here are the numbers:

Some interesting notes:

“t” is extremely low, at 8th place. and “a” is at 7th place

“e, i, r, o, p, s” are the frequent letters 

I’ve had no previous experience with forensics challenges in CTFs so I have compiled a list of (hopefully) useful concepts that people like me could use before starting some of the challenges:

This is how I was testing this module:

These are my initial test results below. Issues were:

continuous display of value 1023 (HIGH) and no significant fluctuations detected

Achieved expected curve when timer code was swapped around:

The results below show the range of values detected when the above issue was fixed (grounding issue). No significant changes were detected when a flame was placed nearby:

The Wi-Fi alliance announced WPA3 in January 2018 as a replacement to WPA2. It adds four features not found in WPA2. However, most devices don’t use WPA3 yet as it is still an optional feature. As it slowly gets adopted it may be set to mandatory by the Wi-Fi alliance.

WPA3 will offer privacy on public Wi-Fi networks by using “individualized data encryption”. This means that when you connect to an open Wi-Fi, the traffic between your device and the access point will be encrypted despite not entering a password during connection. An attacker will have to crack the encryption to snoop

WPA3 will offer protection against brute force attacks. This is responding to the KRACK attack on WPA2. WPA3 defines a new handshake to prevent this.

WPA3 will offer an easier connection process to devices without displays. It was a promise to “simplify the process of configuring security for devices that have limited or no display interface”. This sounds a lot like WPS which created vulnerabilities to WPA and WPA2.

WPA3 will also offer higher security for government, defences and industrial applications. It is a feature requested by the US government for stronger encryption on critical Wi-Fi networks.

Outlined here is my intended project for the term of study:

Motivation I would like to develop well-rounded technical skills in web applications security via hacking a website. With an interest in software development, the project should give good experience in adopting an attacking mindset when developing software, and be a good opportunity to get hands on with a range of security topics. Ideally, the project will establish a solid practical skills complementing the theoretical knowledge of the course, setting good foundation towards whatever field of my interest down the road.

Skills To meet this goal, I will need to first be comfortable with navigating the Linux command line. I will need to understand the theory as well as having hands on practice covering the scope of topics of web applications. I will also need to familiarize myself with tools of the trade web application security. Finally, I can start legally hacking away on a website.

I will achieve this by: 1) Completing overthewire.org Bandit to establish familiarity with the Linux command line, blogging about each challenge. 2) Complete overthewire.org Natas to learn basic serverside security and blog. 3) Read up The Web Application Hacker's Handbook: Finding and Exploiting Security Flaws Chap1 (web application insecurity), Chap2 (Core defence mechanisms), and Chap3 (Web application technologies), with reflection blogs on each chapter. 4) Set up tools with Kali Linux and familiarize with commands, and blog about them. 5) Do CTF challenges on https://ctf365.com/ to get hands on with web app security and write reflection blogs. 6) Going further:  Legally hack a website, being able to demonstrate at exploitations as listed on the OWASP top 10 vulnerabilities. Choose from https://www.cbtnuggets.com/blog/2018/08/how-to-legally-practice-your-new-hacking-skills/. Read up on "How to get started" technologies and blog. 7) Going further: Demonstrate more exploitations, choose another website, further insightful blog posts, or explore other wargames from overthewire.org