zookeeper的ACL权限控制机制介绍

本节介绍
本节我们将给大家介绍一下什么是ACL，zookeeper中的权限都有哪些，权限是怎么控制的，并且也会写一个demo程序演示java api对于权限具体的使用方式。

ACL概述
首先什么是ACL呢？ACL全称为Access Control List 即访问控制列表，用于控制资源的访问权限。zookeeper利用ACL策略控制节点的访问权限，如节点数据读写、节点创建、节点删除、读取子节点列表、设置节点权限等。

在传统的文件系统中，ACL分为两个维度，一个是属组，一个是权限，一个属组包含多个权限，一个文件或目录拥有某个组的权限即拥有了组里的所有权限，文件或子目录默认会继承自父目录的ACL。而在Zookeeper中，znode的ACL是没有继承关系的，每个znode的权限都是独立控制的，只有客户端满足znode设置的权限要求时，才能完成相应的操作。Zookeeper的ACL，分为三个维度：scheme、id、permission，通常表示为：scheme:id:permission，schema代表授权策略，id代表用户，permission代表权限。下面从这三个维度分别来介绍。

scheme
scheme对应于采用哪种方案来进行权限管理，zookeeper的scheme的分类如下：

world: 它下面只有一个id, 叫anyone, world:anyone代表任何人，zookeeper中对所有人有权限的结点就是属于world:anyone的
auth: 它不需要id, 只要是通过authentication的user都有权限（zookeeper支持通过kerberos来进行authencation, 也支持username/password形式的authentication)
digest:是最常用的权限控制模式，也更符合我们对权限控制的认识，其类似于"username:password"形式的权限标识进行权限配置。它对应的id为username:BASE64(SHA1(password))，即对密码先做SHA1加密然后再进行BASE64摘要。

ip: 它对应的id为客户机的IP地址，设置的时候可以设置一个ip段，比如ip:192.168.1.0/16, 表示匹配前16个bit的IP段，也可以设置为某一个具体的ip
super: 在这种scheme情况下，对应的id拥有超级权限，可以做任何事情(cdrwa)
其实这几种scheme中最常用的也就是world，digest和ip，其他的都很少使用，了解一下就行了。

id
id是验证模式，不同的scheme，id的值也不一样。scheme为ip时，id的值为客户端的ip地址。scheme为world时，id的值为anyone。scheme为digest时，id的值为：username:BASE64(SHA1(password))。

permission
zookeeper目前支持下面一些权限：

CREATE(c): 创建权限，可以在在当前node下创建child node，即对子节点Create操作
DELETE(d): 删除权限，可以删除当前的node，即对子节点Delete操作
READ(r): 读权限，可以获取当前node的数据，可以list当前node所有的child nodes，即对本节点GetChildren和GetData操作
WRITE(w): 写权限，可以向当前node写数据，即对本节点SetData操作
ADMIN(a): 管理权限，可以设置当前node的permission，即对本节点setAcl操作
通过命令行操作ACL
获取ACL

通过zookeeper自带的客户端脚本zkCli.sh连接上zookeeper，我们创建一个节点，然后通过getAcl 命令可以查看节点的ACL信息，我们发现当我们创建节点没有设置ACL的时候，默认使用的是world这种scheme，任何客户端都可以访问。
 

[zk: localhost:2181(CONNECTED) 2] create /test aaa
Created /test
[zk: localhost:2181(CONNECTED) 3] getAcl /test
'world,'anyone
: cdrwa
[zk: localhost:2181(CONNECTED) 4] 

设置digest

然后我们给这个节点添加一个digest权限，设置命令格式为

setAcl /node digest:[username]:[Encrypted password]:[perms]

 我们可以看到密码时加密的，前面我们也提到了是先对密码做SHA1加密然后再做Base64，zookeeper的java api中有一个类可以帮助我们做这个加密操作：String str = DigestAuthenticationProvider.generateDigest("wkp:135791"); 这个方法返回的字符串str就会吧冒号后面的密码做加密操作，通过运行得到返回值为"wkp:NrLAZ6FuRnaPGI93r1uPKD67MLw="。我们可以看下这个方法的源码：

然后我们可以给上面创建的/test节点添加一个digest（wkp:135791）的权限

