MazeOfPower

// Solve solves the challenge and returns a solution proof that can be checked by Check.
func (c *Challenge) Solve() string {
	x := gmp.NewInt(0).Set(c.x) // dont mutate c.x
	for i := uint32(0); i < c.d; i++ {
		x.Exp(x, exp, mod)
		x.Xor(x, one)
	}
	return fmt.Sprintf("%s.%s", version, base64.StdEncoding.EncodeToString(x.Bytes()))
}

from base64 import b64encode, b64decode
from Crypto.Util.number import bytes_to_long, long_to_bytes

class Challenge:
    VERSION = "s"
    MOD = (1 << 1279) - 1
    EXP = 1 << 1277

    @staticmethod
    def decode(challenge: str):
        version, raw_d, raw_x = challenge.split('.')
        if version != Challenge.VERSION:
            raise ValueError('Version not supported')
        d = bytes_to_long(b64decode(raw_d))
        x = bytes_to_long(b64decode(raw_x))
        if d.bit_length() > 16:
            raise ValueError('Difficulty too long')
        return d, x

    @staticmethod
    def solve(challenge: str):
        d, x = Challenge.decode(challenge)
        for i in range(d):
            x = pow(x, Challenge.EXP, Challenge.MOD)
            x ^= 1
        return f"{Challenge.VERSION}.{b64encode(long_to_bytes(x)).decode()}"

import zlib

def calculate_checksum(input_string: str) -> int:
    input_bytes = input_string.encode('utf-8')
    return zlib.crc32(input_bytes)

package main

import (
	"fmt"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"github.com/itchyny/maze"
)

func Solve(maze_in *maze.Maze) {
	if maze_in.Solved {
		return
	}
	point := maze_in.Start
	stack := []*maze.Point{point}
	solution := []*maze.Point{point}
	visited := 1 << 12
	// Repeat until we reach the goal
	for !point.Equal(maze_in.Goal) {
		maze_in.Directions[point.X][point.Y] |= visited
		for _, direction := range maze.Directions {
			// Push the nearest points to the stack if not been visited yet
			if maze_in.Directions[point.X][point.Y]&direction == direction {
				next := point.Advance(direction)
				if maze_in.Directions[next.X][next.Y]&visited == 0 {
					stack = append(stack, next)
				}
			}
		}
		// Pop the stack
		point = stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		// We have reached to a dead end so we pop the solution
		for last := solution[len(solution)-1]; !maze_in.Connected(point, last); {
			solution = solution[:len(solution)-1]
			last = solution[len(solution)-1]
		}
		solution = append(solution, point)
	}
	// [MODIFICATION] c'est là dedans qu'on récupèrera le chemin à faire
	path := []int{}
	for i, point := range solution {
		if i < len(solution)-1 {
			next := solution[i+1]
			for _, direction := range maze.Directions {
				if maze_in.Directions[point.X][point.Y]&direction == direction {
					temp := point.Advance(direction)
					if next.X == temp.X && next.Y == temp.Y {
						// [MODIFICATION] et ici que l'on ajoute dedans
						path = append(path, direction)
						maze_in.Directions[point.X][point.Y] |= direction << maze.SolutionOffset
						maze_in.Directions[next.X][next.Y] |= maze.Opposite[direction] << maze.SolutionOffset
						break
					}
				}
			}
		}
	}
	maze_in.Solved = true
	// [MODIFICATION] on le print pour le récupérer avec notre Python
	println(strings.Trim(strings.Join(strings.Fields(fmt.Sprint(path)), ", "), "[]"))
}

func main() {
	seed, err := strconv.Atoi(os.Args[1])
	if err != nil {
		panic(err)
	}

	rand.Seed(int64(seed))

	m := maze.NewMaze(0x19, 0x32)
	m.Generate()
	Solve(m)
}

from challenge import Challenge
from utils import calculate_checksum
import subprocess
from pwnlib.tubes.remote import remote

DIRECTIONS = {1: 'k', 2: 'j', 4: 'h', 8: 'l'}

def parse_maze_solution(raw: str) -> str:
    return ''.join([DIRECTIONS[int(n)] for n in raw.split(', ')])

def solve(host, port):
    client = remote(host, port)

    data = client.recvuntil(b'solution: ').decode()
    challenge = data.split('sh -s ')[1].split('\n')[0]
    print(f"Challenge: {challenge}")

    solution = Challenge.solve(challenge)
    print(f"Solution: {solution}")
    checksum = calculate_checksum(solution + '\n')
    print(f"Checksum: {checksum}")

    cmd = ["go", "run", "./solve.go", str(checksum)]
    output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, universal_newlines=True)
    maze_solution = parse_maze_solution(output)
    print(f"Maze: {maze_solution}")

    client.sendline(solution.encode())
    client.recvuntil(b'\n\n\n')
    client.sendline(maze_solution.encode())
    data = client.recvall(timeout=1)
    flag = data.splitlines()[-2].split(': ')[1]
    print(f"Flag: {flag}")

if __name__ == "__main__":
    solve('83.136.254.221', 36588)