相关概念说明

• SPNEGO：简单且受保护的 GSS-API 协商机制中定义的一项标准规范。如果启用SPNEGO Web 认证，那么在处理第一个入站 HTTP 请求时会对 SPNEGO 进行初始化。Web 认证器组件会与 SPNEGO 交互，SPNEGO 是在安全性配置库中定义并启用的。当鉴权条件得到满足时，SPNEGO 会负责认证对 HTTP 请求中标识的受保护资源的访问权。
• Kerberos与SPNEGO的关系：Kerberos 是GSS-API 的一种实现，其它的实现方式还包括NTLM，DCE之类。
• JAAS：Java验证和授权的API，提供了灵活和可伸缩的机制来保证客户端或服务器端的Java程序。
• Kerberos：一种基于中心认证服务器的中心化认证协议和框架。应用程序访问服务前需使用此框架进行登录认证，以在应用程序之间形成动态可控的受信。中心化登录服务器称为KDC。
• GSSAPI：在jdk中，作为对kerberos认证交互的主要实现。
• Krb5LoginModule.java：在jdk中，负责从KDC获取登录凭证，是kerberos认证的主要实现。
• SASL：在jdk中定义的一种通用的基于客户端和服务端的认证框架，GSSAPI是其实现之一。

SPNEGO Web认证的优点

• window会建立使用 Active Directory 域并具有 Microsoft Windows Server 的集成单点登录环境。
  会降低管理大量标识和密码的成本。
• 对于来自 Web 浏览器或 Microsoft .NET 客户机的安全凭证，将安全地传输这些凭证并且互相进行认证。
• 能够与在传输层使用 SPNEGO 认证的 Web Service 和 Microsoft .NET 或 Web Service 应用程序进行互操作。
• 借助 Kerberos 认证支持，SPNEGO Web 认证可为 Kerberos 解决方案提供端到端 SPNEGO 并且保存来自客户机的 Kerberos 凭证。

JDK中Kerberos的认证原理

Kerberos认证流程

• 关于登录kerberos及其与kdc服务器进行交互的流程，不再描述.

LoginContext

• LoginContext也即是认证上下文，提供了登录/认证相关的基础方法，应用程序层的代码一般只需要和LoginContext打交道。
• LoginContext配置了一组动态的LoginModule。根据LoginContext对象初始化的类型来动态加载对应的LoginModule实现类，加载的实现类可以是一个或者多个，在实现鉴权时将按照堆叠的顺序被调用。在ranger中，如果开启了kerberos环境认证，那么将依次加载下列认证类有

#Krb5LoginModule, JndiLoginModule
org.apache.hadoop.security.SecureClientLogin. loginUserFromKeytab
org.apache.hadoop.security.SecureClientLogin.loginUserWithPassword

• LoginContext方法
  • login () :进行登录操作。该方法激活了配置中制定的所有LoginModule对象。如果成功，它将创建一个经过了验证的Subject对象；否则抛出LoginException异常。
  • getSubject () :返回经过验证的Subject对象。
  • logout () :注销Subject对象，删除与之相关的Principal对象和凭证。
• LoginContext在JAAS认证中位置

image.png

LoginModule

• LoginModule 是认证服务接口类，不同的认证服务均需要实现该接口。如开启了kerberos认证服务实现的类为Krb5LoginModule，基于账户和密码实现的类为JndiLoginModule
• LoginModule方法(一般通过LoginModule调用)
  • login () : 进行验证。
  • commit () : 当LgoninContext对象接受所有LoginModule对象传回的结果后将调用该方法。该方法将Principal对象和凭证赋给Subject对象。
  • abort () : 当任何一个LoginModule对象验证失败时都会调用该方法。此时没有任何Principal对象或凭证关联到Subject对象上。
  • login () : 删除与Subject对象关联的Principal对象和凭证。
• LoginModule例子说明
  • 在下列的ranger登录方法中，在LoginContext的定义中指定了hadoop-keytab-kerberos，则表示要加载的LoginModule是Krb5LoginModule。调用LoginContext的login()方法实际是反向代理到Krb5LoginModule的login来与KDC进行交互。在交互中会带本地已经kinit的用户凭证。如果用户登录kerberos成功，将返回Subject类。

