Space Pirates#

1
...
2

3
#define FLAG_LEN 30
4
const uint8_t TARGET[FLAG_LEN] = {...};
5

6
// The pirate's rotating XOR key
7
const uint8_t XOR_KEY[5] = {0x42, 0x73, 0x21, 0x69, 0x37};
8

9
// The magic addition constant
10
const uint8_t MAGIC_ADD = 0x2A;
11
// PCTF{0x_M4rks_tH3_sp0t_M4t3y}
12

13
...

Yea, they wrote the right flag inside the file, how hilarious it is.

Flag: pctf{0x_M4rks_tH3_sp0t_M4t3y}

Are You Pylingual?#

We’re giving .pyc file. Decompile it and we have this code:

1
import pyfiglet
2
file = open('flag.txt', 'r')
3
flag = file.read()
4
font = 'slant'
5
words = 'MASONCC IS THE BEST CLUB EVER'
6
flag_track = 0
7
art = list(pyfiglet.figlet_format(words, font=font))
8
i = len(art) % 10
9
for ind in range(len(art)):
10
    if ind == i and flag_track < len(flag):
11
        art[ind] = flag[flag_track]
12
        i += 28
13
        flag_track += 1
14
art_str = ''.join(art)
15
first_val = 5
16
second_val = 6
17
first_half = art_str[:len(art_str) // 2]
18
second_half = art_str[len(art_str) // 2:]
19
first = [~ord(char) ^ first_val for char in first_half]
20
second = [~ord(char) ^ second_val for char in second_half]
21
output = second + first
22
print(output)

Basically, the generator split the figlet output art_str into 2 parts, first_half (floor(L / 2)) and second_half. It encoded as:

1
first = [ord(char) ^ first_val for char in first_half]
2
second = [ord(char) ^ second_val for char in second_half]

then printed output = second + first.

So to decode this, we need to split the provided output list into second (length = ceil(len(output) / 2)) and first (length = floor(len(output) / 2)). Then, recover bytes with ord = (~(v ^ val)) & 0xFF and chr(ord) to print it out.

1
from pyfiglet import figlet_format
2

3
output = [...]
4
first_val = 5
5
second_val = 6
6

7
L = len(output)
8
first_len = L // 2         # = floor(L / 2)
9
second_len = L - first_len # = ceil(L / 2)
10
second_enc = output[:second_len]
11
first_enc  = output[second_len:]
12

13
def decode_list(enc_list, val):
14
    chars = []
15
    for v in enc_list:
16
        o = (~(v ^ val)) & 0xFF
17
        chars.append(chr(o))
18
    return ''.join(chars)
19

20
first_half = decode_list(first_enc, first_val)
21
second_half = decode_list(second_enc, second_val)
22
art_str = first_half + second_half
23
print(art_str[:1000])

Run this and it would print out the ASCII art with some characters from the flag.

1
  p __  ______   _____ ____  _c  ______________   ________t
2
   /  |/  /   | / ___// __f\/ | / / ____/ ____/  /  _/{___/
3
  / /|_/ / /| | \__ \/o/ / /  |/ / /   / /       /b/ \__ \
4
 / /  / / ___ |___F / /_/ / /|  / /___/ /___  u_/ / ___/ /
5
/_/  /_/_/  |_s____/\____/_/ |_/\____/\___c/  /___//____/
6
          4                           t
7
  ____i___  ________   ____  _____0___________   ________    _n  ______
8
 /_  __/ / / / ____/  / __ )/ ____/ ___/_  __i  / ____/ /   / / / / __ )
9
5 / / / /_/ / __/    / __  /n__/  \__ \ / /    / /   / /'  / / / / __  |
10
 / / / __  t /___   / /_/ / /___ ___/ /_ /    / /___/ /___/ /_/ / /E/ /
11
/_/ /_/ /_/_____/  /__n__/_____//____//_/     \___c/_____/\____/_____/
12
     R                           y                           p
13
    _______    _t__________
14
   / ____/ |  /1/ ____/ __ \
15
  / __/  | | /o/ __/ / /_/ /
16
 / /___  | |/N/ /___/ _, _/
17
/_____/  |__}/_____/_/ |_|

