---
# System prepended metadata

title: Write-up for ImaginaryCTF2024

---

### Write-up for ImaginaryCTF2024
#### 1. BF
- Đề cho 1 file txt được viết bởi ngôn ngữ bf và bắt chúng ta tìm flag dựa vào file đấy. Ban đầu nhìn vào hơi lú thật :V nhưng qua 1 chút research thì bf chỉ có vài lệnh cơ bản và thao tác trên các ô nhớ liền kề nhau + là +, - là -, các phép toán được thực hiện trên ô nhớ hiện tại, > là dịch qua ô nhớ bên phải, < là dịch qua ô nhớ bên trái. "," là nhập input, [] là kí hiệu vòng lặp, bên trong [] là công việc của 1 vòng lặp và miễn ô nhớ hiện tại lớn hơn 0 thì sẽ lặp. Đáng chú ý trong file có rất nhiều đoạn [><] điều mà sẽ lặp vô tận khi ô nhớ hiện tại khác 0 thế thì chỉ cần nhập sao cho sau 1 series các thao tác ô nhớ hiện tại khác 0 là được đó cũng chính là flag của bài!


```python
v = ",>>+++++++++++[<+++>-]<[-<+>]<------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++++[<+++++++>-]<[-<+>]<-------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++[<++++>-]<[-<+>]<----------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++++[<+++++++>-]<[-<+>]<----------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++++++++[<+++>-]<[-<+>]<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++[<++++++++>-]<[-<+>]<-----------------------------------------------------------------------------------------------------------------[><],>>+++++++++++++[<+++++>-]<[-<+>]<----------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++[<++++>-]<[-<+>]<----------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++[<+++++>-]<[-<+>]<----------------------------------------------------------------------------------[><],>>+++++++++++[<+++++>-]<[-<+>]<---------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++[<+++++++>-]<[-<+>]<------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++[<+++>-]<[-<+>]<--------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++++++++[<+++>-]<[-<+>]<------------------------------------------------------------------------------------------------------[><],>>+++++++++++[<+++++>-]<[-<+>]<--------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++[<+++++++>-]<[-<+>]<--------------------------------------------------------------------------------------------------------[><],>>++++++[<+++++>-]<[-<+>]<------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++[<+++++++>-]<[-<+>]<------------------------------------------------------------------------------------------------------------[><],>>+++++++++[<+++++++>-]<[-<+>]<-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++[<+++++>-]<[-<+>]<-------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++[<+++++>-]<[-<+>]<--------------------------------------------------------------------------------------------------[><],>>++++++++++[<+++++>-]<[-<+>]<-------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++++[<+++++++>-]<[-<+>]<-----------------------------------------------------------------------------------------------------------------------------[><],>>++++++++++[<+++++++>-]<[-<+>]<--------------------------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++++++[<++++++>-]<[-<+>]<----------------------------------------------------------------------------------------------------------------[><],>>+++++++++++++++++[<+++>-]<[-<+>]<---------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++[<++++>-]<[-<+>]<-----------------------------------------------------------------------------------------------[><],>>+++++++++++++++++++++++[<++>-]<[-<+>]<-----------------------------------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++++++++++++++[<+++>-]<[-<+>]<----------------------------------------------------------------------------------------------------------------------[><],>>+++++++++++++++++++[<+++>-]<[-<+>]<-----------------------------------------------------------------------------------------------------------------------------------------------------------[><],>>++++++[<+++++>-]<[-<+>]<-----------------------------------------------------------------------------------------------------------------------------------------------------------[><]"
i = 1
info = [0] * 30000
ptr = 0
while i < len(v):
    if (v[i] == '<'):
        ptr -= 1
    if (v[i] == '>'):
        ptr += 1
    if (v[i] == '+'):
        info[ptr] += 1
    if (v[i] == '-'):
        info[ptr] -= 1
    if v[i] == '[':
        if v[i + 1] == '>' and v[i + 2] == '<' and v[i + 3] == ']':
            i += 3
            print(chr(-info[ptr]),end='')
            info[ptr] = 0
        else:
            tmp = info[ptr]
            while (info[ptr] != 0):
                for j in range(i + 1, len(v)):
                    if (v[j]==']'):
                        break
                    if (v[j] == '<'):
                        ptr -= 1
                    if (v[j] == '>'):
                        ptr += 1
                    if (v[j] == '+'):
                        info[ptr] += 1
                    if (v[j] == '-'):
                        info[ptr] -= 1
        while (v[i] != ']'):
            i += 1
    i += 1
    
#ictf{1_h4t3_3s0l4ng5_7d4f3a1b}
``` 

