LordCasser►LTF

记sqlmap的安装

本来一切正常，我的电脑也安装 了python2.7，按理说是没什么问题的。 可是当我启动sqlmap的时候出现了这种情况。？？？（黑人问号脸） 无论输入什么都判断为退出。？？？（再次问号脸） 以下是解决方案： 将sqlmap文件夹丢到C盘下python27文件夹中 找到sqlmap.py 并创建快捷方式 然后就可以了

LordCasser►LTF

记一次对钓鱼网站的渗透

怎么说呢 一开始我从一个群里看到了钓鱼网站 然后抱着试一试的心态去查后台 结果查到了，特别激动 试着注入，发现有回显，判断有漏洞 结果自己智障了，用了万能用户名忘了输密码，注入失败 被学长@Mio-web提点才发现 进入后台发现安全极差，记录的用户密码全部明文保存，我默默地删掉的 而且任何人都可以删除或创建管理员 我把管理员换掉了 网站通过几个人（网站称广告手）到各个地方发链接诱骗人点击并登陆QQ 每个人发的网址有不同的id后台记录每个人推广数（估计用来提成的） 网页是这样的（上方的提示是后台的截图不是克隆网站的）克隆得特别像 涉及一个左手倒影的人 这个人申明是这样 但是却真的在收集QQ 截止到我删除，这个网站一天之间收集了百多个QQ和密码 神TM居然明文保存 好像他还做了各种腾讯游戏的克隆网站都是同一个IP 所以我推测这个服务器就是个钓鱼服务器 但是他服务器的8888端口好像有防爆破，会记录IP，同一个IP只能试五次 又发现好像是本地验证，可以试试burpsuite挂代理抓包改包 那么问题来了,burpsuite 英文界面实在不友好 所以我滚去学习了 以后有再补充 P.S. 这估计是中国互联网诈骗黑产的一角

LTF►漏断

VMware Workstation Pro12+Kali2017.3安装记录

之前一直用开源的virtual box，但因为使用kali时有诸多不便，总算下决心装了VMware workstation14，结果kali开机黑屏，网上虽然有解决方案，但不想再麻烦了。刚好有VMware Workstation Pro 12的安装包，就试了一下，效果出奇的好（或许是笔记本有16G内存的缘故吧），简单记录下安装流程，以供将来参考。

  1. 到kali官网下载了2017.3的torrent文件，用迅雷下载镜像文件。
  2. 安装VMware Workstation Pro 12 。
  3. 管理员权限运行虚拟机软件，新建虚拟机。
  4. 系统选的debian7 x64，分配30G硬盘，4G内存。
  5. 启动虚拟机，图形化安装系统。
  6. 重启，进入系统。
  7. 工具栏中有安装VM tools选项，下载安装，参考了一下http://www.linuxidc.com/Linux/2016-04/130807.htm，因为没有安装中文输入法，所以在cd目录的时候需要到目录的属性里去复制，安装好后重启。
  8. 根据https://www.cnblogs.com/superye/p/7277699.html进行更新，安装常用软件。
  9. 重启，拍摄一张快照，以备不时之需。
LTF►漏断

正则补充