public synchronized static Subject loginUserWithPassword(String user, String password) throws IOException {
   try {
      Subject subject = new Subject();
      SecureClientLoginConfiguration loginConf = new SecureClientLoginConfiguration(false, user, password);
      LoginContext login = new LoginContext("hadoop-keytab-kerberos", subject, null, loginConf);
      subject.getPrincipals().add(new User(user, AuthenticationMethod.KERBEROS, login));
      login.logout();
      login.login();
      return login.getSubject();
   } catch (LoginException le) {
      throw new IOException("Login failure for " + user + " using password ****", le);
   }
}

• Subject是一个不可继承的实体类，它标志一个请求的来源，包含相关的凭证标识(Principal) 和 公开和私有的凭据(Credential)。在涉及到需要进行权限认证的地方（例如，资源访问，外部链接校验，协议访问等），可以调用Subject.doAs系列方法进行授权代码的调用。

综上所述:kerberos的登录流程，是由LoginContet/LoginModule完成的，成果是Subject对象。

客户端与服务端交互

• 当目前我们已经搞清楚了如何通过KDC拿到Subject对象，但是登录只是获取了某种Token，但是Token的合法性必需通过通信双方进行至少一次交互才能确定，这时候就引入了GSSAPI。
• GSSAPI采用的通信协议正是开启SPNEGO的http协议，具体流程是：
  • Subject.doAs的Context里面，GSSAPI客户端首先调用initSecContext，将得到的byte[]发给服务端。
  • 服务端用收到的byte[]，调用acceptSecContext，将得到的byte[]发还给客户端。
  • 客户端再次调用initSecContext来完成认证。
  • 当客户端和服务端认证完成后，后续的通信应该使用wrap和unwrap对数据进行Base64加密后发送。

kerberos http请求机制

• 基于上述讲解，我们目前指定java中可以通过Krb5LoginModule模块实现Kerberos登录，以及通过GSSAPI来完成通讯双方校验基本流程，详细过程可以如下图：

Kerberos鉴权原理

• 从上图中可以看出这是对服务端的一种保护，只有持有合法用户名(Principal)和密码(keytab)的客户端才可以访问。主要的步骤有：
  • 1-2: 客户端首先从KDC中验证得到票据，基于客户端持有的用户名(Principal)和密码(keytab)。
  • 3-4: 客户端从KDC上获取要访问的服务(server ticker/principal)的票据。
  • 5-6: 客户端访问服务的时候携带服务端的票据(server ticker/principal)，服务端校验票据的合法性

• 从上图中可以得出必备的环境和物料
  • KDC服务器，以及这个服务器的地址信息配置(krb5.conf)，用于Krb5LoginModule从KDC处获取票据。
  • 一个合法的客户端用户名(Principal)和密码(keytab)。
  • 一个合法的服务端SerivcePrincipal，服务端在构建的时候也需要登录SerivcePrincipal，所以SerivcePrincipal对应的keytab也需要
  • 注意：这里的server ticker/principal指的是被请求的服务端，它自己本身运行要运行在kerberos环境中，它也需要一个 principal！所以你应该先分析出服务端server是用什么principal启动的，得出后client 端最好是跟它配置成一致的。(PS:如果分析不出来的话，可以用下面的程序去一个个试)
• ranger中请求详细过程
  1.用户尝试访问 Web 应用程序，发送普通http请求。
  2.服务端返回401和WWW-Authentication: Negotiation头应答客户端浏览器。
  3.客户端初始化gss_context，开始kerberos认证流程：

  (1).以当前kinit登录的用户为客户端用户，从kdc处获取票据(第1,2步)
  (2).以HTTP/host@DOMAIN为service ticker，从kdc处获得该服务的访问票据token,后面用于生成Negotiation的内容(第3.4步)，其中host是被访问的服务器地址或主机名。
  (3)再次发送http请求，生成Authentication: Negotiation xxxxxxx。其中xxxxxxx是第(2)token用base64加密而来。
  (4).服务端验证Authentication: Negotiation xxxxxxx
  (5).如果授予访问权，那么 服务器会发送带有 HTTP 200 的响应。服务器还会在响应中包含 cookie可用于后续请求。

4.特别注意！！这里请求的服务端的hostname一定要和principal的角色名一样(principal组成:用户名/角色@realm域),并配置好相关的hosts,千万不能用ip访问(切记kerberos规则都是用域名的)