[zk: localhost:2181(CONNECTED) 44] setAcl /test digest:wkp:NrLAZ6FuRnaPGI93r1uPKD67MLw=:cdrwa
cZxid = 0x620000001a
ctime = Wed Oct 31 23:03:51 CST 2018
mZxid = 0x620000001a
mtime = Wed Oct 31 23:03:51 CST 2018
pZxid = 0x620000001a
cversion = 0
dataVersion = 0
aclVersion = 1
ephemeralOwner = 0x0
dataLength = 3
numChildren = 0
[zk: localhost:2181(CONNECTED) 45] getAcl /test
'digest,'wkp:NrLAZ6FuRnaPGI93r1uPKD67MLw=
: cdrwa
[zk: localhost:2181(CONNECTED) 46] create /test/aaa 111
Authentication is not valid : /test/aaa
[zk: localhost:2181(CONNECTED) 50] addauth digest wkp:135791
[zk: localhost:2181(CONNECTED) 51] create /test/aaa 111     
Created /test/aaa
[zk: localhost:2181(CONNECTED) 52] 

通过上面的实验，我们可以看到：当我们添加了digest的权限之后，创建节点的时候报错了，然后我们通过权限认证之后才可以再创建节点，digest的认证方式为下面的格式，注意这里的密码为明文

addauth digest [username]:[password plain]

设置ip认证

我们创建一个/ipTest节点并且设置scheme为ip形式，限制连接ip为127.0.0.1，然后我们本机是可以访问的

[zk: localhost:2181(CONNECTED) 1] create /ipTest 111
Created /ipTest
[zk: localhost:2181(CONNECTED) 2] setAcl /ipTest ip:127.0.0.1:crwda
cZxid = 0x620000002a
ctime = Wed Oct 31 23:40:20 CST 2018
mZxid = 0x620000002a
mtime = Wed Oct 31 23:40:20 CST 2018
pZxid = 0x620000002a
cversion = 0
dataVersion = 0
aclVersion = 1
ephemeralOwner = 0x0
dataLength = 3
numChildren = 0
[zk: localhost:2181(CONNECTED) 3] getAcl /ipTest
'ip,'127.0.0.1
: cdrwa
[zk: localhost:2181(CONNECTED) 4] ls /ipTest
[]

下面我们切换到集群的另一台机器上进行操作，发现认证不通过

[zk: localhost:2181(CONNECTED) 0] ls /
[testRoot, dubbo, bhz, test, zookeeper, activemq2, switch, ipTest]
[zk: localhost:2181(CONNECTED) 1] ls /ipTest
Authentication is not valid : /ipTest
[zk: localhost:2181(CONNECTED) 2] 

通过java api操作ACL

下面我们写了一个测试类ZookeeperAuth，演示了一下digest类型的权限使用，分别通过不加验证、使用错误的验证、使用正确的验证去操作测试的节点，代码当中的注释已经写得比较详细了，相信大家一定可以看懂的哈。

package wang.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;

public class ZookeeperAuth implements Watcher {

    /**
     * 连接地址
     */
    final static String CONNECT_ADDR = "192.168.177.12:2181,192.168.177.13:2181";
    /**
     * 测试路径
     */
    final static String PATH = "/testAuth";
    final static String PATH_DEL = "/testAuth/delNode";
    /**
     * 认证类型
     */
    final static String authentication_type = "digest";
    /**
     * 认证正确方法
     */
    final static String correctAuthentication = "123456";
    /**
     * 认证错误方法
     */
    final static String badAuthentication = "654321";
    static ZooKeeper zk = null;
    /**
     * 计时器
     */
    AtomicInteger seq = new AtomicInteger();
    /**
     * 标识
     */
    private static final String LOG_PREFIX_OF_MAIN = "【Main】";
    private CountDownLatch connectedSemaphore = new CountDownLatch(1);

    @Override
    public void process(WatchedEvent event) {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (event == null) {
            return;
        }
        // 连接状态
        KeeperState keeperState = event.getState();
        // 事件类型
        EventType eventType = event.getType();
        // 受影响的path
        String path = event.getPath();

        String logPrefix = "【Watcher-" + this.seq.incrementAndGet() + "】";

        System.out.println(logPrefix + "收到Watcher通知");
        System.out.println(logPrefix + "连接状态:\t" + keeperState.toString());
        System.out.println(logPrefix + "事件类型:\t" + eventType.toString());
        if (KeeperState.SyncConnected == keeperState) {
            // 成功连接上ZK服务器
            if (EventType.None == eventType) {
                System.out.println(logPrefix + "成功连接上ZK服务器");
                connectedSemaphore.countDown();
            }
        } else if (KeeperState.Disconnected == keeperState) {
            System.out.println(logPrefix + "与ZK服务器断开连接");
        } else if (KeeperState.AuthFailed == keeperState) {
            System.out.println(logPrefix + "权限检查失败");
        } else if (KeeperState.Expired == keeperState) {
            System.out.println(logPrefix + "会话失效");
        }
        System.out.println("--------------------------------------------");
    }

