什麼是 Big O (時間複雜度)?

Big O 描述演算法在資料量 n 趨近無限大時的效能趨勢。

🔴 Bubble Sort（氣泡排序）

核心思想：每輪把相鄰的兩個元素互比，如果左邊比較大就交換。這樣最大數字會像泡泡一樣「浮」到最右端，然後一直縮小範圍重複這個動作。

什麼時候用？ 幾乎不用於實戰，但因為邏輯最直覺，是學習演算法的起點。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break; // 優化：提早結束
    }
}

int main() {
    vector<int> v = {64, 34, 25, 12, 22, 11, 90};
    bubbleSort(v);
    for (int x : v) cout << x << " ";
}
// Output: 11 12 22 25 34 64 90

🔴 Selection Sort（選擇排序）

核心思想：每一輪從「尚未排序的部分」找出最小值，然後跟最前面的元素交換。每輪確定一個位置正確的元素。

注意：Selection Sort 永遠執行 O(n²) 次比較，無論資料本身是否已排序，這是它的最大缺點。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void selectionSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        swap(arr[i], arr[minIdx]);
    }
}

🔴 Insertion Sort（插入排序）

核心思想：想像左手拿著已排好的牌，右手每次從右邊抽一張，然後插進左手牌堆的正確位置。

什麼時候用？ 資料已接近排序完成時（nearly sorted），時間複雜度接近 O(n)！在 std::sort 的 IntroSort 實作中，當子陣列縮到小於 16 個元素時，會切換為 Insertion Sort。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void insertionSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

🟡 Merge Sort（合併排序）

核心思想：分治法 (Divide and Conquer). 不斷把陣列對半切，直到每個子陣列只剩 1 個元素。然後再一一將兩個有序陣列「合併」成一個有序陣列。

什麼時候用？ 需要穩定排序且時間複雜度穩定在 O(n log n) 的場合，例如處理鏈結串列、外部排序（待排資料超過記憶體大小）。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void merge(vector<int>& arr, int l, int m, int r) {
    vector<int> L(arr.begin() + l, arr.begin() + m + 1);
    vector<int> R(arr.begin() + m + 1, arr.begin() + r + 1);
    int i = 0, j = 0, k = l;
    while (i < L.size() && j < R.size()) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    while (i < L.size()) arr[k++] = L[i++];
    while (j < R.size()) arr[k++] = R[j++];
}

