openfire源码分析---8

于 2015-11-30 21:24:40 发布
阅读量601 收藏
点赞数
分类专栏： openfire源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/conansonic/article/details/50119041
版权

登录

本章分析用户的登录。

第一个请求

用户首先发送一个关于sasl验证的请求，

<auth mechanism="DIGEST-MD5" xmlns="urn:ietf:params:xml:ns:xmpp-sasl"></auth>

根据前面几章的分析，用户的这条XMPP消息到达服务器后会经过层层处理，最后到达ClientStanzaHandler的process函数，

    public void process(String stanza, XMPPPacketReader reader) throws Exception {

        if (!sessionCreated || initialStream) {
            ...
        }


        Element doc = reader.read(new StringReader(stanza)).getRootElement();

        String tag = doc.getName();
        if ("starttls".equals(tag)) {
            ...
        }
        else if ("auth".equals(tag)) {
            startedSASL = true;
            saslStatus = SASLAuthentication.handle(session, doc);
        } else if (startedSASL && "response".equals(tag) || "abort".equals(tag)) {
            ...
        }
        else if ("compress".equals(tag)) {
            ...
        }
        else {
            process(doc);
        }
    }

这里标签名为tag，因此调用SASLAuthentication的handle函数进一步处理，

    public static Status handle(LocalSession session, Element doc) throws UnsupportedEncodingException {
        Status status;
        String mechanism;
        if (doc.getNamespace().asXML().equals(SASL_NAMESPACE)) {
            ElementType type = ElementType.valueof(doc.getName());
            switch (type) {
                case ABORT:
                    ...
                case AUTH:
                    mechanism = doc.attributeValue("mechanism");
                    session.setSessionData("SaslMechanism", mechanism);
                    if (mechanism.equalsIgnoreCase("ANONYMOUS") &&
                            mechanisms.contains("ANONYMOUS")) {
                        ...
                    }
                    else if (mechanism.equalsIgnoreCase("EXTERNAL")) {
                        ...
                    }
                    else if (mechanisms.contains(mechanism)) {
                        try {
                            Map<String, String> props = new TreeMap<String, String>();
                            props.put(Sasl.QOP, "auth");

                            SaslServer ss = Sasl.createSaslServer(mechanism, "xmpp",
                                    JiveGlobals.getProperty("xmpp.fqdn", session.getServerName()), props, new XMPPCallbackHandler());

                            byte[] token = new byte[0];
                            String value = doc.getTextTrim();
                            if (value.length() > 0) {
                                ...
                            }
                            if (mechanism.equals("DIGEST-MD5")) {
                                token = new byte[0];
                            }
                            byte[] challenge = ss.evaluateResponse(token);
                            if (ss.isComplete()) {
                                ...
                            }
                            else {
                                sendChallenge(session, challenge);
                                status = Status.needResponse;
                            }
                            session.setSessionData("SaslServer", ss);
                        }
                        catch (SaslException e) {

                        }
                    }
                    else {

                    }
                    break;
                case RESPONSE:
                    ...
                default:
                    ...
            }
        }
        else {

        }
        return status;
    }