#### 2.Absolute Flag Checker
- Sau khi bỏ file vào ida thì thấy có rất rất nhiều lệnh if và các biểu thức. Ban đầu chúng ta phải nhập vào 1 string sau 7749 lệnh if (thật ra có 47 cái thôi :v) thì sẽ in ra "Correct flag".

![image](https://hackmd.io/_uploads/Bk3sIvA_R.png)
 
- Ban đầu mình dùng 1 số cách thì lấy được tất cả đống if đó xong mình code thêm cái script viết nó lại để tính theo z3 python. Nhưng mà đợi mãi cũng không thấy kết quả lúc đó có 2 trường hợp 1 là mình lấy data sai 2 là z3 k giải được :)) và vì quá tự tin nên mình nghĩ là z3 k giải được chứ k phải data mình sai nên mình đã đọc kĩ lại và nghĩ cách giải khác... 
- Sau 1 thời gian ngắn thì mình nhận ra là với mỗi lệnh if thì 47 biến từ 52 tới 98 đều xuất hiện đầy đủ mà lại có 47 lệnh if điều này đồng nghĩa ta sẽ có 1 ma trận vuông 47x47 và 1 ma trận đơn kết quả 47x1. Đến đây dùng numpy thôi!
- Nhưng sau mình giải lại ra kết quả sai có số âm, có cả số thực ?!?!
- Mãi sau này mình mới nhận ra script của mình viết lấy data thiếu trường hợp hệ số = 1 :v extremely painful.