从程序的角度看请求过程

• 本java程序的作用是测试client principal 访问开启了kerberos http鉴权的server是否能通。
• Main.java是为程序的主方法，主要是做相关的principal和keytab的定义。
• RequestKerberosUrlUtils.java是主要的测试方法，包括了请求kdc进行验证获取TGT ticker 和 构建SPNEGO请求。

package com.xxxxxx.kantlin.kerberos;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpResponse;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        params();
    }
    public static void params() {
        //client principal！最好和service principal的一致
        String user = "xxxxxx/hive2@<realm>";
        //client的keytab文件，没有的话先kinit一下
        String keytab = "C:\\\\Users\\\\xxxxx\\\\Desktop\\\\keytab\\\\hive2.keytab";
        //kerberos krb5文件(ps:一般机器上都有，找不到的话执行命令:find / -name krb5.conf)
        String krb5Location = "C:\\Users\\xxxxx\\Desktop\\keytab\\krb5.conf";
        try {
            //此处的true为将kerberos设置为debug模式,将打印更多详细日志
            RequestKerberosUrlUtils restTest = new RequestKerberosUrlUtils(user, keytab, krb5Location, true);
            //此处为开启了kerberos http认证的ranger admin 为例,url中带secure表示运行在高安全模式
            //特别重要！！这里请求的hostname一定要和principal的FQDN（hive2)一样,并配置好相关的hosts,千万不能用ip(切记kerberos都是域名)
            String url_liststatus = "http://hive2:6080/service/plugins/secure/policies/download/hive2";
            HttpResponse response = restTest.callRestUrl(url_liststatus, user);
            InputStream is = response.getEntity().getContent();
            System.out.println("Status code " + response.getStatusLine().getStatusCode());
            System.out.println("message is :" + Arrays.deepToString(response.getAllHeaders()));
            System.out.println("string：\n" + new String(IOUtils.toByteArray(is), StandardCharsets.UTF_8));
        } catch (Exception exp) {
            exp.printStackTrace();
        }
    }
}

