zoukankan      html  css  js  c++  java
  • Amphorae 与 Octavia Worker 的安全通信实现

    前言

    在前面的章节中我们记录了 LoadBalancer、Listener、Pool、Member 等等 Octavia 核心资源对象的创建流程,本篇我们在此之上继续讨论处于 LB Management Network 上的 Amphorae 虚拟机是如何与处于 OpenStack Management Network 上的 Octavia Worker 进行安全通信的。

    为什么 Octavia 需要自建 CA 证书?

    首先我们提出一个问题:为什么 Octavia 需要自建 CA 而不使用 OpenStack 的通用认证体系?

    答案是:For production use the ca issuing the client certificate and the ca issuing the server certificate need to be different so a hacker can’t just use the server certificate from a compromised amphora to control all the others.

    简而言之,Octavia 自建 CA 证书主要有两个必要:

    • amphora-agent 没有加入 OpenStack 鉴权体系,需要证书来保证通讯安全
    • 防止恶意用户利用 amphora 作为 “肉鸡” 攻击 OpenStack 的内部网络

    基于自建 CA 实现的 SSL 通信

    Octavia 提供了自动化脚本通过 OpenSSL 指令来创建 CA 中心并自签发 CA 根证书。执行下述指令即可完成:

    $ source /opt/rocky/octavia/bin/create_certificates.sh /etc/octavia/certs/ /opt/rocky/octavia/etc/certificates/openssl.cnf

    NOTE:自签发即自己担保自己,用自己的私钥对自己的 CSR 进行签发。只有顶级认证角色才会自签发,所以也称为根证书,本质是签发服务器证书的公钥。

    所谓 CA,在操作系统上的载体只是一个文件目录(Directory),包含了各类型秘钥的证书。CA 在信任系统中充当第三方信托机构的角色,提供证书签发和管理服务,可以有效解决非对称加密系统中常见的中间人攻击问题。更多关于 CA 中心为内容可以参考《使用 OpenSSL 自建 CA 并签发证书》,这里不再赘述。

    在这里插入图片描述

    Octavia 自建的 CA 中心

    $ ll /etc/octavia/certs/
    total 44
    -rw-r--r-- 1 stack stack 1294 Oct 26 12:51 ca_01.pem
    -rw-r--r-- 1 stack stack  989 Oct 26 12:51 client.csr
    -rw-r--r-- 1 stack stack 1708 Oct 26 12:51 client.key
    -rw-r--r-- 1 stack stack 4405 Oct 26 12:51 client-.pem
    -rw-r--r-- 1 stack stack 6113 Oct 26 12:51 client.pem
    -rw-r--r-- 1 stack stack   71 Oct 26 12:51 index.txt
    -rw-r--r-- 1 stack stack   21 Oct 26 12:51 index.txt.attr
    -rw-r--r-- 1 stack stack    0 Oct 26 12:51 index.txt.old
    drwxr-xr-x 2 stack stack   20 Oct 26 12:51 newcerts
    drwx------ 2 stack stack   23 Oct 26 12:51 private
    -rw-r--r-- 1 stack stack    3 Oct 26 12:51 serial
    -rw-r--r-- 1 stack stack    3 Oct 26 12:51 serial.old
    • newcerts dir:存放 CA 签署(颁发)过的数字证书
    • private dir:存放 CA 的私钥
    • serial file:存放证书序列号(e.g. 01),每新建一张证书,序列号会自动加 1
    • index.txt file:存放证书信息
    • ca_01.pem PEM file:CA 证书文件
    • client.csr file:Server CSR 证书签名请求文件
    • client.key file:Server 私钥文件
    • client-.pem:PEM 编码的 Server 证书文件
    • client.pem:结合了 client-.pem 和 client.key 的文件

    列举 Octavia 与 CA 认证相关的配置项

    • 应用于 Create Amphora Flow 中的 TASK:GenerateServerPEMTask,生成 Amphora 私钥并签发 Amphora 证书。
    [certificates]
    ca_private_key_passphrase = foobar
    ca_private_key = /etc/octavia/certs/private/cakey.pem
    ca_certificate = /etc/octavia/certs/ca_01.pem
    • 应用于 Octavia Worker 的 AmphoraAPIClient,拿着 CA 根证书(是 Amphora 证书的公钥,可以解开 Amphora 证书得到 Amphora 的公钥)和 Amphora 证书向 amphora-agent 发起 SSL 通信。
    [haproxy_amphora]
    server_ca = /etc/octavia/certs/ca_01.pem
    client_cert = /etc/octavia/certs/client.pem
    • 应用于 Task:CertComputeCreate,指定 CA 根证书的路径
    [controller_worker]
    client_ca = /etc/octavia/certs/ca_01.pem

    Amphora Agent 启动加载证书

    首先看为 Amphorae 生成证书的代码实现:

    # /opt/rocky/octavia/octavia/controller/worker/tasks/cert_task.py
    
    class GenerateServerPEMTask(BaseCertTask):
        """Create the server certs for the agent comm
    
        Use the amphora_id for the CN
        """
    
        def execute(self, amphora_id):
            cert = self.cert_generator.generate_cert_key_pair(
                cn=amphora_id,
                validity=CERT_VALIDITY)
    
            return cert.certificate + cert.private_key
    

    Octavia Certificates 功能模块提供了 local_cert_generator(default)anchor_cert_generator 两种证书生成器,通过配置项 [certificates] cert_generator 选用。

    # /opt/rocky/octavia/octavia/certificates/generator/local.py
    
        @classmethod
        def generate_cert_key_pair(cls, cn, validity, bit_length=2048,
                                   passphrase=None, **kwargs):
            pk = cls._generate_private_key(bit_length, passphrase)
            csr = cls._generate_csr(cn, pk, passphrase)
            cert = cls.sign_cert(csr, validity, **kwargs)
            cert_object = local_common.LocalCert(
                certificate=cert,
                private_key=pk,
                private_key_passphrase=passphrase
            )
            return cert_object
    

    上述 LocalCertGenerator.generate_cert_key_pair Method 的语义是:

    1. 生成 Amphora 私钥
    2. 生成 Amphora 证书签名请求(CSR)
    3. 向 CA 中心申请签署 Amphora证书

    属于常规的证书创建流程,与 create_certificates.sh 脚本的区别在于,Octavia Certificates 应用了 cryptography python 库而非 OpenSSL 来实现。

    TASK:GenerateServerPEMTask 最终 return 了 Amphora 私钥和证书,然后实现 TASK:CertComputeCreate 将这些文件注入到 Amphora 虚拟机。登录 Amphora 即可查看这些文件,路径记录在配置文件中:

    # /etc/octavia/amphora-agent.conf
    
    [amphora_agent]
    # Octavia Worker 的证书
    agent_server_ca = /etc/octavia/certs/client_ca.pem
    # Amphora 的私钥和证书
    agent_server_cert = /etc/octavia/certs/server.pem

    Gunicorn HTTP Server 启动时就会将证书文件加载, 加载证书的 options 如下:

    options= {
            'bind': bind_ip_port,
            'workers': 1,
            'timeout': CONF.amphora_agent.agent_request_read_timeout,
            'certfile': CONF.amphora_agent.agent_server_cert,
            'ca_certs': CONF.amphora_agent.agent_server_ca,
            'cert_reqs': True,
            'preload_app': True,
            'accesslog': '/var/log/amphora-agent.log',
            'errorlog': '/var/log/amphora-agent.log',
            'loglevel': 'debug',
        }
    

    AmphoraAPIClient 发送证书请求

    class AmphoraAPIClient(object):
        def __init__(self):
            super(AmphoraAPIClient, self).__init__()
            ...
            self.session = requests.Session()
            self.session.cert = CONF.haproxy_amphora.client_cert
            self.ssl_adapter = CustomHostNameCheckingAdapter()
            self.session.mount('https://', self.ssl_adapter)
            ...
    
        def request(self, method, amp, path='/', timeout_dict=None, **kwargs):
            ...
            LOG.debug("request url %s", path)
            _request = getattr(self.session, method.lower())
            _url = self._base_url(amp.lb_network_ip) + path
            LOG.debug("request url %s", _url)
            reqargs = {
                'verify': CONF.haproxy_amphora.server_ca,
                'url': _url,
                'timeout': (req_conn_timeout, req_read_timeout), }
            reqargs.update(kwargs)
            headers = reqargs.setdefault('headers', {})
            ...
    

    上述代码是 requests 库启用 HTTPS 请求的常规实现:

    • self.session.cert:上传 Octavia Worker 私钥和证书,用于 Amphora 发起的 SSL 通信
    • reqargs = {'verify': CONF.haproxy_amphora.server_ca, ...}:携带 Amphora 证书,向 Amphora 发起 SSL 通信

    小结

    梳理 Octavia 建立 SSL 通信的步骤

    1. 创建 Amphora 的过程中 Octavia Worker 会首先生成 Amphora 的私钥,并且向 CA 中心申请签发 Amphora 证书(内含 Amphora 公钥),此时 Amphora 的私钥、证书都会准备好
    2. Octavia Worker 通过 Config Driver 将 Amphora 的私钥、Amphora 的证书作为 user data 注入到 Amphora 虚拟机。
    3. Amphora 虚拟机上运行的 amphora-agent Web Server 启动时 Flask app 就会加载 Amphora 的私钥和证书,并启用 HTTPS 通讯协议。
    4. Octavia Worker 的 AmphoraAPIClient 首次想 amphora-agent 发送请求时,首先会下载 Amphora 证书,然后与自己手上的 CA 根证书解密出 Amphora 的公钥,然后再与 Amphora 的私钥进行匹配。
    5. 若匹配成功,则建立 SSL 安全通信。

    NOTE: 同样的 Amphora 如果希望向 Octavia Worker 自动发起建立 SSL 通信,那么 Amphora 就需要拿着 Octavia Worker 的证书进行访问。所以 Octavia 的证书也同样会被注入到 Amphora。
    在这里插入图片描述

    最后

    本篇是《OpenStack Rocky Octavia 实现与分析》系列的第四篇,主要讨论 Amphora 是如何与 Octavia Worker 建立双向的 SSL 安全通信的问题。实话说,Octavia 在解决这个问题的时候并不那么清晰明了,从命名到代码的实现都弥漫着混乱的氛围,需要细细梳理才得以清晰。并且 Octavia 和 Amphora 能够健康通信又是 LBaaS 功能正常运作的基础,所以还是非常有必要掌握这一问题的。

    相关阅读:

  • 相关阅读:
    Lua C Api
    Lua string.gsub (s, pattern, repl [, n])
    LearnOpenGL 你好,三角形[转]--附源码
    学习OpenGL简单易懂网站
    泰文排版规则
    Lua截取utf-8编码的中英文混合字符串
    字符编码
    使用Ant编译提示Class not found: javac1.8
    MySQL索引
    转 linux 权限
  • 原文地址:https://www.cnblogs.com/hzcya1995/p/13309739.html
Copyright © 2011-2022 走看看