Flag: pctf{obFusc4ti0n_i5n’t_EncRypt1oN}

Space Pirates 2#

1
use std::env;
2
use std::process;
3

4
const TARGET: [u8; 32] = [0x15, 0x5A, 0xAC, 0xF6, 0x36, 0x22, 0x3B, 0x52, 0x6C, 0x4F, 0x90, 0xD9, 0x35, 0x63, 0xF8, 0x0E, 0x02, 0x33, 0xB0, 0xF1, 0xB7, 0x69, 0x42, 0x67, 0x25, 0xEA, 0x96, 0x63, 0x1B, 0xA7, 0x03, 0x0B];
5
const XOR_KEY: [u8; 5] = [0x7E, 0x33, 0x91, 0x4C, 0xA5];
6
const ROTATION_PATTERN: [u32; 7] = [1, 3, 5, 7, 2, 4, 6];
7
const MAGIC_SUB: u8 = 0x5D;
8

9
fn print_flag(buffer: &str) {
10
    println!("Flag: {0}\n", buffer);
11
}
12

13
/// Rotate a byte left by n positions
14
/// This is a bijection because all 8 bit rotations of a byte are unique
15
/// ROL(ROL(x, n), 8-n) = x, proving invertibility
16
fn rotate_left(byte: u8, n: u32) -> u8 {
17
    byte.rotate_left(n % 8)
18
}
19

20
/// OPERATION 1: XOR with NEW rotating key
21
/// Each byte is XORed with one of 5 NEW key bytes (cycling through them)
22
/// Bijection proof: (x ⊕ k) ⊕ k = x (XOR involution)
23
fn apply_quantum_cipher_v2(buffer: &mut [u8]) {
24
    for (i, byte) in buffer.iter_mut().enumerate() {
25
        *byte ^= XOR_KEY[i % 5];
26
    }
27
}
28

29
/// OPERATION 2 (NEW!): Rotate Left with varying amounts
30
/// Each byte is rotated left by an amount determined by its position
31
/// Bijection proof: ROL⁻¹ = ROR with same amount
32
/// The rotation amount varies: position mod 7 selects from ROTATION_PATTERN
33
fn apply_stellar_rotation(buffer: &mut [u8]) {
34
    for (i, byte) in buffer.iter_mut().enumerate() {
35
        let rotation = ROTATION_PATTERN[i % 7];
36
        *byte = rotate_left(*byte, rotation);
37
    }
38
}
39

40
/// OPERATION 3: Swap adjacent byte pairs
41
/// Bytes at positions (0,1), (2,3), (4,5), etc. are swapped
42
/// Bijection proof: Swapping twice returns original (f ∘ f = identity)
43
fn apply_spatial_transposition(buffer: &mut [u8]) {
44
    for i in (0..buffer.len()).step_by(2) {
45
        buffer.swap(i, i + 1);
46
    }
47
}
48

49
/// OPERATION 4: Subtract magic constant (mod 256) - CHANGED FROM ADDITION!
50
/// Each byte has MAGIC_SUB subtracted from it (wrapping at 256)
51
/// Bijection proof: (x - k) + k ≡ x (mod 256)
52
/// Subtraction forms a group, every element has unique inverse
53
fn apply_gravitational_shift_v2(buffer: &mut [u8]) {
54
    for byte in buffer.iter_mut() {
55
        *byte = byte.wrapping_sub(MAGIC_SUB);
56
    }
57
}
58

59
/// OPERATION 5 (NEW!): Reverse bytes in chunks of 5
60
/// Splits the 30-byte buffer into 6 chunks of 5, reverses each chunk
61
/// Chunk 0: [0,1,2,3,4] -> [4,3,2,1,0]
62
/// Chunk 1: [5,6,7,8,9] -> [9,8,7,6,5], etc.
63
/// Bijection proof: Reversal is self-inverse, f(f(x)) = x
64
fn apply_temporal_inversion(buffer: &mut [u8]) {
65
    const CHUNK_SIZE: usize = 5;
66
    for chunk_start in (0..buffer.len()).step_by(CHUNK_SIZE) {
67
        let chunk_end = (chunk_start + CHUNK_SIZE).min(buffer.len());
68
        buffer[chunk_start..chunk_end].reverse();
69
    }
70
}
71