之前PHP笔记里的正则表达式部分略有不足（致命缺陷[滑稽]），在此进行一些补充，分为19点，当做备忘。主要来源于《正则表达式30分钟入门教程》，可以到http://deerchao.net/tutorials/regex/regex.htm查阅详细内容。

  1. \b匹配这样的位置：它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)\w
  2. \d匹配一个数字
  3. \w匹配字母或数字或汉字或下划线
  4. {n,}重复n次或更多。{n,m}重复n到m次
  5. 分支条件|，注意各条件顺序。匹配分枝条件时，将会从左到右地测试每个条件，如果满足了某个分枝的话，就不会去再管其它的条件了。所以要把匹配较长、成立难度大的放在前面。如：\d{5}|\d{5}-\d{4}只会匹配前五个数字。
  6. 反义。大写与小写反义，如\b与\B,\w与\W。另：[^x]匹配除x以外的任意字符[^dsafl]匹配除dsafl外的任意字符。例：<a[^>]+>匹配用尖括号括起来的以a开头的字符串。
  7. 向后引用。每个分组（）会自动分配组号，0表示整个表达式，1表示第一个（），以此类推。例：\b(\w+)\b\s+\1\b可匹配重复的单词。
  8. 指定表达式组名。语法：(?\w+)或(?‘Word’\w+)，反向引用这个分组捕获的内容，可用\k。例：\b(?\w+)\b\s+\k\b可匹配重复的单词。
  9. （?:exp)匹配，但不捕获，也不分配组号。(?#comment)注释，不产生任何影响。
  10. 零宽度正预测先行断言：（？=exp)断言自身出现的位置的后面能匹配表达式exp。例：\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)。
  11. 零宽度正回顾后发断言：（?<=exp)断言自身出现的位置的前面能匹配表达式exp。例：(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)。
  12. 注意：零宽断言只匹配一个位置，不消费任何字符！假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=\d)\d{3})+\b，用它对1234567890进行查找时结果是234567890。
  13. 零宽度负预测先行断言：（?!exp)断言此位置的后面不能匹配表达式exp。例：\d{3}(?!\d)匹配三位数字，而且这三位数字的后面不能是数字。
  14. 零宽度负回顾后发断言：（?<!exp)断言此位置的前面不能匹配表达式exp。例：(?<![a-z])\d{7}匹配前面不是小写字母的七位数字。
  15. 一个更能体现零宽断言真正用途的例子：(?<=<(\w+)>).*(?=<\/\1>)匹配不包含属性的简单HTML标签内里的内容。(?<=<(\w+)>)指定了这样的前缀：被尖括号括起来的单词(比如可能是)，然后是.*(任意的字符串),最后是一个后缀(?=<\/\1>)。注意后缀里的\/，它用到了前面提过的字符转义；\1则是一个反向引用，引用的正是捕获的第一组，前面的(\w+)匹配的内容，这样如果前缀实际上是的话，后缀就是了。整个表达式匹配的是和之间的内容(再次提醒，不包括前缀和后缀本身)。
  16. 零宽断言的个人总结：“零宽”表示只匹配位置，不消费字符；“正”表示存在，用“=”，“负”表示不存在用“！”；“预测先行”看后面，“回顾后发”看前面，用”<”。
  17. 默认贪婪匹配。在次数标识符后面加“？”表示懒惰匹配。贪婪匹配尽量多的字符，懒惰匹配尽量少
  18. 注意：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。此原则高于贪婪/懒惰规则。
  19. 关于平衡组和递归匹配，只能勉强看懂，根本不会用，放一个例子就溜了。例：匹配嵌套的
    标签：<div[^>]*>[^<>]*(((?’Open’<div[^>]*>)[^<>]*)+((?’-Open’
    )[^<>]*)+)*(?(Open)(?!))。
LTF►XLor

Othello UVa220