    /**
     * 创建ZK连接
     *
     * @param connectString  ZK服务器地址列表
     * @param sessionTimeout Session超时时间
     */
    public void createConnection(String connectString, int sessionTimeout) {
        this.releaseConnection();
        try {
            zk = new ZooKeeper(connectString, sessionTimeout, this);
            //添加节点授权
            zk.addAuthInfo(authentication_type, correctAuthentication.getBytes());
            System.out.println(LOG_PREFIX_OF_MAIN + "开始连接ZK服务器");
            //倒数等待
            connectedSemaphore.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭ZK连接
     */
    public void releaseConnection() {
        if (this.zk != null) {
            try {
                this.zk.close();
            } catch (InterruptedException e) {
            }
        }
    }

    public static void main(String[] args) throws Exception {

        ZookeeperAuth testAuth = new ZookeeperAuth();
        testAuth.createConnection(CONNECT_ADDR, 2000);
        List<ACL> acls = new ArrayList<ACL>(1);
        for (ACL ids_acl : Ids.CREATOR_ALL_ACL) {
            acls.add(ids_acl);
        }
        try {
            zk.create(PATH, "init content".getBytes(), acls, CreateMode.PERSISTENT);
            System.out.println("使用授权key：" + correctAuthentication + "创建节点：" + PATH + ", 初始内容是: init content");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            zk.create(PATH_DEL, "will be deleted! ".getBytes(), acls, CreateMode.PERSISTENT);
            System.out.println("使用授权key：" + correctAuthentication + "创建节点：" + PATH_DEL + ", 初始内容是: init content");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 获取数据
        getDataByNoAuthentication();
        getDataByBadAuthentication();
        getDataByCorrectAuthentication();

        // 更新数据
        updateDataByNoAuthentication();
        updateDataByBadAuthentication();
        updateDataByCorrectAuthentication();

        // 删除数据
        deleteNodeByBadAuthentication();
        deleteNodeByNoAuthentication();
        deleteNodeByCorrectAuthentication();
        //
        Thread.sleep(1000);

        deleteParent();
        //释放连接
        testAuth.releaseConnection();
    }

    /**
     * 获取数据：采用错误的密码
     */
    static void getDataByBadAuthentication() {
        String prefix = "[使用错误的授权信息]";
        try {
            ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
            //授权
            badzk.addAuthInfo(authentication_type, badAuthentication.getBytes());
            Thread.sleep(2000);
            System.out.println(prefix + "获取数据：" + PATH);
            System.out.println(prefix + "成功获取数据：" + badzk.getData(PATH, false, null));
        } catch (Exception e) {
            System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
        }
    }

    /**
     * 获取数据：不采用密码
     */
    static void getDataByNoAuthentication() {
        String prefix = "[不使用任何授权信息]";
        try {
            System.out.println(prefix + "获取数据：" + PATH);
            ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
            Thread.sleep(2000);
            System.out.println(prefix + "成功获取数据：" + nozk.getData(PATH, false, null));
        } catch (Exception e) {
            System.err.println(prefix + "获取数据失败，原因：" + e.getMessage());
        }
    }

    /**
     * 采用正确的密码
     */
    static void getDataByCorrectAuthentication() {
        String prefix = "[使用正确的授权信息]";
        try {
            System.out.println(prefix + "获取数据：" + PATH);

            System.out.println(prefix + "成功获取数据：" + zk.getData(PATH, false, null));
        } catch (Exception e) {
            System.out.println(prefix + "获取数据失败，原因：" + e.getMessage());
        }
    }

    /**
     * 更新数据：不采用密码
     */
    static void updateDataByNoAuthentication() {

        String prefix = "[不使用任何授权信息]";

        System.out.println(prefix + "更新数据： " + PATH);
        try {
            ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
            Thread.sleep(2000);
            Stat stat = nozk.exists(PATH, false);
            if (stat != null) {
                nozk.setData(PATH, prefix.getBytes(), -1);
                System.out.println(prefix + "更新成功");
            }
        } catch (Exception e) {
            System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
        }
    }

    /**
     * 更新数据：采用错误的密码
     */
    static void updateDataByBadAuthentication() {

        String prefix = "[使用错误的授权信息]";

        System.out.println(prefix + "更新数据：" + PATH);
        try {
            ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
            //授权
            badzk.addAuthInfo(authentication_type, badAuthentication.getBytes());
            Thread.sleep(2000);
            Stat stat = badzk.exists(PATH, false);
            if (stat != null) {
                badzk.setData(PATH, prefix.getBytes(), -1);
                System.out.println(prefix + "更新成功");
            }
        } catch (Exception e) {
            System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
        }
    }

    /**
     * 更新数据：采用正确的密码
     */
    static void updateDataByCorrectAuthentication() {

        String prefix = "[使用正确的授权信息]";

        System.out.println(prefix + "更新数据：" + PATH);
        try {
            Stat stat = zk.exists(PATH, false);
            if (stat != null) {
                zk.setData(PATH, prefix.getBytes(), -1);
                System.out.println(prefix + "更新成功");
            }
        } catch (Exception e) {
            System.err.println(prefix + "更新失败，原因是：" + e.getMessage());
        }
    }

    /**
     * 不使用密码 删除节点
     */
    static void deleteNodeByNoAuthentication() throws Exception {

        String prefix = "[不使用任何授权信息]";

        try {
            System.out.println(prefix + "删除节点：" + PATH_DEL);
            ZooKeeper nozk = new ZooKeeper(CONNECT_ADDR, 2000, null);
            Thread.sleep(2000);
            Stat stat = nozk.exists(PATH_DEL, false);
            if (stat != null) {
                nozk.delete(PATH_DEL, -1);
                System.out.println(prefix + "删除成功");
            }
        } catch (Exception e) {
            System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
        }
    }

    /**
     * 采用错误的密码删除节点
     */
    static void deleteNodeByBadAuthentication() throws Exception {

        String prefix = "[使用错误的授权信息]";

        try {
            System.out.println(prefix + "删除节点：" + PATH_DEL);
            ZooKeeper badzk = new ZooKeeper(CONNECT_ADDR, 2000, null);
            //授权
            badzk.addAuthInfo(authentication_type, badAuthentication.getBytes());
            Thread.sleep(2000);
            Stat stat = badzk.exists(PATH_DEL, false);
            if (stat != null) {
                badzk.delete(PATH_DEL, -1);
                System.out.println(prefix + "删除成功");
            }
        } catch (Exception e) {
            System.err.println(prefix + "删除失败，原因是：" + e.getMessage());
        }
    }

    /**
     * 使用正确的密码删除节点
     */
    static void deleteNodeByCorrectAuthentication() throws Exception {

        String prefix = "[使用正确的授权信息]";

        try {
            System.out.println(prefix + "删除节点：" + PATH_DEL);
            Stat stat = zk.exists(PATH_DEL, false);
            if (stat != null) {
                zk.delete(PATH_DEL, -1);
                System.out.println(prefix + "删除成功");
            }
        } catch (Exception e) {
            System.out.println(prefix + "删除失败，原因是：" + e.getMessage());
        }
    }

    /**
     * 使用正确的密码删除节点
     */
    static void deleteParent() throws Exception {
        try {
            Stat stat = zk.exists(PATH_DEL, false);
            if (stat == null) {
                zk.delete(PATH, -1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}

【Main】开始连接ZK服务器
【Watcher-1】收到Watcher通知
【Watcher-1】连接状态:	SyncConnected
【Watcher-1】事件类型:	None
【Watcher-1】成功连接上ZK服务器
--------------------------------------------
使用授权key：123456创建节点：/testAuth, 初始内容是: init content
使用授权key：123456创建节点：/testAuth/delNode, 初始内容是: init content
[不使用任何授权信息]获取数据：/testAuth
[不使用任何授权信息]获取数据失败，原因：KeeperErrorCode = NoAuth for /testAuth
[使用错误的授权信息]获取数据：/testAuth
[使用正确的授权信息]获取数据：/testAuth
[使用错误的授权信息]获取数据失败，原因：KeeperErrorCode = NoAuth for /testAuth
[使用正确的授权信息]成功获取数据：[B@c77d0d6
[不使用任何授权信息]更新数据： /testAuth
[使用错误的授权信息]更新数据：/testAuth
[不使用任何授权信息]更新失败，原因是：KeeperErrorCode = NoAuth for /testAuth
[使用正确的授权信息]更新数据：/testAuth
[使用错误的授权信息]更新失败，原因是：KeeperErrorCode = NoAuth for /testAuth
[使用正确的授权信息]更新成功
[使用错误的授权信息]删除节点：/testAuth/delNode
[不使用任何授权信息]删除节点：/testAuth/delNode
[使用错误的授权信息]删除失败，原因是：KeeperErrorCode = NoAuth for /testAuth/delNode
[使用正确的授权信息]删除节点：/testAuth/delNode[不使用任何授权信息]删除失败，原因是：KeeperErrorCode = NoAuth for /testAuth/delNode
 
[使用正确的授权信息]删除成功

可以看到，不适用授权或者使用错误的授权都无法进行操作，会报KeeperErrorCode = NoAuth for XXX的异常。而只有使用正确的授权信息，才可以正常访问操作对应的节点。