``` python
import numpy as np
heso = np.array([[660, 290, 426, 812, 584, 826, 515, 888, 411, 996, 610, 139, 21, 659, 567, 669, 357, 845, 71, 246, 260, 954, 871, 931, 278, 635, 132, 365, 145, 188, 487, 524, 160, 525, 951, 151, 330, 621, 448, 575, 335, 680, 626, 317, 338, 740, 813],
[9, 573, 886, 444, 205, 738, 1018, 799, 281, 222, 162, 909, 472, 195, 462, 953, 899, 374, 477, 853, 660, 725, 323, 212, 62, 925, 220, 629, 859, 651, 641, 125, 422, 706, 984, 195, 298, 877, 880, 882, 506, 677, 13, 267, 35, 917, 576],
[425, 479, 988, 59, 393, 523, 50, 996, 713, 731, 79, 808, 112, 205, 521, 658, 687, 475, 956, 540, 103, 245, 494, 69, 490, 430, 51, 867, 262, 54, 335, 315, 576, 392, 667, 207, 861, 996, 682, 631, 807, 896, 811, 563, 621, 891, 529],
[64, 588, 786, 498, 1001, 941, 790, 429, 160, 15, 925, 848, 333, 903, 505, 569, 486, 4, 742, 123, 832, 472, 263, 899, 293, 372, 916, 1019, 678, 627, 333, 238, 178, 987, 946, 557, 744, 415, 629, 498, 682, 872, 816, 452, 115, 148, 340],
[666, 874, 383, 609, 67, 823, 514, 605, 5, 21, 314, 127, 645, 296, 651, 43, 230, 274, 996, 547, 309, 193, 324, 507, 517, 138, 381, 973, 342, 892, 56, 559, 700, 238, 313, 98, 189, 91, 228, 204, 378, 880, 512, 936, 658, 610, 188],
[509, 67, 645, 751, 204, 978, 795, 420, 142, 301, 105, 982, 222, 976, 273, 632, 114, 741, 411, 441, 335, 175, 597, 901, 317, 296, 861, 847, 633, 1001, 764, 782, 171, 331, 565, 389, 535, 716, 926, 456, 279, 692, 111, 1020, 457, 760, 985],
[862, 5, 862, 153, 391, 402, 738, 204, 750, 153, 88, 5, 174, 601, 596, 925, 905, 541, 583, 330, 45, 107, 746, 1011, 183, 639, 480, 707, 886, 504, 151, 637, 753, 208, 111, 271, 811, 401, 542, 873, 37, 966, 83, 399, 421, 176, 409],
[237, 54, 59, 382, 236, 880, 560, 245, 450, 377, 940, 506, 398, 972, 209, 628, 932, 313, 699, 607, 549, 301, 438, 298, 468, 52, 942, 606, 36, 444, 743, 385, 918, 796, 238, 314, 577, 981, 463, 438, 690, 791, 904, 585, 759, 647, 446],
[601, 503, 575, 431, 376, 773, 534, 616, 720, 948, 34, 311, 964, 1004, 124, 612, 468, 61, 579, 540, 961, 628, 484, 430, 498, 108, 152, 250, 535, 295, 302, 37, 524, 29, 522, 402, 512, 724, 110, 14, 470, 177, 248, 331, 459, 270, 364],
[144, 602, 909, 948, 430, 861, 683, 549, 54, 628, 152, 260, 745, 170, 582, 329, 880, 854, 191, 162, 590, 64, 189, 699, 786, 261, 116, 957, 209, 445, 947, 21, 723, 730, 555, 374, 397, 595, 14, 289, 975, 3, 221, 868, 63, 332, 123],
[96, 774, 1023, 645, 528, 969, 128, 998, 903, 987, 805, 677, 377, 177, 224, 2, 1021, 662, 798, 194, 401, 927, 750, 967, 863, 738, 870, 739, 703, 995, 834, 494, 1020, 591, 463, 22, 603, 493, 776, 887, 345, 721, 766, 748, 821, 467, 125],
[548, 174, 319, 748, 1016, 526, 462, 885, 763, 359, 981, 358, 83, 541, 189, 471, 200, 420, 179, 654, 27, 395, 160, 31, 665, 698, 92, 855, 239, 504, 287, 475, 576, 432, 56, 525, 117, 244, 513, 559, 725, 962, 274, 715, 725, 134, 437],
[82, 817, 737, 410, 3, 315, 937, 972, 14, 115, 561, 228, 762, 89, 714, 893, 580, 127, 649, 231, 73, 738, 75, 544, 357, 122, 759, 255, 93, 16, 259, 435, 506, 848, 314, 108, 1015, 543, 188, 856, 798, 47, 582, 209, 173, 208, 691],
[469, 766, 265, 707, 182, 359, 999, 540, 18, 864, 277, 910, 518, 739, 429, 667, 927, 537, 846, 567, 145, 50, 367, 204, 812, 404, 242, 385, 139, 825, 508, 700, 271, 338, 5, 485, 268, 305, 43, 110, 449, 613, 460, 528, 654, 807, 339],
[87, 609, 1013, 338, 864, 370, 636, 466, 994, 816, 955, 487, 619, 122, 358, 903, 1004, 531, 648, 411, 888, 848, 877, 87, 329, 276, 191, 967, 772, 254, 495, 171, 317, 225, 726, 901, 574, 629, 157, 496, 516, 844, 474, 563, 907, 263, 507],
[278, 844, 457, 1000, 501, 771, 236, 996, 274, 693, 1011, 180, 47, 754, 960, 4, 349, 88, 520, 518, 15, 88, 771, 92, 114, 829, 872, 56, 257, 873, 664, 962, 596, 482, 281, 698, 312, 14, 839, 606, 773, 699, 70, 142, 44, 610, 315],
[558, 272, 173, 188, 204, 279, 822, 645, 898, 0, 914, 876, 798, 375, 142, 407, 385, 742, 184, 236, 69, 911, 546, 969, 675, 728, 866, 1013, 659, 229, 477, 983, 308, 364, 326, 998, 623, 197, 97, 97, 983, 833, 781, 832, 724, 701, 385],
[618, 513, 631, 214, 552, 466, 288, 198, 986, 122, 306, 691, 233, 268, 899, 490, 508, 480, 27, 298, 623, 568, 322, 352, 1, 803, 222, 437, 716, 930, 1020, 202, 379, 10, 173, 834, 439, 169, 531, 898, 226, 940, 699, 692, 264, 576, 301],
[786, 530, 248, 706, 865, 829, 879, 182, 955, 203, 814, 894, 914, 505, 464, 92, 242, 816, 612, 304, 262, 127, 530, 657, 478, 73, 2, 28, 367, 571, 121, 780, 476, 641, 837, 780, 756, 314, 348, 329, 251, 553, 448, 458, 173, 173, 421],
[772, 128, 1011, 982, 937, 810, 874, 853, 706, 867, 887, 321, 509, 236, 619, 509, 584, 720, 434, 399, 670, 746, 844, 838, 289, 679, 898, 160, 618, 269, 721, 874, 797, 508, 43, 809, 960, 692, 863, 441, 717, 920, 981, 820, 261, 818, 894],
[278, 8, 630, 523, 158, 803, 587, 93, 119, 617, 583, 61, 407, 5, 186, 78, 872, 974, 1007, 63, 805, 284, 174, 325, 647, 730, 517, 713, 418, 477, 585, 862, 9, 372, 343, 501, 313, 577, 31, 852, 53, 839, 356, 964, 621, 323, 957],
[266, 484, 64, 224, 153, 658, 870, 543, 518, 776, 787, 563, 444, 82, 301, 57, 1009, 289, 950, 1018, 985, 42, 416, 879, 793, 457, 483, 389, 382, 234, 206, 541, 239, 809, 922, 855, 416, 56, 581, 16, 649, 129, 926, 937, 535, 781, 924],
[778, 801, 677, 1011, 743, 541, 567, 745, 834, 660, 123, 102, 50, 211, 725, 331, 994, 996, 894, 261, 476, 956, 735, 354, 904, 950, 61, 163, 495, 320, 411, 466, 197, 724, 732, 854, 679, 811, 41, 964, 673, 173, 914, 248, 755, 299, 504],
[357, 277, 464, 810, 937, 760, 853, 334, 100, 399, 629, 899, 587, 142, 161, 964, 120, 882, 244, 15, 772, 961, 361, 711, 472, 147, 76, 600, 448, 849, 494, 25, 962, 445, 669, 630, 685, 306, 211, 590, 756, 813, 942, 922, 189, 781, 416],
[336, 54, 279, 872, 135, 40, 701, 833, 731, 718, 32, 89, 19, 231, 723, 644, 769, 778, 482, 562, 426, 314, 787, 159, 167, 186, 363, 73, 459, 34, 244, 423, 518, 435, 958, 24, 649, 1000, 36, 794, 299, 77, 80, 956, 12, 148, 770],
[598, 120, 486, 396, 119, 270, 631, 802, 799, 801, 349, 336, 302, 862, 162, 460, 541, 431, 408, 366, 236, 96, 876, 125, 859, 641, 1022, 44, 349, 395, 752, 356, 202, 582, 766, 196, 340, 233, 397, 999, 188, 131, 134, 997, 838, 411, 612],
[284, 106, 19, 140, 48, 972, 83, 989, 80, 622, 931, 905, 699, 36, 983, 547, 899, 329, 562, 249, 913, 177, 389, 419, 1002, 478, 919, 476, 561, 887, 457, 401, 620, 501, 250, 824, 523, 672, 169, 611, 38, 698, 345, 149, 774, 762, 570],
[84, 743, 828, 517, 639, 508, 630, 808, 482, 436, 750, 803, 264, 316, 682, 306, 592, 325, 40, 44, 579, 263, 848, 939, 37, 133, 679, 109, 202, 19, 197, 1018, 940, 278, 521, 903, 570, 12, 651, 539, 370, 972, 82, 496, 433, 526, 456],
[284, 202, 301, 106, 368, 598, 812, 964, 929, 588, 504, 157, 421, 466, 236, 111, 96, 594, 922, 282, 128, 719, 457, 216, 678, 890, 186, 628, 710, 896, 432, 439, 720, 295, 430, 36, 144, 25, 643, 485, 723, 511, 260, 772, 459, 338, 153],
[222, 692, 622, 1019, 981, 696, 745, 827, 326, 272, 802, 775, 443, 109, 541, 297, 865, 918, 910, 592, 188, 338, 51, 275, 921, 904, 103, 563, 68, 421, 245, 544, 252, 574, 554, 959, 420, 1015, 302, 107, 955, 419, 916, 314, 654, 428, 303],
[385, 940, 181, 39, 666, 923, 895, 845, 228, 713, 9, 684, 524, 709, 508, 608, 139, 943, 581, 940, 112, 494, 516, 70, 352, 32, 165, 1013, 475, 343, 332, 94, 960, 898, 887, 795, 532, 553, 735, 526, 1023, 350, 671, 501, 279, 240, 919],
[830, 738, 993, 531, 284, 917, 26, 680, 730, 546, 606, 607, 880, 882, 637, 534, 852, 239, 970, 290, 146, 70, 462, 825, 287, 107, 318, 400, 874, 989, 299, 832, 309, 43, 121, 238, 163, 695, 914, 939, 914, 698, 603, 793, 298, 136, 616],
[719, 438, 534, 364, 767, 179, 185, 1011, 86, 295, 48, 83, 804, 53, 741, 479, 445, 493, 880, 95, 543, 105, 861, 957, 725, 277, 815, 1, 795, 78, 932, 383, 578, 815, 59, 335, 598, 935, 756, 510, 511, 719, 343, 131, 421, 379, 695],
[373, 983, 784, 952, 635, 238, 661, 783, 3, 493, 524, 905, 823, 684, 2, 847, 44, 822, 869, 104, 93, 111, 406, 639, 345, 1018, 703, 487, 952, 857, 103, 988, 595, 598, 579, 12, 437, 162, 335, 854, 972, 701, 286, 977, 996, 533, 878],
[528, 727, 114, 512, 932, 893, 657, 679, 739, 874, 527, 414, 1000, 985, 650, 542, 731, 739, 514, 304, 883, 245, 133, 705, 440, 640, 779, 244, 14, 498, 415, 444, 623, 486, 191, 681, 760, 919, 518, 770, 935, 411, 8, 21, 355, 718, 382],
[971, 60, 396, 931, 383, 245, 803, 989, 272, 959, 903, 160, 53, 72, 328, 399, 529, 756, 450, 741, 264, 874, 404, 20, 720, 83, 339, 428, 715, 94, 639, 637, 660, 136, 181, 0, 216, 922, 807, 499, 615, 755, 586, 324, 394, 135, 462],
[560, 920, 552, 723, 428, 196, 517, 602, 516, 569, 112, 1017, 706, 617, 740, 212, 977, 929, 70, 712, 994, 225, 619, 1001, 527, 236, 219, 559, 702, 923, 212, 876, 969, 374, 658, 385, 988, 389, 974, 722, 286, 356, 901, 759, 787, 918, 762],
[949, 961, 27, 1022, 556, 17, 837, 111, 81, 889, 711, 767, 671, 728, 271, 310, 522, 673, 726, 699, 565, 60, 757, 463, 996, 681, 122, 282, 948, 615, 763, 682, 266, 148, 298, 57, 329, 341, 426, 174, 840, 376, 545, 743, 771, 856, 143],
[438, 400, 769, 734, 297, 341, 405, 186, 271, 633, 1007, 930, 183, 920, 133, 319, 1019, 699, 147, 1013, 381, 647, 118, 441, 561, 948, 853, 290, 540, 705, 519, 194, 603, 486, 305, 182, 102, 843, 687, 636, 662, 887, 566, 773, 485, 11, 311],
[779, 246, 688, 518, 421, 85, 78, 571, 281, 1023, 127, 89, 497, 549, 323, 173, 81, 813, 757, 377, 903, 762, 125, 594, 996, 877, 968, 711, 714, 43, 629, 67, 263, 929, 721, 821, 865, 326, 262, 877, 370, 288, 143, 969, 695, 138, 495],
[274, 483, 52, 163, 33, 633, 875, 341, 838, 153, 155, 82, 746, 794, 786, 62, 370, 986, 518, 263, 615, 594, 218, 791, 212, 110, 157, 718, 240, 411, 724, 47, 253, 33, 377, 729, 368, 179, 67, 569, 82, 68, 808, 511, 998, 29, 545],
[718, 140, 45, 557, 824, 485, 928, 920, 233, 824, 947, 381, 546, 789, 198, 650, 874, 568, 434, 771, 384, 431, 350, 9, 915, 64, 653, 29, 437, 773, 506, 224, 910, 345, 679, 540, 845, 1016, 114, 520, 228, 865, 233, 712, 373, 383, 607],
[308, 775, 649, 320, 218, 126, 295, 929, 326, 458, 470, 795, 129, 94, 397, 218, 727, 996, 929, 1009, 989, 815, 742, 496, 179, 369, 535, 441, 903, 942, 887, 143, 90, 624, 953, 368, 775, 957, 29, 677, 641, 326, 989, 407, 348, 737, 199],
[228, 911, 313, 811, 178, 376, 196, 247, 324, 32, 246, 33, 971, 705, 949, 69, 382, 389, 268, 912, 236, 401, 803, 732, 401, 578, 623, 284, 424, 950, 550, 507, 577, 655, 246, 960, 403, 243, 502, 117, 915, 215, 477, 584, 198, 894, 114],
[817, 851, 572, 579, 981, 604, 128, 666, 427, 910, 786, 429, 93, 759, 152, 789, 625, 280, 863, 129, 296, 828, 88, 172, 934, 520, 865, 652, 340, 594, 198, 205, 899, 55, 8, 381, 594, 103, 989, 521, 209, 964, 887, 872, 102, 300, 265],
[662, 880, 402, 392, 324, 811, 596, 431, 718, 212, 456, 69, 365, 525, 536, 418, 942, 130, 593, 112, 546, 205, 438, 943, 343, 151, 346, 507, 8, 0, 1006, 530, 401, 577, 983, 145, 165, 400, 900, 766, 579, 581, 1022, 11, 230, 314, 448],
[281, 1021, 375, 970, 252, 922, 271, 241, 1022, 110, 325, 889, 294, 1013, 499, 741, 186, 238, 45, 14, 2, 14, 33, 883, 591, 245, 577, 464, 828, 865, 933, 754, 564, 162, 426, 713, 820, 334, 224, 191, 210, 821, 803, 328, 895, 919, 263]])
b = np.array([2418373, 2519130, 2410525, 2636936, 2001991, 2616456, 2226206, 2438804, 2107275, 2187656, 3060182, 2106171, 1969653, 2176941, 2658391, 2188027, 2510283, 2220943, 2322631, 3160127, 2180863, 2447720, 2649697, 2531775, 1994440, 2184786, 2380571, 2230704, 2126732, 2538169, 2516019, 2619695, 2297196, 2669838, 2579438, 2285803, 2920377, 2471657, 2512964, 2351755, 1909222, 2557994, 2584886, 2134976, 2504301, 2234809, 2374375])
ans = np.linalg.solve(heso,b)
for i in ans:
    print(chr(round(i)),end='')


#ictf{that_is_a_lot_of_equations_n2u1iye21azl21}
```

