Getting into hacking [Hacking Challenges]: Can you hack it?

1
2
3

for (let i = 0; i < 999999999; i++) {
    document.querySelector("#id_of_button").click()
}

 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

{
    "error": "You're not a paid user.",
    "hc_challenge": {
        "oid": "08be3a909cb31a4f2e80",
        "meta": {
            "points": 50,
            "challenge_id": "paid_content",
            "name": "Paid Content",
            "description": "Pay for things you want! (2.0!!!)",
            "prompt": "You must be a paid user to proceed.",
            "category": {
                "value": "client_side_protections",
                "name": "Client-side Protections"
            },
            "console_message": "[Paid Content]: This challenge got a minor update for the 2023 holidays. It's version 2.0. It's (2 * challenge)!",
            "mobile_friendly": false,
            "encoded": true,
            "error_msg": "You're not a paid user.",
            "version": "2.0",
            "inputs": [],
            "retired": false,
            "bin_hashes": null
        },
        "solved": false,
        "js_file": "...",
        "js_function": "PaidContent",
        "num_solves": 1945,
        "paid": false, <--------- Can you spot this ?
        "challenge": 1964
    }
}

1

aircrack-ng ./de-auth.cap  

1

504b0304140000000800308281576ed34a1e5c0000005c00000008000000666c61672e74787405c1c10e83200c00d0cf5a3c96c6a106b354d4aab7ed02acb8193501ffdef7286eff57ff546c979ec9653609a0c2194a8019c0812629062c8d7475b48dcd72ea4b7f31ad9c99d2d8caded23bf80faebe31e121e187be562a1c93bb01504b01021403140000000800308281576ed34a1e5c0000005c000000080000000000000000000000800100000000666c61672e747874504b0506000000000100010036000000820000000000

1
2
3
4

st = "..."
binary_data = bytes.fromhex(st)
with open("output.zip", "wb") as f:
    f.write(binary_data)

1

