In this basic challenge, the order of operation (point calculation before line calculation) must be followed to solve the equation.

The solution is: 11

Based on the challenge text and the provided assistance

all you have to do is decrypt some HiddenCiphertext!
…
Algorithm: AES-256-CBC …

One might think that this is a decrypting task. Check the file type of the file poracle.diff.

As it is identified as some text file, it can be opened in an editor

Depending on the first lines, it seems to be Git diff, rather than something that needs to be decrypted.

The challenge text had an additional hint.

Hint: As usual, the flag will start with 'FLAG:', so you’ll know when you’ve found it :)

Searching in the file for the text FLAG, find this line:

The solution is: FLAG:1d010f248d

Assuming the file is a Zip archive, check the file with zipinfo:

It reveals the Zip archive contains a file flag.txt, and that the archive is encrypted.

As the Zip file and the challenge itself don’t contain additional hints for the password, we can only try to guess it.

There are two common solutions to achieve it:

• by brute force: try all possible combinations of characters, numbers, and symbols

• using a dictionary: a dictionary is a wordlist of common or leaked passwords

As we don’t have any hints about the password length, brute force might take ages to find the correct password. Hence, using a dictionary most probably will find the password faster.

In July 2024, a wordlist containing around 10 billion passwords was leaked. The wordlist is available on the internet, and it is known as "RockYou2024".

There are different tools to crack passwords. One popular tool for this task is John the Ripper.

It requires a hash to crack the password. To compute the hash from the Zip file the tool zip2john is used.

Now that we have the hash we can run John the Ripper (JtR) with the "RockYou2024" wordlist.

JtR tries 15.089.000 passwords per second. Around nine minutes later … the password wasn’t found.

So we need another strategy for the dictionary. The idea is to use a smaller dictionary, which contains common English words, and use permutations of these words.

The common English words are taken from https://www.ef.com/wwen/english-resources/english-vocabulary/top-3000-words, and are stored in the file 3000-most-common-words-in-English.

Checking the file its to notice that it missed the word password itself. The RockYou2024 wordlist contains 422.379 passwords which contain the part password literally.

There are the following additional assumptions made:

• a password contains only lowercase characters

• a password doesn’t contain numbers or special characters

• a password is a combination of different words

For the password checking, I wrote two scripts.

• zippy-solution.py which generates the permutations and writes them in chunks to a file

• run-jtr.sh which runs JtR for each generated chunk

The first iteration was to generate passwords as permutation of two words.

The second iteration was to generate passwords as permutation of three words.

JtR found the password in the current chunk of permutation wordlist. Now we can check for the discovered password in the file flag.pot.

The password needed to extract the file flag.txt from the Zip archive is supercomplexpassword.

The file flag.txt contains the solution: CTF{this_flag_is_your_flag}.

When open the file corgi.html in an editor it looks like an HTML file with a JavaScript part. So open the file in a browser.

The browser shows:

CTF{JustAS0ngAb0utP1ngP0ng}

Woof!!

The solution is: CTF{JustAS0ngAb0utP1ngP0ng}

Check the file type of file tapesplice.tar.

It’s an uncompressed tar archive.

The challenge mentions that a file is appended "in the 'slack space' part" of the tar archive.

To solve the challenge, we need to know some basics of the tar archive format.

Simplified, it can be summarized as follows:

• a tar archive consists of a series of file entries

• each entry consists of a header and the file content

• header and file content are stored in blocks of 512 bytes

If the file content is not a multiple of 512 bytes, the last block contains bytes which don’t belong to the file content (that is the mentioned slack space).

As the appended file is stored in the slack space we can compute its offset as "length_header + length_file_content".

The file content length can be retrieved as:

So we have the following values:

• the length of the header: 512 bytes (it is always one block)

• the length of content file: 128623 bytes

The offset of the slack space (zero-based) can be computed as: 512 + 128623 = 129135.

Now we can extract the bytes starting from offset 129135 into a new file.

This command uses tapesplice.tar as the input file, skips the first 129135 bytes, and writes the remaining bytes into the file appended_file.

Checking the file type of the created file appended_file.

It is recognized as bzip2 compressed data. So we can try to decompress it

The solution is: CTF{everything_has_space_for_hidden_data}