72
/// OPERATION 6 (NEW!): XOR each byte with its position SQUARED (mod 256)
73
/// Byte at position i is XORed with i² mod 256
74
/// Bijection proof: (x ⊕ k) ⊕ k = x (XOR involution)
75
/// While i² grows, mod 256 keeps values in range, and XOR remains invertible
76
fn apply_coordinate_calibration_v2(buffer: &mut [u8]) {
77
    for (i, byte) in buffer.iter_mut().enumerate() {
78
        let position_squared = ((i * i) % 256) as u8;
79
        *byte ^= position_squared;
80
    }
81
}
82

83
fn process_transmission(input: &str) -> Result<[u8; 32], String> {
84
    if input.len() != 32 {
85
        return Err(format!(input.len()));
86
    }
87
    let mut buffer = [0u8; 32];
88
    buffer.copy_from_slice(input.as_bytes());
89
    apply_quantum_cipher_v2(&mut buffer);
90
    apply_stellar_rotation(&mut buffer);
91
    apply_spatial_transposition(&mut buffer);
92
    apply_gravitational_shift_v2(&mut buffer);
93
    apply_temporal_inversion(&mut buffer);
94
    apply_coordinate_calibration_v2(&mut buffer);
95
    Ok(buffer)
96
}
97

98
fn main() {
99
    let args: Vec<String> = env::args().collect();
100
    if args.len() != 2 {
101
        process::exit(1);
102
    }
103

104
    let input = &args[1];
105
    match process_transmission(input) {
106
        Ok(buffer) => {
107
            if buffer == TARGET {
108
                print_flag(input);
109
            } else {
110
                println!("\n");
111
                process::exit(1);
112
            }
113
        }
114
        Err(err) => {
115
            eprintln!("{}", err);
116
            process::exit(1);
117
        }
118
    }
119
}

The pipeline for the encryption, from input to flag, is:

XOR with rotating key
Rotate left with varying amounts
Swap adjacent byte pairs
Subtract magic constant
Reverse bytes in chunks of 5
XOR each byte with its position squared

So, we need to undo these steps, from operation 6 back to 1, to get the orginal flag. Simple.

1
TARGET = [0x15, 0x5A, 0xAC, 0xF6, 0x36, 0x22, 0x3B, 0x52, 0x6C, 0x4F, 0x90, 0xD9, 0x35, 0x63, 0xF8, 0x0E, 0x02, 0x33, 0xB0, 0xF1, 0xB7, 0x69, 0x42, 0x67, 0x25, 0xEA, 0x96, 0x63, 0x1B, 0xA7, 0x03, 0x0B]
2
XOR_KEY = [0x7E, 0x33, 0x91, 0x4C, 0xA5]
3
ROTATION_PATTERN = [1, 3, 5, 7, 2, 4, 6]
4
MAGIC_SUB = 0x5D
5

6
def ror(byte, n):
7
    n %= 8
8
    return ((byte >> n) | ((byte << (8 - n)) & 0xFF)) & 0xFF
9

10
def solve():
11
    buf = TARGET.copy()
12
    # Operation 6
13
    for i in range(32):
14
        buf[i] ^= (i * i) % 256
15
    # Operation 5
16
    for cs in range(0, 32, 5):
17
        buf[cs:cs+5] = reversed(buf[cs:cs+5])
18
    # Operation 4
19
    for i in range(32):
20
        buf[i] = (buf[i] + MAGIC_SUB) & 0xFF
21
    # Operation 3
22
    for i in range(0, 32, 2):
23
        buf[i], buf[i+1] = buf[i+1], buf[i]
24
    # Operation 2
25
    for i in range(32):
26
        rot = ROTATION_PATTERN[i % 7]
27
        buf[i] = ror(buf[i], rot)
28
    # Operation 1
29
    for i in range(32):
30
        buf[i] ^= XOR_KEY[i % 5]
31
    s = bytes(buf).decode("utf-8")
32
    print("Recovered input:")
33
    print(s)
34

35
if __name__ == "__main__":
36
    solve()

Flag: pctf{Y0U_F0UND_TH3_P1R4T3_B00TY}

Space Pirates 3#