首先调用createSaslServer为客户端请求的 SASL 机制获得一个 SaslServer 实例，其中注册了用来验证用户名和密码的事件处理器XMPPCallbackHandler，最后面分析。然后就调用evaluateResponse获得challenge，然后通过sendChallenge把这个challenge发往客户端，并将刚刚构造的SaslServer设置进Session中。
sendChallenge定义在SASLAuthentication中，

    private static void sendChallenge(Session session, byte[] challenge) {
        StringBuilder reply = new StringBuilder(250);

        String challenge_b64 = StringUtils.encodeBase64(challenge).trim();
        if ("".equals(challenge_b64)) {
            challenge_b64 = "=";
        }
        reply.append(
                "<challenge xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">");
        reply.append(challenge_b64);
        reply.append("</challenge>");
        session.deliverRawText(reply.toString());
    }

根据该函数，服务器返回给客户端的XMPP消息如下，

<response xmlns="urn:ietf:params:xml:ns:xmpp-sasl">
    #challenge
</response>

这里的#challenge代表一串通过编码后的字符串。

第二个请求

客户端收到刚刚服务器发来的challenge后，会根据用户名和密码组织消息，然后向服务器发送第二个消息，

<response xmlns="urn:ietf:params:xml:ns:xmpp-sasl">
    #challenge
</response>

该消息中的#challenge包含了用户名和密码等信息，到达服务器后，会到达ClientStanzaHandler的process函数，

    public void process(String stanza, XMPPPacketReader reader) throws Exception {

        if (!sessionCreated || initialStream) {
            ...
        }


        Element doc = reader.read(new StringReader(stanza)).getRootElement();

        String tag = doc.getName();
        if ("starttls".equals(tag)) {
            ...
        }
        else if ("auth".equals(tag)) {
            ...
        } else if (startedSASL && "response".equals(tag) || "abort".equals(tag)) {
            saslStatus = SASLAuthentication.handle(session, doc);
        }
        else if ("compress".equals(tag)) {
            ...
        }
        else {
            process(doc);
        }
    }

和第一个请求一样，这里也是调用SASLAuthentication的handle函数进一步处理，

    public static Status handle(LocalSession session, Element doc) throws UnsupportedEncodingException {
        Status status;
        String mechanism;
        if (doc.getNamespace().asXML().equals(SASL_NAMESPACE)) {
            ElementType type = ElementType.valueof(doc.getName());
            switch (type) {
                case ABORT:
                    ...
                case AUTH:
                    ...
                case RESPONSE:
                    mechanism = (String) session.getSessionData("SaslMechanism");
                    if (mechanism.equalsIgnoreCase("EXTERNAL")) {
                        ...
                    }
                    else if (mechanism.equalsIgnoreCase("JIVE-SHAREDSECRET")) {
                        ...
                    }
                    else if (mechanisms.contains(mechanism)) {
                        SaslServer ss = (SaslServer) session.getSessionData("SaslServer");
                        if (ss != null) {
                            boolean ssComplete = ss.isComplete();
                            String response = doc.getTextTrim();
                            if (!BASE64_ENCODED.matcher(response).matches()) {
                                ...
                            }
                            try {
                                if (ssComplete) {
                                    ...
                                }
                                else {
                                    byte[] data = StringUtils.decodeBase64(response);
                                    byte[] challenge = ss.evaluateResponse(data);
                                    if (ss.isComplete()) {
                                        authenticationSuccessful(session, ss.getAuthorizationID(),
                                                challenge);
                                        status = Status.authenticated;
                                    }
                                    else {
                                        ...
                                    }
                                }
                            }
                            catch (SaslException e) {

                            }
                        }
                        else {
                            ...
                        }
                    }
                    else {
                        ...
                    }
                    break;
                default:
                    ...
            }
        }
        else {

        }
        if (status == Status.failed || status == Status.authenticated) {
            session.removeSessionData("SaslServer");
            session.removeSessionData("SaslMechanism");
        }
        return status;
    }

这里首先获得前面处理第一个请求时构造的SaslServer，然后调用evaluateResponse处理客户端的信息，这里假设验证成功，则会调用authenticationSuccessful，定义在SASLAuthentication中，

    private static void authenticationSuccessful(LocalSession session, String username,
            byte[] successData) {
        if (username != null && LockOutManager.getInstance().isAccountDisabled(username)) {
            ...
        }
        StringBuilder reply = new StringBuilder(80);
        reply.append("<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"");
        if (successData != null) {
            String successData_b64 = StringUtils.encodeBase64(successData).trim();
            reply.append(">").append(successData_b64).append("</success>");
        }
        else {
            reply.append("/>");
        }
        session.deliverRawText(reply.toString());
        if (session instanceof ClientSession) {
            ((LocalClientSession) session).setAuthToken(new AuthToken(username));
        }
        else if (session instanceof IncomingServerSession) {
            String hostname = username;
            ((LocalIncomingServerSession) session).addValidatedDomain(hostname);
        }
    }

这里就是构造返回信息并发给客户端，然后构造AuthToken并设置进LocalClientSession中。根据代码，客户端返回的信息如下，

<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl">
    #challenge
</success>

XMPPCallbackHandler

Sasl框架会回调XMPPCallbackHandler中的handle函数，

    public void handle(final Callback[] callbacks)
            throws IOException, UnsupportedCallbackException {


        String realm;
        String name = null;

        for (Callback callback : callbacks) {
            if (callback instanceof RealmCallback) {
                realm = ((RealmCallback) callback).getText();
                if (realm == null) {
                    realm = ((RealmCallback) callback).getDefaultText();
                }
            }
            else if (callback instanceof NameCallback) {
                name = ((NameCallback) callback).getName();
                if (name == null) {
                    name = ((NameCallback) callback).getDefaultName();
                }
            }
            else if (callback instanceof PasswordCallback) {
                try {
                    ((PasswordCallback) callback)
                            .setPassword(AuthFactory.getPassword(name).toCharArray());
                }
                ...
            }
            else if (callback instanceof VerifyPasswordCallback) {
                VerifyPasswordCallback vpcb = (VerifyPasswordCallback) callback;
                try {
                    AuthToken at = AuthFactory.authenticate(name, new String(vpcb.getPassword()));
                    vpcb.setVerified((at != null));
                }
                catch (Exception e) {
                    vpcb.setVerified(false);
                }
            }
            else if (callback instanceof AuthorizeCallback) {
                ...
            }
            else {
                ...
            }
        }
    }

获得了用户名和密码之后，会调用AuthFactory.authenticate进行验证，输入为用户名和密码，

    public static AuthToken authenticate(String username, String password)
            throws UnauthorizedException, ConnectionException, InternalUnauthenticatedException {
        authProvider.authenticate(username, password);
        return new AuthToken(username);
    }

authProvider默认为DefaultAuthProvider，

    public void authenticate(String username, String password) throws UnauthorizedException {
        username = username.trim().toLowerCase();
        if (username.contains("@")) {
            int index = username.indexOf("@");
            String domain = username.substring(index + 1);
            if (domain.equals(XMPPServer.getInstance().getServerInfo().getXMPPDomain())) {
                username = username.substring(0, index);
            } else {
                ...
            }
        }
        try {
            if (!password.equals(getPassword(username))) {
                throw new UnauthorizedException();
            }
        }
        catch (UserNotFoundException unfe) {
            ...
        }
    }

该函数就是对用户名做了一些处理，主要是调用getPassword获取密码并比对，getPassword就是简单地从数据库中读取密码。这里假设验证成功，返回到上层的authenticate中，构造AuthToken并返回。

用户验证成功后，需要绑定资源，下一章继续分析。

二侠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安卓xmpp简单介绍（登录）以及自签名证书的使用
fanst_的专栏
12-05 2521
安卓xmpp简单介绍（登录）以及自签名证书的使用概念OSI七层模型开放系统互连参考模型 (Open System Interconnect 简称OSI）是国际标准化组织(ISO)和国际电报电话咨询委员会(CCITT)联合制定的开放系统互连参考模型，为开放式互连信息系统提供了一种功能结构的框架。 它从低到高分别是：物理层、数据链路层、网络层、传输层、会话层、表示层和应用层，具体参考[百度百科](“h
Openfire源码分析
06-21
网上的openfire源码分析，整理成了本地文件，方便查看。作者的博客在此：https://www.cnblogs.com/Fordestiny/p/7462745.html
Openfire 中ＳＡＳＬ的认证方式之：ＰＬＡＩＮ，DIGEST-MD5，anonymous
热门推荐
coding_me的专栏
09-24 1万+
SASL  的认证方式包括：     1. PLAIN：plain是最简单的机制，但同时也是最危险的机制，因为身份证书（登录名称与密码）是以base64字符串格式通过网络，没有任何加密保护措施。因此，使用plain机制时，你可能会想要结合tls。            2.DIGEST-MD5:使用这种机制时，client与server共享同一个隐性密码，而且此密码不通过网络传输。验证过
openfire源码分析---7
conansonic的博客
11-29 697
用户注册 本章介绍openfire中的用户注册，客户端首先发起一个xmpp请求，如下所示 iq id="#id" to="#serverName" type="get"> query xmlns="jabber:iq:register">query> iq> 这里，#id和#serverName都是在上一章中创建的，该请求最终会到达ClientStanzaHandler的proc
openfire源码分析---3
conansonic的博客
10-26 1159
openfire源码分析—3接着openfire源码分析2中的XMPPServer的start()函数，如下所示 ... if (!setupMode) { verifyDataSource(); // First load all the modules so that modules m
openfire源码分析---1
conansonic的博客
10-13 1151
OpenFire源码分析—1openfire 3.10是openfire最近更新的版本，下面就开始分析openfire源码openfire的3.10的源码在Eclipse展开后如下图所示（部分） main函数openfire的main函数有两个 /src/java/org/jivesoftware/openfire/launcher/Launcher.java /src/java/org/ji
openfire源码分析---6
conansonic的博客
11-24 668
openfire源码分析—6 从上一章的分析可知，客户端发来的消息最后会经过ClientStanzaHandler，并调用其中的process函数，在该函数会根据消息头（XML标签）判断是io消息、presence消息还是message消息，然后调用相应的函数进行处理。本章主要分析message消息的处理，其对应的处理函数为processMessage，定义在ClientStanzaHandle
openfire源码分析---2
conansonic的博客
10-22 1744
openfire源码分析—2XMPPServer构造函数 public XMPPServer() { // We may only have one instance of the server running on the JVM if (instance != null) { throw new IllegalStateExcepti
openfire源码分析---5
conansonic的博客
11-19 746
filter源码分析 在上一章分析的createClientListeners函数中构造了3个filter，ExecutorFilter、ProtocolCodecFilter和StalledSessionsFilter并将它们添加到mina框架中，
openfire源码分析---4
conansonic的博客
10-28 1428
openfire源码分析—4 openfire使用的是mina框架，关于mina框架的详细解析可以上网百度或者下载源码自行分析。这里转载一个mina的框架图， 如图所示，简单来说，IoService用于管理Socket的连接，IoFilterChain是一串过滤器，IoHandler用于业务逻辑处理。 下面来看ConnectionManagerImpl模块，由第三章的分析知道，每个模块被
openfire-4.5.0源码
01-29
通过阅读Openfire源码，开发者可以了解即时通讯系统的底层实现，学习如何处理并发连接、优化性能和保证安全性。此外，源码中的注释和文档也能帮助理解设计决策和最佳实践。对于想要二次开发或自定义功能的开发者来说...
关于Openfire集群源码的分析
08-29
通过以上分析，我们可以看到Openfire集群源码分析涉及的主要知识点包括Openfire的基本架构、XMPP协议、分布式计算的CAP理论、集群数据同步策略以及缓存设计与管理。这些内容对于理解Openfire如何在大规模部署中保证...
openfire源码
08-01
源码分析： 1. **XMPP协议**：Openfire的核心在于其对XMPP的实现。XMPP是一种基于XML的开放标准，用于即时消息传递和在线状态管理。通过这个协议，Openfire能与其他兼容XMPP的客户端和服务进行交互，如Pidgin、...
浙江海洋大学考研8个学院，42个专业课历年考试真题及答案汇总，备考资料题库笔记，考前题库汇总.pdf
07-16
浙江海洋大学考研8个学院，42个专业课历年考试真题及答案汇总，备考资料题库笔记，考前题库汇总.pdf
传感器实验指导书.docx
07-16
传感器
海康相机使用IO触发模式并输出NG/OK
最新发布
07-16
1、包含海康工业相机接线图 2、MVS中的相机设置 3、vm4.2中的设置 4、VM简单创建程序步骤
传感器复习--习题.doc
07-16
传感器
传感器心得体会.docx
07-16
传感器
smack-openfire
10-27
Smack-Openfire是基于Java语言的开源软件库，用于实现XMPP（可扩展通信和跨网络传输协议）协议的客户端。它是为了简化开发者在Android、Java和其他基于Java的平台上构建聊天应用程序的过程。 首先，Smack-Openfire...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值