#### 3. Unoriginal

- Bài này là bài dễ nhất trong contest: đề yêu cầu chỉ cần xor cho 5 input là sẽ được string file yêu cầu.

``` python
v = "lfqc~opvqZdkjqm`wZcidbZfm`fn`wZd6130a0`0``761gdx"
for i in v:
    print(chr(5 ^ (int.from_bytes(i.encode()))),end='')


#ictf{just_another_flag_checker_a3465d5e5ee234ba}

```

#### 4. Rust

- Đề bài cho 1 file mà khi mình bỏ vào ida thì nhìn rất xấu:

![image](https://hackmd.io/_uploads/rJh28hgtA.png)

- Và pseudocode theo đó cũng xấu và khó hiểu theo. Đến đây mình hiểu được ý đồ của bài này là muồn mình debug input để xem chương trình làm như thế nào. 
- Sơ lược thì bài này sẽ yêu cầu chúng ta nhập vào 1 message và 1 key (in hex) sau đó in ra 1 list các số.

![image](https://hackmd.io/_uploads/S1y7vnxKC.png)

- Cùng với đó là file output đề cho chính là file encrypted để chúng ta reverse lại message lẫn key. Tới đây nghe có vẻ khá khoai khi có 1 dữ kiện nhưng lại bắt nhập 2 input. 
- Sau quá trình debug thì mình nhận ra chương trình sẽ làm các việc như sau:

![image](https://hackmd.io/_uploads/Ska2w2lK0.png)

- output ra theo dạng số nguyên có dấu bù 2 với ch[i] là từng kí tự của message. Đến đây thì có vẻ sáng sủa hơn khi chúng ta đã có gợi ý cho mọi chall của contest rằng flag có format ictf{}. v thì chỉ cần thử với kí tự 'i' chúng ta sẽ tìm được key

``` python
# script tìm key

out = [-42148619422891531582255418903, -42148619422891531582255418927, -42148619422891531582255418851, -42148619422891531582255418907, -42148619422891531582255418831, -42148619422891531582255418859, -42148619422891531582255418855, -42148619422891531582255419111, -42148619422891531582255419103, -42148619422891531582255418687, -42148619422891531582255418859, -42148619422891531582255419119, -42148619422891531582255418843, -42148619422891531582255418687, -42148619422891531582255419103, -42148619422891531582255418907, -42148619422891531582255419107, -42148619422891531582255418915, -42148619422891531582255419119, -42148619422891531582255418935, -42148619422891531582255418823]


v = ord('c')
v = (v << 5)
v = (v << 0x3d) >> 64
inp = -out[0]
inp = inp - 1 - 0x539
inp ^= v
print(inp)

#42148619422891531582255417681

```

#### 5. Unconditional

- Đề cho 1 file, sau khi check thì mình thử coi trong ida nó có gì


![image](https://hackmd.io/_uploads/rJENLzbKC.png)

- ...Woa từ đầu tới cuối toàn các lệnh call 1 fuction như nhau.
- Tìm hiểu fuction đó ra sao:

![image](https://hackmd.io/_uploads/BkrYLGbY0.png)


- Sau 1 lúc tìm hiểu kĩ thì mình nhận thấy việc call các function thực chất là độc lập, lúc đầu nhìn có vẽ counter 1 và counter 2 hay thậm chí flag[] sẽ thay đổi trong quá trình thực thi, nhưng thực chất các lệnh call là khá độc lập với nhau...
- Đề bài bắt phải output ra được như 33 output đề bài. Và việc mỗi lệnh call độc lập với nhau chỉ có 2 biến counter1 và counter2 phụ thuộc vào đây là lần lặp thứ mấy, việc này có thể quản lí được nên chúng ta sẽ liên tưởng tới brute-force tìm kí tự thích hợp. Độ phức tạp brute-force rất nhanh khoảng O(số kí tự cần thử * 33).

``` c++
#include<bits/stdc++.h>
#define int long long 
using namespace std;

main()
{
  //freopen("flag.txt","r",stdin);
  freopen("out.txt","w",stdout);
  int ans[] = {0xb4, 0x31, 0x8e, 0x02, 0xaf, 0x1c, 0x5d, 0x23, 0x98, 0x7d, 0xa3, 0x1e, 0xb0, 0x3c, 0xb3, 0xc4, 0xa6, 0x06, 0x58, 0x28, 0x19, 0x7d, 0xa3, 0xc0, 0x85, 0x31, 0x68, 0x0a, 0xbc, 0x03, 0x5d, 0x3d, 0x0b};
  int table1[] = {0x52, 0x64, 0x71, 0x51, 0x54, 0x76};
  int table2[] = {1, 3, 4, 2, 6, 5};
  int counter1 = 0;
  int counter2 = 0;
  int tmp = 0x69;
  for (int cnt = 0; cnt <= 32; cnt++)
  {
    for (int i = 48; i <= 125; i++) 
    {
      if (i >= 58 && i <= 94) continue;
      if (i == 96)  continue;
      if (i == 124) continue;
      int flag = i;
      unsigned __int8 v3 = flag;
      bool v1 = v3 > 0x60 && v3 <= 0x7A;
      flag = ((((int)v3 >> table2[counter2]) | (v3 << (8 - table2[counter2]))) * v1
            + !v1 * (((v3 << 6) | (v3 >> 2)) ^ table1[counter1]))
           * ((cnt & 1) == 0)
           + ((v3 ^ table1[counter1]) * v1 + !v1 * ((4 * v3) | (v3 >> 6))) * ((cnt & 1) != 0);
      flag &= 0xff;
      if (flag == ans[cnt])
      {
        cout << char(i);
        break;
      }
    }
    if (cnt % 2 == 1)
    {
      counter1 = (counter1 + 1) % 6;
      counter2 = (counter2 + 1) % 6;
    }
  }
}


//  ictf{m0r3_than_1_way5_t0_c0n7r0l}
```

#### 6. WatchDog

- Đây là 1 trong những chall mình k thể solve ra trong thời gian contest diễn ra. Sau khi phân tích tĩnh nhìn chung đề bài cho 1 số các đẳng thức cùng với 1 số ẩn và bắt mình tìm chúng. Mặc dù ở những phút đầu tiên mình hơi bối rối khi pseudocode trông có vẻ hơi bị nguyên thủy :vvvvv. 

![image](https://hackmd.io/_uploads/SyevxFEFR.png)

- Nếu bài này chỉ dừng lại ở việc reverse đống code đó và nhận ra các vòng for lồng nhau, các phép toán cơ bản để tạo ra hệ phương trình đa ẩn thì không có gì để nói, nhưng điểm chú ý nằm ở đây:

![image](https://hackmd.io/_uploads/S1gnlYNYR.png)

- không khó để nhận ra đây là hàm tính a^b trong O(logn) dựa theo thuật toán chia để trị. Nhưng... hệ số của phép mũ khá lớn dẫn tới tràn số thứ mà mình chưa handle được khi làm trong giải khá là buồn....

- Sau giải thì mình mới nhận ra thực chất phép tràn số của 1 data type unsigned bất kì đơn giản là phép mod cho range của data type đó :v. Đến đây mình cảm giác thậm chí mình có thể dùng numpy để giải được mình nghĩ thế :v nhưng mà sage có sẵn zmod thì tiện hơn.

``` python
from sage.all import *

ans = [ 
    0x59, 0x06, 0xD1, 0x27, 0xA6, 0x48, 0x03, 0x00, 0x61, 0xFE, 
    0x65, 0x03, 0x84, 0x5A, 0x48, 0x27, 0xCD, 0x31, 0x6D, 0xF2, 
    0xAD, 0x5D, 0x73, 0x9E, 0xD9, 0x79, 0xB5, 0xF9, 0xC9, 0x4B, 
    0x71, 0x82, 0xC9, 0x6B, 0xD1, 0x01, 0xC8, 0x7C, 0xFB, 0x3D, 
    0x59, 0xD6, 0xDA, 0xE5, 0xEF, 0x04, 0x2A, 0x60, 0x3D, 0x0D, 
    0xA3, 0x15, 0xD9, 0x01, 0xB8, 0x0E, 0xA1, 0x20, 0xCB, 0xED, 
    0x10, 0xBE, 0x7D, 0x21, 0x19, 0xCA, 0x75, 0xE8, 0x37, 0x26, 
    0xEE, 0xAD, 0x71, 0x98, 0x8E, 0x23, 0xED, 0x4A, 0xD4, 0x0C, 
    0x4D, 0x50, 0x6B, 0xAE, 0x76, 0xFF, 0x3B, 0x0D, 0x89, 0xE7, 
    0x59, 0xFF, 0x6E, 0x42, 0x81, 0x71, 0xC9, 0xDA, 0xC2, 0x20, 
    0xCB, 0x16, 0x76, 0x47, 0xA9, 0xE4, 0x6C, 0xE4, 0xE1, 0x06, 
    0x12, 0xCE, 0x7D, 0xF8, 0xA3, 0x64, 0xB9, 0x7C, 0x6E, 0x94, 
    0x91, 0x32, 0x0C, 0xBF, 0x7C, 0x60, 0x99, 0x04, 0x59, 0xC7, 
    0x47, 0x23, 0x37, 0xD4, 0x71, 0x68, 0x01, 0x8B, 0x7D, 0x6B, 
    0xF5, 0x12, 0x54, 0x07, 0x4D, 0xE3, 0x86, 0x47, 0x26, 0x7C, 
    0xE5, 0xF8, 0xB9, 0x05, 0xC5, 0x0E, 0x02, 0xA6, 0x4C, 0x19, 
    0x49, 0x49, 0xE8, 0x4F, 0xE3, 0x22, 0x1A, 0x3E, 0x79, 0x2B, 
    0x74, 0x72, 0x51, 0xE2, 0x6D, 0xA4, 0x3D, 0x6E, 0xFE, 0xCB, 
    0x1B, 0x97, 0x0E, 0xCD, 0x01, 0x25, 0x8A, 0x13, 0x61, 0x19, 
    0x56, 0x56, 0x19, 0xCA, 0x53, 0xAB, 0x38, 0xB5, 0xD2, 0x78, 
    0x11, 0xD6, 0xB6, 0x5A, 0xA7, 0x0C, 0x98, 0xA9, 0xCD, 0x16, 
    0x47, 0x5D, 0x6B, 0x57, 0x81, 0x5F, 0x69, 0x34, 0xB9, 0x25, 
    0x08, 0x86, 0xB9, 0x17, 0x49, 0x83, 0x29, 0x69, 0x52, 0xF7, 
    0x12, 0xC0, 0xC9, 0xAA, 0xA3, 0xC7, 0xE9, 0x3E, 0x37, 0x17, 
    0x7D, 0x1A, 0x1E, 0xB1, 0x98, 0x07, 0xE5, 0xB2, 0xF1, 0xD7, 
    0x0F, 0x2E, 0x56, 0xA6, 0xA5, 0xAD, 0x59, 0x9E, 0xC9, 0xF1, 
    0x68, 0x9A, 0x3D, 0xEC, 0xA1, 0x79, 0x5D, 0x50, 0x35, 0x8B, 
    0x82, 0x3D, 0xCD, 0x16, 0xBD, 0xF7, 0x64, 0x52, 0x6E, 0xF7, 
    0x99, 0xD3, 0x8E, 0xC4, 0x3E, 0x0B, 0x23, 0xDD, 0xC9, 0x54, 
    0xD3, 0xDC, 0x63, 0x33, 0xD9, 0x80, 0x99, 0x62, 0xE7, 0x81, 
    0x76, 0x56, 0x31, 0x70, 0x3D, 0xA9, 0xE2, 0xD4, 0x8C, 0x33, 
    0x77, 0x89, 0x61, 0x2B, 0xC0, 0xD4, 0xA1, 0x08, 0x57, 0x8A, 
    0x19, 0x10, 0x50, 0x21, 0x6A, 0x29, 0x66, 0x20, 0xB1, 0x75, 
    0xD7, 0xA4, 0x94, 0x0D, 0x26, 0x9E, 0x4D, 0x0F, 0x28, 0x72, 
    0xBD, 0x7B, 0x66, 0xE7, 0x49, 0x43, 0x68, 0xE1, 0x35, 0x40, 
    0xDF, 0x12
    ]
res = []
for i in range(0,len(ans),8):
    res.append(int.from_bytes(ans[i:i+8],'little'))
a = [[i ** index for index in range(42,-1,-1)] for i in range(2,46)]
R = Zmod(2 ** 64)
B = vector(R,res)
A = matrix(R,a)
sol = A.solve_right(B)
for i in sol:
    print(chr(int(i) & 0x7f),end='')

#ictf{i_l0ve_interp0lati0n_2ca38d6ef0a709e0}


```





