精华内容
下载资源
问答
  • 华为路由器登录方式设置

    千次阅读 2019-06-07 21:22:04
    例如,我们想在AR3上面远程登录AR2, <r2> <r2>sy Enter system view, return user view with Ctrl+Z. [r2]inter g [r2]inter GigabitEthernet 0/0/1 [r2-GigabitEthernet0/0/1]ip add 10.0.23....

    首先我们设置相应的接口地址

    例如,我们想在AR3上面远程登录AR2,

    <r2>
    <r2>sy
    Enter system view, return user view with Ctrl+Z.
    [r2]inter g    
    [r2]inter GigabitEthernet 0/0/1
    [r2-GigabitEthernet0/0/1]ip add 10.0.23.2 24 
    [r2-GigabitEthernet0/0/1]

    <r3>
    <r3>sy
    Enter system view, return user view with Ctrl+Z.
    [r3]inter g    
    [r3]inter GigabitEthernet 0/0/1
    [r3-GigabitEthernet0/0/1]ip add 10.0.23.3 24 
    [r3-GigabitEthernet0/0/1]

    接下来设置登录方式(以Telnet登录为例,其它登录方式类似)

    第一种方式是aaa认证模式

    [r2]user-interface vty 0 4 
    [r2-ui-vty0-4]authentication-mode aaa 
    [r2-ui-vty0-4]qu
    [r2]aaa
    [r2-aaa]local-user huawei service-type telnet 
    Info: Add a new user.
    [r2-aaa]local-user huawei password cipher huawei 
    [r2-aaa]

    接下来我们登多发现很多命令都没有显示出来,那是因为权限不够,我们在R2上添加一条命令

    [r2-aaa]local-user huawei privilege level 15 
    再次登录

     

    命令是不是多了,那是因为给的是最高权限,你也可以根据需要给相应的权限。

    第二种方式是password认证模式

     [r2]user-interface vty 0 4 

    [r2-ui-vty0-4]authentication-mode password 
    Please configure the login password (maximum length 16):admin
    [r2-ui-vty0-4]qu
    [r2]super password cipher admin123   (记得设置超级权限密码,要不你进去的只是访问级)
     

    总结一下:

    Telnet认证有两种模式:AAA模式,密码模式。
    1. 当配置用户界面的认证方式为AAA时,用户登录设备时需要首先输
    入登录用户名和密码才能登录。
    2. 当配置用户界面的认证方式为password时,用户登录设备时需要首
    先输入登录密码才能登录。

    展开全文
  • 命令注释,中英对比,清晰明了,可用于命令学习与查询!
  • 运行时请在其目录下添加user.txt passwd.txt两文件。否则会报错。程序没有加异常处理。代码比较挫….. 复制代码 代码如下: #coding:utf-8- import base64 import urllib2 import Queue import threading,re,sys ...
  • 电信天翼网关路由器忘记登录密码解决方法解决方法1解决方法2解决方法3解决方法4 ...路由器后面有个复位的按钮,长按住不动,一直按着等灯闪了之后再松手,路由器恢复出厂设置后再使用路由器背面的默认密码登录。 解决方

    电信天翼网关路由器忘记登录密码

    忘记密码不用怕,以下方法可帮你解决。
    在这里插入图片描述

    解决方法

    忘记密码别着急,可以通过以下方法来解决。

    解决方法1

    找到自家的路由器,一般情况下载路由器的背面有默认的账号密码,可以试下。这种情况适合于您从来没有修改过默认密码。

    解决方法2

    如果您已经修改过默认密码,又不记得新密码, 可以测试恢复出厂设置,让密码重置。路由器后面有个复位的按钮,长按住不动,一直按着等灯闪了之后再松手,路由器恢复出厂设置后再使用路由器背面的默认密码登录。

    解决方法3

    如果方法2解决不了,恢复出厂设置使用原密码还是登录不了,可以尝试使用工作人员默认密码nE7jA%5m这种方式看机型,不同的机型有可能密码不一样,试一下,成功地可能性很大。

    解决方法4

    如果以上方法都解决不了,那自己是无法解决的了,终极大招,打电话到10000号,咨询人工服务。
    希望以上方法能够帮助您!如果帮助到您感谢免费的点赞关注。

    展开全文
  • 本文博客地址:... 一、360路由器登录协议分析的工具配置  1. 路由器型号:360路由器P2  2. 浏览器:火狐浏览器  3. 抓包分析工具:Burp Suite 和 Wireshark 二、360路由器登录协议的分析 通过对3

    本文博客地址:http://blog.csdn.net/qq1084283172/article/details/78878057

    一、360路由器登录协议分析的工具配置

          1. 路由器型号:360路由器P2

          2. 浏览器:火狐浏览器

          3. 抓包分析工具:Burp Suite 和 Wireshark


    二、360路由器登录协议的分析

    通过对360路由器 P2的包装信息进行查看,发现360路由器P2的web登录页面的ip地址为 192.168.0.1 端口为 80,在进行路由器登录协议分析之前,先自己尝试使用浏览器进行路由器登录页面的测试,比如,输入错误的路由器登录密码和输入正确的路由器登录密码,看看路由器登录页面的错误提示,方便后面对路由器的登录web页面的分析,熟悉和了解一下路由器web管理登录的流程,然后再去分析路由器的登录协议,在进行路由器登录协议分析的时候,通过wifi网络或者网线将电脑或者手机连接到路由器设备,登录路由器的web控制界面,然后将 路由器的web管理页面的Html网页全部保存下来,用以接下来路由器登录协议的分析和模拟,还有一个地方需要注意,对于路由器的登录管理,PC的web登录管理,Android或者iOS的web登录管理,Android或者iOS的App管理登录的协议可能是不同也可能都是相同的,有的路由器的App管理终端就是webview嵌套的web页面请求,有的路由器的App管理终端是自己实现另外一种不同web登录页面管理的App协议。




    1. 360路由器P2的PC端Web管理登录页面截图


    2.  对360路由器P2的PC端Web管理登录页面的Html页面进行分析,了解360路由器登录页面的流程。

    (1). 360路由器P2的PC端Web管理登录页面的点击登录按钮处理发送登录请求的事件是由 函数loginIn( ) 来处理的。



    (2). 360路由器P2的PC端Web管理登录的默认用户名是 admin(不需要用户输入,就保存在登录的web页面中),管理员登录的用户登录信息就保存在变量 obj 中,obj.user 保存管理员登录的用户名 adminobj.pass 保存管理员登录的密码(将用户输入的密码进行 AES/CBC/PKCS7Padding 填充AES 加密得到),obj.from 保存管理员登录的登录方式,通过PC登录的此值为1,然后将用户的登录信息 obj 通过 Http 请求 /router/web_login.cgi  POST发送给360路由器P2进行管理员登录验证处理,是这么简单么?还需去 函数getAesString( )  中进行查看一下。

    <script>   
    
     function loginIn() {
    	
    	
            if ($.cookie("Qihoo_360_login")) {
                $.cookie('Qihoo_360_login', null, {
                    path: '/',
                    expires: 1
                });
            }
    		
    		// 保存发送给路由器的数据的信息
            var obj = {};
    		
    		// 获取默认的用户名:admin
            obj.user = igd.global_param.default_user;
    		// 获取用户输入的密码进行AES加密处理
    		// AES/CBC/PKCS7Padding
            obj.pass = getAesString($("#login_pwd").val());
            obj.from = 1;//PC
    		
            if (check_input("login_frm")) {
    		
    			// 向路由器发送数据信息
                $.post("/router/web_login.cgi", obj, function (data) {
                    try {
    				
                        data = eval("(" + data + ")");
    					// 判断路由器是否登陆成功
    					// {"success":"1","token_id":"c6c0511d81b75a3fae36fbe5532ba353"}
                        if (data["success"]=="1"&&data["token_id"]!="") {
    					
    					   // 登陆成功,跳转到登陆路由器的信息主页上
                           location.href = "./new_index.htm?token_id="+data["token_id"];
                        }
                        else {
                            if (!isNaN(data.err_no) && (data.err_no == "48" || data.err_no == "49"|| data.err_no == "50"|| data.err_no == "51"|| data.err_no == "52")) {
                                show_message("login_failure" + data.err_no);
                            } else {
                                show_message("login_failure");
                            }
                        }
                    }
                    catch (e) {
                        show_message("login_failure");
                    }
                });
            }
        }
    	
    	var status_detect_timer;
    	
    	function wan_status_detect_loop(){
    		$.post("/router/interface_status_show.cgi", {noneed: "noneed"});
    		if(status_detect_timer)
    			window.setInterval(status_detect_timer);
    		status_detect_timer = window.setInterval(function(){
    			//console.log("do not release link");
    			$.post("/router/interface_status_show.cgi", {noneed: "noneed"});
    		},30*1000);
    	}
    	
    </script>

    (3). 在360路由器P2的管理员登录的 new_lib.js 文件中找到的 函数getAesString( )  实现,先调用 函数get_rand_key() 发送 GET方式 的Http请求 /router/get_rand_key.cgi 获取返回的 key_index (前32位)对应的 rand_key 值(后32位),这个rand_key值将作为 AES 加密用户输入密码的 AES秘钥参数key。每次进行360路由器P2管理员登录的时候,key_index 和 rand_key值是成对由360路由器P2生成,返回给web登录管理页面使用的,使用rand_key值作为 CryptoJS.pad.Pkcs7 填充的AES加密算法的密钥参数,对用户输入的密码进行AES加密,然后将 AES加密后的用户密码(后32位)和key_index(前32位)成对的,通过 POST方式 的Http请求 /router/web_login.cgi 发送360路由器P2进行管理员登录的验证,等待360路由器P2返回登录成功或者登录失败的结果。

    // #################################################################################################
    
    
    // 进行路由器的登陆测试
        function loginIn() {
    	
    	
            if ($.cookie("Qihoo_360_login")) {
                $.cookie('Qihoo_360_login', null, {
                    path: '/',
                    expires: 1
                });
            }
    		
            var obj = {};
    		// "admin"
            obj.user = igd.global_param.default_user;
    		// 获取用户输入的密码加密后的明文
            obj.pass = getAesString($("#login_pwd").val());
            obj.from = 1;//PC
    		
            if (check_input("login_frm")) {
                $.post("/router/web_login.cgi", obj, function (data) {
                    try {
                        data = eval("(" + data + ")");
    
    					// 登陆成功的情况下
                        if (data["success"]=="1"&&data["token_id"]!="") {
                           location.href = "./new_index.htm?token_id="+data["token_id"];
                        }
                        else {
                            if (!isNaN(data.err_no) && (data.err_no == "48" || data.err_no == "49"|| data.err_no == "50"|| data.err_no == "51"|| data.err_no == "52")) {
                                show_message("login_failure" + data.err_no);
                            } else {
                                show_message("login_failure");
                            }
                        }
                    }
                    catch (e) {
                        show_message("login_failure");
                    }
                });
            }
        }
    	
    // #################################################################################################
    
    // 获取随机密码
    // {"rand_key":"3dac6a73e34fa79fc9364d009f437e8162b0c5bee6082887df50116679231247"}
    // 前32位index,后32位aes的key
    // 3dac6a73e34fa79fc9364d009f437e81 62b0c5bee6082887df50116679231247
    
    function get_rand_key(error_count, key_index, is_get) {
    	
        error_count = error_count || 0;
        if (error_count > 5) {
            return "";
        }
    	
    	// 获取生成的_key_index
        if (key_index) {
    		
    		// substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符。
    		// 获取随机32位数字
            key_index = key_index.substr(0, 32);
        }
    	
        if (is_get && key_index == "") {
            return "";
        }
    	
    	// arguments.callee 在哪一个函数中运行,它就代表哪一个函数
        var calleeFn = arguments.callee;
    	
    	// 用户保存获取返回的数据
        var retObj = {
            "rand_key": "",
            "key_index": key_index
        };
    	
    	// 向指定的url发送数据获取key
        $.ajax({
            url: "/router/get_rand_key.cgi",
            data: {
                "noneed": "noneed",
                "key_index": key_index
            },
            dataType: "json",
            async: false,
    		// 失败情况
            error: function (XMLHttpRequest, textStatus) {
    			// 再次调用当前函数
                retObj = calleeFn(error_count, key_index, is_get);
    
            },
    		// 成功的情况
            success: function (data) {
                if (is_get && data.err_no * 1) {
                    retObj["rand_key"] = "";
                } else {
                    if (data.rand_key) {
    					
    					// 获取返回的数据(后32位)
                        retObj["rand_key"] = data.rand_key.substring(32, 64);
    					// 获取返回的数据(前32位)
                        retObj["key_index"] = data.rand_key.substring(0, 32);
    					
                    } else {
                        retObj = calleeFn(error_count, key_index, is_get);
                    }
                }
    
            }
        });
    
        return retObj;
    }
    
    /* end by houbingyang */
    
    
    // 进行字符串的AES加密
    // user=admin&pass=3dac6a73e34fa79fc9364d009f437e81104ba5af88ebb24bc69ed56dee27327b&from=1
    // 3dac6a73e34fa79fc9364d009f437e81 104ba5af88ebb24bc69ed56dee27327b
    // 前32位index,后32位AES加密后的字符串
    function getAesString(str, keyObj) {
    	
    	// 首先获取随机密码
        var lengthKeyObj = keyObj || get_rand_key(0);
        var key = CryptoJS.enc.Hex.parse(lengthKeyObj.rand_key);
        var iv = CryptoJS.enc.Latin1.parse("360luyou@install");
    	
    	// 进行AES的加密
        var encrypted = CryptoJS.AES.encrypt(str, key, {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
        var cipher_text = encrypted.ciphertext.toString();
        //var retObj={
        //    "cipher_text":cipher_text,
        //    "key_index":lengthKeyObj.key_index
        //}
        return lengthKeyObj.key_index + cipher_text;
    }
    
    // AES解密
    function getDAesString(str, keys) {
    
        var ciphertext = str.substr(32, str.length - 32);
        var lengthKeyObj = {};
        if (keys) {
            lengthKeyObj.rand_key = keys;
        } else {
            lengthKeyObj = get_rand_key(0, str, true);
        }
        if (!lengthKeyObj.rand_key) {
            return str;
        }
        var key = CryptoJS.enc.Hex.parse(lengthKeyObj.rand_key);
        var iv = CryptoJS.enc.Latin1.parse("360luyou@install");
        var str16T64 = CryptoJS.enc.Hex.parse(ciphertext).toString(CryptoJS.enc.Base64);
        var decrypted = CryptoJS.AES.decrypt(str16T64, key, {
            iv: iv,
            mode: CryptoJS.mode.CBC,
            padding: CryptoJS.pad.Pkcs7
        });
        return decrypted.toString(CryptoJS.enc.Utf8);
    }

    (4). 使用抓包工具Wireshark,对360路由器P2进行PC端Web页面管理员登录成功和登录失败的网络数据抓包结果。

    360路由器P2进行 管理员登录成功 的网络数据包结果截图如下所示:

    1.  发送GET方式的HTTP请求 GET /router/get_rand_key.cgi  获取加密用户登录密码的AES算法的 密钥参数rand_key。


    2. 发送POST方式的HTTP请求 POST /router/web_login.cgi 将AES加密的用户登录密码和用户登录用户名admin,发送给360路由器P2进行管理员登录的验证。



    360路由器P2进行 管理员登录失败 的网络数据包结果截图如下所示:

    1.  发送GET方式的HTTP请求 GET /router/get_rand_key.cgi  获取加密用户登录密码的AES算法的 密钥参数rand_key。


    2. 发送POST方式的HTTP请求 POST /router/web_login.cgi 将AES加密的用户登录密码和用户登录用户名admin,发送给360路由器P2进行管理员登录的验证。



    (5). 360路由器P2的PC端Web管理员登录成功和登录失败情况下发送的网络数据包和接收的网络数据包的整理,后面进行路由器管理员登录协议实现的时候,会根据下面的这份数据包来进行编程和登录协议的实现。

    登陆成功的情况:
    
    登陆密码:xxxxxxx(不便于泄露)
    
    第1步,先向服务器发送13位随机数字none为1496719266392
    GET /router/get_rand_key.cgi?noneed=noneed&_=1496719266392 HTTP/1.1
    Host: 192.168.0.1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0
    Accept: application/json, text/javascript, */*; q=0.01
    Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
    Accept-Encoding: gzip, deflate
    X-Requested-With: XMLHttpRequest
    Referer: http://192.168.0.1/login_pc.htm
    Cookie: bLanguage=cn; ecos_pw=Y20yMDE3MDMzMQ==1qw:language=cn
    Connection: keep-alive
    
    HTTP/1.1 200 OK
    Server: Boa/0.94
    Date: Sat, 21 Dec 2013 12:00:00 GMT
    Connection: close
    Cache-Control: no-cache
    Content-Type: text/plain; charset=UTF-8
    
    {"rand_key":"3dac6a73e34fa79fc9364d009f437e8162b0c5bee6082887df50116679231247"}
    // 前32位index,后32位aes的key
    // 3dac6a73e34fa79fc9364d009f437e81 62b0c5bee6082887df50116679231247
    
    
    第2步:
    POST /router/web_login.cgi HTTP/1.1
    Host: 192.168.0.1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0
    Accept: */*
    Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
    Accept-Encoding: gzip, deflate
    Content-Type: application/x-www-form-urlencoded; charset=UTF-8
    X-Requested-With: XMLHttpRequest
    Referer: http://192.168.0.1/login_pc.htm
    Content-Length: 87
    Cookie: bLanguage=cn; ecos_pw=Y20yMDE3MDMzMQ==1qw:language=cn
    Connection: keep-alive
    
    user=admin&pass=3dac6a73e34fa79fc9364d009f437e81104ba5af88ebb24bc69ed56dee27327b&from=1
    // 3dac6a73e34fa79fc9364d009f437e81 104ba5af88ebb24bc69ed56dee27327b
    // 前32位index,后32位AES加密后的字符串
    
    HTTP/1.1 200 OK
    Set-Cookie: Qihoo_360_login=47c28506a01d1c94e6ae3df57910f0ac;path=/
    Connection: close
    content-type: text/plain; charset=UTF-8
    
    {"success":"1","token_id":"c6c0511d81b75a3fae36fbe5532ba353"}
    
    
    
    登陆失败的情况: 
    
    第1步:
    GET /router/get_rand_key.cgi?noneed=noneed&_=1496729004297 HTTP/1.1
    Host: 192.168.0.1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0
    Accept: application/json, text/javascript, */*; q=0.01
    Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
    Accept-Encoding: gzip, deflate
    X-Requested-With: XMLHttpRequest
    Referer: http://192.168.0.1/login_pc.htm
    Cookie: bLanguage=cn; ecos_pw=Y20yMDE3MDMzMQ==1qw:language=cn
    Connection: keep-alive
    
    
    HTTP/1.1 200 OK
    Server: Boa/0.94
    Date: Sat, 21 Dec 2013 12:00:00 GMT
    Connection: close
    Cache-Control: no-cache
    Content-Type: text/plain; charset=UTF-8
    
    {"rand_key":"ea7d47cefd63733d14834950ecc30517d7078b324f804024a17f1b08bf4c817e"}
    
    
    第2步:
    POST /router/web_login.cgi HTTP/1.1
    Host: 192.168.0.1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0
    Accept: */*
    Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
    Accept-Encoding: gzip, deflate
    Content-Type: application/x-www-form-urlencoded; charset=UTF-8
    X-Requested-With: XMLHttpRequest
    Referer: http://192.168.0.1/login_pc.htm
    Content-Length: 87
    Cookie: bLanguage=cn; ecos_pw=Y20yMDE3MDMzMQ==1qw:language=cn
    Connection: keep-alive
    
    user=admin&pass=ea7d47cefd63733d14834950ecc305170743dc6d51d72ec338c520b9ec6dec2a&from=1
    
    
    HTTP/1.1 200 OK
    Server: Boa/0.94
    Date: Sat, 21 Dec 2013 12:00:00 GMT
    Connection: close
    Cache-Control: no-cache
    Content-Type: text/plain; charset=UTF-8
    
    {"err_no":"36","err_msg":"user or password err"}

    (6). 在进行360路由器P2的管理员登录协议编码实现并测试的时候,由于每次路由器返回的rand_key都是不同的,导致加密流程测试不是很方便,每次都要重新计算AES加密数据进行验证比较麻烦,因此 修改new_lib.js文件 以360路由器P2一次管理员登录的数据包为例,即选取一次管理员登录过程中,360路由器P2返回给管理员web页面的rand_key值为"AES/CBC/PKCS7Padding"填充的AES加密算法的密钥参数key(固定下来),将index_key也固定下来 ,用户输入的密码也固定下来。对new_lib.js文件的修改如下所示,后面进行360路由器P2的管理员登录协议的编码实现测试的时候,就以这3个固定的数据(index_key、rand_key、固定的用户密码)为例进行路由器登录协议算法加密模拟是否正确的测试,只要每一步编码得到的结果和下面代码中 alert打印 出来的数据对应上了,就说明编写的360路由器P2的登录协议的算法加密的模拟是正确的。


    使用修改后的 new_lib.js文件 ,在360路由器P2管理员登录web页面点击 登录 按钮,每点击一次就会 alert打印 出AES加密算法每一步加密操作的数据。


    (7). 360路由器P2在对用户输入的登录密码进行加密操作所采用的加密算法AES是用 "AES/CBC/PKCS7Padding" 进行填充的 CBC模式 AES128 加密算法,但是Java的AES算法API不支持PKCS7Padding,只支持PKCS5Padding,因此这里需要选择 开源的bouncycastle组件 来实现"AES/CBC/PKCS7Padding" 填充的AES 128加密,具体的详细细节可以参考文章《Android 使用AES/CBC/PKCS7Padding 加解密字符串》,后面对360路由器P2的登录协议中AES 128加密算法的模拟实现也是在这篇文章的代码中进行修改而来的,在路由器登录协议模拟实现过程中用到的一些算法加密的工具类都是在网上一些博客文章中找到的,使用的时候进行了相应的修改,有的忘记作者博客的链接了,要是侵权了告诉我,我做修改;能记得原作者的博客文章地址的,我会给出链接,对原作者一并表示感谢。


    三、360路由器P2登录协议模拟的编码实现

    1. RouterLogin类是抽象类,getRouterLoginRetCode( )是函数接口,通过函数getRouterLoginRetCode的返回值是否为0即可知道360路由器P2是否登录成功,登录不成功该函数的返回值为-1。

            // 360路由器的登陆测试
    //        RouterLogin routerLogin360 = new QihooRouterLogin("192.168.0.1", 80, "");
    //        int nRetCode360 = routerLogin360.getRouterLoginRetCode("admin", "xxxxxx");
    //        System.out.println("ec 360:"+nRetCode360);

    2. 抽象类RouterLogin的实现 RouterLogin.java文件 。

    package com.login.core;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.ProtocolException;
    import java.net.URL;
    
    
    public abstract class RouterLogin {
    	
    	// 访问的ip地址
    	protected String mIpAddress;
    	// 访问的ip地址的端口
    	protected int mPort;
    	// 访问的Ip地址补充的路径
    	protected String mFilePath;
    	
    	// 登陆路由器的用户名
    	protected String mUserName;
    	// 登陆路由器的密码
    	protected String mPassWord;
    
    	// 是否进行路由器的登陆尝试的标记
    	protected boolean mIsTryLogin;
    	// 登陆路由器得到的错误码
    	protected int mErrorCode;
    	
    	// 进行Tenda路由器登陆尝试的任务线程
    	protected Thread mLoginThread;
    
    	public RouterLogin(String strIpAddress, int nPort, String strFilePath) {
    
    		this.mIpAddress = strIpAddress;
    		this.mPort = nPort;
    		this.mFilePath = strFilePath;
    		
    		this.mUserName = null;
    		this.mPassWord = null;
    		
    		this.mIsTryLogin = false;
    		this.mErrorCode = -1;
    		
    		this.mLoginThread = null;
    	}
    	
    	
    	// 重置用户名和密码为null
    	protected void resetPassWordNull() {
    		
    		this.mUserName = null;
    		this.mPassWord = null;
    	}
    	
    	
    	// 保存路由器登陆的用户名和密码
    	protected void setPassWord(String strUserName, String strPassWord) {
    		
    		this.mUserName = strUserName;
    		this.mPassWord = strPassWord;
    	}
    	
    	// 初始化路由器登陆的任务线程
    	abstract void initRouterLoginThread();
    	
    	
    	// 启动线程进行路由器登陆的尝试
    	protected void startRouterLoginThread() {
    		
    		// 启动线程
    		this.mLoginThread.start();
    	}
    	
    	
    	// 设置等待线程执行结束的时间
    	protected void waitForThreadOver() {
    		
    		// 等待线程执行完成,返回
    		for (int i = 0; i < 200; i++) {
    			
    			// 判断线程是否执行完成
    			if (this.mIsTryLogin == true) {
    				
    				break;
    			}
    			
    			try {
    				
    				// 休眠等待
    				Thread.sleep(200);
    				
    			} catch (InterruptedException e) {
    
    				e.printStackTrace();
    			}
    		}
    		
    	}
    	
    	
    	// 使用的格式 createURL(false, this.serverHost, this.serverPort=80, "/HNAP1/")
        protected URL createURL(boolean isUseSSL, String serverHost, int serverPort, String str_file) {
        	
            URL url = null;
            String strHttp = "http";
            
            // 判断是否使用ssl
            if(isUseSSL) {  
            	
                strHttp = String.valueOf(strHttp) + "s";
            }
    
            // 默认80端口
            if(serverPort == 80) {
            	
                try {
                	
                	return new URL(strHttp, serverHost, str_file); 
                	
                } catch(MalformedURLException e) {
                	
                    e.printStackTrace();
                }
                
            } else {
            	
            	try {
            		
            		// 其他端口
    				return serverPort == 443 && (isUseSSL) ? new URL(strHttp, serverHost, str_file) 
    					: new URL(strHttp, serverHost, serverPort, str_file);
    				
    			} catch (MalformedURLException e) {
    				
    				e.printStackTrace();
    			}
            	
            }
            
    		return url;
        }
        
        
        // 获取登陆路由器的url
    	protected URL getLoginUrl() {
    		
    		// 获取登陆路由器的url地址
    		return createURL(false, this.mIpAddress, this.mPort, this.mFilePath);
    	}
    	
    	
    	// 获取路由器登陆需要发送给服务器的数据
    	abstract String getSendDataToServerce();
    
    	
    	// 进行路由器的登陆尝试
    	abstract void doRouterLogin();
    	
    	
    	// 获取服务器返回的数据转换成字符串
    	protected String getHtmlContent(InputStream is) {
    
    		if(is == null) {
    			
    			return null;
    		}
    		
    		int data = 0;
    		String ResponseHTML = null;
    		
    		try {
    			
    			BufferedReader pBufRd=new BufferedReader(new InputStreamReader(is));
    			StringBuffer sb = new StringBuffer();
    			
    			while ((data = pBufRd.read()) != -1) {
    				
    				sb.append((char) data);
    			}
    
    			ResponseHTML = sb.toString();
    
    		} catch (IOException e) {
    
    			e.printStackTrace();
    		}
    
    		return ResponseHTML;
    	}
    	
    	
    	// 获取Http网络连接对象
    	protected HttpURLConnection getHttpURLConnection(URL url) throws IOException {
    		
    		HttpURLConnection httpURLConnection = (HttpURLConnection)url.openConnection();
    		
    		return httpURLConnection;
    	}
    	
    	
    	// 设置Http网络请求的参数
    	abstract void setHttpRequestProperty(HttpURLConnection httpURLConnection, URL url, String strSendData) throws ProtocolException;
    	
    	
    	// 获取路由器的登陆之后返回的结果码
    	public abstract int getRouterLoginRetCode(String strUserName, String strPassWord);
    	
    }

    3. 360路由器P2登录协议的具体实现的重要 类QihooRouterLogin 所在的 QihooRouterLogin.java文件 。

    package com.login.core;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.ProtocolException;
    import java.net.URL;
    import java.util.Random;
    import org.json.JSONException;
    import org.json.JSONObject;
    
    import com.tools.encode.AES128;
    import com.tools.encode.Base64;
    import com.tools.log.DebugLog;
    
    import org.bouncycastle.util.encoders.Hex;
    
    
    // 360路由器P2测试成功
    // "AES/CBC/PKCS7Padding"填充的AES 128的实现需要使用开源的组件bouncycastle
    // 这里使用的是 bcprov-jdk16-146.jar 
    public class QihooRouterLogin extends RouterLogin {
    	
    	// 前32位
    	// retObj["key_index"] = data.rand_key.substring(0, 32)
    	private String m_pre_key_index_32;
    	
    	// 后32位--AES的秘钥参数
    	// retObj["rand_key"] = data.rand_key.substring(32, 64)
    	private String m_last_rand_key_32;
    
    	
    	public QihooRouterLogin(String strIpAddress, int nPort, String strFilePath) {
    		
    		super(strIpAddress, nPort, strFilePath);
    		
    		this.m_pre_key_index_32 = null;
    		this.m_last_rand_key_32 = null;
    	}
    
    	@Override
    	void initRouterLoginThread() {
    		
    		// 设置进行路由器登陆的任务线程
    		this.mLoginThread = new RouterLoginThread(this);
    
    	}
    	
    	
    	// 将16进制字符串转成字节数组
        private byte[] hexStringToByte(String hex) {  
        	
            int len = (hex.length() / 2);  
            byte[] result = new byte[len];  
            
            // 直接将字符串转成字符数组
            char[] achar = hex.toCharArray();  
            // 将每2个字符转成1个字节
            for (int i = 0; i < len; i++) {  
            	
                int pos = i * 2;  
                result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));  
            }  
            
            return result;  
        }  
      
        private byte toByte(char c) { 
        	
        	// 小写字母的情况
            byte b = (byte) "0123456789abcdef".indexOf(c);  
            
            return b;  
        } 
        
        
        // 将字节数组转成16进制字符串
        private final String bytesToHexString(byte[] bArray) {  
        	
            StringBuffer sb = new StringBuffer(bArray.length);  
            String sTemp;  
            
            for (int i = 0; i < bArray.length; i++) {  
            	
                sTemp = Integer.toHexString(0xFF & bArray[i]);  
                if (sTemp.length() < 2)  
                    sb.append(0);  
                
                // 小写字母的情况
                sb.append(sTemp.toLowerCase());  
            }  
            
            return sb.toString();  
        }  
    
        // 将"ISO-8859-1"字符串转成字节数组
        private byte[] latin1ToArray(String strLatin1) {
        	
    		byte[] btArrayIv = null;
    		try {
    			
    			// 将字符串转换成ISO-8859-1编码的字节数组
    			btArrayIv = strLatin1.getBytes("ISO-8859-1");
    			
    		} catch (UnsupportedEncodingException e) {
    			
    			e.printStackTrace();
    		}
    		
    		return btArrayIv;
        }
    	
    	
    	// 获取服务器验证需要的Aes字符串
    	private String getAesString() {
    		
    //		// 将字符串转成16进制的整形
    //		byte[] btKeyArray = stringToHexArray(this.m_last_rand_key_32);
    //		
    //		// 将字符串转成Latin1格式-Latin1是ISO-8859-1的别名,有些环境下写作Latin-1。
    //		// ISO-8859-1编码是单字节编码,向下兼容ASCII,其编码范围是0x00-0xFF,0x00-0x7F之间完全和ASCII一致,0x80-0x9F之间是控制字符,0xA0-0xFF之间是文字符号。
    //		byte[] btIvArray = stringToLatin1Array("360luyou@install");
    //		
    //
    //		try {
    //			
    //			// 生成iv  
    //			CryptoHandler aes = new CryptoHandler(btKeyArray, btIvArray);
    //			
    //			// 对用户的密码进行,使用PKCS7Padding填充的AES-128-CBC的加密
    //			String str_ciphertext = aes.encrypt(this.mPassWord);
    //			
    //			// 发送给服务器的数据-- lengthKeyObj.key_index + cipher_text
    //			String strAes = this.m_pre_key_index_32+str_ciphertext;
    //			DebugLog.log("getAesString:"+strAes);
    //			
    //			return strAes;
    //			
    //		} catch (Exception e) {
    //
    //			e.printStackTrace();
    //		}
    		
    		// 获取AES的秘钥参数key
    		byte[] btArrayKey = this.hexStringToByte(this.m_last_rand_key_32);
    		DebugLog.log("AES key:"+this.bytesToHexString(btArrayKey));
    		
    		// 获取AES的加密向量iv
    		byte[] btArrayIv = this.latin1ToArray("360luyou@install");
    		// 3336306c75796f7540696e7374616c6c
    		DebugLog.log("AES iv:"+this.bytesToHexString(btArrayIv));
    		
    		// 进行"AES/CBC/PKCS7Padding"的加密处理
    		AES128 aes = new AES128(btArrayIv);
    		  
    		// 被加密的字符串:cm20170331
    		DebugLog.log("AES enc data befor:"+this.mPassWord); 
    		  
    		// 进行用户密码的AES加密
    		byte[] enc = aes.encrypt(this.mPassWord.getBytes(), btArrayKey);
    		
    		String strEncode = new String(Hex.encode(enc));
    		// 加密后的内容:104ba5af88ebb24bc69ed56dee27327b
    		DebugLog.log("AES enc data after:"+strEncode);
    		
    		return strEncode;
    	}
    
    	@Override
    	String getSendDataToServerce() {
    
    		// 获取需要的Aes字符串(发送的pass的后32位)
    		String strAesString = getAesString();
    		
    		// 通过PC发送给服务器的数据 
    		// user=admin&pass=3dac6a73e34fa79fc9364d009f437e81104ba5af88ebb24bc69ed56dee27327b&from=1
    		String strPostData = "user=admin&pass="+this.m_pre_key_index_32+strAesString+"&from=1";
    		
    		return strPostData;
    	}
    	
    	// 用户随机生成13位随机数字字符串
    	private static String getRandomString(int length) { 
    		
    	    String base_first = "123456789";
    	    String base_next = "0123456789"; 
    	    
    	    Random random = new Random();     
    	    StringBuffer sb = new StringBuffer();    
    	    
    	    // 生成第一个数字字符串的数字
    	    int nIndex = random.nextInt(base_first.length()); 
    	    // 拼接字符串
            sb.append(base_first.charAt(nIndex));   
    	    
    	    // 生成其他的数字字符串
    	    for (int i = 0; i < length-1; i++) { 
    	    	
    	    	// 获取随机字符串的取值序列号
    	        int number = random.nextInt(base_next.length());  
    	        // 拼接字符串
    	        sb.append(base_next.charAt(number));     
    	    }  
    	    
    	    return sb.toString();     
    	}    
    	
    	
    	// 获取网络请求返回的数据
    	private String getHTMLContent(InputStream is) {
    
    		if(is == null) {
    			
    			return null;
    		}
    		
    		int data = 0;
    		String ResponseHTML = null;
    		
    		try {
    			
    			BufferedReader pBufRd=new BufferedReader(new InputStreamReader(is));
    			StringBuffer sb = new StringBuffer();
    			
    			while ((data = pBufRd.read()) != -1) {
    				
    				sb.append((char) data);
    			}
    
    			ResponseHTML = sb.toString();
    
    		} catch (IOException e) {
    
    			e.printStackTrace();
    		}
    
    		return ResponseHTML;
    	}
    	
    	
    	public void getRandKey() {
    		
    		// 获取13位的随机字符串
    		String strRandKey = getRandomString(13);
    		DebugLog.log("getRandKey strRandKey:"+strRandKey);
    		
    		// 获取base64加密的用户密码
    		String strBase64 = Base64.encodeToString(this.mPassWord);
    		
    		// 获取路由器登陆的AES的密钥参数的url地址
    		String strUrl = "http://"+this.mIpAddress+"/router/get_rand_key.cgi?noneed=noneed&_="+strRandKey;
    		DebugLog.log("getRandKey url:"+strUrl);
    		
    		try {
    			
    			// 构建Http网络请求对象
    			HttpURLConnection httpURLConnection = (HttpURLConnection)(new URL(strUrl).openConnection());
    			// 判断网络请求对象是否为null
    			if (httpURLConnection != null) {
    				
    		        // 设置Http请求的等待超时时间
    		        httpURLConnection.setConnectTimeout(3000);
    		        httpURLConnection.setReadTimeout(10000);
    		        // 开启输出流
    		        httpURLConnection.setDoInput(true); 
    		        // 关闭写入流
    		        httpURLConnection.setDoOutput(false);      
    		        // 网络请求的方法为"GET"
    		        httpURLConnection.setRequestMethod("GET");
    		        // 使用Post方式不能使用缓存
    		        //httpURLConnection.setUseCaches(false);  
    				
    				httpURLConnection.setRequestProperty("Host", this.mIpAddress);
    				httpURLConnection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0");
    				httpURLConnection.setRequestProperty("Accept", "application/json, text/javascript, */*; q=0.01");
    				httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3");
    				httpURLConnection.setRequestProperty("Accept-Encoding", "gzip, deflate");
    				httpURLConnection.setRequestProperty("X-Requested-With", "XMLHttpRequest");
    				httpURLConnection.setRequestProperty("Referer", "http://"+this.mIpAddress+"/login_pc.htm");
    				httpURLConnection.setRequestProperty("Cookie", "bLanguage=cn; ecos_pw="+strBase64+"1qw:language=cn");
    				httpURLConnection.setRequestProperty("Connection", "keep-alive");
    				
    				// 获取网络输出流
    				InputStream inputstm = httpURLConnection.getInputStream();
    				// 检查
    				if (inputstm != null) {
    					
    					// 获取到服务器返回的数据
    					String strRetData = getHTMLContent(inputstm);
    					// 打印结果
    					DebugLog.log("getRandKey ret data:"+strRetData);
    					
    					// 解析json数据
    					try {
    						
    						JSONObject jSONObject = new JSONObject(strRetData);
    						
    						// 获取服务器返回的rand_key
    						String str_rand_key = jSONObject.getString("rand_key");
    						// 打印结果
    						DebugLog.log("ret rand key:"+str_rand_key);
    						
    						// 前32位 key_index
    						this.m_pre_key_index_32 = str_rand_key.substring(0, 32);
    						DebugLog.log("key index:"+this.m_pre_key_index_32);
    						
    						// 后32位 rand_key
    						this.m_last_rand_key_32 = str_rand_key.substring(32, 64);
    						DebugLog.log("rand key:"+this.m_last_rand_key_32);
    						
    						return;
    						
    					} catch (JSONException e) {
    						
    						// 需要修改值
    						e.printStackTrace();
    					}
    					
    				}
    				
    			}
    			
    		} catch (MalformedURLException e) {
    			
    			e.printStackTrace();
    			
    		} catch (IOException e) {
    			
    			e.printStackTrace();
    		}
    
    		this.m_pre_key_index_32 = null;
    		this.m_last_rand_key_32 = null;
    	}
    	
    
    	// 进行路由器的登陆测试
    	@Override
    	void doRouterLogin() {
    		
    		Class<? extends QihooRouterLogin> clazz = this.getClass();
    		// 进行代码块的同步处理
    		synchronized (clazz) {
    			
    			// 获取服务器返回的key_index和rand_key
    			getRandKey();
    			if (this.m_last_rand_key_32 != null && !this.m_last_rand_key_32.equals("") && this.m_pre_key_index_32 != null && !this.m_pre_key_index_32.equals("")) {
    				
    				// 获取请求服务器的url地址
    				URL url = super.createURL(false, this.mIpAddress, this.mPort, "/router/web_login.cgi");
    				DebugLog.log("post url:"+url.toExternalForm());
    				
    				// 发送给服务器的数据
                	// user=admin&pass=3dac6a73e34fa79fc9364d009f437e81104ba5af88ebb24bc69ed56dee27327b&from=1
    				String strPostData = getSendDataToServerce();
    				DebugLog.log("post data:"+strPostData);
    				
    				try {
    					
    					// 构建Http网络请求的对象
    					HttpURLConnection httpUrlConnect = super.getHttpURLConnection(url);
    					if (httpUrlConnect != null) {
    						
    						// 设置路由器网络请求的参数
    						this.setHttpRequestProperty(httpUrlConnect, url, strPostData);
    						
    						// 向服务器发送数据
    			            OutputStream outputStream = httpUrlConnect.getOutputStream();
    			            if (outputStream != null) {
    
    				            // 向服务器发送数据
    				            outputStream.write(strPostData.getBytes());
    				            
    				            int response = httpUrlConnect.getResponseCode(); 
    				            // 打印服务器的返回码
    				            DebugLog.log("response code:"+response);
    				            
    				            if (response == HttpURLConnection.HTTP_OK) {
    				            	
    								// 获取网络输出流
    								InputStream inputstm = httpUrlConnect.getInputStream();
    								// 检查
    								if (inputstm != null) {
    									
    									// 获取到服务器返回的数据
    									String strRetData = getHTMLContent(inputstm);
    									// 打印结果
    									DebugLog.log("getRandKey ret data:"+strRetData);
    									
    									try {
    										
    										// 解析json数据
    										JSONObject jSONObject = new JSONObject(strRetData);
    										
    										// {"success":"1","token_id":"c6c0511d81b75a3fae36fbe5532ba353"}
    										String str_success = jSONObject.getString("success");
    										String str_token_id = jSONObject.getString("token_id");
    										
    										// 判读是否登陆路由器成功
    										if (str_success.equals("1") && str_token_id != null && !str_token_id.equals("")) {
    											
    											// 登陆路由器成功
    											this.mErrorCode = 0;
    											
    										} else {
    											
    											// {"err_no":"36","err_msg":"user or password err"} 密码错误的情况
    											String err_no = jSONObject.getString("err_no");
    											if (err_no.equals("36")) {
    												
    												// 用户名或者密码错误的情况
    												this.mErrorCode = 36;
    												
    											} else {
    												
    												this.mErrorCode = -1;
    											}
    										}
    										
    										// 设置已经登陆尝试过的标记
    										this.mIsTryLogin = true;
    										// 直接返回
    										return;
    										
    									} catch (JSONException e) {
    										
    										// 登陆路由器失败
    										this.mErrorCode = -1;
    										
    										e.printStackTrace();
    									}
    									
    									// 关闭资源
    									inputstm.close();
    									inputstm = null;
    									
    								}
    								
    							} else {
    								
    								// 登陆路由器失败
    								this.mErrorCode = -1;
    							}
    
    				            // 进行资源的清理
    				            outputStream.close();
    				            outputStream = null;
    			            }
    
    			            // 关闭网络连接
    			            httpUrlConnect.disconnect();
    			            
    						// 设置已经登陆尝试过的标记
    						this.mIsTryLogin = true;
    						return;
    					}
    					
    				} catch (IOException e) {
    					
    					// 登陆路由器失败
    					this.mErrorCode = -1;
    					
    					e.printStackTrace();
    				}
    			}
    			
    			// 设置已经登陆尝试过的标记
    			this.mIsTryLogin = true;
    		}
    
    	}
    	
    
    	@Override
    	void setHttpRequestProperty(HttpURLConnection httpURLConnection, URL url,
    			String strSendData) throws ProtocolException {
    
            // 设置Http请求的等待超时时间
            httpURLConnection.setConnectTimeout(2000);
            httpURLConnection.setReadTimeout(4000);
            // 开启输入输出流
            httpURLConnection.setDoInput(true);                 
            httpURLConnection.setDoOutput(true);      
            // 网络请求的方法为"POST"
            httpURLConnection.setRequestMethod("POST");
            // 使用Post方式不能使用缓存
            httpURLConnection.setUseCaches(false);               
            
            // 设置Http请求头的各种参数属性
            httpURLConnection.setRequestProperty("Host", this.mIpAddress);	// Host: 192.168.1.1
            httpURLConnection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0");	
            httpURLConnection.setRequestProperty("Accept", "*/*");	
            httpURLConnection.setRequestProperty("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3");	
            httpURLConnection.setRequestProperty("Accept-Encoding", "gzip, deflate");	
            httpURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");	
            httpURLConnection.setRequestProperty("X-Requested-With", "XMLHttpRequest");	
            httpURLConnection.setRequestProperty("Referer", "http://192.168.0.1/login_pc.htm");	
            
            // 发送的数据的字节长度
            httpURLConnection.setRequestProperty("Content-Length", strSendData.length()+"");	
    		// 获取base64加密的用户密码
    		String strBase64 = Base64.encodeToString(this.mPassWord);
    		httpURLConnection.setRequestProperty("Cookie", "bLanguage=cn; ecos_pw="+strBase64+"1qw:language=cn");
    		
            httpURLConnection.setRequestProperty("Connection", "keep-alive");	
            
    	}
    	
    
    	@Override
    	public int getRouterLoginRetCode(String strUserName, String strPassWord) {
    		
    		// 保存路由器登陆的用户名和密码
    		super.setPassWord(strUserName, strPassWord);
    		
    		// 创建路由器登陆尝试的任务线程
    		this.initRouterLoginThread();
    		// 启动线程执行任务
    		super.startRouterLoginThread();
    		
    		// 等待线程执行任务结束
    		super.waitForThreadOver();
    		
    		// 返回路由器登陆返回的错误码
    		return this.mErrorCode;
    	}
    
    }

    4. 360路由器P2登录协议中CBC模式 AES/CBC/PKCS7Padding填充 AES128算法 具体实现的重要类AES128所在的 AES128.java文件,在使用这个类的过程中需要导入开源组件的 类org.bouncycastle.jce.provider.BouncyCastleProvider ,具体的就是要下载 开源组件包bcprov-jdk16-146.jar 导入到工程项目中,能使工程项目编译通过。

    package com.tools.encode;
    
    
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;
    import java.security.NoSuchProviderException;
    import java.security.Security;
    import java.util.Arrays;
     
    import javax.crypto.Cipher;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
     
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    /**
     *
     * @author ngh
     * AES128 算法
     *
     * CBC 模式
     *
     * PKCS7Padding 填充模式
     *
     * CBC模式需要添加一个参数iv
     *
     * 介于java 不支持PKCS7Padding,只支持PKCS5Padding 但是PKCS7Padding 和 PKCS5Padding 没有什么区别
     * 要实现在java端用PKCS7Padding填充,需要用到bouncycastle组件来实现
     */
    public class AES128 {
    	
     // 算法名称
     final String KEY_ALGORITHM = "AES";
     // 加解密算法/模式/填充方式
     final String algorithmStr = "AES/CBC/PKCS7Padding";
    
     private Key key;
     private Cipher cipher;
     boolean isInited = false;
     byte[] iv = null;
     
     // 设置加密的向量
     public AES128(byte[] iv) {
    	 
    	this.iv = iv;
    }
    
    
    public void init(byte[] keyBytes) {
    
    	  // 如果密钥不足16位,那么就补足.  这个if 中的内容很重要
    	  int base = 16;
    	  if (keyBytes.length % base != 0) {
    		  
    		   int groups = keyBytes.length / base + (keyBytes.length % base != 0 ? 1 : 0);
    		   byte[] temp = new byte[groups * base];
    		   Arrays.fill(temp, (byte) 0);
    		   System.arraycopy(keyBytes, 0, temp, 0, keyBytes.length);
    		   keyBytes = temp;
    	  }
    	  
    	  // 初始化
    	  Security.addProvider(new BouncyCastleProvider());
    	  // 转化成JAVA的密钥格式
    	  key = new SecretKeySpec(keyBytes, KEY_ALGORITHM);
    	  try {
    	   // 初始化cipher
    	   cipher = Cipher.getInstance(algorithmStr, "BC");
    	   
    	  } catch (NoSuchAlgorithmException e) {
    		  
    		  e.printStackTrace();
    	  } catch (NoSuchPaddingException e) {
    		  e.printStackTrace();
    	  } catch (NoSuchProviderException e) {
    		  e.printStackTrace();
    	  }
     }
     
     
     /**
      * 加密方法
      *
      * @param content
      *            要加密的字符串
      * @param keyBytes
      *            加密密钥
      * @return
      */
     public byte[] encrypt(byte[] content, byte[] keyBytes) {
    	 
      byte[] encryptedText = null;
      init(keyBytes);
      System.out.println("IV:" + new String(iv));
      
      try {
    	  
    	   cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
    	   encryptedText = cipher.doFinal(content);
    	   
      } catch (Exception e) {
    
    	  e.printStackTrace();
      }
      
      return encryptedText;
     }
     
     
     /**
      * 解密方法
      *
      * @param encryptedData
      *            要解密的字符串
      * @param keyBytes
      *            解密密钥
      * @return
      */
     public byte[] decrypt(byte[] encryptedData, byte[] keyBytes) {
    	 
      byte[] encryptedText = null;
      init(keyBytes);
      System.out.println("IV:" + new String(iv));
      
      try {
    	  
    	   cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
    	   encryptedText = cipher.doFinal(encryptedData);
    	   
      } catch (Exception e) {
    	  
    	  e.printStackTrace();
      }
      
      return encryptedText;
     }
     
    }

    5. 工具类Base64所在的 Base64文件,代码来自于网上,侵权请告知修改 。

    package com.tools.encode;
    
    import java.util.Arrays;
    import java.io.UnsupportedEncodingException;
     
    /**
     * One of the <b>fastest</b> Base64 encoder/decoder implementations. Base64
     * encoding is defined in RFC 2045.
     */
    public class Base64 {
     
        private static final char[] CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
                .toCharArray();
        
        private static final int[] INV = new int[256];
     
        static {
        	
            Arrays.fill(INV, -1);
            for (int i = 0, iS = CHARS.length; i < iS; i++) {
                INV[CHARS[i]] = i;
            }
            INV['='] = 0;
        }
     
        /**
         * Returns Base64 characters, a clone of used array.
         */
        public static char[] getAlphabet() {
        	
            return CHARS.clone();
        }
     
        // ---------------------------------------------------------------- char[]
     
        public static char[] encodeToChar(String s) {
            try {
                return encodeToChar(s.getBytes("UTF-8"), false);
            } catch (UnsupportedEncodingException ignore) {
                return null;
            }
        }
     
        public static char[] encodeToChar(byte[] arr) {
            return encodeToChar(arr, false);
        }
     
        /**
         * Encodes a raw byte array into a BASE64 <code>char[]</code>.
         */
        public static char[] encodeToChar(byte[] arr, boolean lineSeparator) {
            int len = arr != null ? arr.length : 0;
            if (len == 0) {
                return new char[0];
            }
     
            int evenlen = (len / 3) * 3;
            int cnt = ((len - 1) / 3 + 1) << 2;
            int destLen = cnt + (lineSeparator ? (cnt - 1) / 76 << 1 : 0);
            char[] dest = new char[destLen];
     
            for (int s = 0, d = 0, cc = 0; s < evenlen;) {
                int i = (arr[s++] & 0xff) << 16 | (arr[s++] & 0xff) << 8
                        | (arr[s++] & 0xff);
     
                dest[d++] = CHARS[(i >>> 18) & 0x3f];
                dest[d++] = CHARS[(i >>> 12) & 0x3f];
                dest[d++] = CHARS[(i >>> 6) & 0x3f];
                dest[d++] = CHARS[i & 0x3f];
     
                if (lineSeparator && (++cc == 19) && (d < (destLen - 2))) {
                    dest[d++] = '\r';
                    dest[d++] = '\n';
                    cc = 0;
                }
            }
     
            int left = len - evenlen; // 0 - 2.
            if (left > 0) {
                int i = ((arr[evenlen] & 0xff) << 10)
                        | (left == 2 ? ((arr[len - 1] & 0xff) << 2) : 0);
     
                dest[destLen - 4] = CHARS[i >> 12];
                dest[destLen - 3] = CHARS[(i >>> 6) & 0x3f];
                dest[destLen - 2] = left == 2 ? CHARS[i & 0x3f] : '=';
                dest[destLen - 1] = '=';
            }
            return dest;
        }
     
        
        /**
         * Decodes a BASE64 encoded char array.
         */
        public byte[] decode(char[] arr) {
        	
            int length = arr.length;
            if (length == 0) {
                return new byte[0];
            }
     
            int sndx = 0, endx = length - 1;
            int pad = arr[endx] == '=' ? (arr[endx - 1] == '=' ? 2 : 1) : 0;
            int cnt = endx - sndx + 1;
            int sepCnt = length > 76 ? (arr[76] == '\r' ? cnt / 78 : 0) << 1 : 0;
            int len = ((cnt - sepCnt) * 6 >> 3) - pad;
            byte[] dest = new byte[len];
     
            int d = 0;
            for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) {
                int i = INV[arr[sndx++]] << 18 | INV[arr[sndx++]] << 12
                        | INV[arr[sndx++]] << 6 | INV[arr[sndx++]];
     
                dest[d++] = (byte) (i >> 16);
                dest[d++] = (byte) (i >> 8);
                dest[d++] = (byte) i;
     
                if (sepCnt > 0 && ++cc == 19) {
                    sndx += 2;
                    cc = 0;
                }
            }
     
            if (d < len) {
                int i = 0;
                for (int j = 0; sndx <= endx - pad; j++) {
                    i |= INV[arr[sndx++]] << (18 - j * 6);
                }
                for (int r = 16; d < len; r -= 8) {
                    dest[d++] = (byte) (i >> r);
                }
            }
     
            return dest;
        }
     
     
        public static byte[] encodeToByte(String s) {
            try {
                return encodeToByte(s.getBytes("UTF-8"), false);
            } catch (UnsupportedEncodingException ignore) {
                return null;
            }
        }
     
        public static byte[] encodeToByte(byte[] arr) {
            return encodeToByte(arr, false);
        }
     
        /**
         * Encodes a raw byte array into a BASE64 <code>byte[]</code>.
         */
        public static byte[] encodeToByte(byte[] arr, boolean lineSep) {
            int len = arr != null ? arr.length : 0;
            if (len == 0) {
                return new byte[0];
            }
     
            int evenlen = (len / 3) * 3;
            int cnt = ((len - 1) / 3 + 1) << 2;
            int destlen = cnt + (lineSep ? (cnt - 1) / 76 << 1 : 0);
            byte[] dest = new byte[destlen];
     
            for (int s = 0, d = 0, cc = 0; s < evenlen;) {
                int i = (arr[s++] & 0xff) << 16 | (arr[s++] & 0xff) << 8
                        | (arr[s++] & 0xff);
     
                dest[d++] = (byte) CHARS[(i >>> 18) & 0x3f];
                dest[d++] = (byte) CHARS[(i >>> 12) & 0x3f];
                dest[d++] = (byte) CHARS[(i >>> 6) & 0x3f];
                dest[d++] = (byte) CHARS[i & 0x3f];
     
                if (lineSep && ++cc == 19 && d < destlen - 2) {
                    dest[d++] = '\r';
                    dest[d++] = '\n';
                    cc = 0;
                }
            }
     
            int left = len - evenlen;
            if (left > 0) {
                int i = ((arr[evenlen] & 0xff) << 10)
                        | (left == 2 ? ((arr[len - 1] & 0xff) << 2) : 0);
     
                dest[destlen - 4] = (byte) CHARS[i >> 12];
                dest[destlen - 3] = (byte) CHARS[(i >>> 6) & 0x3f];
                dest[destlen - 2] = left == 2 ? (byte) CHARS[i & 0x3f] : (byte) '=';
                dest[destlen - 1] = '=';
            }
            return dest;
        }
     
        
        /**
         * Decodes a BASE64 encoded byte array.
         */
        public static byte[] decode(byte[] arr) {
            int length = arr.length;
            if (length == 0) {
                return new byte[0];
            }
     
            int sndx = 0, endx = length - 1;
            int pad = arr[endx] == '=' ? (arr[endx - 1] == '=' ? 2 : 1) : 0;
            int cnt = endx - sndx + 1;
            int sepCnt = length > 76 ? (arr[76] == '\r' ? cnt / 78 : 0) << 1 : 0;
            int len = ((cnt - sepCnt) * 6 >> 3) - pad;
            byte[] dest = new byte[len];
     
            int d = 0;
            for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) {
                int i = INV[arr[sndx++]] << 18 | INV[arr[sndx++]] << 12
                        | INV[arr[sndx++]] << 6 | INV[arr[sndx++]];
     
                dest[d++] = (byte) (i >> 16);
                dest[d++] = (byte) (i >> 8);
                dest[d++] = (byte) i;
     
                if (sepCnt > 0 && ++cc == 19) {
                    sndx += 2;
                    cc = 0;
                }
            }
     
            if (d < len) {
                int i = 0;
                for (int j = 0; sndx <= endx - pad; j++) {
                    i |= INV[arr[sndx++]] << (18 - j * 6);
                }
                for (int r = 16; d < len; r -= 8) {
                    dest[d++] = (byte) (i >> r);
                }
            }
     
            return dest;
        }
        
     
        public static String encodeToString(String s) {
            try {
            	
                return new String(encodeToChar(s.getBytes("UTF-8"), false));
                
            } catch (UnsupportedEncodingException ignore) {
            	
                return null;
            }
        }
     
        public static String decodeToString(String s) {
            try {
                return new String(decode(s), "UTF-8");
            } catch (UnsupportedEncodingException ignore) {
                return null;
            }
        }
     
        public static String encodeToString(byte[] arr) {
            return new String(encodeToChar(arr, false));
        }
     
        
        /**
         * Encodes a raw byte array into a BASE64 <code>String</code>.
         */
        public static String encodeToString(byte[] arr, boolean lineSep) {
            return new String(encodeToChar(arr, lineSep));
        }
     
        
        /**
         * Decodes a BASE64 encoded string.
         */
        public static byte[] decode(String s) {
            int length = s.length();
            if (length == 0) {
                return new byte[0];
            }
     
            int sndx = 0, endx = length - 1;
            int pad = s.charAt(endx) == '=' ? (s.charAt(endx - 1) == '=' ? 2 : 1)
                    : 0;
            int cnt = endx - sndx + 1;
            int sepCnt = length > 76 ? (s.charAt(76) == '\r' ? cnt / 78 : 0) << 1
                    : 0;
            int len = ((cnt - sepCnt) * 6 >> 3) - pad;
            byte[] dest = new byte[len];
     
            int d = 0;
            for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) {
                int i = INV[s.charAt(sndx++)] << 18 | INV[s.charAt(sndx++)] << 12
                        | INV[s.charAt(sndx++)] << 6 | INV[s.charAt(sndx++)];
     
                dest[d++] = (byte) (i >> 16);
                dest[d++] = (byte) (i >> 8);
                dest[d++] = (byte) i;
     
                if (sepCnt > 0 && ++cc == 19) {
                    sndx += 2;
                    cc = 0;
                }
            }
     
            if (d < len) {
                int i = 0;
                for (int j = 0; sndx <= endx - pad; j++) {
                    i |= INV[s.charAt(sndx++)] << (18 - j * 6);
                }
                for (int r = 16; d < len; r -= 8) {
                    dest[d++] = (byte) (i >> r);
                }
            }
     
            return dest;
        }
     
    }

    6. 工具类DebugLog所在的 DebugLog.java文件。

    package com.tools.log;
    
    public class DebugLog {
    	
    	private static boolean mIsDebug;
    	
    	static {
    		
    		mIsDebug = true;
    	}
    
    	// 打印日志消息
    	public static void log(String str) {
    		
    		if (true == mIsDebug) {
    			
    			System.out.println(str);
    		}
    
    	}
    }

    7. 工具类MD5所在的 MD5.java文件,代码来自于网络,侵权请告知修改。

    package com.tools.encode;
    
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    /*
     * MD5 算法
    */
    public class MD5 {
        
        // 全局数组
        private final static String[] strDigits = { "0", "1", "2", "3", "4", "5",
                "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
    
        public MD5() {}
    
        // 返回形式为数字组字符串
        private static String byteToArrayString(byte bByte) {
            int iRet = bByte;
            // System.out.println("iRet="+iRet);
            if (iRet < 0) {
                iRet += 256;
            }
            int iD1 = iRet / 16;
            int iD2 = iRet % 16;
            return strDigits[iD1] + strDigits[iD2];
        }
    
        // 返回形式只为数字
        private static String byteToNum(byte bByte) {
            int iRet = bByte;
            System.out.println("iRet1=" + iRet);
            if (iRet < 0) {
                iRet += 256;
            }
            return String.valueOf(iRet);
        }
    
        // 转换字节数组为16进制字串
        private static String byteToString(byte[] bByte) {
        	
            StringBuffer sBuffer = new StringBuffer();
            for (int i = 0; i < bByte.length; i++) {
                sBuffer.append(byteToArrayString(bByte[i]));
            }
            
            return sBuffer.toString();
        }
    
        // 进行字符串的MD5加密
        public static String getMD5Code(String strObj) {
        	
            String resultString = null;
            try {
            	
                resultString = new String(strObj);
                
                MessageDigest md = MessageDigest.getInstance("MD5");
                // md.digest() 该函数返回值为存放哈希值结果的byte数组
                resultString = byteToString(md.digest(strObj.getBytes()));
                
            } catch (NoSuchAlgorithmException ex) {
            	
                ex.printStackTrace();
            }
            return resultString;
        }
    
    }

    提示下:上面的路由器登录测试代码已经测试了很多次是没有问题,但是还需要优化,在进行网络资源清理和回收上处理的不是很好。


    展开全文
  • password-control login-attempt login-times [ exceed { lock | lock-time time | unlock } ] ...login-times:用户登录尝试次数,取值范围为2~10。 exceed:用户登录尝试失败后的行为。 lock...

    password-control login-attempt login-times [ exceed { lock | lock-time time | unlock } ]

    undo password-control login-attempt

     

    【参数】

    login-times:用户登录尝试次数,取值范围为2~10。

    exceed:用户登录尝试失败后的行为。

    lock:表示永久禁止该用户登录。

    lock-time time:表示禁止该用户一段时间后,再允许该用户重新登录。其中,time为禁止该用户的时间,取值范围为1~360,单位为分钟。

    unlock:表示不禁止该用户,允许其继续登录。

    【描述】

    password-control login-attempt命令用来配置用户登录尝试次数以及登录尝试失败后的行为。

    undo password-control命令用来恢复缺省情况。

    缺省情况下,用户登录尝试次数为3次;如果用户登录失败,则1分钟后再允许该用户重新登录。

    需要注意的是:

     对于被永久禁止登录的用户,只有管理员把该用户从黑名单中删除后,该用户才能重新登录。

     对于被禁止一段时间内登录的用户,当配置的禁止时间超时或者管理员将其从黑名单中删除,该用户才可以重新登录。

    对于不禁止登录的用户,只要用户登录成功或者黑名单的老化时间(系统规定为1分钟)超时后,该用户就会从黑名单中被删除。

     

    相关配置可参考命令  display password-control、display password-control blacklist和reset password-control blacklist。

    【举例】

    # 管理员设定用户登录尝试次数为4次,并且永久禁止该用户登录。

    system-view

    [Sysname] password-control enable

    [Sysname] password-control login-attempt 4 exceed lock

    若有用户连续尝试认证的失败累加次数达到4次,管理员可通过命令查看到被加入黑名单中的用户锁定状态由之前的unlock切换为lock,且该用户无法再次成功登录。

     

    [Sysname] display password-control blacklist

    Username: test

    IP: 192.168.44.1 Login failed times: 4 Lock flag: lock

    Total 1 blacklist item(s) matched.

     

    管理员设定用户登录尝试次数为2次,并且禁止该用户3分钟后,再允许该用户重新登录。

    system-view

    [Sysname] password-control enable

    [Sysname] password-control login-attempt 2 exceed lock-time 3

    若有用户连续尝试认证的失败累加次数达到2次,管理员可通过命令查看到被加入黑名单中的用户锁定状态由之前的unlock切换为lock。

    [Sysname] display password-control blacklist

    Username: test

    IP: 192.168.44.1 Login failed times: 2 Lock flag: lock

    Total 1 blacklist item(s) matched.

    用户被禁止登录3分钟后,将被从黑名单中删除,且可以重新登录。

    configure-user count 5 设置允许同时配置路由器的用户数

    转载于:https://www.cnblogs.com/xzlive/p/11535678.html

    展开全文
  • 路由器设置教程

    千次阅读 2020-02-13 20:37:39
    路由器设置教程 现在很多光猫都自己带了产生WiFi这个功能,WIFI的名字和密码就在光猫的底面。你可以直接用这一个WIFI。 首先你先用手机或电脑连上路由器的这个WIFI,名字在背面,如果没写,就是条形码下面那个。 接...
  • 华为路由器配置Stelnet登录 R2为目标路由,R1模拟客户端。 Stelnet 目标路由配置R2配置syssysname R2int g0/0/0ip add 10.1.1.2 24qaaalocal-user huawei1 password cipher huawei1(创建用户huawei1密码为...
  • Cisco(思科)远程登录路由器

    千次阅读 2020-12-11 12:21:20
    Cisco(思科)远程登录交换机 一、拓扑图 二、实验步骤 1.先配置好路由器,配置如下: 先进入配置电脑的终端进行配置操作 Cisco在模拟器中路由器只有两个接口interface f0/0 、interface f0/1 小编在这里只...
  • 实现路由器自动登录校园网(edu)

    千次阅读 2019-09-28 02:50:29
     (1)一个可以刷openwrt固件的路由器,如大多人使用的crazybox版本的路由.  (2)一个可用的edu账号.  (3)一个浏览器(firfox,chrome) 下面开始:  一:刷openwrt固件,如下:  a)去openwrt官网查看...
  • PHP制作简单仿路由器登录界面

    千次阅读 2014-09-30 15:12:51
    Header('WWW-Authenticate: Basic realm="USER LOGIN"');...页面在载入前会出现一个登录框,要求输入用户名和密码,有没有觉得很像路由器登录界面呢 获取从这个对话框中传来的用户名和密码,分别使用$_SERVER['P
  • 华为AR1200C-S路由WEB登录服务开启 正常教程 首先用超级终端连接路由器 用户名admin密码admin或者Admin@huawei system-view [HUAWEI]http server enable(开启http服务) [HUAWEI]interface vlanif 1 [HUAWEI-Vlanif1]...
  • huawei路由器远程登录配置

    千次阅读 2018-05-09 16:17:00
    [R1]user-interface vty 0 4 //进入远程虚拟链路 [R1-ui-vty0-4]set authentication password cipher huawei //设置远程登陆密码 [R1]super password cipher huawei123 //设置super密码,默认level 3   ...
  • 华为路由器远程ssh登录配置

    万次阅读 2016-09-01 09:01:54
    背景一般企业出口路由器会选择华为路由器,过去一般采用telnet,现在改成了ssh,一般还要增加修改ssh的端口,因为默认的端口容易造成攻击,但是即使如此,端口还是会被别人扫出来,导致进行暴力密码破解,然后工程师...
  • [sw1]user-interface console 0 [sw1-ui-console0]authentication-mode password [sw1-ui-console0]set authentication password ? cipher Set the password with cipher text #密码用密码文本设置密码 simple ...
  • 华为 路由器telnet登录配置实例

    千次阅读 2018-07-15 17:02:09
    telnet登录认证模式有aaa,password,none,这里我们采用aaa和password两种认证模式进行实验,R2的验证模式为password,R3的验证模式为aaa,最后通过telnet登录验证效果。步骤一:配置各接口ip地址,配置rip协议,使...
  • 现在买回来的路由器后自己不会设置,来是连接不上网络,老是出现路由器PPPOE拨号失败,针对这个问题,下面为大家详细介绍下
  • 路由器实现远程登录

    2018-01-29 19:58:50
    需求:华为路由器用AR2来远程操作AR3分析:要想远程控制AR3肯定得在AR3路由器上给它建立一些管理员账号和给它们 一些权限。实现:给AR2和AR3分别先配好ip address先从用户模式<huawei>进入系统视图模式[huawei...
  • 常见路由器默认登录用户名和密码(大全)  艾玛 701g :192.168.101.1 或 192.168.0.1 用户名:admin 密码:admin 或 用户名: SZIM 密码:SZIM    艾玛701H: 192.168.1.1 或 10.0.0.2 用户名:...
  • Requests: 让 HTTP 服务人类前段时间撸了一个斐讯K2P的路由器,最近下车了,刷了一个梅林固件,今天无聊的时候用Python requests库写了个模拟登陆路由器获取在线用户列表的小程序和大家分享。话不多说开整,先看登陆...
  • TP-LINK WR886N路由器登录过程分析

    万次阅读 多人点赞 2016-04-24 19:51:13
    很多人看到标题可能会疑惑为什么要写这个路由器登录过程?一般来说路由器登录不都是使用的HTTP头来确认是否为管理员的吗?但是很不幸,TP这个公司为路由器新开发的固件里面并未使用HTTP头来认证,而是用了POST...
  • Tenda 11N 无线宽带路由器 安装 登录 设置 安全设置 配置等等 非常详细。 详细说明书
  • 用户认证 一个Web应用程序,用于使用auth路由器和expressjs验证用户验证
  • 准备1台路由器,2台二层交换机,4台PC机 一.设置交换机路由器名字,端口IP,登陆密码,远程登陆 system-view 进入全部模式 [Huawei]sysname lsw1 设置交换机1名字 [Huawei]sysname lsw2 设置交换机2名字 [Huawei]...
  • 沼泽龙认证 ... 要访问路由器中的登录用户,请执行以下操作: self.connection.get_user() 或者 self.connection.user 令牌认证(感谢@silentninja) 将以下内容添加到设置文件: SWAMP_DRAGON_CONNECTI
  • 桑荣科技EDGE 路由器(User Manual)英文说明文档rar,桑荣科技EDGE 路由器(User Manual)英文说明文档
  • 200系列企业路由器WEB登录设置 方法/步骤 1、首先超级终端登录路由器,用户名admin密码admin或者Amdin@huawei 2、配置步骤: system-view [HUAWEI]http server enable(开启http服务) [HUAWEI]interface vlanif 1 ...
  • h3c路由器配置ssh登录方式

    万次阅读 2018-12-18 17:07:24
    3.user-interface vty vty号 (0 4) authentication-mode scheme 上述操作是设置一个VTY的,如果允许同时登陆多个,需要登几个就设几个VTY,重复上面俩操作即可 protocol inbound all 4.q...
  • 华为路由器、交换机配置命令

    万次阅读 多人点赞 2018-12-29 21:38:41
    华为路由器交换机配置命令是大家使用时经常遇到的,顾名思义关于交换机的计算机命令,路由器命令,交换机命令和动静态命令都将在文中提到。 史上最全华为路由器交换机配置命令大合集,熟练掌握下面的华为路由器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,115
精华内容 21,646
关键字:

user路由器登录