为什么80%的码农都做不了架构师？>>> 
##前言 KMS是Hadoop下的一个密钥管理服务，它实际是与Hadoop结合，提供HDFS文件做AES加密用的。所以它是用来存储AES秘钥的，AES提供三种位数的秘钥，分别是128, 192, 256，所以KMS只能存储这三种位数的byte数组。
如果你是为了给HDFS文件加密，那么直接通过配置就可以完成，它与Hadoop能够完美契合，由Hadoop调用自动产生秘钥并管理秘钥。但是HDFS文件加密粒度太粗，我们的数据并非要全部加密，而当前针对Hive表列的加密并没有集成方案，官方提供了AES的encrypt函数，但是秘钥key还需明文传入。这样对集群来说其实很不安全。
如果我们自己实现加密UDF，然后借用KMS来做密钥管理，在KMS上加上Kerberos认证，秘钥的处理就可以都封装在UDF内部，不对外暴露，而且可以实现身份认证。
KMS本身提供了一系列API来创建，获取和维护密钥，官网介绍中主要以RESTFUL的形式提供，但如果集群上了Kerberos，请求的认证在RESTFULL里就不好做(具体没操作过)。在Hadoop源码里，提供了KMSClientProvider用于Hadoop的加密，所以我们可以利用这个接口来获取KMS服务，实现创建管理密钥。
##配置
-
KMS是一个Web服务，只需要在一台机器上配置即可，其主要配置文件是
kms-site.xml，主要配置项是hadoop.kms.key.provider.uri，配置值是KMS的key以文件形式存在哪个keystore文件里，配置格式是jceks://file@/path/to/kms.keystore，如jceks://file@/home/kms/kms.keystore，当然，服务最好以kms用户来起。这个文件会在KMS起来后生成。之后在kms-env.sh里配置export KMS_LOG=/path/to/log和export KMS_TEMP=/path/to/log。kms.keystore文件本身和里面的存储密钥都有密码保护，默认配置项为hadoop.security.keystore.java-keystore-provider.password-file，密码存储在文件里，不可换行，由于KMS是通过ClassLoader.getResource来加载该文件，所以该配置必须配在KMS Web服务启动对应的conf目录下。此外也可通过环境变量设置，为HADOOP_KEYSTORE_PASSWORD，可将其配置在kms-env.sh里，环境变量的设置优先级最高！ -
然后在hadoop的
core-site.xml里配上hadoop.security.key.provider.path，未启用https，其值为kms://http@${hostname}:16000/kms，如果启用了https，则应为kms://https@${hostname}:16000/kms。 -
以上两步配完后，重启HDFS，然后以
kms身份，启动KMS(/path/to/hadoop/sbin/kms.sh start)，启动完后，就可以用/path/to/hadoop/bin/hadoop key list -metadata来查看KMS里存储的Key了，当然，还没有创建key，所以没有key信息，但是可以验证KMS服务是否配置正确。其次，这个命令虽然可以创建key，但是只能创建随机key，不能创建指定key。 -
配置SSL(https)，确保传输过程加密。SSL需要用到证书，可以去CA官网下载一个证书作为网站根证书和信任证书，也可以用Java生成一个自签名证书并添加它为受信任证书。详细介绍可以参考CDH官网，我们这里采用自签名证书。
- 以
kms用户生成tomcat根证书(此根证书只能为当前机器上的Web服务所用，其他机器上的web服务如果需要SSL，也需要像这个一样单独生成该服务器的根证书。其次，该证书只是做SSL通信安全加密所用，并不具备可信任性，因为不是权威机构颁发)，执行/usr/java/default/bin/keytool -genkey -alias tomcat -keyalg RSA，过程中问到"What is your first and last name?"时，必须填写运行KMS Service那台机器的hostname，然后会提示输入keystore的密码，这个密码假定为xxx.c0m，需要记住，后面配置时需要用到它。这一步执行完后，会在kms用户的home目录下生成.keystore文件(可用/path/to/java/bin/keytool -list -v -keystore .keystore -storepass xxx.c0m来显示当前keystore里可用的证书)。 - 配置
kms-env.sh，添加证书的位置和密码，即export KMS_SSL_KEYSTORE_FILE=/home/kms/.keystore和export KMS_SSL_KEYSTORE_PASS=xxx.c0m，然后更改core-site.xml里的hadoop.security.key.provider.path为https。到这里KMS的SSL算是配完了，但是重启HDFS和KMS后，发现 list 秘钥会报错: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target)，这是因为我们没有添加证书为受信任根证书，访问并不认同当前根证书。 - 以
kms用户导出根证书为crt文件：/usr/java/default/bin/keytool -export -alias tomcat -keystore /home/kms/.keystore -file /home/kms/tomcat.crt -storepass xxx.c0m，这里就要用到上面的密码。这一步是为了添加受信任证书做准备，当前证书被称作keystore，受信任证书是truststore，java truststore有几个不同的判断维度，可参考这里 - 因为我们并没有配置
javax.net.ssl.trustStore(也可以采用配置这个文件)，也没有/lib/security/jssecacerts /lib/security/cacerts root用户操作，执行cp $JAVA_HOME/jre/lib/security/cacerts $JAVA_HOME/jre/lib/security/jssecacerts，然后将刚导出的根证书添加到受信任证书jssecacerts里，即/usr/java/default/bin/keytool -import -alias tomcat -keystore /usr/java/default/jre/lib/security/jssecacerts -file /home/kms/tomcat.crt -storepass changeit，这里的密码是jssecacerts的密码，默认是changeit - 上面一步做完后，本机上任何账户都可以使用KMS服务，至此KMS的SSL就配完了。这一步的过程实际是把
/home/kms/.keystore的公钥导入到了jssecacerts文件里，私钥还在原文件里。 - 要想其他机器也正常访问KMS，我们需要把
jssecacerts拷贝到其他机器/lib/security/
- 配置KMS Kerberos KMS需要
HTTP的凭据，在KMS服务机器上生成凭据，配置kms-site.xml文件，设置hadoop.kms.authentication.type为kerberos，然后添加hadoop.kms.authentication.kerberos.keytab和hadoop.kms.authentication.kerberos.principal，设置hadoop.kms.authentication.kerberos.name.rules为DEFAULT - 在CDH里配置KMS：CDH里配置很简单，在Cluster界面，Actions -> Add a Service，然后添加Java KeyStore Service，然后一步步走配置流程即可，SSL的配置与上面的一样。然后在Set Up HDFS Dependency这一步里，点击关闭，不配置HDFS文件加密。对于Kerberos配置，选择Administration -> Security -> Kerberos Credentials，查看是否有当前主机的HTTP凭据，没有就生成一个
- 配置完后，我们可以使用
hadoop key list来查看当前存储的密钥，如果报错没有配置provider，我们可以这么用：hadoop key list -metadata -provider kms://https@${hostname}:16000/kms，需带上provider - 配置KMS秘钥访问权限，配置文件是kms-acls.xml，KMS可整体控制秘钥的权限，也可单独就某个秘钥配置它的具体权限，并且支持白名单和黑名单，策略是先白名单后黑名单。在开源Hadoop上，这个配置是热加载的，但是在CDH里改了它之后需要重启KMS服务。配置示例如下：
hadoop.kms.acl.CREATE
*
hadoop.kms.blacklist.CREATE
hdfs,hive
hadoop.kms.acl.DELETE
*
hadoop.kms.blacklist.DELETE
hdfs,hive
hadoop.kms.acl.ROLLOVER
*
hadoop.kms.blacklist.ROLLOVER
*
hadoop.kms.acl.GET
kavn,hive
hadoop.kms.blacklist.GET
hdfs
hadoop.kms.acl.GET_KEYS
*
hadoop.kms.blacklist.GET_KEYS
hdfs,hive
hadoop.kms.acl.GET_METADATA
hadoop.kms.blacklist.GET_METADATA
hdfs,hive
hadoop.kms.blacklist.GENERATE_EEK
*
hadoop.kms.blacklist.DECRYPT_EEK
*
hadoop.kms.acl.SET_KEY_MATERIAL
*
hadoop.kms.blacklist.SET_KEY_MATERIAL
hdfs,hive
default.key.acl.MANAGEMENT
*
default.key.acl.READ
*
default.key.acl.ALL
*
key.acl.key_name.MANAGEMENT
key.acl.key_name.READ
kavn
key.acl.key_name.ALL
9、 至此整个KMS就配置完成了，访问KMS服务就需要以下三个条件：
- 有服务器的受信任证书(如这里的 jssecacerts)
- 有kerberos认证并且票据没过期
- 具备相应Key的访问权限
##访问代码集成 KMS是在集群环境中访问，想要做加密就必须有身份认证，而身份认证就是Kerberos. 这里KeyProviderFactory内部封装了Kerberos认证(实际通过UGI来做的)，我们通过调用它拿到KMS的访问实例，从而实现Kerberos集群环境下的秘钥管理。当用户运行这段代码时，可以使用当前用户的身份认证，也可以利用UGI使用其他用户的身份认证，达到秘钥权限控制的目的。
这里采用单例模式，但在获取Instance的时候，加了获取KeyProvider的逻辑，这是因为同一代码里可能会有多个不同的账户需要访问秘钥，每次访问秘钥都用新的账户去做Kerberos认证，可以保证权限正确。不会因为第一次请求之后，以后的用户请求都用成了第一次请求用户的Kerberos凭据。
package encryption.codec;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.crypto.key.KeyProvider;
import org.apache.hadoop.crypto.key.KeyProviderFactory;
import org.apache.log4j.Logger;
import java.io.IOException;
import java.io.Serializable;
import java.util.List;
/**
* KMS秘钥创建和获取类
*/
public class KeyManagement implements Serializable {
private static final Logger logger = Logger.getLogger(KeyManagement.class);
private static KeyProvider provider = null;
private static final String KEY_PROVIDER_PATH = "hadoop.security.key.provider.path";
private static final Configuration conf = new Configuration();
private static final String KMS = "kms://[email protected]:16000/kms";
private KeyManagement() {
}
private static class KeyManagementInstance {
private final static KeyManagement instance = new KeyManagement();
}
public static KeyManagement getInstance() {
provider = getKeyProvider();
return KeyManagementInstance.instance;
}
/**
* 获取KeyProvider
* @return
*/
private static KeyProvider getKeyProvider() {
// 此处因为拿不到KEY_PROVIDER_PATH配置，所以做了硬编码
conf.set(KEY_PROVIDER_PATH, KMS);
KeyProvider provider = null;
List providers;
try {
providers = KeyProviderFactory.getProviders(conf);
for (KeyProvider p : providers) {
if (!p.isTransient()) {
provider = p;
break;
}
}
} catch (IOException ex) {
logger.error("Get KeyProvider failed! " + ex.getMessage());
ex.printStackTrace();
}
return provider;
}
/**
* 查看当前KMS里有哪些Key，以及Key的信息
* @return
*/
public String[] listAllKeys() {
try {
final List keys = provider.getKeys();
final KeyProvider.Metadata[] meta = provider.getKeysMetadata(keys.toArray(new String[keys.size()]));
String[] out = new String[keys.size()];
for (int i = 0; i < meta.length; ++i) {
out[i] = keys.get(i) + " : " + meta[i];
}
return out;
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
/**
* 获取当前key的秘钥
* @param name
* @return
* @throws IOException
*/
public byte[] getCurrentKey(String name) throws IOException {
if (null == provider) {
logger.error("KeyProvider is null!");
return null;
}
return provider.getCurrentKey(name).getMaterial();
}
/**
* 根据名称，描述，秘钥来创建一个Key, 秘钥位长为128位
* @param name
* @param description
* @param material
* @throws IOException
*/
public void createKey(String name, String description, byte[] material) throws IOException {
createKey(name, description, BitLength.ONE_TWO_EIGHT, material);
}
/**
* 根据名称，描述，秘钥位长和秘钥来创建一个Key
* @param name
* @param description
* @param bitLengthOfKey
* @param material
* @throws IOException
*/
public void createKey(String name, String description, BitLength bitLengthOfKey, byte[] material) throws IOException {
final KeyProvider.Options options = KeyProvider.options(conf);
options.setDescription(description);
int length = 8 * material.length;
try {
switch (bitLengthOfKey) {
case ONE_TWO_EIGHT:
if (length == 128) {
options.setBitLength(128);
break;
} else {
throw new IllegalArgumentException("Wrong key length. Required 128, but got " + length);
}
case ONE_NIGHT_TWO:
if (length == 192) {
options.setBitLength(192);
break;
} else {
throw new IllegalArgumentException("Wrong key length. Required 192, but got " + length);
}
case TWO_FIVE_SIX:
if (length == 256) {
options.setBitLength(256);
break;
} else {
throw new IllegalArgumentException("Wrong key length. Required 256, but got " + length);
}
}
provider.createKey(name, material, options);
provider.flush();
logger.info(name + " has been successfully created with options "
+ options.toString() + ".");
} catch (Exception ex) {
logger.error(name + " has not been created. " + ex.getMessage());
throw ex;
}
}
}
enum BitLength {
ONE_TWO_EIGHT, ONE_NIGHT_TWO, TWO_FIVE_SIX
}
updata: 2017-03-25 对文中描述不全和之前的理解不到位做了修改补充
欢迎转载，但请注明出处：https://my.oschina.net/u/2539801/blog/807974