1
package main
2
import (
3
  "fmt"
4
  "os"
5
)
6
var target = [30]byte{
7
  0x60, 0x6D, 0x5D, 0x97, 0x2C, 0x04, 0xAF, 0x7C, 0xE2, 0x9E, 0x77, 0x85, 0xD1, 0x0F, 0x1D, 0x17, 0xD4, 0x30, 0xB7, 0x48, 0xDC, 0x48, 0x36, 0xC1, 0xCA, 0x28, 0xE1, 0x37, 0x58, 0x0F,
8
}
9
var xorKey = [7]byte{0xC7, 0x2E, 0x89, 0x51, 0xB4, 0x6D, 0x1F}
10
var rotationPattern = [8]uint{7, 5, 3, 1, 6, 4, 2, 0}
11
const magicSub byte = 0x93
12
const chunkSize = 6
13

14
func printFlag(input string) {
15
  fmt.Println("Flag: ", input)
16
}
17
func rotateLeft(b byte, n uint) byte {
18
  n = n % 8
19
  return (b << n) | (b >> (8 - n))
20
}
21
func applyUltimateQuantumCipher(buffer []byte) {
22
  for i := range buffer {
23
    buffer[i] ^= xorKey[i%len(xorKey)]
24
  }
25
}
26
func applyStellarRotationV2(buffer []byte) {
27
  for i := range buffer {
28
    rotation := rotationPattern[i%len(rotationPattern)]
29
    buffer[i] = rotateLeft(buffer[i], rotation)
30
  }
31
}
32
func applySpatialTransposition(buffer []byte) {
33
  for i := 0; i < len(buffer)-1; i += 2 {
34
    buffer[i], buffer[i+1] = buffer[i+1], buffer[i]
35
  }
36
}
37
func applyGravitationalShiftV3(buffer []byte) {
38
  for i := range buffer {
39
    buffer[i] -= magicSub
40
  }
41
}
42
func applyTemporalInversionV2(buffer []byte) {
43
  for chunkStart := 0; chunkStart < len(buffer); chunkStart += chunkSize {
44
    chunkEnd := chunkStart + chunkSize
45
    if chunkEnd > len(buffer) {
46
      chunkEnd = len(buffer)
47
    }
48
    for i, j := chunkStart, chunkEnd-1; i < j; i, j = i+1, j-1 {
49
      buffer[i], buffer[j] = buffer[j], buffer[i]
50
    }
51
  }
52
}
53
func applyCoordinateCalibrationV3(buffer []byte) {
54
  for i := range buffer {
55
    positionValue := ((i * i) + i) % 256
56
    buffer[i] ^= byte(positionValue)
57
  }
58
}
59

60
func processVault(input string) ([30]byte, error) {
61
  var result [30]byte
62
  if len(input) != 30 {
63
    return result, fmt.Errorf(
64
      "Invalid vault combination",
65
    )
66
  }
67
  copy(result[:], input)
68
  buffer := result[:]
69
  applyUltimateQuantumCipher(buffer)
70
  applyStellarRotationV2(buffer)
71
  applySpatialTransposition(buffer)
72
  applyGravitationalShiftV3(buffer)
73
  applyTemporalInversionV2(buffer)
74
  applyCoordinateCalibrationV3(buffer)
75
  return result, nil
76
}
77

78
func main() {
79
  if len(os.Args) != 2 {
80
    os.Exit(1)
81
  }
82
  input := os.Args[1]
83
  result, err := processVault(input)
84
  if err != nil {
85
    fmt.Fprintf(os.Stderr, " %v\n", err)
86
    os.Exit(1)
87
  }
88
  if result == target {
89
    printFlag(input)
90
  } else {
91
    fmt.Println("\n")
92
    os.Exit(1)
93
  }
94
}

Different programming language, but have the same meaning in each operation, the same as Sapce Pirates 2. So, to reverse it, we need to:

XOR each byte with (i^2 + i) mod 256
Reverse each 6-byte chunk
Add magicSub
Swap adjacent pairs
Rotate right by the rotation pattern
XOR with 7-byte xorKey