void mergeSort(vector<int>& arr, int l, int r) {
    if (l >= r) return;
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

int main() {
    vector<int> v = {38, 27, 43, 3, 9, 82, 10};
    mergeSort(v, 0, v.size() - 1);
    for (int x : v) cout << x << " ";
}

🟡 Quick Sort（快速排序）

核心思想：挑一個 Pivot（基準點），把所有比 Pivot 小的元素放到左邊，比 Pivot 大的放到右邊。然後遞迴對左右兩側重複這個動作。

什麼時候用？ 這是實際最常用的排序法。std::sort 的底層 (IntroSort) 即是以 Quick Sort 為核心。平均 O(n log n)，且記憶體使用效率高（In-place）。

⚠️ 坑點：如果每次都選最小/最大值當 Pivot，退化成 O(n²)。實務上要用亂數選 Pivot 或三數取中來避免。

C++ 競程寫法（推薦用 std::sort）：

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

#include <bits/stdc++.h>
using namespace std;

// 競程直接用 std::sort，底層已是 IntroSort (Quick+Heap+Insertion)
int main() {
    vector<int> v = {10, 7, 8, 9, 1, 5};
    sort(v.begin(), v.end()); // 升冪
    sort(v.begin(), v.end(), greater<int>()); // 降冪

    // 自訂排序
    sort(v.begin(), v.end(), [](int a, int b) {
        return a % 3 < b % 3; // 按模 3 餘數升冪
    });
}

// 手刻版本（理解用）
int partition(vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) swap(arr[++i], arr[j]);
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

🟡 Heap Sort（堆積排序）

核心思想：利用 Max-Heap（最大堆積） 這種資料結構。先把陣列建成 Max-Heap，然後每次把堆頂（最大值）取出放到末端，再對剩下的部分重新整理成 Heap，重複直到結束。

什麼時候用？ 當你需要 O(n log n) 且 O(1) 空間複雜度的穩定效能（Quick Sort 最差退化，Merge Sort 需要額外空間）。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

// 競程中 priority_queue 就是一個 Max-Heap
int main() {
    priority_queue<int> maxHeap;
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    for (int x : v) maxHeap.push(x);

    vector<int> sorted;
    while (!maxHeap.empty()) {
        sorted.push_back(maxHeap.top());
        maxHeap.pop();
    }
    reverse(sorted.begin(), sorted.end());
    for (int x : sorted) cout << x << " ";
}

// 手刻 Heap Sort
void heapify(vector<int>& arr, int n, int i) {
    int largest = i, l = 2*i+1, r = 2*i+2;
    if (l < n && arr[l] > arr[largest]) largest = l;
    if (r < n && arr[r] > arr[largest]) largest = r;
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = n/2-1; i >= 0; i--) heapify(arr, n, i);
    for (int i = n-1; i > 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

🔵 Counting Sort（計數排序）

核心思想：不靠「比較」來排序！先統計每個數字出現幾次，再依序填回陣列。

限制條件：只適用於整數，且數值範圍 k 不能太大（k = max - min），因為需要建立大小為 k 的計數陣列。

什麼時候用？ 數字範圍明確且較小時（例如成績 0100、字元 0255、APCS 中 N ≤ 10⁶ 且值域為 0~10⁶）可達到 O(n+k) 的速度，比比較式排序更快。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void countingSort(vector<int>& arr) {
    if (arr.empty()) return;
    int maxVal = *max_element(arr.begin(), arr.end());
    int minVal = *min_element(arr.begin(), arr.end());
    int range = maxVal - minVal + 1;

    vector<int> count(range, 0);
    for (int x : arr) count[x - minVal]++;

    int idx = 0;
    for (int i = 0; i < range; i++) {
        while (count[i]-- > 0) arr[idx++] = i + minVal;
    }
}

int main() {
    vector<int> v = {4, 2, 2, 8, 3, 3, 1};
    countingSort(v);
    for (int x : v) cout << x << " ";
    // Output: 1 2 2 3 3 4 8
}

結論

💡 競程中 99% 的排序直接用 sort() 就夠了。理解底層邏輯的意義在於：當題目限制特殊時，你才知道挑哪把刀。

🔴 Bubble Sort（氣泡排序）

核心思想：每輪把相鄰的兩個元素互比，如果左邊比較大就交換。這樣最大數字會像泡泡一樣「浮」到最右端，然後一直縮小範圍重複這個動作。

什麼時候用？ 幾乎不用於實戰，但因為邏輯最直覺，是學習演算法的起點。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break; // 優化：提早結束
    }
}

int main() {
    vector<int> v = {64, 34, 25, 12, 22, 11, 90};
    bubbleSort(v);
    for (int x : v) cout << x << " ";
}
// Output: 11 12 22 25 34 64 90

🔴 Selection Sort（選擇排序）

核心思想：每一輪從「尚未排序的部分」找出最小值，然後跟最前面的元素交換。每輪確定一個位置正確的元素。

注意：Selection Sort 永遠執行 O(n²) 次比較，無論資料本身是否已排序，這是它的最大缺點。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void selectionSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        swap(arr[i], arr[minIdx]);
    }
}

🔴 Insertion Sort（插入排序）

核心思想：想像左手拿著已排好的牌，右手每次從右邊抽一張，然後插進左手牌堆的正確位置。

什麼時候用？ 資料已接近排序完成時（nearly sorted），時間複雜度接近 O(n)！在 std::sort 的 IntroSort 實作中，當子陣列縮到小於 16 個元素時，會切換為 Insertion Sort。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void insertionSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

🟡 Merge Sort（合併排序）

核心思想：分治法 (Divide and Conquer). 不斷把陣列對半切，直到每個子陣列只剩 1 個元素。然後再一一將兩個有序陣列「合併」成一個有序陣列。

什麼時候用？ 需要穩定排序且時間複雜度穩定在 O(n log n) 的場合，例如處理鏈結串列、外部排序（待排資料超過記憶體大小）。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void merge(vector<int>& arr, int l, int m, int r) {
    vector<int> L(arr.begin() + l, arr.begin() + m + 1);
    vector<int> R(arr.begin() + m + 1, arr.begin() + r + 1);
    int i = 0, j = 0, k = l;
    while (i < L.size() && j < R.size()) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    while (i < L.size()) arr[k++] = L[i++];
    while (j < R.size()) arr[k++] = R[j++];
}