Times: 3 hrs 这种棋啊什么玩意的题目是真的烦，情况没考虑好就要WA，而且对于我这种弱鸡代码写的非常冗余。 本题输出有很多坑，uDebug调试AC后，竟然还是WA。 无奈拿着这个代码自己和自己下黑白棋，最后无意间发现在边界的时候会有迷之吃子。 虽然分析代码后，发现问题不大？还是最后加了宏is进行判断，终于AC。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
#include <cstdio>
#include <cstring>
#define is(x) x>=1&&x<=8
using namespace std;
char map[10][10] = { '\0' };
char f(char x)
{
	if (x == 'W')
		return 'B';
	else
		return 'W';
}
int isPlace(int tot, int x, int y, int t)//tot代表当前回合玩家,xy为目标点位
{
	if (map[x][y] != '-')
		return 0;

	int flag[10] = { 0 };
	char oth = f(tot);//表示对手

	flag[0] = (map[x][y + 1] == oth) && y + 1 <= 8;
	flag[1] = (map[x][y - 1] == oth) && y - 1 >= 1;
	flag[2] = (map[x + 1][y] == oth) && x + 1 <= 8;
	flag[3] = (map[x - 1][y] == oth) && x - 1 >= 1;
	flag[4] = (map[x - 1][y + 1] == oth) && x - 1 >= 1 && y + 1 <= 8;
	flag[5] = (map[x + 1][y + 1] == oth) && x + 1 <= 8 && y + 1 <= 8;
	flag[6] = (map[x + 1][y - 1] == oth) && x + 1 <= 8 && y - 1 >= 1;
	flag[7] = (map[x - 1][y - 1] == oth) && x - 1 >= 1 && y - 1 >= 1;

	for (int i = 2; i <= 7; i++)
	{
		if (flag[0] == 1 && is(y + i))
			if (map[x][y + i] == tot)
				flag[0] = 2;
			else if (map[x][y + i] == '-')
				flag[0] = 0;

		if (flag[1] == 1 && is(y - i))
			if (map[x][y - i] == tot)
				flag[1] = 2;
			else if (map[x][y - i] == '-')
				flag[1] = 0;

		if (flag[2] == 1 && is(x + i))
			if (map[x + i][y] == tot)
				flag[2] = 2;
			else if (map[x + i][y] == '-')
				flag[2] = 0;

		if (flag[3] == 1 && is(x - i))
			if (map[x - i][y] == tot)
				flag[3] = 2;
			else if (map[x - i][y] == '-')
				flag[3] = 0;

		if (flag[4] == 1 && is(x - i) && is(y + i))
			if (map[x - i][y + i] == tot)
				flag[4] = 2;
			else if (map[x - i][y + i] == '-')
				flag[4] = 0;

		if (flag[5] == 1 && is(x + i) && is(y + i))
			if (map[x + i][y + i] == tot)
				flag[5] = 2;
			else if (map[x + i][y + i] == '-')
				flag[5] = 0;

		if (flag[6] == 1 && is(x + i) && is(y - i))
			if (map[x + i][y - i] == tot)
				flag[6] = 2;
			else if (map[x + i][y - i] == '-')
				flag[6] = 0;

		if (flag[7] == 1 && is(x - i) && is(y - i))
			if (map[x - i][y - i] == tot)
				flag[7] = 2;
			else if (map[x - i][y - i] == '-')
				flag[7] = 0;

	}
	if (t)
	{
		for (int i = 1; i <= 7; i++)
		{
			if (flag[0] == 2)
				if (map[x][y + i] == oth)
					map[x][y + i] = tot;
				else
					flag[0] = 3;

			if (flag[1] == 2)
				if (map[x][y - i] == oth)
					map[x][y - i] = tot;
				else
					flag[1] = 3;

			if (flag[2] == 2)
				if (map[x + i][y] == oth)
					map[x + i][y] = tot;
				else
					flag[2] = 3;

			if (flag[3] == 2)
				if (map[x - i][y] == oth)
					map[x - i][y] = tot;
				else
					flag[3] = 3;

			if (flag[4] == 2)
				if (map[x - i][y + i] == oth)
					map[x - i][y + i] = tot;
				else
					flag[4] = 3;

			if (flag[5] == 2)
				if (map[x + i][y + i] == oth)
					map[x + i][y + i] = tot;
				else
					flag[5] = 3;

			if (flag[6] == 2)
				if (map[x + i][y - i] == oth)
					map[x + i][y - i] = tot;
				else
					flag[6] = 3;

			if (flag[7] == 2)
				if (map[x - i][y - i] == oth)
					map[x - i][y - i] = tot;
				else
					flag[7] = 3;
		}
	}
	for (int i = 0; i < 8; i++)
		if (flag[i] >= 2)
		{
			return 1;

		}
	return 0;
}
int main()
{
	//freopen("in.txt", "r", stdin);
	//freopen("out.txt", "w", stdout);
	int T, kase = 0;
	scanf("%d", &T);
	while (T--)
	{
		memset(map, '\0', sizeof map);
		char tot, cmd[5];
		for (int i = 1; i <= 8; i++)
		{
			getchar();
			for (int j = 1; j <= 8; j++)
				scanf("%c", &map[i][j]);

		}
		getchar();
		scanf("%c", &tot);

		if (kase++)
			printf("\n");

		while (scanf("%s", cmd) && cmd[0] != 'Q')
		{
			if (cmd[0] == 'L')
			{
				int flag = 0;
				for (int i = 1; i <= 8; i++)
					for (int j = 1; j <= 8; j++)
						if (isPlace(tot, i, j, 0))
						{
							if (flag++)
								printf(" ");
							printf("(%d,%d)", i, j);
						}
				if (!flag)
					printf("No legal move.");
				printf("\n");
			}
			else
			{
				int x = cmd[1] - '0', y = cmd[2] - '0';
				if (!isPlace(tot, x, y, 1))
				{
					tot = f(tot);
					isPlace(tot, x, y, 1);
				}
				map[x][y] = tot;
				tot = f(tot);
				int s1 = 0, s2 = 0;
				for (int i = 1; i <= 8; i++)
					for (int j = 1; j <= 8; j++)
						if (map[i][j] == 'B')
							s1++;
						else if (map[i][j] == 'W')
							s2++;
				printf("Black - %2d White - %2d\n", s1, s2);
			}
		}
		for (int i = 1; i <= 8; i++)
			printf("%s\n", map[i] + 1);
	}
	return 0;
}