BZh91AY&SY�
�@�@�`�0�i fuxg+ͅW85-F)6cedYhE64SmfCk=knU+>.p!c

1

echo "$base64_encoded_string" | base64 --decode | bzcat > output.txt

1

110110 110110 110110 1100011 110110 110001 110110 110111 110111 1100010 110110 110111 110111 110101 110111 110010 110110 110110 110110 1100011 110110 110101 110010 1100001 110110 111000 110110 110101 110011 110001 110110 1100011 110011 110000 110010 1100110 110111 110111 110011 110000 110111 110010 110110 1100011 110110 110100 110101 1100110 110110 1100101 110111 110101 110110 1100011 110110 1100011 110101 1100110 110100 110000 110110 110110 110110 1100010 110011 1100100 110111 110011 110111 110101 110110 110100 110110 1100110 110111 1100100

1

666c61677b677572666c652a6865316c302f7730726c645f6e756c6c5f40666b3d7375646f7d

1

echo "$hex_string" | xxd -r -p

 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

from itertools import permutations
from string import ascii_uppercase

def enigma_decrypt(encrypted_message, rotor_order, reflector_type, plugboard_settings, initial_positions):
    rotor_wirings = {
        'I': 'EKMFLGDQVZNTOWYHXUSPAIBRCJ',
        'II': 'AJDKSIRUXBLHWTMCQGZNPYFVOE',
        'III': 'BDFHJLCPRTXVZNYEIWGAKMUSQO',
        'IV': 'ESOVPZJAYQUIRHXLNFTGKDCMWB',
        'V': 'VZBRGITYUPSDNHLXAWMJQOFECK'
    }

    reflector_wirings = {
        'UKW-B': 'YRUHQSLDPXNGOKMIEBFZCWVJAT'
    }

    plugboard = {char: char for char in ascii_uppercase}
    plugboard.update(plugboard_settings)

    rotor_positions = {rotor: initial_positions.split()[i] for i, rotor in enumerate(rotor_order.split())}

    decrypted_message = ''
    for char in encrypted_message:
        if char in plugboard:
            char = plugboard[char]

        for rotor, position in rotor_positions.items():
            char = rotor_wirings[rotor][(ord(char) - ord('A') + ord(position) - ord('A')) % 26]

        char = reflector_wirings[reflector_type][ord(char) - ord('A')]

        for rotor, position in reversed(rotor_positions.items()):
            char = chr((ord(char) - ord(position) + ord('A')) % 26 + ord('A'))

        if char in plugboard:
            char = plugboard[char]

        decrypted_message += char

        for rotor in rotor_positions:
            rotor_positions[rotor] = chr((ord(rotor_positions[rotor]) - ord('A') + 1) % 26 + ord('A'))

    return decrypted_message

def get_rotor_permutations():
    """Return all the possible permutations"""
    rotor_labels = ['I', 'II', 'III', 'IV', 'V']
    num_rotors = 3

    rotor_combinations = permutations(rotor_labels, num_rotors)

    return list(rotor_combinations)

encoded_message = "RSHDQ VKAXO LONTP SXKHY DGOWH BKUBK MAAGT YEGAJ ZMKIB AJYDV MFFYH ZOWSW SQYMK CEZXK DBLEA GZTIF IHHNQ PARET PSOXE JPRHO RXLYY GSIHG YBIFC NYUSN JSDXF TGHIX KVWVQ GNWBC CCPFU MKOLT PMLDX DCMSX BEGEN USMUQ BJSJC OEREZ SZ"

# Provided information
plugboard_wiring = {'Q': 'K', 'J': 'O', 'L': 'U', 'X': 'G', 'D': 'V'}
reflector_type = 'UKW-B'
first_5_pi = 'CNO'
metasploit_date = 'JTI'

# Generate all possible combinations
all_combinations = []

# 1. Plugboard wiring
plugboard_permutations = permutations(plugboard_wiring.keys())
for plugboard_permutation in plugboard_permutations:
    plugboard_settings = dict(zip(plugboard_wiring.keys(), plugboard_permutation))

    # 2. Rotor order
    rotor_labels = ['I', 'II', 'III', 'IV', 'V']
    rotor_order_permutations = permutations(rotor_labels, 3)
    for rotor_order_permutation in rotor_order_permutations:
        rotor_order = ' '.join(rotor_order_permutation)

        # 3. Reflectors
        reflector_types = ['UKW-B']
        for reflector_type in reflector_types:

            # 4. Initial positions
            initial_position_permutations = permutations('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 3)
            for initial_positions_permutation in initial_position_permutations:
                initial_positions = ' '.join(initial_positions_permutation)

                # Attempt decryption
                decrypted_message = enigma_decrypt(encoded_message, rotor_order, reflector_type, plugboard_settings, initial_positions)

                print(decrypted_message)
                print("-----")

 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

import hashlib

def calculate_sha256_hash(data):
    sha256 = hashlib.sha256()
    sha256.update(data.encode('utf-8'))
    return sha256.hexdigest()

def check_birthday_hash(target_hash):
    for year in range(1900, 2023):  # Adjust the range based on reasonable birth years
        for month in range(1, 13):
            for day in range(1, 32):
                try:
                    birthday = f"{month:02d}/{day:02d}/{year}"
                    calculated_hash = calculate_sha256_hash(birthday)
                    if calculated_hash == target_hash:
                        return birthday
                except ValueError:
                    continue

    return None

if __name__ == "__main__":
    provided_hash = "6c833595c7502119465895442b340b3118a8c1aec222882d35e364f75e57b268"
    birthday = check_birthday_hash(provided_hash)

    print(f"Found birthday: {birthday}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import random

seed = 1701957089
def generate_otp(seed):
    random.seed(seed)
    otp = ""
    for _ in range(6):
        digit = random.randint(0, 9)
        otp += str(digit)
    return otp

otp = generate_otp(seed)
print(f"Generated OTP with seed {seed}: {otp}")

 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

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function crackCode() {
    const targetCode = "-------";
    let bestScore = 0;
    let currentCode = targetCode;

    for (let position = 0; position < targetCode.length - 1; position++) {
        for (const char of "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") {
            if (char === targetCode[position]) {
                continue;
            }

            const newCode = currentCode.substring(0, position) + char + currentCode.substring(position + 1);
            const score = await CodeBreaker_submit(newCode);
            await sleep(1200); // Simulating a delay, replace with your actual requirements
            
            console.log(`Code: ${currentCode}, Score: ${score}`);
            
            if (score > bestScore) {
                bestScore = score;
                currentCode = newCode;

                // Stop trying more characters for this position if the score changes
                break;
            }
        }
    }

    console.log(`Final Code: ${currentCode}`);
}
crackCode();