void mergeSort(vector<int>& arr, int l, int r) {
    if (l >= r) return;
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

int main() {
    vector<int> v = {38, 27, 43, 3, 9, 82, 10};
    mergeSort(v, 0, v.size() - 1);
    for (int x : v) cout << x << " ";
}

🟡 Quick Sort（快速排序）

核心思想：挑一個 Pivot（基準點），把所有比 Pivot 小的元素放到左邊，比 Pivot 大的放到右邊。然後遞迴對左右兩側重複這個動作。

什麼時候用？ 這是實際最常用的排序法。std::sort 的底層 (IntroSort) 即是以 Quick Sort 為核心。平均 O(n log n)，且記憶體使用效率高（In-place）。

⚠️ 坑點：如果每次都選最小/最大值當 Pivot，退化成 O(n²)。實務上要用亂數選 Pivot 或三數取中來避免。

C++ 競程寫法（推薦用 std::sort）：

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

#include <bits/stdc++.h>
using namespace std;

// 競程直接用 std::sort，底層已是 IntroSort (Quick+Heap+Insertion)
int main() {
    vector<int> v = {10, 7, 8, 9, 1, 5};
    sort(v.begin(), v.end()); // 升冪
    sort(v.begin(), v.end(), greater<int>()); // 降冪
    
    // 自訂排序
    sort(v.begin(), v.end(), [](int a, int b) {
        return a % 3 < b % 3; // 按模 3 餘數升冪
    });
}

// 手刻版本（理解用）
int partition(vector<int>& arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) swap(arr[++i], arr[j]);
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

🟡 Heap Sort（堆積排序）

核心思想：利用 Max-Heap（最大堆積） 這種資料結構。先把陣列建成 Max-Heap，然後每次把堆頂（最大值）取出放到末端，再對剩下的部分重新整理成 Heap，重複直到結束。

什麼時候用？ 當你需要 O(n log n) 且 O(1) 空間複雜度的穩定效能（Quick Sort 最差退化，Merge Sort 需要額外空間）。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

// 競程中 priority_queue 就是一個 Max-Heap
int main() {
    priority_queue<int> maxHeap;
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    for (int x : v) maxHeap.push(x);

    vector<int> sorted;
    while (!maxHeap.empty()) {
        sorted.push_back(maxHeap.top());
        maxHeap.pop();
    }
    // sorted 是降冪，反轉後得升冪
    reverse(sorted.begin(), sorted.end());
    for (int x : sorted) cout << x << " ";
}

// 手刻 Heap Sort
void heapify(vector<int>& arr, int n, int i) {
    int largest = i, l = 2*i+1, r = 2*i+2;
    if (l < n && arr[l] > arr[largest]) largest = l;
    if (r < n && arr[r] > arr[largest]) largest = r;
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = n/2-1; i >= 0; i--) heapify(arr, n, i);
    for (int i = n-1; i > 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

🔵 Counting Sort（計數排序）

核心思想：不靠「比較」來排序！先統計每個數字出現幾次，再依序填回陣列。

限制條件：只適用於整數，且數值範圍 k 不能太大（k = max - min），因為需要建立大小為 k 的計數陣列。

什麼時候用？ 數字範圍明確且較小時（例如成績 0100、字元 0255、APCS 中 N ≤ 10⁶ 且值域為 0~10⁶）可達到 O(n+k) 的速度，比比較式排序更快。

C++ 競程寫法：

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

#include <bits/stdc++.h>
using namespace std;

void countingSort(vector<int>& arr) {
    if (arr.empty()) return;
    int maxVal = *max_element(arr.begin(), arr.end());
    int minVal = *min_element(arr.begin(), arr.end());
    int range = maxVal - minVal + 1;
    
    vector<int> count(range, 0);
    for (int x : arr) count[x - minVal]++;
    
    int idx = 0;
    for (int i = 0; i < range; i++) {
        while (count[i]-- > 0) arr[idx++] = i + minVal;
    }
}

int main() {
    vector<int> v = {4, 2, 2, 8, 3, 3, 1};
    countingSort(v);
    for (int x : v) cout << x << " ";
    // Output: 1 2 2 3 3 4 8
}

結論

💡 競程中 99% 的排序直接用 sort() 就夠了。理解底層邏輯的意義在於：當題目限制特殊時，你才知道挑哪把刀。

今天是平安夜。
這篇文章，當作我送給所有正在準備、或即將踏上特殊選才這條路的學弟妹的一份聖誕禮物。

沒有雞湯，沒有過度美化，
只有一個真實走過 115 資工特選的人，把一路上的現實、心態崩潰與轉彎，完整寫下來。

如果你現在也正在等結果、懷疑自己，
希望這篇能讓你知道：你不是唯一一個撐得很辛苦的人。

📊 115特殊選才報名學校與結果 (沒人權了)

• 清大 刷掉
• 交大 刷掉
• 成大 備取
• 中央 刷掉
• 中興 正取
• 暨南 備取(備上放棄)
• 高師 正取(放棄)
• 逢甲 備取(備上放棄)

放榜前的真實心態：其實真的很難撐

老實說，在特殊選才放榜前那段時間，我的心態非常不穩。

不是因為我沒準備，而是「連續被一階刷掉」這件事，本身就很消耗人。
很多學校連二階都沒進，只在系統上看到一句冷冰冰的「未通過」，卻不知道問題到底出在哪裡。

那段時間，我反覆出現這些念頭：

• 是不是我高估了自己？
• 是不是我做的專題其實根本不被看重？
• 是不是走特殊選才，本來就是一個錯誤？

即使理性上知道「資工特選本來就極度競爭」，
但當結果一次又一次出來，要保持冷靜，其實非常困難。

一階篩選帶來的現實感

這次特殊選才，讓我非常清楚地感受到一件事：

資工相關科系的一階門檻，真的非常高。

不論你做過多少專題、寫過多少程式，只要在量化指標上沒有站在前段班——
例如 APCS 成績、資奧相關經歷、或是非常亮眼的全國競賽名次，
很多學校在第一階段就會直接刷掉。

這不代表你不努力，也不代表你沒能力，
而是資工特選的競爭，本來就集中在極少數頂尖背景的人身上。

心態調整：我到底在證明什麼？

在那段每天都在等結果的時間裡，我後來逼自己冷靜下來，問了自己一個問題：

我是想證明自己，還是真的想找一個能繼續累積能力的地方？

想清楚之後，心態反而慢慢穩定下來。
我開始接受「不是每一條路都一定要從資工系開始」，
也開始認真去看課程結構，而不是只盯著系名。

給想走資工特殊選才的一句實話

這是我親身走過後，非常真心的一段建議。

如果你 沒有 APCS 4 級分以上，
也 沒有資奧或非常亮眼的全國競賽背景，
想走資工特殊選才，真的要有非常強的心理準備。

這條路不只競爭激烈，
而是會長時間消耗你的心態與自信。

如果你的條件比較接近學測體制，
乖乖準備學測，未必是比較差的選擇。

📄 三折頁真的大加分

這一點我一定要特別說。

三折頁在二階面試時，真的非常加分。

它可以幫教授在極短時間內：

• 快速理解你的背景
• 記住你這個人
• 面試時更有依據提問

很多教授其實會一邊翻、一邊問，
有準備三折頁，真的差很多。

🎤 面試時，一定要注意的細節

再來是面試當下的「做人基本功」，但很多人會忽略。

• 一定要等教授講完話再回答
• 即使教授講話慢、時間有限，也請體諒
• 記得你面對的是長輩與學者，不是比賽評審

我知道你可能會很緊張、很想把話一次講完，
但禮貌與態度，本身就是評分的一部分。

Discord 群組：非常重要的自我定位工具

如果你未來有打算走特殊選才，
我真的非常推薦一定要進入特殊選才相關的 Discord 群組。

你會看到來自不同學校、不同領域的強者，
很多人真的是所謂的「電神」。

但也正因為如此，你會更清楚知道：

• 自己大概落在哪個區間？
• 要不要 all in？
• 還是該保留退路？

這個自我定位，比盲目投入還重要。
Discord 群組連結

關於 all in 與退路

我一開始，其實是打算 all in 特殊選才。

但隨著一間又一間學校在一階被刷掉，
心態真的會開始動搖。

後來我選擇把心態調整回來，同步準備學測。
但老實說，大概到十一月才全力拉回學測，其實已經非常困難。

如果你要 all in，請非常清楚風險；
如果要保留退路，請越早開始越好。

不要省特殊選才的錢

這件事很現實，但一定要說。

整個特殊選才下來，報名費大約 1～1.5 萬元。
這不是一個小數目。

我很感謝家裡、尤其是媽媽，一直支持我嘗試。
沒有這份支持，其實很可能中途就被迫停下來。

特殊選才，不只是學生一個人的事，
而是整個家庭一起承擔風險。

結語

回頭看這段特殊選才的過程，我不會說它輕鬆，
但我也不後悔。

它讓我很清楚地看見自己的位置，
也讓我學會在不理想的結果裡，重新為自己做選擇。

最後進入 中興大學應用數學系（數據科學與計算組），
對我來說不是退而求其次，
而是一個重新出發的起點。

如果你正在這條路上，
希望你能撐住，
也希望你不要因為一時的結果，否定整個努力的自己。

我之後會發各校有進入面試的心得感想喔!

🎄 平安夜，祝你聖誕快樂。

這篇文章紀錄我在 2025 AIS3 Junior 中的學習歷程，從基礎 Web 題目開始，一路接觸到前端 XSS 與後端常見漏洞（PHP、SQL Injection、SSRF 等）。

這份內容除了當下的解題紀錄，也整理了我對每一類題目的理解與反思，作為自己之後複習 Web Security 與 CTF 的學習筆記。

一、基礎 Web 題目：培養觀察力

GET aHEAD — HTTP Method 的差異

這題讓我第一次明確感受到，HTTP Method 本身就可能是漏洞來源。

我使用 Burp Suite 攔截請求，將原本的 POST 改成 HEAD，結果在回應標頭中直接看到 flag。

1

HEAD /index.php HTTP/1.1

這題讓我學到：
有些伺服器會把敏感資訊放在 header，而 HEAD 請求因為不回傳 body，反而更容易被忽略。

Cookies — 修改 Cookie value

在瀏覽器中開啟 F12 → Application → Cookies，可以直接修改 Cookie 的 value。這題透過不斷嘗試不同數值，最後在特定值時直接顯示 flag。

這提醒我：
只要沒有在後端驗證，Cookie 就永遠不能被信任。

Inspect HTML / Web Inspector

這幾題都圍繞在一個核心概念：

使用者看到的畫面，往往只是實際 HTML 與 DOM 的一小部分。

包含：

• HTML 註解中藏 flag
• DOM 深層節點藏 Base64 編碼字串
• 將 Base64 解碼後取得 flag

也再次驗證了一件事：Web 題目一定要先打開 F12 看一輪。

二、Linux 基礎操作：CTF 的基本功

在 Linux 題目中，大多數考的不是複雜技巧，而是對基本指令的熟悉度，例如：

• ls -la：查看隱藏檔案
• cat：讀取檔案內容
• touch：建立檔案
• mv：移動檔案
• rm：刪除檔案

這些指令看似簡單，但在 CTF 中就是最重要的「肌肉記憶」。

三、前端題目：XSS 攻擊實作

Stored XSS — Note Sharing

當使用者輸入的內容沒有經過過濾就被直接渲染成 HTML，就可能導致 Stored XSS。

透過插入 <script>，確認可以執行 JavaScript 後，再將 cookie 透過 fetch 傳送到自己的 webhook。

這類題目讓我清楚理解：
只要惡意內容會被存起來並再次顯示，就有機會影響其他使用者。

DOM XSS — innerHTML

這題使用 innerHTML 將使用者輸入直接插入 DOM，導致事件屬性（如 onerror）仍可執行。

即使不能直接使用 <script>，仍可以透過圖片錯誤事件來觸發 JavaScript。

javascript: URL 與 <base> 利用

在某些題目中，使用者輸入會被放入按鈕連結或相對路徑中：

• javascript: URL 可在點擊時執行程式碼
• <base> 標籤可以改變整個頁面的相對路徑解析方式

這些技巧讓我理解到：
XSS 不只存在於 <script>，而是存在於所有「可被解譯的位置」。

四、後端漏洞：邏輯錯誤比技巧更重要

PHP 鬆散比較（Loose Comparison）

透過陣列傳參，讓 strcmp 與 md5 發生型別錯誤回傳 null，再搭配鬆散比較 (==) 繞過條件判斷。

這類題目不需要高深技巧，只要理解 PHP 的型別系統就能突破。

檔案上傳與 WAF 繞過

利用：

• 偽造 Content-Type
• 副檔名大小寫差異（.phP）

即可繞過簡單檢查並成功上傳可執行檔案。

LFI、SQL Injection 與 SSRF

後端題目涵蓋：

• 路徑回跳繞過白名單
• include() 導致的 LFI 轉 RCE
• UNION-based SQL Injection
• 利用 open redirect 繞過 SSRF 主機名檢查

這些題目讓我最大的收穫是：
很多漏洞並不是因為少了 WAF，而是因為「邏輯假設錯誤」。

收穫與反思

這次 2025 AIS3 Junior 對我來說，不只是解題，而是一個完整的 Web Security 入門體驗。

我學到的關鍵包括：

• 永遠不要相信使用者輸入
• 前端與後端的每一個假設，都可能成為漏洞
• 比起背 payload，更重要的是理解程式怎麼「想錯了」

這些經驗也讓我更確定，未來想繼續往資安與系統安全方向深入學習。

Apache 是什麼？模組是幹嘛？

Apache 是高度模組化的 Web 伺服器；處理一個 HTTP 請求時，很多模組會共同讀寫 request_rec 的欄位（如 r->filename、r->args）。不同模組對同一欄位的「語意」若不一致，就可能誤判。Orange Tsai 的研究把這些不一致系統化，歸納出三大類 Confusion 攻擊，其中之一就是 Filename Confusion。

Filename Confusion 的核心：

多個模組對 r->filename 的理解不同——有的把它當檔案路徑，有的把它當URL。這種不一致會造成安全問題。

關鍵：URL 編碼 %3F

• 在網址裡 ? 代表「後面是 query string」。
• 如果要在網址中表示字面上的 ?，需要 URL 編碼：? → %3F。
• Apache 在不同處理階段可能把 %3F 解回 ?，這就是漏洞能被利用的時機差。

1. RewriteRule（mod_rewrite）

RewriteRule 是 mod_rewrite 用來改寫 URL的指令。語法：

1

RewriteRule Pattern Substitution [Flags]

• Pattern（樣式）：正則表達式，用來比對目前請求的 URL 路徑。
• Substitution（替換結果）：匹配後要改到哪裡（可為檔案路徑或 URL）。可用 $1、$2 這類反向引用插入 Pattern 抓到的內容。
• Flags（旗標，可選）：放在 [] 內，調整這條規則的行為，例如：

L：命中後停止再處理後續規則（Last）。
QSA：保留原始 query string 並附加到新 URL。
H=…：指定處理器（Handler），例如 H=application/x-httpd-php。

小例子（Pattern / Substitution / Flags）

想把 https://example.com/user/orange 對應到伺服器檔案 /var/www/user/orange/profile.yml：

1
2

RewriteEngine On
RewriteRule "^/user/(.+)$" "/var/www/user/$1/profile.yml"

• Pattern：^/user/(.+)$ 會抓到 /user/ 後面的使用者名稱到 $1。
• Substitution：/var/www/user/$1/profile.yml → 例如 $1=orange 就是 /var/www/user/orange/profile.yml。
• 這裡沒寫 Flags，使用預設行為。

1‑1-1 Path Truncation（路徑截斷）

成因：

mod_rewrite 在套用 RewriteRule 後，會把替換結果當「URL」處理，呼叫 splitout_queryargs() 把 ? 後的部分視為 query 分離。當替換結果其實是檔案路徑時，還是會被「當 URL 來切」，於是產生可控截斷。

1
2
3
4

RewriteEngine On
RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
# 攻擊請求（%2F = /, %3F = ?）
# /user/orange%2Fsecret.yml%3F  → 讀到 /var/user/orange/secret.yml

因為 %3F 在後續階段被視為 ?，/profile.yml 被當作 query 切掉了。

splitout_queryargs() 在幹嘛？

它把替換結果中的 ? 後段剝離到 r->args（query），? 前面留在 r->filename：

1
2
3

r->filename = "/var/user/orange/profile.yml?debug=1"
               └─── 路徑 ───┘ └─ query ─┘
r->args     = "debug=1"   ← 被 splitout_queryargs() 剝出去

1‑1‑2 Mislead RewriteFlag Assignment（誤導旗標設定）

利用點：

先 Pattern 比對 → 套 Flags → 再把結果當 URL 拆 query。

在比對階段使用 %3F（編碼的 ?）讓請求看起來像是 .php，使規則套上不該有的 Flag（例如指定 PHP Handler）。等到拆 query之後，實際要處理的檔案變回 .gif，但 Flag 不會被移除，導致圖片被當作 PHP 來跑。

規則長這樣

1
2

RewriteEngine On
RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php]

攻擊步驟

1. 上傳看似普通的圖片 /upload/1.gif，實際內容藏有 PHP
   例如：

   1	<?php echo shell_exec('id'); ?>

2. 送出請求：

   1	/upload/1.gif%3Faaa.php

3. Pattern 比對：%3F 尚未解碼，/upload/1.gif%3Faaa.php 尾端看起來是 .php → 命中 → 套上 H=application/x-httpd-php。

4. 拆 query：%3F 解為 ?，?aaa.php 被分離到 r->args，留下 /upload/1.gif。

5. 實際處理：雖然是 .gif，但已指定 PHP Handler → 由 PHP 執行圖片內的程式碼。

對照表

1-2. ACL（Access Control List）與 <Files> / PHP‑FPM

要先了解以下三個角色:

• mod_proxy：代理模組，負責把請求轉送到別的服務。

mod_proxy_fcgi：把請求用 FastCGI 協定轉給 PHP‑FPM。

• PHP‑FPM：PHP FastCGI Process Manager，Apache 把 .php 請求交給它執行。
• <Files>（ACL）：針對「檔案名稱」設定限制，例如特定檔案需登入才可訪問。

常見把 .php 交給 PHP‑FPM 的做法

1
2
3

<FilesMatch ".+\.ph(?:ar|p|tml)$">
  SetHandler "proxy:unix:/run/php/php8.2-fpm.sock|fcgi://localhost"
</FilesMatch>

意思是：

遇到 .php、.phtml… 就不要由 Apache 直接讀檔，而是交給 mod_proxy_fcgi → PHP‑FPM。

1‑2-1 ACL Bypass（存取控制繞過）

情境：用 <Files> 來保護單一檔案，例如：

1
2
3
4
5
6

<Files "admin.php">
  AuthType Basic
  AuthName "Admin Panel"
  AuthUserFile "/etc/apache2/.htpasswd"
  Require valid-user
</Files>

正常流程（安全）

1. 請求 /admin.php。
2. ACL 檢查：r->filename = admin.php → 命中 <Files "admin.php"> → 要求驗證。
3. 驗證通過後，交給 PHP‑FPM 執行 admin.php。

漏洞流程（繞過）

1. 請求：/admin.php%3Fooo.php（%3F 是 ?）

2. ACL 檢查：此時尚未解碼 → r->filename = admin.php%3Fooo.php，不等於 admin.php → 不要求驗證。

3. SetHandler 命中：仍視為 .php → 交給 mod_proxy_fcgi。

4. mod_proxy_fcgi 轉交：把 r->filename 改寫為：

   1	proxy:fcgi://127.0.0.1:9000/var/www/html/admin.php?ooo.php

5. PHP‑FPM 行為：

• 去掉 proxy:fcgi://… 前綴與主機資訊，只留 /var/www/html/admin.php?ooo.php。
• 找到第一個 ?，截斷為 /var/www/html/admin.php。
• 實際執行 admin.php。

6. 結果：受保護的 admin.php 被直接執行，完全跳過 ACL。

對照表

受影響的常見保護寫法（都可能被 %3F 打穿）：

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

<Files "php-info.php">   
Require ip 127.0.0.1   
</Files>

<Files "adminer.php">    
Deny from all          
</Files>

<Files "xmlrpc.php">     
Deny from all          
</Files>

<Files "cron.php">       
Deny from all          
</Files>

修補辦法

• 升級 Apache 至 2.4.60+：新版本把舊有危險行為改為預設拒絕；請勿開啟 RewriteOptions UnsafeAllow3F（除非完全理解風險）。
• 避免用 <Files> 保護單一 PHP 檔（在 PHP‑FPM 架構下）。改用 <Location> / <LocationMatch>（比對 URL 而非檔名），或把敏感腳本移出 DocumentRoot，只透過應用層載入。
• Rewrite 規則審視：不要讓「使用者可控片段」直接拼到檔案路徑；能用 mod_alias（Alias/Redirect）就避免過度使用 mod_rewrite 做檔案映射。
• 監控與偵測：

• 日誌尋找可疑編碼：%3F、%2F；
• 特別是「非 .php 路徑 + %3F...php」的請求模式；
• 除錯時可暫時開 LogLevel rewrite:trace2 觀察改寫流程（完畢務必關閉）。

誤區／備註

• 不是「PHP Handler 會神奇多做什麼」，而是被錯誤套用到不該由 PHP 處理的檔案上。
• %3F 的解碼與處理發生在不同階段；理解「哪一步解、何時解」是這類漏洞的核心。
• 範例程式碼僅用於安全測試與理解機制，請勿在生產環境或未授權系統操作。

文獻來源:Orange Tsai (Orange Tsai)

GitHub 連結

🧩 系統原理與架構

本系統以 Python Flask 為後端主體，結合 Arduino 控制投幣與硬體訊號，並透過熱感應印表機完成現場列印。流程自動化，並以 ngrok 實現公網穿透，讓手機可即時上傳照片。

主要流程

1. 投幣啟動：使用者投幣 40 元，投幣機將訊號傳給 Arduino，Arduino 透過序列埠（Serial）傳送 coin_ok 訊號給主機。
2. QRCode 產生與列印：主機收到訊號後，產生唯一 Token 與專屬上傳網址，並生成 QRCode 票券（含說明、Logo、簽名等），自動列印並切紙。
3. 照片上傳與模板選擇：使用者掃描 QRCode，進入網頁上傳照片並選擇拍貼模板，支援即時預覽與互動。
4. 列印成品：完成後自動將美編照片傳送至印表機列印，現場立即取件。

🔌 技術整合

• Flask 網站系統：提供照片上傳、模板選擇、即時預覽與互動介面。
• 印表機控制：支援多台印表機（如 Xprinter、EPSON），可自動裁切。
• Arduino 投幣與列印指令：硬體負責投幣偵測、列印流程控制與狀態回饋。
• 多種主題模板 + 圖層疊加處理：支援多款拍貼模板，並可自訂圖層與特效。
• 自動 QRCode 產生與票券設計：每次投幣自動產生專屬 QRCode，票券含說明、簽名、直橫排文字、Logo。
• ngrok 公網穿透：自動啟動 ngrok，讓外部手機可連線上傳照片。
• Token 防重複機制：每張票券唯一 Token，防止重複上傳與列印。
• 多執行緒與序列通訊：背景監控硬體訊號，並確保 Token 持久化與執行緒安全。

🛠️ 系統架構

• 前端：RWD 響應式網頁（HTML/CSS/JavaScript），支援手機掃描 QRCode 操作。
• 後端：Python Flask，負責 API、圖片處理、列印指令下發。
• 硬體：Arduino（投幣、訊號控制）、熱感應印表機、顯示模組。
• 通訊：USB/Serial 連接 Arduino 與印表機，HTTP 通訊前後端，ngrok 公網穿透。

⚡ Arduino 與投幣機連接與偵測原理

• 投幣機：將投幣訊號（透過上拉電阻完成脈衝偵測）連接至 Arduino 數位輸入腳位。
• Arduino 程式：偵測到投幣訊號後，透過 Serial（如 COM7, 9600 baud）傳送 coin_ok 給主機。
• 主機（Flask）：背景執行緒監控 Serial 埠，收到 coin_ok 後自動產生 QRCode 並列印，可回傳狀態訊息給 Arduino。
• 安全防呆：主機會記錄 Token，防止重複上傳、重複列印，異常時自動復原。

連接示意圖

graph TD;    A[投幣機] -- 投幣訊號 --> B("Arduino");    B -- "Serial (coin_ok)" --> C["主機 (Flask)"];    C -- QRCode 產生與列印 --> D[熱感應印表機];    D -- 列印完成 --> C;    C -- 狀態回傳 --> B;    B -- 控制訊號 --> A;

📂 主要檔案結構

1
2
3
4
5
6
7
8
9

.
├── app.py               # Flask 主程式
├── config.py            # 主程式設定
├── static/              # 前端網頁
│   ├── simulate_coin_page.html    # 管理端頁面
│   ├── upload.html       # 上傳照片頁面
├── templates/           # 模板圖層
├── qr_codes/            # QRCode 票券
├── uploads/             # 上傳照片

🚀 特色與未來規劃

• 支援多模板、動態特效與自訂票券頁面
• 可加入雲端備份與下載功能
• 多語系介面
• 優化列印速度與美編演算法
• 增加現場狀態顯示與錯誤自動復原