LTF►漏断

PHP笔记

引言

本文系作者学习PHP时的部分笔记，内容主要来源于《PHP+MySQL网站开发从零开始学》一书。此书介绍PHP7与MySQL5.6的相关内容，其中PHP部分含金量较高，MySQL则主要介绍DDL(数据定义语音），笔者认为难度略大，最好先从DML开始学习。以下是PHP基本语法、PHP与用户交互、正则表达式的笔记，语言尽量简洁，方便将来查阅。

PHP基本语法

引用

与c++相同

PHP变量的类型由上下文决定

可变变量：

一个变量的变量名可以动态设置和使用

例：

<?php
$a = "hello";
$$a = "world";
echo $a; //输出hello
echo $$a; //输出world
echo $hello; //输出world
?>

常量声明

A.define（‘常量名’，常量值）

B.const 常量名=常量值

defined（常量名）

检测常量是否存在，若存在则返回true

内置常量

__FILE__程序文件名（包括目录）

__DIR__程序目录

__LINE__当前PHP程序的行数

TRUE,FALSE布尔值

PHP-VERSION php版本号

PHP-OS 操作系统名称

Echo false不输出内容

进制

八进制：数字前加0

十六进制：数字前加0x

十进制： 直接写数字

Gettype(变量名）

获取变量类型

Intval(变量名或算式)

强制类型转换为int型

相当于（int)变量名或算式

字符串

双引号定义的字符串中的变量会被解析

双引号中的特殊字符会被转义解析，如 \n \r \e \t……

\x[0-9A-Fa-f]{1,2} 以十六进制方式表达的字符

\[0-7]{1,3} 以八进制方式表达的字符

heredoc和nowdoc

Heredoc:对变量解析，对特殊字符转义

<<<EOT

大段字符

EOT；

Nowdoc:不对变量解析，不对特殊字符转义

<<<’EOT’

大段字符

EOT；

注：EOT为标识符，符合变量命名规则

一个数值可以通过strval(数值)转换为字符串

与（string)数字 效果相同

资源

资源保存了对外部资源的引用，通过专门函数来建立和使用

例：$handle = fopen(“C:\\folder……”,”r”)

NULL

A.被赋值为null

B.未被赋值

C.被unset（）

类型转换

A.自动转换

（类型）值

例：(int) 1.1

B.强制转换

例：settype(变量名，’int’)

算数运算符

与C++基本相同

.= 将左边的字符串连接右边字符串，然后赋给左边字符串

<>或!=不等号

==类型转换后相等

===类型和值都相等

！=类型转换后不等

！==数值或类型不等

注意：慎用==和！=，因为会自动转换，引发意想不到的麻烦

逻辑运算符

||比OR优先级高

&&比AND优先级高

XOR逻辑异或

错误控制运算符@

@加在表达式前，屏蔽错误信息

NULL合并运算符??

变量存在且值不为NULL则返回值，否则返回第二个操作符

相当于： isset(变量) ?第一个操作符： 第二个操作符

太空船操作符<=>

$a < $b 返回-1

$a = $b 返回0

$a > $b 返回1

函数

Function 函数名（传入参数）{

……

Return 返回值；

}

其余与C++相同

PHP不支持函数重载

通过引用&传递参数

与C++相同

函数参数默认值

与C++相同，有默认值的参数必须放在最后

函数参数可以指定类型

Class 、interface 对象或接口

Array 数组

Callable 回调函数

Bool 、int、string、float标量类型

调用函数时参数不会强制类型转换，不符合则返回异常

用…设置传入任意多个参数

例：

Function myfunction(…$vars){
}
myfunction( …[I,2,3]);
myfunction(1,'test',1.0,false);
myfunction(…array(1,2,3));

也可以指定可变数量参数的类型,或用引用&传递参数

例：

Function myfunction(int …$vars){
}
myfunction(1,2,3,4);
Function myfunction(int …$vars){
}

静态变量

Static变量的值可以一直保持

通过数组可以返回多个值

通常借助list函数

例：

Function myfunction(){
….
Return [$a,$b];
}
List($a,$b)=myfunction();

返回值类型声明

例：

Function myfunction(): int {
…
}

可变函数

将函数名赋值给变量

使用时在变量名后加（参数）

例：

$a = myfunction(){}

$a()；

典型用法：将函数名放入数组中，用foreach依次执行

匿名函数（闭包函数）

