php curl请求返回400 Bad Request的解决方法 

1
2
3
4
5
 
<h1>400 Bad Request</h1>
&nbsp;

<center>nginx/1.2.0</center>

当你使用php的curl方法时会返回400 Bad Request，这有如下几种原因：

1.远端有检测客户端过滤行为。
2.远端有redir行为。
3.请求中间层。
4.近端有过滤行为。
5.某个过程有缓存机制。
6.脚本文件编码问题。

前面5种都是服务器的限制，做一些伪装就可以，但是很多人会忽略掉第六个原因，这是因为Unicode、Unicode big endian和UTF-8编码的txt文件的开头会多出几个字节，分别是FF、FE（Unicode）,FE、FF（Unicode big endian）,EF、BB、BF（UTF-8）。一般只要换成UTF-8编码就没有可以解决了。

看我如何劫持用户的浏览器

标题起的有点大有点夸张，但应该引起重视，起因是我在搜索一个东西的时候，打开了一个垃圾站点，神奇的事情发生了，新标签打开这个站点后，我的Google搜索页面自动跳转到广告页面了，出于好奇必须研究一下，首先它控制了我的Google搜索页面，所以我猜测它代码里有“Google”这个关键词，在Chrome控制台用强大的ctrl+shift+f搜到了几个js文件，前面都是Google广告的js，最后一个js.js是咸鱼饭，于是在这个文件里找到可疑的被加密的代码位置下了个断点。

p1

经过耐心一直按F11跟踪后，控制台VM输出了解密后的关键函数。
p2

看到这里基本上就知道了垃圾站劫持搜索页面的方法了，代码很简单有点基础的同学应该都可以看懂，这时我的想法是这么简单，我怎么没想到，思路很重要，到这里代码分析及实现原理就这样完了，简单到没什么可以讲的了。

垃圾站用这样的方式来刷流量刷广告很正常，但是我想到的是更可怕的事情，被访问页面可以劫持用户的来源页面，也就产生了一个钓鱼攻击的利用场景：

1，用户A在微博看到一个链接好奇打开了；
2，被打开的页面evilA用一些吸引眼球的内容抓住用户的注意力；
3，微博页面被劫持跳转到钓鱼页面，例如一个假的高仿的微博页面evilB；
4，当用户关闭页面evilA，打算继续看微博的时候，此时他看到的是高仿的微博页面evilB，而用户没留意到页面已经被替换；
5，高仿的微博页面evilB提示登录超时，要求用户重新登录，用户输入帐号密码；
6，高仿的微博页面evilB记录用户密码后再跳回正常的微博页面，用户帐号在不知不觉中被盗；

测试页面：http://wanz.im/demo/referrer-hijacking.html

Chrome 28.0.1500.72 m，Firefox 22.0成功劫持，IE 10.0.9200.16635提示没有权限

当然上述是理想状态下的钓鱼攻击，高端点的利用就是程序通过referrer信息立刻生成一个相同的页面来钓鱼，不注意防范依然有风险存在，上网需谨慎！

转载自：http://i.wanz.im/2013/07/19/hijacking-referrer-page/

实现文本相似度算法（余弦定理）(转)

最近由于工作项目，需要判断两个txt文本是否相似，于是开始在网上找资料研究，因为在程序中会把文本转换成String再做比较，所以最开始找到了这篇关于 距离编辑算法 Blog写的非常好，受益匪浅。

于是我决定把它用到项目中，来判断两个文本的相似度。但后来实际操作发现有一些问题：直接说就是查询一本书中的相似章节花了我7、8分钟；这是我不能接受……

于是停下来仔细分析发现，这种算法在此项目中不是特别适用，由于要判断一本书中是否有相同章节，所以每两个章节之间都要比较，若一本书书有x章的话，这里需对比x(x-1)/2次；而此算法采用矩阵的方式，计算两个字符串之间的变化步骤，会遍历两个文本中的每一个字符两两比较，可以推断出时间复杂度至少为document1.length × document2.length，我所比较的章节字数平均在几千～一万字；这样计算实在要了老命。

想到Lucene中的评分机制，也是算一个相似度的问题，不过它采用的是计算向量间的夹角（余弦公式），在google黑板报中的：数学之美（余弦定理和新闻分类） 也有说明，可以通过余弦定理来判断相似度；于是决定自己动手试试。

首相选择向量的模型：在以字为向量还是以词为向量的问题上，纠结了一会；后来还是觉得用字，虽然词更为准确，但分词却需要增加额外的复杂度，并且此项目要求速度，准确率可以放低，于是还是选择字为向量。