package com.xxxxxx.kantlin.kerberos;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthSchemeProvider;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.Credentials;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.config.Lookup;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.impl.auth.SPNegoSchemeFactory;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.security.auth.Subject;
import javax.security.auth.kerberos.KerberosPrincipal;
import javax.security.auth.login.AppConfigurationEntry;
import javax.security.auth.login.Configuration;
import javax.security.auth.login.LoginContext;
import java.io.IOException;
import java.security.Principal;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class RequestKerberosUrlUtils {
    private String principal;
    private String keyTabLocation;

    public RequestKerberosUrlUtils() {
    }

    public RequestKerberosUrlUtils(String principal, String keyTabLocation) {
        super();
        this.principal = principal;
        this.keyTabLocation = keyTabLocation;
    }

    public RequestKerberosUrlUtils(String principal, String keyTabLocation, boolean isDebug) {
        this(principal, keyTabLocation);
        if (isDebug) {
            System.setProperty("sun.security.spnego.debug", "true");
            System.setProperty("sun.security.krb5.debug", "true");
        }
    }

    public RequestKerberosUrlUtils(String principal, String keyTabLocation, String krb5Location, boolean isDebug) {
        this(principal, keyTabLocation, isDebug);
        System.setProperty("java.security.krb5.conf", krb5Location);
    }

    private static HttpClient buildSpengoHttpClient() {
        HttpClientBuilder builder = HttpClientBuilder.create();
        Lookup<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create().
                register(AuthSchemes.SPNEGO, new SPNegoSchemeFactory(true)).build();
        builder.setDefaultAuthSchemeRegistry(authSchemeRegistry);
        BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(new AuthScope(null, -1, null), new Credentials() {
            @Override
            public Principal getUserPrincipal() {
                return null;
            }
            @Override
            public String getPassword() {
                return null;
            }
        });
        builder.setDefaultCredentialsProvider(credentialsProvider);
        CloseableHttpClient httpClient = builder.build();
        return httpClient;
    }

    public HttpResponse callRestUrl(final String url, final String userId) {
        System.out.println(String.format("Calling KerberosHttpClient %s %s %s", this.principal, this.keyTabLocation, url));
        Configuration config = new Configuration() {
            @SuppressWarnings("serial")
            @Override
            public AppConfigurationEntry[] getAppConfigurationEntry(String name) {
                return new AppConfigurationEntry[]{new AppConfigurationEntry("com.sun.security.auth.module.Krb5LoginModule",
                        AppConfigurationEntry.LoginModuleControlFlag.REQUIRED, new HashMap<String, Object>() {
                    {
                        //Krb5 in GSS API needs to be refreshed so it does not throw the error
                        //Specified version of key is not available
                        put("useTicketCache", "false");
                        put("useKeyTab", "true");
                        put("keyTab", keyTabLocation);
                        put("refreshKrb5Config", "true");
                        put("principal", principal);
                        put("storeKey", "true");
                        put("doNotPrompt", "true");
                        put("isInitiator", "true");
                        put("debug", "true");
                    }
                })};
            }
        };
        Set<Principal> princ = new HashSet<Principal>(1);
        princ.add(new KerberosPrincipal(userId));
        Subject sub = new Subject(false, princ, new HashSet<Object>(), new HashSet<Object>());
        try {
            //指定认证模块为Krb5Login
            LoginContext lc = new LoginContext("Krb5Login", sub, null, config);
            //请求kdc进行client身份认证，如果能通过的话，则可以从TGT获取ticker作为后面二次访问时Authorization: Negotiate的基础
            lc.login();
           //无报错则表示client身份认证通过，此时可以在Subject对象中看到已经获取了kerberos的ticker
            Subject serviceSubject = lc.getSubject();
            return Subject.doAs(serviceSubject, new PrivilegedAction<HttpResponse>() {
                HttpResponse httpResponse = null;
                @Override
                public HttpResponse run() {
                    try {
                        HttpUriRequest request = new HttpGet(url);
                        //根据刚刚获取的kerberos的ticker构建Spengo请求，会经历一次401后再带上Negotiate二次请求
                        HttpClient spnegoHttpClient = buildSpengoHttpClient();
                       //返回的为二次响应后的结果
                        httpResponse = spnegoHttpClient.execute(request);
                        return httpResponse;
                    } catch (IOException ioe) {
                        ioe.printStackTrace();
                    }
                    return httpResponse;
                }
            });
        } catch (Exception le) {
            le.printStackTrace();
        }
        return null;
    }
}

• Subject对象中获取的kerberos ticker

  
  
  subject对象中获取到kerberos ticker

• 程序的运行结果

程序运行结果

从抓请求包的角度看请求过程

---->第一次请求
GET /service/plugins/secure/policies/download/hive2 HTTP/1.1
Host: hive2:6080
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.5.12 (Java/1.8.0_144)
Accept-Encoding: gzip,deflate

<----第一次响应
<....HTTP/1.1 401 Unauthorized
Server: Apache-Coyote/1.1
Set-Cookie: RANGERADMINSESSIONID=B1E066D23C9862535612AFD3C9B0A9B9; Path=/; HttpOnly
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-XSS-Protection: 1; mode=block
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
#head包含WWW-Authenticate则表示是spnego请求
WWW-Authenticate: Negotiate
Set-Cookie: hadoop.auth=; Path=/; Domain=hive2; Expires=Thu, 01-Jan-1970 00:00:00 GMT; HttpOnly
Content-Length: 0
Date: Fri, 21 May 2021 07:57:37 GMT


---->第二次请求
GET /service/plugins/secure/policies/download/hive2 HTTP/1.1
Host: hive2:6080
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.5.12 (Java/1.8.0_144)
Accept-Encoding: gzip,deflate
#第二次带上请求头
Authorization: Negotiate YIICoAYGxxxxxxxxxxx


---->第二次响应
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Set-Cookie: RANGERADMINSESSIONID=030939FDEAF93D5E218C6561DD8F1CDA; Path=/; HttpOnly
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-XSS-Protection: 1; mode=block
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
WWW-Authenticate: Negotiate oYH5MIH2oAMKAQChCwYxxxxxxxxxxx
Set-Cookie: hadoop.auth=xxxxxxxxxxxxxxxxx
Strict-Transport-Security: max-age=31536000; includeSubDomains
Content-Type:xxxxxxxxxxxxxxxxxxxxxxxxxx