Digest Auth 摘要认证

最新推荐文章于 2024-04-22 09:07:06 发布
最新推荐文章于 2024-04-22 09:07:06 发布
阅读量2.2k 收藏 4
点赞数
分类专栏： 认证 文章标签： java 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dandan201212/article/details/116457400
版权

Digest Auth 摘要认证

1.非常规方式

转载：https://blog.csdn.net/qq_25391785/article/details/86595529

    public static void postMethod(String url, String query) {
        try {

            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(
                    new AuthScope("xx.xx.xx.xx", 80),//请求地址 + 端口号
                    new UsernamePasswordCredentials("xx", "xxxx"));// 用户名 + 密码 （用于验证）
            CloseableHttpClient httpclient = HttpClients.custom()
                    .setDefaultCredentialsProvider(credsProvider)
                    .build();
            HttpPost postMethod = new HttpPost(url);//请求详细地址（如：http://192.168.1.105:9000/MotorVehicles）
            StringEntity s = new StringEntity(query);//向后台传的json数据
            s.setContentEncoding("utf-8");//编码
            s.setContentType("application/json");//发送json数据需要设置contentType
            postMethod.setEntity(s);
            HttpResponse response = httpclient.execute(postMethod); //执行POST方法

            System.out.println("resCode = " + response.getStatusLine().getStatusCode()); //获取响应码

            System.out.println("result = " + EntityUtils.toString(response.getEntity(), "utf-8")); //获取响应内容

        } catch (Exception e) {
            System.out.println("推送失败："+e);
        }

    }

2.常规认证方式

在这里插入图片描述
1.发送一个请求

    GET /auth/basic/ HTTP/1.1
    HOST: target

2.服务器返回401响应头,要求输入用户凭据

    HTTP/1.1 401 Unauthorized
    WWW-Authenticate: Digest realm="Digest Encrypt",nonce="nmeEHKLeBAA=aa6ac7ab3cae8f1b73b04e1e3048179777a174b3", opaque="0000000000000000",stale=false, algorithm=MD5, qop="auth"

3.输入凭据后再发送请求

    GET /auth/digest/ HTTP/1.1
    Accept: */*
    Authorization:  Digest username="LengWa", realm="Digest Encrypt",  qop="auth", algorithm="MD5", uri="/auth/digest/", nonce="nmeEHKLeBAA=aa6ac7ab3cae8f1b73b04e1e3048179777a174b3", nc=00000001, cnonce="6092d3a53e37bb44b3a6e0159974108b", opaque="0000000000000000", response="652b2f336aeb085d8dd9d887848c3314"

4.服务端验证通过后返回数据

代码工具类（本人的实际服务因第二次传的凭据不返回realm参数，遂在代码里将其写死）：


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.asiainfo.req.DigestAuthReq;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Http Digest Request contains POST、GET、PUT
 * @author zhangdan
 * @date 2021-04-22
 */
@Slf4j
public class HttpRequestUtils {

    private static final Logger logger = LoggerFactory.getLogger(HttpRequestUtils.class);

    public static void main(String[] args) {

//        String param = "";
//        String username = "xxxx";
//        String password = "xxxx";


        postMethod("http://ip:80/api/howell/ver10/aiop_service/garbage_management/GarbageStations/Cameras/List","{\n" +
                "    \"PageIndex\":\"1\",\n" +
                "    \"PageSize\":\"99999\"\n" +
                "}");
        //System.out.println(s);
    }

    static int nc = 0;    //调用次数
    private static final String GET = "GET";
    private static final String POST = "POST";
    private static final String PUT = "PUT";
    private static final String DELETE = "DELETE";




