精华内容
下载资源
问答
  • 180M弱口令字典

    2018-10-04 20:01:42
    弱口令字典180M,有各种类型弱口令,后台弱口令,常用密码,ftp,3389,后台路径等等
  • 弱口令字典.zip

    2019-08-19 14:32:17
    弱口令字典,多种类型:后台弱口令,常用密码,ftp,3389,后台路径等等
  • 系统弱口令检测和网络扫描系统弱口令检测JR安装JR工具检测弱口令账号密码文件的暴力破解配置命令网络扫描nmap命令常用的选项和扫描类型 系统弱口令检测 JR 一款密码分析工具,支持字典式的暴力破解 通过对shadow文件...

    系统弱口令检测

    JR

    一款密码分析工具,支持字典式的暴力破解
    通过对shadow文件的口令分析,可以检测密码强度
    官方网站:http://www.openwall.com/john/

    安装JR工具

    安装方法:make clean 系统类型
    主程序文件为john

    检测弱口令账号

    获得Linux/Unix服务器的shadow文件
    执行john程序,将shadow文件作为参数

    密码文件的暴力破解

    准备好密码字典文件,默认为password.lst
    执行john程序,结合–wordlist=字典文件

    配置命令

    cd /opt
    tar zxf john-1.8.0.tar.gz            #解压工具包
    yum install -y gcc gcc-c++ make        #安装软件编译工具
    cd /opt/john-1.8.0/src  #切换到src子目录
    make clean linux-x86-64     #进行编译安装
    cp /etc/shadow /opt/shadow.txt     #准备待破解的密码文件
    cd /opt/john-1.8.0/run
    ./john /opt/shadow.txt        #执行暴力破解
    ./john --show /opt/shadow.txt     #查看已破解出的账户列表
    使用密码字典文件
    > john.pot 		#清空已破解出的账户列表,以便重新分析
    ./john --wordlist=./password.lst /opt/shadow.txt		#使用指定的字典文件进行破解
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    因为密码过于复杂,破译时间较长,这里我就不贴图了

    网络扫描

    网络扫描——NMAP
    NMAP 是一个强大的端口扫描类安全评测工具,支持 ping 扫描、多端口检测等多种技术
    #安装 NMAP 软件包
    rpm -qa | grep nmap
    yum install -y nmap
    在这里插入图片描述

    nmap命令常用的选项和扫描类型

    -p:指定扫描的端口。
    -n:禁用反向 DNS 解析(以加快扫描速度)。
    -sS:TCP的SYN扫描(半开扫描),只向目标发出SYN数据包,如果收到SYN/ACK响应包就认为目标端口正在监听,并立即断开连接;否则认为目标端口并未开放。
    -sT:TCP连接扫描,这是完整的TCP扫描方式(默认扫描类型),用来建立一个TCP连接,如果成功则认为目标端口正在监听服务,否则认为目标端口并未开放。
    -sF:TCP的FIN扫描,开放的端口会忽略这种数据包,关闭的端口会回应RST数据包。许多防火墙只对SYN数据包进行简单过滤,而忽略了其他形式的 TCP 攻击包。这种类型的扫描可间接检测防火墙的健壮性。
    -sU:UDP 扫描,探测目标主机提供哪些 UDP 服务,UDP 扫描的速度会比较慢。
    -sP:ICMP 扫描,类似于 ping 检测,快速判断目标主机是否存活,不做其他扫描。
    -P0:跳过ping检测,这种方式认为所有的目标主机是存活的,当对方不响应ICMP请求时,使用这种方式可以避免因无法 ping 通而放弃扫描。

    netstat -natp 查看正在运行的使用TCP协议的网络状态信息
    

    在这里插入图片描述

    
    netstat -naup 查看正在运行的使用UDP协议的网络状态信息
    

    在这里插入图片描述

    nmap -sT 127.0.0.1                               #查看本机开放的TCP端口
    

    在这里插入图片描述

    nmap -sU 127.0.0.1                            #查看本机开放的UDP端口
    

    在这里插入图片描述

    #检测192.168.4.0/24网段有哪些主机提供HTTP服务
    nmap -p 80 192.168.4.0/24
    

    在这里插入图片描述

    #检测192.168.4.0/24网段有哪些存活主机
    nmap -n -sP 192.168.4.0/24
    

    在这里插入图片描述

    natstat命令常用选项:
    -a:显示主机中所有活动的网络连接信息(包括监听、非监听状态的服务端口)。
    -n:以数字的形式显示相关的主机地址、端口等信息。
    -t:查看 TCP相关的信息。
    -u:显示 UDP协议相关的信息。
    -p:显示与网络连接相关联的进程号、进程名称信息(该选项需要 root 权限)。
    -r:显示路由表信息。
    -l:显示处于监听状态的网络连接及端口信息。

    展开全文
  • 拼搏百天我要日站——常见弱口令

    千次阅读 2021-05-05 21:34:08
    弱口令 弱口令(weak password) 没有严格和准确的定义,通常认为容易被别人猜测到或被破解工具破解的口令均为弱口令弱口令指的是仅包含简单数字和字母的口令,例如“123”、“abc”等,因为这样的口令很容易被别人...

    我被一个小破站骗钱了,不为别的,拼搏百天我要想办法把它日穿。
    在这里插入图片描述

    弱口令

    弱口令(weak password) 没有严格和准确的定义,通常认为容易被别人猜测到或被破解工具破解的口令均为弱口令。弱口令指的是仅包含简单数字和字母的口令,例如“123”、“abc”等,因为这样的口令很容易被别人破解,从而使用户的互联网账号受到他人控制,因此不推荐用户使用

    常见弱口令

    网站后台:
    admin、manager、admin123、admin888、admin666

    不同的后台类型拥有不同的弱密码:

    数据库(phpmyadmin)
    账号:root
    密码:root、root123、123456

    tomcat
    账号:admin、tomcat、manager
    密码:admin、tomcat、admin123、123456、manager

    jboss
    账号:admin、jboss、manager
    密码:admin、jboss、manager、123456

    weblogic
    账号:weblogic、admin、manager
    密码:weblogic、admin、manager、123456

    展开全文
  • 各种组合类型的密码字典、弱口令字典,常用密码,弱密码集合。解压出来共2.93 GB 的大量密码合辑txt。
  • 系统弱口令检测与网络端口扫描一、系统弱口令检测(一)概述(二)安装JR工具(三)检测弱口令账号(四)密码文件的暴力破解(五)操作步骤二、网络端口扫描NMAP(一)NMAP概述(二) 安装 NMAP 软件包(三)nmap...

    一、系统弱口令检测

    (一)概述

    Joth the Ripper,简称JR

    • 一款开源的密码分析工具,支持字典式的暴力破解
    • 通过对shadow文件的口令分析,可以检测密码强度
    • 官方网站:http://www.openwall.com/john/
      下载字典包

    在这里插入图片描述

    (二)安装JR工具

    1.安装方法 //make clean系统类型
    2. 主程序文件为john

    (三)检测弱口令账号

    1.获得Linux/Unix服务器的shadow文件
    2.执行john程序,将shadow文件作为参数

    (四)密码文件的暴力破解

    1.准备好密码字典文件,默认为password.lst
    2.执行john程序,结合–wordlist=字典文件

    (五)操作步骤

    cd /opt                                  
    tar zxvf john-1.9.0.tar.gz            //解压工具包 
    yum -y install gcc gcc-c++ make       //安装软件编译工具 
    
    cd /opt/john-1.9.0/src
    make clean linux-x86-64               //切换到src子目录,进行编译安装
    
    cp /etc/shadow /opt/shadow.txt        //准备待破解的密码文件
     
    cd /opt/john-1.9.0/run                   
    ./john /opt/shadow.txt                //切换到run子目录,执行暴力破解
    
    ./john --show /opt/shadow.txt          //查看已破解出的账户列表
    
    >john.pot                        //清空已破解出的账户列表,已重新分析
    ./john --wordlist=./password.lst /opt/shadow.txt  //使用指定的字典文件进行破解
    

    1.复制及解压工具包
    在这里插入图片描述
    在这里插入图片描述
    2.安装编译工具(源码安装需要c语言c++语言环境)
    在这里插入图片描述
    3.在/opt/john-1.8.0/src目录下进行编译安装
    在这里插入图片描述

    4.复制密码文件 准备执行暴力破解,在/opt/jhon-.8.0/run目录下执行破解

    补充:john-1.8.0/run目录下的password.lst文件是字典文件,破解密码时会跑一遍这个文件的内容

    在这里插入图片描述

    二、网络端口扫描NMAP

    (一)NMAP概述

    1.是一个强大的端口扫描类安全评测工具,支持 ping 扫描、多端口检测等多种技术
    2.官方网站:http://nmap.org/

    (二) 安装 NMAP 软件包

    mount /dev/sr0 /mnt //先进行本地磁盘挂载
    yum install -y nmap //然后安装nmap软件包

    (三)nmap命令常用选项与对应扫描类型

    • -p:指定扫描的端口。
    • -n:禁用反向 DNS 解析(以加快扫描速度)。
    • -sS:TCP的SYN扫描(半开扫描),只向目标发出SYN数据包,如果收到SYN/ACK响应包就认为目标端口正在监听,并立即断开连接;否则认为目标端口并未开放。
    • -sT:TCP连接扫描,这是完整的TCP扫描方式(默认扫描类型),用来建立一个TCP连接,如果成功则认为目标端口正在监听服务,否则认为目标端口并未开放。
    • -sF:TCP的FIN扫描,开放的端口会忽略这种数据包,关闭的端口会回应RST数据包。许多防火墙只对SYN数据包进行简单过滤,而忽略了其他形式的 TCP 攻击包。这种类型的扫描可间接检测防火墙的健壮性。
    • -sU:UDP 扫描,探测目标主机提供哪些 UDP 服务,UDP 扫描的速度会比较慢。
    • -sP:ICMP 扫描,类似于 ping 检测,快速判断目标主机是否存活,不做其他扫描。
    • -P0:跳过ping检测,这种方式认为所有的目标主机是存活的,当对方不响应ICMP请求时,使用这种方式可以避免因无法 ping 通而放弃扫描。
    nmap -sT 127.0.0.1   //查看本机开放的TCP端口
    
    nmap -sU 127.0.0.1   //查看本机开放的UDP端口 

    三、网络端口扫描netstat

    netstat -natp   // 查看正在运行的使用TCP协议的网络状态信息
    
    netstat -naup     查看正在运行的使用UDP协议的网络状态信息 
    展开全文
  • 弱口令验证方案设计

    2011-12-25 19:08:39
    弱口令的基本校验包括:口令字符串长度校验、口令字符串包含的字符类型校验、口令字符串包含的不同字符数校验。 口令字符串长度校验:验证口令字符串的长度不能低于规定值(如6)。 口令字符串包含的字符类型校验...

    1.1    弱口令设计思路

    1.1.1    基本校验

    弱口令的基本校验包括:口令字符串长度校验、口令字符串包含的字符类型校验、口令字符串包含的不同字符数校验。

    口令字符串长度校验:验证口令字符串的长度不能低于规定值(如6)。

    口令字符串包含的字符类型校验:把字符类型分为大写字母、小写字母、数组、特殊字符四类,校验口令字符串包含的字符类型不能低于规定值(如2)。

    口令字符串包含的不同字符数校验:不区分大、小写时aA算同一字符,区分大、小写时aA为不同字符。校验口令字符串中包含的不同字符数不能低于规定值(如4)。

    1.1.2    高级校验

    弱口令的高级校验包括:连续字符校验、键盘输入规则校验、弱口令字典校验。

    连续字符校验:校验口令字符串中连续字符组成的子串长度不但能高于规定的值(如40%)。

    键盘输入规则校验:详细见2.1.3

    弱口令字典校验:在弱口令字典中校验该口令字符串是否为弱口令。

    1.1.3    键盘输入规则校验

    结合笔记本电脑和台式电脑键盘的布局规则,将字符输入键映射为4*10的二维数组矩阵(1-0q-pa-;,z-?),把密码字符串中每各字符格式化为键盘矩阵中对应的坐标,判断连续字符的坐标是否相邻,并记录连续相邻的串长度进行安全性评估

    1.2    我的弱口令校验工具

    1.2.1  详细验证步骤说明

    1:判断密码是否为null或空,如果不是进入下一步,否则返回结果(密码安全性不符合)

    2:判断密码字符串长度是否符合要求,默认是大于等于6位,如果是进入下一步,否则返回结果(密码安全性不符合)

    3:循环取出密码串中从0位置到长度下限++的子串,进行下面48的操作并记录结果到一个double[]

    4:评估密码中包含的字符类型是否符合要求,如果低于下限返回0,否则返回6-10double

    5:评估密码至少包含的不同字符数(不区分大、小写),返回int,如果字符数小于下限返回0,否则返回6-10double

    6:评估密码字符串是否包含a-z,z-a这样的连续字符,返回一个double,如果连续字符占整个串长度的40%以上返回0,否则返回(1-连续字符占整个串长度的百分比) * 10

    7:评估密码字符串是否匹配键盘输入习惯,返回0-10的整数,值越大表示越不符合键盘输入习惯

    8:根据3456的评估结果综合评估出密码的安全评估值(0-10double

    9:循环3double[]的值,如果全是0返回0,否则从第一个不是0的位置开始累加,如果后一个位置为0则加长度修正值1,如果累加结果大于10,循环结束返回10

    10:判断7产生的安全评估值是否大于安全评估值的下限(默认7),是返回true,否则返回false

    1.2.2  Java实现类

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    import org.apache.log4j.Logger;
    
    /**
     * <strong>Title : CheckPWD</strong><br>
     * <strong>Description : 密码强度验证</strong><br>
     * <strong>Create on : Dec 6, 2011 7:34:45 PM</strong><br>
     * @author liulang@mochasoft.com.cn<br>
     * @version v1.0<br>
     * <br>
     * 详细验证步骤说明:<br>
     * 1:判断密码是否为null或空,如果不是进入下一步,否则返回结果(密码安全性不符合)<br>
     * 2:判断密码字符串长度是否符合要求,默认是大于等于6位,如果是进入下一步,否则返回结果(密码安全性不符合)<br>
     * 3:循环取出密码串中从0位置到长度下限++的子串,进行下面4到8的操作并记录结果到一个double[]中
     * 4:评估密码中包含的字符类型是否符合要求,如果低于下限返回0,否则返回6-10的double<br>
     * 5:评估密码至少包含的不同字符数(不区分大、小写),返回int,如果字符数小于下限返回0,否则返回6-10的double<br>
     * 6:评估密码字符串是否包含a-z,z-a这样的连续字符,返回一个double,如果连续字符占整个串长度的40%以上返回0,否则返回(1-连续字符占整个串长度的百分比) * 10<br>
     * 7:评估密码字符串是否匹配键盘输入习惯,返回0-10的整数,值越大表示越不符合键盘输入习惯<br>
     * 8:根据3、4、5、6的评估结果综合评估出密码的安全评估值(0-10的double)<br>
     * 9:循环3中double[]的值,如果全是0返回0,否则从第一个不是0的位置开始累加,如果后一个位置为0则加长度修正值1,如果累加结果大于10,循环结束返回10<br>
     * 9:判断7产生的安全评估值是否大于安全评估值的下限(默认7),是返回true,否则返回false
     * <br>
     * <strong>修改历史:</strong><br>
     * 修改人-------------修改日期-------------修改描述<br>
     * --------------------------------------------<br>
     * liulang-----------2011/12/7---------<br>
     * &nbsp;&nbsp;1:增加容错处理;<br>
     * &nbsp;&nbsp;2:修改键盘输入习惯匹配评估算法的逻辑;<br>
     * &nbsp;&nbsp;3:增加一个更加严格的键盘习惯匹配算法maches2(可匹配类似1z2x3c4v5b这样的特殊字符串)<br>
     * <br>
     */
    public final class CheckPWD {
    	private static Logger logger = Logger.getLogger(CheckPWD.class);
    	
    	/**
    	 * 安全密码评估值的下限,取值范围:0-10,默认:7
    	 */
    	public static double PASSWORD_STRONG = 7;
    	
    	/**
    	 * 密码字符串包含的字符类型(a-z,A-Z,0-9,特殊字符)在密码安全性评估中所占比例,默认:0.15
    	 */
    	public static double CHAR_TYPE_NUM_THRESHOLD = 0.15;
    	
    	/**
    	 * 密码字符串包含的不同字符数(不区分大、小写,同一键位的视为同一字符)在密码安全性评估中所占比例,默认:0.35
    	 */
    	public static double MIN_CONTAIN_CHAR_NUM_THRESHOLD = 0.35;
    	
    	/**
    	 * 密码字符串匹配键盘输入习惯在密码安全性评估中所占比例,默认:0.3
    	 */
    	public static double KEYSET_MATCHER_THRESHOLD = 0.3;
    	
    	/**
    	 * 评估密码字符串中a-z,z-a这样的连续字符在密码安全性评估中所占比例,默认:0.2
    	 */
    	public static double SEQUENTIAL_CHARS_THRESHOLD = 0.2;
    	
    	/**
    	 * 键盘输入习惯匹配规则严格模式
    	 */
    	public static int KEYSET_MATCHER_STRICT_MODE = 1;
    	
    	/**
    	 * 键盘输入习惯匹配规则不严格模式
    	 */
    	public static int KEYSET_MATCHER_UNDEMANDING_MODE = 0;
    	
    	/**
    	 * 密码最小长度,默认为6
    	 */
    	private static int MIN_LENGTH = 6;
    	
    	/**
    	 * 密码至少包含的不同字符数(不区分大、小写),(例如:"aaa"包含一个字符,"aba"包含2个字符,"aA"包含1个字符等),默认为4
    	 */
    	private static int MIN_CONTAIN_CHAR_NUM = 4;
    	
    	/**
    	 * 密码至少包含的字符类型数(a-z,A-Z,0-9,特殊字符),默认为2
    	 */
    	private static int MIN_CHAR_TYPE_NUM = 2;
    	
    	/**
    	 * 中等强度密码键盘规则匹配严格度,默认0.6
    	 */
    	private static double THRESHOLD_MEDIUM = 0.6;
    	
    	/**
    	 * 高安全度密码键盘规则匹配严格度,默认0.4
    	 */
    	private static double THRESHOLD_STRONG = 0.4;
    	
    	/**
    	 * 高安全度密码键盘规则匹配严格度,默认0.4
    	 */
    	private static double MAX_SEQUENTIAL_CHARS_THRESHOLD = 0.4;
    	
    	/**
    	 * 字母顺序A-Z
    	 */
    	private static String A_Z = "abcdefghijklmnopqrstuvwxyz";
    	
    	/**
    	 * 字母顺序Z-A
    	 */
    	private static String Z_A = "zyxwvutsrqponmlkjihgfedcba";
    	
    	/**
    	 * shift键产生的字符与非shift键时对应的字符
    	 */
    	private static Map CONVERSION_MAP =  new HashMap();
    	
    	/**
    	 * 将键盘按键格式话为4*10的矩阵的坐标
    	 */
    	private static Map DICTIONARY_MAP = new HashMap();
    	private static String[] dictionary1 = "1 2 3 4 5 6 7 8 9 0".split("\\s+");
    	private static String[] dictionary2 = "q w e r t y u i o p".split("\\s+");
    	private static String[] dictionary3 = "a s d f g h j k l ;".split("\\s+");
    	private static String[] dictionary4 = "z x c v b n m , . /".split("\\s+");
    	private static String[][] DICTIONARY_MATRIX = {dictionary1, dictionary2, dictionary3, dictionary4};
    	
    	static {	
    		CONVERSION_MAP.put("!", "1");
    		CONVERSION_MAP.put("@", "2");
    		CONVERSION_MAP.put("#", "3");
    		CONVERSION_MAP.put("$", "4");
    		CONVERSION_MAP.put("%", "5");
    		CONVERSION_MAP.put("^", "6");
    		CONVERSION_MAP.put("&", "7");
    		CONVERSION_MAP.put("*", "8");
    		CONVERSION_MAP.put("(", "9");
    		CONVERSION_MAP.put(")", "0");
    		CONVERSION_MAP.put(":", ";");
    		CONVERSION_MAP.put("<", ",");
    		CONVERSION_MAP.put(">", ".");
    		CONVERSION_MAP.put("?", "/");
    		
    		for(int i=0, ln=DICTIONARY_MATRIX.length; i<ln; i++) {
    			String[] dic = DICTIONARY_MATRIX[i];
    			for(int j=0, lnt=dic.length; j<lnt; j++) {
    				int[] row_cell = {i,j};
    				DICTIONARY_MAP.put(dic[j], row_cell);
    			}
    		}
    	}
    	
    	private CheckPWD(){
    		
    	}
    	
    	/**
    	 * 严格的键盘输入习惯匹配规则,匹配连续或者非连续的(可以匹配:1a2s3d4f5g这样的有规律的串),比matches方法的匹配规则更严格
    	 * @param matcherList
    	 * @param row_cellList
    	 * @param index
    	 */
    	private static void maches2(List matcherList, List row_cellList, int index) {
    		for(; index<row_cellList.size(); index++) {
    			int[] row_cell_t = (int[]) row_cellList.get(index);
    			if(row_cell_t != null) {
    				boolean flag = true;
    				for(int i=0; i<matcherList.size(); i++) {
    					List list = (List) matcherList.get(i);
    					for(int j=0; j<list.size(); j++) {
    						int[] row_cell = (int[]) list.get(j);
    						if(((Math.abs(row_cell_t[0] - row_cell[0]) <= 1) && (Math.abs(row_cell_t[1] - row_cell[1]) <= 1))) {
    							list.add(row_cell_t);
    							flag = false;
    							break;
    						}
    					}
    					if(!flag) break;
    				}
    				if(flag) {
    					List arrt = new ArrayList();
    					arrt.add(row_cell_t);
    					matcherList.add(arrt);
    				}
    			}
    		}
    	}
    	
    	/**
    	 * 键盘输入习惯匹配规则,匹配连续输入(不能匹配:1a2s3d4f5g这样的有规律的串),比maches2方法的匹配规则宽松
    	 * @param matcherList
    	 * @param row_cellList
    	 * @param index
    	 */
    	private static void matches(List matcherList, List row_cellList, int index) {
    		for(int i=0; i<matcherList.size(); i++) {
    			List list = (List) matcherList.get(i);
    			for(int ln=row_cellList.size(); index<ln; index++) {
    				int[] row_cell = (int[]) list.get(list.size()-1);
    				int[] row_cell_t = (int[]) row_cellList.get(index);
    				//如果相邻的键盘字符(某一个键的左右、上下、斜向相邻)被连续输入,在原匹配链条上增加新的输入
    				if((row_cell != null) && (row_cell_t != null) && 
    						((Math.abs(row_cell_t[0] - row_cell[0]) <= 1) && (Math.abs(row_cell_t[1] - row_cell[1]) <= 1))) {
    					list.add(row_cell_t);
    				}else {	//如果新字符和上一匹配链条的结尾字符距离较远,这结束上一匹配链条,以该字符为首增加新的匹配链条
    					List arrt = new ArrayList();
    					arrt.add(row_cell_t);
    					matcherList.add(arrt);
    					index++;
    					break;
    				}
    			}
    		}
    	}
    	
    	/**
    	 * 键盘规则匹配器,返回double
    	 * @param password  密码字符串
    	 * @return
    	 */
    	public static double keysetMatcher(String password, int matchesMode) { 
    		String t_password = new String(password);
    		t_password = t_password.toLowerCase();
    		t_password = canonicalizeWord(password);
    		logger.debug("****************将密码字符串转换为键盘矩阵的对应坐标 start******************");
    		char[] pwdCharArr = t_password.toCharArray();
    		List row_cellList = new ArrayList();
    		int Num = 0;
    		int startIndex = -1;
    		for(int i=0, ln= pwdCharArr.length; i<ln; i++) {
    			int[] row_cell = (int[]) DICTIONARY_MAP.get(String.valueOf(pwdCharArr[i]));
    			if(row_cell != null)  {
    				row_cellList.add(row_cell); 
    				Num++;
    				if(startIndex == -1) startIndex = i; 
    			} else row_cellList.add(null);
    		}
    		logger.debug("****************将密码字符串转换为键盘矩阵的对应坐标 end******************");
    		
    		logger.debug("****************初始化匹配链条 start******************");
    		int index = startIndex+1;
    		int[] row_cell0 = (int[]) row_cellList.get(startIndex);
    		List matcherList = new ArrayList();
    		List arr0 = new ArrayList();
    		arr0.add(row_cell0);
    		matcherList.add(arr0);
    		logger.debug("****************初始化匹配链条 end******************");
    		//根据匹配规则进行匹配
    		if(KEYSET_MATCHER_UNDEMANDING_MODE == matchesMode) matches(matcherList, row_cellList, index);	//不严格的匹配模式
    		else if(KEYSET_MATCHER_STRICT_MODE == matchesMode) maches2(matcherList, row_cellList, index);	//严格的匹配模式
    		
    		double rValue = 0;
    		for(double threshold = THRESHOLD_STRONG; threshold <= THRESHOLD_MEDIUM; threshold+=0.1) {
    			boolean flag = true;
    			int nMinimumMeaningfulMatchLength =  (int) (Num * threshold);
    			//特殊字符(~ ` - _ = + [ { ] } \ | ' ")所占比率上限
    			if(threshold <= ((t_password.length() - Num)*1.0/t_password.length())) flag = false;
    			if(flag) {
    				for(int i=0; i<matcherList.size(); i++) {
    					List list = (List) matcherList.get(i);
    					if(list.size() >= nMinimumMeaningfulMatchLength) {
    						flag = false;
    						return rValue;
    					}
    				}
    			}
    			if(flag) {
    				if(THRESHOLD_MEDIUM == THRESHOLD_STRONG) rValue = 10;
    				else rValue = 6 + 4*(THRESHOLD_MEDIUM-threshold)*1.0/(THRESHOLD_MEDIUM-THRESHOLD_STRONG);
    				break;
    			}
    		}
    		return rValue;
    	}
    
    	/**
    	 * 替换密码中的shift键产生的字符转换为非shift键时对应的字符
    	 * @param password	密码字符串
    	 * @return	替换后的密码字符串
    	 */
    	private static String canonicalizeWord(String password) {
    		StringBuffer sb = new StringBuffer();
    		if(password != null && password.length() > 0) {
    			for(int i=0; i<password.length(); i++) {
    				String cs = String.valueOf(password.charAt(i));
    				if(CONVERSION_MAP.get(cs) != null) sb.append(CONVERSION_MAP.get(cs));
    				else sb.append(cs);
    			}
    		}
    		return sb.toString();
    	}
    	
    	/**
    	 * 搜索字符str中是否包含有regex指定的正则表达式匹配的子串
    	 * @param str 待搜索字符串
    	 * @param regex	正则表达式字符串
    	 * @return	包含匹配子串返回true,否则返回false
    	 */
    	private static boolean stringFind(String str, String regex) {
    		Pattern p = Pattern.compile(regex);
    		Matcher m = p.matcher(str);
    		if(m.find()) return true;
    		return false;
    	}
    	
    	/**
    	 * 评估密码中包含的字符类型是否符合要求,如果低于下限返回0,否则返回6 + (字符类型总数 - 下限) * 2
    	 * @param password  密码字符串
    	 * @param num 密码至少包含的字符类型数(a-z,A-Z,0-9,特殊字符),默认为2
    	 * @return 
    	 */
    	public static double checkCharTypeNum(String password, int num) {
    		int typeNum = 0;
    		if(stringFind(password, "[a-z]+")) typeNum++;
    		if(stringFind(password, "[0-9]+")) typeNum++;
    		if(stringFind(password, "[A-Z]+")) typeNum++;
    		if(stringFind(password, "\\p{Punct}+")) typeNum++;
    		double rValue = 0;
    		if(typeNum >= num) {
    			if(num == 4) rValue = 10;
    			else rValue = 6 + (typeNum - num)*1.0/(4-num) * 4; 
    		}
    		return rValue;
    	}
    	
    	/**
    	 * 评估a-z,z-a这样的连续字符,返回一个double,如果连续字符占整个串长度的40%以上返回0,否则返回(1-连续字符占整个串长度的百分比) * 10
    	 * @param password
    	 * @return
    	 */
    	public static double checkSequentialChars(String password) {
    		String t_password = new String(password);
    		t_password = t_password.toLowerCase();
    		double rValue = 0;
    		int i = 2;
    		int n = t_password.length();
    		for(; i<n; i++) {
    			boolean flag = true;
    			for(int j=0; j+i<n; j++) {
    				String str = t_password.substring(j, j+i);
    				if((A_Z.indexOf(str) != -1) || (Z_A.indexOf(str) != -1)) {
    					flag = false;
    					break;
    				}
    			}
    			if(flag) {
    				if(i*1.0/n > MAX_SEQUENTIAL_CHARS_THRESHOLD)  rValue = 0;
    				else rValue = (1-i*1.0/n) * 10;
    				break;
    			}
    		}
    		return rValue;
    	}
    	
    	/**
    	 * 评估密码至少包含的不同字符数(不区分大、小写),返回int,如果字符数小于下限返回0,否则返回6 + (包含字符数 - 下限),如果大于10,返回10
    	 * @param password 密码字符串
    	 * @param num 密码至少包含的字符类型数(a-z,A-Z,0-9,特殊字符),默认为2
    	 * @return
    	 */
    	public static double checkMinContainCharNum(String password, int num) {
    		String t_password = new String(password);
    //		t_password = t_password.replaceAll("(.)\\1+", "$1");
    		t_password = t_password.toLowerCase();
    		t_password = canonicalizeWord(password);
    		Map map = new HashMap();
    		int snum = 0;
    		for(int i=0,ln= t_password.length(); i<ln; i++) {
    			String cs = String.valueOf(t_password.charAt(i));
    			if(map.get(cs) == null) {
    				map.put(cs, cs);
    				snum++;
    			}
    		}
    		double rValue = 0;
    		if(snum >= num) rValue = 6 + (snum - num);
    		return (rValue > 10 ? 10 : rValue);
    	}
    	
    	/**
    	 * 评估密码强度,根据密码长度,包含的字符类型,包含不同字符数,包含的连续字符,键盘输入习惯综合评估密码强度,返回0-10的double
    	 * @param password
    	 * @return
    	 */
    	public static double evalPWD(String password, int matchesMode) {
    		if(password == null || "".equals(password.replaceAll("\\s+", ""))) return 0;		//判断密码为null或""
    		if(MIN_LENGTH > password.length()) return 0;				//判断密码长度是否符合
    		
    		double[] val = new double[1000];
    		int n = 0;
    		for(int i=MIN_LENGTH; i<=password.length(); i++) {
    			String t_password = password.substring(0, i);
    			//评估密码中包含的字符类型是否符合要求
    			double typeNumCheckResult = checkCharTypeNum(t_password,MIN_CHAR_TYPE_NUM);
    			//评估密码至少包含的不同字符数(不区分大、小写)
    			double minContainCharNumCheckResult = checkMinContainCharNum(t_password, MIN_CONTAIN_CHAR_NUM);
    			//评估a-z,z-a这样的连续字符
    			double sequentialCharsCheckResult = checkSequentialChars(t_password);
    			//评估键盘输入习惯
    			double keysetMatcherResult = keysetMatcher(t_password, matchesMode);
    			logger.debug("评估密码中包含的字符类型结果:"+typeNumCheckResult);
    			logger.debug("评估密码至少包含的不同字符数结果:"+minContainCharNumCheckResult);
    			logger.debug("评估a-z,z-a这样的连续字符结果:"+sequentialCharsCheckResult);
    			logger.debug("评估键盘输入习惯结果:"+keysetMatcherResult);
    			if(typeNumCheckResult == 0 || minContainCharNumCheckResult == 0 || sequentialCharsCheckResult == 0 || keysetMatcherResult == 0) {
    				val[n] = 0;
    			}else {
    				val[n] = typeNumCheckResult*CHAR_TYPE_NUM_THRESHOLD + minContainCharNumCheckResult*MIN_CONTAIN_CHAR_NUM_THRESHOLD + 
    					sequentialCharsCheckResult*SEQUENTIAL_CHARS_THRESHOLD + keysetMatcherResult*KEYSET_MATCHER_THRESHOLD;
    			}
    			n++;
    		}
    		double rValue = 0;
    		boolean flag = false;
    		for(int i=0; i<n; i++) {
    			if(val[i] != 0) {
    				rValue += val[i];
    				flag = true;
    			}
    			if(flag && val[i] == 0) rValue += 1;
    			if(rValue >= 10) {
    				rValue = 10;
    				break;
    			}
    		}
    		return rValue;
    		
    //		//评估密码中包含的字符类型是否符合要求
    //		double typeNumCheckResult = checkCharTypeNum(password,MIN_CHAR_TYPE_NUM);
    //		//评估密码至少包含的不同字符数(不区分大、小写)
    //		double minContainCharNumCheckResult = checkMinContainCharNum(password, MIN_CONTAIN_CHAR_NUM);
    //		//评估a-z,z-a这样的连续字符
    //		double sequentialCharsCheckResult = checkSequentialChars(password);
    //		//评估键盘输入习惯
    //		double keysetMatcherResult = keysetMatcher(password, matchesMode);
    //		logger.debug("评估密码中包含的字符类型结果:"+typeNumCheckResult);
    //		logger.debug("评估密码至少包含的不同字符数结果:"+minContainCharNumCheckResult);
    //		logger.debug("评估a-z,z-a这样的连续字符结果:"+sequentialCharsCheckResult);
    //		logger.debug("评估键盘输入习惯结果:"+keysetMatcherResult);
    //		if(typeNumCheckResult == 0 || minContainCharNumCheckResult == 0 || sequentialCharsCheckResult == 0 || keysetMatcherResult == 0) {
    //			return 0;
    //		}else {
    //			return typeNumCheckResult*CHAR_TYPE_NUM_THRESHOLD + minContainCharNumCheckResult*MIN_CONTAIN_CHAR_NUM_THRESHOLD + 
    //				sequentialCharsCheckResult*SEQUENTIAL_CHARS_THRESHOLD + keysetMatcherResult*KEYSET_MATCHER_THRESHOLD;
    //		}
    	}
    	
    	/**
    	 * 用严格模式校验密码强度,根据密码评估结果判断密码是否可用,默认评估结果大于7的可用
    	 * @param password
    	 * @return
    	 */
    	public static boolean checkPwdInStrictMode(String password) {
    		double rValue = evalPWD(password, KEYSET_MATCHER_STRICT_MODE);
    		if(rValue >= PASSWORD_STRONG)  return true;
    		return false;
    	}
    
    	/**
    	 * 非严格模式校验密码强度,根据密码评估结果判断密码是否可用,默认评估结果大于7的可用
    	 * @param password
    	 * @return
    	 */
    	public static boolean checkPwdIndemandingMode(String password) {
    		double rValue = evalPWD(password, KEYSET_MATCHER_UNDEMANDING_MODE);
    		if(rValue >= PASSWORD_STRONG)  return true;
    		return false;
    	}
    	
    	public static void main(String[] args) {
    		String[] sArr = {
    				"1a2s3d4f5g6h",
    				"zcvjlufw123433546",
    				"~]sdfa^9mi|",
    				"`%0,uTs85vkj",
    				"liulanggood123",
    				"PASSword_123",
    				"yanghao1234",
    				"yanghao123",
    				"yanghao1981"
    		};
    		for(int i=0; i<sArr.length; i++) {
    			System.out.println("严格模式下校验"+sArr[i]+"的密码强度:"+evalPWD(sArr[i], KEYSET_MATCHER_STRICT_MODE));
    			System.out.println("非格模式下校验"+sArr[i]+"的密码强度:"+evalPWD(sArr[i], KEYSET_MATCHER_UNDEMANDING_MODE));
    		}
    		
    	}
    }
    
     
    展开全文
  • 弱口令/敏感后台

    2016-04-20 16:19:00
    其实,任何一种类型的漏洞,都没有弱口令来的简单、奏效,弱口令攻击一般就是直接打管理员的后台页面,以及远程3389 /21/22/23/1433/3306/1521等服务。因此,我们还得先研究下怎么找到这些后台及服务的入口。对于...
  • 漏洞-弱口令介绍与自动攻击示范

    千次阅读 2016-11-07 00:29:24
    基本漏洞类型弱口令top100, web测试密码爆破遍历与弱口令尝试神器Burp的攻击演示
  • 一、弱口令检测——John the Ripper 1、下载并安装John the Ripper 2、检测弱口令账号 3、使用密码字典文件 二、网络扫描——NMAP 1、安装NMAP软件包 2、扫描语法及类型 3、扫描操作示例: 一、弱口令检测——John...
  • 弱口令扫描 ---- Hashcat破解hash

    千次阅读 2018-03-20 21:53:52
    弱口令扫描 —- Hashcat破解hash 在弱口令扫描过程中,有可能对公司正常业务造成一定程度的影响。因此有时候可以尝试用破解工具破解hash值也是一种弱口令扫描方法,能够被破解的hash值也被认为是弱口令或弱Hash。 ...
  • 系统弱口令检测 Joth the Ripper ,简称JR 一款密码分析工具,支持字典式的暴力破解 通过对 shadow 文件的口令分析,可以检测密码强度 官网网站:http://www.openwall.com/john/ 安装JR工具 安装方法:make clean...
  • 实战某省师范大学弱口令js泄露 0x01 前言: 夜黑风高的夜晚,正和当年一起走信安道路的小伙伴规划计划时,某某人挑衅了一下哈哈,所以我必须来点狠料啊. 0x002 信息收集 首先进入首页发现是静态主站就不要想注入了,...
  • 文章目录系统弱口令检测网络扫描(NMAP) 系统弱口令检测 JR 一款密码分析工具,支持字典式的暴力破解 通过对shadow文件的口令分析,可以检测密码强度 官方网站:http://www.openwall.com/john/ 安装JR工具 安装方法...
  • 简称为JR一款密码分析工具,支持字典式的暴力破解通过对shadow文件的口令分析,可以检测密码强度官方网站:http://www.openwall.com/john/2、安装JR工具lean 系统类型主程序文件为John3、检测弱口令账号获得Linux/...
  • 这里写自定义目录标题一、系统弱口令检测joth the Ripper (简称为 JR)二、网络端口扫描2.1 NMAP2.2 NMAP常用选项和扫描类型 一、系统弱口令检测 joth the Ripper (简称为 JR) 一款密码分析工具,支持字典式的...
  • 2.登陆抓包进行爆破,设置一个位置,然后选择类型为custom iterator,然后在下面payload选项中选择三个位置,然后增加编码的方式,最后一定要取消勾选,在选项最下面的url编码特殊字符,否则就算爆出了弱口令也无法...
  • 云计算~John the Ripper弱口令检测网络端口扫描(nmap)查看主机的网络信息inode和block的认识如何恢复EXT类型的文件 John the Ripper弱口令检测 可以使用密码字典(各种密码组合的列表文件)来暴力破解,所以能够破解的...
  • Web安全漏洞-弱口令 常见处理方式

    千次阅读 2020-06-01 17:19:05
    ——密码要求8位以上,包含大小写字母、数字、特殊符号等类型中至少两种。 2.所有密码之间不能有任何关联,如不能由邮箱的密码推测出OA的密码。 3.所有密码不得采用单一的英文单词、拼音或其他有意义的词语和符号...
  • 密码策略和工作单 本部分介绍密码策略设置,并提供一个工作单,以帮助您定义符合要求的密码策略。 注 – ...为特定类型的用户定义密码策略时,需要考虑以下注意事项: 当入侵者看上去要尝试破解密码时如...
  • 弱口令猜测工具-John The Ripper

    千次阅读 2018-12-13 15:27:58
    John the Ripper免费的开源软件,是一...它支持多种不同类型的系统架构,包括Unix、Linux、Windows、DOS模式、BeOS和OpenVMS,主要目的是破解不够牢固的Unix/Linux系统密码。目前的最新版本是John the Ripper 1.8.0...
  • 以 kali自带的hydra为例进行演示,linux版和 windows版的hydra,在使用上几乎是一样的,需要注意的是,有些库没编译进去导致某些服务爆破模块不可用...-x 不用自己准备好的字典,而是直接指定类型在线生成的字典进...
  • 读入数据总结一、系统弱口令检测二、???? nmap命令常用选项与对应扫描类型 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器...
  • 终端及登录控制2.1 禁止 root 用户登录2.2 禁止普通用户登录二、弱口令检测与端口扫描1.弱口令检测——John the Ripper1.1 下载并且安装 John the Ripper1.2 检测弱口令账号1.3 使用密码字典文件2.网络扫描——NMAP1...
  • 最大的区别在于,“==”是判断数值是否相等,“===”则是判断数值和类型是否相等,那就错了,这并没有说到最核心的一个关键点,要知道“==”最可怕的一点是,如果类型不同的进行比较,其会将类型转换成相同的再进行...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 206
精华内容 82
关键字:

弱口令类型