临时创建一个没有名称的函数

例：

$myfunction = function($message){
echo "myfunction:".$message;
}
$myfunction('hello') //输出myfunction:hello

PHP与用户交互

表单处理

get:将数据直接添加到表单的action URL之后，两者之间用？分隔，参数间用&分隔

例：html表单

<form>
请输入手机号：
<input type="text" name="cellphone" />
<input type="submit" name="提交" />
</form>
<form name="form1" action="form1.php" method="get">

返回 action=’http://my.server.com/test.php?cellphone=13912341234&name=test'

post：浏览器与action中的URL连接，用HTTP协议传输给PHP程序

对比：

安全性上post好于get

执行效率上get高于post

post传输数据量大，默认不受限制。

参数被解析为数组形式，存放在全局变量$_GET,$_POST,$_REQUEST中

表单元素及处理

文本框：

附：常见密码框也是文本框，其input的值设为password

例如：

文本区域textarea可看作多行文本框，与文本框功能相同

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<textarea name='description'> </textarea>

<form>
<!--这是HTML的注释语法-->
<p> First name:<input type="text" name="fname" /></p>
<p> Last name:<input type="text" name="lname" /></p>
<p><input type='submit' /></p>
<!--添加一个提交按钮-->
</form>
<?php
//用isset判断$_GET是否有fname
if(isset($_GET['fname'])){
//打印出表单提交的fname
echo "First name : ${_GET['fname']} <br/>\n;
}
if(isset($_GET['lname'])){
echo "First name : ${_GET['lname']} <br/>\n;
}

单选按钮（radio）：