然后每个字在章节中出现的次数，便是以此字向量的值。现在我们假设：

章节1中出现的字为：Z1c1,Z1c2,Z1c3,Z1c4……Z1cn；它们在章节中的个数为：Z1n1,Z1n2,Z1n3……Z1nm；

章节2中出现的字为：Z2c1,Z2c2,Z2c3,Z2c4……Z2cn；它们在章节中的个数为：Z2n1,Z2n2,Z2n3……Z2nm；

其中，Z1c1和Z2c1表示两个文本中同一个字，Z1n1和Z2n1是它们分别对应的个数，

最后我们的相似度可以这么计算：公式

程序实现如下：（若有可优化或更好的实现请不吝赐教）

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
public class CosineSimilarAlgorithm {
    public static double getSimilarity(String doc1, String doc2) {
        if (doc1 != null && doc1.trim().length() > 0 && doc2 != null
                && doc2.trim().length() > 0) {
            
            Map<Integer, int[]> AlgorithmMap = new HashMap<Integer, int[]>();
            
            //将两个字符串中的中文字符以及出现的总数封装到，AlgorithmMap中
            for (int i = 0; i < doc1.length(); i++) {
                char d1 = doc1.charAt(i);
                if(isHanZi(d1)){
                    int charIndex = getGB2312Id(d1);
                    if(charIndex != -1){
                        int[] fq = AlgorithmMap.get(charIndex);
                        if(fq != null && fq.length == 2){
                            fq[0]++;
                        }else {
                            fq = new int[2];
                            fq[0] = 1;
                            fq[1] = 0;
                            AlgorithmMap.put(charIndex, fq);
                        }
                    }
                }
            }
 
            for (int i = 0; i < doc2.length(); i++) {
                char d2 = doc2.charAt(i);
                if(isHanZi(d2)){
                    int charIndex = getGB2312Id(d2);
                    if(charIndex != -1){
                        int[] fq = AlgorithmMap.get(charIndex);
                        if(fq != null && fq.length == 2){
                            fq[1]++;
                        }else {
                            fq = new int[2];
                            fq[0] = 0;
                            fq[1] = 1;
                            AlgorithmMap.put(charIndex, fq);
                        }
                    }
                }
            }
            
            Iterator<Integer> iterator = AlgorithmMap.keySet().iterator();
            double sqdoc1 = 0;
            double sqdoc2 = 0;
            double denominator = 0;
            while(iterator.hasNext()){
                int[] c = AlgorithmMap.get(iterator.next());
                denominator += c[0]*c[1];
                sqdoc1 += c[0]*c[0];
                sqdoc2 += c[1]*c[1];
            }
            
            return denominator / Math.sqrt(sqdoc1*sqdoc2);
        } else {
            throw new NullPointerException(
                    " the Document is null or have not cahrs!!");
        }
    }
 
    public static boolean isHanZi(char ch) {
        // 判断是否汉字
        return (ch >= 0x4E00 && ch <= 0x9FA5);
 
    }
 
    /**
     * 根据输入的Unicode字符，获取它的GB2312编码或者ascii编码，
     *
     * @param ch
     *            输入的GB2312中文字符或者ASCII字符(128个)
     * @return ch在GB2312中的位置，-1表示该字符不认识
     */
    public static short getGB2312Id(char ch) {
        try {
            byte[] buffer = Character.toString(ch).getBytes("GB2312");
            if (buffer.length != 2) {
                // 正常情况下buffer应该是两个字节，否则说明ch不属于GB2312编码，故返回'?'，此时说明不认识该字符
                return -1;
            }
            int b0 = (int) (buffer[0] & 0x0FF) - 161; // 编码从A1开始，因此减去0xA1=161
            int b1 = (int) (buffer[1] & 0x0FF) - 161; // 第一个字符和最后一个字符没有汉字，因此每个区只收16*6-2=94个汉字
            return (short) (b0 * 94 + b1);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return -1;
    }
}

程序中做了两小的改进，以加快效率：

  1. 只将汉字作为向量，其他的如标点，数字等符号不处理；2. 在HashMap中存放汉字和其在文本中对于的个数时，先将单个汉字通过GB2312编码转换成数字，再存放。

最后写了个测试，根据两种不同的算法对比下时间，下面是测试结果：

余弦定理算法：doc1 与 doc2 相似度为：0.9954971, 耗时：22mm

距离编辑算法：doc1 与 doc2 相似度为：0.99425095, 耗时：322mm

可见效率有明显提高，算法复杂度大致为：document1.length + document2.length。

blog转载于http://my.oschina.net/BreathL/blog/42477