1
TARGET = [0x60, 0x6D, 0x5D, 0x97, 0x2C, 0x04, 0xAF, 0x7C, 0xE2, 0x9E, 0x77, 0x85, 0xD1, 0x0F, 0x1D, 0x17, 0xD4, 0x30, 0xB7, 0x48, 0xDC, 0x48, 0x36, 0xC1, 0xCA, 0x28, 0xE1, 0x37, 0x58, 0x0F]
2
XOR_KEY = [0xC7, 0x2E, 0x89, 0x51, 0xB4, 0x6D, 0x1F]
3
ROTATION_PATTERN = [7, 5, 3, 1, 6, 4, 2, 0]
4
MAGIC_SUB = 0x93
5

6
def ror(byte, n):
7
    n %= 8
8
    return ((byte >> n) | ((byte << (8 - n)) & 0xFF)) & 0xFF
9

10
def solve():
11
    buf = TARGET.copy()
12
    # Operation 6
13
    for i in range(30):
14
        buf[i] ^= ((i * i) + i) % 256
15
    # Operation 5
16
    for cs in range(0, 30, 6):
17
        buf[cs:cs+6] = reversed(buf[cs:cs+6])
18
    # Operation 4
19
    for i in range(30):
20
        buf[i] = (buf[i] + MAGIC_SUB) & 0xFF
21
    # Operation 3
22
    for i in range(0, 30, 2):
23
        buf[i], buf[i+1] = buf[i+1], buf[i]
24
    # Operation 2
25
    for i in range(30):
26
        rot = ROTATION_PATTERN[i % 8]
27
        buf[i] = ror(buf[i], rot)
28
    # Operation 1
29
    for i in range(30):
30
        buf[i] ^= XOR_KEY[i % 7]
31
    s = bytes(buf).decode("utf-8")
32
    print("Recovered input:")
33
    print(s)
34

35
if __name__ == "__main__":
36
    solve()

Flag: pctf{M4ST3R_0F_TH3_S3V3N_S34S}

Vorpal Masters#

1
void main(void) {
2
  int iVar1;
3
  int local_20;
4
  char local_1c [11];
5
  char local_11;
6
  char local_10;
7
  char local_f;
8
  char local_e;
9
  int local_c;
10

11
  puts("Welcome to {insert game here}\nPlease enter the license key from the 3rd page of the booklet.");
12
  local_c = __isoc99_scanf("%4s-%d-%10s", &local_11, &local_20, local_1c);
13
  if (local_c != 3) {
14
    puts("Please enter you key in the format xxxx-xxxx-xxxx");
15
    exit(0);
16
  }
17
  if ((((local_11 != 'C') || (local_f != 'C')) || (local_e != 'I')) || (local_10 != 'A')) {
18
    womp_womp();
19
  }
20
  if ((-0x1389 < local_20) && (local_20 < 0x2711)) {
21
    if ((local_20 + 0x16) % 0x6ca == ((local_20 * 2) % 2000) * 6 + 9) goto LAB_00101286;
22
  }
23
  womp_womp();
24
LAB_00101286:
25
  iVar1 = strcmp(local_1c, "PatriotCTF");
26
  if (iVar1 != 0) womp_womp();
27
  puts("Lisence key registered, you may play the game now!");
28
  return;
29
}

The key is in the form xxxx-xxxx-xxxx. In local_c, it decleares that local_c = __isoc99_scanf("%4s-%d-%10s", &local_11, &local_20, local_1c);, meaning there are 3 parts in the key:

First part is a string having 4 characters;
Second part is a number;
Third part is a string having 10 characters.

For the first part, although the arrangement in the code was wrong (CCIA), but based on the memory of each variable, we know that the first part is CACI (like what the challenge statement said).
For the second part, we know that:

1
  if ((-0x1389 < local_20) && (local_20 < 0x2711)) {
2
    if ((local_20 + 0x16) % 0x6ca == ((local_20 * 2) % 2000) * 6 + 9) goto LAB_00101286;
3
  }

which means:

1
for n in range(-4999, 10000):
2
    if (n + 22) % 1738 == ((n * 2) % 2000) * 6 + 9:
3
        print(n) # goto LAB_00101286;

So the second part is 2025.

For the third part, we already know it is PatriotCTF.

Flag: CACI{2025-PatriotCTF}