1
2
3
4
5
6
7
8
9
10
<form>
<input type="radio" name="radiobutton" value="同意" />同意<br/>
<input type="radio" name="radiobutton" value="不同意" />不同意<br/>
<input type="radio" name="radiobutton" value="无法判断" />无法判断<br/>
<input type='submit'>
</form>
<?php
if(isset($_GET['radiobutton'])){
echo "你的选择是 ${_GET[radiobutton]} <br/>\n;
?>

radiobutton是单项选择所以只能有一个结果

复选框（CheckBox）：

1
2
3
4
5
6
7
8
9
10
11
12
13
<form>
<h3>你喜欢的交通方式：</h3>
<input type="checkbox" name="checkbox[]" value="plane" />飞机 <br/>
<input type="checkbox" name="checkbox[]" value="train" />火车 <br/>
<input type="checkbox" name="checkbox[]" value="bus" />汽车 <br/>
<input type="checkbox" name="checkbox[]" value="ship" />船 <br/>
<input tpye="submit">
</form>
<?php
if(isset($_GET['checkbox'])){
var dump($_GET['checkbox']);
}
?>

PHP解析器会自动将checkbox[]参数解析为数组，否则会出现参数值覆盖问题

下拉列表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<form>
<h3>酒店级别</h3>
<select name="hotelclass" >
<option selected >不限</option>
<option>五星级 </option>
<option>四星级 </option>
<option>三星级 </option>
<option>二星以下 </option>
</select>
<input type= 'submit'>
</form>
<?php
if(isset($_GET['hotelclass'])){
echo ("你的选择是：");
var dump($_GET['hotelclass']);
}
?>

如果需要多选，只要将name属性后面加上[]即可

按钮：

重置按钮：

由浏览器直接处理，不会提交数据到服务器

提交按钮：

1
<input type ="submit" value="提交" />

PHP解析器将表单分别放到全局变量$_GET,$_POST,$_REQUEST中，方便进一步处理

cookie存放在客户端可由用户修改，session由服务器的PHP控制

创建cookie：

语法：setcookie(name,value,expire,path,domain,secure);

//setcookie(cookie名字,值,失效时间,服务器上的有效路径,域名,是否使用HTTPS协议传输)

例：

1
2
3
4
5
6
7
8
<?php
setcookie("user","Chole",time()+7200,'''',"yourdomain.com",1);//将使用HTTPS传输，0表示普通传输
?>
<html>
<body>
 
</body>
</html>

注意：setcookie()必须在标签前，否则会出错！

读取cookie：

用$_COOKIE变量取回cookie值

1
2
3
4
<?php
echo $_COOKIE["user"]; //只输出一个cookie值
print_r($_COOKIE);//输出cookie的所有值
?>

确认cookie存在：

用isset()确认是否已设置Cookie

1
2
3
4
<?php
if(isset($_COOKIE["user"])){
echo $_COOKIE["user"]."你好！<br/>";
?>

删除cookie：

设置cookie有效时间为过期即可

1
2
3
4
<?php
//将过期时间设为半小时前
setcookie("user", "", time()-1800);
?>

Session

创建session：

使用session_start()函数

例：

1
2
3
4
5
6
<?php session_start(); ?>
<html>
<body>
 
</body>
<html>

注意：session_start()必须在之前，因为会设置一个Cookie

存储Session：

全局变量$_SESSION,在一个页面赋值，在另一个页面调用就可以实现变量在页面之间的传递

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//每刷新一次浏览次数加一
<?php session_start();
if(isset($_SESSION['views'])){         //判断session是否存在
$_SESSION['views']++;
}
else{
$_SESSION['views']=1;
}
?>
<html>
<body>
<?php
echo "浏览次数=" .$_SESSION['views'];
?>
</body>
<html>

终结session：

unset()函数释放指定的session变量

1
2
3
<?php
unset($_SESSION['views']);
?>

session_destroy彻底终结session，所有已存储的session数据都会被重置

1
2
3
<?php
session_destroy();
?>

正则表达式

函数：

int preg_match(string $pattern,string $subject)搜索与pattern匹配的一个字符串，搜索到返回1，否则返回0

string preg_replace(mixed $pattern,mixed $replacement,mixed $subject)搜索跟正则表达式pattern匹配的一个字符串，并用新的字符串替代所有这个表达式出现的地方

array preg_split(string $pattern ,string $subject)搜索匹配的字符串，以字符串集合方式返回匹配结果

实例：

电子邮件地址检查：

1
2
3
4
5
6
7
8
9
10
11
    preg_match("/^([0-9a-zA-Z\\-_\\.]+)@([0-9a-z]+\\.[a-z]{2,3}(\\.[a-z]{2}?)$/i",$email);

匹配所有正整数：^\[0-9\]{1,}$；

匹配所有整数：^\\-{0,1}\[0-9\]{1,}$;

匹配所有小数：^\\-{0,1}\[0-9\]\\.{0,1}\[0-9\]{0,}$;

url合法性：^(http:\\/\\/)?\[a-zA-Z0-9\]+(\\.\[a-zA-Z0-9\]+)*.

电话号码合法性：+86 010xxxxxxxx ^(\\+86\[\[：space：\]\]010\[0-9\]{8}$

符号

元字符：

^:匹配指定字符串的开头

$:匹配指定字符串的结尾

.:匹配除\n以外的任何单一字符

[]:只匹配方括号内的单一字符，可用-连接匹配范围的首尾

|:或操作符，在两项或多项之间选择一个匹配，如“b(a|e|oo)s”可以匹配boos（因为oo是两个字符，所以这里不用方括号，用圆括号）

\:用来转义一个字符，对元字符、制表符、空格等使用，如\$,\\

():标记一个子表达式的开始和结束

*:匹配前面的子表达式零次或多次

+：匹配前面的子表达式一次或多次

？：匹配前面的子表达式零次或一次

注意：*、+、？只对紧挨它的前面那个字符起作用

转义字符：

\n:匹配一个换行符

\r:匹配一个回车键

\s:匹配任何空白字符，包括空格、制表符、换页符等，等价于[\f\n\r\t\v]

\S:匹配任何非空白字符，等价于[^\f\n\r\t\v]

\t:匹配一个制表符

\v:匹配一个垂直制表符

\f:匹配一个换页符

\cx:匹配由x指明的控制字符。例如：\cM匹配一个Control-M或回车符。x的值必须是A-Z或a-z之一，否则将c视为一个原义‘c’字符，即字符c本身

修正符：

i:忽略大小写

m:除了匹配^和$还分别匹配换行符\n的之后和之前

s:圆点字符（.）匹配所有字符，包括换行符\n

x:除了转义或在字符类中的空白字符全部忽略

e:preg_replace()在替换字符串中对逆向引用做正常替换，将其作为PHP代码求值，并用其结果替换被搜索的字符串

A:强制仅从字符串开头开始匹配

D:行结束（$)仅匹配目标字符串的结尾。没有此项时，最后一个字符串是换行符也会被匹配

S:当一个模式将被匹配多次时，为加速匹配而先对其进行分析

U:使？的默认匹配成为贪婪状态的

X:任何\后面没有特殊意义的字母导致一个错误，从而保留此组合以备将来扩充

u:模式字符串被当成utf-8

LTF►XLor

Squares UVa201

Times：45 mins

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <iostream>
#include <cstring>
using namespace std;
int h[20][20] = { 0 }, v[20][20] = { 0 }, res[20] = { 0 };
int main()
{
	int kase = 0, size, T;
	while (cin >> size >> T)
	{
		memset(h, 0, sizeof h);
		memset(v, 0, sizeof v);
		memset(res, 0, sizeof res);
		while (T--)
		{
			char s;
			int x, y;
			cin >> s >> x >> y;
			if (s == 'H')
				h[x][y] = 1;
			else
				v[y][x] = 1;
		}
		int flag = 1;//标记是否完全无解
		for (int s = 1; s <= size; s++)
		{
			int cnt = 0;
			for (int i = 1; i <= size - s; i++)
				for (int j = 1; j <= size - s; j++)
				{
					int mark = 1;//标记是否缺少边
					for (int x = j; x <= j + s - 1; x++)
						if (!h[i][x] || !h[i + s][x])
							mark = 0;

					for (int x = i; x <= i + s - 1; x++)
						if (!v[x][j] || !v[x][j + s])
							mark = 0;
					if (mark)
						cnt++;
				}
			res[s] = cnt;
			if (cnt)
				flag = 0;
		}
		if(kase)
			cout << endl << "**********************************" << endl << endl;
		cout << "Problem #" << ++kase << endl << endl;
		if (flag)
			cout << "No completed squares can be found." << endl;
		for (int i = 1; i <= size; i++)
			if (res[i])
				cout << res[i] << " square (s) of size " << i << endl;
	}
	return 0;
}

LTF►XLor

Xiangqi UVa1589

Time: 3 hrs 20 mins 一个把我搞得快崩溃的题，一开始没有把问题考虑好，采用边输入边检查攻击范围，没有考虑到后面的棋子。 第二个问题，黑将可以吃子的问题，采用的解决方法是车和炮的攻击范围，从一开始会被棋子打断（该位置不在范围），到包括该位置，即假如黑将吃了这个棋子，那么就进入攻击范围。 第三，忘记把红将也设置为红车进行判定，这才把所有情况考虑周到，但是又忘记删掉重定向，最后才AC。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#include <iostream>
#include <cstring>
using namespace std;
int N, bx, by;
int map[20][20] = { 0 };
int chess[20][20] = { 0 };
void cAtk(int x, int y)
{
	int flag = 0;
	for (int i = x + 1; i < 11; i++)
	{
		if (chess[i][y] < 2 && flag)
			map[i][y] = 1;
		if (chess[i][y] > 1 && flag)
		{
			map[i][y] = 1; break;
		}
		else if (chess[i][y] > 1)
			flag = 1;
	}
	flag = 0;
	for (int i = x - 1; i > 0; i--)
	{
		if (chess[i][y] < 2 && flag)
			map[i][y] = 1;
		if (chess[i][y] > 1 && flag)
		{
			map[i][y] = 1; break;
		}
		else if (chess[i][y] > 1)
			flag = 1;
	}
	flag = 0;
	for (int i = y + 1; i < 10; i++)
	{
		if (chess[x][i] < 2 && flag)
			map[x][i] = 1;
		if (chess[x][i] > 1 && flag)
		{
			map[x][i] = 1; break;
		}
		else if (chess[x][i] > 1)
			flag = 1;
	}
	flag = 0;
	for (int i = y - 1; i > 0; i--)
	{
		if (chess[x][i] < 2 && flag)
			map[x][i] = 1;
		if (chess[x][i] > 1 && flag)
		{
			map[x][i] = 1; break;
		}
		else if (chess[x][i] > 1)
			flag = 1;
	}
}
void rAtk(int x, int y)
{
	for (int i = x + 1; i <= 10; i++)
		if (chess[i][y] > 1)
		{
			map[i][y] = 1; break;
		}
		else
			map[i][y] = 1;
	for (int i = x - 1; i > 0; i--)
		if (chess[i][y] > 1)
		{
			map[i][y] = 1; break;
		}
		else
			map[i][y] = 1;

	for (int i = y + 1; i <= 9; i++)
		if (chess[x][i] > 1)
		{
			map[x][i] = 1; break;
		}
		else
			map[x][i] = 1;

	for (int i = y - 1; i > 0; i--)
		if (chess[x][i] > 1)
		{
			map[x][i] = 1; break;
		}
		else
			map[x][i] = 1;

}
void hAtk(int x, int y)
{
	if (!chess[x][y + 1])
	{
		if (x - 1 > 0 && y + 2 < 10)
			map[x - 1][y + 2] = 1;
		if (x + 1 < 11 && y + 2 < 10)
			map[x + 1][y + 2] = 1;
	}
	if (!chess[x][y - 1])
	{
		if (x - 1 > 0 && y - 2 > 0)
			map[x - 1][y - 2] = 1;
		if (x + 1 < 11 && y - 2 > 0)
			map[x + 1][y - 2] = 1;
	}
	if (!chess[x + 1][y])
	{
		if (x + 2 < 11 && y - 1 > 0)
			map[x + 2][y - 1] = 1;
		if (x + 2 < 11 && y + 1 < 10)
			map[x + 2][y + 1] = 1;
	}
	if (!chess[x - 1][y])
	{
		if (x - 2 > 0 && y - 1 > 0)
			map[x - 2][y - 1] = 1;
		if (x - 2 > 0 && y + 1 < 10)
			map[x - 2][y + 1] = 1;
	}
}
int main()
{
	while (cin >> N >> bx >> by && N)
	{
		memset(map, 0, sizeof map);
		memset(chess, 0, sizeof chess);
		chess[bx][by] = 1;
		int rx, ry, cnt[10] = { 0 }, xx[10][10] = { 0 }, yy[10][10] = { 0 };
		while (N--)
		{
			int x, y;
			char t;
			cin >> t >> x >> y;
			if (t == 'G')
			{
				chess[x][y] = 2;
				rx = x;
				ry = y;
			}
			else if (t == 'R')
			{
				chess[x][y] = 3;
				xx[0][cnt[0]] = x;
				yy[0][cnt[0]++] = y;

			}
			else if (t == 'H')
			{
				chess[x][y] = 4;
				xx[1][cnt[1]] = x;
				yy[1][cnt[1]++] = y;

			}
			else
			{
				chess[x][y] = 5;
				xx[2][cnt[2]] = x;
				yy[2][cnt[2]++] = y;

			}
		}
		for (int i = 0; i < cnt[0]; i++)
			rAtk(xx[0][i], yy[0][i]);
		for (int i = 0; i < cnt[1]; i++)
			hAtk(xx[1][i], yy[1][i]);
		for (int i = 0; i < cnt[2]; i++)
			cAtk(xx[2][i], yy[2][i]);

		int flag = 1;
		for (int i = rx - 1; i > 0; i--)
			if (chess[i][ry] > 2)
				flag = 0;
		if (flag)
		{
			if (chess[1][ry] == 1 || chess[2][ry] == 1 || chess[3][ry] == 1)
			{
				cout << "NO" << endl;
				continue;
			}
		}
		rAtk(rx, ry);
		flag = 1;
		if (bx - 1 > 0 && !map[bx - 1][by])
			flag = 0;
		if (bx + 1 < 4 && !map[bx + 1][by])
			flag = 0;
		if (by - 1 > 3 && !map[bx][by - 1])
			flag = 0;
		if (by + 1 < 7 && !map[bx][by + 1])
			flag = 0;
		cout << (flag ? "YES" : "NO") << endl;

	}
	return 0;
}

LTF

关于CTF

CTF竞赛是安全圈喜闻乐见的竞赛模式，对于培养网络安全技术人才起到了很重要的作用。CTF起源于1996年DEFCON全球黑客大会，是Capture The Flag的简称。经过多年的发展，CTF这种比赛形式已经日益成熟。 CTF注重动手技能，深厚的理论功底厚积薄发，技术的卓越是建立在无数次训练的基础上，那么我们来看看有哪些不错的平台可以来用于比赛训练。 一般线上初选采用传统的夺旗赛模式，也就是在题目中设置一些标识，解题的目的就是为了找到标识并提交。通常包含的题目类型包括MISC、CRYPTO、PWN、REVERSE、WEB等。

  • MISC(Miscellaneous)类型，即安全杂项，题目或涉及流量分析、电子取证、人肉搜索、数据分析等等。
  • CRYPTO(Cryptography)类型，即密码学，题目考察各种加解密技术，包括古典加密技术、现代加密技术甚至出题者自创加密技术。
  • PWN类型，PWN在黑客俚语中代表着攻破、取得权限，多为溢出类题目。
  • REVERSE类型，即逆向工程，题目涉及到软件逆向、破解技术。
  • WEB类型，即题目会涉及到常见的Web漏洞，诸如注入、XSS、文件包含、代码执行等漏洞。