    /**
     * 向指定URL发送POST方法的请求
     * @param url                                       发送请求的URL
     * @param param                                     请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @param username                                  验证所需的用户名
     * @param password                                  验证所需的密码
     * @param json                                      请求json字符串
     * @param type                                      返回xml和json格式数据，默认xml，传入json返回json数据
     * @return URL 所代表远程资源的响应结果
     */
    public  static String sendPost(DigestAuthReq digestAuthReq) {
        StringBuilder result = new StringBuilder();
            String json= digestAuthReq.getJsonStr();
            String url= digestAuthReq.getUrl();
            String param= digestAuthReq.getParam();
            String username=digestAuthReq.getUsername();
            String password=digestAuthReq.getPassword();
            String type= digestAuthReq.getType();
            logger.info("json============="+json);
            BufferedReader in = null;
            try {
                //String wwwAuth = sendGet(url, param);       //发起一次授权请求
                String wwwAuth=sendPost(url, param);
                if (wwwAuth.startsWith("WWW-Authenticate:")) {
                    wwwAuth = wwwAuth.replaceFirst("WWW-Authenticate:", "");
                } else {
                    return wwwAuth;
                }
                nc ++;
                String urlNameString = url + (StringUtils.isNotEmpty(param) ? "?" + param : "");
                URL realUrl = new URL(urlNameString);
                // 打开和URL之间的连接
                HttpURLConnection connection = (HttpURLConnection)realUrl.openConnection();

                // 设置是否向connection输出，因为这个是post请求，参数要放在
                // http正文内，因此需要设为true
                connection.setDoOutput(true);
                // Read from the connection. Defaultis true.
                connection.setDoInput(true);
                // 默认是 GET方式
                connection.setRequestMethod(POST);
                // Post 请求不能使用缓存
                connection.setUseCaches(false);

                // 设置通用的请求属性
                setRequestProperty(connection, wwwAuth,realUrl, username, password, POST, type);

                if (!StringUtils.isEmpty(json)) {
                    byte[] writebytes =json.getBytes();
                    connection.setRequestProperty("Content-Length",String.valueOf(writebytes.length));
                    OutputStream outwritestream = connection.getOutputStream();
                    outwritestream.write(json.getBytes());
                    outwritestream.flush();
                    outwritestream.close();
                }
                if (connection.getResponseCode() == 200 || connection.getResponseCode() == 201) {
                    in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                    String line;
                    while ((line = in.readLine()) != null) {
                        result.append(line);
                    }
                } else {
                    String errResult = formatResultInfo(connection, type);
                    logger.info(errResult);
                    return errResult;
                }

                nc = 0;
            } catch (Exception e) {
                nc = 0;
                throw new RuntimeException(e);
            } finally {
                try {
                    if (in != null) in.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }


        return result.toString();
    }


    /**
     * 向指定URL发送GET方法的请求
     * @param url                                       发送请求的URL
     * @param param                                     请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @param username                                  验证所需的用户名
     * @param password                                  验证所需的密码
     * @param type                                      返回xml和json格式数据，默认xml，传入json返回json数据
     * @return URL 所代表远程资源的响应结果
     */
    public static String sendGet(String url, String param, String username, String password, String type) {

        StringBuilder result = new StringBuilder();
        BufferedReader in = null;
        try {
            String wwwAuth = sendGet(url, param);       //发起一次授权请求
            if (wwwAuth.startsWith("WWW-Authenticate:")) {
                wwwAuth = wwwAuth.replaceFirst("WWW-Authenticate:", "");
            } else {
                return wwwAuth;
            }
            nc ++;
            String urlNameString = url + (StringUtils.isNotEmpty(param) ? "?" + param : "");
            URL realUrl = new URL(urlNameString);
            // 打开和URL之间的连接
            HttpURLConnection connection = (HttpURLConnection)realUrl.openConnection();
            // 设置通用的请求属性
            setRequestProperty(connection, wwwAuth,realUrl, username, password, GET, type);
            // 建立实际的连接
            // connection.connect();
            in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
            nc = 0;
        } catch (Exception e) {
            nc = 0;
            throw new RuntimeException(e);
        } finally {
            try {
                if (in != null) in.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return result.toString();
    }

    /**
     * 生成授权信息
     * @param authorization                             上一次调用返回401的WWW-Authenticate数据
     * @param username                                  用户名
     * @param password                                  密码
     * @return                                          授权后的数据, 应放在http头的Authorization里
     * @throws IOException                              异常
     */
    private static String getAuthorization(String authorization, String uri, String username, String password, String method) throws IOException {

        uri = StringUtils.isEmpty(uri) ? "/" : uri;
        String temp = authorization.replaceFirst("Digest", "").trim().replace("MD5","\"MD5\"").replace("realm=\"\"","realm=\"/howell/ver10/data\"");
        String json = withdrawJson(authorization);

        JSONObject jsonObject = JSON.parseObject(json);
        String cnonce = Digests.generateSalt2(8);
        String ncstr = ("00000000" + nc).substring(Integer.toString(nc).length());     //认证的次数,第一次是1，第二次是2...
        String algorithm = jsonObject.getString("algorithm");
        String qop = jsonObject.getString("qop");
        String nonce = jsonObject.getString("nonce");
        String realm = jsonObject.getString("realm");
        if(StringUtils.isEmpty(realm)){
            realm="/howell/ver10/data";
        }

        String response = Digests.http_da_calc_HA1(username, realm, password,
                nonce, ncstr, cnonce, qop,
                method, uri, algorithm);

        //组成响应authorization
        authorization = "Digest username=\"" + username + "\"," + temp;
        authorization += ",uri=\"" + uri
                + "\",nc=\"" + ncstr
                + "\",cnonce=\"" + cnonce
                + "\",response=\"" + response+"\"";
        return authorization;
    }

    /**
     * 将返回的Authrization信息转成json
     * @param authorization                                     authorization info
     * @return                                                  返回authrization json格式数据 如：String json = "{ \"realm\": \"Wowza\", \" domain\": \"/\", \" nonce\": \"MTU1NzgxMTU1NzQ4MDo2NzI3MWYxZTZkYjBiMjQ2ZGRjYTQ3ZjNiOTM2YjJjZA==\", \" algorithm\": \"MD5\", \" qop\": \"auth\" }";
     */
    private static String withdrawJson(String authorization) {
        String temp = authorization.replaceFirst("Digest", "").trim().replaceAll("\"","");
        String[] split = temp.split(",");
        Map<String, String> map = new HashMap<>();
        Arrays.asList(split).forEach(c -> {
            String c1 = c.replaceFirst("=",":");
            String[] split1 = c1.split(":");
            if(split1[0].trim().equals("realm")){
                map.put(split1[0].trim(), "/howell/ver10/data");
            }else{
                map.put(split1[0].trim(), split1[1].trim());
            }

        });
        return JSONObject.toJSONString(map);
    }

    /**
     * 向指定URL发送GET方法的请求
     * @param url                                                   发送请求的URL
     * @param param                                                 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return URL                                                  所代表远程资源的响应结果
     */
    public static String sendGet(String url, String param) {
        StringBuilder result = new StringBuilder();
        BufferedReader in = null;
        try {

            String urlNameString = url + (StringUtils.isNotEmpty(param) ? "?" + param : "");
            URL realUrl = new URL(urlNameString);
            // 打开和URL之间的连接
            URLConnection connection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");

            connection.connect();

            //返回401时需再次用用户名和密码请求
            //此情况返回服务器的 WWW-Authenticate 信息
            if (((HttpURLConnection) connection).getResponseCode() == 401) {
                Map<String, List<String>> map = connection.getHeaderFields();
                return "WWW-Authenticate:" + map.get("WWW-Authenticate").get(0);
            }

            in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
        } catch (Exception e) {
            throw new RuntimeException("get请求发送失败",e);
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                System.out.println(result.toString());
                if (in != null) in.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        System.out.println(result.toString());
        logger.info(result.toString());
        return result.toString();

    }


    /**
     * 向指定URL发送GET方法的请求
     * @param url                                                   发送请求的URL
     * @param param                                                 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return URL                                                  所代表远程资源的响应结果
     */
    public static String sendPost(String url, String parameters ) {
        String result = "";
        BufferedReader in = null;
        try {
            String ip = "124.71.147.146";
            Integer port = 80;
            String username="wujiaochang";
            String password="3EhcqnbnZ4QFJ9sk";
            int resCode = 404;
            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(new AuthScope(ip, port), // 请求地址 + 端口号
                    new UsernamePasswordCredentials(username, password));// 用户名 + 密码 （用于验证）
            HttpClient httpclient = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
            try {
                SSLContext sslContext = SSLContextBuilder.create().useProtocol(SSLConnectionSocketFactory.SSL).loadTrustMaterial((x, y) -> true).build();
                RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setSocketTimeout(5000).build();
                httpclient = HttpClientBuilder.create().setDefaultRequestConfig(config).setSSLContext(sslContext).setSSLHostnameVerifier((x, y) -> true).build();
            } catch (Exception e) {
                e.printStackTrace();
            }
            HttpPost postMethod = new HttpPost(url);// 请求详细地址（如：http://192.168.1.105:9000/MotorVehicles）
            //根据不通要求自己添加头
            //根据不通要求自己添加头
            postMethod.addHeader("Content-Type", "application/json");
            postMethod.addHeader("accept", "*/*");
            postMethod.addHeader("connection", "Keep-Alive");
            postMethod.addHeader("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");

            StringEntity s = new StringEntity(JSON.toJSONString(parameters));// 向后台传的json数据
            s.setContentEncoding("utf-8");// 编码
            postMethod.setEntity(s);
            HttpResponse response = httpclient.execute(postMethod); // 执行POST方法
            resCode = response.getStatusLine().getStatusCode();
            System.out.println("resCode = " + resCode); // 获取响应码
            result = EntityUtils.toString(response.getEntity(), "utf-8");
            log.info("result = " + result); // 获取响应内容

            if (resCode == 401) {
                return  "" +response.getHeaders("WWW-Authenticate")[0];
            }
        }
        // 使用finally块来关闭输入流
        catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(result.toString());
        logger.info(result.toString());
        return result.toString();

    }
    /**
     * HTTP set request property
     *
     * @param connection                            HttpConnection
     * @param wwwAuth                               授权auth
     * @param realUrl                               实际url
     * @param username                              验证所需的用户名
     * @param password                              验证所需的密码
     * @param method                                请求方式
     * @param type                                  返回xml和json格式数据，默认xml，传入json返回json数据
     */
    private static void setRequestProperty(HttpURLConnection connection, String wwwAuth, URL realUrl, String username, String password, String method, String type)
            throws IOException {

        if (type != null && type.equals("json")) {
            // 返回json
            connection.setRequestProperty("X-Webbrowser-Authentication","Forbidden");
            connection.setRequestProperty("accept", "application/json;charset=UTF-8");
            connection.setRequestProperty("Content-Type","application/json;charset=UTF-8");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
        } else {
            // 返回xml
            if (!method.equals(GET)) {
                connection.setRequestProperty("X-Webbrowser-Authentication","Forbidden");
                connection.setRequestProperty("Content-Type","application/json;charset=UTF-8");
            }
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            // connection.setRequestProperty("Cache-Control", "no-cache");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");

        }
        //授权信息
        String authentication = getAuthorization(wwwAuth, realUrl.getPath(), username, password, method);
        connection.setRequestProperty("Authorization", authentication);
    }

    /**
     * 格式化请求返回信息，支持json和xml格式
     * @param connection                                HttpConnection
     * @param type                                      指定返回数据格式，json、xml，默认xml
     * @return                                          返回数据
     */
    private static String formatResultInfo(HttpURLConnection connection, String type) throws IOException {
        String result = "";
        if (type != null && type.equals("json")) {
            result = String.format("{\"errCode\":%s, \"message\":%s}",connection.getResponseCode(),connection.getResponseMessage());
        } else {
            result = String.format(" <?xml version=\"1.0\" encoding=\"UTF-8\" ?> "
                    + " <wmsResponse>"
                    + " <errCode>%d</errCode>"
                    + " <message>%s</message>"
                    + " </wmsResponse>",connection.getResponseCode(),connection.getResponseMessage());
        }
        return result;
    }



}
adan201212
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
OAuth 认证步骤
YearnWang的专栏
06-02 1477
<br />Twitter 将于本月16日开始限制 Basic authentication 的使用，而直至本月31日，所有 Basic authentication 的请求都将只能收到 403 的回复了。尽管这会给亚洲某个地区的用户带来很大的不便，但是我们也要看到 OAuth 的好处，比如更强的安全性，因为不会泄漏用户的密码等信息，脱离密码的另一个好处就是各种应用可以无视用户对密码的修改，用户修改密码后并不会影响应用的 正常工作，此外，我们可以给自己的消息设置一个自定义来源名称，利于个性化.
OAuth认证原理
Matrix_Designer的专栏
03-31 711
User(Browser)-Client(Web Server)-Server(Service Provider) OAuth1 1: Client->Server:输入client-key；获取ungranted token; 2: User->Server:输入ungranted token，callback-url；通过callback-url的参数获取granted token
HTTP Digest Auth
最新发布
VFSSoft Blogs
04-22 1197
相比于 Basic，Digest 不需要在网络上传输用户的密码。但是它依然不是一个身份验证的完美方案，它没有提供认证消息内容加密的机制。这个协议的目的是创建一个简单的认证方法，避免 Basic 的严重缺陷。
模拟Digest认证的登录demo
01-15
一个模拟http 401 Digest认证的登录海康NVR抓取摄像头列表的小demo
HTTP 基本认证（basic auth）和摘要认证（digest auth）区别
Dontla的博客
02-07 3801
Basic认证是一种较为简单的HTTP认证方式，客户端通过明文（Base64编码格式）传输用户名和密码到服务端进行认证，通常需要配合HTTPS来保证信息传输的安全。Digest认证是为了修复基本认证协议的严重缺陷而设计的，秉承“绝不通过明文在网络发送密码”的原则，通过“密码摘要”进行认证，大大提高了安全性。绝不通过明文在网络上发送密码可以有效防止恶意用户进行重放攻击可以有选择的防止对报文内容的篡改。
Digest Auth 认证
雨陆聪辰的博客
01-22 4646
本人写的Digest 认证一次通过，不需要按照常规的方式来  public void postMethod(String url, String query) { try { CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCred...
OKHTTP3+springboot
qq_35761348的博客
12-29 696
1.pom文件添加 <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> </dependency> 2.工具类创建 import java.io.IOException; import java.net.InetSocketAddress; import java.net.Proxy; import java
java httpClient Digest Auth 认证
coderYJ的博客
06-30 3026
技术交流QQ群 933925017 java httpClient Digest Auth 认证 因为项目需要,请求海康摄像头,进行抓图以及云台控制等功能, 海康有http协议,但是需要进行请求头认证,因为海康给的资料已经过时,所以找了很久 1.先上postMan测试通过 2.httpClient代码 - 发送普通的请求 DefaultHttpClient httpclient = new DefaultHttpClient(); String hostUrl = "http://172.16.1.1.
okhttp-digest:okhttp的摘要身份验证器
05-04
okhttp-digest okhttp的摘要身份验证器。 大多数代码是从Apache Http Client移植的。重要的该工件已从jcenter转移到了Maven Central！ 坐标已从com.burgstaller:okhttp-digest:<version>到io.github.rburgst:okhttp-...
Http Digest 鉴权
06-21
“摘要”式认证（ Digest authentication）是一个简单的认证机制，最初是为HTTP协议开发的，因而也常叫做HTTP摘要，在RFC2671中描述。...摘要认证就是要核实，参与通信的双方，都知道双方共享的一个秘密（即口令）。
go-http-auth:golang http的基本和摘要HTTP身份验证
05-04
Go中的HTTP身份验证实现这是Go语言中HTTP Basic和HTTP Digest身份验证的实现。 它被设计为http.RequestHandler函数的简单包装。特征支持HTTP基本和HTTP摘要身份验证。 支持htpasswd和htdigest格式的文件。 自动重新...
http-client-digest_auth：针对Crystal的RFC 2617摘要访问身份验证的实现
02-04
总的来说，`http-client-digest_auth`库为Crystal开发者提供了方便且安全的摘要认证解决方案，遵循了RFC 2617标准，确保了与各种支持摘要认证的服务器的兼容性。理解和正确使用这个库，能够帮助提升你的应用程序在...
HTTP Digest authentication
热门推荐
Andrea的笔记
05-14 1万+
最近学习了HTTP Digest，并且分别在php和android实现了server端和服务器端逻辑
http-digest的认证
kongyun的博客
08-18 1851
摘要认证 digest authentication　　　←　HTTP1.1提出的基本认证的替代方法     服务器端以nonce进行质询，客户端以用户名，密码，nonce，HTTP方法，请求的URI等信息为基础产生的response信息进行认证的方式。     ※　不包含密码的明文传递          摘要认证步骤：      1. 客户端访问一个受http摘要认证保护的资源。  
WebApi接口安全认证
weixin_30608503的博客
03-02 351
摘要访问认证是一种协议规定的Web服务器用来同网页浏览器进行认证信息协商的方法。它在密码发出前，先对其应用哈希函数，这相对于HTTP基本认证发送明文而言，更安全。从技术上讲，摘要认证是使用随机数来阻止进行密码分析的MD5加密哈希函数应用。它使用HTTP协议。 一、摘要认证基本流程： 1.客户端请求 (无认证) Html代码 GET/dir/in...
http请求digest auth认证
qq_41975712的博客
09-21 707
http请求digest auth认证
http协议之digest(摘要)认证，详细讲解并附Java SpringBoot源码
一火的专栏
12-04 6297
http协议之digest(摘要)认证，详细讲解并附Java SpringBoot源码
HTTP认证之摘要认证——Digest
u010068160的博客
08-07 1647
一、概述 Digest认证是为了修复基本认证协议的严重缺陷而设计的，秉承“绝不通过明文在网络发送密码”的原则，通过“密码摘要”进行认证，大大提高了安全性。 相对于基本认证，主要有如下改进： 绝不通过明文在网络上发送密码 可以有效防止恶意用户进行重放攻击 可以有选择的防止对报文内容的篡改 需要注意的是，摘要认证除了能够保护密码之外，并不能保护其他内容，与HTTPS配合使用仍是一个良好的选择。以下是摘要认证的具体流程图： 看到上面出现了那么多之前没见过的参数，...
ip ospf message-digest-key d123对应华为那条命令
06-12
在华为设备上，对应的命令是： ospf [process-id] message-digest-key [key-id] md5 [key] 其中，process-id 是 OSPF 进程 ID（默认为 1），key-id 是密钥 ID（取值范围为 1~255），key 是密钥内容。因此，如果要添加一个密钥 ID 为 123，密钥内容为 d123 的 OSPF MD5 认证密钥，则应该输入以下命令： ospf message-digest-key 123 md5 d123

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值