cat output.txt

naniy_aslgflmuaa{}salyl
zsvz}i{si}_n}rkpsruckhv
_n{}s}kzrcvkhipvsi}szur

# task.py — три шага
enc, key1 = permute(flag)        # шаг 1: случайная перестановка символов флага → e1
key2 = [randint(1,1337) for ...]
enc = rollingrollingrolling(enc, key2)  # шаг 2: каждый символ сдвигается на key2[i] → e2
enc = arrange(enc, key1)         # шаг 3: e2 раскладывается обратно по key1 → e3

def arrange(enc, key):
    dec = [0]*len(enc)
    for i in range(len(enc)):
        dec[key[i]] = enc[i]   # e3[key[i]] = e2[i]: позиция key[i] стала известна через e3
    return ''.join(dec)

from collections import defaultdict
from pathlib import Path

ALPHABET = 'abcdefghijklmnopqrstuvwxyz{}_'
# Словарь для ранжирования кандидатов по читаемости; применяется после верификации
COMMON_PARTS = {
    'manually': 10, 'analysis': 10,
    'manual': 8,    'analys': 7,
    'ally': 4,      'lysis': 4,
    '_': 2,
}


def load_output(path: str = 'output.txt') -> tuple[str, str, str]:
    lines = [l.strip() for l in Path(path).read_text().splitlines() if l.strip()]
    return tuple(lines)  # возвращает (e1, e2, e3)


def recover_candidates(e1, e2, e3):
    n = len(e1)
    # positions_by_char[c] — все j, где e3[j] == c
    positions_by_char = defaultdict(list)
    for j, c in enumerate(e3):
        positions_by_char[c].append(j)

    # фиксированные позиции из формата flag{...}
    fixed = {0: 'f', 1: 'l', 2: 'a', 3: 'g', 4: '{', n - 1: '}'}
    # обрабатываем в порядке возрастания числа кандидатов → быстрее отсекаем
    order = sorted(range(n), key=lambda i: len(positions_by_char[e2[i]]))

    used = [False] * n
    candidate = ['?'] * n
    found = []

    def bt(step):
        if step == n:
            w = ''.join(candidate)
            if w.startswith('flag{') and w.endswith('}'):
                found.append(w)
            return
        i = order[step]
        for j in positions_by_char[e2[i]]:
            if used[j]:
                continue
            c = e1[i]
            if j in fixed and fixed[j] != c:  # нарушает формат
                continue
            if candidate[j] not in ('?', c):  # конфликт с ранее назначенным
                continue
            prev, used[j], candidate[j] = candidate[j], True, c
            bt(step + 1)
            candidate[j], used[j] = prev, False  # откат

    bt(0)
    return sorted(set(found))


def verify(flag, e1, e2, e3):
    # восстанавливаем key1 из кандидата и проверяем все три строки
    pos = defaultdict(list)
    for j, c in enumerate(e3):
        pos[c].append(j)
    used = [False] * len(flag)
    key1 = [None] * len(flag)
    for i, (l, r) in enumerate(zip(e1, e2)):
        for j in pos[r]:
            if not used[j] and flag[j] == l:
                used[j] = True; key1[i] = j; break
        if key1[i] is None:
            return False
    if ''.join(flag[j] for j in key1) != e1:
        return False
    shifts = [(ALPHABET.index(e2[i]) - ALPHABET.index(e1[i])) % 29 for i in range(len(e1))]
    rolled = ''.join(ALPHABET[(ALPHABET.index(e1[i]) + shifts[i]) % 29] for i in range(len(e1)))
    if rolled != e2:
        return False
    arr = ['?'] * len(flag)
    for i, j in enumerate(key1):
        arr[j] = e2[i]
    return ''.join(arr) == e3


def score(flag):
    inner = flag[5:-1]
    return sum(w for p, w in COMMON_PARTS.items() if p in inner)


e1, e2, e3 = load_output()
candidates = [c for c in recover_candidates(e1, e2, e3) if verify(c, e1, e2, e3)]
candidates.sort(key=lambda c: (-score(c), c))
print(f'Flag: {candidates[0]}')

python3 solve.py
# Flag: flag{manually_analysis}